@bsv/wallet-toolbox 1.7.13 → 1.7.15

package/mobile/node_modules/@bsv/sdk/src/primitives/__tests/Curve.unit.test.ts

@@ -0,0 +1,277 @@
+/* eslint-env jest */
+import Curve from '../../primitives/Curve'
+import Point from '../../primitives/Point'
+import JPoint from '../../primitives/JacobianPoint'
+import BigNumber from '../../primitives/BigNumber'
+
+describe('Curve', () => {
+  it('should work with secp256k1', () => {
+    const curve = new Curve()
+
+    const p = new Point(
+      '79be667e f9dcbbac 55a06295 ce870b07 029bfcdb 2dce28d9 59f2815b 16f81798',
+      '483ada77 26a3c465 5da4fbfc 0e1108a8 fd17b448 a6855419 9c47d08f fb10d4b8'
+    )
+
+    expect(p.validate()).toBe(true)
+    expect(p.dbl().validate()).toBe(true)
+    expect(p.toJ().dbl().toP().validate()).toBe(true)
+    expect(
+      p.mul(new BigNumber('79be667e f9dcbbac 55a06295 ce870b07', 16)).validate()
+    ).toBe(true)
+
+    // Endomorphism test
+    if (curve.endo === null || curve.endo === undefined) {
+      throw new Error('curve.endo is undefined')
+    }
+    expect(curve.endo).toBeDefined()
+    expect(curve.endo.beta.fromRed().toString(16)).toEqual(
+      '7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee'
+    )
+    expect(curve.endo.lambda.toString(16)).toEqual(
+      '5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72'
+    )
+
+    const k = new BigNumber('1234567890123456789012345678901234', 16)
+    const split = curve._endoSplit(k)
+    const testK = split.k1.add(split.k2.mul(curve.endo.lambda)).umod(curve.n)
+
+    expect(testK.toString(16)).toEqual(k.toString(16))
+  })
+
+  it('should compute this problematic secp256k1 multiplication', () => {
+    const curve = new Curve()
+    const g1 = curve.g // precomputed g
+    expect(g1.precomputed).toBeDefined()
+    const g2 = new Point(g1.getX(), g1.getY()) // not precomputed g
+    expect(g2.precomputed).toBeNull()
+
+    const a = new BigNumber(
+      '6d1229a6b24c2e775c062870ad26bc261051e0198c67203167273c7c62538846',
+      16
+    )
+    const p1 = g1.mul(a)
+    const p2 = g2.mul(a)
+
+    expect(p1.eq(p2)).toBe(true)
+  })
+
+  it('should not use fixed NAF when k is too large', () => {
+    const curve = new Curve()
+    const g1 = curve.g // precomputed g
+    expect(g1.precomputed).toBeDefined()
+    const g2 = new Point(g1.getX(), g1.getY()) // not precomputed g
+    expect(g2.precomputed).toBeNull()
+
+    const a = new BigNumber(
+      '6d1229a6b24c2e775c062870ad26bc26' +
+        '1051e0198c67203167273c7c6253884612345678',
+      16
+    )
+    const p1 = g1.mul(a)
+    const p2 = g2.mul(a)
+
+    expect(p1.eq(p2)).toBe(true)
+  })
+
+  it('should not fail on secp256k1 regression', () => {
+    const curve = new Curve()
+    const k1 = new BigNumber(
+      '32efeba414cd0c830aed727749e816a01c471831536fd2fce28c56b54f5a3bb1',
+      16
+    )
+    const k2 = new BigNumber(
+      '5f2e49b5d64e53f9811545434706cde4de528af97bfd49fde1f6cf792ee37a8c',
+      16
+    )
+
+    let p1 = curve.g.mul(k1)
+    let p2 = curve.g.mul(k2)
+
+    // 2 + 2 + 1 = 2 + 1 + 2
+    const two = p2.dbl()
+    const five = two.dbl().add(p2)
+    const three = two.add(p2)
+    const maybeFive = three.add(two)
+
+    expect(maybeFive.eq(five)).toBe(true)
+
+    p1 = p1.mul(k2)
+    p2 = p2.mul(k1)
+
+    expect(p1.validate()).toBe(true)
+    expect(p2.validate()).toBe(true)
+    expect(p1.eq(p2)).toBe(true)
+  })
+
+  test('should correctly double the affine point on secp256k1', () => {
+    const bad = new JPoint(
+      new BigNumber('026a2073b1ef6fab47ace18e60e728a05180a82755bbcec9a0abc08ad9f7a3d4', 16),
+      new BigNumber('9cd8cb48c3281596139f147c1364a3ede88d3f310fdb0eb98c924e599ca1b3c9', 16),
+      new BigNumber('d78587ad45e4102f48b54b5d85598296e069ce6085002e169c6bad78ddc6d9bd', 16)
+    )
+
+    const good = new JPoint(
+      new BigNumber('e7789226739ac2eb3c7ccb2a9a910066beeed86cdb4e0f8a7fee8eeb29dc7016', 16),
+      new BigNumber('4b76b191fd6d47d07828ea965e275b76d0e3e0196cd5056d38384fbb819f9fcb', 16),
+      new BigNumber('cbf8d99056618ba132d6145b904eee1ce566e0feedb9595139c45f84e90cfa7d', 16)
+    )
+
+    // They are the same points
+    expect(bad.add(good.neg()).isInfinity()).toBe(true)
+
+    // But doubling borks them out
+    expect(bad.dbl().add(good.dbl().neg()).isInfinity()).toBe(true)
+  })
+
+  test('should correctly handle scalar multiplication of zero', () => {
+    const curve = new Curve()
+    const p1 = curve.g.mul('0')
+    const p2 = p1.mul('2')
+    expect(p1.eq(p2)).toBe(true)
+  })
+})
+
+describe('Point codec', () => {
+  interface PointDefinition {
+    coordinates: {
+      x: string
+      y: string
+    }
+    compactEncoded: string
+    encoded: string
+    hybrid: string
+  }
+
+  const makeShortTest = (definition: PointDefinition): () => void => {
+    return () => {
+      const co = definition.coordinates
+      const p = new Point(co.x, co.y)
+
+      // Encodes as expected
+      expect(p.encode(false, 'hex')).toBe(definition.encoded)
+      expect(p.encode(true, 'hex')).toBe(definition.compactEncoded)
+
+      // Decodes as expected
+      expect(Point.fromString(definition.encoded).eq(p)).toBe(true)
+      expect(Point.fromString(definition.compactEncoded).eq(p)).toBe(true)
+      expect(Point.fromString(definition.hybrid).eq(p)).toBe(true)
+    }
+  }
+
+  const shortPointEvenY = {
+    coordinates: {
+      x: '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798',
+      y: '483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8'
+    },
+    compactEncoded:
+      '02' + '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798',
+    encoded:
+      '04' +
+      '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798' +
+      '483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8',
+    hybrid:
+      '06' +
+      '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798' +
+      '483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8'
+  }
+
+  const shortPointOddY = {
+    coordinates: {
+      x: 'fff97bd5755eeea420453a14355235d382f6472f8568a18b2f057a1460297556',
+      y: 'ae12777aacfbb620f3be96017f45c560de80f0f6518fe4a03c870c36b075f297'
+    },
+    compactEncoded:
+      '03' + 'fff97bd5755eeea420453a14355235d382f6472f8568a18b2f057a1460297556',
+    encoded:
+      '04' +
+      'fff97bd5755eeea420453a14355235d382f6472f8568a18b2f057a1460297556' +
+      'ae12777aacfbb620f3be96017f45c560de80f0f6518fe4a03c870c36b075f297',
+    hybrid:
+      '07' +
+      'fff97bd5755eeea420453a14355235d382f6472f8568a18b2f057a1460297556' +
+      'ae12777aacfbb620f3be96017f45c560de80f0f6518fe4a03c870c36b075f297'
+  }
+
+  it('should throw when trying to decode random bytes', () => {
+    expect(() => {
+      Point.fromString(
+        '05' +
+          '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798'
+      )
+    }).toThrow()
+  })
+
+  it(
+    'should be able to encode/decode a short curve point with even Y',
+    makeShortTest(shortPointEvenY)
+  )
+
+  it(
+    'should be able to encode/decode a short curve point with odd Y',
+    makeShortTest(shortPointOddY)
+  )
+})
+
+describe('JacobianPoint – Infinity handling and equality (TOB-18)', () => {
+  function J(x: any, y: any, z: any) {
+    return new JPoint(x, y, z)
+  }
+
+  it('Multiple infinity representations are canonicalized and equal', () => {
+    const inf1 = J(null, null, null)
+    const inf2 = J('0', '0', '0')
+    const inf3 = J(new BigNumber(0), new BigNumber(0), new BigNumber(0))
+
+    expect(inf1.isInfinity()).toBe(true)
+    expect(inf2.isInfinity()).toBe(true)
+    expect(inf3.isInfinity()).toBe(true)
+
+    expect(inf1.eq(inf2)).toBe(true)
+    expect(inf2.eq(inf3)).toBe(true)
+    expect(inf1.eq(inf3)).toBe(true)
+  })
+
+  it('Infinity must not equal a finite point', () => {
+    const inf = J(null, null, null)
+
+    const good = J(
+      new BigNumber('e7789226', 16),
+      new BigNumber('4b76b191', 16),
+      new BigNumber('cbf8d990', 16)
+    )
+
+    expect(inf.eq(good)).toBe(false)
+    expect(good.eq(inf)).toBe(false)
+  })
+
+  it('Infinity equals infinity (canonicalized)', () => {
+    const inf1 = J(null, null, null)
+    const inf2 = J('0', '0', '0')
+
+    expect(inf1.eq(inf2)).toBe(true)
+    expect(inf2.eq(inf1)).toBe(true)
+  })
+
+  it('Infinity is detected when z is zero in RED form', () => {
+    const redZero = new BigNumber(0).toRed(new Curve().red)
+    const p = J('1', '2', redZero)
+
+    expect(p.isInfinity()).toBe(true)
+
+    const clean = J(null, null, null)
+    expect(p.eq(clean)).toBe(true)
+    expect(clean.eq(p)).toBe(true)
+  })
+
+  it('eq() must handle mixed canonical and non-canonical infinity cases', () => {
+    const canonical = J(null, null, null)
+    const messy = J('1', '1', new BigNumber(0))
+
+    expect(messy.isInfinity()).toBe(true)
+    expect(canonical.eq(messy)).toBe(true)
+    expect(messy.eq(canonical)).toBe(true)
+  })
+})
+
+

