@dhedge/v2-sdk 2.1.6 → 2.1.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dhedge/v2-sdk",
-  "version": "2.1.6",
+  "version": "2.1.8",
   "license": "MIT",
   "description": "🛠 An SDK for building applications on top of dHEDGE V2",
   "main": "dist/index.js",

package/src/config.ts

@@ -35,7 +35,8 @@ export const routerAddress: AddressDappNetworkMap = {
     [Dapp.ARRAKIS]: "0xc73fb100a995b33f9fa181d420f4c8d74506df66",
     [Dapp.TOROS]: "0x45b90480D6F643dE2f128db091A357C3c90399f2",
     [Dapp.ODOS]: "0x0D05a7D3448512B78fa8A9e46c4872C88C4a0D05",
-    [Dapp.KYBERSWAP]: "0x6131B5fae19EA4f9D964eAc0408E4408b66337b5"
+    [Dapp.KYBERSWAP]: "0x6131B5fae19EA4f9D964eAc0408E4408b66337b5",
+    [Dapp.COWSWAP]: "0x893223Be4e941fAA8A8DB93D0C097fCac37801ce"
   },
   [Network.OPTIMISM]: {
     [Dapp.UNISWAPV3]: "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45",
@@ -88,6 +89,10 @@ export const routerAddress: AddressDappNetworkMap = {
   }
 };
 
