@0xsquid/react-hooks 8.10.0 → 8.11.0

package/dist/{index-Dzir2lUQ.js → index-BzTFES6t.js}

@@ -3463,7 +3463,7 @@ function get$1(object, path, defaultValue) {
 
 var get_1 = get$1;
 
-var get$2 = /*@__PURE__*/getDefaultExportFromCjs(get_1);
+var getProperty = /*@__PURE__*/getDefaultExportFromCjs(get_1);
 
 /**
  * The base implementation of `_.hasIn` without support for deep paths.
@@ -4739,33 +4739,6 @@ class BitcoinConnectorInvalidAccountError extends BitcoinConnectorError {
     }
 }
 
-class KeplrConnector {
-    get getProvider() {
-        const provider = window?.bitcoin_keplr;
-        if (!provider) {
-            throw new BitcoinConnectorProviderNotFoundError("Keplr");
-        }
-        return provider;
-    }
-    async sendBTC(to, amount) {
-        const txHash = await this.getProvider.sendBitcoin(to, amount);
-        if (!txHash) {
-            throw new BitcoinConnectorTransactionFailedError();
-        }
-        return { txHash };
-    }
-    async requestAccount() {
-        const accounts = await this.getProvider.requestAccounts();
-        const account = accounts[0];
-        if (typeof account !== "string") {
-            throw new BitcoinConnectorInvalidAccountError();
-        }
-        return {
-            address: account,
-        };
-    }
-}
-
 bitcoin__namespace.initEccLib(ecc__namespace);
 const network = bitcoin__namespace.networks.bitcoin;
 const fromHexString = (hexString) => {
@@ -4854,6 +4827,53 @@ async function getTransactionStatus$1(txHash) {
         .then((response) => response.data);
 }
 
+class KeplrConnector {
+    get getProvider() {
+        const provider = window?.bitcoin_keplr;
+        if (!provider) {
+            throw new BitcoinConnectorProviderNotFoundError("Keplr");
+        }
+        return provider;
+    }
+    async sendBTC(to, amount) {
+        const txHash = await this.getProvider.sendBitcoin(to, amount);
+        if (!txHash) {
+            throw new BitcoinConnectorTransactionFailedError();
+        }
+        return { txHash };
+    }
+    async requestAccount() {
+        const accounts = await this.getProvider.requestAccounts();
+        const account = accounts[0];
+        if (typeof account !== "string") {
+            throw new BitcoinConnectorInvalidAccountError();
+        }
+        return {
+            address: account,
+        };
+    }
+    async signPsbt(psbtHex) {
+        // Keplr follows the UniSat-style Bitcoin provider API: `signPsbt` signs and,
+        // with `autoFinalized` (the default), finalizes every input, returning the
+        // signed PSBT as a hex string.
+        // https://docs.keplr.app/api/bitcoin
+        const signedPsbtHex = await this.getProvider.signPsbt(psbtHex, {
+            autoFinalized: true,
+        });
+        // Broadcast the finalized raw transaction directly rather than through
+        // Keplr's `pushTx`, which proxies via Keplr's own Bitcoin indexer
+        // (api-indexer-bitcoin.keplr.app) and fails when that service is down.
+        const rawTxHex = bitcoin__namespace.Psbt.fromHex(signedPsbtHex)
+            .extractTransaction()
+            .toHex();
+        const txHash = await broadcastTx(rawTxHex);
+        if (!txHash) {
+            throw new BitcoinConnectorTransactionFailedError();
+        }
+        return { txHash };
+    }
+}
+
 const MAINNET = bitcoin__namespace.networks.bitcoin;
 class PhantomConnector {
     get getProvider() {
@@ -4878,10 +4898,8 @@ class PhantomConnector {
     async sendBTC(to, amount) {
         const { address } = await this.requestAccount();
         const { psbtHex } = await createSendBtcPsbt(address, to, amount);
-        const { txId } = await this.signPsbt(psbtHex);
-        if (!txId)
-            throw new BitcoinConnectorTransactionFailedError();
-        return { txHash: txId };
+        const { txHash } = await this.signPsbt(psbtHex);
+        return { txHash };
     }
     async signPsbt(psbtHex) {
         const { address: paymentAddress } = await this.requestAccount();
@@ -4902,8 +4920,10 @@ class PhantomConnector {
         const signedPsbt = bitcoin__namespace.Psbt.fromBuffer(signedPsbtBytes);
         signedPsbt.finalizeAllInputs();
         const tx = signedPsbt.extractTransaction();
-        const txId = await broadcastTx(tx.toHex());
-        return { txId };
+        const txHash = await broadcastTx(tx.toHex());
+        if (!txHash)
+            throw new BitcoinConnectorTransactionFailedError();
+        return { txHash };
     }
 }
 
@@ -4932,6 +4952,21 @@ class UnisatConnector {
             address: account,
         };
     }
+    async signPsbt(psbtHex) {
+        // UniSat signs and, with `autoFinalized` (the default), finalizes every
+        // input, returning the signed PSBT as a hex string.
+        // https://docs.unisat.io/dev/unisat-developer-center/unisat-wallet/api-list
+        const signedPsbtHex = await this.getProvider.signPsbt(psbtHex, {
+            autoFinalized: true,
+        });
+        // `pushPsbt` extracts the finalized transaction from the signed PSBT and
+        // broadcasts it, returning the transaction id.
+        const txHash = await this.getProvider.pushPsbt(signedPsbtHex);
+        if (!txHash) {
+            throw new BitcoinConnectorTransactionFailedError();
+        }
+        return { txHash };
+    }
 }
 
 var XrplTransactionType;
@@ -20570,7 +20605,7 @@ const walletIconBaseUrl = "https://raw.githubusercontent.com/0xsquid/assets/main
  * Returns the value of the property if found, otherwise undefined.
  */
 const accessProperty = (object, path) => {
-    const value = get$2(object, path);
+    const value = getProperty(object, path);
     if (value === undefined) {
         console.error(`Property "${path}" not found while reading object`, object);
     }
@@ -20898,6 +20933,16 @@ const fallbackWallets = [
             chrome: "https://chromewebstore.google.com/detail/console-wallet/lpnfhpbpmlobjlgkdmnjieeihjmihhjd",
         },
     },
+    {
+        chainType: squidTypes.ChainType.CANTON,
+        id: "nightly",
+        name: "Nightly",
+        connectorName: "Nightly",
+        icon: `${walletIconBaseUrl}/nightly.webp`,
+        links: {
+            chrome: "https://chromewebstore.google.com/detail/nightly/fiikommddbeccaoicoejoniammnalkfa",
+        },
+    },
 ];
 
 // Validation taken from Squid API repo
