@funkit/connect 0.0.0-20260710210119

package/dist/css/touchableStyles.css.d.ts

@@ -0,0 +1,4 @@
+export declare const base: string;
+export declare const primaryBase: string;
+export declare const hover: Record<"grow" | "growLg", string>;
+export declare const active: Record<"shrink" | "shrinkSm", string>;

package/dist/css/touchableStyles.d.ts

@@ -0,0 +1,8 @@
+import * as styles from './touchableStyles.css';
+interface TouchableStylesOptions {
+    hover?: keyof typeof styles.hover;
+    active: keyof typeof styles.active;
+}
+export declare function touchableStyles({ active, hover }: TouchableStylesOptions): (string | undefined)[];
+export declare function touchablePrimaryStyles({ active, hover, }: TouchableStylesOptions): (string | undefined)[];
+export {};

package/dist/dawnWallet-QBFTQLS4.js

@@ -0,0 +1,7 @@
+"use client";
+
+// src/wallets/walletConnectors/dawnWallet/dawnWallet.svg
+var dawnWallet_default = 'data:image/svg+xml,<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="28" height="28" viewBox="0 0 192 192"><defs><linearGradient id="b" x1="50%" x2="50%" y1="0%" y2="100%"><stop offset="0%" stop-color="%23151515"/><stop offset="100%" stop-color="%23232323"/></linearGradient><linearGradient id="c" x1="50%" x2="50%" y1="0%" y2="99.705%"><stop offset="0%" stop-color="%23F3DC83"/><stop offset="100%" stop-color="%23F9EEC8"/></linearGradient><path id="a" d="M0 0h192v192H0z"/></defs><g fill="none" fill-rule="evenodd"><use xlink:href="%23a" fill="%23232323"/><use xlink:href="%23a" fill="url(%23b)"/><path fill="url(%23c)" d="M123.748 157.002C115.293 160.854 105.898 163 96 163s-19.293-2.146-27.748-5.998Zm22.779-17a67 67 0 0 1-5.93 6H51.403a67 67 0 0 1-5.93-6ZM157.337 123a67 67 0 0 1-4.821 9.001H39.484A67 67 0 0 1 34.663 123ZM96 29c37.003 0 67 29.997 67 67a66.9 66.9 0 0 1-3.695 22H32.695A66.9 66.9 0 0 1 29 96c0-37.003 29.997-67 67-67"/></g></svg>';
+export {
+  dawnWallet_default as default
+};

package/dist/desigWallet-IBKYOHSY.js

@@ -0,0 +1,7 @@
+"use client";
+
+// src/wallets/walletConnectors/desigWallet/desigWallet.svg
+var desigWallet_default = 'data:image/svg+xml,<svg xmlns="http://www.w3.org/2000/svg" width="28" height="28" fill="none"><g clip-path="url(%23a)"><path fill="%23F8F8F8" d="M0 0h28v28H0z"/><path fill="%23F8F8F8" d="M0 0h28v28H0z"/><path fill="%235746DB" d="M12.045 8.814A1.96 1.96 0 0 1 14 6.846H8.805a1.96 1.96 0 0 0-1.958 1.967 1.96 1.96 0 0 0 1.958 1.968H14a1.96 1.96 0 0 1-1.955-1.967"/><path fill="%237767F6" d="M19.15 6.847h-5.196a1.96 1.96 0 0 0-1.907 1.532 1.964 1.964 0 0 0 1.907 2.402h5.193a1.96 1.96 0 0 0 1.96-1.967 1.963 1.963 0 0 0-1.957-1.967"/><path fill="%235746DB" d="M13.68 14a1.963 1.963 0 0 1 1.96-1.967H8.784a1.94 1.94 0 0 0-1.937 1.945v.074a1.93 1.93 0 0 0 1.937 1.915h6.856A1.964 1.964 0 0 1 13.68 14"/><path fill="%237767F6" d="M19.216 12.033H15.64A1.963 1.963 0 0 0 13.68 14a1.96 1.96 0 0 0 1.96 1.967h3.576a1.93 1.93 0 0 0 1.937-1.914v-.075a1.94 1.94 0 0 0-1.937-1.945m.09 5.186h-5.292a1.963 1.963 0 0 0-1.958 1.968v.108a1.97 1.97 0 0 0 1.197 1.706c.24.1.497.153.756.152 2.517 0 4.614-1.323 5.74-2.852l.124-.173a.635.635 0 0 0-.567-.909"/><path fill="%235746DB" d="M13.03 20.886a2 2 0 0 1-.261-.183 1.98 1.98 0 0 1-.708-1.408v-.108a1.963 1.963 0 0 1 1.958-1.968l-5.24-.022h-.073a.633.633 0 0 0-.513.955l.072.095A7.09 7.09 0 0 0 14 21.153h.01a1.94 1.94 0 0 1-.98-.267"/></g><defs><clipPath id="a"><path fill="%23fff" d="M0 0h28v28H0z"/></clipPath></defs></svg>';
+export {
+  desigWallet_default as default
+};

