@daimo/pay 0.3.21 → 1.0.0

package/build/src/constants/chainConfigs.js

@@ -0,0 +1,306 @@
+import { jsx } from 'react/jsx-runtime';
+import Chains from '../assets/chains.js';
+
+// Note: these rpcUrls are incomplete, and are subject to change from their respective providers
+// More RPC URLs can be found: https://chainid.network/chains.json
+const chainConfigs = [
+    {
+        id: 1,
+        name: "Ethereum",
+        logo: jsx(Chains.Ethereum, {}),
+        rpcUrls: {
+            alchemy: {
+                http: ["https://eth-mainnet.g.alchemy.com/v2"],
+                webSocket: ["wss://eth-mainnet.g.alchemy.com/v2"],
+            },
+            infura: {
+                http: ["https://mainnet.infura.io/v3"],
+                webSocket: ["wss://mainnet.infura.io/ws/v3"],
+            },
+        },
+    },
+    {
+        id: 3,
+        name: "Rinkeby",
+        logo: jsx(Chains.Ethereum, { testnet: true }),
+        rpcUrls: {},
+    },
+    {
+        id: 4,
+        name: "Ropsten",
+        logo: jsx(Chains.Ethereum, { testnet: true }),
+    },
+    {
+        id: 5,
+        name: "Görli",
+        logo: jsx(Chains.Ethereum, { testnet: true }),
+    },
+    {
+        id: 42,
+        name: "Kovan",
+        logo: jsx(Chains.Ethereum, { testnet: true }),
+    },
+    {
+        id: 10,
+        name: "Optimism",
+        logo: jsx(Chains.Optimism, {}),
+    },
+    {
+        id: 69, // nice
+        name: "Optimism Kovan",
+        logo: jsx(Chains.Optimism, { testnet: true }),
+    },
+    {
+        id: 420, // nice
+        name: "Optimism Goerli",
+        logo: jsx(Chains.Optimism, { testnet: true }),
+    },
+    {
+        id: 11155420,
+        name: "Optimism Sepolia",
+        logo: jsx(Chains.Optimism, { testnet: true }),
+    },
+    {
+        id: 137,
+        name: "Polygon",
+        logo: jsx(Chains.Polygon, {}),
+    },
+    {
+        id: 80001,
+        name: "Polygon Mumbai",
+        logo: jsx(Chains.Polygon, { testnet: true }),
+    },
+    {
+        id: 31337,
+        name: "Hardhat",
+        logo: jsx(Chains.Ethereum, { testnet: true }),
+    },
+    {
+        id: 1337,
+        name: "Localhost",
+        logo: jsx(Chains.Ethereum, { testnet: true }),
+    },
+    {
+        id: 42161,
+        name: "Arbitrum",
+        logo: jsx(Chains.Arbitrum, {}),
+        rpcUrls: {
+            alchemy: {
+                http: ["https://arb-mainnet.g.alchemy.com/v2"],
+                webSocket: ["wss://arb-mainnet.g.alchemy.com/v2"],
+            },
+            infura: {
+                http: ["https://arbitrum-mainnet.infura.io/v3"],
+                webSocket: ["wss://arbitrum-mainnet.infura.io/ws/v3"],
+            },
+        },
+    },
+    {
+        id: 421611,
+        name: "Arbitrum Rinkeby",
+        logo: jsx(Chains.Arbitrum, { testnet: true }),
+    },
+    {
+        id: 421613,
+        name: "Arbitrum Goerli",
+        logo: jsx(Chains.Arbitrum, { testnet: true }),
+        rpcUrls: {
+            alchemy: {
+                http: ["https://arb-goerli.g.alchemy.com/v2"],
+                webSocket: ["wss://arb-goerli.g.alchemy.com/v2"],
+            },
+            infura: {
+                http: ["https://arbitrum-goerli.infura.io/v3"],
+                webSocket: ["wss://arbitrum-goerli.infura.io/ws/v3"],
+            },
+        },
+    },
+    {
+        id: 40,
+        name: "Telos",
+        logo: jsx(Chains.Telos, {}),
+    },
+    {
+        id: 41,
+        name: "Telos Testnet",
+        logo: jsx(Chains.Telos, { testnet: true }),
+    },
+    {
+        id: 1313161554,
+        name: "Aurora",
+        logo: jsx(Chains.Aurora, {}),
+    },
+    {
+        id: 1313161555,
+        name: "Aurora Testnet",
+        logo: jsx(Chains.Aurora, { testnet: true }),
+    },
+    {
+        id: 43_114,
+        name: "Avalanche",
+        logo: jsx(Chains.Avalanche, {}),
+    },
+    {
+        id: 43_113,
+        name: "Avalanche Fuji",
+        logo: jsx(Chains.Avalanche, { testnet: true }),
+    },
+    {
+        id: 31337,
+        name: "Foundry",
+        logo: jsx(Chains.Foundry, { testnet: true }),
+    },
+    {
+        id: 100,
+        name: "Gnosis",
+        logo: jsx(Chains.Gnosis, {}),
+    },
+    {
+        id: 9001,
+        name: "Evmos",
+        logo: jsx(Chains.Evmos, {}),
+    },
+    {
+        id: 9000,
+        name: "Evmos Testnet",
+        logo: jsx(Chains.Evmos, { testnet: true }),
+    },
+    {
+        id: 56,
+        name: "BNB Smart Chain",
+        logo: jsx(Chains.BinanceSmartChain, {}),
+    },
+    {
+        id: 97,
+        name: "Binance Smart Chain Testnet",
+        logo: jsx(Chains.BinanceSmartChain, { testnet: true }),
+    },
+    {
+        id: 11155111,
+        name: "Sepolia",
+        logo: jsx(Chains.Sepolia, {}),
+    },
+    {
+        id: 841,
+        name: "Taraxa",
+        logo: jsx(Chains.Taraxa, {}),
+    },
+    {
+        id: 842,
+        name: "Taraxa Testnet",
+        logo: jsx(Chains.Taraxa, { testnet: true }),
+    },
+    {
+        id: 324,
+        name: "zkSync",
+        logo: jsx(Chains.zkSync, {}),
+    },
+    {
+        id: 280,
+        name: "zkSync Testnet",
+        logo: jsx(Chains.zkSync, { testnet: true }),
+    },
+    {
+        id: 42_220,
+        name: "Celo",
+        logo: jsx(Chains.Celo, {}),
+    },
+    {
+        id: 44_787,
+        name: "Celo Alfajores",
+        logo: jsx(Chains.Celo, { testnet: true }),
+    },
+    {
+        id: 7_700,
+        name: "Canto",
+        logo: jsx(Chains.Canto, {}),
+    },
+    {
+        id: 250,
+        name: "Fantom",
+        logo: jsx(Chains.Fantom, {}),
+    },
+    {
+        id: 4_002,
+        name: "Fantom Testnet",
+        logo: jsx(Chains.Fantom, { testnet: true }),
+    },
+    {
+        id: 14,
+        name: "Flare",
+        logo: jsx(Chains.Flare, {}),
+    },
+    {
+        id: 114,
+        name: "Coston2",
+        logo: jsx(Chains.Flare, {}),
+    },
+    {
+        id: 314,
+        name: "Filecoin",
+        logo: jsx(Chains.Filecoin, {}),
+    },
+    {
+        id: 314_1,
+        name: "Filecoin Hyperspace",
+        logo: jsx(Chains.Filecoin, { testnet: true }),
+    },
+    {
+        id: 314_159,
+        name: "Filecoin Calibration",
+        logo: jsx(Chains.Filecoin, { testnet: true }),
+    },
+    {
+        id: 1_088,
+        name: "Metis",
+        logo: jsx(Chains.Metis, {}),
+    },
+    {
+        id: 599,
+        name: "Metis Goerli",
+        logo: jsx(Chains.Metis, { testnet: true }),
+    },
+    {
+        id: 4_689,
+        name: "IoTeX",
+        logo: jsx(Chains.IoTeX, {}),
+    },
+    {
+        id: 4_690,
+        name: "IoTeX Testnet",
+        logo: jsx(Chains.IoTeX, { testnet: true }),
+    },
+    {
+        id: 8_453,
+        name: "Base",
+        logo: jsx(Chains.Base, {}),
+    },
+    {
+        id: 84_531,
+        name: "Base Goerli",
+        logo: jsx(Chains.Base, { testnet: true }),
+    },
+    {
+        id: 84_532,
+        name: "Base Sepolia",
+        logo: jsx(Chains.Base, { testnet: true }),
+    },
+    {
+        id: 7777777,
+        name: "Zora",
+        logo: jsx(Chains.Zora, {}),
+    },
+    {
+        id: 999999999,
+        name: "Zora Sepolia",
+        logo: jsx(Chains.Zora, { testnet: true }),
+    },
+    {
+        id: 999,
+        name: "Zora Goerli Testnet",
+        logo: jsx(Chains.Zora, { testnet: true }),
+    },
+];
+
+export { chainConfigs };
+//# sourceMappingURL=chainConfigs.js.map

