@funkit/connect 5.2.1 → 5.3.2

package/dist/domains/relay.d.ts

@@ -1,11 +1,38 @@
 import type { CheckoutQuoteResponse } from '@funkit/api-base';
-import type { Address } from 'viem';
+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;
@@ -16,3 +43,10 @@ export declare function getRelayQuote({ toChainId, toTokenAddress, toTokenAmount
     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/useCheckoutDirectExecution.d.ts

@@ -1,6 +1,7 @@
 import { type CheckoutQuoteResponse, DirectExecutionType } from '@funkit/api-base';
-import type { Address } from 'viem';
-import type { FunkitActiveCheckoutItem } from '~/providers/FunkitCheckoutContext';
+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;
@@ -10,10 +11,17 @@ interface DirectExecutionQuoteRequestParams {
     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;

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/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/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 {};