@daimo/pay 1.2.0 → 1.3.1

package/build/src/components/Pages/SelectToken/index.js

@@ -34,11 +34,16 @@ const SelectToken = () => {
             ],
             onClick: () => {
                 setSelectedTokenOption(option);
+                const meta = {
+                    event: "click-token",
+                    tokenSymbol: option.balance.token.symbol,
+                    chainId: option.balance.token.chainId,
+                };
                 if (isDepositFlow) {
-                    setRoute(ROUTES.SELECT_AMOUNT);
+                    setRoute(ROUTES.SELECT_AMOUNT, meta);
                 }
                 else {
-                    setRoute(ROUTES.PAY_WITH_TOKEN);
+                    setRoute(ROUTES.PAY_WITH_TOKEN, meta);
                 }
             },
             disabled,

package/build/src/components/Pages/SelectToken/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/components/Pages/Solana/ConnectSolana/index.js

@@ -20,7 +20,10 @@ const ConnectSolana = () => {
             if (solanaWallets.connected) {
                 await solanaWallets.disconnect();
             }
-            setRoute(ROUTES.SOLANA_CONNECTOR);
+            setRoute(ROUTES.SOLANA_CONNECTOR, {
+                event: "click-solana-wallet",
+                walletName: wallet.adapter.name,
+            });
         },
     }));
     return (jsxs(PageContent, { children: [jsx(OrderHeader, { minified: true }), solanaWallets.wallets.length === 0 && (jsxs(ModalContent, { style: {
@@ -29,7 +32,7 @@ const ConnectSolana = () => {
                     justifyContent: "center",
                     paddingTop: 16,
                     paddingBottom: 16,
-                }, children: [jsx(ModalH1, { children: "No Solana wallets detected." }), jsx(Button, { onClick: () => setRoute(ROUTES.SELECT_METHOD), children: "Select Another Method" })] })), jsx(OptionsList, { options: options })] }));
+                }, children: [jsx(ModalH1, { children: "No Solana wallets detected." }), jsx(Button, { onClick: () => setRoute(ROUTES.SELECT_METHOD, { event: "click-select-another" }), children: "Select Another Method" })] })), jsx(OptionsList, { options: options })] }));
 };
 const SquircleIcon = ({ icon, alt }) => (jsx("div", { style: { borderRadius: "22.5%", overflow: "hidden" }, children: jsx("img", { src: icon, alt: alt }) }));
 

package/build/src/components/Pages/Solana/ConnectSolana/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/components/Pages/Solana/ConnectorSolana/index.js

