@funkit/connect 6.14.11 → 6.14.13

package/CHANGELOG.md

@@ -1,5 +1,49 @@
 # @funkit/connect
 
+## 6.14.13
+
+### Patch Changes
+
+- b1477ac: feat: added tracking for closing withdrawal modal
+- 1b21c9c: add exchange rate in tooltip
+- 3dda7fc: feat(connect, api, apps): avantis theme
+- 1fdce23: feat: added tracking for withdrawal quote on statsig
+- 614c9e4: feat(connect,utils): add new feature flag for bluvo exchange
+- 820d81e: fix(connect): indicate "Withdrawal tx" correctly after performing withdrawal
+- b259fe8: refactor(connect): move checkout modal event to its own file
+- 1e97461: feat(connect,utils): integrate bluvo quoting and fees
+- c3e64b1: feat: added title placement config in FunkitConfig
+- fa772a1: feat: added tracking of withdraw modal open
+- 8bc8d04: feat: added tracking of withdrawal success
+- 8fa45aa: feat(connect): update min deposit logic for brokerage flow - adheres to transfer token mins
+- Updated dependencies [3dda7fc]
+- Updated dependencies [977b232]
+- Updated dependencies [614c9e4]
+- Updated dependencies [1e97461]
+  - @funkit/api-base@1.12.11
+  - @funkit/fun-relay@2.1.3
+  - @funkit/utils@1.1.14
+  - @funkit/core@2.3.56
+  - @funkit/wagmi-tools@3.0.79
+
+## 6.14.12
+
+### Patch Changes
+
+- 3b3fba8: feat: add isMobile flag to statsig log
+- 985dd4c: show send amount in confirmation page
+- 0fdee65: chore: move apiKey to statsig customID for better analytics
+- 5a379cb: add missing function in server config
+- a13f742: feat(connect,fun-relay): handle known Relay errors
+- 2e4c75d: change label from deposit to receive
+- Updated dependencies [a26c8c5]
+- Updated dependencies [a13f742]
+- Updated dependencies [a13f742]
+  - @funkit/api-base@1.12.10
+  - @funkit/core@2.3.55
+  - @funkit/fun-relay@2.1.2
+  - @funkit/wagmi-tools@3.0.78
+
 ## 6.14.11
 
 ### Patch Changes

package/dist/components/FunPayments/FunPaymentMethods.d.ts

@@ -1,10 +1,19 @@
 import React, { type ReactNode } from 'react';
-import { PaymentMethod, type PaymentMethodVirtualBankInfo } from '../../domains/paymentMethods';
+import { PaymentMethod, type PaymentMethodBrokerageInfo, type PaymentMethodVirtualBankInfo } from '../../domains/paymentMethods';
 export declare const getDynamicValueIconComponent: () => React.JSX.Element;
 export declare function PaymentMethodIcon({ paymentIcon, keyIconSize, }: {
     paymentIcon: ReactNode;
     keyIconSize: number;
 }): React.JSX.Element;
+interface ConnectedMeshPaymentMethodItemProps extends ConnectedPaymentMethodItemProps {
+    paymentMethodInfo: PaymentMethodBrokerageInfo;
+    onBrokerageError?: () => void;
+}
+/** it is different from BrokeragePaymentMethodItem
+ * this component is for connected mesh brokerage like robinhood
+ * the other one is for connecting new brokerage button
+ * */
+export declare const ConnectedMeshPaymentMethodItem: ({ paymentMethodInfo, isSelected, onSelect, onBrokerageError, showSelectedCheckmark, }: ConnectedMeshPaymentMethodItemProps) => React.JSX.Element;
 interface ConnectedPaymentMethodItemProps {
     isSelected: boolean;
     showSelectedCheckmark?: boolean;
@@ -27,7 +36,7 @@ type BasePaymentMethodItemProps = {
 export declare function AddPaymentMethodItem({ paymentMethod, isClickable, isActive, onClick, customValueIcon, testId, }: BasePaymentMethodItemProps & {
     paymentMethod: PaymentMethod;
     dynamicLimit?: string;
-}): React.JSX.Element | null | undefined;
+}): React.JSX.Element | undefined;
 export declare function PayPalPaymentMethodItem({ isActive, isClickable, onClick, isLoading, }: BasePaymentMethodItemProps & {
     isLoading: boolean;
 }): React.JSX.Element;

