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

package/src/evm/__tests__/ethereum.test.ts

@@ -1,141 +0,0 @@
-import { afterEach, beforeAll, beforeEach, describe, expect, test } from "bun:test";
-import type ethers from "@nomicfoundation/hardhat-ethers";
-import helpers from "@nomicfoundation/hardhat-network-helpers";
-import { AssetValue, Chain, SKConfig } from "@swapkit/helpers";
-import { erc20ABI } from "@swapkit/helpers/contracts";
-import type { JsonRpcProvider } from "ethers";
-import hre from "hardhat";
-import { getProvider } from "../helpers";
-import { getEvmToolbox } from "../toolbox";
-
-const testAddress = "0x6d6e022eE439C8aB8B7a7dBb0576f8090319CDc6";
-const emptyRecipient = "0xE29E61479420Dd1029A9946710Ac31A0d140e77F";
-const USDCAddress = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48";
-// Get latest block to use as base for reset fork after test
-const block = await hre.ethers.provider.getBlock("latest");
-
-beforeAll(() => {
-  hre.run("node");
-});
-
-const context: {
-  ethers: typeof ethers;
-  provider: JsonRpcProvider;
-  toolbox: Awaited<ReturnType<typeof getEvmToolbox>>;
-} = {} as any;
-
-beforeEach(async () => {
-  context.ethers = hre.artifacts;
-  const provider = await getProvider(Chain.Ethereum, "http://127.0.0.1:8545/");
-  const signer = await hre.ethers.getImpersonatedSigner(testAddress);
-
-  SKConfig.set({
-    apiKeys: {
-      swapKit: process.env.TEST_API_KEY || Bun.env.TEST_API_KEY,
-    },
-  });
-  context.provider = provider;
-  context.toolbox = await getEvmToolbox(Chain.Ethereum, { provider, signer: signer as any });
-});
-
-afterEach(async () => {
-  await helpers.reset(hre.config.networks.hardhat.forking?.url, block?.number);
-});
-
-describe("Ethereum toolkit", () => {
-  // biome-ignore lint/suspicious/noSkippedTests: env not setup correctly
-  test.skip("Get Balances", async () => {
-    const balances = await context.toolbox.getBalance(testAddress);
-    expect(balances.find((balance) => balance.symbol === "ETH")?.getBaseValue("string")).toBe(
-      "20526000000000000",
-    );
-    expect(
-      balances
-        .find(
-          (balance) =>
-            balance.symbol.toLowerCase() ===
-            "USDC-0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48".toLowerCase(),
-        )
-        ?.getBaseValue("string"),
-    ).toBe("6656178");
-  }, 10000);
-
-  test("Send ETH", async () => {
-    expect((await context.provider.getBalance(emptyRecipient)).toString()).toBe("0");
-    await context.toolbox.transfer({
-      recipient: emptyRecipient,
-      assetValue: await AssetValue.from({ chain: Chain.Ethereum, value: "0.010526" }),
-      sender: testAddress,
-    });
-    expect((await context.provider.getBalance(emptyRecipient)).toString()).toBe(
-      "10526000000000000",
-    );
-  }, 10000);
-
-  test("Send Token", async () => {
-    const USDC = await context.toolbox.createContract(USDCAddress, erc20ABI);
-    const balance = await USDC.balanceOf?.(emptyRecipient);
-    expect(balance.toString()).toBe("0");
-
-    await AssetValue.loadStaticAssets(["thorchain"]);
-
-    const assetValue = AssetValue.from({
-      asset: "ETH.USDC-0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
-      value: "1",
-    });
-
-    await context.toolbox.transfer({
-      recipient: emptyRecipient,
-      assetValue,
-      sender: testAddress,
-    });
-    // biome-ignore lint/correctness/noUnsafeOptionalChaining: <explanation>
-    expect((await USDC.balanceOf?.(emptyRecipient)).toString()).toBe("1000000");
-  }, 10000);
-
-  test("Approve Token and validate approved amount", async () => {
-    expect(
-      await context.toolbox.isApproved({
-        assetAddress: USDCAddress,
-        spenderAddress: emptyRecipient,
-        from: testAddress,
-        amount: "1000000",
-      }),
-    ).toBe(false);
-
-    await context.toolbox.approve({
-      assetAddress: USDCAddress,
-      spenderAddress: emptyRecipient,
-      amount: "1000000",
-    });
-
-    expect(
-      await context.toolbox.isApproved({
-        assetAddress: USDCAddress,
-        spenderAddress: emptyRecipient,
-        from: testAddress,
-        amount: "1000000",
-      }),
-    ).toBe(true);
-  }, 10000);
-
-  test("Create contract tx object and sendTransaction", async () => {
-    const USDC = context.toolbox.createContract(USDCAddress, erc20ABI);
-    const balance = await USDC.balanceOf?.(emptyRecipient);
-    expect(balance.toString()).toBe("0");
-
-    const txObject = await context.toolbox.createContractTxObject({
-      contractAddress: USDCAddress,
-      abi: erc20ABI,
-      funcName: "transfer",
-      funcParams: [emptyRecipient, BigInt("2222222")],
-      txOverrides: {
-        from: testAddress,
-      },
-    });
-
-    await context.toolbox.sendTransaction(txObject);
-    // biome-ignore lint/correctness/noUnsafeOptionalChaining: <explanation>
-    expect((await USDC?.balanceOf?.(emptyRecipient)).toString()).toBe("2222222");
-  }, 10000);
-});

