@funkit/connect 5.2.0 → 5.3.1

package/dist/domains/quote.d.ts

@@ -3,23 +3,25 @@ import type { Address } from 'viem';
 import type { Config } from 'wagmi';
 import type { FunkitActiveCheckoutItem } from '~/providers/FunkitCheckoutContext';
 import type { LoginType } from '~/providers/GeneralWalletProvider';
-import { type CheckoutFees } from './fees';
+import type { FunkitDirectExecutionInfo } from '~/hooks/useCheckoutDirectExecution';
+import { type BrokerageDetails, type CheckoutFees } from './fees';
 import { type PaymentMethodInfo } from './paymentMethods';
 export interface FunkitCheckoutQuoteResult extends Omit<ApiFunkitCheckoutQuoteResult, 'finalFeesBreakdown'> {
     finalSpreadUsd: string;
     finalFeesBreakdown: CheckoutFees;
 }
-export declare function getCheckoutBaseQuote(checkoutItem: FunkitActiveCheckoutItem, userId: string, walletAddress: Address, apiKey: string, sponsorInitialTransferGasLimit: number, wagmiConfig: Config): Promise<CheckoutQuoteResponse>;
-export declare function getDirectExecutionBaseQuote({ toChainId, toTokenAddress, toTokenAmount, toTokenDecimals, fromTokenAddress, apiKey, }: {
-    toChainId: string;
-    toTokenAddress: Address;
-    toTokenAmount: number;
-    toTokenDecimals: number;
-    fromTokenAddress: Address;
-    apiKey: string;
-}): Promise<CheckoutQuoteResponse>;
-export declare function getQuoteFinalEstimation(baseQuote: CheckoutQuoteResponse, checkoutItem: FunkitActiveCheckoutItem, newPaymentMethodInfo: PaymentMethodInfo, wagmiConfig: Config, apiKey: string, loginType: LoginType, enableFrogProxyServer?: boolean): Promise<FunkitCheckoutQuoteResult>;
-export declare function getAvailableAssetAmount(checkoutItem: FunkitActiveCheckoutItem, newPaymentMethodInfo: PaymentMethodInfo, finalEstimation: FunkitCheckoutQuoteResult, wagmiConfig: Config, walletAddress: Address): Promise<number | undefined>;
+export declare function getCheckoutBaseQuote(checkoutItem: FunkitActiveCheckoutItem, userId: string, walletAddress: Address, apiKey: string, sponsorInitialTransferGasLimit: number, wagmiConfig: Config, directExecutionInfo: FunkitDirectExecutionInfo): Promise<CheckoutQuoteResponse>;
+export declare function getQuoteFinalEstimation(baseQuote: CheckoutQuoteResponse, checkoutItem: FunkitActiveCheckoutItem, newPaymentMethodInfo: PaymentMethodInfo, wagmiConfig: Config, apiKey: string, loginType: LoginType, enableFrogProxyServer?: boolean): Promise<{
+    finalEstimation: FunkitCheckoutQuoteResult;
+    brokerage?: BrokerageDetails;
+}>;
+export interface CheckedAssetAmount {
+    isAboveMaximum: boolean;
+    isBelowMinimum: boolean;
+    maxTargetAssetAmount?: number;
+    minTargetAssetAmount?: number;
+}
+export declare function checkAssetAmount(checkoutItem: FunkitActiveCheckoutItem, newPaymentMethodInfo: PaymentMethodInfo, finalEstimation: FunkitCheckoutQuoteResult, wagmiConfig: Config, walletAddress: Address, brokerage?: BrokerageDetails): Promise<CheckedAssetAmount>;
 export interface CheckoutQuoteParams {
     checkoutItem: FunkitActiveCheckoutItem;
     userId: string;
@@ -30,9 +32,10 @@ export interface CheckoutQuoteParams {
     wagmiConfig: Config;
     loginType: LoginType;
     enableFrogProxyServer?: boolean;
+    directExecutionInfo: FunkitDirectExecutionInfo;
 }
-export declare function getQuoteAndEstimation({ checkoutItem, userId, walletAddress, apiKey, sponsorInitialTransferGasLimit, newPaymentMethodInfo, wagmiConfig, loginType, enableFrogProxyServer, }: CheckoutQuoteParams): Promise<{
+export declare function getQuoteAndEstimation({ checkoutItem, userId, walletAddress, apiKey, sponsorInitialTransferGasLimit, newPaymentMethodInfo, wagmiConfig, loginType, enableFrogProxyServer, directExecutionInfo, }: CheckoutQuoteParams): Promise<{
     baseQuote: CheckoutQuoteResponse;
+    checkedAssetAmount: CheckedAssetAmount;
     finalEstimation: FunkitCheckoutQuoteResult;
-    availableAssetAmount: number | undefined;
 }>;

package/dist/domains/relay.d.ts

@@ -0,0 +1,52 @@
+import type { CheckoutQuoteResponse } from '@funkit/api-base';
+import { type Execute } from '@reservoir0x/relay-sdk';
+import type { Address, WalletClient } from 'viem';
+export type RelayExecutionStatus = 'refund' | 'delayed' | 'waiting' | 'failure' | 'pending' | 'success';
+export interface RelayExecutionInfo {
+    status: RelayExecutionStatus;
+    details: string;
+    /** Incoming transaction hashes */
+    inTxHashes: string[];
+    /** Outgoing transaction hashes */
+    txHashes: string[];
+    /** The last timestamp the data was updated in milliseconds */
+    time: number;
+    originChainId: number;
+    destinationChainId: number;
+}
+export declare const TERMINAL_RELAY_STATUSES: RelayExecutionStatus[];
+export declare const RELAY_TRANSACTION_PAGE_URL = "https://relay.link/transaction/";
+export declare const FUN_RELAY_REVENUE_WALLET = "0xb61562d83aEC43a050A06BED12Ac2bD8f9BFfd5E";
+export declare const FUN_RELAY_REFERRER = "funxyz";
+export declare const RELAY_NATIVE_TOKEN = "0x0000000000000000000000000000000000000000";
+/**
+ * Convert a token address within Funkit the corresponding Relay token address.
+ */
+export declare function convertFunToRelayTokenAddress(address: string): string;
+export declare function parseRelayFees({ relayFeeItem, }: {
+    relayFeeItem: Execute['fees'];
+}): {
+    relayGasFeesUsd: number;
+    totalLpFeesUsd: number;
+    totalFeesUsd: number;
+    totalFeesFromAmount: number;
+    totalFeesFromAmountBaseUnit: bigint;
+};
+export declare function computeFunRelayFeeBps(): string;
+export declare function getRelayQuote({ toChainId, toTokenAddress, toTokenAmount, toTokenDecimals, fromChainId, fromTokenAddress, recipientAddress, userAddress, }: {
+    toChainId: string;
+    toTokenAddress: Address;
+    toTokenAmount: number;
+    toTokenDecimals: number;
+    fromChainId: string;
+    fromTokenAddress: Address;
+    recipientAddress: Address | undefined;
+    userAddress: Address | undefined;
+}): Promise<CheckoutQuoteResponse>;
+export declare function executeRelayQuote({ relayQuote, walletClient, stepMessageSetter, onConfirmed, onError, }: {
+    relayQuote: Execute;
+    walletClient: WalletClient | undefined;
+    stepMessageSetter: (m: string) => void;
+    onConfirmed: (txHash: string) => Promise<void>;
+    onError: (error: Error) => Promise<void>;
+}): Promise<void>;

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/useCheckoutDirectExecution.d.ts

@@ -0,0 +1,30 @@
+import { type CheckoutQuoteResponse, DirectExecutionType } from '@funkit/api-base';
+import type { Address, Hex } from 'viem';
+import type { FunkitCheckoutQuoteResult } from '~/domains/quote';
+import type { FunkitActiveCheckoutItem, FunkitCheckoutActionParams } from '~/providers/FunkitCheckoutContext';
+interface DirectExecutionQuoteRequestParams {
+    toChainId: string;
+    toTokenAddress: Address;
+    toTokenAmount: number;
+    toTokenDecimals: number;
+    fromChainId: string;
+    fromTokenAddress: Address;
+    recipientAddress: Address;
+}
+interface DirectExecutionStartParams {
+    checkoutItem: FunkitActiveCheckoutItem;
+    stepMessageSetter: (m: string) => void;
+    actionsParams: FunkitCheckoutActionParams[];
+    latestQuote: FunkitCheckoutQuoteResult;
+}
+export interface FunkitDirectExecutionInfo {
+    isDirectExecution: boolean;
+    directExecutionType: DirectExecutionType | null;
+    getDirectExecutionQuote: (params: DirectExecutionQuoteRequestParams) => Promise<CheckoutQuoteResponse | null>;
+    executeDirectExecution: (params: DirectExecutionStartParams) => Promise<Hex | null>;
+}
+interface UseCheckoutDirectExecutionReturn {
+    getDirectExecutionInfo: (checkoutItem: FunkitActiveCheckoutItem | null) => FunkitDirectExecutionInfo;
+}
+export declare function useCheckoutDirectExecution(): UseCheckoutDirectExecutionReturn;
+export {};

package/dist/hooks/useCheckoutDirectExecutionHistory.d.ts

@@ -0,0 +1,11 @@
+import { CheckoutRefundState, CheckoutState, type DirectExecution } from '@funkit/api-base';
+export declare function useCheckoutDirectExecutionHistory({ directExecution, }: {
+    directExecution: DirectExecution | undefined;
+}): {
+    state: CheckoutState;
+    refundState: CheckoutRefundState | undefined;
+    isRefunded: boolean;
+    isCompleted: boolean;
+    isFailed: boolean;
+    isDelayed: boolean;
+};

package/dist/hooks/useCheckoutTimeEstimate.d.ts

@@ -4,4 +4,5 @@ import { PaymentMethod } from '~/domains/paymentMethods';
  * https://linear.app/funxyz/issue/PE-775/sdkconnectwith-next-pm-requests
  * @returns time estimation in seconds
  */
-export declare function useCheckoutTimeEstimate(originalTimeEstimationMs: number | undefined, paymentMethod?: PaymentMethod): number;
+export declare function useCheckoutTimeEstimate(originalTimeEstimationMs: number | undefined, paymentMethod?: PaymentMethod, //TODO: questionable
+bypassFlag?: boolean): number;

package/dist/hooks/useCopyToClipboard.d.ts

@@ -1,4 +1,8 @@
-export declare const useCopyToClipboard: (text: string) => {
-    copied: boolean;
-    copy: () => void;
+/**
+ * Handles copy action on provided text
+ * isCopied state is reverted to default value after provided delay
+ */
+export declare const useCopyToClipboard: (text: string, delay?: number) => {
+    isCopied: boolean;
+    handleCopy: () => void;
 };

package/dist/hooks/useFrogAccount.d.ts

@@ -0,0 +1,335 @@
+import { type BridgeVirtualBankAccount, type Guid } from '@funkit/api-base';
+import { type AllFiatAccounts } from '~/domains/bridge';
+export declare function useFrogAccounts(): import("@tanstack/react-query").UseQueryResult<import("@funkit/api-base").SubAccount[] | null, Error>;
+export declare function useClearFrogAccountsCache(): {
+    clearFrogAccounts: () => void;
+    clearVirtualFiatAccounts: () => void;
+};
+export declare function useVirtualFiatAccounts(): {
+    isLoading: boolean;
+    data: AllFiatAccounts;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<AllFiatAccounts, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<AllFiatAccounts>;
+} | {
+    isLoading: boolean;
+    data: AllFiatAccounts;
+    error: null;
+    isError: false;
+    isPending: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: false;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<AllFiatAccounts, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<AllFiatAccounts>;
+} | {
+    isLoading: boolean;
+    data: undefined;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<AllFiatAccounts, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<AllFiatAccounts>;
+} | {
+    isLoading: boolean;
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<AllFiatAccounts, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<AllFiatAccounts>;
+} | {
+    isLoading: boolean;
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<AllFiatAccounts, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<AllFiatAccounts>;
+} | {
+    isLoading: boolean;
+    data: AllFiatAccounts;
+    isError: false;
+    error: null;
+    isPending: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: true;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<AllFiatAccounts, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<AllFiatAccounts>;
+};
+export declare function useMatchingVirtualFiatAccount(accounts: AllFiatAccounts | undefined): BridgeVirtualBankAccount | undefined;
+export type KycLinkLoad = {
+    kycLink?: string;
+    guid: Guid;
+};
+export declare function useLoadKycLink(linkLoad: KycLinkLoad): {
+    data: string | undefined;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<string, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<string>;
+} | {
+    data: string | undefined;
+    error: null;
+    isError: false;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: false;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<string, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<string>;
+} | {
+    data: string | undefined;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<string, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<string>;
+} | {
+    data: string | undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoading: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<string, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<string>;
+} | {
+    data: string | undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isLoading: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<string, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<string>;
+} | {
+    data: string | undefined;
+    isError: false;
+    error: null;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: true;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<string, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<string>;
+};
+type Result<T, E> = {
+    type: 'success';
+    data: T;
+} | {
+    type: 'error';
+    error: E;
+};
+export declare function useCreateVirtualBankAccount(): () => Promise<Result<BridgeVirtualBankAccount, Error>>;
+export {};

package/dist/hooks/useIsUsBankrUser.d.ts

@@ -0,0 +1 @@
+export declare function useIsUsBankrUser(): boolean;

package/dist/hooks/usePaymentMethodIcon.d.ts

@@ -4,6 +4,7 @@ export declare const PAYMENT_METHOD_ICONS: {
     brokerage: (size: number) => React.JSX.Element;
     card: (size: number) => React.JSX.Element;
     token_transfer: (size: number) => React.JSX.Element;
+    virtual_bank: (size: number) => React.JSX.Element;
 };
 /**
   Reference ENG-716

package/dist/hooks/usePaymentSources.d.ts

@@ -1,6 +1,6 @@
 import { type ConnectablePaymentMethodInfo, PaymentMethod } from '~/domains/paymentMethods';
 export declare const usePaymentSources: (paymentMethodInfo: ConnectablePaymentMethodInfo | null, targetChainId: string) => {
-    preferred: (import("~/domains/paymentMethods").PaymentMethodBrokerageInfo | import("~/domains/paymentMethods").PaymentMethodAccountInfo)[] | PaymentMethod[];
+    preferred: (import("~/domains/paymentMethods").PaymentMethodBrokerageInfo | import("~/domains/paymentMethods").PaymentMethodAccountInfo | import("~/domains/paymentMethods").PaymentMethodVirtualBankInfo)[] | PaymentMethod[];
     moreSources: PaymentMethod[];
 };
 export declare const useRemainingPaymentSourcesCount: (targetChainId: string) => number;

package/dist/hooks/useReceiveAmountLabel.d.ts

@@ -0,0 +1,4 @@
+import { DirectExecutionType } from '@funkit/api-base';
+export declare function useReceiveAmountLabel({ directExecutionType, }: {
+    directExecutionType?: DirectExecutionType | null;
+}): string;

package/dist/hooks/useRelayBypass.d.ts

@@ -1,12 +1,16 @@
+import { PaymentMethod } from '~/domains/paymentMethods';
 export interface RelayBypassChainsAndTokens {
     [chainId: number]: string[];
 }
-export interface UseRelayBypassReturn {
-    isEnabled: boolean;
-}
-export declare function useRelayBypass({ fromChainId, fromTokenAddress, toChainId, toTokenAddress, }: {
-    fromChainId: number;
+interface GetIsRelayEnabledParams {
+    fromChainId: string;
     fromTokenAddress: string;
-    toChainId: number;
+    toChainId: string;
     toTokenAddress: string;
-}): UseRelayBypassReturn;
+    paymentMethod: PaymentMethod | undefined;
+}
+export interface UseRelayBypassReturn {
+    getIsRelayEnabled: (params: GetIsRelayEnabledParams) => boolean;
+}
+export declare function useRelayBypass(): UseRelayBypassReturn;
+export {};

package/dist/hooks/useRelayExecutionInfo.d.ts

@@ -0,0 +1,7 @@
+import { type RelayExecutionInfo } from '~/domains/relay';
+export declare function useRelayExecutionInfo({ relayRequestId, }: {
+    relayRequestId: string | undefined;
+}): {
+    relayExecutionInfo: RelayExecutionInfo | undefined;
+    isLoadingRelayExecutionInfo: boolean;
+};

package/dist/hooks/useTokenTransfer.d.ts

@@ -6,12 +6,13 @@ export type FeeValue = {
 interface UseTokenTransferResult {
     /** where money goes to first */
     depositAddress: FunAddress | undefined;
+    depositAddressTooltip: string;
     /** the final destination of the money */
     recipientAddr: string;
     minTransferUsd: number;
     showOriginalRecipient: boolean;
-    estPriceImpact: FeeValue;
-    maxSlippage: FeeValue;
+    estPriceImpact: FeeValue | undefined;
+    maxSlippage: FeeValue | undefined;
 }
 export declare const useTokenTransfer: (selectedChainId: number, selectedToken: string) => UseTokenTransferResult;
 export {};