@buildonspark/spark-sdk 0.3.8 → 0.4.0

package/src/services/deposit.ts

@@ -12,15 +12,13 @@ import {
   StartDepositTreeCreationResponse,
 } from "../proto/spark.js";
 import { KeyDerivation } from "../signer/types.js";
-import { getSigHashFromTx, getTxId } from "../utils/bitcoin.js";
+import { getSigHashFromTx } from "../utils/bitcoin.js";
 import { subtractPublicKeys } from "../utils/keys.js";
 import { getNetwork } from "../utils/network.js";
 import { proofOfPossessionMessageHashForDepositAddress } from "../utils/proof.js";
 import {
-  createRefundTxs,
-  createRootTx,
-  INITIAL_DIRECT_SEQUENCE,
-  INITIAL_SEQUENCE,
+  createInitialTimelockRefundTxs,
+  createRootNodeTx,
 } from "../utils/transaction.js";
 import { WalletConfigService } from "./config.js";
 import { ConnectionManager } from "./connection/connection.js";
@@ -250,28 +248,10 @@ export class DepositService {
         expected: "Valid output index",
       });
     }
-    const script = output.script;
-    const amount = output.amount;
-    if (!script || !amount) {
-      throw new ValidationError("No script or amount found in deposit tx", {
-        field: "output",
-        value: output,
-        expected: "Output with script and amount",
-      });
-    }
 
