@bsv/wallet-toolbox 1.7.16 → 1.7.17

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

@@ -1,38 +0,0 @@
-/* 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

@@ -1,93 +0,0 @@
-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

@@ -1,76 +0,0 @@
-/* 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

@@ -1,256 +0,0 @@
-/* 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

@@ -1,132 +0,0 @@
-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

@@ -1,92 +0,0 @@
-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())
-  })
-})