@swapkit/toolboxes 0.0.0-nightly-20250304130539

package/src/utxo/helpers/coinselect.ts

@@ -0,0 +1,96 @@
+import { Chain, type UTXOChain } from "@swapkit/helpers";
+
+import {
+  TX_OVERHEAD,
+  UTXOScriptType,
+  calculateTxSize,
+  getInputSize,
+  getOutputSize,
+  getScriptTypeForAddress,
+} from "../helpers";
+import type { TargetOutput, UTXOCalculateTxSizeParams, UTXOType } from "../types";
+
+export const 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;
+    default:
+      throw new Error("Invalid Chain");
+  }
+};
+
+export const accumulative = ({
+  inputs,
+  outputs,
+  feeRate: initialFeeRate = 1,
+  chain = Chain.Bitcoin,
+}: UTXOCalculateTxSizeParams & { outputs: TargetOutput[]; chain: UTXOChain }) => {
+  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 {
+          inputs: inputsToUse,
+          outputs: outputs.concat({ value: remainderAfterExtraOutput, address: "" }),
+          fee: feeAfterExtraOutput,
+        };
+      }
+    }
+    return {
+      inputs: inputsToUse,
+      outputs,
+      fee: fees,
+    };
+  }
+
+  // We don't have enough inputs, let's calculate transaction fee accrude to the last input
+  return { fee: feeRate * calculateTxSize({ inputs, outputs, feeRate }) };
+};

package/src/utxo/helpers/index.ts

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

package/src/utxo/helpers/txSize.ts

