@daimo/pay 0.3.17 → 0.3.18

package/README.md

@@ -53,7 +53,7 @@ Any changes will be reflected on the Pay button in the example app.
 
 ## Support
 
-Message us on [Telegram](https://t.me/daimo_support) if you're interested in integrating Daimo Pay.
+[Contact us](mailto:support@daimo.com) if you'd like to integrate Daimo Pay.
 
 ## License
 

package/build/index.d.ts

@@ -0,0 +1,419 @@
+import { CreateConfigParameters } from '@wagmi/core';
+import { CoinbaseWalletParameters } from 'wagmi/connectors';
+import React$1, { ReactNode } from 'react';
+import { CreateConnectorFn } from 'wagmi';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as _daimo_common from '@daimo/common';
+import { DepositAddressPaymentOptionMetadata, PlatformType, ExternalPaymentOptionMetadata, DaimoPayOrder, DaimoPayTokenAmount, ExternalPaymentOptions, DepositAddressPaymentOptions, DepositAddressPaymentOptionData, SolanaPublicKey } from '@daimo/common';
+import { AppRouter } from '@daimo/pay-api';
+import { CreateTRPCClient } from '@trpc/client';
+import * as abitype from 'abitype';
+import { WalletName } from '@solana/wallet-adapter-base';
+import { Chain as Chain$1 } from 'viem';
+
+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"];
+} & Partial<CreateConfigParameters>;
+/** A utility for use with wagmi's createConfig(). */
+declare const defaultConfig: ({ appName, appIcon, appDescription, appUrl, walletConnectProjectId, coinbaseWalletPreference, chains, client, ...props }: DefaultConfigProps) => CreateConfigParameters;
+
+type Hash$1 = `0x${string}`;
+type CustomAvatarProps = {
+    address?: Hash$1 | undefined;
+    ensName?: string | undefined;
+    ensImage?: string;
+    size: number;
+    radius: number;
+};
+declare const Avatar: React$1.FC<{
+    address?: Hash$1 | undefined;
+    name?: string | undefined;
+    size?: number;
+    radius?: number;
+}>;
+
+type Languages$1 = "ar-AE" | "en-US" | "ee-EE" | "es-ES" | "fa-IR" | "fr-FR" | "ja-JP" | "pt-BR" | "zh-CN" | "ca-AD" | "ru-RU" | "zh-CN" | "tr-TR" | "vi-VN";
+
+type Languages = Languages$1;
+type Theme = "auto" | "web95" | "retro" | "soft" | "midnight" | "minimal" | "rounded" | "nouns";
+type Mode = "light" | "dark" | "auto";
+type CustomTheme = any;
+type All = {
+    theme?: Theme;
+    mode?: Mode;
+    customTheme?: CustomTheme;
+    lang?: Languages;
+};
+
+/** Global options, across all pay buttons and payments. */
+type DaimoPayContextOptions = {
+    language?: Languages;
+    hideBalance?: boolean;
+    hideTooltips?: boolean;
+    hideQuestionMarkCTA?: boolean;
+    hideNoWalletCTA?: boolean;
+    hideRecentBadge?: boolean;
+    walletConnectCTA?: "link" | "modal" | "both";
+    /** Avoids layout shift when the DaimoPay modal is open by adding padding to the body */
+    avoidLayoutShift?: boolean;
+    /** Automatically embeds Google Font of the current theme. Does not work with custom themes */
+    embedGoogleFonts?: boolean;
+    truncateLongENSAddress?: boolean;
+    walletConnectName?: string;
+    reducedMotion?: boolean;
+    disclaimer?: ReactNode | string;
+    bufferPolyfill?: boolean;
+    customAvatar?: React.FC<CustomAvatarProps>;
+    initialChainId?: number;
+    enforceSupportedChains?: boolean;
+    ethereumOnboardingUrl?: string;
+    walletOnboardingUrl?: string;
+    /** Blur the background when the modal is open */
+    overlayBlur?: number;
+};
+/** Modal UI options, set on the pay button triggering that modal. */
+type DaimoPayModalOptions = {
+    closeOnSuccess?: boolean;
+};
+/** Payment status. See webhooks and React useDaimoPayStatus() hook. */
+type PaymentStatus = "payment_pending" | "payment_started" | "payment_completed" | "payment_bounced";
+
+type types_d_All = All;
+type types_d_CustomAvatarProps = CustomAvatarProps;
+type types_d_CustomTheme = CustomTheme;
+type types_d_DaimoPayContextOptions = DaimoPayContextOptions;
+type types_d_DaimoPayModalOptions = DaimoPayModalOptions;
+type types_d_Languages = Languages;
+type types_d_Mode = Mode;
+type types_d_PaymentStatus = PaymentStatus;
+type types_d_Theme = Theme;
+declare namespace types_d {
+  export type { types_d_All as All, types_d_CustomAvatarProps as CustomAvatarProps, types_d_CustomTheme as CustomTheme, types_d_DaimoPayContextOptions as DaimoPayContextOptions, types_d_DaimoPayModalOptions as DaimoPayModalOptions, types_d_Languages as Languages, types_d_Mode as Mode, types_d_PaymentStatus as PaymentStatus, types_d_Theme as Theme };
+}
+
+declare const wallets: {
+    [key: WalletIds]: CreateConnectorFn;
+};
+
+type useConnectCallbackProps = {
+    onConnect?: ({ address, connectorId, }: {
+        address?: string;
+        connectorId?: string;
+    }) => void;
+    onDisconnect?: () => void;
+};
+
+type TrpcClient = CreateTRPCClient<AppRouter>;
+
+declare function useDepositAddressOptions({ trpc, usdRequired, }: {
+    trpc: TrpcClient;
+    usdRequired: number;
+}): {
+    options: DepositAddressPaymentOptionMetadata[];
+    loading: boolean;
+};
+
+declare function useExternalPaymentOptions({ trpc, filterIds, usdRequired, platform, }: {
+    trpc: TrpcClient;
+    filterIds: string[] | undefined;
+    usdRequired: number | undefined;
+    platform: PlatformType | undefined;
+}): {
+    options: ExternalPaymentOptionMetadata[];
+    loading: boolean;
+};
+
+type SolanaPaymentOption = Awaited<ReturnType<TrpcClient["getSolanaPaymentOptions"]["query"]>>[0];
+declare function useSolanaPaymentOptions({ trpc, address, usdRequired, }: {
+    trpc: TrpcClient;
+    address: string | undefined;
+    usdRequired: number | undefined;
+}): {
+    options: {
+        required: {
+            amount: _daimo_common.BigIntStr;
+            token: {
+                symbol: string;
+                chainId: number;
+                token: abitype.Address | _daimo_common.SolanaPublicKey;
+                usd: number;
+                displayDecimals: number;
+                decimals: number;
+                name?: string;
+                fiatSymbol?: string;
+                logoURI?: string;
+            };
+            usd: number;
+        };
+        balance: {
+            amount: _daimo_common.BigIntStr;
+            token: {
+                symbol: string;
+                chainId: number;
+                token: abitype.Address | _daimo_common.SolanaPublicKey;
+                usd: number;
+                displayDecimals: number;
+                decimals: number;
+                name?: string;
+                fiatSymbol?: string;
+                logoURI?: string;
+            };
+            usd: number;
+        };
+    }[] | null;
+    isLoading: boolean;
+};
+
+/** Wallet payment options. User picks one. */
+type WalletPaymentOption = Awaited<ReturnType<TrpcClient["getWalletPaymentOptions"]["query"]>>[0];
+declare function useWalletPaymentOptions({ trpc, address, usdRequired, destChainId, }: {
+    trpc: TrpcClient;
+    address: string | undefined;
+    usdRequired: number | undefined;
+    destChainId: number | undefined;
+}): {
+    options: {
+        required: {
+            amount: _daimo_common.BigIntStr;
+            token: {
+                symbol: string;
+                chainId: number;
+                token: abitype.Address | _daimo_common.SolanaPublicKey;
+                usd: number;
+                displayDecimals: number;
+                decimals: number;
+                name?: string;
+                fiatSymbol?: string;
+                logoURI?: string;
+            };
+            usd: number;
+        };
+        balance: {
+            amount: _daimo_common.BigIntStr;
+            token: {
+                symbol: string;
+                chainId: number;
+                token: abitype.Address | _daimo_common.SolanaPublicKey;
+                usd: number;
+                displayDecimals: number;
+                decimals: number;
+                name?: string;
+                fiatSymbol?: string;
+                logoURI?: string;
+            };
+            usd: number;
+        };
+    }[] | null;
+    isLoading: boolean;
+};
+
+/** Loads a DaimoPayOrder + manages the corresponding modal. */
+interface PaymentInfo {
+    setPayId: (id: string | null) => Promise<void>;
+    daimoPayOrder: DaimoPayOrder | undefined;
+    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: SolanaPaymentOption | undefined;
+    selectedDepositAddressOption: DepositAddressPaymentOptionMetadata | undefined;
+    setSelectedDepositAddressOption: (option: DepositAddressPaymentOptionMetadata | undefined) => void;
+    setSelectedExternalOption: (option: ExternalPaymentOptionMetadata | undefined) => void;
+    setSelectedTokenOption: (option: WalletPaymentOption | undefined) => void;
+    setSelectedSolanaTokenOption: (option: SolanaPaymentOption | undefined) => void;
+    setChosenUsd: (amount: number) => void;
+    payWithToken: (tokenAmount: DaimoPayTokenAmount) => 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;
+}
+
+type SolanaWalletName = WalletName<string>;
+
+declare enum ROUTES {
+    SELECT_METHOD = "daimoPaySelectMethod",
+    SELECT_TOKEN = "daimoPaySelectToken",
+    WAITING_OTHER = "daimoPayWaitingOther",
+    SELECT_DEPOSIT_ADDRESS_CHAIN = "daimoPaySelectDepositAddressChain",
+    WAITING_DEPOSIT_ADDRESS = "daimoPayWaitingDepositAddress",
+    PAY_WITH_TOKEN = "daimoPayPayWithToken",
+    CONFIRMATION = "daimoPayConfirmation",
+    SOLANA_CONNECT = "daimoPaySolanaConnect",
+    SOLANA_CONNECTOR = "daimoPaySolanaConnector",
+    SOLANA_SELECT_TOKEN = "daimoPaySolanaSelectToken",
+    SOLANA_PAY_WITH_TOKEN = "daimoPaySolanaPayWithToken",
+    ONBOARDING = "onboarding",
+    ABOUT = "about",
+    CONNECTORS = "connectors",
+    MOBILECONNECTORS = "mobileConnectors",
+    CONNECT = "connect",
+    DOWNLOAD = "download",
+    SWITCHNETWORKS = "switchNetworks"
+}
+type Connector = {
+    id: string;
+};
+type Error = string | React$1.ReactNode | null;
+type ContextValue = {
+    theme: Theme;
+    setTheme: React$1.Dispatch<React$1.SetStateAction<Theme>>;
+    mode: Mode;
+    setMode: React$1.Dispatch<React$1.SetStateAction<Mode>>;
+    customTheme: CustomTheme | undefined;
+    setCustomTheme: React$1.Dispatch<React$1.SetStateAction<CustomTheme | undefined>>;
+    lang: Languages;
+    setLang: React$1.Dispatch<React$1.SetStateAction<Languages>>;
+    open: boolean;
+    setOpen: React$1.Dispatch<React$1.SetStateAction<boolean>>;
+    route: string;
+    setRoute: React$1.Dispatch<React$1.SetStateAction<ROUTES>>;
+    connector: Connector;
+    setConnector: React$1.Dispatch<React$1.SetStateAction<Connector>>;
+    solanaConnector: SolanaWalletName | undefined;
+    setSolanaConnector: React$1.Dispatch<React$1.SetStateAction<SolanaWalletName | undefined>>;
+    errorMessage: Error;
+    debugMode?: boolean;
+    log: (...props: any) => void;
+    displayError: (message: string | React$1.ReactNode | null, code?: any) => void;
+    resize: number;
+    triggerResize: () => void;
+    /** Global options, across all pay buttons and payments. */
+    options?: DaimoPayContextOptions;
+    /** Loads a payment, then shows the modal to complete payment. */
+    loadAndShowPayment: (payId: string, modalOptions: DaimoPayModalOptions) => Promise<void>;
+    /** Payment status & callbacks. */
+    paymentInfo: PaymentInfo;
+    /** TRPC API client. Internal use only. */
+    trpc: any;
+} & useConnectCallbackProps;
+/** Meant for internal use. This will be non-exported in a future SDK version. */
+declare const Context: React$1.Context<ContextValue | null>;
+type DaimoPayProviderProps = {
+    children?: React$1.ReactNode;
+    theme?: Theme;
+    mode?: Mode;
+    customTheme?: CustomTheme;
+    options?: DaimoPayContextOptions;
+    debugMode?: boolean;
+    /**
+     * Be careful with this endpoint, some endpoints (incl. Alchemy) don't support
+     * `signatureSubscribe` which leads to txes behaving erratically
+     * (ex. successful txes take minutes to confirm instead of seconds)
+     */
+    solanaRpcUrl?: string;
+    /** Custom Pay API, useful for test and staging. */
+    payApiUrl?: string;
+} & useConnectCallbackProps;
+/** Provides context for DaimoPayButton and hooks. Place in app root, layout, or
+ * similar.
+ */
+declare const DaimoPayProvider: (props: DaimoPayProviderProps) => react_jsx_runtime.JSX.Element;
+/** Meant for internal use. This will be non-exported in a future SDK version. */
+declare const usePayContext: () => ContextValue;
+
+type Hash = `0x${string}`;
+type DaimoPayButtonRendererProps = {
+    /** The payment ID, generated via the Daimo Pay API. */
+    payId: string;
+    /** Automatically close the modal after a successful payment. */
+    closeOnSuccess?: boolean;
+    /** Custom renderer */
+    children?: (renderProps: {
+        show?: () => void;
+        hide?: () => void;
+        chain?: Chain$1 & {
+            unsupported?: boolean;
+        };
+        unsupported: boolean;
+        isConnected: boolean;
+        isConnecting: boolean;
+        address?: Hash;
+        truncatedAddress?: string;
+        ensName?: string;
+        payId?: string;
+    }) => React$1.ReactNode;
+};
+type DaimoPayButtonProps = {
+    /** The payment ID, generated via the Daimo Pay API. */
+    payId: string;
+    /** Light mode, dark mode, or auto. */
+    mode?: Mode;
+    /** Named theme. See docs for options. */
+    theme?: Theme;
+    /** Custom theme. See docs for options. */
+    customTheme?: CustomTheme;
+    /** Automatically close the modal after a successful payment. */
+    closeOnSuccess?: boolean;
+    /** Get notified when the user clicks, opening the payment modal. */
+    onClick?: (open: () => void) => void;
+};
+/** A button that shows the Daimo Pay checkout. Replaces the traditional
+ * Connect Wallet » approve » execute sequence with a single action.
+ */
+declare function DaimoPayButton({ payId, theme, mode, customTheme, closeOnSuccess, onClick, }: DaimoPayButtonProps): react_jsx_runtime.JSX.Element | null;
+declare namespace DaimoPayButton {
+    var Custom: React$1.FC<DaimoPayButtonRendererProps>;
+}
+
+type UseModalProps = {} & useConnectCallbackProps;
+declare const useModal: ({ onConnect, onDisconnect }?: UseModalProps) => {
+    open: boolean;
+    setOpen: (show: boolean) => void;
+    openAbout: () => void;
+    openOnboarding: () => void;
+    openSwitchNetworks: () => void;
+};
+
+declare const Chain: React$1.FC<{
+    id?: number;
+    unsupported?: boolean;
+    radius?: number | string;
+    size?: number | string;
+}>;
+
+/** Determines whether the current wagmi configuration supports a given chain. */
+declare function useChainIsSupported(chainId?: number): boolean | null;
+
+/** Returns currently configured wagmi chains. */
+declare function useChains(): Chain$1[];
+
+/** Returns the current payment, or undefined if there is none.
+ *
+ * Status values:
+ * - `payment_pending` - 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.
+ */
+declare function useDaimoPayStatus(): {
+    paymentId: string;
+    status: PaymentStatus;
+} | undefined;
+
+/** Utility. Returns false on first render, true after.
+ * Useful for apps with SSR, for example. */
+declare function useIsMounted(): boolean;
+
+export { Avatar, Chain as ChainIcon, Context, DaimoPayButton, DaimoPayProvider, types_d as Types, defaultConfig as getDefaultConfig, useChainIsSupported, useChains, useDaimoPayStatus, useIsMounted, useModal, usePayContext, wallets };