package/src/evm/api.ts

@@ -1,21 +0,0 @@
-import { type EVMChain, SKConfig, warnOnce } from "@swapkit/helpers";
-import { getBalance } from "../utils";
-
-export function getEvmApi(chain: EVMChain) {
-  const customEvmApi = SKConfig.get("apis")[chain];
-
-  if (customEvmApi) {
-    warnOnce(true, "Using custom EVM API. Be sure to implement all methods to avoid issues.");
-    return customEvmApi as ReturnType<typeof evmApi>;
-  }
-
-  return evmApi(chain);
-}
-
-export function createCustomEvmApi(methods: ReturnType<typeof getEvmApi>) {
-  return methods;
-}
-
-function evmApi(chain: EVMChain) {
-  return { getBalance: getBalance(chain) };
-}

package/src/evm/contracts/eth/multicall.ts

@@ -1,165 +0,0 @@
-export const multicallAbi = [
-  {
-    inputs: [
-      {
-        components: [
-          { internalType: "address", name: "target", type: "address" },
-          { internalType: "bytes", name: "callData", type: "bytes" },
-        ],
-        internalType: "struct Multicall2.Call[]",
-        name: "calls",
-        type: "tuple[]",
-      },
-    ],
-    name: "aggregate",
-    outputs: [
-      { internalType: "uint256", name: "blockNumber", type: "uint256" },
-      { internalType: "bytes[]", name: "returnData", type: "bytes[]" },
-    ],
-    stateMutability: "nonpayable",
-    type: "function",
-  },
-  {
-    inputs: [
-      {
-        components: [
-          { internalType: "address", name: "target", type: "address" },
-          { internalType: "bytes", name: "callData", type: "bytes" },
-        ],
-        internalType: "struct Multicall2.Call[]",
-        name: "calls",
-        type: "tuple[]",
-      },
-    ],
-    name: "blockAndAggregate",
-    outputs: [
-      { internalType: "uint256", name: "blockNumber", type: "uint256" },
-      { internalType: "bytes32", name: "blockHash", type: "bytes32" },
-      {
-        components: [
-          { internalType: "bool", name: "success", type: "bool" },
-          { internalType: "bytes", name: "returnData", type: "bytes" },
-        ],
-        internalType: "struct Multicall2.Result[]",
-        name: "returnData",
-        type: "tuple[]",
-      },
-    ],
-    stateMutability: "nonpayable",
-    type: "function",
-  },
-  {
-    inputs: [{ internalType: "uint256", name: "blockNumber", type: "uint256" }],
-    name: "getBlockHash",
-    outputs: [{ internalType: "bytes32", name: "blockHash", type: "bytes32" }],
-    stateMutability: "view",
-    type: "function",
-  },
-  {
-    inputs: [],
-    name: "getBlockNumber",
-    outputs: [{ internalType: "uint256", name: "blockNumber", type: "uint256" }],
-    stateMutability: "view",
-    type: "function",
-  },
-  {
-    inputs: [],
-    name: "getCurrentBlockCoinbase",
-    outputs: [{ internalType: "address", name: "coinbase", type: "address" }],
-    stateMutability: "view",
-    type: "function",
-  },
-  {
-    inputs: [],
-    name: "getCurrentBlockDifficulty",
-    outputs: [{ internalType: "uint256", name: "difficulty", type: "uint256" }],
-    stateMutability: "view",
-    type: "function",
-  },
-  {
-    inputs: [],
-    name: "getCurrentBlockGasLimit",
-    outputs: [{ internalType: "uint256", name: "gaslimit", type: "uint256" }],
-    stateMutability: "view",
-    type: "function",
-  },
-  {
-    inputs: [],
-    name: "getCurrentBlockTimestamp",
-    outputs: [{ internalType: "uint256", name: "timestamp", type: "uint256" }],
-    stateMutability: "view",
-    type: "function",
-  },
-  {
-    inputs: [{ internalType: "address", name: "addr", type: "address" }],
-    name: "getEthBalance",
-    outputs: [{ internalType: "uint256", name: "balance", type: "uint256" }],
-    stateMutability: "view",
-    type: "function",
-  },
-  {
-    inputs: [],
-    name: "getLastBlockHash",
-    outputs: [{ internalType: "bytes32", name: "blockHash", type: "bytes32" }],
-    stateMutability: "view",
-    type: "function",
-  },
-  {
-    inputs: [
-      { internalType: "bool", name: "requireSuccess", type: "bool" },
-      {
-        components: [
-          { internalType: "address", name: "target", type: "address" },
-          { internalType: "bytes", name: "callData", type: "bytes" },
-        ],
-        internalType: "struct Multicall2.Call[]",
-        name: "calls",
-        type: "tuple[]",
-      },
-    ],
-    name: "tryAggregate",
-    outputs: [
-      {
-        components: [
-          { internalType: "bool", name: "success", type: "bool" },
-          { internalType: "bytes", name: "returnData", type: "bytes" },
-        ],
-        internalType: "struct Multicall2.Result[]",
-        name: "returnData",
-        type: "tuple[]",
-      },
-    ],
-    stateMutability: "nonpayable",
-    type: "function",
-  },
-  {
-    inputs: [
-      { internalType: "bool", name: "requireSuccess", type: "bool" },
-      {
-        components: [
-          { internalType: "address", name: "target", type: "address" },
-          { internalType: "bytes", name: "callData", type: "bytes" },
-        ],
-        internalType: "struct Multicall2.Call[]",
-        name: "calls",
-        type: "tuple[]",
-      },
-    ],
-    name: "tryBlockAndAggregate",
-    outputs: [
-      { internalType: "uint256", name: "blockNumber", type: "uint256" },
-      { internalType: "bytes32", name: "blockHash", type: "bytes32" },
-      {
-        components: [
-          { internalType: "bool", name: "success", type: "bool" },
-          { internalType: "bytes", name: "returnData", type: "bytes" },
-        ],
-        internalType: "struct Multicall2.Result[]",
-        name: "returnData",
-        type: "tuple[]",
-      },
-    ],
-    stateMutability: "nonpayable",
-    type: "function",
-  },
-];

