@daimo/pay 0.3.21 → 1.0.0

package/build/src/hooks/usePayWithSolanaToken.js

@@ -0,0 +1,50 @@
+import { assert, assertNotNull } from '@daimo/common';
+import { useConnection, useWallet } from '@solana/wallet-adapter-react';
+import { VersionedTransaction } from '@solana/web3.js';
+import { hexToBytes } from 'viem';
+
+function usePayWithSolanaToken({ trpc, daimoPayOrder, setDaimoPayOrder, createOrHydrate, platform, log, }) {
+    const { connection } = useConnection();
+    const wallet = useWallet();
+    const payWithSolanaToken = async (inputToken) => {
+        assert(!!wallet.publicKey, "No wallet connected");
+        assert(!!platform && !!daimoPayOrder);
+        const orderId = daimoPayOrder.id;
+        const { hydratedOrder } = await createOrHydrate({
+            order: daimoPayOrder,
+        });
+        log(`[CHECKOUT] Hydrated order: ${JSON.stringify(hydratedOrder)}, checking out with Solana ${inputToken}`);
+        const txHash = await (async () => {
+            try {
+                const serializedTx = await trpc.getSolanaSwapAndBurnTx.query({
+                    orderId: orderId.toString(),
+                    userPublicKey: assertNotNull(wallet.publicKey).toString(),
+                    inputTokenMint: inputToken,
+                });
+                const tx = VersionedTransaction.deserialize(hexToBytes(serializedTx));
+                const txHash = await wallet.sendTransaction(tx, connection);
+                return txHash;
+            }
+            catch (e) {
+                console.error(e);
+                setDaimoPayOrder(hydratedOrder);
+                throw e;
+            }
+            finally {
+                setDaimoPayOrder(hydratedOrder);
+            }
+        })();
+        // TOOD: get the actual amount sent from the tx logs.
+        // We are currently using a fake amount = 0.
+        trpc.processSolanaSourcePayment.mutate({
+            orderId: orderId.toString(),
+            startIntentTxHash: txHash,
+            token: inputToken,
+        });
+        return txHash;
+    };
+    return { payWithSolanaToken };
+}
+
+export { usePayWithSolanaToken };
+//# sourceMappingURL=usePayWithSolanaToken.js.map

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

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

package/build/src/hooks/usePayWithToken.js

@@ -0,0 +1,57 @@
+import { assert, assertNotNull } from '@daimo/common';
+import { zeroAddress, erc20Abi, getAddress } from 'viem';
+import { useWriteContract, useSendTransaction } from 'wagmi';
+
+function usePayWithToken({ trpc, senderAddr, daimoPayOrder, setDaimoPayOrder, createOrHydrate, platform, log, }) {
+    const { writeContractAsync } = useWriteContract();
+    const { sendTransactionAsync } = useSendTransaction();
+    /** Commit to a token + amount = initiate payment. */
+    const payWithToken = async (tokenAmount) => {
+        assert(!!daimoPayOrder && !!platform);
+        const { hydratedOrder } = await createOrHydrate({
+            order: daimoPayOrder,
+            refundAddress: senderAddr,
+        });
+        log(`[CHECKOUT] Hydrated order: ${JSON.stringify(hydratedOrder)}, checking out with ${tokenAmount.token.token}`);
+        const txHash = await (async () => {
+            try {
+                if (tokenAmount.token.token === zeroAddress) {
+                    return await sendTransactionAsync({
+                        to: hydratedOrder.intentAddr,
+                        value: BigInt(tokenAmount.amount),
+                    });
+                }
+                else {
+                    return await writeContractAsync({
+                        abi: erc20Abi,
+                        address: getAddress(tokenAmount.token.token),
+                        functionName: "transfer",
+                        args: [hydratedOrder.intentAddr, BigInt(tokenAmount.amount)],
+                    });
+                }
+            }
+            catch (e) {
+                console.error(`[CHECKOUT] Error sending token: ${e}`);
+                setDaimoPayOrder(hydratedOrder);
+                throw e;
+            }
+            finally {
+                setDaimoPayOrder(hydratedOrder);
+            }
+        })();
+        if (txHash) {
+            await trpc.processSourcePayment.mutate({
+                orderId: daimoPayOrder.id.toString(),
+                sourceInitiateTxHash: txHash,
+                sourceChainId: tokenAmount.token.chainId,
+                sourceFulfillerAddr: assertNotNull(senderAddr),
+                sourceToken: tokenAmount.token.token,
+                sourceAmount: tokenAmount.amount,
+            });
+        }
+    };
+    return { payWithToken };
+}
+
+export { usePayWithToken };
+//# sourceMappingURL=usePayWithToken.js.map

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

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

