@daimo/pay 0.3.5 → 0.3.7

package/build/index.es.js

@@ -5,7 +5,7 @@ import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
 import { detect } from 'detect-browser';
 import React, { useEffect, useState, useCallback, useRef, useLayoutEffect, useMemo, createContext, createElement } from 'react';
 import { Buffer } from 'buffer';
-import { readDaimoPayOrderID, assert, assertNotNull, DaimoPayOrderMode, DaimoPayOrderStatusDest, capitalize, ExternalPaymentOptions, getAddressContraction, getDisplayPrice, writeDaimoPayOrderID, DaimoPayOrderStatusSource } from '@daimo/common';
+import { readDaimoPayOrderID, assert, assertNotNull, DaimoPayOrderMode, DaimoPayOrderStatusDest, ExternalPaymentOptions, getAddressContraction, capitalize, getDisplayPrice, debugJson, writeDaimoPayOrderID, DaimoPayIntentStatus, DaimoPayOrderStatusSource } from '@daimo/common';
 import styled$1, { css, keyframes, ThemeProvider } from 'styled-components';
 import { erc20Abi, getChainName, ethereum, arbitrum as arbitrum$1, base as base$2, optimism as optimism$1, polygon as polygon$1, ethereumSepolia, baseSepolia as baseSepolia$1, getChainExplorerTxUrl } from '@daimo/contract';
 import { zeroAddress, parseUnits } from 'viem';
@@ -900,14 +900,17 @@ const trpc = createTRPCClient({
     ],
 });
 
-function getPaymentInfo() {
+function getPaymentInfo(setOpen, log) {
     // Wallet state.
     const { address: senderAddr } = useAccount();
     const { writeContractAsync } = useWriteContract();
     const { sendTransactionAsync } = useSendTransaction();
     // Daimo Pay order state.
-    const [daimoPayOrder, setDaimoPayOrder] = useState(null);
-    const [paymentWaitingMessage, setPaymentWaitingMessage] = useState(null);
+    const [daimoPayOrder, setDaimoPayOrder] = useState();
+    const [paymentWaitingMessage, setPaymentWaitingMessage] = useState();
+    // Payment UI config.
+    const [modalOptions, setModalOptions] = useState({});
+    // UI state. Selection for external payment (Binance, etc) vs wallet payment.
     const [selectedExternalOption, setSelectedExternalOption] = useState();
     const [selectedTokenOption, setSelectedTokenOption] = useState();
     const payWithToken = async (tokenAmount) => {
@@ -918,7 +921,7 @@ function getPaymentInfo() {
             platform: detectPlatform(window.navigator.userAgent),
             refundAddress: senderAddr,
         });
-        console.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}`);
         const txHash = await (async () => {
             try {
                 if (tokenAmount.token.token === zeroAddress) {
@@ -978,8 +981,9 @@ function getPaymentInfo() {
         });
         setDaimoPayOrder(order);
     }, [daimoPayOrder?.id]);
+    /** User picked a different deposit amount. */
     const setChosenUsd = (usdAmount) => {
-        console.log(`[CHECKOUT] Setting chosen USD amount to ${usdAmount}`);
+        log(`[CHECKOUT] Setting chosen USD amount to ${usdAmount}`);
         assert(!!daimoPayOrder);
         const token = daimoPayOrder.destFinalCallTokenAmount.token;
         const tokenAmount = parseUnits((usdAmount / token.usd).toString(), token.decimals);
@@ -1005,12 +1009,20 @@ function getPaymentInfo() {
             console.error(`[CHECKOUT] No order found for ${payId}`);
             return;
         }
-        console.log(`[CHECKOUT] Parsed order: ${JSON.stringify(order)}`);
+        log(`[CHECKOUT] Parsed order: ${JSON.stringify(order)}`);
         setDaimoPayOrder(order);
     }, [daimoPayOrder]);
+    const onSuccess = ({ txHash, txURL }) => {
+        if (modalOptions?.closeOnSuccess) {
+            log(`[CHECKOUT] transaction succeeded, closing: ${txHash} ${txURL}`);
+            setTimeout(() => setOpen(false), 1000);
+        }
+    };
     return {
         setPayId,
         daimoPayOrder,
+        modalOptions,
+        setModalOptions,
         paymentWaitingMessage,
         selectedExternalOption,
         selectedTokenOption,
@@ -1020,6 +1032,7 @@ function getPaymentInfo() {
         payWithToken,
         payWithExternal,
         refreshOrder,
+        onSuccess,
     };
 }
 
@@ -2164,7 +2177,7 @@ const ResetContainer = styled(motion.div) `
 `;
 
 var name = "@daimo/pay";
-var version = "0.3.5";
+var version = "0.3.7";
 var author = "Daimo";
 var homepage = "https://pay.daimo.com";
 var license = "BSD-2-Clause license";
@@ -2203,8 +2216,8 @@ var keywords = [
 	"crypto"
 ];
 var dependencies = {
-	"@daimo/common": "0.3.1",
-	"@daimo/contract": "0.3.1",
+	"@daimo/common": "0.3.6",
+	"@daimo/contract": "0.3.6",
 	"@trpc/client": "^11.0.0-next-beta.318",
 	"@trpc/server": "^11.0.0-next-beta.318",
 	buffer: "^6.0.3",
@@ -6609,6 +6622,7 @@ const ScrollAreaContainer = styled.div `
 
 const ArrowDown = () => (jsx("svg", { width: "11", height: "12", viewBox: "0 0 11 12", fill: "none", xmlns: "http://www.w3.org/2000/svg", children: jsx("path", { d: "M5.49438 1L5.49438 11M5.49438 11L9.5 7M5.49438 11L1.5 7", stroke: "currentColor", strokeWidth: "1.75", strokeLinecap: "round", strokeLinejoin: "round" }) }));
 const ScrollArea = ({ children, height, backgroundColor, mobileDirection, }) => {
+    const { log } = useContext();
     const ref = useRef(null);
     const moreRef = useRef(null);
     const isMobile = useIsMobile();
@@ -6622,7 +6636,7 @@ const ScrollArea = ({ children, height, backgroundColor, mobileDirection, }) =>
                 moreRef.current.classList.remove("hide");
             }
         }
