@swapkit/toolboxes 0.0.0-nightly-20250304130539

package/src/evm/toolbox/evm.ts

@@ -0,0 +1,89 @@
+import { Chain, type EVMChain, FeeOption } from "@swapkit/helpers";
+import type { BrowserProvider, JsonRpcProvider, Signer } from "ethers";
+import { multicallAbi } from "../contracts/eth/multicall";
+import {
+  getBalance,
+  getEstimateTransactionFee,
+  getIsEIP1559Compatible,
+  getNetworkParams,
+} from "../helpers";
+import { BaseEVMToolbox } from "./baseEVMToolbox";
+
+export function ETHToolbox<P extends JsonRpcProvider | BrowserProvider, S extends Signer>({
+  provider,
+  signer,
+}: { signer?: S; provider: P }) {
+  const evmToolbox = 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 function ARBToolbox<P extends JsonRpcProvider | BrowserProvider, S extends Signer>({
+  provider,
+  signer,
+}: { signer?: S; provider: P }) {
+  const { estimateGasPrices: _, ...evmToolbox } = createEvmToolbox(Chain.Arbitrum)({
+    provider,
+    signer,
+  });
+
+  async function estimateGasPrices() {
+    try {
+      const { gasPrice } = await provider.getFeeData();
+
+      if (!gasPrice) throw new Error("No fee data available");
+
+      return {
+        [FeeOption.Average]: { gasPrice },
+        [FeeOption.Fast]: { gasPrice },
+        [FeeOption.Fastest]: { gasPrice },
+      };
+    } catch (error) {
+      throw new Error(
+        `Failed to estimate gas price: ${(error as any).msg ?? (error as any).toString()}`,
+      );
+    }
+  }
+
+  return { ...evmToolbox, estimateGasPrices };
+}
+
+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 function createEvmToolbox<P extends JsonRpcProvider | BrowserProvider, S extends Signer>({
+    provider,
+    signer,
+  }: { provider: P; signer?: S }) {
+    const isEIP1559Compatible = getIsEIP1559Compatible(chain);
+    const evmToolbox = BaseEVMToolbox({ provider, signer, isEIP1559Compatible });
+
+    return {
+      ...evmToolbox,
+      estimateTransactionFee: getEstimateTransactionFee({ provider, isEIP1559Compatible }),
+      getNetworkParams: getNetworkParams(chain),
+      getBalance: getBalance({ provider, chain }),
+    };
+  };
+}

package/src/evm/toolbox/getToolboxByChain.ts

@@ -0,0 +1,37 @@
+import { Chain } from "@swapkit/helpers";
+
+import { ARBToolbox, AVAXToolbox, BASEToolbox, BSCToolbox, ETHToolbox, MATICToolbox } from "./evm";
+import { OPToolbox } from "./op";
+
+type ToolboxType = {
+  ARB: typeof ARBToolbox;
+  AVAX: typeof AVAXToolbox;
+  BASE: typeof BASEToolbox;
+  BSC: typeof BSCToolbox;
+  ETH: typeof ETHToolbox;
+  MATIC: typeof MATICToolbox;
+  OP: typeof OPToolbox;
+};
+
+export const getToolboxByChain = <T extends keyof ToolboxType>(chain: T): ToolboxType[T] => {
+  switch (chain) {
+    case Chain.Avalanche:
+      return AVAXToolbox as ToolboxType[T];
+    case Chain.Arbitrum:
+      return ARBToolbox as ToolboxType[T];
+    case Chain.Base:
+      return BASEToolbox as ToolboxType[T];
+    case Chain.Optimism:
+      return OPToolbox as ToolboxType[T];
+    case Chain.Polygon:
+      return MATICToolbox as ToolboxType[T];
+    case Chain.BinanceSmartChain:
+      return BSCToolbox as ToolboxType[T];
+    case Chain.Ethereum:
+      return ETHToolbox as ToolboxType[T];
+    default:
+      throw new Error(`Chain ${chain} is not supported`);
+  }
+};
+
+export { evmValidateAddress } from "./baseEVMToolbox";