package/build/src/hooks/usePaymentState.js

@@ -0,0 +1,243 @@
+import { readDaimoPayOrderID, assert, assertNotNull, debugJson } from '@daimo/common';
+import { ethereum } from '@daimo/contract';
+import { useWallet } from '@solana/wallet-adapter-react';
+import { useState, useEffect, useCallback } from 'react';
+import { parseUnits, formatUnits } from 'viem';
+import { useAccount, useEnsName } from 'wagmi';
+import { generatePayId } from '../utils/exports.js';
+import { detectPlatform } from '../utils/platform.js';
+import { useDepositAddressOptions } from './useDepositAddressOptions.js';
+import { useExternalPaymentOptions } from './useExternalPaymentOptions.js';
+import { usePayWithSolanaToken } from './usePayWithSolanaToken.js';
+import { usePayWithToken } from './usePayWithToken.js';
+import { useSolanaPaymentOptions } from './useSolanaPaymentOptions.js';
+import { useWalletPaymentOptions } from './useWalletPaymentOptions.js';
+
+function usePaymentState({ trpc, daimoPayOrder, setDaimoPayOrder, setOpen, log, }) {
+    // Browser state.
+    const [platform, setPlatform] = useState();
+    useEffect(() => {
+        setPlatform(detectPlatform(window.navigator.userAgent));
+    }, []);
+    // Wallet state.
+    const { address: senderAddr } = useAccount();
+    const { data: senderEnsName } = useEnsName({
+        chainId: ethereum.chainId,
+        address: senderAddr,
+    });
+    // Solana wallet state.
+    const solanaWallet = useWallet();
+    const solanaPubKey = solanaWallet.publicKey?.toBase58();
+    // Daimo Pay order state.
+    const [payParams, setPayParamsState] = useState();
+    const [paymentWaitingMessage, setPaymentWaitingMessage] = useState();
+    // Payment UI config.
+    const [modalOptions, setModalOptions] = useState({});
+    // UI state. Selection for external payment (Binance, etc) vs wallet payment.
+    const externalPaymentOptions = useExternalPaymentOptions({
+        trpc,
+        filterIds: daimoPayOrder?.metadata.payer?.paymentOptions,
+        usdRequired: daimoPayOrder?.destFinalCallTokenAmount.usd,
+        platform,
+    });
+    const walletPaymentOptions = useWalletPaymentOptions({
+        trpc,
+        address: senderAddr,
+        usdRequired: daimoPayOrder?.destFinalCallTokenAmount.usd,
+        destChainId: daimoPayOrder?.destFinalCallTokenAmount.token.chainId,
+        preferredChains: daimoPayOrder?.metadata.payer?.preferredChains,
+        preferredTokens: daimoPayOrder?.metadata.payer?.preferredTokens,
+    });
+    const solanaPaymentOptions = useSolanaPaymentOptions({
+        trpc,
+        address: solanaPubKey,
+        usdRequired: daimoPayOrder?.destFinalCallTokenAmount.usd,
+    });
+    const depositAddressOptions = useDepositAddressOptions({
+        trpc,
+        usdRequired: daimoPayOrder?.destFinalCallTokenAmount.usd ?? 0,
+    });
+    /** Create a new order or hydrate an existing one. */
+    const createOrHydrate = async ({ order, refundAddress, externalPaymentOption, }) => {
+        assert(!!platform, "missing platform");
+        if (payParams == null) {
+            log(`[CHECKOUT] hydrating existing order ${order.id}`);
+            return await trpc.hydrateOrder.query({
+                id: order.id.toString(),
+                chosenFinalTokenAmount: order.destFinalCallTokenAmount.amount,
+                platform,
+                refundAddress,
+                externalPaymentOption,
+            });
+        }
+        log(`[CHECKOUT] creating+hydrating new order ${order.id}`);
+        // Update units, if amountEditable the user may have changed the amount.
+        const toUnits = formatUnits(BigInt(order.destFinalCallTokenAmount.amount), order.destFinalCallTokenAmount.token.decimals);
+        return await trpc.createOrder.mutate({
+            appId: payParams.appId,
+            paymentInput: {
+                ...payParams,
+                id: order.id.toString(),
+                toUnits: toUnits,
+                metadata: order.metadata,
+            },
+            platform,
+            refundAddress,
+            externalPaymentOption,
+        });
+    };
+    const { payWithToken } = usePayWithToken({
+        trpc,
+        senderAddr,
+        daimoPayOrder,
+        setDaimoPayOrder,
+        createOrHydrate,
+        platform,
+        log,
+    });
+    const { payWithSolanaToken } = usePayWithSolanaToken({
+        trpc,
+        daimoPayOrder,
+        setDaimoPayOrder,
+        createOrHydrate,
+        platform,
+        log,
+    });
+    const [selectedExternalOption, setSelectedExternalOption] = useState();
+    const [selectedTokenOption, setSelectedTokenOption] = useState();
+    const [selectedSolanaTokenOption, setSelectedSolanaTokenOption] = useState();
+    const [selectedDepositAddressOption, setSelectedDepositAddressOption] = useState();
+    const payWithExternal = async (option) => {
+        assert(!!daimoPayOrder && !!platform);
+        const { hydratedOrder, externalPaymentOptionData } = await createOrHydrate({
+            order: daimoPayOrder,
+            externalPaymentOption: option,
+        });
+        assert(!!externalPaymentOptionData, "missing externalPaymentOptionData");
+        log(`[CHECKOUT] Hydrated order: ${JSON.stringify(hydratedOrder)}, checking out with external payment: ${option}`);
+        setPaymentWaitingMessage(externalPaymentOptionData.waitingMessage);
+        setDaimoPayOrder(hydratedOrder);
+        return externalPaymentOptionData.url;
+    };
+    const payWithDepositAddress = async (option) => {
+        assert(!!daimoPayOrder);
+        const { hydratedOrder } = await createOrHydrate({
+            order: daimoPayOrder,
+        });
+        setDaimoPayOrder(hydratedOrder);
+        log(`[CHECKOUT] Hydrated order: ${JSON.stringify(hydratedOrder)}, checking out with deposit address: ${option}`);
+        const depositAddressOption = await trpc.getDepositAddressOptionData.query({
+            input: option,
+            usdRequired: daimoPayOrder.destFinalCallTokenAmount.usd,
+            toAddress: assertNotNull(hydratedOrder.intentAddr),
+        });
+        return depositAddressOption;
+    };
+    const refreshOrder = useCallback(async () => {
+        const id = daimoPayOrder?.id?.toString();
+        if (!id)
+            return;
+        const { order } = await trpc.getOrder.query({
+            id,
+        });
+        setDaimoPayOrder(order);
+    }, [daimoPayOrder?.id]);
+    /** User picked a different deposit amount. */
+    const setChosenUsd = (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);
+        // TODO: remove amount from destFinalCall, it is redundant with
+        // destFinalCallTokenAmount. Here, we only modify one and not the other.
+        setDaimoPayOrder({
+            ...daimoPayOrder,
+            destFinalCallTokenAmount: {
+                token,
+                amount: tokenAmount.toString(),
+                usd: usdAmount,
+            },
+        });
+    };
+    const setPayId = useCallback(async (payId) => {
+        if (!payId)
+            return;
+        const id = readDaimoPayOrderID(payId).toString();
+        if (daimoPayOrder && BigInt(id) == daimoPayOrder.id) {
+            // Already loaded, ignore.
+            return;
+        }
+        const { order } = await trpc.getOrder.query({ id });
+        if (!order) {
+            console.error(`[CHECKOUT] No order found for ${payId}`);
+            return;
+        }
+        log(`[CHECKOUT] fetched order: ${JSON.stringify(order)}`);
+        setDaimoPayOrder(order);
+    }, [daimoPayOrder]);
+    /** Called whenever params change. */
+    const setPayParams = async (payParams) => {
+        console.log(`[CHECKOUT] setting payParams: ${debugJson(payParams)}`);
+        assert(payParams != null);
+        setPayParamsState(payParams);
+        const newPayId = generatePayId();
+        const newId = readDaimoPayOrderID(newPayId).toString();
+        const payment = await trpc.previewOrder.query({
+            id: newId,
+            toChain: payParams.toChain,
+            toToken: payParams.toToken,
+            toUnits: payParams.toUnits,
+            toAddress: payParams.toAddress,
+            toCallData: payParams.toCallData,
+            isAmountEditable: payParams.isAmountEditable,
+            metadata: {
+                intent: payParams.intent ?? "Pay",
+                items: [],
+                payer: {
+                    paymentOptions: payParams.paymentOptions,
+                    preferredChains: payParams.preferredChains,
+                    preferredTokens: payParams.preferredTokens,
+                },
+            },
+        });
+        setDaimoPayOrder(payment);
+    };
+    const onSuccess = ({ txHash, txURL }) => {
+        if (modalOptions?.closeOnSuccess) {
+            log(`[CHECKOUT] transaction succeeded, closing: ${txHash} ${txURL}`);
+            setTimeout(() => setOpen(false), 1000);
+        }
+    };
+    return {
+        setPayId,
+        payParams,
+        setPayParams,
+        daimoPayOrder,
+        modalOptions,
+        setModalOptions,
+        paymentWaitingMessage,
+        selectedExternalOption,
+        selectedTokenOption,
+        selectedSolanaTokenOption,
+        externalPaymentOptions,
+        walletPaymentOptions,
+        solanaPaymentOptions,
+        depositAddressOptions,
+        selectedDepositAddressOption,
+        setSelectedDepositAddressOption,
+        setSelectedExternalOption,
+        setSelectedTokenOption,
+        setSelectedSolanaTokenOption,
+        setChosenUsd,
+        payWithToken,
+        payWithExternal,
+        payWithDepositAddress,
+        payWithSolanaToken,
+        refreshOrder,
+        onSuccess,
+        senderEnsName: senderEnsName ?? undefined,
+    };
+}
+
+export { usePaymentState };
+//# sourceMappingURL=usePaymentState.js.map

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

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

