@bsv/sdk 1.3.12 → 1.3.13

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

@@ -1,59 +1,65 @@
 /* eslint-env jest */
-import { SHA256HMAC } from '../../../dist/cjs/src/primitives/Hash'
+import { SHA256HMAC } from "../../primitives/Hash";
 
-describe('HMAC', function () {
-  describe('mixed test vector', function () {
+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'
-    })
+      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'
-    })
+      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'
-    })
+      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'
-    })
+      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'
-    })
+      name: "regression 1",
+      key: "48f38d0c6a344959cc94502b7b5e8dffb6a5f41795d9066fc9a649557167ee2f",
+      msg: "1d495eef7761b65dccd0a983d2d7204fea28b5c81f1758046e062eb043755ea1",
+      msgEnc: "hex",
+      res: "cf5ad5984f9e43917aa9087380dac46e410ddc8a7731859c84e9d0f31bd43655",
+    });
 
-    function test (opt): void {
+    function test(opt): void {
       it(`should not fail at ${opt.name as string}`, function (): void {
-        let h = new SHA256HMAC(opt.key)
-        expect(h.update(opt.msg, opt.msgEnc).digestHex()).toEqual(opt.res)
-        h = h = new SHA256HMAC(opt.key)
-        expect(h
-          .update(opt.msg.slice(0, 10), opt.msgEnc)
-          .update(opt.msg.slice(10), opt.msgEnc)
-          .digestHex()).toEqual(opt.res)
-      })
+        let h = new SHA256HMAC(opt.key);
+        expect(h.update(opt.msg, opt.msgEnc).digestHex()).toEqual(opt.res);
+        h = h = new SHA256HMAC(opt.key);
+        expect(
+          h
+            .update(opt.msg.slice(0, 10), opt.msgEnc)
+            .update(opt.msg.slice(10), opt.msgEnc)
+            .digestHex()
+        ).toEqual(opt.res);
+      });
     }
-  })
-})
+  });
+});

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

@@ -1,121 +1,132 @@
 /* eslint-env jest */
-import * as hash from '../../../dist/cjs/src/primitives/Hash'
-import * as crypto from 'crypto'
-import PBKDF2Vectors from './PBKDF2.vectors'
-import { toArray, toHex } from '../../../dist/cjs/src/primitives/utils'
+import * as hash from "../../primitives/Hash";
+import * as crypto from "crypto";
+import PBKDF2Vectors from "./PBKDF2.vectors";
+import { toArray, toHex } from "../../primitives/utils";
 
-describe('Hash', function () {
-  function test (Hash, cases): void {
+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]
+      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)
+      let dgst = new Hash().update(msg, enc).digestHex();
+      expect(dgst).toEqual(res);
 
       // Split message
-      dgst = new Hash().update(msg.slice(0, 2), enc)
+      dgst = new Hash()
+        .update(msg.slice(0, 2), enc)
         .update(msg.slice(2), enc)
-        .digestHex()
-      expect(dgst).toEqual(res)
+        .digestHex();
+      expect(dgst).toEqual(res);
     }
   }
 
-  it('should support sha256', function () {
+  it("should support sha256", function () {
     test(hash.SHA256, [
-      ['abc',
-        'ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad'],
-      ['abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq',
-        '248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1'],
-      ['deadbeef',
-        '5f78c33274e43fa9de5659265c1d917e25c03722dcb0b8d27db8d5feaa813953',
-        'hex']
-    ])
-  })
+      [
+        "abc",
+        "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad",
+      ],
+      [
+        "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
+        "248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1",
+      ],
+      [
+        "deadbeef",
+        "5f78c33274e43fa9de5659265c1d917e25c03722dcb0b8d27db8d5feaa813953",
+        "hex",
+      ],
+    ]);
+  });
 
