@dhedge/trading-widget 3.5.8-canary.2 → 3.6.0

package/core-kit/hooks/trading/use-exchange-rate.d.ts

@@ -0,0 +1,5 @@
+export declare function getExchange(sendAssetSymbol: string, receiveAssetSymbol: string, sendAssetInputBalance: string, receiveAssetInputBalance: string): string;
+export declare const useExchangeRate: () => {
+    value: string;
+    isLoading: boolean;
+};

package/core-kit/hooks/trading/use-handle-trade.d.ts

@@ -0,0 +1,6 @@
+import type { ContractActionFunc } from 'core-kit/types/web3.types';
+export declare const useHandleTrade: (trade: ContractActionFunc) => {
+    disabled: boolean;
+    label: string;
+    handleTrade: () => Promise<void>;
+};

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

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

package/core-kit/hooks/trading/use-is-transaction-loading.d.ts

@@ -0,0 +1,2 @@
+import type { TransactionAction } from 'core-kit/types';
+export declare const useIsTransactionLoading: (transaction: TransactionAction) => boolean;

package/core-kit/hooks/trading/use-raw-asset-price.d.ts

@@ -0,0 +1,8 @@
+import type { ChainId, PoolContractCallParams } from 'core-kit/types/web3.types';
+type AssetPriceParams = PoolContractCallParams & {
+    chainId: ChainId;
+    disabled?: boolean;
+    refetchInterval?: number;
+};
+export declare const useRawAssetPrice: ({ address, chainId, refetchInterval, disabled, }: AssetPriceParams) => bigint | undefined;
+export {};

package/core-kit/hooks/trading/use-send-token-debounced-value.d.ts

@@ -0,0 +1,8 @@
+type UseSendTokenDebouncedValueProps = {
+    extendedDebounceTime?: boolean;
+} | undefined;
+export declare const useSendTokenDebouncedValue: (props?: UseSendTokenDebouncedValueProps) => {
+    debouncedSendTokenValue: string;
+    isDebouncing: boolean;
+};
+export {};

package/core-kit/hooks/trading/use-swap-data-query.d.ts

@@ -0,0 +1,6 @@
+import { type UseQueryOptions } from '@tanstack/react-query';
+import type { SwapDataRequest, SwapDataResponse } from 'core-kit/types';
+export declare const useSwapDataQuery: (variables: Omit<SwapDataRequest, 'fromAddress'>, options?: Omit<UseQueryOptions<SwapDataResponse | null, Error, SwapDataResponse | null, [
+    string,
+    SwapDataRequest
+]>, 'queryKey' | 'queryFn'>) => import("@tanstack/react-query/build/legacy/types").UseQueryResult<SwapDataResponse | null, Error>;

package/core-kit/hooks/trading/use-swaps-data-query.d.ts

@@ -0,0 +1,13 @@
+import { type UseQueryOptions } from '@tanstack/react-query';
+import type { Address } from 'viem';
+import { useGetSwapData } from 'core-kit/hooks/state';
+import type { SwapDataRequest, SwapDataResponse } from 'core-kit/types';
+export declare const fetchSwapsData: ({ assets, getSwapData, signal, }: {
+    assets: Omit<SwapDataRequest, 'fromAddress'>[];
+    getSwapData: ReturnType<typeof useGetSwapData>;
+    signal: AbortSignal;
+}) => Promise<Record<Address, SwapDataResponse>>;
+export declare const useSwapsDataQuery: (assets: Omit<SwapDataRequest, 'fromAddress'>[], options?: Omit<UseQueryOptions<Record<Address, SwapDataResponse | null>, Error, Record<Address, SwapDataResponse | null>, [
+    string,
+    Omit<SwapDataRequest, 'fromAddress'>[]
+]>, 'queryKey' | 'queryFn'>) => import("@tanstack/react-query/build/legacy/types").UseQueryResult<Record<`0x${string}`, SwapDataResponse | null>, Error>;

