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

package/src/evm/toolbox/evm.ts

@@ -0,0 +1,69 @@
+import { Chain, type EVMChain, FeeOption, SKConfig } from "@swapkit/helpers";
+import { HDNodeWallet } from "ethers";
+import { P, match } from "ts-pattern";
+import { getEvmApi } from "../api";
+import { multicallAbi } from "../contracts/eth/multicall";
+import {
+  getEstimateTransactionFee,
+  getIsEIP1559Compatible,
+  getNetworkParams,
+  getProvider,
+} from "../helpers";
+import type { EVMToolboxParams } from "../types";
+import { BaseEVMToolbox } from "./baseEVMToolbox";
+
+export async function ETHToolbox({ provider, ...signer }: EVMToolboxParams) {
+  const evmToolbox = await createEvmToolbox(Chain.Ethereum)({
+    provider,
+    ...signer,
+  });
+  async function multicall(
+    callTuples: { address: string; data: string }[],
+    multicallAddress = "0x5ba1e12693dc8f9c48aad8770482f4739beed696",
+    funcName = "aggregate",
+    feeOptionKey: FeeOption = FeeOption.Fast,
+  ) {
+    const txObject = await evmToolbox.createContractTxObject({
+      contractAddress: multicallAddress,
+      abi: multicallAbi,
+      funcName,
+      funcParams: [callTuples],
+    });
+
+    return evmToolbox.sendTransaction({ ...txObject, feeOptionKey });
+  }
+
+  return { ...evmToolbox, multicall };
+}
+
+export const ARBToolbox = createEvmToolbox(Chain.Arbitrum);
+export const AVAXToolbox = createEvmToolbox(Chain.Avalanche);
+export const BASEToolbox = createEvmToolbox(Chain.Base);
+export const BSCToolbox = createEvmToolbox(Chain.BinanceSmartChain);
+export const MATICToolbox = createEvmToolbox(Chain.Polygon);
+
+function createEvmToolbox<C extends EVMChain>(chain: C) {
+  return async function createEvmToolbox({
+    provider: providerParam,
+    ...toolboxSignerParams
+  }: EVMToolboxParams) {
+    const rpcUrl = SKConfig.get("rpcUrls")[chain];
+
+    const provider = providerParam || (await getProvider(chain, rpcUrl));
+
+    const isEIP1559Compatible = getIsEIP1559Compatible(chain);
+    const signer = match(toolboxSignerParams)
+      .with({ phrase: P.string }, ({ phrase }) => HDNodeWallet.fromPhrase(phrase).connect(provider))
+      .with({ signer: P.any }, ({ signer }) => signer)
+      .otherwise(() => undefined);
+
+    const evmToolbox = BaseEVMToolbox({ provider, signer, isEIP1559Compatible, chain });
+
+    return {
+      ...evmToolbox,
+      estimateTransactionFee: getEstimateTransactionFee({ provider, isEIP1559Compatible, chain }),
+      getNetworkParams: getNetworkParams(chain),
+      getBalance: getEvmApi(chain).getBalance,
+    };
+  };
+}

package/src/evm/toolbox/index.ts

@@ -0,0 +1,36 @@
+import { Chain, type EVMChain } from "@swapkit/helpers";
+
+import { getProvider } from "../helpers";
+import type { EVMToolboxParams } from "../types";
+import { ARBToolbox, AVAXToolbox, BASEToolbox, BSCToolbox, ETHToolbox, MATICToolbox } from "./evm";
+import { OPToolbox } from "./op";
+
+export async function getEvmToolbox<T extends EVMChain>(chain: T, params?: EVMToolboxParams) {
+  const toolboxParams = {
+    ...params,
+    provider: params?.provider || (await getProvider(chain)),
+  };
+
+  switch (chain) {
+    case Chain.Avalanche:
+      return AVAXToolbox(toolboxParams);
+    case Chain.Arbitrum:
+      return ARBToolbox(toolboxParams);
+    case Chain.Base:
+      return BASEToolbox(toolboxParams);
+    case Chain.Optimism:
+      return OPToolbox(toolboxParams);
+    case Chain.Polygon:
+      return MATICToolbox(toolboxParams);
+    case Chain.BinanceSmartChain:
+      return BSCToolbox(toolboxParams);
+    case Chain.Ethereum:
+      return ETHToolbox(toolboxParams);
+    default:
+      throw new Error(`Chain ${chain} is not supported`);
+  }
+}
+
+export * from "./baseEVMToolbox";
+export * from "./evm";
+export * from "./op";

