@funkit/connect 3.1.0 → 3.2.0

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

@@ -1,13 +1,15 @@
 import React from 'react';
 import { FunkitActiveCheckoutItem } from '../../providers/FunkitCheckoutContext';
-export declare function CheckoutPrimaryInfoSnapshot({ checkoutItem, isLoading, prioritizeDraftValue, preserveMinHeight, }: {
+export declare function CheckoutPrimaryInfoSnapshot({ checkoutItem, isLoading, prioritizeDraftValue, preserveMinHeight, showTokenAmount, }: {
     checkoutItem: FunkitActiveCheckoutItem;
     isLoading: boolean;
     prioritizeDraftValue: boolean;
     preserveMinHeight?: boolean;
+    showTokenAmount?: boolean;
 }): React.JSX.Element;
-export declare function CheckoutPrimaryInfo({ checkoutId, prioritizeDraftValue, preserveMinHeight, }: {
+export declare function CheckoutPrimaryInfo({ checkoutId, prioritizeDraftValue, preserveMinHeight, showTokenAmount, }: {
     checkoutId: string;
     prioritizeDraftValue: boolean;
     preserveMinHeight?: boolean;
+    showTokenAmount?: boolean;
 }): React.JSX.Element | null;

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

@@ -1,7 +1,7 @@
 import React from 'react';
 import { Address } from 'viem';
 import { PaymentMethodInfo } from '../../consts/payment';
-import { CheckoutModalCommonState, FunCheckoutStep, StateTransitionProps, StepTransition, TransitionPayload } from './stepTransition';
+import { CheckoutModalCommonState, FunCheckoutStep, StateTransitionProps, StepTransition } from './stepTransition';
 interface MoonpayDepositData {
     depositToken: string;
     depositTokenAmount: number;
@@ -18,19 +18,14 @@ 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;
+    isCloseButtonHidden: boolean;
 }
-export type ConfirmationStepNext = TransitionPayload<{
+export type ConfirmationStepNext = {
     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

@@ -1,15 +1,15 @@
 import React from 'react';
-import { PaymentMethodInfo } from '../../consts/payment';
+import { PaymentMethodBrokerageInfo } from '../../consts/payment';
 import { MeshExchanges } from '../../utils/mesh';
-import { CheckoutModalCommonState, FunCheckoutStep, StateTransitionProps, StepTransition, TransitionPayload } from './stepTransition';
+import { CheckoutModalCommonState, FunCheckoutStep, StateTransitionProps, StepTransition } from './stepTransition';
 export interface ConnectExchangeState extends CheckoutModalCommonState {
     step: FunCheckoutStep.CONNECT_EXCHANGE;
     exchange: MeshExchanges;
 }
-export type ConnectExchangeNext = TransitionPayload<{
+export type ConnectExchangeNext = {
     step: FunCheckoutStep.CONNECT_EXCHANGE;
-    paymentMethodInfo: PaymentMethodInfo;
-}>;
+    paymentMethodInfo: PaymentMethodBrokerageInfo;
+};
 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;

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

@@ -1,10 +1,12 @@
 import React from 'react';
-import { CheckoutModalCommonState, FunCheckoutStep, StateTransitionProps, StepTransition, TransitionPayload } from './stepTransition';
+import { PaymentMethodInfo } from '../../consts/payment';
+import { CheckoutModalCommonState, FunCheckoutStep, StateTransitionProps, StepTransition } from './stepTransition';
 export interface InputAmountState extends CheckoutModalCommonState {
     step: FunCheckoutStep.INPUT_AMOUNT;
+    paymentMethodInfo: PaymentMethodInfo;
 }
-export type InputAmountNext = TransitionPayload<{
+export type InputAmountNext = {
     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;
+};
+export declare function inputAmountNext(state: InputAmountState, _payload: InputAmountNext): StepTransition[FunCheckoutStep.INPUT_AMOUNT];
+export declare function InputAmount({ modalState, onBack, onNext, }: StateTransitionProps<InputAmountState, InputAmountNext>): React.JSX.Element;

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

@@ -0,0 +1,20 @@
+import React from 'react';
+import { PaymentMethod, PaymentMethodAccountInfo, PaymentMethodBrokerageInfo } from '../../consts/payment';
+import { CheckoutModalCommonState, FunCheckoutStep, StateTransitionProps, StepTransition } from './stepTransition';
+export interface LoadingAccountState extends CheckoutModalCommonState {
+    step: FunCheckoutStep.LOADING_ACCOUNT;
+}
+export type LoadingAccountNext = ({
+    usablePaymentMethod: PaymentMethod.ACCOUNT_BALANCE;
+    paymentMethodInfo: PaymentMethodAccountInfo;
+} | {
+    usablePaymentMethod: PaymentMethod.BROKERAGE;
+    paymentMethodInfo: PaymentMethodBrokerageInfo;
+} | {
+    usablePaymentMethod: null;
+}) & {
+    step: FunCheckoutStep.LOADING_ACCOUNT;
+};
+export declare function loadingAccountNext(state: LoadingAccountState, payload: LoadingAccountNext): StepTransition[FunCheckoutStep.LOADING_ACCOUNT];
+/** A placeholder component to handle redirecting to the checkout history page */
+export declare function LoadingAccount({ modalState, onNext, }: StateTransitionProps<LoadingAccountState, LoadingAccountNext>): React.JSX.Element;

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

@@ -1,14 +1,14 @@
 import React from 'react';
 import { Address } from 'viem';
 import { PaymentMethodInfo } from '../../consts/payment';
-import { CheckoutModalCommonState, FunCheckoutStep, StateTransitionProps, StepTransition, TransitionPayload } from './stepTransition';
+import { CheckoutModalCommonState, FunCheckoutStep, StateTransitionProps, StepTransition } from './stepTransition';
 export interface MeshVerificationState extends CheckoutModalCommonState {
     step: FunCheckoutStep.MESH_VERIFICATION;
     paymentMethodInfo: PaymentMethodInfo;
 }
-export type MeshVerificationNext = TransitionPayload<{
+export type MeshVerificationNext = {
     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/MoonpaySetup.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+import { Address } from 'viem';
+import { CheckoutModalCommonState, FunCheckoutStep, StateTransitionProps, StepTransition } from './stepTransition';
+export interface MoonpaySetupState extends CheckoutModalCommonState {
+    step: FunCheckoutStep.MOONPAY_SETUP;
+    paymentAddress: Address;
+    token: string;
+    tokenChainId: string;
+    depositAmount: number;
+}
+export type MoonpaySetupNext = {
+    step: FunCheckoutStep.MOONPAY_SETUP;
+    depositAddress: Address;
+};
+export declare function moonpaySetupNext(state: MoonpaySetupState, payload: MoonpaySetupNext): StepTransition[FunCheckoutStep.MOONPAY_SETUP];
+type Props = StateTransitionProps<MoonpaySetupState, MoonpaySetupNext>;
+export declare function MoonpaySetup({ modalState, onNext }: Props): React.JSX.Element;
+export {};

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

@@ -1,15 +1,16 @@
 import React from 'react';
-import { PaymentMethodInfo } from '../../consts/payment';
-import { CheckoutModalCommonState, FunCheckoutStep, StateTransitionProps, StepTransition, TransitionPayload } from './stepTransition';
+import { PaymentMethodAccountInfo, PaymentMethodBrokerageInfo } from '../../consts/payment';
+import { CheckoutModalCommonState, FunCheckoutStep, StateTransitionProps, StepTransition } from './stepTransition';
 export interface SelectAssetState extends CheckoutModalCommonState {
     step: FunCheckoutStep.SELECT_ASSET;
-    paymentMethodInfo: PaymentMethodInfo;
+    paymentMethodInfo: PaymentMethodBrokerageInfo | PaymentMethodAccountInfo;
 }
-export type SelectAssetNext = TransitionPayload<{
+export type SelectAssetNext = {
     step: FunCheckoutStep.SELECT_ASSET;
-    isQuoteSuccess: true;
-}>;
+    paymentMethodInfo?: PaymentMethodBrokerageInfo | PaymentMethodAccountInfo;
+    disconnectedBrokerage?: boolean;
+};
 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 declare function SelectAsset({ modalState, onNext }: Props): React.JSX.Element;
 export {};

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

@@ -0,0 +1,20 @@
+import React from 'react';
+import { PaymentMethodBrokerageInfo } from '../../consts/payment';
+import { MeshExchanges } from '../../utils/mesh';
+import { CheckoutModalCommonState, FunCheckoutStep, StateTransitionProps, StepTransition } from './stepTransition';
+export interface SelectBrokerageState extends CheckoutModalCommonState {
+    step: FunCheckoutStep.SELECT_BROKERAGE;
+}
+export type SelectBrokerageNext = {
+    step: FunCheckoutStep.SELECT_BROKERAGE;
+    hasActiveConnection: true;
+    paymentInfo: PaymentMethodBrokerageInfo;
+} | {
+    step: FunCheckoutStep.SELECT_BROKERAGE;
+    hasActiveConnection: false;
+    exchange: MeshExchanges;
+};
+export declare function selectBrokerageNext(state: SelectBrokerageState, payload: SelectBrokerageNext): StepTransition[FunCheckoutStep.SELECT_BROKERAGE];
+type Props = StateTransitionProps<SelectBrokerageState, SelectBrokerageNext>;
+export declare function SelectBrokerage({ modalState, onNext }: Props): React.JSX.Element;
+export {};

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

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

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

@@ -0,0 +1,26 @@
+import React from 'react';
+import { PaymentMethod, PaymentMethodAccountInfo, PaymentMethodBrokerageInfo, PaymentMethodCardInfo } from '../../consts/payment';
+import { CheckoutModalCommonState, FunCheckoutStep, StateTransitionProps, StepTransition } from './stepTransition';
+type ConnectablePaymentMethodInfo = PaymentMethodAccountInfo | PaymentMethodBrokerageInfo;
+export interface SourceChangeState extends CheckoutModalCommonState {
+    step: FunCheckoutStep.SOURCE_CHANGE;
+    paymentMethodInfo: ConnectablePaymentMethodInfo;
+}
+export type SourceChangeNext = {
+    step: FunCheckoutStep.SOURCE_CHANGE;
+    connectNew: false;
+    paymentMethodInfo: ConnectablePaymentMethodInfo;
+} | {
+    step: FunCheckoutStep.SOURCE_CHANGE;
+    connectNew: true;
+    paymentMethod: Exclude<PaymentMethod, PaymentMethod.CARD>;
+} | {
+    step: FunCheckoutStep.SOURCE_CHANGE;
+    connectNew: true;
+    paymentMethod: PaymentMethod.CARD;
+    paymentMethodInfo: PaymentMethodCardInfo;
+};
+export declare const sourceChangeNext: (state: SourceChangeState, payload: SourceChangeNext) => StepTransition[FunCheckoutStep.SOURCE_CHANGE];
+type Props = StateTransitionProps<SourceChangeState, SourceChangeNext>;
+export declare const SourceChange: ({ modalState, onNext, onClose }: Props) => React.JSX.Element;
+export {};

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

@@ -0,0 +1,14 @@
+import React from 'react';
+import { Address } from 'viem';
+import { CheckoutModalCommonState, FunCheckoutStep, StateTransitionProps, StepTransition } from './stepTransition';
+export type TransferSetupState = CheckoutModalCommonState & {
+    step: FunCheckoutStep.TRANSFER_SETUP;
+    address: Address;
+};
+export type TransferSetupNext = {
+    step: FunCheckoutStep.TRANSFER_SETUP;
+};
+export declare function transferSetupNext(_state: TransferSetupState, _payload: TransferSetupNext): StepTransition[FunCheckoutStep.TRANSFER_SETUP];
+type Props = StateTransitionProps<TransferSetupState, TransferSetupNext>;
+export declare function TransferSetup({ modalState }: Props): React.JSX.Element;
+export {};

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

@@ -4,19 +4,19 @@ import { CheckoutCompleteState } from './CheckoutComplete';
 import { ConfirmationStepNext, ConfirmationStepState } from './ConfirmationStep';
 import { ConnectExchangeNext, ConnectExchangeState } from './ConnectExchange';
 import { InputAmountNext, InputAmountState } from './InputAmount';
+import { LoadingAccountNext, LoadingAccountState } from './LoadingAccount';
 import { MeshVerificationNext, MeshVerificationState } from './MeshVerification';
-import { PaymentSetupNext, PaymentSetupState } from './PaymentSetup';
+import { MoonpaySetupNext, MoonpaySetupState } from './MoonpaySetup';
 import { SelectAssetNext, SelectAssetState } from './SelectAsset';
+import { SelectBrokerageNext, SelectBrokerageState } from './SelectBrokerage';
 import { SelectPaymentMethodNext, SelectPaymentMethodState } from './SelectPaymentMethod';
+import { SourceChangeNext, SourceChangeState } from './SourceChange';
+import { TransferSetupNext } from './TransferSetup';
 export interface CheckoutModalCommonState {
     checkoutId: string;
+    targetChainId: string;
     isSoftHidden: boolean;
-    countdown?: number;
-    countdownKey?: number;
-    beforeCountdownEndsSeconds?: number;
-    onBeforeCountdownEnds?: () => void;
-    onCountdownLastSecond?: () => void;
-    onCountdownEnded?: () => void;
+    isCloseButtonHidden?: boolean;
 }
 export interface StateTransitionProps<T, N> {
     modalState: T;
@@ -26,37 +26,37 @@ export interface StateTransitionProps<T, N> {
     onClose: () => void;
 }
 export declare function extractCommonState(state: CheckoutModalState): CheckoutModalCommonState;
-type CheckoutModalState = ConfirmationStepState | ConnectExchangeState | InputAmountState | SelectAssetState | SelectPaymentMethodState | PaymentSetupState | MeshVerificationState | CheckoutCompleteState;
+type CheckoutModalState = LoadingAccountState | ConfirmationStepState | ConnectExchangeState | InputAmountState | SelectAssetState | SelectPaymentMethodState | SelectBrokerageState | SourceChangeState | MoonpaySetupState | MeshVerificationState | CheckoutCompleteState;
 export declare enum FunCheckoutStep {
+    LOADING_ACCOUNT = "loading_account",
     INPUT_AMOUNT = "input_amount",
     SELECT_PAYMENT_METHOD = "select_payment",
+    SOURCE_CHANGE = "source_change",
     CONFIRMATION = "confirmation",
-    PAYMENT_SETUP = "payment_setup",
+    MOONPAY_SETUP = "payment_setup",
+    SELECT_BROKERAGE = "select_brokerage",
+    TRANSFER_SETUP = "transfer_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;
+    [FunCheckoutStep.LOADING_ACCOUNT]: SelectPaymentMethodState | SelectAssetState;
+    [FunCheckoutStep.INPUT_AMOUNT]: ConfirmationStepState;
+    [FunCheckoutStep.SELECT_PAYMENT_METHOD]: SelectBrokerageState | InputAmountState | SelectAssetState;
+    [FunCheckoutStep.CONFIRMATION]: MeshVerificationState | MoonpaySetupState | CheckoutCompleteState;
+    [FunCheckoutStep.MOONPAY_SETUP]: CheckoutCompleteState;
+    [FunCheckoutStep.SELECT_BROKERAGE]: ConnectExchangeState | SelectAssetState;
+    [FunCheckoutStep.TRANSFER_SETUP]: CheckoutModalState;
+    [FunCheckoutStep.CONNECT_EXCHANGE]: SelectAssetState;
+    [FunCheckoutStep.SELECT_ASSET]: InputAmountState | SourceChangeState | LoadingAccountState;
+    [FunCheckoutStep.MESH_VERIFICATION]: CheckoutCompleteState;
+    [FunCheckoutStep.SOURCE_CHANGE]: SelectAssetState | SelectBrokerageState | InputAmountState;
 }
-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<{
+type NextPayload = LoadingAccountNext | ConfirmationStepNext | ConnectExchangeNext | InputAmountNext | MeshVerificationNext | MoonpaySetupNext | TransferSetupNext | SelectAssetNext | SelectPaymentMethodNext | SelectBrokerageNext | SourceChangeNext | {
     step: FunCheckoutStep.CHECKOUT_COMPLETE;
-}>;
+};
 export declare function useCheckoutModalTransition(checkoutItem: FunkitActiveCheckoutItem, onClose: () => void): {
     animateOut: boolean;
     modalState: CheckoutModalState;

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

@@ -0,0 +1,4 @@
+import { PaymentMethodInfo } from '../../consts/payment';
+import { QueryResult } from '../../types/utils';
+import { AssetHoldingsItem } from '../../utils/assets';
+export declare function useAvailableBalanceForCheckout(checkoutId: string, paymentMethodInfo: PaymentMethodInfo, targetChainId: string, assetChainId: string, assetSymbol: string | null): QueryResult<AssetHoldingsItem>;

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

@@ -3,13 +3,15 @@ import { FunkitActiveCheckoutItem } from '../../providers/FunkitCheckoutContext'
 export interface SourceAssetConfirmed {
     isQuoteSuccess: boolean;
     newPaymentMethodInfo: PaymentMethodInfo;
-    quoteObject?: FunkitActiveCheckoutItem;
+    quoteObject: FunkitActiveCheckoutItem | undefined;
+    totalFeesUsd: number | undefined;
+    estSubtotalUsd: number | undefined;
 }
 export type OnSourceAssetConfirmed = (confirmed: SourceAssetConfirmed | undefined) => void;
 /**
  *
  * Note: this hook is EXTREMELY confusing in what is doing
- * first, it uses useSymbolRefresh to wait React's setState
+ * 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

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

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

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

@@ -0,0 +1,5 @@
+import { AssetHoldingsMap } from '../../utils/assets';
+export declare function useWalletAssetHoldings(targetChain: string): {
+    data: AssetHoldingsMap | undefined;
+    isLoading: boolean;
+};

package/dist/providers/FunkitCheckoutContext.d.ts

@@ -21,8 +21,8 @@ export interface FunkitCheckoutConfig {
     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. **/
     targetAsset: Address;
-    /** The amount of wanted asset for the checkout operation. **/
-    targetAssetAmount: number;
+    /** The amount of wanted asset for the checkout operation (defaults to $100 equivalent). **/
+    targetAssetAmount?: number;
     /** The ticker information of the wanted asset for the checkout operation. e.g. USDC. **/
     targetAssetTicker: string;
     /** Timestamp (in milliseconds) after which the checkout should not be performed, and the funds will become rescuable. Min: 300000 (5 mins), Max: 3600000 (1 hour). **/
@@ -46,8 +46,6 @@ export interface FunkitCheckoutConfig {
     checkoutItemTitle: string;
     /** The quantity of the item being checked out. If not specified (0, null, undefined), it will default to blank. **/
     checkoutItemAmount?: number;
-    /** Whether editing is skipped and disabled for checkouts with empty actionsParams. **/
-    disableEditing?: boolean;
     /** *****************************
      * Miscellaneous configurations *
      ********************************/
@@ -139,11 +137,13 @@ interface useFunkitPreCheckoutInternalReturn {
     updateSelectedPaymentMethodInfo: (newPaymentMethodInfo: PaymentMethodInfo) => void;
     confirmCheckout: (shouldBatchOpBypassInit: boolean, stepMessageSetter: (m: string) => void) => Promise<Address>;
     cancelCheckout: (depositAddress: Address) => Promise<boolean>;
-    getCheckoutDraftDollarValue: () => Promise<void>;
+    getCheckoutDraftDollarValue: () => Promise<number>;
     clearCheckoutQuoteMessages: () => void;
     getCheckoutQuote: (sponsorInitialTransferGasLimit: number, newPaymentMethodInfo: PaymentMethodInfo, disableInformationStreaming?: boolean) => Promise<{
         success: boolean;
         shellCheckoutItemWithNextQuote: FunkitActiveCheckoutItem | undefined;
+        totalFeesUsd: number | undefined;
+        estSubtotalUsd: number | undefined;
         errorObject?: any;
     }>;
     setCheckoutQuote: (quote: FunkitActiveCheckoutItem) => void;

package/dist/providers/FunkitConfigContext.d.ts

@@ -6,6 +6,18 @@ export interface FunkitTextCustomizationsConfig {
     transferCrypto: string;
     selectAccount: string;
 }
+export interface FunkitUiCustomizationsConfig {
+    confirmationScreen?: {
+        /** Whether to show the amount of tokens below the USD equivalent - defaults to true */
+        showTokenAmount?: boolean;
+    };
+    inputAmountScreen?: {
+        /** Whether to allow entering an amount of tokens, rather than only USD - defaults to true */
+        allowTokenAmountInput?: boolean;
+        /** Whether to show available balance in Input Amount screen (wallet/brokerage only) - defaults to true */
+        showAvailableBalance?: boolean;
+    };
+}
 export declare const DEFAULT_TEXT_CUSTOMIZATIONS: FunkitTextCustomizationsConfig;
 interface FunkitLoginOptionsConfig {
     web2: boolean;
@@ -32,6 +44,8 @@ export type FunkitConfig = {
     allowBackgroundScroll?: boolean;
     /** Text customizations across all widgets **/
     textCustomizations?: Partial<FunkitTextCustomizationsConfig>;
+    /** UI customizations across all widgets **/
+    uiCustomizations?: FunkitUiCustomizationsConfig;
     /** Login modal configuration **/
     loginConfig: Partial<FunkitLoginOptionsConfig>;
 };

package/dist/providers/FunkitFlagsProvider.d.ts

@@ -0,0 +1,25 @@
+import React, { ReactNode } from 'react';
+import { flagConfig as offlineConfig, FlagKey } from '../utils/flags/config';
+import { InferFlagType } from '../utils/flags/types';
+export { FlagKey } from '../utils/flags/config';
+export type FlagValue<K extends FlagKey> = InferFlagType<(typeof offlineConfig)[K]>;
+export type FlagValues = {
+    [K in FlagKey]?: FlagValue<K>;
+};
+export type GetFlagFunction = <K extends FlagKey>(flagKey: K, fallback: FlagValue<K>) => FlagValue<K>;
+export interface FunkitFlagsContextValue {
+    /** Error fetching flag config from server */
+    error: Error | null;
+    /** Loaded flags - each flag may be undefined if configuration from server was missing or invalid */
+    flags: FlagValues;
+    /** Synchronously reads a single flag (derived for current user) - returns fallback while loading */
+    getFlag: GetFlagFunction;
+    /** Whether flags are currently loading */
+    isLoading: boolean;
+}
+export declare const FunkitFlagsContext: React.Context<FunkitFlagsContextValue>;
+export declare function FunkitFlagsProvider({ children }: {
+    children: ReactNode;
+}): React.JSX.Element;
+export declare function useFlags(): FunkitFlagsContextValue;
+export declare function useFlag<K extends FlagKey>(flagKey: K, fallback: FlagValue<K>): FlagValue<K>;

package/dist/providers/FunkitMeshProvider.d.ts

@@ -1,20 +1,25 @@
 import { LinkPayload } from '@meshconnect/web-link-sdk';
 import React from 'react';
 import { MeshExchanges } from '../utils/mesh';
-interface MeshBrokerDataMap {
-    [brokerName: string]: LinkPayload & {
-        connectionExpiresAtMs: number;
-    };
-}
 export declare function FunkitMeshProvider({ children }: any): React.JSX.Element;
-export declare function useFunkitMesh(_notUsedToDelete?: unknown): {
-    meshBrokerDataMap: MeshBrokerDataMap;
+export declare function useFunkitMesh(): {
     unlinkBrokerage: (exchange: MeshExchanges) => void;
-    hasActiveConnectionCheck: (brokerage: MeshExchanges) => boolean;
+    getActiveConnection: (brokerage: MeshExchanges) => (LinkPayload & {
+        connectionExpiresAtMs: number;
+    }) | null;
+    getFirstActiveConnection: () => {
+        accessToken?: import("@meshconnect/web-link-sdk").AccessTokenPayload;
+        delayedAuth?: import("@meshconnect/web-link-sdk").DelayedAuthPayload;
+        connectionExpiresAtMs: number;
+        brokerage: MeshExchanges;
+    } | null;
 };
 interface FunkitMeshHook {
     onBeforeConnect(): void;
-    onConnected(brokerData: LinkPayload | null): void;
+    onConnected(data: {
+        brokerData: LinkPayload;
+        brokerage: MeshExchanges;
+    } | null): void;
     onMeshModalClose(): void;
 }
 /**

package/dist/providers/FunkitMoonpayProvider.d.ts

@@ -4,7 +4,7 @@ export declare function FunkitMoonpayProvider({ children, debug, }: {
     children: any;
     debug: boolean;
 }): React.JSX.Element;
-interface UserIpInfoFromMoonpay {
+export interface UserIpInfoFromMoonpay {
     alpha2: string;
     alpha3: string;
     country: string;
@@ -23,4 +23,3 @@ export declare function useFunkitUserIp(): {
     isUserBlockedForCheckout: boolean;
     userIpInfo: UserIpInfoFromMoonpay | undefined;
 };
-export {};

package/dist/providers/GeneralWalletProvider.d.ts

@@ -2,26 +2,18 @@ import { AssetBalanceInfo } from '@funkit/api-base';
 import { Auth, FunWallet } from '@funkit/core';
 import React from 'react';
 import { FunkitUserInfo } from '../consts/funkit';
-import { PaymentMethodInfo } from '../consts/payment';
+import { PaymentMethodAccountInfo } from '../consts/payment';
 export interface KnownAssetBalanceInfo extends AssetBalanceInfo {
     price: number;
     totalUsdValue: number;
 }
-export type GeneralWalletAssets = null | {
-    [x: string]: KnownAssetBalanceInfo;
-};
 interface GeneralWalletContextProps {
     walletAddress: string;
-    accountBalancePaymentDefaultInfo: PaymentMethodInfo | null;
+    accountBalancePaymentDefaultInfo: PaymentMethodAccountInfo | null;
     isUserLoggedIn: boolean;
     isWeb2Login: boolean;
     isWeb3Login: boolean;
     userInfo: FunkitUserInfo;
-    isFetchingAssets: boolean;
-    walletAssets: GeneralWalletAssets;
-    totalWalletAssetsUsd: number;
-    startAssetsListener: () => void;
-    stopAssetsListener: () => void;
     funWallet: FunWallet | null;
     funWalletAuth: Auth | null;
     handleLogout: () => void;
@@ -99,15 +91,15 @@ export declare const useFunkitDisconnect: () => {
     error: null;
     data: undefined;
     status: "idle";
-    variables: undefined;
     isError: false;
-    isIdle: true;
     isPending: false;
     isSuccess: false;
-    context: unknown;
     failureCount: number;
     failureReason: import("@wagmi/core").DisconnectErrorType | null;
     isPaused: boolean;
+    variables: undefined;
+    isIdle: true;
+    context: unknown;
     submittedAt: number;
     connectors: readonly import("wagmi").Connector[];
 } | {
@@ -117,15 +109,15 @@ export declare const useFunkitDisconnect: () => {
     error: null;
     data: undefined;
     status: "pending";
-    variables: import("wagmi/query").DisconnectVariables;
     isError: false;
-    isIdle: false;
     isPending: true;
     isSuccess: false;
-    context: unknown;
     failureCount: number;
     failureReason: import("@wagmi/core").DisconnectErrorType | null;
     isPaused: boolean;
+    variables: import("wagmi/query").DisconnectVariables;
+    isIdle: false;
+    context: unknown;
     submittedAt: number;
     connectors: readonly import("wagmi").Connector[];
 } | {
@@ -135,15 +127,15 @@ export declare const useFunkitDisconnect: () => {
     error: import("@wagmi/core").DisconnectErrorType;
     data: undefined;
     status: "error";
-    variables: import("wagmi/query").DisconnectVariables;
     isError: true;
-    isIdle: false;
     isPending: false;
     isSuccess: false;
-    context: unknown;
     failureCount: number;
     failureReason: import("@wagmi/core").DisconnectErrorType | null;
     isPaused: boolean;
+    variables: import("wagmi/query").DisconnectVariables;
+    isIdle: false;
+    context: unknown;
     submittedAt: number;
     connectors: readonly import("wagmi").Connector[];
 } | {
@@ -153,15 +145,15 @@ export declare const useFunkitDisconnect: () => {
     error: null;
     data: void;
     status: "success";
-    variables: import("wagmi/query").DisconnectVariables;
     isError: false;
-    isIdle: false;
     isPending: false;
     isSuccess: true;
-    context: unknown;
     failureCount: number;
     failureReason: import("@wagmi/core").DisconnectErrorType | null;
     isPaused: boolean;
+    variables: import("wagmi/query").DisconnectVariables;
+    isIdle: false;
+    context: unknown;
     submittedAt: number;
     connectors: readonly import("wagmi").Connector[];
 };