package/dist/components/FunSelectBrokerage/FunBrokerageItem.css.d.ts

@@ -0,0 +1 @@
+export declare const brokerageItemStyle: string;

package/dist/components/FunSelectBrokerage/FunBrokerageItem.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+export interface FunBrokerageItemProps {
+    exchangeName: string;
+    exchangeIcon: React.ReactNode;
+    hasActiveConnection: boolean;
+    badgeText?: string | null;
+}
+export declare const FunBrokerageItem: ({ exchangeName, exchangeIcon, hasActiveConnection, badgeText, }: FunBrokerageItemProps) => React.JSX.Element;

package/dist/components/FunSelectBrokerage/FunSelectBrokerage.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { type BluvoExchangeType } from '~/consts/bluvo';
+interface FunSelectBrokerageProps {
+    isDisabled?: boolean;
+    onSelect: (value: BluvoExchangeType) => void;
+    selectedValue: BluvoExchangeType | undefined;
+}
+export declare function FunSelectBrokerage({ isDisabled, onSelect, selectedValue, }: FunSelectBrokerageProps): React.JSX.Element;
+export {};

package/dist/consts/bluvo.d.ts

@@ -0,0 +1,37 @@
+import type { UseBluvoFlowHook } from '@bluvo/react';
+export declare const BROKERAGE_MIN_TRANSFER: {
+    mainnet: number;
+    nonMainnet: number;
+};
+export type BluvoQuote = UseBluvoFlowHook['quote'];
+export type BluvoWithdrawableBalance = UseBluvoFlowHook['walletBalances'];
+export type BluvoWithdrawal = UseBluvoFlowHook['withdrawal'];
+export declare enum BluvoExchangeType {
+    Coinbase = "coinbase",
+    Gemini = "gemini",
+    Kraken = "kraken"
+}
+type BluvoExchangeInfo = {
+    icon: (size: number) => JSX.Element | null;
+    name: string;
+};
+export declare enum BluvoExchangeStatus {
+    Live = "live",
+    Offline = "offline",
+    Maintenance = "maintenance",
+    ComingSoon = "coming_soon"
+}
+export declare const SUPPORTED_EXCHANGES: readonly [{
+    readonly exchange: BluvoExchangeType.Coinbase;
+    readonly status: BluvoExchangeStatus.Live;
+}, {
+    readonly exchange: BluvoExchangeType.Kraken;
+    readonly status: BluvoExchangeStatus.ComingSoon;
+}, {
+    readonly exchange: BluvoExchangeType.Gemini;
+    readonly status: BluvoExchangeStatus.ComingSoon;
+}];
+export declare const BLUVO_EXCHANGES: Readonly<Record<BluvoExchangeType, BluvoExchangeInfo>>;
+export declare function getExchangeIcon(brokerType: BluvoExchangeType, size: number): JSX.Element | null;
+export declare function getExchangeName(brokerType: BluvoExchangeType): string;
+export {};

package/dist/consts/customers.d.ts

@@ -9,3 +9,4 @@ export declare function isHyperdashCustomer(apiKey: string): apiKey is "di9ZSqn1
 export declare function isMonkeyTiltCustomer(apiKey: string): apiKey is "2SrxurU07T2XPDxCAItjj4yYEMXlwV8K2kJB78AX";
 export declare function isBasedCustomer(apiKey: string): apiKey is "clDebbfo9edXq1GydZ0CahSAfSimPj616lFa9p8e";
 export declare function isHyenaCustomer(apiKey: string): apiKey is "pLQBJsA6zS9tg990rbdBD6UdABkWRv5O60vlrVcW";
+export declare function isAvantisCustomer(apiKey: string): apiKey is "6TUi99Tq3O9MWj1IFX8Pv6spmPXzcvhy9NvBoeW2";

package/dist/domains/asset.d.ts

@@ -19,9 +19,9 @@ interface AssetUsableToPayParms {
     assetUsdAmount: number | null;
     loginType: LoginType;
     isAllowedForCheckout: boolean;
-    minValueThreshold?: number;
+    minUsdRequired?: number;
 }
