Merge pull request #167 from fleet-sdk/arobsn/i161

Add `SignedTransaction` serialization

Author: arobsn

.changeset/smooth-dragons-draw.md

@@ -0,0 +1,7 @@
+---
+"@fleet-sdk/serializer": patch
+"@fleet-sdk/common": patch
+"@fleet-sdk/wallet": patch
+---
+
+Add `SignedTransaction` serialization

packages/common/src/types/inputs.ts

@@ -13,7 +13,7 @@ export type ProverResult = {
 
 export type SignedInput = {
   readonly boxId: BoxId;
-  readonly spendingProof: ProverResult;
+  readonly spendingProof: ProverResult | null;
 };
 
 export type UnsignedInput = {

packages/common/src/types/transactions.ts

@@ -28,5 +28,5 @@ export type SignedTransaction = {
   readonly id: TransactionId;
   readonly inputs: SignedInput[];
   readonly dataInputs: DataInput[];
-  readonly outputs: Box<string>[];
+  readonly outputs: Box<Amount>[];
 };

packages/serializer/src/_test-vectors/signedTransactions.json

@@ -1,13 +1,36 @@
 import { blake2b256, hex } from "@fleet-sdk/crypto";
-import { describe, expect, it } from "vitest";
+import { describe, expect, it, test } from "vitest";
 import { unsignedTransactionVectors } from "../_test-vectors/transactionVectors";
 import { serializeTransaction } from "./transactionSerializer";
+import signedTransactionVectors from "../_test-vectors/signedTransactions.json";
+import { isEmpty } from "@fleet-sdk/common";
 
 describe("Transaction serializer", () => {
-  it.each(unsignedTransactionVectors)("Should serialize [$name]", (tv) => {
-    const bytes = serializeTransaction(tv.json).toBytes();
+  test.each(unsignedTransactionVectors)(
+    "Should serialize unsigned transaction [$name]",
+    (tv) => {
+      const bytes = serializeTransaction(tv.json).toBytes();
 
-    expect(hex.encode(bytes)).toBe(tv.hex);
-    expect(hex.encode(blake2b256(bytes))).toBe(tv.hash);
+      expect(hex.encode(bytes)).toBe(tv.hex);
+      expect(hex.encode(blake2b256(bytes))).toBe(tv.hash);
+    }
+  );
+
+  test.each(signedTransactionVectors)("should serialize signed transaction", (tv) => {
+    expect(hex.encode(serializeTransaction(tv.json).toBytes())).toBe(tv.hex);
+  });
+
+  it("should serialize if input extension is undefined", () => {
+    const tv = unsignedTransactionVectors[0];
+    const tx = structuredClone(tv.json);
+
+    for (const input of tx.inputs) {
+      if (isEmpty(input.extension)) {
+        // @ts-expect-error intentionally setting extension to undefined
+        input.extension = undefined;
+      }
+    }
+
+    expect(hex.encode(serializeTransaction(tx).toBytes())).toEqual(tv.hex);
   });
 });

packages/serializer/src/serializers/transactionSerializer.spec.ts

@@ -1,21 +1,26 @@
-import {
-  type Amount,
-  type BoxCandidate,
-  type DataInput,
-  isDefined,
-  type UnsignedInput
+import type {
+  Amount,
+  BoxCandidate,
+  DataInput,
+  SignedInput,
+  SignedTransaction,
+  UnsignedInput
 } from "@fleet-sdk/common";
+import { isDefined } from "@fleet-sdk/common";
 import { SigmaByteWriter } from "../coders";
 import { serializeBox } from "./boxSerializer";
+import { hex } from "@fleet-sdk/crypto";
 
 export type MinimalUnsignedTransaction = {
-  inputs: readonly UnsignedInput[];
-  dataInputs: readonly DataInput[];
-  outputs: readonly BoxCandidate<Amount>[];
+  inputs: UnsignedInput[];
+  dataInputs: DataInput[];
+  outputs: BoxCandidate<Amount>[];
 };
 
+type Nullish<T> = T | null | undefined;
+
 export function serializeTransaction(
-  transaction: MinimalUnsignedTransaction
+  transaction: MinimalUnsignedTransaction | SignedTransaction
 ): SigmaByteWriter {
   const writer = new SigmaByteWriter(100_000);
 
@@ -39,16 +44,43 @@ export function serializeTransaction(
   return writer;
 }
 
-function writeInput(writer: SigmaByteWriter, input: UnsignedInput): void {
+function writeInput(writer: SigmaByteWriter, input: UnsignedInput | SignedInput): void {
   writer.writeHex(input.boxId);
-  writer.write(0); // empty proof
+
+  if (isSignedInput(input)) {
+    writeProof(writer, input.spendingProof?.proofBytes);
+    writeExtension(writer, input.spendingProof?.extension);
+    return;
+  }
+
+  writeProof(writer, null);
   writeExtension(writer, input.extension);
 }
 
+function isSignedInput(input: UnsignedInput | SignedInput): input is SignedInput {
+  return (input as SignedInput).spendingProof !== undefined;
+}
+
+function writeProof(writer: SigmaByteWriter, proof: Nullish<string>): void {
+  if (!proof) {
+    writer.write(0);
+    return;
+  }
+
+  const bytes = hex.decode(proof);
+  writer.writeVLQ(bytes.length);
+  writer.writeBytes(bytes);
+}
+
 function writeExtension(
   writer: SigmaByteWriter,
-  extension: Record<string, string | undefined>
+  extension: Nullish<Record<string, string | undefined>>
 ): void {
+  if (!extension) {
+    writer.write(0);
+    return;
+  }
+
   const keys = Object.keys(extension);
   let length = 0;
 

packages/serializer/src/serializers/transactionSerializer.ts

@@ -17,6 +17,8 @@ import { Prover } from "./prover";
 const height = 1234209;
 const externalAddress = "9gN8gmyaDBuWPZLn8zj9uZxnLUj4TE9rtedtLGNjf6cUhTmoTwc";
 
+const toBytes = (input: string | undefined | null) => hex.decode(input ?? "");
+
 describe("Transaction signing", () => {
   it("Should sign a transaction with a single secret and a single input", async () => {
     // generate keys
@@ -41,7 +43,7 @@ describe("Transaction signing", () => {
     const signedTx = prover.signTransaction(unsignedTx, [rootKey]);
 
     // verify
-    const proof = hex.decode(signedTx.inputs[0].spendingProof.proofBytes);
+    const proof = toBytes(signedTx.inputs[0].spendingProof?.proofBytes);
 
     // verify using own verifier
     expect(prover.verify(unsignedTx, proof, rootKey)).to.be.true;
@@ -79,7 +81,7 @@ describe("Transaction signing", () => {
     const signedTx = prover.signTransaction(unsignedTx, [rootKey, child1]);
 
     // verify
-    const proof = hex.decode(signedTx.inputs[0].spendingProof.proofBytes);
+    const proof = toBytes(signedTx.inputs[0].spendingProof?.proofBytes);
 
     // verify using own verifier
     expect(prover.verify(unsignedTx, proof, child1)).to.be.true;
@@ -119,7 +121,7 @@ describe("Transaction signing", () => {
     ]);
 
     // verify
-    const proof = hex.decode(signedTx.inputs[0].spendingProof.proofBytes);
+    const proof = toBytes(signedTx.inputs[0].spendingProof?.proofBytes);
 
     // verify using own verifier
     expect(prover.verify(unsignedTx, proof, rootKey)).to.be.true;
@@ -161,8 +163,8 @@ describe("Transaction signing", () => {
 
     // verify
     const txBytes = unsignedTx.toBytes();
-    const proof0 = hex.decode(signedTx.inputs[0].spendingProof.proofBytes);
-    const proof1 = hex.decode(signedTx.inputs[1].spendingProof.proofBytes);
+    const proof0 = toBytes(signedTx.inputs[0].spendingProof?.proofBytes);
+    const proof1 = toBytes(signedTx.inputs[1].spendingProof?.proofBytes);
 
     // verify using own verifier
     expect(prover.verify(txBytes, proof0, rootKey)).to.be.true;
@@ -208,9 +210,9 @@ describe("Transaction signing", () => {
 
     // verify
     const txBytes = unsignedTx.toBytes();
-    const proof0 = hex.decode(signedTx.inputs[0].spendingProof.proofBytes);
-    const proof1 = hex.decode(signedTx.inputs[1].spendingProof.proofBytes);
-    const proof2 = hex.decode(signedTx.inputs[2].spendingProof.proofBytes);
+    const proof0 = toBytes(signedTx.inputs[0].spendingProof?.proofBytes);
+    const proof1 = toBytes(signedTx.inputs[1].spendingProof?.proofBytes);
+    const proof2 = toBytes(signedTx.inputs[2].spendingProof?.proofBytes);
 
     expect(prover.verify(txBytes, proof0, rootKey)).to.be.false; // inverted by the mapper
     expect(prover.verify(txBytes, proof0, child2)).to.be.true; // inverted by the mapper
@@ -250,8 +252,8 @@ describe("Transaction signing", () => {
 
     // verify
     const txBytes = unsignedTx.toBytes();
-    const proof0 = hex.decode(signedTx.inputs[0].spendingProof.proofBytes);
-    const proof1 = hex.decode(signedTx.inputs[1].spendingProof.proofBytes);
+    const proof0 = toBytes(signedTx.inputs[0].spendingProof?.proofBytes);
+    const proof1 = toBytes(signedTx.inputs[1].spendingProof?.proofBytes);
 
     expect(prover.verify(txBytes, proof0, rootKey)).to.be.false; // inverted by the mapper
     expect(prover.verify(txBytes, proof0, child1)).to.be.true; // inverted by the mapper
@@ -319,14 +321,14 @@ describe("Transaction signing", () => {
 
     // verify all inputs using own verifier
     for (const input of signedTx.inputs) {
-      const proof = hex.decode(input.spendingProof.proofBytes);
+      const proof = toBytes(input.spendingProof?.proofBytes);
       expect(prover.verify(txBytes, proof, rootKey)).to.be.true;
     }
 
     // verify all inputs using sigma-rust for comparison
     const addr = Address.from_public_key(rootKey.publicKey);
     for (const input of signedTx.inputs) {
-      const proof = hex.decode(input.spendingProof.proofBytes);
+      const proof = toBytes(input.spendingProof?.proofBytes);
       expect(verify_signature(addr, txBytes, proof)).to.be.true;
     }
   });
@@ -380,42 +382,42 @@ describe("Transaction proof verification", () => {
 
   it("Should verify from bytes", () => {
     const prover = new Prover();
-    const proof = signedTx.inputs[0].spendingProof.proofBytes;
+    const proof = signedTx.inputs[0].spendingProof?.proofBytes ?? "";
 
     expect(prover.verify(unsignedTx.toBytes(), proof, rootKey)).to.be.true;
   });
 
   it("Should verify from hex", () => {
     const prover = new Prover();
-    const proof = signedTx.inputs[0].spendingProof.proofBytes;
+    const proof = signedTx.inputs[0].spendingProof?.proofBytes ?? "";
 
     expect(prover.verify(hex.encode(unsignedTx.toBytes()), proof, rootKey)).to.be.true;
   });
 
   it("Should verify from SignedTransaction", () => {
     const prover = new Prover();
-    const proof = signedTx.inputs[0].spendingProof.proofBytes;
+    const proof = signedTx.inputs[0].spendingProof?.proofBytes ?? "";
 
     expect(prover.verify(signedTx, proof, rootKey)).to.be.true;
   });
 
   it("Should verify from ErgoUnsignedTransaction", () => {
     const prover = new Prover();
-    const proof = signedTx.inputs[0].spendingProof.proofBytes;
+    const proof = signedTx.inputs[0].spendingProof?.proofBytes ?? "";
 
     expect(prover.verify(unsignedTx, proof, rootKey)).to.be.true;
   });
 
   it("Should verify from EIP12UnsignedTransaction", () => {
     const prover = new Prover();
-    const proof = signedTx.inputs[0].spendingProof.proofBytes;
+    const proof = signedTx.inputs[0].spendingProof?.proofBytes ?? "";
 
     expect(prover.verify(unsignedTx.toEIP12Object(), proof, rootKey)).to.be.true;
   });
 
   it("Should verify from PlainObject", () => {
     const prover = new Prover();
-    const proof = signedTx.inputs[0].spendingProof.proofBytes;
+    const proof = signedTx.inputs[0].spendingProof?.proofBytes ?? "";
 
     expect(prover.verify(unsignedTx.toPlainObject(), proof, rootKey)).to.be.true;
   });

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

@@ -83,8 +83,12 @@ export class Prover implements ISigmaProver {
         ...message,
         inputs: message.inputs.map((input) => ({
           ...input,
+          spendingProof: undefined, // remove spendingProof from inputs
           extension:
-            "extension" in input ? input.extension : input.spendingProof.extension
+            "extension" in input
+              ? input.extension
+              : /* v8 ignore next */
+                (input.spendingProof?.extension ?? {})
         }))
       }).toBytes();
     }