@dhedge/trading-widget 6.0.6 → 6.2.0-canary.0

package/core-kit/abi/index.d.ts

@@ -7,6 +7,8 @@ export { PoolManagerLogicAbi } from '../abi/pool-manager-logic';
 export { RewardDistributionAbi } from '../abi/reward-distribution';
 export { FlatcoinPointsModuleAbi } from '../abi/flatcoin-points-module';
 export { EasySwapperV2Abi } from '../abi/easy-swapper-v2';
+export { HyperliquidWithdrawalManagerAbi } from '../abi/hyperliquid-withdrawal-manager';
 export { LimitOrderAbi } from '../abi/limit-order';
 export { OndoPriceOracleAbi } from '../abi/ondo-price-oracle';
 export { OndoGMTokenAssetGuardAbi, OndoWithdrawDataAbiItem, } from '../abi/ondo-gm-token-asset-guard';
+export { DytmOfficeAssetGuardAbi, DytmOfficeAbi, OndoGMSwapAbi, UnwindPlanAbiItem, } from '../abi/dytm-office-asset-guard';

package/core-kit/abi/ondo-gm-token-asset-guard.d.ts

@@ -20,6 +20,26 @@ export declare const OndoGMTokenAssetGuardAbi: readonly [{
     }];
     readonly stateMutability: "nonpayable";
     readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "ondoGMSwap";