-export declare const isAssetUsableToPayForCheckout: ({ config, payerAddress, paymentMethod, targetChainId, targetTokenAddress, assetChainId, assetTokenAddress, assetUsdAmount, loginType, isAllowedForCheckout, }: AssetUsableToPayParms) => {
+export declare const isAssetUsableToPayForCheckout: ({ config, payerAddress, paymentMethod, targetChainId, targetTokenAddress, assetChainId, assetTokenAddress, assetUsdAmount, loginType, isAllowedForCheckout, minUsdRequired, }: AssetUsableToPayParms) => {
     isUsable: boolean;
     reason: string;
 };

package/dist/domains/fees.d.ts

@@ -1,17 +1,14 @@
+import type { WalletwithdrawquotequotationResponse as WithdrawalQuotation } from '@bluvo/sdk-ts';
 import type { CheckoutQuoteResponse } from '@funkit/utils';
 import type { Config } from 'wagmi';
 import { LoginType } from '~/providers/GeneralWalletProvider';
 import type { FunkitActiveCheckoutItem } from '../providers/FunkitCheckoutContext';
 import { PaymentMethod, type PaymentMethodInfo } from './paymentMethods';
 export interface BrokerageDetails {
-    availableBalance: number;
-    availableBalanceInFiat: number;
     isAboveMaximum: boolean;
     isBelowMinimum: boolean;
     maximumAmount: number | undefined | null;
-    maximumAmountInFiat: number | undefined | null;
     minimumAmount: number;
-    minimumAmountInFiat: number;
 }
 interface BaseCheckoutFees {
     paymentMethod: PaymentMethod;
@@ -36,7 +33,6 @@ interface CardCheckoutFees extends BaseCheckoutFees {
 interface BrokerageCheckoutFees extends BaseCheckoutFees {
     paymentMethod: PaymentMethod.BROKERAGE;
     exchangeFeeUsd: number;
-    meshCostUsd: number;
 }
 export type CheckoutFees = WalletCheckoutFees | CardCheckoutFees | BrokerageCheckoutFees;
 interface EvaluateFeeBreakdownItem {
@@ -48,7 +44,10 @@ interface EvaluateFeeBreakdownItem {
     loginType: LoginType;
     isWithdrawal?: boolean;
 }
-export declare function evaluateFeeBreakdown(evalItem: EvaluateFeeBreakdownItem): Promise<{
+export declare function evaluateFeeBreakdown(evalItem: EvaluateFeeBreakdownItem & {
+    brokerageQuote?: WithdrawalQuotation;
+}): Promise<{
     fees: CheckoutFees;
+    brokerage?: BrokerageDetails;
 }>;
 export {};

package/dist/domains/paymentMethods.d.ts

@@ -1,11 +1,13 @@
 import type { BridgeCustomer, BridgeVirtualBankAccount } from '@funkit/api-base';
+import { type BluvoExchangeType } from '~/consts/bluvo';
+import type { BrokerageAssetHoldingsItem } from './wallet';
 /** Supported payment methods in FunkitConnect. **/
 export declare enum PaymentMethod {
     /** Meld - Credit / Debit Card **/
     CARD = "card",
     /** Account Balance **/
     ACCOUNT_BALANCE = "balance",
-    /** Mesh - Exchange / Brokerage **/
+    /** Bluvo - Exchange / Brokerage **/
     BROKERAGE = "brokerage",
     TOKEN_TRANSFER = "token_transfer",
     VIRTUAL_BANK = "virtual_bank"
@@ -21,6 +23,9 @@ export interface PaymentMethodCardInfo extends PaymentMethodInfoBase {
 }
 export interface PaymentMethodBrokerageInfo extends PaymentMethodInfoBase {
     paymentMethod: PaymentMethod.BROKERAGE;
+    deviceId: string;
+    exchange: BluvoExchangeType;
+    asset?: Partial<BrokerageAssetHoldingsItem>;
 }
 export interface PaymentMethodAccountInfo extends PaymentMethodInfoBase {
     paymentMethod: PaymentMethod.ACCOUNT_BALANCE;
@@ -50,6 +55,9 @@ interface AccountPaymentMethodParams {
 }
 interface BrokeragePaymentMethodParams {
     paymentMethod: PaymentMethod.BROKERAGE;
+    deviceId: string;
+    exchange: BluvoExchangeType;
+    asset?: Partial<BrokerageAssetHoldingsItem>;
 }
 interface TokenTransferPaymentMethodParams {
     paymentMethod: PaymentMethod.TOKEN_TRANSFER;
@@ -66,8 +74,8 @@ interface VirtualBankPaymentMethodParams {
 }
 export declare function createPaymentMethodInfo(params: CardPaymentMethodParams): PaymentMethodCardInfo;
 export declare function createPaymentMethodInfo(params: AccountPaymentMethodParams): PaymentMethodAccountInfo;
-export declare function createPaymentMethodInfo(params: BrokeragePaymentMethodParams): PaymentMethodBrokerageInfo;
 export declare function createPaymentMethodInfo(params: TokenTransferPaymentMethodParams): PaymentMethodTokenTransferInfo;
 export declare function createPaymentMethodInfo(params: VirtualBankPaymentMethodIncompleteParams): PaymentMethodVirtualBankIncompleteInfo;
 export declare function createPaymentMethodInfo(params: VirtualBankPaymentMethodParams): PaymentMethodVirtualBankInfo;
+export declare function createPaymentMethodInfo(params: BrokeragePaymentMethodParams): PaymentMethodBrokerageInfo;
 export {};

package/dist/domains/quote.d.ts

@@ -3,6 +3,7 @@ import type { Address } from 'viem';
 import type { Config } from 'wagmi';
 import type { FunkitActiveCheckoutItem } from '~/providers/FunkitCheckoutContext';
 import type { LoginType } from '~/providers/GeneralWalletProvider';
+import type { WalletwithdrawquotequotationResponse as WithdrawalQuotation } from '@bluvo/sdk-ts';
 import type { FunkitDirectExecutionInfo } from '~/hooks/useCheckoutDirectExecution';
 import { type BrokerageDetails, type CheckoutFees } from './fees';
 import { type PaymentMethodInfo } from './paymentMethods';
@@ -11,7 +12,7 @@ export interface FunkitCheckoutQuoteResult extends Omit<ApiFunkitCheckoutQuoteRe
     finalFeesBreakdown: CheckoutFees;
 }
 export declare function getCheckoutBaseQuote(checkoutItem: FunkitActiveCheckoutItem, userId: string, walletAddress: Address, apiKey: string, sponsorInitialTransferGasLimit: number, wagmiConfig: Config, directExecutionInfo: FunkitDirectExecutionInfo, senderAddress?: Address, isWithdrawal?: boolean): Promise<CheckoutQuoteResponse>;
-export declare function getQuoteFinalEstimation(baseQuote: CheckoutQuoteResponse, checkoutItem: FunkitActiveCheckoutItem, newPaymentMethodInfo: PaymentMethodInfo, wagmiConfig: Config, apiKey: string, loginType: LoginType, isWithdrawal?: boolean): Promise<{
+export declare function getQuoteFinalEstimation(baseQuote: CheckoutQuoteResponse, checkoutItem: FunkitActiveCheckoutItem, newPaymentMethodInfo: PaymentMethodInfo, wagmiConfig: Config, apiKey: string, loginType: LoginType, isWithdrawal?: boolean, brokerageQuote?: WithdrawalQuotation): Promise<{
     finalEstimation: FunkitCheckoutQuoteResult;
     brokerage?: BrokerageDetails;
 }>;

package/dist/domains/wallet.d.ts

@@ -11,8 +11,12 @@ export interface AssetHoldingsItem {
 export interface KnownAssetHoldingsItem extends AssetHoldingsItem {
     usdAmount: number;
 }
-export interface AssetHoldingsMap {
-    [symbol: string]: AssetHoldingsItem;
+export interface BrokerageAssetHoldingsItem extends AssetHoldingsItem {
+    maxAmount: string;
+    minAmount: string;
+}
+export interface AssetHoldingsMap<T extends AssetHoldingsItem = AssetHoldingsItem> {
+    [symbol: string]: T;
 }
 /**
  * @returns formatted max usable USD balance from a given assets map

package/dist/hooks/track/CheckoutModalEvent.d.ts

@@ -0,0 +1,30 @@
+export declare enum CheckoutModalEvent {
+    MODAL_OPENED = "fc::modal_opened",
+    MODAL_CLOSED = "fc::modal_closed",
+    NAVIGATE_SOURCE_CHANGE = "fc::navigate::source_change",
+    NAVIGATE_SELECT_ASSET = "fc::navigate::select_asset",
+    NAVIGATE_CONFIRMATION = "fc::navigate::confirmation",
+    NAVIGATE_CHECKOUT_COMPLETE = "fc::navigate::checkout_complete",
+    NAVIGATE_TRANSFER_TOKEN = "fc::navigate::transfer_token",
+    NAVIGATE_INPUT_AMOUNT = "fc::navigate::input_amount",
+    NAVIGATE_ERROR_SCREEN = "fc::navigate::error_screen",
+    NAVIGATE_FIAT_ACCOUNT_DETAIL = "fc::navigate::fiat_account_detail",
+    NAVIGATE_BRIDGE_KYC = "fc::navigate::bridge_kyc",
+    NAVIGATE_BRIDGE_CUSTOMER = "fc::navigate::bridge_customer",
+    NAVIGATE_MOONPAY_SETUP = "fc::navigate::moonpay_setup",
+    NAVIGATE_MELD_QUOTES = "fc::navigate::meld_quotes",
+    NAVIGATE_MELD_REDIRECT = "fc::navigate::meld_redirect",
+    NAVIGATE_MELD_CURRENCY_SELECT = "fc::navigate::meld_currency_select",
+    NAVIGATE_DIRECT_EXECUTION_NOTIF_CENTER = "fc::navigate::direct_execution_notif_center",
+    NAVIGATE_KYC_IFRAME = "fc::navigate::kyc_iframe",
+    NAVIGATE_CREATE_FIAT_ACCOUNT = "fc::navigate::create_fiat_account",
+    NAVIGATE_LOADING_ACCOUNT = "fc::navigate::loading_account",
+    NAVIGATE_CHECKOUT_HELP = "fc::navigate::checkout_help",
+    NAVIGATE_SELECT_BROKERAGE = "fc::navigate::select_brokerage",
+    NAVIGATE_CONNECT_EXCHANGE = "fc::navigate::connect_exchange",
+    NAVIGATE_MESH_VERIFICATION = "fc::navigate::mesh_verification",
+    FINAL_QUOTE = "fc::quote::final_quote",
+    ACCOUNT_BALANCE_SUCCESS = "fc::success::account_balance",
+    TOKEN_TRANSFER_SUCCESS = "fc::success::token_transfer",
+    BLUVO_WITHDRAWAL_COMPLETED = "fc::success::bluvo_withdrawal_completed"
+}

package/dist/hooks/track/WithdrawModalEvent.d.ts

@@ -1,4 +1,7 @@
 export declare enum WithdrawModalEvent {
     MODAL_OPENED = "fw::modal_opened",
-    MODAL_CLOSED = "fw::modal_closed"
+    MODAL_CLOSED = "fw::modal_closed",
+    FINAL_QUOTE = "fw::quote::final_quote",
+    PENDING_CALLBACK = "fw::pending_callback",
+    SUCCESS = "fw::success"
 }

package/dist/hooks/track/useTrack.d.ts

@@ -1,32 +1,6 @@
 import type { FunkitUserInfo } from '~/consts/funkit';
+import type { CheckoutModalEvent } from './CheckoutModalEvent';
 import type { WithdrawModalEvent } from './WithdrawModalEvent';
-export declare enum CheckoutModalEvent {
-    MODAL_OPENED = "fc::modal_opened",
-    MODAL_CLOSED = "fc::modal_closed",
-    NAVIGATE_SOURCE_CHANGE = "fc::navigate::source_change",
-    NAVIGATE_SELECT_ASSET = "fc::navigate::select_asset",
-    NAVIGATE_CONFIRMATION = "fc::navigate::confirmation",
-    NAVIGATE_CHECKOUT_COMPLETE = "fc::navigate::checkout_complete",
-    NAVIGATE_TRANSFER_TOKEN = "fc::navigate::transfer_token",
-    NAVIGATE_INPUT_AMOUNT = "fc::navigate::input_amount",
-    NAVIGATE_ERROR_SCREEN = "fc::navigate::error_screen",
-    NAVIGATE_FIAT_ACCOUNT_DETAIL = "fc::navigate::fiat_account_detail",
-    NAVIGATE_BRIDGE_KYC = "fc::navigate::bridge_kyc",
-    NAVIGATE_BRIDGE_CUSTOMER = "fc::navigate::bridge_customer",
-    NAVIGATE_MOONPAY_SETUP = "fc::navigate::moonpay_setup",
-    NAVIGATE_MELD_QUOTES = "fc::navigate::meld_quotes",
-    NAVIGATE_MELD_REDIRECT = "fc::navigate::meld_redirect",
-    NAVIGATE_MELD_CURRENCY_SELECT = "fc::navigate::meld_currency_select",
-    NAVIGATE_DIRECT_EXECUTION_NOTIF_CENTER = "fc::navigate::direct_execution_notif_center",
-    NAVIGATE_KYC_IFRAME = "fc::navigate::kyc_iframe",
-    NAVIGATE_CREATE_FIAT_ACCOUNT = "fc::navigate::create_fiat_account",
-    NAVIGATE_LOADING_ACCOUNT = "fc::navigate::loading_account",
-    NAVIGATE_CHECKOUT_HELP = "fc::navigate::checkout_help",
-    FINAL_QUOTE = "fc::quote::final_quote",
-    ACCOUNT_BALANCE_SUCCESS = "fc::success::account_balance",
-    TOKEN_TRANSFER_SUCCESS = "fc::success::token_transfer",
-    WITHDRAWAL_SUCCESS = "fc::success::withdrawal"
-}
 export interface TrackEventData {
     eventName: CheckoutModalEvent | WithdrawModalEvent;
     value?: string | number;

package/dist/hooks/useBluvo.d.ts

@@ -0,0 +1,225 @@
+import type { WalletwithdrawquotequotationResponse as WithdrawalQuotation } from '@bluvo/sdk-ts';
+import { BluvoExchangeStatus, type BluvoExchangeType } from '~/consts/bluvo';
+import { type FunkitActiveCheckoutItem } from '~/providers/FunkitCheckoutContext';
+import type { FunBrokerageItemProps } from '../components/FunSelectBrokerage/FunBrokerageItem';
+type SupportedExchangeOption = FunBrokerageItemProps & {
+    exchange: BluvoExchangeType;
+    status: BluvoExchangeStatus;
+};
+type BluvoCheckoutQuoteParams = {
+    chainId: FunkitActiveCheckoutItem['selectedSourceAssetInfo']['chainId'];
+    symbol: FunkitActiveCheckoutItem['selectedSourceAssetInfo']['symbol'];
+    amount: string;
+};
+export declare const useBluvoExchangeBalance: ({ exchange, }: {
+    exchange: BluvoExchangeType | undefined;
+}) => {
+    data: import("~/domains/wallet").AssetHoldingsMap<import("~/domains/wallet").BrokerageAssetHoldingsItem>;
+    totalBalance: number;
+    isLoading: boolean;
+    isError: boolean;
+};
+export declare const useBluvoCheckoutQuote: () => {
+    getBluvoCheckoutQuote: ({ amount, symbol, chainId, }: BluvoCheckoutQuoteParams) => Promise<WithdrawalQuotation | undefined>;
+};
+export declare const useBluvoSupportedExchanges: ({ fullInfo, iconSize, filterBy, }: {
+    fullInfo?: boolean;
+    iconSize?: number;
+    filterBy?: BluvoExchangeStatus[];
+}) => {
+    exchangeOptions: ReadonlyArray<SupportedExchangeOption>;
+};
+export declare const useBluvo: () => {
+    exchangeType: BluvoExchangeType | undefined;
+    bluvoClient: {
+        listExchanges: (status?: "live" | "offline" | "maintenance" | "coming_soon") => Promise<{
+            id: string;
+            name: string;
+            logoUrl: string;
+            status: import("@bluvo/sdk-ts").StatusEnum;
+        }[] | null>;
+        startWithdrawalFlow: (flowOptions: import("@bluvo/sdk-ts").WithdrawalFlowOptions) => Promise<{
+            machine: import("@bluvo/sdk-ts").Machine<import("@bluvo/sdk-ts").FlowState, import("@bluvo/sdk-ts").FlowActionType>;
+            closeOAuthWindow: null;
+        } | {
+            machine: import("@bluvo/sdk-ts").Machine<import("@bluvo/sdk-ts").FlowState, import("@bluvo/sdk-ts").FlowActionType>;
+            closeOAuthWindow: () => void;
+        }>;
+        resumeWithdrawalFlow: (flowOptions: import("@bluvo/sdk-ts").ResumeWithdrawalFlowOptions) => Promise<{
+            machine: import("@bluvo/sdk-ts").Machine<import("@bluvo/sdk-ts").FlowState, import("@bluvo/sdk-ts").FlowActionType>;
+            closeOAuthWindow: null;
+        }>;
+        silentResumeWithdrawalFlow: (flowOptions: import("@bluvo/sdk-ts").SilentResumeWithdrawalFlowOptions) => Promise<{
+            machine: import("@bluvo/sdk-ts").Machine<import("@bluvo/sdk-ts").FlowState, import("@bluvo/sdk-ts").FlowActionType>;
+        } | null>;
+        requestQuote: (options: import("@bluvo/sdk-ts").QuoteRequestOptions) => Promise<{
+            rawQuote: {
+                id: string;
+                asset: string;
+                amountWithFee?: number | null;
+                amountNoFee?: number | null;
+                estimatedFee?: number | null;
+                amountWithFeeInFiat?: number | null;
+                amountNoFeeInFiat?: number | null;
+                estimatedFeeInFiat?: number | null;
+                destinationAddress: string;
+                network?: string | null;
+                tag?: string | null;
+                estimatedTotal?: number;
+                feeDetails?: Array<{
+                    category: import("@bluvo/sdk-ts").CategoryEnum;
+                    currency: string;
+                    amount: number;
+                    amountInFiat: number;
+                    fiatCurrency: string;
+                }>;
+                expiresAt: string;
+                additionalInfo: {
+                    minWithdrawal: string | null;
+                    maxWithdrawal?: string | null;
+                };
+            };
+            quoteData: {
+                id: string;
+                asset: string;
+                amount: string;
+                estimatedFee: string;
+                estimatedTotal: string;
+                amountWithFeeInFiat: string;
+                amountNoFeeInFiat: string;
+                estimatedFeeInFiat: string;
+                additionalInfo: {
+                    minWithdrawal: string | null;
+                    maxWithdrawal?: string | null;
+                };
+                expiresAt: number;
+            };
+        } | undefined>;
+        executeWithdrawal: (quoteId: string) => Promise<{
+            success: boolean;
+            error?: string;
+            type?: import("@bluvo/sdk-ts").TypeEnum2;
+            result?: unknown;
+        } | null | undefined>;
+        submit2FA: (code: string) => Promise<{
+            success: boolean;
+            error?: string;
+            type?: import("@bluvo/sdk-ts").TypeEnum2;
+            result?: unknown;
+        } | null | undefined>;
+        retryWithdrawal: () => Promise<{
+            success: boolean;
+            error?: string;
+            type?: import("@bluvo/sdk-ts").TypeEnum2;
+            result?: unknown;
+        } | null | undefined>;
+        cancel: () => void;
+        testWithdrawalComplete: (transactionId?: string) => void;
+        isIdle: boolean;
+        isFlowCancelled: boolean;
+        isExchangesLoading: boolean;
+        isExchangesReady: boolean;
+        isExchangesError: boolean;
+        exchangesError: Error | null;
+        isOAuthPending: boolean;
+        isOAuthWaiting: boolean;
+        isOAuthProcessing: boolean;
+        isOAuthError: boolean;
+        isOAuthFatal: boolean;
+        isWalletConnectionInvalid: boolean;
+        isOAuthComplete: boolean;
+        isOAuthWindowBeenClosedByTheUser: boolean;
+        isWalletLoading: boolean;
+        isWalletError: boolean;
+        isWalletReady: boolean;
+        isQuoteLoading: boolean;
+        isQuoteReady: boolean;
+        isQuoteExpired: boolean;
+        isQuoteError: boolean;
+        isWithdrawing: boolean;
+        isWithdrawProcessing: boolean;
+        isWithdrawalComplete: boolean;
+        isWithdrawBlocked: boolean;
+        hasFatalError: boolean;
+        requires2FA: boolean;
+        requiresSMS: boolean;
+        requiresKYC: boolean;
+        requiresValid2FAMethod: boolean;
+        requiresEmailVerification: boolean;
+        hasInsufficientBalance: boolean;
+        canRetry: boolean;
+        hasAmountError: boolean;
+        hasAddressError: boolean;
+        hasNetworkError: boolean;
+        hasWalletNotFoundError: boolean;
+        hasInvalidCredentialsError: boolean;
+        invalid2FAAttempts: number;
+        retryAttempts: number;
+        maxRetryAttempts: number;
+        exchanges: {
+            id: string;
+            name: string;
+            logoUrl: string;
+            status: string;
+        }[];
+        walletBalances: {
+            asset: string;
+            balance: string;
+            balanceInFiat?: string;
+            networks?: Array<{
+                id: string;
+                name: string;
+                displayName: string;
+                minWithdrawal: string;
+                maxWithdrawal?: string;
+                assetName: string;
+                addressRegex?: string | null;
+            }>;
+            extra?: {
+                slug?: string;
+                assetId?: string;
+            };
+        }[];
+        quote: {
+            id: string;
+            asset: string;
+            amount: string;
+            estimatedFee: string;
+            estimatedTotal: string;
+            amountWithFeeInFiat: string;
+            amountNoFeeInFiat: string;
+            estimatedFeeInFiat: string;
+            additionalInfo: {
+                minWithdrawal: string | null;
+                maxWithdrawal?: string | null;
+            };
+            expiresAt: number;
+        } | undefined;
+        withdrawal: {
+            id: string;
+            status: string;
+            transactionId?: string;
+        } | undefined;
+        valid2FAMethods: string[] | undefined;
+        client: import("@bluvo/sdk-ts").BluvoFlowClient;
+        state: import("@bluvo/sdk-ts").FlowState | null;
+        send: (action: import("@bluvo/sdk-ts").FlowActionType) => void;
+        isInState: (stateType: import("@bluvo/sdk-ts").FlowState["type"]) => boolean;
+        hasError: boolean;
+        error: Error | null | undefined;
+        context: (Record<string, any> & import("@bluvo/sdk-ts").FlowContext) | undefined;
+    };
+    isConnected: boolean;
+    walletId: string | undefined;
+    authorizedConnections: Partial<Record<BluvoExchangeType, string>>;
+    handleStartWithdrawal: (brokerType: BluvoExchangeType) => Promise<{
+        machine: import("@bluvo/sdk-ts").Machine<import("@bluvo/sdk-ts").FlowState, import("@bluvo/sdk-ts").FlowActionType>;
+        closeOAuthWindow: null;
+    } | {
+        machine: import("@bluvo/sdk-ts").Machine<import("@bluvo/sdk-ts").FlowState, import("@bluvo/sdk-ts").FlowActionType>;
+        closeOAuthWindow: () => void;
+    } | undefined>;
+    quoteExpiresAt: number | undefined;
+};
+export declare const useUnlinkBluvo: () => () => void;
+export {};

package/dist/hooks/useCheckoutAccountBalanceTransfer.d.ts

@@ -14,7 +14,6 @@ export declare function useCheckoutAccountBalanceTransfer(): {
             bypassInit: boolean;
             apiKey?: string;
             nonce?: bigint | undefined;
-            logger?: import("@funkit/api-base").Logger | undefined;
             fee?: {
                 token?: string;
                 amount?: number;
@@ -22,6 +21,7 @@ export declare function useCheckoutAccountBalanceTransfer(): {
                 recipient: import("viem").Address;
             } | undefined;
             skipDBAction?: boolean | undefined;
+            logger?: import("@funkit/api-base").Logger | undefined;
         };
     } | {
         rFunWallet: null;

package/dist/hooks/usePaymentSources.d.ts

@@ -6,6 +6,7 @@ export declare function usePaymentMethodEnablement({ checkoutConfig, }: {
     isFiatEnabled: boolean;
     isTokenTransferEnabled: boolean;
     isCardEnabled: boolean;
+    isBrokerageEnabled: boolean;
 };
 export declare const usePaymentSources: (paymentMethodInfo: ConnectablePaymentMethodInfo | null, targetChainId: string, checkoutConfig?: FunkitCheckoutConfig) => {
     preferred: PaymentMethod[] | (import("~/domains/paymentMethods").PaymentMethodBrokerageInfo | import("~/domains/paymentMethods").PaymentMethodAccountInfo | import("~/domains/paymentMethods").PaymentMethodVirtualBankInfo)[];

package/dist/hooks/useTokenTransfer.d.ts

@@ -21,4 +21,15 @@ interface UseTokenTransferResult {
     blockchain: 'ethereum' | 'solana' | 'bitcoin';
 }
 export declare const useTokenTransfer: (selectedChainId: number, selectedToken: string, chainIds?: number[]) => UseTokenTransferResult;
+/**
+ * Differentiates limit for Canada/Australia users to avoid confusion with non american dollars
+ */
+export declare const useMinTransferLimits: () => {
+    mainnet: number;
+    nonMainnet: number;
+};
+export declare function getMinTransferValueForChain(chainId: number, limits: {
+    mainnet: number;
+    nonMainnet: number;
+}): number;
 export {};