@buildonspark/spark-sdk 0.1.39 → 0.1.41

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

@@ -4,6 +4,7 @@ import {
   bytesToNumberBE,
   equalBytes,
   hexToBytes,
+  numberToVarBytesBE,
 } from "@noble/curves/abstract/utils";
 import { secp256k1 } from "@noble/curves/secp256k1";
 import { validateMnemonic } from "@scure/bip39";
@@ -11,7 +12,7 @@ import { wordlist } from "@scure/bip39/wordlists/english";
 import { Address, OutScript, Transaction } from "@scure/btc-signer";
 import { TransactionInput } from "@scure/btc-signer/psbt";
 import { Mutex } from "async-mutex";
-import { uuidv7 } from "uuidv7";
+import { uuidv7, uuidv7obj } from "uuidv7";
 import {
   ConfigurationError,
   NetworkError,
@@ -34,6 +35,7 @@ import {
   SwapLeaf,
   UserLeafInput,
 } from "../graphql/objects/index.js";
+import GraphQLTransferObj from "../graphql/objects/Transfer.js";
 import {
   DepositAddressQueryResult,
   OutputWithPreviousTransactionData,
@@ -72,6 +74,7 @@ import {
 } from "../utils/adaptor-signature.js";
 import {
   computeTaprootKeyNoScript,
+  getP2TRScriptFromPublicKey,
   getP2WPKHAddressFromPublicKey,
   getSigHashFromTx,
   getTxFromRawTxBytes,
@@ -95,6 +98,7 @@ import { EventEmitter } from "eventemitter3";
 import {
   decodeSparkAddress,
   encodeSparkAddress,
+  isValidPublicKey,
   SparkAddressFormat,
 } from "../address/index.js";
 import { isReactNative } from "../constants.js";
@@ -430,9 +434,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",
@@ -687,6 +689,56 @@ export class SparkWallet extends EventEmitter {
     return this.sparkAddress;
   }
 
+  public async createSparkPaymentIntent(
+    assetIdentifier?: string,
+    assetAmount: bigint = BigInt(0),
+    memo?: string,
+  ): Promise<SparkAddressFormat> {
+    const MAX_UINT128 = BigInt("340282366920938463463374607431768211455");
+    if (assetAmount < 0 || assetAmount > MAX_UINT128) {
+      throw new ValidationError(
+        "Asset amount must be between 0 and MAX_UINT128",
+        {
+          field: "assetAmount",
+          value: assetAmount,
+        },
+      );
+    }
+    if (memo) {
+      const encoder = new TextEncoder();
+      const memoBytes = encoder.encode(memo);
+      if (memoBytes.length > 120) {
+        throw new ValidationError(
+          "Memo exceeds the maximum allowed byte length of 120.",
+          {
+            field: "memo",
+            value: memo,
+            expected: "less than 120 bytes",
+          },
+        );
+      }
+    }
+    if (assetIdentifier) {
+      isValidPublicKey(assetIdentifier);
+    }
+    const paymentRequest = encodeSparkAddress({
+      identityPublicKey: bytesToHex(
+        await this.config.signer.getIdentityPublicKey(),
+      ),
+      network: this.config.getNetworkType(),
+      paymentIntentFields: {
+        id: uuidv7obj().bytes,
+        assetIdentifier: assetIdentifier
+          ? hexToBytes(assetIdentifier)
+          : undefined,
+        assetAmount: numberToVarBytesBE(assetAmount),
+        memo: memo,
+      },
+    });
+
+    return paymentRequest;
+  }
+
   /**
    * Initializes the wallet using either a mnemonic phrase or a raw seed.
    * initWallet will also claim any pending incoming lightning payment, spark transfer,
@@ -1967,7 +2019,7 @@ export class SparkWallet extends EventEmitter {
 
     const isSelfTransfer = equalBytes(
       signerIdentityPublicKey,
-      hexToBytes(receiverAddress),
+      hexToBytes(receiverAddress.identityPublicKey),
     );
 
     return await this.withLeaves(async () => {
@@ -1988,7 +2040,7 @@ export class SparkWallet extends EventEmitter {
 
       const transfer = await this.transferService.sendTransferWithKeyTweaks(
         leafKeyTweaks,
-        hexToBytes(receiverAddress),
+        hexToBytes(receiverAddress.identityPublicKey),
       );
 
       const leavesToRemove = new Set(leavesToSend.map((leaf) => leaf.id));
@@ -2896,6 +2948,31 @@ export class SparkWallet extends EventEmitter {
     return feeEstimate;
   }
 
+  /**
+   * Gets a transfer that has been sent by the SSP to the wallet.
+   *
+   * @param {string} id - The ID of the transfer
+   * @returns {Promise<GraphQLTransferObj | null>} The transfer
+   */
+  public async getTransferFromSsp(
+    id: string,
+  ): Promise<GraphQLTransferObj | null> {
+    const sspClient = this.getSspClient();
+    return await sspClient.getTransfer(id);
+  }
+
+  /**
+   * Gets a transfer, that the wallet is a participant of, in the Spark network.
+   * Only contains data about the spark->spark transfer, use getTransferFromSsp if you're
+   * looking for information related to a lightning transfer.
+   *
+   * @param {string} id - The ID of the transfer
+   * @returns {Promise<Transfer | undefined>} The transfer
+   */
+  public async getTransfer(id: string): Promise<Transfer | undefined> {
+    return await this.transferService.queryTransfer(id);
+  }
+
   // ***** Token Flow *****
 
   /**
@@ -3116,6 +3193,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 +3372,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);