@dhedge/v2-sdk 1.9.4 → 1.9.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dhedge/v2-sdk",
-  "version": "1.9.4",
+  "version": "1.9.5",
   "license": "MIT",
   "description": "🛠 An SDK for building applications on top of dHEDGE V2",
   "main": "dist/index.js",
@@ -22,7 +22,8 @@
     "analyze": "size-limit --why",
     "fork:polygon": "hardhat node --port 8542 --fork $(grep POLYGON_URL .env | cut -d '=' -f2)",
     "fork:optimism": "hardhat node --port 8544 --fork $(grep OPTIMISM_URL .env | cut -d '=' -f2)",
-    "fork:arbitrum": "hardhat node --port 8540 --fork $(grep ARBITRUM_URL .env | cut -d '=' -f2)"
+    "fork:arbitrum": "hardhat node --port 8540 --fork $(grep ARBITRUM_URL .env | cut -d '=' -f2)",
+    "fork:base": "hardhat node --port 8546 --fork $(grep BASE_URL .env | cut -d '=' -f2)"
   },
   "husky": {
     "hooks": {

package/src/config.ts

@@ -16,7 +16,8 @@ export const factoryAddress: AddressNetworkMap = {
     ? "0xDd87eCdB10cFF7004276AAbAbd30e7a08F69bb53"
     : "0xfdc7b8bFe0DD3513Cc669bB8d601Cb83e2F69cB0",
   [Network.OPTIMISM]: "0x5e61a079A178f0E5784107a4963baAe0c5a680c6",
-  [Network.ARBITRUM]: "0xfffb5fb14606eb3a548c113026355020ddf27535"
+  [Network.ARBITRUM]: "0xfffb5fb14606eb3a548c113026355020ddf27535",
+  [Network.BASE]: "0x49Afe3abCf66CF09Fab86cb1139D8811C8afe56F"
 };
 
 export const routerAddress: AddressDappNetworkMap = {
@@ -50,6 +51,10 @@ export const routerAddress: AddressDappNetworkMap = {
     [Dapp.AAVEV3]: "0x794a61358D6845594F94dc1DB02A252b5b4814aD",
     [Dapp.BALANCER]: "0xBA12222222228d8Ba445958a75a0704d566BF2C8",
     [Dapp.RAMSES]: "0xaaa87963efeb6f7e0a2711f397663105acb1805e"
+  },
+  [Network.BASE]: {
+    [Dapp.ONEINCH]: "0x1111111254EEB25477B68fb85Ed929f73A960582",
+    [Dapp.ZEROEX]: "0xdef1c0ded9bec7f1a1670819833240f027b25eff"
   }
 };
 
@@ -59,7 +64,8 @@ export const dappFactoryAddress: AddressDappNetworkMap = {
     [Dapp.QUICKSWAP]: "0x5757371414417b8C6CAad45bAeF941aBc7d3Ab32"
   },
   [Network.OPTIMISM]: {},
-  [Network.ARBITRUM]: {}
+  [Network.ARBITRUM]: {},
+  [Network.BASE]: {}
 };
 
 export const stakingAddress: AddressDappNetworkMap = {
@@ -70,7 +76,8 @@ export const stakingAddress: AddressDappNetworkMap = {
     [Dapp.AAVEV3]: "0x929EC64c34a17401F460460D4B9390518E5B473e"
   },
   [Network.OPTIMISM]: {},
-  [Network.ARBITRUM]: {}
+  [Network.ARBITRUM]: {},
+  [Network.BASE]: {}
 };
 
 export const aaveAddressProvider: AddressDappNetworkMap = {
@@ -83,31 +90,40 @@ export const aaveAddressProvider: AddressDappNetworkMap = {
   },
   [Network.ARBITRUM]: {
     [Dapp.AAVEV3]: "0xa97684ead0e402dc232d5a977953df7ecbab3cdb"
+  },
+  [Network.BASE]: {
+    // https://docs.aave.com/developers/deployed-contracts/v3-mainnet/base
+    [Dapp.AAVEV3]: "0xe20fCBdBfFC4Dd138cE8b2E6FBb6CB49777ad64D"
   }
 };
 export const nonfungiblePositionManagerAddress: AddressNetworkMap = {
   [Network.POLYGON]: "0xC36442b4a4522E871399CD717aBDD847Ab11FE88",
   [Network.OPTIMISM]: "0xC36442b4a4522E871399CD717aBDD847Ab11FE88",
-  [Network.ARBITRUM]: "0xC36442b4a4522E871399CD717aBDD847Ab11FE88"
+  [Network.ARBITRUM]: "0xC36442b4a4522E871399CD717aBDD847Ab11FE88",
+  // https://docs.uniswap.org/contracts/v3/reference/deployments
+  [Network.BASE]: "0x03a520b32C04BF3bEEf7BEb72E919cf822Ed34f1"
 };
 
 export const networkChainIdMap: NetworkChainIdMap = {
   [Network.POLYGON]: 137,
   [Network.OPTIMISM]: 10,
-  [Network.ARBITRUM]: 42161
+  [Network.ARBITRUM]: 42161,
+  [Network.BASE]: 8453
 };
 
 export const balancerSubgraph: AddressNetworkMap = {
   [Network.POLYGON]:
     "https://api.thegraph.com/subgraphs/name/balancer-labs/balancer-polygon-v2",
   [Network.OPTIMISM]: "",
-  [Network.ARBITRUM]: ""
+  [Network.ARBITRUM]: "",
+  [Network.BASE]: ""
 };
 
 export const multiCallAddress: AddressNetworkMap = {
   [Network.POLYGON]: "0x275617327c958bD06b5D6b871E7f491D76113dd8",
   [Network.OPTIMISM]: "",
-  [Network.ARBITRUM]: ""
+  [Network.ARBITRUM]: "",
+  [Network.BASE]: ""
 };
 
 export const lyraNetworkMap: LyraNetworkMap = {

package/src/test/constants.ts

@@ -41,7 +41,8 @@ export const KWENTA_ETH_PERP_V2 = "0x2b3bb4c683bfc5239b029131eef3b1d214478d93";
 export const TEST_POOL = {
   [Network.POLYGON]: "0x699fd4d6eadb216704c7e355cfa0a12f51813163",
   [Network.OPTIMISM]: "0x12573bfdf764ab9d52aca20e2827497a66829716",
-  [Network.ARBITRUM]: "0x2dc2f936c8b6619facc69355d65dd93d2f4cc2bd"
+  [Network.ARBITRUM]: "0x2dc2f936c8b6619facc69355d65dd93d2f4cc2bd",
+  [Network.BASE]: "0x4842b42F68524383F609aa46eAfc18c1459cE3cD"
 };
 
 export const CONTRACT_ADDRESS = {
@@ -69,7 +70,20 @@ export const CONTRACT_ADDRESS = {
     WSTETH: "0x5979d7b546e38e414f7e9822514be443a4800529",
     BALANCER_WSTETH_WETH_POOL: "0x36bf227d6bac96e2ab1ebb5492ecec69c691943f",
     BALANCER_WSTETH_WETH_GAUGE: "0x251e51b25afa40f2b6b9f05aaf1bc7eaa0551771"
+  },
+  [Network.BASE]: {
+    USDC: "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
+    WETH: "0x4200000000000000000000000000000000000006",
+    WBTC: "",
+    SWETH: ""
   }
 };
 
 export const MAX_AMOUNT = ethers.constants.MaxUint256;
+
+export const USDC_BALANCEOF_SLOT = {
+  [Network.OPTIMISM]: 0,
+  [Network.ARBITRUM]: 9,
+  [Network.POLYGON]: 0,
+  [Network.BASE]: 9
+};

package/src/test/lyra.test.ts

@@ -6,6 +6,7 @@ import { getTxOptions } from "./txOptions";
 import { wallet } from "./wallet";
 
 jest.setTimeout(100000);
+const TEST_POOL_OP = TEST_POOL.optimism;
 
 describe("pool", () => {
   let dhedge: Dhedge;
@@ -16,7 +17,7 @@ describe("pool", () => {
 
   it("buys 0.1 1400 calls with expiry October 28th", async () => {
     let result;
-    const pool = await dhedge.loadPool(TEST_POOL);
+    const pool = await dhedge.loadPool(TEST_POOL_OP);
     try {
       result = await pool.tradeLyraOption(
         "eth",
@@ -37,7 +38,7 @@ describe("pool", () => {
 
   it("adds 0.05 1400 calls with expiry October 28th", async () => {
     let result;
-    const pool = await dhedge.loadPool(TEST_POOL);
+    const pool = await dhedge.loadPool(TEST_POOL_OP);
     try {
       result = await pool.tradeLyraOption(
         "eth",
@@ -61,7 +62,7 @@ describe("pool", () => {
 
   it("sells 0.1 1300 Covered Call with expiry October 28th", async () => {
     let result;
-    const pool = await dhedge.loadPool(TEST_POOL);
+    const pool = await dhedge.loadPool(TEST_POOL_OP);
     try {
       result = await pool.tradeLyraOption(
         "eth",
@@ -86,7 +87,7 @@ describe("pool", () => {
 
   it("adds 0.05 1300 Covered Call with expiry October 28th", async () => {
     let result;
-    const pool = await dhedge.loadPool(TEST_POOL);
+    const pool = await dhedge.loadPool(TEST_POOL_OP);
     try {
       result = await pool.tradeLyraOption(
         "eth",
@@ -113,7 +114,7 @@ describe("pool", () => {
 
   it("closes all 0.15 1300 Covered Call with expiry October 28th", async () => {
     let result;
-    const pool = await dhedge.loadPool(TEST_POOL);
+    const pool = await dhedge.loadPool(TEST_POOL_OP);
     try {
       result = await pool.tradeLyraOption(
         "eth",
@@ -138,7 +139,7 @@ describe("pool", () => {
 
   it("closes all 0.15 1400 Calls with expiry October 28th", async () => {
     let result;
-    const pool = await dhedge.loadPool(TEST_POOL);
+    const pool = await dhedge.loadPool(TEST_POOL_OP);
     try {
       result = await pool.tradeLyraOption(
         "eth",

package/src/test/oneInch.test.ts

@@ -1,12 +1,18 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
+import BigNumber from "bignumber.js";
 import { Dhedge, Pool } from "..";
 import { routerAddress } from "../config";
 import { Dapp, Network } from "../types";
 import { CONTRACT_ADDRESS, MAX_AMOUNT, TEST_POOL } from "./constants";
-import { TestingRunParams, testingHelper } from "./utils/testingHelper";
+import {
+  TestingRunParams,
+  setUSDCAmount,
+  testingHelper
+} from "./utils/testingHelper";
 import { allowanceDelta, balanceDelta } from "./utils/token";
+import { getTxOptions } from "./txOptions";
 
-const testOneInch = ({ wallet, network }: TestingRunParams) => {
+const testOneInch = ({ wallet, network, provider }: TestingRunParams) => {
   const USDC = CONTRACT_ADDRESS[network].USDC;
   const WETH = CONTRACT_ADDRESS[network].WETH;
 
@@ -18,6 +24,19 @@ const testOneInch = ({ wallet, network }: TestingRunParams) => {
     beforeAll(async () => {
       dhedge = new Dhedge(wallet, network);
       pool = await dhedge.loadPool(TEST_POOL[network]);
+      // top up gas
+      await provider.send("hardhat_setBalance", [
+        wallet.address,
+        "0x10000000000000000"
+      ]);
+      await provider.send("evm_mine", []);
+      // top up USDC
+      await setUSDCAmount({
+        amount: new BigNumber(100).times(1e18).toFixed(0),
+        userAddress: pool.address,
+        network,
+        provider
+      });
     });
 
     it("approves unlimited USDC on 1Inch", async () => {
@@ -32,7 +51,14 @@ const testOneInch = ({ wallet, network }: TestingRunParams) => {
     });
 
     it("trades 2 USDC into WETH on 1Inch", async () => {
-      await pool.trade(Dapp.ONEINCH, USDC, WETH, "2000000", 0.5);
+      await pool.trade(
+        Dapp.ONEINCH,
+        USDC,
+        WETH,
+        "2000000",
+        0.5,
+        await getTxOptions(network)
+      );
       const wethBalanceDelta = await balanceDelta(
         pool.address,
         WETH,
@@ -52,3 +78,8 @@ testingHelper({
   network: Network.POLYGON,
   testingRun: testOneInch
 });
+
+testingHelper({
+  network: Network.BASE,
+  testingRun: testOneInch
+});

package/src/test/synthetix.test.ts

@@ -6,6 +6,8 @@ import { TEST_POOL } from "./constants";
 
 import { wallet } from "./wallet";
 
+const TEST_POOL_OP = TEST_POOL.optimism;
+
 let dhedge: Dhedge;
 let options: any;
 jest.setTimeout(100000);
@@ -18,7 +20,7 @@ describe("pool", () => {
   });
 
   it("should swap sETH into sUSD on Synthetix", async () => {
-    const pool = await dhedge.loadPool(TEST_POOL);
+    const pool = await dhedge.loadPool(TEST_POOL_OP);
     const result = await pool.trade(
       Dapp.SYNTHETIX,
       "sETH",

package/src/test/uniswap.test.ts

@@ -5,156 +5,188 @@ import { routerAddress } from "../config";
 import { Dapp, Network } from "../types";
 import { CONTRACT_ADDRESS, TEST_POOL } from "./constants";
 import { allowanceDelta, balanceDelta } from "./utils/token";
-
-import { wallet } from "./wallet";
-
-let dhedge: Dhedge;
-let pool: Pool;
-jest.setTimeout(100000);
-
-const network = Network.POLYGON;
-
-describe("pool", () => {
-  beforeAll(async () => {
-    dhedge = new Dhedge(wallet, network);
-    pool = await dhedge.loadPool(TEST_POOL[network]);
+import {
+  setUSDCAmount,
+  testingHelper,
+  TestingRunParams
+} from "./utils/testingHelper";
+import BigNumber from "bignumber.js";
+
+const testUniswapV3 = ({ wallet, network, provider }: TestingRunParams) => {
+  let dhedge: Dhedge;
+  let pool: Pool;
+
+  jest.setTimeout(100000);
+  describe(`testUniswapV3 on ${network}`, () => {
+    beforeAll(async () => {
+      dhedge = new Dhedge(wallet, network);
+      pool = await dhedge.loadPool(TEST_POOL[network]);
+
+      // top up gas
+      await provider.send("hardhat_setBalance", [
+        wallet.address,
+        "0x10000000000000000"
+      ]);
+      await provider.send("evm_mine", []);
+      await setUSDCAmount({
+        amount: new BigNumber(100).times(1e18).toFixed(0),
+        userAddress: pool.address,
+        network,
+        provider
+      });
+    });
+
+    it("approves unlimited USDC on for trading on UniswapV3", async () => {
+      await pool.approve(
+        Dapp.UNISWAPV3,
+        CONTRACT_ADDRESS[network].USDC,
+        ethers.constants.MaxUint256
+      );
+      const UsdcAllowanceDelta = await allowanceDelta(
+        pool.address,
+        CONTRACT_ADDRESS[network].USDC,
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        routerAddress[network].uniswapV3!,
+        pool.signer
+      );
+      expect(UsdcAllowanceDelta.gte(0));
+    });
+
+    it("should swap 5 USDC into WETH on UniswapV3", async () => {
+      await pool.tradeUniswapV3(
+        CONTRACT_ADDRESS[network].USDC,
+        CONTRACT_ADDRESS[network].WETH,
+        "5000000",
+        FeeAmount.LOW,
+        0.5
+      );
+
+      const wethAllowanceDelta = await balanceDelta(
+        pool.address,
+        CONTRACT_ADDRESS[network].WETH,
+        pool.signer
+      );
+      expect(wethAllowanceDelta.gt(0));
+    });
+
+    // it("approves unlimited WETH on for UniswapV3 LP", async () => {
+    //   await pool.approveUniswapV3Liquidity(
+    //     CONTRACT_ADDRESS[network].USDC,
+    //     ethers.constants.MaxInt256
+    //   );
+    //   const UsdcAllowanceDelta = await allowanceDelta(
+    //     pool.address,
+    //     CONTRACT_ADDRESS[network].USDC,
+    //     pool.address,
+    //     pool.signer
+    //   );
+
+    //   expect(result).not.toBe(null);
+    // });
+
+    // it("adds WETH and WBTC to a new V3 pool", async () => {
+    //   let result;
+    //   const pool = await dhedge.loadPool(TEST_POOL);
+    //   const usdcBalance = await dhedge.utils.getBalance(USDC, pool.address);
+    //   const wethBalance = await dhedge.utils.getBalance(WETH, pool.address);
+
+    //   try {
+    //     result = await pool.addLiquidityUniswapV3(
+    //       USDC,
+    //       WETH,
+    //       usdcBalance,
+    //       wethBalance,
+    //       0.0003,
+    //       0.0004,
+    //       null,
+    //       null,
+    //       FeeAmount.LOW,
+    //       options
+    //     );
+    //     console.log(result);
+    //   } catch (e) {
+    //     console.log(e);
+    //   }
+    //   expect(result).not.toBe(null);
+    // });
+
+    // it("should remove liquidity from an existing pool ", async () => {
+    //   const pool = await dhedge.loadPool(TEST_POOL);
+    //   const result = await pool.decreaseLiquidity(
+    //     Dapp.UNISWAPV3,
+    //     "110507",
+    //     100,
+    //     options
+    //   );
+    //   console.log("result", result);
+    //   expect(result).not.toBe(null);
+    // });
+
+    // it("should increase liquidity in an existing pool WETH/WBTC pool", async () => {
+    //   const pool = await dhedge.loadPool(TEST_POOL);
+    //   const result = await pool.increaseLiquidity(
+    //     Dapp.UNISWAPV3,
+    //     "110507",
+    //     "244838",
+    //     "258300000000000",
+    //     options
+    //   );
+    //   console.log("result", result);
+    //   expect(result).not.toBe(null);
+    // });
+
+    // it("should claim fees an existing pool", async () => {
+    //   const pool = await dhedge.loadPool(TEST_POOL);
+    //   const result = await pool.claimFeesUniswapV3("54929", options);
+    //   console.log("result", result);
+    //   expect(result).not.toBe(null);
+    // });
+
+    // it("approves unlimited USDC to swap on UniswapV3", async () => {
+    //   let result;
+    //   const pool = await dhedge.loadPool(TEST_POOL);
+    //   try {
+    //     result = await pool.approve(
+    //       Dapp.UNISWAPV3,
+    //       USDC,
+    //       ethers.constants.MaxInt256,
+    //       options
+    //     );
+    //     console.log(result);
+    //   } catch (e) {
+    //     console.log(e);
+    //   }
+    //   expect(result).not.toBe(null);
+    // });
+
+    // it("should swap USDC into WETH on UniswapV3 pool", async () => {
+    //   const pool = await dhedge.loadPool(TEST_POOL);
+    //   const result = await pool.tradeUniswapV3(
+    //     USDC,
+    //     WETH,
+    //     "1000000",
+    //     FeeAmount.LOW,
+    //     1,
+    //     options
+    //   );
+
+    //   console.log(result);
+    //   expect(result).not.toBe(null);
+    // });
   });
+};
 
-  it("approves unlimited USDC on for trading on UniswapV3", async () => {
-    await pool.approve(
-      Dapp.UNISWAPV3,
-      CONTRACT_ADDRESS[network].USDC,
-      ethers.constants.MaxUint256
-    );
-    const UsdcAllowanceDelta = await allowanceDelta(
-      pool.address,
-      CONTRACT_ADDRESS[network].USDC,
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-      routerAddress[network].uniswapV3!,
-      pool.signer
-    );
-    expect(UsdcAllowanceDelta.gte(0));
-  });
+testingHelper({
+  network: Network.OPTIMISM,
+  testingRun: testUniswapV3
+});
 
-  it("should swap 5 USDC into WETH on UniswapV3", async () => {
-    await pool.tradeUniswapV3(
-      CONTRACT_ADDRESS[network].USDC,
-      CONTRACT_ADDRESS[network].WETH,
-      "5000000",
-      FeeAmount.LOW,
-      0.5
-    );
-
-    const wethAllowanceDelta = await balanceDelta(
-      pool.address,
-      CONTRACT_ADDRESS[network].WETH,
-      pool.signer
-    );
-    expect(wethAllowanceDelta.gt(0));
-  });
+testingHelper({
+  network: Network.POLYGON,
+  testingRun: testUniswapV3
+});
 
-  // it("approves unlimited WETH on for UniswapV3 LP", async () => {
-  //   await pool.approveUniswapV3Liquidity(
-  //     CONTRACT_ADDRESS[network].USDC,
-  //     ethers.constants.MaxInt256
-  //   );
-  //   const UsdcAllowanceDelta = await allowanceDelta(
-  //     pool.address,
-  //     CONTRACT_ADDRESS[network].USDC,
-  //     pool.address,
-  //     pool.signer
-  //   );
-
-  //   expect(result).not.toBe(null);
-  // });
-
-  // it("adds WETH and WBTC to a new V3 pool", async () => {
-  //   let result;
-  //   const pool = await dhedge.loadPool(TEST_POOL);
-  //   const usdcBalance = await dhedge.utils.getBalance(USDC, pool.address);
-  //   const wethBalance = await dhedge.utils.getBalance(WETH, pool.address);
-
-  //   try {
-  //     result = await pool.addLiquidityUniswapV3(
-  //       USDC,
-  //       WETH,
-  //       usdcBalance,
-  //       wethBalance,
-  //       0.0003,
-  //       0.0004,
-  //       null,
-  //       null,
-  //       FeeAmount.LOW,
-  //       options
-  //     );
-  //     console.log(result);
-  //   } catch (e) {
-  //     console.log(e);
-  //   }
-  //   expect(result).not.toBe(null);
-  // });
-
-  // it("should remove liquidity from an existing pool ", async () => {
-  //   const pool = await dhedge.loadPool(TEST_POOL);
-  //   const result = await pool.decreaseLiquidity(
-  //     Dapp.UNISWAPV3,
-  //     "110507",
-  //     100,
-  //     options
-  //   );
-  //   console.log("result", result);
-  //   expect(result).not.toBe(null);
-  // });
-
-  // it("should increase liquidity in an existing pool WETH/WBTC pool", async () => {
-  //   const pool = await dhedge.loadPool(TEST_POOL);
-  //   const result = await pool.increaseLiquidity(
-  //     Dapp.UNISWAPV3,
-  //     "110507",
-  //     "244838",
-  //     "258300000000000",
-  //     options
-  //   );
-  //   console.log("result", result);
-  //   expect(result).not.toBe(null);
-  // });
-
-  // it("should claim fees an existing pool", async () => {
-  //   const pool = await dhedge.loadPool(TEST_POOL);
-  //   const result = await pool.claimFeesUniswapV3("54929", options);
-  //   console.log("result", result);
-  //   expect(result).not.toBe(null);
-  // });
-
-  // it("approves unlimited USDC to swap on UniswapV3", async () => {
-  //   let result;
-  //   const pool = await dhedge.loadPool(TEST_POOL);
-  //   try {
-  //     result = await pool.approve(
-  //       Dapp.UNISWAPV3,
-  //       USDC,
-  //       ethers.constants.MaxInt256,
-  //       options
-  //     );
-  //     console.log(result);
-  //   } catch (e) {
-  //     console.log(e);
-  //   }
-  //   expect(result).not.toBe(null);
-  // });
-
-  // it("should swap USDC into WETH on UniswapV3 pool", async () => {
-  //   const pool = await dhedge.loadPool(TEST_POOL);
-  //   const result = await pool.tradeUniswapV3(
-  //     USDC,
-  //     WETH,
-  //     "1000000",
-  //     FeeAmount.LOW,
-  //     1,
-  //     options
-  //   );
-
-  //   console.log(result);
-  //   expect(result).not.toBe(null);
-  // });
+testingHelper({
+  network: Network.BASE,
+  testingRun: testUniswapV3
 });

package/src/test/utils/testingHelper.ts

@@ -1,6 +1,7 @@
-import { ethers } from "ethers";
+import { BigNumber, ethers } from "ethers";
 import { Network } from "../../types";
 import { getWalletData } from "../wallet";
+import { CONTRACT_ADDRESS, USDC_BALANCEOF_SLOT } from "../constants";
 
 export type TestingRunParams = {
   network: Network;
@@ -40,3 +41,52 @@ export const beforeAfterReset = ({
     await provider.send("evm_mine", []);
   });
 };
+
+export const setTokenAmount = async ({
+  amount,
+  userAddress,
+  tokenAddress,
+  slot,
+  provider
+}: {
+  amount: string;
+  userAddress: string;
+  tokenAddress: string;
+  slot: number;
+  provider: ethers.providers.JsonRpcProvider;
+}): Promise<void> => {
+  const toBytes32 = (bn: string) => {
+    return ethers.utils.hexlify(
+      ethers.utils.zeroPad(BigNumber.from(bn).toHexString(), 32)
+    );
+  };
+  const index = ethers.utils.solidityKeccak256(
+    ["uint256", "uint256"],
+    [userAddress, slot] // key, slot
+  );
+  await provider.send("hardhat_setStorageAt", [
+    tokenAddress,
+    index,
+    toBytes32(amount).toString()
+  ]);
+  await provider.send("evm_mine", []);
+};
+export const setUSDCAmount = async ({
+  provider,
+  userAddress,
+  amount,
+  network
+}: {
+  amount: string;
+  userAddress: string;
+  provider: ethers.providers.JsonRpcProvider;
+  network: Network;
+}): Promise<void> => {
+  await setTokenAmount({
+    amount,
+    userAddress,
+    provider,
+    tokenAddress: CONTRACT_ADDRESS[network].USDC,
+    slot: USDC_BALANCEOF_SLOT[network]
+  });
+};

package/src/test/wallet.ts

@@ -29,7 +29,8 @@ export const wallet = new ethers.Wallet(
 export const networkPortMap = {
   [Network.POLYGON]: 8542,
   [Network.OPTIMISM]: 8544,
-  [Network.ARBITRUM]: 8540
+  [Network.ARBITRUM]: 8540,
+  [Network.BASE]: 8546
 };
 
 export const getWalletData = (