-  it('should support ripemd160', function () {
+  it("should support ripemd160", function () {
     test(hash.RIPEMD160, [
-      ['', '9c1185a5c5e9fc54612808977ee8f548b2258d31'],
-      ['abc',
-        '8eb208f7e05d987a9b044a8e98c6b087f15a0bfc'],
-      ['message digest',
-        '5d0689ef49d2fae572b881b123a85ffa21595f36'],
-      ['abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq',
-        '12a053384a9c0c88e405a06c27dcf49ada62eb2b'],
-      ['ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789',
-        'b0e20b6e3116640286ed3a87a5713079b21f5189']
-    ])
-  })
+      ["", "9c1185a5c5e9fc54612808977ee8f548b2258d31"],
+      ["abc", "8eb208f7e05d987a9b044a8e98c6b087f15a0bfc"],
+      ["message digest", "5d0689ef49d2fae572b881b123a85ffa21595f36"],
+      [
+        "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
+        "12a053384a9c0c88e405a06c27dcf49ada62eb2b",
+      ],
+      [
+        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
+        "b0e20b6e3116640286ed3a87a5713079b21f5189",
+      ],
+    ]);
+  });
 
-  it('should support sha1', function () {
+  it("should support sha1", function () {
     test(hash.SHA1, [
-      ['',
-        'da39a3ee5e6b4b0d3255bfef95601890afd80709'],
-      ['abc',
-        'a9993e364706816aba3e25717850c26c9cd0d89d'],
-      ['abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq',
-        '84983e441c3bd26ebaae4aa1f95129e5e54670f1'],
-      ['deadbeef',
-        'd78f8bb992a56a597f6c7a1fb918bb78271367eb',
-        'hex']
-    ])
-  })
+      ["", "da39a3ee5e6b4b0d3255bfef95601890afd80709"],
+      ["abc", "a9993e364706816aba3e25717850c26c9cd0d89d"],
+      [
+        "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
+        "84983e441c3bd26ebaae4aa1f95129e5e54670f1",
+      ],
+      ["deadbeef", "d78f8bb992a56a597f6c7a1fb918bb78271367eb", "hex"],
+    ]);
+  });
 
-  it('should support sha512', function () {
+  it("should support sha512", function () {
     test(hash.SHA512, [
-      ['abc',
-        'ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a' +
-        '2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f'
+      [
+        "abc",
+        "ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a" +
+          "2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f",
       ],
       [
-        'abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmn' +
-        'hijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu',
-        '8e959b75dae313da8cf4f72814fc143f8f7779c6eb9f7fa17299aeadb6889018' +
-        '501d289e4900f7e4331b99dec4b5433ac7d329eeb6dd26545e96e55b874be909'
-      ]
-    ])
-  })
+        "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')]))
-  })
+  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('PBKDF2 vectors', () => {
+  describe("PBKDF2 vectors", () => {
     for (let i = 0; i < PBKDF2Vectors.length; i++) {
-      const v = PBKDF2Vectors[i]
-      let key, salt
+      const v = PBKDF2Vectors[i];
+      let key, salt;
       if (v.keyUint8Array) {
-        key = v.keyUint8Array
+        key = v.keyUint8Array;
       }
       if (v.key) {
-        key = toArray(v.key, 'utf8')
+        key = toArray(v.key, "utf8");
       }
       if (v.keyHex) {
-        key = toArray(v.keyHex, 'hex')
+        key = toArray(v.keyHex, "hex");
       }
       if (v.saltUint8Array) {
-        salt = v.saltUint8Array
+        salt = v.saltUint8Array;
       }
       if (v.salt) {
-        salt = toArray(v.salt, 'utf8')
+        salt = toArray(v.salt, "utf8");
       }
       if (v.saltHex) {
-        salt = toArray(v.saltHex, 'hex')
+        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)
-      })
+        const output = hash.pbkdf2(key, salt, v.iterations, v.dkLen);
+        expect(toHex(output)).toEqual(v.results.sha512);
+      });
     }
-  })
-})
+  });
+});

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

