@buildonspark/spark-sdk 0.3.7 → 0.3.9

package/src/services/coop-exit.ts

@@ -7,15 +7,9 @@ import {
   LeafRefundTxSigningJob,
   Transfer,
 } from "../proto/spark.js";
-import {
-  getP2TRScriptFromPublicKey,
-  getTxFromRawTxBytes,
-} from "../utils/bitcoin.js";
+import { getTxFromRawTxBytes } from "../utils/bitcoin.js";
 import { Network } from "../utils/network.js";
-import {
-  getNextTransactionSequence,
-  maybeApplyFee,
-} from "../utils/transaction.js";
+import { createConnectorRefundTxs } from "../utils/transaction.js";
 import { WalletConfigService } from "./config.js";
 import { ConnectionManager } from "./connection/connection.js";
 import { SigningService } from "./signing.js";
@@ -80,93 +74,6 @@ export class CoopExitService extends BaseTransferService {
     };
   }
 
-  private createConnectorRefundTransactions(
-    sequence: number,
-    directSequence: number,
-    cpfpNodeOutPoint: TransactionInput,
-    directNodeOutPoint: TransactionInput | undefined,
-    connectorOutput: TransactionInput,
-    amountSats: bigint,
-    receiverPubKey: Uint8Array,
-  ): {
-    cpfpRefundTx: Transaction;
-    directRefundTx?: Transaction;
-    directFromCpfpRefundTx?: Transaction;
-  } {
-    // Create CPFP refund transaction
-    const cpfpRefundTx = new Transaction();
-    if (!cpfpNodeOutPoint.txid || cpfpNodeOutPoint.index === undefined) {
-      throw new ValidationError("Invalid CPFP node outpoint", {
-        field: "cpfpNodeOutPoint",
-        value: { txid: cpfpNodeOutPoint.txid, index: cpfpNodeOutPoint.index },
-        expected: "Both txid and index must be defined",
-      });
-    }
-    cpfpRefundTx.addInput({
-      txid: cpfpNodeOutPoint.txid,
-      index: cpfpNodeOutPoint.index,
-      sequence,
-    });
-
-    cpfpRefundTx.addInput(connectorOutput);
-    const receiverScript = getP2TRScriptFromPublicKey(
-      receiverPubKey,
-      this.config.getNetwork(),
-    );
-
-    cpfpRefundTx.addOutput({
-      script: receiverScript,
-      amount: amountSats,
-    });
-
-    // Create direct refund transaction
-    let directRefundTx: Transaction | undefined;
-    let directFromCpfpRefundTx: Transaction | undefined;
-    if (directNodeOutPoint) {
-      if (!directNodeOutPoint.txid || directNodeOutPoint.index === undefined) {
-        throw new ValidationError("Invalid direct node outpoint", {
-          field: "directNodeOutPoint",
-          value: {
-            txid: directNodeOutPoint.txid,
-            index: directNodeOutPoint.index,
-          },
-          expected: "Both txid and index must be defined",
-        });
-      }
-      directRefundTx = new Transaction();
-      directRefundTx.addInput({
-        txid: directNodeOutPoint.txid,
-        index: directNodeOutPoint.index,
-        sequence: directSequence,
-      });
-
-      directRefundTx.addInput(connectorOutput);
-      directRefundTx.addOutput({
-        script: receiverScript,
-        amount: maybeApplyFee(amountSats),
-      });
-
-      directFromCpfpRefundTx = new Transaction();
-      directFromCpfpRefundTx.addInput({
-        txid: cpfpNodeOutPoint.txid,
-        index: cpfpNodeOutPoint.index,
-        sequence: directSequence,
-      });
-
-      directFromCpfpRefundTx.addInput(connectorOutput);
-      directFromCpfpRefundTx.addOutput({
-        script: receiverScript,
-        amount: maybeApplyFee(amountSats),
-      });
-    }
-
-    return {
-      cpfpRefundTx,
-      directRefundTx,
-      directFromCpfpRefundTx,
-    };
-  }
-
   private async signCoopExitRefunds(
     leaves: LeafKeyTweak[],
     exitTxId: Uint8Array,
@@ -213,18 +120,31 @@ export class CoopExitService extends BaseTransferService {
           expected: "Valid connector output",
         });
       }
