@dhedge/trading-widget 1.2.10 → 2.0.0

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

@@ -7,7 +7,6 @@ export declare const usePoolFees: ({ address, chainId }: PoolFeesParams) => {
     performanceFee: string;
     streamingFee: string;
     entryFee: string;
-    hasPoolEntryFee: boolean;
     exitFee: string;
     exitFeeNumber: number;
 };

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

@@ -12,7 +12,6 @@ export declare const useSetTradingType: () => (payload: import("../../types").Tr
 export declare const useUpdateTradingMeta: () => (payload: Partial<{
     approvingStatus?: "pending" | "success" | undefined;
 }>) => void;
-export declare const useUpdateEntryFee: () => (payload: Partial<Record<import("../../types").DepositMethodName, number>>) => 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;
@@ -22,3 +21,7 @@ export declare const useOnTransactionEstimationError: () => ((error: import("../
 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>;

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

@@ -1,8 +1,8 @@
-export { useSetTradingType, useUpdateTradingMeta, useUpdateTradingModal, useUpdateSendTokenInput, useSetPoolAddress, useUpdateReceiveTokenInput, useUpdateTradingSettings, useUpdateEntryFee, useOnTransactionError, useOnTransactionSuccess, useOnTransactionEstimationError, useOnTokenSelector, useTradingPanelLogger, useOnSimulateTransaction, useUpdatePoolFallbackData, useOnTradingSettleError, } from './action';
-export { useTradingPanelPoolAddress, useTradingPanelPoolConfig, useTradingPanelDepositMethod, useTradingPanelPoolConfigs, useTradingPanelPoolFallbackData, useIsPoolAddress, } from './pool';
+export { useSetTradingType, useUpdateTradingMeta, useUpdateTradingModal, useUpdateSendTokenInput, useSetPoolAddress, useUpdateReceiveTokenInput, useUpdateTradingSettings, useOnTransactionError, useOnTransactionSuccess, useOnTransactionEstimationError, useOnTokenSelector, useTradingPanelLogger, useOnSimulateTransaction, useUpdatePoolFallbackData, useOnTradingSettleError, useGetSwapData, } from './action';
+export { useTradingPanelPoolAddress, useTradingPanelPoolConfig, useTradingPanelPoolConfigs, useTradingPanelPoolFallbackData, useIsPoolAddress, } from './pool';
 export { useSendTokenInput, useReceiveTokenInput } from './input';
 export { useTradingPanelSettings } from './settings';
-export { useTradingPanelMeta, useTradingPanelApprovingStatus, useTradingPanelEntryFee, useTradingPanelLockTime, } from './meta';
+export { useTradingPanelMeta, useTradingPanelApprovingStatus } from './meta';
 export { useTradingPanelModal } from './modal';
 export { useTradingPanelType, useIsDepositTradingPanelType } from './type';
 export { useTradingPanelTransactions } from './transaction';

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

@@ -4,5 +4,3 @@ export declare const useTradingPanelMeta: () => [
     TradingPanelActionsState['updateTradingMeta']
 ];
 export declare const useTradingPanelApprovingStatus: () => ["pending" | "success" | undefined, (approvingStatus: TradingPanelState['meta']['approvingStatus']) => void];
-export declare const useTradingPanelEntryFee: () => [number, (entryFeeSlice: Partial<TradingPanelState['entryFee']>) => void];
-export declare const useTradingPanelLockTime: () => string;

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

@@ -1,6 +1,5 @@
 import type { PoolConfig } from 'core-kit/types/config.types';
 import type { TradingPanelActionsState, TradingPanelState } from 'core-kit/types/state.types';
-import type { DepositMethodName } from 'core-kit/types/trading-panel.types';
 import type { Address } from 'core-kit/types/web3.types';
 export declare const useTradingPanelPoolAddress: () => [
     TradingPanelState['poolAddress'],
@@ -9,7 +8,6 @@ export declare const useTradingPanelPoolAddress: () => [
 export declare const useTradingPanelPoolConfig: () => PoolConfig;
 export declare const useTradingPanelPoolConfigs: () => PoolConfig[];
 export declare const useIsPoolAddress: (address: Address) => boolean;
-export declare const useTradingPanelDepositMethod: () => [DepositMethodName, (payload: Pick<PoolConfig, 'address'> & Pick<PoolConfig['depositParams'], 'method'>) => void];
 export declare const useTradingPanelPoolFallbackData: () => [
     TradingPanelState['poolFallbackData'],
     TradingPanelActionsState['updatePoolFallbackData']

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

@@ -0,0 +1,16 @@
+export { useDeposit } from './use-deposit';
+export { useDepositAllowance } from './use-deposit-allowance';
+export { useDepositQuote } from './use-deposit-quote';
+export { useDepositQuoteContractRead } from './use-deposit-quote-contract-read';
+export { useDepositSlippage } from './use-deposit-slippage';
+export { useHandlePoolDepositData } from './use-handle-pool-deposit-data';
+export { useIsVaultDepositLocked } from './use-is-vault-deposit-locked';
+export { useSwapDataBasedOnSendToken } from './use-swap-data-based-on-send-token';
+export { useVaultDepositParams } from './use-vault-deposit-params';
+export { useVaultDepositTokenAmount } from './use-vault-deposit-token-amount';
+export { useVaultDepositTokens } from './use-vault-deposit-tokens';
+export { useVaultDepositTransactionArguments } from './use-vault-deposit-transaction-arguments';
+export { useDepositLockTime } from './use-deposit-lock-time';
+export { useDepositPriceDiff } from './use-deposit-price-diff';
+export { useIsDepositWithSwapTransaction } from './use-is-deposit-with-swap-transaction';
+export { useMinVaultTokensReceivedAmount } from './use-min-vault-tokens-received-amount';

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

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

package/core-kit/hooks/trading/deposit-v2/use-deposit-lock-time.d.ts

@@ -0,0 +1 @@
+export declare const useDepositLockTime: () => string;

package/core-kit/hooks/trading/deposit-v2/use-deposit-price-diff.d.ts

@@ -0,0 +1,5 @@
+type UseDepositPriceDiffProps = {
+    includesEntryFee?: boolean;
+} | undefined;
+export declare const useDepositPriceDiff: (props?: UseDepositPriceDiffProps) => number;
+export {};

package/core-kit/hooks/trading/deposit-v2/use-deposit-quote-contract-read.d.ts

@@ -0,0 +1,414 @@
+import type { PoolConfig } from 'core-kit/types/config.types';
+export declare const useDepositQuoteContractRead: ({ address, chainId, }: Pick<PoolConfig, 'address' | 'chainId'>) => import("wagmi").UseReadContractReturnType<readonly [{
+    readonly inputs: readonly [];
+    readonly name: "customCooldown";
+    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: "";
+        readonly type: "address";
+    }];
+    readonly name: "customCooldownDepositsWhitelist";
+    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: "_dHedgeVault";
+        readonly type: "address";
+    }, {
+        readonly internalType: "contract IERC20";
+        readonly name: "_vaultDepositToken";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "_depositAmount";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "_expectedAmountReceived";
+        readonly type: "uint256";
+    }];
+    readonly name: "deposit";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "_dHedgeVault";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "_vaultDepositToken";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "_depositAmount";
+        readonly type: "uint256";
+    }];
+    readonly name: "depositQuote";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "expectedAmountReceived";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "_dHedgeVault";
+        readonly type: "address";
+    }, {
+        readonly internalType: "contract IERC20";
+        readonly name: "_vaultDepositToken";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "_depositAmount";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "_expectedAmountReceived";
+        readonly type: "uint256";
+    }];
+    readonly name: "depositWithCustomCooldown";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "_dHedgeVault";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "_amountIn";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "_slippageTolerance";
+        readonly type: "uint256";
+    }];
+    readonly name: "initWithdrawal";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "_dHedgeVault";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "_expectedAmountReceived";
+        readonly type: "uint256";
+    }];
+    readonly name: "nativeDeposit";
+    readonly outputs: readonly [];
+    readonly stateMutability: "payable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "_dHedgeVault";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "_expectedAmountReceived";
+        readonly type: "uint256";
+    }];
+    readonly name: "nativeDepositWithCustomCooldown";
+    readonly outputs: readonly [];
+    readonly stateMutability: "payable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "swapper";
+    readonly outputs: readonly [{
+        readonly internalType: "contract ISwapper";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "weth";
+    readonly outputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly name: "withdrawalContracts";
+    readonly outputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "wrappedNativeToken";
+    readonly outputs: readonly [{
+        readonly internalType: "contract IWETH";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "_dHedgeVault";
+        readonly type: "address";
+    }, {
+        readonly components: readonly [{
+            readonly components: readonly [{
+                readonly internalType: "contract IERC20";
+                readonly name: "token";
+                readonly type: "address";
+            }, {
+                readonly internalType: "uint256";
+                readonly name: "amount";
+                readonly type: "uint256";
+            }, {
+                readonly components: readonly [{
+                    readonly internalType: "bytes32";
+                    readonly name: "routerKey";
+                    readonly type: "bytes32";
+                }, {
+                    readonly internalType: "bytes";
+                    readonly name: "swapData";
+                    readonly type: "bytes";
+                }];
+                readonly internalType: "struct ISwapper.AggregatorData";
+                readonly name: "aggregatorData";
+                readonly type: "tuple";
+            }];
+            readonly internalType: "struct ISwapper.SrcTokenSwapDetails";
+            readonly name: "srcData";
+            readonly type: "tuple";
+        }, {
+            readonly components: readonly [{
+                readonly internalType: "contract IERC20";
+                readonly name: "destToken";
+                readonly type: "address";
+            }, {
+                readonly internalType: "uint256";
+                readonly name: "minDestAmount";
+                readonly type: "uint256";
+            }];
+            readonly internalType: "struct ISwapper.DestData";
+            readonly name: "destData";
+            readonly type: "tuple";
+        }];
+        readonly internalType: "struct EasySwapperV2.SingleInSingleOutData";
+        readonly name: "_swapData";
+        readonly type: "tuple";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "_expectedAmountReceived";
+        readonly type: "uint256";
+    }];
+    readonly name: "zapDeposit";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "_dHedgeVault";
+        readonly type: "address";
+    }, {
+        readonly components: readonly [{
+            readonly components: readonly [{
+                readonly internalType: "contract IERC20";
+                readonly name: "token";
+                readonly type: "address";
+            }, {
+                readonly internalType: "uint256";
+                readonly name: "amount";
+                readonly type: "uint256";
+            }, {
+                readonly components: readonly [{
+                    readonly internalType: "bytes32";
+                    readonly name: "routerKey";
+                    readonly type: "bytes32";
+                }, {
+                    readonly internalType: "bytes";
+                    readonly name: "swapData";
+                    readonly type: "bytes";
+                }];
+                readonly internalType: "struct ISwapper.AggregatorData";
+                readonly name: "aggregatorData";
+                readonly type: "tuple";
+            }];
+            readonly internalType: "struct ISwapper.SrcTokenSwapDetails";
+            readonly name: "srcData";
+            readonly type: "tuple";
+        }, {
+            readonly components: readonly [{
+                readonly internalType: "contract IERC20";
+                readonly name: "destToken";
+                readonly type: "address";
+            }, {
+                readonly internalType: "uint256";
+                readonly name: "minDestAmount";
+                readonly type: "uint256";
+            }];
+            readonly internalType: "struct ISwapper.DestData";
+            readonly name: "destData";
+            readonly type: "tuple";
+        }];
+        readonly internalType: "struct EasySwapperV2.SingleInSingleOutData";
+        readonly name: "_swapData";
+        readonly type: "tuple";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "_expectedAmountReceived";
+        readonly type: "uint256";
+    }];
+    readonly name: "zapDepositWithCustomCooldown";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "_dHedgeVault";
+        readonly type: "address";
+    }, {
+        readonly components: readonly [{
+            readonly components: readonly [{
+                readonly internalType: "contract IERC20";
+                readonly name: "token";
+                readonly type: "address";
+            }, {
+                readonly internalType: "uint256";
+                readonly name: "amount";
+                readonly type: "uint256";
+            }, {
+                readonly components: readonly [{
+                    readonly internalType: "bytes32";
+                    readonly name: "routerKey";
+                    readonly type: "bytes32";
+                }, {
+                    readonly internalType: "bytes";
+                    readonly name: "swapData";
+                    readonly type: "bytes";
+                }];
+                readonly internalType: "struct ISwapper.AggregatorData";
+                readonly name: "aggregatorData";
+                readonly type: "tuple";
+            }];
+            readonly internalType: "struct ISwapper.SrcTokenSwapDetails";
+            readonly name: "srcData";
+            readonly type: "tuple";
+        }, {
+            readonly components: readonly [{
+                readonly internalType: "contract IERC20";
+                readonly name: "destToken";
+                readonly type: "address";
+            }, {
+                readonly internalType: "uint256";
+                readonly name: "minDestAmount";
+                readonly type: "uint256";
+            }];
+            readonly internalType: "struct ISwapper.DestData";
+            readonly name: "destData";
+            readonly type: "tuple";
+        }];
+        readonly internalType: "struct EasySwapperV2.SingleInSingleOutData";
+        readonly name: "_swapData";
+        readonly type: "tuple";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "_expectedAmountReceived";
+        readonly type: "uint256";
+    }];
+    readonly name: "zapNativeDeposit";
+    readonly outputs: readonly [];
+    readonly stateMutability: "payable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "_dHedgeVault";
+        readonly type: "address";
+    }, {
+        readonly components: readonly [{
+            readonly components: readonly [{
+                readonly internalType: "contract IERC20";
+                readonly name: "token";
+                readonly type: "address";
+            }, {
+                readonly internalType: "uint256";
+                readonly name: "amount";
+                readonly type: "uint256";
+            }, {
+                readonly components: readonly [{
+                    readonly internalType: "bytes32";
+                    readonly name: "routerKey";
+                    readonly type: "bytes32";
+                }, {
+                    readonly internalType: "bytes";
+                    readonly name: "swapData";
+                    readonly type: "bytes";
+                }];
+                readonly internalType: "struct ISwapper.AggregatorData";
+                readonly name: "aggregatorData";
+                readonly type: "tuple";
+            }];
+            readonly internalType: "struct ISwapper.SrcTokenSwapDetails";
+            readonly name: "srcData";
+            readonly type: "tuple";
+        }, {
+            readonly components: readonly [{
+                readonly internalType: "contract IERC20";
+                readonly name: "destToken";
+                readonly type: "address";
+            }, {
+                readonly internalType: "uint256";
+                readonly name: "minDestAmount";
+                readonly type: "uint256";
+            }];
+            readonly internalType: "struct ISwapper.DestData";
+            readonly name: "destData";
+            readonly type: "tuple";
+        }];
+        readonly internalType: "struct EasySwapperV2.SingleInSingleOutData";
+        readonly name: "_swapData";
+        readonly type: "tuple";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "_expectedAmountReceived";
+        readonly type: "uint256";
+    }];
+    readonly name: "zapNativeDepositWithCustomCooldown";
+    readonly outputs: readonly [];
+    readonly stateMutability: "payable";
+    readonly type: "function";
+}], "depositQuote", [`0x${string}`, `0x${string}`, bigint], bigint>;

