@bsv/wallet-toolbox 1.7.16 → 1.7.17

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

@@ -1,128 +0,0 @@
-import SymmetricKey from '../../primitives/SymmetricKey'
-import PrivateKey from '../../primitives/PrivateKey'
-import vectors from './SymmetricKey.vectors'
-
-const KEYS: SymmetricKey[] = [
-  new SymmetricKey(
-    '5a90d59d829197983a54d887fdea2dc4c38098f00ba3110f2645633b6ea11458',
-    16
-  ),
-  new SymmetricKey(
-    'bac6ac492f54d7c997fadc1be593a4ace26ecdf37d30b3ad12f34077fb2629e4',
-    16
-  ),
-  new SymmetricKey(
-    '53dcdc6ea6a6910af35a48708f49228e0e6661ea885435080cbabc58e6a14f10',
-    16
-  )
-]
-
-const PLAINTEXT_1 = 'hello there'
-const CIPHERTEXT_1 =
-  '8c8d25348dfd5240be833215a123173c64919779ab8845a700a4520311504c168ade2d4b728cc53a254f0aba857caaf6af97453ac2ff61487d0d52'
-
-describe('SymmetricKey', () => {
-  it('Produces output that can be decrypted', () => {
-    const originalValue = 'a thing to encrypt'
-    const encryptedValue = KEYS[2].encrypt(originalValue)
-    const decryptedValue = KEYS[2].decrypt(encryptedValue, 'utf8')
-    expect(originalValue).toEqual(decryptedValue)
-  })
-  it('Encrypts values as an array', () => {
-    const originalValue = [42, 99, 33, 0, 1]
-    const encryptedValue = KEYS[2].encrypt(originalValue)
-    const decryptedValue = KEYS[2].decrypt(encryptedValue)
-    expect(originalValue).toEqual(decryptedValue)
-  })
-  it('Decrypts a correctly-encrypted value', () => {
-    const result = KEYS[0].decrypt(CIPHERTEXT_1, 'hex') as string
-    expect(Buffer.from(result, 'hex').toString('utf8')).toEqual(PLAINTEXT_1)
-  })
-  it('Throws a useful error when decryption fails', () => {
-    expect(() => {
-      KEYS[2].decrypt(CIPHERTEXT_1, 'hex')
-    }).toThrow(new Error('Decryption failed!'))
-  })
-  it('decrypts values encrypted with the encrypt function', () => {
-    const originalValue = 'secret value'
-    const encryptedValue = KEYS[1].encrypt(originalValue)
-    const decryptedValue = KEYS[1].decrypt(encryptedValue, 'utf8')
-    expect(originalValue).toEqual(decryptedValue)
-  })
-  vectors.forEach((vector, index) => {
-    it(`Should pass test vector #${index + 1}`, () => {
-      const key = new SymmetricKey([...Buffer.from(vector.key, 'base64')])
-      const result = key.decrypt(
-        [...Buffer.from(vector.ciphertext, 'base64')],
-        'hex'
-      )
-      expect(result).toEqual(Buffer.from(vector.plaintext).toString('hex'))
-    })
-  })
-
-  describe('31-byte and 32-byte key encryption', () => {
-    it('encrypts and decrypts with 31-byte key', () => {
-      // Use a private key that generates a 31-byte X coordinate
-      const privKey = PrivateKey.fromWif('L4B2postXdaP7TiUrUBYs53Fqzheu7WhSoQVPuY8qBdoBeEwbmZx')
-      const pubKey = privKey.toPublicKey()
-
-      expect(pubKey.x).toBeTruthy()
-      const keyArray = pubKey.x!.toArray()
-
-      // Verify this is indeed a 31-byte key
-      expect(keyArray.length).toBe(31)
-
-      const symKey = new SymmetricKey(keyArray)
-      const plaintext = 'test message'
-
-      // Test encryption and decryption
-      const ciphertext = symKey.encrypt(plaintext)
-      const decrypted = symKey.decrypt(ciphertext, 'utf8')
-
-      expect(decrypted).toBe(plaintext)
-    })
-
-    it('encrypts and decrypts with 32-byte key', () => {
-      // Use a private key that generates a 32-byte X coordinate
-      const privKey = PrivateKey.fromWif('KyLGEhYicSoGchHKmVC2fUx2MRrHzWqvwBFLLT4DZB93Nv5DxVR9')
-      const pubKey = privKey.toPublicKey()
-
-      expect(pubKey.x).toBeTruthy()
-      const keyArray = pubKey.x!.toArray()
-
-      // Verify this is indeed a 32-byte key
-      expect(keyArray.length).toBe(32)
-
-      const symKey = new SymmetricKey(keyArray)
-      const plaintext = 'test message'
-
-      // Test encryption and decryption
-      const ciphertext = symKey.encrypt(plaintext)
-      const decrypted = symKey.decrypt(ciphertext, 'utf8')
-
-      expect(decrypted).toBe(plaintext)
-    })
-    
-    it('throws "Ciphertext too short" for inputs shorter than IV + tag', () => {
-      const shortCipherArray = new Array(47).fill(0)
-      expect(() => {
-        KEYS[0].decrypt(shortCipherArray)
-      }).toThrow(new Error('Ciphertext too short'))
-    })
-
-    it('throws "Ciphertext too short" for hex-encoded inputs shorter than IV + tag', () => {
-      const shortBuffer = Buffer.alloc(47, 0)
-      const shortHex = shortBuffer.toString('hex')
-
-      expect(() => {
-        KEYS[0].decrypt(shortHex, 'hex')
-      }).toThrow(new Error('Ciphertext too short'))
-    })
-
-    it('still throws "Decryption failed!" for structurally valid but wrong ciphertext', () => {
-      expect(() => {
-        KEYS[2].decrypt(CIPHERTEXT_1, 'hex')
-      }).toThrow(new Error('Decryption failed!'))
-    })
-  })
-})

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

