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

package/src/substrate/{toolbox/baseSubstrateToolbox.ts → substrate.ts}

@@ -1,60 +1,75 @@
-import { ApiPromise, Keyring, WsProvider } from "@polkadot/api";
+import type { ApiPromise } from "@polkadot/api";
 import type { SubmittableExtrinsic } from "@polkadot/api/types";
 import type { KeyringPair } from "@polkadot/keyring/types";
 import type { Callback, IKeyringPair, ISubmittableResult, Signer } from "@polkadot/types/types";
 import { hexToU8a, isHex, u8aToHex } from "@polkadot/util";
 import {
-  cryptoWaitReady,
   decodeAddress as decodePolkadotAddress,
   encodeAddress as encodePolkadotAddress,
 } from "@polkadot/util-crypto";
 import {
   AssetValue,
   Chain,
+  type DerivationPathArray,
+  type GenericCreateTransactionParams,
   SKConfig,
   type SubstrateChain,
   SwapKitError,
   SwapKitNumber,
 } from "@swapkit/helpers";
 
-import { Network, type SubstrateNetwork } from "../types/network";
+import { P, match } from "ts-pattern";
+import { getBalance } from "../utils";
+import { SubstrateNetwork, type SubstrateTransferParams } from "./types";
 
-// TODO combine this type with the more general SK type
-type SubstrateTransferParams = {
-  recipient: string;
-  assetValue: AssetValue;
-  from?: string;
+export const PolkadotToolbox = ({ generic = false, ...signerParams }: ToolboxParams = {}) => {
+  return createSubstrateToolbox({ chain: Chain.Polkadot, generic, ...signerParams });
 };
 
-export const isKeyringPair = (account: IKeyringPair | Signer): account is IKeyringPair => {
-  return "address" in account;
-};
+export const ChainflipToolbox = async ({
+  generic = false,
+  ...signerParams
+}: ToolboxParams = {}) => {
+  const toolbox = await createSubstrateToolbox({
+    chain: Chain.Chainflip,
+    generic,
+    ...signerParams,
+  });
 
-export const createKeyring = async (phrase: string, networkPrefix: number) => {
-  await cryptoWaitReady();
+  return { ...toolbox, getBalance: getBalance(Chain.Chainflip) };
+};
 
-  return new Keyring({ type: "sr25519", ss58Format: networkPrefix }).addFromUri(phrase);
+export type SubstrateToolboxes = {
+  DOT: Awaited<ReturnType<typeof PolkadotToolbox>>;
+  FLIP: Awaited<ReturnType<typeof ChainflipToolbox>>;
 };
 
-const getNonce = (api: ApiPromise, address: string) => api.rpc.system.accountNextIndex(address);
+export function getSubstrateToolbox<T extends SubstrateChain>(chain: T, params?: ToolboxParams) {
+  switch (chain) {
+    case Chain.Chainflip: {
+      return ChainflipToolbox(params);
+    }
+    case Chain.Polkadot: {
+      return PolkadotToolbox(params);
+    }
+    default:
+      throw new Error(`Chain ${chain} is not supported`);
+  }
+}
 
-const getBalance = async (api: ApiPromise, gasAsset: AssetValue, address: string) => {
-  const data = await api.query.system?.account?.(address);
+export function isKeyringPair(account: IKeyringPair | Signer): account is IKeyringPair {
+  return "address" in account;
+}
 
-  // @ts-expect-error @Towan some parts of data missing?
-  if (!data?.data?.free || data?.data?.isEmpty) {
-    return [gasAsset.set(0)];
-  }
+export async function createKeyring(phrase: string, networkPrefix: number) {
+  const { Keyring } = await import("@polkadot/api");
+  const { cryptoWaitReady } = await import("@polkadot/util-crypto");
+  await cryptoWaitReady();
 
-  return [
-    gasAsset.set(
-      // @ts-expect-error @Towan some parts of data missing?
-      SwapKitNumber.fromBigInt(BigInt(data.data.free.toString()), gasAsset.decimal).getValue(
-        "string",
-      ),
-    ),
-  ];
-};
+  return new Keyring({ type: "sr25519", ss58Format: networkPrefix }).addFromUri(phrase);
+}
+
+const getNonce = (api: ApiPromise, address: string) => api.rpc.system.accountNextIndex(address);
 
 const validateAddress = (address: string, networkPrefix: number) => {
   try {
@@ -68,26 +83,24 @@ const validateAddress = (address: string, networkPrefix: number) => {
   }
 };
 
-const createTransfer = (
-  api: ApiPromise,
-  { recipient, amount }: { recipient: string; amount: number },
-) => api.tx.balances?.transferAllowDeath?.(recipient, amount);
+const createTransaction = (api: ApiPromise, { recipient, assetValue }: SubstrateTransferParams) =>
+  api.tx.balances?.transferAllowDeath?.(recipient, assetValue.getBaseValue("number"));
 
 const transfer = async (
   api: ApiPromise,
   signer: IKeyringPair | Signer,
-  { recipient, assetValue, from }: SubstrateTransferParams,
+  { recipient, assetValue, sender }: SubstrateTransferParams,
 ) => {
-  const transfer = createTransfer(api, {
+  const transfer = createTransaction(api, {
     recipient,
-    amount: assetValue.getBaseValue("number"),
+    assetValue,
   });
 
   const isKeyring = isKeyringPair(signer);
 
   if (!transfer) return;
 
-  const address = from || (isKeyring ? (signer as IKeyringPair).address : undefined);
+  const address = isKeyring ? (signer as IKeyringPair).address : sender;
   if (!address) throw new SwapKitError("core_transaction_invalid_sender_address");
 
   const nonce = await getNonce(api, address);
@@ -104,11 +117,11 @@ const estimateTransactionFee = async (
   api: ApiPromise,
   signer: IKeyringPair | Signer,
   gasAsset: AssetValue,
-  { recipient, assetValue, from }: SubstrateTransferParams,
+  { recipient, assetValue, sender }: SubstrateTransferParams,
 ) => {
-  const transfer = createTransfer(api, { recipient, amount: assetValue.getBaseValue("number") });
+  const transfer = createTransaction(api, { recipient, assetValue });
 
-  const address = from || (isKeyringPair(signer) && signer.address);
+  const address = isKeyringPair(signer) ? signer.address : sender;
   if (!address) return;
 
   const paymentInfo = (await transfer?.paymentInfo(address, {
@@ -199,7 +212,7 @@ export const BaseSubstrateToolbox = ({
   api: ApiPromise;
   network: SubstrateNetwork;
   gasAsset: AssetValue;
-  signer: IKeyringPair | Signer;
+  signer?: IKeyringPair | Signer;
 }) => ({
   api,
   network,
@@ -207,27 +220,34 @@ export const BaseSubstrateToolbox = ({
   decodeAddress,
   encodeAddress,
   convertAddress,
+  getBalance: getBalance(Chain.Polkadot),
   createKeyring: (phrase: string) => createKeyring(phrase, network.prefix),
-  getAddress: (keyring: IKeyringPair | Signer = signer) =>
-    isKeyringPair(keyring) ? keyring.address : undefined,
-  createTransfer: ({ recipient, assetValue }: { recipient: string; assetValue: AssetValue }) =>
-    createTransfer(api, { recipient, amount: assetValue.getBaseValue("number") }),
-  getBalance: (address: string) => getBalance(api, gasAsset, address),
+  getAddress: (keyring?: IKeyringPair | Signer) => {
+    const keyringPair = keyring || signer;
+    if (!keyringPair) throw new SwapKitError("core_wallet_not_keypair_wallet");
+
+    return isKeyringPair(keyringPair) ? keyringPair.address : undefined;
+  },
+  createTransaction: (params: GenericCreateTransactionParams) => createTransaction(api, params),
   validateAddress: (address: string) => validateAddress(address, network.prefix),
-  transfer: (params: SubstrateTransferParams) => transfer(api, signer, params),
-  estimateTransactionFee: (params: SubstrateTransferParams) =>
-    estimateTransactionFee(api, signer, gasAsset, params),
+  transfer: (params: SubstrateTransferParams) => {
+    if (!signer) throw new SwapKitError("core_wallet_not_keypair_wallet");
+    return transfer(api, signer, params);
+  },
+  estimateTransactionFee: (params: SubstrateTransferParams) => {
+    if (!signer) throw new SwapKitError("core_wallet_not_keypair_wallet");
+    return estimateTransactionFee(api, signer, gasAsset, params);
+  },
   sign: (tx: SubmittableExtrinsic<"promise">) => {
-    if (isKeyringPair(signer)) {
-      return sign(signer, tx);
-    }
+    if (!signer) throw new SwapKitError("core_wallet_not_keypair_wallet");
+    if (isKeyringPair(signer)) return sign(signer, tx);
+
     throw new SwapKitError(
       "core_wallet_not_keypair_wallet",
       "Signer does not have keyring pair capabilities required for signing.",
     );
   },
-  broadcast: (tx: SubmittableExtrinsic<"promise">, callback?: Callback<ISubmittableResult>) =>
-    broadcast(tx, callback),
+  broadcast,
   signAndBroadcast: ({
     tx,
     callback,
@@ -237,9 +257,8 @@ export const BaseSubstrateToolbox = ({
     callback?: Callback<ISubmittableResult>;
     address?: string;
   }) => {
-    if (isKeyringPair(signer)) {
-      return signAndBroadcastKeyring(signer, tx, callback);
-    }
+    if (!signer) throw new SwapKitError("core_wallet_not_keypair_wallet");
+    if (isKeyringPair(signer)) return signAndBroadcastKeyring(signer, tx, callback);
 
     if (address) {
       return signAndBroadcast({ signer, address, tx, callback, api });
@@ -256,31 +275,44 @@ export const substrateValidateAddress = ({
   address,
   chain,
 }: { address: string; chain: Chain.Polkadot | Chain.Chainflip }) => {
-  const { prefix } = chain === Chain.Polkadot ? Network.DOT : Network.FLIP;
+  const { prefix } = chain === Chain.Polkadot ? SubstrateNetwork.DOT : SubstrateNetwork.FLIP;
 
-  return validateAddress(address, prefix) || validateAddress(address, Network.GENERIC.prefix);
+  return (
+    validateAddress(address, prefix) || validateAddress(address, SubstrateNetwork.GENERIC.prefix)
+  );
 };
 
-export async function ToolboxFactory({
+export async function createSubstrateToolbox({
   generic,
   chain,
-  signer,
+  ...signerParams
 }: ToolboxParams & { chain: SubstrateChain }) {
-  const rpcUrl = SKConfig.get("rpcUrls")[chain];
-  const provider = new WsProvider(rpcUrl);
+  const { ApiPromise, WsProvider } = await import("@polkadot/api");
+
+  const provider = new WsProvider(SKConfig.get("rpcUrls")[chain]);
   const api = await ApiPromise.create({ provider });
   const gasAsset = AssetValue.from({ chain });
-  const network = generic ? Network.GENERIC : Network[chain];
+  const network = generic ? SubstrateNetwork.GENERIC : SubstrateNetwork[chain];
+
+  const signer = await match(signerParams)
+    .with({ phrase: P.string }, ({ phrase }) =>
+      createKeyring(phrase, SubstrateNetwork[chain].prefix),
+    )
+    .with({ signer: P.any }, ({ signer }) => signer)
+    .otherwise(() => undefined);
 
   return BaseSubstrateToolbox({ api, signer, gasAsset, network });
 }
 
 export type ToolboxParams = {
   generic?: boolean;
-  signer: KeyringPair | Signer;
-};
-
-export type BaseSubstrateWallet = ReturnType<typeof BaseSubstrateToolbox>;
-export type SubstrateWallets = {
-  [chain in SubstrateChain]: BaseSubstrateWallet;
-};
+} & (
+  | {
+      signer?: KeyringPair | Signer;
+    }
+  | {
+      phrase?: string;
+      derivationPath?: DerivationPathArray;
+      index?: number;
+    }
+);

package/src/substrate/types.ts

@@ -0,0 +1,120 @@
+import type { Signer as InjectedSigner } from "@polkadot/api/types";
+import type { ProviderInterface } from "@polkadot/rpc-provider/types";
+import type { ExtDef } from "@polkadot/types/extrinsic/signedExtensions/types";
+import type { KeypairType } from "@polkadot/util-crypto/types";
+import type { GenericTransferParams, SubstrateChain } from "@swapkit/helpers";
+
+const polkadotNetwork = {
+  prefix: 0,
+  network: "polkadot",
+  displayName: "Polkadot Relay Chain",
+  symbols: ["DOT"],
+  decimals: [10],
+  standardAccount: "*25519",
+  website: "https://polkadot.network",
+};
+
+const chainflipNetwork = {
+  prefix: 2112,
+  network: "chainflip",
+  displayName: "Chainflip",
+  symbols: ["FLIP"],
+  decimals: [18],
+  standardAccount: "*25519",
+  website: "https://chainflip.io/",
+};
+
+const subtrateNetwork = {
+  prefix: 42,
+  network: "substrate",
+  displayName: "Substrate",
+  symbols: [],
+  decimals: [],
+  standardAccount: "*25519",
+  website: "https://substrate.io/",
+};
+
+export const SubstrateNetwork: Record<SubstrateChain | "GENERIC", SubstrateNetwork> = {
+  DOT: polkadotNetwork,
+  FLIP: chainflipNetwork,
+  GENERIC: subtrateNetwork,
+};
+
+export type SubstrateNetwork =
+  | typeof polkadotNetwork
+  | typeof chainflipNetwork
+  | typeof subtrateNetwork;
+
+export type SubstrateTransferParams = GenericTransferParams & {
+  sender?: string;
+};
+
+type Unsubcall = () => void;
+
+interface InjectedAccount {
+  address: string;
+  genesisHash?: string | null;
+  name?: string;
+  type?: KeypairType;
+}
+
+interface InjectedAccounts {
+  get: (anyType?: boolean) => Promise<InjectedAccount[]>;
+  subscribe: (cb: (accounts: InjectedAccount[]) => void | Promise<void>) => Unsubcall;
+}
+interface InjectedExtensionInfo {
+  name: string;
+  version: string;
+}
+interface ProviderMeta {
+  network: string;
+  node: "full" | "light";
+  source: string;
+  transport: string;
+}
+interface MetadataDefBase {
+  chain: string;
+  genesisHash: string;
+  icon: string;
+  ss58Format: number;
+  chainType?: "substrate" | "ethereum";
+}
+interface MetadataDef extends MetadataDefBase {
+  color?: string;
+  specVersion: number;
+  tokenDecimals: number;
+  tokenSymbol: string;
+  types: Record<string, Record<string, string> | string>;
+  metaCalls?: string;
+  userExtensions?: ExtDef;
+}
+interface InjectedMetadataKnown {
+  genesisHash: string;
+  specVersion: number;
+}
+interface InjectedMetadata {
+  get: () => Promise<InjectedMetadataKnown[]>;
+  provide: (definition: MetadataDef) => Promise<boolean>;
+}
+type ProviderList = Record<string, ProviderMeta>;
+
+interface InjectedProvider extends ProviderInterface {
+  listProviders: () => Promise<ProviderList>;
+  startProvider: (key: string) => Promise<ProviderMeta>;
+}
+
+type InjectedWalletData = {
+  accounts: InjectedAccounts;
+  metadata?: InjectedMetadata;
+  provider?: InjectedProvider;
+  signer: InjectedSigner;
+};
+
+export type SubstrateInjectedExtension = Record<
+  string,
+  {
+    connect?: (origin: string) => Promise<InjectedExtensionInfo & InjectedWalletData>;
+    enable?: (origin: string) => Promise<InjectedWalletData>;
+    version?: string;
+  }
+>;

package/src/utils.ts

@@ -0,0 +1,27 @@
+import { AssetValue, BaseDecimal, type Chain } from "@swapkit/helpers";
+import { SwapKitApi } from "@swapkit/helpers/api";
+
+const pid = typeof process !== "undefined" && process.pid ? process.pid.toString(36) : "";
+
+let last = 0;
+export function uniqid() {
+  function now() {
+    const time = Date.now();
+    const lastTime = last || time;
+    last = lastTime;
+
+    return time > last ? time : lastTime + 1;
+  }
+
+  return pid + now().toString(36);
+}
+
+export function getBalance<T extends Chain>(chain: T) {
+  return async function getBalance(address: string, scamFilter = true) {
+    const balances = await SwapKitApi.getChainBalance({ chain, address, scamFilter });
+
+    return balances.map(({ identifier, value, decimal }) => {
+      return new AssetValue({ decimal: decimal || BaseDecimal[chain], value, identifier });
+    });
+  };
+}

package/src/utxo/helpers/api.ts

@@ -1,5 +1,5 @@
 import { Chain, RequestClient, SKConfig, type UTXOChain, warnOnce } from "@swapkit/helpers";
-import { uniqid } from "./utils";
+import { uniqid } from "../../utils";
 
 type BlockchairParams<T> = T & { chain: Chain; apiKey?: string };
 type BlockchairFetchUnspentUtxoParams = BlockchairParams<{
@@ -129,25 +129,6 @@ async function getUnconfirmedBalance({
   return response?.address.balance || 0;
 }
 
-async function getConfirmedBalance({
-  chain,
-  address,
-  apiKey,
-}: BlockchairParams<{ address?: string }>) {
-  if (!address) throw new Error("address is required");
-
-  try {
-    const response = await blockchairRequest<BlockchairMultipleBalancesResponse>(
-      `${baseUrl(chain)}/addresses/balances?addresses=${address}`,
-      apiKey,
-    );
-
-    return response[address] || 0;
-  } catch (_error) {
-    return 0;
-  }
-}
-
 async function getRawTx({ chain, apiKey, txHash }: BlockchairParams<{ txHash?: string }>) {
   if (!txHash) throw new Error("txHash is required");
 
@@ -251,7 +232,6 @@ function utxoApi(chain: UTXOChain) {
 
   return {
     broadcastTx: (txHash: string) => broadcastUTXOTx({ txHash, chain }),
-    getConfirmedBalance: (address: string) => getConfirmedBalance({ chain, address, apiKey }),
     getRawTx: (txHash: string) => getRawTx({ txHash, chain, apiKey }),
     getSuggestedTxFee: () => getSuggestedTxFee(chain),
     getBalance: (address: string) => getUnconfirmedBalance({ address, chain, apiKey }),
@@ -279,8 +259,32 @@ export function getUtxoApi(chain: UTXOChain) {
   return utxoApi(chain);
 }
 
-interface BlockchairMultipleBalancesResponse {
-  [key: string]: number;
+export async function getUtxoNetwork() {
+  // @ts-ignore
+  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");
+    }
+  };
 }
 
 interface BlockchairVin {

package/src/utxo/helpers/bchaddrjs.ts

@@ -7,7 +7,7 @@ enum Format {
   Bitpay = "bitpay",
   Cashaddr = "cashaddr",
 }
-enum Network {
+enum UtxoNetwork {
   Mainnet = "mainnet",
   Testnet = "testnet",
 }
@@ -18,21 +18,21 @@ enum Type {
 
 const VERSION_BYTE = {
   [Format.Legacy]: {
-    [Network.Mainnet]: {
+    [UtxoNetwork.Mainnet]: {
       [Type.P2PKH]: 0,
       [Type.P2SH]: 5,
     },
-    [Network.Testnet]: {
+    [UtxoNetwork.Testnet]: {
       [Type.P2PKH]: 111,
       [Type.P2SH]: 196,
     },
   },
   [Format.Bitpay]: {
-    [Network.Mainnet]: {
+    [UtxoNetwork.Mainnet]: {
       [Type.P2PKH]: 28,
       [Type.P2SH]: 40,
     },
-    [Network.Testnet]: {
+    [UtxoNetwork.Testnet]: {
       [Type.P2PKH]: 111,
       [Type.P2SH]: 196,
     },
@@ -41,7 +41,7 @@ const VERSION_BYTE = {
 
 type DecodedType = {
   format: Format;
-  network: Network;
+  network: UtxoNetwork;
   type: Type;
   hash: any;
 };
@@ -97,23 +97,23 @@ function decodeBase58Address(address: string) {
     const hash = Array.prototype.slice.call(payload, 1);
 
     switch (versionByte) {
-      case VERSION_BYTE[Format.Legacy][Network.Mainnet][Type.P2PKH]:
-        return { hash, format: Format.Legacy, network: Network.Mainnet, type: Type.P2PKH };
+      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][Network.Mainnet][Type.P2SH]:
-        return { hash, format: Format.Legacy, network: Network.Mainnet, type: Type.P2SH };
+      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][Network.Testnet][Type.P2PKH]:
-        return { hash, format: Format.Legacy, network: Network.Testnet, type: Type.P2PKH };
+      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][Network.Testnet][Type.P2SH]:
-        return { hash, format: Format.Legacy, network: Network.Testnet, type: Type.P2SH };
+      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][Network.Mainnet][Type.P2PKH]:
-        return { hash, format: Format.Bitpay, network: Network.Mainnet, type: Type.P2PKH };
+      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][Network.Mainnet][Type.P2SH]:
-        return { hash, format: Format.Bitpay, network: Network.Mainnet, type: Type.P2SH };
+      case VERSION_BYTE[Format.Bitpay][UtxoNetwork.Mainnet][Type.P2SH]:
+        return { hash, format: Format.Bitpay, network: UtxoNetwork.Mainnet, type: Type.P2SH };
 
       default:
         throw new Error("Received an invalid Bitcoin Cash address as input.");
@@ -151,7 +151,7 @@ function decodeCashAddressWithPrefix(address: string): DecodedType {
     return {
       format: Format.Cashaddr,
       hash: Array.prototype.slice.call(hash, 0),
-      network: prefix === "bitcoincash" ? Network.Mainnet : Network.Testnet,
+      network: prefix === "bitcoincash" ? UtxoNetwork.Mainnet : UtxoNetwork.Testnet,
       type: type === "P2PKH" ? Type.P2PKH : Type.P2SH,
     };
   } catch (_error) {
@@ -168,10 +168,10 @@ function encodeAsLegacy(decoded: DecodedType) {
 }
 
 function encodeAsCashaddr(decoded: DecodedType) {
-  const prefix = decoded.network === Network.Mainnet ? "bitcoincash" : "bchtest";
+  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, Network, toCashAddress, toLegacyAddress };
+export { detectAddressNetwork, isValidAddress, UtxoNetwork, toCashAddress, toLegacyAddress };

package/src/utxo/helpers/index.ts

@@ -2,4 +2,3 @@ export * from "./api";
 export * from "./bchaddrjs";
 export * from "./coinselect";
 export * from "./txSize";
-export * from "./utils";

package/src/utxo/helpers/txSize.ts

@@ -1,5 +1,3 @@
-import { opcodes, script } from "bitcoinjs-lib";
-
 import type {
   TargetOutput,
   UTXOCalculateTxSizeParams,
@@ -18,10 +16,11 @@ 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) => {
+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

package/src/utxo/index.ts

@@ -1,9 +1,5 @@
-export { type Network, networks, Psbt, Transaction } from "bitcoinjs-lib";
-
-/**
- * Package
- */
-export * from "./toolbox/index";
+export * from "./toolbox";
+export * from "./toolbox/bitcoinCash";
 export * from "./toolbox/utxo";
-export * from "./helpers/index";
+export * from "./helpers";
 export * from "./types";