@dhedge/v2-sdk 2.0.0 → 2.0.2

package/src/services/toros/swapData.ts

@@ -0,0 +1,70 @@
+import axios from "axios";
+import BigNumber from "bignumber.js";
+import { odosBaseUrl } from "../odos";
+
+export const SWAPPER_ADDERSS = "0x4F754e0F0924afD74980886b0B479Fa1D7C58D0D";
+
+export interface SwapParams {
+  srcAsset: string; // Source asset address
+  srcAmount: string; // Amount to swap (use string for big numbers)
+  dstAsset: string; // Destination asset address
+  chainId: number; // Chain ID
+  from: string; // Sender address
+  receiver: string; // Receiver address
+  slippage: number; // Slippage tolerance in basis points (100 = 1%)
+}
+
+export const getSwapDataViaOdos = async ({
+  srcAsset,
+  srcAmount,
+  dstAsset,
+  chainId,
+  from,
+  slippage
+}: SwapParams): Promise<string> => {
+  let referralCode = 0; //  Defaults to 0 for unregistered activity.
+  if (
+    process.env.ODOS_REFERAL_CODE &&
+    Number(process.env.ODOS_REFERAL_CODE) > 0
+  ) {
+    referralCode = Number(process.env.ODOS_REFERAL_CODE);
+  }
+  const quoteParams = {
+    chainId: chainId,
+    inputTokens: [
+      {
+        tokenAddress: srcAsset,
+        amount: srcAmount
+      }
+    ],
+    outputTokens: [
+      {
+        tokenAddress: dstAsset,
+        proportion: 1
+      }
+    ],
+    slippageLimitPercent: new BigNumber(slippage).div(100).toString(), // Convert basis points to percentage
+    userAddr: from,
+    referralCode
+  };
+  try {
+    const quoteResult = await axios.post(
+      `${odosBaseUrl}/quote/v2`,
+      quoteParams
+    );
+
+    const assembleParams = {
+      pathId: quoteResult.data.pathId,
+      userAddr: from
+    };
+
+    const assembleResult = await axios.post(
+      `${odosBaseUrl}/assemble`,
+      assembleParams
+    );
+    return assembleResult.data.transaction.data;
+  } catch (e) {
+    console.error("Error in Odos API request:", e);
+    throw new Error("Swap api request of Odos failed");
+  }
+};

package/src/test/constants.ts