@@ -1,48 +0,0 @@
-/**
- * These vectors check our implementation of AES-GCM encryption.
- *
- * The first 32 bytes of the ciphertext contain the initialization vector and
- * the rest is the AES-GCM ciphertext.
- *
- * The plaintext is whatever we want to encrypt represented as a string.
- *
- * Because the initialization vector is generated randomly during the
- * encryption process, we cannot use determanistic test vectors to test the
- * encrypt functionality. Therefore, only the test runner for the decrypt
- * function will execute and validate against the vectors.
- */
-export default [
-  {
-    ciphertext:
-      '1cf74FpvW0koFZk5e1VQcCtF7UdLj9mtN/L9loFlXwhf6w/06THwVirsvDShuT/KlOjO/HFALj8AcGLU1KRs4zNJDaX2wNebuPkH+qp5N/0cp3fZxgFzHJB3jBPDcdFi8O9WXIBLx9jUQ5KFQk0mZCB2k90VniInWuzqqOQAQQlBy2rgBWp4xg==',
-    key: 'LIe9CoVXxDDDKt9F4j2lE+GP4oPcMElwyX+LVsuRLqw=',
-    plaintext:
-      '5+w9tts+i14GDfPSEJwcaAfce7zVLC7wsRAMnCBqIczkqL08I05FZTl7n14H9hnPkS7HBm3EGWNDKCZ64ckCGg=='
-  },
-  {
-    ciphertext:
-      'IFh45HxwvK7wgIZr5UDxvUiEkvjsXVV6VIksaEQoTNCPleaRxE1CE1eZj5ZSPa/Mo2HXa2kvEmVAMslY12gMb7qHAHT2fSORB8TJKubKcjwGUrRxqOWvk24lv7QKhq3uhKkJxZSkPBZS6UM+xX+x7Mb53CoC8Z+7Ork50wGRAA415C+T8FIluA==',
-    key: 'Di30+CTH8yKVJfXmbkRU6DOesD042IkjZCbFL1lnNqY=',
-    plaintext:
-      '6pHqDrkIuGmWIpB1spu30PP848D04WlERSjrEZ/JD0jfdS814cOjs4MFkePT1IHeM4+qGFwAMk7HKgWShOKFDQ=='
-  },
-  {
-    ciphertext:
-      'JeUMCTX3hW7uH7Njfqjtjxd/8jB0Uj4eLLbLNBSMqF3XJmtq2oyX/WWS1po8cwn7jrcK0k8mVxHax/DctH6CIDMc0udBxWYLDyftvIYr448otWmn2IKQN4d3Bh2PKdiIQOo36DO2wOy+T2OJSmJ2XvAkenSZIckCdPIQVpeIi7Bt2ZpHmkObkg==',
-    key: 'v7kFn4JdB3OVVjy8lk7UTvWe0vY5Qyzn64Q0EVoezlU=',
-    plaintext:
-      'bSYHdJn15pcsaI8CNmfjKQ3ZvMg7zBaxuxBqyWBmCLdqj29bK54C26G1mx5e605hDrFpuJoNSDTECrk67ebffA=='
-  },
-  {
-    ciphertext:
-      'ktpzKolKsvtWrvLl0yMdGvh5ngd1hiaNcC1b5yuzo2DEKO/4S7gePO/CWOmW/dloHhzfbBQH9rKDFKK7xHHgqYRc',
-    key: 'qIgnjD0FfGVMiWo107bP0oHsLA402lhC7AYUFIKY1KQ=',
-    plaintext: 'A cat and a mouse.'
-  },
-  {
-    ciphertext:
-      'vremTalPp+NxN/loEtLMB94tEymdFk2TfBoTWNYcf4sQqYSNkx2WPdJ4LxrIsGuIg9KMOt7FOcIpDb6rRVpP',
-    key: 'K7E/bf3wp6hrVeW0V1KvFJS5JZMhyxwPHCIW6wKBTb0=',
-    plaintext: 'üñîçø∂é'
-  }
-]

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

