284 lines
8.5 KiB
JavaScript
284 lines
8.5 KiB
JavaScript
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)
|
|
})
|
|
})
|
|
})
|