package/dist/domains/aave.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Aave native-supply domain logic: pure constants and predicates shared by
+ * the InputAmount fast-path hook and `FunkitQuoteContext` (toggle gating).
+ * The `@aave/client` SDK singleton stays in
+ * `~/modals/CheckoutModal/InputAmount/aaveClient.ts` — importing it here
+ * would run SDK init for every consumer of this module.
+ */
+import type { Address } from 'viem';
+import type { FunkitCheckoutConfig } from '../providers/FunkitCheckoutContext';
+export declare const AAVE_MARKET_ADDRESS_BY_CHAIN: Record<string, Address>;
+interface AaveNativeSupplyContextArgs {
+    apiKey: string;
+    sourceAsset: {
+        chainId: string | number;
+        address: string | null;
+    } | undefined;
+    checkoutConfig: Pick<FunkitCheckoutConfig, 'targetChain' | 'targetAsset'> | undefined;
+}
+/**
+ * The single check for "is this an Aave native supply" (same chain + same token
+ * as the target, on a chain with an Aave market, for a native-supply-enabled
+ * customer). Tolerates missing source/config — returns false — so callers pass
+ * possibly-undefined checkout state directly without their own guards.
+ */
+export declare function isAaveNativeSupplyContext({ apiKey, sourceAsset, checkoutConfig, }: AaveNativeSupplyContextArgs): boolean;
+/**
+ * Wraps an integrator-provided `resolveHealthFactor` so a throw degrades to a
+ * hidden row (`null`) instead of crashing the confirmation screen — the SDK
+ * never trusts the callback to be total. Returns `undefined` when no resolver
+ * is configured, so callers keep gating on presence.
+ */
+export declare function wrapResolveHealthFactor(resolve: FunkitCheckoutConfig['resolveHealthFactor']): FunkitCheckoutConfig['resolveHealthFactor'];
+export {};

package/dist/domains/asset.d.ts

@@ -0,0 +1,34 @@
+import type { TFunction } from 'i18next';
+import type { Address } from 'viem';
+import type { FunkitCheckoutConfig } from '../providers/FunkitCheckoutContext';
+import type { AssetHoldingsItem } from '../utils/assets';
+import { PaymentMethod } from '../domains/paymentMethods';
+/**
+ * Calculates the minimum USD value an asset must have to be considered usable for checkout.
+ * Accounts for the customer's configured minimum deposit and a global floor.
+ */
+export declare function getMinValueThreshold(config: FunkitCheckoutConfig | undefined, minUsdRequired?: number): number;
+export declare function isPreferredChain(chainId: number, additionalChains?: number[]): boolean;
+export declare function isNativeTokenAddress(address: Address): boolean;
+export declare function isDefaultToken(asset: AssetHoldingsItem, checkoutConfig: FunkitCheckoutConfig): boolean;
+export declare const isPolygonEcosystemToken: (chainId: string, tokenAddress: string) => boolean;
+interface AssetUsableToPayParms {
+    config: FunkitCheckoutConfig;
+    payerAddress: string;
+    paymentMethod: PaymentMethod;
+    targetChainId: string;
+    targetTokenAddress: string;
+    assetChainId: string;
+    assetTokenAddress: string;
+    assetUsdAmount: number | null;
+    isAllowedForCheckout: boolean;
+    minValueThreshold: number;
+    isLighterDynamicRoutingEnabled: boolean;
+    t: TFunction;
+}
+export declare const isAssetUsableToPayForCheckout: ({ config, payerAddress, paymentMethod, targetChainId, targetTokenAddress, assetChainId, assetTokenAddress, assetUsdAmount, isAllowedForCheckout, minValueThreshold, isLighterDynamicRoutingEnabled, t, }: AssetUsableToPayParms) => {
+    isUsable: boolean;
+    reason: string;
+    minUsdWithFees?: number;
+};
+export {};

package/dist/domains/bridge.d.ts

@@ -0,0 +1,26 @@
+/**
+ * See Design Doc
+ * We have three types of accounts in our system:
+ * - Frog SubAccounts: it is used to store data in fun database.
+ * - Bridge Accounts: created by Bridge, our third party fiat provider
+ * - Bridge Bank Account: corresponds to a payment route for a user
+ * https://docs.google.com/document/d/1A0GVWMIe1aLHtblMYJZfFP3C-DybMo47l4vvoxcbpcs/edit?tab=t.0
+ */
+import { type BaseApiRequest, type BridgeCustomer, BridgeCustomerStatus, BridgeKycStatus, type BridgeSubAccount, type BridgeVirtualBankAccount, type CreateBridgeBankAccountRequest, type FunAddress } from '@funkit/api-base';
+/** Bridge only supports a handful of chains so we need to normalize other chains to the supported chain*/
+export declare const findBridgeSupportedChain: (chainId: string) => CreateBridgeBankAccountRequest["chainName"];
+export interface AllFiatAccounts {
+    bridgeCustomer?: BridgeCustomer;
+    bankAccounts?: BridgeVirtualBankAccount[];
+}
+export declare function fetchFrogAccounts(walletAddress: string, params: BaseApiRequest): Promise<import("@funkit/api-base").SubAccount[] | null>;
+export declare function fetchAllFiatAccounts(bridgeSubAccount: BridgeSubAccount | undefined, params: BaseApiRequest): Promise<AllFiatAccounts>;
+export declare function getMatchingBankAccount(accounts: AllFiatAccounts, targetChain: string, targetAddress: FunAddress): BridgeVirtualBankAccount | undefined;
+export declare const getFiatAccountLabel: (defaultLabel: string, account?: BridgeVirtualBankAccount) => string;
+export declare const mapBridgeCustomerStatusToKycStatus: (customerStatus?: BridgeCustomerStatus) => BridgeKycStatus | undefined;
+export declare function isKycUninitialized(customerStatus: BridgeCustomerStatus): customerStatus is BridgeCustomerStatus.AWAITING_QUESTIONNAIRE | BridgeCustomerStatus.AWAITING_UBO | BridgeCustomerStatus.INCOMPLETE | BridgeCustomerStatus.NOT_STARTED;
+/**
+ * When KYC is in the initial state (passed KYC that has to be retried doesn't have a special customer state) but we already get some rejection reasons from bridge
+ */
+export declare const isSoftRejected: (customer: BridgeCustomer | undefined) => boolean | undefined;
+export declare const FIAT_PROCESSING_TIME = "1-2 business days";