@@ -1,150 +0,0 @@
-import SymmetricKey from '../SymmetricKey'
-import PrivateKey from '../PrivateKey'
-
-describe('Cross-SDK Compatibility Tests', () => {
-  describe('31-byte key cross-decryption', () => {
-    it('can decrypt Go SDK ciphertext with TypeScript SDK', () => {
-      // Use the same 31-byte key as Go SDK
-      const privKey = PrivateKey.fromWif('L4B2postXdaP7TiUrUBYs53Fqzheu7WhSoQVPuY8qBdoBeEwbmZx')
-      const pubKey = privKey.toPublicKey()
-
-      expect(pubKey.x).toBeTruthy()
-      const keyBytes = pubKey.x!.toArray()
-
-      // Verify this is a 31-byte key
-      expect(keyBytes.length).toBe(31)
-
-      const symKey = new SymmetricKey(keyBytes)
-      const expectedPlaintext = 'cross-sdk test message'
-
-      // Test cases: Go-generated ciphertext that TypeScript should be able to decrypt
-      const testCases = [
-        {
-          name: 'Go 31-byte ciphertext 1',
-          ciphertextHex: '7604d5bdb0eb843051d21873c871c9b1507c3de7ba222e1b407c163c2c166277df95de73be9534a2caf9d4b72157f78e5e2e69d97bc25b18ff4cfbd61a1306c02c0b8b2d165e'
-        },
-        {
-          name: 'Go 31-byte ciphertext 2',
-          ciphertextHex: 'ab74fa03d7b2d308f007e21fbae056cfde6e3e5fbea7032880e0482b0b5fbe8583d5221b985a8cdfdff1f70c2bb28c9a3149a34dde3b56f54ecd4728d2dd70c1212642b18bc4'
-        },
-        {
-          name: 'Go 31-byte ciphertext 3',
-          ciphertextHex: '6c64ae72a1371084347983568d25515ca75599f747236be6971267fa4b48e518855ce4f8380cc479bb75835641f2173b7932b93be5cd40f54cd84aaff053dbc94c3748e427af'
-        }
-      ]
-
-      testCases.forEach(({name, ciphertextHex}) => {
-        // Convert hex to byte array
-        const ciphertext: number[] = []
-        for (let i = 0; i < ciphertextHex.length; i += 2) {
-          ciphertext.push(parseInt(ciphertextHex.slice(i, i + 2), 16))
-        }
-
-        // Decrypt using TypeScript SDK
-        const decrypted = symKey.decrypt(ciphertext, 'utf8')
-
-        expect(decrypted).toBe(expectedPlaintext)
-      })
-    })
-  })
-
-  describe('32-byte key cross-decryption', () => {
-    it('can decrypt Go SDK ciphertext with TypeScript SDK', () => {
-      // Use the same 32-byte key as Go SDK
-      const privKey = PrivateKey.fromWif('KyLGEhYicSoGchHKmVC2fUx2MRrHzWqvwBFLLT4DZB93Nv5DxVR9')
-      const pubKey = privKey.toPublicKey()
-
-      expect(pubKey.x).toBeTruthy()
-      const keyBytes = pubKey.x!.toArray()
-
-      // Verify this is a 32-byte key
-      expect(keyBytes.length).toBe(32)
-
-      const symKey = new SymmetricKey(keyBytes)
-      const expectedPlaintext = 'cross-sdk test message'
-
-      // Test cases: Go-generated ciphertext that TypeScript should be able to decrypt
-      const testCases = [
-        {
-          name: 'Go 32-byte ciphertext 1',
-          ciphertextHex: 'd7744c85ad3dafcb9fc5752ab0d04c40f87084e8a466f6b6013ebe0fc5170daab8184aaef66ab2c2733f01c0dc3de322ba3ddeea976499548bc6ec166581181f919c69aa2de5'
-        },
-        {
-          name: 'Go 32-byte ciphertext 2',
-          ciphertextHex: 'bed1fc660bb7219d05a0115bc3c8dfb063fceb07c6571e0a21af1a052988dfd8911f625ae747ae6dad4cadb872dbd1d1bdc4b78bf7817e90bc5df718d77b247805eb06773d13'
-        },
-        {
-          name: 'Go 32-byte ciphertext 3',
-          ciphertextHex: '7411f0e9ff2b6ebbb804614fcf11db548a92baeea9cd769e8ee11bd7853a2d055799df476655b7d30f11be17f9513a16b72b6c73f85edd4b6e7548fae68fb47252ff72ace4cf'
-        }
-      ]
-
-      testCases.forEach(({name, ciphertextHex}) => {
-        // Convert hex to byte array
-        const ciphertext: number[] = []
-        for (let i = 0; i < ciphertextHex.length; i += 2) {
-          ciphertext.push(parseInt(ciphertextHex.slice(i, i + 2), 16))
-        }
-
-        // Decrypt using TypeScript SDK
-        const decrypted = symKey.decrypt(ciphertext, 'utf8')
-        expect(decrypted).toBe(expectedPlaintext)
-      })
-    })
-  })
-
-  describe('Bidirectional cross-decryption', () => {
-    it('verifies both SDKs can decrypt each others ciphertext', () => {
-      const testCases = [
-        {
-          name: '31-byte key bidirectional',
-          wif: 'L4B2postXdaP7TiUrUBYs53Fqzheu7WhSoQVPuY8qBdoBeEwbmZx',
-          expectedKeyLength: 31,
-          goCiphertext: '7604d5bdb0eb843051d21873c871c9b1507c3de7ba222e1b407c163c2c166277df95de73be9534a2caf9d4b72157f78e5e2e69d97bc25b18ff4cfbd61a1306c02c0b8b2d165e',
-          tsCiphertext: 'c374d70a4623036f1dd7b971dbeeea375630dc1da40e7068f4c4aa03487d3b19de3afb26a29173deccfbb1ece4fee6c92406b25948e6fe9cb53383057cb826d0a20269e290bd'
-        },
-        {
-          name: '32-byte key bidirectional',
-          wif: 'KyLGEhYicSoGchHKmVC2fUx2MRrHzWqvwBFLLT4DZB93Nv5DxVR9',
-          expectedKeyLength: 32,
-          goCiphertext: 'd7744c85ad3dafcb9fc5752ab0d04c40f87084e8a466f6b6013ebe0fc5170daab8184aaef66ab2c2733f01c0dc3de322ba3ddeea976499548bc6ec166581181f919c69aa2de5',
-          tsCiphertext: '2059fc32910bef280d89c4c7edbbc587b31be22339e609fdcc23319bf458840a91ad1b2da87aea13a5dc5cb3469b41c52001070b8003863843978acbdf57755b24491581a059'
-        }
-      ]
-
-      testCases.forEach(({name, wif, expectedKeyLength, goCiphertext, tsCiphertext}) => {
-        // Create symmetric key
-        const privKey = PrivateKey.fromWif(wif)
-        const pubKey = privKey.toPublicKey()
-
-        expect(pubKey.x).toBeTruthy()
-        const keyBytes = pubKey.x!.toArray()
-        expect(keyBytes.length).toBe(expectedKeyLength)
-
-        const symKey = new SymmetricKey(keyBytes)
-        const expectedPlaintext = 'cross-sdk test message'
-
-        // Test TypeScript decrypting Go ciphertext
-        const goCiphertextBytes: number[] = []
-        for (let i = 0; i < goCiphertext.length; i += 2) {
-          goCiphertextBytes.push(parseInt(goCiphertext.substr(i, 2), 16))
-        }
-
-        const goDecrypted = symKey.decrypt(goCiphertextBytes, 'utf8')
-        expect(goDecrypted).toBe(expectedPlaintext)
-
-        // Test TypeScript decrypting TypeScript ciphertext (sanity check)
-        const tsCiphertextBytes: number[] = []
-        for (let i = 0; i < tsCiphertext.length; i += 2) {
-          tsCiphertextBytes.push(parseInt(tsCiphertext.substr(i, 2), 16))
-        }
-
-        const tsDecrypted = symKey.decrypt(tsCiphertextBytes, 'utf8')
-        expect(tsDecrypted).toBe(expectedPlaintext)
-
-        expect(goDecrypted).toBe(expectedPlaintext)
-        expect(tsDecrypted).toBe(expectedPlaintext)
-      })
-    })
-  })
-})

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

