@swapkit/toolboxes 4.0.0-beta.44 → 4.0.0-beta.46

package/src/utxo/helpers/api.ts

@@ -17,6 +17,8 @@ type BlockchairFetchUnspentUtxoParams = BlockchairParams<{
   offset?: number;
   limit?: number;
   address: string;
+  targetValue?: number;
+  accumulativeValue?: number;
 }>;
 
 async function broadcastUTXOTx({ chain, txHash }: { chain: Chain; txHash: string }) {
@@ -35,7 +37,9 @@ async function broadcastUTXOTx({ chain, txHash }: { chain: Chain; txHash: string
   }>(rpcUrl, { headers: { "Content-Type": "application/json" }, body });
 
   if (response.error) {
-    throw new SwapKitError("toolbox_utxo_broadcast_failed", { error: response.error?.message });
+    throw new SwapKitError("toolbox_utxo_broadcast_failed", {
+      error: response.error?.message,
+    });
   }
 
   if (response.result.includes('"code":-26')) {
@@ -109,14 +113,18 @@ async function blockchairRequest<T>(url: string, apiKey?: string): Promise<T> {
   );
 
   if (!response || response.context.code !== 200)
-    throw new SwapKitError("toolbox_utxo_api_error", { error: `Failed to query ${url}` });
+    throw new SwapKitError("toolbox_utxo_api_error", {
+      error: `Failed to query ${url}`,
+    });
 
   return response.data as T;
 }
 
 async function getAddressData({ address, chain, apiKey }: BlockchairParams<{ address?: string }>) {
   if (!address)
-    throw new SwapKitError("toolbox_utxo_invalid_params", { error: "Address is required" });
+    throw new SwapKitError("toolbox_utxo_invalid_params", {
+      error: "Address is required",
+    });
 
   try {
     const response = await blockchairRequest<BlockchairAddressResponse>(
@@ -142,7 +150,9 @@ async function getUnconfirmedBalance({
 
 async function getRawTx({ chain, apiKey, txHash }: BlockchairParams<{ txHash?: string }>) {
   if (!txHash)
-    throw new SwapKitError("toolbox_utxo_invalid_params", { error: "TxHash is required" });
+    throw new SwapKitError("toolbox_utxo_invalid_params", {
+      error: "TxHash is required",
+    });
 
   try {
     const rawTxResponse = await blockchairRequest<BlockchairRawTransactionResponse>(
@@ -156,46 +166,106 @@ async function getRawTx({ chain, apiKey, txHash }: BlockchairParams<{ txHash?: s
   }
 }
 
-async function fetchUnspentUtxoBatch({
+async function fetchUtxosBatch({
   chain,
   address,
   apiKey,
   offset = 0,
-  limit = 100,
+  limit = 30,
 }: BlockchairFetchUnspentUtxoParams) {
+  // Only fetch the fields we need to reduce payload size
+  const fields = "is_spent,transaction_hash,index,value,script_hex,block_id,spending_signature_hex";
+
   const response = await blockchairRequest<BlockchairOutputsResponse[]>(
-    `${baseUrl(chain)}/outputs?q=is_spent(false),recipient(${address})&limit=${limit}&offset=${offset}`,
+    `${baseUrl(chain)}/outputs?q=recipient(${address}),is_spent(false)&s=value(desc)&fields=${fields}&limit=${limit}&offset=${offset}`,
     apiKey,
   );
 
-  const txs = response
-    .filter(({ is_spent }) => !is_spent)
-    .map(({ script_hex, block_id, transaction_hash, index, value, spending_signature_hex }) => ({
+  const txs = response.map(
+    ({
+      is_spent,
+      script_hex,
+      block_id,
+      transaction_hash,
+      index,
+      value,
+      spending_signature_hex,
+    }) => ({
       hash: transaction_hash,
       index,
       value,
       txHex: spending_signature_hex,
       script_hex,
       is_confirmed: block_id !== -1,
-    }));
+      is_spent,
+    }),
+  );
 
   return txs;
 }
 
+function getTxsValue(txs: Awaited<ReturnType<typeof fetchUtxosBatch>>) {
+  return txs.reduce((total, tx) => total + tx.value, 0);
+}
+
+function pickMostValuableTxs(
+  txs: Awaited<ReturnType<typeof fetchUtxosBatch>>,
+  targetValue?: number,
+): Awaited<ReturnType<typeof fetchUtxosBatch>> {
+  const sortedTxs = [...txs].sort((a, b) => b.value - a.value);
+
+  if (targetValue) {
+    const result = [];
+    let accumulated = 0;
+
+    for (const utxo of sortedTxs) {
+      result.push(utxo);
+      accumulated += utxo.value;
+      if (accumulated >= targetValue) break;
+    }
+
+    return result;
+  }
+
+  return sortedTxs;
+}
+
 async function getUnspentUtxos({
   chain,
   address,
   apiKey,
+  targetValue,
+  accumulativeValue = 0,
   offset = 0,
-  limit = 100,
-}: BlockchairFetchUnspentUtxoParams): Promise<Awaited<ReturnType<typeof fetchUnspentUtxoBatch>>> {
+  limit = 30,
+}: BlockchairFetchUnspentUtxoParams): Promise<Awaited<ReturnType<typeof fetchUtxosBatch>>> {
   if (!address)
-    throw new SwapKitError("toolbox_utxo_invalid_params", { error: "Address is required" });
+    throw new SwapKitError("toolbox_utxo_invalid_params", {
+      error: "Address is required",
+    });
 
   try {
-    const txs = await fetchUnspentUtxoBatch({ chain, address, apiKey, offset, limit });
+    const utxos = await fetchUtxosBatch({
+      targetValue,
+      chain,
+      address,
+      apiKey,
+      offset,
+      limit,
+    });
+    const utxosCount = utxos.length;
+    const isComplete = utxosCount < limit;
+
+    const unspentUtxos = utxos.filter(({ is_spent }) => !is_spent);
+
+    const unspentUtxosValue = getTxsValue(unspentUtxos);
+    const totalCurrentValue = accumulativeValue + unspentUtxosValue;
+
+    const limitReached = targetValue && totalCurrentValue >= targetValue;
 
-    if (txs.length <= limit) return txs;
+    if (isComplete || limitReached) {
+      return pickMostValuableTxs(unspentUtxos, targetValue);
+    }
 
     const nextBatch = await getUnspentUtxos({
       chain,
@@ -203,22 +273,32 @@ async function getUnspentUtxos({
       apiKey,
       offset: offset + limit,
       limit,
+      accumulativeValue: totalCurrentValue,
+      targetValue,
     });
 
-    return [...txs, ...nextBatch];
+    const allUtxos = [...unspentUtxos, ...nextBatch];
+
+    return pickMostValuableTxs(allUtxos, targetValue);
   } catch (error) {
     console.error("Failed to fetch unspent UTXOs:", error);
     return [];
   }
 }
 
-async function scanUTXOs({
+async function getUtxos({
   address,
   chain,
   apiKey,
   fetchTxHex = true,
-}: BlockchairParams<{ address: string; fetchTxHex?: boolean }>) {
-  const utxos = await getUnspentUtxos({ chain, address, apiKey });
+  targetValue,
+}: BlockchairParams<{
+  address: string;
+  fetchTxHex?: boolean;
+  targetValue?: number;
+}>) {
+  const utxos = await getUnspentUtxos({ chain, address, apiKey, targetValue });
+
   const results = [];
 
   for (const { hash, index, script_hex, value } of utxos) {
@@ -249,8 +329,11 @@ function utxoApi(chain: UTXOChain) {
     getSuggestedTxFee: () => getSuggestedTxFee(chain),
     getBalance: (address: string) => getUnconfirmedBalance({ address, chain, apiKey }),
     getAddressData: (address: string) => getAddressData({ address, chain, apiKey }),
-    scanUTXOs: (params: { address: string; fetchTxHex?: boolean }) =>
-      scanUTXOs({ ...params, chain, apiKey }),
+    getUtxos: (params: {
+      address: string;
+      fetchTxHex?: boolean;
+      targetValue?: number;
+    }) => getUtxos({ ...params, chain, apiKey }),
   };
 }
 

package/src/utxo/helpers/bchaddrjs.ts

@@ -75,12 +75,18 @@ function toCashAddress(address: string): string {
 
 function decodeAddress(address: string) {
   try {
-    return decodeBase58Address(address);
+    const decoded = decodeBase58Address(address);
+    if (decoded) {
+      return decoded;
+    }
   } catch (_error) {
     // Try to decode as cashaddr if base58 decoding fails.
   }
   try {
-    return decodeCashAddress(address);
+    const decoded = decodeCashAddress(address);
+    if (decoded) {
+      return decoded;
+    }
   } catch (_error) {
     // Try to decode as bitpay if cashaddr decoding fails.
   }
@@ -116,10 +122,10 @@ function decodeBase58Address(address: string) {
         return { hash, format: Format.Bitpay, network: UtxoNetwork.Mainnet, type: Type.P2SH };
 
       default:
-        throw new SwapKitError("toolbox_utxo_invalid_address", { address });
+        return;
     }
   } catch (_error) {
-    throw new SwapKitError("toolbox_utxo_invalid_address", { address });
+    return;
   }
 }
 
@@ -141,10 +147,10 @@ function decodeCashAddress(address: string) {
     }
   }
 
-  throw new SwapKitError("toolbox_utxo_invalid_address", { address });
+  return;
 }
 
-function decodeCashAddressWithPrefix(address: string): DecodedType {
+function decodeCashAddressWithPrefix(address: string) {
   try {
     const { hash, prefix, type } = cashaddr.decode(address);
 
@@ -155,7 +161,7 @@ function decodeCashAddressWithPrefix(address: string): DecodedType {
       type: type === "P2PKH" ? Type.P2PKH : Type.P2SH,
     };
   } catch (_error) {
-    throw new SwapKitError("toolbox_utxo_invalid_address", { address });
+    return;
   }
 }
 

package/src/utxo/toolbox/bitcoinCash.ts

@@ -97,7 +97,7 @@ export async function createBCHToolbox<T extends Chain.BitcoinCash>(
       : updateDerivationPath(NetworkDerivationPath[chain], { index }),
   );
 
-  const keys = (await getCreateKeysForPath(chain))({ phrase, derivationPath });
+  const keys = phrase ? (await getCreateKeysForPath(chain))({ phrase, derivationPath }) : undefined;
 
   const signer = keys
     ? await createSignerWithKeys(keys)
@@ -140,9 +140,14 @@ async function createTransaction({
 }: UTXOBuildTxParams) {
   if (!bchValidateAddress(recipient))
     throw new SwapKitError("toolbox_utxo_invalid_address", { address: recipient });
-  const utxos = await getUtxoApi(chain).scanUTXOs({
+
+  // Overestimate by 7500 byte * feeRate to ensure we have enough UTXOs for fees and change
+  const targetValue = Math.ceil(assetValue.getBaseValue("number") + feeRate * 7500);
+
+  const utxos = await getUtxoApi(chain).getUtxos({
     address: stripToCashAddress(sender),
     fetchTxHex: true,
+    targetValue,
   });
 
   const compiledMemo = memo ? await compileMemo(memo) : null;
@@ -237,9 +242,13 @@ async function buildTx({ assetValue, recipient, memo, feeRate, sender }: UTXOBui
   if (!bchValidateAddress(recipientCashAddress))
     throw new SwapKitError("toolbox_utxo_invalid_address", { address: recipientCashAddress });
 
-  const utxos = await getUtxoApi(chain).scanUTXOs({
+  // Overestimate by 7500 byte * feeRate to ensure we have enough UTXOs for fees and change
+  const targetValue = Math.ceil(assetValue.getBaseValue("number") + feeRate * 7500);
+
+  const utxos = await getUtxoApi(chain).getUtxos({
     address: stripToCashAddress(sender),
-    fetchTxHex: true,
+    fetchTxHex: false,
+    targetValue,
   });
 
   const feeRateWhole = Number(feeRate.toFixed(0));

package/src/utxo/toolbox/index.ts

@@ -56,7 +56,9 @@ export async function getUtxoToolbox<T extends keyof UTXOToolboxes>(
 ): Promise<UTXOToolboxes[T]> {
   switch (chain) {
     case Chain.BitcoinCash: {
-      const toolbox = await createBCHToolbox(params as UtxoToolboxParams[Chain.BitcoinCash]);
+      const toolbox = await createBCHToolbox(
+        (params as UtxoToolboxParams[Chain.BitcoinCash]) || {},
+      );
       return toolbox as UTXOToolboxes[T];
     }
 

package/src/utxo/toolbox/utxo.ts

@@ -504,18 +504,21 @@ async function getInputsAndTargetOutputs({
   fetchTxHex: fetchTxOverwrite = false,
 }: Omit<UTXOBuildTxParams, "feeRate">) {
   const chain = assetValue.chain as UTXOChain;
+  const feeRate = (await getFeeRates(chain))[FeeOption.Fastest];
 
   const fetchTxHex = fetchTxOverwrite || nonSegwitChains.includes(chain);
 
-  const inputs = await getUtxoApi(chain).scanUTXOs({ address: sender, fetchTxHex });
+  const amountToSend = assetValue.getBaseValue("number");
 
-  //1. add output amount and recipient to targets
-  //2. add output memo to targets (optional)
+  // Overestimate by 5000 byte * highest feeRate to ensure we have enough UTXOs for fees and change
+  const targetValue = Math.ceil(amountToSend + feeRate * 5000);
+
+  const inputs = await getUtxoApi(chain).getUtxos({ address: sender, fetchTxHex, targetValue });
 
   return {
     inputs,
     outputs: [
-      { address: recipient, value: Number(assetValue.bigIntValue) },
+      { address: recipient, value: amountToSend },
       ...(memo ? [{ address: "", script: await compileMemo(memo), value: 0 }] : []),
     ],
   };