@swapkit/toolboxes 4.0.0-beta.50 → 4.0.0-beta.52

package/src/utxo/helpers/bchaddrjs.ts

@@ -1,183 +0,0 @@
-import { SwapKitError } from "@swapkit/helpers";
-import base58check from "bs58check";
-// @ts-ignore
-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 (_error) {
-    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 (_error) {
-    // Try to decode as cashaddr if base58 decoding fails.
-  }
-  try {
-    const decoded = decodeCashAddress(address);
-    if (decoded) {
-      return decoded;
-    }
-  } catch (_error) {
-    // Try to decode as bitpay if cashaddr decoding fails.
-  }
-  throw new SwapKitError("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 SwapKitError("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 { hash, format: Format.Legacy, network: UtxoNetwork.Mainnet, type: Type.P2PKH };
-
-      case VERSION_BYTE[Format.Legacy][UtxoNetwork.Mainnet][Type.P2SH]:
-        return { hash, format: Format.Legacy, network: UtxoNetwork.Mainnet, type: Type.P2SH };
-
-      case VERSION_BYTE[Format.Legacy][UtxoNetwork.Testnet][Type.P2PKH]:
-        return { hash, format: Format.Legacy, network: UtxoNetwork.Testnet, type: Type.P2PKH };
-
-      case VERSION_BYTE[Format.Legacy][UtxoNetwork.Testnet][Type.P2SH]:
-        return { hash, format: Format.Legacy, network: UtxoNetwork.Testnet, type: Type.P2SH };
-
-      case VERSION_BYTE[Format.Bitpay][UtxoNetwork.Mainnet][Type.P2PKH]:
-        return { hash, format: Format.Bitpay, network: UtxoNetwork.Mainnet, type: Type.P2PKH };
-
-      case VERSION_BYTE[Format.Bitpay][UtxoNetwork.Mainnet][Type.P2SH]:
-        return { hash, format: Format.Bitpay, network: UtxoNetwork.Mainnet, type: Type.P2SH };
-
-      default:
-        return;
-    }
-  } catch (_error) {
-    return;
-  }
-}
-
-function decodeCashAddress(address: string) {
-  if (address.indexOf(":") !== -1) {
-    try {
-      return decodeCashAddressWithPrefix(address);
-    } catch (_error) {
-      // 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 (_error) {
-        // 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 (_error) {
-    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

@@ -1,98 +0,0 @@
-import { Chain, SwapKitError, 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;
-    case Chain.Zcash:
-      return 546;
-    default:
-      throw new SwapKitError("toolbox_utxo_not_supported", { 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/txSize.ts

@@ -1,104 +0,0 @@
-import { SwapKitError } from "@swapkit/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) => {
-  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 SwapKitError("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/toolbox/bitcoinCash.ts

@@ -1,320 +0,0 @@
-import {
-  Transaction,
-  TransactionBuilder,
-  address as bchAddress,
-  // @ts-ignore
-} from "@psf/bitcoincashjs-lib";
-import {
-  Chain,
-  type ChainSigner,
-  type DerivationPathArray,
-  FeeOption,
-  NetworkDerivationPath,
-  SwapKitError,
-  derivationPathToString,
-  updateDerivationPath,
-} from "@swapkit/helpers";
-import { Psbt } from "bitcoinjs-lib";
-import type { UtxoToolboxParams } from ".";
-import {
-  accumulative,
-  UtxoNetwork as bchNetwork,
-  compileMemo,
-  detectAddressNetwork,
-  getUtxoApi,
-  getUtxoNetwork,
-  isValidAddress,
-  toCashAddress,
-  toLegacyAddress,
-} from "../helpers";
-import type {
-  BchECPair,
-  TargetOutput,
-  TransactionBuilderType,
-  TransactionType,
-  UTXOBuildTxParams,
-  UTXOTransferParams,
-  UTXOType,
-} from "../types";
-import { createUTXOToolbox, getCreateKeysForPath } from "./utxo";
-
-const chain = Chain.BitcoinCash;
-
-export function stripPrefix(address: string) {
-  return address.replace(/(bchtest:|bitcoincash:)/, "");
-}
-
-export function bchValidateAddress(address: string) {
-  const strippedAddress = stripPrefix(address);
-  return (
-    isValidAddress(strippedAddress) && detectAddressNetwork(strippedAddress) === bchNetwork.Mainnet
-  );
-}
-
-export function stripToCashAddress(address: string) {
-  return stripPrefix(toCashAddress(address));
-}
-
-async function createSignerWithKeys(keys: BchECPair) {
-  async 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 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))({ phrase, derivationPath }) : undefined;
-
-  const signer = keys
-    ? await 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,
-    getAddress,
-    broadcastTx,
-    createTransaction,
-    buildTx,
-    getAddressFromKeys,
-    getBalance: handleGetBalance,
-    getFeeRates,
-    stripPrefix,
-    stripToCashAddress,
-    validateAddress: bchValidateAddress,
-    transfer: transfer({ getFeeRates, broadcastTx, signer }),
-  };
-}
-
-async function createTransaction({
-  assetValue,
-  recipient,
-  memo,
-  feeRate,
-  sender,
-}: UTXOBuildTxParams) {
-  if (!bchValidateAddress(recipient))
-    throw new SwapKitError("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({
-    inputs: utxos,
-    outputs: targetOutputs,
-    feeRate,
-    chain,
-  });
-
-  // .inputs and .outputs will be undefined if no solution was found
-  if (!(inputs && outputs))
-    throw new SwapKitError("toolbox_utxo_insufficient_balance", { sender, assetValue });
-  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 SwapKitError("toolbox_utxo_no_signer");
-    if (!recipient)
-      throw new SwapKitError("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);
-  };
-}
-
-// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: TODO: refactor
-async function buildTx({
-  assetValue,
-  recipient,
-  memo,
-  feeRate,
-  sender,
-  setSigHashType,
-}: UTXOBuildTxParams & { setSigHashType?: boolean }) {
-  const recipientCashAddress = toCashAddress(recipient);
-  if (!bchValidateAddress(recipientCashAddress))
-    throw new SwapKitError("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({
-    inputs: utxos,
-    outputs: targetOutputs,
-    feeRate: feeRateWhole,
-    chain,
-  });
-
-  // .inputs and .outputs will be undefined if no solution was found
-  if (!(inputs && outputs))
-    throw new SwapKitError("toolbox_utxo_insufficient_balance", { sender, assetValue });
-  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,
-      sighashType: setSigHashType ? 0x41 : undefined,
-    });
-  }
-
-  // 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[] };
-}
-
-function getAddressFromKeys(keys: { getAddress: (index?: number) => string }) {
-  const address = keys.getAddress(0);
-  return stripToCashAddress(address);
-}