@@ -0,0 +1,103 @@
+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 async function compileMemo(memo: string) {
+  const { script, opcodes } = await import("bitcoinjs-lib");
+  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) => {
+  if (address.startsWith("bc1") || address.startsWith("ltc1")) {
+    return UTXOScriptType.P2WPKH;
+  }
+  //   if (address.startsWith('3') || address.startsWith('M')) {
+  //     return UTXOScriptType.P2SH;
+  //   }
+  if (
+    address.startsWith("1") ||
+    address.startsWith("3") ||
+    address.startsWith("L") ||
+    address.startsWith("M") ||
+    address.startsWith("X") ||
+    address.startsWith("D") ||
+    address.startsWith("bitcoincash:q") ||
+    address.startsWith("q")
+  ) {
+    return UTXOScriptType.P2PKH;
+  }
+  throw new Error("Invalid 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/helpers/utils.ts

@@ -0,0 +1,48 @@
+import { Chain, FeeOption } from "@swapkit/helpers";
+
+const pid = typeof process !== "undefined" && process.pid ? process.pid.toString(36) : "";
+
+export async function getUtxoNetwork() {
+  // @ts-ignore TODO: check why wallets doesn't see modules included in toolbox
+  const { coininfo } = await import("coininfo");
+  const { networks } = await import("bitcoinjs-lib");
+
+  return function getNetwork(chain: Chain) {
+    switch (chain) {
+      case Chain.Bitcoin:
+        return networks.bitcoin;
+      case Chain.BitcoinCash:
+        return coininfo.bitcoincash.main.toBitcoinJS();
+      case Chain.Dash:
+        return coininfo.dash.main.toBitcoinJS();
+      case Chain.Litecoin:
+        return coininfo.litecoin.main.toBitcoinJS();
+
+      case Chain.Dogecoin: {
+        const bip32 = { private: 0x04358394, public: 0x043587cf };
+        const test = coininfo.dogecoin.test;
+        test.versions.bip32 = bip32;
+        return coininfo.dogecoin.main.toBitcoinJS();
+      }
+      default:
+        throw new Error("Invalid chain");
+    }
+  };
+}
+
+export const standardFeeRates = (rate: number) => ({
+  [FeeOption.Average]: rate,
+  [FeeOption.Fast]: rate * 1.5,
+  [FeeOption.Fastest]: rate * 2.0,
+});
+
+let last = 0;
+const now = () => {
+  const time = Date.now();
+  const lastTime = last || time;
+  last = lastTime;
+
+  return time > last ? time : lastTime + 1;
+};
+
+export const uniqid = () => pid + now().toString(36);

package/src/utxo/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Package
+ */
+export * from "./toolbox/index";
+export * from "./toolbox/utxo";
+export * from "./helpers/index";
+export * from "./types";

package/src/utxo/toolbox/bitcoinCash.ts

@@ -0,0 +1,268 @@
+import { Chain, DerivationPath, FeeOption, type UTXOChain } from "@swapkit/helpers";
+
+import {
+  accumulative,
+  Network as bchNetwork,
+  compileMemo,
+  detectAddressNetwork,
+  getUtxoApi,
+  getUtxoNetwork,
+  isValidAddress,
+  toCashAddress,
+  toLegacyAddress,
+} from "../helpers";
+import type {
+  TargetOutput,
+  TransactionType,
+  UTXOBuildTxParams,
+  UTXOType,
+  UTXOWalletTransferParams,
+} from "../types";
+import { createUTXOToolbox } from "./utxo";
+
+const chain = Chain.BitcoinCash as UTXOChain;
+
+export function stripPrefix(address: string) {
+  return address.replace(/(bchtest:|bitcoincash:)/, "");
+}
+
+export function validateAddress(address: string) {
+  const strippedAddress = stripPrefix(address);
+  return (
+    isValidAddress(strippedAddress) && detectAddressNetwork(strippedAddress) === bchNetwork.Mainnet
+  );
+}
+
+export function stripToCashAddress(address: string) {
+  return stripPrefix(toCashAddress(address));
+}
+
+export async function createBCHToolbox() {
+  const { getBalance, getFeeRates, broadcastTx, ...toolbox } = (
+    await createUTXOToolbox(Chain.BitcoinCash)
+  )();
+
+  function handleGetBalance(address: string, _scamFilter = true) {
+    return getBalance(stripPrefix(toCashAddress(address)));
+  }
+
+  return function createBCHToolbox() {
+    return {
+      ...toolbox,
+      broadcastTx,
+      buildBCHTx,
+      buildTx,
+      createKeysForPath,
+      getAddressFromKeys,
+      getBalance: handleGetBalance,
+      getFeeRates,
+      stripPrefix,
+      stripToCashAddress,
+      validateAddress,
+      transfer: transfer({ getFeeRates, broadcastTx }),
+    };
+  };
+}
+
+async function buildBCHTx({ assetValue, recipient, memo, feeRate, sender }: UTXOBuildTxParams) {
+  const {
+    Transaction,
+    TransactionBuilder,
+    address: bchAddress,
+    // @ts-ignore TODO: check why wallets doesn't see modules included in toolbox
+  } = await import("@psf/bitcoincashjs-lib");
+  if (!validateAddress(recipient)) throw new Error("Invalid address");
+  const utxos = await getUtxoApi(chain).scanUTXOs({
+    address: stripToCashAddress(sender),
+    fetchTxHex: true,
+  });
+
+  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({
+    inputs: utxos,
+    outputs: targetOutputs,
+    feeRate,
+    chain,
+  });
+
+  // .inputs and .outputs will be undefined if no solution was found
+  if (!(inputs && outputs)) throw new Error("Balance insufficient for transaction");
+  const getNetwork = await getUtxoNetwork();
+  const builder = new TransactionBuilder(getNetwork(chain));
+
+  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,
+}: {
+  broadcastTx: (txHash: string) => Promise<string>;
+  getFeeRates: () => Promise<Record<FeeOption, number>>;
+}) {
+  return async function transfer({
+    signTransaction,
+    from,
+    recipient,
+    assetValue,
+    ...rest
+  }: UTXOWalletTransferParams<
+    { builder: TransactionBuilderType; utxos: UTXOType[] },
+    TransactionType
+  >) {
+    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("signTransaction must be provided");
+
+    const feeRate = rest.feeRate || (await getFeeRates())[FeeOption.Fast];
+
+    // try out if psbt tx is faster/better/nicer
+    const { builder, utxos } = await buildBCHTx({
+      ...rest,
+      assetValue,
+      feeRate,
+      recipient,
+      sender: from,
+    });
+
+    const tx = await signTransaction({ builder, utxos });
+    const txHex = tx.toHex();
+
+    return broadcastTx(txHex);
+  };
+}
+
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: TODO: refactor
+async function buildTx({ assetValue, recipient, memo, feeRate, sender }: UTXOBuildTxParams) {
+  const { Psbt } = await import("bitcoinjs-lib");
+  const recipientCashAddress = toCashAddress(recipient);
+  if (!validateAddress(recipientCashAddress)) throw new Error("Invalid address");
+
+  const utxos = await getUtxoApi(chain).scanUTXOs({
+    address: stripToCashAddress(sender),
+    fetchTxHex: true,
+  });
+
+  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({
+    inputs: utxos,
+    outputs: targetOutputs,
+    feeRate: feeRateWhole,
+    chain,
+  });
+
+  // .inputs and .outputs will be undefined if no solution was found
+  if (!(inputs && outputs)) throw new Error("Balance insufficient for transaction");
+  const getNetwork = await getUtxoNetwork();
+  const psbt = new Psbt({ network: getNetwork(chain) }); // Network-specific
+
+  for (const { hash, index, witnessUtxo } of inputs) {
+    psbt.addInput({ hash, index, 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 { psbt, utxos, inputs: inputs as UTXOType[] };
+}
+
+async function createKeysForPath({
+  phrase,
+  derivationPath = `${DerivationPath.BCH}/0`,
+  wif,
+}: { wif?: string; phrase?: string; derivationPath?: string }) {
+  const { ECPairFactory } = await import("ecpair");
+  const secp256k1 = await import("@bitcoinerlab/secp256k1");
+  const { mnemonicToSeedSync } = await import("@scure/bip39");
+  // @ts-ignore TODO: check why wallets doesn't see modules included in toolbox
+  const { HDNode } = await import("@psf/bitcoincashjs-lib");
+  const getNetwork = await getUtxoNetwork();
+
+  const network = getNetwork(chain);
+
+  if (wif) {
+    return ECPairFactory(secp256k1).fromWIF(wif, network);
+  }
+  if (!phrase) throw new Error("No phrase provided");
+
+  const masterHDNode = HDNode.fromSeedBuffer(Buffer.from(mnemonicToSeedSync(phrase)), network);
+  const keyPair = masterHDNode.derivePath(derivationPath).keyPair;
+  // TODO: Figure out same pattern as in BTC
+  // const testWif = keyPair.toWIF();
+  // const k = ECPairFactory(secp256k1).fromWIF(testWif, network);
+  // const a = payments.p2pkh({ pubkey: k.publicKey, network });
+
+  return keyPair;
+}
+
+function getAddressFromKeys(keys: { getAddress: (index?: number) => string }) {
+  const address = keys.getAddress(0);
+  return stripToCashAddress(address);
+}
+
+type TransactionBuilderType = {
+  inputs: any[];
+  sign(
+    vin: number,
+    keyPair: { getAddress: (index?: number) => string },
+    redeemScript?: Buffer,
+    hashType?: number,
+    witnessValue?: number,
+    witnessScript?: Buffer,
+    signatureAlgorithm?: string,
+  ): void;
+  build(): TransactionType;
+};

package/src/utxo/toolbox/index.ts

@@ -0,0 +1,41 @@
+import { Chain, type UTXOChain } from "@swapkit/helpers";
+
+import { createBCHToolbox } from "./bitcoinCash";
+import { createUTXOToolbox } from "./utxo";
+
+type BCHToolbox = Awaited<ReturnType<typeof createBCHToolbox>>;
+type CommonUTXOToolbox = Awaited<ReturnType<typeof createUTXOToolbox>>;
+
+type UTXOToolboxes = {
+  [Chain.BitcoinCash]: BCHToolbox;
+  [Chain.Bitcoin]: CommonUTXOToolbox;
+  [Chain.Dogecoin]: CommonUTXOToolbox;
+  [Chain.Litecoin]: CommonUTXOToolbox;
+  [Chain.Dash]: CommonUTXOToolbox;
+};
+
+export type UTXOWallets = {
+  [key in keyof UTXOToolboxes]: ReturnType<UTXOToolboxes[key]>;
+};
+
+export async function getToolboxByChain<T extends UTXOChain>(chain: T): Promise<UTXOToolboxes[T]> {
+  switch (chain) {
+    case Chain.BitcoinCash: {
+      const toolbox = await createBCHToolbox();
+      return toolbox as UTXOToolboxes[T];
+    }
+
+    case Chain.Bitcoin:
+    case Chain.Dogecoin:
+    case Chain.Litecoin:
+    case Chain.Dash: {
+      const toolbox = await createUTXOToolbox(chain);
+      return toolbox as UTXOToolboxes[T];
+    }
+
+    default:
+      throw new Error(`Chain ${chain} is not supported`);
+  }
+}
+
+export { stripToCashAddress, stripPrefix, validateAddress } from "./bitcoinCash";