@buildonspark/spark-sdk 0.3.9 → 0.4.0

package/dist/native/index.react-native.js

@@ -17108,7 +17108,11 @@ var BASE_CONFIG = {
   console: {
     otel: false
   },
-  events: {}
+  events: {},
+  optimizationOptions: {
+    auto: true,
+    multiplicity: 0
+  }
 };
 var LOCAL_WALLET_CONFIG = {
   ...BASE_CONFIG,
@@ -19714,7 +19718,7 @@ var isWebExtension = (
   "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.9" : "unknown";
+var packageVersion = true ? "0.4.0" : "unknown";
 var baseEnvStr = "unknown";
 if (isBun) {
   const bunVersion = "version" in globalThis.Bun ? globalThis.Bun.version : "unknown-version";
@@ -19790,6 +19794,63 @@ var DefaultSparkKeysGenerator = class {
     };
   }
 };
+var TaprootOutputKeysGenerator = class {
+  constructor(useAddressIndex = false) {
+    this.useAddressIndex = useAddressIndex;
+  }
+  async deriveKeysFromSeed(seed, accountNumber) {
+    const hdkey = HDKey.fromMasterSeed(seed);
+    if (!hdkey.privateKey || !hdkey.publicKey) {
+      throw new ValidationError("Failed to derive keys from seed", {
+        field: "hdkey",
+        value: seed
+      });
+    }
+    const derivationPath = this.useAddressIndex ? `m/86'/0'/0'/0/${accountNumber}` : `m/86'/0'/${accountNumber}'/0/0`;
+    const taprootInternalKey = hdkey.derive(derivationPath);
+    let tweakedPrivateKey = taprootTweakPrivKey(taprootInternalKey.privateKey);
+    let tweakedPublicKey = secp256k17.getPublicKey(tweakedPrivateKey);
+    if (tweakedPublicKey[0] === 3) {
+      tweakedPrivateKey = privateNegate(tweakedPrivateKey);
+      tweakedPublicKey = secp256k17.getPublicKey(tweakedPrivateKey);
+    }
+    const identityKey = {
+      publicKey: tweakedPublicKey,
+      privateKey: tweakedPrivateKey
+    };
+    const signingKey = hdkey.derive(`${derivationPath}/1'`);
+    const depositKey = hdkey.derive(`${derivationPath}/2'`);
+    const staticDepositKey = hdkey.derive(`${derivationPath}/3'`);
+    if (!signingKey.privateKey || !signingKey.publicKey || !depositKey.privateKey || !depositKey.publicKey || !staticDepositKey.privateKey || !staticDepositKey.publicKey) {
+      throw new ValidationError(
+        "Failed to derive all required keys from seed",
+        {
+          field: "derivedKeys"
+        }
+      );
+    }
+    return {
+      identityKey: {
+        privateKey: identityKey.privateKey,
+        publicKey: identityKey.publicKey
+      },
+      signingHDKey: {
+        hdKey: signingKey,
+        privateKey: signingKey.privateKey,
+        publicKey: signingKey.publicKey
+      },
+      depositKey: {
+        privateKey: depositKey.privateKey,
+        publicKey: depositKey.publicKey
+      },
+      staticDepositHDKey: {
+        hdKey: staticDepositKey,
+        privateKey: staticDepositKey.privateKey,
+        publicKey: staticDepositKey.publicKey
+      }
+    };
+  }
+};
 var DefaultSparkSigner = class {
   constructor({
     sparkKeysGenerator
@@ -20108,6 +20169,13 @@ var DefaultSparkSigner = class {
     tx.signIdx(privateKey, index);
   }
 };
+var TaprootSparkSigner = class extends DefaultSparkSigner {
+  constructor(useAddressIndex = false) {
+    super({
+      sparkKeysGenerator: new TaprootOutputKeysGenerator(useAddressIndex)
+    });
+  }
+};
 
 // src/signer/signer.react-native.ts
 var ReactNativeSparkSigner = class extends DefaultSparkSigner {
@@ -20171,6 +20239,70 @@ var ReactNativeSparkSigner = class extends DefaultSparkSigner {
     });
   }
 };
+var ReactNativeTaprootSparkSigner = class extends TaprootSparkSigner {
+  constructor(useAddressIndex = false) {
+    super(useAddressIndex);
+  }
+  async signFrost({
+    message,
+    keyDerivation,
+    publicKey,
+    verifyingKey,
+    selfCommitment,
+    statechainCommitments,
+    adaptorPubKey
+  }) {
+    const signingPrivateKey = await this.getSigningPrivateKeyFromDerivation(keyDerivation);
+    if (!signingPrivateKey) {
+      throw new ValidationError("Private key not found for public key", {
+        field: "privateKey"
+      });
+    }
+    const commitment = selfCommitment.commitment;
+    const nonce = this.commitmentToNonceMap.get(commitment);
+    if (!nonce) {
+      throw new ValidationError("Nonce not found for commitment", {
+        field: "nonce"
+      });
+    }
+    const keyPackage = {
+      secretKey: signingPrivateKey,
+      publicKey,
+      verifyingKey
+    };
+    return NativeSparkFrost.signFrost({
+      message,
+      keyPackage,
+      nonce,
+      selfCommitment: commitment,
+      statechainCommitments,
+      adaptorPubKey
+    });
+  }
+  async aggregateFrost({
+    message,
+    publicKey,
+    verifyingKey,
+    selfCommitment,
+    statechainCommitments,
+    adaptorPubKey,
+    selfSignature,
+    statechainSignatures,
+    statechainPublicKeys
+  }) {
+    return NativeSparkFrost.aggregateFrost({
+      message,
+      statechainSignatures,
+      statechainPublicKeys,
+      verifyingKey,
+      statechainCommitments,
+      selfCommitment: selfCommitment.commitment,
+      selfPublicKey: publicKey,
+      selfSignature,
+      adaptorPubKey
+    });
+  }
+};
 
 // src/services/xhr-transport.ts
 import { throwIfAborted } from "abort-controller-x";
@@ -20308,7 +20440,16 @@ function headersToMetadata(headers) {
     const parts = line.split(": ");
     const header = parts.shift() ?? "";
     const value = parts.join(": ");
-    metadata.set(header, value);
+    if (header.endsWith("-bin")) {
+      try {
+        metadata.set(header, Base64.toUint8Array(value));
+      } catch (e) {
+        console.warn(`Failed to decode binary metadata ${header}:`, e);
+        metadata.set(header, value);
+      }
+    } else {
+      metadata.set(header, value);
+    }
   });
   return metadata;
 }
