@bsv/wallet-toolbox 1.7.14 → 1.7.16

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

@@ -0,0 +1,38 @@
+/* eslint-env jest */
+import PublicKey from '../../primitives/PublicKey'
+import PrivateKey from '../../primitives/PrivateKey'
+import BigNumber from '../../primitives/BigNumber'
+
+describe('ECDH', function () {
+  it('should work with secp256k1', function () {
+    const s1 = PrivateKey.fromRandom()
+    const s2 = PrivateKey.fromRandom()
+    let sh1 = s1.deriveSharedSecret(s2.toPublicKey())
+    let sh2 = s2.deriveSharedSecret(s1.toPublicKey())
+    expect(sh1.toString()).toEqual(sh2.toString())
+    sh1 = s1.deriveSharedSecret(
+      PublicKey.fromString(
+        s2.toPublicKey().toDER('hex') as string
+      )
+    )
+    sh2 = s2.deriveSharedSecret(
+      PublicKey.fromString(
+        s1.toPublicKey().toDER('hex') as string
+      )
+    )
+
+    expect(sh1.toString()).toEqual(sh2.toString())
+    sh1 = s1.deriveSharedSecret(PublicKey.fromPrivateKey(s2))
+    sh2 = s2.deriveSharedSecret(PublicKey.fromPrivateKey(s1))
+    expect(sh1.toString()).toEqual(sh2.toString())
+  })
+  it('should be able to prevent a twist attack for secp256k1', () => {
+    const bob = PrivateKey.fromRandom()
+    // This is a bad point that shouldn't be able to be passed to derive.
+    // If a bad point can be passed it's possible to perform a twist attack.
+    const mallory = new PublicKey(new BigNumber(14), new BigNumber(16))
+    expect(() => {
+      bob.deriveSharedSecret(mallory)
+    }).toThrow(new Error('Public key not valid for ECDH secret derivation'))
+  })
+})

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

@@ -0,0 +1,93 @@
+import * as ECDSA from '../../primitives/ECDSA'
+import BigNumber from '../../primitives/BigNumber'
+import Curve from '../../primitives/Curve'
+import Signature from '../../primitives/Signature'
+
+const msg = new BigNumber('deadbeef', 16)
+const key = new BigNumber(
+  '1e5edd45de6d22deebef4596b80444ffcc29143839c1dce18db470e25b4be7b5',
+  16
+)
+const curve = new Curve()
+const pub = curve.g.mul(key)
+const wrongPub = curve.g.mul(new BigNumber(33))
+
+describe('ECDSA', () => {
+  it('should sign and verify', () => {
+    const signature = ECDSA.sign(msg, key)
+    expect(ECDSA.verify(msg, signature, pub)).toBeTruthy()
+  })
+
+  it('should encode and decode with DER', () => {
+    const signature = ECDSA.sign(msg, key)
+    const encoded = signature.toDER()
+    expect(encoded.length).toBe(71)
+    const decoded = Signature.fromDER(encoded)
+    expect(decoded.r.toString(16)).toEqual(signature.r.toString(16))
+    expect(decoded.s.toString(16)).toEqual(signature.s.toString(16))
+  })
+
+  it('should encode and decode with hex DER', () => {
+    const signature = ECDSA.sign(msg, key)
+    const encoded = signature.toDER('hex')
+    expect(encoded.length).toBe(142)
+    const decoded = Signature.fromDER(encoded, 'hex')
+    expect(decoded.r.toString(16)).toEqual(signature.r.toString(16))
+    expect(decoded.s.toString(16)).toEqual(signature.s.toString(16))
+  })
+
+  it('should have `signature.s <= keys.ec.nh`', () => {
+    // key.sign(msg, options)
+    const sign = ECDSA.sign(msg, key, true)
+    expect(sign.s.cmp(curve.n.ushrn(1)) <= 0).toBeTruthy()
+  })
+
+  it('should support `options.k`', () => {
+    const sign = ECDSA.sign(msg, key, undefined, new BigNumber(1358))
+    expect(ECDSA.verify(msg, sign, pub)).toBeTruthy()
+  })
+
+  it('should not verify an incorrectly signed message', () => {
+    const wrongMessage = new BigNumber(
+      'BA5AABBE1AA9B6EC1E2ADB2DF99699344345678901234567890ABCDEFABCDEF02',
+      16
+    )
+    const signature = ECDSA.sign(msg, key)
+    const result = ECDSA.verify(wrongMessage, signature, pub)
+    expect(result).toBe(false)
+  })
+
+  it('should not verify signature with wrong public key', () => {
+    const signature = ECDSA.sign(msg, key)
+    expect(ECDSA.verify(msg, signature, wrongPub)).toBeFalsy()
+  })
+
+  it('should accept custom k = 1 and k = n-1', () => {
+    const n = curve.n
+    const one = new BigNumber(1)
+
+    // k = 1 → valid
+    const k1 = one
+    const sig1 = ECDSA.sign(msg, key, undefined, k1)
+    expect(ECDSA.verify(msg, sig1, pub)).toBeTruthy()
+
+    // k = n-1 → valid
+    const km1 = n.subn(1)
+    const sig2 = ECDSA.sign(msg, key, undefined, km1)
+    expect(ECDSA.verify(msg, sig2, pub)).toBeTruthy()
+  })
+
+  it('should reject custom k < 1 or k > n-1', () => {
+    const n = curve.n
+
+    // k = 0 → invalid
+    expect(() =>
+      ECDSA.sign(msg, key, undefined, new BigNumber(0))
+    ).toThrow()
+
+    // k = n → invalid
+    expect(() =>
+      ECDSA.sign(msg, key, undefined, n)
+    ).toThrow()
+  })
+})

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