+
+      const nodeTx = getTxFromRawTxBytes(leaf.leaf.nodeTx);
+
+      let directNodeTx: Transaction | undefined;
+      if (leaf.leaf.directTx.length > 0) {
+        directNodeTx = getTxFromRawTxBytes(leaf.leaf.directTx);
+      }
+
       const currentRefundTx = getTxFromRawTxBytes(leaf.leaf.refundTx);
+      if (!currentRefundTx) {
+        throw new ValidationError("Invalid refund transaction", {
+          field: "currentRefundTx",
+          value: currentRefundTx,
+          expected: "Non-null refund transaction",
+        });
+      }
 
-      const sequence = currentRefundTx.getInput(0).sequence;
-      if (!sequence) {
+      const currentSequence = currentRefundTx.getInput(0).sequence;
+      if (!currentSequence) {
         throw new ValidationError("Invalid refund transaction", {
           field: "sequence",
           value: currentRefundTx.getInput(0),
           expected: "Non-null sequence",
         });
       }
-      const { nextSequence, nextDirectSequence } =
-        getNextTransactionSequence(sequence);
 
       let currentDirectRefundTx: Transaction | undefined;
       if (leaf.leaf.directRefundTx.length > 0) {
@@ -232,15 +152,14 @@ export class CoopExitService extends BaseTransferService {
       }
 
       const { cpfpRefundTx, directRefundTx, directFromCpfpRefundTx } =
-        this.createConnectorRefundTransactions(
-          nextSequence,
-          nextDirectSequence,
-          currentRefundTx.getInput(0),
-          currentDirectRefundTx?.getInput(0),
+        createConnectorRefundTxs({
+          nodeTx,
+          directNodeTx,
+          sequence: currentSequence,
           connectorOutput,
-          BigInt(leaf.leaf.value),
-          receiverPubKey,
-        );
+          receivingPubkey: receiverPubKey,
+          network: this.config.getNetwork(),
+        });
 
       const signingNonceCommitment =
         await this.config.signer.getRandomSigningCommitment();

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/lightning.ts

@@ -15,6 +15,7 @@ import {
   ProvidePreimageResponse,
   QueryUserSignedRefundsResponse,
   Transfer,
+  StartTransferRequest,
   UserSignedRefund,
 } from "../proto/spark.js";
 import { getTxFromRawTxBytes } from "../utils/bitcoin.js";
@@ -51,6 +52,9 @@ export type SwapNodesForPreimageParams = {
   isInboundPayment: boolean;
   feeSats?: number;
   amountSatsToSend?: number;
+  startTransferRequest?: StartTransferRequest;
+  expiryTime?: Date;
+  transferID?: string;
 };
 
 export class LightningService {
@@ -175,6 +179,19 @@ export class LightningService {
     return invoice;
   }
 
+  /**
+   * Swap nodes for preimage
+   * @param leaves - The leaves to swap for preimage
+   * @param receiverIdentityPubkey - The receiver identity public key
+   * @param paymentHash - The payment hash
+   * @param invoiceString - The invoice string
+   * @param isInboundPayment - Whether the payment is inbound
+   * @param feeSats - The fee in sats
+   * @param amountSatsToSend - The amount in sats to send
+   * @param expiryTime - The expiry time
+   * @param startTransferRequest - The start transfer request, do not populate if is inbound payment
+   * @param transferID - The transfer ID, do not populate if is inbound payment
+   */
   async swapNodesForPreimage({
     leaves,
     receiverIdentityPubkey,
@@ -183,6 +200,9 @@ export class LightningService {
     isInboundPayment,
     feeSats = 0,
     amountSatsToSend,
+    expiryTime,
+    startTransferRequest,
+    transferID,
   }: SwapNodesForPreimageParams): Promise<InitiatePreimageSwapResponse> {
     const sparkClient = await this.connectionManager.createSparkClient(
       this.config.getCoordinatorAddress(),
@@ -222,7 +242,7 @@ export class LightningService {
       signingCommitments.signingCommitments.slice(2 * leaves.length),
     );
 
-    const transferId = uuidv7();
+    const transferId = transferID ? transferID : uuidv7();
     let bolt11String = "";
     let amountSats: number = 0;
     if (invoiceString) {
@@ -267,6 +287,7 @@ export class LightningService {
       : InitiatePreimageSwapRequest_Reason.REASON_SEND;
 
     let response: InitiatePreimageSwapResponse;
+    // TODO(LIG-8126): Remove transfer inputs once SDK upgrade is complete
     try {
       response = await sparkClient.initiate_preimage_swap_v2({
         paymentHash,
@@ -282,13 +303,18 @@ export class LightningService {
           ownerIdentityPublicKey:
             await this.config.signer.getIdentityPublicKey(),
           leavesToSend: cpfpLeafSigningJobs,
-          directLeavesToSend: directLeafSigningJobs,
-          directFromCpfpLeavesToSend: directFromCpfpLeafSigningJobs,
+          directLeavesToSend: startTransferRequest
+            ? undefined
+            : directLeafSigningJobs,
+          directFromCpfpLeavesToSend: startTransferRequest
+            ? undefined
+            : directFromCpfpLeafSigningJobs,
           receiverIdentityPublicKey: receiverIdentityPubkey,
-          expiryTime: new Date(Date.now() + 2 * 60 * 1000),
+          expiryTime,
         },
         receiverIdentityPublicKey: receiverIdentityPubkey,
         feeSats,
+        transferRequest: startTransferRequest,
       });
     } catch (error) {
       throw new NetworkError(

package/src/services/signing.ts

@@ -1,23 +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,
-  getNextTransactionSequence,
+  createDecrementedTimelockRefundTxs,
+  getCurrentTimelock,
+  getNextHTLCTransactionSequence,
 } from "../utils/transaction.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;
@@ -102,10 +103,132 @@ 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 amountSats = currRefundTx.getOutput(0).amount;
+      if (amountSats === undefined) {
+        throw new ValidationError("Invalid refund transaction", {
+          field: "amount",
+          value: currRefundTx.getOutput(0),
+          expected: "Non-null amount",
+        });
+      }
+
+      let directNodeTx: Transaction | undefined;
+      if (leaf.leaf.directTx.length > 0) {
+        directNodeTx = getTxFromRawTxBytes(leaf.leaf.directTx);
+      }
+
+      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 } =
+        createDecrementedTimelockRefundTxs({
+          nodeTx: nodeTx,
+          directNodeTx: directNodeTx,
+          sequence: currentSequence,
+          receivingPubkey: receiverIdentityPubkey,
+          network: this.config.getNetwork(),
+        });
+
+      const refundSighash = getSigHashFromTx(
+        cpfpRefundTx,
+        0,
+        nodeTx.getOutput(0),
+      );
+      const signingJobs = await this.signRefundsInternal(
+        cpfpRefundTx,
+        refundSighash,
+        leaf,
+        cpfpSigningCommitments[i]?.signingNonceCommitments,
+      );
+
+      cpfpLeafSigningJobs.push(...signingJobs);
+
+      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",
+            {
+              field: "directNodeTx",
+              value: directNodeTx,
+              expected: "Non-null direct node transaction",
+            },
+          );
+        }
+        const refundSighash = getSigHashFromTx(
+          directRefundTx,
+          0,
+          directNodeTx.getOutput(0),
+        );
+        const signingJobs = await this.signRefundsInternal(
+          directRefundTx,
+          refundSighash,
+          leaf,
+          directSigningCommitments[i]?.signingNonceCommitments,
+        );
+        directLeafSigningJobs.push(...signingJobs);
+      }
+
+      if (directFromCpfpRefundTx) {
+        const refundSighash = getSigHashFromTx(
+          directFromCpfpRefundTx,
+          0,
+          nodeTx.getOutput(0),
+        );
+        const signingJobs = await this.signRefundsInternal(
+          directFromCpfpRefundTx,
+          refundSighash,
+          leaf,
+          directFromCpfpSigningCommitments[i]?.signingNonceCommitments,
+        );
+        directFromCpfpLeafSigningJobs.push(...signingJobs);
+      }
+    }
+
+    return {
+      cpfpLeafSigningJobs,
+      directLeafSigningJobs,
+      directFromCpfpLeafSigningJobs,
+    };
+  }
+
+  async signRefundsForLightning(
+    leaves: LeafKeyTweak[],
+    receiverIdentityPubkey: Uint8Array,
+    cpfpSigningCommitments: RequestedSigningCommitments[],
+    directSigningCommitments: RequestedSigningCommitments[],
+    directFromCpfpSigningCommitments: RequestedSigningCommitments[],
+    hash: Uint8Array,
+  ): Promise<{
+    cpfpLeafSigningJobs: UserSignedTxSigningJob[];
+    directLeafSigningJobs: UserSignedTxSigningJob[];
+    directFromCpfpLeafSigningJobs: UserSignedTxSigningJob[];
+  }> {
+    const network = getNetwork(this.config.getNetwork());
+    const cpfpLeafSigningJobs: UserSignedTxSigningJob[] = [];
+    const directLeafSigningJobs: UserSignedTxSigningJob[] = [];
+    const directFromCpfpLeafSigningJobs: UserSignedTxSigningJob[] = [];
+
+    for (let i = 0; i < leaves.length; i++) {
+      const leaf = leaves[i];
+      if (!leaf?.leaf) {
+        throw new ValidationError("Leaf not found in signRefunds", {
+          field: "leaf",
+          value: leaf,
+          expected: "Non-null leaf",
+        });
+      }
+
+      const nodeTx = getTxFromRawTxBytes(leaf.leaf.nodeTx);
 
       const currRefundTx = getTxFromRawTxBytes(leaf.leaf.refundTx);
 
@@ -117,8 +240,6 @@ export class SigningService {
           expected: "Non-null sequence",
         });
       }
-      const { nextSequence, nextDirectSequence } =
-        getNextTransactionSequence(sequence);
 
       const amountSats = currRefundTx.getOutput(0).amount;
       if (amountSats === undefined) {
@@ -129,25 +250,27 @@ export class SigningService {
         });
       }
 
+      const { nextSequence, nextDirectSequence } =
+        getNextHTLCTransactionSequence(sequence);
+
       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 identityPublicKey = await this.config.signer.getIdentityPublicKey();
+
       const { cpfpRefundTx, directRefundTx, directFromCpfpRefundTx } =
-        createRefundTxs({
+        createRefundTxsForLightning({
+          nodeTx: nodeTx,
+          directNodeTx: directNodeTx,
+          vout: 0,
+          network,
           sequence: nextSequence,
           directSequence: nextDirectSequence,
-          input: cpfpNodeOutPoint,
-          directInput: directNodeOutPoint,
-          amountSats,
-          receivingPubkey: receiverIdentityPubkey,
-          network: this.config.getNetwork(),
+          hash,
+          hashLockDestinationPubkey: receiverIdentityPubkey,
+          sequenceLockDestinationPubkey: identityPublicKey,
         });
 
       const refundSighash = getSigHashFromTx(
@@ -190,16 +313,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,
@@ -221,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;
+  }
 }