package/core-kit/hooks/trading/use-trading-result-handling.d.ts

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

package/core-kit/hooks/trading/use-trading-settle-handler.d.ts

@@ -0,0 +1,3 @@
+import type { PendingTransaction } from 'core-kit/types/trading-panel.types';
+import type { UseWriteContractParameters } from 'core-kit/types/web3.types';
+export declare const useTradingSettleHandler: (action: PendingTransaction['action']) => Required<Required<UseWriteContractParameters>['mutation']>['onSettled'];

package/core-kit/hooks/trading/withdraw-v2/complete-step/index.d.ts

@@ -0,0 +1,10 @@
+export { useCompleteWithdrawExpectedAmount } from './use-complete-withdraw-expected-amount';
+export { useCompleteWithdrawTransaction } from './use-complete-withdraw-transaction';
+export { useCompleteWithdrawTotalUsdValue } from './use-complete-withdraw-total-usd-value';
+export { useIsCompleteWithdrawStep } from './use-is-complete-withdraw-step';
+export { useCompleteWithdrawTrackedAssets } from './use-complete-withdraw-tracked-assets';
+export { useCompleteWithdrawSwapData } from './use-complete-withdraw-swap-data';
+export { useCompleteWithdrawQuote } from './use-complete-withdraw-quote';
+export { useHandleCompleteWithdraw } from './use-handle-complete-withdraw';
+export { useCompleteWithdrawReceiveDiff } from './use-complete-withdraw-receive-diff';
+export { useHasSwappableAssets } from './use-has-swappable-assets';

package/core-kit/hooks/trading/withdraw-v2/complete-step/use-complete-withdraw-expected-amount.d.ts

@@ -0,0 +1,4 @@
+export declare const useCompleteWithdrawExpectedAmount: () => {
+    expectedReceiveAmount: string;
+    minExpectedReceiveAmount: string;
+};

package/core-kit/hooks/trading/withdraw-v2/complete-step/use-complete-withdraw-quote.d.ts

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

package/core-kit/hooks/trading/withdraw-v2/complete-step/use-complete-withdraw-receive-diff.d.ts

@@ -0,0 +1 @@
+export declare const useCompleteWithdrawReceiveDiff: () => number;

package/core-kit/hooks/trading/withdraw-v2/complete-step/use-complete-withdraw-swap-data.d.ts

@@ -0,0 +1 @@
+export declare const useCompleteWithdrawSwapData: () => import("@tanstack/react-query/build/legacy/types").UseQueryResult<Record<`0x${string}`, import("../../../../types").SwapDataResponse | null>, Error>;

package/core-kit/hooks/trading/withdraw-v2/complete-step/use-complete-withdraw-total-usd-value.d.ts

@@ -0,0 +1 @@
+export declare const useCompleteWithdrawTotalUsdValue: () => number;

package/core-kit/hooks/trading/withdraw-v2/complete-step/use-complete-withdraw-tracked-assets.d.ts