package/dist/domains/checkout.d.ts

@@ -0,0 +1,18 @@
+import { type FunAddress } from '@funkit/api-base';
+import { CheckoutRefundState, CheckoutState } from '@funkit/api-base';
+import type { GeneralWalletContextProps } from '../providers/GeneralWalletProvider';
+export declare const hasRisk: (apiKey: string, walletAddress: GeneralWalletContextProps["walletAddress"], customRecipient?: FunAddress) => Promise<boolean>;
+export type CheckoutStatus = 'failed' | 'expired' | 'processing' | 'completed';
+type CheckoutStateBooleans = {
+    isProcessing: boolean;
+    isCompleted: boolean;
+    isError: boolean;
+    isExpired: boolean;
+    isFailed: boolean;
+    isTerminal: boolean;
+    /** won't have correct value if `refundState` is not passed into the hook */
+    isRefundProceeded: boolean;
+    status: CheckoutStatus;
+};
+export declare function getCheckoutStateBooleans(checkoutState: CheckoutState, refundState?: CheckoutRefundState): CheckoutStateBooleans;
+export {};

package/dist/domains/checkoutErrors.d.ts

@@ -0,0 +1,22 @@
+import type { TFunction } from 'i18next';
+import type { ErrorNotification } from '../components/FunNotification/FunNotification';
+import type { Config, Connector } from '../wagmi/hooks';
+export interface CheckoutConfirmationError extends ErrorNotification {
+    durationMs?: number;
+    code: ConfirmationErrorCode;
+}
+export declare enum ConfirmationErrorCode {
+    QUOTE_EXPIRED = "QUOTE_EXPIRED",
+    GENERIC_ERROR = "GENERIC_ERROR",
+    WITHDRAWAL_RATE_LIMIT_EXCEEDED = "WITHDRAWAL_RATE_LIMIT_EXCEEDED",
+    RISK_ERROR = "RISK_ERROR",
+    SIGNATURE_DENIED = "SIGNATURE_DENIED",
+    SWITCH_CHAIN_ERROR = "SWITCH_CHAIN_ERROR",
+    WALLET_CLIENT_UNDEFINED = "WALLET_CLIENT_UNDEFINED",
+    INSUFFICIENT_GAS = "INSUFFICIENT_GAS",
+    POLYGON_RPC_ERROR = "POLYGON_RPC_ERROR"
+}
+export declare function toCheckoutConfirmationError(t: TFunction, error: unknown, wagmiConfig: Config, options?: {
+    fromChainId?: string;
+    connector?: Connector;
+}): Promise<CheckoutConfirmationError>;

package/dist/domains/checkoutNotifications.d.ts

@@ -0,0 +1 @@
+export { DEFAULT_NOTIF_CUTOFF, getUpdatedCheckouts, getUpdatedDirectExecutions, isBitcoinLightningDirectExecution, isTokenTransferDirectExecution, isWithdrawalDirectExecution, mergeMultiStepDirectExecutions, type MergedMultiStepDirectExecution, type NotificationVariant, processRecentDepositsForNotifications, } from '@funkit/connect-core';

package/dist/domains/checkoutRecipient.d.ts

@@ -0,0 +1,6 @@
+import type { Address } from 'viem';
+import type { FunkitCheckoutConfig } from '../providers/FunkitCheckoutContext';
+export declare function getCheckoutRecipient({ walletAddress, config, }: {
+    walletAddress: string;
+    config: FunkitCheckoutConfig;
+}): Address;

package/dist/domains/clientMetadata.d.ts

