@dhedge/v2-sdk 2.1.4 → 2.1.6

package/README.md

@@ -34,18 +34,18 @@ yarn add @dhedge/v2-sdk
       <a href="#initial-setup">Initial setup</a>
     </li>
       <li>
-        <a href="#general-pool-management">General Pool Management</a>
+        <a href="#general-vault-management">General Vault Management</a>
         <ul>
-          <li><a href="#1-create-pool">Create pool</a></li>
-          <li><a href="#2-load-pool">Load pool</a></li>
-          <li><a href="#3-get-pool-composition">Get pool composition</a></li>
-          <li><a href="#4-change-pool-assets-enabledisable">Change pool assets</a></li>
+          <li><a href="#1-create-a-vault">Create a vault</a></li>
+          <li><a href="#2-load-a-vault">Load a vault</a></li>
+          <li><a href="#3-get-vault-composition">Get vault composition</a></li>
+          <li><a href="#4-change-vault-assets-enabledisable">Change vault assets</a></li>
           <li><a href="#5-set-trader">Set trader</a></li>
           <li><a href="#6-approve-asset-for-deposit">Approve asset for deposit</a></li>
-          <li><a href="#7-deposit-asset-into-pool">Deposit asset into pool</a></li>
-          <li><a href="#8-withdraw-from-pool">Withdraw from pool</a></li>
-          <li><a href="#9-approve-pool-asset-for-trading--staking)">Approve pool asset for trading & staking</a></li>
-          <li><a href="#10-trade-pool-assets">Trade pool assets</a></li>
+          <li><a href="#7-deposit-asset-into-a-vault">Deposit asset into a vault</a></li>
+          <li><a href="#8-withdraw-from-a-vault">Withdraw from a vault</a></li>
+          <li><a href="#9-approve-vault-asset-for-trading--staking)">Approve vault asset for trading & staking</a></li>
+          <li><a href="#10-trade-vault-assets">Trade vault assets</a></li>
         </ul>
     </li>
     <li>
@@ -77,13 +77,24 @@ yarn add @dhedge/v2-sdk
 
 ---
 