package/build/src/constants/chainConfigs.js.map

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

package/build/src/constants/defaultTheme.js

@@ -0,0 +1,6 @@
+var defaultTheme = {
+    mobileWidth: 560,
+};
+
+export { defaultTheme as default };
+//# sourceMappingURL=defaultTheme.js.map

package/build/src/constants/defaultTheme.js.map

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

package/build/src/defaultConfig.js

@@ -0,0 +1,59 @@
+import { http } from 'wagmi';
+import { mainnet, base, polygon, optimism, arbitrum, linea, bsc, sepolia, baseSepolia } from 'wagmi/chains';
+import defaultConnectors from './defaultConnectors.js';
+
+// TODO: Move these to a provider rather than global variable
+let globalAppName;
+const getAppName = () => globalAppName;
+const REQUIRED_CHAINS = [
+    mainnet,
+    base,
+    polygon,
+    optimism,
+    arbitrum,
+    linea,
+    bsc,
+    sepolia,
+    baseSepolia,
+];
+/** Daimo Pay recommended config, for use with wagmi's createConfig(). */
+const defaultConfig = ({ appName = "Daimo Pay", appIcon, appDescription, appUrl, walletConnectProjectId, coinbaseWalletPreference, chains = REQUIRED_CHAINS, client, ...props }) => {
+    globalAppName = appName;
+    const paddedChains = [...chains];
+    for (const chain of REQUIRED_CHAINS) {
+        if (!paddedChains.includes(chain)) {
+            paddedChains.push(chain);
+        }
+    }
+    const paddedTransports = {};
+    for (const chain of paddedChains) {
+        if (!props?.transports?.[chain.id]) {
+            // Auto inject http transport if not provided for a chain
+            paddedTransports[chain.id] = http();
+        }
+        else {
+            paddedTransports[chain.id] = props.transports[chain.id];
+        }
+    }
+    const connectors = props?.connectors ??
+        defaultConnectors({
+            app: {
+                name: appName,
+                icon: appIcon,
+                description: appDescription,
+                url: appUrl,
+            },
+            walletConnectProjectId: walletConnectProjectId ?? "ea6c5b36001c18b96e06128f14c06f40",
+            coinbaseWalletPreference,
+        });
+    const config = {
+        ...props,
+        chains: paddedChains,
+        transports: paddedTransports,
+        connectors,
+    };
+    return config;
+};
+
+export { REQUIRED_CHAINS, defaultConfig as default, getAppName };
+//# sourceMappingURL=defaultConfig.js.map