@@ -20,7 +20,11 @@ const ConnectSolana = () => {
     useEffect(() => {
         if (isConnected) {
             // Wait so user can see it's connected
-            setTimeout(() => setRoute(ROUTES.SOLANA_SELECT_TOKEN), 500);
+            const meta = {
+                event: "wait-solana-connected",
+                walletName: solanaWallets.wallet?.adapter.name,
+            };
+            setTimeout(() => setRoute(ROUTES.SOLANA_SELECT_TOKEN, meta), 500);
         }
     }, [isConnected]);
     if (!solanaConnector)

package/build/src/components/Pages/Solana/ConnectorSolana/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/components/Pages/Solana/PayWithSolanaToken/index.js

@@ -4,9 +4,6 @@ import { usePayContext, ROUTES } from '../../../DaimoPay.js';
 import { WalletSignTransactionError, WalletSendTransactionError } from '@solana/wallet-adapter-base';
 import { PageContent, ModalContent, ModalH1 } from '../../../Common/Modal/styles.js';
 import { assert } from '@daimo/common';
-import { motion } from 'framer-motion';
-import { css } from 'styled-components';
-import styled from '../../../../styles/styled/index.js';
 import Button from '../../../Common/Button/index.js';
 import PaymentBreakdown from '../../../Common/PaymentBreakdown/index.js';
 import TokenLogoSpinner from '../../../Spinners/TokenLogoSpinner/index.js';
@@ -25,11 +22,11 @@ const PayWithSolanaToken = () => {
     const handleTransfer = async () => {
         try {
             setPayState(PayState.RequestingPayment);
-            assert(!!selectedSolanaTokenOption, "No token option selected");
+            assert(!!selectedSolanaTokenOption, "[PAY SOLANA] No token option selected");
             await payWithSolanaToken(selectedSolanaTokenOption.required.token.token);
             setPayState(PayState.RequestSuccessful);
             setTimeout(() => {
-                setRoute(ROUTES.CONFIRMATION);
+                setRoute(ROUTES.CONFIRMATION, { event: "wait-pay-with-solana" });
             }, 200);
         }
         catch (error) {
@@ -55,37 +52,11 @@ const PayWithSolanaToken = () => {
         triggerResize();
     }, [payState]);
     return (jsxs(PageContent, { children: [selectedSolanaTokenOption && (jsx(TokenLogoSpinner, { token: selectedSolanaTokenOption.required.token })), jsxs(ModalContent, { style: { paddingBottom: 0 }, children: [jsx(ModalH1, { children: payState }), selectedSolanaTokenOption && (jsx(PaymentBreakdown, { paymentOption: selectedSolanaTokenOption })), payState === PayState.RequestCancelled && (jsx(Button, { onClick: handleTransfer, children: "Retry Payment" })), payState === PayState.RequestFailed && (jsx(Button, { onClick: () => {
-                            assert(payParams != null, "payParams cannot be null in deposit flow");
+                            assert(payParams != null, "[PAY SOLANA] payParams cannot be null in deposit flow");
                             generatePreviewOrder(payParams);
-                            setRoute(ROUTES.SELECT_METHOD);
+                            setRoute(ROUTES.SELECT_METHOD, { event: "click-select-another" });
                         }, children: "Select Another Method" }))] })] }));
 };
-styled(motion.div) `
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  margin: 10px auto 16px;
-  height: 120px;
-`;
-styled(motion.div) `
-  user-select: none;
-  position: relative;
-  --spinner-error-opacity: 0;
-  &:before {
-    content: "";
-    position: absolute;
-    inset: 1px;
-    opacity: 0;
-    background: var(--ck-body-color-danger);
-    ${(props) => props.$circle &&
-    css `
-        inset: -5px;
-        border-radius: 50%;
-        background: none;
-        box-shadow: inset 0 0 0 3.5px var(--ck-body-color-danger);
-      `}
-  }
-`;
 
 export { PayWithSolanaToken as default };
 //# sourceMappingURL=index.js.map

package/build/src/components/Pages/Solana/PayWithSolanaToken/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/components/Pages/Solana/SelectSolanaToken/index.js

@@ -31,11 +31,16 @@ const SelectSolanaToken = () => {
             ],
             onClick: () => {
                 setSelectedSolanaTokenOption(option);
+                const meta = {
+                    event: "click-solana-token",
+                    tokenSymbol: option.balance.token.symbol,
+                    chainId: option.balance.token.chainId,
+                };
                 if (isDepositFlow) {
-                    setRoute(ROUTES.SOLANA_SELECT_AMOUNT);
+                    setRoute(ROUTES.SOLANA_SELECT_AMOUNT, meta);
                 }
                 else {
-                    setRoute(ROUTES.SOLANA_PAY_WITH_TOKEN);
+                    setRoute(ROUTES.SOLANA_PAY_WITH_TOKEN, meta);
                 }
             },
             disabled,

package/build/src/components/Pages/Solana/SelectSolanaToken/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/components/Pages/WaitingDepositAddress/index.js

@@ -44,7 +44,7 @@ const WaitingDepositAddress = () => {
     useEffect(() => {
         triggerResize();
     }, [details]);
-    return (jsx(PageContent, { children: failed ? (jsxs(ModalContent, { style: { marginLeft: 24, marginRight: 24 }, children: [jsxs(ModalH1, { children: [selectedDepositAddressOption?.id, " unavailable"] }), jsxs(ModalBody, { children: ["We're unable to process ", selectedDepositAddressOption?.id, " payments at this time. Please select another payment method."] }), jsx(Button, { onClick: () => setRoute(ROUTES.SELECT_METHOD), children: "Select Another Method" })] })) : (jsxs(ModalContent, { children: [jsx(CustomQRCode, { value: details?.uri, image: jsx("img", { src: selectedDepositAddressOption?.logoURI, width: "100%", height: "100%" }), tooltipMessage: jsxs(Fragment, { children: [jsx(ScanIconWithLogos, { logo: jsx("img", { src: selectedDepositAddressOption?.logoURI }) }), jsxs("span", { children: ["Use a ", selectedDepositAddressOption?.id, " wallet to scan"] })] }) }), details && (jsxs(Fragment, { children: [jsx(OrDivider, {}), jsxs(ModalBody, { children: ["Send exactly ", details.amount, " ", details.suffix, " to", " ", getAddressContraction(details.address), " and return to this page. Confirmation should appear in a few minutes."] }), jsx(CopyToClipboard, { variant: "button", string: details.address, children: "Copy Address" }), jsx(CopyToClipboard, { variant: "left", string: details.amount, children: "Copy Amount" })] }))] })) }));
+    return (jsx(PageContent, { children: failed ? (jsxs(ModalContent, { style: { marginLeft: 24, marginRight: 24 }, children: [jsxs(ModalH1, { children: [selectedDepositAddressOption?.id, " unavailable"] }), jsxs(ModalBody, { children: ["We're unable to process ", selectedDepositAddressOption?.id, " payments at this time. Please select another payment method."] }), jsx(Button, { onClick: () => setRoute(ROUTES.SELECT_METHOD, { event: "click-select-another" }), children: "Select Another Method" })] })) : (jsxs(ModalContent, { children: [jsx(CustomQRCode, { value: details?.uri, image: jsx("img", { src: selectedDepositAddressOption?.logoURI, width: "100%", height: "100%" }), tooltipMessage: jsxs(Fragment, { children: [jsx(ScanIconWithLogos, { logo: jsx("img", { src: selectedDepositAddressOption?.logoURI }) }), jsxs("span", { children: ["Use a ", selectedDepositAddressOption?.id, " wallet to scan"] })] }) }), details && (jsxs(Fragment, { children: [jsx(OrDivider, {}), jsxs(ModalBody, { children: ["Send exactly ", details.amount, " ", details.suffix, " to", " ", getAddressContraction(details.address), " and return to this page. Confirmation should appear in a few minutes."] }), jsx(CopyToClipboard, { variant: "button", string: details.address, children: "Copy Address" }), jsx(CopyToClipboard, { variant: "left", string: details.amount, children: "Copy Amount" })] }))] })) }));
 };
 
 export { WaitingDepositAddress as default };

package/build/src/components/Pages/WaitingExternal/index.js

@@ -20,7 +20,7 @@ const WaitingExternal = () => {
                 orderId: daimoPayOrder.id.toString(),
             });
             if (found) {
-                setRoute(ROUTES.CONFIRMATION);
+                setRoute(ROUTES.CONFIRMATION, { event: "found-source-payment" });
             }
         };
         const interval = setInterval(checkForSourcePayment, 1000);

