@funkit/connect 3.0.3 → 3.1.1

package/dist/modals/CheckoutModal/CheckoutComplete.d.ts

@@ -0,0 +1,13 @@
+import { Address } from 'viem';
+import { CheckoutModalCommonState, FunCheckoutStep } from './stepTransition';
+export interface CheckoutCompleteState extends CheckoutModalCommonState {
+    step: FunCheckoutStep.CHECKOUT_COMPLETE;
+    depositAddress: Address;
+}
+type Props = {
+    modalState: CheckoutCompleteState;
+    onClose: () => void;
+};
+/** A placeholder component to handle redirecting to the checkout history page */
+export declare function CheckoutComplete({ modalState, onClose }: Props): null;
+export {};

package/dist/modals/{FunCheckoutModal/FunCheckoutPrimaryInfo.d.ts → CheckoutModal/CheckoutPrimaryInfo.d.ts}

@@ -7,7 +7,7 @@ export declare function CheckoutPrimaryInfoSnapshot({ checkoutItem, isLoading, p
     preserveMinHeight?: boolean;
 }): React.JSX.Element;
 export declare function CheckoutPrimaryInfo({ checkoutId, prioritizeDraftValue, preserveMinHeight, }: {
-    checkoutId: string | null;
+    checkoutId: string;
     prioritizeDraftValue: boolean;
     preserveMinHeight?: boolean;
 }): React.JSX.Element | null;

package/dist/modals/CheckoutModal/ConfirmationStep.d.ts

@@ -0,0 +1,36 @@
+import React from 'react';
+import { Address } from 'viem';
+import { PaymentMethodInfo } from '../../consts/payment';
+import { CheckoutModalCommonState, FunCheckoutStep, StateTransitionProps, StepTransition, TransitionPayload } from './stepTransition';
+interface MoonpayDepositData {
+    depositToken: string;
+    depositTokenAmount: number;
+    depositTokenChainId: string;
+}
+/**
+ * controls in what interval to refresh the quote data in case of a hard refresh, in case of pre-loading it controls when to set the data, should be more than `BEFORE_COUNTDOWN_ENDS_SEC` by at least 10 seconds to provide the API the time needed to complete the call
+ */
+export declare const ESTIMATE_REFRESH_INTERVAL_SEC = 60;
+/**
+ * controls how soon before the end of `ESTIMATE_REFRESH_INTERVAL_SEC` to pre-load the quote data
+ */
+export declare const BEFORE_COUNTDOWN_ENDS_SEC = 10;
+export interface ConfirmationStepState extends CheckoutModalCommonState {
+    step: FunCheckoutStep.CONFIRMATION;
+    paymentMethodInfo: PaymentMethodInfo;
+    countdown: number;
+    countdownKey: number;
+    beforeCountdownEndsSeconds: number;
+    onBeforeCountdownEnds?: () => void;
+    onCountdownLastSecond?: () => void;
+    onCountdownEnded?: () => void;
+}
+export type ConfirmationStepNext = TransitionPayload<{
+    depositAddress: Address;
+    step: FunCheckoutStep.CONFIRMATION;
+    moonpayData?: MoonpayDepositData;
+    paymentMethodInfo: PaymentMethodInfo;
+}>;
+export declare function confirmationStepNext(state: ConfirmationStepState, payload: ConfirmationStepNext): StepTransition[FunCheckoutStep.CONFIRMATION];
+export declare function ConfirmationStep({ modalState, onNext, setModalState, }: StateTransitionProps<ConfirmationStepState, ConfirmationStepNext>): React.JSX.Element;
+export {};

package/dist/modals/CheckoutModal/ConnectExchange.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+import { PaymentMethodInfo } from '../../consts/payment';
+import { MeshExchanges } from '../../utils/mesh';
+import { CheckoutModalCommonState, FunCheckoutStep, StateTransitionProps, StepTransition, TransitionPayload } from './stepTransition';
+export interface ConnectExchangeState extends CheckoutModalCommonState {
+    step: FunCheckoutStep.CONNECT_EXCHANGE;
+    exchange: MeshExchanges;
+}
+export type ConnectExchangeNext = TransitionPayload<{
+    step: FunCheckoutStep.CONNECT_EXCHANGE;
+    paymentMethodInfo: PaymentMethodInfo;
+}>;
+export declare function connectExchangeNext(state: ConnectExchangeState, payload: ConnectExchangeNext): StepTransition[FunCheckoutStep.CONNECT_EXCHANGE];
+type Props = StateTransitionProps<ConnectExchangeState, ConnectExchangeNext>;
+export declare function ConnectExchange({ modalState, onNext, setModalState }: Props): React.JSX.Element;
+export {};

