@bsv/sdk 1.3.13 → 1.3.15

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

@@ -1,282 +1,284 @@
-import Schnorr from "../../primitives/Schnorr";
-import BigNumber from "../../primitives/BigNumber";
-import Curve from "../../primitives/Curve";
-import PrivateKey from "../../primitives/PrivateKey";
+import Schnorr from '../../primitives/Schnorr'
+import BigNumber from '../../primitives/BigNumber'
+import Curve from '../../primitives/Curve'
+import PrivateKey from '../../primitives/PrivateKey'
+import PublicKey from '../../primitives/PublicKey'
+import Point from '../../primitives/Point'
 
-describe("Schnorr Zero-Knowledge Proof", () => {
-  let schnorr: Schnorr;
-  let curve: Curve;
+describe('Schnorr Zero-Knowledge Proof', () => {
+  let schnorr: Schnorr
+  let curve: Curve
 
   beforeAll(() => {
-    schnorr = new Schnorr();
-    curve = new Curve();
-  });
+    schnorr = new Schnorr()
+    curve = new Curve()
+  })
 
-  it("should verify a valid proof", () => {
+  it('should verify a valid proof', () => {
     // Generate private keys
-    const a = PrivateKey.fromRandom();
-    const b = PrivateKey.fromRandom();
+    const a = PrivateKey.fromRandom()
+    const b = PrivateKey.fromRandom()
 
     // Compute public keys
-    const A = a.toPublicKey();
-    const B = b.toPublicKey();
+    const A = a.toPublicKey()
+    const B = b.toPublicKey()
 
     // Compute shared secret S = B * a
-    const S = B.mul(a);
+    const S = B.mul(a)
 
     // Generate proof
-    const proof = schnorr.generateProof(a, A, B, S);
+    const proof = schnorr.generateProof(a, A, B, S)
 
     // Verify proof
-    const result = schnorr.verifyProof(A, B, S, proof);
-    expect(result).toBe(true);
-  });
+    const result = schnorr.verifyProof(A, B, S, proof)
+    expect(result).toBe(true)
+  })
 
-  it("should fail verification if proof is tampered (R modified)", () => {
+  it('should fail verification if proof is tampered (R modified)', () => {
     // Generate private keys
-    const a = PrivateKey.fromRandom();
-    const b = PrivateKey.fromRandom();
+    const a = PrivateKey.fromRandom()
+    const b = PrivateKey.fromRandom()
 
     // Compute public keys
-    const A = a.toPublicKey();
-    const B = b.toPublicKey();
+    const A = a.toPublicKey()
+    const B = b.toPublicKey()
 
     // Compute shared secret S = B * a
-    const S = B.mul(a);
+    const S = B.mul(a)
 
     // Generate proof
-    const proof = schnorr.generateProof(a, A, B, S);
+    const proof = schnorr.generateProof(a, A, B, S)
 
     // Tamper with R
-    const tamperedR = proof.R.add(curve.g);
-    const tamperedProof = { ...proof, R: tamperedR };
+    const tamperedR = proof.R.add(curve.g)
+    const tamperedProof = { ...proof, R: tamperedR }
 
     // Verify proof
-    const result = schnorr.verifyProof(A, B, S, tamperedProof);
-    expect(result).toBe(false);
-  });
+    const result = schnorr.verifyProof(A, B, S, tamperedProof)
+    expect(result).toBe(false)
+  })
 
-  it("should fail verification if proof is tampered (z modified)", () => {
+  it('should fail verification if proof is tampered (z modified)', () => {
     // Generate private keys
-    const a = PrivateKey.fromRandom();
-    const b = PrivateKey.fromRandom();
+    const a = PrivateKey.fromRandom()
+    const b = PrivateKey.fromRandom()
 
     // Compute public keys
-    const A = a.toPublicKey();
-    const B = b.toPublicKey();
+    const A = a.toPublicKey()
+    const B = b.toPublicKey()
 
     // Compute shared secret S = B * a
-    const S = B.mul(a);
+    const S = B.mul(a)
 
     // Generate proof
-    const proof = schnorr.generateProof(a, A, B, S);
+    const proof = schnorr.generateProof(a, A, B, S)
 
     // Tamper with z
-    const tamperedZ = proof.z.add(new BigNumber(1)).umod(curve.n);
-    const tamperedProof = { ...proof, z: tamperedZ };
+    const tamperedZ = proof.z.add(new BigNumber(1)).umod(curve.n)
+    const tamperedProof = { ...proof, z: tamperedZ }
 
     // Verify proof
-    const result = schnorr.verifyProof(A, B, S, tamperedProof);
-    expect(result).toBe(false);
-  });
+    const result = schnorr.verifyProof(A, B, S, tamperedProof)
+    expect(result).toBe(false)
+  })
 
   it("should fail verification if proof is tampered (S' modified)", () => {
     // Generate private keys
-    const a = PrivateKey.fromRandom();
-    const b = PrivateKey.fromRandom();
+    const a = PrivateKey.fromRandom()
+    const b = PrivateKey.fromRandom()
 
     // Compute public keys
-    const A = a.toPublicKey();
-    const B = b.toPublicKey();
+    const A = a.toPublicKey()
+    const B = b.toPublicKey()
 
     // Compute shared secret S = B * a
-    const S = B.mul(a);
+    const S = B.mul(a)
 
     // Generate proof
-    const proof = schnorr.generateProof(a, A, B, S);
+    const proof = schnorr.generateProof(a, A, B, S)
 
     // Tamper with S'
-    const tamperedSPrime = proof.SPrime.add(curve.g);
-    const tamperedProof = { ...proof, SPrime: tamperedSPrime };
+    const tamperedSPrime = proof.SPrime.add(curve.g)
+    const tamperedProof = { ...proof, SPrime: tamperedSPrime }
 
     // Verify proof
-    const result = schnorr.verifyProof(A, B, S, tamperedProof);
-    expect(result).toBe(false);
-  });
+    const result = schnorr.verifyProof(A, B, S, tamperedProof)
+    expect(result).toBe(false)
+  })
 
