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

package/dist/core/connectors/bitcoin/wallets/keplr.d.ts

@@ -8,4 +8,7 @@ export declare class KeplrConnector implements BitcoinConnector {
     requestAccount(): Promise<{
         address: string;
     }>;
+    signPsbt(_: string): Promise<{
+        txHash: string;
+    }>;
 }

package/dist/core/connectors/bitcoin/wallets/phantom.d.ts

@@ -22,6 +22,8 @@ export declare class PhantomConnector implements BitcoinConnector {
     sendBTC(to: string, amount: number): Promise<{
         txHash: string;
     }>;
-    private signPsbt;
+    signPsbt(psbtHex: string): Promise<{
+        txHash: string;
+    }>;
 }
 export {};

package/dist/core/connectors/bitcoin/wallets/unisat.d.ts

@@ -11,5 +11,8 @@ export declare class UnisatConnector implements BitcoinConnector {
     requestAccount(): Promise<{
         address: string;
     }>;
+    signPsbt(_: string): Promise<{
+        txHash: string;
+    }>;
 }
 export {};

package/dist/core/types/bitcoin.d.ts

@@ -2,6 +2,9 @@ export interface BitcoinConnector {
     sendBTC(to: string, amount: number): Promise<{
         txHash: string;
     }>;
+    signPsbt(psbtHex: string): Promise<{
+        txHash: string;
+    }>;
     requestAccount(): Promise<{
         address: string;
     }>;

package/dist/core/types/history.d.ts

@@ -1,7 +1,7 @@
 import { ChainType, StatusResponse } from "@0xsquid/squid-types";
 import { OnRampTransactionStatusType } from "./onramps";
 import { SendTransactionStatus, SimplifiedRouteAction, TransactionStatus } from "./transaction";
-type SimplifiedStatusResponse = Pick<StatusResponse, "axelarTransactionUrl"> & {
+type SimplifiedStatusResponse = Pick<StatusResponse, "axelarTransactionUrl" | "coralTransactionUrl"> & {
     toChain?: Pick<NonNullable<StatusResponse["toChain"]>, "transactionUrl"> | undefined;
 };
 export type SwapTransactionHistory = {

package/dist/hooks/transaction/useExecuteTransaction.d.ts

@@ -1,4 +1,4 @@
-import type { RouteResponse } from "@0xsquid/squid-types";
+import { type RouteResponse } from "@0xsquid/squid-types";
 export declare const useExecuteTransaction: (squidRoute?: RouteResponse["route"]) => {
     executeSwap: () => Promise<void>;
     cancelSwap: () => void;

package/dist/{index-CpHc3uRR.js → index-BOXqAr2r.js}

@@ -1,4 +1,4 @@
-import { ChainType, ActionType, SquidDataType, BridgeType, BridgeProvider, FeeType } from '@0xsquid/squid-types';
+import { ChainType, ActionType, BridgeType, SquidDataType, BridgeProvider, FeeType } from '@0xsquid/squid-types';
 import { zeroAddress as zeroAddress$1, parseUnits, formatUnits, isAddress, SwitchChainError, UserRejectedRequestError, erc20Abi, getAddress, defineChain, encodeFunctionData } from 'viem';
 import React, { useMemo, useCallback, useState, useEffect, createContext, useContext, useRef } from 'react';
 import { useQuery, useMutation, useQueries, useQueryClient, QueryClient, QueryClientProvider } from '@tanstack/react-query';
@@ -4735,6 +4735,9 @@ class KeplrConnector {
             address: account,
         };
     }
+    async signPsbt(_) {
+        throw new Error("Method not implemented.");
+    }
 }
 
 bitcoin.initEccLib(ecc);
@@ -4849,10 +4852,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();
@@ -4873,8 +4874,10 @@ class PhantomConnector {
         const signedPsbt = bitcoin.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 };
     }
 }
 
@@ -4903,6 +4906,9 @@ class UnisatConnector {
             address: account,
         };
     }
+    async signPsbt(_) {
+        throw new Error("Method not implemented.");
+    }
 }
 
 var XrplTransactionType;
