@daimo/pay 1.1.5 → 1.3.0

package/build/src/hooks/useDepositAddressOptions.js.map

@@ -1 +1 @@
-{"version":3,"file":"useDepositAddressOptions.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"useDepositAddressOptions.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/src/hooks/useExternalPaymentOptions.js

@@ -7,18 +7,19 @@ const DEFAULT_EXTERNAL_PAYMENT_OPTIONS = [
     ExternalPaymentOptions.Daimo,
     ExternalPaymentOptions.RampNetwork,
 ];
-function useExternalPaymentOptions({ trpc, filterIds, usdRequired, platform, }) {
+function useExternalPaymentOptions({ trpc, filterIds, platform, usdRequired, mode, }) {
     const [options, setOptions] = useState([]);
     const [loading, setLoading] = useState(false);
     useEffect(() => {
-        const refreshExternalPaymentOptions = async (usd) => {
+        const refreshExternalPaymentOptions = async (usd, mode) => {
             if (!platform)
                 return;
             setLoading(true);
             try {
                 const newOptions = await trpc.getExternalPaymentOptions.query({
-                    usdRequired: usd,
                     platform,
+                    mode,
+                    usdRequired: usd,
                 });
                 // Filter out options not in options JSON
                 const enabledExtPaymentOptions = filterIds || DEFAULT_EXTERNAL_PAYMENT_OPTIONS;
@@ -32,10 +33,10 @@ function useExternalPaymentOptions({ trpc, filterIds, usdRequired, platform, })
                 setLoading(false);
             }
         };
-        if (usdRequired != null) {
-            refreshExternalPaymentOptions(usdRequired);
+        if (usdRequired != null && mode != null) {
+            refreshExternalPaymentOptions(usdRequired, mode);
         }
-    }, [usdRequired, filterIds, platform]);
+    }, [usdRequired, filterIds, platform, mode]);
     return {
         options,
         loading,

package/build/src/hooks/useExternalPaymentOptions.js.map

@@ -1 +1 @@
-{"version":3,"file":"useExternalPaymentOptions.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"useExternalPaymentOptions.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/src/hooks/useOrderUsdLimits.js

@@ -0,0 +1,26 @@
+import { useState, useEffect } from 'react';
+
+function useOrderUsdLimits({ trpc }) {
+    const [limits, setLimits] = useState({});
+    const [loading, setLoading] = useState(false);
+    useEffect(() => {
+        const refreshOrderUsdLimits = async () => {
+            setLoading(true);
+            try {
+                const { limits: newLimits } = await trpc.getOrderUsdLimits.query();
+                setLimits(newLimits);
+            }
+            catch (e) {
+                console.error(e);
+            }
+            finally {
+                setLoading(false);
+            }
+        };
+        refreshOrderUsdLimits();
+    }, []);
+    return { limits, loading };
+}
+
+export { useOrderUsdLimits };
+//# sourceMappingURL=useOrderUsdLimits.js.map

package/build/src/hooks/useOrderUsdLimits.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useOrderUsdLimits.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/src/hooks/usePayWithSolanaToken.js

@@ -7,8 +7,9 @@ function usePayWithSolanaToken({ trpc, daimoPayOrder, setDaimoPayOrder, createOr
     const { connection } = useConnection();
     const wallet = useWallet();
     const payWithSolanaToken = async (inputToken) => {
-        assert(!!wallet.publicKey, "No wallet connected");
-        assert(!!platform && !!daimoPayOrder);
+        assert(!!wallet.publicKey, "[PAY SOLANA] No wallet connected");
+        assert(!!daimoPayOrder, "[PAY SOLANA] daimoPayOrder cannot be null");
+        assert(!!platform, "[PAY SOLANA] platform cannot be null");
         const orderId = daimoPayOrder.id;
         const { hydratedOrder } = await createOrHydrate({
             order: daimoPayOrder,
@@ -18,7 +19,7 @@ function usePayWithSolanaToken({ trpc, daimoPayOrder, setDaimoPayOrder, createOr
             try {
                 const serializedTx = await trpc.getSolanaSwapAndBurnTx.query({
                     orderId: orderId.toString(),
-                    userPublicKey: assertNotNull(wallet.publicKey).toString(),
+                    userPublicKey: assertNotNull(wallet.publicKey, "[PAY SOLANA] wallet.publicKey cannot be null").toString(),
                     inputTokenMint: inputToken,
                 });
                 const tx = VersionedTransaction.deserialize(hexToBytes(serializedTx));

package/build/src/hooks/usePayWithSolanaToken.js.map

@@ -1 +1 @@
-{"version":3,"file":"usePayWithSolanaToken.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"usePayWithSolanaToken.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/src/hooks/usePayWithToken.js

@@ -7,12 +7,14 @@ function usePayWithToken({ trpc, senderAddr, daimoPayOrder, setDaimoPayOrder, cr
     const { sendTransactionAsync } = useSendTransaction();
     /** Commit to a token + amount = initiate payment. */
     const payWithToken = async (tokenAmount) => {
-        assert(!!daimoPayOrder && !!platform);
+        assert(!!daimoPayOrder, "[PAY TOKEN] daimoPayOrder cannot be null");
+        assert(!!platform, "[PAY TOKEN] platform cannot be null");
         const { hydratedOrder } = await createOrHydrate({
             order: daimoPayOrder,
             refundAddress: senderAddr,
         });
-        log(`[CHECKOUT] Hydrated order: ${JSON.stringify(hydratedOrder)}, checking out with ${tokenAmount.token.token}`);
+        log(`[CHECKOUT] hydrated order: ${JSON.stringify(hydratedOrder)}, checking out with ${tokenAmount.token.token}`);
+        setDaimoPayOrder(hydratedOrder);
         const txHash = await (async () => {
             try {
                 if (tokenAmount.token.token === zeroAddress) {
@@ -31,23 +33,20 @@ function usePayWithToken({ trpc, senderAddr, daimoPayOrder, setDaimoPayOrder, cr
                 }
             }
             catch (e) {
-                console.error(`[CHECKOUT] Error sending token: ${e}`);
-                setDaimoPayOrder(hydratedOrder);
+                console.error(`[CHECKOUT] error sending token: ${e}`);
                 throw e;
             }
-            finally {
-                setDaimoPayOrder(hydratedOrder);
-            }
         })();
         if (txHash) {
             await trpc.processSourcePayment.mutate({
                 orderId: daimoPayOrder.id.toString(),
                 sourceInitiateTxHash: txHash,
                 sourceChainId: tokenAmount.token.chainId,
-                sourceFulfillerAddr: assertNotNull(senderAddr),
+                sourceFulfillerAddr: assertNotNull(senderAddr, `[PAY TOKEN] senderAddr cannot be null on order ${daimoPayOrder.id}`),
                 sourceToken: tokenAmount.token.token,
                 sourceAmount: tokenAmount.amount,
             });
+            // TODO: update order immediately, do not wait for polling.
         }
     };
     return { payWithToken };

package/build/src/hooks/usePayWithToken.js.map

@@ -1 +1 @@
-{"version":3,"file":"usePayWithToken.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"usePayWithToken.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/src/hooks/usePaymentState.js

@@ -4,10 +4,10 @@ import { useWallet } from '@solana/wallet-adapter-react';
 import { useState, useEffect, useCallback } from 'react';
 import { parseUnits, formatUnits } from 'viem';
 import { useAccount, useEnsName } from 'wagmi';
-import { generatePayId } from '../utils/exports.js';
 import { detectPlatform } from '../utils/platform.js';
 import { useDepositAddressOptions } from './useDepositAddressOptions.js';
 import { useExternalPaymentOptions } from './useExternalPaymentOptions.js';
+import { useOrderUsdLimits } from './useOrderUsdLimits.js';
 import { usePayWithSolanaToken } from './usePayWithSolanaToken.js';
 import { usePayWithToken } from './usePayWithToken.js';
 import { useSolanaPaymentOptions } from './useSolanaPaymentOptions.js';
@@ -31,14 +31,16 @@ function usePaymentState({ trpc, daimoPayOrder, setDaimoPayOrder, setOpen, log,
     // Daimo Pay order state.
     const [payParams, setPayParamsState] = useState();
     const [paymentWaitingMessage, setPaymentWaitingMessage] = useState();
+    const [isDepositFlow, setIsDepositFlow] = useState(false);
     // Payment UI config.
     const [modalOptions, setModalOptions] = useState({});
     // UI state. Selection for external payment (Binance, etc) vs wallet payment.
     const externalPaymentOptions = useExternalPaymentOptions({
         trpc,
         filterIds: daimoPayOrder?.metadata.payer?.paymentOptions,
-        usdRequired: daimoPayOrder?.destFinalCallTokenAmount.usd,
         platform,
+        usdRequired: daimoPayOrder?.destFinalCallTokenAmount.usd,
+        mode: daimoPayOrder?.mode,
     });
     const walletPaymentOptions = useWalletPaymentOptions({
         trpc,
@@ -47,22 +49,26 @@ function usePaymentState({ trpc, daimoPayOrder, setDaimoPayOrder, setOpen, log,
         destChainId: daimoPayOrder?.destFinalCallTokenAmount.token.chainId,
         preferredChains: daimoPayOrder?.metadata.payer?.preferredChains,
         preferredTokens: daimoPayOrder?.metadata.payer?.preferredTokens,
+        isDepositFlow,
         log,
     });
     const solanaPaymentOptions = useSolanaPaymentOptions({
         trpc,
         address: solanaPubKey,
         usdRequired: daimoPayOrder?.destFinalCallTokenAmount.usd,
+        isDepositFlow,
     });
     const depositAddressOptions = useDepositAddressOptions({
         trpc,
-        usdRequired: daimoPayOrder?.destFinalCallTokenAmount.usd ?? 0,
+        usdRequired: daimoPayOrder?.destFinalCallTokenAmount.usd,
+        mode: daimoPayOrder?.mode,
     });
+    const chainOrderUsdLimits = useOrderUsdLimits({ trpc });
     /** Create a new order or hydrate an existing one. */
     const createOrHydrate = async ({ order, refundAddress, externalPaymentOption, }) => {
-        assert(!!platform, "missing platform");
+        assert(!!platform, "[CREATE/HYDRATE] missing platform");
         if (payParams == null) {
-            log(`[CHECKOUT] hydrating existing order ${order.id}`);
+            log(`[CREATE/HYDRATE] hydrating existing order ${order.id}`);
             return await trpc.hydrateOrder.query({
                 id: order.id.toString(),
                 chosenFinalTokenAmount: order.destFinalCallTokenAmount.amount,
@@ -71,16 +77,18 @@ function usePaymentState({ trpc, daimoPayOrder, setDaimoPayOrder, setOpen, log,
                 externalPaymentOption,
             });
         }
-        log(`[CHECKOUT] creating+hydrating new order ${order.id}`);
-        // Update units, if amountEditable the user may have changed the amount.
+        log(`[CREATE/HYDRATE] creating+hydrating new order ${order.id}`);
+        // Update units, if isDepositFlow then the user may have changed the amount.
         const toUnits = formatUnits(BigInt(order.destFinalCallTokenAmount.amount), order.destFinalCallTokenAmount.token.decimals);
         return await trpc.createOrder.mutate({
             appId: payParams.appId,
             paymentInput: {
                 ...payParams,
                 id: order.id.toString(),
-                toUnits: toUnits,
+                toUnits,
                 metadata: order.metadata,
+                userMetadata: payParams.metadata,
+                isAmountEditable: isDepositFlow,
             },
             platform,
             refundAddress,
@@ -108,29 +116,40 @@ function usePaymentState({ trpc, daimoPayOrder, setDaimoPayOrder, setOpen, log,
     const [selectedTokenOption, setSelectedTokenOption] = useState();
     const [selectedSolanaTokenOption, setSelectedSolanaTokenOption] = useState();
     const [selectedDepositAddressOption, setSelectedDepositAddressOption] = useState();
+    const getOrderUsdLimit = () => {
+        const DEFAULT_USD_LIMIT = 20000;
+        if (daimoPayOrder == null || chainOrderUsdLimits.loading) {
+            return DEFAULT_USD_LIMIT;
+        }
+        const destChainId = daimoPayOrder.destFinalCallTokenAmount.token.chainId;
+        return destChainId in chainOrderUsdLimits.limits
+            ? chainOrderUsdLimits.limits[destChainId]
+            : DEFAULT_USD_LIMIT;
+    };
     const payWithExternal = async (option) => {
-        assert(!!daimoPayOrder && !!platform);
+        assert(!!daimoPayOrder, "[PAY EXTERNAL] daimoPayOrder cannot be null");
+        assert(!!platform, "[PAY EXTERNAL] platform cannot be null");
         const { hydratedOrder, externalPaymentOptionData } = await createOrHydrate({
             order: daimoPayOrder,
             externalPaymentOption: option,
         });
-        assert(!!externalPaymentOptionData, "missing externalPaymentOptionData");
-        log(`[CHECKOUT] Hydrated order: ${JSON.stringify(hydratedOrder)}, checking out with external payment: ${option}`);
+        assert(!!externalPaymentOptionData, "[PAY EXTERNAL] missing externalPaymentOptionData");
+        log(`[PAY EXTERNAL] hydrated order: ${JSON.stringify(hydratedOrder)}, checking out with external payment: ${option}`);
         setPaymentWaitingMessage(externalPaymentOptionData.waitingMessage);
         setDaimoPayOrder(hydratedOrder);
         return externalPaymentOptionData.url;
     };
     const payWithDepositAddress = async (option) => {
-        assert(!!daimoPayOrder);
+        assert(!!daimoPayOrder, "[PAY DEPOSIT ADDRESS] missing daimoPayOrder");
         const { hydratedOrder } = await createOrHydrate({
             order: daimoPayOrder,
         });
         setDaimoPayOrder(hydratedOrder);
-        log(`[CHECKOUT] Hydrated order: ${JSON.stringify(hydratedOrder)}, checking out with deposit address: ${option}`);
+        log(`[PAY DEPOSIT ADDRESS] hydrated order: ${JSON.stringify(hydratedOrder)}, checking out with deposit address: ${option}`);
         const depositAddressOption = await trpc.getDepositAddressOptionData.query({
             input: option,
             usdRequired: daimoPayOrder.destFinalCallTokenAmount.usd,
-            toAddress: assertNotNull(hydratedOrder.intentAddr),
+            toAddress: assertNotNull(hydratedOrder.intentAddr, `[PAY DEPOSIT ADDRESS] missing intentAddr on order ${hydratedOrder.id}`),
         });
         return depositAddressOption;
     };
@@ -141,22 +160,30 @@ function usePaymentState({ trpc, daimoPayOrder, setDaimoPayOrder, setOpen, log,
         const { order } = await trpc.getOrder.query({
             id,
         });
-        setDaimoPayOrder(order);
+        // Don't overwrite the order if a new order was generated.
+        if (daimoPayOrder == null || order.id === daimoPayOrder.id) {
+            log(`[CHECKOUT] refreshed order: ${order.id}`);
+            setDaimoPayOrder(order);
+        }
+        else {
+            log(`[CHECKOUT] IGNORING refreshOrder, wrong ID: ${order.id} vs ${daimoPayOrder.id}`);
+        }
     }, [daimoPayOrder?.id]);
     /** User picked a different deposit amount. */
-    const setChosenUsd = (usdAmount) => {
-        log(`[CHECKOUT] Setting chosen USD amount to ${usdAmount}`);
-        assert(!!daimoPayOrder);
+    const setChosenUsd = (usd) => {
+        assert(!!daimoPayOrder, "[SET CHOSEN USD] daimoPayOrder cannot be null");
         const token = daimoPayOrder.destFinalCallTokenAmount.token;
-        const tokenAmount = parseUnits((usdAmount / token.usd).toString(), token.decimals);
+        const tokenUnits = (usd / token.usd).toString();
+        const tokenAmount = parseUnits(tokenUnits, token.decimals);
         // TODO: remove amount from destFinalCall, it is redundant with
         // destFinalCallTokenAmount. Here, we only modify one and not the other.
+        log(`[CHECKOUT] setting chosen USD amount to $${usd} = ${tokenUnits} ${token.symbol}`);
         setDaimoPayOrder({
             ...daimoPayOrder,
             destFinalCallTokenAmount: {
                 token,
                 amount: tokenAmount.toString(),
-                usd: usdAmount,
+                usd: usd,
             },
         });
     };
@@ -170,26 +197,31 @@ function usePaymentState({ trpc, daimoPayOrder, setDaimoPayOrder, setOpen, log,
         }
         const { order } = await trpc.getOrder.query({ id });
         if (!order) {
-            console.error(`[CHECKOUT] No order found for ${payId}`);
+            console.error(`[CHECKOUT] setPayId: no order found for ${payId}`);
             return;
         }
-        log(`[CHECKOUT] fetched order: ${JSON.stringify(order)}`);
+        log(`[CHECKOUT] setPayId: fetched order: ${JSON.stringify(order)}`);
         setDaimoPayOrder(order);
     }, [daimoPayOrder]);
     /** Called whenever params change. */
     const setPayParams = async (payParams) => {
-        assert(payParams != null);
+        assert(payParams != null, "[SET PAY PARAMS] payParams cannot be null");
         setPayParamsState(payParams);
-        const newPayId = generatePayId();
-        const newId = readDaimoPayOrderID(newPayId).toString();
-        const payment = await trpc.previewOrder.query({
-            id: newId,
+        setIsDepositFlow(payParams.toUnits == null);
+        generatePreviewOrder(payParams);
+    };
+    const generatePreviewOrder = async (payParams) => {
+        // toUnits is undefined if and only if we're in deposit flow.
+        // Set dummy value for deposit flow, since user can edit the amount.
+        const toUnits = payParams.toUnits == null ? "0" : payParams.toUnits;
+        const orderPreview = await trpc.previewOrder.query({
+            appId: payParams.appId,
             toChain: payParams.toChain,
             toToken: payParams.toToken,
-            toUnits: payParams.toUnits,
+            toUnits,
             toAddress: payParams.toAddress,
             toCallData: payParams.toCallData,
-            isAmountEditable: payParams.isAmountEditable,
+            isAmountEditable: payParams.toUnits == null,
             metadata: {
                 intent: payParams.intent ?? "Pay",
                 items: [],
@@ -199,20 +231,25 @@ function usePaymentState({ trpc, daimoPayOrder, setDaimoPayOrder, setOpen, log,
                     preferredTokens: payParams.preferredTokens,
                 },
             },
+            externalId: payParams.externalId,
+            userMetadata: payParams.metadata,
         });
-        setDaimoPayOrder(payment);
+        log(`[CHECKOUT] generated preview: ${JSON.stringify(orderPreview)}`);
+        setDaimoPayOrder(orderPreview);
     };
     const onSuccess = ({ txHash, txURL }) => {
         if (modalOptions?.closeOnSuccess) {
             log(`[CHECKOUT] transaction succeeded, closing: ${txHash} ${txURL}`);
-            setTimeout(() => setOpen(false), 1000);
+            setTimeout(() => setOpen(false, { event: "wait-success" }), 1000);
         }
     };
     return {
         setPayId,
         payParams,
         setPayParams,
+        generatePreviewOrder,
         daimoPayOrder,
+        isDepositFlow,
         modalOptions,
         setModalOptions,
         paymentWaitingMessage,
@@ -224,10 +261,12 @@ function usePaymentState({ trpc, daimoPayOrder, setDaimoPayOrder, setOpen, log,
         solanaPaymentOptions,
         depositAddressOptions,
         selectedDepositAddressOption,
-        setSelectedDepositAddressOption,
+        getOrderUsdLimit,
+        setPaymentWaitingMessage,
         setSelectedExternalOption,
         setSelectedTokenOption,
         setSelectedSolanaTokenOption,
+        setSelectedDepositAddressOption,
         setChosenUsd,
         payWithToken,
         payWithExternal,

package/build/src/hooks/usePaymentState.js.map

@@ -1 +1 @@
-{"version":3,"file":"usePaymentState.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"usePaymentState.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/src/hooks/useSolanaPaymentOptions.js

@@ -1,18 +1,20 @@
 import { useState, useEffect } from 'react';
 
-function useSolanaPaymentOptions({ trpc, address, usdRequired, }) {
+/** Wallet payment options. User picks one. */
+function useSolanaPaymentOptions({ trpc, address, usdRequired, isDepositFlow, }) {
     const [options, setOptions] = useState(null);
     const [isLoading, setIsLoading] = useState(false);
     useEffect(() => {
         const refreshWalletPaymentOptions = async () => {
-            if (!address || !usdRequired)
+            if (address == null || usdRequired == null)
                 return;
             setOptions(null);
             setIsLoading(true);
             try {
                 const newOptions = await trpc.getSolanaPaymentOptions.query({
                     pubKey: address,
-                    usdRequired,
+                    // API expects undefined for deposit flow.
+                    usdRequired: isDepositFlow ? undefined : usdRequired,
                 });
                 setOptions(newOptions);
             }
@@ -23,10 +25,10 @@ function useSolanaPaymentOptions({ trpc, address, usdRequired, }) {
                 setIsLoading(false);
             }
         };
-        if (address && usdRequired != null) {
+        if (address != null && usdRequired != null) {
             refreshWalletPaymentOptions();
         }
-    }, [address, usdRequired]);
+    }, [address, usdRequired, isDepositFlow]);
     return {
         options,
         isLoading,

package/build/src/hooks/useSolanaPaymentOptions.js.map

@@ -1 +1 @@
-{"version":3,"file":"useSolanaPaymentOptions.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"useSolanaPaymentOptions.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/src/hooks/useWalletPaymentOptions.js

@@ -1,25 +1,26 @@
-import { getDAv2Chains } from '@daimo/contract';
 import { useState, useEffect } from 'react';
+import { supportedChainIds } from '../utils/exports.js';
 
-const supportedChainIds = new Set([...getDAv2Chains(false), ...getDAv2Chains(true)].map((c) => c.chainId));
-function useWalletPaymentOptions({ trpc, address, usdRequired, destChainId, preferredChains, preferredTokens, log, }) {
+/** Wallet payment options. User picks one. */
+function useWalletPaymentOptions({ trpc, address, usdRequired, destChainId, preferredChains, preferredTokens, isDepositFlow, log, }) {
     const [options, setOptions] = useState(null);
     const [isLoading, setIsLoading] = useState(false);
     useEffect(() => {
         const refreshWalletPaymentOptions = async () => {
-            if (!address || !usdRequired || !destChainId)
+            if (address == null || usdRequired == null || destChainId == null)
                 return;
             setOptions(null);
             setIsLoading(true);
             try {
                 const newOptions = await trpc.getWalletPaymentOptions.query({
                     payerAddress: address,
-                    usdRequired,
+                    // API expects undefined for deposit flow.
+                    usdRequired: isDepositFlow ? undefined : usdRequired,
                     destChainId,
                     preferredChains,
                     preferredTokens,
                 });
-                // Filter out options we don't support yet.
+                // Filter out chains we don't support yet.
                 const isSupported = (o) => supportedChainIds.has(o.balance.token.chainId);
                 const filteredOptions = newOptions.filter(isSupported);
                 if (filteredOptions.length < newOptions.length) {
@@ -34,10 +35,10 @@ function useWalletPaymentOptions({ trpc, address, usdRequired, destChainId, pref
                 setIsLoading(false);
             }
         };
-        if (address && usdRequired != null && destChainId) {
+        if (address != null && usdRequired != null && destChainId != null) {
             refreshWalletPaymentOptions();
         }
-    }, [address, usdRequired, destChainId]);
+    }, [address, usdRequired, destChainId, isDepositFlow]);
     return {
         options,
         isLoading,

package/build/src/hooks/useWalletPaymentOptions.js.map

@@ -1 +1 @@
-{"version":3,"file":"useWalletPaymentOptions.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"useWalletPaymentOptions.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/src/index.js

@@ -3,9 +3,8 @@ export { Context as DaimoPayContext, DaimoPayProvider, usePayContext } from './c
 export { default as getDefaultConfig } from './defaultConfig.js';
 export { DaimoPayButton } from './components/DaimoPayButton/index.js';
 export { useDaimoPayStatus } from './hooks/useDaimoPayStatus.js';
-export { useModal as useDaimoPayModal } from './hooks/useModal.js';
 export { default as Avatar } from './components/Common/Avatar/index.js';
 export { default as ChainIcon } from './components/Common/Chain/index.js';
 export { wallets } from './wallets/index.js';
-export { daimoPayVersion, generatePayId } from './utils/exports.js';
+export { daimoPayVersion, supportedChainIds } from './utils/exports.js';
 //# sourceMappingURL=index.js.map

package/build/src/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;"}

package/build/src/utils/exports.js

@@ -1,14 +1,10 @@
-import { writeDaimoPayOrderID } from '@daimo/common';
-import { bytesToBigInt } from 'viem';
+import { getDAv2Chains } from '@daimo/contract';
 import packageJson from '../../package.json.js';
 
 // Exported utilities, useful for @daimo/pay users.
 const daimoPayVersion = packageJson.version;
-/** Generates a globally-unique payId. */
-function generatePayId() {
-    const id = bytesToBigInt(crypto.getRandomValues(new Uint8Array(32)));
-    return writeDaimoPayOrderID(id);
-}
+/** Chain ids supported by Daimo Pay. */
+const supportedChainIds = new Set([...getDAv2Chains(false), ...getDAv2Chains(true)].map((c) => c.chainId));
 
-export { daimoPayVersion, generatePayId };
+export { daimoPayVersion, supportedChainIds };
 //# sourceMappingURL=exports.js.map

package/build/src/utils/exports.js.map

@@ -1 +1 @@
-{"version":3,"file":"exports.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;"}
+{"version":3,"file":"exports.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;"}

package/build/src/utils/format.js

@@ -0,0 +1,83 @@
+import { formatUnits } from 'viem';
+
+const USD_DECIMALS = 2;
+/**
+ * Round a number to a given number of decimal places
+ *
+ * @param round - The rounding strategy to use:
+ * - "up": Always rounds up to the next decimal place (ceiling)
+ * - "down": Always rounds down to the previous decimal place (floor)
+ * - "nearest": Rounds to the nearest decimal place (standard rounding)
+ */
+function roundDecimals(value, decimals, round) {
+    const factor = 10 ** decimals;
+    const multiplied = value * factor;
+    let rounded;
+    if (round === "up") {
+        rounded = Math.ceil(multiplied);
+    }
+    else if (round === "down") {
+        rounded = Math.floor(multiplied);
+    }
+    else {
+        rounded = Math.round(multiplied);
+    }
+    return (rounded / factor).toFixed(decimals);
+}
+/**
+ * Format a number as a USD amount
+ *
+ * @param usd - The USD amount to format
+ * @param round - The rounding strategy to use ("up", "down", or "nearest")
+ * @returns The formatted USD amount
+ */
+function formatUsd(usd, round = "down") {
+    return new Intl.NumberFormat("en-US", {
+        style: "currency",
+        currency: "USD",
+    }).format(Number(roundUsd(usd, round)));
+}
+/**
+ * Round a USD amount to `USD_DECIMALS` precision
+ */
+function roundUsd(usd, round = "down") {
+    return roundDecimals(usd, USD_DECIMALS, round);
+}
+/**
+ * Round a token amount to `displayDecimals` precision
+ */
+function roundTokenAmount(amount, token, round = "down") {
+    return roundDecimals(Number(formatUnits(BigInt(amount), token.decimals)), token.displayDecimals, round);
+}
+/**
+ * Round a token amount in units to `displayDecimals` precision
+ */
+function roundTokenAmountUnits(amountUnits, token, round = "down") {
+    return roundDecimals(amountUnits, token.displayDecimals, round);
+}
+/**
+ * Convert a USD amount to a token amount with `displayDecimals` precision
+ *
+ * @param usd - The USD amount to convert
+ * @param token - The token to convert to
+ * @param round - The rounding strategy to use ("up", "down", or "nearest")
+ * @returns The token amount
+ */
+function usdToRoundedTokenAmount(usd, token, round = "down") {
+    return roundTokenAmountUnits(usd / token.usd, token, round);
+}
+/**
+ * Convert a token amount to a USD amount with `USD_DECIMALS` precision
+ *
+ * @param amount - The token amount to convert
+ * @param token - The token to convert from
+ * @param round - The rounding strategy to use ("up", "down", or "nearest")
+ * @returns The formatted USD amount
+ */
+function tokenAmountToRoundedUsd(amount, token, round = "nearest") {
+    const amountUnits = formatUnits(BigInt(amount), token.decimals);
+    return roundUsd(Number(amountUnits) * token.usd, round);
+}
+
+export { USD_DECIMALS, formatUsd, roundDecimals, roundTokenAmount, roundTokenAmountUnits, roundUsd, tokenAmountToRoundedUsd, usdToRoundedTokenAmount };
+//# sourceMappingURL=format.js.map

package/build/src/utils/format.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/src/utils/trpc.js

@@ -1,13 +1,14 @@
 import { createTRPCClient, httpBatchLink } from '@trpc/client';
 import { daimoPayVersion } from './exports.js';
 
-function createTrpcClient(apiUrl) {
+function createTrpcClient(apiUrl, sessionId) {
     return createTRPCClient({
         links: [
             httpBatchLink({
                 url: apiUrl,
                 headers: {
                     "x-pay-version": daimoPayVersion,
+                    "x-session-id": sessionId,
                 },
             }),
         ],

package/build/src/utils/trpc.js.map

@@ -1 +1 @@
-{"version":3,"file":"trpc.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"trpc.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;"}