@buildonspark/spark-sdk 0.1.39 → 0.1.40

package/src/services/tree-creation.ts

@@ -24,7 +24,10 @@ import {
   getTxId,
 } from "../utils/bitcoin.js";
 import { getNetwork, Network } from "../utils/network.js";
-import { getEphemeralAnchorOutput } from "../utils/transaction.js";
+import {
+  DEFAULT_FEE_SATS,
+  getEphemeralAnchorOutput,
+} from "../utils/transaction.js";
 import { WalletConfigService } from "./config.js";
 import { ConnectionManager } from "./connection.js";
 
@@ -42,6 +45,17 @@ export type CreationNodeWithNonces = CreationNode & {
 
 const INITIAL_TIME_LOCK = 2000;
 
+/**
+ * Subtracts the default fee from the amount if it's greater than the fee.
+ * Returns the original amount if it's less than or equal to the fee.
+ */
+function maybeApplyFee(amount: bigint): bigint {
+  if (amount > BigInt(DEFAULT_FEE_SATS)) {
+    return amount - BigInt(DEFAULT_FEE_SATS);
+  }
+  return amount;
+}
+
 export class TreeCreationService {
   private readonly config: WalletConfigService;
   private readonly connectionManager: ConnectionManager;
@@ -303,7 +317,7 @@ export class TreeCreationService {
       children: [],
     };
 
-    const tx = new Transaction();
+    const tx = new Transaction({ version: 3 });
     tx.addInput({
       txid: getTxId(parentTx),
       index: vout,
@@ -316,10 +330,9 @@ export class TreeCreationService {
 
     tx.addOutput({
       script: parentTxOut.script,
-      amount: parentTxOut.amount,
+      amount: parentTxOut.amount, // maybeApplyFee(parentTxOut.amount),
     });
 
-    // Add ephemeral anchor
     tx.addOutput(getEphemeralAnchorOutput());
 
     const signingNonceCommitment =
@@ -342,7 +355,7 @@ export class TreeCreationService {
       children: [],
     };
 
-    const childTx = new Transaction();
+    const childTx = new Transaction({ version: 3 });
     childTx.addInput({
       txid: getTxId(tx),
       index: 0,
@@ -351,10 +364,9 @@ export class TreeCreationService {
 
     childTx.addOutput({
       script: parentTxOut.script,
-      amount: parentTxOut.amount,
+      amount: parentTxOut.amount, // maybeApplyFee(parentTxOut.amount),
     });
 
-    // Add ephemeral anchor
     childTx.addOutput(getEphemeralAnchorOutput());
 
     const childSigningNonceCommitment =
@@ -368,7 +380,7 @@ export class TreeCreationService {
     childCreationNode.nodeTxSigningCommitment = childSigningNonceCommitment;
     childCreationNode.nodeTxSigningJob = childSigningJob;
 
-    const refundTx = new Transaction();
+    const refundTx = new Transaction({ version: 3 });
     refundTx.addInput({
       txid: getTxId(childTx),
       index: 0,
@@ -385,9 +397,11 @@ export class TreeCreationService {
     const refundPkScript = OutScript.encode(refundAddress);
     refundTx.addOutput({
       script: refundPkScript,
-      amount: parentTxOut.amount,
+      amount: maybeApplyFee(parentTxOut.amount),
     });
 
+    refundTx.addOutput(getEphemeralAnchorOutput());
+
     const refundSigningNonceCommitment =
       await this.config.signer.getRandomSigningCommitment();
 
@@ -415,7 +429,7 @@ export class TreeCreationService {
     if (!parentTxOutput?.script || !parentTxOutput?.amount) {
       throw new Error("parentTxOutput is undefined");
     }
-    const rootNodeTx = new Transaction();
+    const rootNodeTx = new Transaction({ version: 3 });
     rootNodeTx.addInput({
       txid: getTxId(parentTx),
       index: vout,
@@ -428,15 +442,16 @@ export class TreeCreationService {
       }
       const childAddress = Address(getNetwork(network)).decode(child.address);
       const childPkScript = OutScript.encode(childAddress);
+
+      // First subtract fee from total amount, then split between children
+      // const feeAdjustedAmount = maybeApplyFee(parentTxOutput.amount);
       rootNodeTx.addOutput({
         script: childPkScript,
-        amount: parentTxOutput.amount / 2n,
+        amount: parentTxOutput.amount / 2n, // feeAdjustedAmount / 2n,
       });
     }
 
-    // Add ephemeral anchor output
-    const anchor = getEphemeralAnchorOutput();
-    rootNodeTx.addOutput(anchor);
+    rootNodeTx.addOutput(getEphemeralAnchorOutput());
 
     const rootNodeSigningCommitment =
       await this.config.signer.getRandomSigningCommitment();

package/src/signer/signer.ts

@@ -1,6 +1,7 @@
 import {
   bytesToHex,
   bytesToNumberBE,
+  equalBytes,
   hexToBytes,
 } from "@noble/curves/abstract/utils";
 import { schnorr, secp256k1 } from "@noble/curves/secp256k1";
@@ -35,12 +36,16 @@ const getSparkFrostModule = async () => {
   return sparkFrostModule;
 };
 
-import { PARITY } from "@buildonspark/lrc20-sdk";
-import type { Psbt } from "bitcoinjs-lib";
-import { TokenSigner, Receipt } from "@buildonspark/lrc20-sdk";
-import { privateNegate, privateAdd } from "@bitcoinerlab/secp256k1";
+import { privateAdd, privateNegate } from "@bitcoinerlab/secp256k1";
+import {
+  fromPrivateKey,
+  PARITY,
+  Receipt,
+  TokenSigner,
+} from "@buildonspark/lrc20-sdk";
 import { sha256 } from "@noble/hashes/sha2";
-import { fromPrivateKey } from "@buildonspark/lrc20-sdk";
+import { Transaction } from "@scure/btc-signer";
+import type { Psbt } from "bitcoinjs-lib";
 
 export type SigningNonce = {
   binding: Uint8Array;
@@ -223,6 +228,12 @@ interface SparkSigner extends TokenSigner {
     signature: Uint8Array,
   ): Promise<boolean>;
 
+  signTransactionIndex(
+    tx: Transaction,
+    index: number,
+    publicKey: Uint8Array,
+  ): void;
+
   encryptLeafPrivateKeyEcies(
     receiverPublicKey: Uint8Array,
     publicKey: Uint8Array,
@@ -790,6 +801,37 @@ class DefaultSparkSigner implements SparkSigner {
     const receiptProof = privateAdd(privateKey, pxhPubkey)!;
     return Buffer.from(receiptProof);
   }
+
+  signTransactionIndex(
+    tx: Transaction,
+    index: number,
+    publicKey: Uint8Array,
+  ): void {
+    let privateKey: Uint8Array | undefined | null;
+
+    if (
+      equalBytes(publicKey, this.identityKey?.publicKey ?? new Uint8Array())
+    ) {
+      privateKey = this.identityKey?.privateKey;
+    } else if (
+      equalBytes(publicKey, this.depositKey?.publicKey ?? new Uint8Array())
+    ) {
+      privateKey = this.depositKey?.privateKey;
+    } else {
+      privateKey = hexToBytes(
+        this.publicKeyToPrivateKeyMap.get(bytesToHex(publicKey)) ?? "",
+      );
+    }
+
+    if (!privateKey) {
+      throw new ValidationError("Private key not found for public key", {
+        field: "privateKey",
+        value: bytesToHex(publicKey),
+      });
+    }
+
+    tx.signIdx(privateKey, index);
+  }
 }
 export { DefaultSparkSigner };
 export type { SparkSigner };

package/src/spark-wallet/spark-wallet.ts

@@ -72,6 +72,7 @@ import {
 } from "../utils/adaptor-signature.js";
 import {
   computeTaprootKeyNoScript,
+  getP2TRScriptFromPublicKey,
   getP2WPKHAddressFromPublicKey,
   getSigHashFromTx,
   getTxFromRawTxBytes,
@@ -430,9 +431,7 @@ export class SparkWallet extends EventEmitter {
     }
   }
 
-  private async getLeaves(
-    isBalanceCheck: boolean = false,
-  ): Promise<TreeNode[]> {
+  public async getLeaves(isBalanceCheck: boolean = false): Promise<TreeNode[]> {
     const leaves = await this.queryNodes({
       source: {
         $case: "ownerIdentityPubkey",
@@ -3116,6 +3115,148 @@ export class SparkWallet extends EventEmitter {
     return this.config.signer.validateMessageWithIdentityKey(hash, signature);
   }
 
+  /**
+   * Signs a transaction with wallet keys.
+   *
+   * @param {string} txHex - The transaction hex to sign
+   * @param {string} keyType - The type of key to use for signing ("identity", "deposit", or "auto-detect")
+   * @returns {Promise<string>} The signed transaction hex
+   */
+  public async signTransaction(
+    txHex: string,
+    keyType: string = "auto-detect",
+  ): Promise<string> {
+    try {
+      // Parse the transaction
+      const tx = Transaction.fromRaw(hexToBytes(txHex));
+
+      let publicKey: Uint8Array;
+
+      switch (keyType.toLowerCase()) {
+        case "identity":
+          publicKey = await this.config.signer.getIdentityPublicKey();
+          break;
+        case "deposit":
+          publicKey = await this.config.signer.getDepositSigningKey();
+          break;
+        case "auto-detect":
+        default:
+          // Try to auto-detect which key to use by examining the transaction inputs
+          const detectedKey = await this.detectKeyForTransaction(tx);
+          if (detectedKey) {
+            publicKey = detectedKey.publicKey;
+          } else {
+            // Fallback to identity key
+            publicKey = await this.config.signer.getIdentityPublicKey();
+          }
+          break;
+      }
+
+      // Check each input to determine which ones need signing
+      let inputsSigned = 0;
+      for (let i = 0; i < tx.inputsLength; i++) {
+        const input = tx.getInput(i);
+        if (!input?.witnessUtxo?.script) {
+          continue;
+        }
+
+        const script = input.witnessUtxo.script;
+
+        // Check if this is an ephemeral anchor (OP_TRUE script)
+        // OP_TRUE is represented as a single byte: 0x51
+        if (script.length === 1 && script[0] === 0x51) {
+          continue;
+        }
+
+        // Check if this script matches one of our keys
+        const identityScript = getP2TRScriptFromPublicKey(
+          publicKey,
+          this.config.getNetwork(),
+        );
+
+        if (bytesToHex(script) === bytesToHex(identityScript)) {
+          // Sign this specific input
+          try {
+            this.config.signer.signTransactionIndex(tx, i, publicKey);
+            inputsSigned++;
+          } catch (error) {
+            throw new ValidationError(`Failed to sign input ${i}: ${error}`, {
+              field: "input",
+              value: i,
+            });
+          }
+        }
+      }
+
+      if (inputsSigned === 0) {
+        throw new Error(
+          "No inputs were signed. Check that the transaction contains inputs controlled by this wallet.",
+        );
+      }
+
+      tx.finalize();
+
+      const signedTxHex = tx.hex;
+
+      return signedTxHex;
+    } catch (error) {
+      console.error("❌ Error signing transaction:", error);
+      throw error;
+    }
+  }
+
+  /**
+   * Helper method to auto-detect which key should be used for signing a transaction.
+   */
+  private async detectKeyForTransaction(tx: Transaction): Promise<{
+    publicKey: Uint8Array;
+    keyType: string;
+  } | null> {
+    try {
+      // Get available keys
+      const identityPubKey = await this.config.signer.getIdentityPublicKey();
+      const depositPubKey = await this.config.signer.getDepositSigningKey();
+
+      // Check if any inputs reference outputs that would be controlled by our keys
+      for (let i = 0; i < tx.inputsLength; i++) {
+        const input = tx.getInput(i);
+        if (input?.witnessUtxo?.script) {
+          const script = input.witnessUtxo.script;
+
+          // Check if this script corresponds to one of our keys
+          // This is a simplified check - in practice, you might need more sophisticated script analysis
+          const identityScript = getP2TRScriptFromPublicKey(
+            identityPubKey,
+            this.config.getNetwork(),
+          );
+          const depositScript = getP2TRScriptFromPublicKey(
+            depositPubKey,
+            this.config.getNetwork(),
+          );
+
+          if (bytesToHex(script) === bytesToHex(identityScript)) {
+            return {
+              publicKey: identityPubKey,
+              keyType: "identity",
+            };
+          }
+
+          if (bytesToHex(script) === bytesToHex(depositScript)) {
+            return {
+              publicKey: depositPubKey,
+              keyType: "deposit",
+            };
+          }
+        }
+      }
+
+      return null;
+    } catch (error) {
+      console.warn("Error during key auto-detection:", error);
+      return null;
+    }
+  }
+
   /**
    * Get a Lightning receive request by ID.
    *
@@ -3153,6 +3294,291 @@ export class SparkWallet extends EventEmitter {
     return await sspClient.getCoopExitRequest(id);
   }
 
+  /**
+   * Check the remaining timelock on a given node.
+   *
+   * @param {string} nodeId - The ID of the node to check
+   * @returns {Promise<{nodeTimelock: number, refundTimelock: number}>} The remaining timelocks in blocks for both node and refund transactions
+   */
+  public async checkTimelock(nodeId: string): Promise<{
+    nodeTimelock: number;
+    refundTimelock: number;
+  }> {
+    const sparkClient = await this.connectionManager.createSparkClient(
+      this.config.getCoordinatorAddress(),
+    );
+
+    try {
+      const response = await sparkClient.query_nodes({
+        source: {
+          $case: "nodeIds",
+          nodeIds: {
+            nodeIds: [nodeId],
+          },
+        },
+        includeParents: false,
+        network: NetworkToProto[this.config.getNetwork()],
+      });
+
+      const node = response.nodes[nodeId];
+      if (!node) {
+        throw new ValidationError("Node not found", {
+          field: "nodeId",
+          value: nodeId,
+        });
+      }
+
+      // Check if this is a root node (no parent)
+      const isRootNode = !node.parentNodeId;
+
+      // Validate transaction data exists
+      if (!node.nodeTx || node.nodeTx.length === 0) {
+        throw new ValidationError(
+          `Node transaction data is missing or empty for ${isRootNode ? "root" : "non-root"} node`,
+          {
+            field: "nodeTx",
+            value: node.nodeTx?.length || 0,
+          },
+        );
+      }
+
+      if (!node.refundTx || node.refundTx.length === 0) {
+        throw new ValidationError(
+          `Refund transaction data is missing or empty for ${isRootNode ? "root" : "non-root"} node`,
+          {
+            field: "refundTx",
+            value: node.refundTx?.length || 0,
+          },
+        );
+      }
+
+      let nodeTx, refundTx;
+
+      try {
+        // Get the node transaction to check its timelock
+        nodeTx = getTxFromRawTxBytes(node.nodeTx);
+      } catch (error) {
+        throw new ValidationError(
+          `Failed to parse node transaction for ${isRootNode ? "root" : "non-root"} node: ${error instanceof Error ? error.message : String(error)}`,
+          {
+            field: "nodeTx",
+            value: node.nodeTx.length,
+          },
+        );
+      }
+
+      try {
+        // Get the refund transaction to check its timelock
+        refundTx = getTxFromRawTxBytes(node.refundTx);
+      } catch (error) {
+        throw new ValidationError(
+          `Failed to parse refund transaction for ${isRootNode ? "root" : "non-root"} node: ${error instanceof Error ? error.message : String(error)}`,
+          {
+            field: "refundTx",
+            value: node.refundTx.length,
+          },
+        );
+      }
+
+      const nodeInput = nodeTx.getInput(0);
+      if (!nodeInput) {
+        throw new ValidationError(
+          `Node transaction has no inputs for ${isRootNode ? "root" : "non-root"} node`,
+          {
+            field: "nodeInput",
+            value: nodeTx.inputsLength,
+          },
+        );
+      }
+
+      if (!nodeInput.sequence) {
+        throw new ValidationError(
+          `Node transaction has no sequence for ${isRootNode ? "root" : "non-root"} node`,
+          {
+            field: "sequence",
+            value: nodeInput.sequence,
+          },
+        );
+      }
+
+      const refundInput = refundTx.getInput(0);
+      if (!refundInput) {
+        throw new ValidationError(
+          `Refund transaction has no inputs for ${isRootNode ? "root" : "non-root"} node`,
+          {
+            field: "refundInput",
+            value: refundTx.inputsLength,
+          },
+        );
+      }
+
+      if (!refundInput.sequence) {
+        throw new ValidationError(
+          `Refund transaction has no sequence for ${isRootNode ? "root" : "non-root"} node`,
+          {
+            field: "sequence",
+            value: refundInput.sequence,
+          },
+        );
+      }
+
+      // Extract timelock from sequence (lower 16 bits)
+      const nodeTimelock = nodeInput.sequence & 0xffff;
+      const refundTimelock = refundInput.sequence & 0xffff;
+
+      return {
+        nodeTimelock,
+        refundTimelock,
+      };
+    } catch (error) {
+      throw new NetworkError(
+        `Failed to check timelock for node ${nodeId}`,
+        {
+          method: "query_nodes",
+        },
+        error as Error,
+      );
+    }
+  }
+
+  /**
+   * Refresh the timelock of a specific node.
+   *
+   * @param {string} nodeId - The ID of the node to refresh
+   * @returns {Promise<void>} Promise that resolves when the timelock is refreshed
+   */
+  public async testOnly_expireTimelock(nodeId: string): Promise<void> {
+    const sparkClient = await this.connectionManager.createSparkClient(
+      this.config.getCoordinatorAddress(),
+    );
+
+    try {
+      // First, get the node and its parent
+      const response = await sparkClient.query_nodes({
+        source: {
+          $case: "nodeIds",
+          nodeIds: {
+            nodeIds: [nodeId],
+          },
+        },
+        includeParents: true,
+      });
+
+      const node = response.nodes[nodeId];
+      if (!node) {
+        throw new ValidationError("Node not found", {
+          field: "nodeId",
+          value: nodeId,
+        });
+      }
+
+      if (!node.parentNodeId) {
+        throw new ValidationError("Node has no parent", {
+          field: "parentNodeId",
+          value: node.parentNodeId,
+        });
+      }
+
+      const parentNode = response.nodes[node.parentNodeId];
+      if (!parentNode) {
+        throw new ValidationError("Parent node not found", {
+          field: "parentNodeId",
+          value: node.parentNodeId,
+        });
+      }
+
+      // Generate signing public key for this node
+      const signingPubKey = await this.config.signer.generatePublicKey(
+        sha256(node.id),
+      );
+
+      // Call the transfer service to refresh the timelock
+      const result = await this.transferService.refreshTimelockNodes(
+        [node],
+        parentNode,
+        signingPubKey,
+      );
+
+      // Update the local leaves if this node is in our wallet
+      const leafIndex = this.leaves.findIndex((leaf) => leaf.id === node.id);
+      if (leafIndex !== -1 && result.nodes.length > 0) {
+        const newNode = result.nodes[0];
+        if (newNode) {
+          this.leaves[leafIndex] = newNode;
+        }
+      }
+    } catch (error) {
+      throw new NetworkError(
+        "Failed to refresh timelock",
+        {
+          method: "refresh_timelock",
+        },
+        error as Error,
+      );
+    }
+  }
+
+  /**
+   * Refresh the timelock of a specific node's refund transaction only.
+   *
+   * @param {string} nodeId - The ID of the node whose refund transaction to refresh
+   * @returns {Promise<void>} Promise that resolves when the refund timelock is refreshed
+   */
+  public async testOnly_expireTimelockRefundTx(nodeId: string): Promise<void> {
+    const sparkClient = await this.connectionManager.createSparkClient(
+      this.config.getCoordinatorAddress(),
+    );
+
+    try {
+      // Get the node
+      const response = await sparkClient.query_nodes({
+        source: {
+          $case: "nodeIds",
+          nodeIds: {
+            nodeIds: [nodeId],
+          },
+        },
+        includeParents: false,
+      });
+
+      const node = response.nodes[nodeId];
+      if (!node) {
+        throw new ValidationError("Node not found", {
+          field: "nodeId",
+          value: nodeId,
+        });
+      }
+
+      // Generate signing public key for this node
+      const signingPubKey = await this.config.signer.generatePublicKey(
+        sha256(node.id),
+      );
+
+      // Call the transfer service to refresh the refund timelock
+      const result = await this.transferService.refreshTimelockRefundTx(
+        node,
+        signingPubKey,
+      );
+
+      // Update the local leaves if this node is in our wallet
+      const leafIndex = this.leaves.findIndex((leaf) => leaf.id === node.id);
+      if (leafIndex !== -1 && result.nodes.length > 0) {
+        const newNode = result.nodes[0];
+        if (newNode) {
+          this.leaves[leafIndex] = newNode;
+        }
+      }
+    } catch (error) {
+      throw new NetworkError(
+        "Failed to refresh refund timelock",
+        {
+          method: "refresh_timelock_refund_tx",
+        },
+        error as Error,
+      );
+    }
+  }
+
   private cleanup() {
     if (this.claimTransfersInterval) {
       clearInterval(this.claimTransfersInterval);

package/src/tests/integration/tree-creation.test.ts

@@ -1,10 +1,14 @@
 // @ts-nocheck
 import { describe, expect, it } from "@jest/globals";
 import { bytesToHex } from "@noble/curves/abstract/utils";
+import { secp256k1 } from "@noble/curves/secp256k1";
 import { ValidationError } from "../../errors/types.js";
 import { getTxFromRawTxBytes, getTxId } from "../../utils/bitcoin.js";
 import { Network } from "../../utils/network.js";
+import { DEFAULT_FEE_SATS } from "../../utils/transaction.js";
+import { createNewTreeWithLevels } from "../test-util.js";
 import { SparkWalletTesting } from "../utils/spark-testing-wallet.js";
+import { BitcoinFaucet } from "../utils/test-faucet.js";
 
 describe("Tree Creation", () => {
   it.skip("test tree creation address generation", async () => {
@@ -19,7 +23,7 @@ describe("Tree Creation", () => {
 
     const dummyTx = createDummyTx({
       address: depositResp.depositAddress!.address,
-      amountSats: 65536n,
+      amountSats: 65536n + DEFAULT_FEE_SATS,
     });
 
     const depositTxHex = bytesToHex(dummyTx.tx);

package/src/utils/index.ts

@@ -10,3 +10,4 @@ export * from "./signing.js";
 export * from "./token-transactions.js";
 export * from "./transfer_package.js";
 export * from "./transaction.js";
+export * from "./unilateral-exit.js";