@dhedge/v2-sdk 1.9.7 → 1.9.9

package/src/config.ts

@@ -54,7 +54,9 @@ export const routerAddress: AddressDappNetworkMap = {
   },
   [Network.BASE]: {
     [Dapp.ONEINCH]: "0x1111111254EEB25477B68fb85Ed929f73A960582",
-    [Dapp.ZEROEX]: "0xdef1c0ded9bec7f1a1670819833240f027b25eff"
+    [Dapp.ZEROEX]: "0xdef1c0ded9bec7f1a1670819833240f027b25eff",
+    [Dapp.AERODROME]: "0xcF77a3Ba9A5CA399B7c97c74d54e5b1Beb874E43",
+    [Dapp.AAVEV3]: "0xA238Dd80C259a72e81d7e4664a9801593F98d1c5"
   }
 };
 
@@ -136,3 +138,22 @@ export const UNISWAPV3_QUOTER_ADDRESS =
 
 export const SYNTHETIX_TRACKING_CODE =
   "0x4448454447450000000000000000000000000000000000000000000000000000";
+
+export const flatMoneyContractAddresses: Readonly<Partial<
+  Record<
+    Network,
+    {
+      DelayedOrder: string;
+      FlatcoinVault: string;
+      StableModule: string;
+      RETH: string;
+    }
+  >
+>> = {
+  [Network.BASE]: {
+    DelayedOrder: "0x6D857e9D24a7566bB72a3FB0847A3E0e4E1c2879",
+    FlatcoinVault: "0x95Fa1ddc9a78273f795e67AbE8f1Cd2Cd39831fF",
+    StableModule: "0xb95fB324b8A2fAF8ec4f76e3dF46C718402736e2",
+    RETH: "0xb6fe221fe9eef5aba221c348ba20a1bf5e73624c"
+  }
+};

package/src/entities/pool.ts

@@ -64,6 +64,11 @@ import {
   getExitVestTxData
 } from "../services/ramses/vesting";
 import { getPoolTxOrGasEstimate } from "../utils/contract";