package/src/evm/toolbox/op.ts

@@ -1,92 +1,85 @@
-import {
-  BaseDecimal,
-  Chain,
-  ChainId,
-  ChainToExplorerUrl,
-  FeeOption,
-  SKConfig,
-} from "@swapkit/helpers";
-import type { BrowserProvider, JsonRpcProvider, Signer, TransactionRequest } from "ethers";
-import { Contract, Transaction } from "ethers";
+import { BaseDecimal, Chain, ChainId, ChainToExplorerUrl, SKConfig } from "@swapkit/helpers";
+import type { BrowserProvider, JsonRpcProvider, Provider, TransactionRequest } from "ethers";
+import { Contract, HDNodeWallet } from "ethers";
 
+import { P } from "ts-pattern";
+import { match } from "ts-pattern";
+import { getEvmApi } from "../api";
 import { gasOracleAbi } from "../contracts/op/gasOracle";
-import { getBalance } from "../index";
-
-import { EVMToolbox } from "./EVMToolbox";
+import { getProvider } from "../helpers";
+import type { EVMToolboxParams } from "../types";
+import { BaseEVMToolbox } from "./baseEVMToolbox";
 
 const GAS_PRICE_ORACLE_ADDRESS = "0x420000000000000000000000000000000000000f";
 
