@dhedge/v2-sdk 2.1.7 → 2.2.0

package/src/services/cowSwap/index.ts

@@ -0,0 +1,281 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import axios from "axios";
+import { ethers } from "ethers";
+import { ApiError } from "../..";
+import { networkChainIdMap, gpv2SettlementAddress } from "../../config";
+import { Pool } from "../../entities";
+import BN from "bignumber.js";
+
+export const KIND_SELL = ethers.utils.keccak256(
+  ethers.utils.toUtf8Bytes("sell")
+);
+export const KIND_BUY = ethers.utils.keccak256(ethers.utils.toUtf8Bytes("buy"));
+export const BALANCE_ERC20 = ethers.utils.keccak256(
+  ethers.utils.toUtf8Bytes("erc20")
+);
+
+// Matches CowSwapOrderTypeHashLib.ORDER_TYPE_HASH exactly:
+// kind/sellTokenBalance/buyTokenBalance are "string" in the type string
+// but encoded as bytes32 values in abi.encode — must replicate this exactly
+const ORDER_TYPE_HASH = ethers.utils.keccak256(
+  ethers.utils.toUtf8Bytes(
+    "Order(" +
+      "address sellToken," +
+      "address buyToken," +
+      "address receiver," +
+      "uint256 sellAmount," +
+      "uint256 buyAmount," +
+      "uint32 validTo," +
+      "bytes32 appData," +
+      "uint256 feeAmount," +
+      "string kind," +
+      "bool partiallyFillable," +
+      "string sellTokenBalance," +
+      "string buyTokenBalance" +
+      ")"
+  )
+);
+
+// Matches CowSwapOrderTypeHashLib.EIP712_DOMAIN_TYPEHASH
+const EIP712_DOMAIN_TYPEHASH = ethers.utils.keccak256(
+  ethers.utils.toUtf8Bytes(
+    "EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"
+  )
+);
+
+const cowSwapApiNetworkMap: Record<string, string> = {
+  polygon: "polygon"
+};
+
+const GPv2Settlement_ABI = [
+  "function setPreSignature(bytes calldata orderUid, bool signed) external"
+];
+
+// Replicates CowSwapOrderTypeHashLib.hashOrder
+function hashOrder(order: {
+  sellToken: string;
+  buyToken: string;
+  receiver: string;
+  sellAmount: string;
+  buyAmount: string;
+  validTo: number;
+  appData: string;
+  feeAmount: string;
+  kind: string;
+  partiallyFillable: boolean;
+  sellTokenBalance: string;
+  buyTokenBalance: string;
+}): string {
+  return ethers.utils.keccak256(
+    ethers.utils.defaultAbiCoder.encode(
+      [
+        "bytes32",
+        "address",
+        "address",
+        "address",
+        "uint256",
+        "uint256",
+        "uint32",
+        "bytes32",
+        "uint256",
+        "bytes32",
+        "bool",
+        "bytes32",
+        "bytes32"
+      ],
+      [
+        ORDER_TYPE_HASH,
+        order.sellToken,
+        order.buyToken,
+        order.receiver,
+        order.sellAmount,
+        order.buyAmount,
+        order.validTo,
+        order.appData,
+        order.feeAmount,
+        order.kind,
+        order.partiallyFillable,
+        order.sellTokenBalance,
+        order.buyTokenBalance
+      ]
+    )
+  );
+}
+
+// Replicates CowSwapOrderTypeHashLib.domainSeparator
+function computeDomainSeparator(
+  name: string,
+  version: string,
+  chainId: number,
+  verifyingContract: string
+): string {
+  return ethers.utils.keccak256(
+    ethers.utils.defaultAbiCoder.encode(
+      ["bytes32", "bytes32", "bytes32", "uint256", "address"],
+      [
+        EIP712_DOMAIN_TYPEHASH,
+        ethers.utils.keccak256(ethers.utils.toUtf8Bytes(name)),
+        ethers.utils.keccak256(ethers.utils.toUtf8Bytes(version)),
+        chainId,
+        verifyingContract
+      ]
+    )
+  );
+}
+
+// Replicates CowSwapOrderTypeHashLib.getDigest
+function computeOrderDigest(domainSep: string, orderHash: string): string {
+  return ethers.utils.keccak256(
+    ethers.utils.solidityPack(
+      ["bytes2", "bytes32", "bytes32"],
+      ["0x1901", domainSep, orderHash]
+    )
+  );
+}
+
+export async function getCowSwapTxData(
+  pool: Pool,
+  assetFrom: string,
+  assetTo: string,
+  amountIn: ethers.BigNumber | string,
+  slippage: number,
+  kind: "sell" | "buy" = "sell"
+): Promise<{
+  encodedTypedData: string;
+  preSignTxData: string;
+  minAmountOut: string;
+}> {
+  const chainId = networkChainIdMap[pool.network];
+  const network = cowSwapApiNetworkMap[pool.network];
+  if (!network) {
+    throw new Error(`CowSwap is not supported on network: ${pool.network}`);
+  }
+
+  const gpv2Settlement = gpv2SettlementAddress[pool.network];
+  if (!gpv2Settlement) {
+    throw new Error(
+      `GPv2Settlement address not configured for network: ${pool.network}`
+    );
+  }
+
+  const baseUrl = `https://api.cow.fi/${network}/api/v1`;
+
+  // 1. Get quote
+  let quoteResponse: any;
+  try {
+    const quoteResult = await axios.post(`${baseUrl}/quote`, {
+      sellToken: assetFrom,
+      buyToken: assetTo,
+      ...(kind === "sell"
+        ? { sellAmountBeforeFee: amountIn.toString() }
+        : { buyAmountAfterFee: amountIn.toString() }),
+      from: pool.address,
+      receiver: pool.address,
+      kind,
+      signingScheme: "presign",
+      partiallyFillable: false,
+      sellTokenBalance: "erc20",
+      buyTokenBalance: "erc20"
+    });
+    quoteResponse = quoteResult.data;
+  } catch (e) {
+    throw new ApiError("CowSwap quote request failed");
+  }
+
+  const { sellAmount, buyAmount, validTo } = quoteResponse.quote;
+
+  const buyAmountWithSlippage = ethers.BigNumber.from(
+    new BN(buyAmount.toString())
+      .times(new BN(1).minus(new BN(slippage).div(100)))
+      .toFixed(0, BN.ROUND_DOWN)
+  );
+
+  const orderValues = {
+    sellToken: assetFrom,
+    buyToken: assetTo,
+    receiver: pool.address,
+    sellAmount,
+    buyAmount: buyAmountWithSlippage.toString(),
+    validTo,
+    appData: ethers.constants.HashZero,
+    feeAmount: "0",
+    kind: kind === "sell" ? KIND_SELL : KIND_BUY,
+    partiallyFillable: false,
+    sellTokenBalance: BALANCE_ERC20,
+    buyTokenBalance: BALANCE_ERC20
+  };
+
+  // 2. Compute digest matching CowSwapOrderTypeHashLib.getDigest exactly
+  const domainSep = computeDomainSeparator(
+    "Gnosis Protocol",
+    "v2",
+    chainId,
+    gpv2Settlement
+  );
+  const orderHash = hashOrder(orderValues);
+  const orderDigest = computeOrderDigest(domainSep, orderHash);
+
+  // orderUid = abi.encodePacked(orderDigest, owner, validTo) — 32 + 20 + 4 = 56 bytes
+  const orderUid = ethers.utils.solidityPack(
+    ["bytes32", "address", "uint32"],
+    [orderDigest, pool.address, validTo]
+  );
+
+  // 3. Submit order to CowSwap API — solver waits for on-chain presign before executing
+  try {
+    await axios.post(`${baseUrl}/orders`, {
+      sellToken: assetFrom,
+      buyToken: assetTo,
+      receiver: pool.address,
+      sellAmount,
+      buyAmount: buyAmountWithSlippage.toString(),
+      validTo,
+      appData: ethers.constants.HashZero,
+      feeAmount: "0",
+      kind,
+      partiallyFillable: false,
+      signingScheme: "presign",
+      signature: pool.address,
+      sellTokenBalance: "erc20",
+      buyTokenBalance: "erc20",
+      from: pool.address,
+      quoteId: quoteResponse.id
+    });
+  } catch (e) {
+    throw new ApiError("CowSwap order submission failed");
+  }
+
+  // 4. Encode CowSwapTypedData for submit() on TypedStructuredDataValidator
+  const typedData = {
+    domain: {
+      name: "Gnosis Protocol",
+      version: "v2",
+      chainId,
+      verifyingContract: gpv2Settlement
+    },
+    order: orderValues
+  };
+
+  const encodedTypedData = ethers.utils.defaultAbiCoder.encode(
+    [
+      "tuple(" +
+        "tuple(string name, string version, uint256 chainId, address verifyingContract) domain," +
+        "tuple(address sellToken, address buyToken, address receiver, uint256 sellAmount, uint256 buyAmount, uint32 validTo, bytes32 appData, uint256 feeAmount, bytes32 kind, bool partiallyFillable, bytes32 sellTokenBalance, bytes32 buyTokenBalance) order" +
+        ")"
+    ],
+    [typedData]
+  );
+
+  // 5. Encode setPreSignature() — guard checks isValidatedHash(pool, orderDigest)
+  const settlementIface = new ethers.utils.Interface(GPv2Settlement_ABI);
+  const preSignTxData = settlementIface.encodeFunctionData("setPreSignature", [
+    orderUid,
+    true
+  ]);
+
+  return {
+    encodedTypedData,
+    preSignTxData,
+    minAmountOut: buyAmountWithSlippage.toString()
+  };
+}