package/build/src/defaultConfig.js.map

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

package/build/src/defaultConnectors.js

@@ -0,0 +1,43 @@
+import { safe, injected, coinbaseWallet, walletConnect } from '@wagmi/connectors';
+
+const defaultConnectors = ({ app, walletConnectProjectId, coinbaseWalletPreference, }) => {
+    const hasAllAppData = app.name && app.icon && app.description && app.url;
+    const shouldUseSafeConnector = !(typeof window === "undefined") && window?.parent !== window;
+    const connectors = [];
+    // If we're in an iframe, include the SafeConnector
+    if (shouldUseSafeConnector) {
+        connectors.push(safe({
+            allowedDomains: [/gnosis-safe.io$/, /app.safe.global$/],
+        }));
+    }
+    // Add the rest of the connectors
+    connectors.push(injected({ target: "metaMask" }), coinbaseWallet({
+        appName: app.name,
+        appLogoUrl: app.icon,
+        overrideIsMetaMask: false,
+        preference: coinbaseWalletPreference,
+    }));
+    connectors.push(walletConnect({
+        showQrModal: false,
+        projectId: walletConnectProjectId,
+        metadata: hasAllAppData
+            ? {
+                name: app.name,
+                description: app.description,
+                url: app.url,
+                icons: [app.icon],
+            }
+            : undefined,
+    }));
+    /*
+    connectors.push(
+      injected({
+        shimDisconnect: true,
+      })
+    );
+    */
+    return connectors;
+};
+
+export { defaultConnectors as default };
+//# sourceMappingURL=defaultConnectors.js.map

