@daimo/pay 1.6.1 → 1.6.2

package/build/pay/packages/connectkit/src/components/Pages/SelectMethod/styles.d.ts

@@ -0,0 +1,9 @@
+export declare const InfoBox: any;
+export declare const InfoBoxButtons: any;
+export declare const LearnMoreContainer: any;
+export declare const LearnMoreButton: any;
+export declare const ConnectorsContainer: any;
+export declare const ConnectorButton: any;
+export declare const ConnectorRecentlyUsed: any;
+export declare const ConnectorLabel: any;
+export declare const ConnectorIcon: any;

package/build/pay/packages/connectkit/src/components/Pages/SelectToken/index.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+declare const SelectToken: React.FC;
+export default SelectToken;

package/build/pay/packages/connectkit/src/components/Pages/Solana/ConnectSolana/index.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+declare const ConnectSolana: React.FC;
+export default ConnectSolana;

package/build/pay/packages/connectkit/src/components/Pages/Solana/ConnectorSolana/index.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+declare const ConnectSolana: React.FC;
+export declare const LoadingContainer: any;
+export default ConnectSolana;

package/build/pay/packages/connectkit/src/components/Pages/Solana/PayWithSolanaToken/index.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+declare const PayWithSolanaToken: React.FC;
+export default PayWithSolanaToken;

package/build/pay/packages/connectkit/src/components/Pages/Solana/SelectSolanaAmount/index.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+declare const SelectSolanaAmount: React.FC;
+export default SelectSolanaAmount;

package/build/pay/packages/connectkit/src/components/Pages/Solana/SelectSolanaToken/index.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+declare const SelectSolanaToken: React.FC;
+export default SelectSolanaToken;

package/build/pay/packages/connectkit/src/components/Pages/SwitchNetworks/index.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+declare const SwitchNetworks: React.FC;
+export default SwitchNetworks;

package/build/pay/packages/connectkit/src/components/Pages/WaitingDepositAddress/index.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+declare const WaitingDepositAddress: React.FC;
+export default WaitingDepositAddress;

package/build/pay/packages/connectkit/src/components/Pages/WaitingExternal/index.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+declare const WaitingExternal: React.FC;
+export default WaitingExternal;

package/build/pay/packages/connectkit/src/components/Spinners/CircleSpinner/index.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+declare const CircleSpinner: ({ logo, smallLogo, loading, unavailable, countdown, }: {
+    logo?: React.ReactNode;
+    smallLogo?: boolean;
+    loading?: boolean;
+    unavailable?: boolean;
+    countdown?: boolean;
+}) => import("react/jsx-runtime").JSX.Element;
+export default CircleSpinner;

package/build/pay/packages/connectkit/src/components/Spinners/CircleSpinner/styles.d.ts

@@ -0,0 +1,5 @@
+export declare const LogoContainer: any;
+export declare const Logo: any;
+export declare const SpinnerContainer: any;
+export declare const ExpiringSpinner: any;
+export declare const Spinner: any;

package/build/pay/packages/connectkit/src/components/Spinners/ExternalPaymentSpinner/index.d.ts

@@ -0,0 +1,6 @@
+declare const ExternalPaymentSpinner: ({ logoURI, logoShape, showSpinner, }: {
+    logoURI: string;
+    logoShape: "circle" | "squircle";
+    showSpinner?: boolean;
+}) => import("react/jsx-runtime").JSX.Element;
+export default ExternalPaymentSpinner;

package/build/pay/packages/connectkit/src/components/Spinners/SquircleSpinner/index.d.ts

@@ -0,0 +1,5 @@
+declare const SquircleSpinner: ({ logo, loading, }: {
+    logo?: React.ReactNode;
+    loading?: boolean;
+}) => import("react/jsx-runtime").JSX.Element;
+export default SquircleSpinner;

package/build/pay/packages/connectkit/src/components/Spinners/SquircleSpinner/styles.d.ts

@@ -0,0 +1,4 @@
+export declare const LogoContainer: any;
+export declare const Logo: any;
+export declare const SpinnerContainer: any;
+export declare const Spinner: any;

package/build/pay/packages/connectkit/src/components/Spinners/TokenLogoSpinner/index.d.ts