@@ -0,0 +1,67 @@
+/**
+ * clientMetadata is a type for FE to store historical state of a checkoutItem
+ * It should be mostly derived by backend data but currently we don't have capacity to do it.
+ *
+ * Make sure it is SERIALIZABLE and BACKWARD COMPATIBLE!!
+ */
+import type { DynamicTargetAssetCandidate } from '@funkit/connect-core';
+import type { ApiCheckoutClientMetadata } from '@funkit/utils';
+import type { FunkitActiveCheckoutItem, FunkitCheckoutActionParams, FunkitCheckoutConfig } from '../providers/FunkitCheckoutContext';
+import type { FunkitCheckoutQuoteResult } from './quote';
+type Serialize<T> = T extends (...args: never[]) => unknown ? DeepSerialize<ReturnType<T>> : T extends object ? DeepSerialize<T> : T;
+type DeepSerialize<T> = {
+    [K in keyof T]: Serialize<T[K]>;
+};
+type SerializedCandidate = Omit<DynamicTargetAssetCandidate, 'generateActionsParams'>;
+/**
+ * Historical Checkout Configuration stored in the server
+ * This is similar to FunkitCheckoutConfig but with some fields changed to serializable types
+ * */
+export type ServerCheckoutConfig = Omit<DeepSerialize<FunkitCheckoutConfig>, 'dynamicTargetAssetCandidates'> & {
+    dynamicTargetAssetCandidates?: SerializedCandidate[];
+};
+type HistoricalCheckoutItemKey = 'id' | 'startTimestampMs' | 'finalDollarValue' | 'latestQuote' | 'depositAddress' | 'selectedSourceAssetInfo' | 'selectedPaymentMethodInfo';
+/**
+ * HistoricalCheckoutItem stored in the server
+ *
+ * Make sure it is SERIALIZABLE and BACKWARD COMPATIBLE!!
+ **/
+export interface HistoricalCheckoutItem extends Pick<FunkitActiveCheckoutItem, HistoricalCheckoutItemKey> {
+    initSettings: {
+        config: ServerCheckoutConfig;
+    };
+    isWithdrawal?: boolean;
+}
+/**
+ * Build the checkout config for a deposit re-started from history (the
+ * "New deposit" CTA). Serialized history can't carry closures, so every
+ * function-valued field is only restorable from the live config:
+ * - candidates' per-route `generateActionsParams` are
+ *   stripped on serialize, so the still-active checkout takes the
+ *   function-bearing candidates from `liveConfig` — otherwise a destination
+ *   switch would re-bind `dynamicRoutingId` without its post-action; a
+ *   non-active historical checkout has no live closures, so it keeps the
+ *   stripped candidates;
+ * - `modalTitle` is restored whenever a live config exists (falling back to the
+ *   serializable value) so validation passes;
+ * - the remaining live-only closures (`getMinDepositUSD`,
+ *   `generateActionsParams`, `polymarketPerpsTransfer`, `resolveHealthFactor`)
+ *   are carried forward only when re-starting the still-active checkout.
+ */
+export declare function createNewCheckoutConfig({ serializedConfig, liveConfig, isActiveCheckout, }: {
+    serializedConfig: ServerCheckoutConfig;
+    liveConfig: FunkitCheckoutConfig | undefined;
+    isActiveCheckout: boolean;
+}): FunkitCheckoutConfig;
+/**
+ * Sanitizes checkoutItem to generate a clientMetadata object to be saved in backend.
+ * Ensures that no react components get sent to backend and the object isn't too big as well.
+ */
+export declare function generateClientMetadataForBackend({ checkoutItem, latestQuote, actionsParams, isWithdrawal, }: {
+    checkoutItem: FunkitActiveCheckoutItem;
+    latestQuote: FunkitCheckoutQuoteResult;
+    actionsParams?: FunkitCheckoutActionParams[];
+    isWithdrawal?: boolean;
+}): ApiCheckoutClientMetadata;
+export declare function generateClientMetadataForTokenTransfer(): HistoricalCheckoutItem;
+export {};

package/dist/domains/dynamicRouting.d.ts

@@ -0,0 +1,36 @@
+import type { DynamicRoutePath } from '@funkit/fun-relay';
+import type { DynamicTargetAssetCandidate, FunkitCheckoutConfig } from '../providers/FunkitCheckoutContext';
+/**
+ * The path shape accepted by {@link mergeDynamicRoutingIntoConfig} /
+ * `applyDynamicRouting`. It is a {@link DynamicRoutePath} with the
+ * already-bound callbacks (`customRecipient`, `generateActionsParams`) and
+ * optional routing context layered on top.
+ */
+export type ApplyDynamicRoutingPath = Omit<DynamicRoutePath, 'getCustomRecipient' | 'generateActionsParams'> & {
+    customRecipient?: FunkitCheckoutConfig['customRecipient'];
+    generateActionsParams?: FunkitCheckoutConfig['generateActionsParams'];
+    bridgeOverride?: FunkitCheckoutConfig['bridgeOverride'];
+    dynamicRoutingId?: FunkitCheckoutConfig['dynamicRoutingId'];
+};
+/**
+ * Merge a resolved dynamic-routing path into a checkout config.
+ *
+ * The `dynamicRoutingId` is kept in lockstep with the target it selects: when
+ * the path carries one it wins, otherwise the config's existing id is
+ * preserved. This is what guarantees that anything keyed off
+ * `dynamicRoutingId` (e.g. the modal title) can't drift away from the active
+ * route when the target asset/chain is rebound.
+ */
+export declare function mergeDynamicRoutingIntoConfig(config: FunkitCheckoutConfig, path: ApplyDynamicRoutingPath): FunkitCheckoutConfig;
+/**
+ * Merge a selected {@link DynamicTargetAssetCandidate} into a checkout config —
+ * the pure core of `applyDynamicTargetAssetCandidate`. Rebinds the target token
+ * fields and, in lockstep, the `dynamicRoutingId`; when the candidate carries a
+ * `customRecipient` (account-style candidates such as Polymarket
+ * Predictions/Perps) it also repoints the recipient, otherwise the existing
+ * recipient and routing id are preserved.
+ *
+ * Shared by the SourceChange target-asset dropdown and customer account pickers
+ * so destination selection has a single, tested code path.
+ */
+export declare function mergeDynamicTargetAssetCandidateIntoConfig(config: FunkitCheckoutConfig, candidate: DynamicTargetAssetCandidate): FunkitCheckoutConfig;

