@buildonspark/spark-sdk 0.2.13 → 0.3.0

package/dist/{chunk-LX45BCZW.js → chunk-RFP7E7TK.js}

@@ -4,11 +4,11 @@ import {
 } from "./chunk-NX5KPN5F.js";
 import {
   SparkTokenServiceDefinition
-} from "./chunk-XXTWWW6L.js";
+} from "./chunk-73GJOG5R.js";
 import {
   mapTransferToWalletTransfer,
   mapTreeNodeToWalletLeaf
-} from "./chunk-TB7DG5CU.js";
+} from "./chunk-MH7BMOLL.js";
 import {
   Empty,
   SatsPayment,
@@ -19,7 +19,7 @@ import {
   TokensPayment,
   TreeNode,
   networkToJSON
-} from "./chunk-5VWGOHED.js";
+} from "./chunk-MGCUXELA.js";
 import {
   BitcoinNetwork_default,
   ClaimStaticDepositFromJson,
@@ -577,22 +577,30 @@ import * as ecies from "eciesjs";
 
 // src/constants.ts
 import { isNode, isBare } from "@lightsparkdev/core";
-var isReactNative = typeof navigator !== "undefined" && navigator.product === "ReactNative";
-var isBun = globalThis.Bun !== void 0;
-var packageVersion = true ? "0.2.13" : "unknown";
+var isReactNative = "navigator" in globalThis && navigator.product === "ReactNative";
+var isBun = "Bun" in globalThis;
+var isWebExtension = (
+  /* globalThis.chrome actually exists in extension contexts for all browsers for legacy reasons: */
+  "chrome" in globalThis && globalThis.chrome.runtime?.id
+);
+var userAgent = "navigator" in globalThis ? globalThis.navigator.userAgent || "unknown-user-agent" : void 0;
+var packageVersion = true ? "0.3.0" : "unknown";
 var baseEnvStr = "unknown";
 if (isBun) {
   const bunVersion = "version" in globalThis.Bun ? globalThis.Bun.version : "unknown-version";
   baseEnvStr = `bun/${bunVersion}`;
 } else if (isNode) {
-  baseEnvStr = `node/${process.version}`;
+  baseEnvStr = `node/${globalThis.process.version}`;
 } else if (isReactNative) {
   baseEnvStr = "react-native";
 } else if (isBare) {
   const bareVersion = Bare.version;
   baseEnvStr = `bare/${bareVersion}`;
+} else if (isWebExtension) {
+  const protocol = "location" in globalThis ? globalThis.location.protocol : "";
+  const extScriptType = "window" in globalThis ? "content-script" : "background-script";
+  baseEnvStr = `web-extension/${protocol.replace(":", "")}/${extScriptType}/${userAgent}`;
 } else {
-  const userAgent = typeof navigator !== "undefined" && navigator.userAgent || "unknown-user-agent";
   baseEnvStr = `browser/${userAgent}`;
 }
 var clientEnv = `js-spark-sdk/${packageVersion} ${baseEnvStr}`;
@@ -2964,10 +2972,10 @@ var INITIAL_TIMELOCK = 2e3;
 var TEST_UNILATERAL_TIMELOCK = 100;
 var TIME_LOCK_INTERVAL = 100;
 var DIRECT_TIMELOCK_OFFSET = 50;
-var INITIAL_SEQUENCE = 1 << 30 | INITIAL_TIMELOCK;
-var INITIAL_DIRECT_SEQUENCE = 1 << 30 | INITIAL_TIMELOCK + DIRECT_TIMELOCK_OFFSET;
-var TEST_UNILATERAL_SEQUENCE = 1 << 30 | TEST_UNILATERAL_TIMELOCK;
-var TEST_UNILATERAL_DIRECT_SEQUENCE = 1 << 30 | TEST_UNILATERAL_TIMELOCK + DIRECT_TIMELOCK_OFFSET;
+var INITIAL_SEQUENCE = INITIAL_TIMELOCK;
+var INITIAL_DIRECT_SEQUENCE = INITIAL_TIMELOCK + DIRECT_TIMELOCK_OFFSET;
+var TEST_UNILATERAL_SEQUENCE = TEST_UNILATERAL_TIMELOCK;
+var TEST_UNILATERAL_DIRECT_SEQUENCE = TEST_UNILATERAL_TIMELOCK + DIRECT_TIMELOCK_OFFSET;
 var ESTIMATED_TX_SIZE = 191;
 var DEFAULT_SATS_PER_VBYTE = 5;
 var DEFAULT_FEE_SATS = ESTIMATED_TX_SIZE * DEFAULT_SATS_PER_VBYTE;
@@ -3238,8 +3246,8 @@ function getCurrentTimelock(currSequence) {
 function getTransactionSequence(currSequence) {
   const timelock = getCurrentTimelock(currSequence);
   return {
-    nextSequence: 1 << 30 | timelock,
-    nextDirectSequence: 1 << 30 | timelock + DIRECT_TIMELOCK_OFFSET
+    nextSequence: timelock,
+    nextDirectSequence: timelock + DIRECT_TIMELOCK_OFFSET
   };
 }
 function checkIfValidSequence(currSequence) {
@@ -3282,8 +3290,8 @@ function getNextTransactionSequence(currSequence, isNodeTx) {
     });
   }
   return {
-    nextSequence: 1 << 30 | nextTimelock,
-    nextDirectSequence: 1 << 30 | nextTimelock + DIRECT_TIMELOCK_OFFSET
+    nextSequence: nextTimelock,
+    nextDirectSequence: nextTimelock + DIRECT_TIMELOCK_OFFSET
   };
 }
 function getEphemeralAnchorOutput() {
@@ -4165,6 +4173,13 @@ function uint64be(value) {
 // src/utils/address.ts
 var BECH32M_LIMIT = 1024;
 var AddressNetwork = {
+  MAINNET: "spark",
+  TESTNET: "sparkt",
+  REGTEST: "sparkrt",
+  SIGNET: "sparks",
+  LOCAL: "sparkl"
+};
+var LegacyAddressNetwork = {
   MAINNET: "sp",
   TESTNET: "spt",
   REGTEST: "sprt",
@@ -4212,11 +4227,11 @@ function encodeSparkAddressWithSignature(payload, signature) {
 function decodeSparkAddress(address2, network) {
   try {
     const decoded = bech32mDecode(address2);
-    if (decoded.prefix !== AddressNetwork[network]) {
+    if (network !== getNetworkFromSparkAddress(address2)) {
       throw new ValidationError("Invalid Spark address prefix", {
         field: "address",
         value: address2,
-        expected: `prefix='${AddressNetwork[network]}'`
+        expected: `prefix='${AddressNetwork[network]}' or '${LegacyAddressNetwork[network]}'`
       });
     }
     const payload = SparkAddress.decode(bech32m.fromWords(decoded.words));
@@ -4262,18 +4277,35 @@ function decodeSparkAddress(address2, network) {
     );
   }
 }
+var PrefixToNetwork = Object.fromEntries(
+  Object.entries(AddressNetwork).map(([k, v]) => [v, k])
+);
+var LegacyPrefixToNetwork = Object.fromEntries(
+  Object.entries(LegacyAddressNetwork).map(([k, v]) => [v, k])
+);
+function getNetworkFromSparkAddress(address2) {
+  const { prefix } = bech32mDecode(address2);
+  const network = PrefixToNetwork[prefix] ?? LegacyPrefixToNetwork[prefix];
+  if (!network) {
+    throw new ValidationError("Invalid Spark address prefix", {
+      field: "network",
+      value: address2,
+      expected: "prefix='spark1', 'sparkt1', 'sparkrt1', 'sparks1', 'sparkl1' or legacy ('sp1', 'spt1', 'sprt1', 'sps1', 'spl1')"
+    });
+  }
+  return network;
+}
+function isLegacySparkAddress(address2) {
+  try {
+    const { prefix } = bech32mDecode(address2);
+    return prefix in LegacyPrefixToNetwork;
+  } catch (error) {
+    return false;
+  }
+}
 function isValidSparkAddress(address2) {
   try {
-    const network = Object.entries(AddressNetwork).find(
-      ([_, prefix]) => address2.startsWith(prefix)
-    )?.[0];
-    if (!network) {
-      throw new ValidationError("Invalid Spark address network", {
-        field: "network",
-        value: address2,
-        expected: Object.values(AddressNetwork)
-      });
-    }
+    const network = getNetworkFromSparkAddress(address2);
     decodeSparkAddress(address2, network);
     return true;
   } catch (error) {
@@ -4469,25 +4501,16 @@ function validateSparkInvoiceSignature(invoice) {
     );
   }
 }
-function getNetworkFromSparkAddress(address2) {
-  const { prefix } = bech32mDecode(address2);
-  const network = Object.entries(AddressNetwork).find(
-    ([, p]) => p === prefix
-  )?.[0];
-  if (!network) {
-    throw new ValidationError("Invalid Spark address network", {
-      field: "network",
-      value: address2,
-      expected: Object.values(AddressNetwork)
-    });
-  }
-  return network;
-}
 function toProtoTimestamp(date) {
   const ms = date.getTime();
   return { seconds: Math.floor(ms / 1e3), nanos: ms % 1e3 * 1e6 };
 }
+function assertBech32(s) {
+  const i = s.lastIndexOf("1");
+  if (i <= 0 || i >= s.length - 1) throw new Error("invalid bech32 string");
+}
 function bech32mDecode(address2) {
+  assertBech32(address2);
   return bech32m.decode(address2, BECH32M_LIMIT);
 }
 function bech32mEncode(prefix, words) {
@@ -4518,6 +4541,9 @@ function encodeSparkInvoiceFieldsV1Canonical(f) {
   }
   return w.finish();
 }
+function isSafeForNumber(bi) {
+  return bi >= BigInt(Number.MIN_SAFE_INTEGER) && bi <= BigInt(Number.MAX_SAFE_INTEGER);
+}
 
 // src/utils/response-validation.ts
 function collectResponses(responses) {
@@ -6534,6 +6560,7 @@ function validateTokenTransaction(finalTokenTransaction, partialTokenTransaction
 
 // src/services/token-transactions.ts
 var MAX_TOKEN_OUTPUTS = 500;
+var QUERY_TOKEN_OUTPUTS_PAGE_SIZE = 100;
 var TokenTransactionService = class {
   config;
   connectionManager;
@@ -7222,6 +7249,36 @@ var TokenTransactionService = class {
     }
   }
   async fetchOwnedTokenOutputs(params) {
+    const {
+      ownerPublicKeys,
+      issuerPublicKeys = [],
+      tokenIdentifiers = []
+    } = params;
+    if (ownerPublicKeys.length === 0) {
+      throw new ValidationError("Owner public keys cannot be empty", {
+        field: "ownerPublicKeys",
+        value: ownerPublicKeys,
+        expected: "Non-empty array"
+      });
+    }
+    for (const ownerPublicKey of ownerPublicKeys) {
+      isValidPublicKey(bytesToHex6(ownerPublicKey));
+    }
+    for (const issuerPublicKey of issuerPublicKeys) {
+      isValidPublicKey(bytesToHex6(issuerPublicKey));
+    }
+    for (const tokenIdentifier of tokenIdentifiers) {
+      if (tokenIdentifier.length !== 32) {
+        throw new ValidationError(
+          "Token identifier must be 32 bytes (64 hex characters) long.",
+          {
+            field: "tokenIdentifier",
+            value: tokenIdentifier,
+            expected: "32 bytes"
+          }
+        );
+      }
+    }
     if (this.config.getTokenTransactionVersion() === "V0") {
       return this.fetchOwnedTokenOutputsV0(params);
     } else {
@@ -7274,13 +7331,30 @@ var TokenTransactionService = class {
       this.config.getCoordinatorAddress()
     );
     try {
-      const result = await tokenClient.query_token_outputs({
-        ownerPublicKeys,
-        issuerPublicKeys,
-        tokenIdentifiers,
-        network: this.config.getNetworkProto()
-      });
-      return result.outputsWithPreviousTransactionData;
+      const allOutputs = [];
+      let after = void 0;
+      do {
+        const result = await tokenClient.query_token_outputs({
+          ownerPublicKeys,
+          issuerPublicKeys,
+          tokenIdentifiers,
+          network: this.config.getNetworkProto(),
+          pageRequest: {
+            pageSize: QUERY_TOKEN_OUTPUTS_PAGE_SIZE,
+            cursor: after,
+            direction: 0 /* NEXT */
+          }
+        });
+        if (Array.isArray(result.outputsWithPreviousTransactionData)) {
+          allOutputs.push(...result.outputsWithPreviousTransactionData);
+        }
+        if (result.pageResponse?.hasNextPage) {
+          after = result.pageResponse.nextCursor;
+        } else {
+          break;
+        }
+      } while (after);
+      return allOutputs;
     } catch (error) {
       throw new NetworkError(
         "Failed to fetch owned token outputs",
@@ -7736,7 +7810,7 @@ import { Address as Address2, OutScript as OutScript2, SigHash as SigHash2, Tran
 import { taprootTweakPrivKey as taprootTweakPrivKey2 } from "@scure/btc-signer/utils";
 
 // src/utils/fetch.ts
-var fetchImpl = typeof window !== "undefined" && window.fetch ? window.fetch.bind(window) : globalThis.fetch ? globalThis.fetch : null;
+var fetchImpl = typeof window !== "undefined" && window.fetch ? window.fetch.bind(window) : globalThis.fetch ? globalThis.fetch.bind(globalThis) : null;
 var Headers = globalThis.Headers ?? null;
 var getFetch = () => {
   if (!fetchImpl) {
@@ -8055,6 +8129,16 @@ var BitcoinFaucet = class _BitcoinFaucet {
   }
 };
 
+// src/spark-wallet/types.ts
+var SparkWalletEvent = {
+  All: "*",
+  TransferClaimed: "transfer:claimed",
+  DepositConfirmed: "deposit:confirmed",
+  StreamConnected: "stream:connected",
+  StreamDisconnected: "stream:disconnected",
+  StreamReconnecting: "stream:reconnecting"
+};
+
 // src/spark-wallet/spark-wallet.ts
 import { isNode as isNode3, isObject as isObject2, mapCurrencyAmount } from "@lightsparkdev/core";
 import { secp256k1 as secp256k114 } from "@noble/curves/secp256k1";
@@ -9304,7 +9388,7 @@ var BaseTransferService = class {
     }
     return response.transfer;
   }
-  async sendTransferWithKeyTweaks(leaves, receiverIdentityPubkey) {
+  async sendTransferWithKeyTweaks(leaves, receiverIdentityPubkey, sparkInvoice) {
     const transferID = uuidv7();
     const keyTweakInputMap = await this.prepareSendTransferKeyTweaks(
       transferID,
@@ -9329,7 +9413,8 @@ var BaseTransferService = class {
         transferId: transferID,
         ownerIdentityPublicKey: await this.config.signer.getIdentityPublicKey(),
         receiverIdentityPublicKey: receiverIdentityPubkey,
-        transferPackage
+        transferPackage,
+        sparkInvoice
       });
     } catch (error) {
       throw new NetworkError(
@@ -11782,7 +11867,7 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
           path: deposit.id
         });
         this.emit(
-          "deposit:confirmed",
+          SparkWalletEvent.DepositConfirmed,
           deposit.id,
           (await this.getBalance()).balance
         );
@@ -11846,7 +11931,7 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
               break;
             }
             if (data.event?.$case === "connected") {
-              this.emit("stream:connected");
+              this.emit(SparkWalletEvent.StreamConnected);
               retryCount = 0;
             }
             if (data.event?.$case === "transfer" && data.event.transfer.transfer && claimedTransfersIds.includes(data.event.transfer.transfer.id)) {
@@ -11868,7 +11953,7 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
         if (retryCount < MAX_RETRIES) {
           retryCount++;
           this.emit(
-            "stream:reconnecting",
+            SparkWalletEvent.StreamReconnecting,
             retryCount,
             MAX_RETRIES,
             backoffDelay,
@@ -11888,7 +11973,10 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
             }
           }
         } else {
-          this.emit("stream:disconnected", "Max reconnection attempts reached");
+          this.emit(
+            SparkWalletEvent.StreamDisconnected,
+            "Max reconnection attempts reached"
+          );
           break;
         }
       }
@@ -11988,6 +12076,10 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
   verifyKey(pubkey1, pubkey2, verifyingKey) {
     return equalBytes6(addPublicKeys(pubkey1, pubkey2), verifyingKey);
   }
+  popOrThrow(arr, msg) {
+    if (!arr || arr.length === 0) throw new ValidationError(msg);
+    return arr.pop();
+  }
   async selectLeaves(targetAmounts) {
     if (targetAmounts.length === 0) {
       throw new ValidationError("Target amounts must be non-empty", {
@@ -12041,7 +12133,11 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
           }
         }
         totalAmount += amount;
-        results2.set(targetAmount, nodes);
+        if (results2.has(targetAmount)) {
+          results2.get(targetAmount).push(nodes);
+        } else {
+          results2.set(targetAmount, [nodes]);
+        }
       }
       return {
         results: results2,
@@ -12168,17 +12264,60 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
    * @param {Object} params - Parameters for the sats payment
    * @param {number} params.amount - The amount of sats to receive
    * @param {string} [params.memo] - The memo for the payment
-   * @param {string} [params.senderPublicKey] - The public key of the expected sender
+   * @param {string} [params.senderSparkAddress] - The spark address of the expected sender
    * @param {Date} [params.expiryTime] - The expiry time of the payment
-   * @returns {Promise<SparkAddressFormat>} The Spark address for the sats payment
+   * @returns {Promise<SparkAddressFormat>} The Spark invoice for the sats payment
    */
   async createSatsInvoice({
     amount,
     memo,
-    senderPublicKey,
+    senderSparkAddress,
     expiryTime
   }) {
-    throw new NotImplementedError("sats invoices are not yet supported.");
+    const MAX_SATS_AMOUNT = 21e14;
+    if (amount && (amount < 0 || amount > MAX_SATS_AMOUNT)) {
+      throw new ValidationError(
+        `Amount must be between 0 and ${MAX_SATS_AMOUNT} sats`,
+        {
+          field: "amount",
+          value: amount,
+          expected: `less than or equal to ${MAX_SATS_AMOUNT}`
+        }
+      );
+    }
+    const protoPayment = {
+      $case: "satsPayment",
+      satsPayment: {
+        amount
+      }
+    };
+    const senderPublicKey = senderSparkAddress ? hexToBytes11(
+      decodeSparkAddress(senderSparkAddress, this.config.getNetworkType()).identityPublicKey
+    ) : void 0;
+    const invoiceFields = {
+      version: 1,
+      id: uuidv7obj().bytes,
+      paymentType: protoPayment,
+      memo,
+      senderPublicKey,
+      expiryTime: expiryTime ?? void 0
+    };
+    validateSparkInvoiceFields(invoiceFields);
+    const identityPublicKey = await this.config.signer.getIdentityPublicKey();
+    const hash = HashSparkInvoice(
+      invoiceFields,
+      identityPublicKey,
+      this.config.getNetworkType()
+    );
+    const signature = await this.config.signer.signSchnorrWithIdentityKey(hash);
+    return encodeSparkAddressWithSignature(
+      {
+        identityPublicKey: bytesToHex10(identityPublicKey),
+        network: this.config.getNetworkType(),
+        sparkInvoiceFields: invoiceFields
+      },
+      signature
+    );
   }
   /**
    * Creates a Spark invoice for a tokens payment on Spark.
@@ -12187,15 +12326,15 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
    * @param {bigint} [params.amount] - The amount of tokens to receive
    * @param {Bech32mTokenIdentifier} [params.tokenIdentifier] - The token identifier
    * @param {string} [params.memo] - The memo for the payment
-   * @param {string} [params.senderPublicKey] - The public key of the expected sender
+   * @param {string} [params.senderSparkAddress] - The spark address of the expected sender
    * @param {Date} [params.expiryTime] - The expiry time of the payment
-   * @returns {Promise<SparkAddressFormat>} The Spark address for the tokens payment
+   * @returns {Promise<SparkAddressFormat>} The Spark invoice for the tokens payment
    */
   async createTokensInvoice({
     amount,
     tokenIdentifier,
     memo,
-    senderPublicKey,
+    senderSparkAddress,
     expiryTime
   }) {
     const MAX_UINT128 = BigInt(2 ** 128 - 1);
@@ -12220,12 +12359,15 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
         amount: amount ? numberToVarBytesBE(amount) : void 0
       }
     };
+    const senderPublicKey = senderSparkAddress ? hexToBytes11(
+      decodeSparkAddress(senderSparkAddress, this.config.getNetworkType()).identityPublicKey
+    ) : void 0;
     const invoiceFields = {
       version: 1,
       id: uuidv7obj().bytes,
       paymentType: protoPayment,
       memo: memo ?? void 0,
-      senderPublicKey: senderPublicKey ? hexToBytes11(senderPublicKey) : void 0,
+      senderPublicKey,
       expiryTime: expiryTime ?? void 0
     };
     validateSparkInvoiceFields(invoiceFields);
@@ -13698,63 +13840,150 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
         }
       );
     }
-    if (!Number.isSafeInteger(amountSats)) {
-      throw new ValidationError("Sats amount must be less than 2^53", {
-        field: "amountSats",
-        value: amountSats,
-        expected: "smaller or equal to " + Number.MAX_SAFE_INTEGER
-      });
+    const [outcome] = await this.transferWithInvoice([
+      {
+        amountSats,
+        receiverIdentityPubkey: hexToBytes11(receiverAddress.identityPublicKey)
+      }
+    ]);
+    if (!outcome) throw new Error("no transfer created");
+    if (!outcome.ok) throw outcome.error;
+    return outcome.transfer;
+  }
+  /**
+   * Transfers with optional invoices.
+   * Does not parse/validate invoices or enforce amount-vs-invoice.
+   * If an invoice is provided, the caller must pass in the correct:
+   *  - amountSats
+   *  - receiverIdentityPubkey
+   *
+   * @param {TransferWithInvoiceParams[]} params - The parameters for the transfers
+   * @returns {Promise<TransferWithInvoiceOutcome[]>} The outcomes of the transfers
+   * @private
+   */
+  async transferWithInvoice(params) {
+    const amountSatsArray = [];
+    for (const param of params) {
+      const { amountSats } = param;
+      if (!Number.isSafeInteger(amountSats)) {
+        throw new ValidationError("Sats amount must be less than 2^53", {
+          field: "amountSats",
+          value: amountSats,
+          expected: "smaller or equal to " + Number.MAX_SAFE_INTEGER
+        });
+      }
+      if (amountSats <= 0) {
+        throw new ValidationError("Amount must be greater than 0", {
+          field: "amountSats",
+          value: amountSats
+        });
+      }
+      amountSatsArray.push(amountSats);
     }
-    if (amountSats <= 0) {
-      throw new ValidationError("Amount must be greater than 0", {
-        field: "amountSats",
-        value: amountSats
+    const transferJobs = await this.withLeaves(async () => {
+      const selectLeavesToSendMap = await this.selectLeaves(amountSatsArray);
+      for (const [amount, selection] of selectLeavesToSendMap) {
+        for (let groupIndex = 0; groupIndex < selection.length; groupIndex++) {
+          const group = selection[groupIndex];
+          if (!group) {
+            throw new ValidationError(
+              `TreeNode group at index ${groupIndex} not found for amount ${amount} after selection`
+            );
+          }
+          let available = await this.checkRefreshTimelockNodes(group);
+          available = await this.checkExtendTimeLockNodes(available);
+          if (available.length < group.length) {
+            throw new Error(
+              `Not enough available nodes after refresh/extend. Expected ${group.length}, got ${available.length}`
+            );
+          }
+          selection[groupIndex] = available;
+        }
+      }
+      const tweaksByAmount = this.buildTweaksByAmount(selectLeavesToSendMap);
+      const idsToRemove = /* @__PURE__ */ new Set();
+      const jobs = params.map((param) => {
+        const { amountSats, receiverIdentityPubkey, sparkInvoice } = param;
+        const leafKeyTweaks = this.popOrThrow(
+          tweaksByAmount.get(amountSats),
+          `no leaves key tweaks for ${amountSats}`
+        );
+        for (const tweak of leafKeyTweaks) {
+          idsToRemove.add(tweak.leaf.id);
+        }
+        return { leafKeyTweaks, receiverIdentityPubkey, sparkInvoice, param };
       });
-    }
+      if (idsToRemove.size > 0) {
+        this.leaves = this.leaves.filter((leaf) => !idsToRemove.has(leaf.id));
+      }
+      return jobs;
+    });
     const signerIdentityPublicKey = await this.config.signer.getIdentityPublicKey();
-    const isSelfTransfer = equalBytes6(
-      signerIdentityPublicKey,
-      hexToBytes11(receiverAddress.identityPublicKey)
+    const outcomes = await Promise.all(
+      transferJobs.map(async (job) => {
+        try {
+          const transfer = await this.transferService.sendTransferWithKeyTweaks(
+            job.leafKeyTweaks,
+            job.receiverIdentityPubkey,
+            job.sparkInvoice
+          );
+          const isSelfTransfer = equalBytes6(
+            signerIdentityPublicKey,
+            job.receiverIdentityPubkey
+          );
+          if (isSelfTransfer) {
+            const pending = await this.transferService.queryTransfer(
+              transfer.id
+            );
+            if (pending) {
+              await this.claimTransfer({ transfer: pending, optimize: true });
+            }
+          }
+          return {
+            ok: true,
+            transfer: mapTransferToWalletTransfer(
+              transfer,
+              bytesToHex10(await this.config.signer.getIdentityPublicKey())
+            ),
+            param: job.param
+          };
+        } catch (error) {
+          return {
+            ok: false,
+            error: error instanceof Error ? error : new Error(String(error)),
+            param: job.param
+          };
+        }
+      })
     );
-    return await this.withLeaves(async () => {
-      let leavesToSend = (await this.selectLeaves([amountSats])).get(
-        amountSats
-      );
-      leavesToSend = await this.checkRefreshTimelockNodes(leavesToSend);
-      leavesToSend = await this.checkExtendTimeLockNodes(leavesToSend);
-      const leafKeyTweaks = await Promise.all(
-        leavesToSend.map(async (leaf) => ({
-          leaf,
-          keyDerivation: {
-            type: "leaf" /* LEAF */,
-            path: leaf.id
-          },
-          newKeyDerivation: {
-            type: "random" /* RANDOM */
+    return outcomes;
+  }
+  buildTweaksByAmount(selectedByAmount) {
+    const tweaksByAmount = /* @__PURE__ */ new Map();
+    for (const [amount, treeNodes] of selectedByAmount) {
+      const keyTweaksForAmount = [];
+      for (const nodes of treeNodes) {
+        const batch = [];
+        for (let i = 0; i < nodes.length; i++) {
+          if (!nodes[i]) {
+            throw new ValidationError(
+              `TreeNode at index ${i} not found for amount ${amount} while building key tweaks by amount`
+            );
           }
-        }))
-      );
-      const transfer = await this.transferService.sendTransferWithKeyTweaks(
-        leafKeyTweaks,
-        hexToBytes11(receiverAddress.identityPublicKey)
-      );
-      const leavesToRemove = new Set(leavesToSend.map((leaf) => leaf.id));
-      this.leaves = this.leaves.filter((leaf) => !leavesToRemove.has(leaf.id));
-      if (isSelfTransfer) {
-        const transactionId = transfer.id;
-        const pendingTransfer = await this.transferService.queryTransfer(transactionId);
-        if (pendingTransfer) {
-          await this.claimTransfer({
-            transfer: pendingTransfer,
-            optimize: true
-          });
+          batch.push(this.toSendTweak(nodes[i]));
         }
+        keyTweaksForAmount.push(batch);
       }
-      return mapTransferToWalletTransfer(
-        transfer,
-        bytesToHex10(await this.config.signer.getIdentityPublicKey())
-      );
-    });
+      tweaksByAmount.set(amount, keyTweaksForAmount);
+    }
+    return tweaksByAmount;
+  }
+  toSendTweak(node) {
+    return {
+      leaf: node,
+      keyDerivation: { type: "leaf" /* LEAF */, path: node.id },
+      newKeyDerivation: { type: "random" /* RANDOM */ }
+    };
   }
   async checkExtendTimeLockNodes(nodes) {
     const nodesToExtend = [];
@@ -13912,7 +14141,7 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
     }
     if (emit) {
       this.emit(
-        "transfer:claimed",
+        SparkWalletEvent.TransferClaimed,
         transfer.id,
         (await this.getBalance()).balance
       );
@@ -13930,10 +14159,20 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
     emit,
     optimize
   }) {
-    const onError = (context) => {
+    const onError = async (context) => {
       const error = context.error;
       if (error instanceof RPCError && error.originalError instanceof ClientError && error.originalError.code === Status.ALREADY_EXISTS) {
-        return [];
+        const transferToUse = context.data || transfer;
+        const updatedTransfer = await this.transferService.queryTransfer(
+          transferToUse.id
+        );
+        if (!updatedTransfer) {
+          return void 0;
+        }
+        const leaves = updatedTransfer.leaves.flatMap(
+          (leaf) => leaf.leaf ? [leaf.leaf] : []
+        );
+        return leaves;
       }
       return;
     };
@@ -14236,7 +14475,13 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
           expected: `${totalAmount} sats`
         });
       }
-      let leaves = (await this.selectLeaves([totalAmount])).get(totalAmount);
+      const selectedLeaves = (await this.selectLeaves([totalAmount])).get(
+        totalAmount
+      );
+      let leaves = this.popOrThrow(
+        selectedLeaves,
+        `no leaves for ${totalAmount}`
+      );
       leaves = await this.checkRefreshTimelockNodes(leaves);
       leaves = await this.checkExtendTimeLockNodes(leaves);
       const leavesToSend = await Promise.all(
@@ -14274,7 +14519,7 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
       );
       const sspResponse = await sspClient.requestLightningSend({
         encodedInvoice: invoice,
-        idempotencyKey: paymentHash,
+        idempotencyKey: uuidv74(),
         amountSats: isZeroAmountInvoice ? amountSatsToSend : void 0
       });
       if (!sspResponse) {
@@ -14293,99 +14538,237 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
         expected: "Non-empty array"
       });
     }
+    const satsTransactionSuccess = [];
+    const satsTransactionErrors = [];
+    const tokenTransactionSuccess = [];
+    const tokenTransactionErrors = [];
+    const { satsInvoices, tokenInvoices, invalidInvoices } = await this.groupSparkInvoicesByPaymentType(sparkInvoices);
+    if (invalidInvoices.length > 0) {
+      return {
+        satsTransactionSuccess,
+        satsTransactionErrors,
+        tokenTransactionSuccess,
+        tokenTransactionErrors,
+        invalidInvoices
+      };
+    }
+    if (tokenInvoices.size > 0) {
+      await this.syncTokenOutputs();
+      const tokenTransferTasks = [];
+      for (const [identifierHex, decodedInvoices] of tokenInvoices.entries()) {
+        const tokenIdentifier = hexToBytes11(identifierHex);
+        const tokenIdB32 = encodeBech32mTokenIdentifier({
+          tokenIdentifier,
+          network: this.config.getNetworkType()
+        });
+        const receiverOutputs = decodedInvoices.map((d) => ({
+          tokenIdentifier: tokenIdB32,
+          tokenAmount: d.amount,
+          receiverSparkAddress: d.invoice
+        }));
+        const invoices = decodedInvoices.map(
+          (d) => d.invoice
+        );
+        tokenTransferTasks.push(
+          this.tokenTransactionService.tokenTransfer({ tokenOutputs: this.tokenOutputs, receiverOutputs }).then((txid) => ({
+            ok: true,
+            tokenIdentifier: tokenIdB32,
+            invoices,
+            txid
+          })).catch((e) => ({
+            ok: false,
+            tokenIdentifier: tokenIdB32,
+            invoices,
+            error: e instanceof Error ? e : new Error(String(e))
+          }))
+        );
+      }
+      const results = await Promise.all(tokenTransferTasks);
+      for (const r of results) {
+        if (r.ok) {
+          tokenTransactionSuccess.push({
+            tokenIdentifier: r.tokenIdentifier,
+            invoices: r.invoices,
+            txid: r.txid
+          });
+        } else {
+          tokenTransactionErrors.push({
+            tokenIdentifier: r.tokenIdentifier,
+            invoices: r.invoices,
+            error: r.error
+          });
+        }
+      }
+    }
+    if (satsInvoices.length > 0) {
+      const transfers = await this.transferWithInvoice(satsInvoices);
+      for (const transfer of transfers) {
+        if (transfer.ok) {
+          satsTransactionSuccess.push({
+            invoice: transfer.param.sparkInvoice ?? "",
+            transferResponse: transfer.transfer
+          });
+        } else {
+          satsTransactionErrors.push({
+            invoice: transfer.param.sparkInvoice ?? "",
+            error: transfer.error
+          });
+        }
+      }
+    }
+    return {
+      satsTransactionSuccess,
+      satsTransactionErrors,
+      tokenTransactionSuccess,
+      tokenTransactionErrors,
+      invalidInvoices
+    };
+  }
+  async groupSparkInvoicesByPaymentType(sparkInvoices) {
+    const satsInvoices = [];
+    const tokenInvoices = /* @__PURE__ */ new Map();
+    const invalidInvoices = [];
     const identityPublicKey = await this.getIdentityPublicKey();
-    let firstTokenIdentifierHexSeen;
-    const decoded = sparkInvoices.map((input, index) => {
+    sparkInvoices.forEach((input) => {
       const { invoice, amount } = input;
+      if (isLegacySparkAddress(invoice)) {
+        invalidInvoices.push({
+          invoice,
+          error: new ValidationError("Deprecated spark invoice format", {
+            field: "invoice",
+            value: invoice,
+            expected: "Modern spark invoice format. Deprecated formats are not supported."
+          })
+        });
+        return;
+      }
       const addressData = decodeSparkAddress(
         invoice,
         this.config.getNetworkType()
       );
       if (!addressData.sparkInvoiceFields) {
-        throw new ValidationError("Spark invoice not present", {
-          field: "sparkInvoice",
-          value: invoice,
-          index
+        invalidInvoices.push({
+          invoice,
+          error: new ValidationError("Missing invoice fields", {
+            field: "invoice",
+            value: invoice,
+            expected: "Valid invoice fields"
+          })
         });
+        return;
       }
       const fields = addressData.sparkInvoiceFields;
-      if (fields.paymentType?.type === "sats") {
-        throw new NotImplementedError("Sats payments are not supported yet");
-      }
       if (fields.expiryTime) {
         if (fields.expiryTime.getTime() <= Date.now()) {
-          throw new ValidationError("Spark invoice is expired", {
-            field: "expiryTime",
-            value: fields.expiryTime,
-            index,
-            expected: "future date"
+          invalidInvoices.push({
+            invoice,
+            error: new ValidationError("Invoice expired", {
+              field: "invoice",
+              value: fields.expiryTime.getTime(),
+              expected: "Expiry time in the future"
+            })
           });
+          return;
         }
       }
-      if (fields.paymentType?.type !== "tokens") {
-        throw new ValidationError("Invalid payment type", {
-          field: "paymentType",
-          value: fields.paymentType,
-          expected: "tokens",
-          index
-        });
-      }
       if (fields.senderPublicKey && fields.senderPublicKey !== identityPublicKey) {
-        throw new ValidationError("Sender public key does not match", {
-          field: "senderPublicKey"
+        invalidInvoices.push({
+          invoice,
+          error: new ValidationError("Sender public key mismatch", {
+            field: "invoice",
+            value: fields.senderPublicKey,
+            expected: identityPublicKey
+          })
         });
+        return;
       }
-      const tokenIdentifierHex = fields.paymentType.tokenIdentifier;
-      if (!tokenIdentifierHex) {
-        throw new ValidationError("Token identifier missing in invoice", {
-          field: "paymentType.tokenIdentifier",
-          value: tokenIdentifierHex,
-          index
+      if (fields.paymentType?.type === "sats") {
+        const encodedAmount = fields.paymentType.amount;
+        if (amount && !isSafeForNumber(amount)) {
+          invalidInvoices.push({
+            invoice,
+            error: new ValidationError("Invalid amount", {
+              field: "invoice",
+              value: amount,
+              expected: "Safe for number"
+            })
+          });
+          return;
+        }
+        if (!encodedAmount && !amount) {
+          invalidInvoices.push({
+            invoice,
+            error: new ValidationError(
+              "No amount passed for nil amount invoice",
+              {
+                field: "invoice",
+                expected: "Amount to fulfill passed to function for nil amount invoice"
+              }
+            )
+          });
+          return;
+        }
+        satsInvoices.push({
+          amountSats: encodedAmount ?? Number(amount),
+          receiverIdentityPubkey: hexToBytes11(addressData.identityPublicKey),
+          sparkInvoice: invoice
+        });
+      } else if (fields.paymentType?.type === "tokens") {
+        const tokenIdentifierHex = fields.paymentType.tokenIdentifier;
+        const encodedAmount = fields.paymentType.amount;
+        if (!tokenIdentifierHex) {
+          invalidInvoices.push({
+            invoice,
+            error: new ValidationError(
+              "No token identifier passed for tokens invoice",
+              {
+                field: "invoice",
+                value: invoice,
+                expected: "Token identifier passed"
+              }
+            )
+          });
+          return;
+        }
+        if (!encodedAmount && !amount) {
+          invalidInvoices.push({
+            invoice,
+            error: new ValidationError(
+              "No amount passed for nil amount invoice",
+              {
+                field: "invoice",
+                expected: "Amount to fulfill passed to function for nil amount invoice"
+              }
+            )
+          });
+          return;
+        }
+        if (!tokenInvoices.has(tokenIdentifierHex)) {
+          tokenInvoices.set(tokenIdentifierHex, [
+            {
+              invoice,
+              identifierHex: tokenIdentifierHex,
+              amount: encodedAmount ?? amount
+            }
+          ]);
+        } else {
+          tokenInvoices.get(tokenIdentifierHex).push({
+            invoice,
+            identifierHex: tokenIdentifierHex,
+            amount: encodedAmount ?? amount
+          });
+        }
+      } else {
+        invalidInvoices.push({
+          invoice,
+          error: new ValidationError("Invalid payment type", {
+            field: "invoice",
+            expected: "sats or tokens invoice"
+          })
         });
       }
-      if (!firstTokenIdentifierHexSeen) {
-        firstTokenIdentifierHexSeen = tokenIdentifierHex;
-      } else if (tokenIdentifierHex !== firstTokenIdentifierHexSeen) {
-        throw new ValidationError(
-          "All spark invoices must have the same token identifier",
-          {
-            field: "sparkInvoices",
-            value: sparkInvoices,
-            expected: "All invoices reference the same token identifier",
-            index
-          }
-        );
-      }
-      let tokenAmount = fields.paymentType.amount ?? amount;
-      if (!tokenAmount) {
-        throw new ValidationError(
-          "Missing token amount. Provide an amount in the invoice or as a parameter.",
-          {
-            field: "amount",
-            index
-          }
-        );
-      }
-      return {
-        invoice,
-        tokenIdentifierHex,
-        tokenAmount
-      };
-    });
-    await this.syncTokenOutputs();
-    const bech32mTokenIdentifier = encodeBech32mTokenIdentifier({
-      tokenIdentifier: hexToBytes11(firstTokenIdentifierHexSeen),
-      network: this.config.getNetworkType()
-    });
-    const receiverOutputs = decoded.map((d) => ({
-      tokenIdentifier: bech32mTokenIdentifier,
-      tokenAmount: d.tokenAmount,
-      receiverSparkAddress: d.invoice
-    }));
-    return this.tokenTransactionService.tokenTransfer({
-      tokenOutputs: this.tokenOutputs,
-      receiverOutputs
     });
+    return { satsInvoices, tokenInvoices, invalidInvoices };
   }
   /**
    * Gets fee estimate for sending Lightning payments.
@@ -14484,7 +14867,12 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
     let leavesToSendToSsp = [];
     let leavesToSendToSE = [];
     if (deductFeeFromWithdrawalAmount) {
-      leavesToSendToSsp = targetAmountSats ? (await this.selectLeaves([targetAmountSats])).get(targetAmountSats) : this.leaves;
+      leavesToSendToSsp = targetAmountSats ? this.popOrThrow(
+        (await this.selectLeaves([targetAmountSats])).get(
+          targetAmountSats
+        ),
+        `no leaves for ${targetAmountSats}`
+      ) : this.leaves;
       if (fee > leavesToSendToSsp.reduce((acc, leaf) => acc + leaf.value, 0)) {
         throw new ValidationError(
           "The fee for the withdrawal is greater than the target withdrawal amount",
@@ -14507,8 +14895,14 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
         );
       }
       const leaves = await this.selectLeaves([targetAmountSats, fee]);
-      const leavesForTargetAmount = leaves.get(targetAmountSats);
-      const leavesForFee = leaves.get(fee);
+      const leavesForTargetAmount = this.popOrThrow(
+        leaves.get(targetAmountSats),
+        `failed to get leaves leaves for targetAmount, val: ${targetAmountSats}`
+      );
+      const leavesForFee = this.popOrThrow(
+        leaves.get(fee),
+        `failed to get leaves leaves for fee, val: ${fee}`
+      );
       if (!leavesForTargetAmount || !leavesForFee) {
         throw new Error("Failed to select leaves for target amount and fee");
       }
@@ -14599,7 +14993,10 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
         expected: "smaller or equal to " + Number.MAX_SAFE_INTEGER
       });
     }
-    let leaves = (await this.selectLeaves([amountSats])).get(amountSats);
+    let leaves = this.popOrThrow(
+      (await this.selectLeaves([amountSats])).get(amountSats),
+      `no leaves for ${amountSats}`
+    );
     leaves = await this.checkRefreshTimelockNodes(leaves);
     leaves = await this.checkExtendTimeLockNodes(leaves);
     const feeEstimate = await sspClient.getCoopExitFeeQuote({
@@ -15275,6 +15672,9 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
       offset += pageSize;
     }
   }
+  async isOptimizationInProgress() {
+    return this.optimizationInProgress;
+  }
   getOtelTraceUrls() {
     const soConfig = this.config.getSigningOperators();
     const sspBaseUrl = this.config.getSspBaseUrl();
@@ -15947,6 +16347,7 @@ __export(utils_exports, {
   addPublicKeys: () => addPublicKeys,
   applyAdaptorToSignature: () => applyAdaptorToSignature,
   applyAdditiveTweakToPublicKey: () => applyAdditiveTweakToPublicKey,
+  assertBech32: () => assertBech32,
   bech32mDecode: () => bech32mDecode,
   bigIntToPrivateKey: () => bigIntToPrivateKey,
   checkIfSelectedOutputsAreAvailable: () => checkIfSelectedOutputsAreAvailable,
@@ -16009,6 +16410,8 @@ __export(utils_exports, {
   getTxId: () => getTxId,
   getTxIdNoReverse: () => getTxIdNoReverse,
   isEphemeralAnchorOutput: () => isEphemeralAnchorOutput,
+  isLegacySparkAddress: () => isLegacySparkAddress,
+  isSafeForNumber: () => isSafeForNumber,
   isTxBroadcast: () => isTxBroadcast,
   isValidPublicKey: () => isValidPublicKey,
   isValidSparkAddress: () => isValidSparkAddress,
@@ -16120,13 +16523,16 @@ export {
   encodeSparkAddress,
   encodeSparkAddressWithSignature,
   decodeSparkAddress,
+  getNetworkFromSparkAddress,
+  isLegacySparkAddress,
   isValidSparkAddress,
   isValidPublicKey,
   validateSparkInvoiceFields,
   validateSparkInvoiceSignature,
-  getNetworkFromSparkAddress,
   toProtoTimestamp,
+  assertBech32,
   bech32mDecode,
+  isSafeForNumber,
   collectResponses,
   encodeBech32mTokenIdentifier,
   decodeBech32mTokenIdentifier,
@@ -16140,6 +16546,7 @@ export {
   validateOutboundAdaptorSignature,
   applyAdaptorToSignature,
   BitcoinFaucet,
+  SparkWalletEvent,
   SparkWallet,
   getLatestDepositTxId,
   isTxBroadcast,