@dhedge/v2-sdk 2.0.0 → 2.0.1

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/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
+      );
     }
   }
 };