@dhedge/v2-sdk 2.2.0 → 2.2.2

package/src/services/toros/completeWithdrawal.ts

@@ -70,19 +70,23 @@ const getSwapWithdrawData = async (
   }
   throw new Error("All swap routers failed for complete withdrawal");
 };
+
 export const createCompleteWithdrawalTxArguments = async (
   pool: Pool,
   receiveToken: string,
-  slippage: number
+  slippage: number,
+  _trackedAssets: TrackedAsset[]
 ): Promise<any> => {
   const easySwapper = new ethers.Contract(
     routerAddress[pool.network][Dapp.TOROS] as string,
     IEasySwapperV2,
     pool.signer
   );
-  const trackedAssets: TrackedAsset[] = await easySwapper.getTrackedAssets(
-    pool.address
-  );
+
+  let trackedAssets: TrackedAsset[] = _trackedAssets;
+  if (trackedAssets.length === 0) {
+    trackedAssets = await easySwapper.getTrackedAssets(pool.address);
+  }
 
   if (
     trackedAssets.length === 0 ||
@@ -170,10 +174,20 @@ export const createCompleteWithdrawalTxArguments = async (
   const withdrawalVaultAddress = await easySwapper.withdrawalContracts(
     pool.address
   );
-  const balanceOfReceiveToken = await receiveTokenErc20.balanceOf(
+  let balanceOfReceiveToken = await receiveTokenErc20.balanceOf(
     withdrawalVaultAddress
   );
 
+  if (trackedAssets.length !== 0) {
+    //  finds the receiveTokenErc20's balance inside trackedAssets
+    const trackedAsset = trackedAssets.find(
+      ({ token }) => token.toLowerCase() === receiveToken.toLowerCase()
+    );
+    if (trackedAsset) {
+      balanceOfReceiveToken = balanceOfReceiveToken.add(trackedAsset.balance);
+    }
+  }
+
   // complete withdraw _expectedDestTokenAmount
   const estimatedMinReceiveAmount = swapDestMinDestAmount.plus(
     balanceOfReceiveToken.toString()
@@ -201,12 +215,14 @@ export const getCompleteWithdrawalTxData = async (
   pool: Pool,
   receiveToken: string,
   slippage: number,
-  useOnChainSwap: boolean
+  useOnChainSwap: boolean,
+  trackedAssets: TrackedAsset[]
 ): Promise<string> => {
   const completeWithdrawTxArguments = await createCompleteWithdrawalTxArguments(
     pool,
     receiveToken,
-    slippage
+    slippage,
+    trackedAssets
   );
 
   const isSwapNeeded = completeWithdrawTxArguments.isSwapNeeded;

package/src/services/toros/easySwapper.ts

@@ -70,7 +70,7 @@ export async function getEasySwapperTxData(
   amountIn: ethers.BigNumber,
   slippage: number
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-): Promise<any> {
+): Promise<{ swapTxData: string; minAmountOut?: any }> {
   const isWithdrawal = await isPool(pool, assetFrom);
   const [torosAsset, investAsset] = isWithdrawal
     ? [assetFrom, assetTo]
@@ -99,11 +99,13 @@ export async function getEasySwapperTxData(
       investAsset,
       amountIn
     );
-    return iEasySwapperV2.encodeFunctionData("depositWithCustomCooldown", [
-      torosAsset,
-      depositAsset,
-      amountIn,
-      minAmountOut.mul(10000 - slippage * 100).div(10000)
-    ]);
+    const _minAmountOut = minAmountOut.mul(10000 - slippage * 100).div(10000);
+    return {
+      swapTxData: iEasySwapperV2.encodeFunctionData(
+        "depositWithCustomCooldown",
+        [torosAsset, depositAsset, amountIn, _minAmountOut]
+      ),
+      minAmountOut: _minAmountOut
+    };
   }
 }

package/src/services/toros/initWithdrawal.ts

@@ -157,7 +157,7 @@ export const getInitWithdrawalTxData = async (
   amountIn: string,
   slippage: number,
   useOnChainSwap: boolean
-): Promise<string> => {
+): Promise<{ swapTxData: string; minAmountOut?: any }> => {
   const complexAssetsData = await createWithdrawTxArguments(
     pool,
     torosAsset,
@@ -166,9 +166,13 @@ export const getInitWithdrawalTxData = async (
     useOnChainSwap
   );
   const iEasySwapperV2 = new ethers.utils.Interface(IEasySwapperV2);
-  return iEasySwapperV2.encodeFunctionData("initWithdrawal", [
-    torosAsset,
-    amountIn,
-    complexAssetsData
-  ]);
+
+  return {
+    swapTxData: iEasySwapperV2.encodeFunctionData("initWithdrawal", [
+      torosAsset,
+      amountIn,
+      complexAssetsData
+    ]),
+    minAmountOut: null // not be used when building multicall tx data
+  };
 };

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/test/ondo.onchain.test.ts

@@ -0,0 +1,132 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+
+/**
+ * Ondo Global Markets on-chain tests for minting and redeeming GM tokens.
+ * These require a live chain connection (onFork: false) because each mint/redeem
+ * needs a fresh attestation signed by the Ondo API against current chain state,
+ * which cannot be reproduced on a Hardhat fork.
+ *
+ * Prerequisites:
+ *   - PRIVATE_KEY in .env (must be the pool manager or trader)
+ *   - ETHEREUM_URL in .env
+ *   - ONDO_API_KEY in .env
+ *   - The test pool must hold USDC to mint (and SPYon, from the mint, to redeem)
+ */
+
+import { ethers } from "ethers";
+import { Dhedge, Pool } from "..";
+
+import { Dapp, Network } from "../types";
+import { CONTRACT_ADDRESS, MAX_AMOUNT } from "./constants";
+import { TestingRunParams, testingHelper } from "./utils/testingHelper";
+
+import { getTxOptions } from "./txOptions";
+import { balanceDelta } from "./utils/token";
+
+import { routerAddress } from "../config";
+
+const testOndo = ({ wallet, network }: TestingRunParams) => {
+  const USDC = CONTRACT_ADDRESS[network].USDC;
+  const SPYon = "0xfedc5f4a6c38211c1338aa411018dfaf26612c08";
+
+  let dhedge: Dhedge;
+  let pool: Pool;
+  jest.setTimeout(100000);
+
+  describe(`pool on ${network}`, () => {
+    beforeAll(async () => {
+      dhedge = new Dhedge(wallet, network);
+      pool = await dhedge.loadPool(
+        "0x9f647b85A514b1e60F8E8E956E636a50dA406279"
+      );
+    });
+
+    it("approves unlimited USDC on Ondo", async () => {
+      const tx = await pool.approve(Dapp.ONDO, USDC, MAX_AMOUNT);
+      await tx.wait();
+      const iERC20 = new ethers.Contract(
+        USDC,
+        ["function allowance(address,address) view returns (uint256)"],
+        pool.signer
+      );
+      const allowance = await iERC20.allowance(
+        pool.address,
+        routerAddress[network][Dapp.ONDO]!
+      );
+      expect(allowance.gt(0)).toBe(true);
+    });
+
+    it("gets gas estimation for 40 USDC into SPYon on Ondo", async () => {
+      const gasEstimate = await pool.trade(
+        Dapp.ONDO,
+        USDC,
+        SPYon,
+        "40000000",
+        0.1,
+        await getTxOptions(network),
+        true
+      );
+      expect(gasEstimate.gasEstimationError).toBeNull();
+      expect(gasEstimate.gas.gt(0)).toBe(true);
+      expect(gasEstimate.minAmountOut).not.toBeNull();
+    });
+
+    it("trades 40 USDC into SPYon on Ondo", async () => {
+      const tx = await pool.trade(
+        Dapp.ONDO,
+        USDC,
+        SPYon,
+        "40000000",
+        0.1,
+        await getTxOptions(network)
+      );
+      await tx.wait();
+      const spBalanceDelta = await balanceDelta(
+        pool.address,
+        SPYon,
+        pool.signer
+      );
+      expect(spBalanceDelta.gt(0)).toBe(true);
+    });
+
+    it("approves unlimited SPYon on Ondo", async () => {
+      const tx = await pool.approve(Dapp.ONDO, SPYon, MAX_AMOUNT);
+      await tx.wait();
+      const iERC20 = new ethers.Contract(
+        SPYon,
+        ["function allowance(address,address) view returns (uint256)"],
+        pool.signer
+      );
+      const allowance = await iERC20.allowance(
+        pool.address,
+        routerAddress[network][Dapp.ONDO]!
+      );
+      expect(allowance.gt(0)).toBe(true);
+    });
+
+    it("sells SPYon balance on Ondo", async () => {
+      const spyonBalance = await pool.utils.getBalance(SPYon, pool.address);
+      const tx = await pool.trade(
+        Dapp.ONDO,
+        SPYon,
+        USDC,
+        spyonBalance,
+        0.1,
+        await getTxOptions(network)
+      );
+      await tx.wait();
+      const usdcBalanceDelta = await balanceDelta(
+        pool.address,
+        USDC,
+        pool.signer
+      );
+      expect(usdcBalanceDelta.gt(0)).toBe(true);
+    });
+  });
+};
+
+testingHelper({
+  network: Network.ETHEREUM,
+  testingRun: testOndo,
+  onFork: false
+});

package/src/types.ts

@@ -36,8 +36,10 @@ export enum Dapp {
   ODOS = "odos",
   PENDLE = "pendle",
   KYBERSWAP = "kyberswap",
+  DYTM = "dytm",
   HYPERLIQUID = "hyperliquid",
-  COWSWAP = "cowswap"
+  COWSWAP = "cowswap",
+  ONDO = "ondo"
 }
 
 /** Function-name strings used when encoding ABI calls — keep in sync with the