@funkit/connect 8.3.0 → 8.3.1-next.0

package/dist/atoms/bridgeProviders/types.d.ts

@@ -0,0 +1,182 @@
+import type { DirectExecutionType } from '@funkit/api-base';
+import type { CheckoutQuoteResponse } from '@funkit/utils';
+import type { ReactNode } from 'react';
+import type { Address, Hex, WalletClient } from 'viem';
+import type { PaymentMethod } from '../../domains/paymentMethods';
+import type { FunkitCheckoutActionParams } from '../../providers/FunkitCheckoutContext';
+import type { WithdrawalClient } from '../../wallets/Wallet';
+/**
+ * Identifies a chain + asset pair for routing decisions.
+ */
+export interface ChainAsset {
+    chainId: string;
+    tokenAddress: Address;
+}
+/**
+ * Standardized quote request parameters across all bridge providers.
+ */
+export interface BridgeQuoteParams {
+    actionParams: FunkitCheckoutActionParams[];
+    fromChainId: string;
+    fromTokenAddress: Address;
+    toChainId: string;
+    toTokenAddress: Address;
+    recipientAddress: Address;
+    /** Sender address - defaults to connected wallet if not provided */
+    senderAddress?: Address;
+}
+/**
+ * Quote request for exact output (target amount specified).
+ */
+export interface BridgeQuoteExactOutParams extends BridgeQuoteParams {
+    toTokenAmount: number;
+    toTokenDecimals: number;
+    isExactIn?: false;
+}
+/**
+ * Quote request for exact input (source amount specified).
+ */
+export interface BridgeQuoteExactInParams extends BridgeQuoteParams {
+    fromTokenAmount: number;
+    fromTokenDecimals: number;
+    isExactIn: true;
+}
+export type BridgeQuoteRequestParams = BridgeQuoteExactOutParams | BridgeQuoteExactInParams;
+/**
+ * Standardized quote result from any bridge provider.
+ * Extends the existing CheckoutQuoteResponse for compatibility.
+ */
+export interface BridgeQuoteResult extends CheckoutQuoteResponse {
+    /** Provider-specific metadata */
+    providerMetadata?: unknown;
+}
+/**
+ * Execution parameters for initiating a bridge transaction.
+ */
+export interface BridgeExecutionParams {
+    quote: BridgeQuoteResult;
+    stepMessageSetter: (message: string) => void;
+    onTransactionConfirmed: (txHash: Hex) => void;
+    walletClient?: WalletClient;
+    withdrawalClient?: WithdrawalClient;
+}
+/**
+ * Result of a bridge execution.
+ */
+export interface BridgeExecutionResult {
+    txHash: Hex;
+}
+/**
+ * Selected route display information.
+ * Used to show which bridge/protocol is being used in the UI.
+ */
+export interface SelectedRouteInfo {
+    /** Route label (e.g., "Relay", "Native Bridge", "Across") */
+    label: string;
+    /** Icon component to display */
+    icon: ReactNode;
+    /** Whether this is a passthrough/native bridge (no solver fees) */
+    isPassthrough: boolean;
+}
+/**
+ * Route eligibility check parameters.
+ */
+export interface RouteEligibilityParams {
+    fromChainId: string;
+    fromTokenAddress: string;
+    toChainId: string;
+    toTokenAddress: string;
+    paymentMethod: PaymentMethod | undefined;
+    isAdditionalActionsRequired: boolean;
+}
+/**
+ * Bridge Provider Adapter Interface
+ *
+ * Defines a standardized contract for bridge providers (Relay, Across, etc.).
+ * Each adapter encapsulates provider-specific quoting and execution logic
+ * behind a common interface.
+ *
+ * @example
+ * ```ts
+ * const relayAdapter: BridgeProviderAdapter = {
+ *   name: 'Relay',
+ *   directExecutionType: DirectExecutionType.RELAY,
+ *   getQuote: async (params) => { ... },
+ *   execute: async (params) => { ... },
+ *   supportsRoute: (params) => { ... },
+ * }
+ * ```
+ */
+export interface BridgeProviderAdapter {
+    /** Human-readable provider name */
+    readonly name: string;
+    /** Provider identifier for backend tracking */
+    readonly directExecutionType: DirectExecutionType;
+    /**
+     * Fetches a quote for the given route.
+     *
+     * @param params - Quote request parameters
+     * @returns Quote result or null if unable to quote
+     */
+    getQuote(params: BridgeQuoteRequestParams): Promise<BridgeQuoteResult | null>;
+    /**
+     * Executes a bridge transaction using the provided quote.
+     *
+     * @param params - Execution parameters including quote and wallet
+     * @returns Transaction hash on success, null on failure
+     */
+    execute(params: BridgeExecutionParams): Promise<Hex | null>;
+    /**
+     * Determines if this provider supports the given route.
+     *
+     * @param params - Route eligibility parameters
+     * @returns true if the provider can handle this route
+     */
+    supportsRoute(params: RouteEligibilityParams): boolean;
+    /**
+     * Returns display information for the selected route.
+     * Used to show which bridge/protocol is being used in the UI.
+     * Retrieves quote, translation, and config from atoms internally.
+     *
+     * @returns Route display info (label, icon, isPassthrough), or null if no quote
+     */
+    getSelectedRoute(): SelectedRouteInfo | null;
+    /**
+     * Estimates time for a given quote.
+     *
+     * @param quote - The quote to estimate time for
+     * @returns Estimated time in milliseconds
+     */
+    estimatedTime?(quote: BridgeQuoteResult): number;
+}
+/**
+ * Provider selection criteria for runtime switching.
+ */
+export interface ProviderSelectionCriteria {
+    amount?: bigint;
+    fromChainId?: string;
+    toChainId?: string;
+    preferredProvider?: string;
+}
+/**
+ * Registry for managing multiple bridge providers.
+ */
+export interface BridgeProviderRegistry {
+    /** All registered providers */
+    readonly providers: readonly BridgeProviderAdapter[];
+    /**
+     * Gets the provider for the given route based on selection criteria.
+     *
+     * @param route - Route eligibility parameters
+     * @param criteria - Optional selection preferences
+     * @returns The selected provider, or undefined if none available
+     */
+    getProvider(route: RouteEligibilityParams, criteria?: ProviderSelectionCriteria): BridgeProviderAdapter | undefined;
+    /**
+     * Gets all providers that support a given route.
+     *
+     * @param route - Route eligibility parameters
+     * @returns Array of supporting providers
+     */
+    getSupportingProviders(route: RouteEligibilityParams): readonly BridgeProviderAdapter[];
+}

