@bsv/sdk 1.0.0

package/src/compat/__tests/ECIES.test.ts

@@ -0,0 +1,90 @@
+import ECIES from '../../../dist/cjs/src/compat/ECIES'
+import * as Hash from '../../../dist/cjs/src/primitives/Hash'
+import PrivateKey from '../../../dist/cjs/src/primitives/PrivateKey'
+import { toArray, toHex, encode, toBase64 } from '../../../dist/cjs/src/primitives/utils'
+
+describe('#ECIES', () => {
+    it('should make a new ECIES object', () => {
+        expect(ECIES).toBeDefined()
+    })
+
+    const fromkey = new PrivateKey(42)
+    const tokey = new PrivateKey(88)
+    const messageBuf = Hash.sha256(toArray('my message is the hash of this string', 'utf8'))
+
+    describe('@bitcoreEncrypt', () => {
+        it('should return a buffer', () => {
+            const encBuf = ECIES.bitcoreEncrypt(messageBuf, tokey.toPublicKey(), fromkey)
+            expect(Array.isArray(encBuf)).toEqual(true)
+        })
+
+        it('should return a buffer if fromkey is not present', () => {
+            const encBuf = ECIES.bitcoreEncrypt(messageBuf, tokey.toPublicKey())
+            expect(Array.isArray(encBuf)).toEqual(true)
+        })
+    })
+
+    describe('@bitcoreDecrypt', () => {
+        it('should decrypt that which was encrypted', () => {
+            const encBuf = ECIES.bitcoreEncrypt(messageBuf, tokey.toPublicKey(), fromkey)
+            const messageBuf2 = ECIES.bitcoreDecrypt(encBuf, tokey)
+            expect(toHex(messageBuf2)).toEqual(toHex(messageBuf))
+        })
+
+        it('should decrypt that which was encrypted if fromPrivateKey was randomly generated', () => {
+            const encBuf = ECIES.bitcoreEncrypt(messageBuf, tokey.toPublicKey())
+            const messageBuf2 = ECIES.bitcoreDecrypt(encBuf, tokey)
+            expect(messageBuf2).toEqual(messageBuf)
+        })
+    })
+
+    describe('Electrum ECIES', () => {
+        // const alicePrivateKey = PrivateKey.fromString('L1Ejc5dAigm5XrM3mNptMEsNnHzS7s51YxU7J61ewGshZTKkbmzJ')
+        // const bobPrivateKey = PrivateKey.fromString('KxfxrUXSMjJQcb3JgnaaA6MqsrKQ1nBSxvhuigdKRyFiEm6BZDgG')
+        const alicePrivateKey = PrivateKey.fromString('77e06abc52bf065cb5164c5deca839d0276911991a2730be4d8d0a0307de7ceb', 16)
+        const bobPrivateKey = PrivateKey.fromString('2b57c7c5e408ce927eef5e2efb49cfdadde77961d342daa72284bb3d6590862d', 16)
+
+        it('should do these test vectors correctly', () => {
+            const message = toArray('this is my test message', 'utf8')
+
+            expect(ECIES.electrumDecrypt(
+                toArray(
+                    'QklFMQOGFyMXLo9Qv047K3BYJhmnJgt58EC8skYP/R2QU/U0yXXHOt6L3tKmrXho6yj6phfoiMkBOhUldRPnEI4fSZXbiaH4FsxKIOOvzolIFVAS0FplUmib2HnlAM1yP/iiPsU=',
+                    'base64'
+                ),
+                alicePrivateKey
+            ))
+                .toEqual(message)
+            expect(ECIES.electrumDecrypt(
+                toArray(
+                    'QklFMQM55QTWSSsILaluEejwOXlrBs1IVcEB4kkqbxDz4Fap53XHOt6L3tKmrXho6yj6phfoiMkBOhUldRPnEI4fSZXbvZJHgyAzxA6SoujduvJXv+A9ri3po9veilrmc8p6dwo=',
+                    'base64'
+                ),
+                bobPrivateKey
+            ))
+                .toEqual(message)
+
+            expect(toBase64(
+                ECIES.electrumEncrypt(message, bobPrivateKey.toPublicKey(), alicePrivateKey)
+            ))
+                .toEqual(
+                    'QklFMQM55QTWSSsILaluEejwOXlrBs1IVcEB4kkqbxDz4Fap53XHOt6L3tKmrXho6yj6phfoiMkBOhUldRPnEI4fSZXbvZJHgyAzxA6SoujduvJXv+A9ri3po9veilrmc8p6dwo='
+                )
+            expect(toBase64(ECIES.electrumEncrypt(message, alicePrivateKey.toPublicKey(), bobPrivateKey)))
+                .toEqual(
+                    'QklFMQOGFyMXLo9Qv047K3BYJhmnJgt58EC8skYP/R2QU/U0yXXHOt6L3tKmrXho6yj6phfoiMkBOhUldRPnEI4fSZXbiaH4FsxKIOOvzolIFVAS0FplUmib2HnlAM1yP/iiPsU='
+                )
+        })
+
+        it('should encrypt and decrypt symmetrically with matching strings in ECDH noKey mode', () => {
+            const message = toArray('this is my ECDH test message', 'utf8')
+            const ecdhMessageEncryptedBob = ECIES.electrumEncrypt(message, bobPrivateKey.toPublicKey(), alicePrivateKey, true)
+            const ecdhMessageEncryptedAlice = ECIES.electrumEncrypt(message, alicePrivateKey.toPublicKey(), bobPrivateKey, true)
+            expect(ecdhMessageEncryptedBob).toEqual(ecdhMessageEncryptedAlice)
+            expect(ECIES.electrumDecrypt(ecdhMessageEncryptedAlice, bobPrivateKey, alicePrivateKey.toPublicKey()))
+                .toEqual(toArray('this is my ECDH test message', 'utf8'))
+            expect(ECIES.electrumDecrypt(ecdhMessageEncryptedBob, alicePrivateKey, bobPrivateKey.toPublicKey()))
+                .toEqual(toArray('this is my ECDH test message', 'utf8'))
+        })
+    })
+})

