@swapkit/toolboxes 1.0.0-beta.0

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,104 @@
+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 const 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) => {
+  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,45 @@
+import { Chain, FeeOption } from "@swapkit/helpers";
+import { networks } from "bitcoinjs-lib";
+// @ts-ignore TODO: check why wallets doesn't see modules included in toolbox
+import coininfo from "coininfo";
+
+const pid = typeof process !== "undefined" && process.pid ? process.pid.toString(36) : "";
+
+export const 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,9 @@
+export { type Network, networks, Psbt, Transaction } from "bitcoinjs-lib";
+
+/**
+ * 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,281 @@
+import * as secp256k1 from "@bitcoinerlab/secp256k1";
+import {
+  HDNode,
+  Transaction,
+  TransactionBuilder,
+  address as bchAddress,
+  // @ts-ignore TODO: check why wallets doesn't see modules included in toolbox
+} from "@psf/bitcoincashjs-lib";
+import { mnemonicToSeedSync } from "@scure/bip39";
+import { Chain, DerivationPath, FeeOption, type UTXOChain } from "@swapkit/helpers";
+import { Psbt } from "bitcoinjs-lib";
+
+import {
+  accumulative,
+  Network as bchNetwork,
+  compileMemo,
+  detectAddressNetwork,
+  getNetwork,
+  getUtxoApi,
+  isValidAddress,
+  toCashAddress,
+  toLegacyAddress,
+} from "../helpers";
+import type {
+  TargetOutput,
+  TransactionBuilderType,
+  TransactionType,
+  UTXOBuildTxParams,
+  UTXOType,
+  UTXOWalletTransferParams,
+} from "../types";
+
+import { BaseUTXOToolbox } from "./utxo";
+
+// needed because TS can not infer types
+type BCHMethods = {
+  stripPrefix: (address: string) => string;
+  stripToCashAddress: (address: string) => string;
+  validateAddress: (address: string, chain?: UTXOChain) => boolean;
+  createKeysForPath: (params: {
+    wif?: string;
+    phrase?: string;
+    derivationPath?: string;
+  }) => Promise<{ getAddress: (index?: number) => string }>;
+  getAddressFromKeys: (keys: { getAddress: (index?: number) => string }) => string;
+  buildBCHTx: (
+    params: UTXOBuildTxParams,
+  ) => Promise<{ builder: TransactionBuilderType; utxos: UTXOType[] }>;
+  buildTx: (params: UTXOBuildTxParams) => Promise<{ psbt: Psbt }>;
+  transfer: (
+    params: UTXOWalletTransferParams<
+      { builder: TransactionBuilderType; utxos: UTXOType[] },
+      TransactionType
+    >,
+  ) => Promise<string>;
+};
+
+const chain = Chain.BitcoinCash as UTXOChain;
+
+export const stripToCashAddress = (address: string) => stripPrefix(toCashAddress(address));
+
+const buildBCHTx: BCHMethods["buildBCHTx"] = async ({
+  assetValue,
+  recipient,
+  memo,
+  feeRate,
+  sender,
+}) => {
+  if (!validateAddress(recipient)) throw new Error("Invalid address");
+  const utxos = await getUtxoApi(chain).scanUTXOs({
+    address: stripToCashAddress(sender),
+    fetchTxHex: true,
+  });
+
+  const compiledMemo = memo ? 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 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 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 };
+};
+
+const transfer = async ({
+  signTransaction,
+  from,
+  recipient,
+  assetValue,
+  broadcastTx,
+  getFeeRates,
+  ...rest
+}: UTXOWalletTransferParams<
+  { builder: TransactionBuilderType; utxos: UTXOType[] },
+  TransactionType
+> & {
+  broadcastTx: (txHash: string) => Promise<string>;
+  getFeeRates: () => Promise<Record<FeeOption, number>>;
+}) => {
+  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);
+};
+
+const buildTx = async ({
+  assetValue,
+  recipient,
+  memo,
+  feeRate,
+  sender,
+  // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: TODO: refactor
+}: UTXOBuildTxParams) => {
+  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 ? 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 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[] };
+};
+
+export const stripPrefix = (address: string) => address.replace(/(bchtest:|bitcoincash:)/, "");
+
+export const validateAddress = (address: string) => {
+  const strippedAddress = stripPrefix(address);
+  return (
+    isValidAddress(strippedAddress) && detectAddressNetwork(strippedAddress) === bchNetwork.Mainnet
+  );
+};
+
+const createKeysForPath: BCHMethods["createKeysForPath"] = async ({
+  phrase,
+  derivationPath = `${DerivationPath.BCH}/0`,
+  wif,
+}) => {
+  const { ECPairFactory } = await import("ecpair");
+
+  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;
+};
+
+const getAddressFromKeys = (keys: { getAddress: (index?: number) => string }) => {
+  const address = keys.getAddress(0);
+  return stripToCashAddress(address);
+};
+
+export const createBCHToolbox = (): Omit<
+  ReturnType<typeof BaseUTXOToolbox>,
+  "getAddressFromKeys" | "transfer" | "createKeysForPath"
+> &
+  BCHMethods => {
+  const { getBalance, ...toolbox } = BaseUTXOToolbox(Chain.BitcoinCash);
+
+  return {
+    ...toolbox,
+    stripPrefix,
+    stripToCashAddress,
+    validateAddress,
+    createKeysForPath,
+    getAddressFromKeys,
+    buildBCHTx,
+    buildTx,
+    getBalance: (address: string, _potentialScamFilter?: boolean) =>
+      getBalance(stripPrefix(toCashAddress(address))),
+    transfer: (
+      params: UTXOWalletTransferParams<
+        { builder: TransactionBuilderType; utxos: UTXOType[] },
+        TransactionType
+      >,
+    ) =>
+      transfer({ ...params, getFeeRates: toolbox.getFeeRates, broadcastTx: toolbox.broadcastTx }),
+  };
+};

package/src/utxo/toolbox/index.ts

@@ -0,0 +1,37 @@
+import { Chain } from "@swapkit/helpers";
+
+import { createBCHToolbox } from "./bitcoinCash";
+import { BaseUTXOToolbox } from "./utxo";
+
+type ToolboxType = {
+  BCH: typeof BCHToolbox;
+  BTC: typeof BTCToolbox;
+  DOGE: typeof DOGEToolbox;
+  LTC: typeof LTCToolbox;
+  DASH: typeof DASHToolbox;
+};
+
+export const BCHToolbox = createBCHToolbox;
+export const BTCToolbox = () => BaseUTXOToolbox(Chain.Bitcoin);
+export const DASHToolbox = () => BaseUTXOToolbox(Chain.Dash);
+export const DOGEToolbox = () => BaseUTXOToolbox(Chain.Dogecoin);
+export const LTCToolbox = () => BaseUTXOToolbox(Chain.Litecoin);
+
+export const getToolboxByChain = <T extends keyof ToolboxType>(chain: T): ToolboxType[T] => {
+  switch (chain) {
+    case Chain.BitcoinCash:
+      return BCHToolbox as ToolboxType[T];
+    case Chain.Bitcoin:
+      return BTCToolbox as ToolboxType[T];
+    case Chain.Dogecoin:
+      return DOGEToolbox as ToolboxType[T];
+    case Chain.Litecoin:
+      return LTCToolbox as ToolboxType[T];
+    case Chain.Dash:
+      return DASHToolbox as ToolboxType[T];
+    default:
+      throw new Error(`Chain ${chain} is not supported`);
+  }
+};
+
+export { stripToCashAddress, stripPrefix, validateAddress } from "./bitcoinCash";