package/core-kit/hooks/trading/deposit-v2/use-deposit-quote.d.ts

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

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

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

package/core-kit/hooks/trading/deposit-v2/use-is-custom-cooldown-deposit.d.ts

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

package/core-kit/hooks/trading/deposit-v2/use-is-deposit-with-swap-transaction.d.ts

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

package/core-kit/hooks/trading/deposit-v2/use-is-vault-deposit-locked.d.ts

@@ -0,0 +1,4 @@
+export declare const useIsVaultDepositLocked: () => {
+    isVaultDepositLocked: boolean | undefined;
+    isAccountWhitelisted: boolean;
+};

package/core-kit/hooks/trading/deposit-v2/use-min-vault-tokens-received-amount.d.ts

@@ -0,0 +1 @@
+export declare const useMinVaultTokensReceivedAmount: () => string;

package/core-kit/hooks/trading/deposit-v2/use-swap-data-based-on-send-token.d.ts

@@ -0,0 +1 @@
+export declare const useSwapDataBasedOnSendToken: () => import("@tanstack/react-query/build/legacy/types").UseQueryResult<import("../../../types").SwapDataResponse | null, Error>;

package/core-kit/hooks/trading/deposit-v2/use-vault-deposit-params.d.ts

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

package/core-kit/hooks/trading/deposit-v2/use-vault-deposit-token-amount.d.ts