package/dist/atoms/checkoutProgress.d.ts

@@ -0,0 +1,22 @@
+import type { CheckoutProgress } from '../providers/FunkitCheckoutContext';
+/**
+ * Stores checkout progress by checkoutId.
+ * Tracks which step each checkout is at.
+ */
+export declare const checkoutsProgressAtom: import("jotai").PrimitiveAtom<{
+    [x: string]: CheckoutProgress | undefined;
+}> & {
+    init: {
+        [x: string]: CheckoutProgress | undefined;
+    };
+};
+/**
+ * Sets the progress for a specific checkout.
+ */
+export declare const setCheckoutProgressAtom: import("jotai").WritableAtom<null, [checkoutId: string, progress: CheckoutProgress], void> & {
+    init: null;
+};
+/**
+ * Gets the progress for a specific checkout by ID.
+ */
+export declare const getCheckoutProgressAtom: import("jotai").Atom<(checkoutId: string) => CheckoutProgress | undefined>;

package/dist/atoms/directExecution.d.ts

@@ -0,0 +1,70 @@
+import { DirectExecutionType } from '@funkit/api-base';
+import type { RelayTxHash, RelayVmType } from '@funkit/fun-relay';
+import type { CheckoutQuoteResponse } from '@funkit/utils';
+import type { Address, Hex } from 'viem';
+import type { PaymentMethod } from '../domains/paymentMethods';
+import type { FunkitCheckoutQuoteResult } from '../domains/quote';
+import type { FunkitActiveCheckoutItem, FunkitCheckoutActionParams } from '../providers/FunkitCheckoutContext';
+import type { WithdrawalClient } from '../wallets/Wallet';
+export interface DirectExecutionQuoteRequestParamsBase {
+    actionParams: FunkitCheckoutActionParams[];
+    fromChainId: string;
+    fromTokenAddress: Address;
+    isExactIn?: boolean;
+    toChainId: string;
+    toTokenAddress: Address;
+    recipientAddress: Address;
+    senderAddress?: Address;
+}
+export interface RegularDEQuoteRequest extends DirectExecutionQuoteRequestParamsBase {
+    toTokenAmount: number;
+    toTokenDecimals: number;
+    isExactIn?: false;
+}
+export interface WithdrawalDEQuoteRequest extends DirectExecutionQuoteRequestParamsBase {
+    fromTokenAmount: number;
+    isExactIn: true;
+    fromTokenDecimals: number;
+}
+export type DirectExecutionQuoteRequestParams = RegularDEQuoteRequest | WithdrawalDEQuoteRequest;
+export interface DirectExecutionStartParams {
+    checkoutItem: FunkitActiveCheckoutItem;
+    stepMessageSetter: (m: string) => void;
+    actionsParams: FunkitCheckoutActionParams[];
+    latestQuote: FunkitCheckoutQuoteResult;
+    onTransactionConfirmed: (txHash: RelayTxHash<RelayVmType>) => void;
+    withdrawalClient?: WithdrawalClient;
+}
+export interface FunkitDirectExecutionInfo {
+    isDirectExecution: boolean;
+    directExecutionType: DirectExecutionType | null;
+    getDirectExecutionQuote: (params: DirectExecutionQuoteRequestParams) => Promise<CheckoutQuoteResponse | null>;
+    executeDirectExecution: (params: DirectExecutionStartParams) => Promise<Hex | null>;
+}
+export interface StartRelayExecutionParams extends DirectExecutionStartParams {
+}
+/**
+ * Mutation atom to get a relay direct execution quote.
+ * Uses apiKey from config atom and defaults senderAddress to wallet client address.
+ */
+export declare const getRelayDirectExecutionQuoteAtom: import("jotai").Atom<import("jotai-tanstack-query").AtomWithMutationResult<CheckoutQuoteResponse | null, unknown, DirectExecutionQuoteRequestParams, unknown>>;
+/**
+ * Determines if a checkout item should use direct execution.
+ */
+export declare function getDirectExecutionInfoFromCheckout(checkoutItem: FunkitActiveCheckoutItem | null, getIsRelayEnabled: (params: {
+    fromChainId: string;
+    fromTokenAddress: string;
+    toChainId: string;
+    toTokenAddress: string;
+    paymentMethod: PaymentMethod | undefined;
+    isAdditionalActionsRequired: boolean;
+}) => boolean, getDirectExecutionQuote: (params: DirectExecutionQuoteRequestParams) => Promise<CheckoutQuoteResponse | null>, executeDirectExecution: (params: DirectExecutionStartParams) => Promise<Hex | null>): FunkitDirectExecutionInfo;
+/**
+ * Returns withdrawal direct execution info.
+ */
+export declare function getWithdrawalDirectExecutionInfo(getDirectExecutionQuote: (params: DirectExecutionQuoteRequestParams) => Promise<CheckoutQuoteResponse | null>, executeDirectExecution: (params: DirectExecutionStartParams) => Promise<Hex | null>): FunkitDirectExecutionInfo;
+/**
+ * Mutation atom to execute a relay direct execution.
+ * This handles the entire relay execution flow including chain switching and approval resets.
+ */
+export declare const startRelayDirectExecutionAtom: import("jotai").Atom<import("jotai-tanstack-query").AtomWithMutationResult<`0x${string}`, unknown, StartRelayExecutionParams, unknown>>;

