0xtrails 0.16.1 → 0.17.0

package/dist/index.d.ts

@@ -1,114 +1,1023 @@
-export { SDK_VERSION, getVersion } from './version.js';
-export { Payload } from '@0xsequence/wallet-primitives';
-export { TrailsError, TrailsApiClientError, isTrailsError, isTrailsApiClientError, type TrailsErrorCode, type TrailsErrorBoundary, InsufficientBalanceError, UserRejectionError, getErrorBoundary, getErrorCode, getFullErrorMessage, getIsUserRejectionError, getIsBalanceTooLowError, getIsApiError, getIsRateLimitedError, getIsRequiredAmountNotMetError, getIsNoAvailableQuoteError, getIsQuoteFailedError, getIsQuoteTokenError, getIsQuoteInputError, getIsInsufficientLiquidityError, getIsWalletAlreadyConnectedError, getPrettifiedErrorMessage, } from './error.js';
-export { getExplorerUrl } from './explorer.js';
-export { abortControllerRegistry } from './abortController.js';
-export { getIsContract } from './contractUtils.js';
-export { getSupportedChains, getChainInfo, getAllChains, getRpcUrl, getPublicClient, type Chain, } from './chains.js';
-export { resolveChainId, resolveChainName } from './widget/shared/resolution.js';
-export { useSupportedChains, usePublicClient, usePublicClientGetter, } from './query/chains.hooks.js';
-export { chainQueries } from './query/chains.queries.js';
-export { geoQueries } from './query/geo.queries.js';
-export { useCountryCode, useCountryList } from './query/geo.hooks.js';
-export { fetchCountryCode } from './query/geo.fetchers.js';
-export { attemptSwitchChain } from './chainSwitch.js';
-export { getERC20TransferData } from './utils.js';
-export { useIndexerGatewayClient } from './indexerClient.js';
-export type { OriginCallParams, TrailsFee } from './intents.js';
-export { getIntentConfigurationFromCalls, calculateOriginAndDestinationIntentAddresses, abortIntent, commitIntent, quoteIntent, sendOriginTransaction, } from './intents.js';
-export type { IntentReceiptStatus } from './intentReceiptMonitor.js';
-export { useIntentReceiptMonitor } from './intentReceiptMonitor.js';
-export { pollIntentReceipt, type IntentReceiptPollerOptions, type IntentReceiptPollerCallbacks, type OnOriginTransactionFound, type OnDestinationTransactionFound, type OnReceiptUpdate, } from './intentReceiptPoller.js';
-export { prepareSend, useQuote, TradeType, RouteProvider, QuoteError, } from './prepareSend.js';
-export { encodeDestinationForIntentProtocol, DestinationEncodingError, type EncodeDestinationForIntentProtocolParams, type EncodeDestinationForIntentProtocolResult, type DestinationEncodingErrorCode, type DestinationEncodingStrategy, } from './intentProtocolEncoding.js';
-export type { UseQuoteReturn, UseQuoteProps, SwapReturn, Quote, QuoteErrorCode, } from './prepareSend.js';
-export { lend, deposit, swap, assertCondition, custom, } from './actions/actionBuilder.js';
-export { dynamic, self, isDynamicAmount, isSelfAddress, } from './actions/dynamic.js';
-export type { DynamicAmount } from './actions/dynamic.js';
-export type { ActionAmount, ActionItem, ActionDirection, LendActionItem, SwapActionItem, DepositActionItem, CustomActionItem, AssertActionItem, AssertERC20BalanceItem, AssertNativeBalanceItem, AssertNotExpiredItem, AssertERC20AllowanceItem, } from './actions/types.js';
-export { SwapType } from './actions/actionBuilder.js';
-export type { SwapProvider } from './actions/actionBuilder.js';
-export { useEarnMarkets } from './actions/hooks/useEarnMarkets.js';
-export type { UseEarnMarketsParams, UseEarnMarketsReturn, } from './actions/hooks/useEarnMarkets.js';
-export { useEarnBalances } from './actions/hooks/useEarnBalances.js';
-export type { UseEarnBalancesParams, UseEarnBalancesReturn, } from './actions/hooks/useEarnBalances.js';
-export { useEarnProviders } from './actions/hooks/useEarnProviders.js';
-export type { UseEarnProvidersParams, UseEarnProvidersReturn, } from './actions/hooks/useEarnProviders.js';
-export { useResolveActions } from './actions/hooks/useResolveActions.js';
-export type { UseResolveActionsProps, UseResolveActionsReturn, } from './actions/hooks/useResolveActions.js';
-export type { EarnMarket, EarnMarketToken, EarnMarketRewardRate, EarnMarketRewardRateComponent, EarnMarketStatistics, EarnMarketMetadata, EarnMarketStatus, EarnMarketArgumentField, EarnMarketArguments, EarnActionArgs, ProviderId, Provider, ProviderType, EarnType, EarnBalance, EarnBalances, EarnBalanceQuery, EarnBalanceError, } from './actions/types/earn.js';
-export { getEarnProviders, getEarnMarkets, getEarnBalances, } from './actions/utils.js';
-export type { GetProvidersParams, GetProvidersResult, GetMarketsParams, GetMarketsResult, GetEarnBalancesParams, GetEarnBalancesResult, } from './actions/utils.js';
-export { resolveActionsToCalls } from './actions/resolveActions.js';
-export type { ResolveActionsToCallsParams } from './actions/resolveActions.js';
-export { encodeDestinationCalls, flattenDestinationCalls, } from './actions/destinationCalls.js';
-export type { DestinationCallsInput, EncodedDestinationCalls, } from './actions/destinationCalls.js';
-export { uniswapV3 } from './actions/custom-integrations/uniswapV3/uniswapV3.js';
-export { sushiswapV3 } from './actions/custom-integrations/sushiswapV3/sushiswapV3.js';
-export { buildCall, buildApproveAndCall, buildErc20Approve, getAmountWithSlippage, erc20Utils, } from './actions/utils.js';
-export type { BuildCallParams, BuildApproveAndCallParams, Erc20Utils, TokenAccessor, TokenInfo, Call, CallWithData, FeePercent, TokenOrAddress, SupportedTokenSymbol, SupportedChainName, SupportedChainId, ChainName, ChainId, ChainIdentifier, } from './actions/types.js';
-export type { UniswapV3ChainScoped, UniswapV3GetPoolParams, UniswapV3QuoteSwapParams, UniswapV3QuoteSwapResponse, UniswapV3QuoteSwapType, UniswapV3SwapExactInputSingleParams, UniswapV3SwapExactOutputSingleParams, } from './actions/custom-integrations/uniswapV3/types.js';
-export type { SushiSwapV3ChainScoped, SushiSwapV3GetPoolParams, SushiSwapV3QuoteSwapParams, SushiSwapV3QuoteSwapResponse, SushiSwapV3QuoteSwapType, SushiSwapV3SwapExactInputSingleParams, SushiSwapV3SwapExactOutputSingleParams, } from './actions/custom-integrations/sushiswapV3/types.js';
-export { TRAILS_ROUTER_ADDRESS } from './actions/constants.js';
-export type { FundMethod } from './transactionIntent/types.js';
-export { useTrailsSendTransaction } from './hooks/useTrailsSendTransaction.js';
-export type { UseTrailsSendTransactionParameters, UseTrailsSendTransactionReturnType, TrailsSendTransactionVariables, } from './hooks/useTrailsSendTransaction.js';
-export { useSendTransaction, useWidgetModal, } from './widgetFlowHooks.js';
-export type { UseSendTransactionParameters, UseSendTransactionReturn, UseWidgetModalReturn, } from './widgetFlowHooks.js';
-export { checkProviderHealth, isSequenceWallet, isTrailsWalletClient, isWalletConnectConnector, signWithTimeout, wrapWalletClient, } from '@0xtrails/wallet';
-export { evmAdapter, type EvmAdapterOptions } from './adapters/evmAdapter.js';
-export { getWalletIcon, getWalletName, getWalletRegistry, isSequenceEmbeddedWalletId, isSequenceWalletId as isSequenceWalletById, SEQUENCE_EMBEDDED_WALLET_ID, topShownWallets, } from '@0xtrails/wallet/registry';
-export type { CreateEvmAdapterOptions, Eip1193ProviderLike, EvmChainConfig, EvmWalletDescriptor, TrailsWalletClient, TrailsWalletConnection, } from '@0xtrails/wallet';
-export type { RuntimeWalletClientConnection, WalletRuntimeConnector, } from '@0xtrails/wallet';
-export { isSmartContractWallet } from './smartContractWallet.js';
-export type { WalletConnectorLike, WalletDescriptor, } from '@0xtrails/wallet';
-export type WalletConnector = import('@0xtrails/wallet').WalletConnectorLike;
-export type { TransactionState, IntentTransaction, IntentTransactionHistoryResponse, TransactionHistoryResponse, GetAccountTransactionHistoryParams, UseAccountTransactionHistoryParams, UseAccountTransactionHistoryReturn, } from './transactions.js';
-export { getAccountTransactionHistory, useAccountTransactionHistory, } from './transactions.js';
-export { useIntentTransactionHistory } from './hooks/useIntentTransactionHistory.js';
-export type { UseIntentTransactionHistoryParams, UseIntentTransactionHistoryReturn, } from './hooks/useIntentTransactionHistory.js';
-export { useGetIntent } from './hooks/useGetIntent.js';
-export type { UseGetIntentParams, UseGetIntentReturn, } from './hooks/useGetIntent.js';
-export { MIN_REFETCH_INTERVAL, useAccountTotalBalanceUsd, useHasSufficientBalanceToken, useHasSufficientBalanceUsd, useTokenBalances, useTokenBalancesForMultipleAccounts, } from './query/balance.hooks.js';
-export { getAccountTotalBalanceUsd, getHasSufficientBalanceToken, getHasSufficientBalanceUsd, invalidateTokenBalancesCache, } from './query/balance.queries.js';
-export { checkSufficientToken } from './query/balance.fetchers.js';
-export type { NativeTokenBalance, TokenBalance, } from './query/balance.hooks.js';
-export { getCommonTokenImageUrl, getSequenceMetadataTokenImageUrl, getSupportedTokens, getTokenAddress, getTokenInfo, convertApiTokenInfoToToken, } from './tokens.js';
-export { useSupportedTokens, useTokenList, useGetTokenImageUrl, useGetSequenceMetadataTokenImageUrl, useTokenAddress, useTokenInfo, } from './query/token.hooks.js';
-export type { Token } from './tokens.js';
-export { tokenQueries, getTokenInfoCached } from './query/token.queries.js';
-export { formatBalanceFields, formatUsdFields, formatPriceFields, formatUsdAmountFormatted, formatUsdAmountLocaleDisplay, } from './utils/format.js';
-export { isZeroAccount } from './utils/address.js';
-export { balanceQueries } from './query/balance.queries.js';
-export { fiatQueries } from './query/fiat.queries.js';
-export { useFiatCurrencyList, useExchangeRate, } from './query/fiat.hooks.js';
-export { meldQueries } from './query/meld.queries.js';
-export { useMeldPaymentMethods, useMeldServiceProviders, } from './query/meld.hooks.js';
-export { getCurrencyInfo } from './utils/fiat.js';
-export { getTokenPrice, getTokenPrices, invalidateTokenPricesCache, priceQueries, } from './query/price.queries.js';
-export { useTokenPrice, useTokenPrices } from './query/price.hooks.js';
-export { intentProtocolQueries } from './query/intentProtocol.queries.js';
-export { calcAmountUsdPrice, normalizeNumber, formatTvl, isValidNumeric, isValidInteger, } from './utils/format.js';
-export { getTxTimeDiff } from './transactions.js';
-export { useCommitIntent, useExecuteIntent } from './mutations.js';
-export type { Mode } from './hooks/useViewManager.js';
-export { TRAILS_HYDRATE_PLACEHOLDER_AMOUNT, TRAILS_ROUTER_PLACEHOLDER_AMOUNT, TRAILS_HYDRATE_SELF_ADDRESS, } from './placeholder.js';
-export type { HydrateTypeData } from './abis/trailsHydrate.js';
-export { createHydratePayload, encodeMulticallHydrateExecute, } from './abis/trailsHydrate.js';
-export * from './widget/index.js';
-export { TrailsProvider, useTrails } from './widget/providers/TrailsProvider.js';
-export type { TrailsConfig, TrailsProviderConfig, TrailsAdapterConfig, TrailsAdapterEntry, TrailsAdapterManagedBy, TrailsAdapterProviderProps, SequenceEnv, WrappedTrailsAdapterEntry, } from './widget/providers/TrailsProvider.js';
-export type { TrailsSequenceSupport, TrailsSequenceSupportConfig, TrailsWaasFeeOptionConfirmation, TrailsWaasFeeOptionsControllerProps, TrailsWaasFeeOptionsControllerValue, } from './widget/providers/sequenceSupport.js';
-export { logger, getMinLogLevel } from './logger.js';
-export * from './onramp/index.js';
-export { getTrailsClient, useTrailsClient, TrailsClient, } from './trailsClient.js';
-export { getOnrampClient, useOnrampClient, } from './onrampClient.js';
-export { TrailsOnramp } from './onramp-client/index.js';
-export { getIntent } from './intents.js';
-export { buildRefundTransactionWithSignature, signPayload, useKeymachineIntentRecovery, useIntentRecover, useIntentRecoverWithAddress, } from './recover.js';
-export type { BuildRefundTransactionWithSignatureParams, UseKeymachineIntentRecoveryParams, UseKeymachineIntentRecoveryReturn, UseIntentRecoverParams, UseIntentRecoverReturn, UseIntentRecoverWithAddressParams, UseIntentRecoverWithAddressReturn, } from './recover.js';
-export { useOfflineIntentRecovery, fetchIntentTokenBalancesViaRpc, } from './offlineRecovery.js';
-export type { UseOfflineIntentRecoveryParams, UseOfflineIntentRecoveryReturn, } from './offlineRecovery.js';
-export { storeCommittedIntent, getCommittedIntents, removeCommittedIntent, } from './committedIntentStore.js';
-export type { IntentReceipt, IntentTransaction as IntentTransactionReceipt, IntentStatus, TransactionStatus, WaitIntentReceiptRequest, WaitIntentReceiptResponse, GetIntentReceiptRequest, GetIntentReceiptResponse, QuoteIntentRequest, Intent, ExecuteIntentRequest, ExecuteIntentResponse, } from '@0xtrails/api';
-//# sourceMappingURL=index.d.ts.map
+"use client";
+
+import { A as SupportedChainId, C as SupportedTokenSymbol, D as TokenOrAddress, E as TokenInfo, O as SwapProvider, S as LendActionItem, T as TokenAccessor, _ as CustomActionItem, a as AssertActionItem, b as FeePercent, c as AssertNativeBalanceItem, d as BuildCallParams, f as Call, g as ChainName, h as ChainIdentifier, j as SupportedChainName, k as SwapType, l as AssertNotExpiredItem, m as ChainId, n as ActionDirection, o as AssertERC20AllowanceItem, p as CallWithData, r as ActionItem, s as AssertERC20BalanceItem, t as ActionAmount, u as BuildApproveAndCallParams, v as DepositActionItem, w as SwapActionItem, x as HydrateTypeData, y as Erc20Utils } from "./types-BK0WkVnx.js";
+import { A as deposit, C as DynamicAmount, D as self, E as isSelfAddress, M as swap, O as assertCondition, S as resolveActionsToCalls, T as isDynamicAmount, _ as DestinationCallsInput, a as SushiSwapV3QuoteSwapResponse, b as flattenDestinationCalls, c as SushiSwapV3SwapExactOutputSingleParams, d as UniswapV3GetPoolParams, f as UniswapV3QuoteSwapParams, g as UniswapV3SwapExactOutputSingleParams, h as UniswapV3SwapExactInputSingleParams, i as SushiSwapV3QuoteSwapParams, j as lend, k as custom, l as uniswapV3, m as UniswapV3QuoteSwapType, n as SushiSwapV3ChainScoped, o as SushiSwapV3QuoteSwapType, p as UniswapV3QuoteSwapResponse, r as SushiSwapV3GetPoolParams, s as SushiSwapV3SwapExactInputSingleParams, t as sushiswapV3, u as UniswapV3ChainScoped, v as EncodedDestinationCalls, w as dynamic, x as ResolveActionsToCallsParams, y as encodeDestinationCalls } from "./sushiswapV3-D3h41LNZ.js";
+import { A as Provider, C as EarnMarketMetadata, D as EarnMarketStatus, E as EarnMarketStatistics, M as ProviderType, O as EarnMarketToken, S as EarnMarketArguments, T as EarnMarketRewardRateComponent, _ as EarnBalanceError, a as GetProvidersParams, b as EarnMarket, c as buildCall, d as getAmountWithSlippage, f as getEarnBalances, g as EarnBalance, h as EarnActionArgs, i as GetMarketsResult, j as ProviderId, k as EarnType, l as buildErc20Approve, m as getEarnProviders, n as GetEarnBalancesResult, o as GetProvidersResult, p as getEarnMarkets, r as GetMarketsParams, s as buildApproveAndCall, t as GetEarnBalancesParams, u as erc20Utils, v as EarnBalanceQuery, w as EarnMarketRewardRate, x as EarnMarketArgumentField, y as EarnBalances } from "./utils-KPnWBA9x.js";
+import { t as Token } from "./tokenTypes-D812t5L9.js";
+import { n as QuoteErrorCode, t as QuoteError } from "./quoteError-CmTH5Qm2.js";
+import { $ as getIsRateLimitedError, A as resolveChainName, B as TrailsErrorBoundary, C as SwapReturn, E as useQuote, F as Chain, G as getFullErrorMessage, H as UserRejectionError, I as getAllChains, J as getIsInsufficientLiquidityError, K as getIsApiError, L as InsufficientBalanceError, M as getPublicClient, N as getSupportedChains, P as getRpcUrl, Q as getIsQuoteTokenError, R as TrailsApiClientError, T as UseQuoteReturn, U as getErrorBoundary, V as TrailsErrorCode, W as getErrorCode, X as getIsQuoteFailedError, Y as getIsNoAvailableQuoteError, Z as getIsQuoteInputError, _ as buildEdgeQuoteRequestFromOriginConfig, a as UnifiedWalletProvider, at as isTrailsError, b as Quote, c as SOLANA_MAINNET_CHAIN_ID, ct as IntentTransactionHistoryResponse, d as prepareSend, dt as UseAccountTransactionHistoryParams, et as getIsRequiredAmountNotMetError, f as FundMethod, ft as UseAccountTransactionHistoryReturn, g as buildEdgeQuoteRequestFromDestinationConfig, h as EdgeWalletConfigs, ht as useAccountTransactionHistory, i as SvmWalletAdapter, it as isTrailsApiClientError, j as getChainInfo, k as resolveChainId, l as isSolanaChainId, lt as TransactionHistoryResponse, m as TradeType, mt as getTxTimeDiff, nt as getIsWalletAlreadyConnectedError, o as useOptionalSolanaWalletContext, ot as GetAccountTransactionHistoryParams, pt as getAccountTransactionHistory, q as getIsBalanceTooLowError, r as SolanaWalletContextValue, rt as getPrettifiedErrorMessage, s as useOptionalSvmWalletContext, st as IntentTransaction, t as Mode, tt as getIsUserRejectionError, u as RouteProvider, ut as TransactionState, v as getEdgeOriginConfig, w as UseQuoteProps, y as toEdgeWalletConfigs, z as TrailsError } from "./useViewManager-BeUH_k1s.js";
+import { C as getTokenAddress, S as getSupportedTokens, _ as isSolanaEdgeDestinationConfig, a as useEdgePluginForChain, b as getCommonTokenImageUrl, c as EDGE_RAIL, d as EdgeRailId, g as createSolanaEdgeOriginConfig, h as createSolanaEdgeDestinationConfig, l as EdgeDestinationConfig, m as SolanaEdgeWalletConfig, n as EdgeDepositParams, o as useEdgePluginForDestinationChain, r as EdgePlugin, s as useEdgePlugins, t as BuildEdgeDestinationConfigOptions, u as EdgeOriginConfig, v as isSolanaEdgeOriginConfig, w as getTokenInfo, x as getSequenceMetadataTokenImageUrl, y as convertApiTokenInfoToToken } from "./edge-DmNcuJar.js";
+import { $ as getEdgeSolanaRpcUrl, A as useTokenPrice, At as getTrailsClient, B as TokenBalance, C as useFiatCurrencyList, Ct as TrailsSendTransactionVariables, D as usePublicClient, Dt as IntentReceiptStatus, E as useIndexerGatewayClient, Et as useTrailsSendTransaction, F as useTokenAddress, G as useHasSufficientBalanceUsd, H as UseHasSufficientBalanceUsdParams, I as useTokenInfo, J as FetchTokenBalanceOnchainReturn, K as useTokenBalances, L as useTokenList, M as useGetSequenceMetadataTokenImageUrl, N as useGetTokenImageUrl, O as usePublicClientGetter, Ot as useIntentReceiptMonitor, P as useSupportedTokens, Q as PUBLIC_SOLANA_MAINNET_JSON_RPC, R as MIN_REFETCH_INTERVAL, S as useExchangeRate, St as useGetIntent, T as useCountryList, Tt as UseTrailsSendTransactionReturnType, U as useAccountTotalBalanceUsd, V as UseHasSufficientBalanceTokenParams, W as useHasSufficientBalanceToken, X as GetTokenBalancesWithPriceReturn, Y as GetTokenBalancesForMultipleAccountsReturn, Z as checkSufficientToken, _ as getOnrampClient, _t as UseIntentTransactionHistoryParams, a as BuildRefundTransactionWithSignatureParams, at as useResolveActions, b as useMeldPaymentMethods, bt as UseGetIntentParams, c as UseIntentRecoverWithAddressParams, ct as useEarnProviders, d as UseKeymachineIntentRecoveryReturn, dt as useEarnBalances, et as getEdgeSolanaRpcUrls, f as buildRefundTransactionWithSignature, ft as UseEarnMarketsParams, g as useKeymachineIntentRecovery, gt as useExecuteIntent, h as useIntentRecoverWithAddress, ht as useCommitIntent, i as useOfflineIntentRecovery, it as UseResolveActionsReturn, j as useTokenPrices, jt as useTrailsClient, k as useSupportedChains, kt as TrailsClient, l as UseIntentRecoverWithAddressReturn, lt as UseEarnBalancesParams, m as useIntentRecover, mt as useEarnMarkets, n as UseOfflineIntentRecoveryReturn, nt as resolveSolanaMainnetJsonRpcUrls, o as UseIntentRecoverParams, ot as UseEarnProvidersParams, p as signPayload, pt as UseEarnMarketsReturn, q as useTokenBalancesForMultipleAccounts, r as fetchIntentTokenBalancesViaRpc, rt as UseResolveActionsProps, s as UseIntentRecoverReturn, st as UseEarnProvidersReturn, t as UseOfflineIntentRecoveryParams, tt as resolveSolanaMainnetJsonRpcUrl, u as UseKeymachineIntentRecoveryParams, ut as UseEarnBalancesReturn, v as useOnrampClient, vt as UseIntentTransactionHistoryReturn, w as useCountryCode, wt as UseTrailsSendTransactionParameters, x as useMeldServiceProviders, xt as UseGetIntentReturn, y as TrailsOnramp, yt as useIntentTransactionHistory, z as NativeTokenBalance } from "./offlineRecovery-BfgccnFf.js";
+import { n as encodeMulticallHydrateExecute, t as createHydratePayload } from "./multicall-BCUHt_9t.js";
+import { $ as WrappedTrailsAdapterEntry, A as TrailsWidget, B as getActiveMeshMode, C as PaymentMethod, D as TrailsConnectWalletInitialPendingWallet, E as TrailsConnectWallet, F as WidgetFundMethod, G as SequenceEnv, H as useTrailsOnRamp, I as MeshConfig, J as TrailsAdapterManagedBy, K as TrailsAdapterConfig, L as TrailsOnRampConfig, M as createModalController, N as FundMethodListOption, O as TrailsConnectWalletProps, P as TrailsWidgetProps, Q as TrailsProviderConfig, R as TrailsOnRampProvider, S as FiatPaymentMethod, T as TrailsConnectDialogProps, U as EvmAdapterOptions, V as isMeshEnabled, W as evmAdapter, X as TrailsConfig, Y as TrailsAdapterProviderProps, Z as TrailsProvider, _ as DevConfig, a as Earn, at as TrailsWaasFeeOptionsControllerValue, b as CryptoPaymentMethod, c as PayProps, ct as TrailsModalProvider, d as Withdraw, et as useTrails, f as WithdrawProps, g as DestinationConfig, h as AppMetadata, i as resolveTokenAddress, it as TrailsWaasFeeOptionsControllerProps, j as TrailsWidgetRef, k as TrailsHookModal, l as Fund, lt as useTrailsModal, m as SwapProps, n as ResolvedTokenInput, nt as TrailsSequenceSupportConfig, o as EarnProps, ot as ModalSelectionParams, p as Swap, q as TrailsAdapterEntry, r as resolveTokenInput, rt as TrailsWaasFeeOptionConfirmation, s as Pay, st as TrailsModalContextType, t as useWalletSession, tt as TrailsSequenceSupport, u as FundProps, v as OptionalDestinationConfig, w as TrailsConnectDialog, x as ExchangePaymentMethod, y as SharedWidgetProps, z as TrailsOnRampProviderProps } from "./index-CMdwQmYL.js";
+import { Config, Payload } from "@0xsequence/wallet-primitives";
+import { AbortIntentResponse, CommitIntentResponse, Country, DepositSignature, EdgeMode, EdgeQuoteRequest, ExchangeRate, ExecuteIntentRequest, ExecuteIntentResponse, ExecuteIntentResponse as ExecuteIntentResponse$1, FiatCurrency, GasFeeOptions, GetIntentReceiptRequest, GetIntentReceiptResponse, GetIntentResponse, Intent, Intent as Intent$1, Intent as Intent$2, IntentProtocolVersion, IntentReceipt, IntentReceipt as IntentReceipt$1, IntentStatus, IntentTransaction as IntentTransactionReceipt, PassthroughInfo, QuoteIntentEdgeRequest, QuoteIntentEdgeResponse, QuoteIntentRequest, QuoteIntentRequest as QuoteIntentRequest$1, Token as Token$1, TokenInfo as TokenInfo$1, TokenPrice, TradeType as TradeType$1, TrailsApi, TransactionStateInfo, TransactionStatus, WaitIntentReceiptRequest, WaitIntentReceiptResponse } from "@0xtrails/api";
+import { Account, Chain as Chain$1, PublicClient, WalletClient } from "viem";
+import React from "react";
+import { QueryClient } from "@tanstack/react-query";
+import { CreateEvmAdapterOptions, Eip1193ProviderLike, EvmChainConfig, EvmWalletDescriptor, RuntimeWalletClientConnection, TrailsWalletClient, TrailsWalletClient as TrailsWalletClient$1, TrailsWalletConnection, WalletConnectorLike, WalletDescriptor, WalletRuntimeConnector, checkProviderHealth, isSequenceWallet, isTrailsWalletClient, isWalletConnectConnector, signWithTimeout, wrapWalletClient } from "@0xtrails/wallet";
+import { SEQUENCE_EMBEDDED_WALLET_ID, getWalletIconUrl, getWalletName, getWalletRegistry, isSequenceEmbeddedWalletId, isSequenceWalletId as isSequenceWalletById, topShownWallets } from "@0xtrails/wallet/registry";
+import { Address, Hex } from "ox";
+import { SequenceIndexerGateway } from "@0xsequence/indexer";
+import { CreateMeshLinkTokenResponse, GetMeldServiceProvidersRequest, GetMeshSupportedTokensRequest, MeldCryptoCurrency, MeldFiatCurrency, MeldPaymentMethod, MeldServiceProvider, MeldTransaction, MeshIntegration, MeshSupportedToken } from "@0xtrails/api/onramp";
+
+//#region src/version.d.ts
+declare const SDK_VERSION: string;
+declare function getVersion(): string;
+//#endregion
+//#region src/explorer.d.ts
+type ExplorerUrlParams = {
+  txHash: string;
+  chainId: number;
+};
+declare function getExplorerUrl({
+  txHash,
+  chainId
+}: ExplorerUrlParams): string;
+//#endregion
+//#region src/abortController.d.ts
+declare const abortControllerRegistry: {
+  register: (id: string, controller: AbortController) => void;
+  unregister: (id: string) => void;
+  abort: (id: string) => void;
+  abortAll: () => void;
+  getAll: () => string[];
+};
+//#endregion
+//#region src/contractUtils.d.ts
+declare function getIsContract(address: `0x${string}`, chainId: number, publicClient?: PublicClient): Promise<boolean>;
+//#endregion
+//#region src/query/chains.queries.d.ts
+declare const chainQueries: {
+  all: readonly ["chains"];
+  supported: (config?: {
+    trailsApiUrl?: string;
+    trailsApiKey?: string;
+  }) => import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<Chain[], Error, Chain[], readonly unknown[]>, "queryFn"> & {
+    queryFn?: import("@tanstack/react-query").QueryFunction<Chain[], readonly unknown[], never> | undefined;
+  } & {
+    queryKey: readonly unknown[] & {
+      [dataTagSymbol]: Chain[];
+      [dataTagErrorSymbol]: Error;
+    };
+  };
+};
+//#endregion
+//#region src/query/geo.queries.d.ts
+declare const geoQueries: {
+  all: readonly ["geo"];
+  countryCode: () => import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<string, Error, string, readonly unknown[]>, "queryFn"> & {
+    queryFn?: import("@tanstack/react-query").QueryFunction<string, readonly unknown[], never> | undefined;
+  } & {
+    queryKey: readonly unknown[] & {
+      [dataTagSymbol]: string;
+      [dataTagErrorSymbol]: Error;
+    };
+  };
+  countryList: (trailsClient: TrailsClient | null | undefined) => import("@tanstack/react-query").UseQueryOptions<Country[], Error, Country[], readonly unknown[]> & {
+    initialData?: Country[] | import("@tanstack/react-query").InitialDataFunction<Country[]> | undefined;
+  } & {
+    queryKey: readonly unknown[] & {
+      [dataTagSymbol]: Country[];
+      [dataTagErrorSymbol]: Error;
+    };
+  };
+};
+//#endregion
+//#region src/query/geo.fetchers.d.ts
+declare const fetchCountryCode: () => Promise<string>;
+//#endregion
+//#region src/chainSwitch.d.ts
+type AttemptSwitchChainParams = {
+  walletClient: WalletClient;
+  desiredChainId: number;
+};
+declare function attemptSwitchChain({
+  walletClient,
+  desiredChainId
+}: AttemptSwitchChainParams): Promise<void>;
+//#endregion
+//#region src/utils.d.ts
+/**
+ * Encodes ERC20 transfer function call data
+ * @param to - The recipient address
+ * @param amount - The amount to transfer (in token's smallest unit)
+ * @returns Encoded transfer function call data
+ */
+declare function getERC20TransferData(to: string, amount: bigint): string;
+//#endregion
+//#region src/intents.d.ts
+interface MetaTxnFeeDetail {
+  metaTxnID: string;
+  estimatedGasLimit: string;
+  feeNative: string;
+}
+interface ChainExecuteQuote {
+  chainId: string;
+  totalGasLimit: string;
+  gasPrice: string;
+  totalFeeAmount: string;
+  nativeTokenSymbol: string;
+  nativeTokenPrice?: string;
+  metaTxnFeeDetails: Array<MetaTxnFeeDetail>;
+  totalFeeUSD?: string;
+}
+interface ExecuteQuote {
+  chainQuotes: Array<ChainExecuteQuote>;
+}
+interface CrossChainFee {
+  providerFee: string;
+  trailsSwapFee: string;
+  providerFeeUSD: number;
+  trailsSwapFeeUSD: number;
+  totalFeeAmount: string;
+  totalFeeUSD: number;
+}
+interface TrailsFee {
+  executeQuote: ExecuteQuote;
+  crossChainFee?: CrossChainFee;
+  trailsFixedFeeUSD?: number;
+  feeToken?: string;
+  originTokenTotalAmount?: string;
+  totalFeeAmount?: string;
+  totalFeeUSD?: string;
+}
+type OriginCallParams = {
+  to: `0x${string}` | null;
+  data: Hex.Hex | null;
+  value: bigint | null;
+  chainId: number | null;
+  error?: string;
+};
+type SendOriginCallTxArgs = {
+  to: string;
+  data: Hex.Hex;
+  value: bigint;
+  chain: Chain$1;
+  gasLimit?: bigint;
+  maxFeePerGas?: bigint;
+  maxPriorityFeePerGas?: bigint;
+};
+declare function quoteIntent(trailsClient: TrailsApi, args: QuoteIntentRequest$1, additionalTrackingProps?: Record<string, string>, abortSignal?: AbortSignal): Promise<{
+  intent: Intent$2;
+  gasFeeOptions?: GasFeeOptions;
+  passthrough?: PassthroughInfo;
+  transactionStates?: TransactionStateInfo[];
+}>;
+declare function quoteIntentEdge(trailsClient: TrailsApi, args: QuoteIntentEdgeRequest, additionalTrackingProps?: Record<string, string>, abortSignal?: AbortSignal): Promise<QuoteIntentEdgeResponse>;
+declare function commitIntent(trailsClient: TrailsClient, intent: Intent$2, additionalTrackingProps?: Record<string, string>): Promise<CommitIntentResponse>;
+declare function sendOriginTransaction(account: Account, trailsWalletClient: TrailsWalletClient$1, originParams: SendOriginCallTxArgs, additionalTrackingProps?: Record<string, string>): Promise<`0x${string}`>;
+/**
+ * Fetches intent data from the Trails API
+ * @param trailsClient - TrailsClient instance
+ * @param intentId - The intent ID to fetch
+ * @returns Promise resolving to the intent data
+ */
+declare function getIntent(trailsClient: TrailsClient, intentId: string): Promise<GetIntentResponse>;
+/**
+ * Abort an intent after a successful recovery
+ * This should be called after the recover function executes successfully
+ *
+ * @param trailsClient - The Trails API client
+ * @param intentId - The ID of the intent to abort
+ * @param chainId - The chain ID where the recovery transaction was executed
+ * @param abortTransactionHash - The transaction hash from the recovery
+ * @returns Promise resolving to the abort response with intent status
+ */
+declare function abortIntent(trailsClient: TrailsClient, intentId: string, chainId: number, abortTransactionHash: string): Promise<AbortIntentResponse>;
+//#endregion
+//#region src/solana/solanaTokenCatalog.d.ts
+/** Solana SOL native token sentinel (system program address). */
+declare const SOLANA_SOL_MINT = "11111111111111111111111111111111";
+/** Solana USDC SPL mint address. */
+declare const SOLANA_USDC_MINT = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
+/** Solana USDT SPL mint address. */
+declare const SOLANA_USDT_MINT = "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB";
+/** Solana PYUSD SPL mint address. */
+declare const SOLANA_PYUSD_MINT = "2b1kV6DkPAnxd5ixfnxCpjxmKwqjjaYmCZfHsFu24GXo";
+/**
+ * trails-api does not price native SOL (chainId 101) directly. The SDK queries
+ * the Wormhole-wrapped SOL ERC-20 on Ethereum and maps the price back to SOL.
+ */
+declare const SOLANA_NATIVE_PRICE_PROXY: {
+  readonly chainId: 1;
+  readonly tokenAddress: "0xD31a59c85AE9D8edEFeC411D448f90841571b89c";
+};
+/** Resolves a known Solana mint address to its Token descriptor. */
+declare function getSolanaToken(mintAddress: string): Token | null;
+/** Known Solana tokens from the shared catalog. */
+declare function getSolanaTokens(): Token[];
+/** Returns true if the mint is a known Solana SPL stablecoin (USDC/USDT/PYUSD). */
+declare function isSolanaStablecoinMint(mint: string | null | undefined): boolean;
+/**
+ * Returns the hardcoded USD price for a Solana token when trails-api cannot
+ * price it, or undefined if a live API fetch is required.
+ * - Native SOL → undefined (priced via {@link SOLANA_NATIVE_PRICE_PROXY})
+ * - Stablecoin SPL → 1
+ * - All other SPL → undefined (priced via API)
+ */
+declare function getSolanaTokenPriceUsd(token: Token): number | undefined;
+//#endregion
+//#region src/edge/constants.d.ts
+/**
+ * Relay edge chain id for Solana. Used in edge API requests (both origin and destination modes).
+ * This is not the SDK UI chain id {@link SOLANA_MAINNET_CHAIN_ID} (101).
+ */
+declare const SOLANA_EDGE_CHAIN_ID = 792703809;
+//#endregion
+//#region src/edge/buildQuoteIntentEdgeRequest.d.ts
+type EdgeQuoteRequestInput = {
+  mode: typeof EdgeMode.ORIGIN;
+  solanaAddressBase58: string;
+  originTokenMint: string;
+  edgeTradeType?: TradeType$1;
+  originTokenAmount?: bigint;
+  refundAddress?: string; /** When set, restricts edge quoting to Relay (API validates). */
+  providerRelayOnly?: boolean;
+} | {
+  mode: typeof EdgeMode.DESTINATION;
+  destinationChainId: number;
+  destinationAddress: string;
+  destinationTokenAddress: string;
+  edgeTradeType?: TradeType$1; /** Solana-side output amount for EXACT_OUTPUT (edge `originTokenAmount`). */
+  originTokenAmount?: bigint;
+};
+declare function buildEdgeQuoteRequest(input: EdgeQuoteRequestInput): EdgeQuoteRequest;
+/**
+ * Builds the inner QuoteIntentRequest for a QuoteIntentEdge call.
+ * ORIGIN mode: zeroes out origin fields (Solana side communicated via edge request).
+ * DESTINATION mode: zeroes out destination fields (Solana side communicated via edge request).
+ */
+declare function buildEdgeInnerQuoteIntentRequest(full: QuoteIntentRequest$1, edgeTradeType: TradeType$1, mode: EdgeMode): QuoteIntentRequest$1;
+declare function buildQuoteIntentEdgeRequest(input: {
+  inner: QuoteIntentRequest$1;
+  edge: EdgeQuoteRequest;
+}): QuoteIntentEdgeRequest;
+//#endregion
+//#region src/intentReceiptPoller.d.ts
+/**
+ * Callback invoked when the deposit transaction hash is discovered (for gasless flows).
+ * @param txHash - The transaction hash of the deposit transaction
+ * @param receipt - The full IntentReceipt containing additional metadata
+ */
+type OnDepositTransactionFound = (txHash: string, receipt: IntentReceipt$1) => Promise<void>;
+/**
+ * Callback invoked when the origin transaction hash is discovered.
+ * @param txHash - The transaction hash of the origin transaction
+ * @param receipt - The full IntentReceipt containing additional metadata
+ */
+type OnOriginTransactionFound = (txHash: string, receipt: IntentReceipt$1) => Promise<void>;
+/**
+ * Callback invoked when the destination transaction hash is discovered.
+ * @param txHash - The transaction hash of the destination transaction
+ * @param receipt - The full IntentReceipt containing additional metadata
+ */
+type OnDestinationTransactionFound = (txHash: string, receipt: IntentReceipt$1) => Promise<void>;
+/**
+ * Callback invoked when the intent receipt is updated (regardless of which field changed).
+ * @param receipt - The full IntentReceipt
+ * @param done - Whether the intent has reached a terminal status
+ */
+type OnReceiptUpdate = (receipt: IntentReceipt$1, done: boolean, receiptStates?: string[]) => Promise<void>;
+interface IntentReceiptPollerCallbacks {
+  onDepositTransactionFound?: OnDepositTransactionFound;
+  onOriginTransactionFound?: OnOriginTransactionFound;
+  onDestinationTransactionFound?: OnDestinationTransactionFound;
+  onReceiptUpdate?: OnReceiptUpdate;
+}
+interface IntentReceiptPollerOptions {
+  intentId: string;
+  trailsClient: TrailsClient;
+  callbacks?: IntentReceiptPollerCallbacks;
+  maxWaitTime?: number;
+  pollInterval?: number;
+  abortSignal?: AbortSignal;
+  waitForEdgeCompletion?: boolean;
+}
+/**
+ * Unified intent receipt poller that monitors a single intent ID and invokes callbacks
+ * as origin and destination transactions are discovered. This consolidates what was
+ * previously done via separate polling loops.
+ *
+ * @param options - Configuration for polling including intent ID, client, and callbacks
+ * @returns A promise that resolves when the intent reaches a terminal status or times out
+ *
+ * Usage:
+ * ```
+ * const poller = pollIntentReceipt({
+ *   intentId: intent.intentId,
+ *   trailsClient,
+ *   callbacks: {
+ *     onOriginTransactionFound: async (txHash, receipt) => {
+ *       // Handle origin transaction discovery
+ *     },
+ *     onDestinationTransactionFound: async (txHash, receipt) => {
+ *       // Handle destination transaction discovery
+ *     },
+ *     onReceiptUpdate: async (receipt, done) => {
+ *       // Handle any receipt update
+ *     },
+ *   },
+ * })
+ * ```
+ */
+declare function pollIntentReceipt(options: IntentReceiptPollerOptions): Promise<IntentReceipt$1 | null>;
+//#endregion
+//#region src/intentProtocolEncoding.d.ts
+type DestinationEncodingErrorCode = "UNSAFE_PLACEHOLDER_MATCH" | "MISSING_AMOUNT_SLOT" | "MULTIPLE_AMOUNT_SLOTS" | "INVALID_DESTINATION_CALLDATA";
+declare class DestinationEncodingError extends Error {
+  readonly code: DestinationEncodingErrorCode;
+  constructor(code: DestinationEncodingErrorCode, message: string, cause?: unknown);
+}
+type DestinationEncodingStrategy = "none" | "v1_5_trails_utils_hydrate";
+interface EncodeDestinationForIntentProtocolParams {
+  intentProtocol: IntentProtocolVersion;
+  destinationAddress: string;
+  destinationCalldata: string;
+  destinationApprovalAddress?: string;
+  isExactInput: boolean;
+  hasCustomCalldata: boolean;
+  swapAmount: string;
+  originChainId: number;
+  destinationChainId: number;
+  originTokenAddress: string;
+  destinationTokenAddress: string;
+  trailsUtilsAddress: string;
+}
+interface EncodeDestinationForIntentProtocolResult {
+  destinationAddress: string;
+  destinationCalldata: `0x${string}`;
+  destinationApprovalAddress?: string;
+  strategy: DestinationEncodingStrategy;
+}
+declare function encodeDestinationForIntentProtocol(params: EncodeDestinationForIntentProtocolParams): EncodeDestinationForIntentProtocolResult;
+//#endregion
+//#region src/widgetFlowHooks.d.ts
+type UseSendTransactionParameters = UseTrailsSendTransactionParameters;
+type UseSendTransactionReturn = UseTrailsSendTransactionReturnType;
+declare function useSendTransaction(params?: UseSendTransactionParameters): UseSendTransactionReturn;
+type UseWidgetModalReturn = Omit<TrailsModalContextType, "isModalOpen" | "openModal" | "closeModal"> & {
+  isOpen: boolean;
+  open: () => void;
+  close: () => void;
+};
+declare function useWidgetModal(): UseWidgetModalReturn;
+//#endregion
+//#region src/smartContractWallet.d.ts
+/**
+ * Checks if an address is a smart contract wallet.
+ * @param address - The wallet address to check
+ * @param chainId - The chain ID to check the wallet on
+ * @returns Promise that resolves to true if the address is a smart contract, false otherwise
+ */
+declare function isSmartContractWallet(address: string, chainId: number): Promise<boolean>;
+//#endregion
+//#region src/query/balance.queries.d.ts
+declare const balanceQueries: {
+  all: readonly ["balances"];
+  multiAccounts: () => readonly ["balances", "multiAccount"];
+  multiAccount: (accounts: string[], indexerClient: SequenceIndexerGateway | null | undefined, opts?: {
+    page?: number;
+    pageSize?: number;
+  }) => import("@tanstack/react-query").UseQueryOptions<GetTokenBalancesForMultipleAccountsReturn, Error, GetTokenBalancesForMultipleAccountsReturn, readonly unknown[]> & {
+    initialData?: GetTokenBalancesForMultipleAccountsReturn | import("@tanstack/react-query").InitialDataFunction<GetTokenBalancesForMultipleAccountsReturn> | undefined;
+  } & {
+    queryKey: readonly unknown[] & {
+      [dataTagSymbol]: GetTokenBalancesForMultipleAccountsReturn;
+      [dataTagErrorSymbol]: Error;
+    };
+  };
+  details: () => readonly ["balances", "detail"];
+  withPrices: (account: string | null | undefined, indexerClient: SequenceIndexerGateway | null | undefined, trailsClient: TrailsClient | null | undefined) => import("@tanstack/react-query").UseQueryOptions<GetTokenBalancesWithPriceReturn, Error, GetTokenBalancesWithPriceReturn, readonly unknown[]> & {
+    initialData?: GetTokenBalancesWithPriceReturn | import("@tanstack/react-query").InitialDataFunction<GetTokenBalancesWithPriceReturn> | undefined;
+  } & {
+    queryKey: readonly unknown[] & {
+      [dataTagSymbol]: GetTokenBalancesWithPriceReturn;
+      [dataTagErrorSymbol]: Error;
+    };
+  };
+  totalUsd: (account: string | null | undefined, indexerClient: SequenceIndexerGateway | null | undefined, trailsClient: TrailsClient | null | undefined) => import("@tanstack/react-query").UseQueryOptions<GetTokenBalancesWithPriceReturn, Error, number, readonly unknown[]> & {
+    initialData?: GetTokenBalancesWithPriceReturn | import("@tanstack/react-query").InitialDataFunction<GetTokenBalancesWithPriceReturn> | undefined;
+  } & {
+    queryKey: readonly unknown[] & {
+      [dataTagSymbol]: GetTokenBalancesWithPriceReturn;
+      [dataTagErrorSymbol]: Error;
+    };
+  };
+  sufficientToken: (account: string | null | undefined, token: string | null | undefined, amount: string | null | undefined, chainId: number | null | undefined, indexerClient: SequenceIndexerGateway | null | undefined, trailsClient: TrailsClient | null | undefined) => import("@tanstack/react-query").UseQueryOptions<GetTokenBalancesWithPriceReturn, Error, boolean, readonly unknown[]> & {
+    initialData?: GetTokenBalancesWithPriceReturn | import("@tanstack/react-query").InitialDataFunction<GetTokenBalancesWithPriceReturn> | undefined;
+  } & {
+    queryKey: readonly unknown[] & {
+      [dataTagSymbol]: GetTokenBalancesWithPriceReturn;
+      [dataTagErrorSymbol]: Error;
+    };
+  };
+  sufficientUsd: (account: string | null | undefined, targetAmountUsd: number | string | null | undefined, indexerClient: SequenceIndexerGateway | null | undefined, trailsClient: TrailsClient | null | undefined) => import("@tanstack/react-query").UseQueryOptions<GetTokenBalancesWithPriceReturn, Error, boolean, readonly unknown[]> & {
+    initialData?: GetTokenBalancesWithPriceReturn | import("@tanstack/react-query").InitialDataFunction<GetTokenBalancesWithPriceReturn> | undefined;
+  } & {
+    queryKey: readonly unknown[] & {
+      [dataTagSymbol]: GetTokenBalancesWithPriceReturn;
+      [dataTagErrorSymbol]: Error;
+    };
+  };
+  onchain: (token: Token | null | undefined, accountAddress: string | null | undefined, solanaRpcUrls?: readonly string[]) => import("@tanstack/react-query").UseQueryOptions<FetchTokenBalanceOnchainReturn, Error, FetchTokenBalanceOnchainReturn, readonly unknown[]> & {
+    initialData?: FetchTokenBalanceOnchainReturn | import("@tanstack/react-query").InitialDataFunction<FetchTokenBalanceOnchainReturn> | undefined;
+  } & {
+    queryKey: readonly unknown[] & {
+      [dataTagSymbol]: FetchTokenBalanceOnchainReturn;
+      [dataTagErrorSymbol]: Error;
+    };
+  };
+  onchainWithPrices: (token: Token | null | undefined, accountAddress: string | null | undefined, trailsClient: TrailsClient | null | undefined, solanaRpcUrls?: readonly string[]) => import("@tanstack/react-query").UseQueryOptions<FetchTokenBalanceOnchainReturn, Error, FetchTokenBalanceOnchainReturn, readonly unknown[]> & {
+    initialData?: FetchTokenBalanceOnchainReturn | import("@tanstack/react-query").InitialDataFunction<FetchTokenBalanceOnchainReturn> | undefined;
+  } & {
+    queryKey: readonly unknown[] & {
+      [dataTagSymbol]: FetchTokenBalanceOnchainReturn;
+      [dataTagErrorSymbol]: Error;
+    };
+  };
+  solanaFundingTokens: (tokens: Token[], accountAddress: string | null | undefined, trailsClient: TrailsClient | null | undefined, solanaRpcUrls?: readonly string[]) => import("@tanstack/react-query").UseQueryOptions<Token[], Error, Token[], readonly unknown[]> & {
+    initialData?: Token[] | import("@tanstack/react-query").InitialDataFunction<Token[]> | undefined;
+  } & {
+    queryKey: readonly unknown[] & {
+      [dataTagSymbol]: Token[];
+      [dataTagErrorSymbol]: Error;
+    };
+  };
+};
+declare function invalidateTokenBalancesCache(account?: string, queryClient?: QueryClient): void;
+type HasSufficientBalanceParams = {
+  account: string;
+  token: string;
+  amount: string;
+  chainId: number;
+  indexerGatewayClient: SequenceIndexerGateway;
+  trailsClient: TrailsClient;
+};
+declare function getHasSufficientBalanceToken({
+  account,
+  token,
+  amount,
+  chainId,
+  indexerGatewayClient,
+  trailsClient
+}: HasSufficientBalanceParams): Promise<boolean>;
+type GetHasSufficientBalanceUsdParams = {
+  account: string;
+  targetAmountUsd: number | string;
+  indexerGatewayClient: SequenceIndexerGateway;
+  trailsClient: TrailsClient;
+};
+declare function getHasSufficientBalanceUsd({
+  account,
+  targetAmountUsd,
+  indexerGatewayClient,
+  trailsClient
+}: GetHasSufficientBalanceUsdParams): Promise<boolean>;
+type GetAccountTotalBalanceUsdParams = {
+  account: string;
+  indexerGatewayClient: SequenceIndexerGateway;
+  trailsClient: TrailsClient;
+};
+declare function getAccountTotalBalanceUsd({
+  account,
+  indexerGatewayClient,
+  trailsClient
+}: GetAccountTotalBalanceUsdParams): Promise<number>;
+//#endregion
+//#region src/query/token.fetchers.d.ts
+type TokenListResult = {
+  tokens: TokenInfo$1[];
+};
+//#endregion
+//#region src/query/token.queries.d.ts
+type TokenQueryConfig = {
+  trailsApiKey: string;
+  trailsApiUrl: string;
+  sequenceMetadataUrl?: string;
+};
+/**
+ * Token query factory.
+ *
+ * Keep all token list/address/info query keys under one root so callers can
+ * share cached data between hooks and imperative paths and invalidate the whole
+ * token domain with `tokenQueries.all`.
+ */
+declare const tokenQueries: {
+  all: readonly ["tokens"];
+  supportedList: (config: TokenQueryConfig | null | undefined) => import("@tanstack/react-query").UseQueryOptions<Token[], Error, Token[], readonly unknown[]> & {
+    initialData?: Token[] | import("@tanstack/react-query").InitialDataFunction<Token[]> | undefined;
+  } & {
+    queryKey: readonly unknown[] & {
+      [dataTagSymbol]: Token[];
+      [dataTagErrorSymbol]: Error;
+    };
+  };
+  search: (trailsClient: TrailsClient | null | undefined, apiKey: string | null | undefined, params: {
+    searchQuery: string;
+    chainIds: number[];
+    limit?: number;
+  }) => import("@tanstack/react-query").UseQueryOptions<TokenListResult, Error, TokenListResult, readonly unknown[]> & {
+    initialData?: TokenListResult | import("@tanstack/react-query").InitialDataFunction<TokenListResult> | undefined;
+  } & {
+    queryKey: readonly unknown[] & {
+      [dataTagSymbol]: TokenListResult;
+      [dataTagErrorSymbol]: Error;
+    };
+  };
+  byChain: (trailsClient: TrailsClient | null | undefined, apiKey: string | null | undefined, params: {
+    chainId: number | null | undefined;
+    limit?: number;
+  }) => import("@tanstack/react-query").UseQueryOptions<TokenListResult, Error, TokenListResult, readonly unknown[]> & {
+    initialData?: TokenListResult | import("@tanstack/react-query").InitialDataFunction<TokenListResult> | undefined;
+  } & {
+    queryKey: readonly unknown[] & {
+      [dataTagSymbol]: TokenListResult;
+      [dataTagErrorSymbol]: Error;
+    };
+  };
+  address: (chainId: number | null | undefined, tokenSymbol: string | null | undefined, config: TokenQueryConfig | null | undefined) => import("@tanstack/react-query").UseQueryOptions<string | null, Error, string | null, readonly unknown[]> & {
+    initialData?: string | import("@tanstack/react-query").InitialDataFunction<string | null> | null | undefined;
+  } & {
+    queryKey: readonly unknown[] & {
+      [dataTagSymbol]: string | null;
+      [dataTagErrorSymbol]: Error;
+    };
+  };
+  info: (chainId: number | null | undefined, contractAddress: string | null | undefined, config: TokenQueryConfig | null | undefined) => import("@tanstack/react-query").UseQueryOptions<Token | null, Error, Token | null, readonly unknown[]> & {
+    initialData?: Token | import("@tanstack/react-query").InitialDataFunction<Token | null> | null | undefined;
+  } & {
+    queryKey: readonly unknown[] & {
+      [dataTagSymbol]: Token | null;
+      [dataTagErrorSymbol]: Error;
+    };
+  };
+};
+declare function getTokenInfoCached(chainId: number | null | undefined, contractAddress: string | null | undefined, config: TokenQueryConfig | null | undefined): Promise<Token | null>;
+//#endregion
+//#region src/utils/validation.d.ts
+/**
+ * True if value is a string representing a valid numeric value (digits with optional decimal).
+ * Empty/null/undefined are considered valid (for form-validation use cases).
+ */
+declare function isValidNumeric(value: number | string | null | undefined): boolean;
+/**
+ * True if value is a string representing a valid integer (digits only).
+ * Empty/null/undefined are considered valid (for form-validation use cases).
+ */
+declare function isValidInteger(value: number | string | null | undefined): boolean;
+//#endregion
+//#region src/utils/format.d.ts
+/**
+ * Formats USD value with user's locale settings (for locale-aware display)
+ * Uses browser's locale for number formatting and currency placement.
+ * Also converts to the user's display currency via forexRateStore if available.
+ */
+declare function formatUsdAmountLocaleDisplay(value?: number | string): string;
+/**
+ * Formats USD value without currency symbol (for formatted fields)
+ * Similar to formatUsdAmountDisplay but without the $ sign
+ */
+declare function formatUsdAmountFormatted(value?: number | string): string;
+/**
+ * Formats balance fields (raw → formatted → display)
+ * Returns all three versions for Token
+ */
+declare function formatBalanceFields(balance: string | bigint, decimals: number): {
+  balance: string;
+  balanceFormatted: string;
+  balanceDisplay: string;
+  balanceLocaleDisplay: string;
+};
+/**
+ * Formats USD value fields (raw → formatted → display)
+ * Returns all three versions for Token
+ */
+declare function formatUsdFields(usdValue: number | string | null | undefined): {
+  balanceUsd?: number;
+  balanceUsdFormatted?: string;
+  balanceUsdDisplay?: string;
+  balanceUsdLocaleDisplay?: string;
+};
+/**
+ * Formats price fields (raw → formatted → display)
+ * Returns all three versions for Token
+ */
+declare function formatPriceFields(price: number | string | null | undefined): {
+  priceUsd?: number;
+  priceUsdFormatted?: string;
+  priceUsdDisplay?: string;
+};
+declare function normalizeNumber(number: number | string | null | undefined): number;
+declare function calcAmountUsdPrice({
+  amount,
+  usdPrice
+}: {
+  amount: number | string;
+  usdPrice: string | number | null | undefined;
+}): number;
+declare function formatTvl(tvl: number): string;
+//#endregion
+//#region src/utils/address.d.ts
+/**
+ * Canonical native-token contract address for a chain.
+ * EVM chains use the zero address; Solana uses the SDK SOL sentinel mint.
+ */
+declare function getNativeTokenContractAddress(chainId: number): string;
+/**
+ * Check if an address is a native token sentinel for the given chain context.
+ *
+ * - **EVM** (`chainId` omitted or any non-Solana id): `0x0…0` and legacy `0xEeee…EeEe`.
+ * - **Solana** (`chainId === 101`): `111111…1111` and wrapped SOL `So111…1112`.
+ * - When `chainId` is omitted, Solana mints are recognized only if
+ *   {@link isSolanaSupportEnabled} is true (SVM adapter / edge plugin mounted).
+ */
+declare function isNativeToken(address?: string | null, chainId?: number | null): boolean;
+/**
+ * Checks if an address is the zero address (0x0000...0000)
+ * Use this for recipient/account addresses, not for token addresses.
+ * For token addresses, use isNativeToken() instead.
+ * @param address - The address to check
+ * @returns True if the address is the zero address
+ */
+declare function isZeroAccount(address?: string | null): boolean;
+/** Returns true if the string looks like a Solana base58 public key. */
+declare function isSolanaAddress(address: string): boolean;
+/** EVM 0x or Solana base58 payout address. */
+declare function isSupportedRecipientAddress(address: string): boolean;
+//#endregion
+//#region src/configStore.d.ts
+/** Mark Solana support as enabled for chain-agnostic native-token helpers. */
+declare function setSolanaSupportEnabled(enabled: boolean): void;
+//#endregion
+//#region src/utils/recipientValidation.d.ts
+type RecipientValidationMode = "pay" | "fund" | "swap" | "earn" | "withdraw";
+type RecipientValidationContext = {
+  mode: RecipientValidationMode;
+  destinationChainId?: number | null;
+  originChainId?: number | null;
+};
+declare function isValidRecipientForContext(address: string, ctx: RecipientValidationContext): boolean;
+declare function isValidToAddressProp(address: string, toChainId?: number | string | null): boolean;
+//#endregion
+//#region src/query/fiat.queries.d.ts
+declare const fiatQueries: {
+  all: readonly ["fiat"];
+  currencies: () => readonly ["fiat", "currencies"];
+  currencyList: (trailsClient: TrailsClient | null | undefined) => import("@tanstack/react-query").UseQueryOptions<FiatCurrency[], Error, FiatCurrency[], readonly unknown[]> & {
+    initialData?: FiatCurrency[] | import("@tanstack/react-query").InitialDataFunction<FiatCurrency[]> | undefined;
+  } & {
+    queryKey: readonly unknown[] & {
+      [dataTagSymbol]: FiatCurrency[];
+      [dataTagErrorSymbol]: Error;
+    };
+  };
+  exchangeRates: () => readonly ["fiat", "exchangeRate"];
+  exchangeRate: (trailsClient: TrailsClient | null | undefined, targetCurrency: string | null | undefined) => import("@tanstack/react-query").UseQueryOptions<ExchangeRate, Error, ExchangeRate, readonly unknown[]> & {
+    initialData?: ExchangeRate | import("@tanstack/react-query").InitialDataFunction<ExchangeRate> | undefined;
+  } & {
+    queryKey: readonly unknown[] & {
+      [dataTagSymbol]: ExchangeRate;
+      [dataTagErrorSymbol]: Error;
+    };
+  };
+};
+//#endregion
+//#region src/query/meld.fetchers.d.ts
+interface MeldCountryDefaults {
+  defaultCurrencyCode: string | undefined;
+  defaultPaymentMethods: string[];
+}
+interface MeldTransactionHistoryResult {
+  transactions: MeldTransaction[];
+  hasMore: boolean;
+}
+//#endregion
+//#region src/query/meld.queries.d.ts
+declare const meldQueries: {
+  all: readonly ["meld"];
+  paymentMethods: () => readonly ["meld", "paymentMethods"];
+  paymentMethodList: (onrampClient: TrailsOnramp | null | undefined, fiatCurrency: string | null | undefined) => import("@tanstack/react-query").UseQueryOptions<MeldPaymentMethod[], Error, MeldPaymentMethod[], readonly unknown[]> & {
+    initialData?: MeldPaymentMethod[] | import("@tanstack/react-query").InitialDataFunction<MeldPaymentMethod[]> | undefined;
+  } & {
+    queryKey: readonly unknown[] & {
+      [dataTagSymbol]: MeldPaymentMethod[];
+      [dataTagErrorSymbol]: Error;
+    };
+  };
+  cryptoCurrencies: () => readonly ["meld", "cryptoCurrencies"];
+  cryptoCurrencyList: (onrampClient: TrailsOnramp | null | undefined, countryCode: string | null | undefined) => import("@tanstack/react-query").UseQueryOptions<MeldCryptoCurrency[], Error, MeldCryptoCurrency[], readonly unknown[]> & {
+    initialData?: MeldCryptoCurrency[] | import("@tanstack/react-query").InitialDataFunction<MeldCryptoCurrency[]> | undefined;
+  } & {
+    queryKey: readonly unknown[] & {
+      [dataTagSymbol]: MeldCryptoCurrency[];
+      [dataTagErrorSymbol]: Error;
+    };
+  };
+  serviceProviders: () => readonly ["meld", "serviceProviders"];
+  serviceProviderList: (onrampClient: TrailsOnramp | null | undefined, options?: Partial<GetMeldServiceProvidersRequest>) => import("@tanstack/react-query").UseQueryOptions<MeldServiceProvider[], Error, MeldServiceProvider[], readonly unknown[]> & {
+    initialData?: MeldServiceProvider[] | import("@tanstack/react-query").InitialDataFunction<MeldServiceProvider[]> | undefined;
+  } & {
+    queryKey: readonly unknown[] & {
+      [dataTagSymbol]: MeldServiceProvider[];
+      [dataTagErrorSymbol]: Error;
+    };
+  };
+  fiatCurrencies: () => readonly ["meld", "fiatCurrencies"];
+  fiatCurrencyList: (onrampClient: TrailsOnramp | null | undefined, countryCode: string | null | undefined) => import("@tanstack/react-query").UseQueryOptions<MeldFiatCurrency[], Error, MeldFiatCurrency[], readonly unknown[]> & {
+    initialData?: MeldFiatCurrency[] | import("@tanstack/react-query").InitialDataFunction<MeldFiatCurrency[]> | undefined;
+  } & {
+    queryKey: readonly unknown[] & {
+      [dataTagSymbol]: MeldFiatCurrency[];
+      [dataTagErrorSymbol]: Error;
+    };
+  };
+  countryDefaults: () => readonly ["meld", "countryDefaults"];
+  countryDefaultsByCode: (onrampClient: TrailsOnramp | null | undefined, countryCode: string | null | undefined) => import("@tanstack/react-query").UseQueryOptions<MeldCountryDefaults, Error, MeldCountryDefaults, readonly unknown[]> & {
+    initialData?: MeldCountryDefaults | import("@tanstack/react-query").InitialDataFunction<MeldCountryDefaults> | undefined;
+  } & {
+    queryKey: readonly unknown[] & {
+      [dataTagSymbol]: MeldCountryDefaults;
+      [dataTagErrorSymbol]: Error;
+    };
+  };
+  transactionHistory: () => readonly ["meld", "transactionHistory"];
+  transactionHistoryList: (onrampClient: TrailsOnramp | null | undefined, walletAddress: string | null | undefined, limit?: number) => import("@tanstack/react-query").UseQueryOptions<MeldTransactionHistoryResult, Error, MeldTransactionHistoryResult, readonly unknown[]> & {
+    initialData?: MeldTransactionHistoryResult | import("@tanstack/react-query").InitialDataFunction<MeldTransactionHistoryResult> | undefined;
+  } & {
+    queryKey: readonly unknown[] & {
+      [dataTagSymbol]: MeldTransactionHistoryResult;
+      [dataTagErrorSymbol]: Error;
+    };
+  };
+};
+//#endregion
+//#region src/utils/fiat.d.ts
+/**
+ * Get formatting info for a fiat currency code.
+ */
+declare function getCurrencyInfo(currencyCode: string): {
+  decimals: number;
+  symbol: string;
+};
+//#endregion
+//#region src/query/price.queries.d.ts
+declare const priceQueries: {
+  all: readonly ["tokenPrices"];
+  batch: () => readonly ["tokenPrices", "batch"];
+  single: () => readonly ["tokenPrices", "single"];
+  byTokens: (tokens: Token$1[], trailsClient: TrailsClient | null | undefined, queryClient?: QueryClient) => import("@tanstack/react-query").UseQueryOptions<TokenPrice[], Error, TokenPrice[], readonly unknown[]> & {
+    initialData?: TokenPrice[] | import("@tanstack/react-query").InitialDataFunction<TokenPrice[]> | undefined;
+  } & {
+    queryKey: readonly unknown[] & {
+      [dataTagSymbol]: TokenPrice[];
+      [dataTagErrorSymbol]: Error;
+    };
+  };
+  byToken: (token: Token$1 | null | undefined, trailsClient: TrailsClient | null | undefined, queryClient?: QueryClient) => import("@tanstack/react-query").UseQueryOptions<TokenPrice | null, Error, TokenPrice | null, readonly unknown[]> & {
+    initialData?: TokenPrice | import("@tanstack/react-query").InitialDataFunction<TokenPrice | null> | null | undefined;
+  } & {
+    queryKey: readonly unknown[] & {
+      [dataTagSymbol]: TokenPrice | null;
+      [dataTagErrorSymbol]: Error;
+    };
+  };
+};
+declare function invalidateTokenPricesCache(token?: Token$1, qc?: QueryClient): Promise<void>;
+declare function getTokenPrice(trailsClient: TrailsClient, token: Token$1): Promise<TokenPrice | null>;
+declare function getTokenPrices(trailsClient: TrailsClient, tokens: Token$1[]): Promise<TokenPrice[]>;
+//#endregion
+//#region src/intentProtocolApi.d.ts
+type IntentProtocolApiContext = {
+  supported: IntentProtocolVersion[];
+  apiDefault: IntentProtocolVersion;
+};
+//#endregion
+//#region src/query/intentProtocol.queries.d.ts
+declare const intentProtocolQueries: {
+  all: readonly ["intentProtocol"];
+  apiContext: (client: TrailsApi) => import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<IntentProtocolApiContext, Error, IntentProtocolApiContext, readonly unknown[]>, "queryFn"> & {
+    queryFn?: import("@tanstack/react-query").QueryFunction<IntentProtocolApiContext, readonly unknown[], never> | undefined;
+  } & {
+    queryKey: readonly unknown[] & {
+      [dataTagSymbol]: IntentProtocolApiContext;
+      [dataTagErrorSymbol]: Error;
+    };
+  };
+  /**
+   * Cached default protocol for a Trails client + optional global override (same
+   * resolution as {@link resolveDefaultIntentProtocol} without an override).
+   */
+  defaultIntentProtocol: (opts: {
+    client: TrailsApi;
+    override?: IntentProtocolVersion;
+    global?: IntentProtocolVersion;
+  }) => import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<IntentProtocolVersion, Error, IntentProtocolVersion, readonly unknown[]>, "queryFn"> & {
+    queryFn?: import("@tanstack/react-query").QueryFunction<IntentProtocolVersion, readonly unknown[], never> | undefined;
+  } & {
+    queryKey: readonly unknown[] & {
+      [dataTagSymbol]: IntentProtocolVersion;
+      [dataTagErrorSymbol]: Error;
+    };
+  };
+};
+//#endregion
+//#region src/placeholder.d.ts
+/**
+ * Sentinel uint256 used internally by the SDK to mark a calldata slot that
+ * should be hydrated with the wallet's token balance at runtime.
+ *
+ * **Internal SDK use only.** Do not pass this value directly in contract
+ * calldata - it is not a valid amount and will cause transactions to revert.
+ * Instead, pass it as the `amount` / `amountIn` field when building calls via
+ * SDK helpers (e.g. `buildUniswapV3ExactInputCall`). `encodeMulticallHydrateExecute`
+ * will detect this sentinel and replace it with the correct `erc20Balance / self`
+ * hydration entry before the calldata is submitted on-chain.
+ *
+ * Hash-derived from
+ * `keccak256(utf8("sequence.trails.hydrate.amount.sentinel.v1"))`.
+ */
+declare const TRAILS_HYDRATE_PLACEHOLDER_AMOUNT = 114316045351081986197366228715807272115562181347258027827511447451103061843027n;
+/**
+ * should be hydrated with `address(this)` (the intent wallet) at runtime.
+ *
+ * **Internal SDK use only.** Do not submit this address directly in contract
+ * calldata - it is not a real address and will cause transactions to revert.
+ * Pass it as the `recipient` (or any address field) when building calls via
+ * SDK helpers. `encodeMulticallHydrateExecute` will detect it and replace the
+ * slot with an `address / self` hydration entry before on-chain submission.
+ *
+ * @example
+ * ```ts
+ * import { TRAILS_HYDRATE_SELF_ADDRESS } from "0xtrails"
+ *
+ * swapExactOutputSingle({
+ *   ...
+ *   recipient: TRAILS_HYDRATE_SELF_ADDRESS,
+ * })
+ * ```
+ *
+ * Hash-derived from:
+ * `uint160(uint256(keccak256(utf8("sequence.trails.hydrate.address.sentinel.v1"))))`
+ * = `0xd80d3a37a85094663c36c062e5ef689f2bf54fca`.
+ */
+declare const TRAILS_HYDRATE_SELF_ADDRESS: "0xd80d3a37a85094663c36c062e5ef689f2bf54fca";
+/**
+ * Check if calldata contains the hydrate placeholder amount
+ * ({@link TRAILS_HYDRATE_PLACEHOLDER_AMOUNT}). If no placeholder is found, the
+ * calldata has a real amount baked in.
+ *
+ * @param calldata - The calldata to check
+ * @returns true if calldata contains the placeholder, false otherwise
+ */
+declare function calldataHasPlaceholder(calldata?: string): boolean;
+//#endregion
+//#region src/logger/index.d.ts
+declare function getMinLogLevel(): number;
+declare const logger: {
+  readonly _enabled: boolean;
+  console: {
+    log: (...args: any[]) => void;
+    error: (...args: any[]) => void;
+    warn: (...args: any[]) => void;
+    info: (...args: any[]) => void;
+    debug: (...args: any[]) => void;
+    trace: (...args: any[]) => void;
+    time: (...args: any[]) => void;
+    timeEnd: (...args: any[]) => void;
+  };
+};
+//#endregion
+//#region src/onramp/MeshConnectFlow.d.ts
+interface SelectedMeshExchange {
+  integrationId: string;
+  exchangeKey: string;
+  exchangeName: string;
+}
+interface MeshConnectFlowProps {
+  onBack?: () => void;
+  onComplete?: (transferData: unknown) => void;
+  onError?: (error: unknown) => void;
+  authOnly?: boolean;
+  accessTokens?: Array<{
+    accountId: string;
+    accountName: string;
+    accessToken: string;
+    brokerType: string;
+    brokerName: string;
+  }>;
+  toTokenSymbol?: string;
+  toTokenAmount?: string;
+  toChainId?: number;
+  toRecipientAddress?: string;
+  toAmountUsd?: number;
+  selectedExchange?: SelectedMeshExchange | null;
+}
+declare const MeshConnectFlow: React.FC<MeshConnectFlowProps>;
+//#endregion
+//#region src/onramp/MeshConnectIframe.d.ts
+interface MeshConnectProps {
+  onBack: () => void;
+  onError?: (error: unknown) => void;
+  authOnly?: boolean;
+  accessTokens?: Array<{
+    accountId: string;
+    accountName: string;
+    accessToken: string;
+    brokerType: string;
+    brokerName: string;
+  }>;
+  toTokenSymbol?: string;
+  onComplete?: (transferData: any) => void;
+  toTokenAmount?: string;
+  toChainId?: number;
+  toRecipientAddress?: string;
+  integrationId?: string;
+  exchangeName?: string;
+}
+declare const MeshConnectIframe: React.FC<MeshConnectProps>;
+//#endregion
+//#region src/onramp/SendFromExchangeButton.d.ts
+interface SendFromExchangeButtonProps {
+  /**
+   * Callback to navigate to the onramp screen.
+   * The onramp screen will show the exchange list.
+   */
+  onNavigateToOnramp?: () => void;
+}
+/**
+ * Button component for "Send from Exchange" option in FundMethods.
+ * Only renders if Mesh onramp is configured and exchanges are configured.
+ * Shows an error message if no exchanges are configured.
+ * When clicked, navigates directly to the onramp screen which shows the exchange list.
+ */
+declare const SendFromExchangeButton: React.FC<SendFromExchangeButtonProps>;
+//#endregion
+//#region src/meld/components/SimpleHeader.d.ts
+interface SimpleHeaderProps {
+  onBack?: () => void;
+  title?: string | React.ReactNode;
+  className?: string;
+}
+declare const SimpleHeader: React.FC<SimpleHeaderProps>;
+//#endregion
+//#region src/onramp/trailsOnramp.d.ts
+interface OnrampWidgetHandlers {
+  setCurrentScreen: (screen: string) => void;
+  onComplete?: (transferData: unknown) => void;
+  onError?: (error: unknown) => void;
+  onBack?: () => void;
+  authOnly?: boolean;
+  accessTokens?: Array<{
+    accountId: string;
+    accountName: string;
+    accessToken: string;
+    brokerType: string;
+    brokerName: string;
+  }>;
+  toTokenSymbol?: string;
+  toTokenAmount?: string;
+  toChainId?: number;
+  toRecipientAddress?: string;
+  toAmountUsd?: number;
+  selectedExchange?: SelectedMeshExchange;
+  apiKey?: string;
+  hostname?: string;
+}
+type OnrampFactory = (handlers: OnrampWidgetHandlers) => React.ReactElement;
+declare function normalizeTrailsOnrampConfig(config?: TrailsOnRampConfig): TrailsOnRampConfig | undefined;
+declare function getTrailsOnrampConfig(factory?: OnrampFactory): TrailsOnRampConfig | undefined;
+declare function trailsOnramp(options: {
+  config?: TrailsOnRampConfig;
+}): OnrampFactory;
+//#endregion
+//#region src/onramp/meshconnect.d.ts
+interface CreateMeshLinkTokenOptions {
+  authOnly?: boolean;
+  userId?: string;
+  address?: string;
+  symbol?: string;
+  amount?: string;
+  destinationChainId?: number | string;
+  integrationId?: string;
+  exchangeType?: string;
+  transactionId?: string;
+  restrictMultipleAccounts?: boolean;
+}
+declare function getMeshIntegrations(config?: TrailsOnRampConfig): Promise<MeshIntegration[]>;
+declare function getMeshIntegrationId(exchangeType: string, config?: TrailsOnRampConfig): Promise<string | undefined>;
+declare function getCoinbaseIntegrationId(config?: TrailsOnRampConfig): Promise<string | undefined>;
+declare function getBinanceIntegrationId(config?: TrailsOnRampConfig): Promise<string | undefined>;
+declare function getBitfinexIntegrationId(config?: TrailsOnRampConfig): Promise<string | undefined>;
+declare function createMeshLinkToken(options: CreateMeshLinkTokenOptions, config?: TrailsOnRampConfig): Promise<CreateMeshLinkTokenResponse>;
+declare function getMeshSupportedTokens(request: Omit<GetMeshSupportedTokensRequest, "environment">, config?: TrailsOnRampConfig): Promise<MeshSupportedToken[]>;
+//#endregion
+//#region src/committedIntentStore.d.ts
+declare function storeCommittedIntent(intent: Intent$1): void;
+declare function getCommittedIntents(ownerAddress: string): Intent$1[];
+declare function removeCommittedIntent(intentId: string, ownerAddress: string): void;
+//#endregion
+//#region src/index.d.ts
+type WalletConnector = import("@0xtrails/wallet").WalletConnectorLike;
+//#endregion
+export { type ActionAmount, type ActionDirection, type ActionItem, type AppMetadata, type AssertActionItem, type AssertERC20AllowanceItem, type AssertERC20BalanceItem, type AssertNativeBalanceItem, type AssertNotExpiredItem, type BuildApproveAndCallParams, type BuildCallParams, type BuildEdgeDestinationConfigOptions, type BuildRefundTransactionWithSignatureParams, type Call, type CallWithData, type Chain, type ChainId, type ChainIdentifier, type ChainName, type CreateEvmAdapterOptions, CreateMeshLinkTokenOptions, type CryptoPaymentMethod, type CustomActionItem, type DepositActionItem, type DestinationCallsInput, type DestinationConfig, DestinationEncodingError, type DestinationEncodingErrorCode, type DestinationEncodingStrategy, type DevConfig, type DynamicAmount, EDGE_RAIL, Earn, type EarnActionArgs, type EarnBalance, type EarnBalanceError, type EarnBalanceQuery, type EarnBalances, type EarnMarket, type EarnMarketArgumentField, type EarnMarketArguments, type EarnMarketMetadata, type EarnMarketRewardRate, type EarnMarketRewardRateComponent, type EarnMarketStatistics, type EarnMarketStatus, type EarnMarketToken, type EarnProps, type EarnType, type EdgeDepositParams, type EdgeDestinationConfig, type EdgeOriginConfig, type EdgePlugin, type EdgeRailId, type EdgeWalletConfigs, type Eip1193ProviderLike, type EncodeDestinationForIntentProtocolParams, type EncodeDestinationForIntentProtocolResult, type EncodedDestinationCalls, type Erc20Utils, type EvmAdapterOptions, type EvmChainConfig, type EvmWalletDescriptor, type ExchangePaymentMethod, type ExecuteIntentRequest, type ExecuteIntentResponse, type FeePercent, type FiatPaymentMethod, Fund, type FundMethod, type FundMethodListOption, type FundProps, type GetAccountTransactionHistoryParams, type GetEarnBalancesParams, type GetEarnBalancesResult, type GetIntentReceiptRequest, type GetIntentReceiptResponse, type GetMarketsParams, type GetMarketsResult, type GetProvidersParams, type GetProvidersResult, type HydrateTypeData, InsufficientBalanceError, type Intent, type IntentReceipt, type IntentReceiptPollerCallbacks, type IntentReceiptPollerOptions, type IntentReceiptStatus, type IntentStatus, type IntentTransaction, type IntentTransactionHistoryResponse, type IntentTransactionReceipt, type LendActionItem, MIN_REFETCH_INTERVAL, type MeshConfig, MeshConnectFlow, type MeshConnectFlowProps, MeshConnectIframe, type MeshConnectProps, type ModalSelectionParams, type Mode, type NativeTokenBalance, type OnDestinationTransactionFound, type OnOriginTransactionFound, type OnReceiptUpdate, type OnrampFactory, type OnrampWidgetHandlers, type OptionalDestinationConfig, type OriginCallParams, PUBLIC_SOLANA_MAINNET_JSON_RPC, Pay, type PayProps, Payload, type PaymentMethod, type Provider, type ProviderId, type ProviderType, type Quote, QuoteError, type QuoteErrorCode, type QuoteIntentRequest, type ResolveActionsToCallsParams, type ResolvedTokenInput, RouteProvider, type RuntimeWalletClientConnection, SDK_VERSION, SEQUENCE_EMBEDDED_WALLET_ID, SOLANA_EDGE_CHAIN_ID, SOLANA_MAINNET_CHAIN_ID, SOLANA_NATIVE_PRICE_PROXY, SOLANA_PYUSD_MINT, SOLANA_SOL_MINT, SOLANA_USDC_MINT, SOLANA_USDT_MINT, type SelectedMeshExchange, SendFromExchangeButton, type SendFromExchangeButtonProps, type SequenceEnv, type SharedWidgetProps, SimpleHeader, type SimpleHeaderProps, type SolanaEdgeWalletConfig, type SolanaWalletContextValue, type SupportedChainId, type SupportedChainName, type SupportedTokenSymbol, type SushiSwapV3ChainScoped, type SushiSwapV3GetPoolParams, type SushiSwapV3QuoteSwapParams, type SushiSwapV3QuoteSwapResponse, type SushiSwapV3QuoteSwapType, type SushiSwapV3SwapExactInputSingleParams, type SushiSwapV3SwapExactOutputSingleParams, type SvmWalletAdapter, Swap, type SwapActionItem, type SwapProps, type SwapProvider, type SwapReturn, SwapType, TRAILS_HYDRATE_PLACEHOLDER_AMOUNT, TRAILS_HYDRATE_SELF_ADDRESS, type Token, type TokenAccessor, type TokenBalance, type TokenInfo, type TokenOrAddress, TradeType, type TrailsAdapterConfig, type TrailsAdapterEntry, type TrailsAdapterManagedBy, type TrailsAdapterProviderProps, TrailsApiClientError, TrailsClient, type TrailsConfig, TrailsConnectDialog, type TrailsConnectDialogProps, TrailsConnectWallet, type TrailsConnectWalletInitialPendingWallet, type TrailsConnectWalletProps, TrailsError, type TrailsErrorBoundary, type TrailsErrorCode, type TrailsFee, TrailsHookModal, type TrailsModalContextType, TrailsModalProvider, type TrailsOnRampConfig, TrailsOnRampProvider, type TrailsOnRampProviderProps, TrailsOnramp, TrailsProvider, type TrailsProviderConfig, type TrailsSendTransactionVariables, type TrailsSequenceSupport, type TrailsSequenceSupportConfig, type TrailsWaasFeeOptionConfirmation, type TrailsWaasFeeOptionsControllerProps, type TrailsWaasFeeOptionsControllerValue, type TrailsWalletClient, type TrailsWalletConnection, TrailsWidget, type TrailsWidgetProps, type TrailsWidgetRef, type TransactionHistoryResponse, type TransactionState, type TransactionStatus, UnifiedWalletProvider, type UniswapV3ChainScoped, type UniswapV3GetPoolParams, type UniswapV3QuoteSwapParams, type UniswapV3QuoteSwapResponse, type UniswapV3QuoteSwapType, type UniswapV3SwapExactInputSingleParams, type UniswapV3SwapExactOutputSingleParams, type UseAccountTransactionHistoryParams, type UseAccountTransactionHistoryReturn, type UseEarnBalancesParams, type UseEarnBalancesReturn, type UseEarnMarketsParams, type UseEarnMarketsReturn, type UseEarnProvidersParams, type UseEarnProvidersReturn, type UseGetIntentParams, type UseGetIntentReturn, type UseHasSufficientBalanceTokenParams, type UseHasSufficientBalanceUsdParams, type UseIntentRecoverParams, type UseIntentRecoverReturn, type UseIntentRecoverWithAddressParams, type UseIntentRecoverWithAddressReturn, type UseIntentTransactionHistoryParams, type UseIntentTransactionHistoryReturn, type UseKeymachineIntentRecoveryParams, type UseKeymachineIntentRecoveryReturn, type UseOfflineIntentRecoveryParams, type UseOfflineIntentRecoveryReturn, type UseQuoteProps, type UseQuoteReturn, type UseResolveActionsProps, type UseResolveActionsReturn, type UseSendTransactionParameters, type UseSendTransactionReturn, type UseTrailsSendTransactionParameters, type UseTrailsSendTransactionReturnType, type UseWidgetModalReturn, UserRejectionError, type WaitIntentReceiptRequest, type WaitIntentReceiptResponse, WalletConnector, type WalletConnectorLike, type WalletDescriptor, type WalletRuntimeConnector, WidgetFundMethod, Withdraw, type WithdrawProps, type WrappedTrailsAdapterEntry, abortControllerRegistry, abortIntent, assertCondition, attemptSwitchChain, balanceQueries, buildApproveAndCall, buildCall, buildEdgeInnerQuoteIntentRequest, buildEdgeQuoteRequest, buildEdgeQuoteRequestFromDestinationConfig, buildEdgeQuoteRequestFromOriginConfig, buildErc20Approve, buildQuoteIntentEdgeRequest, buildRefundTransactionWithSignature, calcAmountUsdPrice, calldataHasPlaceholder, chainQueries, checkProviderHealth, checkSufficientToken, commitIntent, convertApiTokenInfoToToken, createHydratePayload, createMeshLinkToken, createModalController, createSolanaEdgeDestinationConfig, createSolanaEdgeOriginConfig, custom, deposit, dynamic, encodeDestinationCalls, encodeDestinationForIntentProtocol, encodeMulticallHydrateExecute, erc20Utils, evmAdapter, fetchCountryCode, fetchIntentTokenBalancesViaRpc, fiatQueries, flattenDestinationCalls, formatBalanceFields, formatPriceFields, formatTvl, formatUsdAmountFormatted, formatUsdAmountLocaleDisplay, formatUsdFields, geoQueries, getAccountTotalBalanceUsd, getAccountTransactionHistory, getActiveMeshMode, getAllChains, getAmountWithSlippage, getBinanceIntegrationId, getBitfinexIntegrationId, getChainInfo, getCoinbaseIntegrationId, getCommittedIntents, getCommonTokenImageUrl, getCurrencyInfo, getERC20TransferData, getEarnBalances, getEarnMarkets, getEarnProviders, getEdgeOriginConfig, getEdgeSolanaRpcUrl, getEdgeSolanaRpcUrls, getErrorBoundary, getErrorCode, getExplorerUrl, getFullErrorMessage, getHasSufficientBalanceToken, getHasSufficientBalanceUsd, getIntent, getIsApiError, getIsBalanceTooLowError, getIsContract, getIsInsufficientLiquidityError, getIsNoAvailableQuoteError, getIsQuoteFailedError, getIsQuoteInputError, getIsQuoteTokenError, getIsRateLimitedError, getIsRequiredAmountNotMetError, getIsUserRejectionError, getIsWalletAlreadyConnectedError, getMeshIntegrationId, getMeshIntegrations, getMeshSupportedTokens, getMinLogLevel, getNativeTokenContractAddress, getOnrampClient, getPrettifiedErrorMessage, getPublicClient, getRpcUrl, getSequenceMetadataTokenImageUrl, getSolanaToken, getSolanaTokenPriceUsd, getSolanaTokens, getSupportedChains, getSupportedTokens, getTokenAddress, getTokenInfo, getTokenInfoCached, getTokenPrice, getTokenPrices, getTrailsClient, getTrailsOnrampConfig, getTxTimeDiff, getVersion, getWalletIconUrl, getWalletName, getWalletRegistry, intentProtocolQueries, invalidateTokenBalancesCache, invalidateTokenPricesCache, isDynamicAmount, isMeshEnabled, isNativeToken, isSelfAddress, isSequenceEmbeddedWalletId, isSequenceWallet, isSequenceWalletById, isSmartContractWallet, isSolanaAddress, isSolanaChainId, isSolanaEdgeDestinationConfig, isSolanaEdgeOriginConfig, isSolanaStablecoinMint, isSupportedRecipientAddress, isTrailsApiClientError, isTrailsError, isTrailsWalletClient, isValidInteger, isValidNumeric, isValidRecipientForContext, isValidToAddressProp, isWalletConnectConnector, isZeroAccount, lend, logger, meldQueries, normalizeNumber, normalizeTrailsOnrampConfig, pollIntentReceipt, prepareSend, priceQueries, quoteIntent, quoteIntentEdge, removeCommittedIntent, resolveActionsToCalls, resolveChainId, resolveChainName, resolveSolanaMainnetJsonRpcUrl, resolveSolanaMainnetJsonRpcUrls, resolveTokenAddress, resolveTokenInput, self, sendOriginTransaction, setSolanaSupportEnabled, signPayload, signWithTimeout, storeCommittedIntent, sushiswapV3, swap, toEdgeWalletConfigs, tokenQueries, topShownWallets, trailsOnramp, uniswapV3, useAccountTotalBalanceUsd, useAccountTransactionHistory, useCommitIntent, useCountryCode, useCountryList, useEarnBalances, useEarnMarkets, useEarnProviders, useEdgePluginForChain, useEdgePluginForDestinationChain, useEdgePlugins, useExchangeRate, useExecuteIntent, useFiatCurrencyList, useGetIntent, useGetSequenceMetadataTokenImageUrl, useGetTokenImageUrl, useHasSufficientBalanceToken, useHasSufficientBalanceUsd, useIndexerGatewayClient, useIntentReceiptMonitor, useIntentRecover, useIntentRecoverWithAddress, useIntentTransactionHistory, useKeymachineIntentRecovery, useMeldPaymentMethods, useMeldServiceProviders, useOfflineIntentRecovery, useOnrampClient, useOptionalSolanaWalletContext, useOptionalSvmWalletContext, usePublicClient, usePublicClientGetter, useQuote, useResolveActions, useSendTransaction, useSupportedChains, useSupportedTokens, useTokenAddress, useTokenBalances, useTokenBalancesForMultipleAccounts, useTokenInfo, useTokenList, useTokenPrice, useTokenPrices, useTrails, useTrailsClient, useTrailsModal, useTrailsOnRamp, useTrailsSendTransaction, useWalletSession, useWidgetModal, wrapWalletClient };