package/build/src/hooks/usePrevious.js

@@ -0,0 +1,14 @@
+import { useRef } from 'react';
+
+function usePrevious(value, initial) {
+    const ref = useRef({ target: value, previous: initial });
+    if (ref.current.target !== value) {
+        // The value changed.
+        ref.current.previous = ref.current.target;
+        ref.current.target = value;
+    }
+    return ref.current.previous;
+}
+
+export { usePrevious as default };
+//# sourceMappingURL=usePrevious.js.map

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

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

package/build/src/hooks/useSolanaPaymentOptions.js

@@ -0,0 +1,37 @@
+import { useState, useEffect } from 'react';
+
+function useSolanaPaymentOptions({ trpc, address, usdRequired, }) {
+    const [options, setOptions] = useState(null);
+    const [isLoading, setIsLoading] = useState(false);
+    useEffect(() => {
+        const refreshWalletPaymentOptions = async () => {
+            if (!address || !usdRequired)
+                return;
+            setOptions(null);
+            setIsLoading(true);
+            try {
+                const newOptions = await trpc.getSolanaPaymentOptions.query({
+                    pubKey: address,
+                    usdRequired,
+                });
+                setOptions(newOptions);
+            }
+            catch (error) {
+                console.error(error);
+            }
+            finally {
+                setIsLoading(false);
+            }
+        };
+        if (address && usdRequired != null) {
+            refreshWalletPaymentOptions();
+        }
+    }, [address, usdRequired]);
+    return {
+        options,
+        isLoading,
+    };
+}
+
+export { useSolanaPaymentOptions };
+//# sourceMappingURL=useSolanaPaymentOptions.js.map

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

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