package/build/src/defaultConnectors.js.map

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

package/build/src/hooks/connectors/useWalletConnectUri.js

@@ -0,0 +1,93 @@
+import { useState, useEffect } from 'react';
+import { useAccount } from 'wagmi';
+import { usePayContext } from '../../components/DaimoPay.js';
+import { useConnect } from '../useConnect.js';
+import { useWalletConnectConnector } from '../useConnectors.js';
+
+function useWalletConnectUri({ enabled } = {
+    enabled: true,
+}) {
+    const { log } = usePayContext();
+    const [uri, setUri] = useState(undefined);
+    const connector = useWalletConnectConnector();
+    const { isConnected } = useAccount();
+    const { connectAsync } = useConnect();
+    useEffect(() => {
+        if (!enabled)
+            return;
+        async function handleMessage(message) {
+            const { type, data } = message;
+            log("WC Message", type, data);
+            if (type === "display_uri") {
+                setUri(data);
+            }
+            /*
+              // This has the URI as well, but we're probably better off using the one in the display_uri event
+              if (type === 'connecting') {
+                const p = await connector.getProvider();
+                const uri = p.signer.uri;
+                setConnectorUri(uri);
+              }
+              */
+        }
+        async function handleDisconnect() {
+            log("WC Disconnect");
+            if (connector)
+                connectWallet(connector);
+        }
+        async function connectWallet(connector) {
+            const result = await connectAsync({ connector });
+            if (result)
+                return result;
+            return false;
+        }
+        async function connectWalletConnect(connector) {
+            try {
+                await connectWallet(connector);
+            }
+            catch (error) {
+                log("catch error");
+                log(error);
+                if (error.code) {
+                    switch (error.code) {
+                        case 4001:
+                            log("error.code - User rejected");
+                            connectWalletConnect(connector); // Regenerate QR code
+                            break;
+                        default:
+                            log("error.code - Unknown Error");
+                            break;
+                    }
+                }
+                else {
+                    // Sometimes the error doesn't respond with a code
+                    log("WalletConnect cannot connect.", error);
+                }
+            }
+        }
+        if (isConnected) {
+            setUri(undefined);
+        }
+        else {
+            if (!connector || uri)
+                return;
+            if (connector && !isConnected) {
+                connectWalletConnect(connector);
+                log("add wc listeners");
+                connector.emitter.on("message", handleMessage);
+                connector.emitter.on("disconnect", handleDisconnect);
+                return () => {
+                    log("remove wc listeners");
+                    connector.emitter.off("message", handleMessage);
+                    connector.emitter.off("disconnect", handleDisconnect);
+                };
+            }
+        }
+    }, [enabled, connector, isConnected]);
+    return {
+        uri,
+    };
+}
+
+export { useWalletConnectUri };
+//# sourceMappingURL=useWalletConnectUri.js.map

