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

package/core-kit/hooks/pool/synthetixV3/use-pool-token-price-mutable.d.ts

@@ -0,0 +1,8 @@
+import type { Address, ChainId } from 'core-kit/types/web3.types';
+interface PoolTokenPriceParams {
+    address: Address;
+    chainId: ChainId;
+    disabled?: boolean;
+}
+export declare const usePoolTokenPriceMutable: ({ address, chainId, disabled, }: PoolTokenPriceParams) => string | undefined;
+export {};

package/core-kit/hooks/pool/synthetixV3/use-synthetix-v3-asset-balance.d.ts

@@ -0,0 +1,8 @@
+import type { Address, ChainId } from 'core-kit/types';
+interface UseSynthetixV3AssetBalanceVariables {
+    vaultAddress: Address;
+    chainId: ChainId;
+    disabled?: boolean;
+}
+export declare const useSynthetixV3AssetBalance: ({ vaultAddress, disabled, chainId, }: UseSynthetixV3AssetBalanceVariables) => string;
+export {};

package/core-kit/hooks/pool/synthetixV3/use-total-funds-value-mutable.d.ts

@@ -0,0 +1,8 @@
+import type { Address, ChainId } from 'core-kit/types';
+interface UseTotalFundsValueMutable {
+    vaultManagerLogicAddress: Address | undefined;
+    chainId: ChainId;
+    disabled?: boolean;
+}
+export declare const useTotalFundValueMutable: ({ vaultManagerLogicAddress, chainId, disabled, }: UseTotalFundsValueMutable) => string;
+export {};

package/core-kit/hooks/pool/use-check-whitelist.d.ts

@@ -0,0 +1,2 @@
+import type { PoolContractCallParams } from 'core-kit/types/web3.types';
+export declare const useCheckWhitelist: ({ address, chainId, }: PoolContractCallParams) => boolean;

package/core-kit/hooks/pool/use-contract-pool-composition.d.ts

@@ -0,0 +1,3 @@
+import type { PoolComposition } from 'core-kit/types/pool.types';
+import type { PoolContractCallParams } from 'core-kit/types/web3.types';
+export declare const useContractPoolComposition: ({ address, chainId, }: PoolContractCallParams) => PoolComposition[];

package/core-kit/hooks/pool/use-has-nested-vault-in-composition.d.ts