package/dist/domains/feeEstimate.d.ts

@@ -0,0 +1,8 @@
+import { PaymentMethod } from './paymentMethods';
+export declare const L1_FEES_ESTIMATE = 1;
+export declare const L2_FEES_ESTIMATE = 1;
+export declare const BROKERAGE_FEES_ESTIMATE = 0;
+/**
+ * Estimating overall fees
+ */
+export declare const getFeesUsdEstimate: (targetChainId: string, assetChainId: string, paymentMethod: PaymentMethod | undefined) => number;

package/dist/domains/fees.d.ts

@@ -0,0 +1,53 @@
+import type { CheckoutQuoteResponse } from '@funkit/utils';
+import type { BluvoBrokerageQuote } from '../hooks/useBluvo';
+import { LoginType } from '../providers/GeneralWalletProvider';
+import type { Config } from '../wagmi/hooks';
+import type { FunkitActiveCheckoutItem } from '../providers/FunkitCheckoutContext';
+import { PaymentMethod, type PaymentMethodInfo } from './paymentMethods';
+export interface BrokerageDetails {
+    isAboveMaximum: boolean;
+    isBelowMinimum: boolean;
+    maximumAmount: number | undefined | null;
+    minimumAmount: number;
+}
+interface BaseCheckoutFees {
+    paymentMethod: PaymentMethod;
+    marketMakerFeeUsd: number;
+    liquidityProviderFeeUsd: number;
+    totalFeesUsd: number;
+    /** does not include the gas fee since it can be in a
+     * different token than the source token */
+    totalFeesTokenWithoutGas: number;
+}
+interface WalletCheckoutFees extends BaseCheckoutFees {
+    paymentMethod: PaymentMethod.ACCOUNT_BALANCE;
+    eoaWalletFeeToken: number;
+    nativeCurrencySymbol: string;
+    eoaWalletFeeUsd: number;
+}
+interface CardCheckoutFees extends BaseCheckoutFees {
+    paymentMethod: PaymentMethod.CARD;
+    cardProcessingFeeUsd: number;
+    moonpayCostUsd: number;
+}
+interface BrokerageCheckoutFees extends BaseCheckoutFees {
+    paymentMethod: PaymentMethod.BROKERAGE;
+    exchangeFeeUsd: number;
+}
+export type CheckoutFees = WalletCheckoutFees | CardCheckoutFees | BrokerageCheckoutFees;
+interface EvaluateFeeBreakdownItem {
+    baseQuote: CheckoutQuoteResponse;
+    selectedSourceAssetInfo: FunkitActiveCheckoutItem['selectedSourceAssetInfo'];
+    newPaymentMethodInfo: PaymentMethodInfo;
+    wagmiConfig: Config;
+    apiKey: string;
+    loginType: LoginType;
+    isWithdrawal?: boolean;
+}
+export declare function evaluateFeeBreakdown(evalItem: EvaluateFeeBreakdownItem & {
+    brokerageQuote?: BluvoBrokerageQuote;
+}): Promise<{
+    fees: CheckoutFees;
+    brokerage?: BrokerageDetails;
+}>;
+export {};

package/dist/domains/meld.d.ts

@@ -0,0 +1,14 @@
+import { type MeldQuote } from '@funkit/api-base';
+/**
+ * Auto-pick the best quote for the user.
+ * @param quotes - the quotes to pick from
+ * @returns the best quote based on the criteria
+ */
+export declare function autoPickBestQuote(quotes: MeldQuote[]): MeldQuote | undefined;
+/**
+ * Check if the quote is the best price quote.
+ * @param sourceQuotes - the quotes to check
+ * @param targetQuote - the quote to check
+ * @returns true if the quote is the best price quote, false otherwise
+ */
+export declare function isBestPriceQuote(sourceQuotes: MeldQuote[] | undefined, targetQuote: MeldQuote | undefined): boolean;

package/dist/domains/nado.d.ts

@@ -0,0 +1,9 @@
+import type { DynamicTargetAssetCandidate } from '../providers/FunkitCheckoutContext';
+export declare function isXStockTargetAsset(asset: DynamicTargetAssetCandidate | undefined): boolean;
+/**
+ * Strip the trailing display qualifier from a Nado ticker, e.g.
+ * "SPYx (Spot)" → "SPYx", to recover the symbol the xStocks API expects.
+ *
+ * todo: we should have a displaySymbol vs tokenSymbol property on the DynamicTargetAssetCandidate
+ */
+export declare function parseXstocksSymbolFromTicker(ticker: string): string;