package/src/services/hyperliquid/index.ts

@@ -24,6 +24,7 @@ import { getPositionSize } from "./positionData";
 const depositWallet = new ethers.utils.Interface(ICoreDepositWalletAbi);
 const coreWriter = new ethers.utils.Interface(ICoreWriterAbi);
 
+/** Encode `deposit(amount, dexId)` on the Hyperliquid CoreDepositWallet to bridge USDC into HyperCore. */
 export const getDepositHyperliquidTxData = (
   dexId: number,
   amount: ethers.BigNumber | string
@@ -31,6 +32,11 @@ export const getDepositHyperliquidTxData = (
   return depositWallet.encodeFunctionData("deposit", [amount, dexId]);
 };
 
+/**
+ * Encode a CoreWriter `sendRawAction` for SPOT_SEND that bridges USDC from the
+ * HyperCore Spot wallet back to EVM. Amount is supplied in 6 decimals (EVM USDC) and
+ * scaled up by 100 for HyperCore's 8-decimal USDC.
+ */
 export const getWithdrawSpotHyperliquidTxData = (
   amount: ethers.BigNumber | string
 ): string => {
@@ -49,6 +55,11 @@ export const getWithdrawSpotHyperliquidTxData = (
   );
   return coreWriter.encodeFunctionData("sendRawAction", [rawTXData]);
 };
+/**
+ * Encode a CoreWriter `sendRawAction` for SEND_ASSET that moves USDC between
+ * HyperCore dexes (perp/spot/xyz). Amount is supplied in 6 decimals (EVM USDC) and
+ * scaled to HyperCore's 8 decimals.
+ */
 export const getSendAssetHyperliquidTxData = (
   sourceDex: number,
   destinationDex: number,
@@ -80,6 +91,11 @@ export const getSendAssetHyperliquidTxData = (
   return coreWriter.encodeFunctionData("sendRawAction", [rawTXData]);
 };
 
+/**
+ * Encode a CoreWriter `sendRawAction` for an IOC limit order on a Hyperliquid asset.
+ * Auto-flips side and sets `reduceOnly` when `changeAmount` is negative (perp close).
+ * Price is offset by `slippage`% from the current mid in the direction of execution.
+ */
 export const getLimitOrderHyperliquidTxData = async (
   assetId: number,
   isLong: boolean,
@@ -128,6 +144,12 @@ export const getLimitOrderHyperliquidTxData = async (
   return coreWriter.encodeFunctionData("sendRawAction", [rawTXData]);
 };
 
+/**
+ * Encode a CoreWriter `sendRawAction` for an IOC limit order that closes
+ * `percentageToClose`% of the pool's current Hyperliquid position. Reads the
+ * existing position size on-chain to determine the side (buy to close shorts,
+ * sell to close longs).
+ */
 export const getClosePositionHyperliquidTxData = async (
   assetId: number,
   percentageToClose: number,

package/src/services/kyberSwap/index.ts

@@ -9,7 +9,9 @@ export async function getKyberSwapTxData(
   tokenIn: string,
   tokenOut: string,
   amountIn: ethers.BigNumber | string,
-  slippage: number
+  slippage: number,
+  sender?: string,
+  receiver?: string
 ): Promise<{ swapTxData: string; minAmountOut: string }> {
   const params = {
     tokenIn,
@@ -29,8 +31,8 @@ export async function getKyberSwapTxData(
 
     const buildParams = {
       routeSummary: quoteResult.data.data.routeSummary,
-      sender: pool.address,
-      recipient: pool.address,
+      sender: sender || pool.address,
+      recipient: receiver || pool.address,
       slippageTolerance: slippage * 100 // in basis points
     };
 

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 (