@@ -0,0 +1,76 @@
+/* eslint-env jest */
+import { SHA256HMAC } from '../../primitives/Hash'
+
+describe('HMAC', function () {
+  describe('mixed test vector', function () {
+    test({
+      name: 'nist 1',
+      key:
+        '00010203 04050607 08090A0B 0C0D0E0F' +
+        '10111213 14151617 18191A1B 1C1D1E1F 20212223 24252627' +
+        '28292A2B 2C2D2E2F 30313233 34353637 38393A3B 3C3D3E3F',
+      msg: 'Sample message for keylen=blocklen',
+      res: '8bb9a1db9806f20df7f77b82138c7914d174d59e13dc4d0169c9057b133e1d62'
+    })
+    test({
+      name: 'nist 2',
+      key:
+        '00010203 04050607' +
+        '08090A0B 0C0D0E0F 10111213 14151617 18191A1B 1C1D1E1F',
+      msg: 'Sample message for keylen<blocklen',
+      res: 'a28cf43130ee696a98f14a37678b56bcfcbdd9e5cf69717fecf5480f0ebdf790'
+    })
+    test({
+      name: 'nist 3',
+      key:
+        '00010203' +
+        '04050607 08090A0B 0C0D0E0F 10111213 14151617 18191A1B' +
+        '1C1D1E1F 20212223 24252627 28292A2B 2C2D2E2F 30313233' +
+        '34353637 38393A3B 3C3D3E3F 40414243 44454647 48494A4B' +
+        '4C4D4E4F 50515253 54555657 58595A5B 5C5D5E5F 60616263',
+      msg: 'Sample message for keylen=blocklen',
+      res: 'bdccb6c72ddeadb500ae768386cb38cc41c63dbb0878ddb9c7a38a431b78378d'
+    })
+    test({
+      name: 'nist 4',
+      key:
+        '00' +
+        '01020304 05060708 090A0B0C 0D0E0F10 11121314 15161718' +
+        '191A1B1C 1D1E1F20 21222324 25262728 292A2B2C 2D2E2F30',
+      msg: 'Sample message for keylen<blocklen, with truncated tag',
+      res: '27a8b157839efeac98df070b331d593618ddb985d403c0c786d23b5d132e57c7'
+    })
+    test({
+      name: 'regression 1',
+      key: '48f38d0c6a344959cc94502b7b5e8dffb6a5f41795d9066fc9a649557167ee2f',
+      msg: '1d495eef7761b65dccd0a983d2d7204fea28b5c81f1758046e062eb043755ea1',
+      msgEnc: 'hex',
+      res: 'cf5ad5984f9e43917aa9087380dac46e410ddc8a7731859c84e9d0f31bd43655'
+    })
+
+    function normalizeKey (key: string | number[]): string | number[] {
+      if (typeof key === 'string') {
+        // test-only helper: remove whitespace between hex groups
+        return key.replace(/\s+/g, '')
+      }
+      return key
+    }
+
+    function test (opt): void {
+      it(`should not fail at ${opt.name as string}`, function (): void {
+        const key = normalizeKey(opt.key)
+
+        let h = new SHA256HMAC(key as any)
+        expect(h.update(opt.msg, opt.msgEnc).digestHex()).toEqual(opt.res)
+
+        h = new SHA256HMAC(key as any)
+        expect(
+          h
+            .update(opt.msg.slice(0, 10), opt.msgEnc)
+            .update(opt.msg.slice(10), opt.msgEnc)
+            .digestHex()
+        ).toEqual(opt.res)
+      })
+    }
+  })
+})

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