@@ -0,0 +1,64 @@
+import type { PoolContractCallParams } from 'core-kit/types';
+export declare const useHasNestedVaultInComposition: ({ address, chainId, }: PoolContractCallParams) => import("wagmi").UseReadContractsReturnType<{
+    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, boolean>;

package/core-kit/hooks/pool/use-invalidate-pool-contract-data.d.ts

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

package/core-kit/hooks/pool/use-manager-logic-address.d.ts

@@ -0,0 +1,2 @@
+import type { Address, PoolContractCallParams } from 'core-kit/types/web3.types';
+export declare const useManagerLogicAddress: ({ address, chainId, }: PoolContractCallParams) => Address | undefined;

package/core-kit/hooks/pool/use-pool-composition-with-fraction.d.ts

@@ -0,0 +1,14 @@
+import type { PoolComposition, PoolCompositionWithFraction } from 'core-kit/types/pool.types';
+import type { ChainId, PoolContractCallParams } from 'core-kit/types/web3.types';
+interface PoolCompositionParams {
+    composition: PoolComposition[];
+    vaultTokensAmount: string;
+    totalSupply: string;
+}
+type PoolCompositionWithFractionParams = PoolContractCallParams & {
+    vaultTokensAmount: string;
+    chainId: ChainId;
+};
+export declare const formatPoolComposition: ({ composition, vaultTokensAmount, totalSupply, }: PoolCompositionParams) => PoolCompositionWithFraction[];
+export declare const usePoolCompositionWithFraction: ({ address, vaultTokensAmount, chainId, }: PoolCompositionWithFractionParams) => PoolCompositionWithFraction[];
+export {};

package/core-kit/hooks/pool/use-pool-composition.d.ts

@@ -0,0 +1,3 @@
+import type { PoolComposition } from 'core-kit/types/pool.types';
+import type { PoolContractCallParams } from 'core-kit/types/web3.types';
+export declare const usePoolComposition: ({ address, chainId, }: PoolContractCallParams) => PoolComposition[];

package/core-kit/hooks/pool/use-pool-dynamic-contract-data.d.ts

@@ -0,0 +1,20 @@
+import type { Address, ChainId } from 'core-kit/types/web3.types';
+interface PoolDynamicContractDataParams {
+    address: Address;
+    chainId: ChainId;
+}
+export declare const usePoolDynamicContractData: ({ address, chainId, }: PoolDynamicContractDataParams) => {
+    totalValue: string | undefined;
+    isFetched: boolean;
+    userBalance?: string | undefined;
+    tokenPrice?: string | undefined;
+    getExitRemainingCooldown?: string | undefined;
+    totalSupply?: string | undefined;
+    isPrivateVault?: boolean | undefined;
+    performanceFee?: string | undefined;
+    streamingFee?: string | undefined;
+    entryFee?: string | undefined;
+    exitFee?: string | undefined;
+    managerAddress?: string | undefined;
+};
+export {};

package/core-kit/hooks/pool/use-pool-dynamic-exit-remaining-cooldown.d.ts

@@ -0,0 +1,276 @@
+import type { Address, ChainId } from 'core-kit/types/web3.types';
+interface PoolExitRemainingCooldownParams {
+    address: Address;
+    chainId: ChainId;
+    enabled: boolean;
+}
+export declare const REFETCH_INTERVALS: readonly [readonly [number, 5000], readonly [number, 10000], readonly [number, 20000]];
+export declare const getRefetchInterval: (cooldownMs: number) => false | 10000 | 20000 | 5000;
+export declare const usePoolDynamicExitRemainingCooldown: ({ address, chainId, enabled, }: PoolExitRemainingCooldownParams) => import("wagmi").UseReadContractReturnType<readonly [{
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "owner";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "spender";
+        readonly type: "address";
+    }];
+    readonly name: "allowance";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "spender";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "amount";
+        readonly type: "uint256";
+    }];
+    readonly name: "approve";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "account";
+        readonly type: "address";
+    }];
+    readonly name: "balanceOf";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "fundValue";
+        readonly type: "uint256";
+    }];
+    readonly name: "calculateAvailableManagerFee";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "fee";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "decimals";
+    readonly outputs: readonly [{
+        readonly internalType: "uint8";
+        readonly name: "";
+        readonly type: "uint8";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "_asset";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "_amount";
+        readonly type: "uint256";
+    }];
+    readonly name: "deposit";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "liquidityMinted";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "sender";
+        readonly type: "address";
+    }];
+    readonly name: "getExitRemainingCooldown";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "remaining";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "getFundSummary";
+    readonly outputs: readonly [{
+        readonly components: readonly [{
+            readonly internalType: "string";
+            readonly name: "name";
+            readonly type: "string";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "totalSupply";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "totalFundValue";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "address";
+            readonly name: "manager";
+            readonly type: "address";
+        }, {
+            readonly internalType: "string";
+            readonly name: "managerName";
+            readonly type: "string";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "creationTime";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "bool";
+            readonly name: "privatePool";
+            readonly type: "bool";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "performanceFeeNumerator";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "managerFeeNumerator";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "managerFeeDenominator";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "exitFeeNumerator";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "exitFeeDenominator";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "entryFeeNumerator";
+            readonly type: "uint256";
+        }];
+        readonly internalType: "struct PoolLogic.FundSummary";
+        readonly name: "";
+        readonly type: "tuple";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "mintManagerFee";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "name";
+    readonly outputs: readonly [{
+        readonly internalType: "string";
+        readonly name: "";
+        readonly type: "string";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "poolManagerLogic";
+    readonly outputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "symbol";
+    readonly outputs: readonly [{
+        readonly internalType: "string";
+        readonly name: "";
+        readonly type: "string";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "tokenPrice";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "price";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "totalSupply";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "_fundTokenAmount";
+        readonly type: "uint256";
+    }, {
+        readonly components: readonly [{
+            readonly internalType: "address";
+            readonly name: "supportedAsset";
+            readonly type: "address";
+        }, {
+            readonly internalType: "bytes";
+            readonly name: "withdrawData";
+            readonly type: "bytes";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "slippageTolerance";
+            readonly type: "uint256";
+        }];
+        readonly internalType: "struct IPoolLogic.ComplexAsset[]";
+        readonly name: "_complexAssetsData";
+        readonly type: "tuple[]";
+    }];
+    readonly name: "withdrawSafe";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "_fundTokenAmount";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "_slippageTolerance";
+        readonly type: "uint256";
+    }];
+    readonly name: "withdrawSafe";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}], "getExitRemainingCooldown", [`0x${string}`], number>;
+export {};