package/dist/modals/CheckoutModal/FunCheckoutModal.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+interface FunCheckoutModalProps {
+    open: boolean;
+    onClose: () => void;
+    checkoutId: string | null;
+}
+export declare function FunCheckoutModal({ onClose, open, checkoutId, }: FunCheckoutModalProps): React.JSX.Element | null;
+export {};

package/dist/modals/CheckoutModal/InputAmount.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import { CheckoutModalCommonState, FunCheckoutStep, StateTransitionProps, StepTransition, TransitionPayload } from './stepTransition';
+export interface InputAmountState extends CheckoutModalCommonState {
+    step: FunCheckoutStep.INPUT_AMOUNT;
+}
+export type InputAmountNext = TransitionPayload<{
+    step: FunCheckoutStep.INPUT_AMOUNT;
+}>;
+export declare function inputAmountNext(state: InputAmountState, payload: InputAmountNext): StepTransition[FunCheckoutStep.INPUT_AMOUNT];
+export declare function InputAmount({ modalState, onNext, }: StateTransitionProps<InputAmountState, InputAmountNext>): React.JSX.Element;

package/dist/modals/CheckoutModal/MeshVerification.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import { Address } from 'viem';
+import { PaymentMethodInfo } from '../../consts/payment';
+import { CheckoutModalCommonState, FunCheckoutStep, StateTransitionProps, StepTransition, TransitionPayload } from './stepTransition';
+export interface MeshVerificationState extends CheckoutModalCommonState {
+    step: FunCheckoutStep.MESH_VERIFICATION;
+    paymentMethodInfo: PaymentMethodInfo;
+}
+export type MeshVerificationNext = TransitionPayload<{
+    depositAddress: Address;
+    step: FunCheckoutStep.MESH_VERIFICATION;
+}>;
+export declare function meshVerificationNext(state: MeshVerificationState, payload: MeshVerificationNext): StepTransition[FunCheckoutStep.MESH_VERIFICATION];
+export declare function MeshVerification({ modalState, onNext, }: StateTransitionProps<MeshVerificationState, MeshVerificationNext>): React.JSX.Element;

package/dist/modals/CheckoutModal/PaymentSetup.d.ts

@@ -0,0 +1,38 @@
+import React from 'react';
+import { Address } from 'viem';
+import { PaymentMethod, PaymentMethodInfo } from '../../consts/payment';
+import { MeshExchanges } from '../../utils/mesh';
+import { CheckoutModalCommonState, FunCheckoutStep, StateTransitionProps, StepTransition, TransitionPayload } from './stepTransition';
+export type PaymentSetupState = CheckoutModalCommonState & {
+    step: FunCheckoutStep.PAYMENT_SETUP;
+} & ({
+    paymentMethod: PaymentMethod.BROKERAGE;
+} | {
+    paymentMethod: PaymentMethod.CARD;
+    paymentAddress: Address;
+    token: string;
+    tokenChainId: string;
+    depositAmount: number;
+} | {
+    paymentMethod: PaymentMethod.TRANSFER;
+    address: Address;
+});
+export type PaymentSetupNext = TransitionPayload<{
+    step: FunCheckoutStep.PAYMENT_SETUP;
+    hasActiveConnection: true;
+    paymentMethod: PaymentMethod.BROKERAGE;
+    paymentInfo: PaymentMethodInfo;
+} | {
+    step: FunCheckoutStep.PAYMENT_SETUP;
+    hasActiveConnection: false;
+    paymentMethod: PaymentMethod.BROKERAGE;
+    exchange: MeshExchanges;
+} | {
+    step: FunCheckoutStep.PAYMENT_SETUP;
+    paymentMethod: PaymentMethod.CARD;
+    depositAddress: Address;
+}>;
+export declare function paymentSetupNext(state: PaymentSetupState, payload: PaymentSetupNext): StepTransition[FunCheckoutStep.PAYMENT_SETUP];
+type Props = StateTransitionProps<PaymentSetupState, PaymentSetupNext>;
+export declare function PaymentSetup({ modalState, onNext }: Props): React.JSX.Element | null;
+export {};

