@bsv/sdk 1.1.12 → 1.1.14

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

@@ -6,172 +6,171 @@ 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 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)
     })
-
-    it('should have a wordlist of length 2048', () => {
-        expect(enWordList.value.length).toEqual(2048)
+  })
+
+  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)).toEqual(toHex(mB.seed))
     })
+  })
 
-    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')
+  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 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)
+    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('#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('@fromRandom', () => {
+    it('should throw an error if bits is too low', () => {
+      expect(() => {
+        Mnemonic.fromRandom(127)
+      }).toThrow('bits must be multiple of 32')
     })
 
-    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[]))
-        })
+    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('#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('#fromEntropy', () => {
+    it('should build from entropy', () => {
+      const m = new Mnemonic().fromEntropy(Random(32))
+      expect(m).toBeDefined()
     })
+  })
 
-    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 = Mnemonic.fromEntropy(Random(32))
+      expect(m).toBeDefined()
     })
-
-    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('#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('#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)
     })
 
-    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)
-        })
+    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)
-            })
-        })
-
+  })
+
+  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)
+      })
     })
+  })
 })