package/core-kit/hooks/pool/use-pool-fees.d.ts

@@ -0,0 +1,14 @@
+import type { Address, ChainId } from 'core-kit/types/web3.types';
+interface PoolFeesParams {
+    address: Address;
+    chainId: ChainId;
+}
+export declare const usePoolFees: ({ address, chainId }: PoolFeesParams) => {
+    performanceFee: string;
+    streamingFee: string;
+    entryFee: string;
+    exitFee: string;
+    withdrawalFeeNumber: number;
+    exitFeeNumber: number;
+};
+export {};

package/core-kit/hooks/pool/use-pool-manager-logic-data.d.ts

@@ -0,0 +1,16 @@
+import type { Address, ChainId } from 'core-kit/types/web3.types';
+export declare const normalizeFeeIncreaseInfo: (feeIncreaseInfo?: readonly bigint[] | undefined) => {
+    announcedPerformanceFee: string;
+    announcedStreamingFee: string;
+    announcedEntryFee: string;
+    announcedExitFee: string;
+    announcedTimestamp: string;
+};
+export declare const usePoolManagerLogicData: (poolAddress: Address, chainId: ChainId) => {
+    minDepositUSD: number;
+    announcedPerformanceFee: string;
+    announcedStreamingFee: string;
+    announcedEntryFee: string;
+    announcedExitFee: string;
+    announcedTimestamp: string;
+};

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

@@ -0,0 +1,9 @@
+import type { Address, ChainId } from 'core-kit/types/web3.types';
+interface PoolTokenPriceParams {
+    address: Address;
+    chainId: ChainId;
+    formatter?: (tokenPrice: bigint) => string;
+    disabled?: boolean;
+}
+export declare const usePoolTokenPrice: ({ address, chainId, formatter, disabled, }: PoolTokenPriceParams) => string;
+export {};

package/core-kit/hooks/pool/use-vault-vested-points.d.ts

@@ -0,0 +1,73 @@
+import type { Address } from 'core-kit/types';
+interface UseFmedVestedPointsProps {
+    enabled?: boolean;
+    address: Address;
+}
+export declare const useVaultVestedPoints: ({ enabled, address, }: UseFmedVestedPointsProps) => import("wagmi").UseReadContractsReturnType<{
+    address: `0x${string}`;
+    chainId: 8453;
+    abi: readonly [{
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "account";
+            readonly type: "address";
+        }];
+        readonly name: "balanceOf";
+        readonly outputs: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "";
+            readonly type: "uint256";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "account";
+            readonly type: "address";
+        }];
+        readonly name: "getUnlockTax";
+        readonly outputs: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "unlockTax";
+            readonly type: "uint256";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "account";
+            readonly type: "address";
+        }];
+        readonly name: "lockedBalance";
+        readonly outputs: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "amount";
+            readonly type: "uint256";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "account";
+            readonly type: "address";
+        }];
+        readonly name: "unlockTime";
+        readonly outputs: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "unlockTime";
+            readonly type: "uint256";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }];
+    functionName: string;
+    args: string[];
+}[], true, {
+    lockedVaultPointsBalance: bigint | undefined;
+    unlockTaxInPercents: bigint | undefined;
+    unlockTime: bigint | undefined;
+}>;
+export {};

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

