@dhedge/v2-sdk 2.2.0 → 2.2.1

package/package.json

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

package/src/abi/ondo/IOndoGMSwap.json

@@ -0,0 +1,30 @@
+[
+  {
+    "inputs": [
+      { "name": "tokenIn", "type": "address" },
+      { "name": "amountIn", "type": "uint256" },
+      { "name": "tokenOut", "type": "address" },
+      { "name": "amountOutMinimum", "type": "uint256" },
+      { "name": "attestationSignature", "type": "bytes" },
+      {
+        "components": [
+          { "name": "chainId", "type": "uint256" },
+          { "name": "attestationId", "type": "uint256" },
+          { "name": "userId", "type": "bytes32" },
+          { "name": "asset", "type": "address" },
+          { "name": "price", "type": "uint256" },
+          { "name": "quantity", "type": "uint256" },
+          { "name": "expiration", "type": "uint256" },
+          { "name": "side", "type": "uint8" },
+          { "name": "additionalData", "type": "bytes32" }
+        ],
+        "name": "quote",
+        "type": "tuple"
+      }
+    ],
+    "name": "swapExactInWithAttestation",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  }
+]

package/src/config.ts

@@ -77,7 +77,8 @@ export const routerAddress: AddressDappNetworkMap = {
     [Dapp.ODOS]: "0x0D05a7D3448512B78fa8A9e46c4872C88C4a0D05",
     [Dapp.PENDLE]: "0x888888888889758F76e7103c6CbF23ABbF58F946",
     [Dapp.ONEINCH]: "0x111111125421ca6dc452d289314280a0f8842a65",
-    [Dapp.KYBERSWAP]: "0x6131B5fae19EA4f9D964eAc0408E4408b66337b5"
+    [Dapp.KYBERSWAP]: "0x6131B5fae19EA4f9D964eAc0408E4408b66337b5",
+    [Dapp.ONDO]: "0xde41399145F23936b03dD1474eC16c1519c0DC2a"
   },
   [Network.PLASMA]: {
     [Dapp.AAVEV3]: "0x925a2A7214Ed92428B5b1B090F80b25700095e12",

package/src/entities/pool.ts

@@ -87,6 +87,7 @@ import {
 } from "../services/toros/limitOrder";
 import { getKyberSwapTxData } from "../services/kyberSwap";
 import { getCowSwapTxData } from "../services/cowSwap";
+import { getOndoSwapTxData } from "../services/ondo";
 import {
   getClosePositionHyperliquidTxData,
   getDepositHyperliquidTxData,
@@ -451,6 +452,15 @@ export class Pool {
           slippage
         ));
         break;
+      case Dapp.ONDO:
+        ({ swapTxData, minAmountOut } = await getOndoSwapTxData(
+          this,
+          assetFrom,
+          assetTo,
+          amountIn.toString(),
+          slippage
+        ));
+        break;
       case Dapp.COWSWAP: {
         const cowSwapEstimateGas = isSdkOptionsBoolean(sdkOptions)
           ? sdkOptions

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/test/ondo.onchain.test.ts

@@ -0,0 +1,132 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+
+/**
+ * Ondo Global Markets on-chain tests for minting and redeeming GM tokens.
+ * These require a live chain connection (onFork: false) because each mint/redeem
+ * needs a fresh attestation signed by the Ondo API against current chain state,
+ * which cannot be reproduced on a Hardhat fork.
+ *
+ * Prerequisites:
+ *   - PRIVATE_KEY in .env (must be the pool manager or trader)
+ *   - ETHEREUM_URL in .env
+ *   - ONDO_API_KEY in .env
+ *   - The test pool must hold USDC to mint (and SPYon, from the mint, to redeem)
+ */
+
+import { ethers } from "ethers";
+import { Dhedge, Pool } from "..";
+
+import { Dapp, Network } from "../types";
+import { CONTRACT_ADDRESS, MAX_AMOUNT } from "./constants";
+import { TestingRunParams, testingHelper } from "./utils/testingHelper";
+
+import { getTxOptions } from "./txOptions";
+import { balanceDelta } from "./utils/token";
+
+import { routerAddress } from "../config";
+
+const testOndo = ({ wallet, network }: TestingRunParams) => {
+  const USDC = CONTRACT_ADDRESS[network].USDC;
+  const SPYon = "0xfedc5f4a6c38211c1338aa411018dfaf26612c08";
+
+  let dhedge: Dhedge;
+  let pool: Pool;
+  jest.setTimeout(100000);
+
+  describe(`pool on ${network}`, () => {
+    beforeAll(async () => {
+      dhedge = new Dhedge(wallet, network);
+      pool = await dhedge.loadPool(
+        "0x9f647b85A514b1e60F8E8E956E636a50dA406279"
+      );
+    });
+
+    it("approves unlimited USDC on Ondo", async () => {
+      const tx = await pool.approve(Dapp.ONDO, USDC, MAX_AMOUNT);
+      await tx.wait();
+      const iERC20 = new ethers.Contract(
+        USDC,
+        ["function allowance(address,address) view returns (uint256)"],
+        pool.signer
+      );
+      const allowance = await iERC20.allowance(
+        pool.address,
+        routerAddress[network][Dapp.ONDO]!
+      );
+      expect(allowance.gt(0)).toBe(true);
+    });
+
+    it("gets gas estimation for 40 USDC into SPYon on Ondo", async () => {
+      const gasEstimate = await pool.trade(
+        Dapp.ONDO,
+        USDC,
+        SPYon,
+        "40000000",
+        0.1,
+        await getTxOptions(network),
+        true
+      );
+      expect(gasEstimate.gasEstimationError).toBeNull();
+      expect(gasEstimate.gas.gt(0)).toBe(true);
+      expect(gasEstimate.minAmountOut).not.toBeNull();
+    });
+
+    it("trades 40 USDC into SPYon on Ondo", async () => {
+      const tx = await pool.trade(
+        Dapp.ONDO,
+        USDC,
+        SPYon,
+        "40000000",
+        0.1,
+        await getTxOptions(network)
+      );
+      await tx.wait();
+      const spBalanceDelta = await balanceDelta(
+        pool.address,
+        SPYon,
+        pool.signer
+      );
+      expect(spBalanceDelta.gt(0)).toBe(true);
+    });
+
+    it("approves unlimited SPYon on Ondo", async () => {
+      const tx = await pool.approve(Dapp.ONDO, SPYon, MAX_AMOUNT);
+      await tx.wait();
+      const iERC20 = new ethers.Contract(
+        SPYon,
+        ["function allowance(address,address) view returns (uint256)"],
+        pool.signer
+      );
+      const allowance = await iERC20.allowance(
+        pool.address,
+        routerAddress[network][Dapp.ONDO]!
+      );
+      expect(allowance.gt(0)).toBe(true);
+    });
+
+    it("sells SPYon balance on Ondo", async () => {
+      const spyonBalance = await pool.utils.getBalance(SPYon, pool.address);
+      const tx = await pool.trade(
+        Dapp.ONDO,
+        SPYon,
+        USDC,
+        spyonBalance,
+        0.1,
+        await getTxOptions(network)
+      );
+      await tx.wait();
+      const usdcBalanceDelta = await balanceDelta(
+        pool.address,
+        USDC,
+        pool.signer
+      );
+      expect(usdcBalanceDelta.gt(0)).toBe(true);
+    });
+  });
+};
+
+testingHelper({
+  network: Network.ETHEREUM,
+  testingRun: testOndo,
+  onFork: false
+});

package/src/types.ts

@@ -37,7 +37,8 @@ export enum Dapp {
   PENDLE = "pendle",
   KYBERSWAP = "kyberswap",
   HYPERLIQUID = "hyperliquid",
-  COWSWAP = "cowswap"
+  COWSWAP = "cowswap",
+  ONDO = "ondo"
 }
 
 /** Function-name strings used when encoding ABI calls — keep in sync with the