@daimo/pay 1.6.1 → 1.6.3

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

@@ -1,205 +0,0 @@
-import { jsxs, jsx } from 'react/jsx-runtime';
-import { useMemo, useEffect } from 'react';
-import { usePayContext, ROUTES } from '../../DaimoPay.js';
-import { PageContent } from '../../Common/Modal/styles.js';
-import { ExternalPaymentOptions, getAddressContraction } from '@daimo/pay-common';
-import { useWallet } from '@solana/wallet-adapter-react';
-import { useAccount, useDisconnect } from 'wagmi';
-import { Solana, Bitcoin, Tron, Zcash, Ethereum } from '../../../assets/chains.js';
-import { MetaMask, Rainbow, Coinbase, Rabby } from '../../../assets/logos.js';
-import useIsMobile from '../../../hooks/useIsMobile.js';
-import { walletConfigs } from '../../../wallets/walletConfigs.js';
-import OptionsList from '../../Common/OptionsList/index.js';
-import { OrderHeader } from '../../Common/OrderHeader/index.js';
-import PoweredByFooter from '../../Common/PoweredByFooter/index.js';
-import WalletChainLogo from '../../Common/WalletChainLogo/index.js';
-
-// Get 3 icons, skipping the one that is already connected
-function getBestUnconnectedWalletIcons(connector) {
-    const icons = [];
-    const strippedId = connector?.id.toLowerCase(); // some connector ids can have weird casing and or suffixes and prefixes
-    const [isMetaMask, isRainbow, isCoinbase] = [
-        strippedId?.includes("metamask"),
-        strippedId?.includes("rainbow"),
-        strippedId?.includes("coinbase"),
-    ];
-    if (!isMetaMask)
-        icons.push(jsx(MetaMask, {}));
-    if (!isRainbow)
-        icons.push(jsx(Rainbow, {}));
-    if (!isCoinbase)
-        icons.push(jsx(Coinbase, {}));
-    if (icons.length < 3)
-        icons.push(jsx(Rabby, {}));
-    return icons;
-}
-function getSolanaOption(isOnIOS) {
-    const { wallets } = useWallet();
-    const { setRoute } = usePayContext();
-    if (wallets.length === 0 && !isOnIOS)
-        return null;
-    return {
-        id: "solana",
-        title: "Pay on Solana",
-        icons: [jsx(Solana, {})],
-        onClick: () => {
-            setRoute(ROUTES.SOLANA_CONNECT);
-        },
-    };
-}
-function getDepositAddressOption(depositAddressOptions) {
-    const { setRoute, paymentState } = usePayContext();
-    // TODO: API should serve the subtitle and disabled
-    const disabled = !paymentState.isDepositFlow &&
-        !depositAddressOptions.loading &&
-        depositAddressOptions.options.length === 0;
-    const subtitle = disabled ? "Minimum $20.00" : "Bitcoin, Tron, Zcash...";
-    return {
-        id: "depositAddress",
-        title: "Pay on another chain",
-        subtitle,
-        icons: [jsx(Bitcoin, {}), jsx(Tron, {}), jsx(Zcash, {})],
-        onClick: () => {
-            setRoute(ROUTES.SELECT_DEPOSIT_ADDRESS_CHAIN);
-        },
-        disabled,
-    };
-}
-const SelectMethod = () => {
-    const isMobile = useIsMobile();
-    const isOnIOS = useMemo(() => {
-        return /iPad|iPhone/.test(navigator.userAgent);
-    }, []);
-    const { address, chain, isConnected: isEthConnected, connector, } = useAccount();
-    const { connected: isSolanaConnected, wallet: solanaWallet, publicKey, } = useWallet();
-    const { setRoute, paymentState, wcWallet, setWcWallet, log } = usePayContext();
-    const { disconnectAsync } = useDisconnect();
-    const { daimoPayOrder, setSelectedExternalOption, externalPaymentOptions, depositAddressOptions, senderEnsName, } = paymentState;
-    const paymentOptions = daimoPayOrder?.metadata.payer?.paymentOptions;
-    // Extract the currently connect WalletConnect wallet
-    useEffect(() => {
-        connector?.getProvider()?.then((p) => {
-            let name = p.session?.peer?.metadata?.name;
-            if (p.isCoinbaseWallet)
-                name = "Coinbase Wallet";
-            if (name == null)
-                name = "Unknown";
-            const wallet = Object.values(walletConfigs).find((c) => c.name === name || name.includes(c.shortName));
-            log(`[SELECT_METHOD] wcWallet: ${wallet?.name} ${wallet != null}`, p);
-            setWcWallet(wallet);
-        });
-    }, [connector]);
-    const getConnectedWalletOptions = () => {
-        const showChainLogo = isEthConnected && isSolanaConnected;
-        const connectedOptions = [];
-        if (isEthConnected) {
-            const ethWalletDisplayName = senderEnsName ?? (address ? getAddressContraction(address) : "wallet");
-            let walletIcon;
-            if (connector?.icon) {
-                walletIcon = jsx("img", { src: connector.icon, alt: connector.name });
-            }
-            else if (wcWallet?.icon) {
-                walletIcon = (jsx("div", { style: { borderRadius: "22.5%", overflow: "hidden" }, children: wcWallet.icon }));
-            }
-            else {
-                walletIcon = jsx(MetaMask, {});
-            }
-            const connectedEthWalletOption = {
-                id: "connectedWallet",
-                title: `Pay with ${ethWalletDisplayName}`,
-                icons: [
-                    jsx(WalletChainLogo, { walletIcon: walletIcon, walletName: connector?.name || "Wallet", chainLogo: showChainLogo ? jsx(Ethereum, {}) : null }, "eth"),
-                ],
-                onClick: () => {
-                    setRoute(ROUTES.SELECT_TOKEN, {
-                        event: "click-wallet",
-                        walletId: connector?.id,
-                        chainId: chain?.id,
-                        address: address,
-                    });
-                },
-            };
-            connectedOptions.push(connectedEthWalletOption);
-        }
-        if (isSolanaConnected) {
-            const solWalletDisplayName = getAddressContraction(publicKey?.toBase58() ?? "");
-            const connectedSolWalletOption = {
-                id: "connectedSolanaWallet",
-                title: `Pay with ${solWalletDisplayName}`,
-                icons: solanaWallet?.adapter.icon
-                    ? [
-                        jsx(WalletChainLogo, { walletIcon: solanaWallet.adapter.icon, walletName: solanaWallet.adapter.name, chainLogo: showChainLogo && jsx(Solana, {}) }),
-                    ]
-                    : [
-                        jsx(WalletChainLogo, { walletIcon: jsx(Solana, {}), walletName: "Default wallet icon", chainLogo: null }),
-                    ],
-                onClick: () => {
-                    setRoute(ROUTES.SOLANA_SELECT_TOKEN, {
-                        event: "click-wallet",
-                        walletId: solanaWallet?.adapter.name,
-                        chainId: "solana",
-                        address: publicKey?.toBase58(),
-                    });
-                },
-            };
-            connectedOptions.push(connectedSolWalletOption);
-        }
-        return connectedOptions;
-    };
-    // Solana payment option
-    // Include by default if paymentOptions not provided
-    const includeSolana = paymentOptions == null ||
-        paymentOptions.includes(ExternalPaymentOptions.Solana);
-    // Deposit address options, e.g. Bitcoin, Tron, Zcash, etc.
-    // Include by default if paymentOptions not provided
-    const includeDepositAddressOption = paymentOptions == null ||
-        paymentOptions.includes(ExternalPaymentOptions.ExternalChains);
-    const connectedWalletOptions = getConnectedWalletOptions();
-    const unconnectedWalletOption = {
-        id: "unconnectedWallet",
-        title: isEthConnected || isSolanaConnected
-            ? `Pay with another wallet`
-            : `Pay with wallet`,
-        icons: getBestUnconnectedWalletIcons(connector),
-        onClick: async () => {
-            await disconnectAsync();
-            setRoute(ROUTES.CONNECTORS);
-        },
-    };
-    const options = [];
-    options.push(...connectedWalletOptions);
-    options.push(unconnectedWalletOption);
-    log(`[SELECT_METHOD] loading: ${externalPaymentOptions.loading}, options: ${JSON.stringify(externalPaymentOptions.options)}`);
-    if (includeSolana) {
-        const solanaOption = getSolanaOption(isOnIOS);
-        if (solanaOption) {
-            options.push(solanaOption);
-        }
-    }
-    // External payment options, e.g. Binance, Coinbase, etc.
-    options.push(...(externalPaymentOptions.options ?? []).map((option) => ({
-        id: option.id,
-        title: option.cta,
-        icons: [option.logoURI],
-        onClick: () => {
-            setSelectedExternalOption(option);
-            const meta = { event: "click-option", option: option.id };
-            if (paymentState.isDepositFlow) {
-                setRoute(ROUTES.SELECT_EXTERNAL_AMOUNT, meta);
-            }
-            else {
-                setRoute(ROUTES.WAITING_EXTERNAL, meta);
-            }
-        },
-        disabled: option.disabled,
-        subtitle: option.message,
-    })));
-    if (includeDepositAddressOption) {
-        const depositAddressOption = getDepositAddressOption(depositAddressOptions);
-        options.push(depositAddressOption);
-    }
-    return (jsxs(PageContent, { children: [jsx(OrderHeader, {}), jsx(OptionsList, { requiredSkeletons: isMobile ? 4 : 3, isLoading: externalPaymentOptions.loading, options: externalPaymentOptions.loading ? [] : options }), jsx(PoweredByFooter, {})] }));
-};
-
-export { SelectMethod as default };
-//# sourceMappingURL=index.js.map

