@buildonspark/spark-sdk 0.3.9 → 0.4.0

package/dist/bare/index.d.ts

@@ -3703,6 +3703,10 @@ type SigningOperator = {
 type ConsoleOptions = {
     otel?: boolean;
 };
+type OptimizationOptions = {
+    readonly auto?: boolean;
+    readonly multiplicity?: number;
+};
 type ConfigOptions = MayHaveSspClientOptions & {
     readonly network?: NetworkType;
     readonly signingOperators?: Readonly<Record<string, SigningOperator>>;
@@ -3718,6 +3722,7 @@ type ConfigOptions = MayHaveSspClientOptions & {
     readonly signerWithPreExistingKeys?: boolean;
     readonly console?: ConsoleOptions;
     readonly events?: Partial<SparkWalletEvents>;
+    readonly optimizationOptions?: OptimizationOptions;
 };
 
 declare class WalletConfigService implements HasSspClientOptions {
@@ -3743,6 +3748,7 @@ declare class WalletConfigService implements HasSspClientOptions {
     getSspIdentityPublicKey(): string;
     getConsoleOptions(): ConsoleOptions;
     getEvents(): Partial<SparkWalletEvents>;
+    getOptimizationOptions(): OptimizationOptions;
 }
 
 /** Challenge represents the core challenge data */
@@ -4044,8 +4050,11 @@ declare abstract class SparkWallet extends EventEmitter<SparkWalletEvents> {
     private popOrThrow;
     private selectLeaves;
     private selectLeavesForSwap;
-    private areLeavesInefficient;
-    private optimizeLeaves;
+    optimizeLeaves(multiplicity?: number | undefined): AsyncGenerator<{
+        step: number;
+        total: number;
+        controller: AbortController;
+    }, void, void>;
     private syncWallet;
     private withLeaves;
     /**
@@ -4802,6 +4811,7 @@ interface BroadcastResult {
 declare function isEphemeralAnchorOutput(script?: Uint8Array, amount?: bigint): boolean;
 declare function constructUnilateralExitTxs(nodeHexStrings: string[], sparkClient?: SparkServiceClient, network?: any): Promise<TxChain[]>;
 declare function constructUnilateralExitFeeBumpPackages(nodeHexStrings: string[], utxos: Utxo[], feeRate: FeeRate, electrsUrl: string, sparkClient?: SparkServiceClient, network?: any): Promise<FeeBumpTxChain[]>;
+declare function hash160(data: Uint8Array): Uint8Array;
 declare function constructFeeBumpTx(txHex: string, utxos: Utxo[], feeRate: FeeRate, previousFeeBumpTx?: string): {
     feeBumpPsbt: string;
     usedUtxos: Utxo[];
@@ -4823,4 +4833,4 @@ declare class SparkSdkLogger {
     static setAllEnabled(enabled: boolean): void;
 }
 
-export { type AggregateFrostParams, AuthenticationError, type Bech32mTokenIdentifier, type Bech32mTokenIdentifierData, type BroadcastConfig, type BroadcastResult, ConfigurationError, DEFAULT_FEE_SATS, DIRECT_HTLC_TIMELOCK_OFFSET, DIRECT_TIMELOCK_OFFSET, type DecodedSparkAddressData, DefaultSparkSigner, type FeeBumpTxChain, type FeeBumpTxPackage, type FeeRate, HTLC_TIMELOCK_OFFSET, type IKeyPackage, INITIAL_SEQUENCE, InternalValidationError, LOGGER_NAMES, type LeafInfo, type LegacySparkAddressFormat, type LoggerName, Network, NetworkError, NetworkToProto, type NetworkType, NotImplementedError, RPCError, type SignFrostParams, type SparkAddressData, type SparkAddressFormat, SparkSDKError, SparkSdkLogger, type SparkSigner, SparkWalletBare as SparkWallet, TEST_UNILATERAL_DIRECT_SEQUENCE, TEST_UNILATERAL_SEQUENCE, TaprootOutputKeysGenerator, TaprootSparkSigner, type TxChain, UnsafeStatelessSparkSigner, type Utxo, ValidationError, type VerifiableSecretShare, addPrivateKeys, addPublicKeys, applyAdaptorToSignature, applyAdditiveTweakToPublicKey, assertBech32, bech32mDecode, bigIntToPrivateKey, checkIfSelectedOutputsAreAvailable, checkIfValidSequence, collectResponses, computeTaprootKeyNoScript, computerLagrangeCoefficients, constructFeeBumpTx, constructUnilateralExitFeeBumpPackages, constructUnilateralExitTxs, createConnectorRefundTxs, createCurrentTimelockRefundTxs, createDecrementedTimelockNodeTx, createDecrementedTimelockRefundTxs, createInitialTimelockNodeTx, createInitialTimelockRefundTxs, createRootNodeTx, createSigningCommitment, createSigningNonce, createTestUnilateralRefundTxs, createTestUnilateralTimelockNodeTx, createZeroTimelockNodeTx, decodeBech32mTokenIdentifier, decodeBytesToSigningCommitment, decodeBytesToSigningNonce, decodeSparkAddress, doesLeafNeedRefresh, doesTxnNeedRenewed, encodeBech32mTokenIdentifier, encodeSigningCommitmentToBytes, encodeSigningNonceToBytes, encodeSparkAddress, encodeSparkAddressWithSignature, evaluatePolynomial, fieldDiv, filterTokenBalanceForTokenIdentifier, generateAdaptorFromSignature, generatePolynomialForSecretSharing, generateSignatureFromExistingAdaptor, getCurrentTimelock, getEphemeralAnchorOutput, getLatestDepositTxId, getNetwork, getNetworkFromAddress, getNetworkFromBech32mTokenIdentifier, getNetworkFromSparkAddress, getNetworkFromString, getNextHTLCTransactionSequence, getNextTransactionSequence, getP2TRAddressFromPkScript, getP2TRAddressFromPublicKey, getP2TRScriptFromPublicKey, getP2WPKHAddressFromPublicKey, getRandomBigInt, getRandomSigningNonce, getSigHashFromTx, getSigningCommitmentFromNonce, getSparkAddressFromTaproot, getTransactionSequence, getTransferPackageSigningPayload, getTxEstimatedVbytesSizeByNumberOfInputsOutputs, getTxFromRawTxBytes, getTxFromRawTxHex, getTxId, getTxIdNoReverse, isEphemeralAnchorOutput, isLegacySparkAddress, isSafeForNumber, isTxBroadcast, isValidPublicKey, isValidSparkAddress, isZeroTimelock, lastKeyWithTarget, maybeApplyFee, modInverse, proofOfPossessionMessageHashForDepositAddress, protoToNetwork, recoverSecret, splitSecret, splitSecretWithProofs, subtractPrivateKeys, subtractPublicKeys, sumAvailableTokens, sumOfPrivateKeys, toProtoTimestamp, validateOutboundAdaptorSignature, validateShare, validateSparkInvoiceFields, validateSparkInvoiceSignature };
+export { type AggregateFrostParams, AuthenticationError, type Bech32mTokenIdentifier, type Bech32mTokenIdentifierData, type BroadcastConfig, type BroadcastResult, ConfigurationError, DEFAULT_FEE_SATS, DIRECT_HTLC_TIMELOCK_OFFSET, DIRECT_TIMELOCK_OFFSET, type DecodedSparkAddressData, DefaultSparkSigner, type FeeBumpTxChain, type FeeBumpTxPackage, type FeeRate, HTLC_TIMELOCK_OFFSET, type IKeyPackage, INITIAL_SEQUENCE, InternalValidationError, LOGGER_NAMES, type LeafInfo, type LegacySparkAddressFormat, type LoggerName, Network, NetworkError, NetworkToProto, type NetworkType, NotImplementedError, RPCError, type SignFrostParams, type SparkAddressData, type SparkAddressFormat, SparkSDKError, SparkSdkLogger, type SparkSigner, SparkWalletBare as SparkWallet, TEST_UNILATERAL_DIRECT_SEQUENCE, TEST_UNILATERAL_SEQUENCE, TaprootOutputKeysGenerator, TaprootSparkSigner, type TxChain, UnsafeStatelessSparkSigner, type Utxo, ValidationError, type VerifiableSecretShare, addPrivateKeys, addPublicKeys, applyAdaptorToSignature, applyAdditiveTweakToPublicKey, assertBech32, bech32mDecode, bigIntToPrivateKey, checkIfSelectedOutputsAreAvailable, checkIfValidSequence, collectResponses, computeTaprootKeyNoScript, computerLagrangeCoefficients, constructFeeBumpTx, constructUnilateralExitFeeBumpPackages, constructUnilateralExitTxs, createConnectorRefundTxs, createCurrentTimelockRefundTxs, createDecrementedTimelockNodeTx, createDecrementedTimelockRefundTxs, createInitialTimelockNodeTx, createInitialTimelockRefundTxs, createRootNodeTx, createSigningCommitment, createSigningNonce, createTestUnilateralRefundTxs, createTestUnilateralTimelockNodeTx, createZeroTimelockNodeTx, decodeBech32mTokenIdentifier, decodeBytesToSigningCommitment, decodeBytesToSigningNonce, decodeSparkAddress, doesLeafNeedRefresh, doesTxnNeedRenewed, encodeBech32mTokenIdentifier, encodeSigningCommitmentToBytes, encodeSigningNonceToBytes, encodeSparkAddress, encodeSparkAddressWithSignature, evaluatePolynomial, fieldDiv, filterTokenBalanceForTokenIdentifier, generateAdaptorFromSignature, generatePolynomialForSecretSharing, generateSignatureFromExistingAdaptor, getCurrentTimelock, getEphemeralAnchorOutput, getLatestDepositTxId, getNetwork, getNetworkFromAddress, getNetworkFromBech32mTokenIdentifier, getNetworkFromSparkAddress, getNetworkFromString, getNextHTLCTransactionSequence, getNextTransactionSequence, getP2TRAddressFromPkScript, getP2TRAddressFromPublicKey, getP2TRScriptFromPublicKey, getP2WPKHAddressFromPublicKey, getRandomBigInt, getRandomSigningNonce, getSigHashFromTx, getSigningCommitmentFromNonce, getSparkAddressFromTaproot, getTransactionSequence, getTransferPackageSigningPayload, getTxEstimatedVbytesSizeByNumberOfInputsOutputs, getTxFromRawTxBytes, getTxFromRawTxHex, getTxId, getTxIdNoReverse, hash160, isEphemeralAnchorOutput, isLegacySparkAddress, isSafeForNumber, isTxBroadcast, isValidPublicKey, isValidSparkAddress, isZeroTimelock, lastKeyWithTarget, maybeApplyFee, modInverse, proofOfPossessionMessageHashForDepositAddress, protoToNetwork, recoverSecret, splitSecret, splitSecretWithProofs, subtractPrivateKeys, subtractPublicKeys, sumAvailableTokens, sumOfPrivateKeys, toProtoTimestamp, validateOutboundAdaptorSignature, validateShare, validateSparkInvoiceFields, validateSparkInvoiceSignature };

package/dist/bare/index.js

@@ -18230,7 +18230,11 @@ var BASE_CONFIG = {
   console: {
     otel: false
   },
-  events: {}
+  events: {},
+  optimizationOptions: {
+    auto: true,
+    multiplicity: 0
+  }
 };
 var LOCAL_WALLET_CONFIG = {
   ...BASE_CONFIG,
@@ -18441,6 +18445,9 @@ var WalletConfigService = class {
   getEvents() {
     return this.config.events;
   }
+  getOptimizationOptions() {
+    return this.config.optimizationOptions;
+  }
 };
 
 // src/services/coop-exit.ts
@@ -27140,7 +27147,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";
@@ -28612,6 +28619,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: Headers3 } = getFetch();
@@ -28664,15 +28679,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) {
@@ -28773,75 +28823,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 {
-  inLeaves;
-  outLeaves;
-  constructor(inLeaves, 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,
@@ -28918,6 +28899,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 {
+  inLeaves;
+  outLeaves;
+  constructor(inLeaves, 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 {
   config;
@@ -29022,8 +29196,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)) {
@@ -29314,73 +29487,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();
@@ -29963,8 +30147,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:", {
@@ -30993,7 +31176,7 @@ var SparkWallet = class extends EventEmitter {
                 transfer.id
               );
               if (pending) {
-                await this.claimTransfer({ transfer: pending, optimize: true });
+                await this.claimTransfer({ transfer: pending });
               }
             }
             return {
@@ -31166,13 +31349,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(
@@ -31191,8 +31375,7 @@ var SparkWallet = class extends EventEmitter {
    */
   async claimTransfer({
     transfer,
-    emit,
-    optimize
+    emit
   }) {
     const onError = async (context) => {
       const error = context.error;
@@ -31237,12 +31420,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}`,
@@ -31275,7 +31453,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;
         })
@@ -34315,6 +34493,7 @@ export {
   getTxFromRawTxHex,
   getTxId,
   getTxIdNoReverse,
+  hash160,
   isEphemeralAnchorOutput,
   isLegacySparkAddress,
   isSafeForNumber,

package/dist/{chunk-S55NZT4P.js → chunk-27ILUWDJ.js}

@@ -3,7 +3,7 @@ import {
   NetworkError,
   SparkWallet,
   clientEnv
-} from "./chunk-O4C4HGQL.js";
+} from "./chunk-G3LHXHF3.js";
 
 // src/services/connection/connection.browser.ts
 import {