+    readonly outputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "usdc";
+    readonly outputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
 }];
 export declare const OndoWithdrawDataAbiItem: readonly [{
     readonly type: "tuple";

package/core-kit/abi/ondo-price-oracle.d.ts

@@ -1,4 +1,22 @@
 export declare const OndoPriceOracleAbi: readonly [{
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "_gmToken";
+        readonly type: "address";
+    }];
+    readonly name: "getPrice";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "price";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "updatedAt";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
     readonly inputs: readonly [{
         readonly components: readonly [{
             readonly internalType: "uint256";

package/core-kit/const/config.d.ts

@@ -1,5 +1,5 @@
 import type { Address, ChainId } from '../types/web3.types';
-export type ContractId = 'factory' | 'rewardDistribution' | 'aaveLendingPoolV2' | 'aaveLendingPoolV3' | 'poolManagerLogic' | 'erc20' | 'poolLogic' | 'flatcoinPointsModule' | 'easySwapperV2' | 'limitOrder' | 'ondoPriceOracle';
+export type ContractId = 'factory' | 'rewardDistribution' | 'aaveLendingPoolV2' | 'aaveLendingPoolV3' | 'poolManagerLogic' | 'erc20' | 'poolLogic' | 'flatcoinPointsModule' | 'easySwapperV2' | 'limitOrder' | 'ondoPriceOracle' | 'hyperliquidWithdrawalManager';
 type ContractsAddressesMap = Readonly<Record<ChainId, {
     [id in ContractId]?: Address;
 }>>;

package/core-kit/const/hyperliquid.d.ts

@@ -0,0 +1,8 @@
+export declare const HYPERLIQUID_WITHDRAWAL_POLLING_INTERVAL = 3000;
+export declare const HYPERLIQUID_WITHDRAWAL_TIMEOUT_MS = 300000;
+export declare const HYPERLIQUID_INFO_API_URL = "https://api.hyperliquid.xyz/info";
+export declare enum HyperliquidWithdrawalState {
+    NONE = 0,
+    REDUCED = 1,
+    BRIDGED = 2
+}

package/core-kit/const/index.d.ts

@@ -11,6 +11,7 @@ export * from '../const/links';
 export * from '../const/flat-money';
 export * from '../const/trading';
 export * from '../const/gmx';
+export * from '../const/hyperliquid';
 export * from '../const/derive';
 export * from '../const/storage';
 export * from '../const/geoblocking';

package/core-kit/const/logger.d.ts

@@ -18,6 +18,10 @@ export declare const TRADING_PANEL_LOG_EVENT: {
     LIMIT_ORDER_WITHDRAW: string;
     LIMIT_ORDER_WITHDRAW_DELETE: string;
     UPDATE_ONDO_PRICES: string;
+    HYPERLIQUID_ANNOUNCE_WITHDRAW: string;
+    HYPERLIQUID_BRIDGE_WITHDRAW: string;
+    HYPERLIQUID_SETTLE_WITHDRAW: string;
+    HYPERLIQUID_CANCEL_WITHDRAW: string;
 };
 export declare const LOG_EVENT_BY_TRANSACTION_ACTION_MAP: Record<TransactionAction, string[]>;
 /**

package/core-kit/const/trading.d.ts

@@ -3,6 +3,9 @@ export declare const DEFAULT_ONDO_WITHDRAWAL_CONTRACT_SLIPPAGE = 500n;
 export declare const TRANSACTION_SETTLE_DELAY: Record<ChainId, number>;
 export declare const ONDO_PRICES_RABBY_SETTLE_DELAY = 6000;
 export declare const ONDO_PRICE_FRESHNESS_WINDOW_MS = 40000;
+export declare const ONDO_PRICE_MAX_DEVIATION_PERCENT = 0.5;
+export declare const ONDO_PRICES_FETCH_TIMEOUT_MS = 6000;
+export declare const ONDO_PRICE_CHECK_TIMEOUT_MS = 8000;
 export declare const EASY_SWAPPER_V2_DEPOSIT_METHODS: {
     DEPOSIT: "deposit";
     DEPOSIT_CUSTOM: "depositWithCustomCooldown";

package/core-kit/hooks/pool/index.d.ts

@@ -17,3 +17,7 @@ export { useVaultSupplyCap } from '../../hooks/pool/use-vault-supply-cap';
 export { useIsDepositBlocked } from '../../hooks/pool/use-is-deposit-blocked';
 export { useVaultContractData } from '../../hooks/pool/use-vault-contract-data';
 export { useOndoVaultData, type OndoVaultAsset, type OndoVaultData, } from '../../hooks/pool/use-ondo-vault-data';
+export { useOndoPriceDeviation, type OndoPriceDeviationResult, } from '../../hooks/pool/use-ondo-price-deviation';
+export { useDytmVaultData, type DytmVaultData, } from '../../hooks/pool/use-dytm-vault-data';
+export { usePoolAssetsWithType, type PoolAssetWithType, type PoolAssetsWithType, } from '../../hooks/pool/use-pool-assets-with-type';
+export { useAssetGuardAddress, useFetchAssetGuardAddress, } from '../../hooks/pool/use-asset-guard-address';

package/core-kit/hooks/pool/use-asset-guard-address.d.ts

@@ -0,0 +1,8 @@
+import type { Address, ChainId } from '../../types';
+interface UseAssetGuardAddressParams {
+    asset: Address | undefined;
+    chainId: ChainId;
+}
+export declare const useAssetGuardAddress: ({ asset, chainId, }: UseAssetGuardAddressParams) => Address | undefined;
+export declare const useFetchAssetGuardAddress: (chainId: ChainId) => (asset: Address) => Promise<Address | undefined>;
+export {};

package/core-kit/hooks/pool/use-dytm-vault-data.d.ts

@@ -0,0 +1,8 @@
+import type { Address, PoolContractCallParams } from '../../types';
+export interface DytmVaultData {
+    dytmOfficeAddress: Address | undefined;
+    assetGuardAddress: Address | undefined;
+    hasAssets: boolean;
+    isReady: boolean;
+}
+export declare const useDytmVaultData: ({ address, chainId, }: PoolContractCallParams) => DytmVaultData;

package/core-kit/hooks/pool/use-ondo-price-deviation.d.ts

@@ -0,0 +1,10 @@
+import type { PoolContractCallParams } from '../../types';
+export interface OndoPriceDeviationResult {
+    needsPriceUpdate: boolean | undefined;
+    isChecking: boolean;
+}
+interface UseOndoPriceDeviationParams extends PoolContractCallParams {
+    enabled?: boolean;
+}
+export declare const useOndoPriceDeviation: ({ address, chainId, enabled, }: UseOndoPriceDeviationParams) => OndoPriceDeviationResult;
+export {};

package/core-kit/hooks/pool/use-ondo-vault-data.d.ts

@@ -7,5 +7,6 @@ export interface OndoVaultData {
     assets: OndoVaultAsset[];
     assetGuardAddress: Address | undefined;
     hasAssets: boolean;
+    isReady: boolean;
 }
 export declare const useOndoVaultData: ({ address, chainId, }: PoolContractCallParams) => OndoVaultData;

package/core-kit/hooks/pool/use-pool-assets-with-type.d.ts

@@ -0,0 +1,14 @@
+import type { PoolComposition } from '../../types/pool.types';
+import type { PoolContractCallParams } from '../../types/web3.types';
+export interface PoolAssetWithType extends PoolComposition {
+    assetType: number | undefined;
+}
+export interface PoolAssetsWithType {
+    assets: PoolAssetWithType[];
+    isReady: boolean;
+}
+interface UsePoolAssetsWithTypeParams extends PoolContractCallParams {
+    enabled?: boolean;
+}
+export declare const usePoolAssetsWithType: ({ address, chainId, enabled, }: UsePoolAssetsWithTypeParams) => PoolAssetsWithType;
+export {};

package/core-kit/hooks/trading/hyperliquid-withdraw/index.d.ts

@@ -0,0 +1,12 @@
+export * from './use-handle-hyperliquid-withdraw-step';
+export * from './use-hyperliquid-announce-fallback-check';
+export * from './use-hyperliquid-announce-transaction';
+export * from './use-hyperliquid-cancel-availability';
+export * from './use-hyperliquid-manager-transaction';
+export * from './use-hyperliquid-pending-withdrawal';
+export * from './use-purge-hyperliquid-pending-transactions';
+export * from './use-hyperliquid-withdraw-expected-amount';
+export * from './use-hyperliquid-withdrawal-allowance';
+export * from './use-hyperliquid-withdrawal-asset-ids';
+export * from './use-is-hyperliquid-withdraw';
+export * from './use-is-hyperliquid-withdrawal-vault';

package/core-kit/hooks/trading/hyperliquid-withdraw/use-handle-hyperliquid-withdraw-step.d.ts

@@ -0,0 +1,12 @@
+import type { TransactionAction } from '../../../types';
+import type { ContractActionFunc } from '../../../types/web3.types';
+export interface HyperliquidWithdrawStepResult {
+    submitted: boolean;
+    errorMessage?: string;
+}
+interface UseHandleHyperliquidWithdrawStepProps {
+    trade: ContractActionFunc;
+    action: TransactionAction;
+}
+export declare const useHandleHyperliquidWithdrawStep: ({ trade, action, }: UseHandleHyperliquidWithdrawStepProps) => () => Promise<HyperliquidWithdrawStepResult>;
+export {};

package/core-kit/hooks/trading/hyperliquid-withdraw/use-hyperliquid-announce-transaction.d.ts

@@ -0,0 +1,9 @@
+import { type OnTradingSettleErrorCallback } from '../../../hooks/trading';
+import type { ContractActionFunc } from '../../../types/web3.types';
+interface UseHyperliquidAnnounceTransactionParams {
+    onErrorCallback?: OnTradingSettleErrorCallback;
+}
+export declare const useHyperliquidAnnounceTransaction: ({ onErrorCallback, }?: UseHyperliquidAnnounceTransactionParams | undefined) => {
+    announce: ContractActionFunc;
+};
+export {};

package/core-kit/hooks/trading/hyperliquid-withdraw/use-hyperliquid-cancel-availability.d.ts

@@ -0,0 +1,5 @@
+export declare const formatCancelCountdown: (totalSeconds: number) => string;
+export declare const useHyperliquidCancelAvailability: (announcedAt: bigint | undefined) => {
+    canCancel: boolean;
+    cancelRemainingSeconds: number;
+};

package/core-kit/hooks/trading/hyperliquid-withdraw/use-hyperliquid-manager-transaction.d.ts

@@ -0,0 +1,8 @@
+import { type OnTradingSettleErrorCallback } from '../../../hooks/trading';
+import type { TransactionAction } from '../../../types';
+import type { ContractActionFunc } from '../../../types/web3.types';
+export declare const useHyperliquidManagerTransaction: ({ functionName, action, onErrorCallback, }: {
+    functionName: 'bridge' | 'settle' | 'cancel';
+    action: TransactionAction;
+    onErrorCallback?: OnTradingSettleErrorCallback | undefined;
+}) => ContractActionFunc;

package/core-kit/hooks/trading/hyperliquid-withdraw/use-hyperliquid-pending-withdrawal.d.ts

@@ -0,0 +1,313 @@
+import type { UseReadContractReturnType } from 'wagmi';
+import { HyperliquidWithdrawalState } from '../../../const';
+export interface HyperliquidPendingWithdrawal {
+    amount: bigint;
+    announcedAt: bigint;
+    announcedBlock: bigint;
+    bridgedBlock: bigint;
+    state: HyperliquidWithdrawalState;
+    hasPending: boolean;
+}
+export declare const useHyperliquidPendingWithdrawal: ({ watch, }?: {
+    watch?: boolean | undefined;
+}) => UseReadContractReturnType<readonly [{
+    readonly inputs: readonly [];
+    readonly name: "HyperliquidWithdrawalManager__ZeroAmount";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "HyperliquidWithdrawalManager__WithdrawalAlreadyPending";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "HyperliquidWithdrawalManager__InvalidPool";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "HyperliquidWithdrawalManager__PoolHasNoHLIntegration";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "enum IHyperliquidWithdrawalManager.WithdrawalState";
+        readonly name: "current";
+        readonly type: "uint8";
+    }, {
+        readonly internalType: "enum IHyperliquidWithdrawalManager.WithdrawalState";
+        readonly name: "expected";
+        readonly type: "uint8";
+    }];
+    readonly name: "HyperliquidWithdrawalManager__InvalidState";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint32";
+        readonly name: "asset";
+        readonly type: "uint32";
+    }];
+    readonly name: "HyperliquidWithdrawalManager__NoPositionForAsset";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint32";
+        readonly name: "asset";
+        readonly type: "uint32";
+    }];
+    readonly name: "HyperliquidWithdrawalManager__NoSpotBalanceForAsset";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint32";
+        readonly name: "asset";
+        readonly type: "uint32";
+    }];
+    readonly name: "HyperliquidWithdrawalManager__SpotAssetNotSupported";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "HyperliquidWithdrawalManager__NoPendingWithdrawal";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "HyperliquidWithdrawalManager__TimeoutNotReached";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "HyperliquidWithdrawalManager__NothingToBridge";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "HyperliquidWithdrawalManager__NoSpotUsdcFreed";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "HyperliquidWithdrawalManager__TooEarly";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "HyperliquidWithdrawalManager__FullWithdrawalNotSupported";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "HyperliquidWithdrawalManager__UnreducedPerpPosition";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "HyperliquidWithdrawalManager__NoBridgeNeeded";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "HyperliquidWithdrawalManager__UnsortedAssetIds";
+    readonly type: "error";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "user";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "pool";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "amount";
+        readonly type: "uint256";
+    }];
+    readonly name: "WithdrawalAnnounced";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "user";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "pool";
+        readonly type: "address";
+    }];
+    readonly name: "WithdrawalBridged";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "user";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "pool";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "amount";
+        readonly type: "uint256";
+    }];
+    readonly name: "WithdrawalSettled";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "user";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "pool";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "amount";
+        readonly type: "uint256";
+    }];
+    readonly name: "WithdrawalCancelled";
+    readonly type: "event";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "pool";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "tokenAmount";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint32[]";
+        readonly name: "perpAssetIds";
+        readonly type: "uint32[]";
+    }, {
+        readonly internalType: "uint32[]";
+        readonly name: "spotAssetIds";
+        readonly type: "uint32[]";
+    }];
+    readonly name: "announceAndReduce";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "pool";
+        readonly type: "address";
+    }];
+    readonly name: "bridge";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "pool";
+        readonly type: "address";
+    }];
+    readonly name: "settle";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "pool";
+        readonly type: "address";
+    }];
+    readonly name: "cancel";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "user";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "pool";
+        readonly type: "address";
+    }];
+    readonly name: "pendingWithdrawals";
+    readonly outputs: readonly [{
+        readonly components: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "amount";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "announcedAt";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "announcedBlock";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "bridgedBlock";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "enum IHyperliquidWithdrawalManager.WithdrawalState";
+            readonly name: "state";
+            readonly type: "uint8";
+        }, {
+            readonly internalType: "uint32[]";
+            readonly name: "spotAssetIds";
+            readonly type: "uint32[]";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "reservedBridge";
+            readonly type: "uint256";
+        }];
+        readonly internalType: "struct IHyperliquidWithdrawalManager.PendingWithdrawal";
+        readonly name: "";
+        readonly type: "tuple";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "pool";
+        readonly type: "address";
+    }];
+    readonly name: "hasPendingWithdrawal";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "pool";
+        readonly type: "address";
+    }];
+    readonly name: "totalPendingTokens";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "WITHDRAWAL_TIMEOUT";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}], "pendingWithdrawals", readonly [user: `0x${string}`, pool: `0x${string}`], HyperliquidPendingWithdrawal>;

package/core-kit/hooks/trading/hyperliquid-withdraw/use-hyperliquid-withdraw-expected-amount.d.ts

@@ -0,0 +1,4 @@
+export declare const useHyperliquidWithdrawExpectedAmount: () => {
+    expectedAmount: string;
+    symbol: string;
+};

package/core-kit/hooks/trading/hyperliquid-withdraw/use-hyperliquid-withdrawal-allowance.d.ts

@@ -0,0 +1,10 @@
+import type { OnTradingSettleErrorCallback } from '../../../hooks/trading';
+interface UseHyperliquidWithdrawalAllowanceParams {
+    onErrorCallback?: OnTradingSettleErrorCallback;
+}
+export declare const useHyperliquidWithdrawalAllowance: ({ onErrorCallback, }?: UseHyperliquidWithdrawalAllowanceParams | undefined) => {
+    canSpend: boolean;
+    approve: () => Promise<void>;
+    isCanSpendFetching: boolean;
+};
+export {};

package/core-kit/hooks/trading/hyperliquid-withdraw/use-is-hyperliquid-withdraw.d.ts

@@ -0,0 +1,4 @@
+export declare const useIsHyperliquidWithdraw: () => {
+    isHyperliquidWithdraw: boolean;
+    isFullWithdrawalNotSupported: boolean;
+};

package/core-kit/hooks/trading/hyperliquid-withdraw/use-is-hyperliquid-withdrawal-vault.d.ts

@@ -0,0 +1 @@
+export declare const useIsHyperliquidWithdrawalVault: () => boolean;

package/core-kit/hooks/trading/hyperliquid-withdraw/use-purge-hyperliquid-pending-transactions.d.ts

@@ -0,0 +1 @@
+export declare const usePurgeHyperliquidPendingTransactions: () => () => void;

package/core-kit/hooks/trading/withdraw-v2/init-step/use-fetch-dytm-withdraw-asset-data.d.ts

@@ -0,0 +1,3 @@
+import type { PoolConfig } from '../../../../types';
+import type { WithdrawDataOverride } from '../../../../utils';
+export declare const useFetchDytmWithdrawAssetData: ({ address, chainId, }: Pick<PoolConfig, 'address' | 'chainId'>) => (withdrawAmountD18: bigint) => Promise<Map<string, WithdrawDataOverride>>;

package/core-kit/hooks/trading/withdraw-v2/init-step/use-fetch-ondo-withdraw-asset-data.d.ts

@@ -1,2 +1,3 @@
-import type { Hex, PoolConfig } from '../../../../types';
-export declare const useFetchOndoWithdrawAssetData: ({ address, chainId, }: Pick<PoolConfig, 'address' | 'chainId'>) => (withdrawAmountD18: bigint) => Promise<Map<string, Hex>>;
+import type { PoolConfig } from '../../../../types';
+import type { WithdrawDataOverride } from '../../../../utils';
+export declare const useFetchOndoWithdrawAssetData: ({ address, chainId, }: Pick<PoolConfig, 'address' | 'chainId'>) => (withdrawAmountD18: bigint) => Promise<Map<string, WithdrawDataOverride>>;

package/core-kit/services/ondo/api.d.ts

@@ -1,4 +1,4 @@
-import type { OndoAttestationApiResponse, OndoPriceUpdateApiResponse } from '../../services/ondo/types';
+import type { OndoAttestationApiResponse, OndoLatestPricesApiResponse, OndoPriceUpdateApiResponse } from '../../services/ondo/types';
 import type { Address, ChainId } from '../../types';
 interface CreateOndoAttestationsApiResponse {
     attestations: OndoAttestationApiResponse[];
@@ -7,6 +7,10 @@ export declare const fetchOndoPriceUpdateData: ({ chainId, addresses, }: {
     chainId: ChainId;
     addresses: Address[];
 }) => Promise<OndoPriceUpdateApiResponse>;
+export declare const fetchOndoPrices: ({ chainId, addresses, }: {
+    chainId: ChainId;
+    addresses: Address[];
+}) => Promise<OndoLatestPricesApiResponse>;
 export declare const fetchCreateOndoAttestations: ({ chainId, items, }: {
     chainId: ChainId;
     items: {

package/core-kit/services/ondo/index.d.ts

@@ -1,3 +1,3 @@
 export { configureOndoServices, getOndoAppCheckToken, getOndoConfig, prewarmOndoAppCheck, } from '../../services/ondo/firebase-app-check';
-export { fetchCreateOndoAttestations, fetchOndoPriceUpdateData, } from '../../services/ondo/api';
-export type { OndoApiUrls, OndoAttestationApiResponse, OndoFirebaseConfig, OndoIntegrationConfig, OndoPriceUpdateApiQuote, OndoPriceUpdateApiResponse, OndoRecaptchaConfig, } from '../../services/ondo/types';
+export { fetchCreateOndoAttestations, fetchOndoPriceUpdateData, fetchOndoPrices, } from '../../services/ondo/api';
+export type { OndoApiUrls, OndoAttestationApiResponse, OndoFirebaseConfig, OndoIntegrationConfig, OndoLatestPriceApiEntry, OndoLatestPricesApiResponse, OndoPriceUpdateApiQuote, OndoPriceUpdateApiResponse, OndoRecaptchaConfig, } from '../../services/ondo/types';

package/core-kit/services/ondo/types.d.ts

@@ -40,6 +40,15 @@ export interface OndoRecaptchaConfig {
 export interface OndoApiUrls {
     priceUpdateUrl: string;
     createAttestationsUrl: string;
+    getPricesUrl?: string;
+}
+export interface OndoLatestPriceApiEntry {
+    symbol: string;
+    address?: string;
+    price: string;
+}
+export interface OndoLatestPricesApiResponse {
+    prices: OndoLatestPriceApiEntry[];
 }
 export interface OndoIntegrationConfig {
     firebase: OndoFirebaseConfig;

package/core-kit/types/trading-panel.types.d.ts

@@ -22,7 +22,7 @@ type RemoveTransaction = {
 } & Partial<PendingTransaction>;
 export type UpdateTransactionsArguments = AddTransaction | UpdateTransaction | RemoveTransaction;
 export type TradingPanelType = 'deposit' | 'withdraw';
-export type TransactionAction = 'deposit' | 'multi_withdraw' | 'single_withdraw' | 'approve' | 'swap' | 'claim' | 'single_withdraw_and_claim' | 'create_limit_sell_order' | 'create_limit_buy_order' | 'limit_order_withdraw' | 'delete_limit_order_withdraw' | 'update_ondo_prices';
+export type TransactionAction = 'deposit' | 'multi_withdraw' | 'single_withdraw' | 'approve' | 'swap' | 'claim' | 'single_withdraw_and_claim' | 'create_limit_sell_order' | 'create_limit_buy_order' | 'limit_order_withdraw' | 'delete_limit_order_withdraw' | 'update_ondo_prices' | 'hyperliquid_announce_withdraw' | 'hyperliquid_bridge_withdraw' | 'hyperliquid_settle_withdraw' | 'hyperliquid_cancel_withdraw';
 export type SwapEntity = 'token' | 'pool';
 export interface TokenSelectorPayload {
     isOpen: boolean;