-  it("should fail verification if inputs are tampered (A modified)", () => {
+  it('should fail verification if inputs are tampered (A modified)', () => {
     // Generate private keys
-    const a = PrivateKey.fromRandom();
-    const b = PrivateKey.fromRandom();
+    const a = PrivateKey.fromRandom()
+    const b = PrivateKey.fromRandom()
 
     // Compute public keys
-    const A = a.toPublicKey();
-    const B = b.toPublicKey();
+    const A = a.toPublicKey()
+    const B = b.toPublicKey()
 
     // Compute shared secret S = B * a
-    const S = B.mul(a);
+    const S = B.mul(a)
 
     // Generate proof
-    const proof = schnorr.generateProof(a, A, B, S);
+    const proof = schnorr.generateProof(a, A, B, S)
 
     // Tamper with A
-    const tamperedA = A.add(curve.g);
+    const tamperedA = A.add(curve.g)
 
     // Verify proof
-    const result = schnorr.verifyProof(tamperedA, B, S, proof);
-    expect(result).toBe(false);
-  });
+    const result = schnorr.verifyProof(tamperedA, B, S, proof)
+    expect(result).toBe(false)
+  })
 
-  it("should fail verification if inputs are tampered (B modified)", () => {
+  it('should fail verification if inputs are tampered (B modified)', () => {
     // Generate private keys
-    const a = PrivateKey.fromRandom();
-    const b = PrivateKey.fromRandom();
+    const a = PrivateKey.fromRandom()
+    const b = PrivateKey.fromRandom()
 
     // Compute public keys
-    const A = a.toPublicKey();
-    const B = b.toPublicKey();
+    const A = a.toPublicKey()
+    const B = b.toPublicKey()
 
     // Compute shared secret S = B * a
-    const S = B.mul(a);
+    const S = B.mul(a)
 
     // Generate proof
-    const proof = schnorr.generateProof(a, A, B, S);
+    const proof = schnorr.generateProof(a, A, B, S)
 
     // Tamper with B
-    const tamperedB = B.add(curve.g);
+    const tamperedB = B.add(curve.g)
 
     // Verify proof
-    const result = schnorr.verifyProof(A, tamperedB, S, proof);
-    expect(result).toBe(false);
-  });
+    const result = schnorr.verifyProof(A, tamperedB, S, proof)
+    expect(result).toBe(false)
+  })
 
