@daimo/pay 1.0.9 → 1.1.0

package/build/index.d.ts

@@ -1,10 +1,15 @@
 import React$1, { ReactNode } from 'react';
 export { version } from '../package.json';
 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, PaymentStartedEvent, PaymentCompletedEvent, PaymentBouncedEvent } from '@daimo/common';
+import { Address, Hex } from 'viem';
+import { AppRouter } from '@daimo/pay-api';
+import { CreateTRPCClient } from '@trpc/client';
+import * as abitype from 'abitype';
+import { WalletName } from '@solana/wallet-adapter-base';
 import { CreateConfigParameters } from '@wagmi/core';
 import { CoinbaseWalletParameters } from 'wagmi/connectors';
-import { PaymentStartedEvent, PaymentCompletedEvent, PaymentBouncedEvent } from '@daimo/common';
-import { Address, Hex } from 'viem';
 import { CreateConnectorFn } from 'wagmi';
 
 type Hash = `0x${string}`;
@@ -93,6 +98,256 @@ type useConnectCallbackProps = {
     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: {
+            token: {
+                symbol: string;
+                chainId: number;
+                token: abitype.Address | _daimo_common.SolanaPublicKey;
+                usd: number;
+                displayDecimals: number;
+                decimals: number;
+                name?: string;
+                fiatSymbol?: string;
+                logoURI?: string;
+            };
+            amount: _daimo_common.BigIntStr;
+            usd: number;
+        };
+        balance: {
+            token: {
+                symbol: string;
+                chainId: number;
+                token: abitype.Address | _daimo_common.SolanaPublicKey;
+                usd: number;
+                displayDecimals: number;
+                decimals: number;
+                name?: string;
+                fiatSymbol?: string;
+                logoURI?: string;
+            };
+            amount: _daimo_common.BigIntStr;
+            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, preferredChains, preferredTokens, log, }: {
+    trpc: TrpcClient;
+    address: string | undefined;
+    usdRequired: number | undefined;
+    destChainId: number | undefined;
+    preferredChains: number[] | undefined;
+    preferredTokens: {
+        chain: number;
+        address: string;
+    }[] | undefined;
+    log: (msg: string) => void;
+}): {
+    options: {
+        fees: {
+            token: {
+                symbol: string;
+                chainId: number;
+                token: abitype.Address | _daimo_common.SolanaPublicKey;
+                usd: number;
+                displayDecimals: number;
+                decimals: number;
+                name?: string;
+                fiatSymbol?: string;
+                logoURI?: string;
+            };
+            amount: _daimo_common.BigIntStr;
+            usd: number;
+        };
+        required: {
+            token: {
+                symbol: string;
+                chainId: number;
+                token: abitype.Address | _daimo_common.SolanaPublicKey;
+                usd: number;
+                displayDecimals: number;
+                decimals: number;
+                name?: string;
+                fiatSymbol?: string;
+                logoURI?: string;
+            };
+            amount: _daimo_common.BigIntStr;
+            usd: number;
+        };
+        balance: {
+            token: {
+                symbol: string;
+                chainId: number;
+                token: abitype.Address | _daimo_common.SolanaPublicKey;
+                usd: number;
+                displayDecimals: number;
+                decimals: number;
+                name?: string;
+                fiatSymbol?: string;
+                logoURI?: string;
+            };
+            amount: _daimo_common.BigIntStr;
+            usd: number;
+        };
+    }[] | null;
+    isLoading: boolean;
+};
+
+/** Payment parameters. The payment is created only after user taps pay. */
+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. */
+    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;
+    /** Let the user edit the amount to send. */
+    isAmountEditable: boolean;
+    /** 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;
+    }[];
+}
+/** Creates (or loads) a payment and manages the corresponding modal. */
+interface PaymentState {
+    setPayId: (id: string | undefined) => void;
+    setPayParams: (payParams: PayParams | undefined) => void;
+    payParams: PayParams | undefined;
+    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"
+}
+/** Chosen Ethereum wallet, eg MM or Rainbow. Specifies wallet ID. */
+type Connector = {
+    id: string;
+};
+type Error = string | React$1.ReactNode | null;
+/** Daimo Pay internal context. */
+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>>;
+    errorMessage: Error;
+    debugMode?: boolean;
+    log: (...props: any) => void;
+    displayError: (message: string | React$1.ReactNode | null, code?: any) => void;
+    resize: number;
+    triggerResize: () => void;
+    /** Chosen Solana wallet, eg Phantom.*/
+    solanaConnector: SolanaWalletName | undefined;
+    setSolanaConnector: React$1.Dispatch<React$1.SetStateAction<SolanaWalletName | undefined>>;
+    /** Global options, across all pay buttons and payments. */
+    options?: DaimoPayContextOptions;
+    /** Loads a payment, then shows the modal to complete payment. */
+    showPayment: (modalOptions: DaimoPayModalOptions) => Promise<void>;
+    /** Payment status & callbacks. */
+    paymentState: PaymentState;
+    /** 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;
@@ -113,6 +368,8 @@ type DaimoPayProviderProps = {
  * Provides context for DaimoPayButton and hooks. Place in app root or layout.
  */
 declare const DaimoPayProvider: (props: DaimoPayProviderProps) => react_jsx_runtime.JSX.Element;
+/** Daimo Pay internal context. */
+declare const usePayContext: () => ContextValue;
 
 type DefaultConfigProps = {
     appName: string;
@@ -262,4 +519,4 @@ declare const daimoPayVersion: string;
 /** Generates a globally-unique payId. */
 declare function generatePayId(): string;
 
-export { Avatar, Chain as ChainIcon, DaimoPayButton, DaimoPayProvider, types_d as Types, daimoPayVersion, generatePayId, defaultConfig as getDefaultConfig, useModal as useDaimoPayModal, useDaimoPayStatus, wallets };
+export { Avatar, Chain as ChainIcon, DaimoPayButton, Context as DaimoPayContext, DaimoPayProvider, types_d as Types, daimoPayVersion, generatePayId, defaultConfig as getDefaultConfig, useModal as useDaimoPayModal, useDaimoPayStatus, usePayContext, wallets };

package/build/package.json.js

@@ -1,5 +1,5 @@
 var name = "@daimo/pay";
-var version = "1.0.9";
+var version = "1.1.0";
 var author = "Daimo";
 var homepage = "https://pay.daimo.com";
 var license = "BSD-2-Clause license";

package/build/src/index.js

@@ -1,5 +1,5 @@
 export { version } from '../package.json.js';
-export { DaimoPayProvider } from './components/DaimoPay.js';
+export { Context as DaimoPayContext, DaimoPayProvider, usePayContext } from './components/DaimoPay.js';
 export { default as getDefaultConfig } from './defaultConfig.js';
 export { DaimoPayButton } from './components/DaimoPayButton/index.js';
 export { useDaimoPayStatus } from './hooks/useDaimoPayStatus.js';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@daimo/pay",
   "private": false,
-  "version": "1.0.9",
+  "version": "1.1.0",
   "author": "Daimo",
   "homepage": "https://pay.daimo.com",
   "license": "BSD-2-Clause license",