@@ -0,0 +1 @@
+export { useReferralProgram } from './use-referral-program';

package/core-kit/hooks/referral/use-referral-program.d.ts

@@ -0,0 +1,2 @@
+import type { UseReferralProgramProps } from 'core-kit/types';
+export declare const useReferralProgram: ({ vaultAddress, userAddress, query, logEvent, tagInvestorByReferrer, }: UseReferralProgramProps) => void;

package/core-kit/hooks/state/action.d.ts

@@ -0,0 +1,25 @@
+export declare const useSetPoolAddress: () => (payload: `0x${string}`) => void;
+export declare const useUpdateSendTokenInput: () => (payload: Partial<import("../../types").DynamicTradingToken>) => void;
+export declare const useUpdateReceiveTokenInput: () => (payload: Partial<import("../../types").DynamicTradingToken>) => void;
+export declare const useUpdateTradingSettings: () => (payload: Partial<{
+    slippage: number | "auto";
+    minSlippage?: number | undefined;
+    isInfiniteAllowance: boolean;
+    isMultiAssetWithdrawalEnabled: boolean;
+    isMaxSlippageLoading: boolean;
+}>) => void;
+export declare const useSetTradingType: () => (payload: import("../../types").TradingPanelType) => void;
+export declare const useUpdateTradingModal: () => (payload: Partial<import("../../types").TradingPanelStateModal>) => void;
+export declare const useUpdatePoolFallbackData: () => (payload: import("../../types").PoolFallbackData) => void;
+export declare const useOnTransactionError: () => ((error: Error, action: import("../../types").TransactionAction | undefined, chainId?: number | undefined, txHash?: `0x${string}` | undefined) => void) | undefined;
+export declare const useOnTradingSettleError: () => ((error: Error) => void) | undefined;
+export declare const useOnTransactionSuccess: () => ((data: import("viem").TransactionReceipt, action: import("../../types").TransactionAction | undefined, link?: string | undefined) => void) | undefined;
+export declare const useOnTransactionEstimationError: () => ((error: import("../../models").EstimationError, address: `0x${string}`, chainId: number, account?: `0x${string}` | undefined) => void) | undefined;
+export declare const useOnTokenSelector: () => ((payload: import("../../types").TokenSelectorPayload) => void) | undefined;
+export declare const useTradingPanelLogger: () => ((eventName: string, payload?: Record<string, unknown> | undefined) => void) | undefined;
+export declare const useOnSimulateTransaction: () => ((params: import("../../types").SimulateTransactionParams) => Promise<import("../../types").SimulateTransactionResponse | null>) | undefined;
+export declare const useGetSwapData: () => (args: {
+    signal: AbortSignal;
+    variables: import("../../types").SwapDataRequest;
+}) => Promise<import("../../types").SwapDataResponse | null>;
+export declare const useUpdatePoolConfig: () => (payload: Record<`0x${string}`, Pick<import("../../types").PoolConfig, "maintenance" | "maintenanceDeposits" | "maintenanceWithdrawals">>) => void;

package/core-kit/hooks/state/context.d.ts

@@ -0,0 +1,2 @@
+export declare const useTradingPanelState: () => import("../../types").TradingPanelState;
+export declare const useTradingPanelActions: () => import("../../types").TradingPanelActionsState;

package/core-kit/hooks/state/default-data.d.ts

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

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

