bitcoinjs-lib/test/hdnode.js

392 lines
12 KiB
JavaScript
Raw Normal View History

2015-03-19 03:35:25 +01:00
/* global describe, it, beforeEach */
2015-02-23 00:36:57 +01:00
/* eslint-disable no-new */
var assert = require('assert')
var ecdsa = require('../src/ecdsa')
2015-03-02 06:48:36 +01:00
var sinon = require('sinon')
2014-06-01 08:05:47 +02:00
var BigInteger = require('bigi')
2015-03-02 06:48:36 +01:00
var ECPair = require('../src/ecpair')
2014-06-03 09:08:42 +02:00
var HDNode = require('../src/hdnode')
2014-04-16 22:18:31 +02:00
2014-06-03 09:08:42 +02:00
var fixtures = require('./fixtures/hdnode.json')
var curve = ecdsa.__curve
var NETWORKS = require('../src/networks')
var NETWORKS_LIST = [] // Object.values(NETWORKS)
for (var networkName in NETWORKS) {
NETWORKS_LIST.push(NETWORKS[networkName])
}
2015-02-23 00:36:57 +01:00
describe('HDNode', function () {
describe('Constructor', function () {
2015-03-02 06:48:36 +01:00
var keyPair, chainCode
2014-06-01 08:05:47 +02:00
2015-03-02 06:48:36 +01:00
beforeEach(function () {
var d = BigInteger.ONE
2015-03-02 06:48:36 +01:00
keyPair = new ECPair(d, null)
chainCode = new Buffer(32)
chainCode.fill(1)
2014-06-01 08:05:47 +02:00
})
it('stores the keyPair/chainCode directly', function () {
var hd = new HDNode(keyPair, chainCode)
assert.strictEqual(hd.keyPair, keyPair)
assert.strictEqual(hd.chainCode, chainCode)
})
2015-02-23 00:36:57 +01:00
it('has a default depth/index of 0', function () {
2015-03-02 06:48:36 +01:00
var hd = new HDNode(keyPair, chainCode)
2014-06-01 08:05:47 +02:00
assert.strictEqual(hd.depth, 0)
assert.strictEqual(hd.index, 0)
})
2015-03-02 06:48:36 +01:00
it('throws on uncompressed keyPair', function () {
keyPair.compressed = false
2014-06-01 08:05:47 +02:00
2015-03-02 06:48:36 +01:00
assert.throws(function () {
new HDNode(keyPair, chainCode)
}, /BIP32 only allows compressed keyPairs/)
2014-06-01 08:05:47 +02:00
})
2015-02-23 00:36:57 +01:00
it('throws when an invalid length chain code is given', function () {
assert.throws(function () {
new HDNode(keyPair, new Buffer(20))
2016-09-30 08:25:13 +02:00
}, /Expected property "1" of type Buffer\(Length: 32\), got Buffer\(Length: 20\)/)
2014-06-01 08:05:47 +02:00
})
})
2015-02-23 00:36:57 +01:00
describe('fromSeed*', function () {
fixtures.valid.forEach(function (f) {
it('calculates privKey and chainCode for ' + f.master.fingerprint, function () {
var network = NETWORKS[f.network]
var hd = HDNode.fromSeedHex(f.master.seed, network)
2014-06-01 08:05:47 +02:00
2015-05-07 03:29:20 +02:00
assert.strictEqual(hd.keyPair.toWIF(), f.master.wif)
assert.strictEqual(hd.chainCode.toString('hex'), f.master.chainCode)
2014-06-01 08:05:47 +02:00
})
})
2014-07-11 08:33:39 +02:00
it('throws if IL is not within interval [1, n - 1] | IL === 0', sinon.test(function () {
this.mock(BigInteger).expects('fromBuffer')
.once().returns(BigInteger.ZERO)
assert.throws(function () {
HDNode.fromSeedHex('ffffffffffffffffffffffffffffffff')
}, /Private key must be greater than 0/)
}))
it('throws if IL is not within interval [1, n - 1] | IL === n', sinon.test(function () {
this.mock(BigInteger).expects('fromBuffer')
.once().returns(curve.n)
assert.throws(function () {
HDNode.fromSeedHex('ffffffffffffffffffffffffffffffff')
}, /Private key must be less than the curve order/)
}))
2015-02-23 00:36:57 +01:00
it('throws on low entropy seed', function () {
assert.throws(function () {
2014-07-11 08:33:39 +02:00
HDNode.fromSeedHex('ffffffffff')
2014-07-11 11:15:56 +02:00
}, /Seed should be at least 128 bits/)
2014-07-11 08:33:39 +02:00
})
2015-02-23 00:36:57 +01:00
it('throws on too high entropy seed', function () {
assert.throws(function () {
2014-07-11 08:33:39 +02:00
HDNode.fromSeedHex('ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff')
2014-07-11 11:15:56 +02:00
}, /Seed should be at most 512 bits/)
2014-07-11 08:33:39 +02:00
})
2014-06-01 08:05:47 +02:00
})
2015-09-21 08:34:25 +02:00
describe('ECPair wrappers', function () {
var keyPair, hd, hash
beforeEach(function () {
keyPair = ECPair.makeRandom()
hash = new Buffer(32)
var chainCode = new Buffer(32)
hd = new HDNode(keyPair, chainCode)
})
describe('getAddress', function () {
it('wraps keyPair.getAddress', sinon.test(function () {
this.mock(keyPair).expects('getAddress')
.once().withArgs().returns('foobar')
assert.strictEqual(hd.getAddress(), 'foobar')
}))
})
2015-09-21 09:37:21 +02:00
describe('getNetwork', function () {
it('wraps keyPair.getNetwork', sinon.test(function () {
this.mock(keyPair).expects('getNetwork')
.once().withArgs().returns('network')
assert.strictEqual(hd.getNetwork(), 'network')
}))
})
2015-09-21 08:44:53 +02:00
describe('getPublicKeyBuffer', function () {
it('wraps keyPair.getPublicKeyBuffer', sinon.test(function () {
this.mock(keyPair).expects('getPublicKeyBuffer')
.once().withArgs().returns('pubKeyBuffer')
assert.strictEqual(hd.getPublicKeyBuffer(), 'pubKeyBuffer')
}))
})
2015-09-21 08:34:25 +02:00
describe('sign', function () {
it('wraps keyPair.sign', sinon.test(function () {
this.mock(keyPair).expects('sign')
.once().withArgs(hash).returns('signed')
assert.strictEqual(hd.sign(hash), 'signed')
}))
})
describe('verify', function () {
var signature
beforeEach(function () {
signature = hd.sign(hash)
})
it('wraps keyPair.verify', sinon.test(function () {
this.mock(keyPair).expects('verify')
.once().withArgs(hash, signature).returns('verified')
assert.strictEqual(hd.verify(hash, signature), 'verified')
}))
})
})
2015-02-23 00:36:57 +01:00
describe('toBase58', function () {
fixtures.valid.forEach(function (f) {
it('exports ' + f.master.base58 + ' (public) correctly', function () {
var network = NETWORKS[f.network]
var hd = HDNode.fromSeedHex(f.master.seed, network).neutered()
2014-06-01 08:05:47 +02:00
2015-05-07 03:29:20 +02:00
assert.strictEqual(hd.toBase58(), f.master.base58)
2014-06-01 08:05:47 +02:00
})
})
2015-02-23 00:36:57 +01:00
fixtures.valid.forEach(function (f) {
it('exports ' + f.master.base58Priv + ' (private) correctly', function () {
var network = NETWORKS[f.network]
var hd = HDNode.fromSeedHex(f.master.seed, network)
2014-06-01 08:05:47 +02:00
2015-05-07 03:29:20 +02:00
assert.strictEqual(hd.toBase58(), f.master.base58Priv)
2014-06-01 08:05:47 +02:00
})
2014-03-31 05:47:47 +02:00
})
})
2015-02-23 00:36:57 +01:00
describe('fromBase58', function () {
fixtures.valid.forEach(function (f) {
it('imports ' + f.master.base58 + ' (public) correctly', function () {
var network = NETWORKS[f.network]
var hd = HDNode.fromBase58(f.master.base58, network)
2014-06-01 08:05:47 +02:00
2015-05-07 03:29:20 +02:00
assert.strictEqual(hd.toBase58(), f.master.base58)
assert.strictEqual(hd.keyPair.network, network)
2016-02-05 20:24:41 +01:00
assert.strictEqual(hd.isNeutered(), true)
2014-06-01 08:05:47 +02:00
})
})
2015-02-23 00:36:57 +01:00
fixtures.valid.forEach(function (f) {
it('imports ' + f.master.base58Priv + ' (private) correctly', function () {
var network = NETWORKS[f.network]
var hd = HDNode.fromBase58(f.master.base58Priv, network)
2014-06-01 08:05:47 +02:00
2015-05-07 03:29:20 +02:00
assert.strictEqual(hd.toBase58(), f.master.base58Priv)
assert.strictEqual(hd.keyPair.network, network)
2016-02-05 20:24:41 +01:00
assert.strictEqual(hd.isNeutered(), false)
2014-06-01 08:05:47 +02:00
})
})
2015-02-23 00:36:57 +01:00
fixtures.invalid.fromBase58.forEach(function (f) {
it('throws on ' + f.string, function () {
assert.throws(function () {
var networks = f.network ? NETWORKS[f.network] : NETWORKS_LIST
HDNode.fromBase58(f.string, networks)
}, new RegExp(f.exception))
})
})
})
2015-02-23 00:36:57 +01:00
describe('getIdentifier', function () {
2014-06-01 08:05:47 +02:00
var f = fixtures.valid[0]
2015-02-23 00:36:57 +01:00
it('returns the identifier for ' + f.master.fingerprint, function () {
var hd = HDNode.fromBase58(f.master.base58, NETWORKS_LIST)
2015-05-07 03:29:20 +02:00
assert.strictEqual(hd.getIdentifier().toString('hex'), f.master.identifier)
})
2014-03-31 05:47:47 +02:00
})
2015-02-23 00:36:57 +01:00
describe('getFingerprint', function () {
2014-06-01 08:05:47 +02:00
var f = fixtures.valid[0]
2014-05-04 03:40:48 +02:00
2015-02-23 00:36:57 +01:00
it('returns the fingerprint for ' + f.master.fingerprint, function () {
var hd = HDNode.fromBase58(f.master.base58, NETWORKS_LIST)
2015-05-07 03:29:20 +02:00
assert.strictEqual(hd.getFingerprint().toString('hex'), f.master.fingerprint)
2014-05-04 03:40:48 +02:00
})
})
2015-02-23 00:36:57 +01:00
describe('neutered', function () {
2014-07-28 17:34:46 +02:00
var f = fixtures.valid[0]
2015-02-23 00:36:57 +01:00
it('strips all private information', function () {
var hd = HDNode.fromBase58(f.master.base58Priv, NETWORKS_LIST)
2014-07-28 17:34:46 +02:00
var hdn = hd.neutered()
2015-05-07 03:29:20 +02:00
assert.strictEqual(hdn.keyPair.d, undefined)
assert.strictEqual(hdn.keyPair.Q, hd.keyPair.Q)
assert.strictEqual(hdn.chainCode, hd.chainCode)
assert.strictEqual(hdn.depth, hd.depth)
assert.strictEqual(hdn.index, hd.index)
2016-02-05 20:24:41 +01:00
assert.strictEqual(hdn.isNeutered(), true)
assert.strictEqual(hd.isNeutered(), false)
2014-07-28 17:34:46 +02:00
})
})
2015-02-23 00:36:57 +01:00
describe('derive', function () {
2015-03-02 06:48:36 +01:00
function verifyVector (hd, v, depth) {
2015-05-07 03:29:20 +02:00
assert.strictEqual(hd.keyPair.toWIF(), v.wif)
assert.strictEqual(hd.keyPair.getPublicKeyBuffer().toString('hex'), v.pubKey)
assert.strictEqual(hd.chainCode.toString('hex'), v.chainCode)
assert.strictEqual(hd.depth, depth || 0)
2014-06-01 08:05:47 +02:00
if (v.hardened) {
2015-09-09 04:25:50 +02:00
assert.strictEqual(hd.index, v.m + HDNode.HIGHEST_BIT)
2014-06-01 08:05:47 +02:00
} else {
2015-05-07 03:29:20 +02:00
assert.strictEqual(hd.index, v.m)
2014-06-01 08:05:47 +02:00
}
}
2015-02-23 00:36:57 +01:00
fixtures.valid.forEach(function (f) {
var network = NETWORKS[f.network]
var hd = HDNode.fromSeedHex(f.master.seed, network)
var master = hd
2014-06-03 09:22:13 +02:00
// FIXME: test data is only testing Private -> private for now
2015-02-23 00:36:57 +01:00
f.children.forEach(function (c, i) {
it(c.description + ' from ' + f.master.fingerprint, function () {
if (c.hardened) {
hd = hd.deriveHardened(c.m)
2014-06-01 08:05:47 +02:00
} else {
hd = hd.derive(c.m)
}
2015-03-02 06:48:36 +01:00
verifyVector(hd, c, i + 1)
2014-06-01 08:05:47 +02:00
})
})
// testing deriving path from master
f.children.forEach(function (c) {
it(c.description + ' from ' + f.master.fingerprint + ' by path', function () {
var path = c.description
var child = master.derivePath(path)
var pathSplit = path.split('/').slice(1)
var pathNotM = pathSplit.join('/')
var childNotM = master.derivePath(pathNotM)
verifyVector(child, c, pathSplit.length)
verifyVector(childNotM, c, pathSplit.length)
})
})
// testing deriving path from children
f.children.forEach(function (c, i) {
var cn = master.derivePath(c.description)
f.children.slice(i + 1).forEach(function (cc) {
it(cc.description + ' from ' + c.fingerprint + ' by path', function () {
var path = cc.description
var pathSplit = path.split('/').slice(i + 2)
var pathEnd = pathSplit.join('/')
var pathEndM = 'm/' + pathEnd
var child = cn.derivePath(pathEnd)
verifyVector(child, cc, pathSplit.length + i + 1)
assert.throws(function () {
cn.derivePath(pathEndM)
}, /Not a master node/)
})
})
})
})
2014-06-03 08:13:20 +02:00
2015-02-23 00:36:57 +01:00
it('works for Private -> public (neutered)', function () {
2014-06-03 09:22:13 +02:00
var f = fixtures.valid[1]
var c = f.children[0]
var master = HDNode.fromBase58(f.master.base58Priv, NETWORKS_LIST)
var child = master.derive(c.m).neutered()
2014-06-03 09:22:13 +02:00
2015-05-07 03:29:20 +02:00
assert.strictEqual(child.toBase58(), c.base58)
2014-06-03 09:22:13 +02:00
})
2015-02-23 00:36:57 +01:00
it('works for Private -> public (neutered, hardened)', function () {
2014-06-03 09:22:13 +02:00
var f = fixtures.valid[0]
var c = f.children[0]
var master = HDNode.fromBase58(f.master.base58Priv, NETWORKS_LIST)
var child = master.deriveHardened(c.m).neutered()
2014-06-03 09:22:13 +02:00
2015-05-07 03:29:20 +02:00
assert.strictEqual(child.toBase58(), c.base58)
2014-06-03 09:22:13 +02:00
})
2015-02-23 00:36:57 +01:00
it('works for Public -> public', function () {
2014-06-03 08:13:20 +02:00
var f = fixtures.valid[1]
var c = f.children[0]
var master = HDNode.fromBase58(f.master.base58, NETWORKS_LIST)
var child = master.derive(c.m)
2014-06-03 08:13:20 +02:00
2015-05-07 03:29:20 +02:00
assert.strictEqual(child.toBase58(), c.base58)
2014-06-03 08:13:20 +02:00
})
2015-02-23 00:36:57 +01:00
it('throws on Public -> public (hardened)', function () {
2014-06-03 09:22:13 +02:00
var f = fixtures.valid[0]
2014-06-03 08:13:20 +02:00
var c = f.children[0]
var master = HDNode.fromBase58(f.master.base58, NETWORKS_LIST)
2014-06-03 08:13:20 +02:00
2015-02-23 00:36:57 +01:00
assert.throws(function () {
master.deriveHardened(c.m)
2014-06-03 08:13:20 +02:00
}, /Could not derive hardened child key/)
})
it('throws on wrong types', function () {
var f = fixtures.valid[0]
var master = HDNode.fromBase58(f.master.base58, NETWORKS_LIST)
fixtures.invalid.derive.forEach(function (fx) {
assert.throws(function () {
master.derive(fx)
}, /Expected UInt32/)
})
fixtures.invalid.deriveHardened.forEach(function (fx) {
assert.throws(function () {
master.deriveHardened(fx)
}, /Expected UInt31/)
})
fixtures.invalid.derivePath.forEach(function (fx) {
assert.throws(function () {
master.derivePath(fx)
}, /Expected BIP32 derivation path/)
})
})
2014-03-31 05:47:47 +02:00
})
})