@@ -0,0 +1 @@
+export declare const useVaultDepositTokenAmount: () => string;

package/core-kit/hooks/trading/{deposit/use-pool-deposit-tokens.d.ts → deposit-v2/use-vault-deposit-tokens.d.ts}

@@ -1,2 +1,2 @@
 import type { TradingToken } from 'core-kit/types/trading-panel.types';
-export declare const usePoolDepositTokens: () => TradingToken[];
+export declare const useVaultDepositTokens: () => TradingToken[];

package/core-kit/hooks/trading/deposit-v2/use-vault-deposit-transaction-arguments.d.ts

@@ -0,0 +1,2 @@
+import type { VaultDepositParams } from 'core-kit/types';
+export declare const useVaultDepositTransactionArguments: ({ depositMethod, vaultDepositTokenAddress, }: VaultDepositParams) => unknown[];

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

@@ -1,7 +1,5 @@
 export { useTradingResultHandling } from './use-trading-result-handling';
-export { useHandlePoolSwapInfo } from './use-handle-pool-swap-info';
 export { useTradingSettleHandler } from './use-trading-settle-handler';
-export { useTradingPriceDiff } from './use-trading-price-diff';
 export { useAssetPrice } from './use-asset-price';
 export { useRawAssetPrice } from './use-raw-asset-price';
 export { useIsTradingEnabled } from './use-is-trading-enabled';