@@ -0,0 +1,210 @@
+export declare const useCompleteWithdrawTrackedAssets: () => import("wagmi").UseReadContractsReturnType<({
+    address: `0x${string}`;
+    abi: readonly [{
+        readonly type: "event";
+        readonly name: "Approval";
+        readonly inputs: readonly [{
+            readonly indexed: true;
+            readonly name: "owner";
+            readonly type: "address";
+        }, {
+            readonly indexed: true;
+            readonly name: "spender";
+            readonly type: "address";
+        }, {
+            readonly indexed: false;
+            readonly name: "value";
+            readonly type: "uint256";
+        }];
+    }, {
+        readonly type: "event";
+        readonly name: "Transfer";
+        readonly inputs: readonly [{
+            readonly indexed: true;
+            readonly name: "from";
+            readonly type: "address";
+        }, {
+            readonly indexed: true;
+            readonly name: "to";
+            readonly type: "address";
+        }, {
+            readonly indexed: false;
+            readonly name: "value";
+            readonly type: "uint256";
+        }];
+    }, {
+        readonly type: "function";
+        readonly name: "allowance";
+        readonly stateMutability: "view";
+        readonly inputs: readonly [{
+            readonly name: "owner";
+            readonly type: "address";
+        }, {
+            readonly name: "spender";
+            readonly type: "address";
+        }];
+        readonly outputs: readonly [{
+            readonly type: "uint256";
+        }];
+    }, {
+        readonly type: "function";
+        readonly name: "approve";
+        readonly stateMutability: "nonpayable";
+        readonly inputs: readonly [{
+            readonly name: "spender";
+            readonly type: "address";
+        }, {
+            readonly name: "amount";
+            readonly type: "uint256";
+        }];
+        readonly outputs: readonly [{
+            readonly type: "bool";
+        }];
+    }, {
+        readonly type: "function";
+        readonly name: "balanceOf";
+        readonly stateMutability: "view";
+        readonly inputs: readonly [{
+            readonly name: "account";
+            readonly type: "address";
+        }];
+        readonly outputs: readonly [{
+            readonly type: "uint256";
+        }];
+    }, {
+        readonly type: "function";
+        readonly name: "decimals";
+        readonly stateMutability: "view";
+        readonly inputs: readonly [];
+        readonly outputs: readonly [{
+            readonly type: "uint8";
+        }];
+    }, {
+        readonly type: "function";
+        readonly name: "name";
+        readonly stateMutability: "view";
+        readonly inputs: readonly [];
+        readonly outputs: readonly [{
+            readonly type: "string";
+        }];
+    }, {
+        readonly type: "function";
+        readonly name: "symbol";
+        readonly stateMutability: "view";
+        readonly inputs: readonly [];
+        readonly outputs: readonly [{
+            readonly type: "string";
+        }];
+    }, {
+        readonly type: "function";
+        readonly name: "totalSupply";
+        readonly stateMutability: "view";
+        readonly inputs: readonly [];
+        readonly outputs: readonly [{
+            readonly type: "uint256";
+        }];
+    }, {
+        readonly type: "function";
+        readonly name: "transfer";
+        readonly stateMutability: "nonpayable";
+        readonly inputs: readonly [{
+            readonly name: "recipient";
+            readonly type: "address";
+        }, {
+            readonly name: "amount";
+            readonly type: "uint256";
+        }];
+        readonly outputs: readonly [{
+            readonly type: "bool";
+        }];
+    }, {
+        readonly type: "function";
+        readonly name: "transferFrom";
+        readonly stateMutability: "nonpayable";
+        readonly inputs: readonly [{
+            readonly name: "sender";
+            readonly type: "address";
+        }, {
+            readonly name: "recipient";
+            readonly type: "address";
+        }, {
+            readonly name: "amount";
+            readonly type: "uint256";
+        }];
+        readonly outputs: readonly [{
+            readonly type: "bool";
+        }];
+    }];
+    functionName: string;
+    chainId: number;
+    args: never[];
+} | {
+    address: `0x${string}`;
+    abi: readonly [{
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "asset";
+            readonly type: "address";
+        }];
+        readonly name: "getAssetPrice";
+        readonly outputs: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "price";
+            readonly type: "uint256";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "";
+            readonly type: "address";
+        }];
+        readonly name: "isPool";
+        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: "extContract";
+            readonly type: "address";
+        }];
+        readonly name: "getAssetGuard";
+        readonly outputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "guard";
+            readonly type: "address";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "extContract";
+            readonly type: "address";
+        }];
+        readonly name: "getContractGuard";
+        readonly outputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "guard";
+            readonly type: "address";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }];
+    functionName: string;
+    chainId: number;
+    args: `0x${string}`[];
+})[], true, {
+    address: `0x${string}`;
+    symbol: string;
+    decimals: number;
+    rawBalance: bigint;
+    balance: number;
+    price: number;
+}[]>;