package/build/src/components/Pages/SelectMethod/index.js.map

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

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

@@ -1,61 +0,0 @@
-import { jsx, jsxs } from 'react/jsx-runtime';
-import { usePayContext, ROUTES } from '../../DaimoPay.js';
-import { PageContent, ModalContent, ModalH1 } from '../../Common/Modal/styles.js';
-import { getChainName } from '@daimo/pay-common';
-import { formatUsd, roundTokenAmount } from '../../../utils/format.js';
-import Button from '../../Common/Button/index.js';
-import OptionsList from '../../Common/OptionsList/index.js';
-import { OrderHeader } from '../../Common/OrderHeader/index.js';
-import TokenChainLogo from '../../Common/TokenChainLogo/index.js';
-
-function getDaimoTokenKey(token) {
-    return `${token.chainId}-${token.token}`;
-}
-const SelectToken = () => {
-    const { setRoute, paymentState } = usePayContext();
-    const { isDepositFlow, walletPaymentOptions, setSelectedTokenOption } = paymentState;
-    const optionsList = walletPaymentOptions.options?.map((option) => {
-        const chainName = getChainName(option.balance.token.chainId);
-        const titlePrice = isDepositFlow
-            ? formatUsd(option.balance.usd)
-            : roundTokenAmount(option.required.amount, option.required.token);
-        const title = `${titlePrice} ${option.balance.token.symbol} on ${chainName}`;
-        const balanceStr = `${roundTokenAmount(option.balance.amount, option.balance.token)} ${option.balance.token.symbol}`;
-        const subtitle = option.disabledReason ??
-            `${isDepositFlow ? "" : "Balance: "}${balanceStr}`;
-        const disabled = option.disabledReason != null;
-        return {
-            id: getDaimoTokenKey(option.balance.token),
-            title,
-            subtitle,
-            icons: [
-                jsx(TokenChainLogo, { token: option.balance.token }, getDaimoTokenKey(option.balance.token)),
-            ],
-            onClick: () => {
-                setSelectedTokenOption(option);
-                const meta = {
-                    event: "click-token",
-                    tokenSymbol: option.balance.token.symbol,
-                    chainId: option.balance.token.chainId,
-                };
-                if (isDepositFlow) {
-                    setRoute(ROUTES.SELECT_AMOUNT, meta);
-                }
-                else {
-                    setRoute(ROUTES.PAY_WITH_TOKEN, meta);
-                }
-            },
-            disabled,
-        };
-    }) ?? [];
-    return (jsxs(PageContent, { children: [jsx(OrderHeader, { minified: true }), !walletPaymentOptions.isLoading && optionsList.length === 0 && (jsxs(ModalContent, { style: {
-                    display: "flex",
-                    alignItems: "center",
-                    justifyContent: "center",
-                    paddingTop: 16,
-                    paddingBottom: 16,
-                }, children: [jsx(ModalH1, { children: "Insufficient balance." }), jsx(Button, { onClick: () => setRoute(ROUTES.SELECT_METHOD), children: "Select Another Method" })] })), jsx(OptionsList, { requiredSkeletons: 4, isLoading: walletPaymentOptions.isLoading, options: optionsList })] }));
-};
-
-export { SelectToken as default };
-//# sourceMappingURL=index.js.map

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

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

