@dhedge/v2-sdk 1.9.8 → 1.10.0

package/src/config.ts

@@ -98,12 +98,20 @@ export const aaveAddressProvider: AddressDappNetworkMap = {
     [Dapp.AAVEV3]: "0xe20fCBdBfFC4Dd138cE8b2E6FBb6CB49777ad64D"
   }
 };
-export const nonfungiblePositionManagerAddress: AddressNetworkMap = {
-  [Network.POLYGON]: "0xC36442b4a4522E871399CD717aBDD847Ab11FE88",
-  [Network.OPTIMISM]: "0xC36442b4a4522E871399CD717aBDD847Ab11FE88",
-  [Network.ARBITRUM]: "0xC36442b4a4522E871399CD717aBDD847Ab11FE88",
-  // https://docs.uniswap.org/contracts/v3/reference/deployments
-  [Network.BASE]: "0x03a520b32C04BF3bEEf7BEb72E919cf822Ed34f1"
+export const nonfungiblePositionManagerAddress: AddressDappNetworkMap = {
+  [Network.POLYGON]: {
+    [Dapp.UNISWAPV3]: "0xC36442b4a4522E871399CD717aBDD847Ab11FE88"
+  },
+  [Network.OPTIMISM]: {
+    [Dapp.UNISWAPV3]: "0xC36442b4a4522E871399CD717aBDD847Ab11FE88",
+    [Dapp.VELODROMECL]: "0xbb5dfe1380333cee4c2eebd7202c80de2256adf4"
+  },
+  [Network.ARBITRUM]: {
+    [Dapp.UNISWAPV3]: "0xC36442b4a4522E871399CD717aBDD847Ab11FE88"
+  },
+  [Network.BASE]: {
+    [Dapp.UNISWAPV3]: "0x03a520b32C04BF3bEEf7BEb72E919cf822Ed34f1"
+  }
 };
 
 export const networkChainIdMap: NetworkChainIdMap = {
@@ -138,3 +146,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

@@ -3,13 +3,14 @@
 import { Contract, ethers, Wallet, BigNumber } from "ethers";
 
 import IERC20 from "../abi/IERC20.json";
+
+import IERC721 from "../abi/IERC721.json";
 import IMiniChefV2 from "../abi/IMiniChefV2.json";
 import ILendingPool from "../abi/ILendingPool.json";
 import ISynthetix from "../abi/ISynthetix.json";
 import IUniswapV2Router from "../abi/IUniswapV2Router.json";
 import INonfungiblePositionManager from "../abi/INonfungiblePositionManager.json";
 import IAaveIncentivesController from "../abi/IAaveIncentivesController.json";
-import IArrakisV1RouterStaking from "../abi/IArrakisV1RouterStaking.json";
 import ILiquidityGaugeV4 from "../abi/ILiquidityGaugeV4.json";
 import IBalancerRewardsGauge from "../abi/IBalancerRewardsGauge.json";
 
@@ -34,19 +35,23 @@ import {
 
 import { Utils } from "./utils";
 import {
-  getUniswapV3Liquidity,
-  getUniswapV3MintParams
+  getDecreaseLiquidityTxData,
+  getIncreaseLiquidityTxData,
+  getUniswapV3MintTxData
 } from "../services/uniswap/V3Liquidity";
-import { FeeAmount } from "@uniswap/v3-sdk";
 import { getUniswapV3SwapTxData } from "../services/uniswap/V3Trade";
 import { getEasySwapperTxData } from "../services/toros/easySwapper";
 import { getAaveV3ClaimTxData } from "../services/aave/incentives";
 import {
   getVelodromeAddLiquidityTxData,
+  getVelodromeCLDecreaseStakedLiquidityTxData,
+  getVelodromeCLIncreaseStakedLiquidityTxData,
+  getVelodromeClOwner,
   getVelodromeRemoveLiquidityTxData
 } from "../services/velodrome/liquidity";
 import {
   getVelodromeClaimTxData,
+  getVelodromeCLClaimTxData,
   getVelodromeStakeTxData
 } from "../services/velodrome/staking";
 import { getLyraOptionTxData } from "../services/lyra/trade";
@@ -64,6 +69,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;
@@ -256,7 +266,7 @@ export class Pool {
   ): Promise<any> {
     const iERC20 = new ethers.utils.Interface(IERC20.abi);
     const approveTxData = iERC20.encodeFunctionData("approve", [
-      nonfungiblePositionManagerAddress[this.network],
+      nonfungiblePositionManagerAddress[this.network][Dapp.UNISWAPV3],
       amount
     ]);
     const tx = await getPoolTxOrGasEstimate(
@@ -296,6 +306,35 @@ export class Pool {
     return tx;
   }
 
+  /**
+   * Approve NFT for provided spender address
+   * @param {string} spender Spender address
+   * @param {string} asset Address of asset
+   * @param {string} tokenId NFT id
+   * @param {any} options Transaction options
+   * @param {boolean} estimateGas Simulate/estimate gas
+   * @returns {Promise<any>} Transaction
+   */
+  async approveSpenderNFT(
+    spender: string,
+    asset: string,
+    tokenId: string,
+    options: any = null,
+    estimateGas = false
+  ): Promise<any> {
+    const iERC721 = new ethers.utils.Interface(IERC721.abi);
+    const approveTxData = iERC721.encodeFunctionData("approve", [
+      spender,
+      tokenId
+    ]);
+    const tx = await getPoolTxOrGasEstimate(
+      this,
+      [asset, approveTxData, options],
+      estimateGas
+    );
+    return tx;
+  }
+
   /**
    * Trade an asset into another asset
    * @param {Dapp} dapp Platform like Sushiswap or Uniswap
@@ -504,7 +543,7 @@ export class Pool {
    * Stake liquidity pool tokens in gauge contract
    * @param {Dapp} dapp Platform like Balancer or Velodrome
    * @param {string} gauge Gauge contract address
-   * @param {BigNumber | string} amount Amount of liquidity pool tokens
+   * @param {BigNumber | string} amount Amount of liquidity pool tokens or token ID for Velodrome CL
    * @param {any} options Transaction options
    * @param {boolean} estimateGas Simulate/estimate gas
    * @returns {Promise<any>} Transaction
@@ -532,6 +571,7 @@ export class Pool {
         break;
       case Dapp.VELODROMEV2:
       case Dapp.AERODROME:
+      case Dapp.VELODROMECL:
         stakeTxData = getVelodromeStakeTxData(amount, true);
         break;
       default:
@@ -579,7 +619,7 @@ export class Pool {
   /**
    * Unstake liquidity pool tokens from Velodrome or Balancer gauge
    * @param {string} gauge Gauge contract address
-   * @param {BigNumber | string} amount Amount of liquidity pool tokens
+   * @param {BigNumber | string} amount Amount of liquidity pool tokens or CL token ID
    * @param {any} options Transaction options
    * @param {boolean} estimateGas Simulate/estimate gas
    * @returns {Promise<any>} Transaction
@@ -941,6 +981,7 @@ export class Pool {
 
   /**
    * Create UniswapV3 liquidity pool
+   * @param {dapp} Platform either UniswapV3 or VelodromeCL
    * @param {string} assetA First asset
    * @param {string} assetB Second asset
    * @param {BigNumber | string} amountA Amount first asset
@@ -949,12 +990,13 @@ export class Pool {
    * @param { number } maxPrice Upper price range (assetB per assetA)
    * @param { number } minTick Lower tick range
    * @param { number } maxTick Upper tick range
-   * @param { FeeAmount } feeAmount Fee tier (Low 0.05%, Medium 0.3%, High 1%)
+   * @param { number } feeAmountOrTickSpacing Fee tier UniswapV3 or tick spacing VelodromeCL
    * @param {any} options Transaction options
    * @param {boolean} estimateGas Simulate/estimate gas
    * @returns {Promise<any>} Transaction
    */
   async addLiquidityUniswapV3(
+    dapp: Dapp.UNISWAPV3 | Dapp.VELODROMECL,
     assetA: string,
     assetB: string,
     amountA: BigNumber | string,
@@ -963,7 +1005,7 @@ export class Pool {
     maxPrice: number | null,
     minTick: number | null,
     maxTick: number | null,
-    feeAmount: FeeAmount,
+    feeAmountOrTickSpacing: number,
     options: any = null,
     estimateGas = false
   ): Promise<any> {
@@ -972,12 +1014,11 @@ 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");
 
-    const iNonfungiblePositionManager = new ethers.utils.Interface(
-      INonfungiblePositionManager.abi
-    );
-
-    const mintTxParams = await getUniswapV3MintParams(
+    const mintTxData = await getUniswapV3MintTxData(
+      dapp,
       this,
       assetA,
       assetB,
@@ -987,15 +1028,16 @@ export class Pool {
       maxPrice,
       minTick,
       maxTick,
-      feeAmount
-    );
-    const mintTxData = iNonfungiblePositionManager.encodeFunctionData(
-      Transaction.MINT,
-      [mintTxParams]
+      feeAmountOrTickSpacing
     );
+
     const tx = await getPoolTxOrGasEstimate(
       this,
-      [nonfungiblePositionManagerAddress[this.network], mintTxData, options],
+      [
+        nonfungiblePositionManagerAddress[this.network][dapp],
+        mintTxData,
+        options
+      ],
       estimateGas
     );
     return tx;
@@ -1017,46 +1059,37 @@ export class Pool {
     options: any = null,
     estimateGas = false
   ): Promise<any> {
-    let txData;
     let dappAddress;
-    if (dapp === Dapp.UNISWAPV3) {
-      dappAddress = nonfungiblePositionManagerAddress[this.network];
-      const abi = new ethers.utils.Interface(INonfungiblePositionManager.abi);
-      const liquidity = (await getUniswapV3Liquidity(tokenId, this))
-        .mul(Math.round(amount * 1e4))
-        .div(1e6);
-      const decreaseLiquidityTxData = abi.encodeFunctionData(
-        Transaction.DECREASE_LIQUIDITY,
-        [[tokenId, liquidity, 0, 0, await getDeadline(this)]]
-      );
-      const collectTxData = abi.encodeFunctionData(Transaction.COLLECT, [
-        [tokenId, this.address, MaxUint128, MaxUint128]
-      ]);
-
-      const multicallParams = [decreaseLiquidityTxData, collectTxData];
-
-      if (amount === 100) {
-        const burnTxData = abi.encodeFunctionData(Transaction.BURN, [tokenId]);
-        multicallParams.push(burnTxData);
-      }
-      txData = abi.encodeFunctionData(Transaction.MULTI_CALL, [
-        multicallParams
-      ]);
-    } else if (dapp === Dapp.ARRAKIS) {
-      dappAddress = routerAddress[this.network][dapp];
-      const abi = new ethers.utils.Interface(IArrakisV1RouterStaking.abi);
-      const liquidity = (await this.utils.getBalance(tokenId, this.address))
-        .mul(Math.round(amount * 1e4))
-        .div(1e6);
-      txData = abi.encodeFunctionData(Transaction.REMOVE_LIQUIDITY_UNSTAKE, [
-        tokenId,
-        liquidity,
-        0,
-        0,
-        this.address
-      ]);
+    let isStaked = false;
+    let txData;
+    switch (dapp) {
+      case Dapp.UNISWAPV3:
+        dappAddress = nonfungiblePositionManagerAddress[this.network][dapp];
+        break;
+      case Dapp.VELODROMECL:
+        const tokenIdOwner = await getVelodromeClOwner(this, tokenId);
+        if (tokenIdOwner.toLowerCase() === this.address.toLowerCase()) {
+          dappAddress = nonfungiblePositionManagerAddress[this.network][dapp];
+        } else {
+          //staked in gauge
+          dappAddress = tokenIdOwner;
+          isStaked = true;
+        }
+        break;
+      case Dapp.ARRAKIS:
+        dappAddress = routerAddress[this.network][dapp];
+        break;
+      default:
+        throw new Error("dapp not supported");
+    }
+    if (!isStaked) {
+      txData = await getDecreaseLiquidityTxData(this, dapp, tokenId, amount);
     } else {
-      throw new Error("dapp not supported");
+      txData = await getVelodromeCLDecreaseStakedLiquidityTxData(
+        this,
+        tokenId,
+        amount
+      );
     }
     const tx = await getPoolTxOrGasEstimate(
       this,
@@ -1067,7 +1100,7 @@ export class Pool {
   }
 
   /**
-   * Increase liquidity of an UniswapV3 or Arrakis liquidity pool
+   * Increase liquidity of an UniswapV, VelodromeCL or Arrakis liquidity pool
    * @param {Dapp} dapp Platform either UniswapV3 or Arrakis
    * @param {string} tokenId Token Id of UniswapV3 position
    * @param {BigNumber | string} amountA Amount first asset
@@ -1084,28 +1117,44 @@ export class Pool {
     options: any = null,
     estimateGas = false
   ): Promise<any> {
-    let txData;
     let dappAddress;
-    if (dapp === Dapp.UNISWAPV3) {
-      dappAddress = nonfungiblePositionManagerAddress[this.network];
-      const abi = new ethers.utils.Interface(INonfungiblePositionManager.abi);
-      txData = abi.encodeFunctionData(Transaction.INCREASE_LIQUIDITY, [
-        [tokenId, amountA, amountB, 0, 0, await getDeadline(this)]
-      ]);
-    } else if (dapp === Dapp.ARRAKIS) {
-      dappAddress = routerAddress[this.network][dapp];
-      const abi = new ethers.utils.Interface(IArrakisV1RouterStaking.abi);
-      txData = abi.encodeFunctionData(Transaction.ADD_LIQUIDITY_STAKE, [
+    let isStaked = false;
+    let txData;
+    switch (dapp) {
+      case Dapp.UNISWAPV3:
+        dappAddress = nonfungiblePositionManagerAddress[this.network][dapp];
+        break;
+      case Dapp.VELODROMECL:
+        const tokenIdOwner = await getVelodromeClOwner(this, tokenId);
+        if (tokenIdOwner.toLowerCase() === this.address.toLowerCase()) {
+          dappAddress = nonfungiblePositionManagerAddress[this.network][dapp];
+        } else {
+          //staked in gauge
+          dappAddress = tokenIdOwner;
+          isStaked = true;
+        }
+        break;
+      case Dapp.ARRAKIS:
+        dappAddress = routerAddress[this.network][dapp];
+        break;
+      default:
+        throw new Error("dapp not supported");
+    }
+    if (!isStaked) {
+      txData = await getIncreaseLiquidityTxData(
+        this,
+        dapp,
         tokenId,
         amountA,
-        amountB,
-        0,
-        0,
-        0,
-        this.address
-      ]);
+        amountB
+      );
     } else {
-      throw new Error("dapp not supported");
+      txData = await getVelodromeCLIncreaseStakedLiquidityTxData(
+        this,
+        tokenId,
+        amountA,
+        amountB
+      );
     }
     const tx = await getPoolTxOrGasEstimate(
       this,
@@ -1131,12 +1180,12 @@ export class Pool {
   ): Promise<any> {
     let txData;
     let contractAddress;
+    const iNonfungiblePositionManager = new ethers.utils.Interface(
+      INonfungiblePositionManager.abi
+    );
     switch (dapp) {
       case Dapp.UNISWAPV3:
-        contractAddress = nonfungiblePositionManagerAddress[this.network];
-        const iNonfungiblePositionManager = new ethers.utils.Interface(
-          INonfungiblePositionManager.abi
-        );
+        contractAddress = nonfungiblePositionManagerAddress[this.network][dapp];
         txData = iNonfungiblePositionManager.encodeFunctionData(
           Transaction.COLLECT,
           [[tokenId, this.address, MaxUint128, MaxUint128]]
@@ -1158,6 +1207,21 @@ export class Pool {
         contractAddress = tokenId;
         txData = getVelodromeClaimTxData(this, tokenId, true);
         break;
+      case Dapp.VELODROMECL:
+        const tokenIdOwner = await getVelodromeClOwner(this, tokenId);
+        if (tokenIdOwner.toLowerCase() === this.address.toLowerCase()) {
+          contractAddress =
+            nonfungiblePositionManagerAddress[this.network][dapp];
+          txData = iNonfungiblePositionManager.encodeFunctionData(
+            Transaction.COLLECT,
+            [[tokenId, this.address, MaxUint128, MaxUint128]]
+          );
+        } else {
+          //staked in gauge
+          contractAddress = tokenIdOwner;
+          txData = getVelodromeCLClaimTxData(tokenId);
+        }
+        break;
       default:
         throw new Error("dapp not supported");
     }
@@ -1185,7 +1249,7 @@ export class Pool {
     assetFrom: string,
     assetTo: string,
     amountIn: BigNumber | string,
-    feeAmount: FeeAmount,
+    feeAmount: number,
     slippage = 0.5,
     options: any = null,
     estimateGas = false
@@ -1629,4 +1693,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);
+};