@@ -1,208 +0,0 @@
-import BigNumber from '../../primitives/BigNumber'
-import { Reader, Writer, encode } from '../../primitives/utils'
-
-describe('Writer', () => {
-  it('should create a new buffer writer', () => {
-    const bw = new Writer()
-    expect(bw).toBeDefined()
-  })
-
-  describe('#getLength', () => {
-    it('should compute length correctly of two 2-byte buffers', () => {
-      const buf1 = Buffer.from('0000', 'hex')
-      const buf2 = Buffer.from('0000', 'hex')
-      const bw = new Writer().write([...buf1]).write([...buf2])
-      expect(bw.getLength()).toEqual(4)
-    })
-  })
-
-  describe('#toArray', () => {
-    it('should concat these two bufs', () => {
-      const buf1 = [0]
-      const buf2 = [1]
-      const bw = new Writer([buf1, buf2])
-      expect(encode(bw.toArray(), 'hex')).toEqual('0001')
-    })
-  })
-
-  describe('#write', () => {
-    it('should write a buffer', () => {
-      const buf = [0]
-      const bw = new Writer()
-      bw.write(buf)
-      expect(encode(bw.toArray(), 'hex')).toEqual('00')
-    })
-  })
-
-  describe('#writeReverse', () => {
-    it('should write a buffer in reverse', () => {
-      const buf = [0, 1]
-      const bw = new Writer()
-      bw.writeReverse(buf)
-      expect(encode(bw.toArray(), 'hex')).toEqual('0100')
-    })
-  })
-
-  describe('#writeUInt8', () => {
-    it('should write 1', () => {
-      const bw = new Writer()
-      expect(encode(bw.writeUInt8(1).toArray(), 'hex')).toEqual('01')
-    })
-  })
-
-  describe('#writeInt8', () => {
-    it('should write 1', () => {
-      const bw = new Writer()
-      expect(encode(bw.writeInt8(1).toArray(), 'hex')).toEqual('01')
-      expect(encode(new Writer().writeInt8(-1).toArray(), 'hex')).toEqual('ff')
-    })
-  })
-
-  describe('#writeUInt16BE', () => {
-    it('should write 1', () => {
-      const bw = new Writer()
-      expect(encode(bw.writeUInt16BE(1).toArray(), 'hex')).toEqual('0001')
-    })
-  })
-
-  describe('#writeInt16BE', () => {
-    it('should write 1', () => {
-      const bw = new Writer()
-      expect(encode(bw.writeInt16BE(1).toArray(), 'hex')).toEqual('0001')
-      expect(encode(new Writer().writeInt16BE(-1).toArray(), 'hex')).toEqual(
-        'ffff'
-      )
-    })
-  })
-
-  describe('#writeUInt16LE', () => {
-    it('should write 1', () => {
-      const bw = new Writer()
-      expect(encode(bw.writeUInt16LE(1).toArray(), 'hex')).toEqual('0100')
-    })
-  })
-
-  describe('#writeInt16LE', () => {
-    it('should write 1', () => {
-      const bw = new Writer()
-      expect(encode(bw.writeInt16LE(1).toArray(), 'hex')).toEqual('0100')
-      expect(encode(new Writer().writeInt16LE(-1).toArray(), 'hex')).toEqual(
-        'ffff'
-      )
-    })
-  })
-
-  describe('#writeUInt32BE', () => {
-    it('should write 1', () => {
-      const bw = new Writer()
-      expect(encode(bw.writeUInt32BE(1).toArray(), 'hex')).toEqual('00000001')
-    })
-  })
-
-  describe('#writeInt32BE', () => {
-    it('should write 1', () => {
-      const bw = new Writer()
-      expect(encode(bw.writeInt32BE(1).toArray(), 'hex')).toEqual('00000001')
-      expect(encode(new Writer().writeInt32BE(-1).toArray(), 'hex')).toEqual(
-        'ffffffff'
-      )
-    })
-  })
-
-  describe('#writeUInt32LE', () => {
-    it('should write 1', () => {
-      const bw = new Writer()
-      expect(encode(bw.writeUInt32LE(1).toArray(), 'hex')).toEqual('01000000')
-    })
-  })
-
-  describe('#writeInt32LE', () => {
-    it('should write 1', () => {
-      const bw = new Writer()
-      expect(encode(bw.writeInt32LE(1).toArray(), 'hex')).toEqual('01000000')
-      expect(encode(new Writer().writeInt32LE(-1).toArray(), 'hex')).toEqual(
-        'ffffffff'
-      )
-    })
-  })
-
-  describe('#writeUInt64BEBn', () => {
-    it('should write 1', () => {
-      const bw = new Writer()
-      expect(
-        encode(bw.writeUInt64BEBn(new BigNumber(1)).toArray(), 'hex')
-      ).toEqual('0000000000000001')
-    })
-  })
-
-  describe('#writeUInt64LEBn', () => {
-    it('should write 1', () => {
-      const bw = new Writer()
-      expect(
-        encode(bw.writeUInt64LEBn(new BigNumber(1)).toArray(), 'hex')
-      ).toEqual('0100000000000000')
-    })
-  })
-
-  describe('#writeVarInt', () => {
-    it('should write a 1 byte varInt', () => {
-      const bw = new Writer()
-      bw.writeVarIntNum(1)
-      expect(bw.toArray().length).toEqual(1)
-    })
-
-    it('should write a 3 byte varInt', () => {
-      const bw = new Writer()
-      bw.writeVarIntNum(1000)
-      expect(bw.toArray().length).toEqual(3)
-    })
-
-    it('should write a 5 byte varInt', () => {
-      const bw = new Writer()
-      bw.writeVarIntNum(Math.pow(2, 16 + 1))
-      expect(bw.toArray().length).toEqual(5)
-    })
-
-    it('should write a 9 byte varInt', () => {
-      const bw = new Writer()
-      bw.writeVarIntNum(Math.pow(2, 32 + 1))
-      expect(bw.toArray().length).toEqual(9)
-    })
-
-    it('should read back the same value it wrote for a 9 byte varInt', () => {
-      const bw = new Writer()
-      const n = Math.pow(2, 53)
-      expect(n).toEqual(n + 1) // javascript number precision limit
-      bw.writeVarIntNum(n)
-      const br = new Reader(bw.toArray())
-      expect(br.readVarIntBn().toHex()).toEqual('20000000000000')
-    })
-  })
-
-  describe('#writeVarIntBn', () => {
-    it('should write a 1 byte varInt', () => {
-      const bw = new Writer()
-      bw.writeVarIntBn(new BigNumber(1))
-      expect(bw.toArray().length).toEqual(1)
-    })
-
-    it('should write a 3 byte varInt', () => {
-      const bw = new Writer()
-      bw.writeVarIntBn(new BigNumber(1000))
-      expect(bw.toArray().length).toEqual(3)
-    })
-
-    it('should write a 5 byte varInt', () => {
-      const bw = new Writer()
-      const bn = new BigNumber(Math.pow(2, 16 + 1))
-      bw.writeVarIntBn(bn)
-      expect(bw.toArray().length).toEqual(5)
-    })
-
-    it('should write a 9 byte varInt', () => {
-      const bw = new Writer()
-      bw.writeVarIntBn(new BigNumber(Math.pow(2, 32 + 1)))
-      expect(bw.toArray().length).toEqual(9)
-    })
-  })
-})