package/dist/domains/paymentMethods.d.ts

@@ -0,0 +1,90 @@
+import type { BridgeCustomer, BridgeVirtualBankAccount } from '@funkit/api-base';
+import { PaymentMethod } from '@funkit/connect-core';
+import { type BluvoExchangeType } from '../consts/bluvo';
+export { PaymentMethod };
+/** Full payment method information used in frontend during payment flows. **/
+interface PaymentMethodInfoBase {
+    description: string;
+    paymentMethod: PaymentMethod;
+    title: string;
+}
+export interface PaymentMethodCardInfo extends PaymentMethodInfoBase {
+    paymentMethod: PaymentMethod.CARD;
+}
+export interface PaymentMethodBrokerageInfo extends PaymentMethodInfoBase {
+    paymentMethod: PaymentMethod.BROKERAGE;
+    deviceId: string;
+    exchange: BluvoExchangeType;
+}
+export interface PaymentMethodAccountInfo extends PaymentMethodInfoBase {
+    paymentMethod: PaymentMethod.ACCOUNT_BALANCE;
+}
+export interface PaymentMethodTokenTransferInfo extends PaymentMethodInfoBase {
+    paymentMethod: PaymentMethod.TOKEN_TRANSFER;
+}
+export interface PaymentMethodBitcoinLightningInfo extends PaymentMethodInfoBase {
+    paymentMethod: PaymentMethod.BITCOIN_LIGHTNING;
+}
+export interface PaymentMethodCashAppLightningInfo extends PaymentMethodInfoBase {
+    paymentMethod: PaymentMethod.CASH_APP_LIGHTNING;
+}
+export interface PaymentMethodVirtualBankIncompleteInfo extends PaymentMethodInfoBase {
+    paymentMethod: PaymentMethod.VIRTUAL_BANK;
+    matchingFiatAccount: BridgeVirtualBankAccount | undefined;
+    bridgeCustomer: BridgeCustomer | undefined;
+}
+export interface PaymentMethodVirtualBankInfo extends PaymentMethodVirtualBankIncompleteInfo {
+    matchingFiatAccount: BridgeVirtualBankAccount;
+}
+export type ConnectablePaymentMethodInfo = PaymentMethodAccountInfo | PaymentMethodBrokerageInfo | PaymentMethodVirtualBankInfo;
+export declare function isConnectablePaymentMethodInfo(value: unknown): value is ConnectablePaymentMethodInfo;
+/**
+ * Balance-less rails: checkout methods with no on-chain source holding (Card,
+ * Bitcoin Lightning, etc) where "available balance" is not a meaningful concept,
+ * so balance/min/max validation is skipped. Only ACCOUNT_BALANCE and BROKERAGE
+ * carry a measurable holding. Typed to PaymentMethodInfo's methods, not the full
+ * PaymentMethod enum (which also carries Swapped's iframe-only rails).
+ */
+export declare function isBalanceLessPaymentMethod(paymentMethod: PaymentMethodInfo['paymentMethod']): boolean;
+export type PaymentMethodInfo = PaymentMethodCardInfo | PaymentMethodBrokerageInfo | PaymentMethodAccountInfo | PaymentMethodTokenTransferInfo | PaymentMethodBitcoinLightningInfo | PaymentMethodCashAppLightningInfo | PaymentMethodVirtualBankIncompleteInfo;
+interface CardPaymentMethodParams {
+    paymentMethod: PaymentMethod.CARD;
+    /** We also store client's customization in our database :( */
+    titleCustomization: string;
+}
+interface AccountPaymentMethodParams {
+    paymentMethod: PaymentMethod.ACCOUNT_BALANCE;
+    walletAddress: string;
+}
+interface BrokeragePaymentMethodParams {
+    paymentMethod: PaymentMethod.BROKERAGE;
+    deviceId: string;
+    exchange: BluvoExchangeType;
+}
+interface TokenTransferPaymentMethodParams {
+    paymentMethod: PaymentMethod.TOKEN_TRANSFER;
+}
+interface BitcoinLightningPaymentMethodParams {
+    paymentMethod: PaymentMethod.BITCOIN_LIGHTNING;
+}
+interface CashAppLightningPaymentMethodParams {
+    paymentMethod: PaymentMethod.CASH_APP_LIGHTNING;
+}
+interface VirtualBankPaymentMethodIncompleteParams {
+    paymentMethod: PaymentMethod.VIRTUAL_BANK;
+    matchingFiatAccount: undefined;
+    bridgeCustomer: BridgeCustomer | undefined;
+}
+interface VirtualBankPaymentMethodParams {
+    paymentMethod: PaymentMethod.VIRTUAL_BANK;
+    matchingFiatAccount: BridgeVirtualBankAccount;
+    bridgeCustomer: BridgeCustomer | undefined;
+}
+export declare function createPaymentMethodInfo(params: CardPaymentMethodParams): PaymentMethodCardInfo;
+export declare function createPaymentMethodInfo(params: AccountPaymentMethodParams): PaymentMethodAccountInfo;
+export declare function createPaymentMethodInfo(params: TokenTransferPaymentMethodParams): PaymentMethodTokenTransferInfo;
+export declare function createPaymentMethodInfo(params: BitcoinLightningPaymentMethodParams): PaymentMethodBitcoinLightningInfo;
+export declare function createPaymentMethodInfo(params: CashAppLightningPaymentMethodParams): PaymentMethodCashAppLightningInfo;
+export declare function createPaymentMethodInfo(params: VirtualBankPaymentMethodIncompleteParams): PaymentMethodVirtualBankIncompleteInfo;
+export declare function createPaymentMethodInfo(params: VirtualBankPaymentMethodParams): PaymentMethodVirtualBankInfo;
+export declare function createPaymentMethodInfo(params: BrokeragePaymentMethodParams): PaymentMethodBrokerageInfo;