-  it("should fail verification if inputs are tampered (S modified)", () => {
+  it('should fail verification if inputs are tampered (S modified)', () => {
     // Generate private keys
-    const a = PrivateKey.fromRandom();
-    const b = PrivateKey.fromRandom();
+    const a = PrivateKey.fromRandom()
+    const b = PrivateKey.fromRandom()
 
     // Compute public keys
-    const A = a.toPublicKey();
-    const B = b.toPublicKey();
+    const A = a.toPublicKey()
+    const B = b.toPublicKey()
 
     // Compute shared secret S = B * a
-    const S = B.mul(a);
+    const S = B.mul(a)
 
     // Generate proof
-    const proof = schnorr.generateProof(a, A, B, S);
+    const proof = schnorr.generateProof(a, A, B, S)
 
     // Tamper with S
-    const tamperedS = S.add(curve.g);
+    const tamperedS = S.add(curve.g)
 
     // Verify proof
-    const result = schnorr.verifyProof(A, B, tamperedS, proof);
-    expect(result).toBe(false);
-  });
+    const result = schnorr.verifyProof(A, B, tamperedS, proof)
+    expect(result).toBe(false)
+  })
 
-  it("should fail verification if using wrong private key", () => {
+  it('should fail verification if using wrong private key', () => {
     // Generate private keys
-    const a = PrivateKey.fromRandom();
-    const wrongA = PrivateKey.fromRandom();
-    const b = PrivateKey.fromRandom();
+    const a = PrivateKey.fromRandom()
+    const wrongA = PrivateKey.fromRandom()
+    const b = PrivateKey.fromRandom()
 
     // Compute public keys
-    const A = a.toPublicKey();
-    const B = b.toPublicKey();
+    const A = a.toPublicKey()
+    const B = b.toPublicKey()
 
     // Compute shared secret S = B * a
-    const S = B.mul(a);
+    const S = B.mul(a)
 
     // Generate proof using wrong private key
-    const proof = schnorr.generateProof(wrongA, A, B, S);
+    const proof = schnorr.generateProof(wrongA, A, B, S)
 
     // Verify proof
-    const result = schnorr.verifyProof(A, B, S, proof);
-    expect(result).toBe(false);
-  });
+    const result = schnorr.verifyProof(A, B, S, proof)
+    expect(result).toBe(false)
+  })
 
-  it("should fail verification if using wrong public key", () => {
+  it('should fail verification if using wrong public key', () => {
     // Generate private keys
-    const a = PrivateKey.fromRandom();
-    const b = PrivateKey.fromRandom();
-    const wrongB = PrivateKey.fromRandom();
+    const a = PrivateKey.fromRandom()
+    const b = PrivateKey.fromRandom()
+    const wrongB = PrivateKey.fromRandom()
 
     // Compute public keys
-    const A = a.toPublicKey();
-    const B = b.toPublicKey();
-    const wrongBPublic = wrongB.toPublicKey();
+    const A = a.toPublicKey()
+    const B = b.toPublicKey()
+    const wrongBPublic = wrongB.toPublicKey()
 
     // Compute shared secret S = B * a
-    const S = B.mul(a);
+    const S = B.mul(a)
 
     // Generate proof
-    const proof = schnorr.generateProof(a, A, B, S);
+    const proof = schnorr.generateProof(a, A, B, S)
 
     // Verify proof with wrong B
-    const result = schnorr.verifyProof(A, wrongBPublic, S, proof);
-    expect(result).toBe(false);
-  });
+    const result = schnorr.verifyProof(A, wrongBPublic, S, proof)
+    expect(result).toBe(false)
+  })
 
