@funkit/connect 0.0.0-20260710210119

package/dist/utils/address.d.ts

@@ -0,0 +1 @@
+export { getWalletLabel, isAddressCompatibleWithChain, isEvmChainId, isWithdrawalAddressSupported, } from '@funkit/connect-core';

package/dist/utils/assets.d.ts

@@ -0,0 +1,11 @@
+import type { DynamicTargetAssetCandidate, FunkitCheckoutConfig } from '../providers/FunkitCheckoutContext';
+export type { AssetHoldingsItem, AssetHoldingsMap, KnownAssetHoldingsItem, } from '../domains/wallet';
+export declare const getNormalizedTokenBalance: (tokenBalance: bigint | number | string, decimals: number) => number;
+/**
+ * The dynamic-target candidate matching the checkout's *active* target token
+ * (`targetAsset`/`targetChain`), by token-equivalence. Distinct from
+ * `getDefaultDynamicTargetAsset`, which resolves the *default to display* via
+ * routingId/ticker/isDefault
+ */
+export declare const getActiveDynamicTargetAsset: (checkoutConfig: FunkitCheckoutConfig | undefined) => DynamicTargetAssetCandidate | undefined;
+export declare const getDefaultDynamicTargetAsset: (checkoutConfig: FunkitCheckoutConfig | undefined) => DynamicTargetAssetCandidate;

package/dist/utils/bluvo.d.ts

