@buildonspark/spark-sdk 0.0.8 → 0.0.9

package/dist/index.js

@@ -0,0 +1,3390 @@
+import {
+  TokenTransactionService,
+  calculateAvailableTokenAmount,
+  checkIfSelectedLeavesAreAvailable
+} from "./chunk-QX3ZJH2S.js";
+import {
+  ConnectionManager,
+  DepositService,
+  WalletConfigService
+} from "./chunk-SWFFNBSR.js";
+import "./chunk-SWCOMKD6.js";
+import {
+  createRefundTx,
+  getEphemeralAnchorOutput,
+  getNextTransactionSequence,
+  initWasm
+} from "./chunk-F4JW24C4.js";
+import "./chunk-JQFHUW4I.js";
+import {
+  computeTaprootKeyNoScript,
+  getP2TRAddressFromPublicKey,
+  getP2TRScriptFromPublicKey,
+  getSigHashFromTx,
+  getTxFromRawTxBytes,
+  getTxFromRawTxHex,
+  getTxId
+} from "./chunk-NDKNVHGP.js";
+import {
+  applyAdaptorToSignature,
+  generateAdaptorFromSignature,
+  generateSignatureFromExistingAdaptor,
+  getCrypto,
+  getNetwork
+} from "./chunk-COXVABEU.js";
+import "./chunk-5SAJ52IV.js";
+import {
+  BitcoinNetwork_default,
+  CoopExitFeeEstimateOutputFromJson,
+  CoopExitRequestFromJson,
+  FRAGMENT,
+  FRAGMENT2,
+  FRAGMENT3,
+  FRAGMENT4,
+  FRAGMENT5,
+  FRAGMENT6,
+  FRAGMENT7,
+  LeavesSwapRequestFromJson,
+  LightningReceiveFeeEstimateOutputFromJson,
+  LightningReceiveRequestFromJson,
+  LightningSendFeeEstimateOutputFromJson,
+  LightningSendRequestFromJson
+} from "./chunk-WZ74TD7N.js";
+
+// src/spark-sdk.ts
+import { bytesToHex as bytesToHex2, hexToBytes as hexToBytes3 } from "@noble/curves/abstract/utils";
+import { secp256k1 as secp256k13 } from "@noble/curves/secp256k1";
+import { Address as Address2, OutScript as OutScript2 } from "@scure/btc-signer";
+import { sha256 as sha2564 } from "@scure/btc-signer/utils";
+import { decode as decode2 } from "light-bolt11-decoder";
+
+// src/graphql/client.ts
+import {
+  DefaultCrypto,
+  NodeKeyCache,
+  Requester
+} from "@lightsparkdev/core";
+
+// src/graphql/mutations/CompleteCoopExit.ts
+var CompleteCoopExit = `
+  mutation CompleteCoopExit(
+    $user_outbound_transfer_external_id: UUID!
+    $coop_exit_request_id: ID!
+  ) {
+    complete_coop_exit(input: {
+      user_outbound_transfer_external_id: $user_outbound_transfer_external_id
+      coop_exit_request_id: $coop_exit_request_id
+    }) {
+      request {
+        ...CoopExitRequestFragment
+      }
+    }
+  }
+    
+  ${FRAGMENT}
+`;
+
+// src/graphql/mutations/CompleteLeavesSwap.ts
+var CompleteLeavesSwap = `
+  mutation CompleteLeavesSwap(
+    $adaptor_secret_key: String!
+    $user_outbound_transfer_external_id: UUID!
+    $leaves_swap_request_id: ID!
+  ) {
+    complete_leaves_swap(input: { adaptor_secret_key: $adaptor_secret_key, user_outbound_transfer_external_id: $user_outbound_transfer_external_id, leaves_swap_request_id: $leaves_swap_request_id }) {
+      request {
+        ...LeavesSwapRequestFragment
+      }
+    }
+  }
+
+  ${FRAGMENT2}
+`;
+
+// src/graphql/mutations/RequestCoopExit.ts
+var RequestCoopExit = `
+  mutation RequestCoopExit(
+    $leaf_external_ids: [UUID!]!
+    $withdrawal_address: String!
+  ) {
+    request_coop_exit(
+      input: {
+        leaf_external_ids: $leaf_external_ids
+        withdrawal_address: $withdrawal_address
+      }
+    ) {
+      request {
+        ...CoopExitRequestFragment
+      }
+    }
+  }
+  ${FRAGMENT}
+`;
+
+// src/graphql/mutations/RequestLightningReceive.ts
+var RequestLightningReceive = `
+  mutation RequestLightningReceive(
+    $network: BitcoinNetwork!
+    $amount_sats: Long!
+    $payment_hash: Hash32!
+    $expiry_secs: Int
+    $memo: String
+  ) {
+    request_lightning_receive(
+      input: {
+        network: $network
+        amount_sats: $amount_sats
+        payment_hash: $payment_hash
+        expiry_secs: $expiry_secs
+        memo: $memo
+      }
+    ) {
+      request {
+        ...LightningReceiveRequestFragment
+      }
+    }
+  }
+  ${FRAGMENT3}
+`;
+
+// src/graphql/mutations/RequestLightningSend.ts
+var RequestLightningSend = `
+  mutation RequestLightningSend(
+    $encoded_invoice: String!
+    $idempotency_key: String!
+  ) {
+    request_lightning_send(input: {
+      encoded_invoice: $encoded_invoice
+      idempotency_key: $idempotency_key
+    }) {
+      request {
+        ...LightningSendRequestFragment
+      }
+    }
+  }
+  ${FRAGMENT4}
+`;
+
+// src/graphql/mutations/RequestSwapLeaves.ts
+var RequestSwapLeaves = `
+  mutation RequestSwapLeaves(
+    $adaptor_pubkey: String!
+    $total_amount_sats: Long!
+    $target_amount_sats: Long!
+    $fee_sats: Long!
+    $user_leaves: [UserLeafInput!]!
+  ) {
+    request_leaves_swap(input: {
+      adaptor_pubkey: $adaptor_pubkey
+      total_amount_sats: $total_amount_sats
+      target_amount_sats: $target_amount_sats
+      fee_sats: $fee_sats
+      user_leaves: $user_leaves
+    }) {
+      request {
+        ...LeavesSwapRequestFragment
+      }
+    }
+  }
+  ${FRAGMENT2}
+`;
+
+// src/graphql/queries/CoopExitFeeEstimate.ts
+var CoopExitFeeEstimate = `
+  query CoopExitFeeEstimate(
+    $leaf_external_ids: [UUID!]!
+    $withdrawal_address: String!
+  ) {
+    coop_exit_fee_estimate(
+      input: {
+        leaf_external_ids: $leaf_external_ids
+        withdrawal_address: $withdrawal_address
+      }
+    ) {
+      ...CoopExitFeeEstimateOutputFragment
+    }
+  }
+  ${FRAGMENT5}
+`;
+
+// src/graphql/queries/LightningReceiveFeeEstimate.ts
+var LightningReceiveFeeEstimate = `
+  query LightningReceiveFeeEstimate(
+    $network: BitcoinNetwork!
+    $amount_sats: Long!
+  ) {
+    lightning_receive_fee_estimate(
+      input: {
+        network: $network
+        amount_sats: $amount_sats
+      }
+    ) {
+      ...LightningReceiveFeeEstimateOutputFragment
+    }
+  }
+  ${FRAGMENT6}
+`;
+
+// src/graphql/queries/LightningSendFeeEstimate.ts
+var LightningSendFeeEstimate = `
+  query LightningSendFeeEstimate(
+    $encoded_invoice: String!
+  ) {
+    lightning_send_fee_estimate(
+      input: {
+        encoded_invoice: $encoded_invoice
+      }
+    ) {
+      ...LightningSendFeeEstimateOutputFragment
+    }
+  }
+  ${FRAGMENT7}
+`;
+
+// src/graphql/client.ts
+var SspClient = class {
+  requester;
+  identityPublicKey;
+  signingKey;
+  constructor(identityPublicKey) {
+    this.identityPublicKey = identityPublicKey;
+    const fetchFunction = typeof window !== "undefined" ? window.fetch.bind(window) : fetch;
+    this.requester = new Requester(
+      new NodeKeyCache(DefaultCrypto),
+      "graphql/spark/rc",
+      `spark-sdk/0.0.0`,
+      new SparkAuthProvider(identityPublicKey),
+      "https://api.dev.dev.sparkinfra.net",
+      DefaultCrypto,
+      this.signingKey,
+      fetchFunction
+    );
+  }
+  async executeRawQuery(query) {
+    return await this.requester.executeQuery(query);
+  }
+  async getLightningReceiveFeeEstimate(amountSats, network) {
+    return await this.executeRawQuery({
+      queryPayload: LightningReceiveFeeEstimate,
+      variables: {
+        amount_sats: amountSats,
+        network
+      },
+      constructObject: (response) => {
+        return LightningReceiveFeeEstimateOutputFromJson(
+          response.lightning_receive_fee_estimate
+        );
+      }
+    });
+  }
+  async getLightningSendFeeEstimate(encodedInvoice) {
+    return await this.executeRawQuery({
+      queryPayload: LightningSendFeeEstimate,
+      variables: {
+        encoded_invoice: encodedInvoice
+      },
+      constructObject: (response) => {
+        return LightningSendFeeEstimateOutputFromJson(
+          response.lightning_send_fee_estimate
+        );
+      }
+    });
+  }
+  async getCoopExitFeeEstimate({
+    leafExternalIds,
+    withdrawalAddress
+  }) {
+    return await this.executeRawQuery({
+      queryPayload: CoopExitFeeEstimate,
+      variables: {
+        leaf_external_ids: leafExternalIds,
+        withdrawal_address: withdrawalAddress
+      },
+      constructObject: (response) => {
+        return CoopExitFeeEstimateOutputFromJson(
+          response.coop_exit_fee_estimate
+        );
+      }
+    });
+  }
+  // TODO: Might not need
+  async getCurrentUser() {
+    throw new Error("Not implemented");
+  }
+  async completeCoopExit({
+    userOutboundTransferExternalId,
+    coopExitRequestId
+  }) {
+    return await this.executeRawQuery({
+      queryPayload: CompleteCoopExit,
+      variables: {
+        user_outbound_transfer_external_id: userOutboundTransferExternalId,
+        coop_exit_request_id: coopExitRequestId
+      },
+      constructObject: (response) => {
+        return CoopExitRequestFromJson(response.complete_coop_exit.request);
+      }
+    });
+  }
+  async requestCoopExit({
+    leafExternalIds,
+    withdrawalAddress
+  }) {
+    return await this.executeRawQuery({
+      queryPayload: RequestCoopExit,
+      variables: {
+        leaf_external_ids: leafExternalIds,
+        withdrawal_address: withdrawalAddress
+      },
+      constructObject: (response) => {
+        return CoopExitRequestFromJson(response.request_coop_exit.request);
+      }
+    });
+  }
+  // TODO: Lets name this better
+  async requestLightningReceive({
+    amountSats,
+    network,
+    paymentHash,
+    expirySecs,
+    memo
+  }) {
+    return await this.executeRawQuery({
+      queryPayload: RequestLightningReceive,
+      variables: {
+        amount_sats: amountSats,
+        network,
+        payment_hash: paymentHash,
+        expiry_secs: expirySecs,
+        memo
+      },
+      constructObject: (response) => {
+        return LightningReceiveRequestFromJson(
+          response.request_lightning_receive.request
+        );
+      }
+    });
+  }
+  async requestLightningSend({
+    encodedInvoice,
+    idempotencyKey
+  }) {
+    return await this.executeRawQuery({
+      queryPayload: RequestLightningSend,
+      variables: {
+        encoded_invoice: encodedInvoice,
+        idempotency_key: idempotencyKey
+      },
+      constructObject: (response) => {
+        return LightningSendRequestFromJson(
+          response.request_lightning_send.request
+        );
+      }
+    });
+  }
+  async requestLeaveSwap({
+    adaptorPubkey,
+    totalAmountSats,
+    targetAmountSats,
+    feeSats,
+    userLeaves
+  }) {
+    const query = {
+      queryPayload: RequestSwapLeaves,
+      variables: {
+        adaptor_pubkey: adaptorPubkey,
+        total_amount_sats: totalAmountSats,
+        target_amount_sats: targetAmountSats,
+        fee_sats: feeSats,
+        user_leaves: userLeaves
+      },
+      constructObject: (response) => {
+        if (!response.request_leaves_swap) {
+          return null;
+        }
+        return LeavesSwapRequestFromJson(response.request_leaves_swap.request);
+      }
+    };
+    return await this.executeRawQuery(query);
+  }
+  async completeLeaveSwap({
+    adaptorSecretKey,
+    userOutboundTransferExternalId,
+    leavesSwapRequestId
+  }) {
+    return await this.executeRawQuery({
+      queryPayload: CompleteLeavesSwap,
+      variables: {
+        adaptor_secret_key: adaptorSecretKey,
+        user_outbound_transfer_external_id: userOutboundTransferExternalId,
+        leaves_swap_request_id: leavesSwapRequestId
+      },
+      constructObject: (response) => {
+        return LeavesSwapRequestFromJson(response.complete_leaves_swap.request);
+      }
+    });
+  }
+};
+var SparkAuthProvider = class {
+  publicKey;
+  constructor(publicKey) {
+    this.publicKey = publicKey;
+  }
+  async addAuthHeaders(headers) {
+    const _headers = {
+      "Spark-Identity-Public-Key": this.publicKey,
+      "Content-Type": "application/json"
+    };
+    return Promise.resolve(_headers);
+  }
+  async isAuthorized() {
+    return Promise.resolve(true);
+  }
+  async addWsConnectionParams(params) {
+    return Promise.resolve({
+      ...params,
+      "Spark-Identity-Public-Key": this.publicKey
+    });
+  }
+};
+
+// src/services/coop-exit.ts
+import { Transaction as Transaction2 } from "@scure/btc-signer";
+
+// src/services/transfer.ts
+import {
+  bytesToHex,
+  equalBytes,
+  hexToBytes,
+  numberToBytesBE
+} from "@noble/curves/abstract/utils";
+import { secp256k1 } from "@noble/curves/secp256k1";
+import { Transaction } from "@scure/btc-signer";
+import { sha256 } from "@scure/btc-signer/utils";
+import * as ecies from "eciesjs";
+var INITIAL_TIME_LOCK = 2e3;
+function initialSequence() {
+  return 1 << 30 | INITIAL_TIME_LOCK;
+}
+var crypto = getCrypto();
+var BaseTransferService = class {
+  config;
+  connectionManager;
+  constructor(config, connectionManager) {
+    this.config = config;
+    this.connectionManager = connectionManager;
+  }
+  async sendTransferTweakKey(transfer, leaves, refundSignatureMap) {
+    const keyTweakInputMap = await this.prepareSendTransferKeyTweaks(
+      transfer,
+      leaves,
+      refundSignatureMap
+    );
+    let updatedTransfer;
+    const errors = [];
+    const promises = Object.entries(
+      this.config.getConfig().signingOperators
+    ).map(async ([identifier, operator]) => {
+      const sparkClient = await this.connectionManager.createSparkClient(
+        operator.address
+      );
+      const leavesToSend = keyTweakInputMap.get(identifier);
+      if (!leavesToSend) {
+        errors.push(new Error(`No leaves to send for operator ${identifier}`));
+        return;
+      }
+      let transferResp;
+      try {
+        transferResp = await sparkClient.complete_send_transfer({
+          transferId: transfer.id,
+          ownerIdentityPublicKey: await this.config.signer.getIdentityPublicKey(),
+          leavesToSend
+        });
+      } catch (error) {
+        errors.push(new Error(`Error completing send transfer: ${error}`));
+        return;
+      }
+      if (!updatedTransfer) {
+        updatedTransfer = transferResp.transfer;
+      } else {
+        if (!transferResp.transfer) {
+          errors.push(
+            new Error(`No transfer response from operator ${identifier}`)
+          );
+          return;
+        }
+        if (!this.compareTransfers(updatedTransfer, transferResp.transfer)) {
+          errors.push(
+            new Error(`Inconsistent transfer response from operators`)
+          );
+        }
+      }
+    });
+    await Promise.all(promises);
+    if (errors.length > 0) {
+      throw new Error(`Error completing send transfer: ${errors[0]}`);
+    }
+    if (!updatedTransfer) {
+      throw new Error("No updated transfer found");
+    }
+    return updatedTransfer;
+  }
+  async signRefunds(leafDataMap, operatorSigningResults, adaptorPubKey) {
+    const nodeSignatures = [];
+    for (const operatorSigningResult of operatorSigningResults) {
+      const leafData = leafDataMap.get(operatorSigningResult.leafId);
+      if (!leafData || !leafData.tx || leafData.vout === void 0 || !leafData.refundTx) {
+        throw new Error(
+          `Leaf data not found for leaf ${operatorSigningResult.leafId}`
+        );
+      }
+      const txOutput = leafData.tx?.getOutput(0);
+      if (!txOutput) {
+        throw new Error(
+          `Output not found for leaf ${operatorSigningResult.leafId}`
+        );
+      }
+      const refundTxSighash = getSigHashFromTx(leafData.refundTx, 0, txOutput);
+      const userSignature = await this.config.signer.signFrost({
+        message: refundTxSighash,
+        publicKey: leafData.signingPubKey,
+        privateAsPubKey: leafData.signingPubKey,
+        selfCommitment: leafData.signingNonceCommitment,
+        statechainCommitments: operatorSigningResult.refundTxSigningResult?.signingNonceCommitments,
+        adaptorPubKey,
+        verifyingKey: operatorSigningResult.verifyingKey
+      });
+      const refundAggregate = await this.config.signer.aggregateFrost({
+        message: refundTxSighash,
+        statechainSignatures: operatorSigningResult.refundTxSigningResult?.signatureShares,
+        statechainPublicKeys: operatorSigningResult.refundTxSigningResult?.publicKeys,
+        verifyingKey: operatorSigningResult.verifyingKey,
+        statechainCommitments: operatorSigningResult.refundTxSigningResult?.signingNonceCommitments,
+        selfCommitment: leafData.signingNonceCommitment,
+        publicKey: leafData.signingPubKey,
+        selfSignature: userSignature,
+        adaptorPubKey
+      });
+      nodeSignatures.push({
+        nodeId: operatorSigningResult.leafId,
+        refundTxSignature: refundAggregate,
+        nodeTxSignature: new Uint8Array()
+      });
+    }
+    return nodeSignatures;
+  }
+  async prepareSendTransferKeyTweaks(transfer, leaves, refundSignatureMap) {
+    const receiverEciesPubKey = ecies.PublicKey.fromHex(
+      bytesToHex(transfer.receiverIdentityPublicKey)
+    );
+    const leavesTweaksMap = /* @__PURE__ */ new Map();
+    for (const leaf of leaves) {
+      const refundSignature = refundSignatureMap.get(leaf.leaf.id);
+      const leafTweaksMap = await this.prepareSingleSendTransferKeyTweak(
+        transfer.id,
+        leaf,
+        receiverEciesPubKey,
+        refundSignature
+      );
+      for (const [identifier, leafTweak] of leafTweaksMap) {
+        leavesTweaksMap.set(identifier, [
+          ...leavesTweaksMap.get(identifier) || [],
+          leafTweak
+        ]);
+      }
+    }
+    return leavesTweaksMap;
+  }
+  async prepareSingleSendTransferKeyTweak(transferID, leaf, receiverEciesPubKey, refundSignature) {
+    const pubKeyTweak = await this.config.signer.subtractPrivateKeysGivenPublicKeys(
+      leaf.signingPubKey,
+      leaf.newSigningPubKey
+    );
+    const shares = await this.config.signer.splitSecretWithProofs({
+      secret: pubKeyTweak,
+      curveOrder: secp256k1.CURVE.n,
+      threshold: this.config.getConfig().threshold,
+      numShares: Object.keys(this.config.getConfig().signingOperators).length,
+      isSecretPubkey: true
+    });
+    const pubkeySharesTweak = /* @__PURE__ */ new Map();
+    for (const [identifier, operator] of Object.entries(
+      this.config.getConfig().signingOperators
+    )) {
+      const share = this.findShare(shares, operator.id);
+      if (!share) {
+        throw new Error(`Share not found for operator ${operator.id}`);
+      }
+      const pubkeyTweak = secp256k1.getPublicKey(
+        numberToBytesBE(share.share, 32),
+        true
+      );
+      pubkeySharesTweak.set(identifier, pubkeyTweak);
+    }
+    const secretCipher = await this.config.signer.encryptLeafPrivateKeyEcies(
+      receiverEciesPubKey.toBytes(),
+      leaf.newSigningPubKey
+    );
+    const encoder = new TextEncoder();
+    const payload = new Uint8Array([
+      ...encoder.encode(leaf.leaf.id),
+      ...encoder.encode(transferID),
+      ...secretCipher
+    ]);
+    const payloadHash = sha256(payload);
+    const signature = await this.config.signer.signMessageWithIdentityKey(
+      payloadHash,
+      true
+    );
+    const leafTweaksMap = /* @__PURE__ */ new Map();
+    for (const [identifier, operator] of Object.entries(
+      this.config.getConfig().signingOperators
+    )) {
+      const share = this.findShare(shares, operator.id);
+      if (!share) {
+        throw new Error(`Share not found for operator ${operator.id}`);
+      }
+      leafTweaksMap.set(identifier, {
+        leafId: leaf.leaf.id,
+        secretShareTweak: {
+          secretShare: numberToBytesBE(share.share, 32),
+          proofs: share.proofs
+        },
+        pubkeySharesTweak: Object.fromEntries(pubkeySharesTweak),
+        secretCipher,
+        signature,
+        refundSignature: refundSignature ?? new Uint8Array()
+      });
+    }
+    return leafTweaksMap;
+  }
+  findShare(shares, operatorID) {
+    const targetShareIndex = BigInt(operatorID + 1);
+    for (const s of shares) {
+      if (s.index === targetShareIndex) {
+        return s;
+      }
+    }
+    return void 0;
+  }
+  compareTransfers(transfer1, transfer2) {
+    return transfer1.id === transfer2.id && 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;
+  }
+};
+var TransferService = class extends BaseTransferService {
+  constructor(config, connectionManager) {
+    super(config, connectionManager);
+  }
+  async sendTransfer(leaves, receiverIdentityPubkey, expiryTime) {
+    const { transfer, signatureMap } = await this.sendTransferSignRefund(
+      leaves,
+      receiverIdentityPubkey,
+      expiryTime
+    );
+    const transferWithTweakedKeys = await this.sendTransferTweakKey(
+      transfer,
+      leaves,
+      signatureMap
+    );
+    return transferWithTweakedKeys;
+  }
+  async claimTransfer(transfer, leaves) {
+    if (transfer.status === 2 /* TRANSFER_STATUS_SENDER_KEY_TWEAKED */) {
+      await this.claimTransferTweakKeys(transfer, leaves);
+    }
+    const signatures = await this.claimTransferSignRefunds(transfer, leaves);
+    return await this.finalizeTransfer(signatures);
+  }
+  async queryPendingTransfers() {
+    const sparkClient = await this.connectionManager.createSparkClient(
+      this.config.getCoordinatorAddress()
+    );
+    let pendingTransfersResp;
+    try {
+      pendingTransfersResp = await sparkClient.query_pending_transfers({
+        participant: {
+          $case: "receiverIdentityPublicKey",
+          receiverIdentityPublicKey: await this.config.signer.getIdentityPublicKey()
+        }
+      });
+    } catch (error) {
+      throw new Error(`Error querying pending transfers: ${error}`);
+    }
+    return pendingTransfersResp;
+  }
+  async queryAllTransfers(limit, offset) {
+    const sparkClient = await this.connectionManager.createSparkClient(
+      this.config.getCoordinatorAddress()
+    );
+    let allTransfersResp;
+    try {
+      allTransfersResp = await sparkClient.query_all_transfers({
+        identityPublicKey: await this.config.signer.getIdentityPublicKey(),
+        limit,
+        offset
+      });
+    } catch (error) {
+      throw new Error(`Error querying all transfers: ${error}`);
+    }
+    return allTransfersResp;
+  }
+  async verifyPendingTransfer(transfer) {
+    const leafPubKeyMap = /* @__PURE__ */ new Map();
+    for (const leaf of transfer.leaves) {
+      if (!leaf.leaf) {
+        throw new Error("Leaf is undefined");
+      }
+      const encoder = new TextEncoder();
+      const leafIdBytes = encoder.encode(leaf.leaf.id);
+      const transferIdBytes = encoder.encode(transfer.id);
+      const payload = new Uint8Array([
+        ...leafIdBytes,
+        ...transferIdBytes,
+        ...leaf.secretCipher
+      ]);
+      const payloadHash = sha256(payload);
+      if (!secp256k1.verify(
+        leaf.signature,
+        payloadHash,
+        transfer.senderIdentityPublicKey
+      )) {
+        throw new Error("Signature verification failed");
+      }
+      const leafSecret = await this.config.signer.decryptEcies(
+        leaf.secretCipher
+      );
+      leafPubKeyMap.set(leaf.leaf.id, leafSecret);
+    }
+    return leafPubKeyMap;
+  }
+  async sendSwapSignRefund(leaves, receiverIdentityPubkey, expiryTime, adaptorPubKey) {
+    const transferId = crypto.randomUUID();
+    const leafDataMap = /* @__PURE__ */ new Map();
+    for (const leaf of leaves) {
+      const signingNonceCommitment = await this.config.signer.getRandomSigningCommitment();
+      const tx = getTxFromRawTxBytes(leaf.leaf.nodeTx);
+      const refundTx = getTxFromRawTxBytes(leaf.leaf.refundTx);
+      leafDataMap.set(leaf.leaf.id, {
+        signingPubKey: leaf.signingPubKey,
+        receivingPubkey: receiverIdentityPubkey,
+        signingNonceCommitment,
+        tx,
+        refundTx,
+        vout: leaf.leaf.vout
+      });
+    }
+    const signingJobs = this.prepareRefundSoSigningJobs(leaves, leafDataMap);
+    const sparkClient = await this.connectionManager.createSparkClient(
+      this.config.getCoordinatorAddress()
+    );
+    let response;
+    try {
+      response = await sparkClient.leaf_swap({
+        transfer: {
+          transferId,
+          leavesToSend: signingJobs,
+          ownerIdentityPublicKey: await this.config.signer.getIdentityPublicKey(),
+          receiverIdentityPublicKey: receiverIdentityPubkey,
+          expiryTime
+        },
+        swapId: crypto.randomUUID(),
+        adaptorPublicKey: adaptorPubKey || new Uint8Array()
+      });
+    } catch (error) {
+      throw new Error(`Error initiating leaf swap: ${error}`);
+    }
+    if (!response.transfer) {
+      throw new Error("No transfer response from coordinator");
+    }
+    const signatures = await this.signRefunds(
+      leafDataMap,
+      response.signingResults,
+      adaptorPubKey
+    );
+    const signatureMap = /* @__PURE__ */ new Map();
+    for (const signature of signatures) {
+      signatureMap.set(signature.nodeId, signature.refundTxSignature);
+    }
+    return {
+      transfer: response.transfer,
+      signatureMap,
+      leafDataMap,
+      signingResults: response.signingResults
+    };
+  }
+  async sendTransferSignRefund(leaves, receiverIdentityPubkey, expiryTime) {
+    const transferID = crypto.randomUUID();
+    const leafDataMap = /* @__PURE__ */ new Map();
+    for (const leaf of leaves) {
+      const signingNonceCommitment = await this.config.signer.getRandomSigningCommitment();
+      const tx = getTxFromRawTxBytes(leaf.leaf.nodeTx);
+      const refundTx = getTxFromRawTxBytes(leaf.leaf.refundTx);
+      leafDataMap.set(leaf.leaf.id, {
+        signingPubKey: leaf.signingPubKey,
+        receivingPubkey: receiverIdentityPubkey,
+        signingNonceCommitment,
+        tx,
+        refundTx,
+        vout: leaf.leaf.vout
+      });
+    }
+    const signingJobs = this.prepareRefundSoSigningJobs(leaves, leafDataMap);
+    const sparkClient = await this.connectionManager.createSparkClient(
+      this.config.getCoordinatorAddress()
+    );
+    let response;
+    try {
+      response = await sparkClient.start_send_transfer({
+        transferId: transferID,
+        leavesToSend: signingJobs,
+        ownerIdentityPublicKey: await this.config.signer.getIdentityPublicKey(),
+        receiverIdentityPublicKey: receiverIdentityPubkey,
+        expiryTime
+      });
+    } catch (error) {
+      throw new Error(`Error starting send transfer: ${error}`);
+    }
+    const signatures = await this.signRefunds(
+      leafDataMap,
+      response.signingResults
+    );
+    const signatureMap = /* @__PURE__ */ new Map();
+    for (const signature of signatures) {
+      signatureMap.set(signature.nodeId, signature.refundTxSignature);
+    }
+    if (!response.transfer) {
+      throw new Error("No transfer response from coordinator");
+    }
+    return {
+      transfer: response.transfer,
+      signatureMap,
+      leafDataMap
+    };
+  }
+  prepareRefundSoSigningJobs(leaves, leafDataMap) {
+    const signingJobs = [];
+    for (const leaf of leaves) {
+      const refundSigningData = leafDataMap.get(leaf.leaf.id);
+      if (!refundSigningData) {
+        throw new Error(`Leaf data not found for leaf ${leaf.leaf.id}`);
+      }
+      const nodeTx = getTxFromRawTxBytes(leaf.leaf.nodeTx);
+      const nodeOutPoint = {
+        txid: hexToBytes(getTxId(nodeTx)),
+        index: 0
+      };
+      const currRefundTx = getTxFromRawTxBytes(leaf.leaf.refundTx);
+      const nextSequence = getNextTransactionSequence(
+        currRefundTx.getInput(0).sequence
+      );
+      const amountSats = currRefundTx.getOutput(0).amount;
+      if (amountSats === void 0) {
+        throw new Error("Amount not found in signRefunds");
+      }
+      const refundTx = createRefundTx(
+        nextSequence,
+        nodeOutPoint,
+        amountSats,
+        refundSigningData.receivingPubkey,
+        this.config.getNetwork()
+      );
+      refundSigningData.refundTx = refundTx;
+      const refundNonceCommitmentProto = refundSigningData.signingNonceCommitment;
+      signingJobs.push({
+        leafId: leaf.leaf.id,
+        refundTxSigningJob: {
+          signingPublicKey: refundSigningData.signingPubKey,
+          rawTx: refundTx.toBytes(),
+          signingNonceCommitment: refundNonceCommitmentProto
+        }
+      });
+    }
+    return signingJobs;
+  }
+  async claimTransferTweakKeys(transfer, leaves) {
+    const leavesTweaksMap = await this.prepareClaimLeavesKeyTweaks(leaves);
+    const errors = [];
+    const promises = Object.entries(
+      this.config.getConfig().signingOperators
+    ).map(async ([identifier, operator]) => {
+      const sparkClient = await this.connectionManager.createSparkClient(
+        operator.address
+      );
+      const leavesToReceive = leavesTweaksMap.get(identifier);
+      if (!leavesToReceive) {
+        errors.push(
+          new Error(`No leaves to receive for operator ${identifier}`)
+        );
+        return;
+      }
+      try {
+        await sparkClient.claim_transfer_tweak_keys({
+          transferId: transfer.id,
+          ownerIdentityPublicKey: await this.config.signer.getIdentityPublicKey(),
+          leavesToReceive
+        });
+      } catch (error) {
+        errors.push(new Error(`Error claiming transfer tweak keys: ${error}`));
+        return;
+      }
+    });
+    await Promise.all(promises);
+    if (errors.length > 0) {
+      throw new Error(`Error claiming transfer tweak keys: ${errors[0]}`);
+    }
+  }
+  async prepareClaimLeavesKeyTweaks(leaves) {
+    const leafDataMap = /* @__PURE__ */ new Map();
+    for (const leaf of leaves) {
+      const leafData = await this.prepareClaimLeafKeyTweaks(leaf);
+      for (const [identifier, leafTweak] of leafData) {
+        leafDataMap.set(identifier, [
+          ...leafDataMap.get(identifier) || [],
+          leafTweak
+        ]);
+      }
+    }
+    return leafDataMap;
+  }
+  async prepareClaimLeafKeyTweaks(leaf) {
+    const pubKeyTweak = await this.config.signer.subtractPrivateKeysGivenPublicKeys(
+      leaf.signingPubKey,
+      leaf.newSigningPubKey
+    );
+    const shares = await this.config.signer.splitSecretWithProofs({
+      secret: pubKeyTweak,
+      curveOrder: secp256k1.CURVE.n,
+      threshold: this.config.getConfig().threshold,
+      numShares: Object.keys(this.config.getConfig().signingOperators).length,
+      isSecretPubkey: true
+    });
+    const pubkeySharesTweak = /* @__PURE__ */ new Map();
+    for (const [identifier, operator] of Object.entries(
+      this.config.getConfig().signingOperators
+    )) {
+      const share = this.findShare(shares, operator.id);
+      if (!share) {
+        throw new Error(`Share not found for operator ${operator.id}`);
+      }
+      const pubkeyTweak = secp256k1.getPublicKey(
+        numberToBytesBE(share.share, 32)
+      );
+      pubkeySharesTweak.set(identifier, pubkeyTweak);
+    }
+    const leafTweaksMap = /* @__PURE__ */ new Map();
+    for (const [identifier, operator] of Object.entries(
+      this.config.getConfig().signingOperators
+    )) {
+      const share = this.findShare(shares, operator.id);
+      if (!share) {
+        throw new Error(`Share not found for operator ${operator.id}`);
+      }
+      leafTweaksMap.set(identifier, {
+        leafId: leaf.leaf.id,
+        secretShareTweak: {
+          secretShare: numberToBytesBE(share.share, 32),
+          proofs: share.proofs
+        },
+        pubkeySharesTweak: Object.fromEntries(pubkeySharesTweak)
+      });
+    }
+    return leafTweaksMap;
+  }
+  async claimTransferSignRefunds(transfer, leafKeys) {
+    const leafDataMap = /* @__PURE__ */ new Map();
+    for (const leafKey of leafKeys) {
+      const tx = getTxFromRawTxBytes(leafKey.leaf.nodeTx);
+      leafDataMap.set(leafKey.leaf.id, {
+        signingPubKey: leafKey.newSigningPubKey,
+        receivingPubkey: leafKey.newSigningPubKey,
+        signingNonceCommitment: await this.config.signer.getRandomSigningCommitment(),
+        tx,
+        vout: leafKey.leaf.vout
+      });
+    }
+    const signingJobs = this.prepareRefundSoSigningJobs(leafKeys, leafDataMap);
+    const sparkClient = await this.connectionManager.createSparkClient(
+      this.config.getCoordinatorAddress()
+    );
+    let resp;
+    try {
+      resp = await sparkClient.claim_transfer_sign_refunds({
+        transferId: transfer.id,
+        ownerIdentityPublicKey: await this.config.signer.getIdentityPublicKey(),
+        signingJobs
+      });
+    } catch (error) {
+      throw new Error(`Error claiming transfer sign refunds: ${error}`);
+    }
+    return this.signRefunds(leafDataMap, resp.signingResults);
+  }
+  async finalizeTransfer(nodeSignatures) {
+    const sparkClient = await this.connectionManager.createSparkClient(
+      this.config.getCoordinatorAddress()
+    );
+    try {
+      return await sparkClient.finalize_node_signatures({
+        intent: 1 /* TRANSFER */,
+        nodeSignatures
+      });
+    } catch (error) {
+      throw new Error(`Error finalizing node signatures in transfer: ${error}`);
+    }
+  }
+  async cancelSendTransfer(transfer) {
+    const sparkClient = await this.connectionManager.createSparkClient(
+      this.config.getCoordinatorAddress()
+    );
+    try {
+      const response = await sparkClient.cancel_send_transfer({
+        transferId: transfer.id,
+        senderIdentityPublicKey: await this.config.signer.getIdentityPublicKey()
+      });
+      return response.transfer;
+    } catch (error) {
+      throw new Error(`Error canceling send transfer: ${error}`);
+    }
+  }
+  async queryPendingTransfersBySender() {
+    const sparkClient = await this.connectionManager.createSparkClient(
+      this.config.getCoordinatorAddress()
+    );
+    try {
+      return await sparkClient.query_pending_transfers({
+        participant: {
+          $case: "senderIdentityPublicKey",
+          senderIdentityPublicKey: await this.config.signer.getIdentityPublicKey()
+        }
+      });
+    } catch (error) {
+      throw new Error(`Error querying pending transfers by sender: ${error}`);
+    }
+  }
+  async refreshTimelockNodes(nodes, parentNode, signingPubKey) {
+    if (nodes.length === 0) {
+      throw Error("no nodes to refresh");
+    }
+    const signingJobs = [];
+    const newNodeTxs = [];
+    for (let i = 0; i < nodes.length; i++) {
+      const node = nodes[i];
+      if (!node) {
+        throw Error("could not get node");
+      }
+      const nodeTx = getTxFromRawTxBytes(node?.nodeTx);
+      const input = nodeTx.getInput(0);
+      if (!input) {
+        throw Error("Could not fetch tx input");
+      }
+      const newTx = new Transaction({ allowUnknownOutputs: true });
+      for (let j = 0; j < nodeTx.outputsLength; j++) {
+        newTx.addOutput(nodeTx.getOutput(j));
+      }
+      if (i === 0) {
+        const currSequence = input.sequence;
+        newTx.addInput({
+          ...input,
+          sequence: getNextTransactionSequence(currSequence)
+        });
+      } else {
+        newTx.addInput({
+          ...input,
+          sequence: initialSequence(),
+          txid: newNodeTxs[i - 1]?.id
+        });
+      }
+      signingJobs.push({
+        signingPublicKey: signingPubKey,
+        rawTx: newTx.toBytes(),
+        signingNonceCommitment: await this.config.signer.getRandomSigningCommitment()
+      });
+      newNodeTxs[i] = newTx;
+    }
+    const leaf = nodes[nodes.length - 1];
+    if (!leaf?.refundTx) {
+      throw Error("leaf does not have refund tx");
+    }
+    const refundTx = getTxFromRawTxBytes(leaf?.refundTx);
+    const newRefundTx = new Transaction({ allowUnknownOutputs: true });
+    for (let j = 0; j < refundTx.outputsLength; j++) {
+      newRefundTx.addOutput(refundTx.getOutput(j));
+    }
+    const refundTxInput = refundTx.getInput(0);
+    if (!refundTxInput) {
+      throw Error("refund tx doesn't have input");
+    }
+    if (!newNodeTxs[newNodeTxs.length - 1]) {
+      throw Error("Could not get last node tx");
+    }
+    newRefundTx.addInput({
+      ...refundTxInput,
+      sequence: initialSequence(),
+      txid: getTxId(newNodeTxs[newNodeTxs.length - 1])
+    });
+    const refundSigningJob = {
+      signingPublicKey: signingPubKey,
+      rawTx: newRefundTx.toBytes(),
+      signingNonceCommitment: await this.config.signer.getRandomSigningCommitment()
+    };
+    signingJobs.push(refundSigningJob);
+    const sparkClient = await this.connectionManager.createSparkClient(
+      this.config.getCoordinatorAddress()
+    );
+    const response = await sparkClient.refresh_timelock({
+      leafId: leaf.id,
+      ownerIdentityPublicKey: await this.config.signer.getIdentityPublicKey(),
+      signingJobs
+    });
+    if (signingJobs.length !== response.signingResults.length) {
+      throw Error(
+        `number of signing jobs and signing results do not match: ${signingJobs.length} !== ${response.signingResults.length}`
+      );
+    }
+    let nodeSignatures = [];
+    let leafSignature;
+    let refundSignature;
+    let leafNodeId;
+    for (let i = 0; i < response.signingResults.length; i++) {
+      const signingResult = response.signingResults[i];
+      const signingJob = signingJobs[i];
+      if (!signingJob || !signingResult) {
+        throw Error("Signing job does not exist");
+      }
+      if (!signingJob.signingNonceCommitment) {
+        throw Error("nonce commitment does not exist");
+      }
+      const rawTx = getTxFromRawTxBytes(signingJob.rawTx);
+      let parentTx;
+      let nodeId;
+      let vout;
+      if (i === nodes.length) {
+        nodeId = nodes[i - 1]?.id;
+        parentTx = newNodeTxs[i - 1];
+        vout = 0;
+      } else if (i === 0) {
+        nodeId = nodes[i]?.id;
+        parentTx = getTxFromRawTxBytes(parentNode.nodeTx);
+        vout = nodes[i]?.vout;
+      } else {
+        nodeId = nodes[i]?.id;
+        parentTx = newNodeTxs[i - 1];
+        vout = nodes[i]?.vout;
+      }
+      if (!parentTx || !nodeId || vout === void 0) {
+        throw Error("Could not parse signing results");
+      }
+      const txOut = parentTx.getOutput(vout);
+      const rawTxSighash = getSigHashFromTx(rawTx, 0, txOut);
+      const userSignature = await this.config.signer.signFrost({
+        message: rawTxSighash,
+        privateAsPubKey: signingPubKey,
+        publicKey: signingPubKey,
+        verifyingKey: signingResult.verifyingKey,
+        selfCommitment: signingJob.signingNonceCommitment,
+        statechainCommitments: signingResult.signingResult?.signingNonceCommitments,
+        adaptorPubKey: new Uint8Array()
+      });
+      const signature = await this.config.signer.aggregateFrost({
+        message: rawTxSighash,
+        statechainSignatures: signingResult.signingResult?.signatureShares,
+        statechainPublicKeys: signingResult.signingResult?.publicKeys,
+        verifyingKey: signingResult.verifyingKey,
+        statechainCommitments: signingResult.signingResult?.signingNonceCommitments,
+        selfCommitment: signingJob.signingNonceCommitment,
+        publicKey: signingPubKey,
+        selfSignature: userSignature,
+        adaptorPubKey: new Uint8Array()
+      });
+      if (i !== nodes.length && i !== nodes.length - 1) {
+        nodeSignatures.push({
+          nodeId,
+          nodeTxSignature: signature,
+          refundTxSignature: new Uint8Array()
+        });
+      } else if (i === nodes.length) {
+        refundSignature = signature;
+      } else if (i === nodes.length - 1) {
+        leafNodeId = nodeId;
+        leafSignature = signature;
+      }
+    }
+    if (!leafSignature || !refundSignature || !leafNodeId) {
+      throw Error("leaf or refund signature does not exist");
+    }
+    nodeSignatures.push({
+      nodeId: leafNodeId,
+      nodeTxSignature: leafSignature,
+      refundTxSignature: refundSignature
+    });
+    return await sparkClient.finalize_node_signatures({
+      intent: 3 /* REFRESH */,
+      nodeSignatures
+    });
+  }
+  async extendTimelock(node, signingPubKey) {
+    const nodeTx = getTxFromRawTxBytes(node.nodeTx);
+    const refundTx = getTxFromRawTxBytes(node.refundTx);
+    const refundSequence = refundTx.getInput(0).sequence || 0;
+    const newNodeOutPoint = {
+      txid: hexToBytes(nodeTx.id),
+      index: 0
+    };
+    const newNodeSequence = getNextTransactionSequence(refundSequence);
+    const newNodeTx = new Transaction({ allowUnknownOutputs: true });
+    newNodeTx.addInput({ ...newNodeOutPoint, sequence: newNodeSequence });
+    newNodeTx.addOutput(nodeTx.getOutput(0));
+    newNodeTx.addOutput(getEphemeralAnchorOutput());
+    const newRefundOutPoint = {
+      txid: hexToBytes(getTxId(newNodeTx)),
+      index: 0
+    };
+    const amountSats = refundTx.getOutput(0).amount;
+    if (amountSats === void 0) {
+      throw new Error("Amount not found in extendTimelock");
+    }
+    const newRefundTx = createRefundTx(
+      initialSequence(),
+      newRefundOutPoint,
+      amountSats,
+      signingPubKey,
+      this.config.getNetwork()
+    );
+    const nodeSighash = getSigHashFromTx(newNodeTx, 0, nodeTx.getOutput(0));
+    const refundSighash = getSigHashFromTx(newRefundTx, 0, nodeTx.getOutput(0));
+    const newNodeSigningJob = {
+      signingPublicKey: signingPubKey,
+      rawTx: newNodeTx.toBytes(),
+      signingNonceCommitment: await this.config.signer.getRandomSigningCommitment()
+    };
+    const newRefundSigningJob = {
+      signingPublicKey: signingPubKey,
+      rawTx: newRefundTx.toBytes(),
+      signingNonceCommitment: await this.config.signer.getRandomSigningCommitment()
+    };
+    const sparkClient = await this.connectionManager.createSparkClient(
+      this.config.getCoordinatorAddress()
+    );
+    const response = await sparkClient.extend_leaf({
+      leafId: node.id,
+      ownerIdentityPublicKey: await this.config.signer.getIdentityPublicKey(),
+      nodeTxSigningJob: newNodeSigningJob,
+      refundTxSigningJob: newRefundSigningJob
+    });
+    if (!response.nodeTxSigningResult || !response.refundTxSigningResult) {
+      throw new Error("Signing result does not exist");
+    }
+    const nodeUserSig = await this.config.signer.signFrost({
+      message: nodeSighash,
+      privateAsPubKey: signingPubKey,
+      publicKey: signingPubKey,
+      verifyingKey: response.nodeTxSigningResult.verifyingKey,
+      selfCommitment: newNodeSigningJob.signingNonceCommitment,
+      statechainCommitments: response.nodeTxSigningResult.signingResult?.signingNonceCommitments,
+      adaptorPubKey: new Uint8Array()
+    });
+    const refundUserSig = await this.config.signer.signFrost({
+      message: refundSighash,
+      privateAsPubKey: signingPubKey,
+      publicKey: signingPubKey,
+      verifyingKey: response.refundTxSigningResult.verifyingKey,
+      selfCommitment: newRefundSigningJob.signingNonceCommitment,
+      statechainCommitments: response.refundTxSigningResult.signingResult?.signingNonceCommitments,
+      adaptorPubKey: new Uint8Array()
+    });
+    const nodeSig = await this.config.signer.aggregateFrost({
+      message: nodeSighash,
+      statechainSignatures: response.nodeTxSigningResult.signingResult?.signatureShares,
+      statechainPublicKeys: response.nodeTxSigningResult.signingResult?.publicKeys,
+      verifyingKey: response.nodeTxSigningResult.verifyingKey,
+      statechainCommitments: response.nodeTxSigningResult.signingResult?.signingNonceCommitments,
+      selfCommitment: newNodeSigningJob.signingNonceCommitment,
+      publicKey: signingPubKey,
+      selfSignature: nodeUserSig,
+      adaptorPubKey: new Uint8Array()
+    });
+    const refundSig = await this.config.signer.aggregateFrost({
+      message: refundSighash,
+      statechainSignatures: response.refundTxSigningResult.signingResult?.signatureShares,
+      statechainPublicKeys: response.refundTxSigningResult.signingResult?.publicKeys,
+      verifyingKey: response.refundTxSigningResult.verifyingKey,
+      statechainCommitments: response.refundTxSigningResult.signingResult?.signingNonceCommitments,
+      selfCommitment: newRefundSigningJob.signingNonceCommitment,
+      publicKey: signingPubKey,
+      selfSignature: refundUserSig,
+      adaptorPubKey: new Uint8Array()
+    });
+    return await sparkClient.finalize_node_signatures({
+      intent: 4 /* EXTEND */,
+      nodeSignatures: [
+        {
+          nodeId: response.leafId,
+          nodeTxSignature: nodeSig,
+          refundTxSignature: refundSig
+        }
+      ]
+    });
+  }
+};
+
+// src/services/coop-exit.ts
+var crypto2 = getCrypto();
+var CoopExitService = class extends BaseTransferService {
+  constructor(config, connectionManager) {
+    super(config, connectionManager);
+  }
+  async getConnectorRefundSignatures({
+    leaves,
+    exitTxId,
+    connectorOutputs,
+    receiverPubKey
+  }) {
+    const { transfer, signaturesMap } = await this.signCoopExitRefunds(
+      leaves,
+      exitTxId,
+      connectorOutputs,
+      receiverPubKey
+    );
+    const transferTweak = await this.sendTransferTweakKey(
+      transfer,
+      leaves,
+      signaturesMap
+    );
+    return { transfer: transferTweak, signaturesMap };
+  }
+  createConnectorRefundTransaction(sequence, nodeOutPoint, connectorOutput, amountSats, receiverPubKey) {
+    const refundTx = new Transaction2();
+    if (!nodeOutPoint.txid || nodeOutPoint.index === void 0) {
+      throw new Error("Node outpoint txid or index is undefined");
+    }
+    refundTx.addInput({
+      txid: nodeOutPoint.txid,
+      index: nodeOutPoint.index,
+      sequence
+    });
+    refundTx.addInput(connectorOutput);
+    const receiverScript = getP2TRScriptFromPublicKey(
+      receiverPubKey,
+      this.config.getNetwork()
+    );
+    refundTx.addOutput({
+      script: receiverScript,
+      amount: amountSats
+    });
+    return refundTx;
+  }
+  async signCoopExitRefunds(leaves, exitTxId, connectorOutputs, receiverPubKey) {
+    if (leaves.length !== connectorOutputs.length) {
+      throw new Error("Number of leaves and connector outputs must match");
+    }
+    const signingJobs = [];
+    const leafDataMap = /* @__PURE__ */ new Map();
+    for (let i = 0; i < leaves.length; i++) {
+      const leaf = leaves[i];
+      const connectorOutput = connectorOutputs[i];
+      if (!leaf?.leaf) {
+        throw new Error("Leaf not found");
+      }
+      if (!connectorOutput) {
+        throw new Error("Connector output not found");
+      }
+      const currentRefundTx = getTxFromRawTxBytes(leaf.leaf.refundTx);
+      const sequence = getNextTransactionSequence(
+        currentRefundTx.getInput(0).sequence
+      );
+      const refundTx = this.createConnectorRefundTransaction(
+        sequence,
+        currentRefundTx.getInput(0),
+        connectorOutput,
+        BigInt(leaf.leaf.value),
+        receiverPubKey
+      );
+      const signingNonceCommitment = await this.config.signer.getRandomSigningCommitment();
+      const signingJob = {
+        leafId: leaf.leaf.id,
+        refundTxSigningJob: {
+          signingPublicKey: leaf.signingPubKey,
+          rawTx: refundTx.toBytes(),
+          signingNonceCommitment
+        }
+      };
+      signingJobs.push(signingJob);
+      const tx = getTxFromRawTxBytes(leaf.leaf.nodeTx);
+      leafDataMap.set(leaf.leaf.id, {
+        signingPubKey: leaf.signingPubKey,
+        refundTx,
+        signingNonceCommitment,
+        tx,
+        vout: leaf.leaf.vout,
+        receivingPubkey: receiverPubKey
+      });
+    }
+    const sparkClient = await this.connectionManager.createSparkClient(
+      this.config.getCoordinatorAddress()
+    );
+    let response;
+    try {
+      response = await sparkClient.cooperative_exit({
+        transfer: {
+          transferId: crypto2.randomUUID(),
+          leavesToSend: signingJobs,
+          ownerIdentityPublicKey: await this.config.signer.getIdentityPublicKey(),
+          receiverIdentityPublicKey: receiverPubKey,
+          expiryTime: new Date(Date.now() + 24 * 60 * 1e3)
+        },
+        exitId: crypto2.randomUUID(),
+        exitTxid: exitTxId
+      });
+    } catch (error) {
+      throw new Error(`Error initiating cooperative exit: ${error}`);
+    }
+    if (!response.transfer) {
+      throw new Error("Failed to initiate cooperative exit");
+    }
+    const signatures = await this.signRefunds(
+      leafDataMap,
+      response.signingResults
+    );
+    const signaturesMap = /* @__PURE__ */ new Map();
+    for (const signature of signatures) {
+      signaturesMap.set(signature.nodeId, signature.refundTxSignature);
+    }
+    return { transfer: response.transfer, signaturesMap };
+  }
+};
+
+// src/services/lightning.ts
+import {
+  bytesToNumberBE,
+  hexToBytes as hexToBytes2,
+  numberToBytesBE as numberToBytesBE2
+} from "@noble/curves/abstract/utils";
+import { secp256k1 as secp256k12 } from "@noble/curves/secp256k1";
+import { sha256 as sha2562 } from "@scure/btc-signer/utils";
+import { decode } from "light-bolt11-decoder";
+var crypto3 = getCrypto();
+var LightningService = class {
+  config;
+  connectionManager;
+  constructor(config, connectionManager) {
+    this.config = config;
+    this.connectionManager = connectionManager;
+  }
+  async createLightningInvoice({
+    invoiceCreator,
+    amountSats,
+    memo
+  }) {
+    const randBytes = crypto3.getRandomValues(new Uint8Array(32));
+    const preimage = numberToBytesBE2(
+      bytesToNumberBE(randBytes) % secp256k12.CURVE.n,
+      32
+    );
+    return await this.createLightningInvoiceWithPreImage({
+      invoiceCreator,
+      amountSats,
+      memo,
+      preimage
+    });
+  }
+  async createLightningInvoiceWithPreImage({
+    invoiceCreator,
+    amountSats,
+    memo,
+    preimage
+  }) {
+    const paymentHash = sha2562(preimage);
+    const invoice = await invoiceCreator(amountSats, paymentHash, memo);
+    if (!invoice) {
+      throw new Error("Error creating lightning invoice");
+    }
+    const shares = await this.config.signer.splitSecretWithProofs({
+      secret: preimage,
+      curveOrder: secp256k12.CURVE.n,
+      threshold: this.config.getConfig().threshold,
+      numShares: Object.keys(this.config.getConfig().signingOperators).length
+    });
+    const errors = [];
+    const promises = Object.entries(
+      this.config.getConfig().signingOperators
+    ).map(async ([_, operator]) => {
+      const share = shares[operator.id];
+      if (!share) {
+        throw new Error("Share not found");
+      }
+      const sparkClient = await this.connectionManager.createSparkClient(
+        operator.address
+      );
+      try {
+        await sparkClient.store_preimage_share({
+          paymentHash,
+          preimageShare: {
+            secretShare: numberToBytesBE2(share.share, 32),
+            proofs: share.proofs
+          },
+          threshold: this.config.getConfig().threshold,
+          invoiceString: invoice,
+          userIdentityPublicKey: await this.config.signer.getIdentityPublicKey()
+        });
+      } catch (e) {
+        errors.push(e);
+      }
+    });
+    await Promise.all(promises);
+    if (errors.length > 0) {
+      throw new Error(`Error creating lightning invoice: ${errors[0]}`);
+    }
+    return invoice;
+  }
+  async swapNodesForPreimage({
+    leaves,
+    receiverIdentityPubkey,
+    paymentHash,
+    invoiceString,
+    isInboundPayment
+  }) {
+    const sparkClient = await this.connectionManager.createSparkClient(
+      this.config.getCoordinatorAddress()
+    );
+    let signingCommitments;
+    try {
+      signingCommitments = await sparkClient.get_signing_commitments({
+        nodeIds: leaves.map((leaf) => leaf.leaf.id)
+      });
+    } catch (error) {
+      throw new Error(`Error getting signing commitments: ${error}`);
+    }
+    const userSignedRefunds = await this.signRefunds(
+      leaves,
+      signingCommitments.signingCommitments,
+      receiverIdentityPubkey
+    );
+    const transferId = crypto3.randomUUID();
+    let bolt11String = "";
+    let amountSats = 0;
+    if (invoiceString) {
+      const decodedInvoice = decode(invoiceString);
+      let amountMsats = 0;
+      try {
+        amountMsats = Number(
+          decodedInvoice.sections.find((section) => section.name === "amount")?.value
+        );
+      } catch (error) {
+        console.error("Error decoding invoice", error);
+      }
+      amountSats = amountMsats / 1e3;
+      bolt11String = invoiceString;
+    }
+    const reason = isInboundPayment ? 1 /* REASON_RECEIVE */ : 0 /* REASON_SEND */;
+    let response;
+    try {
+      response = await sparkClient.initiate_preimage_swap({
+        paymentHash,
+        userSignedRefunds,
+        reason,
+        invoiceAmount: {
+          invoiceAmountProof: {
+            bolt11Invoice: bolt11String
+          },
+          valueSats: amountSats
+        },
+        transfer: {
+          transferId,
+          ownerIdentityPublicKey: await this.config.signer.getIdentityPublicKey(),
+          receiverIdentityPublicKey: receiverIdentityPubkey
+        },
+        receiverIdentityPublicKey: receiverIdentityPubkey,
+        feeSats: 0
+      });
+    } catch (error) {
+      throw new Error(`Error initiating preimage swap: ${error}`);
+    }
+    return response;
+  }
+  async queryUserSignedRefunds(paymentHash) {
+    const sparkClient = await this.connectionManager.createSparkClient(
+      this.config.getCoordinatorAddress()
+    );
+    let response;
+    try {
+      response = await sparkClient.query_user_signed_refunds({
+        paymentHash
+      });
+    } catch (error) {
+      throw new Error(`Error querying user signed refunds: ${error}`);
+    }
+    return response.userSignedRefunds;
+  }
+  validateUserSignedRefund(userSignedRefund) {
+    const refundTx = getTxFromRawTxBytes(userSignedRefund.refundTx);
+    return refundTx.getOutput(0).amount || 0n;
+  }
+  async providePreimage(preimage) {
+    const sparkClient = await this.connectionManager.createSparkClient(
+      this.config.getCoordinatorAddress()
+    );
+    const paymentHash = sha2562(preimage);
+    let response;
+    try {
+      response = await sparkClient.provide_preimage({
+        preimage,
+        paymentHash
+      });
+    } catch (error) {
+      throw new Error(`Error providing preimage: ${error}`);
+    }
+    if (!response.transfer) {
+      throw new Error("No transfer returned from coordinator");
+    }
+    return response.transfer;
+  }
+  async signRefunds(leaves, signingCommitments, receiverIdentityPubkey) {
+    const userSignedRefunds = [];
+    for (let i = 0; i < leaves.length; i++) {
+      const leaf = leaves[i];
+      if (!leaf?.leaf) {
+        throw new Error("Leaf not found in signRefunds");
+      }
+      const nodeTx = getTxFromRawTxBytes(leaf.leaf.nodeTx);
+      const nodeOutPoint = {
+        txid: hexToBytes2(getTxId(nodeTx)),
+        index: 0
+      };
+      const currRefundTx = getTxFromRawTxBytes(leaf.leaf.refundTx);
+      const nextSequence = getNextTransactionSequence(
+        currRefundTx.getInput(0).sequence
+      );
+      const amountSats = currRefundTx.getOutput(0).amount;
+      if (amountSats === void 0) {
+        throw new Error("Amount not found in signRefunds");
+      }
+      const refundTx = createRefundTx(
+        nextSequence,
+        nodeOutPoint,
+        amountSats,
+        receiverIdentityPubkey,
+        this.config.getNetwork()
+      );
+      const sighash = getSigHashFromTx(refundTx, 0, nodeTx.getOutput(0));
+      const signingCommitment = await this.config.signer.getRandomSigningCommitment();
+      const signingNonceCommitments = signingCommitments[i]?.signingNonceCommitments;
+      if (!signingNonceCommitments) {
+        throw new Error("Signing nonce commitments not found in signRefunds");
+      }
+      const signingResult = await this.config.signer.signFrost({
+        message: sighash,
+        publicKey: leaf.signingPubKey,
+        privateAsPubKey: leaf.signingPubKey,
+        selfCommitment: signingCommitment,
+        statechainCommitments: signingNonceCommitments,
+        adaptorPubKey: new Uint8Array(),
+        verifyingKey: leaf.leaf.verifyingPublicKey
+      });
+      userSignedRefunds.push({
+        nodeId: leaf.leaf.id,
+        refundTx: refundTx.toBytes(),
+        userSignature: signingResult,
+        userSignatureCommitment: signingCommitment,
+        signingCommitments: {
+          signingCommitments: signingNonceCommitments
+        }
+      });
+    }
+    return userSignedRefunds;
+  }
+};
+
+// src/spark-sdk.ts
+import { validateMnemonic } from "@scure/bip39";
+import { wordlist } from "@scure/bip39/wordlists/english";
+import { Mutex } from "async-mutex";
+import bitcoin from "bitcoinjs-lib";
+
+// src/services/tree-creation.ts
+import { Address, OutScript, Transaction as Transaction3 } from "@scure/btc-signer";
+import { sha256 as sha2563 } from "@scure/btc-signer/utils";
+var INITIAL_TIME_LOCK2 = 2e3;
+var TreeCreationService = class {
+  config;
+  connectionManager;
+  constructor(config, connectionManager) {
+    this.config = config;
+    this.connectionManager = connectionManager;
+  }
+  async generateDepositAddressForTree(vout, parentSigningPublicKey, parentTx, parentNode) {
+    if (!parentTx && !parentNode) {
+      throw new Error("No parent tx or parent node provided");
+    }
+    const id = parentNode?.id ?? getTxId(parentTx);
+    const tree = await this.createDepositAddressTree(
+      parentSigningPublicKey,
+      id
+    );
+    const addressRequestNodes = this.createAddressRequestNodeFromTreeNodes(tree);
+    const sparkClient = await this.connectionManager.createSparkClient(
+      this.config.getCoordinatorAddress()
+    );
+    const request = {
+      userIdentityPublicKey: await this.config.signer.getIdentityPublicKey(),
+      node: void 0
+    };
+    if (parentNode) {
+      if (!parentNode.parentNodeId) {
+        throw new Error("Parent node ID is undefined");
+      }
+      request.source = {
+        $case: "parentNodeOutput",
+        parentNodeOutput: {
+          nodeId: parentNode.parentNodeId,
+          vout
+        }
+      };
+    } else if (parentTx) {
+      request.source = {
+        $case: "onChainUtxo",
+        onChainUtxo: {
+          vout,
+          rawTx: parentTx.toBytes(),
+          network: this.config.getNetworkProto()
+        }
+      };
+    } else {
+      throw new Error("No parent node or parent tx provided");
+    }
+    request.node = {
+      userPublicKey: parentSigningPublicKey,
+      children: addressRequestNodes
+    };
+    const root = {
+      address: void 0,
+      signingPublicKey: parentSigningPublicKey,
+      children: tree
+    };
+    let response;
+    try {
+      response = await sparkClient.prepare_tree_address(request);
+    } catch (error) {
+      throw new Error(`Error preparing tree address: ${error}`);
+    }
+    if (!response.node) {
+      throw new Error("No node found in response");
+    }
+    this.applyAddressNodesToTree([root], [response.node]);
+    return root;
+  }
+  async createTree(vout, root, createLeaves, parentTx, parentNode) {
+    const request = {
+      userIdentityPublicKey: await this.config.signer.getIdentityPublicKey(),
+      node: void 0
+    };
+    let tx;
+    if (parentTx) {
+      tx = parentTx;
+      request.source = {
+        $case: "onChainUtxo",
+        onChainUtxo: {
+          vout,
+          rawTx: parentTx.toBytes(),
+          network: this.config.getNetworkProto()
+        }
+      };
+    } else if (parentNode) {
+      tx = getTxFromRawTxBytes(parentNode.nodeTx);
+      if (!parentNode.parentNodeId) {
+        throw new Error("Parent node ID is undefined");
+      }
+      request.source = {
+        $case: "parentNodeOutput",
+        parentNodeOutput: {
+          nodeId: parentNode.parentNodeId,
+          vout
+        }
+      };
+    } else {
+      throw new Error("No parent node or parent tx provided");
+    }
+    const rootCreationNode = await this.buildCreationNodesFromTree(
+      vout,
+      createLeaves,
+      this.config.getNetwork(),
+      root,
+      tx
+    );
+    request.node = rootCreationNode;
+    const sparkClient = await this.connectionManager.createSparkClient(
+      this.config.getCoordinatorAddress()
+    );
+    let response;
+    try {
+      response = await sparkClient.create_tree(request);
+    } catch (error) {
+      throw new Error(`Error creating tree: ${error}`);
+    }
+    if (!response.node) {
+      throw new Error("No node found in response");
+    }
+    const creationResultTreeRoot = response.node;
+    const nodeSignatures = await this.signTreeCreation(
+      tx,
+      vout,
+      root,
+      rootCreationNode,
+      creationResultTreeRoot
+    );
+    let finalizeResp;
+    try {
+      finalizeResp = await sparkClient.finalize_node_signatures({
+        nodeSignatures
+      });
+    } catch (error) {
+      throw new Error(
+        `Error finalizing node signatures in tree creation: ${error}`
+      );
+    }
+    return finalizeResp;
+  }
+  async createDepositAddressTree(targetSigningPublicKey, nodeId) {
+    const leftKey = await this.config.signer.generatePublicKey(sha2563(nodeId));
+    const leftNode = {
+      signingPublicKey: leftKey,
+      children: []
+    };
+    const rightKey = await this.config.signer.subtractPrivateKeysGivenPublicKeys(
+      targetSigningPublicKey,
+      leftKey
+    );
+    const rightNode = {
+      signingPublicKey: rightKey,
+      children: []
+    };
+    return [leftNode, rightNode];
+  }
+  createAddressRequestNodeFromTreeNodes(treeNodes) {
+    const results = [];
+    for (const node of treeNodes) {
+      const result = {
+        userPublicKey: node.signingPublicKey,
+        children: this.createAddressRequestNodeFromTreeNodes(node.children)
+      };
+      results.push(result);
+    }
+    return results;
+  }
+  applyAddressNodesToTree(tree, addressNodes) {
+    for (let i = 0; i < tree.length; i++) {
+      if (!tree[i]) {
+        throw new Error("Tree or address node is undefined");
+      }
+      if (!addressNodes[i]) {
+        throw new Error("Address node is undefined");
+      }
+      tree[i].address = addressNodes[i].address?.address;
+      tree[i].verificationKey = addressNodes[i].address?.verifyingKey;
+      this.applyAddressNodesToTree(tree[i].children, addressNodes[i].children);
+    }
+  }
+  async buildChildCreationNode(node, parentTx, vout, network) {
+    const internalCreationNode = {
+      nodeTxSigningJob: void 0,
+      refundTxSigningJob: void 0,
+      children: []
+    };
+    const tx = new Transaction3();
+    tx.addInput({
+      txid: getTxId(parentTx),
+      index: vout
+    });
+    const parentTxOut = parentTx.getOutput(vout);
+    if (!parentTxOut?.script || !parentTxOut?.amount) {
+      throw new Error("parentTxOut is undefined");
+    }
+    tx.addOutput({
+      script: parentTxOut.script,
+      amount: parentTxOut.amount
+    });
+    tx.addOutput(getEphemeralAnchorOutput());
+    const signingNonceCommitment = await this.config.signer.getRandomSigningCommitment();
+    const signingJob = {
+      signingPublicKey: node.signingPublicKey,
+      rawTx: tx.toBytes(),
+      signingNonceCommitment
+    };
+    internalCreationNode.nodeTxSigningCommitment = signingNonceCommitment;
+    internalCreationNode.nodeTxSigningJob = signingJob;
+    const sequence = 1 << 30 | INITIAL_TIME_LOCK2;
+    const childCreationNode = {
+      nodeTxSigningJob: void 0,
+      refundTxSigningJob: void 0,
+      children: []
+    };
+    const childTx = new Transaction3();
+    childTx.addInput({
+      txid: getTxId(tx),
+      index: 0,
+      sequence
+    });
+    childTx.addOutput({
+      script: parentTxOut.script,
+      amount: parentTxOut.amount
+    });
+    childTx.addOutput(getEphemeralAnchorOutput());
+    const childSigningNonceCommitment = await this.config.signer.getRandomSigningCommitment();
+    const childSigningJob = {
+      signingPublicKey: node.signingPublicKey,
+      rawTx: childTx.toBytes(),
+      signingNonceCommitment: childSigningNonceCommitment
+    };
+    childCreationNode.nodeTxSigningCommitment = childSigningNonceCommitment;
+    childCreationNode.nodeTxSigningJob = childSigningJob;
+    const refundTx = new Transaction3();
+    refundTx.addInput({
+      txid: getTxId(childTx),
+      index: 0,
+      sequence
+    });
+    const refundP2trAddress = getP2TRAddressFromPublicKey(
+      node.signingPublicKey,
+      network
+    );
+    const refundAddress = Address(getNetwork(network)).decode(
+      refundP2trAddress
+    );
+    const refundPkScript = OutScript.encode(refundAddress);
+    refundTx.addOutput({
+      script: refundPkScript,
+      amount: parentTxOut.amount
+    });
+    const refundSigningNonceCommitment = await this.config.signer.getRandomSigningCommitment();
+    const refundSigningJob = {
+      signingPublicKey: node.signingPublicKey,
+      rawTx: refundTx.toBytes(),
+      signingNonceCommitment: refundSigningNonceCommitment
+    };
+    childCreationNode.refundTxSigningCommitment = refundSigningNonceCommitment;
+    childCreationNode.refundTxSigningJob = refundSigningJob;
+    internalCreationNode.children.push(childCreationNode);
+    return internalCreationNode;
+  }
+  async buildCreationNodesFromTree(vout, createLeaves, network, root, parentTx) {
+    const parentTxOutput = parentTx.getOutput(vout);
+    if (!parentTxOutput?.script || !parentTxOutput?.amount) {
+      throw new Error("parentTxOutput is undefined");
+    }
+    const rootNodeTx = new Transaction3();
+    rootNodeTx.addInput({
+      txid: getTxId(parentTx),
+      index: vout
+    });
+    for (let i = 0; i < root.children.length; i++) {
+      const child = root.children[i];
+      if (!child || !child.address) {
+        throw new Error("child address is undefined");
+      }
+      const childAddress = Address(getNetwork(network)).decode(child.address);
+      const childPkScript = OutScript.encode(childAddress);
+      rootNodeTx.addOutput({
+        script: childPkScript,
+        amount: parentTxOutput.amount / 2n
+      });
+    }
+    const anchor = getEphemeralAnchorOutput();
+    rootNodeTx.addOutput(anchor);
+    const rootNodeSigningCommitment = await this.config.signer.getRandomSigningCommitment();
+    const rootNodeSigningJob = {
+      signingPublicKey: root.signingPublicKey,
+      rawTx: rootNodeTx.toBytes(),
+      signingNonceCommitment: rootNodeSigningCommitment
+    };
+    const rootCreationNode = {
+      nodeTxSigningJob: rootNodeSigningJob,
+      refundTxSigningJob: void 0,
+      children: []
+    };
+    rootCreationNode.nodeTxSigningCommitment = rootNodeSigningCommitment;
+    const leftChild = root.children[0];
+    const rightChild = root.children[1];
+    if (!leftChild || !rightChild) {
+      throw new Error("Root children are undefined");
+    }
+    const leftChildCreationNode = await this.buildChildCreationNode(
+      leftChild,
+      rootNodeTx,
+      0,
+      network
+    );
+    const rightChildCreationNode = await this.buildChildCreationNode(
+      rightChild,
+      rootNodeTx,
+      1,
+      network
+    );
+    rootCreationNode.children.push(leftChildCreationNode);
+    rootCreationNode.children.push(rightChildCreationNode);
+    return rootCreationNode;
+  }
+  async signNodeCreation(parentTx, vout, internalNode, creationNode, creationResponseNode) {
+    if (!creationNode.nodeTxSigningJob?.signingPublicKey || !internalNode.verificationKey) {
+      throw new Error("signingPublicKey or verificationKey is undefined");
+    }
+    const parentTxOutput = parentTx.getOutput(vout);
+    if (!parentTxOutput) {
+      throw new Error("parentTxOutput is undefined");
+    }
+    const tx = getTxFromRawTxBytes(creationNode.nodeTxSigningJob.rawTx);
+    const txSighash = getSigHashFromTx(tx, 0, parentTxOutput);
+    let nodeTxSignature = new Uint8Array();
+    if (creationNode.nodeTxSigningCommitment) {
+      const userSignature = await this.config.signer.signFrost({
+        message: txSighash,
+        publicKey: creationNode.nodeTxSigningJob.signingPublicKey,
+        privateAsPubKey: internalNode.signingPublicKey,
+        selfCommitment: creationNode.nodeTxSigningCommitment,
+        statechainCommitments: creationResponseNode.nodeTxSigningResult?.signingNonceCommitments,
+        verifyingKey: internalNode.verificationKey
+      });
+      nodeTxSignature = await this.config.signer.aggregateFrost({
+        message: txSighash,
+        statechainSignatures: creationResponseNode.nodeTxSigningResult?.signatureShares,
+        statechainPublicKeys: creationResponseNode.nodeTxSigningResult?.publicKeys,
+        verifyingKey: internalNode.verificationKey,
+        statechainCommitments: creationResponseNode.nodeTxSigningResult?.signingNonceCommitments,
+        selfCommitment: creationNode.nodeTxSigningCommitment,
+        selfSignature: userSignature,
+        publicKey: internalNode.signingPublicKey
+      });
+    }
+    let refundTxSignature = new Uint8Array();
+    if (creationNode.refundTxSigningCommitment) {
+      const rawTx = creationNode.refundTxSigningJob?.rawTx;
+      if (!rawTx) {
+        throw new Error("rawTx is undefined");
+      }
+      if (!creationNode.refundTxSigningJob?.signingPublicKey) {
+        throw new Error("signingPublicKey is undefined");
+      }
+      const refundTx = getTxFromRawTxBytes(rawTx);
+      const refundTxSighash = getSigHashFromTx(refundTx, 0, parentTxOutput);
+      const refundSigningResponse = await this.config.signer.signFrost({
+        message: refundTxSighash,
+        publicKey: creationNode.refundTxSigningJob.signingPublicKey,
+        privateAsPubKey: internalNode.signingPublicKey,
+        selfCommitment: creationNode.refundTxSigningCommitment,
+        statechainCommitments: creationResponseNode.refundTxSigningResult?.signingNonceCommitments,
+        verifyingKey: internalNode.verificationKey
+      });
+      refundTxSignature = await this.config.signer.aggregateFrost({
+        message: refundTxSighash,
+        statechainSignatures: creationResponseNode.refundTxSigningResult?.signatureShares,
+        statechainPublicKeys: creationResponseNode.refundTxSigningResult?.publicKeys,
+        verifyingKey: internalNode.verificationKey,
+        statechainCommitments: creationResponseNode.refundTxSigningResult?.signingNonceCommitments,
+        selfCommitment: creationNode.refundTxSigningCommitment,
+        selfSignature: refundSigningResponse,
+        publicKey: internalNode.signingPublicKey
+      });
+    }
+    return {
+      tx,
+      signature: {
+        nodeId: creationResponseNode.nodeId,
+        nodeTxSignature,
+        refundTxSignature
+      }
+    };
+  }
+  async signTreeCreation(tx, vout, root, rootCreationNode, creationResultTreeRoot) {
+    const rootSignature = await this.signNodeCreation(
+      tx,
+      vout,
+      root,
+      rootCreationNode,
+      creationResultTreeRoot
+    );
+    const firstRootChild = root.children[0];
+    const secondRootChild = root.children[1];
+    const firstRootChildCreationNode = rootCreationNode.children[0];
+    const secondRootChildCreationNode = rootCreationNode.children[1];
+    const firstRootChildCreationResult = creationResultTreeRoot.children[0];
+    const secondRootChildCreationResult = creationResultTreeRoot.children[1];
+    if (!firstRootChild || !secondRootChild) {
+      throw new Error("Root children are undefined");
+    }
+    if (!firstRootChildCreationNode || !secondRootChildCreationNode) {
+      throw new Error("Root child creation nodes are undefined");
+    }
+    if (!firstRootChildCreationResult || !secondRootChildCreationResult) {
+      throw new Error("Root child creation results are undefined");
+    }
+    const leftChildSignature = await this.signNodeCreation(
+      rootSignature.tx,
+      0,
+      firstRootChild,
+      firstRootChildCreationNode,
+      firstRootChildCreationResult
+    );
+    const rightChildSignature = await this.signNodeCreation(
+      rootSignature.tx,
+      1,
+      secondRootChild,
+      secondRootChildCreationNode,
+      secondRootChildCreationResult
+    );
+    const signatures = [
+      rootSignature.signature,
+      leftChildSignature.signature,
+      rightChildSignature.signature
+    ];
+    return signatures;
+  }
+};
+
+// src/spark-sdk.ts
+var MAX_TOKEN_LEAVES = 100;
+var SparkWallet = class {
+  config;
+  connectionManager;
+  depositService;
+  transferService;
+  treeCreationService;
+  lightningService;
+  coopExitService;
+  tokenTransactionService;
+  claimTransferMutex = new Mutex();
+  leavesMutex = new Mutex();
+  optimizationInProgress = false;
+  sspClient = null;
+  wasmModule = null;
+  leaves = [];
+  tokenLeaves = /* @__PURE__ */ new Map();
+  constructor(network, signer, config) {
+    if (config) {
+      this.config = WalletConfigService.withConfig(config, signer);
+    } else {
+      this.config = new WalletConfigService(network, signer);
+    }
+    this.connectionManager = new ConnectionManager(this.config);
+    this.depositService = new DepositService(
+      this.config,
+      this.connectionManager
+    );
+    this.transferService = new TransferService(
+      this.config,
+      this.connectionManager
+    );
+    this.treeCreationService = new TreeCreationService(
+      this.config,
+      this.connectionManager
+    );
+    this.tokenTransactionService = new TokenTransactionService(
+      this.config,
+      this.connectionManager
+    );
+    this.lightningService = new LightningService(
+      this.config,
+      this.connectionManager
+    );
+    this.coopExitService = new CoopExitService(
+      this.config,
+      this.connectionManager
+    );
+  }
+  async initWasm() {
+    try {
+      this.wasmModule = await initWasm();
+    } catch (e) {
+      console.error("Failed to initialize Wasm module", e);
+    }
+  }
+  async initializeWallet(identityPublicKey) {
+    await this.connectionManager.createClients();
+    this.sspClient = new SspClient(identityPublicKey);
+    await Promise.all([
+      this.initWasm(),
+      // Hacky but do this to store the deposit signing key in the signer
+      this.config.signer.getDepositSigningKey()
+    ]);
+    await this.syncWallet();
+  }
+  async getLeaves() {
+    const sparkClient = await this.connectionManager.createSparkClient(
+      this.config.getCoordinatorAddress()
+    );
+    const leaves = await sparkClient.query_nodes({
+      source: {
+        $case: "ownerIdentityPubkey",
+        ownerIdentityPubkey: await this.config.signer.getIdentityPublicKey()
+      },
+      includeParents: false
+    });
+    return Object.entries(leaves.nodes).filter(([_, node]) => node.status === "AVAILABLE").map(([_, node]) => node);
+  }
+  async selectLeaves(targetAmount) {
+    if (targetAmount <= 0) {
+      throw new Error("Target amount must be positive");
+    }
+    const leaves = await this.getLeaves();
+    if (leaves.length === 0) {
+      return [];
+    }
+    leaves.sort((a, b) => b.value - a.value);
+    let amount = 0;
+    let nodes = [];
+    for (const leaf of leaves) {
+      if (targetAmount - amount >= leaf.value) {
+        amount += leaf.value;
+        nodes.push(leaf);
+      }
+    }
+    if (amount !== targetAmount) {
+      await this.requestLeavesSwap({ targetAmount });
+      amount = 0;
+      nodes = [];
+      const newLeaves = await this.getLeaves();
+      newLeaves.sort((a, b) => b.value - a.value);
+      for (const leaf of newLeaves) {
+        if (targetAmount - amount >= leaf.value) {
+          amount += leaf.value;
+          nodes.push(leaf);
+        }
+      }
+    }
+    return nodes;
+  }
+  async selectLeavesForSwap(targetAmount) {
+    if (targetAmount == 0) {
+      throw new Error("Target amount needs to > 0");
+    }
+    const leaves = await this.getLeaves();
+    leaves.sort((a, b) => a.value - b.value);
+    let amount = 0;
+    const nodes = [];
+    for (const leaf of leaves) {
+      if (amount < targetAmount) {
+        amount += leaf.value;
+        nodes.push(leaf);
+      }
+    }
+    if (amount < targetAmount) {
+      throw new Error(
+        "You don't have enough nodes to swap for the target amount"
+      );
+    }
+    return nodes;
+  }
+  areLeavesInefficient() {
+    const totalAmount = this.leaves.reduce((acc, leaf) => acc + leaf.value, 0);
+    if (this.leaves.length <= 1) {
+      return false;
+    }
+    const nextLowerPowerOfTwo = 31 - Math.clz32(totalAmount);
+    let remainingAmount = totalAmount;
+    let optimalLeavesLength = 0;
+    for (let i = nextLowerPowerOfTwo; i >= 0; i--) {
+      const denomination = 2 ** i;
+      while (remainingAmount >= denomination) {
+        remainingAmount -= denomination;
+        optimalLeavesLength++;
+      }
+    }
+    return this.leaves.length > optimalLeavesLength * 5;
+  }
+  async optimizeLeaves() {
+    if (this.optimizationInProgress || !this.areLeavesInefficient()) {
+      return;
+    }
+    await this.withLeaves(async () => {
+      this.optimizationInProgress = true;
+      try {
+        if (this.leaves.length > 0) {
+          await this.requestLeavesSwap({ leaves: this.leaves });
+        }
+        this.leaves = await this.getLeaves();
+      } finally {
+        this.optimizationInProgress = false;
+      }
+    });
+  }
+  async syncWallet() {
+    await Promise.all([this.claimTransfers(), this.syncTokenLeaves()]);
+    this.leaves = await this.getLeaves();
+    await this.refreshTimelockNodes();
+    await this.config.signer.restoreSigningKeysFromLeafs(this.leaves);
+    this.optimizeLeaves().catch((e) => {
+      console.error("Failed to optimize leaves", e);
+    });
+  }
+  async withLeaves(operation) {
+    const release = await this.leavesMutex.acquire();
+    try {
+      return await operation();
+    } finally {
+      release();
+    }
+  }
+  isInitialized() {
+    return this.sspClient !== null && this.wasmModule !== null;
+  }
+  /**
+   * Gets the identity public key of the wallet.
+   *
+   * @returns {Promise<string>} The identity public key as a hex string.
+   */
+  async getIdentityPublicKey() {
+    return bytesToHex2(await this.config.signer.getIdentityPublicKey());
+  }
+  /**
+   * Gets the Spark address of the wallet.
+   *
+   * @returns {Promise<string>} The Spark address as a hex string.
+   */
+  async getSparkAddress() {
+    return bytesToHex2(await this.config.signer.getIdentityPublicKey());
+  }
+  /**
+   * Initializes the wallet using either a mnemonic phrase or a raw seed.
+   * initWallet will also claim any pending incoming lightning payment, spark transfer,
+   * or bitcoin deposit.
+   *
+   * @param {Uint8Array | string} [mnemonicOrSeed] - (Optional) Either:
+   *   - A BIP-39 mnemonic phrase as string
+   *   - A raw seed as Uint8Array or hex string
+   *   If not provided, generates a new mnemonic and uses it to create a new wallet
+   *
+   * @returns {Promise<Object>} Object containing:
+   *   - mnemonic: The mnemonic if one was generated (undefined for raw seed)
+   *   - balance: The wallet's initial balance in satoshis
+   *   - tokenBalance: Map of token balances and leaf counts
+   */
+  async initWallet(mnemonicOrSeed) {
+    const returnMnemonic = !mnemonicOrSeed;
+    if (!mnemonicOrSeed) {
+      mnemonicOrSeed = await this.config.signer.generateMnemonic();
+    }
+    if (typeof mnemonicOrSeed !== "string") {
+      mnemonicOrSeed = bytesToHex2(mnemonicOrSeed);
+    }
+    let mnemonic;
+    if (validateMnemonic(mnemonicOrSeed, wordlist)) {
+      mnemonic = mnemonicOrSeed;
+      await this.initWalletFromMnemonic(mnemonicOrSeed);
+    } else {
+      await this.initWalletFromSeed(mnemonicOrSeed);
+    }
+    const balance = this.leaves.reduce(
+      (acc, leaf) => acc + BigInt(leaf.value),
+      0n
+    );
+    const tokenBalance = await this.getAllTokenBalances();
+    if (returnMnemonic) {
+      return {
+        mnemonic,
+        balance,
+        tokenBalance
+      };
+    }
+    return {
+      balance,
+      tokenBalance
+    };
+  }
+  async initWalletFromMnemonic(mnemonic) {
+    const identityPublicKey = await this.config.signer.createSparkWalletFromMnemonic(
+      mnemonic,
+      this.config.getNetwork()
+    );
+    await this.initializeWallet(identityPublicKey);
+    return identityPublicKey;
+  }
+  /**
+   * Initializes a wallet from a seed.
+   *
+   * @param {Uint8Array | string} seed - The seed to initialize the wallet from
+   * @returns {Promise<string>} The identity public key
+   * @private
+   */
+  async initWalletFromSeed(seed) {
+    const identityPublicKey = await this.config.signer.createSparkWalletFromSeed(
+      seed,
+      this.config.getNetwork()
+    );
+    await this.initializeWallet(identityPublicKey);
+    return identityPublicKey;
+  }
+  /**
+   * Requests a swap of leaves to optimize wallet structure.
+   *
+   * @param {Object} params - Parameters for the leaves swap
+   * @param {number} [params.targetAmount] - Target amount for the swap
+   * @param {TreeNode[]} [params.leaves] - Specific leaves to swap
+   * @returns {Promise<Object>} The completed swap response
+   * @private
+   */
+  async requestLeavesSwap({
+    targetAmount,
+    leaves
+  }) {
+    if (targetAmount && targetAmount <= 0) {
+      throw new Error("targetAmount must be positive");
+    }
+    await this.claimTransfers();
+    let leavesToSwap;
+    if (targetAmount && leaves && leaves.length > 0) {
+      if (targetAmount < leaves.reduce((acc, leaf) => acc + leaf.value, 0)) {
+        throw new Error("targetAmount is less than the sum of leaves");
+      }
+      leavesToSwap = leaves;
+    } else if (targetAmount) {
+      leavesToSwap = await this.selectLeavesForSwap(targetAmount);
+    } else if (leaves && leaves.length > 0) {
+      leavesToSwap = leaves;
+    } else {
+      throw new Error("targetAmount or leaves must be provided");
+    }
+    const leafKeyTweaks = await Promise.all(
+      leavesToSwap.map(async (leaf) => ({
+        leaf,
+        signingPubKey: await this.config.signer.generatePublicKey(
+          sha2564(leaf.id)
+        ),
+        newSigningPubKey: await this.config.signer.generatePublicKey()
+      }))
+    );
+    const { transfer, signatureMap } = await this.transferService.sendTransferSignRefund(
+      leafKeyTweaks,
+      await this.config.signer.getSspIdentityPublicKey(
+        this.config.getNetwork()
+      ),
+      new Date(Date.now() + 10 * 60 * 1e3)
+    );
+    try {
+      if (!transfer.leaves[0]?.leaf) {
+        throw new Error("Failed to get leaf");
+      }
+      const refundSignature = signatureMap.get(transfer.leaves[0].leaf.id);
+      if (!refundSignature) {
+        throw new Error("Failed to get refund signature");
+      }
+      const { adaptorPrivateKey, adaptorSignature } = generateAdaptorFromSignature(refundSignature);
+      if (!transfer.leaves[0].leaf) {
+        throw new Error("Failed to get leaf");
+      }
+      const userLeaves = [];
+      userLeaves.push({
+        leaf_id: transfer.leaves[0].leaf.id,
+        raw_unsigned_refund_transaction: bytesToHex2(
+          transfer.leaves[0].intermediateRefundTx
+        ),
+        adaptor_added_signature: bytesToHex2(adaptorSignature)
+      });
+      for (let i = 1; i < transfer.leaves.length; i++) {
+        const leaf = transfer.leaves[i];
+        if (!leaf?.leaf) {
+          throw new Error("Failed to get leaf");
+        }
+        const refundSignature2 = signatureMap.get(leaf.leaf.id);
+        if (!refundSignature2) {
+          throw new Error("Failed to get refund signature");
+        }
+        const signature = generateSignatureFromExistingAdaptor(
+          refundSignature2,
+          adaptorPrivateKey
+        );
+        userLeaves.push({
+          leaf_id: leaf.leaf.id,
+          raw_unsigned_refund_transaction: bytesToHex2(
+            leaf.intermediateRefundTx
+          ),
+          adaptor_added_signature: bytesToHex2(signature)
+        });
+      }
+      const adaptorPubkey = bytesToHex2(
+        secp256k13.getPublicKey(adaptorPrivateKey)
+      );
+      let request = null;
+      request = await this.sspClient?.requestLeaveSwap({
+        userLeaves,
+        adaptorPubkey,
+        targetAmountSats: targetAmount || leavesToSwap.reduce((acc, leaf) => acc + leaf.value, 0),
+        totalAmountSats: leavesToSwap.reduce(
+          (acc, leaf) => acc + leaf.value,
+          0
+        ),
+        // TODO: Request fee from SSP
+        feeSats: 0
+      });
+      if (!request) {
+        throw new Error("Failed to request leaves swap. No response returned.");
+      }
+      const sparkClient = await this.connectionManager.createSparkClient(
+        this.config.getCoordinatorAddress()
+      );
+      const nodes = await sparkClient.query_nodes({
+        source: {
+          $case: "nodeIds",
+          nodeIds: {
+            nodeIds: request.swapLeaves.map((leaf) => leaf.leafId)
+          }
+        },
+        includeParents: false
+      });
+      if (Object.values(nodes.nodes).length !== request.swapLeaves.length) {
+        throw new Error("Expected same number of nodes as swapLeaves");
+      }
+      for (const [nodeId, node] of Object.entries(nodes.nodes)) {
+        if (!node.nodeTx) {
+          throw new Error(`Node tx not found for leaf ${nodeId}`);
+        }
+        if (!node.verifyingPublicKey) {
+          throw new Error(`Node public key not found for leaf ${nodeId}`);
+        }
+        const leaf = request.swapLeaves.find((leaf2) => leaf2.leafId === nodeId);
+        if (!leaf) {
+          throw new Error(`Leaf not found for node ${nodeId}`);
+        }
+        const nodeTx = getTxFromRawTxBytes(node.nodeTx);
+        const refundTxBytes = hexToBytes3(leaf.rawUnsignedRefundTransaction);
+        const refundTx = getTxFromRawTxBytes(refundTxBytes);
+        const sighash = getSigHashFromTx(refundTx, 0, nodeTx.getOutput(0));
+        const nodePublicKey = node.verifyingPublicKey;
+        const taprootKey = computeTaprootKeyNoScript(nodePublicKey.slice(1));
+        const adaptorSignatureBytes = hexToBytes3(leaf.adaptorSignedSignature);
+        applyAdaptorToSignature(
+          taprootKey.slice(1),
+          sighash,
+          adaptorSignatureBytes,
+          adaptorPrivateKey
+        );
+      }
+      await this.transferService.sendTransferTweakKey(
+        transfer,
+        leafKeyTweaks,
+        signatureMap
+      );
+      const completeResponse = await this.sspClient?.completeLeaveSwap({
+        adaptorSecretKey: bytesToHex2(adaptorPrivateKey),
+        userOutboundTransferExternalId: transfer.id,
+        leavesSwapRequestId: request.id
+      });
+      if (!completeResponse) {
+        throw new Error("Failed to complete leaves swap");
+      }
+      await this.claimTransfers();
+      return completeResponse;
+    } catch (e) {
+      await this.cancelAllSenderInitiatedTransfers();
+      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<QueryAllTransfersResponse>} Response containing the list of transfers
+   */
+  async getAllTransfers(limit = 20, offset = 0) {
+    return await this.transferService.queryAllTransfers(limit, offset);
+  }
+  /**
+   * Gets the current balance of the wallet.
+   * You can use the forceRefetch option to synchronize your wallet and claim any
+   * pending incoming lightning payment, spark transfer, or bitcoin deposit before returning the balance.
+   *
+   * @param {boolean} [forceRefetch=true] - Synchronizes the wallet before returning the balance
+   * @returns {Promise<Object>} Object containing:
+   *   - balance: The wallet's current balance in satoshis
+   *   - tokenBalances: Map of token balances and leaf counts
+   */
+  async getBalance(forceRefetch = true) {
+    if (forceRefetch) {
+      await Promise.all([this.claimTransfers(), this.syncTokenLeaves()]);
+      this.leaves = await this.getLeaves();
+    }
+    const tokenBalances = /* @__PURE__ */ new Map();
+    for (const [tokenPublicKey, leaves] of this.tokenLeaves.entries()) {
+      tokenBalances.set(tokenPublicKey, {
+        balance: calculateAvailableTokenAmount(leaves)
+      });
+    }
+    return {
+      balance: this.leaves.reduce((acc, leaf) => acc + BigInt(leaf.value), 0n),
+      tokenBalances
+    };
+  }
+  // ***** Deposit Flow *****
+  /**
+   * Generates a new deposit address for receiving bitcoin funds.
+   * Note that this function returns a bitcoin address, not a spark address.
+   * For Layer 1 Bitcoin deposits, Spark generates Pay to Taproot (P2TR) addresses.
+   * These addresses start with "bc1p" and can be used to receive Bitcoin from any wallet.
+   *
+   * @returns {Promise<string>} A Bitcoin address for depositing funds
+   */
+  async getDepositAddress() {
+    return await this.generateDepositAddress();
+  }
+  /**
+   * Generates a deposit address for receiving funds.
+   *
+   * @returns {Promise<string>} A deposit address
+   * @private
+   */
+  async generateDepositAddress() {
+    const signingPubkey = await this.config.signer.getDepositSigningKey();
+    const address = await this.depositService.generateDepositAddress({
+      signingPubkey
+    });
+    if (!address.depositAddress) {
+      throw new Error("Failed to generate deposit address");
+    }
+    return address.depositAddress.address;
+  }
+  /**
+   * Finalizes a deposit to the wallet.
+   *
+   * @param {DepositParams} params - Parameters for finalizing the deposit
+   * @returns {Promise<TreeNode[] | undefined>} The nodes created from the deposit
+   * @private
+   */
+  async finalizeDeposit({
+    signingPubKey,
+    verifyingKey,
+    depositTx,
+    vout
+  }) {
+    const response = await this.depositService.createTreeRoot({
+      signingPubKey,
+      verifyingKey,
+      depositTx,
+      vout
+    });
+    return await this.transferDepositToSelf(response.nodes, signingPubKey);
+  }
+  async claimDeposit(txid) {
+    const baseUrl = this.config.getNetwork() === 3 /* REGTEST */ ? "https://regtest-mempool.dev.dev.sparkinfra.net/api" : "https://mempool.space/api";
+    const auth = btoa("spark-sdk:mCMk1JqlBNtetUNy");
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (this.config.getNetwork() === 3 /* REGTEST */) {
+      headers["Authorization"] = `Basic ${auth}`;
+    }
+    const response = await fetch(`${baseUrl}/tx/${txid}/hex`, {
+      headers
+    });
+    const txHex = await response.text();
+    if (!/^[0-9A-Fa-f]+$/.test(txHex)) {
+      throw new Error("Transaction not found");
+    }
+    const depositTx = getTxFromRawTxHex(txHex);
+    const sparkClient = await this.connectionManager.createSparkClient(
+      this.config.getCoordinatorAddress()
+    );
+    const unusedDepositAddresses = new Map(
+      (await sparkClient.query_unused_deposit_addresses({
+        identityPublicKey: await this.config.signer.getIdentityPublicKey()
+      })).depositAddresses.map((addr) => [addr.depositAddress, addr])
+    );
+    let depositAddress;
+    let vout = 0;
+    for (let i = 0; i < depositTx.outputsLength; i++) {
+      const output = depositTx.getOutput(i);
+      if (!output) {
+        continue;
+      }
+      const parsedScript = OutScript2.decode(output.script);
+      const address = Address2(getNetwork(this.config.getNetwork())).encode(
+        parsedScript
+      );
+      if (unusedDepositAddresses.has(address)) {
+        vout = i;
+        depositAddress = unusedDepositAddresses.get(address);
+        break;
+      }
+    }
+    if (!depositAddress) {
+      throw new Error("Deposit address not found");
+    }
+    const nodes = await this.finalizeDeposit({
+      signingPubKey: depositAddress.userSigningPublicKey,
+      verifyingKey: depositAddress.verifyingPublicKey,
+      depositTx,
+      vout
+    });
+    return nodes;
+  }
+  /**
+   * Queries the mempool for transactions associated with an address.
+   *
+   * @param {string} address - The address to query
+   * @returns {Promise<{depositTx: Transaction, vout: number} | null>} Transaction details or null if none found
+   * @private
+   */
+  async queryMempoolTxs(address) {
+    const network = getNetworkFromAddress(address) || this.config.getNetwork();
+    const baseUrl = network === BitcoinNetwork_default.REGTEST ? "https://regtest-mempool.dev.dev.sparkinfra.net/api" : "https://mempool.space/docs/api";
+    const auth = btoa("spark-sdk:mCMk1JqlBNtetUNy");
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (network === BitcoinNetwork_default.REGTEST) {
+      headers["Authorization"] = `Basic ${auth}`;
+    }
+    const response = await fetch(`${baseUrl}/address/${address}/txs`, {
+      headers
+    });
+    const addressTxs = await response.json();
+    if (addressTxs && addressTxs.length > 0) {
+      const latestTx = addressTxs[0];
+      const outputIndex = latestTx.vout.findIndex(
+        (output) => output.scriptpubkey_address === address
+      );
+      if (outputIndex === -1) {
+        return null;
+      }
+      const txResponse = await fetch(`${baseUrl}/tx/${latestTx.txid}/hex`, {
+        headers
+      });
+      const txHex = await txResponse.text();
+      const depositTx = getTxFromRawTxHex(txHex);
+      return {
+        depositTx,
+        vout: outputIndex
+      };
+    }
+    return null;
+  }
+  /**
+   * Transfers deposit to self to claim ownership.
+   *
+   * @param {TreeNode[]} leaves - The leaves to transfer
+   * @param {Uint8Array} signingPubKey - The signing public key
+   * @returns {Promise<TreeNode[] | undefined>} The nodes resulting from the transfer
+   * @private
+   */
+  async transferDepositToSelf(leaves, signingPubKey) {
+    const leafKeyTweaks = await Promise.all(
+      leaves.map(async (leaf) => ({
+        leaf,
+        signingPubKey,
+        newSigningPubKey: await this.config.signer.generatePublicKey()
+      }))
+    );
+    await this.transferService.sendTransfer(
+      leafKeyTweaks,
+      await this.config.signer.getIdentityPublicKey(),
+      new Date(Date.now() + 10 * 60 * 1e3)
+    );
+    const pendingTransfers = await this.transferService.queryPendingTransfers();
+    if (pendingTransfers.transfers.length > 0) {
+      return (await this.claimTransfer(pendingTransfers.transfers[0])).nodes;
+    }
+    return;
+  }
+  // ***** Transfer Flow *****
+  /**
+   * Sends a transfer to another Spark user.
+   *
+   * @param {Object} params - Parameters for the transfer
+   * @param {string} params.receiverSparkAddress - The recipient's Spark address
+   * @param {number} params.amountSats - Amount to send in satoshis
+   * @returns {Promise<Transfer>} The completed transfer details
+   */
+  async sendSparkTransfer({
+    receiverSparkAddress,
+    amountSats
+  }) {
+    return await this.withLeaves(async () => {
+      return await this._sendTransfer({
+        receiverPubKey: receiverSparkAddress,
+        amount: amountSats
+      });
+    });
+  }
+  /**
+   * Internal method to send a transfer.
+   *
+   * @param {SendTransferParams} params - Parameters for the transfer
+   * @returns {Promise<Transfer>} The completed transfer details
+   * @private
+   */
+  async _sendTransfer({
+    amount,
+    receiverPubKey,
+    leaves,
+    expiryTime = new Date(Date.now() + 10 * 60 * 1e3)
+  }) {
+    let leavesToSend = [];
+    if (leaves) {
+      leavesToSend = leaves.map((leaf) => ({
+        ...leaf
+      }));
+    } else if (amount) {
+      leavesToSend = await this.selectLeaves(amount);
+    } else {
+      throw new Error("Must provide amount or leaves");
+    }
+    await this.refreshTimelockNodes();
+    const leafKeyTweaks = await Promise.all(
+      leavesToSend.map(async (leaf) => ({
+        leaf,
+        signingPubKey: await this.config.signer.generatePublicKey(
+          sha2564(leaf.id)
+        ),
+        newSigningPubKey: await this.config.signer.generatePublicKey()
+      }))
+    );
+    const transfer = await this.transferService.sendTransfer(
+      leafKeyTweaks,
+      hexToBytes3(receiverPubKey),
+      expiryTime
+    );
+    const leavesToRemove = new Set(leavesToSend.map((leaf) => leaf.id));
+    this.leaves = this.leaves.filter((leaf) => !leavesToRemove.has(leaf.id));
+    return transfer;
+  }
+  /**
+   * Internal method to refresh timelock nodes.
+   *
+   * @param {string} nodeId - The optional ID of the node to refresh. If not provided, all nodes will be checked.
+   * @returns {Promise<void>}
+   */
+  async refreshTimelockNodes(nodeId) {
+    const nodesToRefresh = [];
+    const nodeIds = [];
+    if (nodeId) {
+      for (const node of this.leaves) {
+        if (node.id === nodeId) {
+          nodesToRefresh.push(node);
+          nodeIds.push(node.id);
+          break;
+        }
+      }
+      if (nodesToRefresh.length === 0) {
+        throw new Error(`node ${nodeId} not found`);
+      }
+    } else {
+      for (const node of this.leaves) {
+        const refundTx = getTxFromRawTxBytes(node.refundTx);
+        const nextSequence = getNextTransactionSequence(
+          refundTx.getInput(0).sequence
+        );
+        const needRefresh = nextSequence <= 0;
+        if (needRefresh) {
+          nodesToRefresh.push(node);
+          nodeIds.push(node.id);
+        }
+      }
+    }
+    if (nodesToRefresh.length === 0) {
+      return;
+    }
+    const sparkClient = await this.connectionManager.createSparkClient(
+      this.config.getCoordinatorAddress()
+    );
+    const nodesResp = await sparkClient.query_nodes({
+      source: {
+        $case: "nodeIds",
+        nodeIds: {
+          nodeIds
+        }
+      },
+      includeParents: true
+    });
+    const nodesMap = /* @__PURE__ */ new Map();
+    for (const node of Object.values(nodesResp.nodes)) {
+      nodesMap.set(node.id, node);
+    }
+    for (const node of nodesToRefresh) {
+      if (!node.parentNodeId) {
+        throw new Error(`node ${node.id} has no parent`);
+      }
+      const parentNode = nodesMap.get(node.parentNodeId);
+      if (!parentNode) {
+        throw new Error(`parent node ${node.parentNodeId} not found`);
+      }
+      const { nodes } = await this.transferService.refreshTimelockNodes(
+        [node],
+        parentNode,
+        await this.config.signer.generatePublicKey(sha2564(node.id))
+      );
+      if (nodes.length !== 1) {
+        throw new Error(`expected 1 node, got ${nodes.length}`);
+      }
+      const newNode = nodes[0];
+      if (!newNode) {
+        throw new Error("Failed to refresh timelock node");
+      }
+      this.leaves = this.leaves.filter((leaf) => leaf.id !== node.id);
+      this.leaves.push(newNode);
+    }
+  }
+  /**
+   * Claims a specific transfer.
+   *
+   * @param {Transfer} transfer - The transfer to claim
+   * @returns {Promise<Object>} The claim result
+   * @private
+   */
+  async claimTransfer(transfer) {
+    return await this.claimTransferMutex.runExclusive(async () => {
+      const leafPubKeyMap = await this.transferService.verifyPendingTransfer(transfer);
+      let leavesToClaim = [];
+      for (const leaf of transfer.leaves) {
+        if (leaf.leaf) {
+          const leafPubKey = leafPubKeyMap.get(leaf.leaf.id);
+          if (leafPubKey) {
+            leavesToClaim.push({
+              leaf: leaf.leaf,
+              signingPubKey: leafPubKey,
+              newSigningPubKey: await this.config.signer.generatePublicKey(
+                sha2564(leaf.leaf.id)
+              )
+            });
+          }
+        }
+      }
+      const response = await this.transferService.claimTransfer(
+        transfer,
+        leavesToClaim
+      );
+      this.leaves.push(...response.nodes);
+      await this.refreshTimelockNodes();
+      return response.nodes;
+    });
+  }
+  /**
+   * Claims all pending transfers.
+   *
+   * @returns {Promise<boolean>} True if any transfers were claimed
+   * @private
+   */
+  async claimTransfers() {
+    const transfers = await this.transferService.queryPendingTransfers();
+    let claimed = false;
+    for (const transfer of transfers.transfers) {
+      if (transfer.status !== 2 /* TRANSFER_STATUS_SENDER_KEY_TWEAKED */ && transfer.status !== 3 /* TRANSFER_STATUS_RECEIVER_KEY_TWEAKED */ && transfer.status !== 4 /* TRANSFER_STATUSR_RECEIVER_REFUND_SIGNED */) {
+        continue;
+      }
+      await this.claimTransfer(transfer);
+      claimed = true;
+    }
+    return claimed;
+  }
+  /**
+   * Cancels all sender-initiated transfers.
+   *
+   * @returns {Promise<void>}
+   * @private
+   */
+  async cancelAllSenderInitiatedTransfers() {
+    const transfers = await this.transferService.queryPendingTransfersBySender();
+    for (const transfer of transfers.transfers) {
+      if (transfer.status === 0 /* TRANSFER_STATUS_SENDER_INITIATED */) {
+        await this.transferService.cancelSendTransfer(transfer);
+      }
+    }
+  }
+  // ***** Lightning Flow *****
+  /**
+   * Creates a Lightning invoice for receiving payments.
+   *
+   * @param {Object} params - Parameters for the lightning invoice
+   * @param {number} params.amountSats - Amount in satoshis
+   * @param {string} params.memo - Description for the invoice
+   * @param {number} [params.expirySeconds] - Optional expiry time in seconds
+   * @returns {Promise<string>} BOLT11 encoded invoice
+   */
+  async createLightningInvoice({
+    amountSats,
+    memo,
+    expirySeconds = 60 * 60 * 24 * 30
+  }) {
+    if (!this.sspClient) {
+      throw new Error("SSP client not initialized");
+    }
+    const requestLightningInvoice = async (amountSats2, paymentHash, memo2) => {
+      const network = this.config.getNetwork();
+      let bitcoinNetwork = BitcoinNetwork_default.REGTEST;
+      if (network === 0 /* MAINNET */) {
+        bitcoinNetwork = BitcoinNetwork_default.MAINNET;
+      } else if (network === 3 /* REGTEST */) {
+        bitcoinNetwork = BitcoinNetwork_default.REGTEST;
+      }
+      const invoice = await this.sspClient.requestLightningReceive({
+        amountSats: amountSats2,
+        network: bitcoinNetwork,
+        paymentHash: bytesToHex2(paymentHash),
+        expirySecs: expirySeconds,
+        memo: memo2
+      });
+      return invoice?.invoice.encodedEnvoice;
+    };
+    return this.lightningService.createLightningInvoice({
+      amountSats,
+      memo,
+      invoiceCreator: requestLightningInvoice
+    });
+  }
+  /**
+   * Pays a Lightning invoice.
+   *
+   * @param {Object} params - Parameters for paying the invoice
+   * @param {string} params.invoice - The BOLT11-encoded Lightning invoice to pay
+   * @returns {Promise<LightningSendRequest>} The Lightning payment request details
+   */
+  async payLightningInvoice({ invoice }) {
+    return await this.withLeaves(async () => {
+      if (!this.sspClient) {
+        throw new Error("SSP client not initialized");
+      }
+      const decodedInvoice = decode2(invoice);
+      const amountSats = Number(
+        decodedInvoice.sections.find((section) => section.name === "amount")?.value
+      ) / 1e3;
+      if (isNaN(amountSats) || amountSats <= 0) {
+        throw new Error("Invalid amount");
+      }
+      const paymentHash = decodedInvoice.sections.find(
+        (section) => section.name === "payment_hash"
+      )?.value;
+      if (!paymentHash) {
+        throw new Error("No payment hash found in invoice");
+      }
+      const leaves = await this.selectLeaves(amountSats);
+      await this.refreshTimelockNodes();
+      const leavesToSend = await Promise.all(
+        leaves.map(async (leaf) => ({
+          leaf,
+          signingPubKey: await this.config.signer.generatePublicKey(
+            sha2564(leaf.id)
+          ),
+          newSigningPubKey: await this.config.signer.generatePublicKey()
+        }))
+      );
+      const swapResponse = await this.lightningService.swapNodesForPreimage({
+        leaves: leavesToSend,
+        receiverIdentityPubkey: await this.config.signer.getSspIdentityPublicKey(
+          this.config.getNetwork()
+        ),
+        paymentHash: hexToBytes3(paymentHash),
+        isInboundPayment: false,
+        invoiceString: invoice
+      });
+      if (!swapResponse.transfer) {
+        throw new Error("Failed to swap nodes for preimage");
+      }
+      const transfer = await this.transferService.sendTransferTweakKey(
+        swapResponse.transfer,
+        leavesToSend,
+        /* @__PURE__ */ new Map()
+      );
+      const sspResponse = await this.sspClient.requestLightningSend({
+        encodedInvoice: invoice,
+        idempotencyKey: paymentHash
+      });
+      if (!sspResponse) {
+        throw new Error("Failed to contact SSP");
+      }
+      const leavesToRemove = new Set(leavesToSend.map((leaf) => leaf.leaf.id));
+      this.leaves = this.leaves.filter((leaf) => !leavesToRemove.has(leaf.id));
+      return sspResponse;
+    });
+  }
+  /**
+   * Gets fee estimate for receiving Lightning payments.
+   *
+   * @param {LightningReceiveFeeEstimateInput} params - Input parameters for fee estimation
+   * @returns {Promise<LightningReceiveFeeEstimateOutput | null>} Fee estimate for receiving Lightning payments
+   * @private
+   */
+  async getLightningReceiveFeeEstimate({
+    amountSats,
+    network
+  }) {
+    if (!this.sspClient) {
+      throw new Error("SSP client not initialized");
+    }
+    return await this.sspClient.getLightningReceiveFeeEstimate(
+      amountSats,
+      network
+    );
+  }
+  /**
+   * Gets fee estimate for sending Lightning payments.
+   *
+   * @param {LightningSendFeeEstimateInput} params - Input parameters for fee estimation
+   * @returns {Promise<LightningSendFeeEstimateOutput | null>} Fee estimate for sending Lightning payments
+   * @private
+   */
+  async getLightningSendFeeEstimate({
+    encodedInvoice
+  }) {
+    if (!this.sspClient) {
+      throw new Error("SSP client not initialized");
+    }
+    return await this.sspClient.getLightningSendFeeEstimate(encodedInvoice);
+  }
+  // ***** Tree Creation Flow *****
+  /**
+   * Generates a deposit address for a tree.
+   *
+   * @param {number} vout - The vout index
+   * @param {Uint8Array} parentSigningPubKey - The parent signing public key
+   * @param {Transaction} [parentTx] - Optional parent transaction
+   * @param {TreeNode} [parentNode] - Optional parent node
+   * @returns {Promise<Object>} Deposit address information
+   * @private
+   */
+  async generateDepositAddressForTree(vout, parentSigningPubKey, parentTx, parentNode) {
+    return await this.treeCreationService.generateDepositAddressForTree(
+      vout,
+      parentSigningPubKey,
+      parentTx,
+      parentNode
+    );
+  }
+  /**
+   * Creates a tree structure.
+   *
+   * @param {number} vout - The vout index
+   * @param {DepositAddressTree} root - The root of the tree
+   * @param {boolean} createLeaves - Whether to create leaves
+   * @param {Transaction} [parentTx] - Optional parent transaction
+   * @param {TreeNode} [parentNode] - Optional parent node
+   * @returns {Promise<Object>} The created tree
+   * @private
+   */
+  async createTree(vout, root, createLeaves, parentTx, parentNode) {
+    return await this.treeCreationService.createTree(
+      vout,
+      root,
+      createLeaves,
+      parentTx,
+      parentNode
+    );
+  }
+  // ***** Cooperative Exit Flow *****
+  /**
+   * Initiates a withdrawal to move funds from the Spark network to an on-chain Bitcoin address.
+   *
+   * @param {Object} params - Parameters for the withdrawal
+   * @param {string} params.onchainAddress - The Bitcoin address where the funds should be sent
+   * @param {number} [params.targetAmountSats] - The amount in satoshis to withdraw. If not specified, attempts to withdraw all available funds
+   * @returns {Promise<CoopExitRequest | null | undefined>} The withdrawal request details, or null/undefined if the request cannot be completed
+   */
+  async withdraw({
+    onchainAddress,
+    targetAmountSats
+  }) {
+    return await this.withLeaves(async () => {
+      return await this.coopExit(onchainAddress, targetAmountSats);
+    });
+  }
+  /**
+   * Internal method to perform a cooperative exit (withdrawal).
+   *
+   * @param {string} onchainAddress - The Bitcoin address where the funds should be sent
+   * @param {number} [targetAmountSats] - The amount in satoshis to withdraw
+   * @returns {Promise<Object | null | undefined>} The exit request details
+   * @private
+   */
+  async coopExit(onchainAddress, targetAmountSats) {
+    let leavesToSend = [];
+    if (targetAmountSats) {
+      leavesToSend = await this.selectLeaves(targetAmountSats);
+    } else {
+      leavesToSend = this.leaves.map((leaf) => ({
+        ...leaf
+      }));
+    }
+    const leafKeyTweaks = await Promise.all(
+      leavesToSend.map(async (leaf) => ({
+        leaf,
+        signingPubKey: await this.config.signer.generatePublicKey(
+          sha2564(leaf.id)
+        ),
+        newSigningPubKey: await this.config.signer.generatePublicKey()
+      }))
+    );
+    const coopExitRequest = await this.sspClient?.requestCoopExit({
+      leafExternalIds: leavesToSend.map((leaf) => leaf.id),
+      withdrawalAddress: onchainAddress
+    });
+    if (!coopExitRequest?.rawConnectorTransaction) {
+      throw new Error("Failed to request coop exit");
+    }
+    const connectorTx = getTxFromRawTxHex(
+      coopExitRequest.rawConnectorTransaction
+    );
+    const coopExitTxId = connectorTx.getInput(0).txid;
+    const connectorTxId = getTxId(connectorTx);
+    if (!coopExitTxId) {
+      throw new Error("Failed to get coop exit tx id");
+    }
+    const connectorOutputs = [];
+    for (let i = 0; i < connectorTx.outputsLength - 1; i++) {
+      connectorOutputs.push({
+        txid: hexToBytes3(connectorTxId),
+        index: i
+      });
+    }
+    const sspPubIdentityKey = await this.config.signer.getSspIdentityPublicKey(
+      this.config.getNetwork()
+    );
+    const transfer = await this.coopExitService.getConnectorRefundSignatures({
+      leaves: leafKeyTweaks,
+      exitTxId: coopExitTxId,
+      connectorOutputs,
+      receiverPubKey: sspPubIdentityKey
+    });
+    const completeResponse = await this.sspClient?.completeCoopExit({
+      userOutboundTransferExternalId: transfer.transfer.id,
+      coopExitRequestId: coopExitRequest.id
+    });
+    return completeResponse;
+  }
+  /**
+   * Gets fee estimate for cooperative exit (on-chain withdrawal).
+   *
+   * @param {CoopExitFeeEstimateInput} params - Input parameters for fee estimation
+   * @returns {Promise<CoopExitFeeEstimateOutput | null>} Fee estimate for the withdrawal
+   * @private
+   */
+  async getCoopExitFeeEstimate({
+    leafExternalIds,
+    withdrawalAddress
+  }) {
+    if (!this.sspClient) {
+      throw new Error("SSP client not initialized");
+    }
+    return await this.sspClient.getCoopExitFeeEstimate({
+      leafExternalIds,
+      withdrawalAddress
+    });
+  }
+  // ***** Token Flow *****
+  /**
+   * Synchronizes token leaves for the wallet.
+   *
+   * @returns {Promise<void>}
+   * @private
+   */
+  async syncTokenLeaves() {
+    this.tokenLeaves.clear();
+    const trackedPublicKeys = await this.config.signer.getTrackedPublicKeys();
+    const unsortedTokenLeaves = await this.tokenTransactionService.fetchOwnedTokenLeaves(
+      [...trackedPublicKeys, await this.config.signer.getIdentityPublicKey()],
+      []
+    );
+    const groupedLeaves = /* @__PURE__ */ new Map();
+    unsortedTokenLeaves.forEach((leaf) => {
+      const tokenKey = bytesToHex2(leaf.leaf.tokenPublicKey);
+      const index = leaf.previousTransactionVout;
+      if (!groupedLeaves.has(tokenKey)) {
+        groupedLeaves.set(tokenKey, []);
+      }
+      groupedLeaves.get(tokenKey).push({
+        ...leaf,
+        previousTransactionVout: index
+      });
+    });
+    this.tokenLeaves = groupedLeaves;
+  }
+  /**
+   * Gets all token balances.
+   *
+   * @returns {Promise<Map<string, { balance: bigint }>>} Map of token balances and leaf counts
+   * @private
+   */
+  async getAllTokenBalances() {
+    await this.syncTokenLeaves();
+    const balances = /* @__PURE__ */ new Map();
+    for (const [tokenPublicKey, leaves] of this.tokenLeaves.entries()) {
+      balances.set(tokenPublicKey, {
+        balance: calculateAvailableTokenAmount(leaves)
+      });
+    }
+    return balances;
+  }
+  /**
+   * Transfers tokens to another user.
+   *
+   * @param {Object} params - Parameters for the token transfer
+   * @param {string} params.tokenPublicKey - The public key of the token to transfer
+   * @param {bigint} params.tokenAmount - The amount of tokens to transfer
+   * @param {string} params.receiverSparkAddress - The recipient's public key
+   * @param {LeafWithPreviousTransactionData[]} [params.selectedLeaves] - Optional specific leaves to use for the transfer
+   * @returns {Promise<string>} The transaction ID of the token transfer
+   */
+  async sendSparkTokenTransfer({
+    tokenPublicKey,
+    tokenAmount,
+    receiverSparkAddress,
+    selectedLeaves
+  }) {
+    await this.syncTokenLeaves();
+    if (!this.tokenLeaves.has(tokenPublicKey)) {
+      throw new Error("No token leaves with the given tokenPublicKey");
+    }
+    const tokenPublicKeyBytes = hexToBytes3(tokenPublicKey);
+    const receiverSparkAddressBytes = hexToBytes3(receiverSparkAddress);
+    if (selectedLeaves) {
+      if (!checkIfSelectedLeavesAreAvailable(
+        selectedLeaves,
+        this.tokenLeaves,
+        tokenPublicKeyBytes
+      )) {
+        throw new Error("One or more selected leaves are not available");
+      }
+    } else {
+      selectedLeaves = this.selectTokenLeaves(tokenPublicKey, tokenAmount);
+    }
+    if (selectedLeaves.length > MAX_TOKEN_LEAVES) {
+      throw new Error("Too many leaves selected");
+    }
+    const tokenTransaction = await this.tokenTransactionService.constructTransferTokenTransaction(
+      selectedLeaves,
+      receiverSparkAddressBytes,
+      tokenPublicKeyBytes,
+      tokenAmount
+    );
+    return await this.tokenTransactionService.broadcastTokenTransaction(
+      tokenTransaction,
+      selectedLeaves.map((leaf) => leaf.leaf.ownerPublicKey),
+      selectedLeaves.map((leaf) => leaf.leaf.revocationPublicKey)
+    );
+  }
+  /**
+   * Selects token leaves for a transfer.
+   *
+   * @param {string} tokenPublicKey - The public key of the token
+   * @param {bigint} tokenAmount - The amount of tokens to select leaves for
+   * @returns {LeafWithPreviousTransactionData[]} The selected leaves
+   * @private
+   */
+  selectTokenLeaves(tokenPublicKey, tokenAmount) {
+    return this.tokenTransactionService.selectTokenLeaves(
+      this.tokenLeaves.get(tokenPublicKey),
+      tokenAmount
+    );
+  }
+};
+function getNetworkFromAddress(address) {
+  try {
+    const decoded = bitcoin.address.fromBech32(address);
+    if (decoded.prefix === "bc") {
+      return BitcoinNetwork_default.MAINNET;
+    } else if (decoded.prefix === "bcrt") {
+      return BitcoinNetwork_default.REGTEST;
+    }
+  } catch (err) {
+    throw new Error("Invalid Bitcoin address");
+  }
+  return null;
+}
+export {
+  SparkWallet
+};