package/build/src/components/Pages/Solana/ConnectSolana/index.js

@@ -1,80 +0,0 @@
-import { jsx, jsxs } from 'react/jsx-runtime';
-import { PageContent, ModalContent, ModalH1 } from '../../../Common/Modal/styles.js';
-import { useWallet } from '@solana/wallet-adapter-react';
-import { SquircleIcon, Phantom, Solflare, Backpack } from '../../../../assets/logos.js';
-import { isMobile } from '../../../../utils/index.js';
-import Button from '../../../Common/Button/index.js';
-import OptionsList from '../../../Common/OptionsList/index.js';
-import { usePayContext, ROUTES } from '../../../DaimoPay.js';
-
-const ConnectSolana = () => {
-    const { setSolanaConnector, setRoute, log } = usePayContext();
-    const solanaWallets = useWallet();
-    const options = solanaWallets.wallets.map((wallet) => ({
-        id: wallet.adapter.name,
-        title: `${wallet.adapter.name}`,
-        icons: [
-            jsx(SquircleIcon, { icon: wallet.adapter.icon, alt: wallet.adapter.name }),
-        ],
-        onClick: async () => {
-            log("wallet.adapter.name ", wallet.adapter.name);
-            setSolanaConnector(wallet.adapter.name);
-            if (solanaWallets.connected) {
-                await solanaWallets.disconnect();
-            }
-            setRoute(ROUTES.SOLANA_CONNECTOR, {
-                event: "click-solana-wallet",
-                walletName: wallet.adapter.name,
-            });
-        },
-    }));
-    const defaultOptions = [
-        {
-            id: "phantom",
-            title: "Open in Phantom",
-            icons: [
-                jsx(SquircleIcon, { icon: (props) => jsx(Phantom, { ...props, background: true }), alt: "Phantom" }),
-            ],
-            onClick: () => window.open(`https://phantom.app/ul/browse/${encodeURIComponent(window.location.href)}?ref=${encodeURIComponent(window.location.origin)}`),
-        },
-        {
-            id: "solflare",
-            title: "Open in Solflare",
-            icons: [
-                jsx(SquircleIcon, { icon: (props) => jsx(Solflare, { ...props, background: true }), alt: "Solflare" }),
-            ],
-            onClick: () => window.open(`https://solflare.com/ul/v1/browse/${encodeURIComponent(window.location.href)}?ref=${encodeURIComponent(window.location.origin)}`, "_blank"),
-        },
-        {
-            id: "backpack",
-            title: "Open in Backpack",
-            icons: [
-                jsx(SquircleIcon, { icon: (props) => jsx(Backpack, { ...props, background: true }), alt: "Backpack" }),
-            ],
-            onClick: () => window.open(`https://backpack.app/ul/v1/browse/${encodeURIComponent(window.location.href)}?ref=${encodeURIComponent(window.location.origin)}`, "_blank"),
-        },
-    ];
-    return (jsxs(PageContent, { style: {
-            height: "100%",
-        }, children: [solanaWallets.wallets.length === 0 && !isMobile() && (jsxs(ModalContent, { style: {
-                    display: "flex",
-                    flexDirection: "column",
-                    alignItems: "center",
-                    justifyContent: "center",
-                    paddingTop: 16,
-                    paddingBottom: 16,
-                    gap: 16,
-                }, children: [jsx(ModalH1, { children: "No Solana wallets detected." }), jsx(Button, { onClick: () => setRoute(ROUTES.SELECT_METHOD, { event: "click-select-another" }), children: "Select Another Method" })] })), isMobile() &&
-                (solanaWallets.wallets.length === 0 ||
-                    (solanaWallets.wallets.length > 0 &&
-                        solanaWallets.wallets[0].adapter.name ===
-                            "Mobile Wallet Adapter")) && (jsx(ModalContent, { style: {
-                    display: "flex",
-                    flexDirection: "column",
-                    gap: 16,
-                }, children: jsx(OptionsList, { options: defaultOptions }) })), solanaWallets.wallets.length > 0 &&
-                solanaWallets.wallets[0].adapter.name !== "Mobile Wallet Adapter" && (jsx(OptionsList, { options: options }))] }));
-};
-
-export { ConnectSolana as default };
-//# sourceMappingURL=index.js.map

