@bsv/sdk 1.3.11 → 1.3.13

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

@@ -1,272 +1,282 @@
-import Schnorr from '../../../dist/cjs/src/primitives/Schnorr.js'
-import BigNumber from '../../../dist/cjs/src/primitives/BigNumber.js'
-import Curve from '../../../dist/cjs/src/primitives/Curve.js'
-import PrivateKey from '../../../dist/cjs/src/primitives/PrivateKey.js'
-
-describe('Schnorr Zero-Knowledge Proof', () => {
-    let schnorr: Schnorr
-    let curve: Curve
-
-    beforeAll(() => {
-        schnorr = new Schnorr()
-        curve = new Curve()
-    })
-
-    it('should verify a valid proof', () => {
-        // Generate private keys
-        const a = PrivateKey.fromRandom()
-        const b = PrivateKey.fromRandom()
+import Schnorr from "../../primitives/Schnorr";
+import BigNumber from "../../primitives/BigNumber";
+import Curve from "../../primitives/Curve";
+import PrivateKey from "../../primitives/PrivateKey";
+
+describe("Schnorr Zero-Knowledge Proof", () => {
+  let schnorr: Schnorr;
+  let curve: Curve;
+
+  beforeAll(() => {
+    schnorr = new Schnorr();
+    curve = new Curve();
+  });
+
+  it("should verify a valid proof", () => {
+    // Generate private keys
+    const a = PrivateKey.fromRandom();
+    const b = PrivateKey.fromRandom();
 
-        // Compute public keys
-        const A = a.toPublicKey()
-        const B = b.toPublicKey()
+    // Compute public keys
+    const A = a.toPublicKey();
+    const B = b.toPublicKey();
 
-        // Compute shared secret S = B * a
-        const S = B.mul(a)
+    // Compute shared secret S = B * a
+    const S = B.mul(a);
 
-        // Generate proof
-        const proof = schnorr.generateProof(a, A, B, S)
+    // Generate proof
+    const proof = schnorr.generateProof(a, A, B, S);
 
-        // Verify proof
-        const result = schnorr.verifyProof(A, B, S, proof)
-        expect(result).toBe(true)
-    })
+    // Verify proof
+    const result = schnorr.verifyProof(A, B, S, proof);
+    expect(result).toBe(true);
+  });
 
-    it('should fail verification if proof is tampered (R modified)', () => {
-        // Generate private keys
-        const a = PrivateKey.fromRandom()
-        const b = PrivateKey.fromRandom()
+  it("should fail verification if proof is tampered (R modified)", () => {
+    // Generate private keys
+    const a = PrivateKey.fromRandom();
+    const b = PrivateKey.fromRandom();
 
-        // Compute public keys
-        const A = a.toPublicKey()
-        const B = b.toPublicKey()
+    // Compute public keys
+    const A = a.toPublicKey();
+    const B = b.toPublicKey();
 
-        // Compute shared secret S = B * a
-        const S = B.mul(a)
+    // Compute shared secret S = B * a
+    const S = B.mul(a);
 
-        // Generate proof
-        const proof = schnorr.generateProof(a, A, B, S)
+    // Generate proof
+    const proof = schnorr.generateProof(a, A, B, S);
 
-        // Tamper with R
-        const tamperedR = proof.R.add(curve.g)
-        const tamperedProof = { ...proof, R: tamperedR }
+    // Tamper with R
+    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)
-    })
+    // Verify proof
+    const result = schnorr.verifyProof(A, B, S, tamperedProof);
+    expect(result).toBe(false);
+  });
 
-    it('should fail verification if proof is tampered (z modified)', () => {
-        // Generate private keys
-        const a = PrivateKey.fromRandom()
-        const b = PrivateKey.fromRandom()
+  it("should fail verification if proof is tampered (z modified)", () => {
+    // Generate private keys
+    const a = PrivateKey.fromRandom();
+    const b = PrivateKey.fromRandom();
 
-        // Compute public keys
-        const A = a.toPublicKey()
-        const B = b.toPublicKey()
+    // Compute public keys
+    const A = a.toPublicKey();
+    const B = b.toPublicKey();
 
-        // Compute shared secret S = B * a
-        const S = B.mul(a)
+    // Compute shared secret S = B * a
+    const S = B.mul(a);
 
-        // Generate proof
-        const proof = schnorr.generateProof(a, A, B, S)
+    // Generate proof
+    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 }
+    // Tamper with z
+    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)
-    })
+    // Verify proof
+    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()
+  it("should fail verification if proof is tampered (S' modified)", () => {
+    // Generate private keys
+    const a = PrivateKey.fromRandom();
+    const b = PrivateKey.fromRandom();
 
-        // Compute public keys
-        const A = a.toPublicKey()
-        const B = b.toPublicKey()
+    // Compute public keys
+    const A = a.toPublicKey();
+    const B = b.toPublicKey();
 
-        // Compute shared secret S = B * a
-        const S = B.mul(a)
+    // Compute shared secret S = B * a
+    const S = B.mul(a);
 
-        // Generate proof
-        const proof = schnorr.generateProof(a, A, B, S)
+    // Generate proof
+    const proof = schnorr.generateProof(a, A, B, S);
 
-        // Tamper with S'
-        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)
-    })
-
-    it('should fail verification if inputs are tampered (A modified)', () => {
-        // Generate private keys
-        const a = PrivateKey.fromRandom()
-        const b = PrivateKey.fromRandom()
+    // Tamper with S'
+    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);
+  });
+
+  it("should fail verification if inputs are tampered (A modified)", () => {
+    // Generate private keys
+    const a = PrivateKey.fromRandom();
+    const b = PrivateKey.fromRandom();
 
-        // Compute public keys
-        const A = a.toPublicKey()
-        const B = b.toPublicKey()
+    // Compute public keys
+    const A = a.toPublicKey();
+    const B = b.toPublicKey();
 
-        // Compute shared secret S = B * a
-        const S = B.mul(a)
+    // Compute shared secret S = B * a
+    const S = B.mul(a);
 
-        // Generate proof
-        const proof = schnorr.generateProof(a, A, B, S)
+    // Generate proof
+    const proof = schnorr.generateProof(a, A, B, S);
 
-        // Tamper with A
-        const tamperedA = A.add(curve.g)
+    // Tamper with A
+    const tamperedA = A.add(curve.g);
 
-        // Verify proof
-        const result = schnorr.verifyProof(tamperedA, B, S, proof)
-        expect(result).toBe(false)
-    })
+    // Verify proof
+    const result = schnorr.verifyProof(tamperedA, B, S, proof);
+    expect(result).toBe(false);
+  });
 