package/dist/modals/CheckoutModal/SelectAsset.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import { PaymentMethodInfo } from '../../consts/payment';
+import { CheckoutModalCommonState, FunCheckoutStep, StateTransitionProps, StepTransition, TransitionPayload } from './stepTransition';
+export interface SelectAssetState extends CheckoutModalCommonState {
+    step: FunCheckoutStep.SELECT_ASSET;
+    paymentMethodInfo: PaymentMethodInfo;
+}
+export type SelectAssetNext = TransitionPayload<{
+    step: FunCheckoutStep.SELECT_ASSET;
+    isQuoteSuccess: true;
+}>;
+export declare function selectAssetNext(state: SelectAssetState, payload: SelectAssetNext): StepTransition[FunCheckoutStep.SELECT_ASSET];
+type Props = StateTransitionProps<SelectAssetState, SelectAssetNext>;
+export declare function SelectAsset({ modalState, onBack, onNext }: Props): React.JSX.Element;
+export {};

package/dist/modals/CheckoutModal/SelectPaymentMethod.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+import { PaymentMethod, PaymentMethodInfo } from '../../consts/payment';
+import { CheckoutModalCommonState, FunCheckoutStep, StateTransitionProps, StepTransition, TransitionPayload } from './stepTransition';
+export interface SelectPaymentMethodState extends CheckoutModalCommonState {
+    step: FunCheckoutStep.SELECT_PAYMENT_METHOD;
+}
+export type SelectPaymentMethodNext = TransitionPayload<{
+    step: FunCheckoutStep.SELECT_PAYMENT_METHOD;
+    paymentMethod: PaymentMethod.TRANSFER | PaymentMethod.BROKERAGE;
+} | {
+    step: FunCheckoutStep.SELECT_PAYMENT_METHOD;
+    paymentMethod: PaymentMethod.CARD | PaymentMethod.ACCOUNT_BALANCE;
+    paymentMethodInfo: PaymentMethodInfo;
+}>;
+export declare function selectPaymentMethodNext(state: SelectPaymentMethodState, payload: SelectPaymentMethodNext): StepTransition[FunCheckoutStep.SELECT_PAYMENT_METHOD];
+type Props = StateTransitionProps<SelectPaymentMethodState, SelectPaymentMethodNext>;
+export declare function SelectPaymentMethod({ modalState, onNext, onClose }: Props): React.JSX.Element;
+export {};

package/dist/modals/CheckoutModal/stepTransition.d.ts

