@funkit/connect 8.3.0 → 8.3.1-next.0

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # @funkit/connect
 
+## 8.3.1-next.0
+
+### Patch Changes
+
+- addf363: feat(connect): add AZTEC token support for Lighter exchange
+- fdefe58: feat(connect): update lighter utils to use dynamic target id for dynamic target assets
+- Updated dependencies [addf363]
+  - @funkit/fun-relay@2.4.1-next.0
+
 ## 8.3.0
 
 ### Minor Changes

package/dist/__generated__/default_configs.d.ts

@@ -242,6 +242,23 @@ declare const _default: {
                     readonly path: "FUN_MAINNET_DEPOSIT";
                 };
             }];
+        }, {
+            readonly routeId: "LIGHTER_AZTEC_SPOT_NEW_USER";
+            readonly rules: readonly [{
+                readonly when: {
+                    readonly chainId: "1";
+                    readonly tokenAddress: "0xA27EC0006e59f245217Ff08CD52A7E8b169E62D2";
+                };
+                readonly use: {
+                    readonly path: "FUN_MAINNET_DEPOSIT";
+                    readonly badge: "NATIVE";
+                };
+            }, {
+                readonly when: "*";
+                readonly use: {
+                    readonly path: "FUN_MAINNET_DEPOSIT";
+                };
+            }];
         }];
     };
     readonly enablebitcoin: {
@@ -331,6 +348,41 @@ declare const _default: {
             readonly nonMainnet: 2.5;
         };
     };