package/dist/atoms/funkitCheckout.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Main entry point for Funkit checkout atoms.
+ * Re-exports all checkout-related atoms from their respective modules.
+ *
+ * API mirrors FunkitCheckoutContext interface:
+ * - Active checkout management
+ * - Checkout progress tracking
+ * - Withdrawal management
+ * - Quote management
+ */
+export { activeCheckoutAtom, applyDynamicRoutingAtom, assertCheckoutItem, cancelCheckoutAtom, confirmCheckoutAtom, initNewCheckoutAtom, resetCheckoutAtom, setCheckoutAtom, setCompletedTimestampAtom, startDirectExecutionCheckoutAtom, startRegularCheckoutAtom, updateCheckoutAtom, updateCustomRecipientAtom, updateDynamicRoutingIdAtom, updateModalTitleMetaAtom, updateSelectedPaymentMethodInfoAtom, updateSourceAssetAtom, updateTargetAssetAmountAtom, updateTargetAssetAtom, updateWithdrawalSourceAssetAmountAtom, } from './activeCheckout';
+export type { ConfirmCheckoutParams, StartDirectExecutionCheckoutParams, StartRegularCheckoutParams, UDAParams, } from './activeCheckout';
+export { checkoutsProgressAtom, getCheckoutProgressAtom, setCheckoutProgressAtom, } from './checkoutProgress';
+export { initNewWithdrawalAtom, setWithdrawalStateAtom, withdrawalStateAtom, } from './activeWithdrawal';
+export { clearQuoteMessagesAtom, getCheckoutQuoteAtom, isQuotingAtom, latestQuoteAtom, quoteErrorMessageAtom, quoteStepMessageAtom, resetQuoteOnLogoutAtom, setQuoteProgressAtom, } from './quote';
+export type { CheckoutQuoteError, CheckoutQuoteResult, CheckoutQuoteState, GetCheckoutQuoteParams, GetCheckoutQuoteResponse, } from './quote';
+export { connectorAtom, ensAvatarAtom, ensNameAtom, isUserLoggedInAtom, l2AddressAtom, loginTypeAtom, logoutSymbolAtom, syncWalletStateAtom, triggerLogoutAtom, userInfoAtom, walletAddressAtom, } from './generalWallet';
+export { LoginType } from './generalWallet';