-  it("should fail verification if shared secret S is incorrect", () => {
+  it('should fail verification if shared secret S is incorrect', () => {
     // Generate private keys
-    const a = PrivateKey.fromRandom();
-    const b = PrivateKey.fromRandom();
+    const a = PrivateKey.fromRandom()
+    const b = PrivateKey.fromRandom()
 
     // Compute public keys
-    const A = a.toPublicKey();
-    const B = b.toPublicKey();
+    const A = a.toPublicKey()
+    const B = b.toPublicKey()
 
     // Intentionally compute incorrect shared secret
-    const S = B.mul(a).add(curve.g);
+    const S = B.mul(a).add(curve.g)
 
     // Generate proof with correct S
-    const proof = schnorr.generateProof(a, A, B, B.mul(a));
+    const proof = schnorr.generateProof(a, A, B, B.mul(a))
 
     // Verify proof with incorrect S
-    const result = schnorr.verifyProof(A, B, S, proof);
-    expect(result).toBe(false);
-  });
+    const result = schnorr.verifyProof(A, B, S, proof)
+    expect(result).toBe(false)
+  })
 
-  it("should verify a valid proof with fixed keys", () => {
+  it('should verify a valid proof with fixed keys', () => {
     // Use fixed private keys for determinism
     const a = new PrivateKey(
       new BigNumber(
-        "123456789abcdef123456789abcdef123456789abcdef123456789abcdef",
+        '123456789abcdef123456789abcdef123456789abcdef123456789abcdef',
         16
       )
-    );
+    )
     const b = new PrivateKey(
       new BigNumber(
-        "abcdef123456789abcdef123456789abcdef123456789abcdef123456789",
+        'abcdef123456789abcdef123456789abcdef123456789abcdef123456789',
         16
       )
-    );
+    )
 
     // Compute public keys
-    const A = a.toPublicKey();
-    const B = b.toPublicKey();
+    const A = a.toPublicKey()
+    const B = b.toPublicKey()
 
     // Compute shared secret S = B * a
-    const S = B.mul(a);
+    const S = B.mul(a)
 
     // Generate proof
-    const proof = schnorr.generateProof(a, A, B, S);
+    const proof = schnorr.generateProof(a, A, B, S)
 
     // Verify proof
-    const result = schnorr.verifyProof(A, B, S, proof);
-    expect(result).toBe(true);
-  });
-
-  it("should throw an error if inputs are invalid", () => {
-    const a = PrivateKey.fromRandom();
-    const b = PrivateKey.fromRandom();
-    const A = a.toPublicKey();
-    const B = b.toPublicKey();
-    const S = B.mul(a);
-    const proof = schnorr.generateProof(a, A, B, S);
-
-    expect(() => schnorr.verifyProof(null as any, B, S, proof)).toThrow();
-    expect(() => schnorr.verifyProof(A, null as any, S, proof)).toThrow();
-    expect(() => schnorr.verifyProof(A, B, null as any, proof)).toThrow();
-    expect(() => schnorr.verifyProof(A, B, S, null as any)).toThrow();
-  });
-});
+    const result = schnorr.verifyProof(A, B, S, proof)
+    expect(result).toBe(true)
+  })
+
+  it('should throw an error if inputs are invalid', () => {
+    const a = PrivateKey.fromRandom()
+    const b = PrivateKey.fromRandom()
+    const A = a.toPublicKey()
+    const B = b.toPublicKey()
+    const S = B.mul(a)
+    const proof = schnorr.generateProof(a, A, B, S)
+
+    expect(() => schnorr.verifyProof(null as unknown as PublicKey, B, S, proof)).toThrow()
+    expect(() => schnorr.verifyProof(A, null as unknown as PublicKey, S, proof)).toThrow()
+    expect(() => schnorr.verifyProof(A, B, null as unknown as PublicKey, proof)).toThrow()
+    expect(() => schnorr.verifyProof(A, B, S, null as unknown as { R: Point, SPrime: Point, z: BigNumber })).toThrow() // ✅ Correct cast
+  })
+})

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

