@dhedge/v2-sdk 1.10.2 → 1.10.4

package/package.json

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

package/src/abi/compound/ICompoundV3Comet.json

@@ -0,0 +1,51 @@
+[
+	{
+		"inputs": [],
+		"name": "baseToken",
+		"outputs": [
+			{
+				"internalType": "address",
+				"name": "",
+				"type": "address"
+			}
+		],
+		"stateMutability": "view",
+		"type": "function"
+	},
+	{
+		"inputs": [
+			{
+				"internalType": "address",
+				"name": "asset",
+				"type": "address"
+			},
+			{
+				"internalType": "uint256",
+				"name": "amount",
+				"type": "uint256"
+			}
+		],
+		"name": "supply",
+		"outputs": [],
+		"stateMutability": "nonpayable",
+		"type": "function"
+	},
+	{
+		"inputs": [
+			{
+				"internalType": "address",
+				"name": "asset",
+				"type": "address"
+			},
+			{
+				"internalType": "uint256",
+				"name": "amount",
+				"type": "uint256"
+			}
+		],
+		"name": "withdraw",
+		"outputs": [],
+		"stateMutability": "nonpayable",
+		"type": "function"
+	}
+]

package/src/config.ts

@@ -113,7 +113,8 @@ export const nonfungiblePositionManagerAddress: AddressDappNetworkMap = {
     [Dapp.UNISWAPV3]: "0xC36442b4a4522E871399CD717aBDD847Ab11FE88"
   },
   [Network.BASE]: {
-    [Dapp.UNISWAPV3]: "0x03a520b32C04BF3bEEf7BEb72E919cf822Ed34f1"
+    [Dapp.UNISWAPV3]: "0x03a520b32C04BF3bEEf7BEb72E919cf822Ed34f1",
+    [Dapp.AERODROMECL]: "0x827922686190790b37229fd06084350e74485b72"
   }
 };
 

package/src/entities/pool.ts

@@ -72,6 +72,10 @@ import {
   mintUnitViaFlatMoney,
   redeemUnitViaFlatMoney
 } from "../services/flatmoney/stableLp";
