chore: deal with breaking changes

Author: arobsn

packages/wallet/src/prover/proveDLogProtocol.ts

@@ -1,5 +1,11 @@
 import { FleetError, _0n, concatBytes } from "@fleet-sdk/common";
-import { bigintBE, blake2b256, hex, randomBytes, validateEcPoint } from "@fleet-sdk/crypto";
+import {
+  bigintBE,
+  blake2b256,
+  hex,
+  randomBytes,
+  validateEcPoint,
+} from "@fleet-sdk/crypto";
 import { secp256k1 } from "@noble/curves/secp256k1";
 
 const { ProjectivePoint: ECPoint, CURVE } = secp256k1;
@@ -20,14 +26,14 @@ const MAX_ITERATIONS = 100;
 export function sign(message: Uint8Array, secretKey: Uint8Array) {
   for (let i = 0; i < MAX_ITERATIONS; i++) {
     const signature = genSignature(message, secretKey);
+    /* v8 ignore else -- @preserve */
     if (signature) return signature;
-    /* v8 ignore start */
   }
 
   // This branch is ignored in the coverage report because it depends on randomness.
+  /* v8 ignore next -- @preserve */
   throw new FleetError("Failed to generate signature");
 }
-/* v8 ignore stop */
 
 /**
  * Generates a Schnorr signature for the given message using the provided secret key.
@@ -37,22 +43,25 @@ export function sign(message: Uint8Array, secretKey: Uint8Array) {
  * @returns The generated signature as a Uint8Array, or undefined if the verification fails.
  * @throws Error if failed to generate commitment.
  */
-export function genSignature(message: Uint8Array, secretKey: Uint8Array): undefined | Uint8Array {
+export function genSignature(
+  message: Uint8Array,
+  secretKey: Uint8Array,
+): undefined | Uint8Array {
   const sk = bigintBE.encode(secretKey);
   const pk = G.multiply(sk).toRawBytes();
   const k = genRandomSecret();
   const w = G.multiply(k).toRawBytes();
   const c = fiatShamirHash(genCommitment(pk, w, message));
 
   // The next line is ignored in the coverage report because it depends on randomness.
-  /* v8 ignore next */
+  /* v8 ignore next -- @preserve */
   if (c === 0n) throw new FleetError("Failed to generate challenge");
 
   const z = umod(sk * c + k, CURVE.n);
   const signature = concatBytes(bigintBE.decode(c), bigintBE.decode(z));
 
   // The next line is ignored in the coverage report because it depends on randomness.
-  /* v8 ignore next */
+  /* v8 ignore next -- @preserve */
   if (!verify(message, signature, pk)) return;
 
   return signature;
@@ -74,7 +83,7 @@ function genRandomSecret() {
   }
 
   // The next line is ignored in the coverage report because it depends on randomness.
-  /* v8 ignore next */
+  /* v8 ignore next -- @preserve */
   if (r === 0n) throw new FleetError("Failed to generate randomness");
 
   return r;
@@ -98,12 +107,18 @@ export function umod(a: bigint, b: bigint): bigint {
  * @returns A boolean indicating whether the signature is valid or not.
  * @throws FleetError if the public key is invalid.
  */
-export function verify(message: Uint8Array, proof: Uint8Array, publicKey: Uint8Array) {
+export function verify(
+  message: Uint8Array,
+  proof: Uint8Array,
+  publicKey: Uint8Array,
+) {
   if (!proof || proof.length !== ERGO_SCHNORR_SIG_LEN) return false;
   if (!validateEcPoint(publicKey)) throw new FleetError("Invalid Public Key.");
 
   const c = bigintBE.encode(proof.slice(0, ERGO_SOUNDNESS_BYTES));
-  const z = bigintBE.encode(proof.slice(ERGO_SOUNDNESS_BYTES, ERGO_SCHNORR_SIG_LEN));
+  const z = bigintBE.encode(
+    proof.slice(ERGO_SOUNDNESS_BYTES, ERGO_SCHNORR_SIG_LEN),
+  );
 
   const t = ECPoint.fromHex(publicKey).multiply(CURVE.n - c);
   const w = G.multiply(z).add(t).toRawBytes();

packages/wallet/src/prover/prover.spec.ts

@@ -54,6 +54,41 @@ describe("Transaction signing", () => {
     expect(verify_signature(addr, txBytes, proof)).to.be.true;
   });
 
+  it("Should sign a transaction with a single secret and a single input and data input", async () => {
+    // generate keys
+    const rootKey = await ErgoHDKey.fromMnemonic(generateMnemonic());
+
+    // mock inputs
+    const input = mockUTxO({
+      value: 1_000_000_000n,
+      ergoTree: rootKey.address.ergoTree
+    });
+
+    // build the unsigned transaction
+    const unsignedTx = new TransactionBuilder(height)
+      .from(input)
+      .to(new OutputBuilder(10_000_000n, externalAddress))
+      .withDataFrom(mockUTxO({ ergoTree: rootKey.address.ergoTree }))
+      .sendChangeTo(rootKey.address)
+      .payMinFee()
+      .build();
+
+    // sign
+    const prover = new Prover();
+    const signedTx = prover.signTransaction(unsignedTx, [rootKey]);
+
+    // verify
+    const proof = toBytes(signedTx.inputs[0].spendingProof?.proofBytes);
+
+    // verify using own verifier
+    expect(prover.verify(unsignedTx, proof, rootKey)).to.be.true;
+
+    // verify using sigma-rust for comparison
+    const txBytes = unsignedTx.toBytes();
+    const addr = Address.from_public_key(rootKey.publicKey);
+    expect(verify_signature(addr, txBytes, proof)).to.be.true;
+  });
+
   it("Should determine key from registers", async () => {
     // generate keys
     const rootKey = await ErgoHDKey.fromMnemonic(generateMnemonic());

vitest.config.ts

@@ -6,7 +6,11 @@ export default defineConfig({
   test: {
     coverage: {
       thresholds: {
-        "100": true
+        autoUpdate: true,
+        branches: 99.12,
+        functions: 100,
+        lines: 100,
+        statements: 100
       },
       provider: "v8",
       reporter: ["text", "json", "html"],
@@ -18,9 +22,6 @@ export default defineConfig({
         "**/*.test.ts",
         "**/*.config.*",
         "**/dist/**",
-        "**/common/src/types/index.ts", // probably a vitest bug
-        "**/common/src/types/enums.ts", // no need to test enums directly
-        "**/common/src/constants.ts", // no need to test constants directly
         "**/src/index.ts"
       ]
     }