package/core-kit/hooks/trading/withdraw-v2/complete-step/use-complete-withdraw-transaction.d.ts

@@ -0,0 +1,6 @@
+import type { ContractActionFunc } from 'core-kit/types/web3.types';
+interface UseWithdrawSwapTransactionProps {
+    isClaim?: boolean;
+}
+export declare const useCompleteWithdrawTransaction: ({ isClaim, }?: UseWithdrawSwapTransactionProps | undefined) => ContractActionFunc;
+export {};

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

@@ -0,0 +1,11 @@
+import type { ContractActionFunc } from 'core-kit/types/web3.types';
+interface UseHandleWithdrawSwapProps {
+    withdraw: ContractActionFunc;
+    isClaim?: boolean;
+}
+export declare const useHandleCompleteWithdraw: ({ withdraw, isClaim, }: UseHandleWithdrawSwapProps) => {
+    disabled: boolean;
+    label: string;
+    handleTrade: () => Promise<void>;
+};
+export {};

package/core-kit/hooks/trading/withdraw-v2/complete-step/use-has-swappable-assets.d.ts

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

package/core-kit/hooks/trading/withdraw-v2/complete-step/use-is-complete-withdraw-step.d.ts

@@ -0,0 +1,4 @@
+export declare const useIsCompleteWithdrawStep: () => {
+    isCompleteWithdrawStep: boolean;
+    isFetching: boolean;
+};

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

@@ -0,0 +1,4 @@
+export { useWithdrawTypeHandler } from './use-withdraw-type-handler';
+export { useMinWithdrawSlippage } from './use-min-withdraw-slippage';
+export { useAppliedWithdrawSlippage } from './use-applied-withdraw-slippage';
+export { useWithdrawalVaultAddress } from './use-withdrawal-vault-address';

package/core-kit/hooks/trading/withdraw-v2/init-step/index.d.ts

@@ -0,0 +1,6 @@
+export { useIsMultiAssetWithdraw } from './use-is-multi-asset-withdraw';
+export { useInitWithdrawAllowance } from './use-init-withdraw-allowance';
+export { useInitWithdrawTransaction } from './use-init-withdraw-transaction';
+export { useInitWithdrawTransactionArgumentsForSimulationOnly, useGetInitWithdrawTransactionArguments, } from './use-get-init-withdraw-transaction-arguments';
+export { useInitWithdrawEstimatedReceiveAssets } from './use-init-withdraw-estimated-receive-assets';
+export { useIsUnrollAndClaimTransaction } from './use-is-unroll-and-claim-transaction';

package/core-kit/hooks/trading/withdraw-v2/init-step/use-fetch-aave-swap-params.d.ts

@@ -0,0 +1,6 @@
+import type { CalculateSwapDataParamsResponse, PoolConfig } from 'core-kit/types';
+export interface FetchAaveSwapParamsProps {
+    withdrawAmountD18: bigint;
+    slippage: number;
+}
+export declare const useFetchAaveSwapParams: ({ address, chainId, }: Pick<PoolConfig, 'address' | 'chainId'>) => ({ withdrawAmountD18, slippage, }: FetchAaveSwapParamsProps) => Promise<CalculateSwapDataParamsResponse | undefined>;

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

@@ -0,0 +1,5 @@
+import type { CalculateSwapDataParamsResponse, PoolConfig } from 'core-kit/types';
+export declare const useFetchInitWithdrawAaveSwapData: ({ chainId, }: Pick<PoolConfig, 'chainId'>) => ({ swapParams, slippage, }: {
+    swapParams: CalculateSwapDataParamsResponse | undefined;
+    slippage: number;
+}) => Promise<Record<`0x${string}`, import("core-kit/types").SwapDataResponse>>;

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