@@ -0,0 +1,9 @@
+export { useSetTradingType, useUpdateTradingModal, useUpdateSendTokenInput, useSetPoolAddress, useUpdateReceiveTokenInput, useUpdateTradingSettings, useOnTransactionError, useOnTransactionSuccess, useOnTransactionEstimationError, useOnTokenSelector, useTradingPanelLogger, useOnSimulateTransaction, useUpdatePoolFallbackData, useOnTradingSettleError, useGetSwapData, useUpdatePoolConfig, } from './action';
+export { useTradingPanelPoolAddress, useTradingPanelPoolConfig, useTradingPanelPoolConfigs, useTradingPanelPoolFallbackData, useIsPoolAddress, } from './pool';
+export { useSendTokenInput, useReceiveTokenInput } from './input';
+export { useTradingPanelSettings } from './settings';
+export { useTradingPanelModal } from './modal';
+export { useTradingPanelType, useIsDepositTradingPanelType } from './type';
+export { useTradingPanelTransactions } from './transaction';
+export { useTradingPanelActions, useTradingPanelState } from './context';
+export { useTradingPanelDefaultChainId } from './default-data';

package/core-kit/hooks/state/input.d.ts

@@ -0,0 +1,13 @@
+import type { TradingPanelActionsState, TradingPanelState } from 'core-kit/types/state.types';
+export declare const useTradingPanelInput: () => {
+    sendToken: import("../../types").DynamicTradingToken;
+    receiveToken: import("../../types").DynamicTradingToken;
+};
+export declare const useSendTokenInput: () => [
+    TradingPanelState['input']['sendToken'],
+    TradingPanelActionsState['updateSendTokenInput']
+];
+export declare const useReceiveTokenInput: () => [
+    TradingPanelState['input']['receiveToken'],
+    TradingPanelActionsState['updateReceiveTokenInput']
+];

package/core-kit/hooks/state/modal.d.ts

@@ -0,0 +1,5 @@
+import type { TradingPanelActionsState, TradingPanelStateModal } from 'core-kit/types/state.types';
+export declare const useTradingPanelModal: () => [
+    TradingPanelStateModal,
+    TradingPanelActionsState['updateTradingModal']
+];

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

@@ -0,0 +1,14 @@
+import type { PoolConfig } from 'core-kit/types/config.types';
+import type { TradingPanelActionsState, TradingPanelState } from 'core-kit/types/state.types';
+import type { Address } from 'core-kit/types/web3.types';
+export declare const useTradingPanelPoolAddress: () => [
+    TradingPanelState['poolAddress'],
+    TradingPanelActionsState['setPoolAddress']
+];
+export declare const useTradingPanelPoolConfig: () => PoolConfig;
+export declare const useTradingPanelPoolConfigs: () => PoolConfig[];
+export declare const useIsPoolAddress: (address: Address) => boolean;
+export declare const useTradingPanelPoolFallbackData: () => [
+    TradingPanelState['poolFallbackData'],
+    TradingPanelActionsState['updatePoolFallbackData']
+];

package/core-kit/hooks/state/settings.d.ts

@@ -0,0 +1,5 @@
+import type { TradingPanelActionsState, TradingPanelState } from 'core-kit/types/state.types';
+export declare const useTradingPanelSettings: () => [
+    TradingPanelState['settings'],
+    TradingPanelActionsState['updateTradingSettings']
+];

package/core-kit/hooks/state/transaction.d.ts

@@ -0,0 +1,5 @@
+import type { TradingPanelActionsState, TradingPanelState } from 'core-kit/types/state.types';
+export declare const useTradingPanelTransactions: () => [
+    TradingPanelState['transactions'],
+    TradingPanelActionsState['updateTransactions']
+];

package/core-kit/hooks/state/type.d.ts

@@ -0,0 +1,6 @@
+import type { TradingPanelActionsState, TradingPanelState } from 'core-kit/types/state.types';
+export declare const useTradingPanelType: () => [
+    TradingPanelState['type'],
+    TradingPanelActionsState['setTradingType']
+];
+export declare const useIsDepositTradingPanelType: () => boolean;