package/dist/atoms/funkitProvider/index.d.ts

@@ -0,0 +1,24 @@
+import type { Locale } from '../../locales';
+import { type AvatarComponent } from '../../providers/AvatarContext';
+import { type FunkitConfig } from '../../providers/FunkitConfigContext';
+import { type ModalSizes } from '../../providers/ModalSizeContext';
+export declare const avatarAtom: import("jotai").WritableAtom<AvatarComponent, [AvatarComponent | ((prev: AvatarComponent | undefined) => AvatarComponent | undefined) | undefined], void>;
+export declare const modalSizeAtom: import("jotai").WritableAtom<NonNullable<ModalSizes | undefined>, [ModalSizes | ((prev: ModalSizes | undefined) => ModalSizes | undefined) | undefined], void>;
+export declare const funkitConfigAtom: import("jotai").WritableAtom<FunkitConfig, [FunkitConfig | ((prev: FunkitConfig | undefined) => FunkitConfig | undefined) | undefined], void>;
+export declare const sandboxAtom: import("jotai").WritableAtom<NonNullable<boolean | undefined>, [boolean | ((prev: boolean | undefined) => boolean | undefined) | undefined], void>;
+export declare const idAtom: import("jotai").PrimitiveAtom<string | undefined> & {
+    init: string | undefined;
+};
+export declare const initialChainAtom: import("jotai").PrimitiveAtom<number | undefined> & {
+    init: number | undefined;
+};
+export declare const debugAtom: import("jotai").PrimitiveAtom<boolean | undefined> & {
+    init: boolean | undefined;
+};
+export declare const localeAtom: import("jotai").PrimitiveAtom<Locale | undefined> & {
+    init: Locale | undefined;
+};
+export declare const funkitProviderThemeSelectorAtom: import("jotai").Atom<string>;
+export declare const funkitProviderThemeRootPropsAtom: import("jotai").Atom<{
+    "data-rk": string;
+}>;

package/dist/atoms/generalWallet.d.ts

@@ -0,0 +1,45 @@
+import type { Address } from 'viem';
+import type { Connector } from 'wagmi';
+import { type FunkitUserInfo } from '../consts/funkit';
+export declare enum LoginType {
+    Web3 = "web3",
+    Guest = "guest"
+}
+export declare const walletAddressAtom: import("jotai").WritableAtom<"" | `0x${string}`, [value: `0x${string}` | undefined], void>;
+export declare const connectorAtom: import("jotai").WritableAtom<Connector | undefined, [value: Connector | undefined], void>;
+export declare const ensNameAtom: import("jotai").WritableAtom<string | null | undefined, [value: string | null | undefined], void>;
+export declare const ensAvatarAtom: import("jotai").WritableAtom<string | null | undefined, [value: string | null | undefined], void>;
+export declare const l2AddressAtom: import("jotai").WritableAtom<string | undefined, [value: string | undefined], void>;
+/**
+ * Derived atom for login type based on connector presence.
+ */
+export declare const loginTypeAtom: import("jotai").Atom<LoginType>;
+/**
+ * Derived atom for whether the user is logged in.
+ */
+export declare const isUserLoggedInAtom: import("jotai").Atom<boolean>;
+/**
+ * Derived atom for user info computed from wallet state.
+ */
+export declare const userInfoAtom: import("jotai").Atom<FunkitUserInfo>;
+export declare const logoutSymbolAtom: import("jotai").WritableAtom<symbol | undefined, [value: symbol | undefined], void>;
+/**
+ * Write-only atom to trigger a new logout symbol.
+ * Used to signal logout across the app.
+ */
+export declare const triggerLogoutAtom: import("jotai").WritableAtom<null, [], void> & {
+    init: null;
+};
+/**
+ * Write-only atom to sync all wallet state from wagmi hooks.
+ * Called by GeneralWalletProvider to keep atoms in sync.
+ */
+export declare const syncWalletStateAtom: import("jotai").WritableAtom<null, [state: {
+    address: Address | undefined;
+    connector: Connector | undefined;
+    ensName: string | null | undefined;
+    ensAvatar: string | null | undefined;
+    l2Address: string | undefined;
+}], void> & {
+    init: null;
+};

