@buildonspark/spark-sdk 0.2.12 → 0.3.0

package/dist/native/index.cjs

@@ -1111,14 +1111,34 @@ function signFrost({
   statechainCommitments,
   adaptorPubKey
 }) {
-  SparkSdkLogger.get(LOGGER_NAMES.wasm).trace("signFrost", {
+  const logMsg = JSON.stringify({
     message: (0, import_utils12.bytesToHex)(message),
-    keyPackage,
-    nonce,
-    selfCommitment,
-    statechainCommitments
+    keyPackage: {
+      secretKey: (0, import_utils12.bytesToHex)(keyPackage.secretKey),
+      publicKey: (0, import_utils12.bytesToHex)(keyPackage.publicKey),
+      verifyingKey: (0, import_utils12.bytesToHex)(keyPackage.verifyingKey)
+    },
+    nonce: {
+      hiding: (0, import_utils12.bytesToHex)(nonce.hiding),
+      binding: (0, import_utils12.bytesToHex)(nonce.binding)
+    },
+    selfCommitment: {
+      hiding: (0, import_utils12.bytesToHex)(selfCommitment.hiding),
+      binding: (0, import_utils12.bytesToHex)(selfCommitment.binding)
+    },
+    statechainCommitments: Object.fromEntries(
+      Object.entries(statechainCommitments ?? {}).map(([k, v]) => [
+        k,
+        {
+          hiding: (0, import_utils12.bytesToHex)(v.hiding),
+          binding: (0, import_utils12.bytesToHex)(v.binding)
+        }
+      ])
+    ),
+    adaptorPubKey: adaptorPubKey ? (0, import_utils12.bytesToHex)(adaptorPubKey) : void 0
   });
-  return wasm_sign_frost(
+  SparkSdkLogger.get(LOGGER_NAMES.wasm).trace("signFrost", logMsg);
+  const result = wasm_sign_frost(
     message,
     createKeyPackage(keyPackage),
     createSigningNonce2(nonce),
@@ -1126,6 +1146,11 @@ function signFrost({
     statechainCommitments,
     adaptorPubKey
   );
+  SparkSdkLogger.get(LOGGER_NAMES.wasm).trace(
+    "signFrost result",
+    (0, import_utils12.bytesToHex)(result)
+  );
+  return result;
 }
 function aggregateFrost({
   message,
@@ -1138,18 +1163,40 @@ function aggregateFrost({
   verifyingKey,
   adaptorPubKey
 }) {
-  SparkSdkLogger.get(LOGGER_NAMES.wasm).trace("aggregateFrost", {
+  const logMsg = JSON.stringify({
     message: (0, import_utils12.bytesToHex)(message),
-    statechainCommitments,
-    selfCommitment,
-    statechainSignatures,
+    statechainCommitments: Object.fromEntries(
+      Object.entries(statechainCommitments ?? {}).map(([k, v]) => [
+        k,
+        {
+          hiding: (0, import_utils12.bytesToHex)(v.hiding),
+          binding: (0, import_utils12.bytesToHex)(v.binding)
+        }
+      ])
+    ),
+    selfCommitment: {
+      hiding: (0, import_utils12.bytesToHex)(selfCommitment.hiding),
+      binding: (0, import_utils12.bytesToHex)(selfCommitment.binding)
+    },
+    statechainSignatures: Object.fromEntries(
+      Object.entries(statechainSignatures ?? {}).map(([k, v]) => [
+        k,
+        (0, import_utils12.bytesToHex)(v)
+      ])
+    ),
     selfSignature: (0, import_utils12.bytesToHex)(selfSignature),
-    statechainPublicKeys,
+    statechainPublicKeys: Object.fromEntries(
+      Object.entries(statechainPublicKeys ?? {}).map(([k, v]) => [
+        k,
+        (0, import_utils12.bytesToHex)(v)
+      ])
+    ),
     selfPublicKey: (0, import_utils12.bytesToHex)(selfPublicKey),
     verifyingKey: (0, import_utils12.bytesToHex)(verifyingKey),
     adaptorPubKey: adaptorPubKey ? (0, import_utils12.bytesToHex)(adaptorPubKey) : void 0
   });
-  return wasm_aggregate_frost(
+  SparkSdkLogger.get(LOGGER_NAMES.wasm).trace("aggregateFrost", logMsg);
+  const result = wasm_aggregate_frost(
     message,
     statechainCommitments,
     createSigningCommitment2(selfCommitment),
@@ -1160,6 +1207,11 @@ function aggregateFrost({
     verifyingKey,
     adaptorPubKey
   );
+  SparkSdkLogger.get(LOGGER_NAMES.wasm).trace(
+    "aggregateFrost result",
+    (0, import_utils12.bytesToHex)(result)
+  );
+  return result;
 }
 function createDummyTx({
   address: address2,
@@ -1386,6 +1438,7 @@ __export(index_exports, {
   SparkSDKError: () => SparkSDKError,
   SparkSdkLogger: () => SparkSdkLogger,
   SparkWallet: () => SparkWallet,
+  SparkWalletEvent: () => SparkWalletEvent,
   TEST_UNILATERAL_DIRECT_SEQUENCE: () => TEST_UNILATERAL_DIRECT_SEQUENCE,
   TEST_UNILATERAL_SEQUENCE: () => TEST_UNILATERAL_SEQUENCE,
   TokenTransactionService: () => TokenTransactionService,
@@ -1395,6 +1448,7 @@ __export(index_exports, {
   addPublicKeys: () => addPublicKeys,
   applyAdaptorToSignature: () => applyAdaptorToSignature,
   applyAdditiveTweakToPublicKey: () => applyAdditiveTweakToPublicKey,
+  assertBech32: () => assertBech32,
   bech32mDecode: () => bech32mDecode,
   bigIntToPrivateKey: () => bigIntToPrivateKey,
   checkIfSelectedOutputsAreAvailable: () => checkIfSelectedOutputsAreAvailable,
@@ -1457,6 +1511,8 @@ __export(index_exports, {
   getTxId: () => getTxId,
   getTxIdNoReverse: () => getTxIdNoReverse,
   isEphemeralAnchorOutput: () => isEphemeralAnchorOutput,
+  isLegacySparkAddress: () => isLegacySparkAddress,
+  isSafeForNumber: () => isSafeForNumber,
   isTxBroadcast: () => isTxBroadcast,
   isValidPublicKey: () => isValidPublicKey,
   isValidSparkAddress: () => isValidSparkAddress,
@@ -1938,6 +1994,31 @@ function networkToJSON(object) {
       return "UNRECOGNIZED";
   }
 }
+function directionFromJSON(object) {
+  switch (object) {
+    case 0:
+    case "NEXT":
+      return 0 /* NEXT */;
+    case 1:
+    case "PREVIOUS":
+      return 1 /* PREVIOUS */;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return -1 /* UNRECOGNIZED */;
+  }
+}
+function directionToJSON(object) {
+  switch (object) {
+    case 0 /* NEXT */:
+      return "NEXT";
+    case 1 /* PREVIOUS */:
+      return "PREVIOUS";
+    case -1 /* UNRECOGNIZED */:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
 function tokenTransactionStatusFromJSON(object) {
   switch (object) {
     case 0:
@@ -2533,6 +2614,187 @@ var DepositEvent = {
     return message;
   }
 };
+function createBasePageRequest() {
+  return { pageSize: 0, cursor: "", direction: 0 };
+}
+var PageRequest = {
+  encode(message, writer = new import_wire4.BinaryWriter()) {
+    if (message.pageSize !== 0) {
+      writer.uint32(8).int32(message.pageSize);
+    }
+    if (message.cursor !== "") {
+      writer.uint32(18).string(message.cursor);
+    }
+    if (message.direction !== 0) {
+      writer.uint32(24).int32(message.direction);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire4.BinaryReader ? input : new import_wire4.BinaryReader(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBasePageRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+          message.pageSize = reader.int32();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.cursor = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 24) {
+            break;
+          }
+          message.direction = reader.int32();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      pageSize: isSet3(object.pageSize) ? globalThis.Number(object.pageSize) : 0,
+      cursor: isSet3(object.cursor) ? globalThis.String(object.cursor) : "",
+      direction: isSet3(object.direction) ? directionFromJSON(object.direction) : 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.pageSize !== 0) {
+      obj.pageSize = Math.round(message.pageSize);
+    }
+    if (message.cursor !== "") {
+      obj.cursor = message.cursor;
+    }
+    if (message.direction !== 0) {
+      obj.direction = directionToJSON(message.direction);
+    }
+    return obj;
+  },
+  create(base) {
+    return PageRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBasePageRequest();
+    message.pageSize = object.pageSize ?? 0;
+    message.cursor = object.cursor ?? "";
+    message.direction = object.direction ?? 0;
+    return message;
+  }
+};
+function createBasePageResponse() {
+  return { hasNextPage: false, hasPreviousPage: false, nextCursor: "", previousCursor: "" };
+}
+var PageResponse = {
+  encode(message, writer = new import_wire4.BinaryWriter()) {
+    if (message.hasNextPage !== false) {
+      writer.uint32(8).bool(message.hasNextPage);
+    }
+    if (message.hasPreviousPage !== false) {
+      writer.uint32(16).bool(message.hasPreviousPage);
+    }
+    if (message.nextCursor !== "") {
+      writer.uint32(26).string(message.nextCursor);
+    }
+    if (message.previousCursor !== "") {
+      writer.uint32(34).string(message.previousCursor);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire4.BinaryReader ? input : new import_wire4.BinaryReader(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBasePageResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+          message.hasNextPage = reader.bool();
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+          message.hasPreviousPage = reader.bool();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.nextCursor = reader.string();
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+          message.previousCursor = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      hasNextPage: isSet3(object.hasNextPage) ? globalThis.Boolean(object.hasNextPage) : false,
+      hasPreviousPage: isSet3(object.hasPreviousPage) ? globalThis.Boolean(object.hasPreviousPage) : false,
+      nextCursor: isSet3(object.nextCursor) ? globalThis.String(object.nextCursor) : "",
+      previousCursor: isSet3(object.previousCursor) ? globalThis.String(object.previousCursor) : ""
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.hasNextPage !== false) {
+      obj.hasNextPage = message.hasNextPage;
+    }
+    if (message.hasPreviousPage !== false) {
+      obj.hasPreviousPage = message.hasPreviousPage;
+    }
+    if (message.nextCursor !== "") {
+      obj.nextCursor = message.nextCursor;
+    }
+    if (message.previousCursor !== "") {
+      obj.previousCursor = message.previousCursor;
+    }
+    return obj;
+  },
+  create(base) {
+    return PageResponse.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBasePageResponse();
+    message.hasNextPage = object.hasNextPage ?? false;
+    message.hasPreviousPage = object.hasPreviousPage ?? false;
+    message.nextCursor = object.nextCursor ?? "";
+    message.previousCursor = object.previousCursor ?? "";
+    return message;
+  }
+};
 function createBaseDepositAddressProof() {
   return { addressSignatures: {}, proofOfPossessionSignature: new Uint8Array(0) };
 }
@@ -8040,7 +8302,7 @@ function createBaseStartTransferRequest() {
     receiverIdentityPublicKey: new Uint8Array(0),
     expiryTime: void 0,
     transferPackage: void 0,
-    sparkPaymentIntent: ""
+    sparkInvoice: ""
   };
 }
 var StartTransferRequest = {
@@ -8063,8 +8325,8 @@ var StartTransferRequest = {
     if (message.transferPackage !== void 0) {
       TransferPackage.encode(message.transferPackage, writer.uint32(58).fork()).join();
     }
-    if (message.sparkPaymentIntent !== "") {
-      writer.uint32(74).string(message.sparkPaymentIntent);
+    if (message.sparkInvoice !== "") {
+      writer.uint32(82).string(message.sparkInvoice);
     }
     return writer;
   },
@@ -8117,11 +8379,11 @@ var StartTransferRequest = {
           message.transferPackage = TransferPackage.decode(reader, reader.uint32());
           continue;
         }
-        case 9: {
-          if (tag !== 74) {
+        case 10: {
+          if (tag !== 82) {
             break;
           }
-          message.sparkPaymentIntent = reader.string();
+          message.sparkInvoice = reader.string();
           continue;
         }
       }
@@ -8140,7 +8402,7 @@ var StartTransferRequest = {
       receiverIdentityPublicKey: isSet3(object.receiverIdentityPublicKey) ? bytesFromBase642(object.receiverIdentityPublicKey) : new Uint8Array(0),
       expiryTime: isSet3(object.expiryTime) ? fromJsonTimestamp(object.expiryTime) : void 0,
       transferPackage: isSet3(object.transferPackage) ? TransferPackage.fromJSON(object.transferPackage) : void 0,
-      sparkPaymentIntent: isSet3(object.sparkPaymentIntent) ? globalThis.String(object.sparkPaymentIntent) : ""
+      sparkInvoice: isSet3(object.sparkInvoice) ? globalThis.String(object.sparkInvoice) : ""
     };
   },
   toJSON(message) {
@@ -8163,8 +8425,8 @@ var StartTransferRequest = {
     if (message.transferPackage !== void 0) {
       obj.transferPackage = TransferPackage.toJSON(message.transferPackage);
     }
-    if (message.sparkPaymentIntent !== "") {
-      obj.sparkPaymentIntent = message.sparkPaymentIntent;
+    if (message.sparkInvoice !== "") {
+      obj.sparkInvoice = message.sparkInvoice;
     }
     return obj;
   },
@@ -8179,7 +8441,7 @@ var StartTransferRequest = {
     message.receiverIdentityPublicKey = object.receiverIdentityPublicKey ?? new Uint8Array(0);
     message.expiryTime = object.expiryTime ?? void 0;
     message.transferPackage = object.transferPackage !== void 0 && object.transferPackage !== null ? TransferPackage.fromPartial(object.transferPackage) : void 0;
-    message.sparkPaymentIntent = object.sparkPaymentIntent ?? "";
+    message.sparkInvoice = object.sparkInvoice ?? "";
     return message;
   }
 };
@@ -9009,7 +9271,8 @@ function createBaseTransfer() {
     leaves: [],
     createdTime: void 0,
     updatedTime: void 0,
-    type: 0
+    type: 0,
+    sparkInvoice: ""
   };
 }
 var Transfer = {
@@ -9044,6 +9307,9 @@ var Transfer = {
     if (message.type !== 0) {
       writer.uint32(80).int32(message.type);
     }
+    if (message.sparkInvoice !== "") {
+      writer.uint32(90).string(message.sparkInvoice);
+    }
     return writer;
   },
   decode(input, length) {
@@ -9123,6 +9389,13 @@ var Transfer = {
           message.type = reader.int32();
           continue;
         }
+        case 11: {
+          if (tag !== 90) {
+            break;
+          }
+          message.sparkInvoice = reader.string();
+          continue;
+        }
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
@@ -9142,7 +9415,8 @@ var Transfer = {
       leaves: globalThis.Array.isArray(object?.leaves) ? object.leaves.map((e) => TransferLeaf.fromJSON(e)) : [],
       createdTime: isSet3(object.createdTime) ? fromJsonTimestamp(object.createdTime) : void 0,
       updatedTime: isSet3(object.updatedTime) ? fromJsonTimestamp(object.updatedTime) : void 0,
-      type: isSet3(object.type) ? transferTypeFromJSON(object.type) : 0
+      type: isSet3(object.type) ? transferTypeFromJSON(object.type) : 0,
+      sparkInvoice: isSet3(object.sparkInvoice) ? globalThis.String(object.sparkInvoice) : ""
     };
   },
   toJSON(message) {
@@ -9177,6 +9451,9 @@ var Transfer = {
     if (message.type !== 0) {
       obj.type = transferTypeToJSON(message.type);
     }
+    if (message.sparkInvoice !== "") {
+      obj.sparkInvoice = message.sparkInvoice;
+    }
     return obj;
   },
   create(base) {
@@ -9194,6 +9471,7 @@ var Transfer = {
     message.createdTime = object.createdTime ?? void 0;
     message.updatedTime = object.updatedTime ?? void 0;
     message.type = object.type ?? 0;
+    message.sparkInvoice = object.sparkInvoice ?? "";
     return message;
   }
 };
@@ -16368,6 +16646,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",
@@ -16415,11 +16700,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(import_base2.bech32m.fromWords(decoded.words));
@@ -16465,18 +16750,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) {
@@ -16672,25 +16974,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 import_base2.bech32m.decode(address2, BECH32M_LIMIT);
 }
 function bech32mEncode(prefix, words) {
@@ -16721,6 +17014,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/adaptor-signature.ts
 init_buffer();
@@ -18405,7 +18701,7 @@ function mapTransferToWalletTransfer(proto, identityPublicKey, userRequest) {
 
 // src/utils/fetch.ts
 init_buffer();
-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) {
@@ -18975,10 +19271,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;
@@ -19249,8 +19545,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) {
@@ -19293,8 +19589,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() {
@@ -19952,22 +20248,30 @@ var ecies = __toESM(require("eciesjs"), 1);
 // src/constants.ts
 init_buffer();
 var import_core9 = require("@lightsparkdev/core");
-var isReactNative = typeof navigator !== "undefined" && navigator.product === "ReactNative";
-var isBun = globalThis.Bun !== void 0;
-var packageVersion = true ? "0.2.12" : "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 (import_core9.isNode) {
-  baseEnvStr = `node/${process.version}`;
+  baseEnvStr = `node/${globalThis.process.version}`;
 } else if (isReactNative) {
   baseEnvStr = "react-native";
 } else if (import_core9.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}`;
@@ -24307,7 +24611,7 @@ var QueryTokenMetadataResponse = {
   }
 };
 function createBaseQueryTokenOutputsRequest2() {
-  return { ownerPublicKeys: [], issuerPublicKeys: [], tokenIdentifiers: [], network: 0 };
+  return { ownerPublicKeys: [], issuerPublicKeys: [], tokenIdentifiers: [], network: 0, pageRequest: void 0 };
 }
 var QueryTokenOutputsRequest2 = {
   encode(message, writer = new import_wire8.BinaryWriter()) {
@@ -24323,6 +24627,9 @@ var QueryTokenOutputsRequest2 = {
     if (message.network !== 0) {
       writer.uint32(24).int32(message.network);
     }
+    if (message.pageRequest !== void 0) {
+      PageRequest.encode(message.pageRequest, writer.uint32(42).fork()).join();
+    }
     return writer;
   },
   decode(input, length) {
@@ -24360,6 +24667,13 @@ var QueryTokenOutputsRequest2 = {
           message.network = reader.int32();
           continue;
         }
+        case 5: {
+          if (tag !== 42) {
+            break;
+          }
+          message.pageRequest = PageRequest.decode(reader, reader.uint32());
+          continue;
+        }
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
@@ -24373,7 +24687,8 @@ var QueryTokenOutputsRequest2 = {
       ownerPublicKeys: globalThis.Array.isArray(object?.ownerPublicKeys) ? object.ownerPublicKeys.map((e) => bytesFromBase645(e)) : [],
       issuerPublicKeys: globalThis.Array.isArray(object?.issuerPublicKeys) ? object.issuerPublicKeys.map((e) => bytesFromBase645(e)) : [],
       tokenIdentifiers: globalThis.Array.isArray(object?.tokenIdentifiers) ? object.tokenIdentifiers.map((e) => bytesFromBase645(e)) : [],
-      network: isSet6(object.network) ? networkFromJSON(object.network) : 0
+      network: isSet6(object.network) ? networkFromJSON(object.network) : 0,
+      pageRequest: isSet6(object.pageRequest) ? PageRequest.fromJSON(object.pageRequest) : void 0
     };
   },
   toJSON(message) {
@@ -24390,6 +24705,9 @@ var QueryTokenOutputsRequest2 = {
     if (message.network !== 0) {
       obj.network = networkToJSON(message.network);
     }
+    if (message.pageRequest !== void 0) {
+      obj.pageRequest = PageRequest.toJSON(message.pageRequest);
+    }
     return obj;
   },
   create(base) {
@@ -24401,6 +24719,7 @@ var QueryTokenOutputsRequest2 = {
     message.issuerPublicKeys = object.issuerPublicKeys?.map((e) => e) || [];
     message.tokenIdentifiers = object.tokenIdentifiers?.map((e) => e) || [];
     message.network = object.network ?? 0;
+    message.pageRequest = object.pageRequest !== void 0 && object.pageRequest !== null ? PageRequest.fromPartial(object.pageRequest) : void 0;
     return message;
   }
 };
@@ -24709,13 +25028,16 @@ var OutputWithPreviousTransactionData2 = {
   }
 };
 function createBaseQueryTokenOutputsResponse2() {
-  return { outputsWithPreviousTransactionData: [] };
+  return { outputsWithPreviousTransactionData: [], pageResponse: void 0 };
 }
 var QueryTokenOutputsResponse2 = {
   encode(message, writer = new import_wire8.BinaryWriter()) {
     for (const v of message.outputsWithPreviousTransactionData) {
       OutputWithPreviousTransactionData2.encode(v, writer.uint32(10).fork()).join();
     }
+    if (message.pageResponse !== void 0) {
+      PageResponse.encode(message.pageResponse, writer.uint32(18).fork()).join();
+    }
     return writer;
   },
   decode(input, length) {
@@ -24734,6 +25056,13 @@ var QueryTokenOutputsResponse2 = {
           );
           continue;
         }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.pageResponse = PageResponse.decode(reader, reader.uint32());
+          continue;
+        }
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
@@ -24744,7 +25073,8 @@ var QueryTokenOutputsResponse2 = {
   },
   fromJSON(object) {
     return {
-      outputsWithPreviousTransactionData: globalThis.Array.isArray(object?.outputsWithPreviousTransactionData) ? object.outputsWithPreviousTransactionData.map((e) => OutputWithPreviousTransactionData2.fromJSON(e)) : []
+      outputsWithPreviousTransactionData: globalThis.Array.isArray(object?.outputsWithPreviousTransactionData) ? object.outputsWithPreviousTransactionData.map((e) => OutputWithPreviousTransactionData2.fromJSON(e)) : [],
+      pageResponse: isSet6(object.pageResponse) ? PageResponse.fromJSON(object.pageResponse) : void 0
     };
   },
   toJSON(message) {
@@ -24754,6 +25084,9 @@ var QueryTokenOutputsResponse2 = {
         (e) => OutputWithPreviousTransactionData2.toJSON(e)
       );
     }
+    if (message.pageResponse !== void 0) {
+      obj.pageResponse = PageResponse.toJSON(message.pageResponse);
+    }
     return obj;
   },
   create(base) {
@@ -24762,6 +25095,7 @@ var QueryTokenOutputsResponse2 = {
   fromPartial(object) {
     const message = createBaseQueryTokenOutputsResponse2();
     message.outputsWithPreviousTransactionData = object.outputsWithPreviousTransactionData?.map((e) => OutputWithPreviousTransactionData2.fromPartial(e)) || [];
+    message.pageResponse = object.pageResponse !== void 0 && object.pageResponse !== null ? PageResponse.fromPartial(object.pageResponse) : void 0;
     return message;
   }
 };
@@ -25889,7 +26223,7 @@ var BaseTransferService = class {
     }
     return response.transfer;
   }
-  async sendTransferWithKeyTweaks(leaves, receiverIdentityPubkey) {
+  async sendTransferWithKeyTweaks(leaves, receiverIdentityPubkey, sparkInvoice) {
     const transferID = (0, import_uuidv72.uuidv7)();
     const keyTweakInputMap = await this.prepareSendTransferKeyTweaks(
       transferID,
@@ -25914,7 +26248,8 @@ var BaseTransferService = class {
         transferId: transferID,
         ownerIdentityPublicKey: await this.config.signer.getIdentityPublicKey(),
         receiverIdentityPublicKey: receiverIdentityPubkey,
-        transferPackage
+        transferPackage,
+        sparkInvoice
       });
     } catch (error) {
       throw new NetworkError(
@@ -26775,24 +27110,6 @@ var TransferService = class extends BaseTransferService {
       throw new Error(`Error finalizing node signatures in transfer: ${error}`);
     }
   }
-  async cancelTransfer(transfer, operatorAddress) {
-    const sparkClient = await this.connectionManager.createSparkClient(operatorAddress);
-    try {
-      const response = await sparkClient.cancel_transfer({
-        transferId: transfer.id,
-        senderIdentityPublicKey: await this.config.signer.getIdentityPublicKey()
-      });
-      return response.transfer;
-    } catch (error) {
-      throw new NetworkError(
-        "Failed to cancel transfer",
-        {
-          method: "POST"
-        },
-        error
-      );
-    }
-  }
   async queryPendingTransfersBySender(operatorAddress) {
     const sparkClient = await this.connectionManager.createSparkClient(operatorAddress);
     try {
@@ -30527,6 +30844,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;
@@ -31215,6 +31533,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((0, import_utils19.bytesToHex)(ownerPublicKey));
+    }
+    for (const issuerPublicKey of issuerPublicKeys) {
+      isValidPublicKey((0, import_utils19.bytesToHex)(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 {
@@ -31267,13 +31615,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",
@@ -32146,6 +32511,17 @@ async function withRetry(operation, options = {}) {
   throw new Error("Unexpected retry loop exit");
 }
 
+// src/spark-wallet/types.ts
+init_buffer();
+var SparkWalletEvent = {
+  All: "*",
+  TransferClaimed: "transfer:claimed",
+  DepositConfirmed: "deposit:confirmed",
+  StreamConnected: "stream:connected",
+  StreamDisconnected: "stream:disconnected",
+  StreamReconnecting: "stream:reconnecting"
+};
+
 // src/spark-wallet/spark-wallet.ts
 var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
   config;
@@ -32259,7 +32635,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
           path: deposit.id
         });
         this.emit(
-          "deposit:confirmed",
+          SparkWalletEvent.DepositConfirmed,
           deposit.id,
           (await this.getBalance()).balance
         );
@@ -32323,7 +32699,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.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)) {
@@ -32345,7 +32721,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
         if (retryCount < MAX_RETRIES) {
           retryCount++;
           this.emit(
-            "stream:reconnecting",
+            SparkWalletEvent.StreamReconnecting,
             retryCount,
             MAX_RETRIES,
             backoffDelay,
@@ -32365,7 +32741,10 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
             }
           }
         } else {
-          this.emit("stream:disconnected", "Max reconnection attempts reached");
+          this.emit(
+            SparkWalletEvent.StreamDisconnected,
+            "Max reconnection attempts reached"
+          );
           break;
         }
       }
@@ -32465,6 +32844,10 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
   verifyKey(pubkey1, pubkey2, verifyingKey) {
     return (0, import_utils24.equalBytes)(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", {
@@ -32518,7 +32901,11 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
           }
         }
         totalAmount += amount;
-        results2.set(targetAmount, nodes);
+        if (results2.has(targetAmount)) {
+          results2.get(targetAmount).push(nodes);
+        } else {
+          results2.set(targetAmount, [nodes]);
+        }
       }
       return {
         results: results2,
@@ -32645,17 +33032,60 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.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 ? (0, import_utils24.hexToBytes)(
+      decodeSparkAddress(senderSparkAddress, this.config.getNetworkType()).identityPublicKey
+    ) : void 0;
+    const invoiceFields = {
+      version: 1,
+      id: (0, import_uuidv75.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: (0, import_utils24.bytesToHex)(identityPublicKey),
+        network: this.config.getNetworkType(),
+        sparkInvoiceFields: invoiceFields
+      },
+      signature
+    );
   }
   /**
    * Creates a Spark invoice for a tokens payment on Spark.
@@ -32664,15 +33094,15 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.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);
@@ -32697,12 +33127,15 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
         amount: amount ? (0, import_utils24.numberToVarBytesBE)(amount) : void 0
       }
     };
+    const senderPublicKey = senderSparkAddress ? (0, import_utils24.hexToBytes)(
+      decodeSparkAddress(senderSparkAddress, this.config.getNetworkType()).identityPublicKey
+    ) : void 0;
     const invoiceFields = {
       version: 1,
       id: (0, import_uuidv75.uuidv7obj)().bytes,
       paymentType: protoPayment,
       memo: memo ?? void 0,
-      senderPublicKey: senderPublicKey ? (0, import_utils24.hexToBytes)(senderPublicKey) : void 0,
+      senderPublicKey,
       expiryTime: expiryTime ?? void 0
     };
     validateSparkInvoiceFields(invoiceFields);
@@ -33231,7 +33664,6 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
         message: e.message,
         stack: e.stack
       });
-      await this.cancelAllSenderInitiatedTransfers();
       throw new Error(`Failed to request leaves swap: ${e}`);
     }
   }
@@ -33694,6 +34126,64 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
     });
     return tx.hex;
   }
+  /**
+   * Refunds a static deposit and broadcasts the transaction to the network.
+   *
+   * @param {Object} params - The refund parameters
+   * @param {string} params.depositTransactionId - The ID of the transaction
+   * @param {number} [params.outputIndex] - The index of the output
+   * @param {string} params.destinationAddress - The destination address
+   * @param {number} [params.satsPerVbyteFee] - The fee per vbyte to refund
+   * @returns {Promise<string>} The transaction ID
+   */
+  async refundAndBroadcastStaticDeposit({
+    depositTransactionId,
+    outputIndex,
+    destinationAddress,
+    satsPerVbyteFee
+  }) {
+    const txHex = await this.refundStaticDeposit({
+      depositTransactionId,
+      outputIndex,
+      destinationAddress,
+      satsPerVbyteFee
+    });
+    return await this.broadcastTx(txHex);
+  }
+  /**
+   * Broadcasts a transaction to the network.
+   *
+   * @param {string} txHex - The hex of the transaction
+   * @returns {Promise<string>} The transaction ID
+   */
+  async broadcastTx(txHex) {
+    if (!txHex) {
+      throw new ValidationError("Transaction hex cannot be empty", {
+        field: "txHex"
+      });
+    }
+    const { fetch, Headers: Headers2 } = getFetch();
+    const baseUrl = this.config.getElectrsUrl();
+    const headers = new Headers2();
+    if (this.config.getNetwork() === 4 /* LOCAL */) {
+      const localFaucet = BitcoinFaucet.getInstance();
+      const response = await localFaucet.broadcastTx(txHex);
+      return response;
+    } else {
+      if (this.config.getNetwork() === 3 /* REGTEST */) {
+        const auth = btoa(
+          `${ELECTRS_CREDENTIALS.username}:${ELECTRS_CREDENTIALS.password}`
+        );
+        headers.set("Authorization", `Basic ${auth}`);
+      }
+      const response = await fetch(`${baseUrl}/tx`, {
+        method: "POST",
+        body: txHex,
+        headers
+      });
+      return response.text();
+    }
+  }
   async getStaticDepositSigningPayload(transactionID, outputIndex, network, requestType, creditAmountSats, sspSignature) {
     const encoder = new TextEncoder();
     const parts = [];
@@ -34118,63 +34608,150 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.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: (0, import_utils24.hexToBytes)(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 = (0, import_utils24.equalBytes)(
-      signerIdentityPublicKey,
-      (0, import_utils24.hexToBytes)(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 = (0, import_utils24.equalBytes)(
+            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,
+              (0, import_utils24.bytesToHex)(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,
-        (0, import_utils24.hexToBytes)(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,
-        (0, import_utils24.bytesToHex)(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 = [];
@@ -34332,7 +34909,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
     }
     if (emit) {
       this.emit(
-        "transfer:claimed",
+        SparkWalletEvent.TransferClaimed,
         transfer.id,
         (await this.getBalance()).balance
       );
@@ -34350,10 +34927,20 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
     emit,
     optimize
   }) {
-    const onError = (context) => {
+    const onError = async (context) => {
       const error = context.error;
       if (error instanceof RPCError && error.originalError instanceof import_nice_grpc_common3.ClientError && error.originalError.code === import_nice_grpc_common3.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;
     };
@@ -34432,24 +35019,6 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
       (result) => result.status === "fulfilled" && result.value !== null
     ).map((result) => result.value);
   }
-  /**
-   * Cancels all sender-initiated transfers.
-   *
-   * @returns {Promise<void>}
-   * @private
-   */
-  async cancelAllSenderInitiatedTransfers() {
-    for (const operator of Object.values(this.config.getSigningOperators())) {
-      const transfers = await this.transferService.queryPendingTransfersBySender(
-        operator.address
-      );
-      for (const transfer of transfers.transfers) {
-        if (transfer.status === 0 /* TRANSFER_STATUS_SENDER_INITIATED */) {
-          await this.transferService.cancelTransfer(transfer, operator.address);
-        }
-      }
-    }
-  }
   // ***** Lightning Flow *****
   /**
    * Creates a Lightning invoice for receiving payments.
@@ -34674,7 +35243,13 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.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(
@@ -34712,7 +35287,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
       );
       const sspResponse = await sspClient.requestLightningSend({
         encodedInvoice: invoice,
-        idempotencyKey: paymentHash,
+        idempotencyKey: (0, import_uuidv75.uuidv7)(),
         amountSats: isZeroAmountInvoice ? amountSatsToSend : void 0
       });
       if (!sspResponse) {
@@ -34731,99 +35306,237 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.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 = (0, import_utils24.hexToBytes)(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: (0, import_utils24.hexToBytes)(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: (0, import_utils24.hexToBytes)(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.
@@ -34922,7 +35635,12 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.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",
@@ -34945,8 +35663,14 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.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");
       }
@@ -35037,7 +35761,10 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.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({
@@ -35713,6 +36440,9 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
       offset += pageSize;
     }
   }
+  async isOptimizationInProgress() {
+    return this.optimizationInProgress;
+  }
   getOtelTraceUrls() {
     const soConfig = this.config.getSigningOperators();
     const sspBaseUrl = this.config.getSspBaseUrl();
@@ -35822,9 +36552,6 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
   }
 };
 
-// src/spark-wallet/types.ts
-init_buffer();
-
 // src/native/index.ts
 setCrypto(globalThis.crypto);
 // Annotate the CommonJS export names for ESM import in node:
@@ -35848,6 +36575,7 @@ setCrypto(globalThis.crypto);
   SparkSDKError,
   SparkSdkLogger,
   SparkWallet,
+  SparkWalletEvent,
   TEST_UNILATERAL_DIRECT_SEQUENCE,
   TEST_UNILATERAL_SEQUENCE,
   TokenTransactionService,
@@ -35857,6 +36585,7 @@ setCrypto(globalThis.crypto);
   addPublicKeys,
   applyAdaptorToSignature,
   applyAdditiveTweakToPublicKey,
+  assertBech32,
   bech32mDecode,
   bigIntToPrivateKey,
   checkIfSelectedOutputsAreAvailable,
@@ -35919,6 +36648,8 @@ setCrypto(globalThis.crypto);
   getTxId,
   getTxIdNoReverse,
   isEphemeralAnchorOutput,
+  isLegacySparkAddress,
+  isSafeForNumber,
   isTxBroadcast,
   isValidPublicKey,
   isValidSparkAddress,