@tcswap/toolboxes 4.3.15

package/src/utxo/helpers/bchaddrjs.ts

@@ -0,0 +1,170 @@
+/**
+ * Modifications © 2025 Horizontal Systems.
+ */
+
+import { USwapError } from "@tcswap/helpers";
+import base58check from "bs58check";
+// @ts-expect-error
+import cashaddr from "cashaddrjs";
+
+enum Format {
+  Legacy = "legacy",
+  Bitpay = "bitpay",
+  Cashaddr = "cashaddr",
+}
+enum UtxoNetwork {
+  Mainnet = "mainnet",
+  Testnet = "testnet",
+}
+enum Type {
+  P2PKH = "p2pkh",
+  P2SH = "p2sh",
+}
+
+const VERSION_BYTE = {
+  [Format.Legacy]: {
+    [UtxoNetwork.Mainnet]: { [Type.P2PKH]: 0, [Type.P2SH]: 5 },
+    [UtxoNetwork.Testnet]: { [Type.P2PKH]: 111, [Type.P2SH]: 196 },
+  },
+  [Format.Bitpay]: {
+    [UtxoNetwork.Mainnet]: { [Type.P2PKH]: 28, [Type.P2SH]: 40 },
+    [UtxoNetwork.Testnet]: { [Type.P2PKH]: 111, [Type.P2SH]: 196 },
+  },
+};
+
+type DecodedType = { format: Format; network: UtxoNetwork; type: Type; hash: any };
+
+function isValidAddress(input: any) {
+  try {
+    decodeAddress(input);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function detectAddressNetwork(address: string) {
+  return decodeAddress(address)?.network;
+}
+
+function toLegacyAddress(address: string): string {
+  const decoded = decodeAddress(address);
+  if (decoded?.format === Format.Legacy) {
+    return address;
+  }
+  return encodeAsLegacy(decoded);
+}
+
+function toCashAddress(address: string): string {
+  const decoded = decodeAddress(address);
+  return encodeAsCashaddr(decoded);
+}
+
+function decodeAddress(address: string) {
+  try {
+    const decoded = decodeBase58Address(address);
+    if (decoded) {
+      return decoded;
+    }
+  } catch {
+    // Try to decode as cashaddr if base58 decoding fails.
+  }
+  try {
+    const decoded = decodeCashAddress(address);
+    if (decoded) {
+      return decoded;
+    }
+  } catch {
+    // Try to decode as bitpay if cashaddr decoding fails.
+  }
+  throw new USwapError("toolbox_utxo_invalid_address", { address });
+}
+
+function decodeBase58Address(address: string) {
+  try {
+    const payload = base58check.decode(address);
+
+    // BASE_58_CHECK_PAYLOAD_LENGTH
+    if (payload.length !== 21) throw new USwapError("toolbox_utxo_invalid_address", { address });
+    const versionByte = payload[0];
+    const hash = Array.prototype.slice.call(payload, 1);
+
+    switch (versionByte) {
+      case VERSION_BYTE[Format.Legacy][UtxoNetwork.Mainnet][Type.P2PKH]:
+        return { format: Format.Legacy, hash, network: UtxoNetwork.Mainnet, type: Type.P2PKH };
+
+      case VERSION_BYTE[Format.Legacy][UtxoNetwork.Mainnet][Type.P2SH]:
+        return { format: Format.Legacy, hash, network: UtxoNetwork.Mainnet, type: Type.P2SH };
+
+      case VERSION_BYTE[Format.Legacy][UtxoNetwork.Testnet][Type.P2PKH]:
+        return { format: Format.Legacy, hash, network: UtxoNetwork.Testnet, type: Type.P2PKH };
+
+      case VERSION_BYTE[Format.Legacy][UtxoNetwork.Testnet][Type.P2SH]:
+        return { format: Format.Legacy, hash, network: UtxoNetwork.Testnet, type: Type.P2SH };
+
+      case VERSION_BYTE[Format.Bitpay][UtxoNetwork.Mainnet][Type.P2PKH]:
+        return { format: Format.Bitpay, hash, network: UtxoNetwork.Mainnet, type: Type.P2PKH };
+
+      case VERSION_BYTE[Format.Bitpay][UtxoNetwork.Mainnet][Type.P2SH]:
+        return { format: Format.Bitpay, hash, network: UtxoNetwork.Mainnet, type: Type.P2SH };
+
+      default:
+        return;
+    }
+  } catch {
+    return;
+  }
+}
+
+function decodeCashAddress(address: string) {
+  if (address.indexOf(":") !== -1) {
+    try {
+      return decodeCashAddressWithPrefix(address);
+    } catch {
+      // Try to decode as legacy if cashaddr decoding fails.
+    }
+  } else {
+    const prefixes = ["bitcoincash", "bchtest", "bchreg"];
+    for (const prefix of prefixes) {
+      try {
+        return decodeCashAddressWithPrefix(`${prefix}:${address}`);
+      } catch {
+        // Try next prefix if decoding fails.
+      }
+    }
+  }
+
+  return;
+}
+
+function decodeCashAddressWithPrefix(address: string) {
+  try {
+    const { hash, prefix, type } = cashaddr.decode(address);
+
+    return {
+      format: Format.Cashaddr,
+      hash: Array.prototype.slice.call(hash, 0),
+      network: prefix === "bitcoincash" ? UtxoNetwork.Mainnet : UtxoNetwork.Testnet,
+      type: type === "P2PKH" ? Type.P2PKH : Type.P2SH,
+    };
+  } catch {
+    return;
+  }
+}
+
+function encodeAsLegacy(decoded: DecodedType) {
+  const versionByte = VERSION_BYTE[Format.Legacy][decoded.network][decoded.type];
+  const buffer = Buffer.alloc(1 + decoded.hash.length);
+  buffer[0] = versionByte;
+  buffer.set(decoded.hash, 1);
+  return base58check.encode(buffer);
+}
+
+function encodeAsCashaddr(decoded: DecodedType) {
+  const prefix = decoded.network === UtxoNetwork.Mainnet ? "bitcoincash" : "bchtest";
+  const type = decoded.type === Type.P2PKH ? "P2PKH" : "P2SH";
+  const hash = new Uint8Array(decoded.hash);
+  return cashaddr.encode(prefix, type, hash);
+}
+
+export { detectAddressNetwork, isValidAddress, UtxoNetwork, toCashAddress, toLegacyAddress };

package/src/utxo/helpers/coinselect.ts

@@ -0,0 +1,96 @@
+/**
+ * Modifications © 2025 Horizontal Systems.
+ */
+
+import { Chain, USwapError, type UTXOChain } from "@tcswap/helpers";
+
+import {
+  calculateTxSize,
+  getInputSize,
+  getOutputSize,
+  getScriptTypeForAddress,
+  TX_OVERHEAD,
+  UTXOScriptType,
+} from "../helpers/txSize";
+import type { TargetOutput, UTXOCalculateTxSizeParams, UTXOType } from "../types";
+
+export function getDustThreshold(chain: UTXOChain) {
+  switch (chain) {
+    case Chain.Bitcoin:
+    case Chain.BitcoinCash:
+      return 550;
+    case Chain.Dash:
+    case Chain.Litecoin:
+      return 5500;
+    case Chain.Dogecoin:
+      return 100000;
+    case Chain.Zcash:
+      return 546;
+    default:
+      throw new USwapError("toolbox_utxo_not_supported", { chain });
+  }
+}
+
+export function accumulative({
+  inputs,
+  outputs,
+  feeRate: initialFeeRate = 1,
+  chain = Chain.Bitcoin,
+  changeAddress = "",
+}: UTXOCalculateTxSizeParams & { outputs: TargetOutput[]; chain: UTXOChain; changeAddress?: string }) {
+  const feeRate = Math.ceil(initialFeeRate);
+
+  const newTxType =
+    inputs[0] && "address" in inputs[0] && inputs[0].address
+      ? getScriptTypeForAddress(inputs[0].address)
+      : UTXOScriptType.P2PKH;
+  // skip input if adding it would cost more than input is worth
+  const filteredInputs = inputs.filter((input) => getInputSize(input) * feeRate <= input.value);
+
+  const txSizeWithoutInputs =
+    TX_OVERHEAD + outputs.reduce((total, output) => total + getOutputSize(output, newTxType), 0);
+
+  const amountToSend = outputs.reduce((total, output) => total + output.value, 0);
+
+  let fees = txSizeWithoutInputs * feeRate;
+  let inputsValue = 0;
+  const inputsToUse: typeof inputs = [];
+
+  for (const input of filteredInputs) {
+    const inputSize = getInputSize(input);
+    const inputFee = feeRate * inputSize;
+
+    fees += inputFee;
+    inputsValue += input.value;
+
+    inputsToUse.push(input);
+
+    const totalCost = fees + amountToSend;
+
+    // we need more inputs
+    if (inputsValue < totalCost) continue;
+
+    const remainder = inputsValue - totalCost;
+
+    const feeForExtraOutput = feeRate * getOutputSize({ address: "", value: 0 }, newTxType);
+
+    // potential change address
+    if (remainder > feeForExtraOutput) {
+      const feeAfterExtraOutput = feeForExtraOutput + fees;
+      const remainderAfterExtraOutput = inputsValue - (amountToSend + feeAfterExtraOutput);
+
+      // is it worth a change output aka can we send it in the future?
+      if (remainderAfterExtraOutput > Math.max(getInputSize({} as UTXOType) * feeRate, getDustThreshold(chain))) {
+        return {
+          fee: feeAfterExtraOutput,
+          inputs: inputsToUse,
+          outputs: outputs.concat({ address: changeAddress, value: remainderAfterExtraOutput }),
+        };
+      }
+    }
+    return { fee: fees, inputs: inputsToUse, outputs };
+  }
+
+  // We don't have enough inputs, let's calculate transaction fee accrude to the last input
+  return { fee: feeRate * calculateTxSize({ feeRate, inputs, outputs }) };
+}

package/src/utxo/helpers/index.ts

@@ -0,0 +1,4 @@
+export * from "./api";
+export * from "./bchaddrjs";
+export * from "./coinselect";
+export * from "./txSize";

package/src/utxo/helpers/txSize.ts

@@ -0,0 +1,141 @@
+/**
+ * Modifications © 2025 Horizontal Systems.
+ */
+
+import { USwapError } from "@tcswap/helpers";
+import { opcodes, script } from "bitcoinjs-lib";
+import type { TargetOutput, UTXOCalculateTxSizeParams, UTXOInputWithScriptType, UTXOType } from "../types";
+
+/**
+ * Minimum transaction fee
+ * 1000 satoshi/kB (similar to current `minrelaytxfee`)
+ * @see https://github.com/bitcoin/bitcoin/blob/db88db47278d2e7208c50d16ab10cb355067d071/src/validation.h#L56
+ */
+export const MIN_TX_FEE = 1000;
+export const TX_OVERHEAD = 4 + 1 + 1 + 4; //10
+export const OP_RETURN_OVERHEAD = 1 + 8 + 1; //10
+const TX_INPUT_BASE = 32 + 4 + 1 + 4; // 41
+const TX_INPUT_PUBKEYHASH = 107;
+
+export function compileMemo(memo: string) {
+  const data = Buffer.from(memo, "utf8"); // converts MEMO to buffer
+  return script.compile([opcodes.OP_RETURN as number, data]); // Compile OP_RETURN script
+}
+
+export enum UTXOScriptType {
+  P2PKH = "P2PKH", // legacy
+  //   P2SH = 'P2SH', // multisig
+  P2WPKH = "P2WPKH", // bech32 - native segwit
+  //   P2TR = "P2TR", // taproot
+}
+
+export const InputSizes: Record<UTXOScriptType, number> = {
+  [UTXOScriptType.P2PKH]: 148,
+  //   [UTXOScriptType.P2SH]: 91,
+  [UTXOScriptType.P2WPKH]: 68,
+};
+
+export const OutputSizes: Record<UTXOScriptType, number> = {
+  [UTXOScriptType.P2PKH]: 34,
+  //   [UTXOScriptType.P2SH]: 91,
+  [UTXOScriptType.P2WPKH]: 31,
+};
+
+export const getScriptTypeForAddress = (address: string) => {
+  // Native SegWit (Bech32) addresses - P2WPKH
+  // Bitcoin: bc1 (mainnet), tb1 (testnet)
+  // Litecoin: ltc1 (mainnet), tltc1 (testnet)
+  if (
+    address.startsWith("bc1") ||
+    address.startsWith("tb1") ||
+    address.startsWith("ltc1") ||
+    address.startsWith("tltc1")
+  ) {
+    // Note: bc1p/tb1p are Taproot (P2TR) addresses, but we're treating them as P2WPKH for now
+    // since P2TR is not yet implemented
+    return UTXOScriptType.P2WPKH;
+  }
+
+  // P2SH addresses (Pay-to-Script-Hash) - Currently commented out but kept for future use
+  // Bitcoin: 3 (mainnet), 2 (testnet)
+  // Litecoin: M or 2 (mainnet), Q (testnet)
+  // Dash: 7 (mainnet)
+  // if (address.startsWith('3') || address.startsWith('2') ||
+  //     address.startsWith('M') || address.startsWith('Q') ||
+  //     address.startsWith('7')) {
+  //   return UTXOScriptType.P2SH;
+  // }
+
+  // Legacy P2PKH addresses
+  // Bitcoin: 1 (mainnet), m/n (testnet)
+  // Bitcoin Cash: bitcoincash:q (CashAddr format), q (legacy), 1 (legacy)
+  // Litecoin: L (mainnet), m/n (testnet)
+  // Dogecoin: D (mainnet), n (testnet)
+  // Dash: X (mainnet), y (testnet)
+  // Zcash: t1 (transparent mainnet), tm (testnet)
+  if (
+    // Bitcoin legacy
+    address.startsWith("1") ||
+    address.startsWith("m") ||
+    address.startsWith("n") ||
+    // Bitcoin Cash
+    address.startsWith("bitcoincash:q") ||
+    address.startsWith("bitcoincash:p") ||
+    address.startsWith("q") ||
+    address.startsWith("p") ||
+    // Litecoin legacy (also uses 3 for P2SH but treating as P2PKH for now)
+    address.startsWith("L") ||
+    address.startsWith("M") ||
+    address.startsWith("3") ||
+    // Dogecoin
+    address.startsWith("D") ||
+    address.startsWith("A") ||
+    address.startsWith("9") ||
+    // Dash
+    address.startsWith("X") ||
+    address.startsWith("7") ||
+    address.startsWith("y") ||
+    // Zcash transparent addresses
+    address.startsWith("t1") ||
+    address.startsWith("t3") ||
+    address.startsWith("tm")
+  ) {
+    return UTXOScriptType.P2PKH;
+  }
+
+  throw new USwapError("toolbox_utxo_invalid_address", { address });
+};
+
+export const calculateTxSize = ({ inputs, outputs, feeRate }: UTXOCalculateTxSizeParams) => {
+  const newTxType =
+    inputs[0] && "address" in inputs[0] && inputs[0].address
+      ? getScriptTypeForAddress(inputs[0].address)
+      : UTXOScriptType.P2PKH;
+  const inputSize = inputs
+    .filter((utxo) => utxo.value >= InputSizes["type" in utxo ? utxo.type : UTXOScriptType.P2PKH] * Math.ceil(feeRate))
+    .reduce((total, utxo) => total + getInputSize(utxo), 0);
+
+  const outputSize = outputs?.reduce((total, output) => total + getOutputSize(output), 0) || OutputSizes[newTxType];
+
+  return TX_OVERHEAD + inputSize + outputSize;
+};
+
+export const getInputSize = (input: UTXOInputWithScriptType | UTXOType) => {
+  if ("type" in input) {
+    return InputSizes[input.type];
+  }
+  if ("address" in input && input.address) {
+    return InputSizes[getScriptTypeForAddress(input.address as string)];
+  }
+  return TX_INPUT_BASE + TX_INPUT_PUBKEYHASH;
+};
+
+export const getOutputSize = (output: TargetOutput, scriptType?: UTXOScriptType) => {
+  if (output?.script) {
+    return OP_RETURN_OVERHEAD + output.script.length + (output.script.length >= 74 ? 2 : 1);
+  }
+  if (scriptType) {
+    return OutputSizes[scriptType];
+  }
+  return OutputSizes[UTXOScriptType.P2PKH];
+};

package/src/utxo/index.ts

@@ -0,0 +1,6 @@
+export * from "./helpers";
+export * from "./toolbox";
+export * from "./toolbox/bitcoinCash";
+export * from "./toolbox/utxo";
+export * from "./toolbox/zcash";
+export * from "./types";

package/src/utxo/toolbox/bitcoinCash.ts

@@ -0,0 +1,247 @@
+/**
+ * Modifications © 2025 Horizontal Systems.
+ */
+
+import {
+  address as bchAddress,
+  Transaction,
+  TransactionBuilder,
+  // @ts-expect-error
+} from "@psf/bitcoincashjs-lib";
+import {
+  Chain,
+  type ChainSigner,
+  type DerivationPathArray,
+  derivationPathToString,
+  FeeOption,
+  NetworkDerivationPath,
+  USwapError,
+  updateDerivationPath,
+} from "@tcswap/helpers";
+import { Psbt } from "bitcoinjs-lib";
+import { accumulative, compileMemo, getUtxoApi, getUtxoNetwork, toCashAddress, toLegacyAddress } from "../helpers";
+import type {
+  BchECPair,
+  TargetOutput,
+  TransactionBuilderType,
+  TransactionType,
+  UTXOBuildTxParams,
+  UTXOTransferParams,
+  UTXOType,
+} from "../types";
+import type { UtxoToolboxParams } from "./params";
+import { createUTXOToolbox, getCreateKeysForPath } from "./utxo";
+import { bchValidateAddress, stripPrefix } from "./validators";
+
+const chain = Chain.BitcoinCash;
+
+export function stripToCashAddress(address: string) {
+  return stripPrefix(toCashAddress(address));
+}
+
+function createSignerWithKeys(keys: BchECPair) {
+  function signTransaction({ builder, utxos }: { builder: TransactionBuilderType; utxos: UTXOType[] }) {
+    utxos.forEach((utxo, index) => {
+      builder.sign(index, keys, undefined, 0x41, utxo.witnessUtxo?.value);
+    });
+
+    return builder.build();
+  }
+
+  const getAddress = () => {
+    const address = keys.getAddress(0);
+    return Promise.resolve(stripToCashAddress(address));
+  };
+
+  return { getAddress, signTransaction };
+}
+
+export async function createBCHToolbox<T extends typeof Chain.BitcoinCash>(
+  toolboxParams: UtxoToolboxParams[T] | { phrase?: string; derivationPath?: DerivationPathArray; index?: number },
+) {
+  const phrase = "phrase" in toolboxParams ? toolboxParams.phrase : undefined;
+
+  const index = "index" in toolboxParams ? toolboxParams.index || 0 : 0;
+
+  const derivationPath = derivationPathToString(
+    "derivationPath" in toolboxParams && toolboxParams.derivationPath
+      ? toolboxParams.derivationPath
+      : updateDerivationPath(NetworkDerivationPath[chain], { index }),
+  );
+
+  const keys = phrase ? (await getCreateKeysForPath(chain))({ derivationPath, phrase }) : undefined;
+
+  const signer = keys ? createSignerWithKeys(keys) : "signer" in toolboxParams ? toolboxParams.signer : undefined;
+
+  function getAddress() {
+    return Promise.resolve(signer?.getAddress());
+  }
+
+  const { getBalance, getFeeRates, broadcastTx, ...toolbox } = await createUTXOToolbox({ chain });
+
+  function handleGetBalance(address: string, _scamFilter = true) {
+    return getBalance(stripPrefix(toCashAddress(address)));
+  }
+
+  return {
+    ...toolbox,
+    broadcastTx,
+    buildTx,
+    createTransaction,
+    getAddress,
+    getAddressFromKeys,
+    getBalance: handleGetBalance,
+    getFeeRates,
+    stripPrefix,
+    stripToCashAddress,
+    transfer: transfer({ broadcastTx, getFeeRates, signer }),
+    validateAddress: bchValidateAddress,
+  };
+}
+
+async function createTransaction({ assetValue, recipient, memo, feeRate, sender }: UTXOBuildTxParams) {
+  if (!bchValidateAddress(recipient)) throw new USwapError("toolbox_utxo_invalid_address", { address: recipient });
+
+  // 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;
+
+  const targetOutputs: TargetOutput[] = [];
+  // output to recipient
+  targetOutputs.push({ address: recipient, value: assetValue.getBaseValue("number") });
+  const { inputs, outputs } = accumulative({ chain, feeRate, inputs: utxos, outputs: targetOutputs });
+
+  // .inputs and .outputs will be undefined if no solution was found
+  if (!(inputs && outputs)) throw new USwapError("toolbox_utxo_insufficient_balance", { assetValue, sender });
+  const getNetwork = await getUtxoNetwork();
+  const builder = new TransactionBuilder(getNetwork(chain)) as TransactionBuilderType;
+
+  await Promise.all(
+    inputs.map(async (utxo: UTXOType) => {
+      const txHex = await getUtxoApi(chain).getRawTx(utxo.hash);
+
+      builder.addInput(Transaction.fromBuffer(Buffer.from(txHex, "hex")), utxo.index);
+    }),
+  );
+
+  for (const output of outputs) {
+    const address = "address" in output && output.address ? output.address : toLegacyAddress(sender);
+    const getNetwork = await getUtxoNetwork();
+    const outputScript = bchAddress.toOutputScript(toLegacyAddress(address), getNetwork(chain));
+
+    builder.addOutput(outputScript, output.value);
+  }
+
+  // add output for memo
+  if (compiledMemo) {
+    builder.addOutput(compiledMemo, 0); // Add OP_RETURN {script, value}
+  }
+
+  return { builder, utxos: inputs };
+}
+
+function transfer({
+  broadcastTx,
+  getFeeRates,
+  signer,
+}: {
+  broadcastTx: (txHash: string) => Promise<string>;
+  getFeeRates: () => Promise<Record<FeeOption, number>>;
+  signer?: ChainSigner<{ builder: TransactionBuilderType; utxos: UTXOType[] }, TransactionType>;
+}) {
+  return async function transfer({
+    recipient,
+    assetValue,
+    feeOptionKey = FeeOption.Fast,
+    ...rest
+  }: UTXOTransferParams) {
+    const from = await signer?.getAddress();
+    if (!(signer && from)) throw new USwapError("toolbox_utxo_no_signer");
+    if (!recipient)
+      throw new USwapError("toolbox_utxo_invalid_params", { error: "Recipient address must be provided" });
+
+    const feeRate = rest.feeRate || (await getFeeRates())[feeOptionKey];
+
+    // try out if psbt tx is faster/better/nicer
+    const { builder, utxos } = await createTransaction({ ...rest, assetValue, feeRate, recipient, sender: from });
+
+    const tx = await signer.signTransaction({ builder, utxos });
+    const txHex = tx.toHex();
+
+    return broadcastTx(txHex);
+  };
+}
+
+async function buildTx({
+  assetValue,
+  recipient,
+  memo,
+  feeRate,
+  sender,
+  setSigHashType,
+}: UTXOBuildTxParams & { setSigHashType?: boolean }) {
+  const recipientCashAddress = toCashAddress(recipient);
+  if (!bchValidateAddress(recipientCashAddress))
+    throw new USwapError("toolbox_utxo_invalid_address", { address: recipientCashAddress });
+
+  // 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: false,
+    targetValue,
+  });
+
+  const feeRateWhole = Number(feeRate.toFixed(0));
+  const compiledMemo = memo ? await compileMemo(memo) : null;
+
+  const targetOutputs = [] as TargetOutput[];
+
+  // output to recipient
+  targetOutputs.push({ address: toLegacyAddress(recipient), value: assetValue.getBaseValue("number") });
+
+  //2. add output memo to targets (optional)
+  if (compiledMemo) {
+    targetOutputs.push({ script: compiledMemo, value: 0 });
+  }
+
+  const { inputs, outputs } = accumulative({ chain, feeRate: feeRateWhole, inputs: utxos, outputs: targetOutputs });
+
+  // .inputs and .outputs will be undefined if no solution was found
+  if (!(inputs && outputs)) throw new USwapError("toolbox_utxo_insufficient_balance", { assetValue, sender });
+  const getNetwork = await getUtxoNetwork();
+  const psbt = new Psbt({ network: getNetwork(chain) }); // Network-specific
+
+  for (const { hash, index, witnessUtxo } of inputs) {
+    psbt.addInput({ hash, index, sighashType: setSigHashType ? 0x41 : undefined, witnessUtxo });
+  }
+
+  // Outputs
+  for (const output of outputs) {
+    const address = "address" in output && output.address ? output.address : toLegacyAddress(sender);
+    const params = output.script
+      ? compiledMemo
+        ? { script: compiledMemo, value: 0 }
+        : undefined
+      : { address, value: output.value };
+
+    if (params) {
+      psbt.addOutput(params);
+    }
+  }
+
+  return { inputs: inputs as UTXOType[], psbt, utxos };
+}
+
+function getAddressFromKeys(keys: { getAddress: (index?: number) => string }) {
+  const address = keys.getAddress(0);
+  return stripToCashAddress(address);
+}