package/build/src/components/Pages/Solana/ConnectSolana/index.js.map

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

package/build/src/components/Pages/Solana/ConnectorSolana/index.js

@@ -1,55 +0,0 @@
-import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
-import { useEffect } from 'react';
-import { PageContent, ModalContent, ModalH1, ModalBody } from '../../../Common/Modal/styles.js';
-import { useWallet } from '@solana/wallet-adapter-react';
-import { motion, AnimatePresence } from 'framer-motion';
-import styled from '../../../../styles/styled/index.js';
-import { usePayContext, ROUTES } from '../../../DaimoPay.js';
-import SquircleSpinner from '../../../Spinners/SquircleSpinner/index.js';
-
-const ConnectSolana = () => {
-    const solanaWallets = useWallet();
-    const isConnected = solanaWallets.connected;
-    const { solanaConnector, setRoute } = usePayContext();
-    const selectedWallet = solanaWallets.wallets.find((wallet) => wallet.adapter.name === solanaConnector);
-    useEffect(() => {
-        if (!solanaConnector)
-            return;
-        solanaWallets.select(solanaConnector);
-    }, [solanaConnector]);
-    useEffect(() => {
-        if (isConnected) {
-            // Wait so user can see it's connected
-            const meta = {
-                event: "wait-solana-connected",
-                walletName: solanaWallets.wallet?.adapter.name,
-            };
-            setTimeout(() => setRoute(ROUTES.SOLANA_SELECT_TOKEN, meta), 500);
-        }
-    }, [isConnected]);
-    if (!solanaConnector)
-        return null;
-    return (jsxs(PageContent, { children: [jsx(LoadingContainer, { children: jsx(AnimationContainer, { children: jsx(AnimatePresence, { children: jsx(SquircleSpinner, { logo: jsx("div", { style: { borderRadius: "22.5%", overflow: "hidden" }, children: jsx("img", { src: selectedWallet?.adapter.icon, alt: selectedWallet?.adapter.name }) }), loading: true }) }) }) }), jsx(ModalContent, { style: { paddingBottom: 0 }, children: isConnected ? (jsx(ModalH1, { children: "Connected" })) : (jsxs(Fragment, { children: [jsx(ModalH1, { children: "Requesting Connection" }), jsxs(ModalBody, { children: ["Open ", selectedWallet?.adapter.name, " to continue."] })] })) })] }));
-};
-const LoadingContainer = styled(motion.div) `
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  margin: 10px auto 16px;
-  height: 120px;
-`;
-const AnimationContainer = styled(motion.div) `
-  user-select: none;
-  position: relative;
-  --spinner-error-opacity: 0;
-  &:before {
-    content: "";
-    position: absolute;
-    inset: 1px;
-    opacity: 0;
-    background: var(--ck-body-color-danger);
-  }
-`;
-
-export { LoadingContainer, ConnectSolana as default };
-//# sourceMappingURL=index.js.map

