@bsv/sdk 1.3.13 → 1.3.14

package/src/primitives/__tests/PBKDF2.vectors.ts

@@ -1,119 +1,132 @@
-export default [{
-  key: 'password',
-  salt: 'salt',
-  iterations: 1,
-  dkLen: 32,
-  results: {
-    sha512: '867f70cf1ade02cff3752599a3a53dc4af34c7a669815ae5d513554e1c8cf252'
+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'
+    }
   }
-},
-{
-  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/src/primitives/__tests/PrivateKey.split.test.ts

@@ -15,7 +15,7 @@ describe('PrivateKey', () => {
     expect(backup.length).toBe(totalShares)
 
     // Check that each share is a BigNumber
-    shares.points.forEach(share => {
+    shares.points.forEach((share) => {
       expect(share).toBeInstanceOf(PointInFiniteField)
     })
     expect(shares.threshold).toBe(threshold)
@@ -37,11 +37,11 @@ describe('PrivateKey', () => {
   it('should throw an error for invalid threshold or totalShares', () => {
     const k = PrivateKey.fromRandom()
 
-    expect(() => k.toKeyShares('invalid' as any, 14)).toThrow(
+    expect(() => k.toKeyShares('invalid' as unknown as number, 14)).toThrow(
       'threshold and totalShares must be numbers'
     )
 
-    expect(() => k.toKeyShares(4, undefined as any)).toThrow(
+    expect(() => k.toKeyShares(4, undefined as unknown as number)).toThrow(
       'threshold and totalShares must be numbers'
     )
   })
@@ -53,7 +53,9 @@ describe('PrivateKey', () => {
 
   it('should throw an error for invalid totalShares', () => {
     const k = PrivateKey.fromRandom()
-    expect(() => k.toKeyShares(2, -4)).toThrow('totalShares must be at least 2')
+    expect(() => k.toKeyShares(2, -4)).toThrow(
+      'totalShares must be at least 2'
+    )
   })
 
   it('should throw an error for totalShares being less than threshold', () => {

package/src/primitives/__tests/PrivateKey.test.ts

@@ -1,60 +1,58 @@
-import PublicKey from "../../primitives/PublicKey";
-import PrivateKey from "../../primitives/PrivateKey";
-import BRC42Private from "./BRC42.private.vectors";
-import Curve from "../../primitives/Curve";
-import BigNumber from "../../primitives/BigNumber";
-
-describe("PrivateKey", () => {
-  describe("BRC42 vectors", () => {
-    const curve = new Curve();
+import PublicKey from '../../primitives/PublicKey'
+import PrivateKey from '../../primitives/PrivateKey'
+import BRC42Private from './BRC42.private.vectors'
+import Curve from '../../primitives/Curve'
+import BigNumber from '../../primitives/BigNumber'
 
+describe('PrivateKey', () => {
+  describe('BRC42 vectors', () => {
     BRC42Private.forEach((vector, index) => {
       it(`Passes BRC42 private vector #${index + 1}`, () => {
-        const publicKey = PublicKey.fromString(vector.senderPublicKey);
-        const privateKey = PrivateKey.fromString(vector.recipientPrivateKey);
-        const derived = privateKey.deriveChild(publicKey, vector.invoiceNumber);
-        expect(derived.toHex()).toEqual(vector.privateKey);
-      });
-    });
-  });
+        const publicKey = PublicKey.fromString(vector.senderPublicKey)
+        const privateKey = PrivateKey.fromString(vector.recipientPrivateKey)
+        const derived = privateKey.deriveChild(publicKey, vector.invoiceNumber)
+        expect(derived.toHex()).toEqual(vector.privateKey)
+      })
+    })
+  })
 
-  describe("PrivateKey Validation and Conversion", () => {
-    const curve = new Curve();
+  describe('PrivateKey Validation and Conversion', () => {
+    const curve = new Curve()
 
-    const isValidPrivateKey = (key) => {
+    const isValidPrivateKey = (key: string): boolean => {
       try {
-        const keyAsNumber = new BigNumber(key, 16);
+        const keyAsNumber = new BigNumber(key, 16)
         return (
           !keyAsNumber.isZero() &&
           keyAsNumber.cmp(curve.n) < 0 &&
           key.length === 64
-        );
-      } catch (e) {
-        return false;
+        )
+      } catch {
+        return false
       }
-    };
+    }
 
-    it("Validates and converts valid private keys between hex and string", () => {
+    it('Validates and converts valid private keys between hex and string', () => {
       const validKeys = [
-        "0000000000000000000000000000000000000000000000000000000000000001",
-        "fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140",
-        "8a2f85e08360a04c8a36b7c22c5e9e9a0d3bcf2f95c97db2b8bd90fc5f5ff66a",
-        "1b5a8f2392e6959a7de2b0a58f8a64cc528c9bfc1788ee0d32e1455063e71545",
-      ];
+        '0000000000000000000000000000000000000000000000000000000000000001',
+        'fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140',
+        '8a2f85e08360a04c8a36b7c22c5e9e9a0d3bcf2f95c97db2b8bd90fc5f5ff66a',
+        '1b5a8f2392e6959a7de2b0a58f8a64cc528c9bfc1788ee0d32e1455063e71545'
+      ]
 
-      validKeys.forEach((key, index) => {
-        const privateKeyFromHex = PrivateKey.fromHex(key);
-        const privateKeyFromString = PrivateKey.fromString(key, "hex");
-        const privateKeyToHex = privateKeyFromHex.toHex();
-        const privateKeyToString = privateKeyFromString.toString("hex");
-        expect(isValidPrivateKey(privateKeyToHex)).toBe(true);
-        expect(isValidPrivateKey(privateKeyToString)).toBe(true);
+      validKeys.forEach((key) => {
+        const privateKeyFromHex = PrivateKey.fromHex(key)
+        const privateKeyFromString = PrivateKey.fromString(key, 'hex')
+        const privateKeyToHex = privateKeyFromHex.toHex()
+        const privateKeyToString = privateKeyFromString.toString('hex')
+        expect(isValidPrivateKey(privateKeyToHex)).toBe(true)
+        expect(isValidPrivateKey(privateKeyToString)).toBe(true)
 
         // Round-trip conversion checks
-        expect(privateKeyToHex).toEqual(key);
-        expect(privateKeyToString).toEqual(key);
-      });
-    });
+        expect(privateKeyToHex).toEqual(key)
+        expect(privateKeyToString).toEqual(key)
+      })
+    })
 
     // it('Rejects invalid private keys during validation and conversion', () => {
     //   const invalidKeys = [
@@ -76,25 +74,25 @@ describe("PrivateKey", () => {
     //   })
     // })
 
-    it("Tests 10,000 random private keys for valid conversions", () => {
+    it('Tests 10,000 random private keys for valid conversions', () => {
       for (let i = 0; i < 10000; i++) {
-        const privateKey = PrivateKey.fromRandom();
-        const privateKeyHex = privateKey.toHex();
-        const privateKeyString = privateKey.toString("hex");
+        const privateKey = PrivateKey.fromRandom()
+        const privateKeyHex = privateKey.toHex()
+        const privateKeyString = privateKey.toString('hex')
 
         // Validate the random key's format
-        expect(isValidPrivateKey(privateKeyHex)).toBe(true);
-        expect(isValidPrivateKey(privateKeyString)).toBe(true);
+        expect(isValidPrivateKey(privateKeyHex)).toBe(true)
+        expect(isValidPrivateKey(privateKeyString)).toBe(true)
 
         // Round-trip conversion checks
-        const roundTripHex = PrivateKey.fromHex(privateKeyHex).toHex();
+        const roundTripHex = PrivateKey.fromHex(privateKeyHex).toHex()
         const roundTripString = PrivateKey.fromString(
           privateKeyString,
-          "hex"
-        ).toString("hex");
-        expect(roundTripHex).toEqual(privateKeyHex);
-        expect(roundTripString).toEqual(privateKeyString);
+          'hex'
+        ).toString('hex')
+        expect(roundTripHex).toEqual(privateKeyHex)
+        expect(roundTripString).toEqual(privateKeyString)
       }
-    });
-  });
-});
+    })
+  })
+})

package/src/primitives/__tests/PublicKey.test.ts

@@ -21,74 +21,76 @@ describe('PublicKey', () => {
     test('fromDER should create a PublicKey from a string', () => {
       const pubKeyString = publicKey.toString()
       const newPublicKey = PublicKey.fromString(pubKeyString)
+
       expect(newPublicKey).toBeInstanceOf(PublicKey)
-      expect(newPublicKey.x.toHex()).toEqual(publicKey.x.toHex())
-      expect(newPublicKey.y.toHex()).toEqual(publicKey.y.toHex())
-    })
-  })
 
-  describe('Constructor', () => {
-    it('Should throw when accidentally passing in DER', () => {
-      expect(
-        () =>
-          new PublicKey(
-            '036af279b60aa437d48bb0e2ec0b0c6b5cfaa976663f1f08ad456fd7fff149321d'
-          )
-      ).toThrow()
+      expect(newPublicKey.x?.toHex()).toEqual(publicKey.x?.toHex()) // ✅ Safe access
+      expect(newPublicKey.y?.toHex()).toEqual(publicKey.y?.toHex()) // ✅ Safe access
     })
-  })
 
-  describe('Instance methods', () => {
-    test('deriveSharedSecret should derive a shared secret Point', () => {
-      const sharedSecret = publicKey.deriveSharedSecret(privateKey)
-      expect(sharedSecret).toBeInstanceOf(Point)
+    describe('Constructor', () => {
+      it('Should throw when accidentally passing in DER', () => {
+        expect(
+          () =>
+            new PublicKey(
+              '036af279b60aa437d48bb0e2ec0b0c6b5cfaa976663f1f08ad456fd7fff149321d'
+            )
+        ).toThrow()
+      })
     })
 
-    test('deriveSharedSecret should throw error for invalid public key', () => {
-      const invalidPublicKey = new PublicKey(10, 13)
-      expect(() => {
-        invalidPublicKey.deriveSharedSecret(privateKey)
-      }).toThrow('Public key not valid for ECDH secret derivation')
-    })
+    describe('Instance methods', () => {
+      test('deriveSharedSecret should derive a shared secret Point', () => {
+        const sharedSecret = publicKey.deriveSharedSecret(privateKey)
+        expect(sharedSecret).toBeInstanceOf(Point)
+      })
 
-    test('verify should return true for valid signature', () => {
-      const message = new BigNumber('deadbeef', 16)
-      const signature = privateKey.sign(message)
-      expect(publicKey.verify(message, signature)).toBe(true)
-    })
+      test('deriveSharedSecret should throw error for invalid public key', () => {
+        const invalidPublicKey = new PublicKey(10, 13)
+        expect(() => {
+          invalidPublicKey.deriveSharedSecret(privateKey)
+        }).toThrow('Public key not valid for ECDH secret derivation')
+      })
 
-    test('toDER should return DER encoded string of public key', () => {
-      const derString = publicKey.toString()
-      expect(typeof derString).toBe('string')
-      expect(derString.length).toBe(66)
-    })
+      test('verify should return true for valid signature', () => {
+        const message = new BigNumber('deadbeef', 16)
+        const signature = privateKey.sign(message)
+        expect(publicKey.verify(message, signature)).toBe(true)
+      })
 
-    test('toDER should return DER encoded number[] of public key', () => {
-      const der = publicKey.toDER()
-      expect(typeof der).toBe('object')
-      expect(der.length).toBe(33)
-    })
+      test('toDER should return DER encoded string of public key', () => {
+        const derString = publicKey.toString()
+        expect(typeof derString).toBe('string')
+        expect(derString.length).toBe(66)
+      })
 
-    test('fromDER and fromString should result in the same public key', () => {
-      const key = PrivateKey.fromRandom()
-      const original = key.toPublicKey()
-      const toDERResult = original.toDER()
-      const backAndForth = Array.isArray(toDERResult)
-        ? PublicKey.fromString(Buffer.from(toDERResult).toString('hex'))
-        : PublicKey.fromString(toDERResult)
+      test('toDER should return DER encoded number[] of public key', () => {
+        const der = publicKey.toDER()
+        expect(typeof der).toBe('object')
+        expect(der.length).toBe(33)
+      })
 
-      expect(backAndForth.toString()).toEqual(original.toString())
-    })
-  })
-  describe('BRC42 vectors', () => {
-    for (let i = 0; i < BRC42Public.length; i++) {
-      it(`Passes BRC42 public vector #${i + 1}`, () => {
-        const v = BRC42Public[i]
-        const publicKey = PublicKey.fromString(v.recipientPublicKey)
-        const privateKey = PrivateKey.fromString(v.senderPrivateKey, 16)
-        const derived = publicKey.deriveChild(privateKey, v.invoiceNumber)
-        expect(derived.toString()).toEqual(v.publicKey)
+      test('fromDER and fromString should result in the same public key', () => {
+        const key = PrivateKey.fromRandom()
+        const original = key.toPublicKey()
+        const toDERResult = original.toDER()
+        const backAndForth = Array.isArray(toDERResult)
+          ? PublicKey.fromString(Buffer.from(toDERResult).toString('hex'))
+          : PublicKey.fromString(toDERResult)
+
+        expect(backAndForth.toString()).toEqual(original.toString())
       })
-    }
+    })
+    describe('BRC42 vectors', () => {
+      for (let i = 0; i < BRC42Public.length; i++) {
+        it(`Passes BRC42 public vector #${i + 1}`, () => {
+          const v = BRC42Public[i]
+          const publicKey = PublicKey.fromString(v.recipientPublicKey)
+          const privateKey = PrivateKey.fromString(v.senderPrivateKey, 16)
+          const derived = publicKey.deriveChild(privateKey, v.invoiceNumber)
+          expect(derived.toString()).toEqual(v.publicKey)
+        })
+      }
+    })
   })
 })

package/src/primitives/__tests/Random.test.ts

@@ -1,14 +1,14 @@
 /* eslint-env jest */
-import Random from "../../primitives/Random";
+import Random from '../../primitives/Random'
 
-describe("Random", () => {
-  it("Produces random bytes of correct length", () => {
-    expect(Random(3).length).toBe(3);
-    expect(Random(10).length).toBe(10);
-  });
-  it("Does not produce the same thing every time", () => {
+describe('Random', () => {
+  it('Produces random bytes of correct length', () => {
+    expect(Random(3).length).toBe(3)
+    expect(Random(10).length).toBe(10)
+  })
+  it('Does not produce the same thing every time', () => {
     // While this test may fail once every few hundred trillion years or so,
     // I haven't seen it fail yet. If you see it fail, please let me know.
-    expect(Random(32)).not.toEqual(Random(32));
-  });
-});
+    expect(Random(32)).not.toEqual(Random(32))
+  })
+})