@@ -21053,6 +21059,7 @@ const formatSwapTxStatusResponseForStorage = (sr) => {
     }
     return {
         axelarTransactionUrl: sr.axelarTransactionUrl,
+        coralTransactionUrl: sr.coralTransactionUrl,
         toChain: sr.toChain?.transactionUrl
             ? {
                 transactionUrl: sr.toChain?.transactionUrl,
@@ -21112,10 +21119,6 @@ function isCoralBridgeAction(action) {
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
-const isDepositRoute = (route) => {
-    return (!!route &&
-        route.transactionRequest?.type === SquidDataType.ChainflipDepositAddress);
-};
 /**
  * Checks if the route contains a Chainflip bridge action
  */
@@ -21323,11 +21326,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(
@@ -21335,15 +21338,9 @@ const executeSolanaSwap = async ({ route, signer, connection, onSigned, }) => {
     // );
     const transaction = 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);
@@ -21357,10 +21354,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");
@@ -21400,15 +21396,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 = 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;
@@ -23293,7 +23291,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 import('./secretService-DnKMq9Ib.js');
+    const { fetchAllSecretBalances } = await import('./secretService-Dg30HRy1.js');
     return fetchAllSecretBalances(chainData, cosmosAddress, squidSecretTokens, keplrTypeWallet);
 };
 function getTokenAssetsKey(token) {
@@ -26691,7 +26689,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 import('./stellarService.client-B3kAxROD.js');
+                const { formatStellarWallet } = await import('./stellarService.client-B9bDVrW_.js');
                 const modules = [...initializeAllModules(), new LedgerModule()];
                 const promises = modules.map(async (module) => {
                     const isAvailable = await module.isAvailable();
@@ -29334,7 +29332,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
@@ -29347,7 +29344,7 @@ const useEvmBalance = ({ chain, token, userAddress, enabled = true, refreshInter
                 isNativeToken &&
                 !!chain &&
                 chain.chainType === ChainType.EVM &&
-                isChainTypeConnected(chain.chainType),
+                isWalletAddressValid(chain, userAddress),
             refetchInterval: refreshIntervalMs,
             retry: 2,
         },
@@ -29361,10 +29358,10 @@ const useEvmBalance = ({ chain, token, userAddress, enabled = true, refreshInter
         args: [userAddressParsed],
         chainId: Number(chain?.chainId),
         query: {
-            enabled: isChainTypeConnected(ChainType.EVM) &&
-                enabled &&
+            enabled: enabled &&
                 !!userAddress &&
-                !isNativeToken,
+                !isNativeToken &&
+                isWalletAddressValid(chain, userAddress),
             refetchInterval: refreshIntervalMs,
             retry: 2,
         },
@@ -29534,12 +29531,12 @@ function useNativeTokenForChain(chain) {
 }
 
 const useEvmNativeBalance = ({ address, chain, }) => {
-    const { isChainTypeConnected } = useWallet();
     const { data: nativeEvmBalance, isLoading } = useBalance({
         address: address,
         chainId: Number(chain?.chainId),
         query: {
-            enabled: isChainTypeConnected(ChainType.EVM) && !!address,
+            enabled: chain?.chainType === ChainType.EVM &&
+                isWalletAddressValid(chain, address),
             refetchInterval: 10000,
             staleTime: 5000,
             refetchOnWindowFocus: true,
@@ -29561,13 +29558,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 === ChainType.COSMOS,
+        enabled: chain?.chainType === ChainType.COSMOS &&
+            isWalletAddressValid(chain, address),
         refreshIntervalMs: 10000,
     });
     const balance = useMemo(() => {
@@ -29615,9 +29612,9 @@ const useSolanaNativeBalance = ({ chain, address, }) => {
         const balance = await getSolanaNativeBalance(address);
         return formatBNToReadable(balance, nativeToken.decimals);
     }, {
-        enabled: !!address &&
-            nativeToken?.decimals != null &&
-            chain?.chainType === ChainType.SOLANA,
+        enabled: nativeToken?.decimals != null &&
+            chain?.chainType === ChainType.SOLANA &&
+            isWalletAddressValid(chain, address),
         refetchInterval: 40000,
         staleTime: 20000,
         refetchOnWindowFocus: true,
@@ -29642,6 +29639,8 @@ const useSuiNativeBalance = ({ address, chain, }) => {
         chain,
         token: nativeToken,
         userAddress: address,
+        enabled: chain?.chainType === ChainType.SUI &&
+            isWalletAddressValid(chain, address),
     });
     const balance = useMemo(() => {
         if (nativeToken?.decimals && rawBalance) {
@@ -29662,7 +29661,8 @@ const useXrplNativeBalance = ({ address, chain, }) => {
         chain,
         token: nativeToken,
         userAddress: address,
-        enabled: chain?.chainType === ChainType.XRPL,
+        enabled: chain?.chainType === ChainType.XRPL &&
+            isWalletAddressValid(chain, address),
     });
     const balance = useMemo(() => {
         if (nativeToken?.decimals && rawBalance) {
@@ -29683,7 +29683,8 @@ const useStellarNativeBalance = ({ address, chain, }) => {
         chain,
         token: nativeToken,
         userAddress: address,
-        enabled: chain?.chainType === ChainType.STELLAR,
+        enabled: chain?.chainType === ChainType.STELLAR &&
+            isWalletAddressValid(chain, address),
     });
     const balance = useMemo(() => {
         if (nativeToken?.decimals && rawBalance) {
@@ -30011,7 +30012,7 @@ function hederaWalletConnect(parameters) {
                 const optionalChains = config.chains.map((x) => x.id);
                 if (!optionalChains.length)
                     return;
-                const { EthereumProvider } = await import('./index.es-DYEb3pTJ.js');
+                const { EthereumProvider } = await import('./index.es-DBsq8Frv.js');
                 const rawProvider = await EthereumProvider.init({
                     ...restParameters,
                     disableProviderPing: true,
@@ -31823,7 +31824,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,
@@ -36147,7 +36148,7 @@ const useExecuteTransaction = (squidRoute) => {
     });
     const swapMutationSolana = useMutation(async ({ id, route }) => {
         try {
-            if (!route) {
+            if (!route?.transactionRequest) {
                 throw new Error("Route is required");
             }
             if (!solanaSigner) {
@@ -36156,69 +36157,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 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 SquidDataType.OnChainExecution: {
+                    txResult = await executeSolanaSwap({
+                        transactionRequest: route.transactionRequest,
+                        signer: solanaSigner,
+                        connection: solanaConnection,
+                    });
+                    break;
+                }
+                case 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: TransactionStatus.INITIAL_LOADING,
-                            sourceStatus: 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: TransactionStatus.INITIAL_LOADING,
-                        sourceStatus: TransactionStatus.ONGOING,
-                        id,
-                    });
-                    if (txParams) {
-                        addSwapTransaction({
-                            ...txParams,
-                            params: route.params,
-                            estimate: route.estimate,
-                        });
-                    }
-                },
+                txHash,
+                userAddress: sourceUserAddress,
+                status: TransactionStatus.INITIAL_LOADING,
+                sourceStatus: 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);
@@ -36265,47 +36266,91 @@ const useExecuteTransaction = (squidRoute) => {
         },
     });
     const swapMutationBitcoin = 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 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: TransactionStatus.INITIAL_LOADING,
+                        sourceStatus: 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: TransactionStatus.INITIAL_LOADING,
-                    sourceStatus: TransactionStatus.ONGOING,
-                    axelarUrl: undefined,
-                    id,
-                });
-                if (txParams) {
-                    addSwapTransaction({
-                        ...txParams,
-                        params: route.params,
-                        estimate: route.estimate,
+            case 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: TransactionStatus.INITIAL_LOADING,
+                        sourceStatus: 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 = useMutation(async ({ id, route }) => {
@@ -37452,5 +37497,5 @@ const SquidProvider = ({ children, config, placeholder, }) => {
                                     React.createElement(CosmosProvider, null, children)))))))))) : (placeholder);
 };
 
-export { useDepositAddress as $, AxelarStatusResponseType as A, useHederaTokenAssociations as B, CHAIN_IDS as C, DEFAULT_LOCALE as D, useKeyboardNavigation as E, useSquidQueryClient as F, useSquid as G, HistoryTxType as H, useStellarAccountActivation as I, useStellarTrustLine as J, useAddressBookStore as K, useAssetsColorsStore as L, useFavoriteTokensStore as M, Nr as N, useHistoryStore as O, useSendTransactionStore as P, QueryKeys as Q, useConfigStore as R, SquidStatusErrorType as S, TransactionErrorType as T, useSquidStore as U, useSwapRoutePersistStore as V, Wo as W, XamanXrplNetwork as X, useTransactionStore as Y, ConnectingWalletStatus as Z, useWalletStore as _, WindowWalletFlag as a, useGetOnrampPaymentTypes as a$, useSwap as a0, buildUrlSearchParamsFromSwapEvent as a1, parseInitialAssetsFromUrl as a2, useUrlSwapParams as a3, useAllConnectedWalletBalances as a4, useAllTokensWithBalanceForChainType as a5, useCosmosBalance as a6, useEvmBalance as a7, useMultiChainBalance as a8, useMultipleTokenPrices as a9, useSwapTransactionStatus as aA, useAvatar as aB, useHistory as aC, useDebouncedValue as aD, useAddToken as aE, useAutoConnect as aF, useEnsDataForAddress as aG, useEnsSearch as aH, useGnosisContext as aI, useIsSameAddressAndGnosisContext as aJ, useIntegratorContext as aK, useMultiChainWallet as aL, useSigner as aM, useWallet as aN, useWallets as aO, useXrplTrustLine as aP, TX_STATUS_CONSTANTS as aQ, FINAL_TRANSACTION_STATUSES as aR, useGetFiatQuote as aS, useGetOnRampConfig as aT, useExecuteFiatQuote as aU, useFiatOnRampTxStatus as aV, useFiatTransactions as aW, useCurrencyDetails as aX, useCountryDetails as aY, useAvailableQuotes as aZ, useRecommendedQuote as a_, useBitcoinNativeBalance as aa, useCosmosNativeBalance as ab, useEvmNativeBalance as ac, useNativeBalance as ad, useSolanaNativeBalance as ae, useStellarNativeBalance as af, useSuiNativeBalance as ag, useXrplNativeBalance as ah, useNativeTokenForChain as ai, useSingleTokenPrice as aj, useSourceChainGasToken as ak, useSquidTokens as al, useHistoricalData as am, useTokensData as an, useEstimateSendTransaction as ao, useSendTransaction as ap, useSendTransactionGas as aq, useAllTransactionsStatus as ar, useApproval as as, useEstimate as at, useEstimatePriceImpact as au, useExecuteTransaction as av, useGetRoute as aw, useGetRouteWrapper as ax, useRouteWarnings as ay, useSendTransactionStatus as az, chainTypeToZeroAddressMap as b, filterWagmiConnector as b$, useSuggestedFiatAmounts as b0, SquidProvider as b1, EnsService as b2, getXummClient as b3, isXamanXAppContext as b4, getQueryHeaders as b5, getStatusCode as b6, is404Error as b7, assetsBaseUrl as b8, shareSubgraphId as b9, fetchHighestBalanceToken as bA, getInitialOrDefaultTokenAddressForChain as bB, getInitialTokenAddressForChain as bC, filterTokensForDestination as bD, getInitialChainIdFromConfig as bE, getCosmosKey as bF, getKeysSettled as bG, getAllKeysForSupportedCosmosChains as bH, isCosmosAddressValid as bI, getCosmosSigningClient as bJ, getCosmosChainInfosObject as bK, connectCosmosWallet as bL, isFallbackAddressNeeded as bM, suggestChainOrThrow as bN, normalizeError as bO, transactionErrorCode as bP, isUserRejectionError as bQ, getTransactionError as bR, handleTransactionErrorEvents as bS, isSwapRouteError as bT, isStatusError as bU, createQuoteRequestParamsHash as bV, WidgetEvents as bW, EvmNetworkNotSupportedErrorCode as bX, addEthereumChain as bY, parseEvmAddress as bZ, formatEvmWallet as b_, sortTokensBySharedSubgraphIds as ba, getSupportedChainIdsForDirection as bb, filterChains as bc, filterTokens as bd, getTokenImage as be, getNewSwapParamsFromInput as bf, sortAllTokens as bg, findToken as bh, findNativeToken as bi, normalizeIbcAddress as bj, groupTokensBySymbol as bk, groupTokensByChainId as bl, filterViewableTokens as bm, getSecretNetworkBalances as bn, getTokenAssetsKey as bo, fetchAssetsColors as bp, initializeSquidWithAssetsColors as bq, isEmptyObject as br, normalizeTokenSymbol as bs, areTokenSymbolsCompatible as bt, isEvmosChain as bu, resolveChainIdFromAsset as bv, getConfigWithDefaults as bw, randomIntFromInterval as bx, getTokensForChain as by, getFirstAvailableChainId as bz, chainTypeToNativeTokenAddressMap as c, isHistoryTransactionFailed as c$, waitForReceiptWithRetry as c0, getUserCountry as c1, getCountryData as c2, getCurrencyData as c3, adaptiveRound as c4, getSuggestedAmountsForCurrency as c5, HederaExtensionHelper as c6, convertHederaAccountIdToEvmAddress as c7, convertEvmAddressToHederaAccountId as c8, scaleHbarToWei as c9, isValidHorizonAsset as cA, formatTransactionHistoryDate as cB, getAxelarExplorerTxUrl as cC, getSourceExplorerTxUrl as cD, getMainExplorerUrl as cE, formatDistance as cF, formatSeconds as cG, formatSwapTxStatusResponseForStorage as cH, simplifyRouteAction as cI, fetchSwapTransactionStatus as cJ, compareTransactionIds as cK, isCoralBridgeAction as cL, sleep as cM, isDepositRoute as cN, isChainflipBridgeTransaction as cO, isOnChainTxData as cP, getHistoryTransactionId as cQ, getStepStatuses as cR, getHalfSuccessState as cS, getStepsInfos as cT, getSwapTxStatusRefetchInterval as cU, getSendTxStatusRefetchInterval as cV, chainflipMultihopBridgeType as cW, getBridgeType as cX, getTransactionStatus as cY, getTransactionEndStatus as cZ, isHistoryTransactionPending as c_, scaleWeiToHbar as ca, parseToBigInt as cb, roundNumericValue as cc, formatUnitsRounded as cd, formatTokenAmount as ce, formatUsdAmount as cf, trimExtraDecimals as cg, getNumericValue as ch, cleanAmount as ci, convertTokenAmountToUSD as cj, convertUSDToTokenAmount as ck, calculateTotal24hChange as cl, getRouteExpiry as cm, searchTokens as cn, filterSolanaWallets as co, isSolanaAddressValid as cp, executeSolanaSwap as cq, executeSolanaTransfer as cr, isStellarAddressValid as cs, getStellarNetwork as ct, stellarAddressToScVal as cu, getStellarTrustLineAsset as cv, isStellarToken as cw, isStellarIssuedToken as cx, getStellarHorizonApiUrl as cy, isValidIssuedAsset as cz, definedInWindow as d, isHistoryTransactionWarning as d0, isHistoryTransactionEnded as d1, formatHash as d2, isWalletAddressValid as d3, redirectToExtensionsStore as d4, accessProperty as d5, populateWallets as d6, getDefaultChain as d7, sortWallets as d8, areSameAddress as d9, sortAddressBook as da, calculateTotalUsdBalanceUSD as db, addTokenToWallet as dc, isEvmChainNotSupportedError as dd, getWalletSupportedChainTypes as de, getConnectorForChainType as df, walletSupportsChainType as dg, connectWallet as dh, cancelConnectWallet as di, isProblematicConnector as dj, mergeWallets as dk, isXionSmartContractAddress as dl, isXrplAddressValid as dm, buildXrplTrustSetTx as dn, getXrplNetwork as dp, parseXrplPaymentTx as dq, parseXrplTokenAddress as dr, er as e, formatBNToReadable as f, DEFAULT_ROUTE_REFETCH_INTERVAL as g, destinationAddressResetValue as h, fallbackAddressResetValue as i, nativeCosmosTokenAddress as j, nativeEvmTokenAddress as k, nativeSolanaTokenAddress as l, nativeStellarTokenAddress as m, nativeBitcoinTokenAddress as n, nativeSuiTokenAddress as o, nativeXrplTokenAddress as p, CosmosProvider as q, SendTransactionStatus as r, TransactionStatus as s, useTrackSearchEmpty as t, useCosmosContext as u, useSquidChains as v, walletIconBaseUrl as w, useClient as x, useCosmosForChain as y, useHederaAccountActivation as z };
-//# sourceMappingURL=index-CpHc3uRR.js.map
+export { useDepositAddress as $, AxelarStatusResponseType as A, useHederaTokenAssociations as B, CHAIN_IDS as C, DEFAULT_LOCALE as D, useKeyboardNavigation as E, useSquidQueryClient as F, useSquid as G, HistoryTxType as H, useStellarAccountActivation as I, useStellarTrustLine as J, useAddressBookStore as K, useAssetsColorsStore as L, useFavoriteTokensStore as M, Nr as N, useHistoryStore as O, useSendTransactionStore as P, QueryKeys as Q, useConfigStore as R, SquidStatusErrorType as S, TransactionErrorType as T, useSquidStore as U, useSwapRoutePersistStore as V, Wo as W, XamanXrplNetwork as X, useTransactionStore as Y, ConnectingWalletStatus as Z, useWalletStore as _, WindowWalletFlag as a, useGetOnrampPaymentTypes as a$, useSwap as a0, buildUrlSearchParamsFromSwapEvent as a1, parseInitialAssetsFromUrl as a2, useUrlSwapParams as a3, useAllConnectedWalletBalances as a4, useAllTokensWithBalanceForChainType as a5, useCosmosBalance as a6, useEvmBalance as a7, useMultiChainBalance as a8, useMultipleTokenPrices as a9, useSwapTransactionStatus as aA, useAvatar as aB, useHistory as aC, useDebouncedValue as aD, useAddToken as aE, useAutoConnect as aF, useEnsDataForAddress as aG, useEnsSearch as aH, useGnosisContext as aI, useIsSameAddressAndGnosisContext as aJ, useIntegratorContext as aK, useMultiChainWallet as aL, useSigner as aM, useWallet as aN, useWallets as aO, useXrplTrustLine as aP, TX_STATUS_CONSTANTS as aQ, FINAL_TRANSACTION_STATUSES as aR, useGetFiatQuote as aS, useGetOnRampConfig as aT, useExecuteFiatQuote as aU, useFiatOnRampTxStatus as aV, useFiatTransactions as aW, useCurrencyDetails as aX, useCountryDetails as aY, useAvailableQuotes as aZ, useRecommendedQuote as a_, useBitcoinNativeBalance as aa, useCosmosNativeBalance as ab, useEvmNativeBalance as ac, useNativeBalance as ad, useSolanaNativeBalance as ae, useStellarNativeBalance as af, useSuiNativeBalance as ag, useXrplNativeBalance as ah, useNativeTokenForChain as ai, useSingleTokenPrice as aj, useSourceChainGasToken as ak, useSquidTokens as al, useHistoricalData as am, useTokensData as an, useEstimateSendTransaction as ao, useSendTransaction as ap, useSendTransactionGas as aq, useAllTransactionsStatus as ar, useApproval as as, useEstimate as at, useEstimatePriceImpact as au, useExecuteTransaction as av, useGetRoute as aw, useGetRouteWrapper as ax, useRouteWarnings as ay, useSendTransactionStatus as az, chainTypeToZeroAddressMap as b, filterWagmiConnector as b$, useSuggestedFiatAmounts as b0, SquidProvider as b1, EnsService as b2, getXummClient as b3, isXamanXAppContext as b4, getQueryHeaders as b5, getStatusCode as b6, is404Error as b7, assetsBaseUrl as b8, shareSubgraphId as b9, fetchHighestBalanceToken as bA, getInitialOrDefaultTokenAddressForChain as bB, getInitialTokenAddressForChain as bC, filterTokensForDestination as bD, getInitialChainIdFromConfig as bE, getCosmosKey as bF, getKeysSettled as bG, getAllKeysForSupportedCosmosChains as bH, isCosmosAddressValid as bI, getCosmosSigningClient as bJ, getCosmosChainInfosObject as bK, connectCosmosWallet as bL, isFallbackAddressNeeded as bM, suggestChainOrThrow as bN, normalizeError as bO, transactionErrorCode as bP, isUserRejectionError as bQ, getTransactionError as bR, handleTransactionErrorEvents as bS, isSwapRouteError as bT, isStatusError as bU, createQuoteRequestParamsHash as bV, WidgetEvents as bW, EvmNetworkNotSupportedErrorCode as bX, addEthereumChain as bY, parseEvmAddress as bZ, formatEvmWallet as b_, sortTokensBySharedSubgraphIds as ba, getSupportedChainIdsForDirection as bb, filterChains as bc, filterTokens as bd, getTokenImage as be, getNewSwapParamsFromInput as bf, sortAllTokens as bg, findToken as bh, findNativeToken as bi, normalizeIbcAddress as bj, groupTokensBySymbol as bk, groupTokensByChainId as bl, filterViewableTokens as bm, getSecretNetworkBalances as bn, getTokenAssetsKey as bo, fetchAssetsColors as bp, initializeSquidWithAssetsColors as bq, isEmptyObject as br, normalizeTokenSymbol as bs, areTokenSymbolsCompatible as bt, isEvmosChain as bu, resolveChainIdFromAsset as bv, getConfigWithDefaults as bw, randomIntFromInterval as bx, getTokensForChain as by, getFirstAvailableChainId as bz, chainTypeToNativeTokenAddressMap as c, isHistoryTransactionFailed as c$, waitForReceiptWithRetry as c0, getUserCountry as c1, getCountryData as c2, getCurrencyData as c3, adaptiveRound as c4, getSuggestedAmountsForCurrency as c5, HederaExtensionHelper as c6, convertHederaAccountIdToEvmAddress as c7, convertEvmAddressToHederaAccountId as c8, scaleHbarToWei as c9, isValidIssuedAsset as cA, isValidHorizonAsset as cB, formatTransactionHistoryDate as cC, getAxelarExplorerTxUrl as cD, getSourceExplorerTxUrl as cE, getMainExplorerUrl as cF, formatDistance as cG, formatSeconds as cH, formatSwapTxStatusResponseForStorage as cI, simplifyRouteAction as cJ, fetchSwapTransactionStatus as cK, compareTransactionIds as cL, isCoralBridgeAction as cM, sleep as cN, isChainflipBridgeTransaction as cO, isOnChainTxData as cP, getHistoryTransactionId as cQ, getStepStatuses as cR, getHalfSuccessState as cS, getStepsInfos as cT, getSwapTxStatusRefetchInterval as cU, getSendTxStatusRefetchInterval as cV, chainflipMultihopBridgeType as cW, getBridgeType as cX, getTransactionStatus as cY, getTransactionEndStatus as cZ, isHistoryTransactionPending as c_, scaleWeiToHbar as ca, parseToBigInt as cb, roundNumericValue as cc, formatUnitsRounded as cd, formatTokenAmount as ce, formatUsdAmount as cf, trimExtraDecimals as cg, getNumericValue as ch, cleanAmount as ci, convertTokenAmountToUSD as cj, convertUSDToTokenAmount as ck, calculateTotal24hChange as cl, getRouteExpiry as cm, searchTokens as cn, filterSolanaWallets as co, isSolanaAddressValid as cp, executeSolanaSwap as cq, executeSolanaTransfer as cr, executeSolanaDepositAddressCalldata as cs, isStellarAddressValid as ct, getStellarNetwork as cu, stellarAddressToScVal as cv, getStellarTrustLineAsset as cw, isStellarToken as cx, isStellarIssuedToken as cy, getStellarHorizonApiUrl as cz, definedInWindow as d, isHistoryTransactionWarning as d0, isHistoryTransactionEnded as d1, formatHash as d2, isWalletAddressValid as d3, redirectToExtensionsStore as d4, accessProperty as d5, populateWallets as d6, getDefaultChain as d7, sortWallets as d8, areSameAddress as d9, sortAddressBook as da, calculateTotalUsdBalanceUSD as db, addTokenToWallet as dc, isEvmChainNotSupportedError as dd, getWalletSupportedChainTypes as de, getConnectorForChainType as df, walletSupportsChainType as dg, connectWallet as dh, cancelConnectWallet as di, isProblematicConnector as dj, mergeWallets as dk, isXionSmartContractAddress as dl, isXrplAddressValid as dm, buildXrplTrustSetTx as dn, getXrplNetwork as dp, parseXrplPaymentTx as dq, parseXrplTokenAddress as dr, er as e, formatBNToReadable as f, DEFAULT_ROUTE_REFETCH_INTERVAL as g, destinationAddressResetValue as h, fallbackAddressResetValue as i, nativeCosmosTokenAddress as j, nativeEvmTokenAddress as k, nativeSolanaTokenAddress as l, nativeStellarTokenAddress as m, nativeBitcoinTokenAddress as n, nativeSuiTokenAddress as o, nativeXrplTokenAddress as p, CosmosProvider as q, SendTransactionStatus as r, TransactionStatus as s, useTrackSearchEmpty as t, useCosmosContext as u, useSquidChains as v, walletIconBaseUrl as w, useClient as x, useCosmosForChain as y, useHederaAccountActivation as z };
+//# sourceMappingURL=index-BOXqAr2r.js.map