@@ -20334,7 +20475,7 @@ function getStatusFromHttpCode(statusCode) {
   }
 }
 function getErrorDetailsFromHttpResponse(statusCode, responseText) {
-  return `Received HTTP ${statusCode} response: ` + (responseText.length > 1e3 ? responseText.slice(0, 1e3) + "... (truncated)" : responseText);
+  return `Received HTTP ${statusCode} response: ` + (responseText?.length > 1e3 ? responseText?.slice(0, 1e3) + "... (truncated)" : responseText);
 }
 
 // src/spark-wallet/spark-wallet.ts
@@ -21566,6 +21707,9 @@ var WalletConfigService = class {
   getEvents() {
     return this.config.events;
   }
+  getOptimizationOptions() {
+    return this.config.optimizationOptions;
+  }
 };
 
 // src/services/coop-exit.ts
@@ -29438,6 +29582,14 @@ var _BitcoinFaucet = class _BitcoinFaucet {
   async mineBlocks(numBlocks) {
     return await this.generateToAddress(numBlocks, this.miningAddress);
   }
+  async mineBlocksAndWaitForMiningToComplete(numBlocks) {
+    const startBlock = await this.getBlockCount();
+    await this.mineBlocks(numBlocks);
+    await this.waitForBlocksMined({
+      startBlock,
+      expectedIncrease: numBlocks
+    });
+  }
   async call(method, params) {
     try {
       const { fetch, Headers: Headers2 } = getFetch();
@@ -29490,15 +29642,50 @@ var _BitcoinFaucet = class _BitcoinFaucet {
   async getBlock(blockHash) {
     return await this.call("getblock", [blockHash, 2]);
   }
+  async getBlockCount() {
+    return await this.call("getblockcount", []);
+  }
+  async waitForBlocksMined({
+    startBlock,
+    expectedIncrease,
+    timeoutMs = 3e4,
+    intervalMs = 5e3
+  }) {
+    const deadline = Date.now() + timeoutMs;
+    await new Promise((r) => setTimeout(r, intervalMs));
+    const start = startBlock;
+    const target = start + expectedIncrease;
+    while (Date.now() < deadline) {
+      const currentBlock = await this.getBlockCount();
+      if (currentBlock >= target) return currentBlock;
+      await new Promise((r) => setTimeout(r, intervalMs));
+    }
+    throw new Error(
+      `Timed out waiting for ${expectedIncrease} blocks (target height ${target})`
+    );
+  }
   async broadcastTx(txHex) {
     let response = await this.call("sendrawtransaction", [txHex, 0]);
     return response;
   }
+  async submitPackage(txHexs) {
+    let response = await this.call("submitpackage", [txHexs]);
+    return response;
+  }
   async getNewAddress() {
     const key = secp256k112.utils.randomPrivateKey();
     const pubKey = secp256k112.getPublicKey(key);
     return getP2TRAddressFromPublicKey(pubKey, 4 /* LOCAL */);
   }
+  async getNewExternalWallet() {
+    const key = secp256k112.utils.randomPrivateKey();
+    const pubKey = secp256k112.getPublicKey(key);
+    return {
+      address: getP2TRAddressFromPublicKey(pubKey, 4 /* LOCAL */),
+      key,
+      pubKey
+    };
+  }
   async sendToAddress(address, amount, blocksToGenerate = 1) {
     const coin = await this.fund();
     if (!coin) {
@@ -29556,75 +29743,6 @@ function chunkArray(arr, size) {
   return chunks;
 }
 
-// src/utils/optimize.ts
-var DENOMINATIONS = Array.from({ length: 28 }, (_, i) => 2 ** i);
-function assert(condition, message) {
-  if (!condition) {
-    throw new InternalValidationError(message || "Assertion failed");
-  }
-}
-function sum(arr) {
-  return arr.reduce((a, b) => a + b, 0);
-}
-function sorted(arr) {
-  return [...arr].sort((a, b) => a - b);
-}
-function equals(a, b) {
-  return a.length === b.length && a.every((val, index) => val === b[index]);
-}
-function greedyLeaves(amount) {
-  const leaves = [];
-  let remaining = amount;
-  for (let i = DENOMINATIONS.length - 1; i >= 0; i--) {
-    const leaf = DENOMINATIONS[i];
-    if (typeof leaf === "number" && leaf > 0) {
-      while (remaining >= leaf) {
-        remaining -= leaf;
-        leaves.push(leaf);
-      }
-    }
-  }
-  assert(sum(leaves) === amount, "greedy_leaves: sum mismatch");
-  return sorted(leaves);
-}
-var Swap = class {
-  constructor(inLeaves, outLeaves) {
-    __publicField(this, "inLeaves");
-    __publicField(this, "outLeaves");
-    this.inLeaves = [...inLeaves];
-    this.outLeaves = [...outLeaves];
-    assert(
-      sum(this.inLeaves) === sum(this.outLeaves),
-      "Swap in/out leaves must sum to same value for swap: " + this.toString()
-    );
-  }
-  toString() {
-    return `Swap(in=${JSON.stringify(this.inLeaves)}, out=${JSON.stringify(this.outLeaves)})`;
-  }
-};
-function maximizeUnilateralExit(inputLeaves, maxLeavesPerSwap = 64) {
-  const swaps = [];
-  let batch = [];
-  let leaves = sorted(inputLeaves);
-  while (leaves.length > 0) {
-    batch.push(leaves.shift());
-    const target = greedyLeaves(sum(batch));
-    if (batch.length >= maxLeavesPerSwap || target.length >= maxLeavesPerSwap) {
-      if (!equals(target, batch)) {
-        swaps.push(new Swap([...batch], target));
-      }
-      batch = [];
-    }
-  }
-  if (batch.length > 0) {
-    const target = greedyLeaves(sum(batch));
-    if (!equals(target, batch)) {
-      swaps.push(new Swap([...batch], target));
-    }
-  }
-  return swaps;
-}
-
 // src/utils/retry.ts
 var DEFAULT_RETRY_CONFIG = {
   maxAttempts: 5,
@@ -29701,6 +29819,199 @@ var SparkWalletEvent = {
   StreamReconnecting: "stream:reconnecting"
 };
 
+// src/utils/optimize.ts
+var DENOMINATIONS = Array.from({ length: 28 }, (_, i) => 2 ** i);
+function assert(condition, message) {
+  if (!condition) {
+    throw new InternalValidationError(message || "Assertion failed");
+  }
+}
+function sum(arr) {
+  return arr.reduce((a, b) => a + b, 0);
+}
+function sorted(arr) {
+  return [...arr].sort((a, b) => a - b);
+}
+function equals(a, b) {
+  return a.length === b.length && a.every((val, index) => val === b[index]);
+}
+function countOccurrences(arr) {
+  const map = /* @__PURE__ */ new Map();
+  for (const x of arr) {
+    map.set(x, (map.get(x) ?? 0) + 1);
+  }
+  return map;
+}
+function subtractCounters(a, b) {
+  const result = /* @__PURE__ */ new Map();
+  for (const [key, value] of a.entries()) {
+    const diff = value - (b.get(key) ?? 0);
+    if (diff > 0) {
+      result.set(key, diff);
+    }
+  }
+  return result;
+}
+function counterToFlatArray(counter) {
+  const arr = [];
+  for (const [k, v] of Array.from(counter.entries()).sort(
+    (a, b) => a[0] - b[0]
+  )) {
+    for (let i = 0; i < v; i++) {
+      arr.push(k);
+    }
+  }
+  return arr;
+}
+function greedyLeaves(amount) {
+  const leaves = [];
+  let remaining = amount;
+  for (let i = DENOMINATIONS.length - 1; i >= 0; i--) {
+    const leaf = DENOMINATIONS[i];
+    if (typeof leaf === "number" && leaf > 0) {
+      while (remaining >= leaf) {
+        remaining -= leaf;
+        leaves.push(leaf);
+      }
+    }
+  }
+  assert(sum(leaves) === amount, "greedy_leaves: sum mismatch");
+  return sorted(leaves);
+}
+function swapMinimizingLeaves(amount, multiplicity = 1) {
+  const leaves = [];
+  let remaining = amount;
+  assert(multiplicity > 0, "multiplicity must be > 0");
+  for (const leaf of DENOMINATIONS) {
+    if (typeof leaf === "number" && leaf > 0) {
+      for (let i = 0; i < multiplicity; i++) {
+        if (remaining >= leaf) {
+          remaining -= leaf;
+          leaves.push(leaf);
+        }
+      }
+    }
+  }
+  leaves.push(...greedyLeaves(remaining));
+  assert(sum(leaves) === amount, "swap_minimizing_leaves: sum mismatch");
+  return sorted(leaves);
+}
+var Swap = class {
+  constructor(inLeaves, outLeaves) {
+    __publicField(this, "inLeaves");
+    __publicField(this, "outLeaves");
+    this.inLeaves = [...inLeaves];
+    this.outLeaves = [...outLeaves];
+    assert(
+      sum(this.inLeaves) === sum(this.outLeaves),
+      "Swap in/out leaves must sum to same value for swap: " + this.toString()
+    );
+  }
+  toString() {
+    return `Swap(in=${JSON.stringify(this.inLeaves)}, out=${JSON.stringify(this.outLeaves)})`;
+  }
+};
+function maximizeUnilateralExit(inputLeaves, maxLeavesPerSwap = 64) {
+  const swaps = [];
+  let batch = [];
+  let leaves = sorted(inputLeaves);
+  while (leaves.length > 0) {
+    batch.push(leaves.shift());
+    const target = greedyLeaves(sum(batch));
+    if (batch.length >= maxLeavesPerSwap || target.length >= maxLeavesPerSwap) {
+      if (!equals(target, batch)) {
+        swaps.push(new Swap([...batch], target));
+      }
+      batch = [];
+    }
+  }
+  if (batch.length > 0) {
+    const target = greedyLeaves(sum(batch));
+    if (!equals(target, batch)) {
+      swaps.push(new Swap([...batch], target));
+    }
+  }
+  return swaps;
+}
+function minimizeTransferSwap(inputLeaves, multiplicity = 1, maxLeavesPerSwap = 64) {
+  const balance = sum(inputLeaves);
+  const optimalLeaves = swapMinimizingLeaves(balance, multiplicity);
+  const walletCounter = countOccurrences(inputLeaves);
+  const optimalCounter = countOccurrences(optimalLeaves);
+  const leavesToGive = subtractCounters(walletCounter, optimalCounter);
+  const leavesToReceive = subtractCounters(optimalCounter, walletCounter);
+  const leavesToGiveFlat = counterToFlatArray(leavesToGive);
+  const leavesToReceiveFlat = counterToFlatArray(leavesToReceive);
+  const swaps = [];
+  let toGiveBatch = [];
+  let toReceiveBatch = [];
+  let give = [...leavesToGiveFlat];
+  let receive = [...leavesToReceiveFlat];
+  while (give.length > 0 || receive.length > 0) {
+    if (sum(toGiveBatch) > sum(toReceiveBatch)) {
+      if (receive.length === 0) break;
+      toReceiveBatch.push(receive.shift());
+    } else {
+      if (give.length === 0) break;
+      toGiveBatch.push(give.shift());
+    }
+    if (toGiveBatch.length > 0 && toReceiveBatch.length > 0 && sum(toGiveBatch) === sum(toReceiveBatch)) {
+      if (toGiveBatch.length > maxLeavesPerSwap) {
+        for (let i = 0; i < toGiveBatch.length; i += maxLeavesPerSwap) {
+          const subset = toGiveBatch.slice(i, i + maxLeavesPerSwap);
+          swaps.push(new Swap(subset, greedyLeaves(sum(subset))));
+        }
+      } else if (toReceiveBatch.length > maxLeavesPerSwap) {
+        for (let cutoff = maxLeavesPerSwap; cutoff > 0; cutoff--) {
+          const sumCut = sum(toReceiveBatch.slice(0, cutoff));
+          const remainder = sum(toGiveBatch) - sumCut;
+          const alternateBatch = [
+            ...toReceiveBatch.slice(0, cutoff),
+            ...greedyLeaves(remainder)
+          ];
+          if (alternateBatch.length <= maxLeavesPerSwap) {
+            swaps.push(new Swap([...toGiveBatch], alternateBatch));
+            break;
+          }
+        }
+      } else {
+        swaps.push(new Swap([...toGiveBatch], [...toReceiveBatch]));
+      }
+      toGiveBatch = [];
+      toReceiveBatch = [];
+    }
+  }
+  return swaps;
+}
+function shouldOptimize(inputLeaves, multiplicity = 1, maxLeavesPerSwap = 64) {
+  if (multiplicity == 0) {
+    const swaps = maximizeUnilateralExit(inputLeaves, maxLeavesPerSwap);
+    const numInputs = sum(swaps.map((swap) => swap.inLeaves.length));
+    const numOutputs = sum(swaps.map((swap) => swap.outLeaves.length));
+    return numOutputs * 5 < numInputs;
+  } else {
+    const swaps = minimizeTransferSwap(
+      inputLeaves,
+      multiplicity,
+      maxLeavesPerSwap
+    );
+    const inputCounter = countOccurrences(
+      swaps.flatMap((swap) => swap.inLeaves)
+    );
+    const outputCounter = countOccurrences(
+      swaps.flatMap((swap) => swap.outLeaves)
+    );
+    return Math.abs(inputCounter.size - outputCounter.size) > 1;
+  }
+}
+function optimize(inputLeaves, multiplicity = 1, maxLeavesPerSwap = 64) {
+  if (multiplicity == 0) {
+    return maximizeUnilateralExit(inputLeaves, maxLeavesPerSwap);
+  } else {
+    return minimizeTransferSwap(inputLeaves, multiplicity, maxLeavesPerSwap);
+  }
+}
+
 // src/spark-wallet/spark-wallet.ts
 var SparkWallet = class extends EventEmitter {
   constructor(options, signerArg) {
@@ -29805,8 +30116,7 @@ var SparkWallet = class extends EventEmitter {
         if (event.transfer.transfer && !equalBytes6(senderIdentityPublicKey, receiverIdentityPublicKey)) {
           await this.claimTransfer({
             transfer: event.transfer.transfer,
-            emit: true,
-            optimize: true
+            emit: true
           });
         }
       } else if (isDepositStreamEvent(event)) {
@@ -30097,73 +30407,84 @@ var SparkWallet = class extends EventEmitter {
     }
     return nodes;
   }
-  areLeavesInefficient() {
-    const totalAmount = this.getInternalBalance();
-    if (this.leaves.length <= 1) {
-      return false;
+  async *optimizeLeaves(multiplicity = void 0) {
+    const multiplicityValue = multiplicity ?? this.config.getOptimizationOptions().multiplicity ?? 0;
+    if (multiplicityValue < 0) {
+      throw new ValidationError("Multiplicity cannot be negative");
+    } else if (multiplicityValue > 5) {
+      throw new ValidationError("Multiplicity cannot be greater than 5");
     }
-    const nextLowerPowerOfTwo = 31 - Math.clz32(totalAmount);
-    let remainingAmount = totalAmount;
-    let optimalLeavesLength = 0;
-    for (let i = nextLowerPowerOfTwo; i >= 0; i--) {
-      const denomination = 2 ** i;
-      while (remainingAmount >= denomination) {
-        remainingAmount -= denomination;
-        optimalLeavesLength++;
-      }
-    }
-    return this.leaves.length > optimalLeavesLength * 5;
-  }
-  async optimizeLeaves() {
-    if (this.optimizationInProgress || !this.areLeavesInefficient()) {
+    if (this.optimizationInProgress || !shouldOptimize(
+      this.leaves.map((leaf) => leaf.value),
+      multiplicityValue
+    )) {
       return;
     }
-    await this.withLeaves(async () => {
+    const controller = new AbortController();
+    const release = await this.leavesMutex.acquire();
+    try {
       this.optimizationInProgress = true;
-      try {
-        this.leaves = await this.getLeaves();
-        const swaps = maximizeUnilateralExit(
-          this.leaves.map((leaf) => leaf.value)
-        );
-        const valueToNodes = /* @__PURE__ */ new Map();
-        this.leaves.forEach((leaf) => {
-          if (!valueToNodes.has(leaf.value)) {
-            valueToNodes.set(leaf.value, []);
-          }
-          valueToNodes.get(leaf.value).push(leaf);
-        });
-        for (const swap of swaps) {
-          const leavesToSend = [];
-          for (const leafValue of swap.inLeaves) {
-            const nodes = valueToNodes.get(leafValue);
-            if (nodes && nodes.length > 0) {
-              const node = nodes.shift();
-              leavesToSend.push(node);
-            } else {
-              throw new InternalValidationError(
-                `No unused leaf with value ${leafValue} found in leaves`
-              );
-            }
+      this.leaves = await this.getLeaves();
+      const swaps = optimize(
+        this.leaves.map((leaf) => leaf.value),
+        multiplicityValue
+      );
+      if (swaps.length === 0) {
+        return;
+      }
+      yield {
+        step: 0,
+        total: swaps.length,
+        controller
+      };
+      const valueToNodes = /* @__PURE__ */ new Map();
+      this.leaves.forEach((leaf) => {
+        if (!valueToNodes.has(leaf.value)) {
+          valueToNodes.set(leaf.value, []);
+        }
+        valueToNodes.get(leaf.value).push(leaf);
+      });
+      for (const swap of swaps) {
+        if (controller.signal.aborted) {
+          break;
+        }
+        const leavesToSend = [];
+        for (const leafValue of swap.inLeaves) {
+          const nodes = valueToNodes.get(leafValue);
+          if (nodes && nodes.length > 0) {
+            const node = nodes.shift();
+            leavesToSend.push(node);
+          } else {
+            throw new InternalValidationError(
+              `No unused leaf with value ${leafValue} found in leaves`
+            );
           }
-          await this.requestLeavesSwap({
-            leaves: leavesToSend,
-            targetAmounts: swap.outLeaves
-          });
         }
-        this.leaves = await this.getLeaves();
-      } finally {
-        this.optimizationInProgress = false;
+        await this.requestLeavesSwap({
+          leaves: leavesToSend,
+          targetAmounts: swap.outLeaves
+        });
+        yield {
+          step: swaps.indexOf(swap) + 1,
+          total: swaps.length,
+          controller
+        };
       }
-    });
+      this.leaves = await this.getLeaves();
+    } finally {
+      this.optimizationInProgress = false;
+      release();
+    }
   }
   async syncWallet() {
     await this.syncTokenOutputs();
     let leaves = await this.getLeaves();
     leaves = await this.checkRenewLeaves(leaves);
     this.leaves = leaves;
-    this.optimizeLeaves().catch((e) => {
-      console.error("Failed to optimize leaves", e);
-    });
+    if (this.config.getOptimizationOptions().auto) {
+      for await (const _ of this.optimizeLeaves()) {
+      }
+    }
   }
   async withLeaves(operation) {
     const release = await this.leavesMutex.acquire();
@@ -30746,8 +31067,7 @@ var SparkWallet = class extends EventEmitter {
       }
       return await this.claimTransfer({
         transfer: incomingTransfer,
-        emit: false,
-        optimize: false
+        emit: false
       });
     } catch (e) {
       console.error("[processSwapBatch] Error details:", {
@@ -31776,7 +32096,7 @@ var SparkWallet = class extends EventEmitter {
                 transfer.id
               );
               if (pending) {
-                await this.claimTransfer({ transfer: pending, optimize: true });
+                await this.claimTransfer({ transfer: pending });
               }
             }
             return {
@@ -31949,13 +32269,14 @@ var SparkWallet = class extends EventEmitter {
       return response.nodes;
     });
   }
-  async processClaimedTransferResults(result, transfer, emit, optimize) {
+  async processClaimedTransferResults(result, transfer, emit) {
     result = await this.checkRenewLeaves(result);
     const existingIds = new Set(this.leaves.map((leaf) => leaf.id));
     const uniqueResults = result.filter((node) => !existingIds.has(node.id));
     this.leaves.push(...uniqueResults);
-    if (optimize && transfer.type !== 40 /* COUNTER_SWAP */) {
-      await this.optimizeLeaves();
+    if (this.config.getOptimizationOptions().auto && transfer.type !== 40 /* COUNTER_SWAP */) {
+      for await (const _ of this.optimizeLeaves()) {
+      }
     }
     if (emit) {
       this.emit(
@@ -31974,8 +32295,7 @@ var SparkWallet = class extends EventEmitter {
    */
   async claimTransfer({
     transfer,
-    emit,
-    optimize
+    emit
   }) {
     const onError = async (context) => {
       const error = context.error;
@@ -32020,12 +32340,7 @@ var SparkWallet = class extends EventEmitter {
       if (result.length === 0) {
         return [];
       }
-      return await this.processClaimedTransferResults(
-        result,
-        transfer,
-        emit,
-        optimize
-      );
+      return await this.processClaimedTransferResults(result, transfer, emit);
     } catch (error) {
       console.warn(
         `Failed to claim transfer after all retries. Please try reinitializing your wallet in a few minutes. Transfer ID: ${transfer.id}`,
@@ -32058,7 +32373,7 @@ var SparkWallet = class extends EventEmitter {
         continue;
       }
       promises.push(
-        this.claimTransfer({ transfer, emit, optimize: true }).then(() => transfer.id).catch((error) => {
+        this.claimTransfer({ transfer, emit }).then(() => transfer.id).catch((error) => {
           console.warn(`Failed to claim transfer ${transfer.id}:`, error);
           return null;
         })
@@ -34406,12 +34721,14 @@ export {
   NotImplementedError,
   RPCError,
   ReactNativeSparkSigner,
+  ReactNativeTaprootSparkSigner,
   SparkSDKError,
   SparkSdkLogger,
   SparkWalletReactNative as SparkWallet,
   SparkWalletEvent,
   TEST_UNILATERAL_DIRECT_SEQUENCE,
   TEST_UNILATERAL_SEQUENCE,
+  ReactNativeTaprootSparkSigner as TaprootSparkSigner,
   TokenTransactionService,
   ValidationError,
   WalletConfig,
@@ -34485,6 +34802,7 @@ export {
   getTxFromRawTxHex,
   getTxId,
   getTxIdNoReverse,
+  hash160,
   isEphemeralAnchorOutput,
   isLegacySparkAddress,
   isSafeForNumber,