Feat/sp sending

.changeset/ripe-turkeys-dance.md

@@ -0,0 +1,15 @@
+---
+"@caravan/psbt": minor
+---
+
+Add BIP375 silent payment sending support to PsbtV2
+
+- Add PSBT_OUT_SP_V0_INFO and PSBT_OUT_SP_V0_LABEL getters and methods
+- Add PSBT_GLOBAL_SP_ECDH_SHARE, PSBT_GLOBAL_SP_DLEQ getters and methods
+- Add PSBT_IN_SP_ECDH_SHARE, PSBT_IN_SP_DLEQ getters and methods
+- Add silentPayment option to addOutput() for SP output construction
+- Add computeSilentPaymentOutputScripts() implementing BIP352 derivation
+- Add hasSilentPaymentOutputs, hasAllSPOutputScripts, hasCompleteECDHCoverage predicates
+- Add eligibleIndices, sumECDHShares, computeInputHash, deriveSilentPaymentOutput to silentpayment.ts
+- Update isReadyForSigner to enforce BIP375 signing rules
+- Update getTransactionId() for BIP375 unique identification

packages/caravan-psbt/src/psbtv2/dleq.test.ts

@@ -0,0 +1,208 @@
+import { describe, expect, it } from "vitest";
+import { secp256k1 } from "@noble/curves/secp256k1";
+
+import {
+  generateDLEQProof,
+  multiplyCompressedPoint,
+  verifyDLEQProof,
+} from "./dleq";
+function hex(s: string): Buffer {
+  return Buffer.from(s, "hex");
+}
+
+function pubkeyFromSecret(secret: Buffer): Buffer {
+  return Buffer.from(
+    secp256k1.ProjectivePoint.BASE.multiply(
+      BigInt(`0x${secret.toString("hex")}`),
+    ).toRawBytes(true),
+  );
+}
+
+describe("BIP374 DLEQ", () => {
+  it("generates a proof that verifies", () => {
+    const secret = hex(
+      "0000000000000000000000000000000000000000000000000000000000000001",
+    );
+    const baseSecret = hex(
+      "0000000000000000000000000000000000000000000000000000000000000002",
+    );
+    const auxRand = Buffer.alloc(32, 0);
+
+    const publicKey = pubkeyFromSecret(secret);
+    const basePoint = pubkeyFromSecret(baseSecret);
+    const result = multiplyCompressedPoint(basePoint, secret);
+
+    const proof = generateDLEQProof({
+      secret,
+      basePoint,
+      auxRand,
+    });
+
+    expect(proof.length).toBe(64);
+
+    expect(
+      verifyDLEQProof({
+        proof,
+        publicKey,
+        basePoint,
+        result,
+      }),
+    ).toBe(true);
+  });
+
+  it("fails verification with the wrong public key", () => {
+    const secret = hex(
+      "0000000000000000000000000000000000000000000000000000000000000001",
+    );
+    const wrongSecret = hex(
+      "0000000000000000000000000000000000000000000000000000000000000003",
+    );
+    const baseSecret = hex(
+      "0000000000000000000000000000000000000000000000000000000000000002",
+    );
+
+    const basePoint = pubkeyFromSecret(baseSecret);
+    const result = multiplyCompressedPoint(basePoint, secret);
+    const wrongPublicKey = pubkeyFromSecret(wrongSecret);
+
+    const proof = generateDLEQProof({
+      secret,
+      basePoint,
+      auxRand: Buffer.alloc(32, 0),
+    });
+
+    expect(
+      verifyDLEQProof({
+        proof,
+        publicKey: wrongPublicKey,
+        basePoint,
+        result,
+      }),
+    ).toBe(false);
+  });
+
+  it("fails verification with the wrong base point", () => {
+    const secret = hex(
+      "0000000000000000000000000000000000000000000000000000000000000001",
+    );
+    const baseSecret = hex(
+      "0000000000000000000000000000000000000000000000000000000000000002",
+    );
+    const wrongBaseSecret = hex(
+      "0000000000000000000000000000000000000000000000000000000000000003",
+    );
+
+    const publicKey = pubkeyFromSecret(secret);
+    const basePoint = pubkeyFromSecret(baseSecret);
+    const wrongBasePoint = pubkeyFromSecret(wrongBaseSecret);
+    const result = multiplyCompressedPoint(basePoint, secret);
+
+    const proof = generateDLEQProof({
+      secret,
+      basePoint,
+      auxRand: Buffer.alloc(32, 0),
+    });
+
+    expect(
+      verifyDLEQProof({
+        proof,
+        publicKey,
+        basePoint: wrongBasePoint,
+        result,
+      }),
+    ).toBe(false);
+  });
+
+  it("fails verification with the wrong ECDH result", () => {
+    const secret = hex(
+      "0000000000000000000000000000000000000000000000000000000000000001",
+    );
+    const baseSecret = hex(
+      "0000000000000000000000000000000000000000000000000000000000000002",
+    );
+    const wrongSecret = hex(
+      "0000000000000000000000000000000000000000000000000000000000000003",
+    );
+
+    const publicKey = pubkeyFromSecret(secret);
+    const basePoint = pubkeyFromSecret(baseSecret);
+    const wrongResult = multiplyCompressedPoint(basePoint, wrongSecret);
+
+    const proof = generateDLEQProof({
+      secret,
+      basePoint,
+      auxRand: Buffer.alloc(32, 0),
+    });
+
+    expect(
+      verifyDLEQProof({
+        proof,
+        publicKey,
+        basePoint,
+        result: wrongResult,
+      }),
+    ).toBe(false);
+  });
+
+  it("fails verification when proof bytes are mutated", () => {
+    const secret = hex(
+      "0000000000000000000000000000000000000000000000000000000000000001",
+    );
+    const baseSecret = hex(
+      "0000000000000000000000000000000000000000000000000000000000000002",
+    );
+
+    const publicKey = pubkeyFromSecret(secret);
+    const basePoint = pubkeyFromSecret(baseSecret);
+    const result = multiplyCompressedPoint(basePoint, secret);
+
+    const proof = generateDLEQProof({
+      secret,
+      basePoint,
+      auxRand: Buffer.alloc(32, 0),
+    });
+
+    const mutated = Buffer.from(proof);
+    mutated[0] ^= 1;
+
+    expect(
+      verifyDLEQProof({
+        proof: mutated,
+        publicKey,
+        basePoint,
+        result,
+      }),
+    ).toBe(false);
+  });
+
+  it("rejects malformed proof lengths", () => {
+    const secret = hex(
+      "0000000000000000000000000000000000000000000000000000000000000001",
+    );
+    const baseSecret = hex(
+      "0000000000000000000000000000000000000000000000000000000000000002",
+    );
+
+    const publicKey = pubkeyFromSecret(secret);
+    const basePoint = pubkeyFromSecret(baseSecret);
+    const result = multiplyCompressedPoint(basePoint, secret);
+
+    expect(
+      verifyDLEQProof({
+        proof: Buffer.alloc(63),
+        publicKey,
+        basePoint,
+        result,
+      }),
+    ).toBe(false);
+
+    expect(
+      verifyDLEQProof({
+        proof: Buffer.alloc(65),
+        publicKey,
+        basePoint,
+        result,
+      }),
+    ).toBe(false);
+  });
+});