@@ -89,7 +89,7 @@ export const CONTRACT_ADDRESS = {
     VELO: "0x9560e827aF36c94D2Ac33a39bCE1Fe78631088Db",
     COMPOUNDV3_WETH: "",
     FLUID_WETH: "",
-    TOROS: "0x49bf093277bf4dde49c48c6aa55a3bda3eedef68" //USDmny
+    TOROS: "0xcacb5a722a36cff6baeb359e21c098a4acbffdfa" //ETHBEAR1X
   },
   [Network.ARBITRUM]: {
     USDC: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",

package/src/test/pool.test.ts

@@ -1,14 +1,8 @@
-import { BigNumber } from "ethers";
-import { Dhedge, ethers, Pool } from "..";
-import { AssetEnabled, Network } from "../types";
-import { CONTRACT_ADDRESS, TEST_POOL } from "./constants";
-
-import {
-  beforeAfterReset,
-  testingHelper,
-  TestingRunParams
-} from "./utils/testingHelper";
-import { allowanceDelta, balanceDelta } from "./utils/token";
+import { Dhedge, Pool } from "..";
+import { Network } from "../types";
+import { TEST_POOL } from "./constants";
+
+import { testingHelper, TestingRunParams } from "./utils/testingHelper";
 
 const testPool = ({ wallet, network, provider }: TestingRunParams) => {
   let dhedge: Dhedge;
@@ -20,85 +14,94 @@ const testPool = ({ wallet, network, provider }: TestingRunParams) => {
     beforeAll(async () => {
       dhedge = new Dhedge(wallet, network);
       pool = await dhedge.loadPool(TEST_POOL[network]);
+
+      await provider.send("hardhat_setBalance", [
+        wallet.address,
+        "0x10000000000000000"
+      ]);
     });
-    beforeAfterReset({ beforeAll, afterAll, provider });
 
     it("checks fund composition", async () => {
       const result = await pool.getComposition();
       expect(result.length).toBeGreaterThan(0);
     });
 
-    it("approves USDC balance of User for Deposit", async () => {
-      await pool.approveDeposit(
-        CONTRACT_ADDRESS[network].USDC,
-        ethers.constants.MaxUint256
-      );
-      const UsdcAllowanceDelta = await allowanceDelta(
-        pool.signer.address,
-        CONTRACT_ADDRESS[network].USDC,
-        pool.address,
-        pool.signer
-      );
-      expect(UsdcAllowanceDelta.gt(0));
+    it("sets pool private", async () => {
+      const result = await pool.setPrivate(true);
+      expect(result).not.toBeNull();
     });
 
-    it("deposits 1 USDC into Pool", async () => {
-      await pool.deposit(CONTRACT_ADDRESS[network].USDC, (1e6).toString());
-      const poolTokenDelta = await balanceDelta(
-        pool.signer.address,
-        pool.address,
-        pool.signer
-      );
-      expect(poolTokenDelta.gt(0));
-    });
+    //   it("approves USDC balance of User for Deposit", async () => {
+    //     await pool.approveDeposit(
+    //       CONTRACT_ADDRESS[network].USDC,
+    //       ethers.constants.MaxUint256
+    //     );
+    //     const UsdcAllowanceDelta = await allowanceDelta(
+    //       pool.signer.address,
+    //       CONTRACT_ADDRESS[network].USDC,
+    //       pool.address,
+    //       pool.signer
+    //     );
+    //     expect(UsdcAllowanceDelta.gt(0));
+    //   });
 
-    it("adds WBTC to enabled assets", async () => {
-      const assetsBefore = await pool.getComposition();
-
-      const newAssets: AssetEnabled[] = [
-        { asset: CONTRACT_ADDRESS[network].USDC, isDeposit: true },
-        { asset: CONTRACT_ADDRESS[network].WETH, isDeposit: false },
-        { asset: CONTRACT_ADDRESS[network].WBTC, isDeposit: false }
-      ];
-      await pool.changeAssets(newAssets);
-      const assetsAfter = await pool.getComposition();
-      if (assetsBefore.length < newAssets.length) {
-        expect(assetsAfter.length).toBeGreaterThan(assetsBefore.length);
-      } else {
-        expect(assetsAfter.length).toBeLessThanOrEqual(assetsBefore.length);
-      }
-    });
+    //   it("deposits 1 USDC into Pool", async () => {
+    //     await pool.deposit(CONTRACT_ADDRESS[network].USDC, (1e6).toString());
+    //     const poolTokenDelta = await balanceDelta(
+    //       pool.signer.address,
+    //       pool.address,
+    //       pool.signer
+    //     );
+    //     expect(poolTokenDelta.gt(0));
+    //   });
 
-    it("get available Manager Fee", async () => {
-      const result = await pool.getAvailableManagerFee();
-      expect(result).toBeInstanceOf(BigNumber);
-    });
+    //   it("adds WBTC to enabled assets", async () => {
+    //     const assetsBefore = await pool.getComposition();
 
-    it("mintManagerFee; should not revert", async () => {
-      const tx = await pool.mintManagerFee();
-      expect(tx).toHaveProperty("wait");
-    });
+    //     const newAssets: AssetEnabled[] = [
+    //       { asset: CONTRACT_ADDRESS[network].USDC, isDeposit: true },
+    //       { asset: CONTRACT_ADDRESS[network].WETH, isDeposit: false },
+    //       { asset: CONTRACT_ADDRESS[network].WBTC, isDeposit: false }
+    //     ];
+    //     await pool.changeAssets(newAssets);
+    //     const assetsAfter = await pool.getComposition();
+    //     if (assetsBefore.length < newAssets.length) {
+    //       expect(assetsAfter.length).toBeGreaterThan(assetsBefore.length);
+    //     } else {
+    //       expect(assetsAfter.length).toBeLessThanOrEqual(assetsBefore.length);
+    //     }
+    //   });
 
-    it("withdraw 0.1 pool token into Pool", async () => {
-      await provider.send("evm_increaseTime", [24 * 60 * 60]);
-      await provider.send("evm_mine", []);
-      await pool.withdraw((0.1 * 1e18).toString());
-      const poolTokenDelta = await balanceDelta(
-        pool.signer.address,
-        pool.address,
-        pool.signer
-      );
-      expect(poolTokenDelta.lt(0));
-    });
+    //   it("get available Manager Fee", async () => {
+    //     const result = await pool.getAvailableManagerFee();
+    //     expect(result).toBeInstanceOf(BigNumber);
+    //   });
+
+    //   it("mintManagerFee; should not revert", async () => {
+    //     const tx = await pool.mintManagerFee();
+    //     expect(tx).toHaveProperty("wait");
+    //   });
+
+    //   it("withdraw 0.1 pool token into Pool", async () => {
+    //     await provider.send("evm_increaseTime", [24 * 60 * 60]);
+    //     await provider.send("evm_mine", []);
+    //     await pool.withdraw((0.1 * 1e18).toString());
+    //     const poolTokenDelta = await balanceDelta(
+    //       pool.signer.address,
+    //       pool.address,
+    //       pool.signer
+    //     );
+    //     expect(poolTokenDelta.lt(0));
+    //   });
   });
 };
 
-testingHelper({
-  network: Network.POLYGON,
-  testingRun: testPool
-});
-
 // testingHelper({
-//   network: Network.OPTIMISM,
+//   network: Network.POLYGON,
 //   testingRun: testPool
 // });
+
+testingHelper({
+  network: Network.OPTIMISM,
+  testingRun: testPool
+});

package/src/test/toros.test.ts

@@ -1,18 +1,19 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 
+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,
   setChainlinkTimeout,
   setUSDCAmount,
-  testingHelper
+  testingHelper,
+  TestingRunParams
 } from "./utils/testingHelper";
+
 import { allowanceDelta, balanceDelta } from "./utils/token";
-import BigNumber from "bignumber.js";
 
 const testToros = ({ wallet, network, provider }: TestingRunParams) => {
   const USDC = CONTRACT_ADDRESS[network].USDC;
@@ -34,7 +35,7 @@ const testToros = ({ wallet, network, provider }: TestingRunParams) => {
       ]);
       await provider.send("evm_mine", []);
       // top up USDC
-      const amount = new BigNumber(1000).times(1e6).toFixed(0);
+      const amount = new BigNumber(100).times(1e6).toFixed(0);
       await setUSDCAmount({
         amount,
         userAddress: pool.address,
@@ -56,7 +57,7 @@ const testToros = ({ wallet, network, provider }: TestingRunParams) => {
 
     it("trades USDC balance into Toros Token", async () => {
       const usdcBalance = await pool.utils.getBalance(USDC, pool.address);
-      await pool.trade(Dapp.TOROS, USDC, TOROS, usdcBalance, 1);
+      await pool.trade(Dapp.TOROS, USDC, TOROS, usdcBalance, 1.5);
       const torosBalanceDelta = await balanceDelta(
         pool.address,
         TOROS,
@@ -70,7 +71,7 @@ const testToros = ({ wallet, network, provider }: TestingRunParams) => {
       await provider.send("evm_mine", []);
       const torosBalance = await pool.utils.getBalance(TOROS, pool.address);
       await pool.approve(Dapp.TOROS, TOROS, MAX_AMOUNT);
-      await pool.trade(Dapp.TOROS, TOROS, USDC, torosBalance, 1);
+      await pool.trade(Dapp.TOROS, TOROS, USDC, torosBalance, 1.5);
       const torosBalanceDelta = await balanceDelta(
         pool.address,
         TOROS,
@@ -80,7 +81,7 @@ const testToros = ({ wallet, network, provider }: TestingRunParams) => {
     });
 
     it("complete withdrawal from Toros asset", async () => {
-      await pool.completeTorosWithdrawal(USDC, 1);
+      await pool.completeTorosWithdrawal(USDC, 1.5);
       const usdcBalanceDelta = await balanceDelta(
         pool.address,
         USDC,
@@ -93,5 +94,6 @@ const testToros = ({ wallet, network, provider }: TestingRunParams) => {
 
 testingHelper({
   network: Network.OPTIMISM,
-  testingRun: testToros
+  testingRun: testToros,
+  onFork: true
 });

package/src/types.ts

@@ -101,3 +101,11 @@ export type LyraPosition = {
   collateral: BigNumber;
   state: number;
 };
+
+export type SDKOptions =
+  | {
+      estimateGas: boolean;
+      onlyGetTxData?: boolean;
+      useTraderAddressAsFrom?: boolean;
+    }
+  | boolean; // shorthand for { estimateGas: true/false }; for backward compatibility

package/src/utils/contract.ts

@@ -3,7 +3,7 @@
 import set from "lodash/set";
 import { Interface } from "@ethersproject/abi";
 import { multiCallAddress } from "../config";
-import { ethers, Network, Pool } from "..";
+import { ethers, Network, Pool, SDKOptions } from "..";
 
 export async function call(
   provider: ethers.Signer,
@@ -94,56 +94,84 @@ export class Multicaller {
   }
 }
 
+const getGasEstimateData = async (
+  estimateFunc: ethers.ContractFunction<ethers.BigNumber>,
+  txInfoData: { to: string; txData: string; minAmountOut: any },
+  txOptions: any = {}
+) => {
+  let gas = null;
+  let gasEstimationError = null;
+  try {
+    gas = await estimateFunc(txInfoData.to, txInfoData.txData, txOptions);
+  } catch (e) {
+    gasEstimationError = e;
+  }
+  return {
+    gas,
+    gasEstimationError,
+    ...txInfoData
+  };
+};
+
+export const isSdkOptionsBoolean = (
+  sdkOptions: SDKOptions
+): sdkOptions is boolean => {
+  return typeof sdkOptions === "boolean";
+};
+
 export const getPoolTxOrGasEstimate = async (
   pool: Pool,
   args: any[],
-  estimateGas: boolean
+  sdkOptions: SDKOptions
 ): Promise<any> => {
-  if (pool.isDhedge) {
-    if (estimateGas) {
-      let gas = null;
-      let gasEstimationError = null;
-      try {
-        gas = await pool.poolLogic.estimateGas.execTransaction(
-          args[0],
-          args[1],
-          args[2]
-        );
-      } catch (e) {
-        gasEstimationError = e;
-      }
-      return {
-        gas,
-        txData: args[1],
-        to: args[0],
-        gasEstimationError,
-        minAmountOut: args[3] || null
-      };
+  const txInfoData = {
+    txData: args[1],
+    to: args[0],
+    minAmountOut: args[3] || null
+  };
+
+  if (!isSdkOptionsBoolean(sdkOptions) && sdkOptions.onlyGetTxData) {
+    return txInfoData;
+  }
+
+  const txOptions = args[2];
+
+  if (
+    !pool.isDhedge ||
+    (!isSdkOptionsBoolean(sdkOptions) && sdkOptions.useTraderAddressAsFrom)
+  ) {
+    if (
+      sdkOptions === true ||
+      (!isSdkOptionsBoolean(sdkOptions) && sdkOptions.estimateGas)
+    ) {
+      return await getGasEstimateData(
+        pool.signer.estimateGas,
+        txInfoData,
+        txOptions
+      );
     } else {
-      return await pool.poolLogic.execTransaction(args[0], args[1], args[2]);
+      return await pool.signer.sendTransaction({
+        to: txInfoData.to,
+        data: txInfoData.txData,
+        ...txOptions
+      });
     }
   } else {
-    if (estimateGas) {
-      let gas = null;
-      let gasEstimationError = null;
-      try {
-        gas = await pool.signer.estimateGas({ to: args[0], data: args[1] });
-      } catch (e) {
-        gasEstimationError = e;
-      }
-      return {
-        gas,
-        txData: args[1],
-        to: args[0],
-        gasEstimationError,
-        minAmountOut: args[3] || null
-      };
+    if (
+      sdkOptions === true ||
+      (!isSdkOptionsBoolean(sdkOptions) && sdkOptions.estimateGas)
+    ) {
+      return await getGasEstimateData(
+        pool.poolLogic.estimateGas.execTransaction,
+        txInfoData,
+        txOptions
+      );
     } else {
-      return await pool.signer.sendTransaction({
-        to: args[0],
-        data: args[1],
-        ...args[2]
-      });
+      return await pool.poolLogic.execTransaction(
+        txInfoData.to,
+        txInfoData.txData,
+        txOptions
+      );
     }
   }
 };