@@ -0,0 +1,74 @@
+import { Dispatch, SetStateAction } from 'react';
+import { FunkitActiveCheckoutItem } from '../../providers/FunkitCheckoutContext';
+import { CheckoutCompleteState } from './CheckoutComplete';
+import { ConfirmationStepNext, ConfirmationStepState } from './ConfirmationStep';
+import { ConnectExchangeNext, ConnectExchangeState } from './ConnectExchange';
+import { InputAmountNext, InputAmountState } from './InputAmount';
+import { MeshVerificationNext, MeshVerificationState } from './MeshVerification';
+import { PaymentSetupNext, PaymentSetupState } from './PaymentSetup';
+import { SelectAssetNext, SelectAssetState } from './SelectAsset';
+import { SelectPaymentMethodNext, SelectPaymentMethodState } from './SelectPaymentMethod';
+export interface CheckoutModalCommonState {
+    checkoutId: string;
+    isSoftHidden: boolean;
+    countdown?: number;
+    countdownKey?: number;
+    beforeCountdownEndsSeconds?: number;
+    onBeforeCountdownEnds?: () => void;
+    onCountdownLastSecond?: () => void;
+    onCountdownEnded?: () => void;
+}
+export interface StateTransitionProps<T, N> {
+    modalState: T;
+    setModalState: Dispatch<SetStateAction<CheckoutModalState>>;
+    onNext: (payload: N) => void;
+    onBack: () => void;
+    onClose: () => void;
+}
+export declare function extractCommonState(state: CheckoutModalState): CheckoutModalCommonState;
+type CheckoutModalState = ConfirmationStepState | ConnectExchangeState | InputAmountState | SelectAssetState | SelectPaymentMethodState | PaymentSetupState | MeshVerificationState | CheckoutCompleteState;
+export declare enum FunCheckoutStep {
+    INPUT_AMOUNT = "input_amount",
+    SELECT_PAYMENT_METHOD = "select_payment",
+    CONFIRMATION = "confirmation",
+    PAYMENT_SETUP = "payment_setup",
+    CONNECT_EXCHANGE = "connect_exchange",
+    SELECT_ASSET = "select_asset",
+    MESH_VERIFICATION = "mesh_verification",
+    CHECKOUT_COMPLETE = "checkout_complete"
+}
+export interface StepTransition {
+    [FunCheckoutStep.INPUT_AMOUNT]: SelectPaymentMethodState | InputAmountState;
+    [FunCheckoutStep.SELECT_PAYMENT_METHOD]: SelectAssetState | PaymentSetupState | ConfirmationStepState | InputAmountState;
+    [FunCheckoutStep.CONFIRMATION]: MeshVerificationState | PaymentSetupState | SelectPaymentMethodState | SelectAssetState | ConfirmationStepState | CheckoutCompleteState;
+    [FunCheckoutStep.PAYMENT_SETUP]: SelectAssetState | ConnectExchangeState | SelectPaymentMethodState | CheckoutCompleteState;
+    [FunCheckoutStep.CONNECT_EXCHANGE]: SelectAssetState | PaymentSetupState;
+    [FunCheckoutStep.SELECT_ASSET]: SelectPaymentMethodState | PaymentSetupState | ConfirmationStepState;
+    [FunCheckoutStep.MESH_VERIFICATION]: ConfirmationStepState | MeshVerificationState | CheckoutCompleteState;
+}
+export type TransitionPayload<T extends {
+    step: FunCheckoutStep;
+}> = (T & {
+    isBack?: false;
+}) | {
+    step: T['step'];
+    isBack: true;
+};
+type NextPayload = ConfirmationStepNext | ConnectExchangeNext | InputAmountNext | MeshVerificationNext | PaymentSetupNext | SelectAssetNext | SelectPaymentMethodNext | TransitionPayload<{
+    step: FunCheckoutStep.CHECKOUT_COMPLETE;
+}>;
+export declare function useCheckoutModalTransition(checkoutItem: FunkitActiveCheckoutItem, onClose: () => void): {
+    animateOut: boolean;
+    modalState: CheckoutModalState;
+    onBack: () => void;
+    onCloseWrapper: () => void;
+    onNext: (payload: NextPayload) => void;
+    setModalState: Dispatch<SetStateAction<CheckoutModalState>>;
+};
+interface TitleConfig {
+    hasBack: boolean;
+    title: string;
+    showFullHeight: boolean;
+}
+export declare function useTitleConfig(checkoutItem: FunkitActiveCheckoutItem, state: CheckoutModalState): TitleConfig;
+export {};

package/dist/modals/CheckoutModal/useAccountBalancePostCheckout.d.ts

@@ -0,0 +1,3 @@
+import { Address } from 'viem';
+import { useFunkitConfig } from '../../providers/FunkitConfigContext';
+export declare function useAccountBalancePostCheckout(checkoutId: string, setPostCheckoutStepMessage: (s: string) => void, funkitConfig: ReturnType<typeof useFunkitConfig>): (depositAddress: Address) => Promise<void>;

package/dist/modals/CheckoutModal/useAssetPrice.d.ts

@@ -0,0 +1,9 @@
+import { Address } from 'viem';
+export declare function useAssetPrice({ chainId, assetTokenAddress, }: {
+    chainId: string | undefined;
+    assetTokenAddress: Address | undefined;
+}): {
+    error: Error | null;
+    isLoading: boolean;
+    unitPrice: number | undefined;
+};

package/dist/modals/CheckoutModal/useBottomSection.d.ts

