@bsv/wallet-toolbox 1.7.14 → 1.7.16

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

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

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

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

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

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

@@ -0,0 +1,57 @@
+/* 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')
+    })
+  })
+})