package/build/src/components/Pages/Solana/ConnectorSolana/index.js.map

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

package/build/src/components/Pages/Solana/PayWithSolanaToken/index.js

@@ -1,62 +0,0 @@
-import { jsxs, jsx } from 'react/jsx-runtime';
-import { useState, useEffect } from 'react';
-import { usePayContext, ROUTES } from '../../../DaimoPay.js';
-import { WalletSignTransactionError, WalletSendTransactionError } from '@solana/wallet-adapter-base';
-import { PageContent, ModalContent, ModalH1 } from '../../../Common/Modal/styles.js';
-import { assert } from '@daimo/pay-common';
-import Button from '../../../Common/Button/index.js';
-import PaymentBreakdown from '../../../Common/PaymentBreakdown/index.js';
-import TokenLogoSpinner from '../../../Spinners/TokenLogoSpinner/index.js';
-
-var PayState;
-(function (PayState) {
-    PayState["RequestingPayment"] = "Requesting Payment";
-    PayState["RequestCancelled"] = "Payment Cancelled";
-    PayState["RequestFailed"] = "Payment Failed";
-    PayState["RequestSuccessful"] = "Payment Successful";
-})(PayState || (PayState = {}));
-const PayWithSolanaToken = () => {
-    const { triggerResize, paymentState, setRoute } = usePayContext();
-    const { payParams, generatePreviewOrder, selectedSolanaTokenOption, payWithSolanaToken, } = paymentState;
-    const [payState, setPayState] = useState(PayState.RequestingPayment);
-    const handleTransfer = async () => {
-        try {
-            setPayState(PayState.RequestingPayment);
-            assert(!!selectedSolanaTokenOption, "[PAY SOLANA] No token option selected");
-            await payWithSolanaToken(selectedSolanaTokenOption.required.token.token);
-            setPayState(PayState.RequestSuccessful);
-            setTimeout(() => {
-                setRoute(ROUTES.CONFIRMATION, { event: "wait-pay-with-solana" });
-            }, 200);
-        }
-        catch (error) {
-            console.error(error);
-            if (error instanceof WalletSignTransactionError ||
-                error instanceof WalletSendTransactionError) {
-                setPayState(PayState.RequestCancelled);
-            }
-            else {
-                setPayState(PayState.RequestFailed);
-            }
-        }
-    };
-    let transferTimeout; // Prevent double-triggering in React dev strict mode.
-    useEffect(() => {
-        if (!selectedSolanaTokenOption)
-            return;
-        // Give user time to see the UI before opening
-        transferTimeout = setTimeout(handleTransfer, 100);
-        return () => clearTimeout(transferTimeout);
-    }, []);
-    useEffect(() => {
-        triggerResize();
-    }, [payState]);
-    return (jsxs(PageContent, { children: [selectedSolanaTokenOption && (jsx(TokenLogoSpinner, { token: selectedSolanaTokenOption.required.token })), jsxs(ModalContent, { style: { paddingBottom: 0 }, children: [jsx(ModalH1, { children: payState }), selectedSolanaTokenOption && (jsx(PaymentBreakdown, { paymentOption: selectedSolanaTokenOption })), payState === PayState.RequestCancelled && (jsx(Button, { onClick: handleTransfer, children: "Retry Payment" })), payState === PayState.RequestFailed && (jsx(Button, { onClick: () => {
-                            assert(payParams != null, "[PAY SOLANA] payParams cannot be null in deposit flow");
-                            generatePreviewOrder(payParams);
-                            setRoute(ROUTES.SELECT_METHOD, { event: "click-select-another" });
-                        }, children: "Select Another Method" }))] })] }));
-};
-
-export { PayWithSolanaToken as default };
-//# sourceMappingURL=index.js.map

