@dhedge/v2-sdk 2.1.8 → 2.2.1

package/src/services/ondo/index.ts

@@ -0,0 +1,142 @@
+import axios from "axios";
+import { ethers } from "ethers";
+import BigNumber from "bignumber.js";
+import { ApiError, Pool } from "../..";
+import IOndoGMSwap from "../../abi/ondo/IOndoGMSwap.json";
+
+const ONDO_API_URL = "https://api.gm.ondo.finance/v1/attestations";
+
+// Ethereum mainnet USDC — Ondo is Ethereum-only
+const USDC_ETHEREUM = "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48";
+
+type OndoAttestation = {
+  attestationId: string;
+  userId: string;
+  chainId: string;
+  assetAddress: string;
+  side: string;
+  tokenAmount: string;
+  price: string;
+  expiration: number;
+  signature: string;
+  additionalData: string;
+};
+
+const iface = new ethers.utils.Interface(IOndoGMSwap);
+
+// Ondo returns userId as a left-aligned 32-byte hex (significant bytes first,
+// e.g. 0x474d...0000), so right-pad to preserve byte order and fix it to 32 bytes.
+function toBytes32(s: string): string {
+  const hex = s.startsWith("0x") ? s.slice(2) : s;
+  return "0x" + hex.padEnd(64, "0").slice(0, 64);
+}
+
+async function postOndoAttestation(
+  symbol: string,
+  side: "buy" | "sell",
+  amount: { notionalValue: string } | { tokenAmount: string },
+  apiKey: string
+): Promise<OndoAttestation> {
+  try {
+    const { data } = await axios.post(
+      ONDO_API_URL,
+      { chainId: "ethereum-1", symbol, side, ...amount, duration: "short" },
+      { headers: { "x-api-key": apiKey } }
+    );
+    return data as OndoAttestation;
+  } catch (error) {
+    // Surface Ondo's structured error (e.g. ASSET_NOT_FOUND, MARKET_CLOSED)
+    if (axios.isAxiosError(error) && error.response) {
+      const { code, message } = error.response.data ?? {};
+      throw new ApiError(
+        `Ondo attestation request failed (${error.response.status}): ${code ??
+          ""} ${message ?? JSON.stringify(error.response.data)}`.trim()
+      );
+    }
+    throw new ApiError(
+      `Ondo attestation request failed: ${
+        error instanceof Error ? error.message : String(error)
+      }`
+    );
+  }
+}
+
+export async function getOndoSwapTxData(
+  pool: Pool,
+  tokenIn: string,
+  tokenOut: string,
+  amountIn: string,
+  slippage: number
+): Promise<{ swapTxData: string; minAmountOut: string }> {
+  const apiKey = process.env.ONDO_API_KEY;
+  if (!apiKey) throw new Error("ONDO_API_KEY environment variable is not set");
+
+  const amount = new BigNumber(amountIn);
+  const isMint = tokenIn.toLowerCase() === USDC_ETHEREUM.toLowerCase();
+  const gmToken = isMint ? tokenOut : tokenIn;
+  const slippageBps = Math.round(slippage * 100);
+
+  const tokenContract = new ethers.Contract(
+    gmToken,
+    ["function symbol() view returns (string)"],
+    pool.signer
+  );
+  const symbol: string = await tokenContract.symbol();
+
+  // For mint: notionalValue is the USD amount to subscribe. USDonManager values
+  // USDC at par (1 USDC = 1 USDon), so pass the USDC amount as-is (6dp -> decimal).
+  // Discounting by a USDC market price would strand the gap as USDon in the swapper
+  // (and revert via ExcessiveAmountIn once it exceeds the 1 USDC tolerance).
+  // For redeem: pass the GM token amount directly as tokenAmount.
+  const attestationAmount = isMint
+    ? { notionalValue: amount.div(1e6).toFixed(18) }
+    : { tokenAmount: amount.div(1e18).toFixed(18) };
+
+  const attestation = await postOndoAttestation(
+    symbol,
+    isMint ? "buy" : "sell",
+    attestationAmount,
+    apiKey
+  );
+
+  const signature =
+    "0x" + Buffer.from(attestation.signature, "base64").toString("hex");
+  const additionalData = ethers.utils.hexZeroPad(
+    "0x" + Buffer.from(attestation.additionalData, "base64").toString("hex"),
+    32
+  );
+  const quantity = new BigNumber(attestation.tokenAmount);
+  const priceD18 = new BigNumber(attestation.price);
+
+  let minAmountOut: BigNumber;
+  if (isMint) {
+    minAmountOut = quantity.times(10000 - slippageBps).div(10000);
+  } else {
+    // USDC out (6 dec) = quantity_D18 * price_D18 / 1e30
+    const usdcOut = quantity.times(priceD18).div(1e30);
+    minAmountOut = usdcOut.times(10000 - slippageBps).div(10000);
+  }
+
+  const quote = {
+    chainId: 1,
+    attestationId: attestation.attestationId,
+    userId: toBytes32(attestation.userId),
+    asset: attestation.assetAddress,
+    price: priceD18.toFixed(0),
+    quantity: quantity.toFixed(0),
+    expiration: attestation.expiration,
+    side: Number(attestation.side),
+    additionalData
+  };
+
+  const swapTxData = iface.encodeFunctionData("swapExactInWithAttestation", [
+    tokenIn,
+    amount.toFixed(0),
+    tokenOut,
+    minAmountOut.toFixed(0),
+    signature,
+    quote
+  ]);
+
+  return { swapTxData, minAmountOut: minAmountOut.toFixed(0) };
+}

