@funkit/connect 9.19.0 → 9.20.0

package/dist/consts/customers.d.ts

@@ -21,4 +21,17 @@ export declare function isAaveCustomer(apiKey: string): apiKey is "EWzSv8tWnQ7Uc
  */
 export declare function isCustomerNativeFastPathEnabled(apiKey: string): apiKey is "EWzSv8tWnQ7UcZ2IsDqFw1dYo3Df56FX6KBJ5ztS";
 export declare function isLighterEthSpot(apiKey: string, checkoutConfig: FunkitCheckoutConfig | undefined): boolean | undefined;
+/**
+ * Whether a Lighter checkout targets a spot asset (as opposed to a perps
+ * deposit). Lighter's spot routes encode "SPOT" in their `dynamicRoutingId`
+ * (`LIGHTER_ETH_SPOT`, `LIGHTER_USDC_SPOT_NEW_USER`, …) while perps routes
+ * encode "PERPS" (`LIGHTER_USDC_PERPS`, …). The active `dynamicRoutingId`
+ * tracks the selected target candidate, so this distinguishes spot from perps
+ * even when they share the same target token (the mainnet USDC new-user routes).
+ *
+ * Used to scope the token-entry-by-default treatment to spot deposits only —
+ * perps deposits always open in fiat. A route without a recognisable spot id
+ * is treated as non-spot (the safe, fiat default).
+ */
+export declare function isLighterSpot(apiKey: string, checkoutConfig: Pick<FunkitCheckoutConfig, 'dynamicRoutingId'> | undefined): boolean;
 export declare function isLighterSlowDeposit(apiKey: string, checkoutConfig: Pick<FunkitCheckoutConfig, 'targetChain'> | undefined): boolean;

package/dist/consts/funkit.d.ts

@@ -4,6 +4,8 @@ import type { Address } from 'viem';
  * e.g. on Base it is ETH, but on Polygon it is MATIC/POL. It is not one specific real token address.
  **/
 export declare const NATIVE_TOKEN = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