@@ -0,0 +1,6 @@
+import type { FetchAaveSwapParamsProps } from 'core-kit/hooks/trading/withdraw-v2/init-step/use-fetch-aave-swap-params';
+import type { ComplexWithdrawAssetData, PoolConfig } from 'core-kit/types';
+export declare const useFetchInitWithdrawComplexAssetData: ({ address, chainId, }: Pick<PoolConfig, 'address' | 'chainId'>) => ({ withdrawAmountD18, vaultTokenPrice, slippage, disabled, }: FetchAaveSwapParamsProps & {
+    disabled?: boolean | undefined;
+    vaultTokenPrice: string;
+}) => Promise<ComplexWithdrawAssetData[]>;

package/core-kit/hooks/trading/withdraw-v2/init-step/use-get-init-withdraw-transaction-arguments.d.ts

@@ -0,0 +1,10 @@
+interface UseGetInitWithdrawTransactionArguments {
+    debounceTime?: number;
+}
+export declare const useGetInitWithdrawTransactionArguments: () => () => Promise<(bigint | `0x${string}` | import("../../../../types").ComplexWithdrawAssetData[])[]>;
+export declare const useInitWithdrawTransactionArgumentsForSimulationOnly: ({ debounceTime, }?: UseGetInitWithdrawTransactionArguments) => (bigint | `0x${string}` | {
+    supportedAsset: `0x${string}`;
+    withdrawData: string;
+    slippageTolerance: bigint;
+}[])[];
+export {};

package/core-kit/hooks/trading/withdraw-v2/init-step/use-init-withdraw-allowance.d.ts

@@ -0,0 +1,4 @@
+export declare const useInitWithdrawAllowance: () => {
+    canSpend: boolean;
+    approve: () => Promise<void>;
+};

package/core-kit/hooks/trading/withdraw-v2/init-step/use-init-withdraw-estimated-receive-assets.d.ts

