@dhedge/v2-sdk 1.9.8 → 1.9.9

package/src/config.ts

@@ -138,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;
@@ -1629,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/flatmoney.test.ts

@@ -0,0 +1,164 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import BigNumber from "bignumber.js";
+import { Dhedge, Pool } from "../entities";
+import { AssetEnabled, Network } from "../types";
+import {
+  TestingRunParams,
+  setTokenAmount,
+  testingHelper
+} from "./utils/testingHelper";
+import { Contract, ethers } from "ethers";
+import { CONTRACT_ADDRESS, MAX_AMOUNT, TEST_POOL } from "./constants";
+import { flatMoneyContractAddresses } from "../config";
+import DelayedOrderAbi from "../abi/flatmoney/DelayedOrder.json";
+import { allowanceDelta } from "./utils/token";
+import { getKeeperFee } from "../services/flatmoney/keeperFee";
+
+const RETH = "0xb6fe221fe9eef5aba221c348ba20a1bf5e73624c";
+const RETH_SLOT = 0;
+const UNIT = "0xb95fB324b8A2fAF8ec4f76e3dF46C718402736e2";
+// https://github.com/OpenZeppelin/openzeppelin-contracts-upgradeable/blob/master/contracts/token/ERC20/ERC20Upgradeable.sol#L31
+// https://eips.ethereum.org/EIPS/eip-7201
+const UNIT_SLOT =
+  "0x52c63247e1f47db19d5ce0460030c497f067ca4cebf71ba98eeadabe20bace00";
+
+const testFlatMoney = ({
+  wallet,
+  network,
+  provider,
+  rpcUrl
+}: TestingRunParams) => {
+  let dhedge: Dhedge;
+  let pool: Pool;
+  let delayOrderContract: Contract;
+  jest.setTimeout(200000);
+  describe(`flatmoney on ${network}`, () => {
+    beforeAll(async () => {
+      dhedge = new Dhedge(wallet, network);
+      pool = await dhedge.loadPool(TEST_POOL[network]);
+
+      const flatMoneyContracts = flatMoneyContractAddresses[pool.network];
+      if (!flatMoneyContracts) {
+        throw new Error("testFlatMoney: network not supported");
+      }
+      delayOrderContract = new Contract(
+        flatMoneyContracts.DelayedOrder,
+        DelayedOrderAbi,
+        pool.signer
+      );
+
+      // top up gas
+      await provider.send("hardhat_setBalance", [
+        wallet.address,
+        "0x10000000000000000"
+      ]);
+      await provider.send("evm_mine", []);
+
+      await setTokenAmount({
+        amount: new BigNumber(100).times(1e18).toString(),
+        provider,
+        tokenAddress: RETH,
+        slot: RETH_SLOT,
+        userAddress: pool.address
+      });
+      await setTokenAmount({
+        amount: new BigNumber(100).times(1e18).toString(),
+        provider,
+        tokenAddress: UNIT,
+        slot: UNIT_SLOT,
+        userAddress: pool.address
+      });
+
+      const currentAssets: any[] = await pool.managerLogic.getSupportedAssets();
+      const exisitingAssets = currentAssets.map(item => {
+        return {
+          asset: item[0],
+          isDeposit: item[1]
+        };
+      });
+
+      const newAssets: AssetEnabled[] = [
+        ...exisitingAssets,
+        { asset: CONTRACT_ADDRESS[network].USDC, isDeposit: true },
+        { asset: CONTRACT_ADDRESS[network].WETH, isDeposit: true },
+        {
+          asset: UNIT,
+          isDeposit: false
+        },
+        {
+          asset: RETH,
+          isDeposit: false
+        }
+      ];
+      await pool.changeAssets(newAssets);
+    });
+
+    it("mint UNIT", async () => {
+      //approve
+      await pool.approveSpender(delayOrderContract.address, RETH, MAX_AMOUNT);
+      const collateralAllowanceDelta = await allowanceDelta(
+        pool.address,
+        RETH,
+        delayOrderContract.address,
+        pool.signer
+      );
+      await expect(collateralAllowanceDelta.gt(0));
+
+      const depositAmountStr = new BigNumber(1).times(1e18).toString();
+      const tx = await pool.mintUnitViaFlatMoney(
+        depositAmountStr,
+        0.5,
+        10, // set higher to tolerate high gasPrice returned by forked local chain
+        null,
+        false
+      );
+      expect(tx).not.toBe(null);
+      const existingOrder = await delayOrderContract.getAnnouncedOrder(
+        pool.address
+      );
+      expect(existingOrder.orderType).toBe(1);
+    });
+
+    it("cancel order", async () => {
+      await provider.send("evm_increaseTime", [60 * 2]); // more than 1 min
+      await pool.cancelOrderViaFlatMoney();
+      const existingOrder = await delayOrderContract.getAnnouncedOrder(
+        pool.address
+      );
+      expect(existingOrder.orderType).toBe(0);
+    });
+
+    it("redeem UNIT", async () => {
+      const withdrawAmountStr = new BigNumber(2).times(1e18).toString();
+      const tx = await pool.redeemUnitViaFlatMoney(
+        withdrawAmountStr,
+        0.5,
+        10, //  set higher to tolerate high gasPrice returned by forked local chain
+        null,
+        false
+      );
+      expect(tx).not.toBe(null);
+      const existingOrder = await delayOrderContract.getAnnouncedOrder(
+        pool.address
+      );
+      expect(existingOrder.orderType).toBe(2);
+
+      await provider.send("evm_increaseTime", [60 * 2]); // more than 1 min
+      await pool.cancelOrderViaFlatMoney();
+    });
+
+    it("keeperFee is small", async () => {
+      const provider = new ethers.providers.JsonRpcProvider(rpcUrl);
+      const walletOnChain = wallet.connect(provider);
+      const dhedge = new Dhedge(walletOnChain, network);
+      const pool = await dhedge.loadPool(TEST_POOL[network]);
+      const keeperFee = await getKeeperFee(pool, 3);
+      expect(keeperFee).toBeTruthy();
+    });
+  });
+};
+
+testingHelper({
+  network: Network.BASE,
+  testingRun: testFlatMoney
+});