-        console.log(`[SCROLL AREA]: ${el.scrollHeight}, ${el.clientHeight}`);
+        log(`[SCROLL AREA]: ${el.scrollHeight}, ${el.clientHeight}`);
         const handleScroll = (e) => {
             const { scrollTop, scrollHeight, clientHeight, scrollLeft, scrollWidth, clientWidth, } = e.target;
             if (moreRef.current) {
@@ -6959,6 +6973,7 @@ const InputField = styled(motion.input) `
   line-height: inherit;
   font-size: inherit;
   font-weight: inherit;
+  color: inherit;
   border: none;
   padding: 0;
   &:focus {
@@ -10036,24 +10051,27 @@ const Confirmation = () => {
         }, 300);
         return () => clearInterval(interval);
     }, [refreshOrder]);
-    const { done, txURL, currency } = (() => {
+    const { done, txURL } = (() => {
         if (daimoPayOrder && daimoPayOrder.mode === DaimoPayOrderMode.HYDRATED) {
-            if (daimoPayOrder.destStatus === DaimoPayOrderStatusDest.CLAIMED ||
-                daimoPayOrder.destStatus === DaimoPayOrderStatusDest.FAST_FINISHED) {
+            // Frontends are optimistic, assume submits will be successful
+            const { destStatus } = daimoPayOrder;
+            if (destStatus === DaimoPayOrderStatusDest.FAST_FINISH_SUBMITTED ||
+                destStatus === DaimoPayOrderStatusDest.FAST_FINISHED ||
+                destStatus === DaimoPayOrderStatusDest.CLAIM_SUCCESSFUL) {
                 const txHash = daimoPayOrder.destFastFinishTxHash ?? daimoPayOrder.destClaimTxHash;
                 const chainId = daimoPayOrder.destFinalCallTokenAmount.token.chainId;
-                const currency = `${capitalize(getChainName(chainId))} ${daimoPayOrder.destFinalCallTokenAmount.token.symbol}`;
+                assert(txHash != null, `Dest ${destStatus}, but missing txHash`);
+                const txURL = getChainExplorerTxUrl(chainId, txHash);
+                paymentInfo.onSuccess({ txHash, txURL });
                 return {
                     done: true,
-                    txURL: txHash ? getChainExplorerTxUrl(chainId, txHash) : undefined,
-                    currency,
+                    txURL,
                 };
             }
         }
         return {
             done: false,
             txURL: undefined,
-            currency: undefined,
         };
     })();
     return (jsx(PageContent, { style: {
@@ -10065,7 +10083,7 @@ const Confirmation = () => {
                 justifyContent: "center",
                 alignItems: "center",
                 paddingBottom: 0,
-            }, children: [jsx(AnimationContainer$2, { children: jsxs(InsetContainer, { children: [jsx(Spinner, { "$status": done }), jsx(SuccessIcon, { "$status": done })] }) }), !done ? (jsx(ModalH1, { children: "Confirming..." })) : (jsx(ModalH1, { children: jsxs(Link, { href: txURL, target: "_blank", rel: "noopener noreferrer", children: ["Payment completed in ", currency] }) })), jsx(PoweredByFooter, {})] }) }));
+            }, children: [jsx(AnimationContainer$2, { children: jsxs(InsetContainer, { children: [jsx(Spinner, { "$status": done }), jsx(SuccessIcon, { "$status": done })] }) }), !done ? (jsx(ModalH1, { children: "Confirming..." })) : (jsx(ModalH1, { children: jsx(Link, { href: txURL, target: "_blank", rel: "noopener noreferrer", children: "Payment completed" }) })), jsx(PoweredByFooter, {})] }) }));
 };
 const AnimationContainer$2 = styled(motion.div) `
   position: relative;
@@ -10131,7 +10149,7 @@ var PayState;
     PayState["RequestSuccessful"] = "Payment Successful";
 })(PayState || (PayState = {}));
 const PayWithToken = () => {
-    const { triggerResize, paymentInfo, setRoute } = useContext();
+    const { triggerResize, paymentInfo, setRoute, log } = useContext();
     const { selectedTokenOption, payWithToken } = paymentInfo;
     const [payState, setPayState] = useState(PayState.RequestingPayment);
     const walletChainId = useChainId();
@@ -10160,7 +10178,7 @@ const PayWithToken = () => {
         setPayState(PayState.SwitchingChain);
         const switchChain = await trySwitchingChain(option);
         if (!switchChain) {
-            console.log("Switching chain failed");
+            console.error("Switching chain failed");
             setPayState(PayState.RequestCancelled);
             return;
         }
@@ -10176,7 +10194,7 @@ const PayWithToken = () => {
             if (e?.name === "ConnectorChainMismatchError") {
                 // Workaround for Rainbow wallet bug -- user is able to switch chain without
                 // the wallet updating the chain ID for wagmi.
-                console.log("Chain mismatch detected, attempting to switch and retry");
+                log("Chain mismatch detected, attempting to switch and retry");
                 const switchSuccessful = await trySwitchingChain(option, true);
                 if (switchSuccessful) {
                     try {
@@ -10434,10 +10452,10 @@ const OptionsContainer = styled.div `
 `;
 
 const OptionsList = ({ options, isLoading, requiredSkeletons, }) => {
-    const { triggerResize } = useContext();
+    const { triggerResize, log } = useContext();
     const optionsLength = options.length;
     useEffect(() => {
-        console.log(`[OPTIONS RESIZE]: ${optionsLength}, triggering resize`);
+        log(`[OPTIONS RESIZE]: ${optionsLength}, triggering resize`);
         if (optionsLength > 0) {
             triggerResize();
         }
@@ -10649,6 +10667,7 @@ const SelectToken = () => {
     useEffect(() => {
         if (!payerAddress || !daimoPayOrder)
             return;
+        setPaymentOptions(null);
         setIsLoadingOptions(true);
         const destChainId = daimoPayOrder.destFinalCallTokenAmount.token.chainId;
         trpc.getWalletPaymentOptions
@@ -10666,7 +10685,7 @@ const SelectToken = () => {
                     justifyContent: "center",
                     paddingTop: 16,
                     paddingBottom: 16,
-                }, children: [jsx(ModalH1, { children: "Insufficient balance. Please select an alternative payment method." }), jsx(Button, { onClick: () => setRoute(ROUTES.SELECT_METHOD), children: "Select another method" })] })), jsx(OptionsList, { requiredSkeletons: 4, isLoading: isLoadingOptions, options: paymentOptions?.map((option) => {
+                }, children: [jsx(ModalH1, { children: "Insufficient balance. Please select an alternative payment method." }), jsx(Button, { onClick: () => setRoute(ROUTES.SELECT_METHOD), children: "Select Another Method" })] })), jsx(OptionsList, { requiredSkeletons: 4, isLoading: isLoadingOptions, options: paymentOptions?.map((option) => {
                     const capitalizedChainName = capitalize(getChainName(option.required.token.chainId));
                     const title = `${getDisplayPrice(option.required)} ${option.required.token.symbol} on ${capitalizedChainName}`;
                     const subtitle = `Balance: ${getDisplayPrice(option.balance)} ${option.balance.token.symbol}`;
@@ -10688,6 +10707,7 @@ const SelectToken = () => {
 const WaitingOther = () => {
     const { triggerResize, paymentInfo, setRoute } = useContext();
     const { selectedExternalOption, payWithExternal, paymentWaitingMessage, daimoPayOrder, } = paymentInfo;
+    const [externalURL, setExternalURL] = useState(null);
     useEffect(() => {
         const checkForSourcePayment = async () => {
             if (!daimoPayOrder)
@@ -10702,6 +10722,20 @@ const WaitingOther = () => {
         const interval = setInterval(checkForSourcePayment, 1000);
         return () => clearInterval(interval);
     }, [daimoPayOrder?.id]);
+    useEffect(() => {
+        if (!selectedExternalOption)
+            return;
+        payWithExternal(selectedExternalOption.id).then((url) => {
+            setExternalURL(url);
+            setTimeout(() => {
+                window.open(url, "_blank");
+            });
+        });
+    }, [selectedExternalOption]);
+    const waitingMessageLength = paymentWaitingMessage?.length;
+    useEffect(() => {
+        triggerResize();
+    }, [waitingMessageLength, externalURL]);
     if (!selectedExternalOption) {
         return jsx(PageContent, {});
     }
@@ -10713,23 +10747,10 @@ const WaitingOther = () => {
             return (jsx(SquircleSpinner, { logo: jsx("img", { src: selectedExternalOption.logoURI }), connecting: true }));
         }
     })();
-    useEffect(() => {
-        if (!selectedExternalOption)
-            return;
-        // Note: Safari doesn't support window.open in an async function.
-        // We need to trigger this in the main thread:
-        // https://stackoverflow.com/a/39387533
-        const windowOpen = window.open("about:blank", "_blank");
-        payWithExternal(selectedExternalOption.id).then((url) => {
-            if (windowOpen)
-                windowOpen.location.href = url;
-        });
-    }, [selectedExternalOption]);
-    const waitingMessageLength = paymentWaitingMessage?.length;
-    useEffect(() => {
-        triggerResize();
-    }, [waitingMessageLength]);
-    return (jsxs(PageContent, { children: [jsx(LoadingContainer, { children: jsx(AnimationContainer, { "$circle": selectedExternalOption.logoShape === "circle", children: jsx(AnimatePresence, { children: optionSpinner }) }) }), jsxs(ModalContent, { style: { marginLeft: 24, marginRight: 24 }, children: [jsx(ModalH1, { children: "Waiting for Payment" }), paymentWaitingMessage && (jsx(ModalBody, { style: { marginTop: 12 }, children: paymentWaitingMessage }))] })] }));
+    return (jsxs(PageContent, { children: [jsx(LoadingContainer, { children: jsx(AnimationContainer, { "$circle": selectedExternalOption.logoShape === "circle", children: jsx(AnimatePresence, { children: optionSpinner }) }) }), jsxs(ModalContent, { style: { marginLeft: 24, marginRight: 24 }, children: [jsx(ModalH1, { children: "Waiting for Payment" }), paymentWaitingMessage && (jsx(ModalBody, { style: { marginTop: 12, marginBottom: 12 }, children: paymentWaitingMessage })), jsx(Button, { icon: jsx(ExternalLinkIcon, {}), onClick: () => {
+                            if (externalURL)
+                                window.open(externalURL, "_blank");
+                        }, children: "Open in New Tab" })] })] }));
 };
 const LoadingContainer = styled(motion.div) `
   display: flex;
@@ -10759,7 +10780,7 @@ const AnimationContainer = styled(motion.div) `
 `;
 
 const customThemeDefault = {};
-const ConnectModal = ({ mode = "auto", theme = "auto", customTheme = customThemeDefault, lang = "en-US", }) => {
+const DaimoPayModal = ({ mode = "auto", theme = "auto", customTheme = customThemeDefault, lang = "en-US", }) => {
     const context = useContext();
     const { setSelectedExternalOption, setSelectedTokenOption } = context.paymentInfo;
     const { isConnected, chain } = useAccount();
@@ -10820,7 +10841,9 @@ const ConnectModal = ({ mode = "auto", theme = "auto", customTheme = customTheme
         context.setOpen(false);
     }
     useEffect(() => {
-        if (context.route === ROUTES.CONNECT || context.route === ROUTES.CONNECTORS || context.route === ROUTES.MOBILECONNECTORS) {
+        if (context.route === ROUTES.CONNECT ||
+            context.route === ROUTES.CONNECTORS ||
+            context.route === ROUTES.MOBILECONNECTORS) {
             if (isConnected) {
                 context.setRoute(ROUTES.SELECT_TOKEN);
             }
@@ -10915,6 +10938,7 @@ const DaimoPayProvider = ({ children, theme = "auto", mode = "auto", customTheme
         enforceSupportedChains: false,
         ethereumOnboardingUrl: undefined,
         walletOnboardingUrl: undefined,
+        overlayBlur: undefined,
     };
     const opts = Object.assign({}, defaultOptions, options);
     if (typeof window !== "undefined") {
@@ -10963,9 +10987,11 @@ const DaimoPayProvider = ({ children, theme = "auto", mode = "auto", customTheme
         }
     }, [injectedConnector]);
     const log = debugMode ? console.log : () => { };
-    const paymentInfo = getPaymentInfo();
-    const loadPayment = async (payId) => {
+    const paymentInfo = getPaymentInfo(setOpen, log);
+    const loadAndShowPayment = async (payId, modalOptions) => {
+        log(`[PAY] showing order ${payId}, options ${debugJson(modalOptions)}`);
         await paymentInfo.setPayId(payId);
+        paymentInfo.setModalOptions(modalOptions);
         const daimoPayOrder = paymentInfo.daimoPayOrder;
         if (daimoPayOrder &&
             daimoPayOrder.mode === DaimoPayOrderMode.HYDRATED &&
@@ -10975,6 +11001,7 @@ const DaimoPayProvider = ({ children, theme = "auto", mode = "auto", customTheme
         else {
             setRoute(ROUTES.SELECT_METHOD);
         }
+        setOpen(true);
     };
     const value = {
         theme: ckTheme,
@@ -10989,7 +11016,7 @@ const DaimoPayProvider = ({ children, theme = "auto", mode = "auto", customTheme
         setOpen,
         route,
         setRoute,
-        loadPayment,
+        loadAndShowPayment,
         connector,
         setConnector,
         onConnect,
@@ -11010,7 +11037,7 @@ const DaimoPayProvider = ({ children, theme = "auto", mode = "auto", customTheme
         triggerResize: () => onResize((prev) => prev + 1),
         paymentInfo,
     };
-    return createElement(Context.Provider, { value }, jsx(Web3ContextProvider, { enabled: open, children: jsxs(ThemeProvider, { theme: defaultTheme$1, children: [children, jsx(ConnectModal, { lang: ckLang, theme: ckTheme, mode: mode, customTheme: ckCustomTheme })] }) }));
+    return createElement(Context.Provider, { value }, jsx(Web3ContextProvider, { enabled: open, children: jsxs(ThemeProvider, { theme: defaultTheme$1, children: [children, jsx(DaimoPayModal, { lang: ckLang, theme: ckTheme, mode: mode, customTheme: ckCustomTheme })] }) }));
 };
 const useContext = () => {
     const context = React.useContext(Context);
@@ -11019,41 +11046,6 @@ const useContext = () => {
     return context;
 };
 
-const useModal = ({ onConnect, onDisconnect } = {}) => {
-    const context = useContext();
-    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();
-            }
-        },
-        // Disconnected Routes
-        openAbout: () => gotoAndOpen(ROUTES.ABOUT),
-        openOnboarding: () => gotoAndOpen(ROUTES.ONBOARDING),
-        // Connected Routes
-        openProfile: () => gotoAndOpen(ROUTES.PROFILE),
-        openSwitchNetworks: () => gotoAndOpen(ROUTES.SWITCHNETWORKS),
-    };
-};
-
 const TextContainer = styled(motion.div) `
   top: 0;
   bottom: 0;
@@ -11290,28 +11282,23 @@ const contentVariants = {
         },
     },
 };
-const DaimoPayButtonRenderer = ({ payId, children, }) => {
+const DaimoPayButtonRenderer = ({ payId, closeOnSuccess, children, }) => {
     const isMounted = useIsMounted();
     const context = useContext();
-    const { open, setOpen } = useModal();
-    const { address, isConnected, chain } = useAccount();
+    const { address, chain } = useAccount();
     const isChainSupported = useChainIsSupported(chain?.id);
     const { data: ensName } = useEnsName({
         chainId: 1,
         address: address,
     });
-    function hide() {
-        setOpen(false);
-    }
     // Pre-load payment info in background.
     const { setPayId } = context.paymentInfo;
     useEffect(() => {
         setPayId(payId);
     }, [payId]);
-    async function show() {
-        await context.loadPayment(payId); // ensure payment info is loaded before opening.
-        context.setOpen(true);
-    }
+    const hide = () => context.setOpen(false);
+    const modalOptions = { closeOnSuccess };
+    const show = () => context.loadAndShowPayment(payId, modalOptions);
     if (!children)
         return null;
     if (!isMounted)
@@ -11323,7 +11310,7 @@ const DaimoPayButtonRenderer = ({ payId, children, }) => {
             chain: chain,
             unsupported: !isChainSupported,
             isConnected: !!address,
-            isConnecting: open, // Using `open` to determine if connecting as wagmi isConnecting only is set to true when an active connector is awaiting connection
+            isConnecting: context.open,
             address: address,
             truncatedAddress: address ? truncateEthAddress(address) : undefined,
             ensName: ensName?.toString(),
@@ -11332,17 +11319,12 @@ const DaimoPayButtonRenderer = ({ payId, children, }) => {
 DaimoPayButtonRenderer.displayName = "DaimoPayButton.Custom";
 function DaimoPayButtonInner() {
     const { paymentInfo } = useContext();
-    const label = paymentInfo?.daimoPayOrder?.metadata.intent ?? "Pay";
+    const label = paymentInfo?.daimoPayOrder?.metadata?.intent ?? "Pay";
     return (jsx(AnimatePresence, { initial: false, children: jsx(TextContainer, { initial: "initial", animate: "animate", exit: "exit", variants: contentVariants, style: {
                 height: 40,
-                //padding: '0 5px',
             }, children: label }, "connectWalletText") }));
 }
-function DaimoPayButton({ payId, 
-// Theming
-theme, mode, customTheme, 
-// Events
-onClick, }) {
+function DaimoPayButton({ payId, theme, mode, customTheme, closeOnSuccess, onClick, }) {
     const isMounted = useIsMounted();
     const context = useContext();
     // Pre-load payment info in background.
@@ -11350,10 +11332,8 @@ onClick, }) {
     useEffect(() => {
         setPayId(payId);
     }, [payId]);
-    async function show() {
-        await context.loadPayment(payId); // ensure payment info is loaded
-        context.setOpen(true);
-    }
+    const modalOptions = { closeOnSuccess };
+    const show = () => context.loadAndShowPayment(payId, modalOptions);
     if (!isMounted)
         return null;
     return (jsx(ResetContainer, { "$useTheme": theme ?? context.theme, "$useMode": mode ?? context.mode, "$customTheme": customTheme ?? context.customTheme, children: jsx(ThemeContainer, { onClick: () => {
@@ -11367,6 +11347,41 @@ onClick, }) {
 }
 DaimoPayButton.Custom = DaimoPayButtonRenderer;
 
+const useModal = ({ onConnect, onDisconnect } = {}) => {
+    const context = useContext();
+    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();
+            }
+        },
+        // Disconnected Routes
+        openAbout: () => gotoAndOpen(ROUTES.ABOUT),
+        openOnboarding: () => gotoAndOpen(ROUTES.ONBOARDING),
+        // Connected Routes
+        openProfile: () => gotoAndOpen(ROUTES.PROFILE),
+        openSwitchNetworks: () => gotoAndOpen(ROUTES.SWITCHNETWORKS),
+    };
+};
+
 function useDaimoPayStatus() {
     const { paymentInfo } = useContext();
     const status = (() => {
@@ -11375,9 +11390,11 @@ function useDaimoPayStatus() {
         const order = paymentInfo.daimoPayOrder;
         const paymentId = writeDaimoPayOrderID(order.id);
         if (order.mode === DaimoPayOrderMode.HYDRATED) {
-            if (order.destStatus === DaimoPayOrderStatusDest.FAST_FINISHED || order.destStatus === DaimoPayOrderStatusDest.CLAIMED) {
+            if (order.intentStatus != DaimoPayIntentStatus.PENDING) {
                 return {
-                    status: "payment_completed",
+                    status: order.intentStatus === DaimoPayIntentStatus.SUCCESSFUL
+                        ? "payment_completed"
+                        : "payment_bounced",
                     paymentId,
                 };
             }

package/build/index.es.js.map

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

package/build/packages/paykit/packages/connectkit/src/assets/chains.d.ts

@@ -7,7 +7,7 @@ export declare const Optimism: ({ testnet, ...props }: Logo) => import("react/js
 export declare const Arbitrum: ({ testnet, ...props }: Logo) => import("react/jsx-runtime").JSX.Element;
 export declare const Telos: ({ testnet, ...props }: Logo) => import("react/jsx-runtime").JSX.Element;
 export declare const Base: ({ testnet, ...props }: {
-    testnet?: boolean | undefined;
+    testnet?: boolean;
 }) => import("react/jsx-runtime").JSX.Element;
 export declare const chainToLogo: {
     [x: number]: import("react/jsx-runtime").JSX.Element;
@@ -15,30 +15,30 @@ export declare const chainToLogo: {
 declare const _default: {
     UnknownChain: ({ testnet, ...props }: Logo) => import("react/jsx-runtime").JSX.Element;
     Base: ({ testnet, ...props }: {
-        testnet?: boolean | undefined;
+        testnet?: boolean;
     }) => import("react/jsx-runtime").JSX.Element;
     Ethereum: ({ testnet, ...props }: Logo) => import("react/jsx-runtime").JSX.Element;
     Polygon: ({ testnet, ...props }: Logo) => import("react/jsx-runtime").JSX.Element;
     Optimism: ({ testnet, ...props }: Logo) => import("react/jsx-runtime").JSX.Element;
     Arbitrum: ({ testnet, ...props }: Logo) => import("react/jsx-runtime").JSX.Element;
     Aurora: ({ testnet, ...props }: {
-        testnet?: boolean | undefined;
+        testnet?: boolean;
     }) => import("react/jsx-runtime").JSX.Element;
     Avalanche: ({ testnet, ...props }: {
-        testnet?: boolean | undefined;
+        testnet?: boolean;
     }) => import("react/jsx-runtime").JSX.Element;
     Celo: ({ testnet, ...props }: {
-        testnet?: boolean | undefined;
+        testnet?: boolean;
     }) => import("react/jsx-runtime").JSX.Element;
     Telos: ({ testnet, ...props }: Logo) => import("react/jsx-runtime").JSX.Element;
     Gnosis: ({ testnet, ...props }: {
-        testnet?: boolean | undefined;
+        testnet?: boolean;
     }) => import("react/jsx-runtime").JSX.Element;
     Evmos: ({ testnet, ...props }: {
-        testnet?: boolean | undefined;
+        testnet?: boolean;
     }) => import("react/jsx-runtime").JSX.Element;
     BinanceSmartChain: ({ testnet, ...props }: {
-        testnet?: boolean | undefined;
+        testnet?: boolean;
     }) => import("react/jsx-runtime").JSX.Element;
     Foundry: ({ testnet, ...props }: Logo) => import("react/jsx-runtime").JSX.Element;
     Sepolia: ({ testnet, ...props }: Logo) => import("react/jsx-runtime").JSX.Element;
@@ -46,22 +46,22 @@ declare const _default: {
     zkSync: ({ testnet, ...props }: Logo) => import("react/jsx-runtime").JSX.Element;
     Flare: ({ testnet, ...props }: Logo) => import("react/jsx-runtime").JSX.Element;
     Canto: ({ testnet, ...props }: {
-        testnet?: boolean | undefined;
+        testnet?: boolean;
     }) => import("react/jsx-runtime").JSX.Element;
     Fantom: ({ testnet, ...props }: {
-        testnet?: boolean | undefined;
+        testnet?: boolean;
     }) => import("react/jsx-runtime").JSX.Element;
     Filecoin: ({ testnet, ...props }: {
-        testnet?: boolean | undefined;
+        testnet?: boolean;
     }) => import("react/jsx-runtime").JSX.Element;
     Metis: ({ testnet, ...props }: {
-        testnet?: boolean | undefined;
+        testnet?: boolean;
     }) => import("react/jsx-runtime").JSX.Element;
     IoTeX: ({ testnet, ...props }: {
-        testnet?: boolean | undefined;
+        testnet?: boolean;
     }) => import("react/jsx-runtime").JSX.Element;
     Zora: ({ testnet, ...props }: {
-        testnet?: boolean | undefined;
+        testnet?: boolean;
     }) => import("react/jsx-runtime").JSX.Element;
 };
 export default _default;

package/build/packages/paykit/packages/connectkit/src/components/Common/Alert/types.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 export type AlertProps = {
     children?: React.ReactNode;
     icon?: React.ReactNode;

package/build/packages/paykit/packages/connectkit/src/components/Common/ChainSelectList/index.d.ts

@@ -1,4 +1,4 @@
 declare const ChainSelectList: ({ variant, }: {
-    variant?: "primary" | "secondary" | undefined;
+    variant?: "primary" | "secondary";
 }) => import("react/jsx-runtime").JSX.Element;
 export default ChainSelectList;

package/build/packages/paykit/packages/connectkit/src/components/Common/CopyToClipboard/CopyToClipboardIcon.d.ts

@@ -1,5 +1,5 @@
 declare const CopyToClipboardIcon: ({ copied, small, }: {
-    copied?: boolean | undefined;
-    small?: boolean | undefined;
+    copied?: boolean;
+    small?: boolean;
 }) => import("react/jsx-runtime").JSX.Element;
 export default CopyToClipboardIcon;

package/build/packages/paykit/packages/connectkit/src/components/Common/OptionsList/index.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 interface Option {
     id: string;
     title: string;
@@ -8,7 +7,7 @@ interface Option {
 }
 declare const OptionsList: ({ options, isLoading, requiredSkeletons, }: {
     options: Option[];
-    isLoading?: boolean | undefined;
-    requiredSkeletons?: number | undefined;
+    isLoading?: boolean;
+    requiredSkeletons?: number;
 }) => import("react/jsx-runtime").JSX.Element;
 export default OptionsList;

package/build/packages/paykit/packages/connectkit/src/components/Common/OrderHeader/index.d.ts

@@ -1,3 +1,3 @@
 export declare const OrderHeader: ({ minified }: {
-    minified?: boolean | undefined;
+    minified?: boolean;
 }) => import("react/jsx-runtime").JSX.Element;

package/build/packages/paykit/packages/connectkit/src/components/Common/Portal/index.d.ts

@@ -1,3 +1,2 @@
-/// <reference types="react" />
 declare const Portal: (props: any) => import("react").ReactPortal | null;
 export default Portal;

package/build/packages/paykit/packages/connectkit/src/components/Common/ScrollArea/index.d.ts

@@ -1,7 +1,7 @@
 import React from "react";
 export declare const ScrollArea: ({ children, height, backgroundColor, mobileDirection, }: {
     children: React.ReactNode;
-    height?: number | undefined;
-    backgroundColor?: string | undefined;
-    mobileDirection?: "horizontal" | "vertical" | undefined;
+    height?: number;
+    backgroundColor?: string;
+    mobileDirection?: "horizontal" | "vertical";
 }) => import("react/jsx-runtime").JSX.Element;

package/build/packages/paykit/packages/connectkit/src/components/Common/Tooltip/types.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 export type TooltipSizeProps = "small" | "large";
 export type TooltipProps = {
     message?: string | React.ReactNode;

package/build/packages/paykit/packages/connectkit/src/components/ConnectModal/index.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 import { CustomTheme, Languages, Mode, Theme } from "../../types";
 declare const ConnectModal: React.FC<{
     mode?: Mode;

package/build/packages/paykit/packages/connectkit/src/components/DaimoPay.d.ts

@@ -1,5 +1,5 @@
-import React, { ReactNode } from "react";
-import { CustomAvatarProps, CustomTheme, Languages, Mode, Theme } from "../types";
+import React from "react";
+import { CustomTheme, DaimoPayContextOptions, DaimoPayModalOptions, Languages, Mode, Theme } from "../types";
 import { useConnectCallbackProps } from "../hooks/useConnectCallback";
 import { PaymentInfo } from "../utils/getPaymentInfo";
 export declare enum ROUTES {
@@ -34,47 +34,28 @@ type ContextValue = {
     setOpen: React.Dispatch<React.SetStateAction<boolean>>;
     route: string;
     setRoute: React.Dispatch<React.SetStateAction<ROUTES>>;
-    loadPayment: (payId: string) => Promise<void>;
     connector: Connector;
     setConnector: React.Dispatch<React.SetStateAction<Connector>>;
     errorMessage: Error;
-    options?: DaimoPayOptions;
     debugMode?: boolean;
     log: (...props: any) => void;
     displayError: (message: string | React.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;
 } & useConnectCallbackProps;
 export declare const Context: React.Context<ContextValue | null>;
-export type DaimoPayOptions = {
-    language?: Languages;
-    hideBalance?: boolean;
-    hideTooltips?: boolean;
-    hideQuestionMarkCTA?: boolean;
-    hideNoWalletCTA?: boolean;
-    hideRecentBadge?: boolean;
-    walletConnectCTA?: "link" | "modal" | "both";
-    avoidLayoutShift?: boolean;
-    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;
-    overlayBlur?: number;
-};
 type DaimoPayProviderProps = {
     children?: React.ReactNode;
     theme?: Theme;
     mode?: Mode;
     customTheme?: CustomTheme;
-    options?: DaimoPayOptions;
+    options?: DaimoPayContextOptions;
     debugMode?: boolean;
 } & useConnectCallbackProps;
 export declare const DaimoPayProvider: ({ children, theme, mode, customTheme, options, onConnect, onDisconnect, debugMode, }: DaimoPayProviderProps) => React.FunctionComponentElement<React.ProviderProps<ContextValue | null>>;

package/build/packages/paykit/packages/connectkit/src/components/DaimoPayButton/index.d.ts

@@ -3,7 +3,11 @@ import { Chain } from "viem";
 import { CustomTheme, Mode, Theme } from "../../types";
 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;
@@ -20,13 +24,20 @@ type DaimoPayButtonRendererProps = {
     }) => React.ReactNode;
 };
 type DaimoPayButtonProps = {
+    /** The payment ID, generated via the Daimo Pay API. */
     payId: string;
-    theme?: Theme;
+    /** 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;
 };
-export declare function DaimoPayButton({ payId, theme, mode, customTheme, onClick, }: DaimoPayButtonProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function DaimoPayButton({ payId, theme, mode, customTheme, closeOnSuccess, onClick, }: DaimoPayButtonProps): import("react/jsx-runtime").JSX.Element | null;
 export declare namespace DaimoPayButton {
     var Custom: React.FC<DaimoPayButtonRendererProps>;
 }

package/build/packages/paykit/packages/connectkit/src/components/DaimoPayModal/ConnectUsing.d.ts

@@ -0,0 +1,2 @@
+declare const ConnectUsing: () => import("react/jsx-runtime").JSX.Element;
+export default ConnectUsing;

package/build/packages/paykit/packages/connectkit/src/components/DaimoPayModal/ConnectWithInjector/index.d.ts

@@ -0,0 +1,15 @@
+import React from "react";
+export declare const states: {
+    CONNECTED: string;
+    CONNECTING: string;
+    EXPIRING: string;
+    FAILED: string;
+    REJECTED: string;
+    NOTCONNECTED: string;
+    UNAVAILABLE: string;
+};
+declare const ConnectWithInjector: React.FC<{
+    switchConnectMethod: (id?: string) => void;
+    forceState?: typeof states;
+}>;
+export default ConnectWithInjector;

package/build/packages/paykit/packages/connectkit/src/components/DaimoPayModal/ConnectWithInjector/styles.d.ts

@@ -0,0 +1,6 @@
+export declare const Content: any;
+export declare const Container: any;
+export declare const ConnectingContainer: any;
+export declare const ConnectingAnimation: any;
+export declare const RetryButton: any;
+export declare const RetryIconContainer: any;

package/build/packages/paykit/packages/connectkit/src/components/DaimoPayModal/ConnectWithQRCode.d.ts

@@ -0,0 +1,5 @@
+import React from "react";
+declare const ConnectWithQRCode: React.FC<{
+    switchConnectMethod: (id?: string) => void;
+}>;
+export default ConnectWithQRCode;

package/build/packages/paykit/packages/connectkit/src/components/DaimoPayModal/index.d.ts

@@ -0,0 +1,7 @@
+import { CustomTheme, Languages, Mode, Theme } from "../../types";
+export declare const DaimoPayModal: React.FC<{
+    mode?: Mode;
+    theme?: Theme;
+    customTheme?: CustomTheme;
+    lang?: Languages;
+}>;

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

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

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

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

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

@@ -18,7 +18,7 @@ type Web3Context = {
 };
 declare const Web3Context: React.Context<Web3Context>;
 export declare const Web3ContextProvider: ({ enabled, children, }: {
-    enabled?: boolean | undefined;
+    enabled?: boolean;
     children: React.ReactNode;
 }) => import("react/jsx-runtime").JSX.Element;
 export declare const useWeb3: () => Web3Context;

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

@@ -20,12 +20,12 @@ export declare function useConnect({ ...props }?: UseConnectParameters): {
     submittedAt: number;
     connect: ({ connector, chainId, mutation, }: {
         connector: CreateConnectorFn | Connector;
-        chainId?: number | undefined;
+        chainId?: number;
         mutation?: UseConnectParameters["mutation"];
     }) => void;
     connectAsync: ({ connector, chainId, mutation, }: {
         connector: CreateConnectorFn | Connector;
-        chainId?: number | undefined;
+        chainId?: number;
         mutation?: UseConnectParameters["mutation"];
     }) => Promise<import("wagmi/query").ConnectData<import("wagmi").Config>>;
     connectors: readonly Connector[];
@@ -33,7 +33,7 @@ export declare function useConnect({ ...props }?: UseConnectParameters): {
     data: undefined;
     variables: {
         chainId?: number | undefined;
-        connector: CreateConnectorFn | Connector;
+        connector: Connector | CreateConnectorFn;
     };
     error: null;
     isError: false;
@@ -49,12 +49,12 @@ export declare function useConnect({ ...props }?: UseConnectParameters): {
     submittedAt: number;
     connect: ({ connector, chainId, mutation, }: {
         connector: CreateConnectorFn | Connector;
-        chainId?: number | undefined;
+        chainId?: number;
         mutation?: UseConnectParameters["mutation"];
     }) => void;
     connectAsync: ({ connector, chainId, mutation, }: {
         connector: CreateConnectorFn | Connector;
-        chainId?: number | undefined;
+        chainId?: number;
         mutation?: UseConnectParameters["mutation"];
     }) => Promise<import("wagmi/query").ConnectData<import("wagmi").Config>>;
     connectors: readonly Connector[];
@@ -62,7 +62,7 @@ export declare function useConnect({ ...props }?: UseConnectParameters): {
     data: undefined;
     variables: {
         chainId?: number | undefined;
-        connector: CreateConnectorFn | Connector;
+        connector: Connector | CreateConnectorFn;
     };
     error: import("@wagmi/core").ConnectErrorType;
     isError: true;
@@ -78,12 +78,12 @@ export declare function useConnect({ ...props }?: UseConnectParameters): {
     submittedAt: number;
     connect: ({ connector, chainId, mutation, }: {
         connector: CreateConnectorFn | Connector;
-        chainId?: number | undefined;
+        chainId?: number;
         mutation?: UseConnectParameters["mutation"];
     }) => void;
     connectAsync: ({ connector, chainId, mutation, }: {
         connector: CreateConnectorFn | Connector;
-        chainId?: number | undefined;
+        chainId?: number;
         mutation?: UseConnectParameters["mutation"];
     }) => Promise<import("wagmi/query").ConnectData<import("wagmi").Config>>;
     connectors: readonly Connector[];
@@ -91,7 +91,7 @@ export declare function useConnect({ ...props }?: UseConnectParameters): {
     data: import("wagmi/query").ConnectData<import("wagmi").Config>;
     variables: {
         chainId?: number | undefined;
-        connector: CreateConnectorFn | Connector;
+        connector: Connector | CreateConnectorFn;
     };
     error: null;
     isError: false;
@@ -107,12 +107,12 @@ export declare function useConnect({ ...props }?: UseConnectParameters): {
     submittedAt: number;
     connect: ({ connector, chainId, mutation, }: {
         connector: CreateConnectorFn | Connector;
-        chainId?: number | undefined;
+        chainId?: number;
         mutation?: UseConnectParameters["mutation"];
     }) => void;
     connectAsync: ({ connector, chainId, mutation, }: {
         connector: CreateConnectorFn | Connector;
-        chainId?: number | undefined;
+        chainId?: number;
         mutation?: UseConnectParameters["mutation"];
     }) => Promise<import("wagmi/query").ConnectData<import("wagmi").Config>>;
     connectors: readonly Connector[];

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

@@ -1,10 +1,4 @@
 export declare function useDaimoPayStatus(): {
-    status: "payment_completed";
-    paymentId: string;
-} | {
-    status: "payment_started";
-    paymentId: string;
-} | {
-    status: "payment_pending";
+    status: string;
     paymentId: string;
 } | undefined;

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

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 export type TLogLevel = "debug" | "info" | "warn" | "error" | "none";
 export type TOptions = {
     logLevel?: TLogLevel;

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

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

package/build/packages/paykit/packages/connectkit/src/types.d.ts

@@ -1,3 +1,5 @@
+import { ReactNode } from "react";
+import { CustomAvatarProps } from "./components/Common/Avatar";
 import { Languages as Lang } from "./localizations";
 export type Languages = Lang;
 export type Theme = "auto" | "web95" | "retro" | "soft" | "midnight" | "minimal" | "rounded" | "nouns";
@@ -9,5 +11,34 @@ export type All = {
     customTheme?: CustomTheme;
     lang?: Languages;
 };
-export type { CustomAvatarProps } from "./components/Common/Avatar";
-export type { DaimoPayOptions } from "./components/DaimoPay";
+export type { CustomAvatarProps };
+/** Global options, across all pay buttons and payments. */
+export 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. */
+export type DaimoPayModalOptions = {
+    closeOnSuccess?: boolean;
+};

package/build/packages/paykit/packages/connectkit/src/utils/getPaymentInfo.d.ts

@@ -1,12 +1,17 @@
-/// <reference types="react" />
 import { DaimoPayOrder, DaimoPayTokenAmount, ExternalPaymentOptionMetadata, ExternalPaymentOptions } from "@daimo/common";
+import { DaimoPayModalOptions } from "../types";
 import { trpc } from "./trpc";
-export type SourcePayment = Parameters<typeof trpc.processSourcePayment.mutate>[0];
+/** Wallet payment options. User picks one. */
 export type PaymentOption = Awaited<ReturnType<typeof trpc.getWalletPaymentOptions.query>>[0];
+/** Wallet payment details, sent to processSourcePayment after submitting tx. */
+export type SourcePayment = Parameters<typeof trpc.processSourcePayment.mutate>[0];
+/** Loads a DaimoPayOrder + manages the corresponding modal. */
 export interface PaymentInfo {
     setPayId: (id: string | null) => Promise<void>;
-    daimoPayOrder: DaimoPayOrder | null;
-    paymentWaitingMessage: string | null;
+    daimoPayOrder: DaimoPayOrder | undefined;
+    modalOptions: DaimoPayModalOptions;
+    setModalOptions: (modalOptions: DaimoPayModalOptions) => void;
+    paymentWaitingMessage: string | undefined;
     selectedExternalOption: ExternalPaymentOptionMetadata | undefined;
     selectedTokenOption: PaymentOption | undefined;
     setSelectedExternalOption: (option: ExternalPaymentOptionMetadata | undefined) => void;
@@ -15,11 +20,17 @@ export interface PaymentInfo {
     payWithToken: (tokenAmount: DaimoPayTokenAmount) => Promise<void>;
     payWithExternal: (option: ExternalPaymentOptions) => Promise<string>;
     refreshOrder: () => Promise<void>;
+    onSuccess: (args: {
+        txHash: string;
+        txURL?: string;
+    }) => void;
 }
-export declare function getPaymentInfo(): {
+export declare function getPaymentInfo(setOpen: (showModal: boolean) => void, log: (...args: any[]) => void): {
     setPayId: (payId: string | null) => Promise<void>;
-    daimoPayOrder: DaimoPayOrder | null;
-    paymentWaitingMessage: string | null;
+    daimoPayOrder: DaimoPayOrder | undefined;
+    modalOptions: DaimoPayModalOptions;
+    setModalOptions: import("react").Dispatch<import("react").SetStateAction<DaimoPayModalOptions>>;
+    paymentWaitingMessage: string | undefined;
     selectedExternalOption: ExternalPaymentOptionMetadata | undefined;
     selectedTokenOption: any;
     setSelectedExternalOption: import("react").Dispatch<import("react").SetStateAction<ExternalPaymentOptionMetadata | undefined>>;
@@ -28,4 +39,8 @@ export declare function getPaymentInfo(): {
     payWithToken: (tokenAmount: DaimoPayTokenAmount) => Promise<void>;
     payWithExternal: (option: ExternalPaymentOptions) => Promise<any>;
     refreshOrder: () => Promise<void>;
+    onSuccess: ({ txHash, txURL }: {
+        txHash: string;
+        txURL?: string;
+    }) => void;
 };

package/build/packages/paykit/packages/connectkit/src/utils/index.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import React from "react";
 declare const truncateEthAddress: (address?: string, separator?: string) => string;
 declare const truncateENSAddress: (ensName: string, maxLength: number) => string;
@@ -9,10 +8,10 @@ declare const isAndroid: () => boolean;
 declare const isMobile: () => boolean;
 type ReactChildArray = ReturnType<typeof React.Children.toArray>;
 declare function flattenChildren(children: React.ReactNode): ReactChildArray;
-export declare const isWalletConnectConnector: (connectorId?: string) => boolean;
-export declare const isMetaMaskConnector: (connectorId?: string) => boolean;
-export declare const isCoinbaseWalletConnector: (connectorId?: string) => boolean;
-export declare const isLedgerConnector: (connectorId?: string) => boolean;
-export declare const isSafeConnector: (connectorId?: string) => boolean;
-export declare const isInjectedConnector: (connectorId?: string) => boolean;
+export declare const isWalletConnectConnector: (connectorId?: string) => connectorId is "walletConnect";
+export declare const isMetaMaskConnector: (connectorId?: string) => connectorId is "metaMaskSDK";
+export declare const isCoinbaseWalletConnector: (connectorId?: string) => connectorId is "coinbaseWalletSDK";
+export declare const isLedgerConnector: (connectorId?: string) => connectorId is "ledger";
+export declare const isSafeConnector: (connectorId?: string) => connectorId is "safe";
+export declare const isInjectedConnector: (connectorId?: string) => connectorId is "injected";
 export { detectBrowser, detectOS, flattenChildren, isAndroid, isMobile, nFormatter, truncateENSAddress, truncateEthAddress };

package/build/packages/paykit/packages/connectkit/src/wallets/walletConfigs.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 /**
  * EIP-6963: Multi Injected Provider Discovery
  * https://eips.ethereum.org/EIPS/eip-6963

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@daimo/pay",
   "private": false,
-  "version": "0.3.5",
+  "version": "0.3.7",
   "author": "Daimo",
   "homepage": "https://pay.daimo.com",
   "license": "BSD-2-Clause license",
@@ -40,8 +40,8 @@
     "crypto"
   ],
   "dependencies": {
-    "@daimo/common": "0.3.1",
-    "@daimo/contract": "0.3.1",
+    "@daimo/common": "0.3.6",
+    "@daimo/contract": "0.3.6",
     "@trpc/client": "^11.0.0-next-beta.318",
     "@trpc/server": "^11.0.0-next-beta.318",
     "buffer": "^6.0.3",