package/build/src/hooks/useWalletConnectModal.js

@@ -0,0 +1,52 @@
+import { useState } from 'react';
+import { walletConnect } from 'wagmi/connectors';
+import { usePayContext } from '../components/DaimoPay.js';
+import { isWalletConnectConnector } from '../utils/index.js';
+import { useConnect } from './useConnect.js';
+
+function useWalletConnectModal() {
+    const { log } = usePayContext();
+    const { connectAsync, connectors } = useConnect();
+    const [isOpen, setIsOpen] = useState(false);
+    return {
+        isOpen,
+        open: async () => {
+            // add modal styling because wagmi does not let you add styling to the modal
+            const w3mcss = document.createElement("style");
+            w3mcss.innerHTML = `w3m-modal, wcm-modal{ --wcm-z-index: 2147483647; --w3m-z-index:2147483647; }`;
+            document.head.appendChild(w3mcss);
+            const clientConnector = connectors.find((c) => isWalletConnectConnector(c.id));
+            if (clientConnector == null) {
+                log("No WalletConnect connector available");
+                return;
+            }
+            try {
+                const provider = await clientConnector.getProvider();
+                const projectId = provider.rpc.projectId;
+                const connector = walletConnect({
+                    projectId,
+                    showQrModal: true,
+                });
+                setIsOpen(true);
+                try {
+                    await connectAsync({ connector: connector });
+                }
+                catch (err) {
+                    log("WalletConnect", err);
+                }
+                setIsOpen(false);
+                // remove modal styling
+                try {
+                    document.head.removeChild(w3mcss);
+                }
+                catch { }
+            }
+            catch (err) {
+                log("Could not get WalletConnect provider", err);
+            }
+        },
+    };
+}
+
+export { useWalletConnectModal };
+//# sourceMappingURL=useWalletConnectModal.js.map

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

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

package/build/src/hooks/useWalletPaymentOptions.js