@@ -12,4 +10,4 @@ export { useMaxSlippagePlaceholder } from './use-max-slippage-placeholder';
 export { useSynthetixV3OraclesUpdate } from './synthetix-v3/use-synthetix-v3-oracles-update';
 export { useDepositProjectedEarnings } from './projected-earnings/use-deposit-projected-earnings';
 export { useProjectedEarningsCore } from './projected-earnings/use-projected-earnings-core';
-export { useIsEasySwapperTrading } from './use-is-easy-swapper-trading';
+export { useSwapDataQuery } from './use-swap-data-query';

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: SwapDataRequest, 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/models/index.d.ts

@@ -1,5 +1,2 @@
-export { BuyingWithEasyswapperArgs } from './buying-with-easyswapper-args';
-export { BuyingWithNativeAssetArgs } from './buying-with-native-asset-args';
-export { BuyingWithPoolLogicArgs } from './buying-with-pool-logic-args';
 export { DefaultSellingParams } from './default-selling-params';
 export { EstimationError } from './estimation-error';

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

@@ -1,21 +1,18 @@
 import type { PoolComposition } from 'core-kit/types/pool.types';
-import type { ApyCurrency, DepositMethodName, TradingToken, WithdrawTradingToken } from 'core-kit/types/trading-panel.types';
+import type { ApyCurrency, TradingToken, WithdrawTradingToken } from 'core-kit/types/trading-panel.types';
 import type { Address, ChainId } from 'core-kit/types/web3.types';
 export interface PoolConfig {
     address: Address;
     symbol: string;
     chainId: ChainId;
     depositParams: {
-        method?: DepositMethodName;
         customTokens: TradingToken[];
         defaultDepositTokenSymbol?: string;
     };
     withdrawParams: {
-        method?: string;
         customTokens: WithdrawTradingToken[];
     };
     deprecated?: boolean;
-    usePoolLogicDeposit?: boolean;
 }
 export interface PoolFallbackData {
     address: Address;