@@ -20919,6 +20964,32 @@ const isBitcoinAddressValid = (address) => {
     }
 };
 
+/**
+ * Format a Canton connector into a Squid {@link CantonWallet}. Shared by the
+ * announce-discovery and injected-provider paths.
+ */
+function formatCantonWallet({ connectorId, name, icon, connector, }) {
+    return {
+        name,
+        connectorId,
+        connectorName: name,
+        icon,
+        windowFlag: connectorId,
+        skipInstallCheck: true,
+        isInstalled: () => true,
+        isMultiChain: false,
+        type: squidTypes.ChainType.CANTON,
+        connector,
+    };
+}
+/**
+ * Append injected wallets that aren't already covered by an announce-discovered
+ * wallet with the same connectorId (in case a wallet later does both).
+ */
+function mergeInjectedCantonWallets(announced, injected) {
+    const seen = new Set(announced.map((w) => w.connectorId));
+    return [...announced, ...injected.filter((w) => !seen.has(w.connectorId))];
+}
 // Canton PartyID = address
 const CANTON_PARTY_ID_SEPARATOR = "::";
 /** Canton Coin's well-known token-standard instrument id (its address carries no id prefix). */
@@ -22894,21 +22965,21 @@ const resolveChainIdFromAsset = (asset, chains) => {
 };
 const getConfigWithDefaults = (config) => {
     return {
-        integratorId: get$2(config, "integratorId", defaultConfigValues.integratorId),
-        slippage: get$2(config, "slippage", defaultConfigValues.slippage),
-        collectFees: get$2(config, "collectFees", defaultConfigValues.collectFees),
-        apiUrl: get$2(config, "apiUrl", defaultConfigValues.apiUrl),
-        priceImpactWarnings: get$2(config, "priceImpactWarnings", defaultConfigValues.priceImpactWarnings),
-        initialAssets: get$2(config, "initialAssets", defaultConfigValues.initialAssets),
-        defaultTokensPerChain: get$2(config, "defaultTokensPerChain", defaultConfigValues.defaultTokensPerChain),
-        loadPreviousStateFromLocalStorage: get$2(config, "loadPreviousStateFromLocalStorage", defaultConfigValues.loadPreviousStateFromLocalStorage),
-        availableChains: get$2(config, "availableChains", defaultConfigValues.availableChains),
-        availableTokens: get$2(config, "availableTokens", defaultConfigValues.availableTokens),
-        disabledChains: get$2(config, "disabledChains", defaultConfigValues.disabledChains),
-        degenMode: get$2(config, "degenMode", defaultConfigValues.degenMode),
-        preHook: get$2(config, "preHook", defaultConfigValues.preHook),
-        postHook: get$2(config, "postHook", defaultConfigValues.postHook),
-        overrideGasRefundAddress: get$2(config, "overrideGasRefundAddress", defaultConfigValues.overrideGasRefundAddress),
+        integratorId: getProperty(config, "integratorId", defaultConfigValues.integratorId),
+        slippage: getProperty(config, "slippage", defaultConfigValues.slippage),
+        collectFees: getProperty(config, "collectFees", defaultConfigValues.collectFees),
+        apiUrl: getProperty(config, "apiUrl", defaultConfigValues.apiUrl),
+        priceImpactWarnings: getProperty(config, "priceImpactWarnings", defaultConfigValues.priceImpactWarnings),
+        initialAssets: getProperty(config, "initialAssets", defaultConfigValues.initialAssets),
+        defaultTokensPerChain: getProperty(config, "defaultTokensPerChain", defaultConfigValues.defaultTokensPerChain),
+        loadPreviousStateFromLocalStorage: getProperty(config, "loadPreviousStateFromLocalStorage", defaultConfigValues.loadPreviousStateFromLocalStorage),
+        availableChains: getProperty(config, "availableChains", defaultConfigValues.availableChains),
+        availableTokens: getProperty(config, "availableTokens", defaultConfigValues.availableTokens),
+        disabledChains: getProperty(config, "disabledChains", defaultConfigValues.disabledChains),
+        degenMode: getProperty(config, "degenMode", defaultConfigValues.degenMode),
+        preHook: getProperty(config, "preHook", defaultConfigValues.preHook),
+        postHook: getProperty(config, "postHook", defaultConfigValues.postHook),
+        overrideGasRefundAddress: getProperty(config, "overrideGasRefundAddress", defaultConfigValues.overrideGasRefundAddress),
     };
 };
 const randomIntFromInterval = (min, max) => {
@@ -23605,7 +23676,7 @@ const filterViewableTokens = (tokens, config, direction) => {
 };
 const getSecretNetworkBalances = async (chainData, cosmosAddress, squidTokens, keplrTypeWallet) => {
     const squidSecretTokens = squidTokens.filter((t) => t.chainId === CHAIN_IDS.SECRET);
-    const { fetchAllSecretBalances } = await Promise.resolve().then(function () { return require('./secretService-ICina23f.js'); });
+    const { fetchAllSecretBalances } = await Promise.resolve().then(function () { return require('./secretService-D70MRo5w.js'); });
     return fetchAllSecretBalances(chainData, cosmosAddress, squidSecretTokens, keplrTypeWallet);
 };
 function getTokenAssetsKey(token) {
@@ -26836,14 +26907,16 @@ class CantonBrowserConnector {
     client;
     listeners = { connect: new Set(), disconnect: new Set() };
     _accounts = [];
-    constructor(provider, win = window) {
+    constructor(provider, win = window, client) {
         this.providerId = provider.id;
         this.name = provider.name;
         this.target = provider.target ?? provider.id;
-        this.client = dapp.createCantonClient(new dapp.WindowTransport(win, {
-            target: this.target,
-            timeout: REQUEST_TIMEOUT_MS,
-        }));
+        this.client =
+            client ??
+                dapp.createCantonClient(new dapp.WindowTransport(win, {
+                    target: this.target,
+                    timeout: REQUEST_TIMEOUT_MS,
+                }));
     }
     get accounts() {
         return this._accounts;
@@ -26945,44 +27018,116 @@ async function discoverCantonProviders(timeoutMs = DEFAULT_DISCOVERY_TIMEOUT_MS,
 }
 
 /**
- * Discovers Canton browser-extension wallets via the CIP-103 announce protocol
- * (on mount and on window focus) and maps each to a {@link CantonWallet}.
+ * CIP-103 wallets that expose their provider as an injected `window` global
+ * instead of participating in the `canton:announceProvider` discovery protocol.
+ * Add an entry to support a new one.
+ */
+const INJECTED_CANTON_WALLETS = [
+    {
+        connectorId: "nightly",
+        name: "Nightly",
+        icon: `${walletIconBaseUrl}/nightly.webp`,
+        windowPath: "nightly.canton",
+    },
+];
+/**
+ * Adapts an injected CIP-103 `SpliceProvider` (the normative `request` API) to
+ * the {@link CantonClient} surface consumed by `CantonBrowserConnector`, so
+ * injected wallets reuse the same connector as announce-discovered ones.
+ */
+function cantonClientFromSpliceProvider(provider) {
+    return {
+        status: () => provider.request({ method: "status" }),
+        connect: () => provider.request({ method: "connect" }),
+        disconnect: () => provider.request({ method: "disconnect" }),
+        isConnected: () => provider.request({ method: "isConnected" }),
+        getActiveNetwork: () => provider.request({ method: "getActiveNetwork" }),
+        listAccounts: () => provider.request({ method: "listAccounts" }),
+        getPrimaryAccount: () => provider.request({ method: "getPrimaryAccount" }),
+        prepareExecute: (params) => provider.request({ method: "prepareExecute", params }),
+        prepareExecuteAndWait: (params) => provider.request({ method: "prepareExecuteAndWait", params }),
+        signMessage: (params) => provider.request({ method: "signMessage", params }),
+        ledgerApi: (params) => provider.request({ method: "ledgerApi", params }),
+    };
+}
+/**
+ * Detect installed injected Canton wallets by walking each registered
+ * `windowPath`, mirroring the `definedInWindow` install check used for other
+ * non-autodiscovered wallets.
+ */
+function discoverInjectedCantonWallets(win) {
+    const source = (typeof window !== "undefined" ? window : undefined);
+    if (!source)
+        return [];
+    return INJECTED_CANTON_WALLETS.flatMap((config) => {
+        const provider = getProperty(source, config.windowPath);
+        if (!provider || typeof provider.request !== "function")
+            return [];
+        return [{ config, provider }];
+    });
+}
+
+/**
+ * Discovers Canton browser-extension wallets and maps each to a
+ * {@link CantonWallet}: CIP-103 announce-protocol wallets (on mount and on
+ * window focus), plus injected wallets that ship the CIP-103 RPC surface as a
+ * `window` global instead of announcing (see `INJECTED_CANTON_WALLETS`).
  */
 function useCantonWallets() {
     const [wallets, setWallets] = React.useState([]);
-    const connectorCache = React.useRef(new Map());
-    const toWallet = React.useCallback((provider) => {
-        let connector = connectorCache.current.get(provider.id);
+    const announcedCache = React.useRef(new Map());
+    const injectedCache = React.useRef(new Map());
+    const toAnnouncedWallet = React.useCallback((provider) => {
+        let connector = announcedCache.current.get(provider.id);
         if (!connector) {
             connector = new CantonBrowserConnector(provider);
-            connectorCache.current.set(provider.id, connector);
+            announcedCache.current.set(provider.id, connector);
         }
-        return {
-            name: provider.name,
+        return formatCantonWallet({
             connectorId: provider.id,
-            connectorName: provider.name,
+            name: provider.name,
             icon: provider.icon,
-            windowFlag: provider.id,
-            skipInstallCheck: true,
-            isInstalled: () => true,
-            isMultiChain: false,
-            type: squidTypes.ChainType.CANTON,
             connector,
-        };
+        });
+    }, []);
+    const toInjectedWallet = React.useCallback(({ config, provider }) => {
+        // Rebuild if the wallet re-injects a new provider object (e.g. extension
+        // reload): the cached connector closes over the previous provider.
+        let entry = injectedCache.current.get(config.connectorId);
+        if (!entry || entry.provider !== provider) {
+            entry = {
+                connector: new CantonBrowserConnector({ id: config.connectorId, name: config.name, icon: config.icon }, window, cantonClientFromSpliceProvider(provider)),
+                provider,
+            };
+            injectedCache.current.set(config.connectorId, entry);
+        }
+        return formatCantonWallet({
+            connectorId: config.connectorId,
+            name: config.name,
+            icon: config.icon,
+            connector: entry.connector,
+        });
     }, []);
     const refresh = React.useCallback(async () => {
         if (typeof window === "undefined")
             return;
-        const providers = await discoverCantonProviders();
-        setWallets(providers.map(toWallet));
-    }, [toWallet]);
+        const announced = (await discoverCantonProviders()).map(toAnnouncedWallet);
+        const injected = discoverInjectedCantonWallets().map(toInjectedWallet);
+        setWallets(mergeInjectedCantonWallets(announced, injected));
+    }, [toAnnouncedWallet, toInjectedWallet]);
     React.useEffect(() => {
         refresh();
         if (typeof window === "undefined")
-            return;
+            return undefined;
         const onFocus = () => refresh();
         window.addEventListener("focus", onFocus);
-        return () => window.removeEventListener("focus", onFocus);
+        // Extensions may inject their global shortly after mount; re-check a couple
+        // of times so late injection surfaces without a focus change.
+        const retries = [500, 1500].map((ms) => window.setTimeout(refresh, ms));
+        return () => {
+            window.removeEventListener("focus", onFocus);
+            retries.forEach((id) => window.clearTimeout(id));
+        };
     }, [refresh]);
     return { wallets };
 }
@@ -27279,7 +27424,7 @@ function useStellarWallets() {
             try {
                 const { allowAllModules: initializeAllModules } = await import('@creit.tech/stellar-wallets-kit');
                 const { LedgerModule } = await import('@creit.tech/stellar-wallets-kit/modules/ledger.module.mjs');
-                const { formatStellarWallet } = await Promise.resolve().then(function () { return require('./stellarService.client-Bjc92sC_.js'); });
+                const { formatStellarWallet } = await Promise.resolve().then(function () { return require('./stellarService.client-DhwF4F1c.js'); });
                 const modules = [...initializeAllModules(), new LedgerModule()];
                 const promises = modules.map(async (module) => {
                     const isAvailable = await module.isAvailable();
@@ -30738,7 +30883,7 @@ function hederaWalletConnect(parameters) {
                 const optionalChains = config.chains.map((x) => x.id);
                 if (!optionalChains.length)
                     return;
-                const { EthereumProvider } = await Promise.resolve().then(function () { return require('./index.es-BPXYaraD.js'); });
+                const { EthereumProvider } = await Promise.resolve().then(function () { return require('./index.es-DaKI7v5_.js'); });
                 const rawProvider = await EthereumProvider.init({
                     ...restParameters,
                     disableProviderPing: true,
@@ -37465,47 +37610,83 @@ const useExecuteTransaction = (squidRoute) => {
         }
     });
     const swapMutationBitcoin = reactQuery.useMutation(async ({ id, route }) => {
-        const { depositAddress, amount: sendAmount, statusTrackingId, } = useDepositAddressStore.getState().deposit ?? {};
-        if (!depositAddress) {
-            throw new Error(`Invalid deposit address: ${depositAddress}`);
-        }
-        if (!sendAmount) {
-            throw new Error(`Invalid send amount: ${sendAmount}`);
+        if (!bitcoinSigner || !route?.transactionRequest) {
+            throw new Error("Need all parameters");
         }
-        const allParamsValid = route && bitcoinSigner && depositAddress && sendAmount;
-        await changeNetworkIfNeeded.mutateAsync();
-        if (allParamsValid) {
-            dispatchSignatureRequestEvent(route);
-            const { txHash } = await bitcoinSigner.sendBTC(depositAddress, Number(sendAmount));
-            if (txHash) {
-                resetQueriesAfterTxSigned();
+        switch (route.transactionRequest.type) {
+            case squidTypes.SquidDataType.ChainflipDepositAddress: {
+                const { depositAddress, amount: sendAmount, statusTrackingId, } = useDepositAddressStore.getState().deposit ?? {};
+                const allParamsValid = route && bitcoinSigner && depositAddress && sendAmount;
+                if (!allParamsValid) {
+                    throw new Error("Need all parameters");
+                }
+                await changeNetworkIfNeeded.mutateAsync();
+                dispatchSignatureRequestEvent(route);
+                const { txHash } = await bitcoinSigner.sendBTC(depositAddress, Number(sendAmount));
+                if (txHash) {
+                    resetQueriesAfterTxSigned();
+                }
+                // Dispatch event so it can be listened from outside the widget
+                WidgetEvents.getInstance().dispatchSwapExecuteCall(route, txHash);
+                if (route.transactionRequest) {
+                    const txParams = setTransactionState({
+                        route,
+                        txHash,
+                        // When bridging from Bitcoin we need to send the chainflipId to the status endpoint
+                        // instead of the Bitcoin transaction hash
+                        transactionIdForStatus: statusTrackingId,
+                        userAddress: sourceUserAddress,
+                        status: exports.TransactionStatus.INITIAL_LOADING,
+                        sourceStatus: exports.TransactionStatus.ONGOING,
+                        axelarUrl: undefined,
+                        id,
+                    });
+                    if (txParams) {
+                        addSwapTransaction({
+                            ...txParams,
+                            params: route.params,
+                            estimate: route.estimate,
+                        });
+                    }
+                }
+                break;
             }
-            // Dispatch event so it can be listened from outside the widget
-            WidgetEvents.getInstance().dispatchSwapExecuteCall(route, txHash);
-            if (route.transactionRequest) {
-                const txParams = setTransactionState({
-                    route,
-                    txHash,
-                    // When bridging from Bitcoin we need to send the chainflipId to the status endpoint
-                    // instead of the Bitcoin transaction hash
-                    transactionIdForStatus: statusTrackingId,
-                    userAddress: sourceUserAddress,
-                    status: exports.TransactionStatus.INITIAL_LOADING,
-                    sourceStatus: exports.TransactionStatus.ONGOING,
-                    axelarUrl: undefined,
-                    id,
-                });
-                if (txParams) {
-                    addSwapTransaction({
-                        ...txParams,
-                        params: route.params,
-                        estimate: route.estimate,
+            case squidTypes.SquidDataType.DepositAddressCalldata: {
+                if (!isOnChainTxData(route.transactionRequest)) {
+                    throw new Error("Invalid route data");
+                }
+                const { data: transactionHex } = route.transactionRequest;
+                await changeNetworkIfNeeded.mutateAsync();
+                dispatchSignatureRequestEvent(route);
+                const { txHash } = await bitcoinSigner.signPsbt(transactionHex);
+                if (txHash) {
+                    resetQueriesAfterTxSigned();
+                }
+                // Dispatch event so it can be listened from outside the widget
+                WidgetEvents.getInstance().dispatchSwapExecuteCall(route, txHash);
+                if (route.transactionRequest) {
+                    const txParams = setTransactionState({
+                        route,
+                        txHash,
+                        userAddress: sourceUserAddress,
+                        status: exports.TransactionStatus.INITIAL_LOADING,
+                        sourceStatus: exports.TransactionStatus.ONGOING,
+                        axelarUrl: undefined,
+                        id,
                     });
+                    if (txParams) {
+                        addSwapTransaction({
+                            ...txParams,
+                            params: route.params,
+                            estimate: route.estimate,
+                        });
+                    }
                 }
+                break;
+            }
+            default: {
+                throw new Error(`Unhandled route type ${route.transactionRequest.type}`);
             }
-        }
-        else {
-            throw new Error("Need all parameters");
         }
     });
     const swapMutationXrpl = reactQuery.useMutation(async ({ id, route }) => {
@@ -38811,6 +38992,7 @@ exports.isXionSmartContractAddress = isXionSmartContractAddress;
 exports.isXrplAddressValid = isXrplAddressValid;
 exports.mergeWallets = mergeWallets;
 exports.nativeBitcoinTokenAddress = nativeBitcoinTokenAddress;
+exports.nativeCantonTokenAddress = nativeCantonTokenAddress;
 exports.nativeCosmosTokenAddress = nativeCosmosTokenAddress;
 exports.nativeEvmTokenAddress = nativeEvmTokenAddress;
 exports.nativeSolanaTokenAddress = nativeSolanaTokenAddress;
@@ -38932,4 +39114,4 @@ exports.useXrplTrustLine = useXrplTrustLine;
 exports.waitForReceiptWithRetry = waitForReceiptWithRetry;
 exports.walletIconBaseUrl = walletIconBaseUrl;
 exports.walletSupportsChainType = walletSupportsChainType;
-//# sourceMappingURL=index-Dzir2lUQ.js.map
+//# sourceMappingURL=index-BzTFES6t.js.map