package/src/evm/toolbox/op.ts

@@ -0,0 +1,152 @@
+import {
+  BaseDecimal,
+  Chain,
+  ChainId,
+  ChainToExplorerUrl,
+  FeeOption,
+  SKConfig,
+} from "@swapkit/helpers";
+import type { BrowserProvider, JsonRpcProvider, Signer, TransactionRequest } from "ethers";
+import { Contract } from "ethers";
+
+import { gasOracleAbi } from "../contracts/op/gasOracle";
+import { getBalance } from "../helpers";
+import { BaseEVMToolbox } from "./baseEVMToolbox";
+
+const GAS_PRICE_ORACLE_ADDRESS = "0x420000000000000000000000000000000000000f";
+
+function connectGasPriceOracle<P extends JsonRpcProvider | BrowserProvider>(provider: P) {
+  return new Contract(GAS_PRICE_ORACLE_ADDRESS, gasOracleAbi, provider);
+}
+
+function getL1GasPriceFetcher<P extends JsonRpcProvider | BrowserProvider>(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,
+  chainName: "Optimism",
+  nativeCurrency: { name: "Ethereum", symbol: Chain.Ethereum, decimals: BaseDecimal.ETH },
+  rpcUrls: [SKConfig.get("rpcUrls")[Chain.Optimism]],
+  blockExplorerUrls: [ChainToExplorerUrl[Chain.Optimism]],
+});
+
+function estimateGasPrices<P extends JsonRpcProvider | BrowserProvider>(provider: P) {
+  return async function estimateGasPrices() {
+    try {
+      const { maxFeePerGas, maxPriorityFeePerGas, gasPrice } = await provider.getFeeData();
+      const l1GasPrice = getL1GasPriceFetcher(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 function OPToolbox<P extends JsonRpcProvider | BrowserProvider, S extends Signer>({
+  provider,
+  signer,
+}: { signer?: S; provider: P }) {
+  const evmToolbox = BaseEVMToolbox({ provider, signer });
+  const getL1GasPrice = getL1GasPriceFetcher(provider);
+
+  return {
+    ...evmToolbox,
+    estimateGasPrices: estimateGasPrices(provider),
+    estimateL1Gas: estimateL1Gas(provider),
+    estimateL1GasCost: estimateL1GasCost(provider),
+    estimateL2GasCost: estimateL2GasCost(provider),
+    estimateTotalGasCost: estimateTotalGasCost(provider),
+    getBalance: getBalance({ provider, chain: Chain.Optimism }),
+    getL1GasPrice,
+    getNetworkParams,
+  };
+}

package/src/evm/types.ts

@@ -0,0 +1,110 @@
+import type { AssetValue, FeeOption, WalletTxParams } from "@swapkit/helpers";
+import type { BigNumberish, JsonFragment, Transaction } from "ethers";
+
+import type {
+  ARBToolbox,
+  AVAXToolbox,
+  BASEToolbox,
+  BSCToolbox,
+  ETHToolbox,
+  MATICToolbox,
+  OPToolbox,
+  getProvider,
+} from "./index";
+
+export enum EthNetwork {
+  Test = "goerli",
+  Main = "homestead",
+}
+
+export type ApproveParams = {
+  assetAddress: string;
+  spenderAddress: string;
+  feeOptionKey?: FeeOption;
+  amount?: BigNumberish;
+  from: string;
+  // Optional fallback in case estimation for gas limit fails
+  gasLimitFallback?: BigNumberish;
+  nonce?: number;
+};
+
+export type ApprovedParams = {
+  assetAddress: string;
+  spenderAddress: string;
+  from: string;
+};
+
+export type IsApprovedParams = ApprovedParams & {
+  amount?: BigNumberish;
+};
+
+export type CallParams = {
+  callProvider?: ReturnType<typeof getProvider>;
+  contractAddress: string;
+  abi: readonly JsonFragment[];
+  funcName: string;
+  funcParams?: unknown[];
+  txOverrides?: Partial<Transaction>;
+  feeOption?: FeeOption;
+};
+
+export type EstimateCallParams = Pick<
+  CallParams,
+  "contractAddress" | "abi" | "funcName" | "funcParams" | "txOverrides"
+>;
+
+export type TransferParams = WalletTxParams & {
+  gasLimit?: bigint;
+  gasPrice?: bigint;
+  maxFeePerGas?: bigint;
+  maxPriorityFeePerGas?: bigint;
+  data?: string;
+  from: string;
+  nonce?: number;
+  assetValue: AssetValue;
+};
+
+export type BaseEVMToolboxType = ReturnType<
+  | typeof ARBToolbox
+  | typeof AVAXToolbox
+  | typeof BASEToolbox
+  | typeof BSCToolbox
+  | typeof ETHToolbox
+  | typeof MATICToolbox
+  | typeof OPToolbox
+>;
+
+export type EVMMaxSendableAmountsParams = {
+  from: string;
+  toolbox: BaseEVMToolboxType;
+  assetValue: AssetValue;
+  feeOptionKey?: FeeOption;
+  memo?: string;
+  abi?: readonly JsonFragment[];
+  funcName?: string;
+  contractAddress?: string;
+  funcParams?: unknown[];
+  txOverrides?: Partial<Transaction>;
+};
+
+export type EVMTxBaseParams<T = bigint> = {
+  to?: string;
+  from?: string;
+  nonce?: number;
+  gasLimit?: T;
+  data?: string;
+  value?: T;
+  chainId?: T;
+};
+
+export type EIP1559TxParams<T = bigint> = EVMTxBaseParams<T> & {
+  type?: number;
+  maxFeePerGas?: T;
+  maxPriorityFeePerGas?: T;
+};
+
+export type LegacyEVMTxParams<T = bigint> = EVMTxBaseParams<T> & {
+  gasPrice?: T;
+};
+
+export type EVMTxParams = EIP1559TxParams | LegacyEVMTxParams;

package/src/radix/index.ts

@@ -0,0 +1,151 @@
+import type {
+  FungibleResourcesCollectionItem,
+  GatewayApiClient,
+  StateEntityDetailsVaultResponseItem,
+  StateEntityFungiblesPageRequest,
+  StateEntityFungiblesPageResponse,
+} from "@radixdlt/babylon-gateway-api-sdk";
+import { AssetValue, Chain, type SKConfigIntegrations } from "@swapkit/helpers";
+
+export type RadixWallets = {
+  [Chain.Radix]: Awaited<ReturnType<typeof RadixToolbox>>;
+};
+
+type RadixGetBalanceParams = {
+  address: string;
+  networkApi: GatewayApiClient;
+};
+// Could not find anything sync in SDK, ask Radix team
+export function validateAddress(address: string) {
+  return address.startsWith("account_rdx1") && address.length === 66;
+}
+
+function getBalance({ networkApi }: { networkApi: GatewayApiClient }) {
+  return async function getBalance(address: string) {
+    const fungibleResources = await fetchFungibleResources({ address, networkApi });
+    const fungibleBalances = convertResourcesToBalances({
+      resources: fungibleResources,
+      networkApi,
+    });
+    return fungibleBalances;
+  };
+}
+
+async function fetchFungibleResources({
+  address,
+  networkApi,
+}: RadixGetBalanceParams): Promise<FungibleResourcesCollectionItem[]> {
+  let hasNextPage = true;
+  let nextCursor: string | undefined;
+  let fungibleResources: FungibleResourcesCollectionItem[] = [];
+  const stateVersion = await currentStateVersion(networkApi);
+  while (hasNextPage) {
+    const stateEntityFungiblesPageRequest: StateEntityFungiblesPageRequest = {
+      address: address,
+      limit_per_page: 100,
+      cursor: nextCursor,
+      at_ledger_state: {
+        state_version: stateVersion,
+      },
+    };
+
+    const stateEntityFungiblesPageResponse: StateEntityFungiblesPageResponse =
+      await networkApi.state.innerClient.entityFungiblesPage({
+        stateEntityFungiblesPageRequest: stateEntityFungiblesPageRequest,
+      });
+
+    fungibleResources = fungibleResources.concat(stateEntityFungiblesPageResponse.items);
+    if (stateEntityFungiblesPageResponse.next_cursor) {
+      nextCursor = stateEntityFungiblesPageResponse.next_cursor;
+    } else {
+      hasNextPage = false;
+    }
+  }
+  return fungibleResources;
+}
+
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: <explanation>
+async function convertResourcesToBalances({
+  resources,
+  networkApi,
+}: {
+  resources: FungibleResourcesCollectionItem[]; //| NonFungibleResourcesCollectionItem[];
+  networkApi: GatewayApiClient;
+}): Promise<AssetValue[]> {
+  const balances: AssetValue[] = [];
+  const BATCH_SIZE = 50;
+
+  // Split resources into batches of up to 50 items
+  const resourceBatches: FungibleResourcesCollectionItem[][] = [];
+  for (let i = 0; i < resources.length; i += BATCH_SIZE) {
+    resourceBatches.push(resources.slice(i, i + BATCH_SIZE));
+  }
+
+  for (const batch of resourceBatches) {
+    const addresses = batch.map((item) => item.resource_address);
+    const response: StateEntityDetailsVaultResponseItem[] =
+      await networkApi.state.getEntityDetailsVaultAggregated(addresses);
+
+    const divisibilities = new Map<string, { decimals: number; symbol: string }>();
+
+    for (const result of response) {
+      if (result.details !== undefined) {
+        const metaDataSymbol = result.metadata?.items.find((item) => item.key === "symbol");
+        const symbol =
+          metaDataSymbol?.value.typed.type === "String" ? metaDataSymbol.value.typed.value : "?";
+
+        if (result.details.type === "FungibleResource") {
+          divisibilities.set(result.address, {
+            decimals: result.details.divisibility,
+            symbol,
+          });
+        }
+      }
+    }
+
+    for (const item of batch) {
+      if (item.aggregation_level === "Global") {
+        const assetInfo = divisibilities.get(item.resource_address) || { decimals: 0, symbol: "?" };
+
+        const balance = AssetValue.from({
+          asset:
+            assetInfo.symbol !== Chain.Radix
+              ? `${Chain.Radix}.${assetInfo.symbol}-${item.resource_address}`
+              : "XRD.XRD",
+          value: item.amount,
+        });
+        balances.push(balance);
+      }
+    }
+  }
+
+  return balances;
+}
+
+async function currentStateVersion(networkApi: GatewayApiClient) {
+  return networkApi.status.getCurrent().then((status) => status.ledger_state.state_version);
+}
+
+export const RadixToolbox = async ({
+  dappConfig,
+}: { dappConfig: SKConfigIntegrations["radix"] }) => {
+  const { RadixDappToolkit } = await import("@radixdlt/radix-dapp-toolkit");
+  const { GatewayApiClient } = await import("@radixdlt/babylon-gateway-api-sdk");
+
+  const radixToolkit = RadixDappToolkit({
+    ...dappConfig,
+    networkId: dappConfig.network?.networkId || 1,
+  });
+
+  const networkApi = GatewayApiClient.initialize(radixToolkit.gatewayApi.clientConfig);
+
+  return {
+    getAddress: () => "",
+    getBalance: getBalance({ networkApi }),
+    networkApi,
+    validateAddress,
+    signAndBroadcast: (() => {
+      throw new Error("Not implemented");
+    }) as (params: any) => Promise<string>,
+  };
+};