package/dist/atoms/i18n.d.ts

@@ -0,0 +1,6 @@
+declare const i18nextAtom: import("jotai").PrimitiveAtom<import("i18next").i18n> & {
+    init: import("i18next").i18n;
+} & {
+    effect: import("jotai-effect").Effect;
+};
+export { i18nextAtom };

package/dist/atoms/modalState.d.ts

@@ -0,0 +1,30 @@
+import type { SelectedHomeTab } from '../modals/ProfileDetails/FunProfileViews/Home';
+import type { FunkitWithdrawalConfig } from '../providers/FunkitCheckoutContext';
+export declare const connectModalStateAtom: import("jotai").WritableAtom<boolean, [open: boolean], void>;
+export declare const accountModalStateAtom: import("jotai").WritableAtom<{
+    isOpen: boolean;
+    tab: SelectedHomeTab | null;
+}, [update: {
+    isOpen: boolean;
+    tab?: SelectedHomeTab | null;
+}], void>;
+export declare const chainModalStateAtom: import("jotai").WritableAtom<boolean, [open: boolean], void>;
+export declare const walletConnectModalStateAtom: import("jotai").WritableAtom<boolean, [open: boolean], void>;
+export declare const checkoutModalStateAtom: import("jotai").WritableAtom<{
+    isOpen: boolean;
+    checkoutId: string | null;
+}, [update: {
+    isOpen: boolean;
+    checkoutId?: string | null;
+}], void>;
+export declare const softHiddenCheckoutStateAtom: import("jotai").WritableAtom<string | null, [checkoutId: string | null], void>;
+export type WithdrawalModalConfig = FunkitWithdrawalConfig & {
+    withdrawalId: string;
+};
+export declare const withdrawalModalStateAtom: import("jotai").WritableAtom<{
+    isOpen: boolean;
+    config: WithdrawalModalConfig | null;
+}, [update: {
+    isOpen: boolean;
+    config?: WithdrawalModalConfig | null;
+}], void>;

package/dist/atoms/quote.d.ts