package/dist/domains/quote.d.ts

@@ -0,0 +1,66 @@
+import type { ApiFunkitCheckoutQuoteResult, CheckoutQuoteResponse } from '@funkit/utils';
+import type { Dnum } from 'dnum';
+import { type Address } from 'viem';
+import type { Config } from '../wagmi/hooks';
+import type { BluvoBrokerageQuote } from '../hooks/useBluvo';
+import type { FunkitDirectExecutionInfo } from '../hooks/useCheckoutDirectExecution';
+import type { FunkitActiveCheckoutItem } from '../providers/FunkitCheckoutContext';
+import type { LoginType } from '../providers/GeneralWalletProvider';
+import { type BrokerageDetails, type CheckoutFees } from './fees';
+import { type PaymentMethodInfo } from './paymentMethods';
+import type { QuoteBuilder } from './quoteMode';
+export interface FunkitCheckoutQuoteResult extends Omit<ApiFunkitCheckoutQuoteResult, 'finalFeesBreakdown'> {
+    finalSpreadUsd: string;
+    finalFeesBreakdown: CheckoutFees;
+}
+export declare function getCheckoutBaseQuote(checkoutItem: FunkitActiveCheckoutItem, userId: string, walletAddress: Address, apiKey: string, wagmiConfig: Config, directExecutionInfo: FunkitDirectExecutionInfo, senderAddress?: Address, isWithdrawal?: boolean, quoteBuilder?: QuoteBuilder, 
+/**
+ * User-driven preference for the source-side authorization step. Forwarded
+ * to the direct-execution branch (`getDirectExecutionQuote` →
+ * `getCheckoutQuoteV2`) where Relay's `usePermit` flag actually flows. The
+ * legacy `getApiCheckoutQuote` branch ignores this. On the Aave native
+ * fast path it drives `shouldUsePermitForSupply` instead of flowing here.
+ */
+usePermit?: boolean): Promise<CheckoutQuoteResponse>;
+/**
+ * In EXACT_IN/ONE_TO_ONE mode, the user's input is the source (from) amount.
+ * When a canonical bigint is available, use formatUnits to produce the precise
+ * human-readable string, avoiding precision loss from bigint->Number->string.
+ */
+export declare function resolveFromTokenAmount(checkoutItem: FunkitActiveCheckoutItem, isExactInViaBuilder: boolean, userInputAmount: number, fromTokenDecimals: number): string;
+/**
+ * Derives estSubtotalToAmount from metadata.toAmountBaseUnit for EXACT_IN quotes.
+ * Returns null when derivation isn't needed or isn't possible.
+ **/
+export declare function deriveEstSubtotalToAmountIfNeeded(baseQuote: CheckoutQuoteResponse, isExactIn: boolean, toTokenDecimals: number): string | null;
+export declare function getQuoteFinalEstimation(baseQuote: CheckoutQuoteResponse, checkoutItem: FunkitActiveCheckoutItem, newPaymentMethodInfo: PaymentMethodInfo, wagmiConfig: Config, apiKey: string, loginType: LoginType, isWithdrawal?: boolean, brokerageQuote?: BluvoBrokerageQuote): Promise<{
+    finalEstimation: FunkitCheckoutQuoteResult;
+    brokerage?: BrokerageDetails;
+}>;
+export interface CheckedAssetAmount {
+    isAboveMaximum: boolean;
+    isBelowMinimum: boolean;
+    maxTargetAssetAmount?: Dnum;
+    minTargetAssetAmount?: Dnum;
+}
+export declare function checkAssetAmount(checkoutItem: FunkitActiveCheckoutItem, finalEstimation: FunkitCheckoutQuoteResult, wagmiConfig: Config, walletAddress: Address, brokerage?: BrokerageDetails): Promise<CheckedAssetAmount>;
+export interface CheckoutQuoteParams {
+    checkoutItem: FunkitActiveCheckoutItem;
+    userId: string;
+    walletAddress: Address;
+    apiKey: string;
+    newPaymentMethodInfo: PaymentMethodInfo;
+    wagmiConfig: Config;
+    loginType: LoginType;
+    directExecutionInfo: FunkitDirectExecutionInfo;
+    /** when sender address is different from wallet address
+     *  this happens when withdrawing from a different wallet
+     **/
+    senderAddress?: Address;
+    isWithdrawal?: boolean;
+}
+export declare function getQuoteAndEstimation({ checkoutItem, userId, walletAddress, apiKey, newPaymentMethodInfo, wagmiConfig, loginType, directExecutionInfo, senderAddress, isWithdrawal, }: CheckoutQuoteParams): Promise<{
+    baseQuote: CheckoutQuoteResponse;
+    checkedAssetAmount: CheckedAssetAmount;
+    finalEstimation: FunkitCheckoutQuoteResult;
+}>;