package/src/services/oneInch/index.ts

@@ -1,7 +1,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import axios from "axios";
 import { ApiError, ethers } from "../..";
-import { networkChainIdMap, routerAddress } from "../../config";
+import { networkChainIdMap } from "../../config";
 import { Pool } from "../../entities";
 
 const oneInchBaseUrl = "https://api.1inch.dev/swap/v6.0/";
@@ -12,7 +12,8 @@ export async function getOneInchSwapTxData(
   assetTo: string,
   amountIn: ethers.BigNumber | string,
   slippage: number,
-  forEasySwapper = false
+  sender?: string,
+  receiver?: string
 ): Promise<{ swapTxData: string; dstAmount: string }> {
   if (!process.env.ONEINCH_API_KEY)
     throw new Error("ONEINCH_API_KEY not configured in .env file");
@@ -23,8 +24,8 @@ export async function getOneInchSwapTxData(
     src: assetFrom,
     dst: assetTo,
     amount: amountIn.toString(),
-    from: forEasySwapper ? routerAddress[pool.network].toros : pool.address,
-    receiver: forEasySwapper ? routerAddress[pool.network].toros : pool.address,
+    from: sender || pool.address,
+    receiver: receiver || pool.address,
     slippage: slippage,
     disableEstimate: true,
     usePermit2: false

package/src/services/toros/completeWithdrawal.ts

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { Dapp, ethers, Pool } from "../..";
-import { networkChainIdMap, routerAddress } from "../../config";
+import { routerAddress } from "../../config";
 import IEasySwapperV2 from "../../abi/IEasySwapperV2.json";
 import BigNumber from "bignumber.js";
 import AssetHandlerAbi from "../../abi/AssetHandler.json";
@@ -10,7 +10,7 @@ import {
   SLIPPAGE_FOR_LOW_VALUE_SWAP
 } from "./easySwapper";
 import { retry } from "./retry";
-import { getSwapDataViaOdos, SWAPPER_ADDERSS } from "./swapData";
+import { getSwapData, ROUTER_KEYS } from "./swapData";
 
 export interface TrackedAsset {
   token: string;
@@ -19,46 +19,56 @@ export interface TrackedAsset {
 
 const getSwapWithdrawData = async (
   pool: Pool,
-  trackedAssets: TrackedAsset[],
+  trackedAssets: {
+    token: string;
+    balance: ethers.BigNumber;
+    slippage: number;
+  }[],
   receiveToken: string,
-  slippage: number,
   swapDestMinDestAmount: BigNumber
 ) => {
-  const srcData = [];
-  const routerKey = ethers.utils.formatBytes32String("ODOS_V3");
-  // const destData
-  for (const { token, balance } of trackedAssets) {
-    if (token.toLowerCase() === receiveToken.toLowerCase()) {
+  for (const routerKeyString of ROUTER_KEYS) {
+    try {
+      const srcData = [];
+      const routerKey = ethers.utils.formatBytes32String(routerKeyString);
+      for (const { token, balance, slippage } of trackedAssets) {
+        if (token.toLowerCase() === receiveToken.toLowerCase()) {
+          continue;
+        }
+        const swapData = await retry({
+          fn: () => {
+            return getSwapData(
+              pool,
+              {
+                srcAsset: token,
+                srcAmount: balance.toString(),
+                dstAsset: receiveToken,
+                slippage
+              },
+              routerKeyString
+            );
+          },
+          delayMs: 1500,
+          maxRetries: 7
+        });
+        srcData.push({
+          token,
+          amount: balance,
+          aggregatorData: { routerKey, swapData }
+        });
+      }
+      return {
+        srcData,
+        destData: {
+          destToken: receiveToken,
+          minDestAmount: swapDestMinDestAmount.toString()
+        }
+      };
+    } catch {
       continue;
     }
-    const swapData = await retry({
-      fn: () => {
-        return getSwapDataViaOdos({
-          srcAsset: token,
-          srcAmount: balance.toString(),
-          dstAsset: receiveToken,
-          chainId: networkChainIdMap[pool.network],
-          from: SWAPPER_ADDERSS,
-          receiver: SWAPPER_ADDERSS,
-          slippage
-        });
-      },
-      delayMs: 1500,
-      maxRetries: 7
-    });
-    srcData.push({
-      token,
-      amount: balance,
-      aggregatorData: { routerKey, swapData }
-    });
   }
-  return {
-    srcData,
-    destData: {
-      destToken: receiveToken,
-      minDestAmount: swapDestMinDestAmount.toString()
-    }
-  };
+  throw new Error("All swap routers failed for complete withdrawal");
 };
 export const createCompleteWithdrawalTxArguments = async (
   pool: Pool,
@@ -138,12 +148,16 @@ export const createCompleteWithdrawalTxArguments = async (
         .div(receiveTokenPriceD18)
         .div(10 ** Number(swapTAssetDecimals.toString()))
         .times(10 ** Number(receiveTokenDecimals.toString()))
-        .times(1 - adjustedSlippage / 10000) // slippage is in basis points, so divide by 10000
+        // Outer floor stays strict on the user slippage — this is the
+        // withdrawer's safety check. Dust leniency applies only to the
+        // aggregator calldata below.
+        .times(1 - slippage / 10000) // slippage is in basis points, so divide by 10000
         .decimalPlaces(0, BigNumber.ROUND_DOWN);
 
       return {
         token: swapTAsset.token,
         balance: swapTAsset.balance,
+        slippage: adjustedSlippage,
         estimatedMinReceiveAmount
       };
     })
@@ -167,10 +181,13 @@ export const createCompleteWithdrawalTxArguments = async (
 
   const swapData = await getSwapWithdrawData(
     pool,
-    swapTrackedAssets,
+    tAssetInfos.map(({ token, balance, slippage }) => ({
+      token,
+      balance,
+      slippage
+    })),
     receiveToken,
-    slippage,
-    estimatedMinReceiveAmount
+    swapDestMinDestAmount
   );
 
   return {

package/src/services/toros/easySwapper.ts

@@ -8,9 +8,16 @@ import { isPool, loadPool } from "./pool";
 
 import { getInitWithdrawalTxData } from "./initWithdrawal";
 
-export const LOW_USD_VALUE_FOR_WITHDRAWAL = 1; // 1 USD minimum value for withdrawal
+/** Minimum USD value of a leftover token to bother swapping during a withdrawal. */
+export const LOW_USD_VALUE_FOR_WITHDRAWAL = 1;
+/** Slippage (bps) applied to the swap of small-value leftover tokens during withdrawal. */
 export const SLIPPAGE_FOR_LOW_VALUE_SWAP = 500;
 
+/**
+ * Resolve which asset should be used to deposit into a Toros pool. Returns the
+ * caller's `investAsset` if the pool already accepts it, otherwise the pool's
+ * primary deposit asset.
+ */
 export async function getPoolDepositAsset(
   pool: Pool,
   poolAddress: string,
@@ -26,6 +33,7 @@ export async function getPoolDepositAsset(
   return composition.find(e => e.isDeposit)?.asset;
 }
 
+/** Read the current per-token price of a Toros vault from its PoolLogic. */
 export async function getTorosPoolTokenPrice(
   pool: Pool,
   poolAddress: string
@@ -34,6 +42,7 @@ export async function getTorosPoolTokenPrice(
   return await torosPool.poolLogic.tokenPrice();
 }
 
+/** Quote how many Toros vault tokens a deposit of `investAsset` would mint. */
 export async function getEasySwapperDepositQuote(
   pool: Pool,
   torosAsset: string,
@@ -49,6 +58,11 @@ export async function getEasySwapperDepositQuote(
   return await easySwapper.depositQuote(torosAsset, investAsset, amountIn);
 }
 
+/**
+ * Build the EasySwapper calldata for a Toros deposit or the start of a withdrawal.
+ * If `assetFrom` is a Toros pool, this is treated as a withdrawal and routes through
+ * `getInitWithdrawalTxData`. Otherwise it builds a `depositWithCustomCooldown` call.
+ */
 export async function getEasySwapperTxData(
   pool: Pool,
   assetFrom: string,

package/src/services/toros/initWithdrawal.ts

@@ -1,11 +1,11 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { Dapp, ethers, Pool } from "../..";
-import { networkChainIdMap, routerAddress } from "../../config";
+import { routerAddress } from "../../config";
 import { retry } from "./retry";
 import AaveLendingPoolAssetGuardAbi from "../../abi/IAaveLendingPoolAssetGuard.json";
 import IEasySwapperV2 from "../../abi/IEasySwapperV2.json";
 import { loadPool } from "./pool";
-import { getSwapDataViaOdos, SWAPPER_ADDERSS } from "./swapData";
+import { getSwapData, ROUTER_KEYS } from "./swapData";
 const AAVE_WITHDRAW_ONCHAIN_SWAP_SLIPPAGE = 150; // 1.5% slippage for onchain swap in Aave withdrawal
 
 const getCalculateSwapDataParams = async (
@@ -45,38 +45,46 @@ const getAaveAssetWithdrawData = async (
 ) => {
   const { srcData, dstData } = swapDataParams;
 
-  const srcDataToEncode: unknown[] = [];
-  const routerKey = ethers.utils.formatBytes32String("ODOS_V3");
-  for (const { asset, amount } of srcData) {
-    const swapData = await retry({
-      fn: () => {
-        return getSwapDataViaOdos({
-          srcAsset: asset,
-          srcAmount: amount.toString(),
-          dstAsset: dstData.asset,
-          chainId: networkChainIdMap[pool.network],
-          from: SWAPPER_ADDERSS,
-          receiver: SWAPPER_ADDERSS,
-          slippage
+  for (const routerKeyString of ROUTER_KEYS) {
+    try {
+      const srcDataToEncode: unknown[] = [];
+      const routerKey = ethers.utils.formatBytes32String(routerKeyString);
+      for (const { asset, amount } of srcData) {
+        const swapData = await retry({
+          fn: () => {
+            return getSwapData(
+              pool,
+              {
+                srcAsset: asset,
+                srcAmount: amount.toString(),
+                dstAsset: dstData.asset,
+                slippage
+              },
+              routerKeyString
+            );
+          },
+          delayMs: 1500,
+          maxRetries: 7
         });
-      },
-      delayMs: 1500,
-      maxRetries: 7
-    });
-    srcDataToEncode.push([asset, amount, [routerKey, swapData]]);
-  }
-  const coder = ethers.utils.defaultAbiCoder;
+        srcDataToEncode.push([asset, amount, [routerKey, swapData]]);
+      }
+      const coder = ethers.utils.defaultAbiCoder;
 
-  const encodedSrcData = coder.encode(
-    ["tuple(address, uint256, tuple(bytes32, bytes))[]"],
-    [srcDataToEncode]
-  );
-  const withdrawData = coder.encode(
-    ["tuple(bytes, tuple(address, uint256), uint256)"],
-    [[encodedSrcData, [dstData.asset, dstData.amount], slippage]]
-  );
+      const encodedSrcData = coder.encode(
+        ["tuple(address, uint256, tuple(bytes32, bytes))[]"],
+        [srcDataToEncode]
+      );
+      const withdrawData = coder.encode(
+        ["tuple(bytes, tuple(address, uint256), uint256)"],
+        [[encodedSrcData, [dstData.asset, dstData.amount], slippage]]
+      );
 
-  return withdrawData;
+      return withdrawData;
+    } catch {
+      continue;
+    }
+  }
+  throw new Error("All swap routers failed for init withdrawal");
 };
 
 export const createWithdrawTxArguments = async (

package/src/services/toros/swapData.ts

@@ -1,141 +1,55 @@
-import axios from "axios";
 import BigNumber from "bignumber.js";
-import { ethers } from "ethers";
-import { odosBaseUrl, SwapReferralInfo, SwapTokenInfo } from "../odos";
-import { networkChainIdMap, OdosSwapFeeRecipient } from "../../config";
-import OdosRouterV3Abi from "../../abi/odos/OdosRouterV3.json";
+import { Pool } from "../..";
+import { getKyberSwapTxData } from "../kyberSwap";
+import { getOneInchSwapTxData } from "../oneInch";
 
-export const SWAPPER_ADDERSS = "0x4F754e0F0924afD74980886b0B479Fa1D7C58D0D";
+export const SWAPPER_ADDRESS = "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%)
-}
+// Order matters: routers are tried in sequence by init/completeWithdrawal.
+// KyberSwap is the primary route; 1inch is the fallback.
+export const ROUTER_KEYS = ["KYBER_SWAP_V2", "ONE_INCH"] as const;
 
-export const getSwapDataViaOdos = async ({
-  srcAsset,
-  srcAmount,
-  dstAsset,
-  chainId,
-  from,
-  slippage
-}: SwapParams): Promise<string> => {
-  if (!process.env.ODOS_API_KEY) {
-    throw new Error("ODOS_API_KEY is not set");
-  }
-  const ODOS_API_KEY = process.env.ODOS_API_KEY;
-  const network = (Object.keys(networkChainIdMap) as Array<
-    keyof typeof networkChainIdMap
-  >).find(key => networkChainIdMap[key] === chainId);
-  if (!network) {
-    throw new Error(`Unsupported chainId: ${chainId}`);
-  }
+export type RouterKey = typeof ROUTER_KEYS[number];
 
-  const referralFeeBips = 2; // 2 basis points = 0.02%
+export interface SwapParams {
+  srcAsset: string;
+  srcAmount: string;
+  dstAsset: string;
+  slippage: number; // in basis points (100 = 1%)
+}
 
-  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,
-    referralFee: referralFeeBips, // 0.02% fee
-    referralFeeRecipient: OdosSwapFeeRecipient[network],
-    compact: false
-  };
-  try {
-    const quoteResult = await axios.post(
-      `${odosBaseUrl}/quote/v3`,
-      quoteParams,
-      {
-        headers: {
-          "Content-Type": "application/json",
-          "x-api-key": ODOS_API_KEY
-        }
-      }
+export const getSwapData = async (
+  pool: Pool,
+  params: SwapParams,
+  routerKeyString: RouterKey
+): Promise<string> => {
+  const { srcAsset, srcAmount, dstAsset, slippage } = params;
+  // Convert basis points to percentage for aggregator APIs
+  const slippagePercent = new BigNumber(slippage).div(100).toNumber();
+
+  if (routerKeyString === "KYBER_SWAP_V2") {
+    const { swapTxData } = await getKyberSwapTxData(
+      pool,
+      srcAsset,
+      dstAsset,
+      srcAmount,
+      slippagePercent,
+      SWAPPER_ADDRESS,
+      SWAPPER_ADDRESS
     );
-
-    const assembleParams = {
-      pathId: quoteResult.data.pathId,
-      userAddr: from
-    };
-
-    const assembleResult = await axios.post(
-      `${odosBaseUrl}/assemble`,
-      assembleParams,
-      {
-        headers: {
-          "Content-Type": "application/json",
-          "x-api-key": ODOS_API_KEY
-        }
-      }
+    return swapTxData;
+  } else if (routerKeyString === "ONE_INCH") {
+    const { swapTxData } = await getOneInchSwapTxData(
+      pool,
+      srcAsset,
+      dstAsset,
+      srcAmount,
+      slippagePercent,
+      SWAPPER_ADDRESS,
+      SWAPPER_ADDRESS
     );
-
-    const txData = assembleResult.data.transaction.data;
-
-    // Decode the transaction data
-    const iface = new ethers.utils.Interface(OdosRouterV3Abi.abi);
-    const decodedData = iface.parseTransaction({ data: txData });
-
-    const tokenInfo = decodedData.args[0] as SwapTokenInfo;
-    const pathDefinition = decodedData.args[1] as string;
-    const executor = decodedData.args[2] as string;
-    const referralInfo = decodedData.args[3] as SwapReferralInfo;
-
-    if (
-      referralInfo.fee.lte(
-        ethers.BigNumber.from((referralFeeBips * 1e18) / 10000)
-      )
-    ) {
-      // Referral fee is already correct, return original txData
-      return txData;
-    }
-
-    const FEE_DENOM = new BigNumber(1e18);
-    const correctedFee = new BigNumber((referralFeeBips * 1e18) / 10000);
-    const factor = 1.1;
-    const correctedOutputQuote = new BigNumber(tokenInfo.outputQuote.toString())
-      .times(
-        FEE_DENOM.minus(correctedFee).div(
-          FEE_DENOM.minus(referralInfo.fee.toString())
-        )
-      )
-      .times(factor);
-
-    // example referralInfo.fee could be 0.0005 * 1e18 = 500000000000000, which is 0.05%
-    // Create corrected referral info
-    const correctedTxData = iface.encodeFunctionData(decodedData.name, [
-      {
-        ...tokenInfo,
-        outputQuote: correctedOutputQuote.toFixed(0)
-      },
-      pathDefinition,
-      executor,
-      {
-        code: referralInfo.code,
-        fee: correctedFee.toFixed(0), // align with referralFeeBips
-        feeRecipient: referralInfo.feeRecipient
-      }
-    ]);
-
-    return correctedTxData;
-  } catch (e) {
-    console.error("Error in Odos API request:", e);
-    throw new Error("Swap api request of Odos failed");
+    return swapTxData;
+  } else {
+    throw new Error(`Unsupported router: ${routerKeyString}`);
   }
 };