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

package/src/utxo/toolbox/bitcoinCash.ts

@@ -1,82 +1,155 @@
-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";
-
+  Chain,
+  type ChainSigner,
+  type DerivationPathArray,
+  FeeOption,
+  NetworkDerivationPath,
+  derivationPathToString,
+  updateDerivationPath,
+} from "@swapkit/helpers";
+import type { UtxoToolboxParams } from ".";
 import {
   accumulative,
-  Network as bchNetwork,
+  UtxoNetwork as bchNetwork,
   compileMemo,
   detectAddressNetwork,
-  getNetwork,
   getUtxoApi,
+  getUtxoNetwork,
   isValidAddress,
   toCashAddress,
   toLegacyAddress,
 } from "../helpers";
 import type {
+  BchECPair,
   TargetOutput,
   TransactionBuilderType,
   TransactionType,
   UTXOBuildTxParams,
+  UTXOTransferParams,
   UTXOType,
-  UTXOWalletTransferParams,
 } 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 = (await getCreateKeysForPath(chain))({ phrase, derivationPath });
+
+  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 }),
+  };
+}
 
-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 ({
+async function createTransaction({
   assetValue,
   recipient,
   memo,
   feeRate,
   sender,
-}) => {
-  if (!validateAddress(recipient)) throw new Error("Invalid address");
+}: UTXOBuildTxParams) {
+  const {
+    Transaction,
+    TransactionBuilder,
+    address: bchAddress,
+    // @ts-ignore
+  } = await import("@psf/bitcoincashjs-lib");
+  if (!bchValidateAddress(recipient)) throw new Error("Invalid address");
   const utxos = await getUtxoApi(chain).scanUTXOs({
     address: stripToCashAddress(sender),
     fetchTxHex: true,
   });
 
-  const compiledMemo = memo ? compileMemo(memo) : null;
+  const compiledMemo = memo ? await compileMemo(memo) : null;
 
   const targetOutputs: TargetOutput[] = [];
   // output to recipient
-  targetOutputs.push({ address: recipient, value: assetValue.getBaseValue("number") });
+  targetOutputs.push({
+    address: recipient,
+    value: assetValue.getBaseValue("number"),
+  });
   const { inputs, outputs } = accumulative({
     inputs: utxos,
     outputs: targetOutputs,
@@ -86,7 +159,7 @@ const buildBCHTx: BCHMethods["buildBCHTx"] = async ({
 
   // .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(
@@ -100,6 +173,7 @@ const buildBCHTx: BCHMethods["buildBCHTx"] = async ({
   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);
@@ -111,54 +185,50 @@ const buildBCHTx: BCHMethods["buildBCHTx"] = async ({
   }
 
   return { builder, utxos: inputs };
-};
+}
 
-const transfer = async ({
-  signTransaction,
-  from,
-  recipient,
-  assetValue,
+function transfer({
   broadcastTx,
   getFeeRates,
-  ...rest
-}: UTXOWalletTransferParams<
-  { builder: TransactionBuilderType; utxos: UTXOType[] },
-  TransactionType
-> & {
+  signer,
+}: {
   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,
+  signer?: ChainSigner<{ builder: TransactionBuilderType; utxos: UTXOType[] }, TransactionType>;
+}) {
+  return async function transfer({
     recipient,
-    sender: from,
-  });
-
-  const tx = await signTransaction({ builder, utxos });
-  const txHex = tx.toHex();
-
-  return broadcastTx(txHex);
-};
+    assetValue,
+    feeOptionKey = FeeOption.Fast,
+    ...rest
+  }: UTXOTransferParams) {
+    const from = await signer?.getAddress();
+    if (!(signer && from)) throw new Error("Signer must provider address");
+    if (!recipient) throw new 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);
+  };
+}
 
-const buildTx = async ({
-  assetValue,
-  recipient,
-  memo,
-  feeRate,
-  sender,
-  // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: TODO: refactor
-}: UTXOBuildTxParams) => {
+// 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");
+  if (!bchValidateAddress(recipientCashAddress)) throw new Error("Invalid address");
 
   const utxos = await getUtxoApi(chain).scanUTXOs({
     address: stripToCashAddress(sender),
@@ -166,7 +236,7 @@ const buildTx = async ({
   });
 
   const feeRateWhole = Number(feeRate.toFixed(0));
-  const compiledMemo = memo ? compileMemo(memo) : null;
+  const compiledMemo = memo ? await compileMemo(memo) : null;
 
   const targetOutputs = [] as TargetOutput[];
 
@@ -190,6 +260,7 @@ const buildTx = async ({
 
   // .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) {
@@ -212,70 +283,9 @@ const buildTx = async ({
   }
 
   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 }) => {
+function 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

@@ -1,37 +1,76 @@
-import { Chain } from "@swapkit/helpers";
+import {
+  Chain,
+  type ChainSigner,
+  type DerivationPathArray,
+  type UTXOChain,
+} from "@swapkit/helpers";
+import type { Psbt } from "bitcoinjs-lib";
 
+import type { TransactionBuilderType, TransactionType, UTXOType } from "../types";
 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;
+import { createUTXOToolbox } from "./utxo";
+
+type BCHToolbox = Awaited<ReturnType<typeof createBCHToolbox>>;
+type CommonUTXOToolbox = Awaited<
+  ReturnType<typeof createUTXOToolbox<Exclude<UTXOChain, Chain.BitcoinCash>>>
+>;
+
+export type UTXOToolboxes = {
+  [Chain.BitcoinCash]: BCHToolbox;
+  [Chain.Bitcoin]: CommonUTXOToolbox;
+  [Chain.Dogecoin]: CommonUTXOToolbox;
+  [Chain.Litecoin]: CommonUTXOToolbox;
+  [Chain.Dash]: CommonUTXOToolbox;
+};
+
+export type UTXOWallets = {
+  [key in keyof UTXOToolboxes]: UTXOToolboxes[key];
 };
 
-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 type UtxoToolboxParams = {
+  [Chain.BitcoinCash]: {
+    signer: ChainSigner<{ builder: TransactionBuilderType; utxos: UTXOType[] }, TransactionType>;
+  };
+  [Chain.Bitcoin]: { signer: ChainSigner<Psbt, Psbt> };
+  [Chain.Dogecoin]: { signer: ChainSigner<Psbt, Psbt> };
+  [Chain.Litecoin]: { signer: ChainSigner<Psbt, Psbt> };
+  [Chain.Dash]: { signer: ChainSigner<Psbt, Psbt> };
+};
 
-export const getToolboxByChain = <T extends keyof ToolboxType>(chain: T): ToolboxType[T] => {
+export async function getUtxoToolbox<T extends keyof UTXOToolboxes>(
+  chain: T,
+  params?:
+    | UtxoToolboxParams[T]
+    | {
+        phrase?: string;
+        derivationPath?: DerivationPathArray;
+        index?: number;
+      },
+): Promise<UTXOToolboxes[T]> {
   switch (chain) {
-    case Chain.BitcoinCash:
-      return BCHToolbox as ToolboxType[T];
+    case Chain.BitcoinCash: {
+      const toolbox = await createBCHToolbox(params as UtxoToolboxParams[Chain.BitcoinCash]);
+      return toolbox as UTXOToolboxes[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];
+    case Chain.Dash: {
+      const toolbox = await createUTXOToolbox({
+        chain,
+        ...(params as UtxoToolboxParams[Exclude<T, Chain.BitcoinCash>]),
+      });
+      return toolbox as UTXOToolboxes[Exclude<T, Chain.BitcoinCash>];
+    }
+
     default:
       throw new Error(`Chain ${chain} is not supported`);
   }
-};
+}
 
-export { stripToCashAddress, stripPrefix, validateAddress } from "./bitcoinCash";
+export {
+  stripToCashAddress,
+  stripPrefix,
+  bchValidateAddress,
+} from "./bitcoinCash";