@swapkit/toolboxes 1.0.0-beta.0

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

@@ -0,0 +1,147 @@
+import { afterEach, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import type ethers from "@nomicfoundation/hardhat-ethers";
+import { AssetValue, Chain, FeeOption } from "@swapkit/helpers";
+import { erc20ABI } from "@swapkit/helpers/contracts";
+import type { JsonRpcProvider } from "ethers";
+// import hre from "hardhat";
+
+import type { ETHToolbox } from "../index";
+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: ReturnType<typeof ETHToolbox>;
+} = {} as any;
+
+beforeEach(async () => {
+  // context.ethers = hre.artifacts;
+  // const provider = getProvider(Chain.Ethereum, "http://127.0.0.1:8545/");
+  // const signer = (await hre.ethers.getImpersonatedSigner(testAddress)) as unknown as JsonRpcSigner;
+  // context.provider = provider;
+  // context.toolbox = ETHToolbox({ provider, signer });
+});
+
+afterEach(async () => {
+  // await helpers.reset(hre.config.networks.hardhat.forking?.url, block?.number);
+});
+
+describe("Ethereum toolkit", () => {
+  test.todo(
+    "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.todo(
+    "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" }),
+        from: testAddress,
+      });
+      expect((await context.provider.getBalance(emptyRecipient)).toString()).toBe(
+        "10526000000000000",
+      );
+    },
+    10000,
+  );
+
+  test.todo(
+    "Send Token",
+    async () => {
+      const USDC = await context.toolbox.createContract(USDCAddress, erc20ABI, context.provider);
+      const balance = await USDC.balanceOf?.(emptyRecipient);
+      expect(balance.toString()).toBe("0");
+      await context.toolbox.transfer({
+        recipient: emptyRecipient,
+        assetValue: await AssetValue.from({
+          asset: "ETH.USDC-0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+          value: "1",
+        }),
+        from: testAddress,
+      });
+      // biome-ignore lint/correctness/noUnsafeOptionalChaining: <explanation>
+      expect((await USDC.balanceOf?.(emptyRecipient)).toString()).toBe("1000000");
+    },
+    10000,
+  );
+
+  test.todo(
+    "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",
+        from: testAddress,
+      });
+
+      expect(
+        await context.toolbox.isApproved({
+          assetAddress: USDCAddress,
+          spenderAddress: emptyRecipient,
+          from: testAddress,
+          amount: "1000000",
+        }),
+      ).toBe(true);
+    },
+    10000,
+  );
+
+  test.todo(
+    "Create contract tx object and sendTransaction",
+    async () => {
+      const USDC = context.toolbox.createContract(USDCAddress, erc20ABI, context.provider);
+      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, FeeOption.Average);
+      // biome-ignore lint/correctness/noUnsafeOptionalChaining: <explanation>
+      expect((await USDC?.balanceOf?.(emptyRecipient)).toString()).toBe("2222222");
+    },
+    10000,
+  );
+});

package/src/evm/api.ts