+/** WETH on Ethereum mainnet (checksummed). */
+export declare const WETH_MAINNET_ADDRESS: Address;
 export declare const FUN_ORG_NAME = "Fun.xyz";
 export declare const FUN_TERMS_URL = "https://fun.xyz/terms";
 export interface FunkitUserInfoBase {

package/dist/consts/polymarket.d.ts

@@ -1,3 +1,4 @@
+import { type Address } from 'viem';
 /** Action type signalling a Polymarket Perps deposit (USDC.e → pUSD → Perps). */
 export declare const POLYMARKET_PERPS_DEPOSIT_ACTION_TYPE = "POLYMARKET_PERPS_DEPOSIT";
 /**
@@ -5,3 +6,11 @@ export declare const POLYMARKET_PERPS_DEPOSIT_ACTION_TYPE = "POLYMARKET_PERPS_DE
  * QR/UDA transfers for the deposit action target this address.
  */
 export declare const POLYMARKET_PUSD_ADDRESS: `0x${string}`;
+/**
+ * Customer-scoped destination-token override for the token-transfer param
+ * builder. Polymarket Perps deposits must target pUSD on-chain regardless of
+ * the configured target asset. Lives here (not in the now-core
+ * `getCheckoutTokenTransferParams`) so the shared param builder stays
+ * customer-agnostic — web resolves the override and injects it.
+ */
+export declare function getPolymarketPerpsTargetAssetOverride(qrcodeActionType: string | undefined): Address | undefined;

package/dist/domains/aave.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Aave native-supply domain logic: pure constants and predicates shared by
+ * the InputAmount fast-path hook and `FunkitQuoteContext` (toggle gating).
+ * The `@aave/client` SDK singleton stays in
+ * `~/modals/CheckoutModal/InputAmount/aaveClient.ts` — importing it here
+ * would run SDK init for every consumer of this module.
+ */
+import type { Address } from 'viem';
+import type { FunkitCheckoutConfig } from '../providers/FunkitCheckoutContext';
+export declare const AAVE_MARKET_ADDRESS_BY_CHAIN: Record<string, Address>;
+interface AaveNativeSupplyContextArgs {
+    apiKey: string;
+    sourceAsset: {
+        chainId: string | number;
+        address: string;
+    };
+    checkoutConfig: Pick<FunkitCheckoutConfig, 'targetChain' | 'targetAsset'>;
+}
+/**
+ * True when the customer has the Aave native fast-path enabled, the
+ * checkout's target chain has an Aave market configured (membership in
+ * AAVE_MARKET_ADDRESS_BY_CHAIN is the single source of truth for "Aave
+ * supported here"), and the source asset matches the target asset
+ * (same chain, same token address). Decoupled from the hook so callers
+ * can branch their UI before mounting the hook.
+ */
+export declare function isAaveNativeSupplyContext({ apiKey, sourceAsset, checkoutConfig, }: AaveNativeSupplyContextArgs): boolean;
+export {};

package/dist/domains/dynamicRouting.d.ts

@@ -1,5 +1,5 @@
 import type { DynamicRoutePath } from '@funkit/fun-relay';
-import type { FunkitCheckoutConfig } from '../providers/FunkitCheckoutContext';
+import type { DynamicTargetAssetCandidate, FunkitCheckoutConfig } from '../providers/FunkitCheckoutContext';
 /**
  * The path shape accepted by {@link mergeDynamicRoutingIntoConfig} /
  * `applyDynamicRouting`. It is a {@link DynamicRoutePath} with the
@@ -22,3 +22,15 @@ export type ApplyDynamicRoutingPath = Omit<DynamicRoutePath, 'getCustomRecipient
  * route when the target asset/chain is rebound.
  */
 export declare function mergeDynamicRoutingIntoConfig(config: FunkitCheckoutConfig, path: ApplyDynamicRoutingPath): FunkitCheckoutConfig;
+/**
+ * Merge a selected {@link DynamicTargetAssetCandidate} into a checkout config —
+ * the pure core of `applyDynamicTargetAssetCandidate`. Rebinds the target token
+ * fields and, in lockstep, the `dynamicRoutingId`; when the candidate carries a
+ * `customRecipient` (account-style candidates such as Polymarket
+ * Predictions/Perps) it also repoints the recipient, otherwise the existing
+ * recipient and routing id are preserved.
+ *
+ * Shared by the SourceChange target-asset dropdown and customer account pickers
+ * so destination selection has a single, tested code path.
+ */
+export declare function mergeDynamicTargetAssetCandidateIntoConfig(config: FunkitCheckoutConfig, candidate: DynamicTargetAssetCandidate): FunkitCheckoutConfig;

package/dist/domains/paymentMethods.d.ts

@@ -35,6 +35,14 @@ export interface PaymentMethodVirtualBankInfo extends PaymentMethodVirtualBankIn
 }
 export type ConnectablePaymentMethodInfo = PaymentMethodAccountInfo | PaymentMethodBrokerageInfo | PaymentMethodVirtualBankInfo;
 export declare function isConnectablePaymentMethodInfo(value: unknown): value is ConnectablePaymentMethodInfo;