@@ -1,5 +1,5 @@
-import PrivateKey, { KeyShares } from '../../../dist/cjs/src/primitives/PrivateKey'
-import { PointInFiniteField } from '../../../dist/cjs/src/primitives/Polynomial'
+import PrivateKey, { KeyShares } from '../../primitives/PrivateKey'
+import { PointInFiniteField } from '../../primitives/Polynomial'
 
 describe('PrivateKey', () => {
   it('should split the private key into shares correctly', () => {
@@ -27,7 +27,7 @@ describe('PrivateKey', () => {
       const key = PrivateKey.fromRandom()
       const allShares = key.toKeyShares(3, 5)
       const backup = allShares.toBackupFormat()
-      const someShares = KeyShares.fromBackupFormat(backup.slice(0,3))
+      const someShares = KeyShares.fromBackupFormat(backup.slice(0, 3))
       const rebuiltKey = PrivateKey.fromKeyShares(someShares)
       expect(rebuiltKey.toWif()).toBe(key.toWif())
       x++
@@ -36,8 +36,14 @@ describe('PrivateKey', () => {
 
   it('should throw an error for invalid threshold or totalShares', () => {
     const k = PrivateKey.fromRandom()
-    expect(() => k.toKeyShares('12', 14)).toThrow('threshold and totalShares must be numbers')
-    expect(() => k.toKeyShares(4, '5')).toThrow('threshold and totalShares must be numbers')
+
+    expect(() => k.toKeyShares('invalid' as any, 14)).toThrow(
+      'threshold and totalShares must be numbers'
+    )
+
+    expect(() => k.toKeyShares(4, undefined as any)).toThrow(
+      'threshold and totalShares must be numbers'
+    )
   })
 
   it('should throw an error for invalid threshold', () => {
@@ -52,13 +58,27 @@ describe('PrivateKey', () => {
 
   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')
+    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.')
+    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', () => {

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

@@ -1,60 +1,60 @@
-import PublicKey from '../../../dist/cjs/src/primitives/PublicKey'
-import PrivateKey from '../../../dist/cjs/src/primitives/PrivateKey'
-import BRC42Private from './BRC42.private.vectors'
-import Curve from '../../../dist/cjs/src/primitives/Curve'
-import BigNumber from '../../../dist/cjs/src/primitives/BigNumber'
+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()
+describe("PrivateKey", () => {
+  describe("BRC42 vectors", () => {
+    const curve = new Curve();
 
     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) => {
       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
+        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)
+        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,22 +76,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 roundTripString = PrivateKey.fromString(privateKeyString, 'hex').toString('hex')
-        expect(roundTripHex).toEqual(privateKeyHex)
-        expect(roundTripString).toEqual(privateKeyString)
+        const roundTripHex = PrivateKey.fromHex(privateKeyHex).toHex();
+        const roundTripString = PrivateKey.fromString(
+          privateKeyString,
+          "hex"
+        ).toString("hex");
+        expect(roundTripHex).toEqual(privateKeyHex);
+        expect(roundTripString).toEqual(privateKeyString);
       }
-    })
-  })
-})
+    });
+  });
+});

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

@@ -1,7 +1,7 @@
-import PublicKey from '../../../dist/cjs/src/primitives/PublicKey'
-import PrivateKey from '../../../dist/cjs/src/primitives/PrivateKey'
-import Point from '../../../dist/cjs/src/primitives/Point'
-import BigNumber from '../../../dist/cjs/src/primitives/BigNumber'
+import PublicKey from '../../primitives/PublicKey'
+import PrivateKey from '../../primitives/PrivateKey'
+import Point from '../../primitives/Point'
+import BigNumber from '../../primitives/BigNumber'
 import BRC42Public from './BRC42.public.vectors'
 
 describe('PublicKey', () => {
@@ -29,7 +29,12 @@ describe('PublicKey', () => {
 
   describe('Constructor', () => {
     it('Should throw when accidentally passing in DER', () => {
-      expect(() => new PublicKey('036af279b60aa437d48bb0e2ec0b0c6b5cfaa976663f1f08ad456fd7fff149321d')).toThrow()
+      expect(
+        () =>
+          new PublicKey(
+            '036af279b60aa437d48bb0e2ec0b0c6b5cfaa976663f1f08ad456fd7fff149321d'
+          )
+      ).toThrow()
     })
   })
 
@@ -67,7 +72,11 @@ describe('PublicKey', () => {
     test('fromDER and fromString should result in the same public key', () => {
       const key = PrivateKey.fromRandom()
       const original = key.toPublicKey()
-      const backAndForth = PublicKey.fromString(PublicKey.fromDER(original.toDER()).toString())
+      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())
     })
   })

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

@@ -1,14 +1,14 @@
 /* eslint-env jest */
-import Random from '../../../dist/cjs/src/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));
+  });
+});