@buildonspark/spark-sdk 0.2.4 → 0.2.5

package/dist/native/index.cjs

@@ -1367,6 +1367,7 @@ __export(index_exports, {
   getSparkAddressFromTaproot: () => getSparkAddressFromTaproot,
   getTransactionSequence: () => getTransactionSequence,
   getTransferPackageSigningPayload: () => getTransferPackageSigningPayload,
+  getTxEstimatedVbytesSizeByNumberOfInputsOutputs: () => getTxEstimatedVbytesSizeByNumberOfInputsOutputs,
   getTxFromRawTxBytes: () => getTxFromRawTxBytes,
   getTxFromRawTxHex: () => getTxFromRawTxHex,
   getTxId: () => getTxId,
@@ -16553,6 +16554,12 @@ function getTxId(tx) {
 function getTxIdNoReverse(tx) {
   return (0, import_utils5.bytesToHex)((0, import_sha2.sha256)((0, import_sha2.sha256)(tx.toBytes(true))));
 }
+function getTxEstimatedVbytesSizeByNumberOfInputsOutputs(numInputs, numOutputs) {
+  const TX_OVERHEAD = 10;
+  const IN_VBYTES = 150;
+  const OUT_VBYTES = 34;
+  return TX_OVERHEAD + numInputs * IN_VBYTES + numOutputs * OUT_VBYTES;
+}
 
 // src/utils/keys.ts
 init_buffer();
@@ -16935,6 +16942,20 @@ var import_core = require("@lightsparkdev/core");
 
 // src/graphql/objects/ClaimStaticDepositStatus.ts
 init_buffer();
+var ClaimStaticDepositStatus = /* @__PURE__ */ ((ClaimStaticDepositStatus2) => {
+  ClaimStaticDepositStatus2["FUTURE_VALUE"] = "FUTURE_VALUE";
+  ClaimStaticDepositStatus2["CREATED"] = "CREATED";
+  ClaimStaticDepositStatus2["TRANSFER_CREATED"] = "TRANSFER_CREATED";
+  ClaimStaticDepositStatus2["TRANSFER_CREATION_FAILED"] = "TRANSFER_CREATION_FAILED";
+  ClaimStaticDepositStatus2["REFUND_SIGNING_COMMITMENTS_QUERYING_FAILED"] = "REFUND_SIGNING_COMMITMENTS_QUERYING_FAILED";
+  ClaimStaticDepositStatus2["REFUND_SIGNING_FAILED"] = "REFUND_SIGNING_FAILED";
+  ClaimStaticDepositStatus2["UTXO_SWAPPING_FAILED"] = "UTXO_SWAPPING_FAILED";
+  ClaimStaticDepositStatus2["TRANSFER_COMPLETED"] = "TRANSFER_COMPLETED";
+  ClaimStaticDepositStatus2["SPEND_TX_CREATED"] = "SPEND_TX_CREATED";
+  ClaimStaticDepositStatus2["SPEND_TX_BROADCAST"] = "SPEND_TX_BROADCAST";
+  return ClaimStaticDepositStatus2;
+})(ClaimStaticDepositStatus || {});
+var ClaimStaticDepositStatus_default = ClaimStaticDepositStatus;
 
 // src/graphql/objects/CurrencyAmount.ts
 init_buffer();
@@ -16977,6 +16998,26 @@ var CurrencyAmountToJson = (obj) => {
   };
 };
 
+// src/graphql/objects/ClaimStaticDeposit.ts
+var ClaimStaticDepositFromJson = (obj) => {
+  return {
+    id: obj["claim_static_deposit_id"],
+    createdAt: obj["claim_static_deposit_created_at"],
+    updatedAt: obj["claim_static_deposit_updated_at"],
+    network: BitcoinNetwork_default[obj["claim_static_deposit_network"]] ?? BitcoinNetwork_default.FUTURE_VALUE,
+    creditAmount: CurrencyAmountFromJson(
+      obj["claim_static_deposit_credit_amount"]
+    ),
+    maxFee: CurrencyAmountFromJson(obj["claim_static_deposit_max_fee"]),
+    status: ClaimStaticDepositStatus_default[obj["claim_static_deposit_status"]] ?? ClaimStaticDepositStatus_default.FUTURE_VALUE,
+    transactionId: obj["claim_static_deposit_transaction_id"],
+    outputIndex: obj["claim_static_deposit_output_index"],
+    bitcoinNetwork: BitcoinNetwork_default[obj["claim_static_deposit_bitcoin_network"]] ?? BitcoinNetwork_default.FUTURE_VALUE,
+    typename: "ClaimStaticDeposit",
+    transferSparkId: obj["claim_static_deposit_transfer_spark_id"]
+  };
+};
+
 // src/graphql/objects/ClaimStaticDepositRequestType.ts
 init_buffer();
 var ClaimStaticDepositRequestType = /* @__PURE__ */ ((ClaimStaticDepositRequestType2) => {
@@ -17844,7 +17885,7 @@ function mapTransferLeafToWalletTransferLeaf(proto) {
     intermediateRefundTx: (0, import_utils7.bytesToHex)(proto.intermediateRefundTx)
   };
 }
-function mapTransferToWalletTransfer(proto, identityPublicKey) {
+function mapTransferToWalletTransfer(proto, identityPublicKey, userRequest) {
   const receiverIdentityPublicKey = (0, import_utils7.bytesToHex)(proto.receiverIdentityPublicKey);
   const senderIdentityPublicKey = (0, import_utils7.bytesToHex)(proto.senderIdentityPublicKey);
   return {
@@ -17858,7 +17899,8 @@ function mapTransferToWalletTransfer(proto, identityPublicKey) {
     createdTime: proto.createdTime ? new Date(proto.createdTime) : void 0,
     updatedTime: proto.updatedTime ? new Date(proto.updatedTime) : void 0,
     type: TransferType[proto.type],
-    transferDirection: receiverIdentityPublicKey === identityPublicKey ? "INCOMING" /* INCOMING */ : "OUTGOING" /* OUTGOING */
+    transferDirection: receiverIdentityPublicKey === identityPublicKey ? "INCOMING" /* INCOMING */ : "OUTGOING" /* OUTGOING */,
+    userRequest
   };
 }
 
@@ -19372,7 +19414,7 @@ init_buffer();
 var import_core8 = require("@lightsparkdev/core");
 var isReactNative = typeof navigator !== "undefined" && navigator.product === "ReactNative";
 var isBun = globalThis.Bun !== void 0;
-var packageVersion = true ? "0.2.4" : "unknown";
+var packageVersion = true ? "0.2.5" : "unknown";
 var baseEnvStr = "unknown";
 if (isBun) {
   const bunVersion = "version" in globalThis.Bun ? globalThis.Bun.version : "unknown-version";
@@ -20465,15 +20507,19 @@ var LightningSendFeeEstimate = `
   ${FRAGMENT13}
 `;
 
-// src/graphql/queries/Transfer.ts
+// src/graphql/queries/Transfers.ts
 init_buffer();
-var GetTransfer = `
-  query Transfer($transfer_spark_id: UUID!) {
-    transfer(transfer_spark_id: $transfer_spark_id) {
+var GetTransfers = `
+  query Transfers($transfer_spark_ids: [UUID!]!) {
+    transfers(transfer_spark_ids: $transfer_spark_ids) {
       ...TransferFragment
+      transfer_user_request: user_request {
+        ...UserRequestFragment
+      }
     }
   }
   ${FRAGMENT2}
+  ${FRAGMENT6}
 `;
 
 // src/graphql/queries/UserRequest.ts
@@ -20830,14 +20876,47 @@ var SspClient = class {
       }
     });
   }
-  async getTransfer(id) {
+  async getTransfers(ids) {
     return await this.executeRawQuery({
-      queryPayload: GetTransfer,
+      queryPayload: GetTransfers,
       variables: {
-        transfer_spark_id: id
+        transfer_spark_ids: ids
       },
       constructObject: (response) => {
-        return TransferFromJson(response.transfer);
+        return response.transfers.map((transfer) => {
+          const transferObj = TransferFromJson(
+            transfer
+          );
+          switch (transfer.transfer_user_request.__typename) {
+            case "ClaimStaticDeposit":
+              transferObj.userRequest = ClaimStaticDepositFromJson(
+                transfer.transfer_user_request
+              );
+              break;
+            case "CoopExitRequest":
+              transferObj.userRequest = CoopExitRequestFromJson(
+                transfer.transfer_user_request
+              );
+              break;
+            case "LeavesSwapRequest":
+              transferObj.userRequest = LeavesSwapRequestFromJson(
+                transfer.transfer_user_request
+              );
+              break;
+            case "LightningReceiveRequest":
+              transferObj.userRequest = LightningReceiveRequestFromJson(
+                transfer.transfer_user_request
+              );
+              break;
+            case "LightningSendRequest":
+              transferObj.userRequest = LightningSendRequestFromJson(
+                transfer.transfer_user_request
+              );
+              break;
+          }
+          const { userRequestId, ...rest } = transferObj;
+          return rest;
+        });
       }
     });
   }
@@ -32275,9 +32354,22 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
     const identityPublicKey = (0, import_utils24.bytesToHex)(
       await this.config.signer.getIdentityPublicKey()
     );
+    const userRequests = await this.sspClient?.getTransfers(
+      transfers.transfers.map((transfer) => transfer.id)
+    );
+    const userRequestsMap = /* @__PURE__ */ new Map();
+    for (const userRequest of userRequests || []) {
+      if (userRequest && userRequest.sparkId && userRequest.userRequest) {
+        userRequestsMap.set(userRequest.sparkId, userRequest.userRequest);
+      }
+    }
     return {
       transfers: transfers.transfers.map(
-        (transfer) => mapTransferToWalletTransfer(transfer, identityPublicKey)
+        (transfer) => mapTransferToWalletTransfer(
+          transfer,
+          identityPublicKey,
+          userRequestsMap.get(transfer.id)
+        )
       ),
       offset: transfers.offset
     };
@@ -32460,7 +32552,9 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
       network = BitcoinNetwork_default.REGTEST;
     }
     if (outputIndex === void 0) {
-      outputIndex = await this.getDepositTransactionVout(transactionId);
+      outputIndex = await this.getDepositTransactionVout({
+        txid: transactionId
+      });
     }
     const quote = await sspClient.getClaimDepositQuote({
       transactionId,
@@ -32491,7 +32585,9 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
       throw new Error("SSP client not initialized");
     }
     if (outputIndex === void 0) {
-      outputIndex = await this.getDepositTransactionVout(transactionId);
+      outputIndex = await this.getDepositTransactionVout({
+        txid: transactionId
+      });
     }
     let network = this.config.getSspNetwork();
     if (network === BitcoinNetwork_default.FUTURE_VALUE) {
@@ -32525,25 +32621,94 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
     }
     return response;
   }
+  /**
+   * Get a quote on how much credit you can claim for a deposit from the SSP. If the quote charges less fees than the max fee, claim the deposit.
+   *
+   * @param {Object} params - The parameters object
+   * @param {string} params.transactionId - The ID of the transaction
+   * @param {number} params.maxFee - The maximum fee to claim the deposit for
+   * @param {number} [params.outputIndex] - The index of the output
+   * @returns {Promise<StaticDepositQuoteOutput>} Quote for claiming a deposit to a static deposit address
+   */
+  async claimStaticDepositWithMaxFee({
+    transactionId,
+    maxFee,
+    outputIndex
+  }) {
+    const sspClient = this.getSspClient();
+    let network = this.config.getSspNetwork();
+    if (network === BitcoinNetwork_default.FUTURE_VALUE) {
+      network = BitcoinNetwork_default.REGTEST;
+    }
+    const depositTx = await this.getDepositTransaction(transactionId);
+    if (outputIndex === void 0) {
+      outputIndex = await this.getDepositTransactionVout({
+        txid: transactionId,
+        depositTx
+      });
+    }
+    const depositAmount = Number(depositTx.getOutput(outputIndex).amount);
+    const quote = await sspClient.getClaimDepositQuote({
+      transactionId,
+      outputIndex,
+      network
+    });
+    if (!quote) {
+      throw new Error("Failed to get claim deposit quote");
+    }
+    const { creditAmountSats, signature: sspSignature } = quote;
+    const feeCharged = depositAmount - creditAmountSats;
+    if (feeCharged > maxFee) {
+      throw new ValidationError("Fee larger than max fee", {
+        field: "feeCharged",
+        value: feeCharged
+      });
+    }
+    const response = await this.claimStaticDeposit({
+      transactionId,
+      creditAmountSats,
+      sspSignature,
+      outputIndex
+    });
+    if (!response) {
+      throw new Error("Failed to claim static deposit");
+    }
+    return response;
+  }
   /**
    * Refunds a static deposit to a destination address.
    *
-   * @param {string} depositTransactionId - The ID of the transaction
-   * @param {number} [outputIndex] - The index of the output
-   * @param {string} destinationAddress - The destination address
-   * @param {number} fee - The fee to refund
+   * @param {Object} params - The refund parameters
+   * @param {string} params.depositTransactionId - The ID of the transaction
+   * @param {number} [params.outputIndex] - The index of the output
+   * @param {string} params.destinationAddress - The destination address
+   * @param {number} [params.fee] - **@deprecated** The fee to refund
+   * @param {number} [params.satsPerVbyteFee] - The fee per vbyte to refund
    * @returns {Promise<string>} The hex of the refund transaction
    */
   async refundStaticDeposit({
     depositTransactionId,
     outputIndex,
     destinationAddress,
-    fee
+    fee,
+    satsPerVbyteFee
   }) {
-    if (fee <= 300) {
+    if (fee !== void 0) {
+      console.warn(
+        `refundStaticDeposit(): \`fee\` parameter is deprecated and will be removed; please switch to \`satsPerVbyteFee\`.`
+      );
+    }
+    if (fee === void 0 && satsPerVbyteFee === void 0) {
+      throw new ValidationError("Fee or satsPerVbyteFee must be provided");
+    }
+    if (satsPerVbyteFee && satsPerVbyteFee > 150) {
+      throw new ValidationError("satsPerVbyteFee must be less than 150");
+    }
+    const finalFee = satsPerVbyteFee ? satsPerVbyteFee * getTxEstimatedVbytesSizeByNumberOfInputsOutputs(1, 1) : fee;
+    if (finalFee <= 200) {
       throw new ValidationError("Fee must be greater than 300", {
         field: "fee",
-        value: fee
+        value: finalFee
       });
     }
     let network = this.config.getNetwork();
@@ -32551,10 +32716,13 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
     const networkJSON = networkToJSON(networkType);
     const depositTx = await this.getDepositTransaction(depositTransactionId);
     if (outputIndex === void 0) {
-      outputIndex = await this.getDepositTransactionVout(depositTransactionId);
+      outputIndex = await this.getDepositTransactionVout({
+        txid: depositTransactionId,
+        depositTx
+      });
     }
     const totalAmount = depositTx.getOutput(outputIndex).amount;
-    const creditAmountSats = Number(totalAmount) - fee;
+    const creditAmountSats = Number(totalAmount) - finalFee;
     if (creditAmountSats <= 0) {
       throw new ValidationError(
         "Fee too large. Credit amount must be greater than 0",
@@ -32602,26 +32770,14 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
     const sparkClient = await this.connectionManager.createSparkClient(
       this.config.getCoordinatorAddress()
     );
-    const transferId = (0, import_uuidv75.uuidv7)();
-    const swapResponse = await sparkClient.initiate_utxo_swap({
+    const swapResponse = await sparkClient.initiate_static_deposit_utxo_refund({
       onChainUtxo: {
         txid: (0, import_utils24.hexToBytes)(depositTransactionId),
         vout: outputIndex,
         network: networkType
       },
-      requestType: 2 /* Refund */,
-      amount: {
-        creditAmountSats: 0,
-        $case: "creditAmountSats"
-      },
       userSignature: swapResponseUserSignature,
-      sspSignature: new Uint8Array(),
-      transfer: {
-        transferId,
-        ownerIdentityPublicKey: await this.config.signer.getIdentityPublicKey(),
-        receiverIdentityPublicKey: await this.config.signer.getIdentityPublicKey()
-      },
-      spendTxSigningJob: signingJob
+      refundTxSigningJob: signingJob
     });
     if (!swapResponse) {
       throw new Error("Failed to initiate utxo swap");
@@ -32634,15 +32790,15 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
         path: 0
       },
       selfCommitment: signingNonceCommitment,
-      statechainCommitments: swapResponse.spendTxSigningResult.signingNonceCommitments,
+      statechainCommitments: swapResponse.refundTxSigningResult.signingNonceCommitments,
       verifyingKey: swapResponse.depositAddress.verifyingPublicKey
     });
     const signatureResult = await this.config.signer.aggregateFrost({
       message: spendTxSighash,
-      statechainSignatures: swapResponse.spendTxSigningResult.signatureShares,
-      statechainPublicKeys: swapResponse.spendTxSigningResult.publicKeys,
+      statechainSignatures: swapResponse.refundTxSigningResult.signatureShares,
+      statechainPublicKeys: swapResponse.refundTxSigningResult.publicKeys,
       verifyingKey: swapResponse.depositAddress.verifyingPublicKey,
-      statechainCommitments: swapResponse.spendTxSigningResult.signingNonceCommitments,
+      statechainCommitments: swapResponse.refundTxSigningResult.signingNonceCommitments,
       selfCommitment: signingNonceCommitment,
       publicKey: await this.config.signer.getStaticDepositSigningKey(0),
       selfSignature: userSignature
@@ -32695,8 +32851,13 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
     }
     return payload;
   }
-  async getDepositTransactionVout(txid) {
-    const depositTx = await this.getDepositTransaction(txid);
+  async getDepositTransactionVout({
+    txid,
+    depositTx
+  }) {
+    if (!depositTx) {
+      depositTx = await this.getDepositTransaction(txid);
+    }
     const staticDepositAddresses = new Set(
       await this.queryStaticDepositAddresses()
     );
@@ -33911,11 +34072,12 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
    * 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
+   * @returns {Promise<TransferWithUserRequest | undefined>} The transfer
    */
   async getTransferFromSsp(id) {
     const sspClient = this.getSspClient();
-    return await sspClient.getTransfer(id);
+    const transfers = await sspClient.getTransfers([id]);
+    return transfers?.[0];
   }
   /**
    * Gets a transfer, that the wallet is a participant of, in the Spark network.
@@ -34597,6 +34759,7 @@ setCrypto(globalThis.crypto);
   getSparkAddressFromTaproot,
   getTransactionSequence,
   getTransferPackageSigningPayload,
+  getTxEstimatedVbytesSizeByNumberOfInputsOutputs,
   getTxFromRawTxBytes,
   getTxFromRawTxHex,
   getTxId,