package/src/compat/__tests/HD.test.ts

@@ -0,0 +1,405 @@
+import HD from '../../../dist/cjs/src/compat/HD'
+import { fromBase58Check, toBase58Check, toArray, toHex } from '../../../dist/cjs/src/primitives/utils'
+
+describe('HD', () => {
+    it('should satisfy these basic API features', () => {
+        expect(HD.fromRandom().toString().slice(0, 4)).toEqual('xprv')
+        expect(HD.fromRandom().toPublic().toString().slice(0, 4)).toEqual('xpub')
+    })
+
+    // test vectors: https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki
+    const vector1master = '000102030405060708090a0b0c0d0e0f'
+    const vector1mPublic =
+        'xpub661MyMwAqRbcFtXgS5sYJABqqG9YLmC4Q1Rdap9gSE8NqtwybGhePY2gZ29ESFjqJoCu1Rupje8YtGqsefD265TMg7usUDFdp6W1EGMcet8'
+    const vector1mPrivate =
+        'xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi'
+    const vector1m0hPublic =
+        'xpub68Gmy5EdvgibQVfPdqkBBCHxA5htiqg55crXYuXoQRKfDBFA1WEjWgP6LHhwBZeNK1VTsfTFUHCdrfp1bgwQ9xv5ski8PX9rL2dZXvgGDnw'
+    const vector1m0hPrivate =
+        'xprv9uHRZZhk6KAJC1avXpDAp4MDc3sQKNxDiPvvkX8Br5ngLNv1TxvUxt4cV1rGL5hj6KCesnDYUhd7oWgT11eZG7XnxHrnYeSvkzY7d2bhkJ7'
+    const vector1m0h1Public =
+        'xpub6ASuArnXKPbfEwhqN6e3mwBcDTgzisQN1wXN9BJcM47sSikHjJf3UFHKkNAWbWMiGj7Wf5uMash7SyYq527Hqck2AxYysAA7xmALppuCkwQ'
+    const vector1m0h1Private =
+        'xprv9wTYmMFdV23N2TdNG573QoEsfRrWKQgWeibmLntzniatZvR9BmLnvSxqu53Kw1UmYPxLgboyZQaXwTCg8MSY3H2EU4pWcQDnRnrVA1xe8fs'
+    const vector1m0h12hPublic =
+        'xpub6D4BDPcP2GT577Vvch3R8wDkScZWzQzMMUm3PWbmWvVJrZwQY4VUNgqFJPMM3No2dFDFGTsxxpG5uJh7n7epu4trkrX7x7DogT5Uv6fcLW5'
+    const vector1m0h12hPrivate =
+        'xprv9z4pot5VBttmtdRTWfWQmoH1taj2axGVzFqSb8C9xaxKymcFzXBDptWmT7FwuEzG3ryjH4ktypQSAewRiNMjANTtpgP4mLTj34bhnZX7UiM'
+    const vector1m0h12h2Public =
+        'xpub6FHa3pjLCk84BayeJxFW2SP4XRrFd1JYnxeLeU8EqN3vDfZmbqBqaGJAyiLjTAwm6ZLRQUMv1ZACTj37sR62cfN7fe5JnJ7dh8zL4fiyLHV'
+    const vector1m0h12h2Private =
+        'xprvA2JDeKCSNNZky6uBCviVfJSKyQ1mDYahRjijr5idH2WwLsEd4Hsb2Tyh8RfQMuPh7f7RtyzTtdrbdqqsunu5Mm3wDvUAKRHSC34sJ7in334'
+    const vector1m0h12h21000000000Public =
+        'xpub6H1LXWLaKsWFhvm6RVpEL9P4KfRZSW7abD2ttkWP3SSQvnyA8FSVqNTEcYFgJS2UaFcxupHiYkro49S8yGasTvXEYBVPamhGW6cFJodrTHy'
+    const vector1m0h12h21000000000Private =
+        'xprvA41z7zogVVwxVSgdKUHDy1SKmdb533PjDz7J6N6mV6uS3ze1ai8FHa8kmHScGpWmj4WggLyQjgPie1rFSruoUihUZREPSL39UNdE3BBDu76'
+    const vector2master =
+        'fffcf9f6f3f0edeae7e4e1dedbd8d5d2cfccc9c6c3c0bdbab7b4b1aeaba8a5a29f9c999693908d8a8784817e7b7875726f6c696663605d5a5754514e4b484542'
+    const vector2mPublic =
+        'xpub661MyMwAqRbcFW31YEwpkMuc5THy2PSt5bDMsktWQcFF8syAmRUapSCGu8ED9W6oDMSgv6Zz8idoc4a6mr8BDzTJY47LJhkJ8UB7WEGuduB'
+    const vector2mPrivate =
+        'xprv9s21ZrQH143K31xYSDQpPDxsXRTUcvj2iNHm5NUtrGiGG5e2DtALGdso3pGz6ssrdK4PFmM8NSpSBHNqPqm55Qn3LqFtT2emdEXVYsCzC2U'
+    const vector2m0Public =
+        'xpub69H7F5d8KSRgmmdJg2KhpAK8SR3DjMwAdkxj3ZuxV27CprR9LgpeyGmXUbC6wb7ERfvrnKZjXoUmmDznezpbZb7ap6r1D3tgFxHmwMkQTPH'
+    const vector2m0Private =
+        'xprv9vHkqa6EV4sPZHYqZznhT2NPtPCjKuDKGY38FBWLvgaDx45zo9WQRUT3dKYnjwih2yJD9mkrocEZXo1ex8G81dwSM1fwqWpWkeS3v86pgKt'
+    const vector2m02147483647hPublic =
+        'xpub6ASAVgeehLbnwdqV6UKMHVzgqAG8Gr6riv3Fxxpj8ksbH9ebxaEyBLZ85ySDhKiLDBrQSARLq1uNRts8RuJiHjaDMBU4Zn9h8LZNnBC5y4a'
+    const vector2m02147483647hPrivate =
+        'xprv9wSp6B7kry3Vj9m1zSnLvN3xH8RdsPP1Mh7fAaR7aRLcQMKTR2vidYEeEg2mUCTAwCd6vnxVrcjfy2kRgVsFawNzmjuHc2YmYRmagcEPdU9'
+    const vector2m02147483647h1Public =
+        'xpub6DF8uhdarytz3FWdA8TvFSvvAh8dP3283MY7p2V4SeE2wyWmG5mg5EwVvmdMVCQcoNJxGoWaU9DCWh89LojfZ537wTfunKau47EL2dhHKon'
+    const vector2m02147483647h1Private =
+        'xprv9zFnWC6h2cLgpmSA46vutJzBcfJ8yaJGg8cX1e5StJh45BBciYTRXSd25UEPVuesF9yog62tGAQtHjXajPPdbRCHuWS6T8XA2ECKADdw4Ef'
+    const vector2m02147483647h12147483646hPublic =
+        'xpub6ERApfZwUNrhLCkDtcHTcxd75RbzS1ed54G1LkBUHQVHQKqhMkhgbmJbZRkrgZw4koxb5JaHWkY4ALHY2grBGRjaDMzQLcgJvLJuZZvRcEL'
+    const vector2m02147483647h12147483646hPrivate =
+        'xprvA1RpRA33e1JQ7ifknakTFpgNXPmW2YvmhqLQYMmrj4xJXXWYpDPS3xz7iAxn8L39njGVyuoseXzU6rcxFLJ8HFsTjSyQbLYnMpCqE2VbFWc'
+    const vector2m02147483647h12147483646h2Public =
+        'xpub6FnCn6nSzZAw5Tw7cgR9bi15UV96gLZhjDstkXXxvCLsUXBGXPdSnLFbdpq8p9HmGsApME5hQTZ3emM2rnY5agb9rXpVGyy3bdW6EEgAtqt'
+    const vector2m02147483647h12147483646h2Private =
+        'xprvA2nrNbFZABcdryreWet9Ea4LvTJcGsqrMzxHx98MMrotbir7yrKCEXw7nadnHM8Dq38EGfSh6dqA9QWTyefMLEcBYJUuekgW4BYPJcr9E7j'
+
+    it('should make a new a bip32', () => {
+        let bip32
+        bip32 = new HD()
+        expect(bip32).toBeDefined()
+        expect(new HD().fromString(vector1mPrivate).toString()).toEqual(vector1mPrivate)
+        expect(new HD()
+            .fromString(new HD().fromString(vector1mPrivate).toString())
+            .toString())
+            .toEqual(vector1mPrivate)
+    })
+
+    it('should initialize test vector 1 from the extended public key', () => {
+        const bip32 = new HD().fromString(vector1mPublic)
+        expect(bip32).toBeDefined()
+    })
+
+    it('should initialize test vector 1 from the extended private key', () => {
+        const bip32 = new HD().fromString(vector1mPrivate)
+        expect(bip32).toBeDefined()
+    })
+
+    it('should get the extended public key from the extended private key for test vector 1', () => {
+        const bip32 = new HD().fromString(vector1mPrivate)
+        expect(bip32.toPublic().toString()).toEqual(vector1mPublic)
+    })
+
+    it("should get m/0' ext. private key from test vector 1", () => {
+        const bip32 = new HD().fromString(vector1mPrivate)
+        const child = bip32.derive("m/0'")
+        expect(child).toBeDefined()
+        expect(child.toString()).toEqual(vector1m0hPrivate)
+    })
+
+    it("should get m/0' ext. public key from test vector 1", () => {
+        const bip32 = new HD().fromString(vector1mPrivate)
+        const child = bip32.derive("m/0'")
+        expect(child).toBeDefined()
+        expect(child.toPublic().toString()).toEqual(vector1m0hPublic)
+    })
+
+    it("should get m/0'/1 ext. private key from test vector 1", () => {
+        const bip32 = new HD().fromString(vector1mPrivate)
+        const child = bip32.derive("m/0'/1")
+        expect(child).toBeDefined()
+        expect(child.toString()).toEqual(vector1m0h1Private)
+    })
+
+    it("should get m/0'/1 ext. public key from test vector 1", () => {
+        const bip32 = new HD().fromString(vector1mPrivate)
+        const child = bip32.derive("m/0'/1")
+        expect(child).toBeDefined()
+        expect(child.toPublic().toString()).toEqual(vector1m0h1Public)
+    })
+
+    it("should get m/0'/1 ext. public key from m/0' public key from test vector 1", () => {
+        const bip32 = new HD().fromString(vector1mPrivate)
+        const child = bip32.derive("m/0'")
+        const childPub = new HD().fromString(child.toPublic().toString())
+        const child2 = childPub.derive('m/1')
+        expect(child2).toBeDefined()
+        expect(child2.toPublic().toString()).toEqual(vector1m0h1Public)
+    })
+
+    it("should get m/0'/1/2h ext. private key from test vector 1", () => {
+        const bip32 = new HD().fromString(vector1mPrivate)
+        const child = bip32.derive("m/0'/1/2'")
+        expect(child).toBeDefined()
+        expect(child.toString()).toEqual(vector1m0h12hPrivate)
+    })
+
+    it("should get m/0'/1/2h ext. public key from test vector 1", () => {
+        const bip32 = new HD().fromString(vector1mPrivate)
+        const child = bip32.derive("m/0'/1/2'")
+        expect(child).toBeDefined()
+        expect(child.toPublic().toString()).toEqual(vector1m0h12hPublic)
+    })
+
+    it("should get m/0'/1/2h/2 ext. private key from test vector 1", () => {
+        const bip32 = new HD().fromString(vector1mPrivate)
+        const child = bip32.derive("m/0'/1/2'/2")
+        expect(child).toBeDefined()
+        expect(child.toString()).toEqual(vector1m0h12h2Private)
+    })
+
+    it("should get m/0'/1/2'/2 ext. public key from m/0'/1/2' public key from test vector 1", () => {
+        const bip32 = new HD().fromString(vector1mPrivate)
+        const child = bip32.derive("m/0'/1/2'")
+        const childPub = new HD().fromString(child.toPublic().toString())
+        const child2 = childPub.derive('m/2')
+        expect(child2).toBeDefined()
+        expect(child2.toPublic().toString()).toEqual(vector1m0h12h2Public)
+    })
+
+    it("should get m/0'/1/2h/2 ext. public key from test vector 1", () => {
+        const bip32 = new HD().fromString(vector1mPrivate)
+        const child = bip32.derive("m/0'/1/2'/2")
+        expect(child).toBeDefined()
+        expect(child.toPublic().toString()).toEqual(vector1m0h12h2Public)
+    })
+
+    it("should get m/0'/1/2h/2/1000000000 ext. private key from test vector 1", () => {
+        const bip32 = new HD().fromString(vector1mPrivate)
+        const child = bip32.derive("m/0'/1/2'/2/1000000000")
+        expect(child).toBeDefined()
+        expect(child.toString()).toEqual(vector1m0h12h21000000000Private)
+    })
+
+    it("should get m/0'/1/2h/2/1000000000 ext. public key from test vector 1", () => {
+        const bip32 = new HD().fromString(vector1mPrivate)
+        const child = bip32.derive("m/0'/1/2'/2/1000000000")
+        expect(child).toBeDefined()
+        expect(child.toPublic().toString()).toEqual(vector1m0h12h21000000000Public)
+    })
+
+    it("should get m/0'/1/2'/2/1000000000 ext. public key from m/0'/1/2'/2 public key from test vector 1", () => {
+        const bip32 = new HD().fromString(vector1mPrivate)
+        const child = bip32.derive("m/0'/1/2'/2")
+        const childPub = new HD().fromString(child.toPublic().toString())
+        const child2 = childPub.derive('m/1000000000')
+        expect(child2).toBeDefined()
+        expect(child2.toPublic().toString()).toEqual(vector1m0h12h21000000000Public)
+    })
+
+    it('should initialize test vector 2 from the extended public key', () => {
+        const bip32 = new HD().fromString(vector2mPublic)
+        expect(bip32).toBeDefined()
+    })
+
+    it('should initialize test vector 2 from the extended private key', () => {
+        const bip32 = new HD().fromString(vector2mPrivate)
+        expect(bip32).toBeDefined()
+    })
+
+    it('should get the extended public key from the extended private key for test vector 2', () => {
+        const bip32 = new HD().fromString(vector2mPrivate)
+        expect(bip32.toPublic().toString()).toEqual(vector2mPublic)
+    })
+
+    it('should get m/0 ext. private key from test vector 2', () => {
+        const bip32 = new HD().fromString(vector2mPrivate)
+        const child = bip32.derive('m/0')
+        expect(child).toBeDefined()
+        expect(child.toString()).toEqual(vector2m0Private)
+    })
+
+    it('should get m/0 ext. public key from test vector 2', () => {
+        const bip32 = new HD().fromString(vector2mPrivate)
+        const child = bip32.derive('m/0')
+        expect(child).toBeDefined()
+        expect(child.toPublic().toString()).toEqual(vector2m0Public)
+    })
+
+    it('should get m/0 ext. public key from m public key from test vector 2', () => {
+        const bip32 = new HD().fromString(vector2mPrivate)
+        const child = bip32.derive('m')
+        const childPub = new HD().fromString(child.toPublic().toString())
+        const child2 = childPub.derive('m/0')
+        expect(child2).toBeDefined()
+        expect(child2.toPublic().toString()).toEqual(vector2m0Public)
+    })
+
+    it('should get m/0/2147483647h ext. private key from test vector 2', () => {
+        const bip32 = new HD().fromString(vector2mPrivate)
+        const child = bip32.derive("m/0/2147483647'")
+        expect(child).toBeDefined()
+        expect(child.toString()).toEqual(vector2m02147483647hPrivate)
+    })
+
+    it('should get m/0/2147483647h ext. public key from test vector 2', () => {
+        const bip32 = new HD().fromString(vector2mPrivate)
+        const child = bip32.derive("m/0/2147483647'")
+        expect(child).toBeDefined()
+        expect(child.toPublic().toString()).toEqual(vector2m02147483647hPublic)
+    })
+
+    it('should get m/0/2147483647h/1 ext. private key from test vector 2', () => {
+        const bip32 = new HD().fromString(vector2mPrivate)
+        const child = bip32.derive("m/0/2147483647'/1")
+        expect(child).toBeDefined()
+        expect(child.toString()).toEqual(vector2m02147483647h1Private)
+    })
+
+    it('should get m/0/2147483647h/1 ext. public key from test vector 2', () => {
+        const bip32 = new HD().fromString(vector2mPrivate)
+        const child = bip32.derive("m/0/2147483647'/1")
+        expect(child).toBeDefined()
+        expect(child.toPublic().toString()).toEqual(vector2m02147483647h1Public)
+    })
+
+    it('should get m/0/2147483647h/1 ext. public key from m/0/2147483647h public key from test vector 2', () => {
+        const bip32 = new HD().fromString(vector2mPrivate)
+        const child = bip32.derive("m/0/2147483647'")
+        const childPub = new HD().fromString(child.toPublic().toString())
+        const child2 = childPub.derive('m/1')
+        expect(child2).toBeDefined()
+        expect(child2.toPublic().toString()).toEqual(vector2m02147483647h1Public)
+    })
+
+    it('should get m/0/2147483647h/1/2147483646h ext. private key from test vector 2', () => {
+        const bip32 = new HD().fromString(vector2mPrivate)
+        const child = bip32.derive("m/0/2147483647'/1/2147483646'")
+        expect(child).toBeDefined()
+        expect(child.toString()).toEqual(vector2m02147483647h12147483646hPrivate)
+    })
+
+    it('should get m/0/2147483647h/1/2147483646h ext. public key from test vector 2', () => {
+        const bip32 = new HD().fromString(vector2mPrivate)
+        const child = bip32.derive("m/0/2147483647'/1/2147483646'")
+        expect(child).toBeDefined()
+        expect(child.toPublic().toString()).toEqual(vector2m02147483647h12147483646hPublic)
+    })
+
+    it('should get m/0/2147483647h/1/2147483646h/2 ext. private key from test vector 2', () => {
+        const bip32 = new HD().fromString(vector2mPrivate)
+        const child = bip32.derive("m/0/2147483647'/1/2147483646'/2")
+        expect(child).toBeDefined()
+        expect(child.toString()).toEqual(vector2m02147483647h12147483646h2Private)
+    })
+
+    it('should get m/0/2147483647h/1/2147483646h/2 ext. public key from test vector 2', () => {
+        const bip32 = new HD().fromString(vector2mPrivate)
+        const child = bip32.derive("m/0/2147483647'/1/2147483646'/2")
+        expect(child).toBeDefined()
+        expect(child.toPublic().toString()).toEqual(vector2m02147483647h12147483646h2Public)
+    })
+
+    it('should get m/0/2147483647h/1/2147483646h/2 ext. public key from m/0/2147483647h/2147483646h public key from test vector 2', () => {
+        const bip32 = new HD().fromString(vector2mPrivate)
+        const child = bip32.derive("m/0/2147483647'/1/2147483646'")
+        const childPub = new HD().fromString(child.toPublic().toString())
+        const child2 = childPub.derive('m/2')
+        expect(child2).toBeDefined()
+        expect(child2.toPublic().toString()).toEqual(vector2m02147483647h12147483646h2Public)
+    })
+
+    describe('#fromRandom', () => {
+        it('should not return the same one twice', () => {
+            const bip32a = new HD().fromRandom()
+            const bip32b = new HD().fromRandom()
+            expect(bip32a.toString()).not.toEqual(bip32b.toString())
+        })
+    })
+
+    describe('@fromRandom', () => {
+        it('should not return the same one twice', () => {
+            const bip32a = HD.fromRandom()
+            const bip32b = HD.fromRandom()
+            expect(bip32a.toString()).not.toEqual(bip32b.toString())
+        })
+    })
+
+    describe('#fromSeed', () => {
+        it('should initialize a new Bip32 correctly from test vector 1 seed', () => {
+            const hex = vector1master
+            const bip32 = new HD().fromSeed(toArray(hex, 'hex'))
+            expect(bip32).toBeDefined()
+            expect(bip32.toString()).toEqual(vector1mPrivate)
+            expect(bip32.toPublic().toString()).toEqual(vector1mPublic)
+        })
+
+        it('should initialize a new Bip32 correctly from test vector 2 seed', () => {
+            const hex = vector2master
+            const bip32 = new HD().fromSeed(toArray(hex, 'hex'))
+            expect(bip32).toBeDefined()
+            expect(bip32.toString()).toEqual(vector2mPrivate)
+            expect(bip32.toPublic().toString()).toEqual(vector2mPublic)
+        })
+    })
+
+    describe('@fromSeed', () => {
+        it('should initialize a new Bip32 correctly from test vector 1 seed', () => {
+            const hex = vector1master
+            const bip32 = HD.fromSeed(toArray(hex, 'hex'))
+            expect(bip32).toBeDefined()
+            expect(bip32.toString()).toEqual(vector1mPrivate)
+            expect(bip32.toPublic().toString()).toEqual(vector1mPublic)
+        })
+
+        it('should initialize a new Bip32 correctly from test vector 2 seed', () => {
+            const hex = vector2master
+            const bip32 = HD.fromSeed(toArray(hex, 'hex'))
+            expect(bip32).toBeDefined()
+            expect(bip32.toString()).toEqual(vector2mPrivate)
+            expect(bip32.toPublic().toString()).toEqual(vector2mPublic)
+        })
+    })
+
+    describe('#fromBinary', () => {
+        it('should make a bip32 from binary', () => {
+            const str =
+                'xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi'
+            const buf = fromBase58Check(str)
+            let bip32 = new HD().fromBinary([...buf.prefix, ...buf.data])
+            expect(bip32).toBeDefined()
+            expect(bip32.toString()).toEqual(str)
+            bip32 = bip32.toPublic()
+            const xpub = bip32.toString()
+            bip32 = new HD().fromBinary(bip32.toBinary())
+            expect(bip32.toString()).toEqual(xpub)
+        })
+    })
+
+    describe('#toBinary', () => {
+        it('should return a bip32 buffer', () => {
+            const str =
+                'xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi'
+            const buf = fromBase58Check(str)
+            const bip32 = new HD().fromString(str)
+            expect(toHex(bip32.toBinary())).toEqual(toHex([...buf.prefix, ...buf.data]))
+        })
+    })
+
+    describe('#fromString', () => {
+        it('should make a bip32 from a string', () => {
+            const str =
+                'xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi'
+            const bip32 = new HD().fromString(str)
+            expect(bip32).toBeDefined()
+            expect(bip32.toString()).toEqual(str)
+        })
+    })
+
+    describe('#toString', () => {
+        const bip32 = new HD()
+        bip32.fromRandom()
+        it('should return an xprv string', () => {
+            expect(bip32.toString().slice(0, 4)).toEqual('xprv')
+        })
+
+        it('should return an xpub string', () => {
+            expect(bip32.toPublic().toString().slice(0, 4)).toEqual('xpub')
+        })
+    })
+
+    describe('#isPrivate', () => {
+        it('should know if this bip32 is private', () => {
+            const bip32priv = new HD().fromRandom()
+            const bip32pub = bip32priv.toPublic()
+            expect(bip32priv.isPrivate()).toEqual(true)
+            expect(bip32pub.isPrivate()).toEqual(false)
+        })
+    })
+})