package/mobile/node_modules/@bsv/sdk/src/primitives/__tests/bug-31.test.ts

@@ -1,27 +0,0 @@
-import PrivateKey from '../../primitives/PrivateKey'
-import Curve from '../../primitives/Curve'
-import BigNumber from '../../primitives/BigNumber'
-
-describe('bug-31 tests', () => {
-  test('0', () => {
-    const c = new Curve()
-    // const bn = new BigNumber(c.n + 12)
-    const bn = c.n.addn(12)
-    const sn = new BigNumber(12)
-    expect(() => new PrivateKey(bn.toHex(), 'hex', 'be', 'error')).toThrow(
-      'Input is out of field'
-    )
-    const o = PrivateKey.fromString(bn.toHex(), 'hex')
-    const os = PrivateKey.fromString(sn.toHex(), 'hex')
-    expect(o.cmp(os)).toBe(0)
-    const os2 = new PrivateKey(bn.toHex(), 'hex', 'be', 'nocheck')
-    expect(o.cmp(os2)).not.toBe(0)
-
-    const oWif = o.toWif()
-    expect(oWif).toBe('KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYjgd9M7rFU79MFFcB1G')
-    const osWif = os.toWif()
-    expect(osWif).toBe('KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYjgd9M7rFU79MFFcB1G')
-
-    expect(() => os2.toWif()).toThrow('Value is out of field')
-  })
-})

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