@@ -0,0 +1,256 @@
+/* eslint-env jest */
+import * as hash from '../../primitives/Hash'
+import * as crypto from 'crypto'
+import PBKDF2Vectors from './PBKDF2.vectors'
+import { toArray, toHex } from '../../primitives/utils'
+import { SHA1 } from '../..//primitives/Hash'
+
+describe('Hash', function () {
+  function test (Hash, cases): void {
+    for (let i = 0; i < cases.length; i++) {
+      const msg = cases[i][0]
+      const res = cases[i][1]
+      const enc = cases[i][2]
+
+      let dgst = new Hash().update(msg, enc).digestHex()
+      expect(dgst).toEqual(res)
+
+      // Split message
+      dgst = new Hash()
+        .update(msg.slice(0, 2), enc)
+        .update(msg.slice(2), enc)
+        .digestHex()
+      expect(dgst).toEqual(res)
+    }
+  }
+
+  it('should support sha256', function () {
+    test(hash.SHA256, [
+      [
+        'abc',
+        'ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad'
+      ],
+      [
+        'abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq',
+        '248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1'
+      ],
+      [
+        'deadbeef',
+        '5f78c33274e43fa9de5659265c1d917e25c03722dcb0b8d27db8d5feaa813953',
+        'hex'
+      ]
+    ])
+  })
+
+  it('should support ripemd160', function () {
+    test(hash.RIPEMD160, [
+      ['', '9c1185a5c5e9fc54612808977ee8f548b2258d31'],
+      ['abc', '8eb208f7e05d987a9b044a8e98c6b087f15a0bfc'],
+      ['message digest', '5d0689ef49d2fae572b881b123a85ffa21595f36'],
+      [
+        'abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq',
+        '12a053384a9c0c88e405a06c27dcf49ada62eb2b'
+      ],
+      [
+        'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789',
+        'b0e20b6e3116640286ed3a87a5713079b21f5189'
+      ]
+    ])
+  })
+
+  it('should support sha1', function () {
+    test(hash.SHA1, [
+      ['', 'da39a3ee5e6b4b0d3255bfef95601890afd80709'],
+      ['abc', 'a9993e364706816aba3e25717850c26c9cd0d89d'],
+      [
+        'abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq',
+        '84983e441c3bd26ebaae4aa1f95129e5e54670f1'
+      ],
+      ['deadbeef', 'd78f8bb992a56a597f6c7a1fb918bb78271367eb', 'hex']
+    ])
+  })
+
+  it('should support sha512', function () {
+    test(hash.SHA512, [
+      [
+        'abc',
+        'ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a' +
+          '2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f'
+      ],
+      [
+        'abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmn' +
+          'hijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu',
+        '8e959b75dae313da8cf4f72814fc143f8f7779c6eb9f7fa17299aeadb6889018' +
+          '501d289e4900f7e4331b99dec4b5433ac7d329eeb6dd26545e96e55b874be909'
+      ]
+    ])
+  })
+
+  it('handles utf8 in strings just like crypto', function () {
+    test(
+      hash.SHA256,
+      [
+        'hello', // one byte per character
+        'привет', // two bytes per character
+        '您好', // three bytes per character
+        '👋', // four bytes per character
+        'hello привет 您好 👋!!!' // mixed character lengths
+      ].map((str) => [
+        str,
+        crypto.createHash('sha256').update(str).digest('hex')
+      ])
+    )
+  })
+
+  describe('BaseHash padding and endianness', () => {
+    it('encodes length in big-endian for SHA1', () => {
+      const sha1 = new (hash as any).SHA1()
+      ;(sha1).pendingTotal = 12345
+      const pad = (sha1)._pad() as number[]
+      const padLength = (sha1).padLength as number
+      const lengthBytes = pad.slice(-padLength)
+
+      const totalBits = BigInt(12345) * 8n
+      const expected = new Array<number>(padLength)
+      let tmp = totalBits
+      for (let i = padLength - 1; i >= 0; i--) {
+        expected[i] = Number(tmp & 0xffn)
+        tmp >>= 8n
+      }
+
+      expect(lengthBytes).toEqual(expected)
+    })
+
+    it('encodes length in little-endian for RIPEMD160', () => {
+      const ripemd = new (hash as any).RIPEMD160()
+      ;(ripemd).pendingTotal = 12345
+      const pad = (ripemd)._pad() as number[]
+      const padLength = (ripemd).padLength as number
+      const lengthBytes = pad.slice(-padLength)
+
+      const totalBits = BigInt(12345) * 8n
+      const expected = new Array<number>(padLength)
+      let tmp = totalBits
+      for (let i = 0; i < padLength; i++) {
+        expected[i] = Number(tmp & 0xffn)
+        tmp >>= 8n
+      }
+
+      expect(lengthBytes).toEqual(expected)
+    })
+
+    it('throws when message length exceeds maximum encodable bits', () => {
+      const sha1 = new (hash as any).SHA1()
+      ;(sha1).padLength = 1
+      ;(sha1).pendingTotal = 40
+
+      expect(() => {
+        ;(sha1)._pad()
+      }).toThrow(new Error('Message too long for this hash function'))
+    })
+  })
+
+  describe('PBKDF2 vectors', () => {
+    for (let i = 0; i < PBKDF2Vectors.length; i++) {
+      const v = PBKDF2Vectors[i]
+      let key, salt
+      if (v.keyUint8Array != null) {
+        key = v.keyUint8Array
+      }
+      if (v.key != null && v.key !== '') {
+        key = toArray(v.key, 'utf8')
+      }
+      if (v.keyHex != null && v.keyHex !== '') {
+        key = toArray(v.keyHex, 'hex')
+      }
+      if (v.saltUint8Array != null) {
+        salt = v.saltUint8Array
+      }
+      if (v.salt != null && v.salt !== '') {
+        salt = toArray(v.salt, 'utf8')
+      }
+      if (v.saltHex != null && v.saltHex !== '') {
+        salt = toArray(v.saltHex, 'hex')
+      }
+      it(`Passes PBKDF2 vector ${i}`, () => {
+        const output = hash.pbkdf2(key, salt, v.iterations, v.dkLen)
+        expect(toHex(output)).toEqual(v.results.sha512)
+      })
+    }
+  })
+
+  describe('Hash strict length validation (TOB-21)', () => {
+    it('throws when pendingTotal is not a safe integer', () => {
+      const h = new SHA1()
+
+      h.pendingTotal = Number.MAX_SAFE_INTEGER + 10
+
+      expect(() => {
+        h.digest()
+      }).toThrow('Message too long for this hash function')
+    })
+
+    it('throws when pendingTotal is negative', () => {
+      const h = new SHA1()
+
+      h.pendingTotal = -5
+
+      expect(() => {
+        h.digest()
+      }).toThrow('Message too long for this hash function')
+    })
+  })
+
+  describe('TOB-20 byte-order helper functions', () => {
+    const { htonl, swapBytes32, realHtonl } = hash
+
+    it('swapBytes32 performs a strict 32-bit byte swap', () => {
+      expect(swapBytes32(0x11223344)).toBe(0x44332211)
+      expect(swapBytes32(0xaabbccdd)).toBe(0xddccbbaa)
+      expect(swapBytes32(0x00000000)).toBe(0x00000000)
+      expect(swapBytes32(0xffffffff)).toBe(0xffffffff)
+    })
+
+    it('swapBytes32 always returns an unsigned 32-bit integer', () => {
+      expect(swapBytes32(-1)).toBe(0xffffffff) // wraps to unsigned
+      expect(swapBytes32(0x80000000)).toBe(0x00000080) // MSB becomes LSB
+    })
+
+    it('htonl is now an alias for swapBytes32 (deprecated)', () => {
+      expect(htonl(0x11223344)).toBe(swapBytes32(0x11223344))
+      expect(htonl(0xaabbccdd)).toBe(swapBytes32(0xaabbccdd))
+    })
+
+    it('realHtonl matches swapBytes32 on little-endian systems', () => {
+      // All JS engines used for Node/Jest are little-endian
+      expect(realHtonl(0x11223344)).toBe(0x44332211)
+      expect(realHtonl(0xaabbccdd)).toBe(0xddccbbaa)
+    })
+
+    it('realHtonl preserves value when system is big-endian (forced simulation)', () => {
+      // We simulate the big-endian branch of realHtonl by calling
+      // the fallback path directly.
+      const forceBigEndianRealHtonl = (w: number) => (w >>> 0)
+
+      expect(forceBigEndianRealHtonl(0x11223344)).toBe(0x11223344)
+      expect(forceBigEndianRealHtonl(0xaabbccdd)).toBe(0xaabbccdd)
+      expect(forceBigEndianRealHtonl(0xffffffff)).toBe(0xffffffff >>> 0)
+    })
+
+    it('htonl, swapBytes32, realHtonl never throw for any 32-bit input', () => {
+      const inputs = [
+        0, 1, -1,
+        0x7fffffff,
+        0x80000000,
+        0xffffffff,
+        0x12345678
+      ]
+
+      for (const n of inputs) {
+        expect(() => htonl(n)).not.toThrow()
+        expect(() => swapBytes32(n)).not.toThrow()
+        expect(() => realHtonl(n)).not.toThrow()
+      }
+    })
+  })
+})

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

