@swapkit/toolboxes 1.0.0-beta.0 → 1.0.0-beta.10

package/src/utxo/toolbox/utxo.ts

@@ -1,17 +1,20 @@
-import * as secp256k1 from "@bitcoinerlab/secp256k1";
-import { HDKey } from "@scure/bip32";
-import { mnemonicToSeedSync } from "@scure/bip39";
 import {
   AssetValue,
-  BaseDecimal,
   Chain,
+  type ChainSigner,
+  DerivationPath,
+  type DerivationPathArray,
   FeeOption,
+  NetworkDerivationPath,
   SwapKitNumber,
   type UTXOChain,
+  derivationPathToString,
+  updateDerivationPath,
 } from "@swapkit/helpers";
-import { Psbt, address as btcLibAddress, initEccLib, payments } from "bitcoinjs-lib";
+import type { Psbt } from "bitcoinjs-lib";
 import type { ECPairInterface } from "ecpair";
-
+import type { UtxoToolboxParams } from ".";
+import { getBalance } from "../../utils";
 import {
   UTXOScriptType,
   accumulative,
@@ -19,227 +22,249 @@ import {
   compileMemo,
   getDustThreshold,
   getInputSize,
-  getNetwork,
   getUtxoApi,
-  standardFeeRates,
+  getUtxoNetwork,
 } from "../helpers";
-import type { TargetOutput, UTXOBuildTxParams, UTXOType, UTXOWalletTransferParams } from "../types";
-import { validateAddress as validateBCHAddress } from "./bitcoinCash";
-import type { BCHToolbox, BTCToolbox, DASHToolbox, DOGEToolbox, LTCToolbox } from "./index";
+import type {
+  BchECPair,
+  TargetOutput,
+  UTXOBuildTxParams,
+  UTXOTransferParams,
+  UTXOType,
+} from "../types";
+import { bchValidateAddress } from "./bitcoinCash";
 
 export const nonSegwitChains = [Chain.Dash, Chain.Dogecoin];
 
-async function createKeysForPath({
-  phrase,
-  wif,
-  derivationPath,
+async function addInputsAndOutputs({
+  inputs,
+  outputs,
   chain,
-}: { phrase?: string; wif?: string; derivationPath: string; chain: Chain }) {
-  const { ECPairFactory } = await import("ecpair");
-  if (!(wif || phrase)) throw new Error("Either phrase or wif must be provided");
+  psbt,
+  sender,
+  compiledMemo,
+}: {
+  inputs: UTXOType[];
+  outputs: TargetOutput[];
+  chain: UTXOChain;
+  psbt: Psbt;
+  sender: string;
+  compiledMemo: Buffer<ArrayBufferLike> | null;
+}) {
+  for (const utxo of inputs) {
+    const witnessInfo = !!utxo.witnessUtxo &&
+      !nonSegwitChains.includes(chain) && { witnessUtxo: utxo.witnessUtxo };
+
+    const nonWitnessInfo = nonSegwitChains.includes(chain) && {
+      nonWitnessUtxo: utxo.txHex ? Buffer.from(utxo.txHex, "hex") : undefined,
+    };
 
-  const factory = ECPairFactory(secp256k1);
-  const network = getNetwork(chain);
+    psbt.addInput({ hash: utxo.hash, index: utxo.index, ...witnessInfo, ...nonWitnessInfo });
+  }
 
-  if (wif) return factory.fromWIF(wif, network);
+  const { initEccLib } = (await import("bitcoinjs-lib")).default;
+  const secp256k1 = (await import("@bitcoinerlab/secp256k1")).default;
 
-  const seed = mnemonicToSeedSync(phrase as string);
-  const master = HDKey.fromMasterSeed(seed, network).derive(derivationPath);
-  if (!master.privateKey) throw new Error("Could not get private key from phrase");
+  for (const output of outputs) {
+    const address = "address" in output && output.address ? output.address : sender;
+    const hasOutputScript = output.script;
 
-  return factory.fromPrivateKey(Buffer.from(master.privateKey), { network });
-}
+    if (hasOutputScript && !compiledMemo) {
+      continue;
+    }
+
+    const mappedOutput = hasOutputScript
+      ? {
+          script: compiledMemo as Buffer<ArrayBufferLike>,
+          value: 0,
+        }
+      : {
+          address,
+          value: output.value,
+        };
 
-function validateAddress({ address, chain }: { address: string; chain: UTXOChain }) {
-  try {
     initEccLib(secp256k1);
-    btcLibAddress.toOutputScript(address, getNetwork(chain));
-    return true;
-  } catch (_error) {
-    return false;
+    psbt.addOutput(mappedOutput);
   }
-}
 
-function getAddressFromKeys({ keys, chain }: { chain: UTXOChain; keys: ECPairInterface }) {
-  if (!keys) throw new Error("Keys must be provided");
-
-  const method = nonSegwitChains.includes(chain) ? payments.p2pkh : payments.p2wpkh;
-  const { address } = method({ pubkey: keys.publicKey, network: getNetwork(chain) });
-  if (!address) throw new Error("Address not defined");
-
-  return address;
+  return { psbt, inputs };
 }
 
-function transfer(chain: UTXOChain) {
-  return async function transfer({
-    signTransaction,
-    from,
-    memo,
-    recipient,
-    feeOptionKey,
-    broadcastTx,
-    feeRate,
+async function createTransaction({
+  assetValue,
+  recipient,
+  memo,
+  feeRate,
+  sender,
+  fetchTxHex = false,
+}: UTXOBuildTxParams): Promise<{
+  psbt: Psbt;
+  utxos: UTXOType[];
+  inputs: UTXOType[];
+}> {
+  const chain = assetValue.chain as UTXOChain;
+
+  const { Psbt } = (await import("bitcoinjs-lib")).default;
+  const compiledMemo = memo ? await compileMemo(memo) : null;
+
+  const inputsAndOutputs = await getInputsAndTargetOutputs({
     assetValue,
-  }: UTXOWalletTransferParams<Psbt, Psbt>) {
-    if (!from) throw new Error("From address must be provided");
-    if (!recipient) throw new Error("Recipient address must be provided");
-    if (!signTransaction) throw new Error("Sign transaction must be provided");
-    const txFeeRate = feeRate || (await getFeeRates(chain))[feeOptionKey || FeeOption.Fast];
+    recipient,
+    memo,
+    sender,
+    fetchTxHex,
+  });
 
-    const { psbt } = await buildTx(chain)({
-      recipient,
-      feeRate: txFeeRate,
-      sender: from,
-      fetchTxHex: nonSegwitChains.includes(chain),
-      assetValue,
-      memo,
-    });
-    const signedPsbt = await signTransaction(psbt);
-    signedPsbt.finalizeAllInputs(); // Finalise inputs
-    // TX extracted and formatted to hex
-    return broadcastTx(signedPsbt.extractTransaction().toHex());
-  };
-}
+  const { inputs, outputs } = accumulative({ ...inputsAndOutputs, feeRate, chain });
 
-const getBalance = async ({ address, chain }: { address: string; chain: UTXOChain }) => {
-  const baseBalance = await getUtxoApi(chain).getBalance(address);
-  const balance = SwapKitNumber.fromBigInt(BigInt(baseBalance), BaseDecimal[chain]).getValue(
-    "string",
-  );
-  const asset = AssetValue.from({ asset: `${chain}.${chain}`, value: balance });
+  // .inputs and .outputs will be undefined if no solution was found
+  if (!(inputs && outputs)) throw new Error("Insufficient Balance for transaction");
+  const getNetwork = await getUtxoNetwork();
+  const psbt = new Psbt({ network: getNetwork(chain) });
 
-  return [asset];
-};
+  if (chain === Chain.Dogecoin) psbt.setMaximumFeeRate(650000000);
 
-async function getFeeRates(chain: UTXOChain) {
-  const suggestedFeeRate = await getUtxoApi(chain).getSuggestedTxFee();
+  const { psbt: mappedPsbt, inputs: mappedInputs } = await addInputsAndOutputs({
+    inputs,
+    outputs,
+    chain,
+    psbt,
+    sender,
+    compiledMemo,
+  });
 
-  return standardFeeRates(suggestedFeeRate);
+  return {
+    psbt: mappedPsbt,
+    utxos: inputsAndOutputs.inputs,
+    inputs: mappedInputs,
+  };
 }
 
-function getInputsAndTargetOutputs(chain: UTXOChain) {
-  return async function getInputsAndTargetOutputs({
-    assetValue,
-    recipient,
-    memo,
-    sender,
-    fetchTxHex = false,
-  }: {
-    assetValue: AssetValue;
-    recipient: string;
-    memo?: string;
-    sender: string;
-    fetchTxHex?: boolean;
-  }) {
-    const inputs = await getUtxoApi(chain).scanUTXOs({ address: sender, fetchTxHex });
+export async function getUTXOAddressValidator() {
+  const secp256k1 = (await import("@bitcoinerlab/secp256k1")).default;
+  const { initEccLib, address: btcLibAddress } = (await import("bitcoinjs-lib")).default;
+  const getNetwork = await getUtxoNetwork();
 
-    //1. add output amount and recipient to targets
-    //2. add output memo to targets (optional)
+  return function validateAddress({ address, chain }: { address: string; chain: UTXOChain }) {
+    if (chain === Chain.BitcoinCash) {
+      return bchValidateAddress(address);
+    }
 
-    return {
-      inputs,
-      outputs: [
-        { address: recipient, value: Number(assetValue.bigIntValue) },
-        ...(memo ? [{ address: "", script: compileMemo(memo), value: 0 }] : []),
-      ],
-    };
+    try {
+      initEccLib(secp256k1);
+      btcLibAddress.toOutputScript(address, getNetwork(chain));
+      return true;
+    } catch (_error) {
+      return false;
+    }
   };
 }
 
-export function buildTx(chain: UTXOChain) {
-  // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: TODO: refactor
-  return async function buildTx({
-    assetValue,
-    recipient,
-    memo,
-    feeRate,
-    sender,
-    fetchTxHex = false,
-  }: UTXOBuildTxParams): Promise<{
-    psbt: Psbt;
-    utxos: UTXOType[];
-    inputs: UTXOType[];
-  }> {
-    const compiledMemo = memo ? compileMemo(memo) : null;
-    const getInputsAndOutputs = getInputsAndTargetOutputs(chain);
-
-    const inputsAndOutputs = await getInputsAndOutputs({
-      assetValue,
-      recipient,
-      memo,
-      sender,
-      fetchTxHex,
-    });
+async function createSignerWithKeys({
+  chain,
+  phrase,
+  derivationPath,
+}: { chain: UTXOChain; phrase: string; derivationPath: string }) {
+  const keyPair = (await getCreateKeysForPath(chain as Chain.Bitcoin))({ phrase, derivationPath });
 
-    const { inputs, outputs } = accumulative({ ...inputsAndOutputs, feeRate, chain });
+  async function signTransaction(psbt: Psbt) {
+    await psbt.signAllInputs(keyPair);
+    return psbt;
+  }
 
-    // .inputs and .outputs will be undefined if no solution was found
-    if (!(inputs && outputs)) throw new Error("Insufficient Balance for transaction");
-    const psbt = new Psbt({ network: getNetwork(chain) });
+  async function getAddress() {
+    const addressGetter = await addressFromKeysGetter(chain);
+    return addressGetter(keyPair);
+  }
 
-    if (chain === Chain.Dogecoin) psbt.setMaximumFeeRate(650000000);
+  return {
+    getAddress,
+    signTransaction,
+  };
+}
 
-    for (const utxo of inputs) {
-      psbt.addInput({
-        hash: utxo.hash,
-        index: utxo.index,
-        ...(!!utxo.witnessUtxo &&
-          !nonSegwitChains.includes(chain) && { witnessUtxo: utxo.witnessUtxo }),
-        ...(nonSegwitChains.includes(chain) && {
-          nonWitnessUtxo: utxo.txHex ? Buffer.from(utxo.txHex, "hex") : undefined,
-        }),
-      });
+export async function createUTXOToolbox<T extends UTXOChain>({
+  chain,
+  ...toolboxParams
+}: (
+  | UtxoToolboxParams[T]
+  | {
+      phrase?: string;
+      derivationPath?: DerivationPathArray;
+      index?: number;
     }
+) & { chain: T }) {
+  const phrase = "phrase" in toolboxParams ? toolboxParams.phrase : undefined;
 
-    for (const output of outputs) {
-      const address = "address" in output && output.address ? output.address : sender;
-      const params = output.script
-        ? compiledMemo
-          ? { script: compiledMemo, value: 0 }
-          : undefined
-        : { address, value: output.value };
-
-      if (params) {
-        initEccLib(secp256k1);
-        psbt.addOutput(params);
-      }
-    }
+  const index = "index" in toolboxParams ? toolboxParams.index || 0 : 0;
+
+  const derivationPath = derivationPathToString(
+    "derivationPath" in toolboxParams && toolboxParams.derivationPath
+      ? toolboxParams.derivationPath
+      : updateDerivationPath(NetworkDerivationPath[chain], { index }),
+  );
+
+  const signer = phrase
+    ? await createSignerWithKeys({ chain, phrase, derivationPath })
+    : "signer" in toolboxParams
+      ? toolboxParams.signer
+      : undefined;
 
-    return { psbt, utxos: inputsAndOutputs.inputs, inputs };
+  function getAddress() {
+    return Promise.resolve(signer?.getAddress());
+  }
+
+  //   const { signer } = params || {};
+  const getAddressFromKeys = await addressFromKeysGetter(chain);
+  const validateAddress = await getUTXOAddressValidator();
+  const createKeysForPath = await getCreateKeysForPath(chain);
+
+  return {
+    accumulative,
+    calculateTxSize,
+    getAddressFromKeys,
+    getAddress,
+    validateAddress: (address: string) => validateAddress({ address, chain }),
+    broadcastTx: (txHash: string) => getUtxoApi(chain).broadcastTx(txHash),
+    createTransaction,
+    createKeysForPath,
+    getFeeRates: () => getFeeRates(chain),
+    getInputsOutputsFee,
+    transfer: transfer(signer as UtxoToolboxParams["BTC"]["signer"]),
+    getPrivateKeyFromMnemonic: (params: { phrase: string; derivationPath: string }) => {
+      const keys = createKeysForPath(params);
+      return keys.toWIF();
+    },
+
+    getBalance: getBalance(chain),
+    estimateTransactionFee: estimateTransactionFee(chain),
+    estimateMaxSendableAmount: estimateMaxSendableAmount(chain),
   };
 }
 
-function getInputsOutputsFee(chain: UTXOChain) {
-  return async function getInputsOutputsFee({
+async function getInputsOutputsFee({
+  assetValue,
+  feeOptionKey = FeeOption.Fast,
+  feeRate,
+  memo,
+  sender,
+  recipient,
+}: Omit<UTXOBuildTxParams, "feeRate"> & {
+  feeOptionKey?: FeeOption;
+  feeRate?: number;
+}) {
+  const chain = assetValue.chain as UTXOChain;
+
+  const inputsAndOutputs = await getInputsAndTargetOutputs({
     assetValue,
-    feeOptionKey = FeeOption.Fast,
-    feeRate,
-    fetchTxHex = false,
+    sender,
     memo,
     recipient,
-    from,
-  }: {
-    assetValue: AssetValue;
-    recipient: string;
-    memo?: string;
-    from: string;
-    feeOptionKey?: FeeOption;
-    feeRate?: number;
-    fetchTxHex?: boolean;
-  }) {
-    const getInputsAndOutputs = getInputsAndTargetOutputs(chain);
-    const inputsAndOutputs = await getInputsAndOutputs({
-      assetValue,
-      recipient,
-      memo,
-      sender: from,
-      fetchTxHex,
-    });
+  });
 
-    const feeRateWhole = feeRate ? Math.floor(feeRate) : (await getFeeRates(chain))[feeOptionKey];
+  const feeRateWhole = feeRate ? Math.floor(feeRate) : (await getFeeRates(chain))[feeOptionKey];
 
-    return accumulative({ ...inputsAndOutputs, feeRate: feeRateWhole, chain });
-  };
+  return accumulative({ ...inputsAndOutputs, feeRate: feeRateWhole, chain });
 }
 
 function estimateMaxSendableAmount(chain: UTXOChain) {
@@ -286,8 +311,8 @@ function estimateMaxSendableAmount(chain: UTXOChain) {
         : recipients;
 
     if (memo) {
-      const compiledMemo = compileMemo(memo);
-      outputs.push({ address: from, script: compiledMemo, value: 0 });
+      const script = await compileMemo(memo);
+      outputs.push({ address: from, script, value: 0 });
     }
 
     const txSize = calculateTxSize({ inputs, outputs, feeRate: feeRateWhole });
@@ -298,63 +323,185 @@ function estimateMaxSendableAmount(chain: UTXOChain) {
   };
 }
 
-export const BaseUTXOToolbox = (chain: UTXOChain) => ({
-  accumulative,
-  calculateTxSize,
-  getFeeRates: () => getFeeRates(chain),
-  buildTx: buildTx(chain),
-  transfer: transfer(chain),
-  getInputsOutputsFee: getInputsOutputsFee(chain),
-
-  broadcastTx: (txHash: string) => getUtxoApi(chain).broadcastTx(txHash),
-  getAddressFromKeys: (keys: ECPairInterface) => getAddressFromKeys({ keys, chain }),
-  validateAddress: (address: string) => validateAddress({ address, chain }),
-  createKeysForPath: (params: any) => createKeysForPath({ ...params, chain }),
-
-  getPrivateKeyFromMnemonic: async (params: {
-    phrase: string;
-    derivationPath: string;
-  }) => {
-    const keys = await createKeysForPath({ ...params, chain });
-    return keys.toWIF();
-  },
-
-  getBalance: async (address: string, _potentialScamFilter?: boolean) =>
-    getBalance({ address, chain }),
-
-  estimateTransactionFee: async (params: {
+function estimateTransactionFee(chain: UTXOChain) {
+  return async (params: {
     assetValue: AssetValue;
     recipient: string;
-    from: string;
+    sender: string;
     memo?: string;
     feeOptionKey?: FeeOption;
     feeRate?: number;
     fetchTxHex?: boolean;
   }) => {
-    const getInputsFee = getInputsOutputsFee(chain);
-    const inputFees = await getInputsFee(params);
+    const inputFees = await getInputsOutputsFee(params);
 
     return AssetValue.from({
       chain,
       value: SwapKitNumber.fromBigInt(BigInt(inputFees.fee), 8).getValue("string"),
     });
-  },
+  };
+}
 
-  estimateMaxSendableAmount: async (params: any) => estimateMaxSendableAmount({ ...params, chain }),
-});
+type CreateKeysForPathReturnType = {
+  [Chain.BitcoinCash]: BchECPair;
+  [Chain.Bitcoin]: ECPairInterface;
+  [Chain.Dash]: ECPairInterface;
+  [Chain.Dogecoin]: ECPairInterface;
+  [Chain.Litecoin]: ECPairInterface;
+};
 
-export function utxoValidateAddress({ chain, address }: { chain: UTXOChain; address: string }) {
-  return chain === Chain.BitcoinCash
-    ? validateBCHAddress(address)
-    : validateAddress({ address, chain });
+export async function getCreateKeysForPath<T extends keyof CreateKeysForPathReturnType>(
+  chain: T,
+): Promise<
+  (params: {
+    wif?: string;
+    phrase?: string;
+    derivationPath?: string;
+  }) => CreateKeysForPathReturnType[T]
+> {
+  const { ECPairFactory } = await import("ecpair");
+  const secp256k1 = (await import("@bitcoinerlab/secp256k1")).default;
+  const { HDKey } = await import("@scure/bip32");
+  const { mnemonicToSeedSync } = await import("@scure/bip39");
+  const getNetwork = await getUtxoNetwork();
+  // @ts-ignore
+  const { HDNode, ECPair } = await import("@psf/bitcoincashjs-lib");
+
+  switch (chain) {
+    case Chain.BitcoinCash: {
+      return function createKeysForPath({
+        phrase,
+        derivationPath = `${DerivationPath.BCH}/0`,
+        wif,
+      }: { wif?: string; phrase?: string; derivationPath?: string }) {
+        const network = getNetwork(chain);
+
+        if (wif) {
+          return ECPair.fromWIF(wif, network) as BchECPair;
+        }
+        if (!phrase) throw new Error("No phrase provided");
+
+        const masterHDNode = HDNode.fromSeedBuffer(
+          Buffer.from(mnemonicToSeedSync(phrase)),
+          network,
+        );
+        const keyPair = masterHDNode.derivePath(derivationPath).keyPair;
+
+        return keyPair as BchECPair;
+      } as (params: {
+        wif?: string;
+        phrase?: string;
+        derivationPath?: string;
+      }) => CreateKeysForPathReturnType[T];
+    }
+    case Chain.Bitcoin:
+    case Chain.Dogecoin:
+    case Chain.Litecoin:
+    case Chain.Dash: {
+      return function createKeysForPath({
+        phrase,
+        wif,
+        derivationPath,
+      }: { phrase?: string; wif?: string; derivationPath: string }) {
+        if (!(wif || phrase)) throw new Error("Either phrase or wif must be provided");
+
+        const factory = ECPairFactory(secp256k1);
+        const network = getNetwork(chain);
+
+        if (wif) return factory.fromWIF(wif, network);
+
+        const seed = mnemonicToSeedSync(phrase as string);
+        const master = HDKey.fromMasterSeed(seed, network).derive(derivationPath);
+        if (!master.privateKey) throw new Error("Could not get private key from phrase");
+
+        return factory.fromPrivateKey(Buffer.from(master.privateKey), { network });
+      } as (params: {
+        wif?: string;
+        phrase?: string;
+        derivationPath?: string;
+      }) => CreateKeysForPathReturnType[T];
+    }
+    default:
+      throw new Error(`Chain ${chain} is not supported`);
+  }
 }
 
-export type BaseUTXOWallet = ReturnType<typeof BaseUTXOToolbox>;
-type UTXOWalletType = {
-  [Chain.Bitcoin]: ReturnType<typeof BTCToolbox>;
-  [Chain.BitcoinCash]: ReturnType<typeof BCHToolbox>;
-  [Chain.Dogecoin]: ReturnType<typeof DOGEToolbox>;
-  [Chain.Litecoin]: ReturnType<typeof LTCToolbox>;
-  [Chain.Dash]: ReturnType<typeof DASHToolbox>;
-};
-export type UTXOWallets = { [chain in UTXOChain]: BaseUTXOWallet & UTXOWalletType[chain] };
+export async function addressFromKeysGetter(chain: UTXOChain) {
+  const { payments } = (await import("bitcoinjs-lib")).default;
+  const getNetwork = await getUtxoNetwork();
+
+  return function getAddressFromKeys(keys: ECPairInterface | BchECPair) {
+    if (!keys) throw new Error("Keys must be provided");
+
+    const method = nonSegwitChains.includes(chain) ? payments.p2pkh : payments.p2wpkh;
+    const { address } = method({ pubkey: keys.publicKey as Buffer, network: getNetwork(chain) });
+    if (!address) throw new Error("Address not defined");
+
+    return address;
+  };
+}
+
+function transfer(signer?: ChainSigner<Psbt, Psbt>) {
+  return async function transfer({
+    memo,
+    recipient,
+    feeOptionKey,
+    feeRate,
+    assetValue,
+  }: UTXOTransferParams) {
+    const from = await signer?.getAddress();
+
+    const chain = assetValue.chain as UTXOChain;
+
+    if (!(signer && from)) throw new Error("From address must be provided");
+    if (!recipient) throw new Error("Recipient address must be provided");
+    const txFeeRate = feeRate || (await getFeeRates(chain))[feeOptionKey || FeeOption.Fast];
+
+    const { psbt } = await createTransaction({
+      recipient,
+      feeRate: txFeeRate,
+      sender: from,
+      assetValue,
+      memo,
+    });
+    const signedPsbt = await signer.signTransaction(psbt);
+    signedPsbt.finalizeAllInputs(); // Finalise inputs
+    // TX extracted and formatted to hex
+    return getUtxoApi(chain).broadcastTx(signedPsbt.extractTransaction().toHex());
+  };
+}
+
+async function getFeeRates(chain: UTXOChain) {
+  const suggestedFeeRate = await getUtxoApi(chain).getSuggestedTxFee();
+
+  return {
+    [FeeOption.Average]: suggestedFeeRate,
+    [FeeOption.Fast]: suggestedFeeRate * 1.5,
+    [FeeOption.Fastest]: suggestedFeeRate * 2.0,
+  };
+}
+
+async function getInputsAndTargetOutputs({
+  assetValue,
+  recipient,
+  memo,
+  sender,
+  fetchTxHex: fetchTxOverwrite = false,
+}: Omit<UTXOBuildTxParams, "feeRate">) {
+  const chain = assetValue.chain as UTXOChain;
+
+  const fetchTxHex = fetchTxOverwrite || nonSegwitChains.includes(chain);
+
+  const inputs = await getUtxoApi(chain).scanUTXOs({ address: sender, fetchTxHex });
+
+  //1. add output amount and recipient to targets
+  //2. add output memo to targets (optional)
+
+  return {
+    inputs,
+    outputs: [
+      { address: recipient, value: Number(assetValue.bigIntValue) },
+      ...(memo ? [{ address: "", script: await compileMemo(memo), value: 0 }] : []),
+    ],
+  };
+}