@dhedge/v2-sdk 1.9.6 → 1.9.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dhedge/v2-sdk",
-  "version": "1.9.6",
+  "version": "1.9.8",
   "license": "MIT",
   "description": "🛠 An SDK for building applications on top of dHEDGE V2",
   "main": "dist/index.js",

package/src/config.ts

@@ -47,14 +47,16 @@ export const routerAddress: AddressDappNetworkMap = {
   },
   [Network.ARBITRUM]: {
     [Dapp.ONEINCH]: "0x1111111254EEB25477B68fb85Ed929f73A960582",
-    [Dapp.UNISWAPV3]: "0xe592427a0aece92de3edee1f18e0157c05861564",
+    [Dapp.UNISWAPV3]: "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45",
     [Dapp.AAVEV3]: "0x794a61358D6845594F94dc1DB02A252b5b4814aD",
     [Dapp.BALANCER]: "0xBA12222222228d8Ba445958a75a0704d566BF2C8",
     [Dapp.RAMSES]: "0xaaa87963efeb6f7e0a2711f397663105acb1805e"
   },
   [Network.BASE]: {
     [Dapp.ONEINCH]: "0x1111111254EEB25477B68fb85Ed929f73A960582",
-    [Dapp.ZEROEX]: "0xdef1c0ded9bec7f1a1670819833240f027b25eff"
+    [Dapp.ZEROEX]: "0xdef1c0ded9bec7f1a1670819833240f027b25eff",
+    [Dapp.AERODROME]: "0xcF77a3Ba9A5CA399B7c97c74d54e5b1Beb874E43",
+    [Dapp.AAVEV3]: "0xA238Dd80C259a72e81d7e4664a9801593F98d1c5"
   }
 };
 

package/src/entities/pool.ts