package/src/evm/contracts/op/gasOracle.ts

@@ -1,151 +0,0 @@
-export const gasOracleAbi = [
-  {
-    inputs: [{ internalType: "address", name: "_owner", type: "address" }],
-    stateMutability: "nonpayable",
-    type: "constructor",
-  },
-  {
-    anonymous: false,
-    inputs: [{ indexed: false, internalType: "uint256", name: "", type: "uint256" }],
-    name: "DecimalsUpdated",
-    type: "event",
-  },
-  {
-    anonymous: false,
-    inputs: [{ indexed: false, internalType: "uint256", name: "", type: "uint256" }],
-    name: "GasPriceUpdated",
-    type: "event",
-  },
-  {
-    anonymous: false,
-    inputs: [{ indexed: false, internalType: "uint256", name: "", type: "uint256" }],
-    name: "L1BaseFeeUpdated",
-    type: "event",
-  },
-  {
-    anonymous: false,
-    inputs: [{ indexed: false, internalType: "uint256", name: "", type: "uint256" }],
-    name: "OverheadUpdated",
-    type: "event",
-  },
-  {
-    anonymous: false,
-    inputs: [
-      { indexed: true, internalType: "address", name: "previousOwner", type: "address" },
-      { indexed: true, internalType: "address", name: "newOwner", type: "address" },
-    ],
-    name: "OwnershipTransferred",
-    type: "event",
-  },
-  {
-    anonymous: false,
-    inputs: [{ indexed: false, internalType: "uint256", name: "", type: "uint256" }],
-    name: "ScalarUpdated",
-    type: "event",
-  },
-  {
-    inputs: [],
-    name: "decimals",
-    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
-    stateMutability: "view",
-    type: "function",
-  },
-  {
-    inputs: [],
-    name: "gasPrice",
-    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
-    stateMutability: "view",
-    type: "function",
-  },
-  {
-    inputs: [{ internalType: "bytes", name: "_data", type: "bytes" }],
-    name: "getL1Fee",
-    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
-    stateMutability: "view",
-    type: "function",
-  },
-  {
-    inputs: [{ internalType: "bytes", name: "_data", type: "bytes" }],
-    name: "getL1GasUsed",
-    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
-    stateMutability: "view",
-    type: "function",
-  },
-  {
-    inputs: [],
-    name: "l1BaseFee",
-    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
-    stateMutability: "view",
-    type: "function",
-  },
-  {
-    inputs: [],
-    name: "overhead",
-    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
-    stateMutability: "view",
-    type: "function",
-  },
-  {
-    inputs: [],
-    name: "owner",
-    outputs: [{ internalType: "address", name: "", type: "address" }],
-    stateMutability: "view",
-    type: "function",
-  },
-  {
-    inputs: [],
-    name: "renounceOwnership",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function",
-  },
-  {
-    inputs: [],
-    name: "scalar",
-    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
-    stateMutability: "view",
-    type: "function",
-  },
-  {
-    inputs: [{ internalType: "uint256", name: "_decimals", type: "uint256" }],
-    name: "setDecimals",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function",
-  },
-  {
-    inputs: [{ internalType: "uint256", name: "_gasPrice", type: "uint256" }],
-    name: "setGasPrice",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function",
-  },
-  {
-    inputs: [{ internalType: "uint256", name: "_baseFee", type: "uint256" }],
-    name: "setL1BaseFee",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function",
-  },
-  {
-    inputs: [{ internalType: "uint256", name: "_overhead", type: "uint256" }],
-    name: "setOverhead",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function",
-  },
-  {
-    inputs: [{ internalType: "uint256", name: "_scalar", type: "uint256" }],
-    name: "setScalar",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function",
-  },
-  {
-    inputs: [{ internalType: "address", name: "newOwner", type: "address" }],
-    name: "transferOwnership",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function",
-  },
-];