@@ -1,57 +0,0 @@
-/* eslint-env jest */
-
-import { assertValidHex, normalizeHex } from '../../primitives/hex'
-
-describe('hex utils', () => {
-  describe('assertValidHex', () => {
-    it('should not throw on valid hex strings', () => {
-      expect(() => assertValidHex('')).not.toThrow()          // empty is allowed
-      expect(() => assertValidHex('00')).not.toThrow()
-      expect(() => assertValidHex('abcdef')).not.toThrow()
-      expect(() => assertValidHex('ABCDEF')).not.toThrow()
-      expect(() => assertValidHex('1234567890')).not.toThrow()
-    })
-
-    it('should throw on non-hex characters', () => {
-      expect(() => assertValidHex('zz')).toThrow('Invalid hex string')
-      expect(() => assertValidHex('0x1234')).toThrow('Invalid hex string')
-      expect(() => assertValidHex('12 34')).toThrow('Invalid hex string')
-      expect(() => assertValidHex('g1')).toThrow('Invalid hex string')
-    })
-
-    // ❌ old behavior: empty string was considered invalid
-    // it('should throw on empty string', () => {
-    //   expect(() => assertValidHex('')).toThrow('Invalid hex string')
-    // })
-
-    it('should throw on undefined or null', () => {
-      expect(() => assertValidHex(undefined as any)).toThrow('Invalid hex string')
-      expect(() => assertValidHex(null as any)).toThrow('Invalid hex string')
-    })
-  })
-
-  describe('normalizeHex', () => {
-    it('should return lowercase hex', () => {
-      expect(normalizeHex('ABCD')).toBe('abcd')
-    })
-
-    it('should prepend 0 to odd-length hex strings', () => {
-      expect(normalizeHex('abc')).toBe('0abc')
-      expect(normalizeHex('f')).toBe('0f')
-    })
-
-    it('should leave even-length hex strings untouched (except lowercase)', () => {
-      expect(normalizeHex('AABB')).toBe('aabb')
-      expect(normalizeHex('001122')).toBe('001122')
-    })
-
-    it('should return empty string unchanged', () => {
-      expect(normalizeHex('')).toBe('')
-    })
-
-    it('should throw on invalid hex', () => {
-      expect(() => normalizeHex('xyz')).toThrow('Invalid hex string')
-      expect(() => normalizeHex('12 34')).toThrow('Invalid hex string')
-    })
-  })
-})