package/src/test/utils/testingHelper.ts

@@ -7,6 +7,7 @@ export type TestingRunParams = {
   network: Network;
   wallet: ethers.Wallet;
   provider: ethers.providers.JsonRpcProvider;
+  rpcUrl: string;
 };
 
 type TestHelperParams = {
@@ -17,8 +18,8 @@ export const testingHelper = ({
   network,
   testingRun
 }: TestHelperParams): void => {
-  const { wallet, provider } = getWalletData(network);
-  testingRun({ network, wallet, provider });
+  const { wallet, provider, rpcUrl } = getWalletData(network);
+  testingRun({ network, wallet, provider, rpcUrl });
 };
 
 export const beforeAfterReset = ({
@@ -52,7 +53,7 @@ export const setTokenAmount = async ({
   amount: string;
   userAddress: string;
   tokenAddress: string;
-  slot: number;
+  slot: number | string;
   provider: ethers.providers.JsonRpcProvider;
 }): Promise<void> => {
   const toBytes32 = (bn: string) => {

package/src/test/wallet.ts

@@ -38,12 +38,15 @@ export const getWalletData = (
 ): {
   wallet: ethers.Wallet;
   provider: ethers.providers.JsonRpcProvider;
+  rpcUrl: string;
 } => {
   const provider = new ethers.providers.JsonRpcProvider(
     `http://127.0.0.1:${networkPortMap[network]}/`
   );
+  const rpcUrl = process.env[`${network.toUpperCase()}_URL`] || "";
   return {
     wallet: new ethers.Wallet(process.env.PRIVATE_KEY as string, provider),
-    provider
+    provider,
+    rpcUrl
   };
 };