package/build/src/hooks/useDaimoPayStatus.js

@@ -1,10 +1,10 @@
-import { writeDaimoPayOrderID, DaimoPayOrderMode, DaimoPayIntentStatus, DaimoPayOrderStatusSource } from '@daimo/common';
+import { writeDaimoPayOrderID } from '@daimo/common';
 import { usePayContext } from '../components/DaimoPay.js';
 
 /** Returns the current payment, or undefined if there is none.
  *
  * Status values:
- * - `payment_pending` - the user has not paid yet
+ * - `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
@@ -17,20 +17,7 @@ function useDaimoPayStatus() {
         return undefined;
     const order = paymentState.daimoPayOrder;
     const paymentId = writeDaimoPayOrderID(order.id);
-    if (order.mode === DaimoPayOrderMode.HYDRATED) {
-        if (order.intentStatus !== DaimoPayIntentStatus.PENDING) {
-            if (order.intentStatus === DaimoPayIntentStatus.SUCCESSFUL) {
-                return { paymentId, status: "payment_completed" };
-            }
-            else {
-                return { paymentId, status: "payment_bounced" };
-            }
-        }
-        else if (order.sourceStatus !== DaimoPayOrderStatusSource.WAITING_PAYMENT) {
-            return { paymentId, status: "payment_started" };
-        }
-    }
-    return { paymentId, status: "payment_pending" };
+    return { paymentId, status: order.intentStatus };
 }
 
 export { useDaimoPayStatus };

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

@@ -1 +1 @@
-{"version":3,"file":"useDaimoPayStatus.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"useDaimoPayStatus.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,7 +4,6 @@ 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';
@@ -67,9 +66,9 @@ function usePaymentState({ trpc, daimoPayOrder, setDaimoPayOrder, setOpen, log,
     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,
@@ -78,7 +77,7 @@ function usePaymentState({ trpc, daimoPayOrder, setDaimoPayOrder, setOpen, log,
                 externalPaymentOption,
             });
         }
-        log(`[CHECKOUT] creating+hydrating new order ${order.id}`);
+        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({
@@ -88,6 +87,7 @@ function usePaymentState({ trpc, daimoPayOrder, setDaimoPayOrder, setOpen, log,
                 id: order.id.toString(),
                 toUnits,
                 metadata: order.metadata,
+                userMetadata: payParams.metadata,
                 isAmountEditable: isDepositFlow,
             },
             platform,
@@ -127,28 +127,29 @@ function usePaymentState({ trpc, daimoPayOrder, setDaimoPayOrder, setOpen, log,
             : 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;
     };
@@ -161,17 +162,22 @@ function usePaymentState({ trpc, daimoPayOrder, setDaimoPayOrder, setOpen, log,
         });
         // 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 = (usd) => {
-        log(`[CHECKOUT] Setting chosen USD amount to ${usd}`);
-        assert(!!daimoPayOrder);
+        assert(!!daimoPayOrder, "[SET CHOSEN USD] daimoPayOrder cannot be null");
         const token = daimoPayOrder.destFinalCallTokenAmount.token;
-        const tokenAmount = parseUnits((usd / 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: {
@@ -191,27 +197,25 @@ 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);
         setIsDepositFlow(payParams.toUnits == null);
         generatePreviewOrder(payParams);
     };
     const generatePreviewOrder = async (payParams) => {
-        const newPayId = generatePayId();
-        const newId = readDaimoPayOrderID(newPayId).toString();
         // 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({
-            id: newId,
+            appId: payParams.appId,
             toChain: payParams.toChain,
             toToken: payParams.toToken,
             toUnits,
@@ -227,13 +231,16 @@ function usePaymentState({ trpc, daimoPayOrder, setDaimoPayOrder, setOpen, log,
                     preferredTokens: payParams.preferredTokens,
                 },
             },
+            externalId: payParams.externalId,
+            userMetadata: payParams.metadata,
         });
+        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 {

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/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, supportedChainIds } 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,17 +1,10 @@
-import { writeDaimoPayOrderID } from '@daimo/common';
 import { getDAv2Chains } from '@daimo/contract';
-import { bytesToBigInt } from 'viem';
 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, supportedChainIds };
+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/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":";;;;;;;;;;;;;;;;;;;"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@daimo/pay",
   "private": false,
-  "version": "1.2.0",
+  "version": "1.3.1",
   "author": "Daimo",
   "homepage": "https://pay.daimo.com",
   "license": "BSD-2-Clause license",
@@ -40,8 +40,8 @@
     "crypto"
   ],
   "dependencies": {
-    "@daimo/common": "1.1.1",
-    "@daimo/contract": "1.1.1",
+    "@daimo/common": "1.3.1",
+    "@daimo/contract": "1.3.1",
     "@solana/wallet-adapter-base": "^0.9.23",
     "@solana/wallet-adapter-react": "^0.15.35",
     "@solana/web3.js": "^1.95.4",
@@ -79,4 +79,4 @@
     "rollup-plugin-visualizer": "^5.5.4",
     "typescript-plugin-styled-components": "^3.0.0"
   }
-}
+}

package/build/src/hooks/useModal.js

@@ -1,35 +0,0 @@
-import { usePayContext, ROUTES } from '../components/DaimoPay.js';
-import { useConnectCallback } from './useConnectCallback.js';
-
-/** Opens and closes the payment modal. */
-const useModal = ({ onConnect, onDisconnect } = {}) => {
-    const context = usePayContext();
-    useConnectCallback({
-        onConnect,
-        onDisconnect,
-    });
-    const close = () => {
-        context.setOpen(false);
-    };
-    const open = () => {
-        context.setOpen(true);
-    };
-    const gotoAndOpen = (route) => {
-        context.setRoute(route);
-        open();
-    };
-    return {
-        open: context.open,
-        setOpen: (show) => {
-            if (show) {
-                gotoAndOpen(ROUTES.SELECT_METHOD);
-            }
-            else {
-                close();
-            }
-        },
-    };
-};
-
-export { useModal };
-//# sourceMappingURL=useModal.js.map

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

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