package/src/evm/helpers.ts

@@ -1,194 +0,0 @@
-import {
-  AssetValue,
-  BaseDecimal,
-  Chain,
-  ChainToExplorerUrl,
-  ChainToHexChainId,
-  type EVMChain,
-  FeeOption,
-  type NetworkParams,
-  SKConfig,
-  SwapKitError,
-  SwapKitNumber,
-} from "@swapkit/helpers";
-import type { BrowserProvider, Provider } from "ethers";
-
-import { getEstimateGasPrices } from "./toolbox/baseEVMToolbox";
-import type { EIP1559TxParams, EVMMaxSendableAmountsParams } from "./types";
-
-export async function getProvider(chain: EVMChain, customUrl?: string) {
-  const { JsonRpcProvider } = await import("ethers");
-
-  return new JsonRpcProvider(customUrl || SKConfig.get("rpcUrls")[chain]);
-}
-
-/**
- * @deprecated
- */
-export const estimateMaxSendableAmount = async ({
-  from,
-  memo = "",
-  feeOptionKey = FeeOption.Fastest,
-  assetValue,
-  abi,
-  funcName,
-  funcParams,
-  contractAddress,
-  txOverrides,
-}: EVMMaxSendableAmountsParams): Promise<AssetValue> => {
-  const { getEvmToolbox } = await import("@swapkit/toolboxes/evm");
-  const toolbox = await getEvmToolbox(assetValue.chain as EVMChain);
-
-  const balances = await toolbox.getBalance(from);
-  const balance = balances.find(({ symbol, chain }) =>
-    assetValue ? symbol === assetValue.symbol : symbol === AssetValue.from({ chain })?.symbol,
-  );
-
-  const gasRate = (await toolbox.estimateGasPrices())[feeOptionKey];
-
-  if (!balance) return AssetValue.from({ chain: assetValue.chain });
-
-  if (assetValue && (balance.chain !== assetValue.chain || balance.symbol !== assetValue?.symbol)) {
-    return balance;
-  }
-
-  const gasLimit =
-    abi && funcName && funcParams && contractAddress
-      ? await toolbox.estimateCall({
-          contractAddress,
-          abi,
-          funcName,
-          funcParams,
-          txOverrides,
-        })
-      : await toolbox.estimateGasLimit({
-          sender: from,
-          recipient: from,
-          memo,
-          assetValue,
-        });
-
-  const isFeeEIP1559Compatible = "maxFeePerGas" in gasRate;
-  const isFeeEVMLegacyCompatible = "gasPrice" in gasRate && gasRate.gasPrice !== undefined;
-
-  if (!(gasRate && (isFeeEVMLegacyCompatible || isFeeEIP1559Compatible))) {
-    throw new SwapKitError("toolbox_evm_no_fee_data");
-  }
-
-  const gasPrice = isFeeEIP1559Compatible
-    ? (gasRate.maxFeePerGas || 1n) + (gasRate.maxPriorityFeePerGas || 1n)
-    : gasRate.gasPrice || 1n;
-
-  const fee = gasLimit * gasPrice;
-  const maxSendableAmount = SwapKitNumber.fromBigInt(balance.getBaseValue("bigint")).sub(
-    fee.toString(),
-  );
-
-  return AssetValue.from({ chain: balance.chain, value: maxSendableAmount.getValue("string") });
-};
-
-export function toHexString(value: bigint) {
-  return value > 0n ? `0x${value.toString(16)}` : "0x0";
-}
-
-export function getEstimateTransactionFee({
-  provider,
-  isEIP1559Compatible = true,
-}: { provider: Provider | BrowserProvider; isEIP1559Compatible?: boolean; chain: EVMChain }) {
-  return async function estimateTransactionFee({
-    feeOption = FeeOption.Fast,
-    chain,
-    ...txObject
-  }: EIP1559TxParams & { feeOption: FeeOption; chain: EVMChain }) {
-    const estimateGasPrices = getEstimateGasPrices({ provider, isEIP1559Compatible, chain });
-    const gasPrices = await estimateGasPrices();
-    const gasLimit = await provider.estimateGas(txObject);
-
-    const assetValue = AssetValue.from({ chain });
-    const { gasPrice, maxFeePerGas, maxPriorityFeePerGas } = gasPrices[feeOption];
-
-    if (!isEIP1559Compatible && gasPrice) {
-      return assetValue.set(SwapKitNumber.fromBigInt(gasPrice * gasLimit, assetValue.decimal));
-    }
-
-    if (maxFeePerGas && maxPriorityFeePerGas) {
-      const fee = (maxFeePerGas + maxPriorityFeePerGas) * gasLimit;
-
-      return assetValue.set(SwapKitNumber.fromBigInt(fee, assetValue.decimal));
-    }
-
-    throw new SwapKitError("toolbox_evm_no_gas_price");
-  };
-}
-
-export function getNetworkParams<C extends EVMChain>(chain: C) {
-  return () =>
-    (Chain.Ethereum === chain
-      ? undefined
-      : {
-          ...getNetworkInfo({ chain }),
-          chainId: ChainToHexChainId[chain],
-          rpcUrls: [SKConfig.get("rpcUrls")[chain]],
-          blockExplorerUrls: [ChainToExplorerUrl[chain]],
-        }) as C extends Chain.Ethereum ? undefined : NetworkParams;
-}
-
-export function getIsEIP1559Compatible<C extends EVMChain>(chain: C) {
-  const notCompatible = [Chain.Arbitrum, Chain.BinanceSmartChain];
-
-  return !notCompatible.includes(chain);
-}
-
-function getNetworkInfo<C extends EVMChain>({ chain }: { chain: C }) {
-  const decimals = BaseDecimal[chain];
-
-  switch (chain) {
-    case Chain.Arbitrum:
-      return {
-        chainName: "Arbitrum One",
-        nativeCurrency: { name: "Ethereum", symbol: Chain.Ethereum, decimals },
-      };
-    case Chain.Aurora:
-      return {
-        chainName: "Aurora Mainnet",
-        nativeCurrency: { name: "Ethereum", symbol: Chain.Ethereum, decimals },
-      };
-    case Chain.Avalanche:
-      return {
-        chainName: "Avalanche Network",
-        nativeCurrency: { name: "Avalanche", symbol: chain, decimals },
-      };
-    case Chain.Base:
-      return {
-        chainName: "Base Mainnet",
-        nativeCurrency: { name: "Ethereum", symbol: Chain.Ethereum, decimals },
-      };
-    case Chain.Berachain:
-      return {
-        chainName: "Berachain",
-        nativeCurrency: { name: "Berachain", symbol: "BERA", decimals },
-      };
-    case Chain.BinanceSmartChain:
-      return {
-        chainName: "BNB Smart Chain Mainnet",
-        nativeCurrency: { name: "Binance Coin", symbol: "BNB", decimals },
-      };
-    case Chain.Gnosis:
-      return {
-        chainName: "Gnosis",
-        nativeCurrency: { name: "xDAI", symbol: "XDAI", decimals },
-      };
-    case Chain.Optimism:
-      return {
-        chainName: "OP Mainnet",
-        nativeCurrency: { name: "Ethereum", symbol: Chain.Ethereum, decimals },
-      };
-    case Chain.Polygon:
-      return {
-        chainName: "Polygon Mainnet",
-        nativeCurrency: { name: "Polygon", symbol: Chain.Polygon, decimals },
-      };
-    default:
-      throw new SwapKitError("toolbox_evm_not_supported", { chain });
-  }
-}