-    it('should fail verification if inputs are tampered (B modified)', () => {
-        // Generate private keys
-        const a = PrivateKey.fromRandom()
-        const b = PrivateKey.fromRandom()
+  it("should fail verification if inputs are tampered (B modified)", () => {
+    // Generate private keys
+    const a = PrivateKey.fromRandom();
+    const b = PrivateKey.fromRandom();
 
-        // Compute public keys
-        const A = a.toPublicKey()
-        const B = b.toPublicKey()
+    // Compute public keys
+    const A = a.toPublicKey();
+    const B = b.toPublicKey();
 
-        // Compute shared secret S = B * a
-        const S = B.mul(a)
+    // Compute shared secret S = B * a
+    const S = B.mul(a);
 
-        // Generate proof
-        const proof = schnorr.generateProof(a, A, B, S)
-
-        // Tamper with B
-        const tamperedB = B.add(curve.g)
-
-        // Verify proof
-        const result = schnorr.verifyProof(A, tamperedB, S, proof)
-        expect(result).toBe(false)
-    })
-
-    it('should fail verification if inputs are tampered (S modified)', () => {
-        // Generate private keys
-        const a = PrivateKey.fromRandom()
-        const b = PrivateKey.fromRandom()
-
-        // Compute public keys
-        const A = a.toPublicKey()
-        const B = b.toPublicKey()
-
-        // Compute shared secret S = B * a
-        const S = B.mul(a)
-
-        // Generate proof
-        const proof = schnorr.generateProof(a, A, B, S)
-
-        // Tamper with S
-        const tamperedS = S.add(curve.g)
-
-        // Verify proof
-        const result = schnorr.verifyProof(A, B, tamperedS, proof)
-        expect(result).toBe(false)
-    })
-
-    it('should fail verification if using wrong private key', () => {
-        // Generate private keys
-        const a = PrivateKey.fromRandom()
-        const wrongA = PrivateKey.fromRandom()
-        const b = PrivateKey.fromRandom()
-
-        // Compute public keys
-        const A = a.toPublicKey()
-        const B = b.toPublicKey()
-
-        // Compute shared secret S = B * a
-        const S = B.mul(a)
-
-        // Generate proof using wrong private key
-        const proof = schnorr.generateProof(wrongA, A, B, S)
-
-        // Verify proof
-        const result = schnorr.verifyProof(A, B, S, proof)
-        expect(result).toBe(false)
-    })
-
-    it('should fail verification if using wrong public key', () => {
-        // Generate private keys
-        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()
-
-        // Compute shared secret S = B * a
-        const S = B.mul(a)
-
-        // Generate proof
-        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)
-    })
-
-    it('should fail verification if shared secret S is incorrect', () => {
-        // Generate private keys
-        const a = PrivateKey.fromRandom()
-        const b = PrivateKey.fromRandom()
-
-        // Compute public keys
-        const A = a.toPublicKey()
-        const B = b.toPublicKey()
-
-        // Intentionally compute incorrect shared secret
-        const S = B.mul(a).add(curve.g)
-
-        // Generate proof with correct S
-        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)
-    })
-
-    it('should verify a valid proof with fixed keys', () => {
-        // Use fixed private keys for determinism
-        const a = new PrivateKey(new BigNumber('123456789abcdef123456789abcdef123456789abcdef123456789abcdef', 16))
-        const b = new PrivateKey(new BigNumber('abcdef123456789abcdef123456789abcdef123456789abcdef123456789', 16))
-
-        // Compute public keys
-        const A = a.toPublicKey()
-        const B = b.toPublicKey()
-
-        // Compute shared secret S = B * a
-        const S = B.mul(a)
-
-        // Generate proof
-        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()
-    })
-})
+    // Generate proof
+    const proof = schnorr.generateProof(a, A, B, S);
+
+    // Tamper with B
+    const tamperedB = B.add(curve.g);
+
+    // Verify proof
+    const result = schnorr.verifyProof(A, tamperedB, S, proof);
+    expect(result).toBe(false);
+  });
+
+  it("should fail verification if inputs are tampered (S modified)", () => {
+    // Generate private keys
+    const a = PrivateKey.fromRandom();
+    const b = PrivateKey.fromRandom();
+
+    // Compute public keys
+    const A = a.toPublicKey();
+    const B = b.toPublicKey();
+
+    // Compute shared secret S = B * a
+    const S = B.mul(a);
+
+    // Generate proof
+    const proof = schnorr.generateProof(a, A, B, S);
+
+    // Tamper with S
+    const tamperedS = S.add(curve.g);
+
+    // Verify proof
+    const result = schnorr.verifyProof(A, B, tamperedS, proof);
+    expect(result).toBe(false);
+  });
+
+  it("should fail verification if using wrong private key", () => {
+    // Generate private keys
+    const a = PrivateKey.fromRandom();
+    const wrongA = PrivateKey.fromRandom();
+    const b = PrivateKey.fromRandom();
+
+    // Compute public keys
+    const A = a.toPublicKey();
+    const B = b.toPublicKey();
+
+    // Compute shared secret S = B * a
+    const S = B.mul(a);
+
+    // Generate proof using wrong private key
+    const proof = schnorr.generateProof(wrongA, A, B, S);
+
+    // Verify proof
+    const result = schnorr.verifyProof(A, B, S, proof);
+    expect(result).toBe(false);
+  });
+
+  it("should fail verification if using wrong public key", () => {
+    // Generate private keys
+    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();
+
+    // Compute shared secret S = B * a
+    const S = B.mul(a);
+
+    // Generate proof
+    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);
+  });
+
+  it("should fail verification if shared secret S is incorrect", () => {
+    // Generate private keys
+    const a = PrivateKey.fromRandom();
+    const b = PrivateKey.fromRandom();
+
+    // Compute public keys
+    const A = a.toPublicKey();
+    const B = b.toPublicKey();
+
+    // Intentionally compute incorrect shared secret
+    const S = B.mul(a).add(curve.g);
+
+    // Generate proof with correct S
+    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);
+  });
+
+  it("should verify a valid proof with fixed keys", () => {
+    // Use fixed private keys for determinism
+    const a = new PrivateKey(
+      new BigNumber(
+        "123456789abcdef123456789abcdef123456789abcdef123456789abcdef",
+        16
+      )
+    );
+    const b = new PrivateKey(
+      new BigNumber(
+        "abcdef123456789abcdef123456789abcdef123456789abcdef123456789",
+        16
+      )
+    );
+
+    // Compute public keys
+    const A = a.toPublicKey();
+    const B = b.toPublicKey();
+
+    // Compute shared secret S = B * a
+    const S = B.mul(a);
+
+    // Generate proof
+    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();
+  });
+});

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