package/build/src/components/Pages/Solana/PayWithSolanaToken/index.js.map

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

package/build/src/components/Pages/Solana/SelectSolanaAmount/index.js

@@ -1,16 +0,0 @@
-import { jsx } from 'react/jsx-runtime';
-import { usePayContext, ROUTES } from '../../../DaimoPay.js';
-import MultiCurrencySelectAmount from '../../../Common/AmountInput/index.js';
-import { PageContent } from '../../../Common/Modal/styles.js';
-
-const SelectSolanaAmount = () => {
-    const { paymentState } = usePayContext();
-    const { selectedSolanaTokenOption, setSelectedSolanaTokenOption } = paymentState;
-    if (selectedSolanaTokenOption == null) {
-        return jsx(PageContent, {});
-    }
-    return (jsx(MultiCurrencySelectAmount, { selectedTokenOption: selectedSolanaTokenOption, setSelectedTokenOption: setSelectedSolanaTokenOption, nextPage: ROUTES.SOLANA_PAY_WITH_TOKEN }));
-};
-
-export { SelectSolanaAmount as default };
-//# sourceMappingURL=index.js.map

package/build/src/components/Pages/Solana/SelectSolanaAmount/index.js.map

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

package/build/src/components/Pages/Solana/SelectSolanaToken/index.js