@@ -119,14 +119,19 @@ export class Pool {
    * @param {string} nasset Address of deposit asset
    * @param {BigNumber | string} amount Amount to be approved
    * @param {any} options Transaction options
+   * @param {boolean} estimateGas Simulate/estimate gas
    * @returns {Promise<any>} Transaction
    */
   async approveDeposit(
     asset: string,
     amount: BigNumber | string,
-    options: any = null
+    options: any = null,
+    estimateGas = false
   ): Promise<any> {
     const iERC20 = new ethers.Contract(asset, IERC20.abi, this.signer);
+    if (estimateGas) {
+      return await iERC20.estimateGas.approve(this.address, amount, options);
+    }
     const tx = await iERC20.approve(this.address, amount, options);
     return tx;
   }
@@ -136,13 +141,18 @@ export class Pool {
    * @param {string} asset Address of asset
    * @param {BigNumber | string} amount Amount to be deposited
    * @param {any} options Transaction options
+   * @param {boolean} estimateGas Simulate/estimate gas
    * @returns {Promise<any>} Transaction
    */
   async deposit(
     asset: string,
     amount: string | BigNumber,
-    options: any = null
+    options: any = null,
+    estimateGas = false
   ): Promise<any> {
+    if (estimateGas) {
+      return await this.poolLogic.estimateGas.deposit(asset, amount, options);
+    }
     const tx = await this.poolLogic.deposit(asset, amount, options);
     return tx;
   }
@@ -151,12 +161,20 @@ export class Pool {
    * Withdraw  assets from a pool
    * @param fundTokenAmount Amount of pool tokens to be withdrawn
    * @param {any} options Transaction options
+   * @param {boolean} estimateGas Simulate/estimate gas
    * @returns {Promise<any>} Transaction
    */
   async withdraw(
     fundTokenAmount: string | BigNumber,
-    options: any = null
+    options: any = null,
+    estimateGas = false
   ): Promise<any> {
+    if (estimateGas) {
+      return await this.poolLogic.estimateGas.withdraw(
+        fundTokenAmount,
+        options
+      );
+    }
     const tx = await this.poolLogic.withdraw(fundTokenAmount, options);
     return tx;
   }
@@ -513,6 +531,7 @@ export class Pool {
         stakeTxData = getVelodromeStakeTxData(amount, false);
         break;
       case Dapp.VELODROMEV2:
+      case Dapp.AERODROME:
         stakeTxData = getVelodromeStakeTxData(amount, true);
         break;
       default:
@@ -742,11 +761,13 @@ export class Pool {
    * Change enabled pool assets
    * @param {AssetEnabled[]} assets New pool assets
    * @param {any} options Transaction options
+   * @param {boolean} estimateGas Simulate/estimate gas
    * @returns {Promise<any>} Transaction
    */
   public async changeAssets(
     assets: AssetEnabled[],
-    options: any = null
+    options: any = null,
+    estimateGas = false
   ): Promise<any> {
     const currentAssetsEnabled = await this.getComposition();
     const currentAssets = currentAssetsEnabled.map(e =>
@@ -755,6 +776,14 @@ export class Pool {
     const newAssets = assets.map(e => e.asset.toLocaleLowerCase());
     const removedAssets = currentAssets.filter(e => !newAssets.includes(e));
     const changedAssets = assets.map(e => [e.asset, e.isDeposit]);
+
+    if (estimateGas) {
+      return await this.managerLogic.estimateGas.changeAssets(
+        changedAssets,
+        removedAssets,
+        options
+      );
+    }
     const tx = await this.managerLogic.changeAssets(
       changedAssets,
       removedAssets,
@@ -767,9 +796,17 @@ export class Pool {
    * Set a new trader with trading permissions
    * @param {string} trader Address trader account
    * @param {any} options Transaction options
+   * @param {boolean} estimateGas Simulate/estimate gas
    * @returns {Promise<any>} Transaction
    */
-  async setTrader(trader: string, options: any = null): Promise<any> {
+  async setTrader(
+    trader: string,
+    options: any = null,
+    estimateGas = false
+  ): Promise<any> {
+    if (estimateGas) {
+      return await this.managerLogic.estimateGas.setTrader(trader, options);
+    }
     const tx = await this.managerLogic.setTrader(trader, options);
     return tx;
   }
@@ -1117,6 +1154,7 @@ export class Pool {
         txData = getVelodromeClaimTxData(this, tokenId, false);
         break;
       case Dapp.VELODROMEV2:
+      case Dapp.AERODROME:
         contractAddress = tokenId;
         txData = getVelodromeClaimTxData(this, tokenId, true);
         break;
@@ -1320,7 +1358,7 @@ export class Pool {
 
   /**
    * Add liquidity to Velodrome V2 or Ramses pool
-   * @param {Dapp} dapp VelodromeV2 or Ramses
+   * @param {Dapp} dapp VelodromeV2, Ramses or Aerodrome
    * @param {string} assetA First asset
    * @param {string} assetB Second asset
    * @param {BigNumber | string} amountA Amount first asset
@@ -1331,7 +1369,7 @@ export class Pool {
    * @returns {Promise<any>} Transaction
    */
   async addLiquidityV2(
-    dapp: Dapp.VELODROMEV2 | Dapp.RAMSES,
+    dapp: Dapp.VELODROMEV2 | Dapp.RAMSES | Dapp.AERODROME,
     assetA: string,
     assetB: string,
     amountA: BigNumber | string,
@@ -1361,7 +1399,7 @@ export class Pool {
 
   /**
    * Remove liquidity from Velodrome V2 or Ramses pool
-   * @param {Dapp} dapp VelodromeV2 or Ramses
+   * @param {Dapp} dapp VelodromeV2, Ramses or Aerodrome
    * @param {string} assetA First asset
    * @param {string} assetB Second asset
    * @param {BigNumber | string} amount Amount of LP tokens
@@ -1371,7 +1409,7 @@ export class Pool {
    * @returns {Promise<any>} Transaction
    */
   async removeLiquidityV2(
-    dapp: Dapp.VELODROMEV2 | Dapp.RAMSES,
+    dapp: Dapp.VELODROMEV2 | Dapp.RAMSES | Dapp.AERODROME,
     assetA: string,
     assetB: string,
     amount: BigNumber | string,
@@ -1526,9 +1564,13 @@ export class Pool {
   /**
    * mintManagerFee
    * @param {any} options Transaction options
+   * @param {boolean} estimateGas Simulate/estimate gas
    * @returns {Promise<any>} Transaction
    */
-  async mintManagerFee(options: any = null): Promise<any> {
+  async mintManagerFee(options: any = null, estimateGas = false): Promise<any> {
+    if (estimateGas) {
+      return await this.poolLogic.estimateGas.mintManagerFee(options);
+    }
     const tx = await this.poolLogic.mintManagerFee(options);
     return tx;
   }

package/src/test/aerodrome.test.ts

@@ -0,0 +1,154 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+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,
+  beforeAfterReset,
+  setUSDCAmount,
+  testingHelper
+} from "./utils/testingHelper";
+import { allowanceDelta, balanceDelta } from "./utils/token";
+import { getWalletData } from "./wallet";
+
+const testAerodrome = ({ network, provider }: TestingRunParams) => {
+  const WETH_USDC_Lp = "0xcDAC0d6c6C59727a65F871236188350531885C43";
+  const WETH_USDC__Gauge = "0x519BBD1Dd8C6A94C46080E24f316c14Ee758C025";
+
+  const USDC = CONTRACT_ADDRESS[network].USDC;
+  const WETH = CONTRACT_ADDRESS[network].WETH;
+  const AERO = "0x940181a94A35A4569E4529A3CDfB74e38FD98631";
+
+  let dhedge: Dhedge;
+  let pool: Pool;
+  jest.setTimeout(100000);
+
+  describe(`[${network}] aerodrome tests`, () => {
+    beforeAll(async () => {
+      const { wallet } = getWalletData(network);
+      // top up ETH (gas)
+      await provider.send("hardhat_setBalance", [
+        wallet.address,
+        "0x100000000000000"
+      ]);
+      dhedge = new Dhedge(wallet, network);
+      pool = await dhedge.loadPool(TEST_POOL[network]);
+      await setUSDCAmount({
+        amount: new BigNumber(10).times(1e6).toFixed(0),
+        userAddress: pool.address,
+        network,
+        provider
+      });
+      await pool.approve(Dapp.ONEINCH, USDC, MAX_AMOUNT);
+      await pool.trade(Dapp.ONEINCH, USDC, WETH, (5 * 1e6).toString());
+    });
+    beforeAfterReset({ beforeAll, afterAll, provider });
+
+    it("approves unlimited USDC and swETH on for Aerodrome", async () => {
+      await pool.approve(Dapp.AERODROME, USDC, MAX_AMOUNT);
+      await pool.approve(Dapp.AERODROME, WETH, MAX_AMOUNT);
+      const UsdcAllowanceDelta = await allowanceDelta(
+        pool.address,
+        USDC,
+        routerAddress[network].aerodrome!,
+        pool.signer
+      );
+      await expect(UsdcAllowanceDelta.gt(0));
+    });
+
+    it("adds USDC and WETH to a Aerodrome volatile pool", async () => {
+      const usdcBalance = await pool.utils.getBalance(USDC, pool.address);
+      const wethBalance = await pool.utils.getBalance(WETH, pool.address);
+      await pool.addLiquidityV2(
+        Dapp.AERODROME,
+        WETH,
+        USDC,
+        wethBalance,
+        usdcBalance,
+        false
+      );
+
+      const lpTokenDelta = await balanceDelta(
+        pool.address,
+        WETH_USDC_Lp,
+        pool.signer
+      );
+      expect(lpTokenDelta.gt(0));
+    });
+
+    it("should stake WETH-USDC LP in a gauge", async () => {
+      const balance = await dhedge.utils.getBalance(WETH_USDC_Lp, pool.address);
+      await pool.approveSpender(WETH_USDC__Gauge, WETH_USDC_Lp, MAX_AMOUNT);
+      await pool.stakeInGauge(Dapp.AERODROME, WETH_USDC__Gauge, balance);
+      const gaugeBalance = await balanceDelta(
+        pool.address,
+        WETH_USDC__Gauge,
+        pool.signer
+      );
+      expect(gaugeBalance.gt(0));
+    });
+
+    it("should claim rewards from Gauge", async () => {
+      await provider.send("evm_increaseTime", [24 * 60 * 60]); // 1 day
+      await provider.send("evm_mine", []);
+      const claimTx = await pool.claimFees(Dapp.AERODROME, WETH_USDC__Gauge);
+      expect(claimTx).not.toBe(null);
+      const aeroBalanceDelta = await balanceDelta(
+        pool.address,
+        AERO,
+        pool.signer
+      );
+      expect(aeroBalanceDelta.gt(0));
+    });
+
+    it("should unStakeWETH-USDC LP from a gauge", async () => {
+      const gaugeBalance = await dhedge.utils.getBalance(
+        WETH_USDC__Gauge,
+        pool.address
+      );
+      await pool.unstakeFromGauge(WETH_USDC__Gauge, gaugeBalance);
+      const lpTokenDelta = await balanceDelta(
+        pool.address,
+        WETH_USDC_Lp,
+        pool.signer
+      );
+      expect(lpTokenDelta.gt(0));
+    });
+
+    it("approves unlimited WETH-USDC LP for Aerodrome", async () => {
+      await pool.approve(Dapp.AERODROME, WETH_USDC_Lp, MAX_AMOUNT);
+      const lpAllowanceDelta = await allowanceDelta(
+        pool.address,
+        WETH_USDC_Lp,
+        routerAddress[network].aerodrome!,
+        pool.signer
+      );
+      expect(lpAllowanceDelta.gt(0));
+    });
+
+    it("should remove all liquidity from an existing pool ", async () => {
+      const balance = await dhedge.utils.getBalance(WETH_USDC_Lp, pool.address);
+      await pool.removeLiquidityV2(Dapp.AERODROME, WETH, USDC, balance, false);
+      const usdcBalanceDelta = await balanceDelta(
+        pool.address,
+        USDC,
+        pool.signer
+      );
+      const wethBalanceDelta = await balanceDelta(
+        pool.address,
+        WETH,
+        pool.signer
+      );
+      expect(usdcBalanceDelta.gt(0));
+      expect(wethBalanceDelta.gt(0));
+    });
+  });
+};
+
+testingHelper({
+  network: Network.BASE,
+  testingRun: testAerodrome
+});

package/src/test/arrakis.test.ts

@@ -1,95 +1,139 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 /* eslint-disable @typescript-eslint/no-explicit-any */
+import BigNumber from "bignumber.js";
 import { Dhedge, Pool } from "..";
 import { routerAddress } from "../config";
-import { Dapp, Network } from "../types";
+import { AssetEnabled, Dapp, Network } from "../types";
 import { CONTRACT_ADDRESS, MAX_AMOUNT, TEST_POOL } from "./constants";
+import {
+  TestingRunParams,
+  setUSDCAmount,
+  testingHelper,
+  wait
+} from "./utils/testingHelper";
 import { allowanceDelta, balanceDelta } from "./utils/token";
 
-import { wallet } from "./wallet";
-
 //const network = Network.OPTIMISM;
 const network = Network.POLYGON;
 const USDC = CONTRACT_ADDRESS[network].USDC;
 const WETH = CONTRACT_ADDRESS[network].WETH;
-
-let dhedge: Dhedge;
-let pool: Pool;
 jest.setTimeout(100000);
 
-describe("pool", () => {
-  beforeAll(async () => {
-    dhedge = new Dhedge(wallet, network);
-    pool = await dhedge.loadPool(TEST_POOL[network]);
-    await pool.approve(Dapp.ONEINCH, USDC, MAX_AMOUNT);
-    await pool.trade(Dapp.ONEINCH, USDC, WETH, "1000000", 0.5);
-  });
+const testArrakis = ({ wallet, network, provider }: TestingRunParams) => {
+  let dhedge: Dhedge;
+  let pool: Pool;
 
-  it("approves unlimited USDC on Arrakis", async () => {
-    await pool.approve(Dapp.ARRAKIS, USDC, MAX_AMOUNT);
-    const usdcAllowanceDelta = await allowanceDelta(
-      pool.address,
-      USDC,
-      routerAddress[network].arrakis!,
-      pool.signer
-    );
-    await expect(usdcAllowanceDelta.gt(0));
-  });
+  describe("pool", () => {
+    beforeAll(async () => {
+      dhedge = new Dhedge(wallet, network);
+      pool = await dhedge.loadPool(TEST_POOL[network]);
 
-  it("approves unlimited WETH on Arrakis", async () => {
-    await pool.approve(Dapp.ARRAKIS, WETH, MAX_AMOUNT);
-    const wethAllowanceDelta = await allowanceDelta(
-      pool.address,
-      USDC,
-      routerAddress[network].arrakis!,
-      pool.signer
-    );
-    await expect(wethAllowanceDelta.gt(0));
-  });
+      // top up gas
+      await provider.send("hardhat_setBalance", [
+        wallet.address,
+        "0x10000000000000000"
+      ]);
+      await provider.send("evm_mine", []);
+      await setUSDCAmount({
+        amount: new BigNumber(10000000).times(1e6).toFixed(0),
+        userAddress: pool.address,
+        network,
+        provider
+      });
 
-  it("should add liquidity and stake in an WETH/USDC Arrakis pool", async () => {
-    const usdcBalance = await pool.utils.getBalance(USDC, pool.address);
-    const wethBalance = await pool.utils.getBalance(WETH, pool.address);
-    await pool.increaseLiquidity(
-      Dapp.ARRAKIS,
-      CONTRACT_ADDRESS[network].ARRAKIS_USDC_WETH_GAUGE,
-      usdcBalance,
-      wethBalance
-    );
-    const lpBalanceDelta = await balanceDelta(
-      pool.address,
-      CONTRACT_ADDRESS[network].ARRAKIS_USDC_WETH_LP,
-      pool.signer
-    );
-    expect(lpBalanceDelta.gt(0));
-  });
+      const newAssets: AssetEnabled[] = [
+        { asset: CONTRACT_ADDRESS[network].USDC, isDeposit: true },
+        { asset: CONTRACT_ADDRESS[network].WETH, isDeposit: true },
+        {
+          asset: CONTRACT_ADDRESS[network].ARRAKIS_USDC_WETH_GAUGE,
+          isDeposit: false
+        },
+        {
+          asset: CONTRACT_ADDRESS[network].WMATIC, // reward token
+          isDeposit: false
+        },
+        {
+          asset: CONTRACT_ADDRESS[network].uniswapV3.nonfungiblePositionManager,
+          isDeposit: false
+        }
+      ];
+      await pool.changeAssets(newAssets);
+      await pool.approve(Dapp.ONEINCH, USDC, MAX_AMOUNT);
+      await pool.trade(Dapp.ONEINCH, USDC, WETH, "10000000", 0.5, null, false);
+    });
 
-  it("approves unlimited LP staking Token before on Arrakis", async () => {
-    await pool.approve(
-      Dapp.ARRAKIS,
-      CONTRACT_ADDRESS[network].ARRAKIS_USDC_WETH_GAUGE,
-      MAX_AMOUNT
-    );
-    const gaugeAllowanceDelta = await allowanceDelta(
-      pool.address,
-      CONTRACT_ADDRESS[network].ARRAKIS_USDC_WETH_GAUGE,
-      routerAddress[network].arrakis!,
-      pool.signer
-    );
-    await expect(gaugeAllowanceDelta.gt(0));
-  });
+    it("approves unlimited USDC on Arrakis", async () => {
+      await pool.approve(Dapp.ARRAKIS, USDC, MAX_AMOUNT);
+      const usdcAllowanceDelta = await allowanceDelta(
+        pool.address,
+        USDC,
+        routerAddress[network].arrakis!,
+        pool.signer
+      );
+      await expect(usdcAllowanceDelta.gt(0));
+      await wait(5);
+    });
+
+    it("approves unlimited WETH on Arrakis", async () => {
+      await pool.approve(Dapp.ARRAKIS, WETH, MAX_AMOUNT);
+      const wethAllowanceDelta = await allowanceDelta(
+        pool.address,
+        USDC,
+        routerAddress[network].arrakis!,
+        pool.signer
+      );
+      await expect(wethAllowanceDelta.gt(0));
+    });
+
+    it("should add liquidity and stake in an WETH/USDC Arrakis pool", async () => {
+      const usdcBalance = await pool.utils.getBalance(USDC, pool.address);
+      const wethBalance = await pool.utils.getBalance(WETH, pool.address);
+      await pool.increaseLiquidity(
+        Dapp.ARRAKIS,
+        CONTRACT_ADDRESS[network].ARRAKIS_USDC_WETH_GAUGE,
+        usdcBalance,
+        wethBalance
+      );
+      const lpBalanceDelta = await balanceDelta(
+        pool.address,
+        CONTRACT_ADDRESS[network].ARRAKIS_USDC_WETH_LP,
+        pool.signer
+      );
+      expect(lpBalanceDelta.gt(0));
+    });
 
-  it("should remove liquidity from an existing pool ", async () => {
-    await pool.decreaseLiquidity(
-      Dapp.ARRAKIS,
-      CONTRACT_ADDRESS[network].ARRAKIS_USDC_WETH_GAUGE,
-      100
-    );
-    const wethBalanceDelta = await balanceDelta(
-      pool.address,
-      CONTRACT_ADDRESS[network].WETH,
-      pool.signer
-    );
-    expect(wethBalanceDelta.gt(0));
+    it("approves unlimited LP staking Token before on Arrakis", async () => {
+      await pool.approve(
+        Dapp.ARRAKIS,
+        CONTRACT_ADDRESS[network].ARRAKIS_USDC_WETH_GAUGE,
+        MAX_AMOUNT
+      );
+      const gaugeAllowanceDelta = await allowanceDelta(
+        pool.address,
+        CONTRACT_ADDRESS[network].ARRAKIS_USDC_WETH_GAUGE,
+        routerAddress[network].arrakis!,
+        pool.signer
+      );
+      await expect(gaugeAllowanceDelta.gt(0));
+    });
+
+    it("should remove liquidity from an existing pool ", async () => {
+      await pool.decreaseLiquidity(
+        Dapp.ARRAKIS,
+        CONTRACT_ADDRESS[network].ARRAKIS_USDC_WETH_GAUGE,
+        100
+      );
+      const wethBalanceDelta = await balanceDelta(
+        pool.address,
+        CONTRACT_ADDRESS[network].WETH,
+        pool.signer
+      );
+      expect(wethBalanceDelta.gt(0));
+    });
   });
+};
+
+testingHelper({
+  network: Network.POLYGON,
+  testingRun: testArrakis
 });

package/src/test/constants.ts

@@ -52,15 +52,27 @@ export const CONTRACT_ADDRESS = {
     WETH: "0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619",
     WBTC: "0x1BFD67037B42Cf73acF2047067bd4F2C47D9BfD6",
     ARRAKIS_USDC_WETH_GAUGE: "0x33d1ad9Cd88A509397CD924C2d7613C285602C20",
-    ARRAKIS_USDC_WETH_LP: "0xa173340f1e942c2845bcbce8ebd411022e18eb13"
+    ARRAKIS_USDC_WETH_LP: "0xa173340f1e942c2845bcbce8ebd411022e18eb13",
+    WMATIC: "0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270",
+    uniswapV3: {
+      nonfungiblePositionManager: "0xC36442b4a4522E871399CD717aBDD847Ab11FE88"
+    }
   },
+
   [Network.OPTIMISM]: {
     USDC: "0x7F5c764cBc14f9669B88837ca1490cCa17c31607",
     SUSD: "0x8c6f28f2f1a3c87f0f938b96d27520d9751ec8d9",
     SWETH: "",
     WETH: "0x4200000000000000000000000000000000000006",
     WBTC: "0x68f180fcCe6836688e9084f035309E29Bf0A2095",
-    KWENTA_ETH_PERP_V2: "0x2b3bb4c683bfc5239b029131eef3b1d214478d93"
+    KWENTA_ETH_PERP_V2: "0x2b3bb4c683bfc5239b029131eef3b1d214478d93",
+    uniswapV3: {
+      nonfungiblePositionManager: "0xC36442b4a4522E871399CD717aBDD847Ab11FE88"
+    },
+    WMATIC: "",
+    //
+    ARRAKIS_USDC_WETH_GAUGE: "",
+    ARRAKIS_USDC_WETH_LP: ""
   },
   [Network.ARBITRUM]: {
     USDC: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
@@ -69,13 +81,29 @@ export const CONTRACT_ADDRESS = {
     WBTC: "0x2f2a2543b76a4166549f7aab2e75bef0aefc5b0f",
     WSTETH: "0x5979d7b546e38e414f7e9822514be443a4800529",
     BALANCER_WSTETH_WETH_POOL: "0x36bf227d6bac96e2ab1ebb5492ecec69c691943f",
-    BALANCER_WSTETH_WETH_GAUGE: "0x251e51b25afa40f2b6b9f05aaf1bc7eaa0551771"
+    BALANCER_WSTETH_WETH_GAUGE: "0x251e51b25afa40f2b6b9f05aaf1bc7eaa0551771",
+
+    uniswapV3: {
+      nonfungiblePositionManager: "0xC36442b4a4522E871399CD717aBDD847Ab11FE88"
+    },
+
+    //
+    ARRAKIS_USDC_WETH_GAUGE: "",
+    ARRAKIS_USDC_WETH_LP: "",
+    WMATIC: ""
   },
   [Network.BASE]: {
     USDC: "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
     WETH: "0x4200000000000000000000000000000000000006",
     WBTC: "",
-    SWETH: ""
+    SWETH: "",
+    uniswapV3: {
+      nonfungiblePositionManager: ""
+    },
+    //
+    ARRAKIS_USDC_WETH_GAUGE: "",
+    ARRAKIS_USDC_WETH_LP: "",
+    WMATIC: ""
   }
 };