-    const depositOutPoint = {
-      txid: hexToBytes(getTxId(depositTx)),
-      index: vout,
-    };
-    const depositTxOut = {
-      script,
-      amount,
-    };
-
-    const [cpfpRootTx, directRootTx] = createRootTx(
-      depositOutPoint,
-      depositTxOut,
+    const { nodeTx: cpfpRootTx, directNodeTx: directRootTx } = createRootNodeTx(
+      depositTx,
+      vout,
     );
 
     // Create nonce commitments for root transactions
@@ -287,14 +267,10 @@ export class DepositService {
     const signingPubKey =
       await this.config.signer.getPublicKeyFromDerivation(keyDerivation);
 
-    // Create refund transactions (CPFP and direct)
     const { cpfpRefundTx, directRefundTx, directFromCpfpRefundTx } =
-      createRefundTxs({
-        sequence: INITIAL_SEQUENCE,
-        directSequence: INITIAL_DIRECT_SEQUENCE,
-        input: { txid: hexToBytes(getTxId(cpfpRootTx)), index: 0 },
-        directInput: { txid: hexToBytes(getTxId(directRootTx)), index: 0 },
-        amountSats: amount,
+      createInitialTimelockRefundTxs({
+        nodeTx: cpfpRootTx,
+        directNodeTx: directRootTx,
         receivingPubkey: signingPubKey,
         network: this.config.getNetwork(),
       });
@@ -675,16 +651,7 @@ export class DepositService {
       });
     }
 
-    const depositOutPoint = {
-      txid: hexToBytes(getTxId(depositTx)),
-      index: vout,
-    };
-    const depositTxOut = {
-      script,
-      amount,
-    };
-
-    const [cpfpRootTx, _] = createRootTx(depositOutPoint, depositTxOut);
+    const { nodeTx: cpfpRootTx } = createRootNodeTx(depositTx, vout);
 
     // Create nonce commitments for root transactions
     const cpfpRootNonceCommitment =
@@ -696,11 +663,8 @@ export class DepositService {
     const signingPubKey =
       await this.config.signer.getPublicKeyFromDerivation(keyDerivation);
 
-    // Create refund transactions (CPFP and direct)
-    const { cpfpRefundTx } = createRefundTxs({
-      sequence: INITIAL_SEQUENCE,
-      input: { txid: hexToBytes(getTxId(cpfpRootTx)), index: 0 },
-      amountSats: amount,
+    const { cpfpRefundTx } = createInitialTimelockRefundTxs({
+      nodeTx: cpfpRootTx,
       receivingPubkey: signingPubKey,
       network: this.config.getNetwork(),
     });

package/src/services/signing.ts

@@ -1,26 +1,24 @@
-import { hexToBytes } from "@noble/curves/utils";
 import { Transaction } from "@scure/btc-signer";
-import { TransactionInput } from "@scure/btc-signer/psbt";
 import { ValidationError } from "../errors/types.js";
 import { SigningCommitment } from "../proto/common.js";
 import {
   RequestedSigningCommitments,
   UserSignedTxSigningJob,
 } from "../proto/spark.js";
+import { getSigHashFromTx, getTxFromRawTxBytes } from "../utils/bitcoin.js";
+import { createRefundTxsForLightning } from "../utils/htlc-transactions.js";
+import { getNetwork } from "../utils/network.js";
 import {
-  getSigHashFromTx,
-  getTxFromRawTxBytes,
-  getTxId,
-} from "../utils/bitcoin.js";
-import {
-  createRefundTxs,
+  createDecrementedTimelockRefundTxs,
+  getCurrentTimelock,
   getNextHTLCTransactionSequence,
-  getNextTransactionSequence,
 } from "../utils/transaction.js";
-import { createRefundTxsForLightning } from "../utils/htlc-transactions.js";
-import { getNetwork } from "../utils/network.js";
 import { WalletConfigService } from "./config.js";
-import type { LeafKeyTweak } from "./transfer.js";
+import type {
+  LeafKeyTweak,
+  SigningJobType,
+  SigningJobWithOptionalNonce,
+} from "./transfer.js";
 
 export class SigningService {
   private readonly config: WalletConfigService;
@@ -105,24 +103,9 @@ export class SigningService {
       }
 
       const nodeTx = getTxFromRawTxBytes(leaf.leaf.nodeTx);
-      const cpfpNodeOutPoint: TransactionInput = {
-        txid: hexToBytes(getTxId(nodeTx)),
-        index: 0,
-      };
 
       const currRefundTx = getTxFromRawTxBytes(leaf.leaf.refundTx);
 
-      const sequence = currRefundTx.getInput(0).sequence;
-      if (!sequence) {
-        throw new ValidationError("Invalid refund transaction", {
-          field: "sequence",
-          value: currRefundTx.getInput(0),
-          expected: "Non-null sequence",
-        });
-      }
-      const { nextSequence, nextDirectSequence } =
-        getNextTransactionSequence(sequence);
-
       const amountSats = currRefundTx.getOutput(0).amount;
       if (amountSats === undefined) {
         throw new ValidationError("Invalid refund transaction", {
@@ -133,22 +116,24 @@ export class SigningService {
       }
 
       let directNodeTx: Transaction | undefined;
-      let directNodeOutPoint: TransactionInput | undefined;
       if (leaf.leaf.directTx.length > 0) {
         directNodeTx = getTxFromRawTxBytes(leaf.leaf.directTx);
-        directNodeOutPoint = {
-          txid: hexToBytes(getTxId(directNodeTx)),
-          index: 0,
-        };
+      }
+
+      const currentSequence = currRefundTx.getInput(0).sequence;
+      if (!currentSequence) {
+        throw new ValidationError("Invalid refund transaction", {
+          field: "sequence",
+          value: currRefundTx.getInput(0),
+          expected: "Non-null sequence",
+        });
       }
 
       const { cpfpRefundTx, directRefundTx, directFromCpfpRefundTx } =
-        createRefundTxs({
-          sequence: nextSequence,
-          directSequence: nextDirectSequence,
-          input: cpfpNodeOutPoint,
-          directInput: directNodeOutPoint,
-          amountSats,
+        createDecrementedTimelockRefundTxs({
+          nodeTx: nodeTx,
+          directNodeTx: directNodeTx,
+          sequence: currentSequence,
           receivingPubkey: receiverIdentityPubkey,
           network: this.config.getNetwork(),
         });
@@ -167,7 +152,8 @@ export class SigningService {
 
       cpfpLeafSigningJobs.push(...signingJobs);
 
-      if (directRefundTx) {
+      const isZeroNode = getCurrentTimelock(nodeTx.getInput(0).sequence);
+      if (directRefundTx && !isZeroNode) {
         if (!directNodeTx) {
           throw new ValidationError(
             "Direct node transaction undefined while direct refund transaction is defined",
@@ -193,16 +179,6 @@ export class SigningService {
       }
 
       if (directFromCpfpRefundTx) {
-        if (!directNodeTx) {
-          throw new ValidationError(
-            "Direct node transaction undefined while direct from CPFP refund transaction is defined",
-            {
-              field: "directNodeTx",
-              value: directNodeTx,
-              expected: "Non-null direct node transaction",
-            },
-          );
-        }
         const refundSighash = getSigHashFromTx(
           directFromCpfpRefundTx,
           0,
@@ -358,4 +334,41 @@ export class SigningService {
       directFromCpfpLeafSigningJobs,
     };
   }
+
+  async signSigningJobs(
+    signingJobs: (SigningJobWithOptionalNonce & RequestedSigningCommitments)[],
+  ): Promise<Map<SigningJobType, UserSignedTxSigningJob>> {
+    const userSignedTxSigningJobs: Map<SigningJobType, UserSignedTxSigningJob> =
+      new Map();
+
+    for (const signingJob of signingJobs) {
+      const rawTx = getTxFromRawTxBytes(signingJob.rawTx);
+      const txOut = signingJob.parentTxOut;
+      const rawTxSighash = getSigHashFromTx(rawTx, 0, txOut);
+      const userSignature = await this.config.signer.signFrost({
+        message: rawTxSighash,
+        keyDerivation: signingJob.keyDerivation,
+        publicKey: signingJob.signingPublicKey,
+        verifyingKey: signingJob.verifyingKey,
+        selfCommitment: signingJob.signingNonceCommitment,
+        statechainCommitments: signingJob.signingNonceCommitments,
+        adaptorPubKey: new Uint8Array(),
+      });
+
+      const userSignedTxSigningJob: UserSignedTxSigningJob = {
+        leafId: signingJob.leafId,
+        signingPublicKey: signingJob.signingPublicKey,
+        rawTx: rawTx.toBytes(),
+        signingNonceCommitment: signingJob.signingNonceCommitment.commitment,
+        signingCommitments: {
+          signingCommitments: signingJob.signingNonceCommitments,
+        },
+        userSignature,
+      };
+
+      userSignedTxSigningJobs.set(signingJob.type, userSignedTxSigningJob);
+    }
+
+    return userSignedTxSigningJobs;
+  }
 }