@dhedge/v2-sdk 2.2.1 → 2.2.2

package/src/test/dytm.test.ts

@@ -0,0 +1,241 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+
+import BigNumber from "bignumber.js";
+import { BigNumber as EthersBigNumber, Contract, providers } from "ethers";
+import { Dhedge, Pool } from "..";
+import { Dapp, Network } from "../types";
+import { CONTRACT_ADDRESS, MAX_AMOUNT } from "./constants";
+import {
+  TestingRunParams,
+  runWithImpersonateAccount,
+  setTokenAmount,
+  setUSDCAmount,
+  testingHelper
+} from "./utils/testingHelper";
+import { balanceDelta } from "./utils/token";
+import { routerAddress } from "../config";
+
+const officeAbi = [
+  "function getMarketConfig(uint88 market) view returns (address marketConfig)"
+];
+const marketConfigAbi = ["function hooks() view returns (address hooks)"];
+const borrowerWhitelistAbi = [
+  "function owner() view returns (address)",
+  "function setAddressWhitelist(address accountOwner, bool allowed)"
+];
+const erc20AllowanceAbi = [
+  "function allowance(address owner, address spender) view returns (uint256)"
+];
+
+const DYTM_MARKET_ID = 1;
+// ReserveKey: (marketId uint88 << 160) | asset address — DYTM src/types/ReserveKey.sol
+const toReserveKey = (marketId: number, asset: string): EthersBigNumber =>
+  EthersBigNumber.from(marketId)
+    .shl(160)
+    .or(asset);
+// full tokenId: (TokenType << 248) | reserveKey — DYTM src/libraries/TokenHelpers.sol
+// TokenType: ESCROW = 1, LEND = 2, DEBT = 3
+const toLentId = (key: EthersBigNumber): EthersBigNumber =>
+  EthersBigNumber.from(2)
+    .shl(248)
+    .or(key);
+const toEscrowId = (key: EthersBigNumber): EthersBigNumber =>
+  EthersBigNumber.from(1)
+    .shl(248)
+    .or(key);
+
+// SPYon (Ondo) collateral on mainnet market 1
+const SPYON_MAINNET = "0xFeDC5f4a6c38211c1338aa411018DFAf26612c08";
+const SPYON_BALANCEOF_SLOT = 51; // OZ ERC20Upgradeable layout
+
+// market 1 borrows are gated by the BorrowerWhitelist hook — impersonate its
+// owner and whitelist the pool
+const whitelistPoolAsBorrower = async ({
+  pool,
+  network,
+  provider
+}: {
+  pool: Pool;
+  network: Network;
+  provider: providers.JsonRpcProvider;
+}): Promise<void> => {
+  const office = new Contract(
+    routerAddress[network][Dapp.DYTM]!,
+    officeAbi,
+    provider
+  );
+  const marketConfigAddress = await office.getMarketConfig(DYTM_MARKET_ID);
+  const hookAddress = await new Contract(
+    marketConfigAddress,
+    marketConfigAbi,
+    provider
+  ).hooks();
+  const hook = new Contract(hookAddress, borrowerWhitelistAbi, provider);
+  const hookOwner = await hook.owner();
+  await runWithImpersonateAccount(
+    { account: hookOwner, provider },
+    async ({ signer }) => {
+      await hook.connect(signer).setAddressWhitelist(pool.address, true);
+    }
+  );
+};
+
+const testDytm = ({ network, wallet, provider }: TestingRunParams) => {
+  const USDC = CONTRACT_ADDRESS[network].USDC;
+  const usdcKey = toReserveKey(DYTM_MARKET_ID, USDC);
+  // supply/withdraw take the full LEND tokenId; borrow/repay take the bare ReserveKey
+  const USDC_DEPOSIT_TOKEN = toLentId(usdcKey).toString();
+  const USDC_BORROW_TOKEN = usdcKey.toString();
+
+  const USDC_FUNDING_AMOUNT = new BigNumber(100).shiftedBy(6).toFixed(0);
+  const USDC_LIQUIDITY_AMOUNT = new BigNumber(50).shiftedBy(6).toFixed(0);
+
+  // the asset backing the borrow differs per network: on arbitrum lent USDC
+  // counts as collateral, on mainnet USDC has lend weight 0 and SPYon escrow
+  // collateral (weight 0.75) is required instead
+  const collateral =
+    network === Network.ETHEREUM
+      ? {
+          asset: SPYON_MAINNET,
+          tokenId: toEscrowId(
+            toReserveKey(DYTM_MARKET_ID, SPYON_MAINNET)
+          ).toString(),
+          supplyAmount: new BigNumber(1).shiftedBy(18).toFixed(0),
+          // SPYon isn't covered by the USDC funding — deal it via its balanceOf slot
+          funding: {
+            slot: SPYON_BALANCEOF_SLOT,
+            amount: new BigNumber(10).shiftedBy(18).toFixed(0)
+          }
+        }
+      : {
+          asset: USDC,
+          tokenId: USDC_DEPOSIT_TOKEN,
+          supplyAmount: USDC_LIQUIDITY_AMOUNT,
+          funding: null // covered by the USDC funded in beforeAll
+        };
+
+  let dhedge: Dhedge;
+  let pool: Pool;
+  jest.setTimeout(100000);
+
+  describe(`[${network}] DYTM tests`, () => {
+    beforeAll(async () => {
+      // top up ETH (gas)
+      await provider.send("hardhat_setBalance", [
+        wallet.address,
+        "0x100000000000000"
+      ]);
+      // mine a local block so eth_calls run under hardhat's own hardfork —
+      // the remote fork-point block executes as london (hardforkHistory) and
+      // lacks the cancun opcodes DYTM needs (transient storage)
+      await provider.send("evm_mine", []);
+      dhedge = new Dhedge(wallet, network);
+      pool = await dhedge.loadPool(wallet.address, false);
+
+      await whitelistPoolAsBorrower({ pool, network, provider });
+
+      // fund USDC and supply half of it as market liquidity to be borrowed
+      await setUSDCAmount({
+        amount: USDC_FUNDING_AMOUNT,
+        userAddress: pool.address,
+        network,
+        provider
+      });
+      await pool.approve(Dapp.DYTM, USDC, MAX_AMOUNT);
+      await pool.lend(Dapp.DYTM, USDC_DEPOSIT_TOKEN, USDC_LIQUIDITY_AMOUNT);
+
+      // fund the collateral asset for the supply tests
+      if (collateral.funding) {
+        await setTokenAmount({
+          amount: collateral.funding.amount,
+          userAddress: pool.address,
+          tokenAddress: collateral.asset,
+          slot: collateral.funding.slot,
+          provider
+        });
+      }
+    });
+
+    it("approves unlimited collateral for DYTM", async () => {
+      await pool.approve(Dapp.DYTM, collateral.asset, MAX_AMOUNT);
+      const allowance = await new Contract(
+        collateral.asset,
+        erc20AllowanceAbi,
+        provider
+      ).allowance(pool.address, routerAddress[network][Dapp.DYTM]!);
+      expect(allowance.eq(MAX_AMOUNT)).toBe(true);
+    });
+
+    it("estimates supplying collateral to DYTM market", async () => {
+      const result = await pool.lend(
+        Dapp.DYTM,
+        collateral.tokenId,
+        collateral.supplyAmount,
+        0,
+        null,
+        true
+      );
+      expect(result.gas.gt(0)).toBe(true);
+    });
+
+    it("supplies collateral to DYTM market", async () => {
+      await pool.lend(Dapp.DYTM, collateral.tokenId, collateral.supplyAmount);
+
+      const collateralDelta = await balanceDelta(
+        pool.address,
+        collateral.asset,
+        pool.signer
+      );
+      expect(collateralDelta.lt(0)).toBe(true);
+    });
+
+    it("borrows USDC from DYTM market", async () => {
+      // borrow value must clear the market's minDebtAmountUSD ($1 on arbitrum);
+      // borrow 3 USDC so the ~2 USDC debt left after the repay test stays above it
+      await pool.borrow(Dapp.DYTM, USDC_BORROW_TOKEN, (3 * 1e6).toString());
+
+      const usdcTokenDelta = await balanceDelta(
+        pool.address,
+        USDC,
+        pool.signer
+      );
+      expect(usdcTokenDelta.gt(0)).toBe(true);
+    });
+
+    it("repays USDC to DYTM market", async () => {
+      await pool.repay(Dapp.DYTM, USDC_BORROW_TOKEN, (1 * 1e6).toString());
+
+      const usdcTokenDelta = await balanceDelta(
+        pool.address,
+        USDC,
+        pool.signer
+      );
+      expect(usdcTokenDelta.lt(0)).toBe(true);
+    });
+
+    it("withdraws USDC from DYTM market", async () => {
+      await pool.withdrawDeposit(
+        Dapp.DYTM,
+        USDC_DEPOSIT_TOKEN,
+        (5 * 1e6).toString()
+      );
+
+      const usdcTokenDelta = await balanceDelta(
+        pool.address,
+        USDC,
+        pool.signer
+      );
+      expect(usdcTokenDelta.gt(0)).toBe(true);
+    });
+  });
+};
+
+testingHelper({
+  network: Network.ARBITRUM,
+  testingRun: testDytm
+});
+
+testingHelper({
+  network: Network.ETHEREUM,
+  testingRun: testDytm
+});

package/src/types.ts

@@ -36,6 +36,7 @@ export enum Dapp {
   ODOS = "odos",
   PENDLE = "pendle",
   KYBERSWAP = "kyberswap",
+  DYTM = "dytm",
   HYPERLIQUID = "hyperliquid",
   COWSWAP = "cowswap",
   ONDO = "ondo"