@@ -1,59 +0,0 @@
-import { jsx, jsxs } from 'react/jsx-runtime';
-import { usePayContext, ROUTES } from '../../../DaimoPay.js';
-import { PageContent, ModalContent, ModalH1 } from '../../../Common/Modal/styles.js';
-import { formatUsd, roundTokenAmount } from '../../../../utils/format.js';
-import Button from '../../../Common/Button/index.js';
-import OptionsList from '../../../Common/OptionsList/index.js';
-import { OrderHeader } from '../../../Common/OrderHeader/index.js';
-import TokenChainLogo from '../../../Common/TokenChainLogo/index.js';
-
-function getDaimoSolanaTokenKey(token) {
-    return `${token.chainId}-${token.token}`;
-}
-const SelectSolanaToken = () => {
-    const { paymentState, setRoute } = usePayContext();
-    const { isDepositFlow, solanaPaymentOptions, setSelectedSolanaTokenOption } = paymentState;
-    const optionsList = solanaPaymentOptions.options?.map((option) => {
-        const titlePrice = isDepositFlow
-            ? formatUsd(option.balance.usd)
-            : roundTokenAmount(option.required.amount, option.required.token);
-        const title = `${titlePrice} ${option.balance.token.symbol} on Solana`;
-        const balanceStr = `${roundTokenAmount(option.balance.amount, option.balance.token)} ${option.balance.token.symbol}`;
-        const subtitle = option.disabledReason ??
-            `${isDepositFlow ? "" : "Balance: "}${balanceStr}`;
-        const disabled = option.disabledReason != null;
-        return {
-            id: getDaimoSolanaTokenKey(option.balance.token),
-            title,
-            subtitle,
-            icons: [
-                jsx(TokenChainLogo, { token: option.balance.token }, getDaimoSolanaTokenKey(option.balance.token)),
-            ],
-            onClick: () => {
-                setSelectedSolanaTokenOption(option);
-                const meta = {
-                    event: "click-solana-token",
-                    tokenSymbol: option.balance.token.symbol,
-                    chainId: option.balance.token.chainId,
-                };
-                if (isDepositFlow) {
-                    setRoute(ROUTES.SOLANA_SELECT_AMOUNT, meta);
-                }
-                else {
-                    setRoute(ROUTES.SOLANA_PAY_WITH_TOKEN, meta);
-                }
-            },
-            disabled,
-        };
-    }) ?? [];
-    return (jsxs(PageContent, { children: [jsx(OrderHeader, { minified: true }), !solanaPaymentOptions.isLoading && optionsList.length === 0 && (jsxs(ModalContent, { style: {
-                    display: "flex",
-                    alignItems: "center",
-                    justifyContent: "center",
-                    paddingTop: 16,
-                    paddingBottom: 16,
-                }, children: [jsx(ModalH1, { children: "Insufficient balance." }), jsx(Button, { onClick: () => setRoute(ROUTES.SELECT_METHOD), children: "Select Another Method" })] })), jsx(OptionsList, { requiredSkeletons: 4, isLoading: solanaPaymentOptions.isLoading, options: optionsList })] }));
-};
-
-export { SelectSolanaToken as default };
-//# sourceMappingURL=index.js.map

package/build/src/components/Pages/Solana/SelectSolanaToken/index.js.map

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

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

@@ -1,26 +0,0 @@
-import { jsx, jsxs } from 'react/jsx-runtime';
-import { useConnect, useDisconnect, useAccount } from 'wagmi';
-import ChainSelectList from '../../Common/ChainSelectList/index.js';
-import { PageContent, ModalContent, ModalBody } from '../../Common/Modal/styles.js';
-import useLocales from '../../../hooks/useLocales.js';
-import { DisconnectIcon } from '../../../assets/icons.js';
-import { useChainIsSupported } from '../../../hooks/useChainIsSupported.js';
-import { isSafeConnector } from '../../../utils/index.js';
-import Button from '../../Common/Button/index.js';
-import { OrDivider } from '../../Common/Modal/index.js';
-
-const SwitchNetworks = () => {
-    const { reset } = useConnect();
-    const { disconnect } = useDisconnect();
-    const { connector, chain } = useAccount();
-    const isChainSupported = useChainIsSupported(chain?.id);
-    const locales = useLocales({});
-    const onDisconnect = () => {
-        disconnect();
-        reset();
-    };
-    return (jsx(PageContent, { style: { width: 278 }, children: jsxs(ModalContent, { style: { padding: 0, marginTop: -10 }, children: [!isChainSupported && (jsxs(ModalBody, { children: [locales.warnings_chainUnsupported, " ", locales.warnings_chainUnsupportedResolve] })), jsx("div", { style: { padding: "6px 8px" }, children: jsx(ChainSelectList, { variant: "secondary" }) }), !isChainSupported && !isSafeConnector(connector?.id) && (jsxs("div", { style: { paddingTop: 12 }, children: [jsx(OrDivider, {}), jsx(Button, { icon: jsx(DisconnectIcon, {}), variant: "secondary", onClick: onDisconnect, children: locales.disconnect })] }))] }) }));
-};
-
-export { SwitchNetworks as default };
-//# sourceMappingURL=index.js.map