@@ -1,58 +1,61 @@
-import SymmetricKey from '../../../dist/cjs/src/primitives/SymmetricKey'
-import vectors from './SymmetricKey.vectors'
+import SymmetricKey from "../../primitives/SymmetricKey";
+import vectors from "./SymmetricKey.vectors";
 
 const KEYS: SymmetricKey[] = [
-  new SymmetricKey('5a90d59d829197983a54d887fdea2dc4c38098f00ba3110f2645633b6ea11458', 16),
-  new SymmetricKey('bac6ac492f54d7c997fadc1be593a4ace26ecdf37d30b3ad12f34077fb2629e4', 16),
-  new SymmetricKey('53dcdc6ea6a6910af35a48708f49228e0e6661ea885435080cbabc58e6a14f10', 16)
-]
+  new SymmetricKey(
+    "5a90d59d829197983a54d887fdea2dc4c38098f00ba3110f2645633b6ea11458",
+    16
+  ),
+  new SymmetricKey(
+    "bac6ac492f54d7c997fadc1be593a4ace26ecdf37d30b3ad12f34077fb2629e4",
+    16
+  ),
+  new SymmetricKey(
+    "53dcdc6ea6a6910af35a48708f49228e0e6661ea885435080cbabc58e6a14f10",
+    16
+  ),
+];
 
-const PLAINTEXT_1 = 'hello there'
-const CIPHERTEXT_1 = '8c8d25348dfd5240be833215a123173c64919779ab8845a700a4520311504c168ade2d4b728cc53a254f0aba857caaf6af97453ac2ff61487d0d52'
+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', () => {
+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"));
+    });
+  });
+});