@@ -0,0 +1,153 @@
+import type { WalletwithdrawbalancebalanceResponse } from '@bluvo/sdk-ts';
+type WithdrawableBalance = WalletwithdrawbalancebalanceResponse['balances'][number];
+import { type BluvoExecuteWithdrawalResponse, BluvoWithdrawalError } from '@funkit/api-base';
+import type { BluvoExchangeType } from '../consts/bluvo';
+import type { AssetHoldingsItem, AssetHoldingsMap, BrokerageAssetHoldingsItem } from '../domains/wallet';
+import { type MinTransferConfig } from '../hooks/useTokenTransfer';
+export declare const isBrokerageAsset: (asset: AssetHoldingsItem) => asset is BrokerageAssetHoldingsItem & {
+    usdAmount: number;
+};
+/**
+ * Computes the minimum and maximum USD values for a brokerage asset.
+ * Combines brokerage exchange limits with QR Code/token transfer limits.
+ * @param asset The brokerage asset with min/max amounts
+ * @param minTransferLimits Chain-specific minimum transfer limits
+ * @returns Object with minUsd and maxUsd values
+ */
+export declare function getBrokerageMinMax(asset: BrokerageAssetHoldingsItem & {
+    usdAmount: number;
+}, minTransferLimits: MinTransferConfig, minDeposit?: number): {
+    minUsd: number;
+    maxUsd: number;
+};
+/**
+ * Transforms Bluvo wallet balances into the AssetHoldingsMap format
+ * used by the SelectAsset component.
+ */
+export declare function transformBluvoBalancesToAssetHoldings(balances: WithdrawableBalance[], preferredChainId?: string): AssetHoldingsMap<BrokerageAssetHoldingsItem>;
+export declare function getWalletId(authorizedConnections: Partial<Record<BluvoExchangeType, string>>, exchange: BluvoExchangeType): string;
+declare class BluvoError<ErrorCode extends string> extends Error {
+    readonly message: string;
+    readonly errorCode: ErrorCode;
+    constructor(message: string, errorCode: ErrorCode);
+}
+type ExtractErrorCode<OriginalBluvoError extends {
+    error: string;
+    type: string;
+}> = OriginalBluvoError extends {
+    error: string;
+    type: infer ErrorCode;
+} ? ErrorCode : never;
+export declare function getBluvoError<OriginalBluvoError extends {
+    error: string;
+    type: string;
+}, ErrorCode extends string = ExtractErrorCode<OriginalBluvoError>>(error: OriginalBluvoError): BluvoError<ErrorCode>;
+/**
+ *
+ * @param response - The response from the Bluvo API
+ * @returns The normalized response
+ *
+ * @throws - {@link BluvoWithdrawalError} if the response is invalid or if the withdrawal fails
+ *
+ */
+export declare const normalizeWithdrawalResponse: (response: BluvoExecuteWithdrawalResponse) => {
+    [key: string]: unknown;
+    transactionId: string;
+} | {
+    [key: string]: unknown;
+    bizNo: string;
+    steps: Array<{
+        type: import("@bluvo/sdk-ts").TypeEnum3;
+        status: import("@bluvo/sdk-ts").StatusEnum4;
+        required: boolean;
+        metadata?: {
+            email?: string;
+            emailSent?: boolean;
+            qrCodeUrl?: string;
+            qrCodeValidSeconds?: number;
+            [key: string]: unknown | string | boolean | number | undefined;
+        };
+        [key: string]: unknown | import("@bluvo/sdk-ts").TypeEnum3 | import("@bluvo/sdk-ts").StatusEnum4 | boolean | {
+            email?: string;
+            emailSent?: boolean;
+            qrCodeUrl?: string;
+            qrCodeValidSeconds?: number;
+            [key: string]: unknown | string | boolean | number | undefined;
+        } | undefined;
+    }>;
+    relation: import("@bluvo/sdk-ts").RelationEnum;
+    mfa?: {
+        bizNo?: string;
+        verified: {
+            EMAIL?: boolean;
+            SMS?: boolean;
+            GOOGLE?: boolean;
+            FACE?: boolean;
+        };
+        attempts?: Array<{
+            method: import("@bluvo/sdk-ts").TypeEnum3;
+            status: import("@bluvo/sdk-ts").StatusEnum4;
+            createdAt: number;
+            validatedAt?: number;
+            expiresAt?: number;
+            success: boolean;
+        }>;
+        methods?: Array<{
+            method: "EMAIL";
+            email: string;
+        } | {
+            method: "SMS";
+            phoneNumber: string;
+        } | {
+            method: "GOOGLE";
+        } | {
+            method: "FACE";
+            viaMobile: boolean;
+        }>;
+    };
+} | {
+    [key: string]: unknown;
+    bizNo?: string;
+    steps?: Array<{
+        type: string;
+        status: import("@bluvo/sdk-ts").StatusEnum4;
+        error?: string;
+        [key: string]: unknown | string | import("@bluvo/sdk-ts").StatusEnum4 | undefined;
+    }>;
+    mfa?: {
+        bizNo?: string;
+        verified: {
+            EMAIL?: boolean;
+            SMS?: boolean;
+            GOOGLE?: boolean;
+            FACE?: boolean;
+        };
+        attempts?: Array<{
+            method: import("@bluvo/sdk-ts").TypeEnum3;
+            status: import("@bluvo/sdk-ts").StatusEnum4;
+            createdAt: number;
+            validatedAt?: number;
+            expiresAt?: number;
+            success: boolean;
+        }>;
+        methods?: Array<{
+            method: "EMAIL";
+            email: string;
+        } | {
+            method: "SMS";
+            phoneNumber: string;
+        } | {
+            method: "GOOGLE";
+        } | {
+            method: "FACE";
+            viaMobile: boolean;
+        }>;
+    };
+} | {
+    [key: string]: unknown;
+    valid2FAMethods: Array<string>;
+} | {
+    [key: string]: unknown;
+} | undefined;
+export declare const isBluvoWithdrawalError: (error: unknown) => error is BluvoWithdrawalError;
+export {};

package/dist/utils/checkout.d.ts