@@ -0,0 +1,132 @@
+export default [
+  {
+    key: 'password',
+    salt: 'salt',
+    iterations: 1,
+    dkLen: 32,
+    results: {
+      sha512:
+        '867f70cf1ade02cff3752599a3a53dc4af34c7a669815ae5d513554e1c8cf252'
+    }
+  },
+  {
+    key: 'password',
+    salt: 'salt',
+    iterations: 2,
+    dkLen: 32,
+    results: {
+      sha512:
+        'e1d9c16aa681708a45f5c7c4e215ceb66e011a2e9f0040713f18aefdb866d53c'
+    }
+  },
+  {
+    key: 'password',
+    salt: 'salt',
+    iterations: 1,
+    dkLen: 64,
+    results: {
+      sha512:
+        '867f70cf1ade02cff3752599a3a53dc4af34c7a669815ae5d513554e1c8cf252c02d470a285a0501bad999bfe943c08f050235d7d68b1da55e63f73b60a57fce'
+    }
+  },
+  {
+    key: 'password',
+    salt: 'salt',
+    iterations: 2,
+    dkLen: 64,
+    results: {
+      sha512:
+        'e1d9c16aa681708a45f5c7c4e215ceb66e011a2e9f0040713f18aefdb866d53cf76cab2868a39b9f7840edce4fef5a82be67335c77a6068e04112754f27ccf4e'
+    }
+  },
+  {
+    key: 'password',
+    salt: 'salt',
+    iterations: 4096,
+    dkLen: 32,
+    results: {
+      sha512:
+        'd197b1b33db0143e018b12f3d1d1479e6cdebdcc97c5c0f87f6902e072f457b5'
+    }
+  },
+  {
+    key: 'passwordPASSWORDpassword',
+    salt: 'saltSALTsaltSALTsaltSALTsaltSALTsalt',
+    iterations: 4096,
+    dkLen: 40,
+    results: {
+      sha512:
+        '8c0511f4c6e597c6ac6315d8f0362e225f3c501495ba23b868c005174dc4ee71115b59f9e60cd953'
+    }
+  },
+  {
+    key: 'pass\u00000word',
+    salt: 'sa\u00000lt',
+    iterations: 4096,
+    dkLen: 16,
+    results: {
+      sha512: '336d14366099e8aac2c46c94a8f178d2'
+    }
+  },
+  {
+    keyHex: '63ffeeddccbbaa',
+    salt: 'salt',
+    iterations: 1,
+    dkLen: 32,
+    results: {
+      sha512:
+        'f69de451247225a7b30cc47632899572bb980f500d7c606ac9b1c04f928a3488'
+    }
+  },
+  {
+    description: 'Unicode salt, no truncation due to hex',
+    key: 'abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about',
+    saltHex:
+      '6d6e656d6f6e6963e383a1e383bce38388e383abe382abe38299e3838fe38299e382a6e38299e382a1e381afe3829ae381afe38299e3818fe38299e3829de38299e381a1e381a1e38299e58d81e4babae58d81e889b2',
+    iterations: 2048,
+    dkLen: 64,
+    results: {
+      sha512:
+        'ba553eedefe76e67e2602dc20184c564010859faada929a090dd2c57aacb204ceefd15404ab50ef3e8dbeae5195aeae64b0def4d2eead1cdc728a33ced520ffd'
+    }
+  },
+  {
+    key: 'password',
+    salt: 'salt',
+    iterations: 1,
+    dkLen: 10,
+    results: {
+      sha512: '867f70cf1ade02cff375'
+    }
+  },
+  {
+    key: 'password',
+    salt: 'salt',
+    iterations: 1,
+    dkLen: 100,
+    results: {
+      sha512:
+        '867f70cf1ade02cff3752599a3a53dc4af34c7a669815ae5d513554e1c8cf252c02d470a285a0501bad999bfe943c08f050235d7d68b1da55e63f73b60a57fce7b532e206c2967d4c7d2ffa460539fc4d4e5eec70125d74c6c7cf86d25284f297907fcea'
+    }
+  },
+  {
+    keyUint8Array: [112, 97, 115, 115, 119, 111, 114, 100],
+    salt: 'salt',
+    iterations: 1,
+    dkLen: 32,
+    results: {
+      sha512:
+        '867f70cf1ade02cff3752599a3a53dc4af34c7a669815ae5d513554e1c8cf252'
+    }
+  },
+  {
+    key: 'password',
+    saltUint8Array: [115, 97, 108, 116],
+    iterations: 1,
+    dkLen: 32,
+    results: {
+      sha512:
+        '867f70cf1ade02cff3752599a3a53dc4af34c7a669815ae5d513554e1c8cf252'
+    }
+  }
+]

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