@@ -0,0 +1,98 @@
+import type { BluvoBrokerageQuote } from '../hooks/useBluvo';
+import type { FunkitActiveCheckoutItem } from '../providers/FunkitCheckoutContext';
+import type { FunkitCheckoutQuoteResult } from '../domains/quote';
+import type { FunkitDirectExecutionInfo } from './directExecution';
+export type CheckoutQuoteError = {
+    maxTargetAssetAmount?: number;
+    minTargetAssetAmount?: number;
+    reason: 'insufficientBalance';
+} | {
+    maxTargetAssetAmount?: number;
+    minTargetAssetAmount?: number;
+    minTargetUsdAmount?: number;
+    reason: 'insufficientAmount';
+} | {
+    originalError: Error;
+    reason: 'internal';
+};
+export type CheckoutQuoteResult = {
+    success: true;
+} | {
+    error: CheckoutQuoteError;
+    success: false;
+};
+export interface CheckoutQuoteState {
+    /** Whether the checkout quote is being fetched **/
+    isQuoting: boolean;
+    /** Latest checkout estimated fees and time **/
+    latestQuote: null | FunkitCheckoutQuoteResult;
+    /** The quotation step message **/
+    quoteStepMessage: string;
+    /** Error messages associated with checkout quote **/
+    quoteErrorMessage: string;
+}
+export type GetCheckoutQuoteResponse = CheckoutQuoteResult & {
+    shellCheckoutItemWithNextQuote: FunkitActiveCheckoutItem;
+    quoteState: CheckoutQuoteState;
+};
+export interface GetCheckoutQuoteParams {
+    getDirectExecutionInfo: (checkoutItem: FunkitActiveCheckoutItem) => FunkitDirectExecutionInfo;
+    getBluvoCheckoutQuote: (params: {
+        amount: string;
+        chainId: string;
+        symbol: string | null;
+    }) => Promise<BluvoBrokerageQuote | undefined>;
+    selectedBrokerageAsset?: {
+        amount?: number;
+    };
+    disableInformationStreaming?: boolean;
+}
+/**
+ * Read/write atom for the latest checkout quote.
+ */
+export declare const latestQuoteAtom: import("jotai").WritableAtom<FunkitCheckoutQuoteResult | null, [value: FunkitCheckoutQuoteResult | null], void>;
+/**
+ * Atom indicating whether a quote is being fetched.
+ */
+export declare const isQuotingAtom: import("jotai").PrimitiveAtom<boolean> & {
+    init: boolean;
+};
+/**
+ * Atom holding the current quote step message.
+ */
+export declare const quoteStepMessageAtom: import("jotai").PrimitiveAtom<string> & {
+    init: string;
+};
+/**
+ * Atom holding the current quote error message.
+ */
+export declare const quoteErrorMessageAtom: import("jotai").PrimitiveAtom<string> & {
+    init: string;
+};
+/**
+ * Write-only atom to set the quote progress state.
+ */
+export declare const setQuoteProgressAtom: import("jotai").WritableAtom<null, [state: {
+    isQuoting: boolean;
+    quoteStepMessage: string;
+    quoteErrorMessage: string;
+}], void> & {
+    init: null;
+};
+/**
+ * Write-only atom to clear quote messages.
+ */
+export declare const clearQuoteMessagesAtom: import("jotai").WritableAtom<null, [], void> & {
+    init: null;
+};
+/**
+ * Write-only atom to reset quote state on logout.
+ */
+export declare const resetQuoteOnLogoutAtom: import("jotai").WritableAtom<null, [logoutSymbol: symbol | null | undefined], void> & {
+    init: null;
+};
+/**
+ * Mutation atom to get a checkout quote.
+ * This is the main entry point for fetching quotes.
+ */
+export declare const getCheckoutQuoteAtom: import("jotai").Atom<import("jotai-tanstack-query").AtomWithMutationResult<GetCheckoutQuoteResponse, unknown, GetCheckoutQuoteParams, unknown>>;

package/dist/atoms/stepTransition.d.ts

@@ -0,0 +1,6 @@
+import { type SetStateAction } from 'jotai';
+import { type CheckoutModalState } from '../modals/CheckoutModal/stepTransition';
+export declare const stateHistoryAtom: import("jotai").PrimitiveAtom<CheckoutModalState[]> & {
+    init: CheckoutModalState[];
+};
+export declare const modalStateAtom: import("jotai").WritableAtom<CheckoutModalState, [update: SetStateAction<CheckoutModalState>], void>;

package/dist/atoms/store.d.ts

@@ -0,0 +1 @@
+export declare const funkitStore: import("jotai/vanilla/internals").INTERNAL_Store;

package/dist/atoms/track/index.d.ts

@@ -0,0 +1,10 @@
+import { StatsigClient } from '@statsig/react-bindings';
+import type { CheckoutModalEvent } from '../../hooks/track/CheckoutModalEvent';
+import type { WithdrawModalEvent } from '../../hooks/track/WithdrawModalEvent';
+export declare const eventCountsAtom: import("jotai").PrimitiveAtom<Partial<Record<CheckoutModalEvent | WithdrawModalEvent, number>>> & {
+    init: Partial<Record<CheckoutModalEvent | WithdrawModalEvent, number>>;
+};
+export declare const eventStartTimesAtom: import("jotai").PrimitiveAtom<Partial<Record<CheckoutModalEvent | WithdrawModalEvent, number>>> & {
+    init: Partial<Record<CheckoutModalEvent | WithdrawModalEvent, number>>;
+};
+export declare const statsigClientAtom: import("jotai").Atom<StatsigClient>;

package/dist/atoms/utils.d.ts

@@ -0,0 +1,2 @@
+import type { WritableAtom } from 'jotai';
+export declare const atomWithFallback: <T, Args extends unknown[], Result>(atom: WritableAtom<T, Args, Result>, fallback: NonNullable<T>) => WritableAtom<NonNullable<T>, Args, Result>;

package/dist/atoms/wagmi.d.ts

@@ -0,0 +1,4 @@
+import type { Config } from 'wagmi';
+export declare const wagmiConfigAtom: import("jotai").PrimitiveAtom<Config | undefined> & {
+    init: Config | undefined;
+};