package/dist/domains/quoteMode/exactIn.d.ts

@@ -0,0 +1,2 @@
+import { type QuoteBuilder } from './types';
+export declare function createExactInBuilder(): QuoteBuilder;

package/dist/domains/quoteMode/exactOut.d.ts

@@ -0,0 +1,3 @@
+import type { IsStablecoinFn } from '../../hooks/useIsStablecoin';
+import { type QuoteBuilder } from './types';
+export declare function createExactOutBuilder(isStablecoin: IsStablecoinFn): QuoteBuilder;

package/dist/domains/quoteMode/gasEstimate.d.ts

@@ -0,0 +1,9 @@
+import type { Dnum } from 'dnum';
+/**
+ * Compute a gas cost estimate in wei as an 18-decimal Dnum.
+ *
+ * @param gasPriceWei - Current gas price in wei (e.g. from `getGasPrice`)
+ * @param gasUnits - Conservative gas-unit buffer reserved for the checkout tx
+ * @returns Gas estimate as a Dnum: [gasUnits * gasPriceWei, 18]
+ */
+export declare function getGasEstimateWei(gasPriceWei: bigint, gasUnits: bigint): Dnum;

package/dist/domains/quoteMode/index.d.ts

@@ -0,0 +1,9 @@
+export { QuickOptionType, QuoteBuildType, QuoteMode, RetryActionType, RetryErrorReason, } from './types';
+export type { QuoteBuilder, QuoteBuildResult, QuoteRetryError, RetryAction, QuoteDisplayAmounts, MaxSendableParams, } from './types';
+export type { Dnum } from 'dnum';
+export { createExactOutBuilder } from './exactOut';
+export { createExactInBuilder } from './exactIn';
+export { createOneToOneBuilder } from './oneToOne';
+export { resolveQuoteBuilder, _resolveQuoteMode } from './resolveQuoteMode';
+export type { ResolveQuoteBuilderParams } from './resolveQuoteMode';
+export { getGasEstimateWei } from './gasEstimate';

package/dist/domains/quoteMode/oneToOne.d.ts

@@ -0,0 +1,21 @@
+import { type QuoteBuilder } from './types';
+/**
+ * @TODO: Wire it up to UI components, currently it is not used.
+ * More about the purpose of this quote mode: https://www.notion.so/the-fun-group/Refactoring-Quote-Mode-Selection-Max-Button-Behavior-327fc3b2a00281eea8f0eb0a28a08045#8d7655b63b9c416a91021718702ffe8f
+ *
+ * ONE_TO_ONE is EXACT_IN with subsidized fees — the user sends X tokens and
+ * receives exactly X tokens on the destination chain. All bridge/relay fees
+ * are absorbed by the protocol, so send === receive and feesUsd === '0'.
+ *
+ * Mechanically it inherits all EXACT_IN behavior (max sendable calculation,
+ * quote request building, retry logic, quick options) and only overrides
+ * `getDisplayAmounts` to reflect the 1:1 guarantee.
+ *
+ * @TODO: Revisit whether ONE_TO_ONE should remain a separate builder or be
+ * collapsed into EXACT_IN with overrides. Jeremy suspects it may just be
+ * EXACT_IN with some config flags. Discuss with Connor before removing since
+ * it's in the approved design doc.
+ * See: https://fun-xyz.slack.com/archives/C0AN3BXPBNK/p1775167066455859
+ * Tracked: https://linear.app/funxyz/issue/ENG-3282/revisit-one-to-one-quote-mode-consider-collapsing-into-exact-in
+ */
+export declare function createOneToOneBuilder(): QuoteBuilder;

package/dist/domains/quoteMode/resolveQuoteMode.d.ts

@@ -0,0 +1,22 @@
+import type { IsStablecoinFn } from '../../hooks/useIsStablecoin';
+import { type QuoteBuilder } from './types';
+export interface ResolveQuoteBuilderParams {
+    hasPostAction: boolean | undefined;
+    isExactInEnabled: boolean;
+    isStablecoin: IsStablecoinFn;
+    providerSupportsExactInWithActions?: boolean;
+}
+/**
+ * Determines the quote mode and returns the corresponding builder.
+ *
+ * Resolution order:
+ * 1. No checkout config (hasPostAction is undefined) → EXACT_OUT (safe default)
+ * 2. Feature gate off → EXACT_OUT (Stage 1 default)
+ * 3. No action params → EXACT_IN
+ * 4. Action params + provider supports → EXACT_IN
+ * 5. Action params + no support → EXACT_OUT
+ *
+ * Note: ONE_TO_ONE (subsidized routes) is not yet auto-detected.
+ * It will be enabled in a future phase when subsidy detection is implemented.
+ */
+export declare function resolveQuoteBuilder({ hasPostAction, isExactInEnabled, isStablecoin, providerSupportsExactInWithActions, }: ResolveQuoteBuilderParams): QuoteBuilder;