@@ -0,0 +1,92 @@
+import PrivateKey, { KeyShares } from '../../primitives/PrivateKey'
+import { PointInFiniteField } from '../../primitives/Polynomial'
+
+describe('PrivateKey', () => {
+  it('should split the private key into shares correctly', () => {
+    const privateKey = PrivateKey.fromRandom()
+    const threshold = 2
+    const totalShares = 5
+
+    // Split the private key
+    const shares = privateKey.toKeyShares(threshold, totalShares)
+    const backup = shares.toBackupFormat()
+
+    // Check the number of shares
+    expect(backup.length).toBe(totalShares)
+
+    // Check that each share is a BigNumber
+    shares.points.forEach((share) => {
+      expect(share).toBeInstanceOf(PointInFiniteField)
+    })
+    expect(shares.threshold).toBe(threshold)
+  })
+
+  it('should recombine the shares into a private key correctly', () => {
+    let x = 0
+    while (x < 3) {
+      const key = PrivateKey.fromRandom()
+      const allShares = key.toKeyShares(3, 5)
+      const backup = allShares.toBackupFormat()
+      const someShares = KeyShares.fromBackupFormat(backup.slice(0, 3))
+      const rebuiltKey = PrivateKey.fromKeyShares(someShares)
+      expect(rebuiltKey.toWif()).toBe(key.toWif())
+      x++
+    }
+  })
+
+  it('should throw an error for invalid threshold or totalShares', () => {
+    const k = PrivateKey.fromRandom()
+
+    expect(() => k.toKeyShares('invalid' as unknown as number, 14)).toThrow(
+      'threshold and totalShares must be numbers'
+    )
+
+    expect(() => k.toKeyShares(4, undefined as unknown as number)).toThrow(
+      'threshold and totalShares must be numbers'
+    )
+  })
+
+  it('should throw an error for invalid threshold', () => {
+    const k = PrivateKey.fromRandom()
+    expect(() => k.toKeyShares(1, 2)).toThrow('threshold must be at least 2')
+  })
+
+  it('should throw an error for invalid totalShares', () => {
+    const k = PrivateKey.fromRandom()
+    expect(() => k.toKeyShares(2, -4)).toThrow(
+      'totalShares must be at least 2'
+    )
+  })
+
+  it('should throw an error for totalShares being less than threshold', () => {
+    const k = PrivateKey.fromRandom()
+    expect(() => k.toKeyShares(3, 2)).toThrow(
+      'threshold should be less than or equal to totalShares'
+    )
+  })
+
+  it('should throw an error if the same share is included twice during recovery', () => {
+    const backup = [
+      '45s4vLL2hFvqmxrarvbRT2vZoQYGZGocsmaEksZ64o5M.A7nZrGux15nEsQGNZ1mbfnMKugNnS6SYYEQwfhfbDZG8.3.2f804d43',
+      '7aPzkiGZgvU4Jira5PN9Qf9o7FEg6uwy1zcxd17NBhh3.CCt7NH1sPFgceb6phTRkfviim2WvmUycJCQd2BxauxP9.3.2f804d43',
+      '9GaS2Tw5sXqqbuigdjwGPwPsQuEFqzqUXo5MAQhdK3es.8MLh2wyE3huyq6hiBXjSkJRucgyKh4jVY6ESq5jNtXRE.3.2f804d43',
+      'GBmoNRbsMVsLmEK5A6G28fktUNonZkn9mDrJJ58FXgsf.HDBRkzVUCtZ38ApEu36fvZtDoDSQTv3TWmbnxwwR7kto.3.2f804d43',
+      '2gHebXBgPd7daZbsj6w9TPDta3vQzqvbkLtJG596rdN1.E7ZaHyyHNDCwR6qxZvKkPPWWXzFCiKQFentJtvSSH5Bi.3.2f804d43'
+    ]
+    const recovery = KeyShares.fromBackupFormat([
+      backup[0],
+      backup[1],
+      backup[1]
+    ])
+    expect(() => PrivateKey.fromKeyShares(recovery)).toThrow(
+      'Duplicate share detected, each must be unique.'
+    )
+  })
+
+  it('should be able to create a backup array from a private key, and recover the same key back from the backup', () => {
+    const key = PrivateKey.fromRandom()
+    const backup = key.toBackupShares(3, 5)
+    const recoveredKey = PrivateKey.fromBackupShares(backup.slice(0, 3))
+    expect(recoveredKey.toWif()).toBe(key.toWif())
+  })
+})