+    readonly relaybypasssourcechainsandassets: {
+        readonly value: {
+            readonly '1': readonly ["*"];
+            readonly '10': readonly ["*"];
+            readonly '56': readonly ["*"];
+            readonly '137': readonly ["*"];
+            readonly '143': readonly ["*"];
+            readonly '999': readonly ["*"];
+            readonly '2741': readonly ["*"];
+            readonly '8453': readonly ["*"];
+            readonly '42161': readonly ["*"];
+            readonly '747474': readonly ["*"];
+            readonly '5064014': readonly ["*"];
+            readonly '8253038': readonly ["*"];
+        };
+    };
+    readonly relaybypasstargetchainsandassets: {
+        readonly value: {
+            readonly '1': readonly ["*"];
+            readonly '10': readonly ["*"];
+            readonly '56': readonly ["*"];
+            readonly '137': readonly ["*"];
+            readonly '143': readonly ["*"];
+            readonly '999': readonly ["*"];
+            readonly '1337': readonly ["*"];
+            readonly '2741': readonly ["*"];
+            readonly '8453': readonly ["*"];
+            readonly '42161': readonly ["*"];
+            readonly '747474': readonly ["*"];
+            readonly '3586256': readonly ["*"];
+            readonly '5064014': readonly ["*"];
+            readonly '8253038': readonly ["*"];
+            readonly '1151111081099710': readonly ["*"];
+        };
+    };
     readonly showinfobanner: {
         readonly value: {
             readonly message: "";
@@ -344,6 +396,17 @@ declare const _default: {
     readonly supportedexchangesv2: {
         readonly value: readonly [];
     };
+    readonly tokentransferchaingroups: {
+        readonly value: {
+            readonly popular: readonly [1151111081099710, 1, 728126428];
+        };
+    };
+    readonly tokentransfertokengroups: {
+        readonly value: {
+            readonly popular: readonly [];
+            readonly stablecoins: readonly ["BUSD", "DAI", "USDC", "USDC.e", "USDe", "USDT"];
+        };
+    };
     readonly uda_params: {
         readonly value: readonly [{
             readonly dynamicRoutingId: "LIGHTER_ETH_SPOT";

package/dist/atoms/activeCheckout.d.ts

@@ -0,0 +1,183 @@
+import type { DynamicRoutePath } from '@funkit/fun-relay';
+import type { Address } from 'viem';
+import { type PaymentMethodInfo } from '../domains/paymentMethods';
+import type { FunkitCheckoutQuoteResult } from '../domains/quote';
+import type { AssetHoldingsItem } from '../domains/wallet';
+import type { TrackEventData } from '../hooks/track/useTrack';
+import type { FunkitActiveCheckoutItem, FunkitCheckoutActionParams, FunkitCheckoutConfig, UseFunkitCheckoutPropsWithFullConfig } from '../providers/FunkitCheckoutContext';
+import type { LoginType } from '../providers/GeneralWalletProvider';
+import type { WithdrawalClient } from '../wallets/Wallet';
+import type { FunkitDirectExecutionInfo } from './directExecution';
+/**
+ * Write-only atom to set the checkout state.
+ */
+export declare const setCheckoutAtom: import("jotai").WritableAtom<null, [value: FunkitActiveCheckoutItem | null], void> & {
+    init: null;
+};
+/**
+ * Read/write atom for the active checkout.
+ */
+export declare const activeCheckoutAtom: import("jotai").WritableAtom<FunkitActiveCheckoutItem | null, [value: FunkitActiveCheckoutItem | null], void>;
+/**
+ * Partial update atom for the active checkout.
+ * Accepts either partial data or a function that receives current checkout and returns partial data.
+ */
+export declare const updateCheckoutAtom: import("jotai").WritableAtom<null, [data: Partial<FunkitActiveCheckoutItem> | ((checkoutItem: FunkitActiveCheckoutItem) => Partial<FunkitActiveCheckoutItem>)], void> & {
+    init: null;
+};
+/**
+ * Updates the source asset of a given checkout.
+ */
+export declare const updateSourceAssetAtom: import("jotai").WritableAtom<null, [selectedSource: Omit<AssetHoldingsItem, "amount" | "usdAmount">], void> & {
+    init: null;
+};
+/**
+ * Updates the target asset amount of a given checkout.
+ * Uses flushSync internally to avoid stale data issues.
+ */
+export declare const updateTargetAssetAmountAtom: import("jotai").WritableAtom<null, [newTargetAssetAmount: number], void> & {
+    init: null;
+};
+/**
+ * Updates the selected payment method info.
+ */
+export declare const updateSelectedPaymentMethodInfoAtom: import("jotai").WritableAtom<null, [newInfo: PaymentMethodInfo], void> & {
+    init: null;
+};
+/**
+ * Resets the checkout state to initial (null).
+ */
+export declare const resetCheckoutAtom: import("jotai").WritableAtom<null, [], void> & {
+    init: null;
+};
+/**
+ * Creates a new checkout object in the frontend. Not yet initialized in backend.
+ * @returns The new checkoutId
+ */
+export declare const initNewCheckoutAtom: import("jotai").WritableAtom<null, [props: UseFunkitCheckoutPropsWithFullConfig], string> & {
+    init: null;
+};
+export declare const setCompletedTimestampAtom: import("jotai").WritableAtom<null, [timestampMs: number], void> & {
+    init: null;
+};
+/**
+ * Updates the target asset of a checkout.
+ */
+export declare const updateTargetAssetAtom: import("jotai").WritableAtom<null, [asset: {
+    targetAsset: Address;
+    targetChain: string;
+    targetAssetTicker: string;
+    targetAssetMinAmount?: number;
+    iconSrc: string | undefined;
+}], void> & {
+    init: null;
+};
+/**
+ * Applies dynamic routing configuration to the checkout.
+ */
+export declare const applyDynamicRoutingAtom: import("jotai").WritableAtom<null, [path: Omit<DynamicRoutePath, "generateActionsParams" | "getCustomRecipient"> & {
+    customRecipient?: FunkitCheckoutConfig["customRecipient"];
+    generateActionsParams?: FunkitCheckoutConfig["generateActionsParams"];
+}], void> & {
+    init: null;
+};
+/**
+ * Updates the dynamic routing ID.
+ */
+export declare const updateDynamicRoutingIdAtom: import("jotai").WritableAtom<null, [id: string], void> & {
+    init: null;
+};
+/**
+ * Updates the modal title meta.
+ */
+export declare const updateModalTitleMetaAtom: import("jotai").WritableAtom<null, [newMeta: string], void> & {
+    init: null;
+};
+/**
+ * Updates the custom recipient address.
+ */
+export declare const updateCustomRecipientAtom: import("jotai").WritableAtom<null, [recipient: `0x${string}`], void> & {
+    init: null;
+};
+/**
+ * Updates the withdrawal source asset amount.
+ */
+export declare const updateWithdrawalSourceAssetAmountAtom: import("jotai").WritableAtom<null, [amount: number], void> & {
+    init: null;
+};
+/**
+ * Asserts that a checkout item exists, throws if null.
+ */
+export declare function assertCheckoutItem(checkoutItem: FunkitActiveCheckoutItem | null): FunkitActiveCheckoutItem;
+/**
+ * Mutation atom to cancel/deactivate a checkout using jotai-tanstack-query.
+ * Use `mutateAsync` to get a promise that resolves to boolean indicating success.
+ */
+export declare const cancelCheckoutAtom: import("jotai").Atom<import("jotai-tanstack-query").AtomWithMutationResult<boolean, unknown, `0x${string}`, unknown>>;
+export interface UDAParams {
+    targetChain: string;
+    targetAsset: Address;
+    targetAssetTicker: string;
+    iconSrc: string;
+    qrcodeActionType?: string;
+    defaultTokenSymbol?: string;
+    defaultChainId?: string;
+}
+export interface StartDirectExecutionCheckoutParams {
+    stepMessageSetter: (m: string) => void;
+    latestQuote: FunkitCheckoutQuoteResult;
+    sourceOfFund: string;
+    clientMetadata: object;
+    actionsParams: FunkitCheckoutActionParams[];
+    withdrawalClient?: WithdrawalClient;
+    isPaymentMethodBalance: boolean;
+    directExecutionInfo: FunkitDirectExecutionInfo;
+    userId: string;
+    walletAddress: Address | '';
+    udaParams?: UDAParams;
+    logEvent: (event: TrackEventData) => void;
+    refreshCheckoutHistory: () => void;
+    setCheckoutProgress: (checkoutId: string, progress: {
+        step: 1 | 2;
+    }) => void;
+    updateActiveCheckout: (update: Partial<FunkitActiveCheckoutItem>) => void;
+}
+export interface StartRegularCheckoutParams {
+    stepMessageSetter: (m: string) => void;
+    latestQuote: FunkitCheckoutQuoteResult;
+    sourceOfFund: string;
+    clientMetadata: object;
+    refreshCheckoutHistory: () => void;
+    updateActiveCheckout: (update: Partial<FunkitActiveCheckoutItem>) => void;
+}
+export interface ConfirmCheckoutParams {
+    latestQuote: FunkitCheckoutQuoteResult;
+    stepMessageSetter: (m: string) => void;
+    withdrawalClient?: WithdrawalClient;
+    getDirectExecutionInfo: (checkoutItem: FunkitActiveCheckoutItem | null) => FunkitDirectExecutionInfo;
+    getWithdrawalDirectExecution: () => FunkitDirectExecutionInfo;
+    loginType: LoginType;
+    userId: string;
+    walletAddress: Address | '';
+    udaParams?: UDAParams;
+    logEvent: (event: TrackEventData) => void;
+    refreshCheckoutHistory: () => void;
+    setCheckoutProgress: (checkoutId: string, progress: {
+        step: 1 | 2;
+    }) => void;
+    updateActiveCheckout: (update: Partial<FunkitActiveCheckoutItem>) => void;
+}
+/**
+ * Mutation atom to start a direct execution checkout.
+ * Handles both account balance and other direct execution flows.
+ */
+export declare const startDirectExecutionCheckoutAtom: import("jotai").Atom<import("jotai-tanstack-query").AtomWithMutationResult<`0x${string}`, unknown, StartDirectExecutionCheckoutParams, unknown>>;
+/**
+ * Mutation atom to start a regular (non-direct-execution) checkout.
+ */
+export declare const startRegularCheckoutAtom: import("jotai").Atom<import("jotai-tanstack-query").AtomWithMutationResult<`0x${string}`, unknown, StartRegularCheckoutParams, unknown>>;
+/**
+ * Mutation atom to confirm and initialize a checkout.
+ * Main entry point that coordinates checkout confirmation.
+ */
+export declare const confirmCheckoutAtom: import("jotai").Atom<import("jotai-tanstack-query").AtomWithMutationResult<`0x${string}`, unknown, ConfirmCheckoutParams, unknown>>;

package/dist/atoms/activeWithdrawal.d.ts

@@ -0,0 +1,21 @@
+import type { FunkitActiveWithdrawalItem, UseFunkitCheckoutPropsWithFullConfig } from '../providers/FunkitCheckoutContext';
+/**
+ * Base atom holding the active withdrawal state.
+ */
+export declare const withdrawalStateAtom: import("jotai").PrimitiveAtom<FunkitActiveWithdrawalItem | null> & {
+    init: FunkitActiveWithdrawalItem | null;
+};
+/**
+ * Write-only atom to set the withdrawal state.
+ */
+export declare const setWithdrawalStateAtom: import("jotai").WritableAtom<null, [value: FunkitActiveWithdrawalItem | null], void> & {
+    init: null;
+};
+/**
+ * Creates a new withdrawal object in the frontend. Not yet initialized in backend.
+ * Also creates a corresponding checkout item for the withdrawal flow.
+ * @returns The new withdrawalId
+ */
+export declare const initNewWithdrawalAtom: import("jotai").WritableAtom<null, [props: UseFunkitCheckoutPropsWithFullConfig, checkoutConfig: UseFunkitCheckoutPropsWithFullConfig], string> & {
+    init: null;
+};

package/dist/atoms/bridgeProviders/acrossAdapter.d.ts

@@ -0,0 +1,109 @@
+import { type AcrossClient } from '@across-protocol/app-sdk';
+import { type Getter } from 'jotai';
+import type { Address, Hex } from 'viem';
+import type { BridgeExecutionParams, BridgeProviderAdapter, BridgeQuoteRequestParams, BridgeQuoteResult, SelectedRouteInfo } from './types';
+/**
+ * Across quote metadata structure.
+ * Contains provider-specific data from Across SDK.
+ */
+export interface AcrossQuoteMetadata {
+    /** The execution chain ID where the deposit transaction occurs */
+    executionChainId?: number;
+    /** Across swap quote from the SDK */
+    acrossSwapQuote?: AcrossSwapQuote;
+}
+/**
+ * Across swap quote data from the SDK.
+ */
+export interface AcrossSwapQuote {
+    /** Swap transaction details */
+    swapTx?: {
+        to: Address;
+        value?: string;
+        data: Hex;
+        chainId: number;
+    };
+    /** Estimated fill time in seconds */
+    expectedFillTime?: number;
+    /** Input amount */
+    inputAmount?: string;
+    /** Output amount */
+    expectedOutputAmount?: string;
+    /** Approval transactions if needed */
+    approvalTxns?: Array<{
+        to: string;
+        data: string;
+        chainId: number;
+    }>;
+}
+/**
+ * Extended quote result with Across-specific metadata.
+ */
+export interface AcrossQuote extends BridgeQuoteResult {
+    metadata?: {
+        acrossSwapQuote?: AcrossSwapQuote;
+    };
+}
+/**
+ * Atom holding the Across client instance.
+ * Lazily created when first accessed.
+ */
+export declare const acrossClientAtom: import("jotai").Atom<AcrossClient | null>;
+/**
+ * Mutation atom for getting an Across quote using the SDK.
+ *
+ * @example
+ * ```ts
+ * const { mutateAsync: getQuote } = useAtomValue(acrossGetQuoteAtom)
+ * const quote = await getQuote(params)
+ * ```
+ */
+export declare const acrossGetQuoteAtom: import("jotai").Atom<import("jotai-tanstack-query").AtomWithMutationResult<BridgeQuoteResult | null, unknown, BridgeQuoteRequestParams, unknown>>;
+/**
+ * Mutation atom for executing an Across quote using the SDK.
+ *
+ * @example
+ * ```ts
+ * const { mutateAsync: execute } = useAtomValue(acrossExecuteAtom)
+ * const txHash = await execute(params)
+ * ```
+ */
+export declare const acrossExecuteAtom: import("jotai").Atom<import("jotai-tanstack-query").AtomWithMutationResult<`0x${string}` | null, unknown, BridgeExecutionParams, unknown>>;
+/**
+ * Derived atom for getting the selected route display info.
+ * Reactively updates when quote or config changes.
+ *
+ * @example
+ * ```ts
+ * const selectedRoute = useAtomValue(acrossSelectedRouteAtom)
+ * if (selectedRoute) {
+ *   console.log(selectedRoute.label, selectedRoute.isPassthrough)
+ * }
+ * ```
+ */
+export declare const acrossSelectedRouteAtom: import("jotai").Atom<SelectedRouteInfo | null>;
+/**
+ * Derived atom for estimated time from the latest quote.
+ *
+ * @example
+ * ```ts
+ * const estimatedTime = useAtomValue(acrossEstimatedTimeAtom)
+ * ```
+ */
+export declare const acrossEstimatedTimeAtom: import("jotai").Atom<number | null>;
+/**
+ * Composed Across adapter atom that implements BridgeProviderAdapter.
+ * Combines all individual atoms into a unified interface.
+ *
+ * @example
+ * ```ts
+ * const adapter = useAtomValue(acrossAdapterAtom)
+ * const quote = await adapter.getQuote(params)
+ * ```
+ */
+export declare const acrossAdapterAtom: import("jotai").Atom<BridgeProviderAdapter>;
+/**
+ * @deprecated Use `acrossAdapterAtom` instead.
+ * Creates an Across bridge provider adapter.
+ */
+export declare function createAcrossAdapter(get: Getter): BridgeProviderAdapter;

package/dist/atoms/bridgeProviders/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Bridge Provider Adapters
+ *
+ * This module provides a standardized interface for bridge providers
+ * (Relay, Across, etc.) used in the wallet checkout flow.
+ *
+ * @example
+ * ```ts
+ * import {
+ *   relayAdapterAtom,
+ *   relaySelectedRouteAtom,
+ *   createProviderRegistry,
+ *   type BridgeProviderAdapter,
+ * } from './bridgeProviders'
+ *
+ * // Use the composed adapter
+ * const adapter = useAtomValue(relayAdapterAtom)
+ *
+ * // Or use individual atoms for reactive updates
+ * const selectedRoute = useAtomValue(relaySelectedRouteAtom)
+ * ```
+ */
+export type { BridgeProviderAdapter, BridgeProviderRegistry, BridgeQuoteParams, BridgeQuoteExactInParams, BridgeQuoteExactOutParams, BridgeQuoteRequestParams, BridgeQuoteResult, BridgeExecutionParams, BridgeExecutionResult, ChainAsset, ProviderSelectionCriteria, RouteEligibilityParams, SelectedRouteInfo, } from './types';
+export { createProviderRegistry } from './registry';
+export { relayAdapterAtom, relayGetQuoteAtom, relayExecuteAtom, relaySelectedRouteAtom, relayEstimatedTimeAtom, createRelayAdapter, } from './relayAdapter';

package/dist/atoms/bridgeProviders/registry.d.ts

@@ -0,0 +1,12 @@
+import type { BridgeProviderAdapter, BridgeProviderRegistry } from './types';
+/**
+ * Creates a simple provider registry with default selection logic.
+ *
+ * Selection priority:
+ * 1. Preferred provider (if specified and supports route)
+ * 2. First provider that supports the route
+ *
+ * @param providers - Array of bridge provider adapters
+ * @returns A provider registry
+ */
+export declare function createProviderRegistry(providers: BridgeProviderAdapter[]): BridgeProviderRegistry;

package/dist/atoms/bridgeProviders/relayAdapter.d.ts

@@ -0,0 +1,60 @@
+import { type Getter } from 'jotai';
+import type { BridgeExecutionParams, BridgeProviderAdapter, BridgeQuoteRequestParams, BridgeQuoteResult, SelectedRouteInfo } from './types';
+/**
+ * Mutation atom for getting a Relay quote.
+ *
+ * @example
+ * ```ts
+ * const { mutateAsync: getQuote } = useAtomValue(relayGetQuoteAtom)
+ * const quote = await getQuote(params)
+ * ```
+ */
+export declare const relayGetQuoteAtom: import("jotai").Atom<import("jotai-tanstack-query").AtomWithMutationResult<BridgeQuoteResult | null, unknown, BridgeQuoteRequestParams, unknown>>;
+/**
+ * Mutation atom for executing a Relay quote.
+ *
+ * @example
+ * ```ts
+ * const { mutateAsync: execute } = useAtomValue(relayExecuteAtom)
+ * const txHash = await execute(params)
+ * ```
+ */
+export declare const relayExecuteAtom: import("jotai").Atom<import("jotai-tanstack-query").AtomWithMutationResult<`0x${string}` | null, unknown, BridgeExecutionParams, unknown>>;
+/**
+ * Derived atom for getting the selected route display info.
+ * Reactively updates when quote or config changes.
+ *
+ * @example
+ * ```ts
+ * const selectedRoute = useAtomValue(relaySelectedRouteAtom)
+ * if (selectedRoute) {
+ *   console.log(selectedRoute.label, selectedRoute.isPassthrough)
+ * }
+ * ```
+ */
+export declare const relaySelectedRouteAtom: import("jotai").Atom<SelectedRouteInfo | null>;
+/**
+ * Derived atom for estimated time from the latest quote.
+ *
+ * @example
+ * ```ts
+ * const estimatedTime = useAtomValue(relayEstimatedTimeAtom)
+ * ```
+ */
+export declare const relayEstimatedTimeAtom: import("jotai").Atom<number | null>;
+/**
+ * Composed Relay adapter atom that implements BridgeProviderAdapter.
+ * Combines all individual atoms into a unified interface.
+ *
+ * @example
+ * ```ts
+ * const adapter = useAtomValue(relayAdapterAtom)
+ * const quote = await adapter.getQuote(params)
+ * ```
+ */
+export declare const relayAdapterAtom: import("jotai").Atom<BridgeProviderAdapter>;
+/**
+ * @deprecated Use `relayAdapterAtom` instead.
+ * Creates a Relay bridge provider adapter.
+ */
+export declare function createRelayAdapter(get: Getter): BridgeProviderAdapter;