+export const gpv2SettlementAddress: Partial<Record<Network, string>> = {
+  [Network.POLYGON]: "0x9008D19f58AAbD9eD0D60971565AA8510560ab41"
+};
+
 export const dappFactoryAddress: AddressDappNetworkMap = {
   [Network.POLYGON]: {
     [Dapp.SUSHISWAP]: "0xc35DADB65012eC5796536bD9864eD8773aBc74C4",

package/src/entities/pool.ts

@@ -18,6 +18,7 @@ import {
   MaxUint128,
   nonfungiblePositionManagerAddress,
   routerAddress,
+  gpv2SettlementAddress,
   stakingAddress,
   SYNTHETIX_TRACKING_CODE,
   limitOrderAddress
@@ -69,7 +70,7 @@ import {
   getExitVestTxData,
   getRewardsTxDta
 } from "../services/ramses/vesting";
-import { getPoolTxOrGasEstimate } from "../utils/contract";
+import { getPoolTxOrGasEstimate, isSdkOptionsBoolean } from "../utils/contract";
 import {
   cancelOrderViaFlatMoney,
   mintUnitViaFlatMoney,
@@ -96,14 +97,18 @@ import {
   hasActiveTorosLimitOrder
 } from "../services/toros/limitOrder";
 import { getKyberSwapTxData } from "../services/kyberSwap";
+import { getCowSwapTxData } from "../services/cowSwap";
 import {
   getClosePositionHyperliquidTxData,
   getDepositHyperliquidTxData,
   getLimitOrderHyperliquidTxData,
-  getPerpToSpotHyperliquidTxData,
+  getSendAssetHyperliquidTxData,
   getWithdrawSpotHyperliquidTxData
 } from "../services/hyperliquid";
-import { CORE_WRITER_ADDRESS } from "../services/hyperliquid/constants";
+import {
+  CORE_WRITER_ADDRESS,
+  SPOT_DEX_ID
+} from "../services/hyperliquid/constants";
 
 export class Pool {
   public readonly poolLogic: Contract;
@@ -471,6 +476,60 @@ export class Pool {
           slippage
         ));
         break;
+      case Dapp.COWSWAP: {
+        const cowSwapEstimateGas = isSdkOptionsBoolean(sdkOptions)
+          ? sdkOptions
+          : sdkOptions.estimateGas;
+        if (
+          cowSwapEstimateGas ||
+          (!isSdkOptionsBoolean(sdkOptions) && sdkOptions.onlyGetTxData)
+        ) {
+          throw new Error(
+            "CowSwap requires two sequential transactions (submit + preSign) and does not support estimateGas or onlyGetTxData"
+          );
+        }
+        const {
+          encodedTypedData,
+          preSignTxData,
+          minAmountOut: cowMinOut
+        } = await getCowSwapTxData(
+          this,
+          assetFrom,
+          assetTo,
+          amountIn,
+          slippage
+        );
+        // Tx 1: manager calls submit() directly on TypedStructuredDataValidator (not via pool.execTransaction)
+        const validatorContract = new Contract(
+          routerAddress[this.network][dapp] as string,
+          [
+            "function submit(address _poolLogic, uint8 _dataType, bytes memory _structuredData) external"
+          ],
+          this.signer
+        );
+        const submitTx = await validatorContract.submit(
+          this.address,
+          1 /* COWSWAP_ORDER */,
+          encodedTypedData,
+          ...(options ? [options] : [])
+        );
+        const submitReceipt = await submitTx.wait(3);
+        if (submitReceipt.status === 0) {
+          return submitReceipt;
+        }
+
+        // Tx 2: pool.execTransaction → setPreSignature() on GPv2Settlement — guard checks stored digest, solvers execute
+        return getPoolTxOrGasEstimate(
+          this,
+          [
+            gpv2SettlementAddress[this.network],
+            preSignTxData,
+            options,
+            cowMinOut
+          ],
+          sdkOptions
+        );
+      }
       default:
         const iUniswapV2Router = new ethers.utils.Interface(
           IUniswapV2Router.abi
@@ -2220,7 +2279,38 @@ export class Pool {
       this,
       [
         CORE_WRITER_ADDRESS,
-        getPerpToSpotHyperliquidTxData(dexId, this.address, amount),
+        getSendAssetHyperliquidTxData(dexId, SPOT_DEX_ID, this.address, amount),
+        options
+      ],
+      sdkOptions
+    );
+    return tx;
+  }
+
+  /** Move USDC from HyperCore spot wallet to a trading dex.
+   *
+   * @param {number} dexId Destination dex ID where USDC will be moved to
+   *   - 0: Core Perp dex (standard perps like BTC, ETH)
+   *   - 1: xyz HIP-3 dex (builder perps like TSLA, GOLD)
+   * @param {BigNumber | string} amount USDC amount to transfer (6 decimals, e.g. "1000000" = 1 USDC)
+   * @param {any} options Transaction options
+   * @param {SDKOptions} sdkOptions SDK options including estimateGas
+   * @returns {Promise<any>} Transaction
+   */
+
+  async spotToPerpHyperliquid(
+    dexId: number,
+    amount: BigNumber | string,
+    options: any = null,
+    sdkOptions: SDKOptions = {
+      estimateGas: false
+    }
+  ): Promise<any> {
+    const tx = await getPoolTxOrGasEstimate(
+      this,
+      [
+        CORE_WRITER_ADDRESS,
+        getSendAssetHyperliquidTxData(SPOT_DEX_ID, dexId, this.address, amount),
         options
       ],
       sdkOptions

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

@@ -6,7 +6,6 @@ import {
   LIMIT_ORDER_ACTION,
   LIMIT_ORDER_TIF_IOC,
   SEND_ASSET_ACTION,
-  SPOT_DEX_ID,
   SPOT_SEND_ACTION,
   USDC_CORE_ADDRESS,
   USDC_TOKEN_ID
@@ -50,12 +49,15 @@ export const getWithdrawSpotHyperliquidTxData = (
   );
   return coreWriter.encodeFunctionData("sendRawAction", [rawTXData]);
 };
-export const getPerpToSpotHyperliquidTxData = (
-  dexId: number,
+export const getSendAssetHyperliquidTxData = (
+  sourceDex: number,
+  destinationDex: number,
   receiver: string,
   amount: ethers.BigNumber | string
 ): string => {
-  const coreAmount = ethers.BigNumber.from(amount).mul(100); //USDC on Core has two more decimals
+  // Convert 6-decimal EVM USDC to 8-decimal HyperCore USDC (spot, main perp, and xyz)
+  // Transfer USDC between dexes (perp, spot, xyz)
+  const coreAmount = ethers.BigNumber.from(amount).mul(100);
   //From Perp to Spot
   const innerEncoded = ethers.utils.defaultAbiCoder.encode(
     //destination, subAccount, sourceDex, destinationDex, token, amount
@@ -63,8 +65,8 @@ export const getPerpToSpotHyperliquidTxData = (
     [
       receiver,
       ethers.constants.AddressZero,
-      dexId,
-      SPOT_DEX_ID,
+      sourceDex,
+      destinationDex,
       USDC_TOKEN_ID,
       coreAmount
     ]

package/src/test/constants.ts

@@ -50,7 +50,7 @@ export const TEST_POOL = {
 
 export const CONTRACT_ADDRESS = {
   [Network.POLYGON]: {
-    USDC: "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174",
+    USDC: "0x3c499c542cef5e3811e1192ce70d8cc03d5c3359",
     USDT: "",
     USDE: "",
     SUSD: "",

package/src/test/cowswap.test.ts

@@ -0,0 +1,81 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+
+import { Dhedge, Pool } from "..";
+
+import { Dapp, Network } from "../types";
+import { CONTRACT_ADDRESS, TEST_POOL } from "./constants";
+import { getTxOptions } from "./txOptions";
+import { TestingRunParams, testingHelper } from "./utils/testingHelper";
+import { balanceDelta } from "./utils/token";
+
+const testCowswap = ({ wallet, network }: TestingRunParams) => {
+  const USDC = CONTRACT_ADDRESS[network].USDC;
+  const WETH = CONTRACT_ADDRESS[network].WETH;
+
+  let dhedge: Dhedge;
+  let pool: Pool;
+  jest.setTimeout(100000);
+
+  describe(`pool on ${network}`, () => {
+    beforeAll(async () => {
+      dhedge = new Dhedge(wallet, network);
+      pool = await dhedge.loadPool(TEST_POOL[network]);
+    });
+
+    // it("approves unlimited USDC on Cowswap", async () => {
+    //   await pool.approveSpender(
+    //     "0xC92E8bdf79f0507f65a392b0ab4667716BFE0110", //Vault relayer
+    //     USDC,
+    //     MAX_AMOUNT,
+    //     await getTxOptions(network)
+    //   );
+    //   const usdcAllowanceDelta = await allowanceDelta(
+    //     pool.address,
+    //     USDC,
+    //     "0xC92E8bdf79f0507f65a392b0ab4667716BFE0110", //Vault relayer
+    //     pool.signer
+    //   );
+    //   await expect(usdcAllowanceDelta.gt(0).toBe(true));
+    // });
+
+    // it("gets gas estimation for 2 USDC into WETH on Cowswap", async () => {
+    //   const gasEstimate = await pool.trade(
+    //     Dapp.COWSWAP,
+    //     USDC,
+    //     WETH,
+    //     "2000000",
+    //     1,
+    //     await getTxOptions(network),
+    //     true
+    //   );
+    //   console.log(
+    //     "Gas estimate for trading 2 USDC to WETH on Cowswap:",
+    //     gasEstimate
+    //   );
+    //   expect(gasEstimate.minAmountOut).not.toBeNull();
+    // });
+
+    it("trades 2 USDC into WETH on Cowswap", async () => {
+      await pool.trade(
+        Dapp.COWSWAP,
+        USDC,
+        WETH,
+        "2000000",
+        0.5,
+        await getTxOptions(network)
+      );
+      const wethBalanceDelta = await balanceDelta(
+        pool.address,
+        WETH,
+        pool.signer
+      );
+      expect(wethBalanceDelta.gt(0)).toBe(true);
+    });
+  });
+};
+
+testingHelper({
+  network: Network.POLYGON,
+  testingRun: testCowswap,
+  onFork: false
+});

package/src/types.ts

@@ -35,7 +35,8 @@ export enum Dapp {
   ODOS = "odos",
   PENDLE = "pendle",
   KYBERSWAP = "kyberswap",
-  HYPERLIQUID = "hyperliquid"
+  HYPERLIQUID = "hyperliquid",
+  COWSWAP = "cowswap"
 }
 
 export enum Transaction {