@@ -1,61 +1,61 @@
-import SymmetricKey from "../../primitives/SymmetricKey";
-import vectors from "./SymmetricKey.vectors";
+import SymmetricKey from '../../primitives/SymmetricKey'
+import vectors from './SymmetricKey.vectors'
 
 const KEYS: SymmetricKey[] = [
   new SymmetricKey(
-    "5a90d59d829197983a54d887fdea2dc4c38098f00ba3110f2645633b6ea11458",
+    '5a90d59d829197983a54d887fdea2dc4c38098f00ba3110f2645633b6ea11458',
     16
   ),
   new SymmetricKey(
-    "bac6ac492f54d7c997fadc1be593a4ace26ecdf37d30b3ad12f34077fb2629e4",
+    'bac6ac492f54d7c997fadc1be593a4ace26ecdf37d30b3ad12f34077fb2629e4',
     16
   ),
   new SymmetricKey(
-    "53dcdc6ea6a6910af35a48708f49228e0e6661ea885435080cbabc58e6a14f10",
+    '53dcdc6ea6a6910af35a48708f49228e0e6661ea885435080cbabc58e6a14f10',
     16
-  ),
-];
+  )
+]
 
-const PLAINTEXT_1 = "hello there";
+const PLAINTEXT_1 = 'hello there'
 const CIPHERTEXT_1 =
-  "8c8d25348dfd5240be833215a123173c64919779ab8845a700a4520311504c168ade2d4b728cc53a254f0aba857caaf6af97453ac2ff61487d0d52";
+  '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", () => {
+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);
-  });
+      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 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"));
-    });
-  });
-});
+        [...Buffer.from(vector.ciphertext, 'base64')],
+        'hex'
+      )
+      expect(result).toEqual(Buffer.from(vector.plaintext).toString('hex'))
+    })
+  })
+})

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