package/build/src/components/Pages/SwitchNetworks/index.js.map

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

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

@@ -1,51 +0,0 @@
-import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
-import { useEffect, useState } from 'react';
-import { usePayContext, ROUTES } from '../../DaimoPay.js';
-import { PageContent, ModalContent, ModalH1, ModalBody } from '../../Common/Modal/styles.js';
-import { getAddressContraction } from '@daimo/pay-common';
-import ScanIconWithLogos from '../../../assets/ScanIconWithLogos.js';
-import Button from '../../Common/Button/index.js';
-import CopyToClipboard from '../../Common/CopyToClipboard/index.js';
-import CustomQRCode from '../../Common/CustomQRCode/index.js';
-import { OrDivider } from '../../Common/Modal/index.js';
-
-const WaitingDepositAddress = () => {
-    const context = usePayContext();
-    const { triggerResize, paymentState, setRoute } = context;
-    const trpc = context.trpc;
-    const { daimoPayOrder, payWithDepositAddress, selectedDepositAddressOption } = paymentState;
-    useEffect(() => {
-        const checkForSourcePayment = async () => {
-            if (!daimoPayOrder || !selectedDepositAddressOption)
-                return;
-            const found = await trpc.findSourcePayment.query({
-                orderId: daimoPayOrder.id.toString(),
-            });
-            if (found) {
-                setRoute(ROUTES.CONFIRMATION);
-            }
-        };
-        // Check every 10 seconds, bitcoin takes a while
-        const interval = setInterval(checkForSourcePayment, 10000);
-        return () => clearInterval(interval);
-    }, [daimoPayOrder?.id]);
-    const [details, setDetails] = useState();
-    const [failed, setFailed] = useState(false);
-    useEffect(() => {
-        if (!selectedDepositAddressOption)
-            return;
-        payWithDepositAddress(selectedDepositAddressOption.id).then((details) => {
-            if (!details)
-                setFailed(true);
-            else
-                setDetails(details);
-        });
-    }, [selectedDepositAddressOption]);
-    useEffect(() => {
-        triggerResize();
-    }, [details]);
-    return (jsx(PageContent, { children: failed ? (jsxs(ModalContent, { style: { marginLeft: 24, marginRight: 24 }, children: [jsxs(ModalH1, { children: [selectedDepositAddressOption?.id, " unavailable"] }), jsxs(ModalBody, { children: ["We're unable to process ", selectedDepositAddressOption?.id, " payments at this time. Please select another payment method."] }), jsx(Button, { onClick: () => setRoute(ROUTES.SELECT_METHOD, { event: "click-select-another" }), children: "Select Another Method" })] })) : (jsxs(ModalContent, { children: [jsx(CustomQRCode, { value: details?.uri, image: jsx("img", { src: selectedDepositAddressOption?.logoURI, width: "100%", height: "100%" }), tooltipMessage: jsxs(Fragment, { children: [jsx(ScanIconWithLogos, { logo: jsx("img", { src: selectedDepositAddressOption?.logoURI }) }), jsxs("span", { children: ["Use a ", selectedDepositAddressOption?.id, " wallet to scan"] })] }) }), details && (jsxs(Fragment, { children: [jsx(OrDivider, {}), jsxs(ModalBody, { children: ["Send exactly ", details.amount, " ", details.suffix, " to", " ", getAddressContraction(details.address), " and return to this page. Confirmation should appear in a few minutes."] }), jsx(CopyToClipboard, { variant: "button", string: details.address, children: "Copy Address" }), jsx(CopyToClipboard, { variant: "left", string: details.amount, children: "Copy Amount" })] }))] })) }));
-};
-
-export { WaitingDepositAddress as default };
-//# sourceMappingURL=index.js.map

package/build/src/components/Pages/WaitingDepositAddress/index.js.map

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