@buildonspark/spark-sdk 0.2.4 → 0.2.6

package/dist/native/index.cjs

@@ -1345,7 +1345,7 @@ __export(index_exports, {
   encodeSparkAddress: () => encodeSparkAddress,
   evaluatePolynomial: () => evaluatePolynomial,
   fieldDiv: () => fieldDiv,
-  filterTokenBalanceForTokenPublicKey: () => filterTokenBalanceForTokenPublicKey,
+  filterTokenBalanceForTokenIdentifier: () => filterTokenBalanceForTokenIdentifier,
   generateAdaptorFromSignature: () => generateAdaptorFromSignature,
   generatePolynomialForSecretSharing: () => generatePolynomialForSecretSharing,
   generateSignatureFromExistingAdaptor: () => generateSignatureFromExistingAdaptor,
@@ -1354,6 +1354,7 @@ __export(index_exports, {
   getLatestDepositTxId: () => getLatestDepositTxId,
   getNetwork: () => getNetwork,
   getNetworkFromAddress: () => getNetworkFromAddress,
+  getNetworkFromBech32mTokenIdentifier: () => getNetworkFromBech32mTokenIdentifier,
   getNetworkFromString: () => getNetworkFromString,
   getNextTransactionSequence: () => getNextTransactionSequence,
   getP2TRAddressFromPkScript: () => getP2TRAddressFromPkScript,
@@ -1367,6 +1368,7 @@ __export(index_exports, {
   getSparkAddressFromTaproot: () => getSparkAddressFromTaproot,
   getTransactionSequence: () => getTransactionSequence,
   getTransferPackageSigningPayload: () => getTransferPackageSigningPayload,
+  getTxEstimatedVbytesSizeByNumberOfInputsOutputs: () => getTxEstimatedVbytesSizeByNumberOfInputsOutputs,
   getTxFromRawTxBytes: () => getTxFromRawTxBytes,
   getTxFromRawTxHex: () => getTxFromRawTxHex,
   getTxId: () => getTxId,
@@ -16553,6 +16555,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();
@@ -16781,7 +16789,7 @@ function getLocalFrostSignerAddress() {
 var BASE_CONFIG = {
   network: "LOCAL",
   lrc20Address: getLrc20Url("LOCAL"),
-  coodinatorIdentifier: "0000000000000000000000000000000000000000000000000000000000000001",
+  coordinatorIdentifier: "0000000000000000000000000000000000000000000000000000000000000001",
   frostSignerAddress: getLocalFrostSignerAddress(),
   threshold: 2,
   signingOperators: getLocalSigningOperators(),
@@ -16800,6 +16808,9 @@ var BASE_CONFIG = {
     baseUrl: getSspUrl("LOCAL"),
     identityPublicKey: getSspIdentityPublicKey("LOCAL"),
     schemaEndpoint: getSspSchemaEndpoint("LOCAL")
+  },
+  console: {
+    otel: false
   }
 };
 var LOCAL_WALLET_CONFIG = {
@@ -16882,6 +16893,10 @@ function getSigningOperators() {
   };
 }
 function getLocalSigningOperators() {
+  const addresses = Array.from(
+    { length: 5 },
+    (_, i) => isHermeticTest ? `https://${i}.spark.minikube.local` : `https://localhost:${i + 8535}`
+  );
   const pubkeys = [
     "0322ca18fc489ae25418a0e768273c2c61cabb823edfb14feb891e9bec62016510",
     "0341727a6c41b168f07eb50865ab8c397a53c7eef628ac1020956b705e43b6cb27",
@@ -16893,31 +16908,31 @@ function getLocalSigningOperators() {
     "0000000000000000000000000000000000000000000000000000000000000001": {
       id: 0,
       identifier: "0000000000000000000000000000000000000000000000000000000000000001",
-      address: "https://localhost:8535",
+      address: addresses[0],
       identityPublicKey: pubkeys[0]
     },
     "0000000000000000000000000000000000000000000000000000000000000002": {
       id: 1,
       identifier: "0000000000000000000000000000000000000000000000000000000000000002",
-      address: "https://localhost:8536",
+      address: addresses[1],
       identityPublicKey: pubkeys[1]
     },
     "0000000000000000000000000000000000000000000000000000000000000003": {
       id: 2,
       identifier: "0000000000000000000000000000000000000000000000000000000000000003",
-      address: "https://localhost:8537",
+      address: addresses[2],
       identityPublicKey: pubkeys[2]
     },
     "0000000000000000000000000000000000000000000000000000000000000004": {
       id: 3,
       identifier: "0000000000000000000000000000000000000000000000000000000000000004",
-      address: "https://localhost:8538",
+      address: addresses[3],
       identityPublicKey: pubkeys[3]
     },
     "0000000000000000000000000000000000000000000000000000000000000005": {
       id: 4,
       identifier: "0000000000000000000000000000000000000000000000000000000000000005",
-      address: "https://localhost:8539",
+      address: addresses[4],
       identityPublicKey: pubkeys[4]
     }
   };
@@ -16935,6 +16950,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 +17006,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 +17893,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 +17907,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
   };
 }
 
@@ -18267,6 +18317,15 @@ var Bech32mTokenIdentifierTokenIdentifierNetworkPrefix = {
 function encodeBech32mTokenIdentifier(payload) {
   try {
     const words = import_base3.bech32m.toWords(payload.tokenIdentifier);
+    if (!payload.network) {
+      throw new ValidationError(
+        "Network is required to encode bech32m encoded token identifier",
+        {
+          field: "network",
+          value: payload.network
+        }
+      );
+    }
     return import_base3.bech32m.encode(
       Bech32mTokenIdentifierTokenIdentifierNetworkPrefix[payload.network],
       words,
@@ -18289,7 +18348,7 @@ function decodeBech32mTokenIdentifier(bech32mTokenIdentifier, network) {
       bech32mTokenIdentifier,
       500
     );
-    if (decoded.prefix !== Bech32mTokenIdentifierTokenIdentifierNetworkPrefix[network]) {
+    if (network && decoded.prefix !== Bech32mTokenIdentifierTokenIdentifierNetworkPrefix[network]) {
       throw new ValidationError(
         "Invalid bech32m encoded token identifier prefix",
         {
@@ -18302,7 +18361,7 @@ function decodeBech32mTokenIdentifier(bech32mTokenIdentifier, network) {
     const tokenIdentifier = import_base3.bech32m.fromWords(decoded.words);
     return {
       tokenIdentifier,
-      network
+      network: network ?? getNetworkFromBech32mTokenIdentifier(bech32mTokenIdentifier)
     };
   } catch (error) {
     if (error instanceof ValidationError) {
@@ -18318,10 +18377,35 @@ function decodeBech32mTokenIdentifier(bech32mTokenIdentifier, network) {
     );
   }
 }
+function getNetworkFromBech32mTokenIdentifier(bech32mTokenIdentifier) {
+  const separatorIndex = bech32mTokenIdentifier.indexOf("1");
+  if (separatorIndex === -1) {
+    throw new ValidationError(
+      "Invalid bech32m token identifier: no separator found",
+      {
+        field: "bech32mTokenIdentifier",
+        value: bech32mTokenIdentifier
+      }
+    );
+  }
+  const prefix = bech32mTokenIdentifier.slice(0, separatorIndex);
+  for (const [network, networkPrefix] of Object.entries(
+    Bech32mTokenIdentifierTokenIdentifierNetworkPrefix
+  )) {
+    if (networkPrefix === prefix) {
+      return network;
+    }
+  }
+  throw new ValidationError("Unknown bech32m token identifier prefix", {
+    field: "bech32mTokenIdentifier",
+    value: bech32mTokenIdentifier
+  });
+}
 
 // src/utils/token-transactions.ts
 init_buffer();
 var import_utils9 = require("@noble/curves/abstract/utils");
+var import_utils10 = require("@scure/btc-signer/utils");
 function sumAvailableTokens(outputs) {
   return outputs.reduce(
     (sum, output) => sum + BigInt((0, import_utils9.bytesToNumberBE)(output.output.tokenAmount)),
@@ -18346,12 +18430,13 @@ function checkIfSelectedOutputsAreAvailable(selectedOutputs, tokenOutputs, token
   }
   return true;
 }
-function filterTokenBalanceForTokenPublicKey(tokenBalances, publicKey) {
+function filterTokenBalanceForTokenIdentifier(tokenBalances, tokenIdentifier) {
   if (!tokenBalances) {
     return { balance: 0n };
   }
+  const tokenIdentifierBytes = decodeBech32mTokenIdentifier(tokenIdentifier).tokenIdentifier;
   const tokenBalance = [...tokenBalances.entries()].find(
-    ([, info]) => info.tokenMetadata.tokenPublicKey === publicKey
+    ([, info]) => (0, import_utils10.equalBytes)(info.tokenMetadata.rawTokenIdentifier, tokenIdentifierBytes)
   );
   if (!tokenBalance) {
     return {
@@ -18365,7 +18450,7 @@ function filterTokenBalanceForTokenPublicKey(tokenBalances, publicKey) {
 
 // src/utils/transfer_package.ts
 init_buffer();
-var import_utils10 = require("@noble/curves/abstract/utils");
+var import_utils11 = require("@noble/curves/abstract/utils");
 var import_sha23 = require("@noble/hashes/sha2");
 function getTransferPackageSigningPayload(transferID, transferPackage) {
   const encryptedPayload = transferPackage.keyTweakPackage;
@@ -18374,7 +18459,7 @@ function getTransferPackageSigningPayload(transferID, transferPackage) {
   ).map(([key, value]) => ({ key, value }));
   pairs.sort((a, b) => a.key.localeCompare(b.key));
   const encoder = new TextEncoder();
-  let message = (0, import_utils10.hexToBytes)(transferID.replaceAll("-", ""));
+  let message = (0, import_utils11.hexToBytes)(transferID.replaceAll("-", ""));
   for (const pair of pairs) {
     const keyPart = encoder.encode(pair.key + ":");
     const separator = encoder.encode(";");
@@ -18727,7 +18812,7 @@ function getEphemeralAnchorOutput() {
 
 // src/utils/unilateral-exit.ts
 init_buffer();
-var import_utils11 = require("@noble/curves/abstract/utils");
+var import_utils12 = require("@noble/curves/abstract/utils");
 var import_legacy = require("@noble/hashes/legacy");
 var import_sha24 = require("@noble/hashes/sha2");
 var btc3 = __toESM(require("@scure/btc-signer"), 1);
@@ -18742,7 +18827,7 @@ function isEphemeralAnchorOutput(script, amount) {
 }
 async function constructUnilateralExitTxs(nodeHexStrings, sparkClient, network) {
   const result = [];
-  const nodes = nodeHexStrings.map((hex) => TreeNode.decode((0, import_utils11.hexToBytes)(hex)));
+  const nodes = nodeHexStrings.map((hex) => TreeNode.decode((0, import_utils12.hexToBytes)(hex)));
   const nodeMap = /* @__PURE__ */ new Map();
   for (const node of nodes) {
     nodeMap.set(node.id, node);
@@ -18798,10 +18883,10 @@ async function constructUnilateralExitTxs(nodeHexStrings, sparkClient, network)
       }
     }
     for (const chainNode of chain) {
-      const nodeTx = (0, import_utils11.bytesToHex)(chainNode.nodeTx);
+      const nodeTx = (0, import_utils12.bytesToHex)(chainNode.nodeTx);
       transactions.push(nodeTx);
       if (chainNode.id === node.id) {
-        const refundTx = (0, import_utils11.bytesToHex)(chainNode.refundTx);
+        const refundTx = (0, import_utils12.bytesToHex)(chainNode.refundTx);
         transactions.push(refundTx);
       }
     }
@@ -18831,7 +18916,7 @@ async function constructUnilateralExitFeeBumpPackages(nodeHexStrings, utxos, fee
           `Node hex string at index ${i} appears to be a raw transaction hex, not a TreeNode protobuf. Use 'leafidtohex' command to convert node IDs to proper hex strings.`
         );
       }
-      const nodeBytes = (0, import_utils11.hexToBytes)(hex);
+      const nodeBytes = (0, import_utils12.hexToBytes)(hex);
       const node = TreeNode.decode(nodeBytes);
       if (!node.id) {
         throw new Error(
@@ -18907,7 +18992,7 @@ async function constructUnilateralExitFeeBumpPackages(nodeHexStrings, utxos, fee
       }
     }
     for (const chainNode of chain) {
-      let nodeTxHex = (0, import_utils11.bytesToHex)(chainNode.nodeTx);
+      let nodeTxHex = (0, import_utils12.bytesToHex)(chainNode.nodeTx);
       try {
         const txObj = getTxFromRawTxHex(nodeTxHex);
         const txid = getTxId(txObj);
@@ -18924,7 +19009,7 @@ async function constructUnilateralExitFeeBumpPackages(nodeHexStrings, utxos, fee
         for (let i = txObj.outputsLength - 1; i >= 0; i--) {
           const output = txObj.getOutput(i);
           if (output?.amount === 0n && output.script) {
-            anchorOutputScriptHex = (0, import_utils11.bytesToHex)(output.script);
+            anchorOutputScriptHex = (0, import_utils12.bytesToHex)(output.script);
             break;
           }
         }
@@ -18945,11 +19030,11 @@ async function constructUnilateralExitFeeBumpPackages(nodeHexStrings, utxos, fee
         usedUtxos,
         correctedParentTx
       } = constructFeeBumpTx(nodeTxHex, availableUtxos, feeRate, void 0);
-      const feeBumpTx = btc3.Transaction.fromPSBT((0, import_utils11.hexToBytes)(nodeFeeBumpPsbt));
+      const feeBumpTx = btc3.Transaction.fromPSBT((0, import_utils12.hexToBytes)(nodeFeeBumpPsbt));
       var feeBumpOut = feeBumpTx.outputsLength === 1 ? feeBumpTx.getOutput(0) : null;
       var feeBumpOutPubKey = null;
       for (const usedUtxo of usedUtxos) {
-        if (feeBumpOut && (0, import_utils11.bytesToHex)(feeBumpOut.script) == usedUtxo.script) {
+        if (feeBumpOut && (0, import_utils12.bytesToHex)(feeBumpOut.script) == usedUtxo.script) {
           feeBumpOutPubKey = usedUtxo.publicKey;
         }
         const index = availableUtxos.findIndex(
@@ -18964,20 +19049,20 @@ async function constructUnilateralExitFeeBumpPackages(nodeHexStrings, utxos, fee
           txid: getTxId(feeBumpTx),
           vout: 0,
           value: feeBumpOut.amount,
-          script: (0, import_utils11.bytesToHex)(feeBumpOut.script),
+          script: (0, import_utils12.bytesToHex)(feeBumpOut.script),
           publicKey: feeBumpOutPubKey
         });
       const finalNodeTx = correctedParentTx || nodeTxHex;
       txPackages.push({ tx: finalNodeTx, feeBumpPsbt: nodeFeeBumpPsbt });
       if (chainNode.id === node.id) {
-        let refundTxHex = (0, import_utils11.bytesToHex)(chainNode.refundTx);
+        let refundTxHex = (0, import_utils12.bytesToHex)(chainNode.refundTx);
         try {
           const txObj = getTxFromRawTxHex(refundTxHex);
           let anchorOutputScriptHex;
           for (let i = txObj.outputsLength - 1; i >= 0; i--) {
             const output = txObj.getOutput(i);
             if (output?.amount === 0n && output.script) {
-              anchorOutputScriptHex = (0, import_utils11.bytesToHex)(output.script);
+              anchorOutputScriptHex = (0, import_utils12.bytesToHex)(output.script);
               break;
             }
           }
@@ -19000,12 +19085,12 @@ async function constructUnilateralExitFeeBumpPackages(nodeHexStrings, utxos, fee
           void 0
         );
         const feeBumpTx2 = btc3.Transaction.fromPSBT(
-          (0, import_utils11.hexToBytes)(refundFeeBump.feeBumpPsbt)
+          (0, import_utils12.hexToBytes)(refundFeeBump.feeBumpPsbt)
         );
         var feeBumpOut = feeBumpTx2.outputsLength === 1 ? feeBumpTx2.getOutput(0) : null;
         var feeBumpOutPubKey = null;
         for (const usedUtxo of usedUtxos) {
-          if (feeBumpOut && (0, import_utils11.bytesToHex)(feeBumpOut.script) == usedUtxo.script) {
+          if (feeBumpOut && (0, import_utils12.bytesToHex)(feeBumpOut.script) == usedUtxo.script) {
             feeBumpOutPubKey = usedUtxo.publicKey;
           }
           const index = availableUtxos.findIndex(
@@ -19020,7 +19105,7 @@ async function constructUnilateralExitFeeBumpPackages(nodeHexStrings, utxos, fee
             txid: getTxId(feeBumpTx2),
             vout: 0,
             value: feeBumpOut.amount,
-            script: (0, import_utils11.bytesToHex)(feeBumpOut.script),
+            script: (0, import_utils12.bytesToHex)(feeBumpOut.script),
             publicKey: feeBumpOutPubKey
           });
         txPackages.push({
@@ -19115,10 +19200,10 @@ function constructFeeBumpTx(txHex, utxos, feeRate, previousFeeBumpTx) {
     if (!fundingUtxo) {
       throw new Error(`UTXO at index ${i} is undefined`);
     }
-    const pubKeyHash = hash160((0, import_utils11.hexToBytes)(fundingUtxo.publicKey));
+    const pubKeyHash = hash160((0, import_utils12.hexToBytes)(fundingUtxo.publicKey));
     const scriptToUse = new Uint8Array([0, 20, ...pubKeyHash]);
-    const providedScript = (0, import_utils11.hexToBytes)(fundingUtxo.script);
-    if ((0, import_utils11.bytesToHex)(scriptToUse) !== (0, import_utils11.bytesToHex)(providedScript)) {
+    const providedScript = (0, import_utils12.hexToBytes)(fundingUtxo.script);
+    if ((0, import_utils12.bytesToHex)(scriptToUse) !== (0, import_utils12.bytesToHex)(providedScript)) {
       throw new Error(
         `\u274C  Derived script doesn't match provided script for UTXO ${i + 1}.`
       );
@@ -19183,7 +19268,7 @@ function constructFeeBumpTx(txHex, utxos, feeRate, previousFeeBumpTx) {
   }
   let psbtHex;
   try {
-    psbtHex = (0, import_utils11.bytesToHex)(builder.toPSBT());
+    psbtHex = (0, import_utils12.bytesToHex)(builder.toPSBT());
   } catch (error) {
     throw new Error(`Failed to extract transaction: ${error}`);
   }
@@ -19358,13 +19443,13 @@ var NativeSparkFrost = class {
 init_buffer();
 var import_secp256k17 = require("@bitcoinerlab/secp256k1");
 var import_lrc20_sdk2 = require("@buildonspark/lrc20-sdk");
-var import_utils12 = require("@noble/curves/abstract/utils");
+var import_utils13 = require("@noble/curves/abstract/utils");
 var import_secp256k18 = require("@noble/curves/secp256k1");
 var import_sha25 = require("@noble/hashes/sha2");
 var import_bip32 = require("@scure/bip32");
 var import_bip39 = require("@scure/bip39");
 var import_english = require("@scure/bip39/wordlists/english");
-var import_utils13 = require("@scure/btc-signer/utils");
+var import_utils14 = require("@scure/btc-signer/utils");
 var ecies = __toESM(require("eciesjs"), 1);
 
 // src/constants.ts
@@ -19372,7 +19457,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.6" : "unknown";
 var baseEnvStr = "unknown";
 if (isBun) {
   const bunVersion = "version" in globalThis.Bun ? globalThis.Bun.version : "unknown-version";
@@ -19481,7 +19566,7 @@ var DefaultSparkSigner = class {
       });
     }
     const receiverEciesPrivKey = ecies.PrivateKey.fromHex(
-      (0, import_utils12.bytesToHex)(this.identityKey.privateKey)
+      (0, import_utils13.bytesToHex)(this.identityKey.privateKey)
     );
     const privateKey = ecies.decrypt(receiverEciesPrivKey.toHex(), ciphertext);
     return privateKey;
@@ -19615,7 +19700,7 @@ var DefaultSparkSigner = class {
     threshold,
     numShares
   }) {
-    const secretAsInt = (0, import_utils12.bytesToNumberBE)(secret);
+    const secretAsInt = (0, import_utils13.bytesToNumberBE)(secret);
     return splitSecretWithProofs(secretAsInt, curveOrder, threshold, numShares);
   }
   async signFrost({
@@ -19691,7 +19776,7 @@ var DefaultSparkSigner = class {
   }
   async createSparkWalletFromSeed(seed, accountNumber) {
     if (typeof seed === "string") {
-      seed = (0, import_utils12.hexToBytes)(seed);
+      seed = (0, import_utils13.hexToBytes)(seed);
     }
     const {
       identityKey,
@@ -19703,7 +19788,7 @@ var DefaultSparkSigner = class {
     this.depositKey = depositKey;
     this.signingKey = signingKey.hdKey;
     this.staticDepositKey = staticDepositKey.hdKey;
-    return (0, import_utils12.bytesToHex)(identityKey.publicKey);
+    return (0, import_utils13.bytesToHex)(identityKey.publicKey);
   }
   async signMessageWithIdentityKey(message, compact) {
     if (!this.identityKey?.privateKey) {
@@ -19724,7 +19809,7 @@ var DefaultSparkSigner = class {
       });
     }
     const receiverEciesPrivKey = ecies.PrivateKey.fromHex(
-      (0, import_utils12.bytesToHex)(this.identityKey.privateKey)
+      (0, import_utils13.bytesToHex)(this.identityKey.privateKey)
     );
     const privateKey = ecies.decrypt(receiverEciesPrivKey.toHex(), ciphertext);
     const publicKey = import_secp256k18.secp256k1.getPublicKey(privateKey);
@@ -19776,15 +19861,15 @@ var DefaultSparkSigner = class {
   }
   signTransactionIndex(tx, index, publicKey) {
     let privateKey;
-    if ((0, import_utils12.equalBytes)(publicKey, this.identityKey?.publicKey ?? new Uint8Array())) {
+    if ((0, import_utils13.equalBytes)(publicKey, this.identityKey?.publicKey ?? new Uint8Array())) {
       privateKey = this.identityKey?.privateKey;
-    } else if ((0, import_utils12.equalBytes)(publicKey, this.depositKey?.publicKey ?? new Uint8Array())) {
+    } else if ((0, import_utils13.equalBytes)(publicKey, this.depositKey?.publicKey ?? new Uint8Array())) {
       privateKey = this.depositKey?.privateKey;
     }
     if (!privateKey) {
       throw new ValidationError("Private key not found for public key", {
         field: "privateKey",
-        value: (0, import_utils12.bytesToHex)(publicKey)
+        value: (0, import_utils13.bytesToHex)(publicKey)
       });
     }
     tx.signIdx(privateKey, index);
@@ -19857,7 +19942,7 @@ var ReactNativeSparkSigner = class extends DefaultSparkSigner {
 // src/spark-wallet/spark-wallet.ts
 init_buffer();
 var import_core12 = require("@lightsparkdev/core");
-var import_utils24 = require("@noble/curves/abstract/utils");
+var import_utils25 = require("@noble/curves/abstract/utils");
 var import_secp256k115 = require("@noble/curves/secp256k1");
 var import_bip392 = require("@scure/bip39");
 var import_english2 = require("@scure/bip39/wordlists/english");
@@ -20465,15 +20550,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 +20919,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;
+        });
       }
     });
   }
@@ -21002,7 +21124,7 @@ var WalletConfigService = class {
     }
   }
   getCoordinatorAddress() {
-    const coordinator = this.config.signingOperators[this.config.coodinatorIdentifier];
+    const coordinator = this.config.signingOperators[this.config.coordinatorIdentifier];
     if (!coordinator) {
       throw new ConfigurationError(
         "Coordinator not found in signing operators",
@@ -21023,7 +21145,7 @@ var WalletConfigService = class {
     return this.config.threshold;
   }
   getCoordinatorIdentifier() {
-    return this.config.coodinatorIdentifier;
+    return this.config.coordinatorIdentifier;
   }
   getExpectedWithdrawBondSats() {
     return this.config.expectedWithdrawBondSats;
@@ -21064,9 +21186,17 @@ var WalletConfigService = class {
   getElectrsUrl() {
     return this.config.electrsUrl;
   }
+  getSspBaseUrl() {
+    return this.config.sspClientOptions.baseUrl;
+  }
   getSspIdentityPublicKey() {
     return this.config.sspClientOptions.identityPublicKey;
   }
+  getConsoleOptions() {
+    return {
+      ...this.config.console
+    };
+  }
 };
 
 // src/services/connection.ts
@@ -24881,7 +25011,7 @@ var import_uuidv73 = require("uuidv7");
 
 // src/services/transfer.ts
 init_buffer();
-var import_utils14 = require("@noble/curves/abstract/utils");
+var import_utils15 = require("@noble/curves/abstract/utils");
 var import_secp256k19 = require("@noble/curves/secp256k1");
 var import_sha28 = require("@noble/hashes/sha2");
 var import_btc_signer2 = require("@scure/btc-signer");
@@ -25252,7 +25382,7 @@ var BaseTransferService = class {
   }
   async prepareSendTransferKeyTweaks(transferID, receiverIdentityPubkey, leaves, cpfpRefundSignatureMap, directRefundSignatureMap, directFromCpfpRefundSignatureMap) {
     const receiverEciesPubKey = ecies2.PublicKey.fromHex(
-      (0, import_utils14.bytesToHex)(receiverIdentityPubkey)
+      (0, import_utils15.bytesToHex)(receiverIdentityPubkey)
     );
     const leavesTweaksMap = /* @__PURE__ */ new Map();
     for (const leaf of leaves) {
@@ -25293,7 +25423,7 @@ var BaseTransferService = class {
         throw new Error(`Share not found for operator ${operator.id}`);
       }
       const pubkeyTweak = import_secp256k19.secp256k1.getPublicKey(
-        (0, import_utils14.numberToBytesBE)(share.share, 32),
+        (0, import_utils15.numberToBytesBE)(share.share, 32),
         true
       );
       pubkeySharesTweak.set(identifier, pubkeyTweak);
@@ -25318,7 +25448,7 @@ var BaseTransferService = class {
       leafTweaksMap.set(identifier, {
         leafId: leaf.leaf.id,
         secretShareTweak: {
-          secretShare: (0, import_utils14.numberToBytesBE)(share.share, 32),
+          secretShare: (0, import_utils15.numberToBytesBE)(share.share, 32),
           proofs: share.proofs
         },
         pubkeySharesTweak: Object.fromEntries(pubkeySharesTweak),
@@ -25341,7 +25471,7 @@ var BaseTransferService = class {
     return void 0;
   }
   compareTransfers(transfer1, transfer2) {
-    return transfer1.id === transfer2.id && (0, import_utils14.equalBytes)(
+    return transfer1.id === transfer2.id && (0, import_utils15.equalBytes)(
       transfer1.senderIdentityPublicKey,
       transfer2.senderIdentityPublicKey
     ) && transfer1.status === transfer2.status && transfer1.totalValue === transfer2.totalValue && transfer1.expiryTime?.getTime() === transfer2.expiryTime?.getTime() && transfer1.leaves.length === transfer2.leaves.length;
@@ -25638,7 +25768,7 @@ var TransferService = class extends BaseTransferService {
       }
       const nodeTx = getTxFromRawTxBytes(leaf.leaf.nodeTx);
       const cpfpNodeOutPoint = {
-        txid: (0, import_utils14.hexToBytes)(getTxId(nodeTx)),
+        txid: (0, import_utils15.hexToBytes)(getTxId(nodeTx)),
         index: 0
       };
       let directNodeTx;
@@ -25646,7 +25776,7 @@ var TransferService = class extends BaseTransferService {
       if (leaf.leaf.directTx.length > 0) {
         directNodeTx = getTxFromRawTxBytes(leaf.leaf.directTx);
         directNodeOutPoint = {
-          txid: (0, import_utils14.hexToBytes)(getTxId(directNodeTx)),
+          txid: (0, import_utils15.hexToBytes)(getTxId(directNodeTx)),
           index: 0
         };
       }
@@ -25788,7 +25918,7 @@ var TransferService = class extends BaseTransferService {
         throw new Error(`Share not found for operator ${operator.id}`);
       }
       const pubkeyTweak = import_secp256k19.secp256k1.getPublicKey(
-        (0, import_utils14.numberToBytesBE)(share.share, 32)
+        (0, import_utils15.numberToBytesBE)(share.share, 32)
       );
       pubkeySharesTweak.set(identifier, pubkeyTweak);
     }
@@ -25801,7 +25931,7 @@ var TransferService = class extends BaseTransferService {
       leafTweaksMap.set(identifier, {
         leafId: leaf.leaf.id,
         secretShareTweak: {
-          secretShare: (0, import_utils14.numberToBytesBE)(share.share, 32),
+          secretShare: (0, import_utils15.numberToBytesBE)(share.share, 32),
           proofs: share.proofs
         },
         pubkeySharesTweak: Object.fromEntries(pubkeySharesTweak)
@@ -25981,13 +26111,13 @@ var TransferService = class extends BaseTransferService {
       });
     }
     const newCpfpRefundOutPoint = {
-      txid: (0, import_utils14.hexToBytes)(getTxId(cpfpNodeTx)),
+      txid: (0, import_utils15.hexToBytes)(getTxId(cpfpNodeTx)),
       index: 0
     };
     let newDirectRefundOutPoint;
     if (newDirectNodeTx) {
       newDirectRefundOutPoint = {
-        txid: (0, import_utils14.hexToBytes)(getTxId(newDirectNodeTx)),
+        txid: (0, import_utils15.hexToBytes)(getTxId(newDirectNodeTx)),
         index: 0
       };
     }
@@ -26115,7 +26245,7 @@ var TransferService = class extends BaseTransferService {
     const refundTx = getTxFromRawTxBytes(node.refundTx);
     const refundSequence = refundTx.getInput(0).sequence || 0;
     const newNodeOutPoint = {
-      txid: (0, import_utils14.hexToBytes)(getTxId(nodeTx)),
+      txid: (0, import_utils15.hexToBytes)(getTxId(nodeTx)),
       index: 0
     };
     const {
@@ -26152,13 +26282,13 @@ var TransferService = class extends BaseTransferService {
       });
     }
     const newCpfpRefundOutPoint = {
-      txid: (0, import_utils14.hexToBytes)(getTxId(newNodeTx)),
+      txid: (0, import_utils15.hexToBytes)(getTxId(newNodeTx)),
       index: 0
     };
     let newDirectRefundOutPoint;
     if (newDirectNodeTx) {
       newDirectRefundOutPoint = {
-        txid: (0, import_utils14.hexToBytes)(getTxId(newDirectNodeTx)),
+        txid: (0, import_utils15.hexToBytes)(getTxId(newDirectNodeTx)),
         index: 0
       };
     }
@@ -26392,13 +26522,13 @@ var TransferService = class extends BaseTransferService {
     };
     const signingPublicKey = await this.config.signer.getPublicKeyFromDerivation(keyDerivation);
     const cpfpRefundOutPoint = {
-      txid: (0, import_utils14.hexToBytes)(getTxId(nodeTx)),
+      txid: (0, import_utils15.hexToBytes)(getTxId(nodeTx)),
       index: 0
     };
     let directRefundOutPoint;
     if (directNodeTx) {
       directRefundOutPoint = {
-        txid: (0, import_utils14.hexToBytes)(getTxId(directNodeTx)),
+        txid: (0, import_utils15.hexToBytes)(getTxId(directNodeTx)),
         index: 0
       };
     }
@@ -26774,9 +26904,9 @@ var CoopExitService = class extends BaseTransferService {
 init_buffer();
 var import_secp256k110 = require("@noble/curves/secp256k1");
 var import_sha29 = require("@noble/hashes/sha2");
-var import_utils15 = require("@noble/hashes/utils");
+var import_utils16 = require("@noble/hashes/utils");
 var import_btc_signer4 = require("@scure/btc-signer");
-var import_utils16 = require("@scure/btc-signer/utils");
+var import_utils17 = require("@scure/btc-signer/utils");
 var DepositService = class {
   config;
   connectionManager;
@@ -26827,7 +26957,7 @@ var DepositService = class {
       if (operator.identifier === this.config.getCoordinatorIdentifier()) {
         continue;
       }
-      const operatorPubkey2 = (0, import_utils15.hexToBytes)(operator.identityPublicKey);
+      const operatorPubkey2 = (0, import_utils16.hexToBytes)(operator.identityPublicKey);
       const operatorSig = address2.depositAddressProof.addressSignatures[operator.identifier];
       if (!operatorSig) {
         throw new ValidationError("Operator signature not found", {
@@ -26912,7 +27042,7 @@ var DepositService = class {
       });
     }
     const depositOutPoint = {
-      txid: (0, import_utils15.hexToBytes)(getTxId(depositTx)),
+      txid: (0, import_utils16.hexToBytes)(getTxId(depositTx)),
       index: vout
     };
     const depositTxOut = {
@@ -26931,8 +27061,8 @@ var DepositService = class {
     const { cpfpRefundTx, directRefundTx, directFromCpfpRefundTx } = createRefundTxs({
       sequence: INITIAL_SEQUENCE,
       directSequence: INITIAL_DIRECT_SEQUENCE,
-      input: { txid: (0, import_utils15.hexToBytes)(getTxId(cpfpRootTx)), index: 0 },
-      directInput: { txid: (0, import_utils15.hexToBytes)(getTxId(directRootTx)), index: 0 },
+      input: { txid: (0, import_utils16.hexToBytes)(getTxId(cpfpRootTx)), index: 0 },
+      directInput: { txid: (0, import_utils16.hexToBytes)(getTxId(directRootTx)), index: 0 },
       amountSats: amount,
       receivingPubkey: signingPubKey,
       network: this.config.getNetwork()
@@ -27062,7 +27192,7 @@ var DepositService = class {
         }
       );
     }
-    if (!(0, import_utils16.equalBytes)(treeResp.rootNodeSignatureShares.verifyingKey, verifyingKey)) {
+    if (!(0, import_utils17.equalBytes)(treeResp.rootNodeSignatureShares.verifyingKey, verifyingKey)) {
       throw new ValidationError("Verifying key mismatch", {
         field: "verifyingKey",
         value: treeResp.rootNodeSignatureShares.verifyingKey,
@@ -27226,7 +27356,7 @@ var DepositService = class {
       });
     }
     const depositOutPoint = {
-      txid: (0, import_utils15.hexToBytes)(getTxId(depositTx)),
+      txid: (0, import_utils16.hexToBytes)(getTxId(depositTx)),
       index: vout
     };
     const depositTxOut = {
@@ -27239,7 +27369,7 @@ var DepositService = class {
     const signingPubKey = await this.config.signer.getPublicKeyFromDerivation(keyDerivation);
     const { cpfpRefundTx } = createRefundTxs({
       sequence: INITIAL_SEQUENCE,
-      input: { txid: (0, import_utils15.hexToBytes)(getTxId(cpfpRootTx)), index: 0 },
+      input: { txid: (0, import_utils16.hexToBytes)(getTxId(cpfpRootTx)), index: 0 },
       amountSats: amount,
       receivingPubkey: signingPubKey,
       network: this.config.getNetwork()
@@ -27309,7 +27439,7 @@ var DepositService = class {
         }
       );
     }
-    if (!(0, import_utils16.equalBytes)(treeResp.rootNodeSignatureShares.verifyingKey, verifyingKey)) {
+    if (!(0, import_utils17.equalBytes)(treeResp.rootNodeSignatureShares.verifyingKey, verifyingKey)) {
       throw new ValidationError("Verifying key mismatch", {
         field: "verifyingKey",
         value: treeResp.rootNodeSignatureShares.verifyingKey,
@@ -27385,7 +27515,7 @@ var DepositService = class {
 
 // src/services/lightning.ts
 init_buffer();
-var import_utils17 = require("@noble/curves/abstract/utils");
+var import_utils18 = require("@noble/curves/abstract/utils");
 var import_secp256k111 = require("@noble/curves/secp256k1");
 var import_sha210 = require("@noble/hashes/sha2");
 var import_uuidv74 = require("uuidv7");
@@ -27472,8 +27602,8 @@ var LightningService = class {
   }) {
     const crypto = getCrypto();
     const randBytes = crypto.getRandomValues(new Uint8Array(32));
-    const preimage = (0, import_utils17.numberToBytesBE)(
-      (0, import_utils17.bytesToNumberBE)(randBytes) % import_secp256k111.secp256k1.CURVE.n,
+    const preimage = (0, import_utils18.numberToBytesBE)(
+      (0, import_utils18.bytesToNumberBE)(randBytes) % import_secp256k111.secp256k1.CURVE.n,
       32
     );
     return await this.createLightningInvoiceWithPreImage({
@@ -27528,12 +27658,12 @@ var LightningService = class {
         const sparkClient = await this.connectionManager.createSparkClient(
           operator.address
         );
-        const userIdentityPublicKey = receiverIdentityPubkey ? (0, import_utils17.hexToBytes)(receiverIdentityPubkey) : await this.config.signer.getIdentityPublicKey();
+        const userIdentityPublicKey = receiverIdentityPubkey ? (0, import_utils18.hexToBytes)(receiverIdentityPubkey) : await this.config.signer.getIdentityPublicKey();
         try {
           await sparkClient.store_preimage_share({
             paymentHash,
             preimageShare: {
-              secretShare: (0, import_utils17.numberToBytesBE)(share.share, 32),
+              secretShare: (0, import_utils18.numberToBytesBE)(share.share, 32),
               proofs: share.proofs
             },
             threshold: this.config.getThreshold(),
@@ -27734,9 +27864,9 @@ var LightningService = class {
 
 // src/services/token-transactions.ts
 init_buffer();
-var import_utils18 = require("@noble/curves/abstract/utils");
+var import_utils19 = require("@noble/curves/abstract/utils");
 var import_secp256k113 = require("@noble/curves/secp256k1");
-var import_utils19 = require("@noble/hashes/utils");
+var import_utils20 = require("@noble/hashes/utils");
 
 // src/utils/token-hashing.ts
 init_buffer();
@@ -29184,7 +29314,7 @@ var TokenTransactionService = class {
         this.config.getNetworkType()
       );
       return {
-        receiverSparkAddress: (0, import_utils19.hexToBytes)(receiverAddress.identityPublicKey),
+        receiverSparkAddress: (0, import_utils20.hexToBytes)(receiverAddress.identityPublicKey),
         rawTokenIdentifier,
         tokenPublicKey,
         // Remove for full v0 deprecation
@@ -29222,7 +29352,7 @@ var TokenTransactionService = class {
     const tokenOutputs = tokenOutputData.map((output) => ({
       ownerPublicKey: output.receiverSparkAddress,
       tokenPublicKey: output.tokenPublicKey,
-      tokenAmount: (0, import_utils18.numberToBytesBE)(output.tokenAmount, 16)
+      tokenAmount: (0, import_utils19.numberToBytesBE)(output.tokenAmount, 16)
     }));
     if (availableTokenAmount > totalRequestedAmount) {
       const changeAmount = availableTokenAmount - totalRequestedAmount;
@@ -29230,7 +29360,7 @@ var TokenTransactionService = class {
       tokenOutputs.push({
         ownerPublicKey: await this.config.signer.getIdentityPublicKey(),
         tokenPublicKey: firstTokenPublicKey,
-        tokenAmount: (0, import_utils18.numberToBytesBE)(changeAmount, 16)
+        tokenAmount: (0, import_utils19.numberToBytesBE)(changeAmount, 16)
       });
     }
     return {
@@ -29261,7 +29391,7 @@ var TokenTransactionService = class {
       (output) => ({
         ownerPublicKey: output.receiverSparkAddress,
         tokenIdentifier: output.rawTokenIdentifier,
-        tokenAmount: (0, import_utils18.numberToBytesBE)(output.tokenAmount, 16)
+        tokenAmount: (0, import_utils19.numberToBytesBE)(output.tokenAmount, 16)
       })
     );
     if (availableTokenAmount > totalRequestedAmount) {
@@ -29270,7 +29400,7 @@ var TokenTransactionService = class {
       tokenOutputs.push({
         ownerPublicKey: await this.config.signer.getIdentityPublicKey(),
         tokenIdentifier: firstTokenIdentifierBytes,
-        tokenAmount: (0, import_utils18.numberToBytesBE)(changeAmount, 16)
+        tokenAmount: (0, import_utils19.numberToBytesBE)(changeAmount, 16)
       });
     }
     return {
@@ -29296,7 +29426,7 @@ var TokenTransactionService = class {
     for (const [_, operator] of Object.entries(
       this.config.getSigningOperators()
     )) {
-      operatorKeys.push((0, import_utils19.hexToBytes)(operator.identityPublicKey));
+      operatorKeys.push((0, import_utils20.hexToBytes)(operator.identityPublicKey));
     }
     return operatorKeys;
   }
@@ -29380,7 +29510,7 @@ var TokenTransactionService = class {
               {
                 field: "revocationCommitment",
                 value: derivedRevocationCommitment,
-                expected: (0, import_utils18.bytesToHex)(outputsToSpendCommitments[outputIndex]),
+                expected: (0, import_utils19.bytesToHex)(outputsToSpendCommitments[outputIndex]),
                 outputIndex
               }
             )
@@ -29406,7 +29536,7 @@ var TokenTransactionService = class {
         threshold
       );
     }
-    return (0, import_utils18.bytesToHex)(finalTokenTransactionHash);
+    return (0, import_utils19.bytesToHex)(finalTokenTransactionHash);
   }
   async broadcastTokenTransactionV1(tokenTransaction, signingOperators, outputsToSpendSigningPublicKeys, outputsToSpendCommitments) {
     const { finalTokenTransaction, finalTokenTransactionHash, threshold } = await this.startTokenTransaction(
@@ -29420,7 +29550,7 @@ var TokenTransactionService = class {
       finalTokenTransactionHash,
       signingOperators
     );
-    return (0, import_utils18.bytesToHex)(finalTokenTransactionHash);
+    return (0, import_utils19.bytesToHex)(finalTokenTransactionHash);
   }
   async startTokenTransactionV0(tokenTransaction, signingOperators, outputsToSpendSigningPublicKeys, outputsToSpendCommitments) {
     const sparkClient = await this.connectionManager.createSparkClient(
@@ -29644,7 +29774,7 @@ var TokenTransactionService = class {
           const identityPublicKey = await this.config.signer.getIdentityPublicKey();
           const payload = {
             finalTokenTransactionHash,
-            operatorIdentityPublicKey: (0, import_utils19.hexToBytes)(operator.identityPublicKey)
+            operatorIdentityPublicKey: (0, import_utils20.hexToBytes)(operator.identityPublicKey)
           };
           const payloadHash = await hashOperatorSpecificTokenTransactionSignablePayload(payload);
           let operatorSpecificSignatures = [];
@@ -29851,19 +29981,27 @@ var TokenTransactionService = class {
       issuerPublicKeys,
       tokenTransactionHashes,
       tokenIdentifiers,
-      outputIds
+      outputIds,
+      pageSize,
+      offset
     } = params;
     const sparkClient = await this.connectionManager.createSparkClient(
       this.config.getCoordinatorAddress()
     );
     let queryParams = {
-      tokenPublicKeys: issuerPublicKeys?.map(import_utils19.hexToBytes),
-      ownerPublicKeys: ownerPublicKeys?.map(import_utils19.hexToBytes),
-      tokenIdentifiers: tokenIdentifiers?.map(import_utils19.hexToBytes),
-      tokenTransactionHashes: tokenTransactionHashes?.map(import_utils19.hexToBytes),
+      tokenPublicKeys: issuerPublicKeys?.map(import_utils20.hexToBytes),
+      ownerPublicKeys: ownerPublicKeys?.map(import_utils20.hexToBytes),
+      tokenIdentifiers: tokenIdentifiers?.map((identifier) => {
+        const { tokenIdentifier } = decodeBech32mTokenIdentifier(
+          identifier,
+          this.config.getNetworkType()
+        );
+        return tokenIdentifier;
+      }),
+      tokenTransactionHashes: tokenTransactionHashes?.map(import_utils20.hexToBytes),
       outputIds: outputIds || [],
-      limit: 100,
-      offset: 0
+      limit: pageSize,
+      offset
     };
     try {
       const response = await sparkClient.query_token_transactions(queryParams);
@@ -29913,10 +30051,16 @@ var TokenTransactionService = class {
       this.config.getCoordinatorAddress()
     );
     let queryParams = {
-      issuerPublicKeys: issuerPublicKeys?.map(import_utils19.hexToBytes),
-      ownerPublicKeys: ownerPublicKeys?.map(import_utils19.hexToBytes),
-      tokenIdentifiers: tokenIdentifiers?.map(import_utils19.hexToBytes),
-      tokenTransactionHashes: tokenTransactionHashes?.map(import_utils19.hexToBytes),
+      issuerPublicKeys: issuerPublicKeys?.map(import_utils20.hexToBytes),
+      ownerPublicKeys: ownerPublicKeys?.map(import_utils20.hexToBytes),
+      tokenIdentifiers: tokenIdentifiers?.map((identifier) => {
+        const { tokenIdentifier } = decodeBech32mTokenIdentifier(
+          identifier,
+          this.config.getNetworkType()
+        );
+        return tokenIdentifier;
+      }),
+      tokenTransactionHashes: tokenTransactionHashes?.map(import_utils20.hexToBytes),
       outputIds: outputIds || [],
       limit: pageSize,
       offset
@@ -29945,7 +30089,7 @@ var TokenTransactionService = class {
       });
     }
     const exactMatch = tokenOutputs.find(
-      (item) => (0, import_utils18.bytesToNumberBE)(item.output.tokenAmount) === tokenAmount
+      (item) => (0, import_utils19.bytesToNumberBE)(item.output.tokenAmount) === tokenAmount
     );
     if (exactMatch) {
       return [exactMatch];
@@ -29956,7 +30100,7 @@ var TokenTransactionService = class {
     for (const outputWithPreviousTransactionData of tokenOutputs) {
       if (remainingAmount <= 0n) break;
       selectedOutputs.push(outputWithPreviousTransactionData);
-      remainingAmount -= (0, import_utils18.bytesToNumberBE)(
+      remainingAmount -= (0, import_utils19.bytesToNumberBE)(
         outputWithPreviousTransactionData.output.tokenAmount
       );
     }
@@ -29972,13 +30116,13 @@ var TokenTransactionService = class {
     if (strategy === "SMALL_FIRST") {
       tokenOutputs.sort((a, b) => {
         return Number(
-          (0, import_utils18.bytesToNumberBE)(a.output.tokenAmount) - (0, import_utils18.bytesToNumberBE)(b.output.tokenAmount)
+          (0, import_utils19.bytesToNumberBE)(a.output.tokenAmount) - (0, import_utils19.bytesToNumberBE)(b.output.tokenAmount)
         );
       });
     } else {
       tokenOutputs.sort((a, b) => {
         return Number(
-          (0, import_utils18.bytesToNumberBE)(b.output.tokenAmount) - (0, import_utils18.bytesToNumberBE)(a.output.tokenAmount)
+          (0, import_utils19.bytesToNumberBE)(b.output.tokenAmount) - (0, import_utils19.bytesToNumberBE)(a.output.tokenAmount)
         );
       });
     }
@@ -29986,7 +30130,7 @@ var TokenTransactionService = class {
   // Helper function for deciding if the signer public key is the identity public key
   async signMessageWithKey(message, publicKey) {
     const tokenSignatures = this.config.getTokenSignatures();
-    if ((0, import_utils18.bytesToHex)(publicKey) === (0, import_utils18.bytesToHex)(await this.config.signer.getIdentityPublicKey())) {
+    if ((0, import_utils19.bytesToHex)(publicKey) === (0, import_utils19.bytesToHex)(await this.config.signer.getIdentityPublicKey())) {
       if (tokenSignatures === "SCHNORR") {
         return await this.config.signer.signSchnorrWithIdentityKey(message);
       } else {
@@ -29995,8 +30139,8 @@ var TokenTransactionService = class {
     } else {
       throw new ValidationError("Invalid public key", {
         field: "publicKey",
-        value: (0, import_utils18.bytesToHex)(publicKey),
-        expected: (0, import_utils18.bytesToHex)(await this.config.signer.getIdentityPublicKey())
+        value: (0, import_utils19.bytesToHex)(publicKey),
+        expected: (0, import_utils19.bytesToHex)(await this.config.signer.getIdentityPublicKey())
       });
     }
   }
@@ -30059,7 +30203,7 @@ var TokenTransactionService = class {
         }
         const payload = {
           finalTokenTransactionHash,
-          operatorIdentityPublicKey: (0, import_utils19.hexToBytes)(operator.identityPublicKey)
+          operatorIdentityPublicKey: (0, import_utils20.hexToBytes)(operator.identityPublicKey)
         };
         const payloadHash = await hashOperatorSpecificTokenTransactionSignablePayload(payload);
         const ownerSignature = await this.signMessageWithKey(
@@ -30081,7 +30225,7 @@ var TokenTransactionService = class {
         }
         const payload = {
           finalTokenTransactionHash,
-          operatorIdentityPublicKey: (0, import_utils19.hexToBytes)(operator.identityPublicKey)
+          operatorIdentityPublicKey: (0, import_utils20.hexToBytes)(operator.identityPublicKey)
         };
         const payloadHash = await hashOperatorSpecificTokenTransactionSignablePayload(payload);
         const ownerSignature = await this.signMessageWithKey(
@@ -30097,7 +30241,7 @@ var TokenTransactionService = class {
         for (let i = 0; i < transferInput.outputsToSpend.length; i++) {
           const payload = {
             finalTokenTransactionHash,
-            operatorIdentityPublicKey: (0, import_utils19.hexToBytes)(operator.identityPublicKey)
+            operatorIdentityPublicKey: (0, import_utils20.hexToBytes)(operator.identityPublicKey)
           };
           const payloadHash = await hashOperatorSpecificTokenTransactionSignablePayload(payload);
           let ownerSignature;
@@ -30114,7 +30258,7 @@ var TokenTransactionService = class {
       }
       inputTtxoSignaturesPerOperator.push({
         ttxoSignatures,
-        operatorIdentityPublicKey: (0, import_utils19.hexToBytes)(operator.identityPublicKey)
+        operatorIdentityPublicKey: (0, import_utils20.hexToBytes)(operator.identityPublicKey)
       });
     }
     return inputTtxoSignaturesPerOperator;
@@ -30126,7 +30270,7 @@ function isTokenTransaction(tokenTransaction) {
 
 // src/services/tree-creation.ts
 init_buffer();
-var import_utils20 = require("@noble/curves/abstract/utils");
+var import_utils21 = require("@noble/curves/abstract/utils");
 var import_btc_signer5 = require("@scure/btc-signer");
 var TreeCreationService = class {
   config;
@@ -30167,7 +30311,7 @@ var TreeCreationService = class {
       request.source = {
         $case: "onChainUtxo",
         onChainUtxo: {
-          txid: (0, import_utils20.hexToBytes)(getTxId(parentTx)),
+          txid: (0, import_utils21.hexToBytes)(getTxId(parentTx)),
           vout,
           rawTx: parentTx.toBytes(),
           network: this.config.getNetworkProto()
@@ -30208,7 +30352,7 @@ var TreeCreationService = class {
       request.source = {
         $case: "onChainUtxo",
         onChainUtxo: {
-          txid: (0, import_utils20.hexToBytes)(getTxId(parentTx)),
+          txid: (0, import_utils21.hexToBytes)(getTxId(parentTx)),
           vout,
           rawTx: parentTx.toBytes(),
           network: this.config.getNetworkProto()
@@ -30335,7 +30479,7 @@ var TreeCreationService = class {
       throw new Error("parentTxOut is undefined");
     }
     const parentOutPoint = {
-      txid: (0, import_utils20.hexToBytes)(getTxId(parentTx)),
+      txid: (0, import_utils21.hexToBytes)(getTxId(parentTx)),
       index: vout
     };
     const parentTxOutObj = {
@@ -30375,7 +30519,7 @@ var TreeCreationService = class {
     const [cpfpLeafTx, directLeafTx] = createLeafNodeTx(
       sequence,
       directSequence,
-      { txid: (0, import_utils20.hexToBytes)(getTxId(cpfpNodeTx)), index: 0 },
+      { txid: (0, import_utils21.hexToBytes)(getTxId(cpfpNodeTx)), index: 0 },
       parentTxOutObj,
       true
       // shouldCalculateFee
@@ -30399,8 +30543,8 @@ var TreeCreationService = class {
     const { cpfpRefundTx, directRefundTx, directFromCpfpRefundTx } = createRefundTxs({
       sequence,
       directSequence,
-      input: { txid: (0, import_utils20.hexToBytes)(getTxId(cpfpLeafTx)), index: 0 },
-      directInput: { txid: (0, import_utils20.hexToBytes)(getTxId(directLeafTx)), index: 0 },
+      input: { txid: (0, import_utils21.hexToBytes)(getTxId(cpfpLeafTx)), index: 0 },
+      directInput: { txid: (0, import_utils21.hexToBytes)(getTxId(directLeafTx)), index: 0 },
       amountSats: parentTxOut.amount,
       receivingPubkey: node.signingPublicKey,
       network
@@ -30451,7 +30595,7 @@ var TreeCreationService = class {
       });
     }
     const parentOutPoint = {
-      txid: (0, import_utils20.hexToBytes)(getTxId(parentTx)),
+      txid: (0, import_utils21.hexToBytes)(getTxId(parentTx)),
       index: vout
     };
     const [cpfpSplitTx, directSplitTx] = createSplitTx(
@@ -30728,11 +30872,13 @@ var TreeCreationService = class {
 // src/spark-wallet/spark-wallet.ts
 var import_lrc20_sdk3 = require("@buildonspark/lrc20-sdk");
 var import_sha212 = require("@noble/hashes/sha2");
+var import_api = require("@opentelemetry/api");
+var import_sdk_trace_base = require("@opentelemetry/sdk-trace-base");
 var import_eventemitter3 = require("eventemitter3");
 
 // src/services/signing.ts
 init_buffer();
-var import_utils21 = require("@noble/curves/abstract/utils");
+var import_utils22 = require("@noble/curves/abstract/utils");
 var SigningService = class {
   config;
   constructor(config) {
@@ -30788,7 +30934,7 @@ var SigningService = class {
       }
       const nodeTx = getTxFromRawTxBytes(leaf.leaf.nodeTx);
       const cpfpNodeOutPoint = {
-        txid: (0, import_utils21.hexToBytes)(getTxId(nodeTx)),
+        txid: (0, import_utils22.hexToBytes)(getTxId(nodeTx)),
         index: 0
       };
       const currRefundTx = getTxFromRawTxBytes(leaf.leaf.refundTx);
@@ -30814,7 +30960,7 @@ var SigningService = class {
       if (leaf.leaf.directTx.length > 0) {
         directNodeTx = getTxFromRawTxBytes(leaf.leaf.directTx);
         directNodeOutPoint = {
-          txid: (0, import_utils21.hexToBytes)(getTxId(directNodeTx)),
+          txid: (0, import_utils22.hexToBytes)(getTxId(directNodeTx)),
           index: 0
         };
       }
@@ -30898,15 +31044,15 @@ var SigningService = class {
 
 // src/tests/utils/test-faucet.ts
 init_buffer();
-var import_utils22 = require("@noble/curves/abstract/utils");
+var import_utils23 = require("@noble/curves/abstract/utils");
 var import_secp256k114 = require("@noble/curves/secp256k1");
 var btc5 = __toESM(require("@scure/btc-signer"), 1);
 var import_btc_signer6 = require("@scure/btc-signer");
-var import_utils23 = require("@scure/btc-signer/utils");
-var STATIC_FAUCET_KEY = (0, import_utils22.hexToBytes)(
+var import_utils24 = require("@scure/btc-signer/utils");
+var STATIC_FAUCET_KEY = (0, import_utils23.hexToBytes)(
   "deadbeef1337cafe4242424242424242deadbeef1337cafe4242424242424242"
 );
-var STATIC_MINING_KEY = (0, import_utils22.hexToBytes)(
+var STATIC_MINING_KEY = (0, import_utils23.hexToBytes)(
   "1337cafe4242deadbeef4242424242421337cafe4242deadbeef424242424242"
 );
 var SATS_PER_BTC = 1e8;
@@ -30969,7 +31115,7 @@ var BitcoinFaucet = class _BitcoinFaucet {
     if (!scanResult.success || scanResult.unspents.length === 0) {
       const blockHash = await this.generateToAddress(1, address2);
       const block = await this.getBlock(blockHash[0]);
-      const fundingTx = import_btc_signer6.Transaction.fromRaw((0, import_utils22.hexToBytes)(block.tx[0].hex), {
+      const fundingTx = import_btc_signer6.Transaction.fromRaw((0, import_utils23.hexToBytes)(block.tx[0].hex), {
         allowUnknownOutputs: true
       });
       await this.generateToAddress(100, this.miningAddress);
@@ -31031,13 +31177,13 @@ var BitcoinFaucet = class _BitcoinFaucet {
       },
       STATIC_MINING_KEY
     );
-    await this.broadcastTx((0, import_utils22.bytesToHex)(signedSplitTx.extract()));
+    await this.broadcastTx((0, import_utils23.bytesToHex)(signedSplitTx.extract()));
     const splitTxId = signedSplitTx.id;
     for (let i = 0; i < numCoinsToCreate; i++) {
       this.coins.push({
         key: STATIC_FAUCET_KEY,
         outpoint: {
-          txid: (0, import_utils22.hexToBytes)(splitTxId),
+          txid: (0, import_utils23.hexToBytes)(splitTxId),
           index: i
         },
         txout: signedSplitTx.getOutput(i)
@@ -31065,7 +31211,7 @@ var BitcoinFaucet = class _BitcoinFaucet {
       coinToSend.txout,
       coinToSend.key
     );
-    await this.broadcastTx((0, import_utils22.bytesToHex)(signedTx.extract()));
+    await this.broadcastTx((0, import_utils23.bytesToHex)(signedTx.extract()));
   }
   async signFaucetCoin(unsignedTx, fundingTxOut, key) {
     const pubKey = import_secp256k114.secp256k1.getPublicKey(key);
@@ -31085,7 +31231,7 @@ var BitcoinFaucet = class _BitcoinFaucet {
       new Array(unsignedTx.inputsLength).fill(fundingTxOut.amount)
     );
     const merkleRoot = new Uint8Array();
-    const tweakedKey = (0, import_utils23.taprootTweakPrivKey)(key, merkleRoot);
+    const tweakedKey = (0, import_utils24.taprootTweakPrivKey)(key, merkleRoot);
     if (!tweakedKey)
       throw new Error("Invalid private key for taproot tweaking");
     const signature = import_secp256k114.schnorr.sign(sighash, tweakedKey);
@@ -31155,7 +31301,7 @@ var BitcoinFaucet = class _BitcoinFaucet {
     const pubKey = import_secp256k114.secp256k1.getPublicKey(key);
     return getP2TRAddressFromPublicKey(pubKey, 4 /* LOCAL */);
   }
-  async sendToAddress(address2, amount) {
+  async sendToAddress(address2, amount, blocksToGenerate = 1) {
     const coin = await this.fund();
     if (!coin) {
       throw new Error("No coins available");
@@ -31185,7 +31331,7 @@ var BitcoinFaucet = class _BitcoinFaucet {
       });
     }
     const signedTx = await this.signFaucetCoin(tx, coin.txout, coin.key);
-    const txHex = (0, import_utils22.bytesToHex)(signedTx.extract());
+    const txHex = (0, import_utils23.bytesToHex)(signedTx.extract());
     await this.broadcastTx(txHex);
     const randomKey = import_secp256k114.secp256k1.utils.randomPrivateKey();
     const randomPubKey = import_secp256k114.secp256k1.getPublicKey(randomKey);
@@ -31193,7 +31339,7 @@ var BitcoinFaucet = class _BitcoinFaucet {
       randomPubKey,
       4 /* LOCAL */
     );
-    await this.generateToAddress(1, randomAddress);
+    await this.generateToAddress(blocksToGenerate, randomAddress);
     return signedTx;
   }
   async getRawTransaction(txid) {
@@ -31237,11 +31383,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
   tokenOutputs = /* @__PURE__ */ new Map();
   // Add this property near the top of the class with other private properties
   claimTransfersInterval = null;
-  wrapWithOtelSpan(name, fn) {
-    return async (...args) => {
-      return await fn(...args);
-    };
-  }
+  tracer = null;
   constructor(options, signer) {
     super();
     this.config = new WalletConfigService(options, signer);
@@ -31274,6 +31416,8 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
       this.connectionManager,
       this.signingService
     );
+    this.tracer = import_api.trace.getTracer(this.tracerId);
+    this.wrapSparkWalletMethodsWithTracing();
   }
   static async initialize({
     mnemonicOrSeed,
@@ -31282,6 +31426,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
     options
   }) {
     const wallet = new _SparkWallet(options, signer);
+    wallet.initializeTracer(wallet);
     const initResponse = await wallet.initWallet(mnemonicOrSeed, accountNumber);
     return {
       wallet,
@@ -31310,7 +31455,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
     try {
       if (event?.$case === "transfer" && event.transfer.transfer && event.transfer.transfer.type !== 40 /* COUNTER_SWAP */) {
         const { senderIdentityPublicKey, receiverIdentityPublicKey } = event.transfer.transfer;
-        if (event.transfer.transfer && !(0, import_utils24.equalBytes)(senderIdentityPublicKey, receiverIdentityPublicKey)) {
+        if (event.transfer.transfer && !(0, import_utils25.equalBytes)(senderIdentityPublicKey, receiverIdentityPublicKey)) {
           await this.claimTransfer({
             transfer: event.transfer.transfer,
             emit: true,
@@ -31475,10 +31620,10 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
               leavesToIgnore.add(nodeId);
               continue;
             }
-            if (leaf.status !== operatorLeaf.status || !leaf.signingKeyshare || !operatorLeaf.signingKeyshare || !(0, import_utils24.equalBytes)(
+            if (leaf.status !== operatorLeaf.status || !leaf.signingKeyshare || !operatorLeaf.signingKeyshare || !(0, import_utils25.equalBytes)(
               leaf.signingKeyshare.publicKey,
               operatorLeaf.signingKeyshare.publicKey
-            ) || !(0, import_utils24.equalBytes)(leaf.nodeTx, operatorLeaf.nodeTx)) {
+            ) || !(0, import_utils25.equalBytes)(leaf.nodeTx, operatorLeaf.nodeTx)) {
               leavesToIgnore.add(nodeId);
             }
           }
@@ -31529,7 +31674,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
     });
   }
   verifyKey(pubkey1, pubkey2, verifyingKey) {
-    return (0, import_utils24.equalBytes)(addPublicKeys(pubkey1, pubkey2), verifyingKey);
+    return (0, import_utils25.equalBytes)(addPublicKeys(pubkey1, pubkey2), verifyingKey);
   }
   async selectLeaves(targetAmounts) {
     if (targetAmounts.length === 0) {
@@ -31687,7 +31832,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
    * @returns {Promise<string>} The identity public key as a hex string.
    */
   async getIdentityPublicKey() {
-    return (0, import_utils24.bytesToHex)(await this.config.signer.getIdentityPublicKey());
+    return (0, import_utils25.bytesToHex)(await this.config.signer.getIdentityPublicKey());
   }
   /**
    * Gets the Spark address of the wallet.
@@ -31697,7 +31842,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
   async getSparkAddress() {
     if (!this.sparkAddress) {
       this.sparkAddress = encodeSparkAddress({
-        identityPublicKey: (0, import_utils24.bytesToHex)(
+        identityPublicKey: (0, import_utils25.bytesToHex)(
           await this.config.signer.getIdentityPublicKey()
         ),
         network: this.config.getNetworkType()
@@ -31734,14 +31879,14 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
       isValidPublicKey(assetIdentifier);
     }
     const paymentRequest = encodeSparkAddress({
-      identityPublicKey: (0, import_utils24.bytesToHex)(
+      identityPublicKey: (0, import_utils25.bytesToHex)(
         await this.config.signer.getIdentityPublicKey()
       ),
       network: this.config.getNetworkType(),
       paymentIntentFields: {
         id: (0, import_uuidv75.uuidv7obj)().bytes,
-        assetIdentifier: assetIdentifier ? (0, import_utils24.hexToBytes)(assetIdentifier) : void 0,
-        assetAmount: (0, import_utils24.numberToVarBytesBE)(assetAmount),
+        assetIdentifier: assetIdentifier ? (0, import_utils25.hexToBytes)(assetIdentifier) : void 0,
+        assetAmount: (0, import_utils25.numberToVarBytesBE)(assetAmount),
         memo
       }
     });
@@ -31786,7 +31931,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
         mnemonic = mnemonicOrSeed;
         seed = await this.config.signer.mnemonicToSeed(mnemonicOrSeed);
       } else {
-        seed = (0, import_utils24.hexToBytes)(mnemonicOrSeed);
+        seed = (0, import_utils25.hexToBytes)(mnemonicOrSeed);
       }
     }
     await this.initWalletFromSeed(seed, accountNumber);
@@ -31916,7 +32061,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
       directFromCpfpSignatureMap
     } = await this.transferService.startSwapSignRefund(
       leafKeyTweaks,
-      (0, import_utils24.hexToBytes)(this.config.getSspIdentityPublicKey()),
+      (0, import_utils25.hexToBytes)(this.config.getSspIdentityPublicKey()),
       new Date(Date.now() + 2 * 60 * 1e3)
     );
     try {
@@ -31976,18 +32121,18 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
       const userLeaves = [];
       userLeaves.push({
         leaf_id: transfer.leaves[0].leaf.id,
-        raw_unsigned_refund_transaction: (0, import_utils24.bytesToHex)(
+        raw_unsigned_refund_transaction: (0, import_utils25.bytesToHex)(
           transfer.leaves[0].intermediateRefundTx
         ),
-        direct_raw_unsigned_refund_transaction: (0, import_utils24.bytesToHex)(
+        direct_raw_unsigned_refund_transaction: (0, import_utils25.bytesToHex)(
           transfer.leaves[0].intermediateDirectRefundTx
         ),
-        direct_from_cpfp_raw_unsigned_refund_transaction: (0, import_utils24.bytesToHex)(
+        direct_from_cpfp_raw_unsigned_refund_transaction: (0, import_utils25.bytesToHex)(
           transfer.leaves[0].intermediateDirectFromCpfpRefundTx
         ),
-        adaptor_added_signature: (0, import_utils24.bytesToHex)(cpfpAdaptorSignature),
-        direct_adaptor_added_signature: (0, import_utils24.bytesToHex)(directAdaptorSignature),
-        direct_from_cpfp_adaptor_added_signature: (0, import_utils24.bytesToHex)(
+        adaptor_added_signature: (0, import_utils25.bytesToHex)(cpfpAdaptorSignature),
+        direct_adaptor_added_signature: (0, import_utils25.bytesToHex)(directAdaptorSignature),
+        direct_from_cpfp_adaptor_added_signature: (0, import_utils25.bytesToHex)(
           directFromCpfpAdaptorSignature
         )
       });
@@ -32040,24 +32185,24 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
         }
         userLeaves.push({
           leaf_id: leaf.leaf.id,
-          raw_unsigned_refund_transaction: (0, import_utils24.bytesToHex)(
+          raw_unsigned_refund_transaction: (0, import_utils25.bytesToHex)(
             leaf.intermediateRefundTx
           ),
-          direct_raw_unsigned_refund_transaction: (0, import_utils24.bytesToHex)(
+          direct_raw_unsigned_refund_transaction: (0, import_utils25.bytesToHex)(
             leaf.intermediateDirectRefundTx
           ),
-          direct_from_cpfp_raw_unsigned_refund_transaction: (0, import_utils24.bytesToHex)(
+          direct_from_cpfp_raw_unsigned_refund_transaction: (0, import_utils25.bytesToHex)(
             leaf.intermediateDirectFromCpfpRefundTx
           ),
-          adaptor_added_signature: (0, import_utils24.bytesToHex)(cpfpSignature),
-          direct_adaptor_added_signature: (0, import_utils24.bytesToHex)(directSignature),
-          direct_from_cpfp_adaptor_added_signature: (0, import_utils24.bytesToHex)(
+          adaptor_added_signature: (0, import_utils25.bytesToHex)(cpfpSignature),
+          direct_adaptor_added_signature: (0, import_utils25.bytesToHex)(directSignature),
+          direct_from_cpfp_adaptor_added_signature: (0, import_utils25.bytesToHex)(
             directFromCpfpSignature
           )
         });
       }
       const sspClient = this.getSspClient();
-      const cpfpAdaptorPubkey = (0, import_utils24.bytesToHex)(
+      const cpfpAdaptorPubkey = (0, import_utils25.bytesToHex)(
         import_secp256k115.secp256k1.getPublicKey(cpfpAdaptorPrivateKey)
       );
       if (!cpfpAdaptorPubkey) {
@@ -32065,13 +32210,13 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
       }
       let directAdaptorPubkey;
       if (directAdaptorPrivateKey.length > 0) {
-        directAdaptorPubkey = (0, import_utils24.bytesToHex)(
+        directAdaptorPubkey = (0, import_utils25.bytesToHex)(
           import_secp256k115.secp256k1.getPublicKey(directAdaptorPrivateKey)
         );
       }
       let directFromCpfpAdaptorPubkey;
       if (directFromCpfpAdaptorPrivateKey.length > 0) {
-        directFromCpfpAdaptorPubkey = (0, import_utils24.bytesToHex)(
+        directFromCpfpAdaptorPubkey = (0, import_utils25.bytesToHex)(
           import_secp256k115.secp256k1.getPublicKey(directFromCpfpAdaptorPrivateKey)
         );
       }
@@ -32131,7 +32276,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
           throw new Error(`Leaf not found for node ${nodeId}`);
         }
         const cpfpNodeTx = getTxFromRawTxBytes(node.nodeTx);
-        const cpfpRefundTxBytes = (0, import_utils24.hexToBytes)(leaf.rawUnsignedRefundTransaction);
+        const cpfpRefundTxBytes = (0, import_utils25.hexToBytes)(leaf.rawUnsignedRefundTransaction);
         const cpfpRefundTx = getTxFromRawTxBytes(cpfpRefundTxBytes);
         const cpfpSighash = getSigHashFromTx(
           cpfpRefundTx,
@@ -32140,7 +32285,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
         );
         const nodePublicKey = node.verifyingPublicKey;
         const taprootKey = computeTaprootKeyNoScript(nodePublicKey.slice(1));
-        const cpfpAdaptorSignatureBytes = (0, import_utils24.hexToBytes)(
+        const cpfpAdaptorSignatureBytes = (0, import_utils25.hexToBytes)(
           leaf.adaptorSignedSignature
         );
         applyAdaptorToSignature(
@@ -32149,70 +32294,59 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
           cpfpAdaptorSignatureBytes,
           cpfpAdaptorPrivateKey
         );
-        if (!leaf.directRawUnsignedRefundTransaction) {
-          throw new Error(
-            `Direct raw unsigned refund transaction missing for node ${nodeId}`
+        if (leaf.directRawUnsignedRefundTransaction) {
+          const directNodeTx = getTxFromRawTxBytes(node.directTx);
+          const directRefundTxBytes = (0, import_utils25.hexToBytes)(
+            leaf.directRawUnsignedRefundTransaction
           );
-        }
-        if (!leaf.directAdaptorSignedSignature) {
-          throw new Error(
-            `Direct adaptor signed signature missing for node ${nodeId}`
+          const directRefundTx = getTxFromRawTxBytes(directRefundTxBytes);
+          const directSighash = getSigHashFromTx(
+            directRefundTx,
+            0,
+            directNodeTx.getOutput(0)
           );
-        }
-        const directNodeTx = getTxFromRawTxBytes(node.directTx);
-        const directRefundTxBytes = (0, import_utils24.hexToBytes)(
-          leaf.directRawUnsignedRefundTransaction
-        );
-        const directRefundTx = getTxFromRawTxBytes(directRefundTxBytes);
-        const directSighash = getSigHashFromTx(
-          directRefundTx,
-          0,
-          directNodeTx.getOutput(0)
-        );
-        if (!leaf.directFromCpfpAdaptorSignedSignature) {
-          throw new Error(
-            `Direct adaptor signed signature missing for node ${nodeId}`
+          if (!leaf.directAdaptorSignedSignature) {
+            throw new Error(
+              `Direct adaptor signed signature missing for node ${nodeId}`
+            );
+          }
+          const directAdaptorSignatureBytes = (0, import_utils25.hexToBytes)(
+            leaf.directAdaptorSignedSignature
           );
-        }
-        const directAdaptorSignatureBytes = (0, import_utils24.hexToBytes)(
-          leaf.directAdaptorSignedSignature
-        );
-        applyAdaptorToSignature(
-          taprootKey.slice(1),
-          directSighash,
-          directAdaptorSignatureBytes,
-          directAdaptorPrivateKey
-        );
-        if (!leaf.directRawUnsignedRefundTransaction) {
-          throw new Error(
-            `Direct raw unsigned refund transaction missing for node ${nodeId}`
+          applyAdaptorToSignature(
+            taprootKey.slice(1),
+            directSighash,
+            directAdaptorSignatureBytes,
+            directAdaptorPrivateKey
           );
         }
-        if (!leaf.directFromCpfpRawUnsignedRefundTransaction) {
-          throw new Error(
-            `Direct raw unsigned refund transaction missing for node ${nodeId}`
+        if (leaf.directFromCpfpRawUnsignedRefundTransaction) {
+          const directFromCpfpRefundTxBytes = (0, import_utils25.hexToBytes)(
+            leaf.directFromCpfpRawUnsignedRefundTransaction
+          );
+          const directFromCpfpRefundTx = getTxFromRawTxBytes(
+            directFromCpfpRefundTxBytes
+          );
+          const directFromCpfpSighash = getSigHashFromTx(
+            directFromCpfpRefundTx,
+            0,
+            cpfpNodeTx.getOutput(0)
+          );
+          if (!leaf.directFromCpfpAdaptorSignedSignature) {
+            throw new Error(
+              `Direct adaptor signed signature missing for node ${nodeId}`
+            );
+          }
+          const directFromCpfpAdaptorSignatureBytes = (0, import_utils25.hexToBytes)(
+            leaf.directFromCpfpAdaptorSignedSignature
+          );
+          applyAdaptorToSignature(
+            taprootKey.slice(1),
+            directFromCpfpSighash,
+            directFromCpfpAdaptorSignatureBytes,
+            directFromCpfpAdaptorPrivateKey
           );
         }
-        const directFromCpfpRefundTxBytes = (0, import_utils24.hexToBytes)(
-          leaf.directFromCpfpRawUnsignedRefundTransaction
-        );
-        const directFromCpfpRefundTx = getTxFromRawTxBytes(
-          directFromCpfpRefundTxBytes
-        );
-        const directFromCpfpSighash = getSigHashFromTx(
-          directFromCpfpRefundTx,
-          0,
-          cpfpNodeTx.getOutput(0)
-        );
-        const directFromCpfpAdaptorSignatureBytes = (0, import_utils24.hexToBytes)(
-          leaf.directFromCpfpAdaptorSignedSignature
-        );
-        applyAdaptorToSignature(
-          taprootKey.slice(1),
-          directFromCpfpSighash,
-          directFromCpfpAdaptorSignatureBytes,
-          directFromCpfpAdaptorPrivateKey
-        );
       }
       await this.transferService.deliverTransferPackage(
         transfer,
@@ -32222,9 +32356,9 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
         directFromCpfpSignatureMap
       );
       const completeResponse = await sspClient.completeLeaveSwap({
-        adaptorSecretKey: (0, import_utils24.bytesToHex)(cpfpAdaptorPrivateKey),
-        directAdaptorSecretKey: (0, import_utils24.bytesToHex)(directAdaptorPrivateKey),
-        directFromCpfpAdaptorSecretKey: (0, import_utils24.bytesToHex)(
+        adaptorSecretKey: (0, import_utils25.bytesToHex)(cpfpAdaptorPrivateKey),
+        directAdaptorSecretKey: (0, import_utils25.bytesToHex)(directAdaptorPrivateKey),
+        directFromCpfpAdaptorSecretKey: (0, import_utils25.bytesToHex)(
           directFromCpfpAdaptorPrivateKey
         ),
         userOutboundTransferExternalId: transfer.id,
@@ -32260,28 +32394,6 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
       throw new Error(`Failed to request leaves swap: ${e}`);
     }
   }
-  /**
-   * Gets all transfers for the wallet.
-   *
-   * @param {number} [limit=20] - Maximum number of transfers to return
-   * @param {number} [offset=0] - Offset for pagination
-   * @returns {Promise<QueryTransfersResponse>} Response containing the list of transfers
-   */
-  async getTransfers(limit = 20, offset = 0) {
-    const transfers = await this.transferService.queryAllTransfers(
-      limit,
-      offset
-    );
-    const identityPublicKey = (0, import_utils24.bytesToHex)(
-      await this.config.signer.getIdentityPublicKey()
-    );
-    return {
-      transfers: transfers.transfers.map(
-        (transfer) => mapTransferToWalletTransfer(transfer, identityPublicKey)
-      ),
-      offset: transfers.offset
-    };
-  }
   /**
    * Gets the current balance of the wallet.
    * You can use the forceRefetch option to synchronize your wallet and claim any
@@ -32342,12 +32454,12 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
     let tokenMetadataMap = /* @__PURE__ */ new Map();
     for (const [tokenIdentifier, metadata] of this.tokenMetadata) {
       tokenMetadataMap.set(tokenIdentifier, {
-        tokenPublicKey: (0, import_utils24.bytesToHex)(metadata.issuerPublicKey),
+        tokenPublicKey: (0, import_utils25.bytesToHex)(metadata.issuerPublicKey),
         rawTokenIdentifier: metadata.tokenIdentifier,
         tokenName: metadata.tokenName,
         tokenTicker: metadata.tokenTicker,
         decimals: metadata.decimals,
-        maxSupply: (0, import_utils24.bytesToNumberBE)(metadata.maxSupply)
+        maxSupply: (0, import_utils25.bytesToNumberBE)(metadata.maxSupply)
       });
     }
     return tokenMetadataMap;
@@ -32460,7 +32572,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,13 +32605,15 @@ 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) {
       network = BitcoinNetwork_default.REGTEST;
     }
-    const depositSecretKey = (0, import_utils24.bytesToHex)(
+    const depositSecretKey = (0, import_utils25.bytesToHex)(
       await this.config.signer.getStaticDepositSecretKey(0)
     );
     const message = await this.getStaticDepositSigningPayload(
@@ -32510,7 +32626,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
     );
     const hashBuffer = (0, import_sha212.sha256)(message);
     const signatureBytes = await this.config.signer.signMessageWithIdentityKey(hashBuffer);
-    const signature = (0, import_utils24.bytesToHex)(signatureBytes);
+    const signature = (0, import_utils25.bytesToHex)(signatureBytes);
     const response = await this.sspClient.claimStaticDeposit({
       transactionId,
       outputIndex,
@@ -32525,25 +32641,89 @@ 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) {
-      throw new ValidationError("Fee must be greater than 300", {
+    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 < 194) {
+      throw new ValidationError("Fee must be at least 194", {
         field: "fee",
-        value: fee
+        value: finalFee
       });
     }
     let network = this.config.getNetwork();
@@ -32551,10 +32731,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",
@@ -32595,33 +32778,21 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
       networkJSON.toLowerCase(),
       2 /* Refund */,
       creditAmountSats,
-      (0, import_utils24.bytesToHex)(spendTxSighash)
+      (0, import_utils25.bytesToHex)(spendTxSighash)
     );
     const hashBuffer = (0, import_sha212.sha256)(message);
     const swapResponseUserSignature = await this.config.signer.signMessageWithIdentityKey(hashBuffer);
     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),
+        txid: (0, import_utils25.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 +32805,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
@@ -32685,7 +32856,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
     creditAmountView.setUint32(0, lowerHalf, true);
     creditAmountView.setUint32(4, upperHalf, true);
     parts.push(new Uint8Array(creditAmountBuffer));
-    parts.push((0, import_utils24.hexToBytes)(sspSignature));
+    parts.push((0, import_utils25.hexToBytes)(sspSignature));
     const totalLength = parts.reduce((sum, part) => sum + part.length, 0);
     const payload = new Uint8Array(totalLength);
     let offset = 0;
@@ -32695,8 +32866,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()
     );
@@ -33076,9 +33252,9 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
       this.config.getNetworkType()
     );
     const signerIdentityPublicKey = await this.config.signer.getIdentityPublicKey();
-    const isSelfTransfer = (0, import_utils24.equalBytes)(
+    const isSelfTransfer = (0, import_utils25.equalBytes)(
       signerIdentityPublicKey,
-      (0, import_utils24.hexToBytes)(receiverAddress.identityPublicKey)
+      (0, import_utils25.hexToBytes)(receiverAddress.identityPublicKey)
     );
     return await this.withLeaves(async () => {
       let leavesToSend = (await this.selectLeaves([amountSats])).get(
@@ -33100,7 +33276,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
       );
       const transfer = await this.transferService.sendTransferWithKeyTweaks(
         leafKeyTweaks,
-        (0, import_utils24.hexToBytes)(receiverAddress.identityPublicKey)
+        (0, import_utils25.hexToBytes)(receiverAddress.identityPublicKey)
       );
       const leavesToRemove = new Set(leavesToSend.map((leaf) => leaf.id));
       this.leaves = this.leaves.filter((leaf) => !leavesToRemove.has(leaf.id));
@@ -33116,7 +33292,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
       }
       return mapTransferToWalletTransfer(
         transfer,
-        (0, import_utils24.bytesToHex)(await this.config.signer.getIdentityPublicKey())
+        (0, import_utils25.bytesToHex)(await this.config.signer.getIdentityPublicKey())
       );
     });
   }
@@ -33453,7 +33629,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
       const invoice2 = await sspClient.requestLightningReceive({
         amountSats: amountSats2,
         network: bitcoinNetwork,
-        paymentHash: (0, import_utils24.bytesToHex)(paymentHash),
+        paymentHash: (0, import_utils25.bytesToHex)(paymentHash),
         expirySecs: expirySeconds,
         memo: memo2,
         includeSparkAddress,
@@ -33517,7 +33693,8 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
   }) {
     const invoiceNetwork = getNetworkFromInvoice(invoice);
     const walletNetwork = this.config.getNetwork();
-    if (invoiceNetwork !== walletNetwork) {
+    const isValidNetworkForWallet = invoiceNetwork === walletNetwork || invoiceNetwork === 3 /* REGTEST */ && (walletNetwork === 3 /* REGTEST */ || walletNetwork === 4 /* LOCAL */);
+    if (!isValidNetworkForWallet) {
       throw new ValidationError(
         `Invoice network: ${invoiceNetwork} does not match wallet network: ${walletNetwork}`,
         {
@@ -33561,7 +33738,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
     const sparkFallbackAddress = decodedInvoice.fallbackAddress;
     const paymentHash = decodedInvoice.paymentHash;
     if (preferSpark) {
-      if (sparkFallbackAddress === void 0 || isValidSparkFallback((0, import_utils24.hexToBytes)(sparkFallbackAddress)) === false) {
+      if (sparkFallbackAddress === void 0 || isValidSparkFallback((0, import_utils25.hexToBytes)(sparkFallbackAddress)) === false) {
         console.warn(
           "No valid spark address found in invoice. Defaulting to lightning."
         );
@@ -33615,10 +33792,10 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
       );
       const swapResponse = await this.lightningService.swapNodesForPreimage({
         leaves: leavesToSend,
-        receiverIdentityPubkey: (0, import_utils24.hexToBytes)(
+        receiverIdentityPubkey: (0, import_utils25.hexToBytes)(
           this.config.getSspIdentityPublicKey()
         ),
-        paymentHash: (0, import_utils24.hexToBytes)(paymentHash),
+        paymentHash: (0, import_utils25.hexToBytes)(paymentHash),
         isInboundPayment: false,
         invoiceString: invoice,
         feeSats: feeEstimate,
@@ -33861,11 +34038,11 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
     const connectorOutputs = [];
     for (let i = 0; i < connectorTx.outputsLength - 1; i++) {
       connectorOutputs.push({
-        txid: (0, import_utils24.hexToBytes)(connectorTxId),
+        txid: (0, import_utils25.hexToBytes)(connectorTxId),
         index: i
       });
     }
-    const sspPubIdentityKey = (0, import_utils24.hexToBytes)(this.config.getSspIdentityPublicKey());
+    const sspPubIdentityKey = (0, import_utils25.hexToBytes)(this.config.getSspIdentityPublicKey());
     const transfer = await this.coopExitService.getConnectorRefundSignatures({
       leaves: leafKeyTweaks,
       exitTxId: coopExitTxId,
@@ -33911,11 +34088,41 @@ 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];
+  }
+  async constructTransfersWithUserRequest(transfers) {
+    const identityPublicKey = (0, import_utils25.bytesToHex)(
+      await this.config.signer.getIdentityPublicKey()
+    );
+    const userRequests = await this.sspClient?.getTransfers(
+      transfers.filter(
+        (transfer) => [
+          1 /* COOPERATIVE_EXIT */,
+          40 /* COUNTER_SWAP */,
+          0 /* PREIMAGE_SWAP */,
+          30 /* SWAP */,
+          3 /* UTXO_SWAP */
+        ].includes(transfer.type)
+      ).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.map(
+      (transfer) => mapTransferToWalletTransfer(
+        transfer,
+        identityPublicKey,
+        userRequestsMap.get(transfer.id)
+      )
+    );
   }
   /**
    * Gets a transfer, that the wallet is a participant of, in the Spark network.
@@ -33930,10 +34137,26 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
     if (!transfer) {
       return void 0;
     }
-    return mapTransferToWalletTransfer(
-      transfer,
-      (0, import_utils24.bytesToHex)(await this.config.signer.getIdentityPublicKey())
+    return (await this.constructTransfersWithUserRequest([transfer]))[0];
+  }
+  /**
+   * Gets all transfers for the wallet.
+   *
+   * @param {number} [limit=20] - Maximum number of transfers to return
+   * @param {number} [offset=0] - Offset for pagination
+   * @returns {Promise<QueryTransfersResponse>} Response containing the list of transfers
+   */
+  async getTransfers(limit = 20, offset = 0) {
+    const transfers = await this.transferService.queryAllTransfers(
+      limit,
+      offset
     );
+    return {
+      transfers: await this.constructTransfersWithUserRequest(
+        transfers.transfers
+      ),
+      offset: transfers.offset
+    };
   }
   // ***** Token Flow *****
   /**
@@ -34066,8 +34289,8 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
     tokenTransactionHashes,
     tokenIdentifiers,
     outputIds,
-    pageSize = 100,
-    offset = 0
+    pageSize,
+    offset
   }) {
     return this.tokenTransactionService.queryTokenTransactions({
       ownerPublicKeys,
@@ -34075,8 +34298,8 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
       tokenTransactionHashes,
       tokenIdentifiers,
       outputIds,
-      pageSize,
-      offset
+      pageSize: pageSize ?? 100,
+      offset: offset ?? 0
     });
   }
   async getTokenL1Address() {
@@ -34098,7 +34321,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
       hash,
       compact
     );
-    return (0, import_utils24.bytesToHex)(signature);
+    return (0, import_utils25.bytesToHex)(signature);
   }
   /**
    * Validates a message with the identity key.
@@ -34110,7 +34333,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
   async validateMessageWithIdentityKey(message, signature) {
     const hash = (0, import_sha212.sha256)(message);
     if (typeof signature === "string") {
-      signature = (0, import_utils24.hexToBytes)(signature);
+      signature = (0, import_utils25.hexToBytes)(signature);
     }
     return this.config.signer.validateMessageWithIdentityKey(hash, signature);
   }
@@ -34123,7 +34346,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
    */
   async signTransaction(txHex, keyType = "auto-detect") {
     try {
-      const tx = import_btc_signer7.Transaction.fromRaw((0, import_utils24.hexToBytes)(txHex));
+      const tx = import_btc_signer7.Transaction.fromRaw((0, import_utils25.hexToBytes)(txHex));
       let publicKey;
       switch (keyType.toLowerCase()) {
         case "identity":
@@ -34156,7 +34379,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
           publicKey,
           this.config.getNetwork()
         );
-        if ((0, import_utils24.bytesToHex)(script) === (0, import_utils24.bytesToHex)(identityScript)) {
+        if ((0, import_utils25.bytesToHex)(script) === (0, import_utils25.bytesToHex)(identityScript)) {
           try {
             this.config.signer.signTransactionIndex(tx, i, publicKey);
             inputsSigned++;
@@ -34200,13 +34423,13 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
             depositPubKey,
             this.config.getNetwork()
           );
-          if ((0, import_utils24.bytesToHex)(script) === (0, import_utils24.bytesToHex)(identityScript)) {
+          if ((0, import_utils25.bytesToHex)(script) === (0, import_utils25.bytesToHex)(identityScript)) {
             return {
               publicKey: identityPubKey,
               keyType: "identity"
             };
           }
-          if ((0, import_utils24.bytesToHex)(script) === (0, import_utils24.bytesToHex)(depositScript)) {
+          if ((0, import_utils25.bytesToHex)(script) === (0, import_utils25.bytesToHex)(depositScript)) {
             return {
               publicKey: depositPubKey,
               keyType: "deposit"
@@ -34509,6 +34732,111 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
       offset += pageSize;
     }
   }
+  getOtelTraceUrls() {
+    const soConfig = this.config.getSigningOperators();
+    const sspBaseUrl = this.config.getSspBaseUrl();
+    const domains = [];
+    Object.values(soConfig).forEach((so) => {
+      domains.push(so.address);
+    });
+    if (sspBaseUrl) {
+      domains.push(sspBaseUrl);
+    }
+    return domains;
+  }
+  initializeTracer(wallet) {
+    const consoleOptions = wallet.config.getConsoleOptions();
+    const spanProcessors = [];
+    if (consoleOptions.otel) {
+      console.log("OpenTelemetry client logging enabled.");
+      spanProcessors.push(new import_sdk_trace_base.SimpleSpanProcessor(new import_sdk_trace_base.ConsoleSpanExporter()));
+    }
+    const traceUrls = this.getOtelTraceUrls();
+    wallet.initializeTracerEnv({ spanProcessors, traceUrls });
+  }
+  initializeTracerEnv({
+    spanProcessors,
+    traceUrls
+  }) {
+  }
+  wrapWithOtelSpan(name, fn) {
+    return async (...args) => {
+      if (!this.tracer) {
+        throw new Error("Tracer not initialized");
+      }
+      return await this.tracer.startActiveSpan(name, async (span) => {
+        const traceId = span.spanContext().traceId;
+        try {
+          const result = await fn(...args);
+          return result;
+        } catch (error) {
+          if (error instanceof Error) {
+            error.message += ` [traceId: ${traceId}]`;
+          } else if ((0, import_core12.isObject)(error)) {
+            error["traceId"] = traceId;
+          }
+          throw error;
+        } finally {
+          span.end();
+        }
+      });
+    };
+  }
+  getTraceName(methodName) {
+    return `SparkWallet.${methodName}`;
+  }
+  wrapPublicSparkWalletMethodWithOtelSpan(methodName) {
+    const original = this[methodName];
+    if (typeof original !== "function") {
+      throw new Error(`Method ${methodName} is not a function on SparkWallet.`);
+    }
+    const wrapped = this.wrapWithOtelSpan(
+      this.getTraceName(methodName),
+      original.bind(this)
+    );
+    this[methodName] = wrapped;
+  }
+  wrapSparkWalletMethodsWithTracing() {
+    const methods = [
+      "getLeaves",
+      "getIdentityPublicKey",
+      "getSparkAddress",
+      "createSparkPaymentIntent",
+      "getSwapFeeEstimate",
+      "getTransfers",
+      "getBalance",
+      "getSingleUseDepositAddress",
+      "getStaticDepositAddress",
+      "queryStaticDepositAddresses",
+      "getClaimStaticDepositQuote",
+      "claimStaticDeposit",
+      "refundStaticDeposit",
+      "getUnusedDepositAddresses",
+      "claimDeposit",
+      "advancedDeposit",
+      "transfer",
+      "createLightningInvoice",
+      "payLightningInvoice",
+      "getLightningSendFeeEstimate",
+      "withdraw",
+      "getWithdrawalFeeQuote",
+      "getTransferFromSsp",
+      "getTransfer",
+      "transferTokens",
+      "batchTransferTokens",
+      "queryTokenTransactions",
+      "getLightningReceiveRequest",
+      "getLightningSendRequest",
+      "getCoopExitRequest",
+      "checkTimelock",
+      "testOnly_expireTimelock"
+    ];
+    methods.forEach((m) => this.wrapPublicSparkWalletMethodWithOtelSpan(m));
+    this.initWallet = this.wrapWithOtelSpan(
+      this.getTraceName("initWallet"),
+      this.initWallet.bind(this)
+    );
+  }
 };
 
 // src/spark-wallet/types.ts
@@ -34575,7 +34903,7 @@ setCrypto(globalThis.crypto);
   encodeSparkAddress,
   evaluatePolynomial,
   fieldDiv,
-  filterTokenBalanceForTokenPublicKey,
+  filterTokenBalanceForTokenIdentifier,
   generateAdaptorFromSignature,
   generatePolynomialForSecretSharing,
   generateSignatureFromExistingAdaptor,
@@ -34584,6 +34912,7 @@ setCrypto(globalThis.crypto);
   getLatestDepositTxId,
   getNetwork,
   getNetworkFromAddress,
+  getNetworkFromBech32mTokenIdentifier,
   getNetworkFromString,
   getNextTransactionSequence,
   getP2TRAddressFromPkScript,
@@ -34597,6 +34926,7 @@ setCrypto(globalThis.crypto);
   getSparkAddressFromTaproot,
   getTransactionSequence,
   getTransferPackageSigningPayload,
+  getTxEstimatedVbytesSizeByNumberOfInputsOutputs,
   getTxFromRawTxBytes,
   getTxFromRawTxHex,
   getTxId,