package/src/compat/__tests/Mnemonic.test.ts

@@ -0,0 +1,177 @@
+import Mnemonic from '../../../dist/cjs/src/compat/Mnemonic'
+import { wordList as enWordList } from '../../../dist/cjs/src/compat/bip-39-wordlist-en'
+import Random from '../../../dist/cjs/src/primitives/Random'
+import vectors from './Mnemonic.vectors'
+import HD from '../../../dist/cjs/src/compat/HD'
+import { toBase58Check, toHex, toArray } from '../../../dist/cjs/src/primitives/utils'
+
+describe('Mnemonic', function () {
+    it('should initialize the class', () => {
+        expect(Mnemonic).toBeDefined()
+        expect(new Mnemonic()).toBeDefined()
+    })
+
+    it('should have a wordlist of length 2048', () => {
+        expect(enWordList.value.length).toEqual(2048)
+    })
+
+    it('should handle this community-derived test vector', () => {
+        // There was a bug in Copay and bip32jp about deriving addresses with Mnemonic
+        // and bip44. This confirms we are handling the situation correctly and
+        // derive the correct value.
+        //
+        // More information here:
+        // https://github.com/iancoleman/bip39/issues/58
+        const seed = Mnemonic.fromString('fruit wave dwarf banana earth journey tattoo true farm silk olive fence').toSeed(
+            'banana'
+        )
+        let bip32 = HD.fromSeed(seed)
+        bip32 = bip32.derive("m/44'/0'/0'/0/0")
+        const pkh = bip32.pubKey.toHash()
+        const addr = toBase58Check(pkh)
+        expect(addr).toEqual('17rxURoF96VhmkcEGCj5LNQkmN9HVhWb7F')
+    })
+
+    it('should generate a mnemonic phrase that passes the check', () => {
+        let mnemonic
+
+        // should be able to make a mnemonic with or without the default wordlist
+        let m = new Mnemonic().fromRandom(128)
+        expect(m.check()).toEqual(true)
+        m = new Mnemonic().fromRandom(128)
+        expect(m.check()).toEqual(true)
+
+        const entropy = Array(32)
+        entropy.fill(0)
+        m = new Mnemonic().fromEntropy(entropy)
+        expect(m.check()).toEqual(true)
+
+        mnemonic = m.mnemonic
+
+        // mnemonics with extra whitespace do not pass the check
+        m = new Mnemonic().fromString(mnemonic + ' ')
+        expect(m.check()).toEqual(false)
+
+        // mnemonics with a word replaced do not pass the check
+        const words = mnemonic.split(' ')
+        expect(words[words.length - 1]).not.toEqual('zoo')
+        words[words.length - 1] = 'zoo'
+        mnemonic = words.join(' ')
+        expect(new Mnemonic().fromString(mnemonic).check()).toEqual(false)
+    })
+
+    describe('#toBinary', () => {
+        it('should convert to a binary array', () => {
+            const m = new Mnemonic().fromRandom()
+            expect(m.seed).toBeDefined()
+            expect(m.mnemonic).toBeDefined()
+            const buf = m.toBinary()
+            expect(buf.length).toBeGreaterThan(512 / 8 + 1 + 1)
+        })
+    })
+
+    describe('#fromBinary', () => {
+        it('should convert from a binary array', () => {
+            const mA = new Mnemonic().fromRandom()
+            const mB = new Mnemonic().fromBinary(mA.toBinary())
+            expect(mA.mnemonic).toEqual(mB.mnemonic)
+            expect(toHex(mA.seed as number[])).toEqual(toHex(mB.seed as number[]))
+        })
+    })
+
+    describe('#fromRandom', () => {
+        it('should throw an error if bits is too low', () => {
+            expect(() => {
+                new Mnemonic().fromRandom(127)
+            }).toThrow('bits must be multiple of 32')
+        })
+
+        it('should throw an error if bits is not a multiple of 32', () => {
+            expect(() => {
+                new Mnemonic().fromRandom(256 - 1)
+            }).toThrow('bits must be multiple of 32')
+        })
+    })
+
+    describe('@fromRandom', () => {
+        it('should throw an error if bits is too low', () => {
+            expect(() => {
+                Mnemonic.fromRandom(127)
+            }).toThrow('bits must be multiple of 32')
+        })
+
+        it('should throw an error if bits is not a multiple of 32', () => {
+            expect(() => {
+                Mnemonic.fromRandom(256 - 1)
+            }).toThrow('bits must be multiple of 32')
+        })
+    })
+
+    describe('#fromEntropy', () => {
+        it('should build from entropy', () => {
+            const m = new Mnemonic().fromEntropy(Random(32))
+            expect(m).toBeDefined()
+        })
+    })
+
+    describe('@fromEntropy', () => {
+        it('should build from entropy', () => {
+            const m = Mnemonic.fromEntropy(Random(32))
+            expect(m).toBeDefined()
+        })
+    })
+
+    describe('#entropy2Mnemonic', () => {
+        it('should throw an error if you do not use enough entropy', () => {
+            const buf = Buffer.alloc(128 / 8 - 1)
+            buf.fill(0)
+            expect(() => {
+                new Mnemonic().entropy2Mnemonic([...buf])
+            }).toThrow('Entropy is less than 128 bits. It must be 128 bits or more.')
+        })
+    })
+
+    describe('#fromString', () => {
+        it('should throw an error in invalid mnemonic', () => {
+            expect(() => {
+                new Mnemonic().fromString('invalid mnemonic').toSeed()
+            }).toThrow(
+                'Mnemonic does not pass the check - was the mnemonic typed incorrectly? Are there extra spaces?'
+            )
+        })
+    })
+
+    describe('@isValid', () => {
+        it('should know this is valid', () => {
+            const isValid = Mnemonic.isValid(
+                'abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about',
+                'TREZOR'
+            )
+            expect(isValid).toBe(true)
+        })
+
+        it('should know this is invalid', () => {
+            const isValid = Mnemonic.isValid(
+                'abandonnnnnnn abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about',
+                'TREZOR'
+            )
+            expect(isValid).toEqual(false)
+        })
+    })
+
+    describe('vectors', () => {
+        // eslint-disable-next-line ban/ban
+        vectors.english.forEach((vector, v) => {
+            it('should pass english test vector ' + v, () => {
+                const entropy = toArray(vector.entropy, 'hex')
+                const m = new Mnemonic().fromEntropy(entropy)
+                expect(m.toString()).toEqual(vector.mnemonic)
+                expect(m.check()).toEqual(true)
+                const seed = m.toSeed(vector.passphrase)
+                expect(toHex(seed)).toEqual(vector.seed)
+                expect(HD.fromSeed(seed).toString()).toEqual(vector.bip32_xprv)
+            })
+        })
+
+    })
+})