@daimo/pay 0.3.4 → 0.3.6

package/build/index.es.js

@@ -1,13 +1,13 @@
 import { http, useConfig, useAccountEffect, useConnectors as useConnectors$1, useAccount, useWriteContract, useSendTransaction, useSwitchChain, useConnect as useConnect$1, createConfig, useEnsAddress, useEnsName, useEnsAvatar, useDisconnect, useBalance, useChainId, WagmiContext } from 'wagmi';
-import { mainnet, base as base$1, polygon, optimism, arbitrum, linea, sepolia } from 'wagmi/chains';
+import { mainnet, base as base$1, polygon, optimism, arbitrum, linea, sepolia, baseSepolia } from 'wagmi/chains';
 import { safe, injected, coinbaseWallet, walletConnect } from '@wagmi/connectors';
 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, capitalize, ExternalPaymentOptions, getAddressContraction, getDisplayPrice, 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, getChainExplorerTxUrl } from '@daimo/contract';
+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';
 import { createTRPCClient, httpBatchLink } from '@trpc/client';
 import { motion, AnimatePresence, MotionConfig } from 'framer-motion';
@@ -71,6 +71,7 @@ const REQUIRED_CHAINS = [
     arbitrum,
     linea,
     sepolia,
+    baseSepolia,
 ];
 const defaultConfig = ({ appName = "Daimo Pay", appIcon, appDescription, appUrl, walletConnectProjectId, coinbaseWalletPreference, chains = REQUIRED_CHAINS, client, ...props }) => {
     globalAppName = appName;
@@ -899,7 +900,7 @@ const trpc = createTRPCClient({
     ],
 });
 
-function getPaymentInfo() {
+function getPaymentInfo(log) {
     // Wallet state.
     const { address: senderAddr } = useAccount();
     const { writeContractAsync } = useWriteContract();
@@ -917,7 +918,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,7 +979,7 @@ function getPaymentInfo() {
         setDaimoPayOrder(order);
     }, [daimoPayOrder?.id]);
     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);
@@ -1004,7 +1005,7 @@ 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]);
     return {
@@ -2163,7 +2164,7 @@ const ResetContainer = styled(motion.div) `
 `;
 
 var name = "@daimo/pay";
-var version = "0.3.4";
+var version = "0.3.6";
 var author = "Daimo";
 var homepage = "https://pay.daimo.com";
 var license = "BSD-2-Clause license";
@@ -2202,8 +2203,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",
@@ -6608,6 +6609,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();
@@ -6621,7 +6623,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) {
@@ -6902,7 +6904,7 @@ const chainToLogo = {
     [optimism$1.chainId]: jsx(Optimism, {}),
     [polygon$1.chainId]: jsx(Polygon, {}),
     [ethereumSepolia.chainId]: jsx(Ethereum, {}),
-    [baseSepolia.chainId]: jsx(Base, {}),
+    [baseSepolia$1.chainId]: jsx(Base, {}),
 };
 var ChainIcons = {
     UnknownChain,
@@ -6958,6 +6960,7 @@ const InputField = styled(motion.input) `
   line-height: inherit;
   font-size: inherit;
   font-weight: inherit;
+  color: inherit;
   border: none;
   padding: 0;
   &:focus {
@@ -10037,8 +10040,10 @@ const Confirmation = () => {
     }, [refreshOrder]);
     const { done, txURL, currency } = (() => {
         if (daimoPayOrder && daimoPayOrder.mode === DaimoPayOrderMode.HYDRATED) {
-            if (daimoPayOrder.destStatus === DaimoPayOrderStatusDest.CLAIMED ||
-                daimoPayOrder.destStatus === DaimoPayOrderStatusDest.FAST_FINISHED) {
+            if (daimoPayOrder.destStatus ===
+                DaimoPayOrderStatusDest.FAST_FINISH_SUBMITTED || // Frontends are optimistic, assume submits will be successful
+                daimoPayOrder.destStatus === DaimoPayOrderStatusDest.FAST_FINISHED ||
+                daimoPayOrder.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}`;
@@ -10130,7 +10135,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();
@@ -10159,7 +10164,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;
         }
@@ -10175,7 +10180,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 {
@@ -10433,10 +10438,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();
         }
@@ -10648,6 +10653,7 @@ const SelectToken = () => {
     useEffect(() => {
         if (!payerAddress || !daimoPayOrder)
             return;
+        setPaymentOptions(null);
         setIsLoadingOptions(true);
         const destChainId = daimoPayOrder.destFinalCallTokenAmount.token.chainId;
         trpc.getWalletPaymentOptions
@@ -10665,7 +10671,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}`;
@@ -10687,6 +10693,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)
@@ -10701,6 +10708,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, {});
     }
@@ -10712,23 +10733,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;
@@ -10819,7 +10827,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);
             }
@@ -10962,7 +10972,7 @@ const DaimoPayProvider = ({ children, theme = "auto", mode = "auto", customTheme
         }
     }, [injectedConnector]);
     const log = debugMode ? console.log : () => { };
-    const paymentInfo = getPaymentInfo();
+    const paymentInfo = getPaymentInfo(log);
     const loadPayment = async (payId) => {
         await paymentInfo.setPayId(payId);
         const daimoPayOrder = paymentInfo.daimoPayOrder;
@@ -11374,9 +11384,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/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/utils/getPaymentInfo.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 import { DaimoPayOrder, DaimoPayTokenAmount, ExternalPaymentOptionMetadata, ExternalPaymentOptions } from "@daimo/common";
 import { trpc } from "./trpc";
 export type SourcePayment = Parameters<typeof trpc.processSourcePayment.mutate>[0];
@@ -16,7 +15,7 @@ export interface PaymentInfo {
     payWithExternal: (option: ExternalPaymentOptions) => Promise<string>;
     refreshOrder: () => Promise<void>;
 }
-export declare function getPaymentInfo(): {
+export declare function getPaymentInfo(log: (...args: any[]) => void): {
     setPayId: (payId: string | null) => Promise<void>;
     daimoPayOrder: DaimoPayOrder | null;
     paymentWaitingMessage: string | null;

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.4",
+  "version": "0.3.6",
   "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",