@@ -0,0 +1,120 @@
+import type { FunAddress } from '@funkit/api-base';
+export { isCheckoutHistoryDirectExecution, isCheckoutValid, type MergedCheckoutHistoryItem, toMergedCheckoutHistoryItem, } from '@funkit/connect-core';
+import { type ApiFunkitCheckoutQuoteResult, type CheckoutQuoteResponse } from '@funkit/utils';
+import type { Dnum } from 'dnum';
+import { type Address } from 'viem';
+import type { ServerCheckoutConfig } from '../domains/clientMetadata';
+import type { FunkitCheckoutQuoteResult } from '../domains/quote';
+import type { Config, UseConfigReturnType } from '../wagmi/hooks';
+import { type FunkitCheckoutActionParams, type FunkitCheckoutConfig } from '../providers/FunkitCheckoutContext';
+export declare const MOONPAY_TIME_ESTIMATE_MS = 120000;
+export declare const BROKERAGE_TIME_ESTIMATE_MS = 0;
+export declare const BANK_TIME_ESTIMATE_MS = 0;
+export declare const DUMMY_TRANSFER_PARAMS: {
+    toAddress: "0x000000000000000000000000000000000000dEaD";
+    tokenAmount: number;
+};
+type ValidateCheckoutConfigReturn = Promise<{
+    config: FunkitCheckoutConfig;
+    isValid: true;
+    message: string;
+} | {
+    isValid: false;
+    message: string;
+}>;
+/**
+ * Validates the checkout configuration.
+ * @param config - The checkout configuration to validate.
+ * @returns An object indicating whether the configuration is valid and a message if it is not.
+ */
+export declare function validateCheckoutConfig(config: Partial<FunkitCheckoutConfig>): ValidateCheckoutConfigReturn;
+export declare const hasSufficientBalance: (wagmiConfig: UseConfigReturnType, walletAddress: string, tokenAddress: string, tokenChainId: string, requiredAssetAmount: number) => Promise<{
+    balance: number;
+    result: boolean;
+    tokenTicker: string;
+} | {
+    balance: number;
+    result: boolean;
+    tokenTicker: null;
+}>;
+export declare const hasGasToken: (wagmiConfig: UseConfigReturnType, walletAddress: string, chainId: string) => Promise<boolean>;
+export type TokenInfo = {
+    symbol: string;
+    tokenAddress: null | Address;
+    tokenUnitPriceUsd: null | number;
+    pickedChainId: string;
+};
+export declare function getTimeFromNowSeconds(startTimeMs: number, durationMs: number): number;
+export declare function getCheckoutReceivedAmount({ config, quote, }: {
+    config: FunkitCheckoutConfig | ServerCheckoutConfig;
+    quote: ApiFunkitCheckoutQuoteResult | null;
+}): number;
+export declare function getCheckoutReceivedAmountFormatted({ config, quote, }: {
+    config: FunkitCheckoutConfig | ServerCheckoutConfig;
+    quote: ApiFunkitCheckoutQuoteResult | null;
+}): string;
+export declare function getCheckoutSentAmount({ quote, }: {
+    quote: ApiFunkitCheckoutQuoteResult | null;
+}): number;
+export declare function getCheckoutSentAmountFormatted({ quote, }: {
+    quote: ApiFunkitCheckoutQuoteResult | null;
+}): string;
+/**
+ * Given a checkout config, returns the display string for the checkout item.
+ * Arbitrary action checkouts: Display the targetAssetAmount
+ * - not 100% accurate since userOp will consume some tokens, but FINE now.
+ * - e.g. "2.1234 aArbUSDCn" or "Staked VRTX"
+ * Basic buy checkouts: Display the targetAssetAmount with the targetAssetTicker.
+ * - e.g. "0.12345 ETH"
+ * Ideally, should be used via the hook `useCheckoutItemDisplay` to handle the customer cutomization check.
+ */
+export declare function getCheckoutItemDisplay({ checkoutConfig, hideAmount, overrideAmount, }: {
+    checkoutConfig: FunkitCheckoutConfig | ServerCheckoutConfig;
+    hideAmount?: boolean;
+    overrideAmount?: number;
+}): string;
+/**
+ * Given the result of a quote, calculate the effective fees (in source asset).
+ *
+ * _These are only the fees from our base quote, **not** including the initial transfer / brokerage / card processing fees._
+ */
+export declare function getBaseQuoteTotalFeesFromAmount(baseQuote: CheckoutQuoteResponse): number;
+/**
+ * Given the result of a quote, calculate the effective exchange rate (target asset / source asset).
+ */
+export declare function getQuoteExchangeRate(config: FunkitCheckoutConfig, baseQuote: CheckoutQuoteResponse): number;
+/**
+ * Given the result of a quote, estimate the maximum targetAssetAmount for which the checkout should succeed.
+ * The result is then reduced by 1% to further reduce the risk of insufficient funds.
+ *
+ * NOTE: This assumes fees are (roughly) constant, at least when the target amount does not change much.
+ * Only the API could give us a true number here.
+ *
+ * @param sourceAssetBalance - Total source asset balance
+ * @param config - Checkout config
+ * @param quoteResult - Failed quote results
+ */
+export declare function getMaxTargetAssetAmountEstimate(sourceAssetBalance: number, config: FunkitCheckoutConfig, quoteResult: FunkitCheckoutQuoteResult, targetAssetDecimals: number): Dnum;
+export declare function getTokenDecimals(wagmiConfig: Config, chainId: string, tokenAddress: FunAddress): Promise<number>;
+export declare function evaluateCheckoutGenerateActionsParams(config: FunkitCheckoutConfig): Promise<FunkitCheckoutActionParams[]>;
+export declare function isCheckoutCrFlow(config: FunkitCheckoutConfig): boolean;
+/**
+ * @param config can be either be a config from live checkoutItem OR from checkout history's clientMetadata
+ */
+export declare function isCheckoutPostActionRequired(config: FunkitCheckoutConfig | ServerCheckoutConfig): boolean;
+/**
+ * The amount-input switcher labels the *traded* token, which differs by quote
+ * mode: in EXACT_IN the entered amount is the source quantity, so it's labelled
+ * with the input token; in EXACT_OUT it's the destination quantity, labelled
+ * with the output token. Single source of truth shared by the loaded and
+ * loading screens so their labels never diverge.
+ */
+export declare function computeSwitcherDisplayToken({ checkoutConfig, displayAssetAmount, isExactIn, sourceTokenSymbol, }: {
+    checkoutConfig: FunkitCheckoutConfig | ServerCheckoutConfig | undefined;
+    displayAssetAmount: number;
+    isExactIn: boolean;
+    sourceTokenSymbol: string | null | undefined;
+}): {
+    amount: number;
+    symbol: string;
+};