@@ -0,0 +1,40 @@
+import { useState, useEffect } from 'react';
+
+function useWalletPaymentOptions({ trpc, address, usdRequired, destChainId, preferredChains, preferredTokens, }) {
+    const [options, setOptions] = useState(null);
+    const [isLoading, setIsLoading] = useState(false);
+    useEffect(() => {
+        const refreshWalletPaymentOptions = async () => {
+            if (!address || !usdRequired || !destChainId)
+                return;
+            setOptions(null);
+            setIsLoading(true);
+            try {
+                const newOptions = await trpc.getWalletPaymentOptions.query({
+                    payerAddress: address,
+                    usdRequired,
+                    destChainId,
+                    preferredChains,
+                    preferredTokens,
+                });
+                setOptions(newOptions);
+            }
+            catch (error) {
+                console.error(error);
+            }
+            finally {
+                setIsLoading(false);
+            }
+        };
+        if (address && usdRequired != null && destChainId) {
+            refreshWalletPaymentOptions();
+        }
+    }, [address, usdRequired, destChainId]);
+    return {
+        options,
+        isLoading,
+    };
+}
+
+export { useWalletPaymentOptions };
+//# sourceMappingURL=useWalletPaymentOptions.js.map

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

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

package/build/src/hooks/useWindowSize.js

@@ -0,0 +1,23 @@
+import { useState, useEffect } from 'react';
+
+function useWindowSize() {
+    const [windowSize, setWindowSize] = useState({
+        width: 0,
+        height: 0,
+    });
+    useEffect(() => {
+        function handleResize() {
+            setWindowSize({
+                width: window.innerWidth,
+                height: window.innerHeight,
+            });
+        }
+        window.addEventListener("resize", handleResize);
+        handleResize();
+        return () => window.removeEventListener("resize", handleResize);
+    }, []);
+    return windowSize;
+}
+
+export { useWindowSize as default };
+//# sourceMappingURL=useWindowSize.js.map

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

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

package/build/src/index.js

@@ -0,0 +1,10 @@
+export { DaimoPayProvider } from './components/DaimoPay.js';
+export { default as getDefaultConfig } from './defaultConfig.js';
+export { DaimoPayButton } from './components/DaimoPayButton/index.js';
+export { useDaimoPayStatus } from './hooks/useDaimoPayStatus.js';
+export { useModal as useDaimoPayModal } from './hooks/useModal.js';
+export { default as Avatar } from './components/Common/Avatar/index.js';
+export { default as ChainIcon } from './components/Common/Chain/index.js';
+export { wallets } from './wallets/index.js';
+export { generatePayId } from './utils/exports.js';
+//# sourceMappingURL=index.js.map

package/build/src/index.js.map

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

package/build/src/localizations/index.js

@@ -0,0 +1,57 @@
+import arAE from './locales/ar-AE.js';
+import caAD from './locales/ca-AD.js';
+import eeEE from './locales/ee-EE.js';
+import enUS from './locales/en-US.js';
+import esES from './locales/es-ES.js';
+import faIR from './locales/fa-IR.js';
+import frFR from './locales/fr-FR.js';
+import jaJP from './locales/ja-JP.js';
+import ptBR from './locales/pt-BR.js';
+import ruRU from './locales/ru-RU.js';
+import trTR from './locales/tr-TR.js';
+import viVN from './locales/vi-VN.js';
+import zhCN from './locales/zh-CN.js';
+
+// TODO: tree-shaking
+const getLocale = (lang) => {
+    switch (lang) {
+        case "ee-EE":
+            return eeEE;
+        case "ar-AE":
+            return arAE;
+        case "es-ES":
+            return esES;
+        case "fa-IR":
+            return faIR;
+        case "fr-FR":
+            return frFR;
+        case "ja-JP":
+            return jaJP;
+        case "pt-BR":
+            return ptBR;
+        case "ru-RU":
+            return ruRU;
+        case "zh-CN":
+            return zhCN;
+        case "ca-AD":
+            return caAD;
+        case "tr-TR":
+            return trTR;
+        case "vi-VN":
+            return viVN;
+        default:
+            return enUS;
+    }
+};
+/*
+// Could be useful for locale files to use these keys rather than hard-coded into the objects
+export const keys = {
+  connectorName: '{{ CONNECTORNAME }}',
+  connectorShortName: '{{ CONNECTORSHORTNAME }}',
+  suggestedExtensionBrowser: '{{ SUGGESTEDEXTENSIONBROWSER }}',
+  walletConnectLogo: '{{ WALLETCONNECTLOGO }}',
+};
+*/
+
+export { getLocale };
+//# sourceMappingURL=index.js.map

package/build/src/localizations/index.js.map

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