const { describe, it, beforeEach } = require('mocha') const assert = require('assert') const proxyquire = require('proxyquire') const hoodwink = require('hoodwink') const ECPair = require('../src/ecpair') const tinysecp = require('tiny-secp256k1') const fixtures = require('./fixtures/ecpair.json') const NETWORKS = require('../src/networks') const NETWORKS_LIST = [] // Object.values(NETWORKS) for (let networkName in NETWORKS) { NETWORKS_LIST.push(NETWORKS[networkName]) } const ZERO = Buffer.alloc(32, 0) const ONE = Buffer.from('0000000000000000000000000000000000000000000000000000000000000001', 'hex') const GROUP_ORDER = Buffer.from('fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141', 'hex') const GROUP_ORDER_LESS_1 = Buffer.from('fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140', 'hex') describe('ECPair', () => { describe('getPublicKey', () => { let keyPair beforeEach(() => { keyPair = ECPair.fromPrivateKey(ONE) }) it('calls pointFromScalar lazily', hoodwink(() => { assert.strictEqual(keyPair.__Q, undefined) // .publicKey forces the memoization assert.strictEqual(keyPair.publicKey.toString('hex'), '0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798') assert.strictEqual(keyPair.__Q.toString('hex'), '0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798') })) }) describe('fromPrivateKey', () => { it('defaults to compressed', () => { const keyPair = ECPair.fromPrivateKey(ONE) assert.strictEqual(keyPair.compressed, true) }) it('supports the uncompressed option', () => { const keyPair = ECPair.fromPrivateKey(ONE, { compressed: false }) assert.strictEqual(keyPair.compressed, false) }) it('supports the network option', () => { const keyPair = ECPair.fromPrivateKey(ONE, { compressed: false, network: NETWORKS.testnet }) assert.strictEqual(keyPair.network, NETWORKS.testnet) }) fixtures.valid.forEach(f => { it('derives public key for ' + f.WIF, () => { const d = Buffer.from(f.d, 'hex') const keyPair = ECPair.fromPrivateKey(d, { compressed: f.compressed }) assert.strictEqual(keyPair.publicKey.toString('hex'), f.Q) }) }) fixtures.invalid.fromPrivateKey.forEach(f => { it('throws ' + f.exception, () => { const d = Buffer.from(f.d, 'hex') assert.throws(() => { ECPair.fromPrivateKey(d, f.options) }, new RegExp(f.exception)) }) }) }) describe('fromPublicKey', () => { fixtures.invalid.fromPublicKey.forEach(f => { it('throws ' + f.exception, () => { const Q = Buffer.from(f.Q, 'hex') assert.throws(() => { ECPair.fromPublicKey(Q, f.options) }, new RegExp(f.exception)) }) }) }) describe('fromWIF', () => { fixtures.valid.forEach(f => { it('imports ' + f.WIF + ' (' + f.network + ')', () => { const network = NETWORKS[f.network] const keyPair = ECPair.fromWIF(f.WIF, network) assert.strictEqual(keyPair.privateKey.toString('hex'), f.d) assert.strictEqual(keyPair.compressed, f.compressed) assert.strictEqual(keyPair.network, network) }) }) fixtures.valid.forEach(f => { it('imports ' + f.WIF + ' (via list of networks)', () => { const keyPair = ECPair.fromWIF(f.WIF, NETWORKS_LIST) assert.strictEqual(keyPair.privateKey.toString('hex'), f.d) assert.strictEqual(keyPair.compressed, f.compressed) assert.strictEqual(keyPair.network, NETWORKS[f.network]) }) }) fixtures.invalid.fromWIF.forEach(f => { it('throws on ' + f.WIF, () => { assert.throws(() => { const networks = f.network ? NETWORKS[f.network] : NETWORKS_LIST ECPair.fromWIF(f.WIF, networks) }, new RegExp(f.exception)) }) }) }) describe('toWIF', () => { fixtures.valid.forEach(f => { it('exports ' + f.WIF, () => { const keyPair = ECPair.fromWIF(f.WIF, NETWORKS_LIST) const result = keyPair.toWIF() assert.strictEqual(result, f.WIF) }) }) }) describe('makeRandom', () => { const d = Buffer.alloc(32, 4) const exWIF = 'KwMWvwRJeFqxYyhZgNwYuYjbQENDAPAudQx5VEmKJrUZcq6aL2pv' describe('uses randombytes RNG', () => { it('generates a ECPair', () => { const stub = { randombytes: () => { return d } } const ProxiedECPair = proxyquire('../src/ecpair', stub) const keyPair = ProxiedECPair.makeRandom() assert.strictEqual(keyPair.toWIF(), exWIF) }) }) it('allows a custom RNG to be used', () => { const keyPair = ECPair.makeRandom({ rng: size => { return d.slice(0, size) } }) assert.strictEqual(keyPair.toWIF(), exWIF) }) it('retains the same defaults as ECPair constructor', () => { const keyPair = ECPair.makeRandom() assert.strictEqual(keyPair.compressed, true) assert.strictEqual(keyPair.network, NETWORKS.bitcoin) }) it('supports the options parameter', () => { const keyPair = ECPair.makeRandom({ compressed: false, network: NETWORKS.testnet }) assert.strictEqual(keyPair.compressed, false) assert.strictEqual(keyPair.network, NETWORKS.testnet) }) it('throws if d is bad length', () => { function rng () { return Buffer.alloc(28) } assert.throws(() => { ECPair.makeRandom({ rng: rng }) }, /Expected Buffer\(Length: 32\), got Buffer\(Length: 28\)/) }) it('loops until d is within interval [1, n) : 1', hoodwink(function () { const rng = this.stub(() => { if (rng.calls === 0) return ZERO // 0 return ONE // >0 }, 2) ECPair.makeRandom({ rng: rng }) })) it('loops until d is within interval [1, n) : n - 1', hoodwink(function () { const rng = this.stub(() => { if (rng.calls === 0) return ZERO // <1 if (rng.calls === 1) return GROUP_ORDER // >n-1 return GROUP_ORDER_LESS_1 // n-1 }, 3) ECPair.makeRandom({ rng: rng }) })) }) describe('.network', () => { fixtures.valid.forEach(f => { it('returns ' + f.network + ' for ' + f.WIF, () => { const network = NETWORKS[f.network] const keyPair = ECPair.fromWIF(f.WIF, NETWORKS_LIST) assert.strictEqual(keyPair.network, network) }) }) }) describe('tinysecp wrappers', () => { let keyPair let hash let signature beforeEach(() => { keyPair = ECPair.makeRandom() hash = ZERO signature = Buffer.alloc(64, 1) }) describe('signing', () => { it('wraps tinysecp.sign', hoodwink(function () { this.mock(tinysecp, 'sign', (h, d) => { assert.strictEqual(h, hash) assert.strictEqual(d, keyPair.privateKey) return signature }, 1) assert.strictEqual(keyPair.sign(hash), signature) })) it('throws if no private key is found', () => { delete keyPair.__D assert.throws(() => { keyPair.sign(hash) }, /Missing private key/) }) }) describe('verify', () => { it('wraps tinysecp.verify', hoodwink(function () { this.mock(tinysecp, 'verify', (h, q, s) => { assert.strictEqual(h, hash) assert.strictEqual(q, keyPair.publicKey) assert.strictEqual(s, signature) return true }, 1) assert.strictEqual(keyPair.verify(hash, signature), true) })) }) }) describe('optional low R signing', () => { const sig = Buffer.from('95a6619140fca3366f1d3b013b0367c4f86e39508a50fdce' + 'e5245fbb8bd60aa6086449e28cf15387cf9f85100bfd0838624ca96759e59f65c10a00' + '16b86f5229', 'hex') const sigLowR = Buffer.from('6a2660c226e8055afad317eeba918a304be79208d505' + '3bc5ea4a5e4c5892b4a061c717c5284ae5202d721c0e49b4717b79966280906b1d3b52' + '95d1fdde963c35', 'hex') const lowRKeyPair = ECPair.fromWIF('L3nThUzbAwpUiBAjR5zCu66ybXSPMr2zZ3ikp' + 'ScpTPiYTxBynfZu') const dataToSign = Buffer.from('b6c5c548a7f6164c8aa7af5350901626ebd69f9ae' + '2c1ecf8871f5088ec204cfe', 'hex') it('signs with normal R by default', () => { const signed = lowRKeyPair.sign(dataToSign) assert.deepStrictEqual(sig, signed) }) it('signs with low R when true is passed', () => { const signed = lowRKeyPair.sign(dataToSign, true) assert.deepStrictEqual(sigLowR, signed) }) }) })