package/mobile/node_modules/@bsv/sdk/src/primitives/__tests/DRBG.test.ts

@@ -0,0 +1,281 @@
+import DRBG from '../../primitives/DRBG'
+import DRBGVectors from './DRBG.vectors'
+import { toArray, toHex } from '../../primitives/utils'
+import { SHA256 } from '../../primitives/Hash'
+
+describe('DRBG', () => {
+  describe('NIST vector compatibility', () => {
+    DRBGVectors.forEach((opt, index) => {
+      it(`handles NIST-style vector ${index} consistently`, () => {
+        const entropyBytes = toArray(opt.entropy, 'hex')
+        const nonceBytes = toArray(opt.nonce, 'hex')
+
+        const expectedByteLen = opt.expected.length / 2
+
+        if (entropyBytes.length !== 32 || nonceBytes.length !== 32) {
+          expect(() => new DRBG(opt.entropy, opt.nonce)).toThrow()
+          return
+        }
+
+        const drbg1 = new DRBG(opt.entropy, opt.nonce)
+        const out1 = drbg1.generate(expectedByteLen)
+
+        const drbg2 = new DRBG(opt.entropy, opt.nonce)
+        const out2 = drbg2.generate(expectedByteLen)
+
+        expect(out1).toEqual(out2)
+        expect(out1.length).toBe(opt.expected.length)
+      })
+    })
+  })
+
+  describe('constructor input validation', () => {
+    it('throws if entropy is shorter than 32 bytes', () => {
+      const entropy = new Array(31).fill(0x01)
+      const nonce = new Array(32).fill(0x02)
+
+      expect(() => {
+        new DRBG(entropy, nonce)
+      }).toThrow('Entropy must be exactly 32 bytes (256 bits)')
+    })
+
+    it('throws if entropy is longer than 32 bytes', () => {
+      const entropy = new Array(33).fill(0x01)
+      const nonce = new Array(32).fill(0x02)
+
+      expect(() => {
+        new DRBG(entropy, nonce)
+      }).toThrow('Entropy must be exactly 32 bytes (256 bits)')
+    })
+
+    it('throws if nonce is shorter than 32 bytes', () => {
+      const entropy = new Array(32).fill(0x01)
+      const nonce = new Array(31).fill(0x02)
+
+      expect(() => {
+        new DRBG(entropy, nonce)
+      }).toThrow('Nonce must be exactly 32 bytes (256 bits)')
+    })
+
+    it('throws if nonce is longer than 32 bytes', () => {
+      const entropy = new Array(32).fill(0x01)
+      const nonce = new Array(33).fill(0x02)
+
+      expect(() => {
+        new DRBG(entropy, nonce)
+      }).toThrow('Nonce must be exactly 32 bytes (256 bits)')
+    })
+
+    it('accepts both hex strings and number[] inputs equivalently', () => {
+      const entropyArr = new Array(32).fill(0x11)
+      const nonceArr = new Array(32).fill(0x22)
+
+      const entropyHex = Buffer.from(entropyArr).toString('hex')
+      const nonceHex = Buffer.from(nonceArr).toString('hex')
+
+      const drbgArray = new DRBG(entropyArr, nonceArr)
+      const drbgHex = new DRBG(entropyHex, nonceHex)
+
+      const outArray = drbgArray.generate(32)
+      const outHex = drbgHex.generate(32)
+
+      expect(outArray).toEqual(outHex)
+    })
+  })
+
+  describe('determinism', () => {
+    const entropyHex =
+      '1b2e3d4c5f60718293a4b5c6d7e8f9011b2e3d4c5f60718293a4b5c6d7e8f901'
+    const nonceHex =
+      'abcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcd'
+
+    it('produces the same sequence for the same inputs', () => {
+      const drbg1 = new DRBG(entropyHex, nonceHex)
+      const drbg2 = new DRBG(entropyHex, nonceHex)
+
+      const seq1 = [
+        drbg1.generate(32),
+        drbg1.generate(32),
+        drbg1.generate(16)
+      ]
+
+      const seq2 = [
+        drbg2.generate(32),
+        drbg2.generate(32),
+        drbg2.generate(16)
+      ]
+
+      expect(seq1).toEqual(seq2)
+    })
+
+    it('produces different sequences if entropy changes', () => {
+      const entropyHex2 =
+        '2b3e4d5c6f708192a3b4c5d6e7f809112b3e4d5c6f708192a3b4c5d6e7f80911'
+      const drbg1 = new DRBG(entropyHex, nonceHex)
+      const drbg2 = new DRBG(entropyHex2, nonceHex)
+
+      const out1 = drbg1.generate(32)
+      const out2 = drbg2.generate(32)
+
+      expect(out1).not.toEqual(out2)
+    })
+
+    it('produces different sequences if nonce changes', () => {
+      const nonceHex2 =
+        '00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff'
+      const drbg1 = new DRBG(entropyHex, nonceHex)
+      const drbg2 = new DRBG(entropyHex, nonceHex2)
+
+      const out1 = drbg1.generate(32)
+      const out2 = drbg2.generate(32)
+
+      expect(out1).not.toEqual(out2)
+    })
+  })
+
+  describe('output length and state advancement', () => {
+    const entropyBytes = new Array(32).fill(0x33)
+    const nonceBytes = new Array(32).fill(0x44)
+
+    it('returns hex strings of length 2 * len', () => {
+      const drbg = new DRBG(entropyBytes, nonceBytes)
+
+      const out16 = drbg.generate(16)
+      const out32 = drbg.generate(32)
+
+      expect(out16.length).toBe(16 * 2)
+      expect(out32.length).toBe(32 * 2)
+    })
+
+    it('advances internal state between generate calls', () => {
+      const drbg = new DRBG(entropyBytes, nonceBytes)
+
+      const first = drbg.generate(32)
+      const second = drbg.generate(32)
+
+      expect(second).not.toEqual(first)
+    })
+
+    it('matches output when seeded with explicit number[] arrays', () => {
+      const entropyHex = 'aa'.repeat(32)
+      const nonceHex = 'bb'.repeat(32)
+      const entropyArr = toArray(entropyHex, 'hex')
+      const nonceArr = toArray(nonceHex, 'hex')
+
+      const drbgFromHex = new DRBG(entropyHex, nonceHex)
+      const drbgFromArr = new DRBG(entropyArr, nonceArr)
+
+      const outHex = drbgFromHex.generate(32)
+      const outArr = drbgFromArr.generate(32)
+
+      expect(outHex).toEqual(outArr)
+    })
+  })
+
+  describe('RFC 6979 ECDSA P-256 / SHA-256 vectors', () => {
+    // q for NIST P-256, from RFC 6979 A.2.5
+    const qHex =
+      'FFFFFFFF00000000FFFFFFFFFFFFFFFFBCE6FAADA7179E84F3B9CAC2FC632551'
+    const q = BigInt('0x' + qHex)
+
+    // int2octets: convert a non-negative bigint < 2^256 to a 32-byte big-endian array
+    const intToOctets = (x: bigint): number[] => {
+      const out = new Array<number>(32)
+      let v = x
+      for (let i = 31; i >= 0; i--) {
+        out[i] = Number(v & 0xffn)
+        v >>= 8n
+      }
+      return out
+    }
+
+    // bits2octets(h1): convert hash output to int, reduce mod q, return 32-byte big-endian
+    const bits2octets = (h1: number[]): number[] => {
+      const h1Int = BigInt('0x' + toHex(h1))
+      const z1 = h1Int % q
+      return intToOctets(z1)
+    }
+
+    const normalizeHex = (hex: string): string => hex.toLowerCase()
+
+    it('reproduces RFC 6979 k for P-256, SHA-256, message "sample"', () => {
+      // From RFC 6979 A.2.5 (ECDSA, 256 bits, P-256):
+      // private key x:
+      const xHex =
+        'C9AFA9D845BA75166B5C215767B1D6934E50C3DB36E89B127B8A622B120F6721'
+
+      // expected k for SHA-256, message = "sample"
+      const expectedKHex =
+        'A6E3C57DD01ABE90086538398355DD4C3B17AA873382B0F24D6129493D8AAD60'
+
+      const msg = 'sample'
+
+      const x = BigInt('0x' + xHex)
+      const entropy = intToOctets(x)
+
+      // h1 = SHA-256(message)
+      const h1Bytes = new SHA256().update(msg, 'utf8').digest()
+      const nonce = bits2octets(h1Bytes)
+
+      const drbg = new DRBG(entropy, nonce)
+
+      // First 32-byte block from DRBG
+      const tHex = drbg.generate(32) // 32 bytes = 64 hex chars
+      const tInt = BigInt('0x' + tHex)
+
+      // RFC 6979 derives k as tInt mod q (and retries if out of range; here it’s fine)
+      const k = tInt % q
+      const kHex = k.toString(16).padStart(64, '0')
+
+      expect(normalizeHex(kHex)).toBe(normalizeHex(expectedKHex))
+    })
+
+    it('reproduces RFC 6979 k for P-256, SHA-256, message "test"', () => {
+      // Same key x as above (RFC 6979 A.2.5), different message:
+      const xHex =
+        'C9AFA9D845BA75166B5C215767B1D6934E50C3DB36E89B127B8A622B120F6721'
+
+      // expected k for SHA-256, message = "test"
+      const expectedKHex =
+        'D16B6AE827F17175E040871A1C7EC3500192C4C92677336EC2537ACAEE0008E0'
+
+      const msg = 'test'
+
+      const x = BigInt('0x' + xHex)
+      const entropy = intToOctets(x)
+
+      const h1Bytes = new SHA256().update(msg, 'utf8').digest()
+      const nonce = bits2octets(h1Bytes)
+
+      const drbg = new DRBG(entropy, nonce)
+
+      const tHex = drbg.generate(32)
+      const tInt = BigInt('0x' + tHex)
+      const k = tInt % q
+      const kHex = k.toString(16).padStart(64, '0')
+
+      expect(normalizeHex(kHex)).toBe(normalizeHex(expectedKHex))
+    })
+
+    it('is deterministic for the same RFC 6979 key and message', () => {
+      const xHex =
+        'C9AFA9D845BA75166B5C215767B1D6934E50C3DB36E89B127B8A622B120F6721'
+      const msg = 'sample'
+
+      const x = BigInt('0x' + xHex)
+      const entropy = intToOctets(x)
+      const h1Bytes = new SHA256().update(msg, 'utf8').digest()
+      const nonce = bits2octets(h1Bytes)
+
+      const drbg1 = new DRBG(entropy, nonce)
+      const drbg2 = new DRBG(entropy, nonce)
+
+      const out1 = drbg1.generate(32)
+      const out2 = drbg2.generate(32)
+
+      expect(out1).toBe(out2)
+    })
+  })
+})
+
+

