@0xsquid/react-hooks 8.7.0 → 8.7.2-beta-bitcoin-solana-xrpl.0

package/dist/{index-BOMoTOCH.js → index-CpphPhUS.js}

@@ -4756,6 +4756,9 @@ class KeplrConnector {
             address: account,
         };
     }
+    async signPsbt(_) {
+        throw new Error("Method not implemented.");
+    }
 }
 
 bitcoin__namespace.initEccLib(ecc__namespace);
@@ -4870,10 +4873,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();
@@ -4894,8 +4895,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 };
     }
 }
 
@@ -4924,6 +4927,9 @@ class UnisatConnector {
             address: account,
         };
     }
+    async signPsbt(_) {
+        throw new Error("Method not implemented.");
+    }
 }
 
 var XrplTransactionType;
@@ -21074,6 +21080,7 @@ const formatSwapTxStatusResponseForStorage = (sr) => {
     }
     return {
         axelarTransactionUrl: sr.axelarTransactionUrl,
+        coralTransactionUrl: sr.coralTransactionUrl,
         toChain: sr.toChain?.transactionUrl
             ? {
                 transactionUrl: sr.toChain?.transactionUrl,
@@ -21133,10 +21140,6 @@ function isCoralBridgeAction(action) {
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
-const isDepositRoute = (route) => {
-    return (!!route &&
-        route.transactionRequest?.type === squidTypes.SquidDataType.ChainflipDepositAddress);
-};
 /**
  * Checks if the route contains a Chainflip bridge action
  */
@@ -21344,11 +21347,11 @@ const isSolanaAddressValid = (address) => {
  * Execute a Solana swap transaction
  * This will be used for the swap flow - Using Jupiter Dex under the hood
  */
-const executeSolanaSwap = async ({ route, signer, connection, onSigned, }) => {
-    if (!route.transactionRequest || !isOnChainTxData(route.transactionRequest)) {
-        throw new Error("Invalid parameters");
+const executeSolanaSwap = async ({ transactionRequest, signer, connection, }) => {
+    if (!isOnChainTxData(transactionRequest)) {
+        throw new Error("Invalid transaction request");
     }
-    const swapRequest = route.transactionRequest.data;
+    const swapRequest = transactionRequest.data;
     const swapTransactionBuf = Buffer.from(swapRequest, "base64");
     // TODO: fix types
     // const transaction = VersionedTransaction.deserialize(
@@ -21356,15 +21359,9 @@ const executeSolanaSwap = async ({ route, signer, connection, onSigned, }) => {
     // );
     const transaction = web3_js.VersionedTransaction.deserialize(swapTransactionBuf);
     try {
-        const latestBlockhash = await connection.getLatestBlockhash();
+        const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash();
         const signature = await signer.sendTransaction(transaction, connection);
-        onSigned?.(signature);
-        await connection.confirmTransaction({
-            signature,
-            blockhash: latestBlockhash.blockhash,
-            lastValidBlockHeight: latestBlockhash.lastValidBlockHeight,
-        });
-        return signature;
+        return { signature, blockhash, lastValidBlockHeight };
     }
     catch (error) {
         console.error("Solana swap failed:", error);
@@ -21378,10 +21375,9 @@ const executeSolanaSwap = async ({ route, signer, connection, onSigned, }) => {
  * @param signer - Solana wallet adapter instance
  * @param connection - Solana RPC connection
  * @param sourceToken - Token information (undefined for native SOL)
- * @param onSigned - Optional callback triggered when transaction is signed
  * @returns Transaction signature
  */
-const executeSolanaTransfer = async ({ amount, target, signer, connection, sourceToken, onSigned, }) => {
+const executeSolanaTransfer = async ({ amount, target, signer, connection, sourceToken, }) => {
     // Validate signer and target address
     if (!signer.publicKey) {
         throw new Error("Signer public key not found");
@@ -21421,15 +21417,17 @@ const executeSolanaTransfer = async ({ amount, target, signer, connection, sourc
     transaction.recentBlockhash = blockhash;
     transaction.feePayer = signer.publicKey;
     const signature = await signer.sendTransaction(transaction, connection);
-    // Trigger callback for UI purposes (show loading state)
-    onSigned?.(signature);
-    // Wait for transaction confirmation
-    await connection.confirmTransaction({
-        signature,
-        blockhash,
-        lastValidBlockHeight,
-    });
-    return signature;
+    return { signature, blockhash, lastValidBlockHeight };
+};
+const executeSolanaDepositAddressCalldata = async ({ transactionRequest, signer, connection, }) => {
+    if (!isOnChainTxData(transactionRequest)) {
+        throw new Error("Invalid transaction request");
+    }
+    const tx = web3_js.Transaction.from(Buffer.from(transactionRequest.data, "base64"));
+    const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash();
+    tx.recentBlockhash = blockhash;
+    const signature = await signer.sendTransaction(tx, connection);
+    return { signature, blockhash, lastValidBlockHeight };
 };
 
 var StellarHorizonAssetType;
@@ -23314,7 +23312,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-0Y9Bj_Ic.js'); });
+    const { fetchAllSecretBalances } = await Promise.resolve().then(function () { return require('./secretService-DN6Mr9e8.js'); });
     return fetchAllSecretBalances(chainData, cosmosAddress, squidSecretTokens, keplrTypeWallet);
 };
 function getTokenAssetsKey(token) {
@@ -26712,7 +26710,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');
-                const { formatStellarWallet } = await Promise.resolve().then(function () { return require('./stellarService.client-Dyichswq.js'); });
+                const { formatStellarWallet } = await Promise.resolve().then(function () { return require('./stellarService.client-CybwDtEp.js'); });
                 const modules = [...initializeAllModules(), new LedgerModule()];
                 const promises = modules.map(async (module) => {
                     const isAvailable = await module.isAvailable();
@@ -29355,7 +29353,6 @@ function timeout(ms, promise) {
 
 const DEFAULT_REFRESH_INTERVAL_MS$1 = 15000;
 const useEvmBalance = ({ chain, token, userAddress, enabled = true, refreshIntervalMs = DEFAULT_REFRESH_INTERVAL_MS$1, }) => {
-    const { isChainTypeConnected } = useWallet();
     const isNativeToken = token?.address.toLowerCase() === nativeEvmTokenAddress.toLowerCase();
     const userAddressParsed = userAddress;
     // Only fetch using useBalance if it's a native token
@@ -29368,7 +29365,7 @@ const useEvmBalance = ({ chain, token, userAddress, enabled = true, refreshInter
                 isNativeToken &&
                 !!chain &&
                 chain.chainType === squidTypes.ChainType.EVM &&
-                isChainTypeConnected(chain.chainType),
+                isWalletAddressValid(chain, userAddress),
             refetchInterval: refreshIntervalMs,
             retry: 2,
         },
@@ -29382,10 +29379,10 @@ const useEvmBalance = ({ chain, token, userAddress, enabled = true, refreshInter
         args: [userAddressParsed],
         chainId: Number(chain?.chainId),
         query: {
-            enabled: isChainTypeConnected(squidTypes.ChainType.EVM) &&
-                enabled &&
+            enabled: enabled &&
                 !!userAddress &&
-                !isNativeToken,
+                !isNativeToken &&
+                isWalletAddressValid(chain, userAddress),
             refetchInterval: refreshIntervalMs,
             retry: 2,
         },
@@ -29555,12 +29552,12 @@ function useNativeTokenForChain(chain) {
 }
 
 const useEvmNativeBalance = ({ address, chain, }) => {
-    const { isChainTypeConnected } = useWallet();
     const { data: nativeEvmBalance, isLoading } = wagmi.useBalance({
         address: address,
         chainId: Number(chain?.chainId),
         query: {
-            enabled: isChainTypeConnected(squidTypes.ChainType.EVM) && !!address,
+            enabled: chain?.chainType === squidTypes.ChainType.EVM &&
+                isWalletAddressValid(chain, address),
             refetchInterval: 10000,
             staleTime: 5000,
             refetchOnWindowFocus: true,
@@ -29582,13 +29579,13 @@ const useEvmNativeBalance = ({ address, chain, }) => {
     };
 };
 const useCosmosNativeBalance = ({ address, chain, }) => {
-    const { isConnected: isCosmosConnected } = useCosmosContext();
     const { nativeToken: nativeCosmosToken } = useNativeTokenForChain(chain);
     const { balance: rawBalance, isLoading } = useCosmosBalance({
         chain,
         token: nativeCosmosToken,
         userAddress: address,
-        enabled: isCosmosConnected && chain?.chainType === squidTypes.ChainType.COSMOS,
+        enabled: chain?.chainType === squidTypes.ChainType.COSMOS &&
+            isWalletAddressValid(chain, address),
         refreshIntervalMs: 10000,
     });
     const balance = React.useMemo(() => {
@@ -29636,9 +29633,9 @@ const useSolanaNativeBalance = ({ chain, address, }) => {
         const balance = await getSolanaNativeBalance(address);
         return formatBNToReadable(balance, nativeToken.decimals);
     }, {
-        enabled: !!address &&
-            nativeToken?.decimals != null &&
-            chain?.chainType === squidTypes.ChainType.SOLANA,
+        enabled: nativeToken?.decimals != null &&
+            chain?.chainType === squidTypes.ChainType.SOLANA &&
+            isWalletAddressValid(chain, address),
         refetchInterval: 40000,
         staleTime: 20000,
         refetchOnWindowFocus: true,
@@ -29663,6 +29660,8 @@ const useSuiNativeBalance = ({ address, chain, }) => {
         chain,
         token: nativeToken,
         userAddress: address,
+        enabled: chain?.chainType === squidTypes.ChainType.SUI &&
+            isWalletAddressValid(chain, address),
     });
     const balance = React.useMemo(() => {
         if (nativeToken?.decimals && rawBalance) {
@@ -29683,7 +29682,8 @@ const useXrplNativeBalance = ({ address, chain, }) => {
         chain,
         token: nativeToken,
         userAddress: address,
-        enabled: chain?.chainType === squidTypes.ChainType.XRPL,
+        enabled: chain?.chainType === squidTypes.ChainType.XRPL &&
+            isWalletAddressValid(chain, address),
     });
     const balance = React.useMemo(() => {
         if (nativeToken?.decimals && rawBalance) {
@@ -29704,7 +29704,8 @@ const useStellarNativeBalance = ({ address, chain, }) => {
         chain,
         token: nativeToken,
         userAddress: address,
-        enabled: chain?.chainType === squidTypes.ChainType.STELLAR,
+        enabled: chain?.chainType === squidTypes.ChainType.STELLAR &&
+            isWalletAddressValid(chain, address),
     });
     const balance = React.useMemo(() => {
         if (nativeToken?.decimals && rawBalance) {
@@ -30032,7 +30033,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-Bx1b09ob.js'); });
+                const { EthereumProvider } = await Promise.resolve().then(function () { return require('./index.es-BOb7ZHW7.js'); });
                 const rawProvider = await EthereumProvider.init({
                     ...restParameters,
                     disableProviderPing: true,
@@ -31844,7 +31845,7 @@ async function sendTransactionCosmos({ amount, rpcUrl, signer, to, token, native
 }
 async function sendTransactionSolana({ signer, amount, to, token, connection, }) {
     const amountBn = BigInt(amount);
-    const txHash = await executeSolanaTransfer({
+    const { signature: txHash } = await executeSolanaTransfer({
         amount: amountBn,
         connection,
         signer,
@@ -36168,7 +36169,7 @@ const useExecuteTransaction = (squidRoute) => {
     });
     const swapMutationSolana = reactQuery.useMutation(async ({ id, route }) => {
         try {
-            if (!route) {
+            if (!route?.transactionRequest) {
                 throw new Error("Route is required");
             }
             if (!solanaSigner) {
@@ -36177,69 +36178,69 @@ const useExecuteTransaction = (squidRoute) => {
             if (!route.params.fromAddress || !route.params.toAddress) {
                 throw new Error("From or to address is required");
             }
-            const isDirectTransfer = isDepositRoute(route);
-            // Means it's a transfer to a deposit address
-            // Instead of a Swap/Contract call using a DEX like Jupiter
-            if (isDirectTransfer) {
-                // Get the deposit address from the squidRoute
-                const depositData = useDepositAddressStore.getState().deposit;
-                // Validate params
-                if (!depositData?.depositAddress) {
-                    throw new Error("Deposit address is required");
+            let txResult;
+            let transactionIdForStatus;
+            switch (route.transactionRequest.type) {
+                case squidTypes.SquidDataType.ChainflipDepositAddress: {
+                    // Means it's a transfer to a deposit address
+                    // Instead of a Swap/Contract call using a DEX like Jupiter
+                    const depositData = useDepositAddressStore.getState().deposit;
+                    if (!depositData?.depositAddress) {
+                        throw new Error("Deposit address is required");
+                    }
+                    txResult = await executeSolanaTransfer({
+                        amount: BigInt(route.params.fromAmount),
+                        target: depositData.depositAddress,
+                        signer: solanaSigner,
+                        connection: solanaConnection,
+                        sourceToken: findToken(route.params.fromToken, route.params.fromChain),
+                    });
+                    transactionIdForStatus = depositData.chainflipStatusTrackingId;
+                    break;
+                }
+                case squidTypes.SquidDataType.OnChainExecution: {
+                    txResult = await executeSolanaSwap({
+                        transactionRequest: route.transactionRequest,
+                        signer: solanaSigner,
+                        connection: solanaConnection,
+                    });
+                    break;
+                }
+                case squidTypes.SquidDataType.DepositAddressCalldata: {
+                    txResult = await executeSolanaDepositAddressCalldata({
+                        transactionRequest: route.transactionRequest,
+                        signer: solanaSigner,
+                        connection: solanaConnection,
+                    });
+                    break;
+                }
+                default: {
+                    throw new Error(`Unhandled transaction type: ${route.transactionRequest.type}`);
                 }
-                const signature = await executeSolanaTransfer({
-                    amount: BigInt(route.params.fromAmount),
-                    target: depositData.depositAddress,
-                    signer: solanaSigner,
-                    connection: solanaConnection,
-                    sourceToken: findToken(route.params.fromToken, route?.params?.fromChain),
-                    onSigned: (txHash) => {
-                        WidgetEvents.getInstance().dispatchSwapExecuteCall(route, txHash);
-                        const txParams = setTransactionState({
-                            route,
-                            txHash,
-                            transactionIdForStatus: depositData.chainflipStatusTrackingId,
-                            userAddress: sourceUserAddress,
-                            status: exports.TransactionStatus.INITIAL_LOADING,
-                            sourceStatus: exports.TransactionStatus.ONGOING,
-                            id,
-                        });
-                        if (txParams) {
-                            addSwapTransaction({
-                                ...txParams,
-                                params: route.params,
-                                estimate: route.estimate,
-                            });
-                        }
-                    },
-                });
-                return signature;
             }
-            const signature = await executeSolanaSwap({
+            const { signature: txHash, blockhash, lastValidBlockHeight } = txResult;
+            WidgetEvents.getInstance().dispatchSwapExecuteCall(route, txHash);
+            const txParams = setTransactionState({
                 route,
-                signer: solanaSigner,
-                connection: solanaConnection,
-                onSigned: (txHash) => {
-                    WidgetEvents.getInstance().dispatchSwapExecuteCall(route, txHash);
-                    const txParams = setTransactionState({
-                        route,
-                        txHash,
-                        transactionIdForStatus: undefined,
-                        userAddress: sourceUserAddress,
-                        status: exports.TransactionStatus.INITIAL_LOADING,
-                        sourceStatus: exports.TransactionStatus.ONGOING,
-                        id,
-                    });
-                    if (txParams) {
-                        addSwapTransaction({
-                            ...txParams,
-                            params: route.params,
-                            estimate: route.estimate,
-                        });
-                    }
-                },
+                txHash,
+                userAddress: sourceUserAddress,
+                status: exports.TransactionStatus.INITIAL_LOADING,
+                sourceStatus: exports.TransactionStatus.ONGOING,
+                id,
+                transactionIdForStatus,
+            });
+            if (txParams) {
+                addSwapTransaction({
+                    ...txParams,
+                    params: route.params,
+                    estimate: route.estimate,
+                });
+            }
+            await solanaConnection.confirmTransaction({
+                blockhash,
+                lastValidBlockHeight,
+                signature: txHash,
             });
-            return signature;
         }
         catch (error) {
             console.error("Solana transaction failed:", error);
@@ -36286,47 +36287,91 @@ const useExecuteTransaction = (squidRoute) => {
         },
     });
     const swapMutationBitcoin = reactQuery.useMutation(async ({ id, route }) => {
-        const { depositAddress, amount: sendAmount, chainflipStatusTrackingId, } = useDepositAddressStore.getState().deposit ?? {};
-        if (!depositAddress) {
-            throw new Error(`Invalid deposit address: ${depositAddress}`);
-        }
-        if (!sendAmount) {
-            throw new Error(`Invalid send amount: ${sendAmount}`);
+        console.log("Validating route", {
+            bitcoinSigner,
+            route,
+        });
+        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, chainflipStatusTrackingId, } = 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: chainflipStatusTrackingId,
+                        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: chainflipStatusTrackingId,
-                    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: {
+                console.log(`Route type: ${route.transactionRequest?.type}`);
+                if (!isOnChainTxData(route.transactionRequest)) {
+                    console.log("Invalid route data", route.transactionRequest);
+                    throw new Error("Invalid route data");
+                }
+                const { data: transactionHex } = route.transactionRequest;
+                await changeNetworkIfNeeded.mutateAsync();
+                dispatchSignatureRequestEvent(route);
+                console.log("Signing psbt", { transactionHex });
+                const { txHash } = await bitcoinSigner.signPsbt(transactionHex);
+                console.log("Signed psbt", { txHash });
+                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 }) => {
@@ -37513,6 +37558,7 @@ exports.createQuoteRequestParamsHash = createQuoteRequestParamsHash;
 exports.definedInWindow = definedInWindow;
 exports.destinationAddressResetValue = destinationAddressResetValue;
 exports.er = er;
+exports.executeSolanaDepositAddressCalldata = executeSolanaDepositAddressCalldata;
 exports.executeSolanaSwap = executeSolanaSwap;
 exports.executeSolanaTransfer = executeSolanaTransfer;
 exports.fallbackAddressResetValue = fallbackAddressResetValue;
@@ -37590,7 +37636,6 @@ exports.is404Error = is404Error;
 exports.isChainflipBridgeTransaction = isChainflipBridgeTransaction;
 exports.isCoralBridgeAction = isCoralBridgeAction;
 exports.isCosmosAddressValid = isCosmosAddressValid;
-exports.isDepositRoute = isDepositRoute;
 exports.isEmptyObject = isEmptyObject;
 exports.isEvmChainNotSupportedError = isEvmChainNotSupportedError;
 exports.isEvmosChain = isEvmosChain;
@@ -37736,4 +37781,4 @@ exports.useXrplTrustLine = useXrplTrustLine;
 exports.waitForReceiptWithRetry = waitForReceiptWithRetry;
 exports.walletIconBaseUrl = walletIconBaseUrl;
 exports.walletSupportsChainType = walletSupportsChainType;
-//# sourceMappingURL=index-BOMoTOCH.js.map
+//# sourceMappingURL=index-CpphPhUS.js.map