@@ -0,0 +1,2 @@
+export declare const CHECKOUT_MODAL_BOTTOM_BAR_ID = "checkout-modal-bottom-bar";
+export declare function useBottomSectionRef(): HTMLElement | null;

package/dist/modals/CheckoutModal/useRedirectToCheckoutHistory.d.ts

@@ -0,0 +1,3 @@
+import { Address } from 'viem';
+import { FunkitActiveCheckoutItem } from '../../providers/FunkitCheckoutContext';
+export declare function useRedirectToCheckoutHistory(checkoutItem: FunkitActiveCheckoutItem | null, onClose: () => void): (depositAddress: Address) => void;

package/dist/modals/CheckoutModal/useSourceAssetConfirm.d.ts

@@ -0,0 +1,25 @@
+import { PaymentMethodInfo } from '../../consts/payment';
+import { FunkitActiveCheckoutItem } from '../../providers/FunkitCheckoutContext';
+export interface SourceAssetConfirmed {
+    isQuoteSuccess: boolean;
+    newPaymentMethodInfo: PaymentMethodInfo;
+    quoteObject?: FunkitActiveCheckoutItem;
+}
+export type OnSourceAssetConfirmed = (confirmed: SourceAssetConfirmed | undefined) => void;
+/**
+ *
+ * Note: this hook is EXTREMELY confusing in what is doing
+ * first, it useHackyTriggerWorkaroundReactDevBrainExplode to wait React's setState
+ * and read the latest update of the checkoutItem
+ * second, it will trigger a quote request to the backend
+ * and write the value back to the checkoutItem
+ * finally, it will also set the newPaymentMethodInfo to
+ * the checkoutItem
+ *
+ * USE THIS WITH CAUTION
+ **/
+export declare function useTriggerQuoteAndOtherStuffsWithExtremeCaution(checkoutId: string, onSuccess: (confirmed: SourceAssetConfirmed | undefined) => void, setPreloadedQuoteData?: (quoteData: FunkitActiveCheckoutItem) => void): {
+    isSourceAssetConfirming: boolean;
+    triggerAssetConfirm: () => void;
+    onSourceAssetConfirmed: (preloadQuoteData?: boolean) => Promise<SourceAssetConfirmed | undefined>;
+};

package/dist/modals/CheckoutModal/useUpdateSourceAssetForCard.d.ts

@@ -0,0 +1,2 @@
+import { OnSourceAssetConfirmed } from './useSourceAssetConfirm';
+export declare function useUpdateCardSourceAsset(checkoutId: string, onSuccess: OnSourceAssetConfirmed): () => Promise<void>;

package/dist/providers/FunkitCheckoutContext.d.ts

@@ -4,6 +4,7 @@ import { Abi, Address } from 'viem';
 import { CheckoutFeesBreakdownItem } from '../consts/checkoutFees';
 import { PaymentMethod, PaymentMethodInfo } from '../consts/payment';
 import { CheckoutHistoryStateMap } from '../utils/checkout';