package/mobile/node_modules/@bsv/sdk/src/primitives/__tests/DRBG.vectors.ts

@@ -0,0 +1,137 @@
+export default [
+  {
+    name: '0',
+    entropy: 'ca851911349384bffe89de1cbdc46e6831e44d34a4fb935ee285dd14b71a7488',
+    nonce: '659ba96c601dc69fc902940805ec0ca8',
+    pers: null,
+    add: [null, null],
+    expected:
+      'e528e9abf2dece54d47c7e75e5fe302149f817ea9fb4bee6f4199697d04d5b89d54fbb978a15b5c443c9ec21036d2460b6f73ebad0dc2aba6e624abf07745bc107694bb7547bb0995f70de25d6b29e2d3011bb19d27676c07162c8b5ccde0668961df86803482cb37ed6d5c0bb8d50cf1f50d476aa0458bdaba806f48be9dcb8'
+  },
+  {
+    name: '1',
+    entropy: '79737479ba4e7642a221fcfd1b820b134e9e3540a35bb48ffae29c20f5418ea3',
+    nonce: '3593259c092bef4129bc2c6c9e19f343',
+    pers: null,
+    add: [null, null],
+    expected:
+      'cf5ad5984f9e43917aa9087380dac46e410ddc8a7731859c84e9d0f31bd43655b924159413e2293b17610f211e09f770f172b8fb693a35b85d3b9e5e63b1dc252ac0e115002e9bedfb4b5b6fd43f33b8e0eafb2d072e1a6fee1f159df9b51e6c8da737e60d5032dd30544ec51558c6f080bdbdab1de8a939e961e06b5f1aca37'
+  },
+  {
+    name: '2',
+    entropy: 'b340907445b97a8b589264de4a17c0bea11bb53ad72f9f33297f05d2879d898d',
+    nonce: '65cb27735d83c0708f72684ea58f7ee5',
+    pers: null,
+    add: [null, null],
+    expected:
+      '75183aaaf3574bc68003352ad655d0e9ce9dd17552723b47fab0e84ef903694a32987eeddbdc48efd24195dbdac8a46ba2d972f5808f23a869e71343140361f58b243e62722088fe10a98e43372d252b144e00c89c215a76a121734bdc485486f65c0b16b8963524a3a70e6f38f169c12f6cbdd169dd48fe4421a235847a23ff'
+  },
+  {
+    name: '3',
+    entropy: '8e159f60060a7d6a7e6fe7c9f769c30b98acb1240b25e7ee33f1da834c0858e7',
+    nonce: 'c39d35052201bdcce4e127a04f04d644',
+    pers: null,
+    add: [null, null],
+    expected:
+      '62910a77213967ea93d6457e255af51fc79d49629af2fccd81840cdfbb4910991f50a477cbd29edd8a47c4fec9d141f50dfde7c4d8fcab473eff3cc2ee9e7cc90871f180777a97841597b0dd7e779eff9784b9cc33689fd7d48c0dcd341515ac8fecf5c55a6327aea8d58f97220b7462373e84e3b7417a57e80ce946d6120db5'
+  },
+  {
+    name: '4',
+    entropy: '74755f196305f7fb6689b2fe6835dc1d81484fc481a6b8087f649a1952f4df6a',
+    nonce: 'c36387a544a5f2b78007651a7b74b749',
+    pers: null,
+    add: [null, null],
+    expected:
+      'b2896f3af4375dab67e8062d82c1a005ef4ed119d13a9f18371b1b873774418684805fd659bfd69964f83a5cfe08667ddad672cafd16befffa9faed49865214f703951b443e6dca22edb636f3308380144b9333de4bcb0735710e4d9266786342fc53babe7bdbe3c01a3addb7f23c63ce2834729fabbd419b47beceb4a460236'
+  },
+  {
+    name: '5',
+    entropy: '4b222718f56a3260b3c2625a4cf80950b7d6c1250f170bd5c28b118abdf23b2f',
+    nonce: '7aed52d0016fcaef0b6492bc40bbe0e9',
+    pers: null,
+    add: [null, null],
+    expected:
+      'a6da029b3665cd39fd50a54c553f99fed3626f4902ffe322dc51f0670dfe8742ed48415cf04bbad5ed3b23b18b7892d170a7dcf3ef8052d5717cb0c1a8b3010d9a9ea5de70ae5356249c0e098946030c46d9d3d209864539444374d8fbcae068e1d6548fa59e6562e6b2d1acbda8da0318c23752ebc9be0c1c1c5b3cf66dd967'
+  },
+  {
+    name: '6',
+    entropy: 'b512633f27fb182a076917e39888ba3ff35d23c3742eb8f3c635a044163768e0',
+    nonce: 'e2c39b84629a3de5c301db5643af1c21',
+    pers: null,
+    add: [null, null],
+    expected:
+      'fb931d0d0194a97b48d5d4c231fdad5c61aedf1c3a55ac24983ecbf38487b1c93396c6b86ff3920cfa8c77e0146de835ea5809676e702dee6a78100da9aa43d8ec0bf5720befa71f82193205ac2ea403e8d7e0e6270b366dc4200be26afd9f63b7e79286a35c688c57cbff55ac747d4c28bb80a2b2097b3b62ea439950d75dff'
+  },
+  {
+    name: '7',
+    entropy: 'aae3ffc8605a975befefcea0a7a286642bc3b95fb37bd0eb0585a4cabf8b3d1e',
+    nonce: '9504c3c0c4310c1c0746a036c91d9034',
+    pers: null,
+    add: [null, null],
+    expected:
+      '2819bd3b0d216dad59ddd6c354c4518153a2b04374b07c49e64a8e4d055575dfbc9a8fcde68bd257ff1ba5c6000564b46d6dd7ecd9c5d684fd757df62d85211575d3562d7814008ab5c8bc00e7b5a649eae2318665b55d762de36eba00c2906c0e0ec8706edb493e51ca5eb4b9f015dc932f262f52a86b11c41e9a6d5b3bd431'
+  },
+  {
+    name: '8',
+    entropy: 'b9475210b79b87180e746df704b3cbc7bf8424750e416a7fbb5ce3ef25a82cc6',
+    nonce: '24baf03599c10df6ef44065d715a93f7',
+    pers: null,
+    add: [null, null],
+    expected:
+      'ae12d784f796183c50db5a1a283aa35ed9a2b685dacea97c596ff8c294906d1b1305ba1f80254eb062b874a8dfffa3378c809ab2869aa51a4e6a489692284a25038908a347342175c38401193b8afc498077e10522bec5c70882b7f760ea5946870bd9fc72961eedbe8bff4fd58c7cc1589bb4f369ed0d3bf26c5bbc62e0b2b2'
+  },
+  {
+    name: '9',
+    entropy: '27838eb44ceccb4e36210703ebf38f659bc39dd3277cd76b7a9bcd6bc964b628',
+    nonce: '39cfe0210db2e7b0eb52a387476e7ea1',
+    pers: null,
+    add: [null, null],
+    expected:
+      'e5e72a53605d2aaa67832f97536445ab774dd9bff7f13a0d11fd27bf6593bfb52309f2d4f09d147192199ea584503181de87002f4ee085c7dc18bf32ce5315647a3708e6f404d6588c92b2dda599c131aa350d18c747b33dc8eda15cf40e95263d1231e1b4b68f8d829f86054d49cfdb1b8d96ab0465110569c8583a424a099a'
+  },
+  {
+    name: '10',
+    entropy: 'd7129e4f47008ad60c9b5d081ff4ca8eb821a6e4deb91608bf4e2647835373a5',
+    nonce: 'a72882773f78c2fc4878295840a53012',
+    pers: null,
+    add: [null, null],
+    expected:
+      '0cbf48585c5de9183b7ff76557f8fc9ebcfdfde07e588a8641156f61b7952725bbee954f87e9b937513b16bba0f2e523d095114658e00f0f3772175acfcb3240a01de631c19c5a834c94cc58d04a6837f0d2782fa53d2f9f65178ee9c837222494c799e64c60406069bd319549b889fa00a0032dd7ba5b1cc9edbf58de82bfcd'
+  },
+  {
+    name: '11',
+    entropy: '67fe5e300c513371976c80de4b20d4473889c9f1214bce718bc32d1da3ab7532',
+    nonce: 'e256d88497738a33923aa003a8d7845c',
+    pers: null,
+    add: [null, null],
+    expected:
+      'b44660d64ef7bcebc7a1ab71f8407a02285c7592d755ae6766059e894f694373ed9c776c0cfc8594413eefb400ed427e158d687e28da3ecc205e0f7370fb089676bbb0fa591ec8d916c3d5f18a3eb4a417120705f3e2198154cd60648dbfcfc901242e15711cacd501b2c2826abe870ba32da785ed6f1fdc68f203d1ab43a64f'
+  },
+  {
+    name: '12',
+    entropy: 'de8142541255c46d66efc6173b0fe3ffaf5936c897a3ce2e9d5835616aafa2cb',
+    nonce: 'd01f9002c407127bc3297a561d89b81d',
+    pers: null,
+    add: [null, null],
+    expected:
+      '64d1020929d74716446d8a4e17205d0756b5264867811aa24d0d0da8644db25d5cde474143c57d12482f6bf0f31d10af9d1da4eb6d701bdd605a8db74fb4e77f79aaa9e450afda50b18d19fae68f03db1d7b5f1738d2fdce9ad3ee9461b58ee242daf7a1d72c45c9213eca34e14810a9fca5208d5c56d8066bab1586f1513de7'
+  },
+  {
+    name: '13',
+    entropy: '4a8e0bd90bdb12f7748ad5f147b115d7385bb1b06aee7d8b76136a25d779bcb7',
+    nonce: '7f3cce4af8c8ce3c45bdf23c6b181a00',
+    pers: null,
+    add: [null, null],
+    expected:
+      '320c7ca4bbeb7af977bc054f604b5086a3f237aa5501658112f3e7a33d2231f5536d2c85c1dad9d9b0bf7f619c81be4854661626839c8c10ae7fdc0c0b571be34b58d66da553676167b00e7d8e49f416aacb2926c6eb2c66ec98bffae20864cf92496db15e3b09e530b7b9648be8d3916b3c20a3a779bec7d66da63396849aaf'
+  },
+  {
+    name: '14',
+    entropy: '451ed024bc4b95f1025b14ec3616f5e42e80824541dc795a2f07500f92adc665',
+    nonce: '2f28e6ee8de5879db1eccd58c994e5f0',
+    pers: null,
+    add: [null, null],
+    expected:
+      '3fb637085ab75f4e95655faae95885166a5fbb423bb03dbf0543be063bcd48799c4f05d4e522634d9275fe02e1edd920e26d9accd43709cb0d8f6e50aa54a5f3bdd618be23cf73ef736ed0ef7524b0d14d5bef8c8aec1cf1ed3e1c38a808b35e61a44078127c7cb3a8fd7addfa50fcf3ff3bc6d6bc355d5436fe9b71eb44f7fd'
+  }
+]