+import {
+  cancelOrderViaFlatMoney,
+  mintUnitViaFlatMoney,
+  redeemUnitViaFlatMoney
+} from "../services/flatmoney/stableLp";
 
 export class Pool {
   public readonly poolLogic: Contract;
@@ -531,6 +536,7 @@ export class Pool {
         stakeTxData = getVelodromeStakeTxData(amount, false);
         break;
       case Dapp.VELODROMEV2:
+      case Dapp.AERODROME:
         stakeTxData = getVelodromeStakeTxData(amount, true);
         break;
       default:
@@ -1153,6 +1159,7 @@ export class Pool {
         txData = getVelodromeClaimTxData(this, tokenId, false);
         break;
       case Dapp.VELODROMEV2:
+      case Dapp.AERODROME:
         contractAddress = tokenId;
         txData = getVelodromeClaimTxData(this, tokenId, true);
         break;
@@ -1356,7 +1363,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
@@ -1367,7 +1374,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,
@@ -1397,7 +1404,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
@@ -1407,7 +1414,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,
@@ -1627,4 +1634,66 @@ export class Pool {
     );
     return tx;
   }
+
+  /** deposit rETH to mint UNIT via the Flat Money protocol
+   *
+   * @param { BigNumber | string } depositAmount Amount of rETH to deposit
+   * @param { number } slippage slippage, 0.5 represents 0.5%
+   * @param { number | null } maxKeeperFeeInUsd 5 represents $5; null will skip the maxKeeperFee check
+   * @param {any} options Transaction options
+   * @param {boolean} estimateGas Simulate/estimate gas
+   * @returns {Promise<any>} Transaction
+   */
+  async mintUnitViaFlatMoney(
+    depositAmount: ethers.BigNumber | string,
+    slippage = 0.5,
+    maxKeeperFeeInUsd: number | null,
+    options: any = null,
+    estimateGas = false
+  ): Promise<any> {
+    const tx = await mintUnitViaFlatMoney(
+      this,
+      depositAmount,
+      slippage,
+      maxKeeperFeeInUsd,
+      options,
+      estimateGas
+    );
+    return tx;
+  }
+
+  /** redeem UNIT via the Flat Money protocol
+   *
+   * @param { BigNumber | string } depositAmount Amount of UNIT to withdraw
+   * @param { number } slippage slippage, 0.5 represents 0.5%
+   * @param { number | null } maxKeeperFeeInUsd 5 represents $5; null will skip the maxKeeperFee check
+   * @param {any} options Transaction options
+   * @param {boolean} estimateGas Simulate/estimate gas
+   * @returns {Promise<any>} Transaction
+   */
+  async redeemUnitViaFlatMoney(
+    withdrawAmount: ethers.BigNumber | string,
+    slippage = 0.5,
+    maxKeeperFeeInUsd: number | null,
+    options: any = null,
+    estimateGas = false
+  ): Promise<any> {
+    const tx = await redeemUnitViaFlatMoney(
+      this,
+      withdrawAmount,
+      slippage,
+      maxKeeperFeeInUsd,
+      options,
+      estimateGas
+    );
+    return tx;
+  }
+
+  async cancelOrderViaFlatMoney(
+    options: any = null,
+    estimateGas = false
+  ): Promise<any> {
+    const tx = await cancelOrderViaFlatMoney(this, options, estimateGas);
+    return tx;
+  }
 }

package/src/services/flatmoney/keeperFee.ts

@@ -0,0 +1,84 @@
+import { Contract, ethers } from "ethers";
+import { Pool } from "../../entities";
+import IFlatcoinVaultAbi from "../../abi/flatmoney/IFlatcoinVault.json";
+import KeeperFeeAbi from "../../abi/flatmoney/KeeperFee.json";
+import { flatMoneyContractAddresses } from "../../config";
+import BigNumber from "bignumber.js";
+
+export const getKeeperFeeContract = async (pool: Pool): Promise<Contract> => {
+  const flatMoneyContracts = flatMoneyContractAddresses[pool.network];
+  if (!flatMoneyContracts) {
+    throw new Error(
+      `getStableModuleContract: network of ${pool.network} not supported`
+    );
+  }
+  const flatcoinVaultContract = new Contract(
+    flatMoneyContracts.FlatcoinVault,
+    IFlatcoinVaultAbi,
+    pool.signer
+  );
+  const key = ethers.utils.formatBytes32String("keeperFee");
+  const keeperFeeContractAddress: string = await flatcoinVaultContract.callStatic.moduleAddress(
+    key
+  );
+
+  const keeperFeeContract = new ethers.Contract(
+    keeperFeeContractAddress,
+    KeeperFeeAbi,
+    pool.signer
+  );
+  return keeperFeeContract;
+};
+
+export const getKeeperFee = async (
+  pool: Pool,
+  maxKeeperFeeInUsd: number | null
+): Promise<ethers.BigNumber> => {
+  const keeperFeeContract = await getKeeperFeeContract(pool);
+  const gasPrice = await pool.signer.provider.getGasPrice();
+
+  let keeperfee: ethers.BigNumber;
+  if (gasPrice) {
+    keeperfee = await keeperFeeContract["getKeeperFee(uint256)"](
+      new BigNumber(gasPrice.toString()).times(1.2).toFixed(0)
+    );
+  } else {
+    keeperfee = await keeperFeeContract["getKeeperFee()"]();
+  }
+
+  const keeperFeeInUsd = await getKeeperFeeInUsd(pool, keeperfee);
+
+  if (
+    Number.isFinite(maxKeeperFeeInUsd) &&
+    keeperFeeInUsd.gt(ethers.BigNumber.from(maxKeeperFeeInUsd).toString())
+  ) {
+    throw new Error("mintUnitViaFlatMoney: keeperFee too large");
+  }
+
+  return keeperfee;
+};
+
+export const getKeeperFeeInUsd = async (
+  pool: Pool,
+  keeperFee: ethers.BigNumber
+): Promise<BigNumber> => {
+  const flatMoneyContracts = flatMoneyContractAddresses[pool.network];
+  if (!flatMoneyContracts) {
+    throw new Error(
+      `getKeeperFeeInUsd: network of ${pool.network} not supported`
+    );
+  }
+  const fundComposition = await pool.getComposition();
+  const filteredFc = fundComposition.filter(
+    fc =>
+      fc.asset.toLocaleLowerCase() ===
+      flatMoneyContracts.RETH.toLocaleLowerCase()
+  );
+
+  if (!filteredFc[0])
+    throw new Error(`getKeeperFeeInUsd: required asset not enabled yet`);
+
+  const rateD1 = new BigNumber(filteredFc[0].rate.toString()).div(1e18);
+
+  return rateD1.times(keeperFee.toString()).div(1e18);
+};

package/src/services/flatmoney/stableLp.ts

@@ -0,0 +1,135 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import BigNumber from "bignumber.js";
+import { Pool, ethers } from "../..";
+import DelayedOrderAbi from "../../abi/flatmoney/DelayedOrder.json";
+import { flatMoneyContractAddresses } from "../../config";
+import { getPoolTxOrGasEstimate } from "../../utils/contract";
+import { getStableDepositQuote, getStableWithdrawQuote } from "./stableModule";
+import { getKeeperFee } from "./keeperFee";
+
+export function getAnnounceStableDepositTxData(
+  depositAmount: ethers.BigNumber | string,
+  minAmountOut: ethers.BigNumber | string,
+  keeperFee: ethers.BigNumber | string
+): string {
+  return new ethers.utils.Interface(
+    DelayedOrderAbi
+  ).encodeFunctionData("announceStableDeposit", [
+    depositAmount,
+    minAmountOut,
+    keeperFee
+  ]);
+}
+
+export function getAnnounceStableWithdrawTxData(
+  withdrawAmount: ethers.BigNumber | string,
+  minAmountOut: ethers.BigNumber | string,
+  keeperFee: ethers.BigNumber | string
+): string {
+  return new ethers.utils.Interface(
+    DelayedOrderAbi
+  ).encodeFunctionData("announceStableWithdraw", [
+    withdrawAmount,
+    minAmountOut,
+    keeperFee
+  ]);
+}
+
+export function getCancelExistingOrderTxData(account: string): string {
+  return new ethers.utils.Interface(
+    DelayedOrderAbi
+  ).encodeFunctionData("cancelExistingOrder", [account]);
+}
+
+export async function mintUnitViaFlatMoney(
+  pool: Pool,
+  depositAmount: ethers.BigNumber | string,
+  slippage: number, // 0.5 means 0.5%
+  maxKeeperFeeInUsd: number | null,
+  options: any = null,
+  estimateGas = false
+): Promise<any> {
+  const flatMoneyContracts = flatMoneyContractAddresses[pool.network];
+  if (!flatMoneyContracts) {
+    throw new Error("mintUnitViaFlatMoney: network not supported");
+  }
+
+  const keeperfee = await getKeeperFee(pool, maxKeeperFeeInUsd); // in RETH
+
+  const adjustedDepositAmount = new BigNumber(depositAmount.toString()).minus(
+    keeperfee.toString() // keeper fee deducted from amountIn
+  );
+
+  const amountOut = await getStableDepositQuote(
+    pool,
+    adjustedDepositAmount.toFixed(0)
+  );
+  const minAmountOut = new BigNumber(amountOut.toString())
+    .times(1 - slippage / 100)
+    .toFixed(0);
+
+  const mintUnitTxData = await getAnnounceStableDepositTxData(
+    adjustedDepositAmount.toFixed(0),
+    minAmountOut,
+    keeperfee
+  );
+
+  const tx = await getPoolTxOrGasEstimate(
+    pool,
+    [flatMoneyContracts.DelayedOrder, mintUnitTxData, options],
+    estimateGas
+  );
+  return tx;
+}
+
+export async function redeemUnitViaFlatMoney(
+  pool: Pool,
+  withdrawAmount: ethers.BigNumber | string,
+  slippage: number, // 0.5 means 0.5%
+  maxKeeperFeeInUsd: number | null,
+  options: any = null,
+  estimateGas = false
+): Promise<any> {
+  const flatMoneyContracts = flatMoneyContractAddresses[pool.network];
+  if (!flatMoneyContracts) {
+    throw new Error("redeemUnitViaFlatMoney: network not supported");
+  }
+  const keeperfee = await getKeeperFee(pool, maxKeeperFeeInUsd); // in RETH
+
+  const amountOut = await getStableWithdrawQuote(pool, withdrawAmount);
+  const minAmountOut = new BigNumber(amountOut.toString())
+    .times(1 - slippage / 100)
+    .minus(keeperfee.toString()) // keeper fee deducted from amountOut
+    .toFixed(0);
+
+  const redeemUnitTxData = await getAnnounceStableWithdrawTxData(
+    withdrawAmount,
+    minAmountOut,
+    keeperfee
+  );
+  const tx = await getPoolTxOrGasEstimate(
+    pool,
+    [flatMoneyContracts.DelayedOrder, redeemUnitTxData, options],
+    estimateGas
+  );
+  return tx;
+}
+
+export async function cancelOrderViaFlatMoney(
+  pool: Pool,
+  options: any = null,
+  estimateGas = false
+): Promise<any> {
+  const flatMoneyContracts = flatMoneyContractAddresses[pool.network];
+  if (!flatMoneyContracts) {
+    throw new Error("cancelOrderViaFlatMoney: network not supported");
+  }
+  const cancelOrderTxData = await getCancelExistingOrderTxData(pool.address);
+  const tx = await getPoolTxOrGasEstimate(
+    pool,
+    [flatMoneyContracts.DelayedOrder, cancelOrderTxData, options],
+    estimateGas
+  );
+  return tx;
+}

package/src/services/flatmoney/stableModule.ts

@@ -0,0 +1,43 @@
+import { BigNumber, Contract } from "ethers";
+import { flatMoneyContractAddresses } from "../../config";
+import { Pool } from "../../entities";
+import StableModuleAbi from "../../abi/flatmoney/StableModule.json";
+
+const getStableModuleContract = (pool: Pool): Contract => {
+  const flatMoneyContracts = flatMoneyContractAddresses[pool.network];
+  if (!flatMoneyContracts) {
+    throw new Error(
+      `getStableModuleContract: network of ${pool.network} not supported`
+    );
+  }
+  const stableModuleContract = new Contract(
+    flatMoneyContracts.StableModule,
+    StableModuleAbi,
+    pool.signer
+  );
+  return stableModuleContract;
+};
+
+/// @notice Quoter function for getting the stable deposit amount out.
+export const getStableDepositQuote = async (
+  pool: Pool,
+  depositAmount: string | BigNumber
+): Promise<BigNumber> => {
+  const stableModuleContract = getStableModuleContract(pool);
+  const amountOut: BigNumber = await stableModuleContract.stableDepositQuote(
+    depositAmount.toString()
+  );
+  return amountOut;
+};
+
+/// @notice Quoter function for getting the stable withdraw amount out.
+export const getStableWithdrawQuote = async (
+  pool: Pool,
+  withdrawAmount: string | BigNumber
+): Promise<BigNumber> => {
+  const stableModuleContract = getStableModuleContract(pool);
+  const amountOut: BigNumber = await stableModuleContract.stableWithdrawQuote(
+    withdrawAmount.toString()
+  );
+  return amountOut;
+};

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
+});