@@ -0,0 +1,210 @@
+export declare const useInitWithdrawEstimatedReceiveAssets: () => import("wagmi").UseReadContractsReturnType<({
+    address: `0x${string}`;
+    abi: readonly [{
+        readonly type: "event";
+        readonly name: "Approval";
+        readonly inputs: readonly [{
+            readonly indexed: true;
+            readonly name: "owner";
+            readonly type: "address";
+        }, {
+            readonly indexed: true;
+            readonly name: "spender";
+            readonly type: "address";
+        }, {
+            readonly indexed: false;
+            readonly name: "value";
+            readonly type: "uint256";
+        }];
+    }, {
+        readonly type: "event";
+        readonly name: "Transfer";
+        readonly inputs: readonly [{
+            readonly indexed: true;
+            readonly name: "from";
+            readonly type: "address";
+        }, {
+            readonly indexed: true;
+            readonly name: "to";
+            readonly type: "address";
+        }, {
+            readonly indexed: false;
+            readonly name: "value";
+            readonly type: "uint256";
+        }];
+    }, {
+        readonly type: "function";
+        readonly name: "allowance";
+        readonly stateMutability: "view";
+        readonly inputs: readonly [{
+            readonly name: "owner";
+            readonly type: "address";
+        }, {
+            readonly name: "spender";
+            readonly type: "address";
+        }];
+        readonly outputs: readonly [{
+            readonly type: "uint256";
+        }];
+    }, {
+        readonly type: "function";
+        readonly name: "approve";
+        readonly stateMutability: "nonpayable";
+        readonly inputs: readonly [{
+            readonly name: "spender";
+            readonly type: "address";
+        }, {
+            readonly name: "amount";
+            readonly type: "uint256";
+        }];
+        readonly outputs: readonly [{
+            readonly type: "bool";
+        }];
+    }, {
+        readonly type: "function";
+        readonly name: "balanceOf";
+        readonly stateMutability: "view";
+        readonly inputs: readonly [{
+            readonly name: "account";
+            readonly type: "address";
+        }];
+        readonly outputs: readonly [{
+            readonly type: "uint256";
+        }];
+    }, {
+        readonly type: "function";
+        readonly name: "decimals";
+        readonly stateMutability: "view";
+        readonly inputs: readonly [];
+        readonly outputs: readonly [{
+            readonly type: "uint8";
+        }];
+    }, {
+        readonly type: "function";
+        readonly name: "name";
+        readonly stateMutability: "view";
+        readonly inputs: readonly [];
+        readonly outputs: readonly [{
+            readonly type: "string";
+        }];
+    }, {
+        readonly type: "function";
+        readonly name: "symbol";
+        readonly stateMutability: "view";
+        readonly inputs: readonly [];
+        readonly outputs: readonly [{
+            readonly type: "string";
+        }];
+    }, {
+        readonly type: "function";
+        readonly name: "totalSupply";
+        readonly stateMutability: "view";
+        readonly inputs: readonly [];
+        readonly outputs: readonly [{
+            readonly type: "uint256";
+        }];
+    }, {
+        readonly type: "function";
+        readonly name: "transfer";
+        readonly stateMutability: "nonpayable";
+        readonly inputs: readonly [{
+            readonly name: "recipient";
+            readonly type: "address";
+        }, {
+            readonly name: "amount";
+            readonly type: "uint256";
+        }];
+        readonly outputs: readonly [{
+            readonly type: "bool";
+        }];
+    }, {
+        readonly type: "function";
+        readonly name: "transferFrom";
+        readonly stateMutability: "nonpayable";
+        readonly inputs: readonly [{
+            readonly name: "sender";
+            readonly type: "address";
+        }, {
+            readonly name: "recipient";
+            readonly type: "address";
+        }, {
+            readonly name: "amount";
+            readonly type: "uint256";
+        }];
+        readonly outputs: readonly [{
+            readonly type: "bool";
+        }];
+    }];
+    functionName: string;
+    chainId: number;
+    args: never[];
+} | {
+    address: `0x${string}`;
+    abi: readonly [{
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "asset";
+            readonly type: "address";
+        }];
+        readonly name: "getAssetPrice";
+        readonly outputs: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "price";
+            readonly type: "uint256";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "";
+            readonly type: "address";
+        }];
+        readonly name: "isPool";
+        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: "extContract";
+            readonly type: "address";
+        }];
+        readonly name: "getAssetGuard";
+        readonly outputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "guard";
+            readonly type: "address";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "extContract";
+            readonly type: "address";
+        }];
+        readonly name: "getContractGuard";
+        readonly outputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "guard";
+            readonly type: "address";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }];
+    functionName: string;
+    chainId: number;
+    args: `0x${string}`[];
+})[], true, {
+    address: `0x${string}`;
+    symbol: string;
+    decimals: number;
+    rawBalance: bigint;
+    balance: number;
+    price: number;
+}[]>;

package/core-kit/hooks/trading/withdraw-v2/init-step/use-init-withdraw-quote.d.ts

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

package/core-kit/hooks/trading/withdraw-v2/init-step/use-init-withdraw-transaction.d.ts

@@ -0,0 +1,6 @@
+import type { TransactionAction } from 'core-kit/types';
+import type { ContractActionFunc } from 'core-kit/types/web3.types';
+export declare const useInitWithdrawTransaction: () => {
+    withdraw: ContractActionFunc;
+    action: TransactionAction;
+};

package/core-kit/hooks/trading/withdraw-v2/init-step/use-is-multi-asset-withdraw.d.ts

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

package/core-kit/hooks/trading/withdraw-v2/init-step/use-is-offchain-aave-withdraw-supported.d.ts

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

package/core-kit/hooks/trading/withdraw-v2/init-step/use-is-unroll-and-claim-transaction.d.ts

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

package/core-kit/hooks/trading/withdraw-v2/use-applied-withdraw-slippage.d.ts

@@ -0,0 +1 @@
+export declare const useAppliedWithdrawSlippage: () => number;

package/core-kit/hooks/trading/withdraw-v2/use-min-withdraw-slippage.d.ts

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