+/**
+ * Balance-less rails: checkout methods with no on-chain source holding (Card,
+ * Bitcoin Lightning, etc) where "available balance" is not a meaningful concept,
+ * so balance/min/max validation is skipped. Only ACCOUNT_BALANCE and BROKERAGE
+ * carry a measurable holding. Typed to PaymentMethodInfo's methods, not the full
+ * PaymentMethod enum (which also carries Swapped's iframe-only rails).
+ */
+export declare function isBalanceLessPaymentMethod(paymentMethod: PaymentMethodInfo['paymentMethod']): boolean;
 export type PaymentMethodInfo = PaymentMethodCardInfo | PaymentMethodBrokerageInfo | PaymentMethodAccountInfo | PaymentMethodTokenTransferInfo | PaymentMethodBitcoinLightningInfo | PaymentMethodVirtualBankIncompleteInfo;
 interface CardPaymentMethodParams {
     paymentMethod: PaymentMethod.CARD;

package/dist/domains/quote.d.ts

@@ -18,8 +18,8 @@ export declare function getCheckoutBaseQuote(checkoutItem: FunkitActiveCheckoutI
  * User-driven preference for the source-side authorization step. Forwarded
  * to the direct-execution branch (`getDirectExecutionQuote` →
  * `getCheckoutQuoteV2`) where Relay's `usePermit` flag actually flows. The
- * legacy `getApiCheckoutQuote` branch ignores this; the permit toggle is
- * scoped to Wallet (Relay direct-execution) only.
+ * legacy `getApiCheckoutQuote` branch ignores this. On the Aave native
+ * fast path it drives `shouldUsePermitForSupply` instead of flowing here.
  */
 usePermit?: boolean): Promise<CheckoutQuoteResponse>;
 /**

package/dist/hooks/statsig/useDynamicConfig.d.ts

@@ -1,8 +1,5 @@
-import fallbackDynamicConfigs from '../../__generated__/default_configs';
-type FallbackDynamicConfigs = typeof fallbackDynamicConfigs;
-type DynamicConfigName = keyof FallbackDynamicConfigs;
-export type DynamicConfigValue<Name extends DynamicConfigName> = FallbackDynamicConfigs[Name]['value'];
+import { type DynamicConfigName, type DynamicConfigValue } from '@funkit/connect-core';
+export type { DynamicConfigName, DynamicConfigValue };
 export declare const useDynamicConfig: <Name extends DynamicConfigName>(name: Name, options?: {
     bypassCountryCode?: boolean;
 }) => DynamicConfigValue<Name>;
-export {};

package/dist/hooks/statsig/useExperiment.d.ts

@@ -1,33 +1 @@
-/**
- * Hook for accessing Statsig experiments with type-safe fallback values.
- *
- * Unlike feature gates and dynamic configs, experiments don't have a base configuration
- * with overrides. Instead, they have multiple horizontal variations. Because of this,
- * you must provide a fallback value and can optionally specify the return type.
- *
- * @example
- * // Basic usage (returns string by default)
- * const buttonColor = useExperiment('button-color-test', 'value', 'blue')
- *
- * @example
- * // With explicit type parameter
- * interface ButtonConfig {
- *   color: string
- *   size: 'small' | 'medium' | 'large'
- * }
- * const config = useExperiment<ButtonConfig>(
- *   'button-experiment',
- *   'config',
- *   { color: 'blue', size: 'medium' }
- * )
- *
- * @example
- * // Getting a specific parameter
- * const variant = useExperiment('checkout-flow-test', 'variant', 'control')
- *
- * @param experimentName - The name of the experiment in Statsig
- * @param parameterName - The name of the parameter to get from the experiment
- * @param fallback - The fallback value to use when the experiment/parameter is not available
- * @returns The experiment parameter value with the specified type
- */
-export declare function useExperiment<T = string>(experimentName: string, parameterName: string, fallback: T): T;
+export { useExperiment } from '@funkit/connect-core';

package/dist/hooks/statsig/useFeatureGate.d.ts

@@ -1,4 +1 @@
-import type fallbackFeatureGates from '../../__generated__/default_feature_gates';
-type FeatureGateName = keyof typeof fallbackFeatureGates;
-export declare const useFeatureGate: (name: FeatureGateName) => boolean;
-export {};
+export { useFeatureGate } from '@funkit/connect-core';

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

@@ -25,6 +25,7 @@ export declare enum CheckoutModalEvent {
     NAVIGATE_BROKERAGE_TWO_FA = "fc::navigate::brokerage_two_fa",
     NAVIGATE_BROKERAGE_SUCCESS = "fc::navigate::brokerage_success",
     NAVIGATE_SWAPPED_IFRAME = "fc::navigate::swapped_iframe",
+    NAVIGATE_PERPS_TRANSFER = "fc::navigate::perps_transfer",
     READY_CONFIRMATION = "fc::ready::confirmation",
     READY_INPUT_AMOUNT = "fc::ready::input_amount",
     READY_SELECT_ASSET = "fc::ready::select_asset",

package/dist/hooks/useCheckoutTransferInit.d.ts

@@ -1,6 +1,6 @@
 import { type CheckoutInitTokenTransferAddressParams, type CheckoutInitTokenTransferResponse, type FunAddress } from '@funkit/api-base';
-import { type FunkitCheckoutConfig } from '../providers/FunkitCheckoutContext';
-import { type UDAConfig } from './useUDAParams';
+import { getCheckoutTokenTransferParams } from '@funkit/connect-core';
+export { getCheckoutTokenTransferParams };
 interface UseCheckoutTransferInitResponse {
     transferInit: CheckoutInitTokenTransferResponse | undefined;
     recipientAddr: FunAddress;
@@ -9,20 +9,6 @@ interface UseCheckoutTransferInitResponse {
 }
 type CheckoutTokenTransferParams = Omit<CheckoutInitTokenTransferAddressParams, 'logger' | 'clientMetadata'>;
 export declare function checkoutTransferFetch(params: CheckoutTokenTransferParams): Promise<CheckoutInitTokenTransferResponse>;
-export declare function getCheckoutTokenTransferParams({ checkoutConfig, userId, recipientAddr, apiKey, udaParams, }: {
-    checkoutConfig: FunkitCheckoutConfig | undefined;
-    userId: string;
-    recipientAddr: FunAddress;
-    apiKey: string;
-    udaParams?: UDAConfig | undefined;
-}): {
-    toChainId: string;
-    toTokenAddress: `0x${string}`;
-    actionType: string | undefined;
-    userId: string;
-    apiKey: string;
-    recipientAddr: FunAddress;
-} | undefined;
 export declare function useIsQRCodeTransferEnabled(): {
     enabled: boolean;
     comingSoon: boolean;
@@ -32,4 +18,3 @@ export declare function useIsQRCodeTransferEnabled(): {
  * creates QR code transfer EOA
  */
 export declare const useCheckoutTransferInit: (enabled?: boolean) => UseCheckoutTransferInitResponse;
-export {};

package/dist/hooks/useExchangeOptions.d.ts

@@ -5,6 +5,15 @@ import { type BrokerageOption } from '../consts/bluvo';
  * payment-method preview row. Live entries come first; ComingSoon (and
  * FOPs that came back without an embeddedFlowUrl) follow.
  */
-export declare function useExchangeOptions({ iconSize, }: {
+export declare function useExchangeOptions({ iconSize }: {
     iconSize: number;
-}): BrokerageOption[];
+}): {
+    options: BrokerageOption[];
+    /**
+     * True while the Swapped FOPs are stale placeholder data (kept visible during
+     * a refetch triggered by a recipient/destination change). Callers that act on
+     * a selection should gate Swapped options on this, since a stale FOP's
+     * embedded flow URL may still target the previous recipient.
+     */
+    isPlaceholderData: boolean;
+};

package/dist/hooks/useTokenAndChainDropdown.d.ts

@@ -19,7 +19,7 @@ interface UseTokenChainResult {
 export interface UseTokenAndChainDropdownOptions {
     transferInit?: CheckoutInitTokenTransferResponse;
     defaultValues?: TransferTokenDefault;
-    /** When true, uses legacy withdrawal flags instead of Statsig config. Defaults to false. */
+    /** When true, resolves the withdrawal Statsig config instead of the token-transfer one. Defaults to false. */
     isWithdrawal?: boolean;
     /** When true, starts with no chain/token pre-selected (user must pick both). Defaults to false. */
     noDefaultSelection?: boolean;

package/dist/hooks/useTokenTransfer.d.ts

@@ -1,15 +1,12 @@
 import type { FunAddress } from '@funkit/api-base';
+import { type MinTransferConfig, getMinTransferValueForChain } from '@funkit/connect-core';
 import { type QRCodeUri } from '../utils/transfer';
 export type FeeValue = {
     label: string;
     value: number;
 };
-export interface MinTransferConfig {
-    default: number;
-    chains: {
-        [chainId: string]: number;
-    };
-}
+export type { MinTransferConfig };
+export { getMinTransferValueForChain };
 interface UseTokenTransferResult {
     /** where money goes to first */
     depositAddress: FunAddress | undefined;
@@ -27,7 +24,5 @@ interface UseTokenTransferResult {
     blockchain: 'ethereum' | 'solana' | 'bitcoin' | 'tron';
 }
 export declare const useTokenTransfer: (selectedChainId: number | undefined, selectedToken: string | undefined, chainIds?: number[]) => UseTokenTransferResult;
-export declare function getMinTransferValueForChain(chainId: number, limits: MinTransferConfig): number;
 export declare const useMinTransferValueUsd: (selectedChainId: number | undefined) => number;
 export declare const useMinTransferValueEur: (selectedChainId: number | undefined) => number;
-export {};

package/dist/hooks/useUDAParams.d.ts

@@ -1,11 +1,3 @@
-import type { Address } from 'viem';
-export interface UDAConfig {
-    targetChain: string;
-    targetAsset: Address;
-    targetAssetTicker: string;
-    iconSrc: string;
-    qrcodeActionType?: string;
-    defaultTokenSymbol?: string;
-    defaultChainId?: string;
-}
+import type { UDAConfig } from '@funkit/connect-core';
+export type { UDAConfig };
 export declare const useUDAParams: (_dynamicRoutingId?: string) => UDAConfig | undefined;