+import { PurifiedCheckoutHistoryItem } from '../utils/purifyCheckoutHistoryItem';
 export interface FunkitCheckoutActionParams {
     contractAbi: Abi;
     contractAddress: Address;
@@ -16,8 +17,6 @@ export interface FunkitCheckoutConfig {
     /** ****************************
      * Api-related configurations *
      ******************************/
-    /** List of contract action params **/
-    actionsParams: FunkitCheckoutActionParams[];
     /** The ID of the chain where the checkout operation is to be performed. **/
     targetChain: string;
     /** The wanted asset for the checkout operation. This can be either a chain native token (by specifying NATIVE_TOKEN) or an ERC-20 token (by specifying actual token address) on the target chain. **/
@@ -32,6 +31,8 @@ export interface FunkitCheckoutConfig {
     customRecipient?: Address | DydxAddress;
     /** If available, the specified payment method will be selected by default during checkout or deposits **/
     defaultPaymentMethod?: PaymentMethod | undefined;
+    /** List of contract action params **/
+    generateActionsParams?: (targetAssetAmount: number) => FunkitCheckoutActionParams[];
     /** ****************************************
      * Checkout ModalUI-related configurations *
      *******************************************/
@@ -126,8 +127,6 @@ export interface FunkitActiveCheckoutItem {
         symbol: string | null;
         chainId: string;
     };
-    /** Whether the checkout is fastforwarded to confirmation page because the user's funwallet already has sufficient target asset */
-    isFastForwarded: boolean;
 }
 export declare function FunkitCheckoutProvider({ children }: {
     children: ReactNode;
@@ -142,12 +141,17 @@ interface useFunkitPreCheckoutInternalReturn {
     cancelCheckout: (depositAddress: Address) => Promise<boolean>;
     getCheckoutDraftDollarValue: () => Promise<void>;
     clearCheckoutQuoteMessages: () => void;
-    getCheckoutQuote: (sponsorInitialTransferGasLimit: number, newPaymentMethodInfo: PaymentMethodInfo) => Promise<boolean>;
+    getCheckoutQuote: (sponsorInitialTransferGasLimit: number, newPaymentMethodInfo: PaymentMethodInfo, disableInformationStreaming?: boolean) => Promise<{
+        success: boolean;
+        shellCheckoutItemWithNextQuote: FunkitActiveCheckoutItem | undefined;
+        errorObject?: any;
+    }>;
+    setCheckoutQuote: (quote: FunkitActiveCheckoutItem) => void;
 }
 /**
  * Internal hook to handle frontend pre-checkout operations, PER-CHECKOUT ITEM.
  */
-export declare const useFunkitPreCheckoutInternal: (checkoutId: string | null) => useFunkitPreCheckoutInternalReturn;
+export declare const useFunkitPreCheckoutInternal: (checkoutId: string) => useFunkitPreCheckoutInternalReturn;
 /**
  * Internal hook to handle post-checkout, PER-BACKEND-CHECKOUT ITEM.
  */
@@ -172,4 +176,18 @@ export declare const useFunkitAllPostCheckoutsInternal: () => {
 export declare const useFunkitCheckout: (props: useFunkitCheckoutProps) => {
     beginCheckout: (inputConfig?: FunkitCheckoutConfig) => Promise<void>;
 };
+/**
+ * External hook to listen for checkout history every 5000ms
+ *
+ * @param userId ID of the user (wallet address)
+ * @returns PurifiedCheckoutHistoryItem[]
+ */
+export declare function useCheckoutsListenerByUserId(userId: string): PurifiedCheckoutHistoryItem[];
+/**
+ * External hook to listen for checkout history every 5000ms
+ *
+ * @param checkoutId ID of the checkout
+ * @returns PurifiedCheckoutHistoryItem | undefined
+ */
+export declare function useCheckoutListenerByCheckoutId(checkoutId: string): PurifiedCheckoutHistoryItem | undefined;
 export {};

package/dist/providers/FunkitMeshProvider.d.ts

@@ -7,14 +7,20 @@ interface MeshBrokerDataMap {
     };
 }
 export declare function FunkitMeshProvider({ children }: any): React.JSX.Element;
-export declare function useFunkitMesh({ onBeforeConnect, onConnected, onMeshModalClose, }: {
-    onBeforeConnect?: () => void;
-    onConnected?: (brokerData: LinkPayload | null) => void;
-    onMeshModalClose?: () => void;
-}): {
+export declare function useFunkitMesh(_notUsedToDelete?: unknown): {
     meshBrokerDataMap: MeshBrokerDataMap;
-    connectToBrokerage: (brokerage: MeshExchanges) => Promise<void>;
     unlinkBrokerage: (exchange: MeshExchanges) => void;
     hasActiveConnectionCheck: (brokerage: MeshExchanges) => boolean;
 };
+interface FunkitMeshHook {
+    onBeforeConnect(): void;
+    onConnected(brokerData: LinkPayload | null): void;
+    onMeshModalClose(): void;
+}
+/**
+ * all hooks SHOULD be in object method style
+ * capturing the latest value in render.
+ * useMeshConnect will return a stable function.
+ * */
+export declare function useMeshConnect(hooks: FunkitMeshHook): (brokerage: MeshExchanges) => Promise<void>;
 export {};

package/dist/providers/FunkitMoonpayProvider.d.ts

@@ -1,4 +1,5 @@
 import React from 'react';
+import { FunButtonProps } from '../components/FunButton/FunButton';
 export declare function FunkitMoonpayProvider({ children, debug, }: {
     children: any;
     debug: boolean;
@@ -16,9 +17,10 @@ interface UserIpInfoFromMoonpay {
     isLowLimitEnabled: boolean;
     state: string;
 }
+export declare const geoCheckInProgressProps: FunButtonProps;
 export declare function useFunkitUserIp(): {
-    userIpInfo: UserIpInfoFromMoonpay | null;
     isLoadingGeoCheck: boolean;
     isUserBlockedForCheckout: boolean;
+    userIpInfo: UserIpInfoFromMoonpay | undefined;
 };
 export {};

package/dist/providers/ModalContext.d.ts

@@ -11,7 +11,7 @@ export declare function useModalState(): {
 };
 export declare function useAccountModal(): {
     accountModalOpen: boolean;
-    openAccountModal: ((tab: SelectedHomeTab | null) => void) | undefined;
+    openAccountModal: ((tab?: SelectedHomeTab | null) => void) | undefined;
 };
 export declare function useChainModal(): {
     chainModalOpen: boolean;

package/dist/utils/{assetAbort.d.ts → aborts.d.ts}

@@ -6,4 +6,5 @@ declare class AssetAbortClass {
     abort(reason?: any): void;
 }
 export declare const singletonAssetAbort: AssetAbortClass;
+export declare const singletonCheckoutAbort: AssetAbortClass;
 export {};

package/dist/utils/assets.d.ts

@@ -1,5 +1,5 @@
 import { PaymentMethod } from '../consts/payment';
-import { FunkitActiveCheckoutItem } from '../providers/FunkitCheckoutContext';
+import { FunkitActiveCheckoutItem, FunkitCheckoutConfig } from '../providers/FunkitCheckoutContext';
 export declare const getNormalizedTokenBalance: (tokenBalance: number, decimals: number) => number;
 export declare const isAssetUsableToPayForCheckout: (checkoutItem: FunkitActiveCheckoutItem, paymentMethod: PaymentMethod, assetChainId: string, assetTokenAddress: string, isWeb2Login: boolean, isWeb3Login: boolean) => {
     isUsable: boolean;
@@ -30,3 +30,10 @@ export type RecommendedAsset = {
     label: string | null;
 } | null;
 export declare const getRecommendedAsset: (checkoutItem: FunkitActiveCheckoutItem, accountHoldingsMap: AssetHoldingsMap, isWeb3Login: boolean, isWeb2Login: boolean) => RecommendedAsset;
+/**
+ *
+ * @param {FunkitCheckoutConfig} checkoutConfig
+ * @param mockedChains optional array of additional chains we want to replace with FALLBACK_CHAIN_ID
+ * @returns targetChain either from the provided config or arbitrum chainId for dydxChain since that's a non evm chain processed with evm tech
+ */
+export declare const getMockedTargetChainId: ({ targetChain }: FunkitCheckoutConfig, mockedChains?: string[]) => string;

package/dist/utils/checkout.d.ts

@@ -117,10 +117,10 @@ export declare function getEstimateEndTimeInfo(createdTimeMs: number, checkoutIt
     isExceededEstimation: boolean;
 };
 /**
- * Given a checkout config and checkout item, returns the display string for the checkout item.
+ * Given a checkout config, returns the display string for the checkout item.
  * Arbitary action checkouts: Display the checkoutItemAmount if it is greater than 0, otherwise display the checkoutItemTitle.
  * - e.g. "2.1234 aArbUSDCn" or "Staked VRTX"
  * Basic buy checkouts: Display the targetAssetAmount with the targetAssetTicker.
  * - e.g. "0.12345 ETH"
  */
-export declare function getCheckoutItemDisplay(checkoutConfig: FunkitCheckoutConfig, checkoutItem: FunkitActiveCheckoutItem, hideAmount?: boolean): string;
+export declare function getCheckoutItemDisplay(checkoutConfig: FunkitCheckoutConfig, hideAmount?: boolean): string;

package/dist/utils/exhaustiveCheck.d.ts

@@ -0,0 +1 @@
+export declare function exhaustiveCheck(_value: never): any;

package/dist/utils/flags/config.d.ts

@@ -5,15 +5,6 @@ import type { BooleanFlagConfig, StringFlagConfig } from './types';
  * Once we ship a feature flag, we can't change the key.
  */
 export declare enum FlagKey {
-    /** Custom text for the select payment method button */
-    SelectPaymentMethodText = "select_payment_method_text",
-    /**
-     * Changing the copy for each of three payment methods:
-     * - “Cross-Chain Swap” → Wallet
-     * - “Debit or Credit” → Card
-     * - “Brokerage or Exchange” → Exchange
-     */
-    PaymentMethodCopyV1 = "payment_method_copy_v1",
     /** Whether mantle assets can be used as source asset for payment for any checkout */
     DisableMantleSourceAssets = "disable_mantle_source_assets",
     /** Whether zksync assets can be used as source asset for payment in a mantle checkout  */
@@ -28,7 +19,6 @@ export declare enum FlagKey {
     ShowPoweredTagline = "show_powered_tagline"
 }
 export declare const flagConfig: {
-    [FlagKey.PaymentMethodCopyV1]: BooleanFlagConfig;
     [FlagKey.DisableMantleSourceAssets]: BooleanFlagConfig;
     [FlagKey.DisableZkSyncSourceAssetsForMantleCheckouts]: BooleanFlagConfig;
     [FlagKey.DisableZkSyncSourceAssetsForDydxCheckouts]: BooleanFlagConfig;

package/dist/utils/flags/index.d.ts

@@ -2,7 +2,6 @@ import { FlagKey } from './config';
 import { FeatureFlag } from './impl';
 export { FlagKey };
 declare const singleton: FeatureFlag<{
-    payment_method_copy_v1: import("./types").BooleanFlagConfig;
     disable_mantle_source_assets: import("./types").BooleanFlagConfig;
     disable_zksync_source_assets_for_mantle_checkouts: import("./types").BooleanFlagConfig;
     disable_zksync_source_assets_for_dydx_checkouts: import("./types").BooleanFlagConfig;

package/dist/utils/funLogger.d.ts

@@ -8,7 +8,7 @@ declare class FunLogger {
     protected sdkVersion: string | null;
     constructor();
     private getFunLogEnv;
-    private decorateLogDataForDdog;
+    private logDataDog;
     private onDebug;
     private onInfo;
     private onWarn;

package/dist/utils/mesh.d.ts

@@ -21,7 +21,7 @@ export declare enum MeshExchanges {
     Bitstamp = "Bitstamp",
     GateIo = "GateIo",
     Acorns = "Acorns",
-    Okx = "Okx",
+    Okx = "OKX",
     BitFlyer = "BitFlyer",
     Coinlist = "Coinlist",
     Huobi = "Huobi",

package/dist/utils/purifyCheckoutHistoryItem.d.ts

@@ -0,0 +1,3 @@
+import { CheckoutHistoryItem } from '@funkit/api-base';
+export type PurifiedCheckoutHistoryItem = Pick<CheckoutHistoryItem, 'depositAddr' | 'state' | 'fromChainId' | 'fromTokenAddress' | 'toChainId' | 'toTokenAddress' | 'toAmountBaseUnit'>;
+export declare const purifyCheckoutHistoryItem: (item: CheckoutHistoryItem) => PurifiedCheckoutHistoryItem;

package/dist/wallets/walletConnectors/chunk-FLTQRYFS.js

@@ -0,0 +1,27 @@
+"use client";
+import {
+  getInjectedConnector,
+  hasInjectedProvider
+} from "./chunk-WRA2DVJ7.js";
+import {
+  isIOS
+} from "./chunk-RETKWSKD.js";
+
+// src/wallets/walletConnectors/dawnWallet/dawnWallet.ts
+var dawnWallet = () => ({
+  id: "dawn",
+  name: "Dawn",
+  iconUrl: async () => (await import("./dawnWallet-ONVAA3S4.js")).default,
+  iconBackground: "#000000",
+  installed: hasInjectedProvider({ flag: "isDawn" }),
+  hidden: () => !isIOS(),
+  downloadUrls: {
+    ios: "https://apps.apple.com/us/app/dawn-ethereum-wallet/id1673143782",
+    mobile: "https://dawnwallet.xyz"
+  },
+  createConnector: getInjectedConnector({ flag: "isDawn" })
+});
+
+export {
+  dawnWallet
+};