package/dist/utils/checkoutHistory.d.ts

@@ -0,0 +1,10 @@
+import type { CheckoutHistoryItem } from '@funkit/api-base';
+export declare enum HistoryContentPages {
+    DETAIL = "detail"
+}
+/**
+ * Get the checkout completion time in seconds
+ * @param checkout
+ * @returns
+ */
+export declare function getCheckoutCompletionTime(checkout: Pick<CheckoutHistoryItem, 'stateTimestampMs' | 'createdTimeMs' | 'lastUpdatedTimeMs'>): number;

package/dist/utils/combineChainSymbolOrAddress.d.ts

@@ -0,0 +1,4 @@
+export declare function combineChainSymbolOrAddress({ chainId, symbolOrAddress, }: {
+    chainId: string;
+    symbolOrAddress: string;
+}): string;

package/dist/utils/consts.d.ts

@@ -0,0 +1,5 @@
+export declare const MIN_CHECKOUT_AMOUNT_USD = 1;
+export declare const MAX_BTC_LIGHTNING_AMOUNT_USD = 10000;
+export declare const LOW_BALANCE = "Low Balance";
+export declare const CONTACT_US_LINK = "https://intercom.help/funxyz/en/articles/10732578-contact-us";
+export declare const DEFAULT_CHECKOUT_HISTORY_DETAIL_TITLE = "Your Purchase";