@@ -0,0 +1,157 @@
+import {
+  Chain,
+  ChainToChainId,
+  type EVMChain,
+  RequestClient,
+  SKConfig,
+  formatBigIntToSafeValue,
+  warnOnce,
+} from "@swapkit/helpers";
+
+async function getEthplorerBalance({ address }: { address: string }) {
+  const apiKey = SKConfig.get("apiKeys").ethplorer || "freekey";
+
+  const { tokens = [] } = await RequestClient.get<AddressInfo>(
+    `https://api.ethplorer.io/getAddressInfo/${address}`,
+    { searchParams: { apiKey } },
+  );
+
+  return tokens
+    .filter(({ tokenInfo: { symbol }, rawBalance }) => symbol && rawBalance !== "0")
+    .map(({ tokenInfo: { symbol, decimals, address: tokenAddress }, rawBalance }) => ({
+      chain: Chain.Ethereum,
+      decimal: Number.parseInt(decimals),
+      symbol: tokenAddress ? `${symbol}-${tokenAddress}` : symbol,
+      value: formatBigIntToSafeValue({
+        value: BigInt(rawBalance),
+        decimal: Number.parseInt(decimals),
+        bigIntDecimal: Number.parseInt(decimals),
+      }),
+    }));
+}
+
+async function getCovalentBalance({ chain, address }: { chain: Chain; address: string }) {
+  const apiKey = SKConfig.get("apiKeys").covalent;
+
+  if (!apiKey) {
+    warnOnce(true, "No covalent api key found. Use SKConfig.setApiKey('your-api-key')");
+    return [];
+  }
+
+  const { data } = await RequestClient.get<{ data: CovalentBalanceResponse }>(
+    `https://api.covalenthq.com/v1/${ChainToChainId[chain]}/address/${address}/balances_v2/`,
+    { searchParams: { key: apiKey } },
+  );
+
+  return (data?.items || [])
+    .filter(({ is_spam }) => !is_spam)
+    .map(
+      ({ balance, contract_decimals, contract_ticker_symbol, contract_address, native_token }) => ({
+        value: formatBigIntToSafeValue({
+          value: BigInt(balance),
+          decimal: contract_decimals,
+          bigIntDecimal: contract_decimals,
+        }),
+        decimal: contract_decimals,
+        chain,
+        symbol: `${contract_ticker_symbol || "Unknown"}${native_token ? "" : `-${contract_address}`}`,
+      }),
+    );
+}
+
+export function getEvmApi(chain: EVMChain) {
+  const getBalance = chain === Chain.Ethereum ? getEthplorerBalance : getCovalentBalance;
+  return { getBalance: (address: string) => getBalance({ address, chain }) };
+}
+
+export function createCustomEvmApi(methods: ReturnType<typeof getEvmApi>) {
+  return methods;
+}
+
+type CovalentBalanceResponse = {
+  address: string;
+  updated_at: string;
+  next_updated_at: string;
+  quote_currency: string;
+  items: {
+    is_spam: boolean;
+    contract_decimals: number;
+    contract_name: string;
+    contract_ticker_symbol: string;
+    contract_address: string;
+    logo_url: string;
+    last_transferred_at: string;
+    native_token: boolean;
+    type: string;
+    balance: number;
+    balance_24h: number;
+    quote_rate: number;
+    quote_rate_24h: number;
+    quote: number;
+    quote_24h: number;
+  }[];
+};
+
+type PriceInfo = {
+  rate: number;
+  diff: number;
+  diff7d?: number;
+  ts: number;
+  marketCapUsd?: number;
+  availableSupply?: number;
+  volume24h?: number;
+  diff30d?: number;
+  volDiff1?: number;
+  volDiff7?: number;
+  volDiff30?: number;
+  currency?: string;
+};
+
+type TokenInfo = {
+  address: string;
+  decimals: string;
+  name: string;
+  owner: string;
+  symbol: string;
+  totalSupply: string;
+  lastUpdated: number;
+  issuancesCount: number;
+  holdersCount: number;
+  image?: string;
+  description?: string;
+  website?: string;
+  twitter?: string;
+  facebook?: string;
+  coingecko?: string;
+  ethTransfersCount: number;
+  price: boolean | PriceInfo | unknown;
+  publicTags?: string[];
+  txsCount?: number;
+  transfersCount?: number;
+};
+
+type TokenBalance = {
+  tokenInfo: TokenInfo;
+  balance: number;
+  rawBalance: string;
+  totalIn?: number;
+  totalOut?: number;
+};
+
+export type AddressInfo = {
+  address: string;
+  ETH: {
+    balance: number;
+    totalIn?: number;
+    totalOut?: number;
+    price: PriceInfo;
+  };
+  contractInfo?: {
+    creatorAddress: string;
+    transactionHash: string;
+    timestamp: string;
+  };
+  tokenInfo?: TokenInfo;
+  tokens?: TokenBalance[];
+  countTxs: number;
+};

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

@@ -0,0 +1,165 @@
+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

@@ -0,0 +1,151 @@
+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",
+  },
+];