@@ -0,0 +1,6 @@
+import { DaimoPayToken } from "@daimo/pay-common";
+declare const TokenLogoSpinner: ({ token, showSpinner, }: {
+    token: DaimoPayToken;
+    showSpinner?: boolean;
+}) => import("react/jsx-runtime").JSX.Element;
+export default TokenLogoSpinner;

package/build/pay/packages/connectkit/src/components/Spinners/TokenLogoSpinner/styles.d.ts

@@ -0,0 +1 @@
+export declare const ChainLogoContainer: any;

package/build/pay/packages/connectkit/src/components/Spinners/styles.d.ts

@@ -0,0 +1,2 @@
+export declare const LoadingContainer: any;
+export declare const AnimationContainer: any;

package/build/pay/packages/connectkit/src/components/contexts/solana/index.d.ts

@@ -0,0 +1,6 @@
+import { WalletName } from "@solana/wallet-adapter-base";
+export type SolanaWalletName = WalletName<string>;
+export declare const SolanaContextProvider: ({ children, solanaRpcUrl, }: {
+    children: React.ReactNode;
+    solanaRpcUrl?: string;
+}) => import("react/jsx-runtime").JSX.Element;

package/build/pay/packages/connectkit/src/components/contexts/web3/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * This provider is responsible for handling reusable web3 logic across the app.
+ */
+import React from "react";
+import { Address, Chain } from "viem";
+type Web3Context = {
+    connect: {
+        getUri: (id?: string) => string;
+    };
+    dapp: {
+        chains: Chain[];
+    };
+    account?: {
+        chain: Chain;
+        chainIsSupported: boolean;
+        address: Address;
+    };
+};
+declare const Web3Context: React.Context<Web3Context>;
+export declare const Web3ContextProvider: ({ enabled, children, }: {
+    enabled?: boolean;
+    children: React.ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const useWeb3: () => Web3Context;
+export {};

package/build/pay/packages/connectkit/src/constants/defaultTheme.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    mobileWidth: number;
+};
+export default _default;

package/build/pay/packages/connectkit/src/defaultConfig.d.ts

@@ -0,0 +1,22 @@
+import { type CreateConfigParameters } from "@wagmi/core";
+import { CreateConnectorFn } from "wagmi";
+import { CoinbaseWalletParameters } from "wagmi/connectors";
+export declare const getAppName: () => string;
+export declare const getAppIcon: () => string;
+type DefaultConfigProps = {
+    appName: string;
+    appIcon?: string;
+    appDescription?: string;
+    appUrl?: string;
+    /**
+     * WC 2.0 Project ID (get one here: https://cloud.walletconnect.com/sign-in),
+     * it doesn't do much besides tracking. If not provided, use Daimo's
+     * WalletConnect project ID by default. */
+    walletConnectProjectId?: string;
+    coinbaseWalletPreference?: CoinbaseWalletParameters<"4">["preference"];
+    additionalConnectors?: CreateConnectorFn[];
+} & Partial<CreateConfigParameters>;
+export declare const REQUIRED_CHAINS: CreateConfigParameters["chains"];
+/** Daimo Pay recommended config, for use with wagmi's createConfig(). */
+declare const defaultConfig: ({ appName, appIcon, appDescription, appUrl, walletConnectProjectId, coinbaseWalletPreference, additionalConnectors, chains, client, ...props }: DefaultConfigProps) => CreateConfigParameters;
+export default defaultConfig;

package/build/pay/packages/connectkit/src/defaultConnectors.d.ts

@@ -0,0 +1,15 @@
+import { CoinbaseWalletParameters } from "@wagmi/connectors";
+import { CreateConnectorFn } from "wagmi";
+type DefaultConnectorsProps = {
+    app: {
+        name: string;
+        icon?: string;
+        description?: string;
+        url?: string;
+    };
+    walletConnectProjectId: string;
+    coinbaseWalletPreference?: CoinbaseWalletParameters<"4">["preference"];
+    additionalConnectors?: CreateConnectorFn[];
+};
+declare const defaultConnectors: ({ app, walletConnectProjectId, coinbaseWalletPreference, additionalConnectors, }: DefaultConnectorsProps) => CreateConnectorFn[];
+export default defaultConnectors;

package/build/pay/packages/connectkit/src/hooks/connectors/useWalletConnectUri.d.ts

@@ -0,0 +1,7 @@
+type Props = {
+    enabled?: boolean;
+};
+export declare function useWalletConnectUri({ enabled }?: Props): {
+    uri: string | undefined;
+};
+export {};

package/build/pay/packages/connectkit/src/hooks/hookTypes.d.ts

@@ -0,0 +1,9 @@
+import { DaimoPayHydratedOrder, DaimoPayOrder, ExternalPaymentOptionData, ExternalPaymentOptions } from "@daimo/pay-common";
+export type CreateOrHydrateFn = (opts: {
+    order: DaimoPayOrder;
+    refundAddress?: string;
+    externalPaymentOption?: ExternalPaymentOptions;
+}) => Promise<{
+    hydratedOrder: DaimoPayHydratedOrder;
+    externalPaymentOptionData: ExternalPaymentOptionData | null;
+}>;

package/build/pay/packages/connectkit/src/hooks/useChainIsSupported.d.ts

@@ -0,0 +1,2 @@
+/** Determines whether the current wagmi configuration supports a given chain. */
+export declare function useChainIsSupported(chainId?: number): boolean | null;

package/build/pay/packages/connectkit/src/hooks/useChains.d.ts

@@ -0,0 +1,3 @@
+import { Chain } from "viem";
+/** Returns currently configured wagmi chains. */
+export declare function useChains(): Chain[];

package/build/pay/packages/connectkit/src/hooks/useConnect.d.ts

@@ -0,0 +1,110 @@
+/**
+ * This is a wrapper around wagmi's useConnect hook that adds some
+ * additional functionality.
+ */
+import { Connector, CreateConnectorFn, type UseConnectParameters } from "wagmi";
+export declare function useConnect({ ...props }?: UseConnectParameters): {
+    status: "idle";
+    data: undefined;
+    reset: () => void;
+    error: null;
+    variables: undefined;
+    isError: false;
+    isIdle: true;
+    isPending: false;
+    isSuccess: false;
+    context: unknown;
+    failureCount: number;
+    failureReason: import("@wagmi/core").ConnectErrorType | null;
+    isPaused: boolean;
+    submittedAt: number;
+    connect: ({ connector, chainId, mutation, }: {
+        connector: CreateConnectorFn | Connector;
+        chainId?: number;
+        mutation?: UseConnectParameters["mutation"];
+    }) => void;
+    connectAsync: ({ connector, chainId, mutation, }: {
+        connector: CreateConnectorFn | Connector;
+        chainId?: number;
+        mutation?: UseConnectParameters["mutation"];
+    }) => Promise<import("wagmi/query").ConnectData<import("wagmi").Config>>;
+    connectors: readonly Connector<CreateConnectorFn>[];
+} | {
+    status: "pending";
+    data: undefined;
+    reset: () => void;
+    error: null;
+    variables: import("wagmi/query").ConnectVariables<import("wagmi").Config, Connector<CreateConnectorFn>>;
+    isError: false;
+    isIdle: false;
+    isPending: true;
+    isSuccess: false;
+    context: unknown;
+    failureCount: number;
+    failureReason: import("@wagmi/core").ConnectErrorType | null;
+    isPaused: boolean;
+    submittedAt: number;
+    connect: ({ connector, chainId, mutation, }: {
+        connector: CreateConnectorFn | Connector;
+        chainId?: number;
+        mutation?: UseConnectParameters["mutation"];
+    }) => void;
+    connectAsync: ({ connector, chainId, mutation, }: {
+        connector: CreateConnectorFn | Connector;
+        chainId?: number;
+        mutation?: UseConnectParameters["mutation"];
+    }) => Promise<import("wagmi/query").ConnectData<import("wagmi").Config>>;
+    connectors: readonly Connector<CreateConnectorFn>[];
+} | {
+    status: "error";
+    data: undefined;
+    reset: () => void;
+    error: import("@wagmi/core").ConnectErrorType;
+    variables: import("wagmi/query").ConnectVariables<import("wagmi").Config, Connector<CreateConnectorFn>>;
+    isError: true;
+    isIdle: false;
+    isPending: false;
+    isSuccess: false;
+    context: unknown;
+    failureCount: number;
+    failureReason: import("@wagmi/core").ConnectErrorType | null;
+    isPaused: boolean;
+    submittedAt: number;
+    connect: ({ connector, chainId, mutation, }: {
+        connector: CreateConnectorFn | Connector;
+        chainId?: number;
+        mutation?: UseConnectParameters["mutation"];
+    }) => void;
+    connectAsync: ({ connector, chainId, mutation, }: {
+        connector: CreateConnectorFn | Connector;
+        chainId?: number;
+        mutation?: UseConnectParameters["mutation"];
+    }) => Promise<import("wagmi/query").ConnectData<import("wagmi").Config>>;
+    connectors: readonly Connector<CreateConnectorFn>[];
+} | {
+    status: "success";
+    data: import("wagmi/query").ConnectData<import("wagmi").Config>;
+    reset: () => void;
+    error: null;
+    variables: import("wagmi/query").ConnectVariables<import("wagmi").Config, Connector<CreateConnectorFn>>;
+    isError: false;
+    isIdle: false;
+    isPending: false;
+    isSuccess: true;
+    context: unknown;
+    failureCount: number;
+    failureReason: import("@wagmi/core").ConnectErrorType | null;
+    isPaused: boolean;
+    submittedAt: number;
+    connect: ({ connector, chainId, mutation, }: {
+        connector: CreateConnectorFn | Connector;
+        chainId?: number;
+        mutation?: UseConnectParameters["mutation"];
+    }) => void;
+    connectAsync: ({ connector, chainId, mutation, }: {
+        connector: CreateConnectorFn | Connector;
+        chainId?: number;
+        mutation?: UseConnectParameters["mutation"];
+    }) => Promise<import("wagmi/query").ConnectData<import("wagmi").Config>>;
+    connectors: readonly Connector<CreateConnectorFn>[];
+};

package/build/pay/packages/connectkit/src/hooks/useConnectCallback.d.ts

@@ -0,0 +1,8 @@
+export type useConnectCallbackProps = {
+    onConnect?: ({ address, connectorId, }: {
+        address?: string;
+        connectorId?: string;
+    }) => void;
+    onDisconnect?: () => void;
+};
+export declare const useConnectCallback: ({ onConnect, onDisconnect, }: useConnectCallbackProps) => void;

package/build/pay/packages/connectkit/src/hooks/useConnectors.d.ts

@@ -0,0 +1,7 @@
+import { type Connector } from "wagmi";
+export declare function useConnectors(): readonly Connector<import("wagmi").CreateConnectorFn>[];
+export declare function useConnector(id: string, uuid?: string): Connector;
+export declare function useInjectedConnector(uuid?: string): Connector;
+export declare function useWalletConnectConnector(): Connector;
+export declare function useCoinbaseWalletConnector(): Connector;
+export declare function useMetaMaskConnector(): Connector;

package/build/pay/packages/connectkit/src/hooks/useDaimoPayStatus.d.ts

@@ -0,0 +1,15 @@
+import { DaimoPayIntentStatus } from "@daimo/pay-common";
+/** Returns the current payment, or undefined if there is none.
+ *
+ * Status values:
+ * - `payment_unpaid` - the user has not paid yet
+ * - `payment_started` - the user has paid & payment is in progress. This status
+ *    typically lasts a few seconds.
+ * - `payment_completed` - the final call or transfer succeeded
+ * - `payment_bounced` - the final call or transfer reverted. Funds were sent
+ *    to the payment's configured refund address on the destination chain.
+ */
+export declare function useDaimoPayStatus(): {
+    paymentId: string;
+    status: DaimoPayIntentStatus;
+} | undefined;

package/build/pay/packages/connectkit/src/hooks/useDepositAddressOptions.d.ts

@@ -0,0 +1,10 @@
+import { DaimoPayOrderMode, DepositAddressPaymentOptionMetadata } from "@daimo/pay-common";
+import { TrpcClient } from "../utils/trpc";
+export declare function useDepositAddressOptions({ trpc, usdRequired, mode, }: {
+    trpc: TrpcClient;
+    usdRequired: number | undefined;
+    mode: DaimoPayOrderMode | undefined;
+}): {
+    options: DepositAddressPaymentOptionMetadata[];
+    loading: boolean;
+};

package/build/pay/packages/connectkit/src/hooks/useEnsFallbackConfig.d.ts

@@ -0,0 +1,2 @@
+import type { Config } from "@wagmi/core";
+export declare function useEnsFallbackConfig(): Config | undefined;

package/build/pay/packages/connectkit/src/hooks/useExternalPaymentOptions.d.ts

@@ -0,0 +1,12 @@
+import { DaimoPayOrderMode, ExternalPaymentOptionMetadata, PlatformType } from "@daimo/pay-common";
+import { TrpcClient } from "../utils/trpc";
+export declare function useExternalPaymentOptions({ trpc, filterIds, platform, usdRequired, mode, }: {
+    trpc: TrpcClient;
+    filterIds: string[] | undefined;
+    platform: PlatformType | undefined;
+    usdRequired: number | undefined;
+    mode: DaimoPayOrderMode | undefined;
+}): {
+    options: ExternalPaymentOptionMetadata[];
+    loading: boolean;
+};

package/build/pay/packages/connectkit/src/hooks/useFitText.d.ts

@@ -0,0 +1,14 @@
+export type TLogLevel = "debug" | "info" | "warn" | "error" | "none";
+export type TOptions = {
+    logLevel?: TLogLevel;
+    maxFontSize?: number;
+    minFontSize?: number;
+    onFinish?: (fontSize: number) => void;
+    onStart?: () => void;
+    resolution?: number;
+};
+declare const useFitText: ({ logLevel: logLevelOption, maxFontSize, minFontSize, onFinish, onStart, resolution, }?: TOptions) => {
+    fontSize: number;
+    ref: import("react").RefObject<HTMLDivElement>;
+};
+export default useFitText;

package/build/pay/packages/connectkit/src/hooks/useFocusTrap.d.ts

@@ -0,0 +1 @@
+export default function FocusTrap(props: any): import("react/jsx-runtime").JSX.Element;

package/build/pay/packages/connectkit/src/hooks/useGoogleFont.d.ts

@@ -0,0 +1,3 @@
+import { Theme } from "../types";
+export declare function useGoogleFont(font: string): void;
+export declare function useThemeFont(theme: Theme): void;

package/build/pay/packages/connectkit/src/hooks/useIsMobile.d.ts

@@ -0,0 +1 @@
+export default function useIsMobile(): boolean;

package/build/pay/packages/connectkit/src/hooks/useIsMounted.d.ts

@@ -0,0 +1,3 @@
+/** Utility. Returns false on first render, true after.
+ * Useful for apps with SSR, for example. */
+export default function useIsMounted(): boolean;

package/build/pay/packages/connectkit/src/hooks/useLastConnector.d.ts

@@ -0,0 +1,4 @@
+export declare const useLastConnector: () => {
+    lastConnectorId: string | null;
+    updateLastConnectorId: (id: string) => void;
+};

package/build/pay/packages/connectkit/src/hooks/useLocalStorage.d.ts

@@ -0,0 +1,7 @@
+export declare const useLocalStorage: (storageKey: string) => {
+    data: any;
+    add: (item: any) => void;
+    remove: (item: any) => void;
+    update: (items: any) => void;
+    clear: () => void;
+};

package/build/pay/packages/connectkit/src/hooks/useLocales.d.ts

@@ -0,0 +1 @@
+export default function useLocales(replacements?: any): any;

package/build/pay/packages/connectkit/src/hooks/useLockBodyScroll.d.ts

@@ -0,0 +1 @@
+export default function useLockBodyScroll(initialLocked: boolean): (boolean | import("react").Dispatch<import("react").SetStateAction<boolean>>)[];

package/build/pay/packages/connectkit/src/hooks/useModal.d.ts

@@ -0,0 +1,8 @@
+import { useConnectCallbackProps } from "./useConnectCallback";
+type UseModalProps = {} & useConnectCallbackProps;
+/** Opens and closes the payment modal. */
+export declare const useModal: ({ onConnect, onDisconnect }?: UseModalProps) => {
+    open: boolean;
+    setOpen: (show: boolean) => void;
+};
+export {};

package/build/pay/packages/connectkit/src/hooks/useOrderUsdLimits.d.ts

@@ -0,0 +1,7 @@
+import { TrpcClient } from "../utils/trpc";
+export declare function useOrderUsdLimits({ trpc }: {
+    trpc: TrpcClient;
+}): {
+    limits: Record<string, number>;
+    loading: boolean;
+};

package/build/pay/packages/connectkit/src/hooks/usePayWithSolanaToken.d.ts

@@ -0,0 +1,12 @@
+import { DaimoPayOrder, SolanaPublicKey } from "@daimo/pay-common";
+import { TrpcClient } from "../utils/trpc";
+import { CreateOrHydrateFn } from "./hookTypes";
+export declare function usePayWithSolanaToken({ trpc, daimoPayOrder, setDaimoPayOrder, createOrHydrate, log, }: {
+    trpc: TrpcClient;
+    daimoPayOrder: DaimoPayOrder | undefined;
+    setDaimoPayOrder: (order: DaimoPayOrder) => void;
+    createOrHydrate: CreateOrHydrateFn;
+    log: (message: string) => void;
+}): {
+    payWithSolanaToken: (inputToken: SolanaPublicKey) => Promise<string>;
+};

package/build/pay/packages/connectkit/src/hooks/usePayWithToken.d.ts

@@ -0,0 +1,14 @@
+import { DaimoPayOrder, WalletPaymentOption } from "@daimo/pay-common";
+import { Address } from "viem";
+import { TrpcClient } from "../utils/trpc";
+import { CreateOrHydrateFn } from "./hookTypes";
+export declare function usePayWithToken({ trpc, senderAddr, daimoPayOrder, setDaimoPayOrder, createOrHydrate, log, }: {
+    trpc: TrpcClient;
+    createOrHydrate: CreateOrHydrateFn;
+    senderAddr: Address | undefined;
+    daimoPayOrder: DaimoPayOrder | undefined;
+    setDaimoPayOrder: (order: DaimoPayOrder) => void;
+    log: (message: string) => void;
+}): {
+    payWithToken: (walletOption: WalletPaymentOption) => Promise<void>;
+};

package/build/pay/packages/connectkit/src/hooks/usePaymentState.d.ts

@@ -0,0 +1,90 @@
+import { DaimoPayOrder, DaimoPayUserMetadata, DepositAddressPaymentOptionData, DepositAddressPaymentOptionMetadata, DepositAddressPaymentOptions, ExternalPaymentOptionMetadata, ExternalPaymentOptions, SolanaPublicKey, WalletPaymentOption } from "@daimo/pay-common";
+import { Address, Hex } from "viem";
+import { DaimoPayModalOptions, PaymentOption } from "../types";
+import { TrpcClient } from "../utils/trpc";
+import { useDepositAddressOptions } from "./useDepositAddressOptions";
+import { useExternalPaymentOptions } from "./useExternalPaymentOptions";
+import { useSolanaPaymentOptions } from "./useSolanaPaymentOptions";
+import { useWalletPaymentOptions } from "./useWalletPaymentOptions";
+/** Wallet payment details, sent to processSourcePayment after submitting tx. */
+export type SourcePayment = Parameters<TrpcClient["processSourcePayment"]["mutate"]>[0];
+/** Payment parameters. The payment is created only after user taps pay. */
+export interface PayParams {
+    /** App ID, for authentication. */
+    appId: string;
+    /** Destination chain ID. */
+    toChain: number;
+    /** The destination token to send. */
+    toToken: Address;
+    /**
+     * The amount of the token to send.
+     * If not provided, the user will be prompted to enter an amount.
+     */
+    toUnits?: string;
+    /** The final address to transfer to or contract to call. */
+    toAddress: Address;
+    /** Calldata for final call, or empty data for transfer. */
+    toCallData?: Hex;
+    /** The intent verb, such as Pay, Deposit, or Purchase. Default: Pay */
+    intent?: string;
+    /** Payment options. By default, all are enabled. */
+    paymentOptions?: PaymentOption[];
+    /** Preferred chain IDs. */
+    preferredChains?: number[];
+    /** Preferred tokens. These appear first in the token list. */
+    preferredTokens?: {
+        chain: number;
+        address: Address;
+    }[];
+    /** Only allow payments on these EVM chains. */
+    evmChains?: number[];
+    /** External ID. E.g. a correlation ID. */
+    externalId?: string;
+    /** Developer metadata. E.g. correlation ID. */
+    metadata?: DaimoPayUserMetadata;
+}
+/** Creates (or loads) a payment and manages the corresponding modal. */
+export interface PaymentState {
+    setPayId: (id: string | undefined) => void;
+    setPayParams: (payParams: PayParams | undefined) => void;
+    payParams: PayParams | undefined;
+    generatePreviewOrder: (payParams: PayParams) => void;
+    daimoPayOrder: DaimoPayOrder | undefined;
+    isDepositFlow: boolean;
+    modalOptions: DaimoPayModalOptions;
+    setModalOptions: (modalOptions: DaimoPayModalOptions) => void;
+    paymentWaitingMessage: string | undefined;
+    externalPaymentOptions: ReturnType<typeof useExternalPaymentOptions>;
+    walletPaymentOptions: ReturnType<typeof useWalletPaymentOptions>;
+    solanaPaymentOptions: ReturnType<typeof useSolanaPaymentOptions>;
+    depositAddressOptions: ReturnType<typeof useDepositAddressOptions>;
+    selectedExternalOption: ExternalPaymentOptionMetadata | undefined;
+    selectedTokenOption: WalletPaymentOption | undefined;
+    selectedSolanaTokenOption: WalletPaymentOption | undefined;
+    selectedDepositAddressOption: DepositAddressPaymentOptionMetadata | undefined;
+    getOrderUsdLimit: () => number;
+    setPaymentWaitingMessage: (message: string | undefined) => void;
+    setSelectedExternalOption: (option: ExternalPaymentOptionMetadata | undefined) => void;
+    setSelectedTokenOption: (option: WalletPaymentOption | undefined) => void;
+    setSelectedSolanaTokenOption: (option: WalletPaymentOption | undefined) => void;
+    setSelectedDepositAddressOption: (option: DepositAddressPaymentOptionMetadata | undefined) => void;
+    setChosenUsd: (usd: number) => void;
+    payWithToken: (walletOption: WalletPaymentOption) => Promise<void>;
+    payWithExternal: (option: ExternalPaymentOptions) => Promise<string>;
+    payWithDepositAddress: (option: DepositAddressPaymentOptions) => Promise<DepositAddressPaymentOptionData | null>;
+    payWithSolanaToken: (inputToken: SolanaPublicKey) => Promise<string | undefined>;
+    refreshOrder: () => Promise<void>;
+    onSuccess: (args: {
+        txHash: string;
+        txURL?: string;
+    }) => void;
+    senderEnsName: string | undefined;
+}
+export declare function usePaymentState({ trpc, daimoPayOrder, setDaimoPayOrder, setOpen, log, redirectReturnUrl, }: {
+    trpc: TrpcClient;
+    daimoPayOrder: DaimoPayOrder | undefined;
+    setDaimoPayOrder: (o: DaimoPayOrder) => void;
+    setOpen: (showModal: boolean, meta?: Record<string, any>) => void;
+    log: (...args: any[]) => void;
+    redirectReturnUrl?: string;
+}): PaymentState;

package/build/pay/packages/connectkit/src/hooks/usePrevious.d.ts

@@ -0,0 +1 @@
+export default function usePrevious(value: any, initial?: any): any;

package/build/pay/packages/connectkit/src/hooks/useSolanaPaymentOptions.d.ts

@@ -0,0 +1,12 @@
+import { WalletPaymentOption } from "@daimo/pay-common";
+import { TrpcClient } from "../utils/trpc";
+/** Wallet payment options. User picks one. */
+export declare function useSolanaPaymentOptions({ trpc, address, usdRequired, isDepositFlow, }: {
+    trpc: TrpcClient;
+    address: string | undefined;
+    usdRequired: number | undefined;
+    isDepositFlow: boolean;
+}): {
+    options: WalletPaymentOption[] | null;
+    isLoading: boolean;
+};

package/build/pay/packages/connectkit/src/hooks/useWalletConnectModal.d.ts

@@ -0,0 +1,4 @@
+export declare function useWalletConnectModal(): {
+    isOpen: boolean;
+    open: () => Promise<void>;
+};

package/build/pay/packages/connectkit/src/hooks/useWalletPaymentOptions.d.ts

@@ -0,0 +1,20 @@
+import { WalletPaymentOption } from "@daimo/pay-common";
+import { TrpcClient } from "../utils/trpc";
+/** Wallet payment options. User picks one. */
+export declare function useWalletPaymentOptions({ trpc, address, usdRequired, destChainId, preferredChains, preferredTokens, evmChains, isDepositFlow, log, }: {
+    trpc: TrpcClient;
+    address: string | undefined;
+    usdRequired: number | undefined;
+    destChainId: number | undefined;
+    preferredChains: number[] | undefined;
+    preferredTokens: {
+        chain: number;
+        address: string;
+    }[] | undefined;
+    evmChains: number[] | undefined;
+    isDepositFlow: boolean;
+    log: (msg: string) => void;
+}): {
+    options: WalletPaymentOption[] | null;
+    isLoading: boolean;
+};