package/build/src/hooks/connectors/useWalletConnectUri.js.map

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

package/build/src/hooks/useChainIsSupported.js

@@ -0,0 +1,12 @@
+import { useConfig } from 'wagmi';
+
+/** Determines whether the current wagmi configuration supports a given chain. */
+function useChainIsSupported(chainId) {
+    const { chains } = useConfig();
+    if (!chainId)
+        return false;
+    return chains.some((x) => x.id === chainId);
+}
+
+export { useChainIsSupported };
+//# sourceMappingURL=useChainIsSupported.js.map

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

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

package/build/src/hooks/useChains.js

@@ -0,0 +1,11 @@
+import { useConfig } from 'wagmi';
+
+/** Returns currently configured wagmi chains. */
+function useChains() {
+    const wagmi = useConfig();
+    const chains = wagmi?.chains ?? [];
+    return chains.map((c) => c);
+}
+
+export { useChains };
+//# sourceMappingURL=useChains.js.map

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

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

package/build/src/hooks/useConnect.js

@@ -0,0 +1,45 @@
+import { useConnect as useConnect$1 } from 'wagmi';
+import { usePayContext } from '../components/DaimoPay.js';
+
+/**
+ * This is a wrapper around wagmi's useConnect hook that adds some
+ * additional functionality.
+ */
+function useConnect({ ...props } = {}) {
+    const context = usePayContext();
+    const { connect, connectAsync, connectors, ...rest } = useConnect$1({
+        ...props,
+        mutation: {
+            ...props.mutation,
+            onError(err) {
+                if (err.message) {
+                    if (err.message !== "User rejected request") {
+                        context.log(err.message, err);
+                    }
+                }
+                else {
+                    context.log(`Could not connect.`, err);
+                }
+            },
+        },
+    });
+    return {
+        connect: ({ connector, chainId, mutation, }) => {
+            return connect({
+                connector,
+                chainId: chainId ?? context.options?.initialChainId,
+            }, mutation);
+        },
+        connectAsync: async ({ connector, chainId, mutation, }) => {
+            return connectAsync({
+                connector,
+                chainId: chainId ?? context.options?.initialChainId,
+            }, mutation);
+        },
+        connectors,
+        ...rest,
+    };
+}
+
+export { useConnect };
+//# sourceMappingURL=useConnect.js.map

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

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

package/build/src/hooks/useConnectCallback.js

@@ -0,0 +1,18 @@
+import { useAccountEffect } from 'wagmi';
+
+const useConnectCallback = ({ onConnect, onDisconnect, }) => {
+    useAccountEffect({
+        onConnect: ({ address, connector, isReconnected }) => {
+            if (!isReconnected) {
+                onConnect?.({
+                    address: address,
+                    connectorId: connector?.id,
+                });
+            }
+        },
+        onDisconnect: () => onDisconnect?.(),
+    });
+};
+
+export { useConnectCallback };
+//# sourceMappingURL=useConnectCallback.js.map

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

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

package/build/src/hooks/useConnectors.js

@@ -0,0 +1,29 @@
+import { useConnectors as useConnectors$1 } from 'wagmi';
+
+function useConnectors() {
+    const connectors = useConnectors$1();
+    return connectors ?? [];
+}
+function useConnector(id, uuid) {
+    const connectors = useConnectors();
+    if (id === "injected" && uuid) {
+        return connectors.find((c) => c.id === id && c.name === uuid);
+    }
+    else if (id === "injected") {
+        return connectors.find((c) => c.id === id && c.name.includes("Injected"));
+    }
+    return connectors.find((c) => c.id === id);
+}
+function useWalletConnectConnector() {
+    /*
+    options: {
+      qrcode: false,
+      // or
+      showQrModal: false,
+    }
+    */
+    return useConnector("walletConnect");
+}
+
+export { useConnector, useConnectors, useWalletConnectConnector };
+//# sourceMappingURL=useConnectors.js.map

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

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