-If you want to use 1Inch to trade pool assets you need to apply for an API key at [1Inch Dev Portal](https://docs.1inch.io/docs/aggregation-protocol/introduction).
-Then you need to copy .env.example file to .env and set your API key there.
+If you want to use aggregators such as 1Inch or Odos, copy `.env.example` to `.env` and configure the API keys you need.
 
 ```
 ONEINCH_API_KEY=YOUR_API_KEY_FROM_1INCH
+ODOS_API_KEY=YOUR_ODOS_API_KEY
 ```
 
+- `ONEINCH_API_KEY` is required for `Dapp.ONEINCH`
+- `ODOS_API_KEY` is required for `Dapp.ODOS`
+- `ODOS_API_KEY` can also be required by `completeTorosWithdrawal(...)` when a Toros withdrawal needs Odos-backed swap data
+
+To get started:
+
+- get a 1inch API key from the [1inch Developer Portal](https://docs.1inch.io/docs/aggregation-protocol/introduction)
+- get an Odos API key via the [Odos developer docs](https://docs.odos.xyz/build/api-docs), and make sure it is valid for the Odos endpoint configured by this SDK
+- place the keys in a `.env` file at the project root before calling aggregator-backed methods
+- if a required key is missing, the SDK will fail before transaction submission
+
 Initialize the sdk with an [ethers wallet](https://docs.ethers.io/v5/api/signer/#Wallet) and the network.
 
 ```ts
@@ -98,20 +109,74 @@ const walletWithProvider = new ethers.Wallet(privateKey, provider);
 const dhedge = new Dhedge(walletWithProvider, Network.POLYGON);
 ```
 
+In dHEDGE product language these are usually called vaults. In the SDK and smart contracts, many classes and methods still use the older `pool` naming, so both terms may appear in the code examples below.
+
+Important notes:
+
+- `Dhedge` expects a provider-connected `ethers.Wallet`. Read-only providers are not enough for state-changing calls.
+- The wallet you pass in is the account that signs transactions. In most cases this is the pool manager wallet.
+- `loadPool(address)` assumes the address is a dHEDGE pool and resolves the manager contract automatically.
+- `loadPool(address, false)` can be used when you want to work with a non-dHEDGE contract that should execute directly from the signer.
+
+#### Execution model
+
+By default, manager actions are executed through `pool.poolLogic.execTransaction(...)`.
+
+If you set a separate trader account with `pool.setTrader(...)`, you can estimate or send transactions from the trader wallet by using `sdkOptions.useTraderAddressAsFrom`.
+
+```ts
+const tx = await pool.trade(
+  Dapp.ONEINCH,
+  "USDC_TOKEN_ADDRESS",
+  "WETH_TOKEN_ADDRESS",
+  "1000000",
+  0.5,
+  null,
+  {
+    estimateGas: true,
+    useTraderAddressAsFrom: true,
+  }
+)
+```
+
+#### Simulation and tx data
+
+Most manager methods accept `sdkOptions` as the last argument.
+
+- `true` is shorthand for `{ estimateGas: true }`
+- `{ estimateGas: true }` returns `{ gas, gasEstimationError, to, txData, minAmountOut }`
+- `{ onlyGetTxData: true }` returns `{ to, txData, minAmountOut }` without sending a transaction
+
+```ts
+const result = await pool.trade(
+  Dapp.ONEINCH,
+  "USDC_TOKEN_ADDRESS",
+  "WETH_TOKEN_ADDRESS",
+  "1000000",
+  0.5,
+  null,
+  { estimateGas: true }
+)
+
+if (result.gasEstimationError) {
+  console.error(result.gasEstimationError)
+}
+```
+
 <br>
 
-### General Pool Management
+### General Vault Management
 
 ---
 
-#### 1. Create a pool
+#### 1. Create a vault
 
 USDC and DAI enabled assets, but only USDC available for deposit.
 
 ```ts
 const usdcTokenAddress = "USDC_TOKEN_ADDRESS"
 const daiTokenAddress = "DAI_TOKEN_ADDRESS"
-const pool = await dhedge.createPool(
+const vault = await dhedge.createPool(
   "Day Ralio",
   "Awesome Fund",
   "DRAF",
@@ -121,23 +186,45 @@ const pool = await dhedge.createPool(
   ],
   10
 )
-console.log("created pool with address", pool.address)
+console.log("created vault with address", vault.address)
 ```
 
-#### 2. Load pool
+#### 2. Load a vault
 
 ```ts
-const poolAddress = "YOUR_POOL_ADDRESS"
-const pool = await dhedge.loadPool(poolAddress)
+const vaultAddress = "YOUR_VAULT_ADDRESS"
+const vault = await dhedge.loadPool(vaultAddress)
 ```
 
-#### 3. Get pool composition
+Validate a vault address before loading it:
 
 ```ts
-const composition = await pool.getComposition();
+const isValidVault = await dhedge.validatePool(vaultAddress)
+if (!isValidVault) throw new Error("invalid dHEDGE vault address")
 ```
 
-#### 4. Change pool assets (enable/disable)
+#### 3. Get vault composition
+
+```ts
+const composition = await vault.getComposition();
+```
+
+`getComposition()` returns raw on-chain values:
+
+```ts
+[
+  {
+    asset: "0x...",
+    isDeposit: true,
+    balance: BigNumber,
+    rate: BigNumber,
+  }
+]
+```
+
+You will usually need to fetch token decimals and symbols separately before displaying vault holdings to users.
+
+#### 4. Change vault assets (enable/disable)
 
 Change pool assets to allow DAI for deposits. Also enable WETH as an asset, but shouldn't be allowed as deposit.
 
@@ -147,7 +234,7 @@ const enabledAssets = [
   { asset: "DAI_TOKEN_ADDRESS", isDeposit: true },
   { asset: "WETH_TOKEN_ADDRESS", isDeposit: false },
 ]
-const tx = await pool.changeAssets(enabledAssets)
+const tx = await vault.changeAssets(enabledAssets)
 ```
 
 #### 5. Set trader
@@ -155,59 +242,66 @@ const tx = await pool.changeAssets(enabledAssets)
 Set an account with trading permissions
 
 ```ts
-const tx = await pool.setTrader("TRADER_ACCOUNT_ADDRESS")
+const tx = await vault.setTrader("TRADER_ACCOUNT_ADDRESS")
 ```
 
 #### 6. Approve asset for deposit
 
-Before depositing an asset into a Pool, it needs to be approved.
+Before depositing an asset into a vault, the user wallet must approve the vault to transfer that asset.
 
-Approve unlimited amount of USDC to deposit into Pool.
+Approve unlimited amount of USDC to deposit into a vault.
 
 ```ts
-const tx = await pool.approveDeposit("USDC_TOKEN_ADDRESS", ethers.constants.MaxUint256);
+const tx = await vault.approveDeposit("USDC_TOKEN_ADDRESS", ethers.constants.MaxUint256);
 ```
 
-#### 7. Deposit asset into pool
+#### 7. Deposit asset into a vault
 
-Deposit 1 USDC into Pool
+Deposit 1 USDC into a vault
 
 ```ts
 const usdcDepositAmount = "100000"
-const tx = await pool.deposit("USDC_TOKEN_ADDRESS", usdcDepositAmount);
+const tx = await vault.deposit("USDC_TOKEN_ADDRESS", usdcDepositAmount);
 ```
 
-#### 8. Withdraw from pool
+#### 8. Withdraw from a vault
 
-Withdraw 1.00002975 pool tokens. Note that this cannot be called if set as Trader account
+Withdraw 1.00002975 vault tokens. Note that this cannot be called if set as Trader account
 
 ```ts
 const poolTokensWithdrawAmount = "1000029750000000000"
-const tx = await pool.withdraw(poolTokensWithdrawAmount);
+const tx = await vault.withdraw(poolTokensWithdrawAmount);
 ```
 
-#### 9. Approve pool asset for trading & staking
+#### 9. Approve vault asset for trading & staking
 
-Before trading an asset on platforms like Sushiswap it needs to be approved.
+Before the vault can trade or stake an asset on an external protocol, the vault must approve that protocol router or staking contract.
 
 Approve unlimited amount of USDC to trade on Sushiswap
 
 ```ts
-const tx = await pool.approve(
+const tx = await vault.approve(
   Dapp.SUSHISWAP,
   "USDC_TOKEN_ADDRESS",
   ethers.constants.MaxInt256
 )
 ```
 
-#### 10. Trade pool assets
+Approval model summary:
+
+- `approveDeposit(asset, amount)` approves from the user wallet to the vault
+- `approve(dapp, asset, amount)` approves from the vault to a protocol router
+- `approveStaking(dapp, asset, amount)` approves from the vault to a staking contract
+- `approveSpender(spender, asset, amount)` is available for custom integrations
 
-Trade 1 USDC into DAI on Sushiswap (other options: TOROS, QUICKSWAP, BALANCER, or ONEINCH)
+#### 10. Trade vault assets
+
+Trade 1 USDC into DAI on Sushiswap (other options depend on network and configured API keys, and can include TOROS, QUICKSWAP, BALANCER, ONEINCH, and ODOS)
 
 ```ts
 const amountIn = "1000000"
 const slippage = 0.5
-const tx = await pool.trade(
+const tx = await vault.trade(
   Dapp.SUSHISWAP,
   "USDC_TOKEN_ADDRESS",
   "DAI_TOKEN_ADDRESS",
@@ -216,21 +310,62 @@ const tx = await pool.trade(
 )
 ```
 
-#### 🚨 Important Update  
-Due to the upgrade of our contract, trading out of a Toros token now involves a second step. Please follow the updated process below:
-1. Step:
+#### Toros mint flow
+
+Minting a Toros token uses `vault.trade(...)`, but it is not a generic token-to-token swap. The input asset must be a valid deposit asset for the underlying Toros vault.
+
 ```ts
-const tx = await pool.trade(
+await vault.approve(
+  Dapp.TOROS,
+  "USDC_TOKEN_ADDRESS",
+  ethers.constants.MaxUint256
+)
+
+const tx = await vault.trade(
+  Dapp.TOROS,
+  "USDC_TOKEN_ADDRESS",
+  "TOROS_TOKEN_ADDRESS",
+  "100000000",
+  slippage
+)
+```
+
+#### Toros redeem flow
+
+Redeeming a Toros token has more prerequisites than a normal trade:
+
+- newly minted Toros or dHEDGE vault tokens may be subject to a cooldown before redemption can be initiated
+- while that cooldown is active, redemption cannot be initiated
+- before initiating redemption, the vault must approve the Toros token for the Toros router
+- after redemption is initiated, some Toros withdrawals require a second completion step
+- `completeTorosWithdrawal(...)` can require `ODOS_API_KEY` when Odos-backed swap data is needed
+
+1. Approve the Toros token for redemption:
+
+```ts
+await vault.approve(
+  Dapp.TOROS,
+  "TOROS_TOKEN_ADDRESS",
+  ethers.constants.MaxUint256
+)
+```
+
+2. Initiate the redemption:
+
+```ts
+const tx = await vault.trade(
   Dapp.TOROS,
   "TOROS_TOKEN_ADDRESS",
   "USDC_TOKEN_ADDRESS",
-  '100000000',
+  "100000000",
   slippage
 )
 ```
-2. Step:
+
+3. Complete the withdrawal when required by the product flow:
+
 ```ts
-const tx = await pool.completeTorosWithdrawal(
+const tx = await vault.completeTorosWithdrawal(
   "USDC_TOKEN_ADDRESS",
   slippage
 )

package/dist/config.d.ts

@@ -20,3 +20,13 @@ export declare const flatMoneyContractAddresses: Readonly<Partial<Record<Network
     StableModule: string;
     COLLATERAL: string;
 }>>>;
+export declare const limitOrderAddress: AddressNetworkMap;
+export declare const OdosSwapFeeRecipient: {
+    polygon: string;
+    optimism: string;
+    arbitrum: string;
+    base: string;
+    ethereum: string;
+    plasma: string;
+    hyperliquid: string;
+};

package/dist/entities/pool.d.ts

@@ -1,5 +1,5 @@
 import { Contract, ethers, Wallet, BigNumber, BigNumberish } from "ethers";
-import { Dapp, FundComposition, AssetEnabled, Network, LyraOptionMarket, LyraOptionType, LyraTradeType, LyraPosition, SDKOptions } from "../types";
+import { Dapp, FundComposition, AssetEnabled, Network, LyraOptionMarket, LyraOptionType, LyraTradeType, LyraPosition, SDKOptions, LimitOrderInfo } from "../types";
 import { Utils } from "./utils";
 export declare class Pool {
     readonly poolLogic: Contract;
@@ -574,4 +574,113 @@ export declare class Pool {
      * @returns {Promise<any>} Transaction
      */
     mintPendle(assetFrom: string, pt: string, amountIn: BigNumber | string, slippage?: number, options?: any, sdkOptions?: SDKOptions): Promise<any>;
+    /** Deposit USDC from EVM to a HyperCore trading dex via the CoreDepositWallet.
+     *  This bridges USDC on-chain to Hyperliquid for perp/spot trading.
+     *
+     * @param {BigNumber | string} amount USDC amount to deposit (6 decimals, e.g. "1000000" = 1 USDC)
+     * @param {number} dexId Destination dex ID where USDC will be available (default 0)
+     *   - 0: Core Perp dex (standard perps like BTC, ETH)
+     *   - 1: xyz HIP-3 dex (builder perps like TSLA, GOLD)
+     * @param {any} options Transaction options
+     * @param {SDKOptions} sdkOptions SDK options including estimateGas
+     * @returns {Promise<any>} Transaction
+     */
+    depositHyperliquid(amount: BigNumber | string, dexId?: number, options?: any, sdkOptions?: SDKOptions): Promise<any>;
+    /** Move USDC from a HyperCore trading dex to the Spot wallet.
+     *  Required before calling withdrawHyperliquid() to bridge USDC back to EVM.
+     *
+     * @param {number} dexId Source dex ID where USDC currently sits
+     *   - 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
+     */
+    perpToSpotHyperliquid(dexId: number, amount: BigNumber | string, options?: any, sdkOptions?: SDKOptions): Promise<any>;
+    /** Withdraw USDC from Hyperliquid Spot wallet back to EVM.
+     *  USDC must be in the Spot wallet first — use perpToSpotHyperliquid() to move it from a trading dex.
+     *
+     * @param {BigNumber | string} amount USDC amount to withdraw (6 decimals, e.g. "1000000" = 1 USDC)
+     * @param {any} options Transaction options
+     * @param {SDKOptions} sdkOptions SDK options including estimateGas
+     * @returns {Promise<any>} Transaction
+     */
+    withdrawHyperliquid(amount: BigNumber | string, options?: any, sdkOptions?: SDKOptions): Promise<any>;
+    /** Open a market order on Hyperliquid
+     *  @param {number} assetId Asset id
+     * @param {boolean} isLong Long or short (Note: Spot assets only support long positions)
+     * @param {number} value Order value in base asset units (positive for opening/increasing,
+     *        negative for closing/reducing or selling spot)
+     * @param {number } slippage Slippage tolerance in %
+     * @param {any} options Transaction options
+     * @param {SDKOptions} sdkOptions SDK options including estimateGas
+     * @returns {Promise<any>} Transaction
+     */
+    openMarketOrderHyperliquid(assetId: number, isLong: boolean, value: number, slippage?: number, options?: any, sdkOptions?: SDKOptions): Promise<any>;
+    /** Close a position on Hyperliquid
+     *  @param {number} assetId Asset id
+     * @param {number} percentageToClose Percentage of position to close (0-100)
+     * @param {number } slippage Slippage tolerance in %
+     * @param {any} options Transaction options
+     * @param {SDKOptions} sdkOptions SDK options including estimateGas
+     * @returns {Promise<any>} Transaction
+     */
+    closePositionHyperliquid(assetId: number, percentageToClose?: number, slippage?: number, options?: any, sdkOptions?: SDKOptions): Promise<any>;
+    /**
+     * Approve the Toros vault token for the PoolLimitOrderManager
+     * Must be called before createTorosLimitOrder
+     * @param {string} vaultAddress Address of the Toros vault token to approve
+     * @param {BigNumber | string} amount Amount to approve
+     * @param {any} options Transaction options
+     * @param {SDKOptions} sdkOptions SDK options including estimateGas
+     * @returns {Promise<any>} Transaction
+     */
+    approveTorosLimitOrder(vaultAddress: string, amount: BigNumber | string, options?: any, sdkOptions?: SDKOptions): Promise<any>;
+    /**
+     * Create a Toros limit order (stop-loss / take-profit)
+     * @param {string} vaultAddress Address of the Toros vault token
+     * @param {BigNumber | string} amount Vault token amount (18 decimals)
+     * @param {BigNumber | string | null | undefined} stopLossPriceD18 Stop-loss price in D18 (0 or null/undefined = disabled)
+     * @param {BigNumber | string | null | undefined} takeProfitPriceD18 Take-profit price in D18 (MaxUint256 or null/undefined = disabled)
+     * @param {string} pricingAsset Address of the pricing asset (e.g. USDC)
+     * @param {any} options Transaction options
+     * @param {SDKOptions} sdkOptions SDK options including estimateGas
+     * @returns {Promise<any>} Transaction
+     */
+    createTorosLimitOrder(vaultAddress: string, amount: BigNumber | string, stopLossPriceD18: BigNumber | string | null | undefined, takeProfitPriceD18: BigNumber | string | null | undefined, pricingAsset: string, options?: any, sdkOptions?: SDKOptions): Promise<any>;
+    /**
+     * Modify an existing Toros limit order
+     * @param {string} vaultAddress Address of the Toros vault token
+     * @param {BigNumber | string} amount New vault token amount (18 decimals)
+     * @param {BigNumber | string | null | undefined} stopLossPriceD18 New stop-loss price in D18 (0 or null/undefined = disabled)
+     * @param {BigNumber | string | null | undefined} takeProfitPriceD18 New take-profit price in D18 (MaxUint256 or null/undefined = disabled)
+     * @param {string} pricingAsset Address of the pricing asset
+     * @param {any} options Transaction options
+     * @param {SDKOptions} sdkOptions SDK options including estimateGas
+     * @returns {Promise<any>} Transaction
+     */
+    modifyTorosLimitOrder(vaultAddress: string, amount: BigNumber | string, stopLossPriceD18: BigNumber | string | null | undefined, takeProfitPriceD18: BigNumber | string | null | undefined, pricingAsset: string, options?: any, sdkOptions?: SDKOptions): Promise<any>;
+    /**
+     * Delete an existing Toros limit order
+     * @param {string} vaultAddress Address of the Toros vault token
+     * @param {any} options Transaction options
+     * @param {SDKOptions} sdkOptions SDK options including estimateGas
+     * @returns {Promise<any>} Transaction
+     */
+    deleteTorosLimitOrder(vaultAddress: string, options?: any, sdkOptions?: SDKOptions): Promise<any>;
+    /**
+     * Fetch a Toros limit order for a given user and vault
+     * @param {string} userAddress Address of the order owner (the dHEDGE pool)
+     * @param {string} vaultAddress Address of the Toros vault token
+     * @returns {Promise<LimitOrderInfo | null>} Order info, or null if none exists
+     */
+    getTorosLimitOrder(userAddress: string, vaultAddress: string): Promise<LimitOrderInfo | null>;
+    /**
+     * Check whether an active Toros limit order exists for a given user and vault
+     * @param {string} userAddress Address of the order owner (the dHEDGE pool)
+     * @param {string} vaultAddress Address of the Toros vault token
+     * @returns {Promise<boolean>}
+     */
+    hasActiveTorosLimitOrder(userAddress: string, vaultAddress: string): Promise<boolean>;
 }

package/dist/services/hyperliquid/constants.d.ts

@@ -0,0 +1,16 @@
+export declare const USDC_TOKEN_ID = 0;
+export declare const USDC_CORE_ADDRESS = "0x2000000000000000000000000000000000000000";
+export declare const CORE_WRITER_ADDRESS = "0x3333333333333333333333333333333333333333";
+export declare const PERP_DEX_ID = 0;
+export declare const SPOT_DEX_ID = 4294967295;
+export declare const HYPERLIQUID_VERSION = 1;
+export declare const SPOT_SEND_ACTION = 6;
+export declare const SEND_ASSET_ACTION = 13;
+export declare const LIMIT_ORDER_ACTION = 1;
+export declare const LIMIT_ORDER_TIF_ALO = 1;
+export declare const LIMIT_ORDER_TIF_GTC = 2;
+export declare const LIMIT_ORDER_TIF_IOC = 3;
+export declare const dexIdNameMap: {
+    [key: number]: string;
+};
+export declare const API_URL = "https://api.hyperliquid.xyz/info";

package/dist/services/hyperliquid/index.d.ts

@@ -0,0 +1,6 @@
+import { ethers } from "ethers";
+export declare const getDepositHyperliquidTxData: (dexId: number, amount: ethers.BigNumber | string) => string;
+export declare const getWithdrawSpotHyperliquidTxData: (amount: ethers.BigNumber | string) => string;
+export declare const getPerpToSpotHyperliquidTxData: (dexId: number, receiver: string, amount: ethers.BigNumber | string) => string;
+export declare const getLimitOrderHyperliquidTxData: (assetId: number, isLong: boolean, changeAmount: number, slippage: number) => Promise<string>;
+export declare const getClosePositionHyperliquidTxData: (assetId: number, percentageToClose: number, slippage: number, poolAddress: string) => Promise<string>;

package/dist/services/hyperliquid/marketData.d.ts

@@ -0,0 +1,12 @@
+export declare const perpDexIndex: (assetId: number) => number;
+export declare const spotAssetIndex: (assetId: number) => number;
+export declare const isSpotAsset: (assetId: number) => boolean;
+export declare const getMidPrice: (assetId: number, assetName: string) => Promise<number>;
+export declare const getAssetInfo: (assetId: number) => Promise<{
+    assetName: string;
+    szDecimals: number;
+    baseTokenName?: string;
+}>;
+export declare const calculatePrice: (isSpotAsset: boolean, szDecimals: number, midPrice: number, isBuy: boolean, slippage: number) => string;
+export declare const calculateSize: (szDecimals: number, value: number, price: number) => string;
+export declare const scaleSize: (szDecimals: number, positionSize: number, percentageToClose: number) => string;

package/dist/services/hyperliquid/positionData.d.ts

@@ -0,0 +1 @@
+export declare const getPositionSize: (assetId: number, isSpot: boolean, assetName: string, user: string) => Promise<number>;

package/dist/services/odos/index.d.ts

@@ -1,6 +1,20 @@
 import { ethers } from "../..";
 import { Pool } from "../../entities";
-export declare const odosBaseUrl = "https://api.odos.xyz/sor";
+export declare const odosBaseUrl = "https://enterprise-api.odos.xyz/sor";
+export interface SwapTokenInfo {
+    inputToken: string;
+    inputAmount: ethers.BigNumber;
+    inputReceiver: string;
+    outputToken: string;
+    outputQuote: ethers.BigNumber;
+    outputMin: ethers.BigNumber;
+    outputReceiver: string;
+}
+export interface SwapReferralInfo {
+    code: ethers.BigNumber;
+    fee: ethers.BigNumber;
+    feeRecipient: string;
+}
 export declare function getOdosSwapTxData(pool: Pool, assetFrom: string, assetTo: string, amountIn: ethers.BigNumber | string, slippage: number): Promise<{
     swapTxData: string;
     minAmountOut: string;

package/dist/services/toros/limitOrder.d.ts

@@ -0,0 +1,8 @@
+import { Pool } from "../..";
+import { LimitOrderInfo } from "../../types";
+export declare function getLimitOrderId(userAddress: string, vaultAddress: string): string;
+export declare function getCreateLimitOrderTxData(info: LimitOrderInfo): string;
+export declare function getModifyLimitOrderTxData(info: LimitOrderInfo): string;
+export declare function getDeleteLimitOrderTxData(vaultAddress: string): string;
+export declare function getTorosLimitOrder(pool: Pool, userAddress: string, vaultAddress: string): Promise<LimitOrderInfo | null>;
+export declare function hasActiveTorosLimitOrder(pool: Pool, userAddress: string, vaultAddress: string): Promise<boolean>;

package/dist/test/constants.d.ts

@@ -20,6 +20,7 @@ export declare const TEST_POOL: {
     base: string;
     ethereum: string;
     plasma: string;
+    hyperliquid: string;
 };
 export declare const CONTRACT_ADDRESS: {
     polygon: {
@@ -137,6 +138,10 @@ export declare const CONTRACT_ADDRESS: {
         USDT: string;
         USDE: string;
     };
+    hyperliquid: {
+        USDC: string;
+        WETH: string;
+    };
 };
 export declare const MAX_AMOUNT: ethers.BigNumber;
 export declare const USDC_BALANCEOF_SLOT: {
@@ -146,6 +151,7 @@ export declare const USDC_BALANCEOF_SLOT: {
     base: number;
     ethereum: number;
     plasma: number;
+    hyperliquid: number;
 };
 export declare const WETH_BALANCEOF_SLOT: {
     optimism: number;
@@ -154,4 +160,5 @@ export declare const WETH_BALANCEOF_SLOT: {
     base: number;
     ethereum: number;
     plasma: number;
+    hyperliquid: number;
 };

package/dist/test/wallet.d.ts

@@ -7,6 +7,7 @@ export declare const networkPortMap: {
     base: number;
     ethereum: number;
     plasma: number;
+    hyperliquid: number;
 };
 export declare const getWalletData: (network: Network, onFork?: boolean) => {
     wallet: ethers.Wallet;

package/dist/types.d.ts

@@ -6,7 +6,8 @@ export declare enum Network {
     ARBITRUM = "arbitrum",
     BASE = "base",
     ETHEREUM = "ethereum",
-    PLASMA = "plasma"
+    PLASMA = "plasma",
+    HYPERLIQUID = "hyperliquid"
 }
 export declare enum Dapp {
     SUSHISWAP = "sushiswap",
@@ -31,7 +32,8 @@ export declare enum Dapp {
     COMPOUNDV3 = "compoundV3",
     ODOS = "odos",
     PENDLE = "pendle",
-    KYBERSWAP = "kyberswap"
+    KYBERSWAP = "kyberswap",
+    HYPERLIQUID = "hyperliquid"
 }
 export declare enum Transaction {
     SWAP = "swapExactTokensForTokens",
@@ -97,3 +99,11 @@ export declare type SDKOptions = {
     onlyGetTxData?: boolean;
     useTraderAddressAsFrom?: boolean;
 } | boolean;
+export declare type LimitOrderInfo = {
+    amount: BigNumber;
+    stopLossPriceD18: BigNumber;
+    takeProfitPriceD18: BigNumber;
+    user: string;
+    pool: string;
+    pricingAsset: string;
+};