+import {
+  getCompoundV3LendTxData,
+  getCompoundV3WithdrawTxData
+} from "../services/compound/lending";
 
 export class Pool {
   public readonly poolLogic: Contract;
@@ -570,6 +574,7 @@ export class Pool {
       case Dapp.VELODROMEV2:
       case Dapp.AERODROME:
       case Dapp.VELODROMECL:
+      case Dapp.AERODROMECL:
         stakeTxData = getVelodromeStakeTxData(amount, true);
         break;
       default:
@@ -665,6 +670,7 @@ export class Pool {
       this.address,
       referralCode
     ]);
+
     const tx = await getPoolTxOrGasEstimate(
       this,
       [routerAddress[this.network][dapp], depositTxData, options],
@@ -673,6 +679,32 @@ export class Pool {
     return tx;
   }
 
+  /**
+   * Lend asset to a Compound V3 style lending pool
+   * @param {string} market Address of market e.g cUSDCv3 address
+   * @param {string} asset Asset
+   * @param {BigNumber | string} amount Amount of asset to lend
+   * @param {any} options Transaction options
+   * @param {boolean} estimateGas Simulate/estimate gas
+   * @returns {Promise<any>} Transaction
+   */
+  async lendCompoundV3(
+    market: string,
+    asset: string,
+    amount: BigNumber | string,
+    options: any = null,
+    estimateGas = false
+  ): Promise<any> {
+    const supplyTxData = getCompoundV3LendTxData(asset, amount);
+
+    const tx = await getPoolTxOrGasEstimate(
+      this,
+      [market, supplyTxData, options],
+      estimateGas
+    );
+    return tx;
+  }
+
   /**
    * Witdraw asset from a lending pool
    * @param {Dapp} dapp Platform like Aave
@@ -694,6 +726,7 @@ export class Pool {
       Transaction.WITHDRAW,
       [asset, amount, this.address]
     );
+
     const tx = await getPoolTxOrGasEstimate(
       this,
       [routerAddress[this.network][dapp], withdrawTxData, options],
@@ -702,6 +735,32 @@ export class Pool {
     return tx;
   }
 
+  /**
+   * Witdraw asset from a COmpound V3 style lending pool
+   * @param {string} market Address of market e.g cUSDCv3 address
+   * @param {string} asset Asset
+   * @param  {BigNumber | string} amount Amount of asset to withdraw
+   * @param {any} options Transaction options
+   * @param {boolean} estimateGas Simulate/estimate gas
+   * @returns {Promise<any>} Transaction
+   */
+  async withdrawCompoundV3(
+    market: string,
+    asset: string,
+    amount: BigNumber | string,
+    options: any = null,
+    estimateGas = false
+  ): Promise<any> {
+    const withdrawTxData = getCompoundV3WithdrawTxData(asset, amount);
+
+    const tx = await getPoolTxOrGasEstimate(
+      this,
+      [market, withdrawTxData, options],
+      estimateGas
+    );
+    return tx;
+  }
+
   /**
    * Borrow asset from a lending pool
    * @param {Dapp} dapp Platform like Aave
@@ -979,7 +1038,7 @@ export class Pool {
 
   /**
    * Create UniswapV3 liquidity pool
-   * @param {dapp} Platform either UniswapV3 or VelodromeCL
+   * @param {dapp} Platform UniswapV3, VelodromeCL or AerodromeCL
    * @param {string} assetA First asset
    * @param {string} assetB Second asset
    * @param {BigNumber | string} amountA Amount first asset
@@ -994,7 +1053,7 @@ export class Pool {
    * @returns {Promise<any>} Transaction
    */
   async addLiquidityUniswapV3(
-    dapp: Dapp.UNISWAPV3 | Dapp.VELODROMECL,
+    dapp: Dapp.UNISWAPV3 | Dapp.VELODROMECL | Dapp.AERODROMECL,
     assetA: string,
     assetB: string,
     amountA: BigNumber | string,
@@ -1012,8 +1071,8 @@ export class Pool {
       (minTick === null || maxTick === null)
     )
       throw new Error("Need to provide price or tick range");
-    if ((minPrice || maxPrice) && dapp === Dapp.VELODROMECL)
-      throw new Error("no price conversion for Velodrome CL");
+    if ((minPrice || maxPrice) && dapp !== Dapp.UNISWAPV3)
+      throw new Error("no price conversion for Aerodrome/Velodrome CL");
 
     const mintTxData = await getUniswapV3MintTxData(
       dapp,
@@ -1065,7 +1124,8 @@ export class Pool {
         dappAddress = nonfungiblePositionManagerAddress[this.network][dapp];
         break;
       case Dapp.VELODROMECL:
-        const tokenIdOwner = await getVelodromeClOwner(this, tokenId);
+      case Dapp.AERODROMECL:
+        const tokenIdOwner = await getVelodromeClOwner(this, dapp, tokenId);
         if (tokenIdOwner.toLowerCase() === this.address.toLowerCase()) {
           dappAddress = nonfungiblePositionManagerAddress[this.network][dapp];
         } else {
@@ -1121,7 +1181,8 @@ export class Pool {
         dappAddress = nonfungiblePositionManagerAddress[this.network][dapp];
         break;
       case Dapp.VELODROMECL:
-        const tokenIdOwner = await getVelodromeClOwner(this, tokenId);
+      case Dapp.AERODROMECL:
+        const tokenIdOwner = await getVelodromeClOwner(this, dapp, tokenId);
         if (tokenIdOwner.toLowerCase() === this.address.toLowerCase()) {
           dappAddress = nonfungiblePositionManagerAddress[this.network][dapp];
         } else {
@@ -1201,7 +1262,8 @@ export class Pool {
         txData = getVelodromeClaimTxData(this, tokenId, true);
         break;
       case Dapp.VELODROMECL:
-        const tokenIdOwner = await getVelodromeClOwner(this, tokenId);
+      case Dapp.AERODROMECL:
+        const tokenIdOwner = await getVelodromeClOwner(this, dapp, tokenId);
         if (tokenIdOwner.toLowerCase() === this.address.toLowerCase()) {
           contractAddress =
             nonfungiblePositionManagerAddress[this.network][dapp];

package/src/services/compound/lending.ts

@@ -0,0 +1,20 @@
+import { ethers } from "../..";
+import ICompoundV3Comet from "../../abi/compound/ICompoundV3Comet.json";
+
+export function getCompoundV3LendTxData(
+  asset: string,
+  amount: ethers.BigNumber | string
+): string {
+  return new ethers.utils.Interface(
+    ICompoundV3Comet
+  ).encodeFunctionData("supply", [asset, amount]);
+}
+
+export function getCompoundV3WithdrawTxData(
+  asset: string,
+  amount: ethers.BigNumber | string
+): string {
+  return new ethers.utils.Interface(
+    ICompoundV3Comet
+  ).encodeFunctionData("withdraw", [asset, amount]);
+}

package/src/services/uniswap/V3Liquidity.ts

@@ -70,7 +70,7 @@ export function tryParseTick(
 }
 
 export async function getUniswapV3MintTxData(
-  dapp: Dapp.UNISWAPV3 | Dapp.VELODROMECL,
+  dapp: Dapp.UNISWAPV3 | Dapp.VELODROMECL | Dapp.AERODROMECL,
   pool: Pool,
   assetA: string,
   assetB: string,
@@ -147,7 +147,7 @@ export async function getUniswapV3MintTxData(
     INonfungiblePositionManager.abi
   );
 
-  if (dapp === Dapp.VELODROMECL) {
+  if (dapp === Dapp.VELODROMECL || dapp === Dapp.AERODROMECL) {
     iNonfungiblePositionManager = new ethers.utils.Interface(
       IVeldodromePositionManager.abi
     );
@@ -162,7 +162,7 @@ export async function getUniswapV3MintTxData(
 }
 
 export async function getUniswapV3Liquidity(
-  dapp: Dapp.UNISWAPV3 | Dapp.VELODROMECL,
+  dapp: Dapp.UNISWAPV3 | Dapp.VELODROMECL | Dapp.AERODROMECL,
   tokenId: string,
   pool: Pool
 ): Promise<BigNumber> {
@@ -184,7 +184,11 @@ export async function getIncreaseLiquidityTxData(
   amountB: ethers.BigNumber | string
 ): Promise<any> {
   let txData;
-  if (dapp === Dapp.UNISWAPV3 || dapp === Dapp.VELODROMECL) {
+  if (
+    dapp === Dapp.UNISWAPV3 ||
+    dapp === Dapp.VELODROMECL ||
+    dapp === Dapp.AERODROMECL
+  ) {
     const abi = new ethers.utils.Interface(INonfungiblePositionManager.abi);
     txData = abi.encodeFunctionData(Transaction.INCREASE_LIQUIDITY, [
       [tokenId, amountA, amountB, 0, 0, await getDeadline(pool)]
@@ -214,7 +218,11 @@ export async function getDecreaseLiquidityTxData(
   amount = 100
 ): Promise<any> {
   let txData;
-  if (dapp === Dapp.UNISWAPV3 || dapp === Dapp.VELODROMECL) {
+  if (
+    dapp === Dapp.UNISWAPV3 ||
+    dapp === Dapp.VELODROMECL ||
+    dapp === Dapp.AERODROMECL
+  ) {
     const abi = new ethers.utils.Interface(INonfungiblePositionManager.abi);
     const liquidity = (await getUniswapV3Liquidity(dapp, tokenId, pool))
       .times(amount)

package/src/services/velodrome/liquidity.ts

@@ -51,11 +51,12 @@ export async function getVelodromeRemoveLiquidityTxData(
 
 export async function getVelodromeClOwner(
   pool: Pool,
+  dapp: Dapp.VELODROMECL | Dapp.AERODROMECL,
   tokenId: string
 ): Promise<string> {
   const iNonfungiblePositionManager = new ethers.Contract(
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    nonfungiblePositionManagerAddress[pool.network][Dapp.VELODROMECL]!,
+    nonfungiblePositionManagerAddress[pool.network][dapp]!,
     INonfungiblePositionManager.abi,
     pool.signer
   );

package/src/test/aerodromeCL.test.ts

@@ -0,0 +1,188 @@
+import { Dhedge, Pool, ethers } from "..";
+
+import { nonfungiblePositionManagerAddress } from "../config";
+import { AssetEnabled, Dapp, Network } from "../types";
+import { CONTRACT_ADDRESS, MAX_AMOUNT, TEST_POOL } from "./constants";
+import {
+  TestingRunParams,
+  beforeAfterReset,
+  setChainlinkTimeout,
+  testingHelper
+} from "./utils/testingHelper";
+import { allowanceDelta, balanceDelta } from "./utils/token";
+import INonfungiblePositionManager from "../abi/INonfungiblePositionManager.json";
+
+const testAerodromeCL = ({ wallet, network, provider }: TestingRunParams) => {
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  const AERODROME_POSITION_MANGER = nonfungiblePositionManagerAddress[network][
+    Dapp.AERODROMECL
+  ]!;
+
+  const USDC = CONTRACT_ADDRESS[network].USDC;
+  const USDT = CONTRACT_ADDRESS[network].USDT;
+  const USDC_USDT_CL_GAUGE = "0xBd85D45f1636fCEB2359d9Dcf839f12b3cF5AF3F";
+  const AERO = CONTRACT_ADDRESS[network].VELO;
+
+  let dhedge: Dhedge;
+  let pool: Pool;
+  let velodromePositionManager: ethers.Contract;
+  let tokenId: string;
+  jest.setTimeout(100000);
+
+  describe(`[${network}] Aerodrome CL  tests`, () => {
+    beforeAll(async () => {
+      // top up ETH (gas)
+      await provider.send("hardhat_setBalance", [
+        wallet.address,
+        "0x100000000000000"
+      ]);
+      dhedge = new Dhedge(wallet, network);
+      pool = await dhedge.loadPool(TEST_POOL[network]);
+
+      // setChainlinkTimeout
+      await setChainlinkTimeout({ pool, provider }, 86400 * 365);
+
+      const newAssets: AssetEnabled[] = [
+        { asset: USDC, isDeposit: true },
+        { asset: USDT, isDeposit: true },
+        {
+          asset: AERODROME_POSITION_MANGER,
+          isDeposit: false
+        },
+        {
+          asset: AERO,
+          isDeposit: false
+        }
+      ];
+      await pool.managerLogic.changeAssets(newAssets, []);
+
+      velodromePositionManager = new ethers.Contract(
+        AERODROME_POSITION_MANGER,
+        INonfungiblePositionManager.abi,
+        pool.signer
+      );
+    });
+
+    beforeAfterReset({ beforeAll, afterAll, provider });
+
+    describe("Liquidity", () => {
+      it("approves unlimited USDC and USDT on for Aerodrome CL", async () => {
+        await pool.approveSpender(AERODROME_POSITION_MANGER, USDC, MAX_AMOUNT);
+        await pool.approveSpender(AERODROME_POSITION_MANGER, USDT, MAX_AMOUNT);
+        const UsdcAllowanceDelta = await allowanceDelta(
+          pool.address,
+          USDC,
+          AERODROME_POSITION_MANGER,
+          pool.signer
+        );
+        await expect(UsdcAllowanceDelta.gt(0));
+      });
+
+      it("adds USDC and WETH to a CL (mint position)", async () => {
+        const usdcBalance = await pool.utils.getBalance(USDC, pool.address);
+        const usdtBalance = await pool.utils.getBalance(USDT, pool.address);
+        await pool.addLiquidityUniswapV3(
+          Dapp.AERODROMECL,
+          USDC,
+          USDT,
+          usdcBalance.div(2),
+          usdtBalance.div(2),
+          null,
+          null,
+          -2,
+          4,
+          1
+        );
+
+        tokenId = (
+          await velodromePositionManager.tokenOfOwnerByIndex(pool.address, 0)
+        ).toString();
+        expect(tokenId).not.toBe(null);
+      });
+
+      it("increases liquidity in a CL position", async () => {
+        const usdcBalance = await pool.utils.getBalance(USDC, pool.address);
+        const usdtBalance = await pool.utils.getBalance(USDT, pool.address);
+        const positionBefore = await velodromePositionManager.positions(
+          tokenId
+        );
+        await pool.increaseLiquidity(
+          Dapp.AERODROMECL,
+          tokenId,
+          usdcBalance.div(2),
+          usdtBalance.div(2)
+        );
+        const positionAfter = await velodromePositionManager.positions(tokenId);
+        expect(positionAfter.liquidity.gt(positionBefore.liquidity));
+      });
+
+      it("decreases liquidity from a CL position", async () => {
+        const positionBefore = await velodromePositionManager.positions(
+          tokenId
+        );
+        await pool.decreaseLiquidity(Dapp.AERODROMECL, tokenId, 50);
+        const positionAfter = await velodromePositionManager.positions(tokenId);
+        expect(positionAfter.liquidity.lt(positionBefore.liquidity));
+      });
+
+      it("collects fess of a CL position", async () => {
+        await provider.send("evm_increaseTime", [24 * 3600 * 3]); // 1 day
+        await provider.send("evm_mine", []);
+        await pool.claimFees(Dapp.AERODROMECL, tokenId);
+        expect((await balanceDelta(pool.address, USDC, pool.signer)).gt(0));
+      });
+    });
+    describe("Liquidity staking", () => {
+      it("stakes a CL position in gauge", async () => {
+        await pool.approveSpender(AERODROME_POSITION_MANGER, USDC, MAX_AMOUNT);
+        await pool.approveSpender(AERODROME_POSITION_MANGER, USDT, MAX_AMOUNT);
+        const usdcBalance = await pool.utils.getBalance(USDC, pool.address);
+        const usdtBalance = await pool.utils.getBalance(USDT, pool.address);
+        await pool.addLiquidityUniswapV3(
+          Dapp.AERODROMECL,
+          USDC,
+          USDT,
+          usdcBalance.div(2),
+          usdtBalance.div(2),
+          null,
+          null,
+          -2,
+          4,
+          1
+        );
+
+        tokenId = (
+          await velodromePositionManager.tokenOfOwnerByIndex(pool.address, 0)
+        ).toString();
+        await pool.approveSpenderNFT(
+          USDC_USDT_CL_GAUGE,
+          AERODROME_POSITION_MANGER,
+          tokenId
+        );
+        await pool.stakeInGauge(Dapp.AERODROMECL, USDC_USDT_CL_GAUGE, tokenId);
+        expect(await velodromePositionManager.ownerOf(tokenId)).toBe(
+          USDC_USDT_CL_GAUGE
+        );
+      });
+
+      it("collects fess of a staked CL position", async () => {
+        await provider.send("evm_increaseTime", [24 * 3600]); // 1 day
+        await provider.send("evm_mine", []);
+        await pool.claimFees(Dapp.AERODROMECL, tokenId);
+        expect((await balanceDelta(pool.address, AERO, pool.signer)).gt(0));
+      });
+
+      it("unstakes a CL position from a gauge", async () => {
+        await pool.unstakeFromGauge(USDC_USDT_CL_GAUGE, tokenId);
+        expect(
+          (await velodromePositionManager.ownerOf(tokenId)).toLowerCase()
+        ).toBe(pool.address.toLowerCase());
+      });
+    });
+  });
+};
+
+testingHelper({
+  network: Network.BASE,
+  testingRun: testAerodromeCL
+});

package/src/test/compoundV3.test.ts

@@ -0,0 +1,90 @@
+/* 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 { AssetEnabled, Network } from "../types";
+import { CONTRACT_ADDRESS, MAX_AMOUNT, TEST_POOL } from "./constants";
+import {
+  TestingRunParams,
+  beforeAfterReset,
+  setWETHAmount,
+  testingHelper
+} from "./utils/testingHelper";
+import { allowanceDelta, balanceDelta } from "./utils/token";
+import { getWalletData } from "./wallet";
+
+const testCompoundV3 = ({ network, provider }: TestingRunParams) => {
+  const WETH = CONTRACT_ADDRESS[network].WETH;
+  const COMPOUNDV3_WETH = CONTRACT_ADDRESS[network].COMPOUNDV3_WETH;
+
+  let dhedge: Dhedge;
+  let pool: Pool;
+  jest.setTimeout(100000);
+
+  describe(`[${network}] compound V3 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 setWETHAmount({
+        amount: new BigNumber(1e18).toFixed(0),
+        userAddress: pool.address,
+        network,
+        provider
+      });
+
+      const newAssets: AssetEnabled[] = [
+        { asset: WETH, isDeposit: true },
+        {
+          asset: COMPOUNDV3_WETH,
+          isDeposit: false
+        }
+      ];
+      await pool.managerLogic.changeAssets(newAssets, []);
+    });
+    beforeAfterReset({ beforeAll, afterAll, provider });
+
+    it("approves unlimited WETH for cWETHv3 market", async () => {
+      await pool.approveSpender(COMPOUNDV3_WETH, WETH, MAX_AMOUNT);
+      const UsdcAllowanceDelta = await allowanceDelta(
+        pool.address,
+        WETH,
+        COMPOUNDV3_WETH,
+        pool.signer
+      );
+      await expect(UsdcAllowanceDelta.gt(0));
+    });
+
+    it("lends WETH to CompundV3 WETH market", async () => {
+      const wethBalance = await pool.utils.getBalance(WETH, pool.address);
+      await pool.lendCompoundV3(COMPOUNDV3_WETH, WETH, wethBalance);
+
+      const cWETHTokenDelta = await balanceDelta(
+        pool.address,
+        COMPOUNDV3_WETH,
+        pool.signer
+      );
+      expect(cWETHTokenDelta.gt(0));
+    });
+
+    it("withdraw WETH from CompundV3 WETH market", async () => {
+      const cWETHBalance = await pool.utils.getBalance(
+        COMPOUNDV3_WETH,
+        pool.address
+      );
+      await pool.withdrawCompoundV3(COMPOUNDV3_WETH, WETH, cWETHBalance);
+      const wethBalance = await balanceDelta(pool.address, WETH, pool.signer);
+      expect(wethBalance.gt(0));
+    });
+  });
+};
+
+testingHelper({
+  network: Network.ARBITRUM,
+  testingRun: testCompoundV3
+});

package/src/test/constants.ts

@@ -48,6 +48,7 @@ export const TEST_POOL = {
 export const CONTRACT_ADDRESS = {
   [Network.POLYGON]: {
     USDC: "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174",
+    USDT: "",
     SWETH: "",
     WETH: "0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619",
     WBTC: "0x1BFD67037B42Cf73acF2047067bd4F2C47D9BfD6",
@@ -58,13 +59,15 @@ export const CONTRACT_ADDRESS = {
       nonfungiblePositionManager: "0xC36442b4a4522E871399CD717aBDD847Ab11FE88"
     },
     VELODROME_CL_USDC_WETH_GAUGE: "",
-    VELO: ""
+    VELO: "",
+    COMPOUNDV3_WETH: ""
   },
 
   [Network.OPTIMISM]: {
     USDC: "0x0b2c639c533813f4aa9d7837caf62653d097ff85",
-    SUSD: "0x8c6f28f2f1a3c87f0f938b96d27520d9751ec8d9",
+    USDT: "",
     SWETH: "",
+    SUSD: "0x8c6f28f2f1a3c87f0f938b96d27520d9751ec8d9",
     WETH: "0x4200000000000000000000000000000000000006",
     WBTC: "0x68f180fcCe6836688e9084f035309E29Bf0A2095",
     KWENTA_ETH_PERP_V2: "0x2b3bb4c683bfc5239b029131eef3b1d214478d93",
@@ -77,10 +80,12 @@ export const CONTRACT_ADDRESS = {
     ARRAKIS_USDC_WETH_GAUGE: "",
     ARRAKIS_USDC_WETH_LP: "",
     VELODROME_CL_USDC_WETH_GAUGE: "0xa75127121d28a9BF848F3B70e7Eea26570aa7700",
-    VELO: "0x9560e827aF36c94D2Ac33a39bCE1Fe78631088Db"
+    VELO: "0x9560e827aF36c94D2Ac33a39bCE1Fe78631088Db",
+    COMPOUNDV3_WETH: ""
   },
   [Network.ARBITRUM]: {
     USDC: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
+    USDT: "",
     SWETH: "0xbc011A12Da28e8F0f528d9eE5E7039E22F91cf18",
     WETH: "0x82af49447d8a07e3bd95bd0d56f35241523fbab1",
     WBTC: "0x2f2a2543b76a4166549f7aab2e75bef0aefc5b0f",
@@ -97,10 +102,12 @@ export const CONTRACT_ADDRESS = {
     ARRAKIS_USDC_WETH_LP: "",
     WMATIC: "",
     VELODROME_CL_USDC_WETH_GAUGE: "",
-    VELO: ""
+    VELO: "",
+    COMPOUNDV3_WETH: "0x6f7D514bbD4aFf3BcD1140B7344b32f063dEe486"
   },
   [Network.BASE]: {
     USDC: "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
+    USDT: "0xfde4c96c8593536e31f229ea8f37b2ada2699bb2",
     WETH: "0x4200000000000000000000000000000000000006",
     WBTC: "",
     SWETH: "",
@@ -111,8 +118,9 @@ export const CONTRACT_ADDRESS = {
     ARRAKIS_USDC_WETH_GAUGE: "",
     ARRAKIS_USDC_WETH_LP: "",
     WMATIC: "",
-    VELODROME_CL_USDC_WETH_GAUGE: "",
-    VELO: ""
+    VELODROME_CL_USDC_WETH_GAUGE: "0xF33a96b5932D9E9B9A0eDA447AbD8C9d48d2e0c8",
+    VELO: "0x940181a94A35A4569E4529A3CDfB74e38FD98631",
+    COMPOUNDV3_WETH: ""
   }
 };
 

package/src/types.ts

@@ -25,7 +25,8 @@ export enum Dapp {
   LYRA = "lyra",
   ZEROEX = "0x",
   RAMSES = "ramses",
-  AERODROME = "aerodrome"
+  AERODROME = "aerodrome",
+  AERODROMECL = "aerodromeCL"
 }
 
 export enum Transaction {