-export const connectGasPriceOracle = (provider: JsonRpcProvider | BrowserProvider) => {
+function connectGasPriceOracle<P extends Provider>(provider: P) {
   return new Contract(GAS_PRICE_ORACLE_ADDRESS, gasOracleAbi, provider);
-};
-
-export const getL1GasPrice = (provider: JsonRpcProvider | BrowserProvider) => {
-  const gasPriceOracle = connectGasPriceOracle(provider);
-
-  if (gasPriceOracle && "l1BaseFee" in gasPriceOracle) {
-    return gasPriceOracle?.l1BaseFee() as unknown as bigint;
-  }
-
-  return undefined;
-};
-
-const _serializeTx = async (
-  provider: JsonRpcProvider | BrowserProvider,
-  { data, from, to, gasPrice, type, gasLimit, nonce }: TransactionRequest,
-) => {
-  if (!to) throw new Error("Missing to address");
-
-  return Transaction.from({
-    data,
-    to: to as string,
-    gasPrice,
-    type,
-    gasLimit,
-    nonce: nonce ? nonce : from ? await provider.getTransactionCount(from) : 0,
-  }).serialized;
-};
-
-export const estimateL1GasCost = async (
-  provider: JsonRpcProvider | BrowserProvider,
-  tx: TransactionRequest,
-) => {
-  const gasPriceOracle = await connectGasPriceOracle(provider);
-  const serializedTx = await _serializeTx(provider, tx);
-
-  if (gasPriceOracle && "getL1Fee" in gasPriceOracle) {
-    return gasPriceOracle.getL1Fee(serializedTx);
-  }
-};
-
-export const estimateL2GasCost = async (
-  provider: JsonRpcProvider | BrowserProvider,
-  tx: TransactionRequest,
-) => {
-  const l2GasPrice = await provider.send("eth_gasPrice", []);
-  const l2GasCost = await provider.estimateGas(tx);
-  return l2GasPrice.mul(l2GasCost);
-};
-
-export const estimateTotalGasCost = async (
-  provider: JsonRpcProvider | BrowserProvider,
-  tx: TransactionRequest,
-) => {
-  const l1GasCost = await estimateL1GasCost(provider, tx);
-  const l2GasCost = await estimateL2GasCost(provider, tx);
-  return l1GasCost.add(l2GasCost);
-};
-
-export const estimateL1Gas = async (
-  provider: JsonRpcProvider | BrowserProvider,
-  tx: TransactionRequest,
-) => {
-  const gasPriceOracle = connectGasPriceOracle(provider);
-  const serializedTx = await _serializeTx(provider, tx);
-
-  if (gasPriceOracle && "getL1GasUsed" in gasPriceOracle) {
-    return gasPriceOracle.getL1GasUsed(serializedTx);
-  }
-};
+}
+
+export function getL1GasPriceFetcher<P extends Provider>(provider: P) {
+  return function getL1GasPrice() {
+    const gasPriceOracle = connectGasPriceOracle(provider);
+
+    if (gasPriceOracle && "l1BaseFee" in gasPriceOracle) {
+      return gasPriceOracle?.l1BaseFee() as unknown as bigint;
+    }
+
+    return undefined;
+  };
+}
+
+function serializeTx<P extends JsonRpcProvider | BrowserProvider>(provider: P) {
+  return async function serializeTx({ from, to, nonce, ...tx }: TransactionRequest) {
+    const { Transaction } = await import("ethers");
+
+    if (!to) throw new Error("Missing to address");
+    const txParams = {
+      ...tx,
+      to: to as string,
+      nonce: nonce ? nonce : from ? await provider.getTransactionCount(from) : 0,
+    };
+
+    return Transaction.from(txParams).serialized;
+  };
+}
+
+function estimateL1GasCost<P extends JsonRpcProvider | BrowserProvider>(provider: P) {
+  return async function estimateL1GasCost(tx: TransactionRequest) {
+    const gasPriceOracle = connectGasPriceOracle(provider);
+    const serializedTx = await serializeTx(provider)(tx);
+
+    if (gasPriceOracle && "getL1Fee" in gasPriceOracle) {
+      return gasPriceOracle.getL1Fee(serializedTx);
+    }
+  };
+}
+
+function estimateL2GasCost<P extends JsonRpcProvider | BrowserProvider>(provider: P) {
+  return async function estimateL2GasCost(tx: TransactionRequest) {
+    const l2GasPrice = await provider.send("eth_gasPrice", []);
+    const l2GasCost = await provider.estimateGas(tx);
+    return l2GasPrice.mul(l2GasCost);
+  };
+}
+
+function estimateTotalGasCost<P extends JsonRpcProvider | BrowserProvider>(provider: P) {
+  return async function estimateTotalGasCost(tx: TransactionRequest) {
+    const l1GasCost = await estimateL1GasCost(provider)(tx);
+    const l2GasCost = await estimateL2GasCost(provider)(tx);
+    return l1GasCost.add(l2GasCost);
+  };
+}
+
+export function estimateL1Gas<P extends JsonRpcProvider | BrowserProvider>(provider: P) {
+  return async function estimateL1Gas(tx: TransactionRequest) {
+    const gasPriceOracle = connectGasPriceOracle(provider);
+    const serializedTx = await serializeTx(provider)(tx);
+
+    if (gasPriceOracle && "getL1GasUsed" in gasPriceOracle) {
+      return gasPriceOracle.getL1GasUsed(serializedTx);
+    }
+  };
+}
 
 const getNetworkParams = () => ({
   chainId: ChainId.OptimismHex,
@@ -96,68 +89,29 @@ const getNetworkParams = () => ({
   blockExplorerUrls: [ChainToExplorerUrl[Chain.Optimism]],
 });
 
-const estimateGasPrices = async (provider: JsonRpcProvider | BrowserProvider) => {
-  try {
-    const { maxFeePerGas, maxPriorityFeePerGas, gasPrice } = await provider.getFeeData();
-    const l1GasPrice = await getL1GasPrice(provider);
-    const price = gasPrice as bigint;
-
-    if (!(maxFeePerGas && maxPriorityFeePerGas)) {
-      throw new Error("No fee data available");
-    }
-
-    return {
-      [FeeOption.Average]: {
-        l1GasPrice,
-        gasPrice,
-        maxFeePerGas,
-        maxPriorityFeePerGas,
-      },
-      [FeeOption.Fast]: {
-        l1GasPrice: ((l1GasPrice || 0n) * 15n) / 10n,
-        gasPrice: (price * 15n) / 10n,
-        maxFeePerGas,
-        maxPriorityFeePerGas: (maxPriorityFeePerGas * 15n) / 10n,
-      },
-      [FeeOption.Fastest]: {
-        l1GasPrice: (l1GasPrice || 0n) * 2n,
-        gasPrice: price * 2n,
-        maxFeePerGas,
-        maxPriorityFeePerGas: maxPriorityFeePerGas * 2n,
-      },
-    };
-  } catch (error) {
-    throw new Error(
-      `Failed to estimate gas price: ${(error as any).msg ?? (error as any).toString()}`,
-    );
-  }
-};
-
-export const OPToolbox = ({
-  provider,
-  signer,
-}: { signer?: Signer; provider: JsonRpcProvider | BrowserProvider }) => {
-  const evmToolbox = EVMToolbox({ provider, signer });
+export async function OPToolbox({
+  provider: providerParam,
+  ...toolboxSignerParams
+}: EVMToolboxParams) {
+  const chain = Chain.Optimism;
+  const rpcUrl = SKConfig.get("rpcUrls")[chain];
+  const provider = providerParam || (await getProvider(chain, rpcUrl));
+  const signer = match(toolboxSignerParams)
+    .with({ phrase: P.string }, ({ phrase }) => HDNodeWallet.fromPhrase(phrase).connect(provider))
+    .with({ signer: P.any }, ({ signer }) => signer)
+    .otherwise(() => undefined);
+
+  const evmToolbox = BaseEVMToolbox({ provider, signer });
+  const getL1GasPrice = getL1GasPriceFetcher(provider);
 
   return {
     ...evmToolbox,
-    estimateTotalGasCost: (tx: TransactionRequest) => estimateTotalGasCost(provider, tx),
-    estimateL1GasCost: (tx: TransactionRequest) => estimateL1GasCost(provider, tx),
-    estimateL2GasCost: (tx: TransactionRequest) => estimateL2GasCost(provider, tx),
-    getL1GasPrice: () => getL1GasPrice(provider),
-    estimateL1Gas: (tx: TransactionRequest) => estimateL1Gas(provider, tx),
+    estimateL1Gas: estimateL1Gas(provider),
+    estimateL1GasCost: estimateL1GasCost(provider),
+    estimateL2GasCost: estimateL2GasCost(provider),
+    estimateTotalGasCost: estimateTotalGasCost(provider),
+    getBalance: getEvmApi(Chain.Optimism).getBalance,
+    getL1GasPrice,
     getNetworkParams,
-    estimateGasPrices: () => estimateGasPrices(provider),
-    getBalance: (
-      address: string,
-      potentialScamFilter = true,
-      overwriteProvider?: JsonRpcProvider | BrowserProvider,
-    ) =>
-      getBalance({
-        provider: overwriteProvider || provider,
-        address,
-        chain: Chain.Optimism,
-        potentialScamFilter,
-      }),
   };
-};
+}

package/src/evm/types.ts

@@ -1,6 +1,21 @@
-import type { AssetValue, FeeOption, WalletTxParams } from "@swapkit/helpers";
-import type { BigNumberish, JsonFragment, Transaction } from "ethers";
-
+import type {
+  AssetValue,
+  ChainSigner,
+  DerivationPathArray,
+  FeeOption,
+  GenericCreateTransactionParams,
+  GenericTransferParams,
+} from "@swapkit/helpers";
+import { Chain } from "@swapkit/helpers";
+import type {
+  BigNumberish,
+  BrowserProvider,
+  JsonFragment,
+  JsonRpcProvider,
+  JsonRpcSigner,
+  Signer,
+  Transaction,
+} from "ethers";
 import type {
   ARBToolbox,
   AVAXToolbox,
@@ -9,8 +24,9 @@ import type {
   ETHToolbox,
   MATICToolbox,
   OPToolbox,
-} from "./index";
-import type { getProvider } from "./provider";
+} from "./toolbox";
+
+import type { getProvider } from "./index";
 
 export enum EthNetwork {
   Test = "goerli",
@@ -22,7 +38,7 @@ export type ApproveParams = {
   spenderAddress: string;
   feeOptionKey?: FeeOption;
   amount?: BigNumberish;
-  from: string;
+  from?: string;
   // Optional fallback in case estimation for gas limit fails
   gasLimitFallback?: BigNumberish;
   nonce?: number;
@@ -39,7 +55,7 @@ export type IsApprovedParams = ApprovedParams & {
 };
 
 export type CallParams = {
-  callProvider?: ReturnType<typeof getProvider>;
+  callProvider?: Awaited<ReturnType<typeof getProvider>>;
   contractAddress: string;
   abi: readonly JsonFragment[];
   funcName: string;
@@ -53,30 +69,21 @@ export type EstimateCallParams = Pick<
   "contractAddress" | "abi" | "funcName" | "funcParams" | "txOverrides"
 >;
 
-export type TransferParams = WalletTxParams & {
+export type EVMTransferParams = GenericTransferParams & {
+  sender?: string;
+};
+
+export type EVMCreateTransactionParams = Omit<GenericCreateTransactionParams, "feeRate"> & {
   gasLimit?: bigint;
   gasPrice?: bigint;
   maxFeePerGas?: bigint;
   maxPriorityFeePerGas?: bigint;
   data?: string;
-  from: string;
   nonce?: number;
-  assetValue: AssetValue;
 };
 
-export type EVMToolboxType = ReturnType<
-  | typeof ARBToolbox
-  | typeof AVAXToolbox
-  | typeof BASEToolbox
-  | typeof BSCToolbox
-  | typeof ETHToolbox
-  | typeof MATICToolbox
-  | typeof OPToolbox
->;
-
 export type EVMMaxSendableAmountsParams = {
   from: string;
-  toolbox: EVMToolboxType;
   assetValue: AssetValue;
   feeOptionKey?: FeeOption;
   memo?: string;
@@ -109,10 +116,25 @@ export type LegacyEVMTxParams<T = bigint> = EVMTxBaseParams<T> & {
 
 export type EVMTxParams = EIP1559TxParams | LegacyEVMTxParams;
 
-export type NonETHToolbox =
-  | ReturnType<typeof ARBToolbox>
-  | ReturnType<typeof AVAXToolbox>
-  | ReturnType<typeof BSCToolbox>
-  | ReturnType<typeof MATICToolbox>
-  | ReturnType<typeof OPToolbox>
-  | ReturnType<typeof BASEToolbox>;
+export type EVMToolboxParams = {
+  provider?: BrowserProvider | JsonRpcProvider;
+} & (
+  | {
+      signer?: (ChainSigner<EVMTransferParams, string> & Signer) | JsonRpcSigner;
+    }
+  | {
+      phrase?: string;
+      derivationPath?: DerivationPathArray;
+      index?: number;
+    }
+);
+
+export type EVMToolboxes = {
+  [Chain.Arbitrum]: Awaited<ReturnType<typeof ARBToolbox>>;
+  [Chain.Avalanche]: Awaited<ReturnType<typeof AVAXToolbox>>;
+  [Chain.Base]: Awaited<ReturnType<typeof BASEToolbox>>;
+  [Chain.BinanceSmartChain]: Awaited<ReturnType<typeof BSCToolbox>>;
+  [Chain.Ethereum]: Awaited<ReturnType<typeof ETHToolbox>>;
+  [Chain.Optimism]: Awaited<ReturnType<typeof OPToolbox>>;
+  [Chain.Polygon]: Awaited<ReturnType<typeof MATICToolbox>>;
+};