@@ -13,27 +13,35 @@
  */
 export default [
   {
-    ciphertext: '1cf74FpvW0koFZk5e1VQcCtF7UdLj9mtN/L9loFlXwhf6w/06THwVirsvDShuT/KlOjO/HFALj8AcGLU1KRs4zNJDaX2wNebuPkH+qp5N/0cp3fZxgFzHJB3jBPDcdFi8O9WXIBLx9jUQ5KFQk0mZCB2k90VniInWuzqqOQAQQlBy2rgBWp4xg==',
+    ciphertext:
+      '1cf74FpvW0koFZk5e1VQcCtF7UdLj9mtN/L9loFlXwhf6w/06THwVirsvDShuT/KlOjO/HFALj8AcGLU1KRs4zNJDaX2wNebuPkH+qp5N/0cp3fZxgFzHJB3jBPDcdFi8O9WXIBLx9jUQ5KFQk0mZCB2k90VniInWuzqqOQAQQlBy2rgBWp4xg==',
     key: 'LIe9CoVXxDDDKt9F4j2lE+GP4oPcMElwyX+LVsuRLqw=',
-    plaintext: '5+w9tts+i14GDfPSEJwcaAfce7zVLC7wsRAMnCBqIczkqL08I05FZTl7n14H9hnPkS7HBm3EGWNDKCZ64ckCGg=='
+    plaintext:
+      '5+w9tts+i14GDfPSEJwcaAfce7zVLC7wsRAMnCBqIczkqL08I05FZTl7n14H9hnPkS7HBm3EGWNDKCZ64ckCGg=='
   },
   {
-    ciphertext: 'IFh45HxwvK7wgIZr5UDxvUiEkvjsXVV6VIksaEQoTNCPleaRxE1CE1eZj5ZSPa/Mo2HXa2kvEmVAMslY12gMb7qHAHT2fSORB8TJKubKcjwGUrRxqOWvk24lv7QKhq3uhKkJxZSkPBZS6UM+xX+x7Mb53CoC8Z+7Ork50wGRAA415C+T8FIluA==',
+    ciphertext:
+      'IFh45HxwvK7wgIZr5UDxvUiEkvjsXVV6VIksaEQoTNCPleaRxE1CE1eZj5ZSPa/Mo2HXa2kvEmVAMslY12gMb7qHAHT2fSORB8TJKubKcjwGUrRxqOWvk24lv7QKhq3uhKkJxZSkPBZS6UM+xX+x7Mb53CoC8Z+7Ork50wGRAA415C+T8FIluA==',
     key: 'Di30+CTH8yKVJfXmbkRU6DOesD042IkjZCbFL1lnNqY=',
-    plaintext: '6pHqDrkIuGmWIpB1spu30PP848D04WlERSjrEZ/JD0jfdS814cOjs4MFkePT1IHeM4+qGFwAMk7HKgWShOKFDQ=='
+    plaintext:
+      '6pHqDrkIuGmWIpB1spu30PP848D04WlERSjrEZ/JD0jfdS814cOjs4MFkePT1IHeM4+qGFwAMk7HKgWShOKFDQ=='
   },
   {
-    ciphertext: 'JeUMCTX3hW7uH7Njfqjtjxd/8jB0Uj4eLLbLNBSMqF3XJmtq2oyX/WWS1po8cwn7jrcK0k8mVxHax/DctH6CIDMc0udBxWYLDyftvIYr448otWmn2IKQN4d3Bh2PKdiIQOo36DO2wOy+T2OJSmJ2XvAkenSZIckCdPIQVpeIi7Bt2ZpHmkObkg==',
+    ciphertext:
+      'JeUMCTX3hW7uH7Njfqjtjxd/8jB0Uj4eLLbLNBSMqF3XJmtq2oyX/WWS1po8cwn7jrcK0k8mVxHax/DctH6CIDMc0udBxWYLDyftvIYr448otWmn2IKQN4d3Bh2PKdiIQOo36DO2wOy+T2OJSmJ2XvAkenSZIckCdPIQVpeIi7Bt2ZpHmkObkg==',
     key: 'v7kFn4JdB3OVVjy8lk7UTvWe0vY5Qyzn64Q0EVoezlU=',
-    plaintext: 'bSYHdJn15pcsaI8CNmfjKQ3ZvMg7zBaxuxBqyWBmCLdqj29bK54C26G1mx5e605hDrFpuJoNSDTECrk67ebffA=='
+    plaintext:
+      'bSYHdJn15pcsaI8CNmfjKQ3ZvMg7zBaxuxBqyWBmCLdqj29bK54C26G1mx5e605hDrFpuJoNSDTECrk67ebffA=='
   },
   {
-    ciphertext: 'ktpzKolKsvtWrvLl0yMdGvh5ngd1hiaNcC1b5yuzo2DEKO/4S7gePO/CWOmW/dloHhzfbBQH9rKDFKK7xHHgqYRc',
+    ciphertext:
+      'ktpzKolKsvtWrvLl0yMdGvh5ngd1hiaNcC1b5yuzo2DEKO/4S7gePO/CWOmW/dloHhzfbBQH9rKDFKK7xHHgqYRc',
     key: 'qIgnjD0FfGVMiWo107bP0oHsLA402lhC7AYUFIKY1KQ=',
     plaintext: 'A cat and a mouse.'
   },
   {
-    ciphertext: 'vremTalPp+NxN/loEtLMB94tEymdFk2TfBoTWNYcf4sQqYSNkx2WPdJ4LxrIsGuIg9KMOt7FOcIpDb6rRVpP',
+    ciphertext:
+      'vremTalPp+NxN/loEtLMB94tEymdFk2TfBoTWNYcf4sQqYSNkx2WPdJ4LxrIsGuIg9KMOt7FOcIpDb6rRVpP',
     key: 'K7E/bf3wp6hrVeW0V1KvFJS5JZMhyxwPHCIW6wKBTb0=',
     plaintext: 'üñîçø∂é'
   }

package/src/primitives/__tests/bug-31.test.ts

@@ -1,33 +1,27 @@
-// import { PrivateKey, PublicKey, Curve, Hash, BigNumber } from '..';
-import PublicKey from "../../primitives/PublicKey";
-// import { PrivateKey } from '..';
-import PrivateKey from "../../primitives/PrivateKey";
-import Curve from "../../primitives/Curve";
-import BigNumber from "../../primitives/BigNumber";
+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 G = c.g;
+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 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");
+    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");
-  });
-});
+    expect(() => os2.toWif()).toThrow('Value is out of field')
+  })
+})

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

@@ -47,7 +47,7 @@ describe('utils', () => {
       expect(toHex(actual)).toEqual('00000039')
     })
     it('Throws when called with undefined base58 string', () => {
-      expect(() => (fromBase58 as any)()).toThrow(
+      expect(() => fromBase58(undefined as unknown as string)).toThrow(
         new Error('Expected base58 string but got “undefined”')
       )
     })