@0xsquid/react-hooks 8.8.1-beta-canton.4 → 8.9.0

package/dist/{index-mgE1SeE-.js → index-DcBFug8t.js}

@@ -78,8 +78,6 @@ const solanaZeroAddress = "11111111111111111111111111111111";
 const suiZeroAddress = "0x0000000000000000000000000000000000000000";
 const xrplZeroAddress = "rrrrrrrrrrrrrrrrrrrrrhoLvTp";
 const stellarZeroAddress = "GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWHF";
-// TODO: check
-const cantonZeroAddress = "none::12200000000000000000000000000000000000000000000000000000000000000000";
 const chainTypeToZeroAddressMap = {
     [squidTypes.ChainType.EVM]: viem.zeroAddress,
     [squidTypes.ChainType.COSMOS]: cosmosZeroAddress,
@@ -88,7 +86,6 @@ const chainTypeToZeroAddressMap = {
     [squidTypes.ChainType.SUI]: suiZeroAddress,
     [squidTypes.ChainType.XRPL]: xrplZeroAddress,
     [squidTypes.ChainType.STELLAR]: stellarZeroAddress,
-    [squidTypes.ChainType.CANTON]: cantonZeroAddress,
 };
 const nativeEvmTokenAddress = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
 const nativeCosmosTokenAddress = "uosmo";
@@ -97,7 +94,6 @@ const nativeBitcoinTokenAddress = "satoshi";
 const nativeSuiTokenAddress = "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI";
 const nativeXrplTokenAddress = "xrp";
 const nativeStellarTokenAddress = "CAS3J7GYLGXMF6TDJBBYYSE3HQ6BBSMLNUQ34T6TZMYMW2EVH34XOWMA";
-const nativeCantonTokenAddress = "DSO::1220b1431ef217342db44d516bb9befde802be7d8899637d290895fa58880f19accc";
 // by setting slippage to undefined, it's set to "auto"
 const defaultSlippage = undefined;
 const destinationAddressResetValue = "null";
@@ -161,7 +157,6 @@ const CHAIN_IDS = {
     XRPL_TESTNET: "xrpl-testnet",
     STELLAR: "stellar-mainnet",
     STELLAR_TESTNET: "stellar-testnet",
-    CANTON: "canton",
 };
 const chainTypeToDefaultChainIdMap = {
     [squidTypes.ChainType.EVM]: CHAIN_IDS.ETHEREUM,
@@ -171,7 +166,6 @@ const chainTypeToDefaultChainIdMap = {
     [squidTypes.ChainType.SUI]: CHAIN_IDS.SUI,
     [squidTypes.ChainType.XRPL]: CHAIN_IDS.XRPL,
     [squidTypes.ChainType.STELLAR]: CHAIN_IDS.STELLAR,
-    [squidTypes.ChainType.CANTON]: CHAIN_IDS.CANTON,
 };
 const chainTypeToNativeTokenAddressMap = {
     [squidTypes.ChainType.EVM]: nativeEvmTokenAddress,
@@ -181,7 +175,6 @@ const chainTypeToNativeTokenAddressMap = {
     [squidTypes.ChainType.SUI]: nativeSuiTokenAddress,
     [squidTypes.ChainType.XRPL]: nativeXrplTokenAddress,
     [squidTypes.ChainType.STELLAR]: nativeStellarTokenAddress,
-    [squidTypes.ChainType.CANTON]: nativeCantonTokenAddress,
 };
 const defaultConfigValues = {
     integratorId: INTEGRATOR_ID,
@@ -20879,17 +20872,31 @@ const isBitcoinAddressValid = (address) => {
     }
 };
 
-// Canton PartyID = address
-const CANTON_PARTY_ID_SEPARATOR = "::";
-function isCantonAddressValid(address) {
-    // Canton address format: `name::fingerprint`, where name is an arbitrary string
-    // and fingerprint is a 64-character hex string with a 1220 prefix (SHA-256 hash of the public key)
-    const parts = address.split(CANTON_PARTY_ID_SEPARATOR);
-    if (parts.length !== 2)
-        return false;
-    const [name, fingerprint] = parts;
-    return name.length > 0 && /^1220[0-9a-f]{64}$/.test(fingerprint);
-}
+const solanaTokenProgramIdByAddress = {
+    [splToken.TOKEN_PROGRAM_ID.toBase58()]: splToken.TOKEN_PROGRAM_ID,
+    [splToken.TOKEN_2022_PROGRAM_ID.toBase58()]: splToken.TOKEN_2022_PROGRAM_ID,
+};
+const isSupportedSolanaTokenProgramId = (programId) => programId.toBase58() in solanaTokenProgramIdByAddress;
+const getSupportedSolanaTokenProgramId = (tokenProgramId) => {
+    if (!tokenProgramId)
+        return undefined;
+    return solanaTokenProgramIdByAddress[tokenProgramId];
+};
+const resolveSolanaTokenProgramId = async ({ connection, token, }) => {
+    const tokenProgramId = getSupportedSolanaTokenProgramId(token.tokenProgramId);
+    if (tokenProgramId) {
+        return tokenProgramId;
+    }
+    const mint = new web3_js.PublicKey(token.address);
+    const mintAccount = await connection.getAccountInfo(mint);
+    if (!mintAccount) {
+        throw new Error(`Solana mint account not found: ${token.address}`);
+    }
+    if (!isSupportedSolanaTokenProgramId(mintAccount.owner)) {
+        throw new Error(`Unsupported Solana token program for mint ${token.address}: ${mintAccount.owner.toBase58()}`);
+    }
+    return mintAccount.owner;
+};
 
 exports.HistoryTxType = void 0;
 (function (HistoryTxType) {
@@ -21004,7 +21011,6 @@ const getSourceExplorerTxUrl = (chain, txID) => {
         case CHAIN_IDS.AGORIC:
         case CHAIN_IDS.XRPL:
         case CHAIN_IDS.XRPL_TESTNET:
-        case CHAIN_IDS.CANTON:
             txSuffix = "/transactions/";
             break;
         case CHAIN_IDS.HEDERA:
@@ -21114,16 +21120,10 @@ const simplifyRouteAction = (action) => {
 };
 const fetchSwapTransactionStatus = async ({ transaction, integratorId, apiUrl, }) => {
     const statusEndpoint = `${apiUrl}/v2/status`;
-    const isCanton = transaction?.fromChain === CHAIN_IDS.CANTON;
-    // For Canton, the backend handles all tx detection/submission from the quoteId
-    // alone, so no transactionId is sent — only the quoteId param below.
-    const transactionId = isCanton
-        ? undefined
-        : transaction?.transactionIdForStatus ?? transaction?.transactionId;
     try {
         const response = await axios.get(statusEndpoint, {
             params: {
-                transactionId,
+                transactionId: transaction?.transactionIdForStatus ?? transaction?.transactionId,
                 fromChainId: transaction?.fromChain,
                 toChainId: transaction?.toChain,
                 bridgeType: transaction?.bridgeType,
@@ -21170,7 +21170,7 @@ function isActionCompletedOnSourceTx(action, fromChainId) {
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
-const isChainflipDepositRoute = (route) => {
+const isDepositRoute = (route) => {
     return (!!route &&
         route.transactionRequest?.type === squidTypes.SquidDataType.ChainflipDepositAddress);
 };
@@ -21195,12 +21195,6 @@ function isOnChainTxData(squidData) {
         squidTypes.SquidDataType.DepositAddressWithMemo,
     ].includes(squidData.type);
 }
-/**
- * Checks if a route is of type DepositAddressDirectTransfer
- */
-function isDepositAddressDirectTransferRoute(squidData) {
-    return (squidData.type === squidTypes.SquidDataType.DepositAddressDirectTransfer);
-}
 function getHistoryTransactionId(tx) {
     switch (tx.txType) {
         case exports.HistoryTxType.SWAP:
@@ -21383,6 +21377,16 @@ const isSolanaAddressValid = (address) => {
         return false;
     }
 };
+const deserializeSolanaTransaction = (transactionBuffer) => {
+    // Squid can return legacy Solana transactions (ITS) or versioned transactions
+    // (Jupiter/Chainflip). Deserialize once to detect the payload type. Legacy
+    // transactions need to be converted to Transaction because their blockhash is
+    // mutable and must be refreshed before signing.
+    const versionedTransaction = web3_js.VersionedTransaction.deserialize(transactionBuffer);
+    return versionedTransaction.version === "legacy"
+        ? web3_js.Transaction.from(transactionBuffer)
+        : versionedTransaction;
+};
 /**
  * Execute a Solana swap transaction
  * This will be used for the swap flow - Using Jupiter Dex under the hood
@@ -21393,13 +21397,16 @@ const executeSolanaSwap = async ({ route, signer, connection, onSigned, }) => {
     }
     const swapRequest = route.transactionRequest.data;
     const swapTransactionBuf = Buffer.from(swapRequest, "base64");
-    // TODO: fix types
-    // const transaction = VersionedTransaction.deserialize(
-    //   Uint8Array.from(swapTransactionBuf)
-    // );
-    const transaction = web3_js.VersionedTransaction.deserialize(swapTransactionBuf);
+    const transaction = deserializeSolanaTransaction(swapTransactionBuf);
     try {
         const latestBlockhash = await connection.getLatestBlockhash();
+        if (transaction instanceof web3_js.Transaction) {
+            // ITS legacy transactions arrive with the placeholder blockhash
+            // 11111111111111111111111111111111.
+            // Refresh it right before signing so the submitted transaction
+            // uses a valid blockhash. Versioned transactions are not mutable here.
+            transaction.recentBlockhash = latestBlockhash.blockhash;
+        }
         const signature = await signer.sendTransaction(transaction, connection);
         onSigned?.(signature);
         await connection.confirmTransaction({
@@ -21448,16 +21455,20 @@ const executeSolanaTransfer = async ({ amount, target, signer, connection, sourc
     else {
         // Handle SPL token transfer
         const mint = new web3_js.PublicKey(sourceToken.address);
+        const tokenProgramId = await resolveSolanaTokenProgramId({
+            connection,
+            token: sourceToken,
+        });
         // Get Associated Token Accounts (ATAs) for both source and target
-        const sourceATA = await splToken.getAssociatedTokenAddress(mint, signer.publicKey, true);
-        const targetATA = await splToken.getAssociatedTokenAddress(mint, targetPubKey, true);
+        const sourceATA = await splToken.getAssociatedTokenAddress(mint, signer.publicKey, true, tokenProgramId);
+        const targetATA = await splToken.getAssociatedTokenAddress(mint, targetPubKey, true, tokenProgramId);
         // Check if target ATA exists and create if needed
         const targetAccount = await connection.getAccountInfo(targetATA);
         if (!targetAccount) {
-            transaction.add(splToken.createAssociatedTokenAccountInstruction(signer.publicKey, targetATA, targetPubKey, mint));
+            transaction.add(splToken.createAssociatedTokenAccountInstruction(signer.publicKey, targetATA, targetPubKey, mint, tokenProgramId));
         }
         // Add the token transfer instruction
-        transaction.add(splToken.createTransferInstruction(sourceATA, targetATA, signer.publicKey, amount));
+        transaction.add(splToken.createTransferInstruction(sourceATA, targetATA, signer.publicKey, amount, [], tokenProgramId));
     }
     // Get latest blockhash and sign transaction
     const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash();
@@ -21703,17 +21714,7 @@ const chainTypeToTrimLength = {
         start: 4,
         end: 4,
     },
-    // abc...123::abc...123
-    [squidTypes.ChainType.CANTON]: {
-        start: 3,
-        end: 3,
-    },
 };
-const truncateWithEllipsis = (value, startLength, endLength) => value.length <= startLength + endLength
-    ? value
-    : value.slice(0, startLength) +
-        "..." +
-        value.slice(value.length - endLength);
 const formatHash = ({ chainType, hash }) => {
     if (!hash)
         return "";
@@ -21726,15 +21727,14 @@ const formatHash = ({ chainType, hash }) => {
             chainTypeFormat = squidTypes.ChainType.COSMOS;
         }
     }
-    const { start, end } = chainTypeToTrimLength[chainTypeFormat];
-    if (chainTypeFormat === squidTypes.ChainType.CANTON &&
-        hash.includes(CANTON_PARTY_ID_SEPARATOR)) {
-        const [namespace, identifier] = hash.split(CANTON_PARTY_ID_SEPARATOR);
-        return (truncateWithEllipsis(namespace, start, end) +
-            CANTON_PARTY_ID_SEPARATOR +
-            truncateWithEllipsis(identifier, start, end));
-    }
-    return truncateWithEllipsis(hash, start, end);
+    const trimLengthStart = chainTypeToTrimLength[chainTypeFormat].start;
+    const trimLengthEnd = chainTypeToTrimLength[chainTypeFormat].end;
+    // return the same hash if its length is less than the trim length
+    if (hash.length <= trimLengthStart + trimLengthEnd)
+        return hash;
+    return (hash.slice(0, trimLengthStart) +
+        "..." +
+        hash.slice(hash.length - trimLengthEnd, hash.length));
 };
 const isWalletAddressValid = (chainData, address) => {
     if (!address || !chainData?.chainType)
@@ -21754,8 +21754,6 @@ const isWalletAddressValid = (chainData, address) => {
             return isXrplAddressValid(address);
         case squidTypes.ChainType.STELLAR:
             return isStellarAddressValid(address);
-        case squidTypes.ChainType.CANTON:
-            return isCantonAddressValid(address);
     }
 };
 const redirectToExtensionsStore = (wallet) => {
@@ -22017,8 +22015,6 @@ const connectByChainType = async (chainType, wallet, defaultChain, params) => {
                     connector,
                 },
             });
-        case squidTypes.ChainType.CANTON:
-            return null;
     }
 };
 const getChainTypesToConnect = (selectedChainTypes, defaultChain, supportedChains) => {
@@ -23093,10 +23089,7 @@ const getNewSwapParamsFromInput = ({ inputParams, initialSwapRoute, tokens, chai
     else {
         newFallbackAddress = fallbackAddress ?? initialSwapRoute?.fallbackAddress;
     }
-    const sourceChainChanged = fromChainId !== undefined && fromChainId !== initialSwapRoute?.fromChainId;
-    const newDepositRefundAddress = sourceChainChanged
-        ? undefined
-        : depositRefundAddress || initialSwapRoute?.depositRefundAddress;
+    const newDepositRefundAddress = depositRefundAddress || initialSwapRoute?.depositRefundAddress;
     return {
         fromChainId: srcChainId,
         fromTokenAddress: sourceTokenAddress,
@@ -23375,7 +23368,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-DWq78rM5.js'); });
+    const { fetchAllSecretBalances } = await Promise.resolve().then(function () { return require('./secretService-B1SDXLS1.js'); });
     return fetchAllSecretBalances(chainData, cosmosAddress, squidSecretTokens, keplrTypeWallet);
 };
 function getTokenAssetsKey(token) {
@@ -23402,29 +23395,9 @@ async function fetchAssetsColors() {
         };
     }
 }
-const supportedChainTypes = new Set(Object.values(squidTypes.ChainType));
-function isSupportedChainType(chainType) {
-    return supportedChainTypes.has(chainType);
-}
-/**
- * Normalizes SDK data after each init/refetch before the rest of hooks consumes it.
- *
- * - Removes chains whose chainType is not supported by the local package.
- * - Drops tokens for those removed chains.
- * - Converts Evmos chains/tokens to EVM.
- * - Applies optional asset colors.
- */
-function initializeSquidData(squid, assetsColors = {
-    chains: {},
-    tokens: {},
-}) {
-    const supportedChains = squid.chains.filter((chain) => isSupportedChainType(chain.chainType));
-    const supportedChainIds = new Set(supportedChains.map((chain) => chain.chainId));
-    const evmosChainIds = supportedChains
-        .filter(isEvmosChain)
-        .map((c) => c.chainId);
-    const supportedTokens = squid.tokens.filter((token) => supportedChainIds.has(token.chainId));
-    squid.tokens = supportedTokens.map((token) => {
+function initializeSquidWithAssetsColors(squid, assetsColors) {
+    const evmosChainIds = squid.chains.filter(isEvmosChain).map((c) => c.chainId);
+    squid.tokens = squid.tokens.map((token) => {
         const isEvmosToken = evmosChainIds.includes(token.chainId);
         return {
             ...token,
@@ -23433,7 +23406,7 @@ function initializeSquidData(squid, assetsColors = {
             textColor: assetsColors.tokens[getTokenAssetsKey(token)]?.textColor,
         };
     });
-    squid.chains = supportedChains.map((chain) => {
+    squid.chains = squid.chains.map((chain) => {
         const bgColor = assetsColors.chains[chain.chainId]?.bgColor;
         // convert evmos cosmos chains to evm chains
         // TODO: this will be fixed in the backend
@@ -25310,7 +25283,7 @@ const useSquid = () => {
         queryFn: async () => {
             if (squid) {
                 await squid?.init();
-                initializeSquidData(squid, assetsColors);
+                initializeSquidWithAssetsColors(squid, assetsColors);
                 return squid;
             }
             return null;
@@ -25369,7 +25342,7 @@ const useSquidTokens = (direction) => {
         config.availableChains,
         direction,
     ]);
-    const { evmTokens, cosmosTokens, solanaTokens, bitcoinTokens, suiTokens, xrplTokens, stellarTokens, cantonTokens, } = React.useMemo(() => {
+    const { evmTokens, cosmosTokens, solanaTokens, bitcoinTokens, suiTokens, xrplTokens, stellarTokens, } = React.useMemo(() => {
         return tokens?.reduce((acc, token) => {
             switch (token.type) {
                 case squidTypes.ChainType.EVM:
@@ -25393,9 +25366,6 @@ const useSquidTokens = (direction) => {
                 case squidTypes.ChainType.STELLAR:
                     acc.stellarTokens.push(token);
                     break;
-                case squidTypes.ChainType.CANTON:
-                    acc.cantonTokens.push(token);
-                    break;
             }
             return acc;
         }, {
@@ -25406,7 +25376,6 @@ const useSquidTokens = (direction) => {
             suiTokens: [],
             xrplTokens: [],
             stellarTokens: [],
-            cantonTokens: [],
         });
     }, [tokens]);
     const findToken = React.useCallback((address, chainId) => {
@@ -25424,7 +25393,6 @@ const useSquidTokens = (direction) => {
         suiTokens,
         xrplTokens,
         stellarTokens,
-        cantonTokens,
     };
 };
 
@@ -25962,7 +25930,6 @@ const chainTypeToRefetchInterval = {
     [squidTypes.ChainType.SUI]: 1_000,
     [squidTypes.ChainType.XRPL]: 1_000,
     [squidTypes.ChainType.STELLAR]: 1_000,
-    [squidTypes.ChainType.CANTON]: 1_000,
 };
 /**
  * Returns the status refetch interval of a Send transaction
@@ -26229,7 +26196,7 @@ const useSquidChains = (direction) => {
         const chain = findChain(chainId);
         return chain?.chainType;
     }, [findChain]);
-    const { evmChains, cosmosChains, suiChains, stellarChains, xrplChains, cantonChains, } = React.useMemo(() => {
+    const { evmChains, cosmosChains, suiChains, stellarChains, xrplChains } = React.useMemo(() => {
         return chains.reduce((acc, chain) => {
             switch (chain.chainType) {
                 case squidTypes.ChainType.EVM:
@@ -26247,9 +26214,6 @@ const useSquidChains = (direction) => {
                 case squidTypes.ChainType.STELLAR:
                     acc.stellarChains.push(chain);
                     break;
-                case squidTypes.ChainType.CANTON:
-                    acc.cantonChains.push(chain);
-                    break;
             }
             return acc;
         }, {
@@ -26258,7 +26222,6 @@ const useSquidChains = (direction) => {
             suiChains: [],
             xrplChains: [],
             stellarChains: [],
-            cantonChains: [],
         });
     }, [chains]);
     const { supportedSourceChains, supportedDestinationChains } = React.useMemo(() => {
@@ -26279,7 +26242,6 @@ const useSquidChains = (direction) => {
         suiChains,
         xrplChains,
         stellarChains,
-        cantonChains,
         getChainType,
         findChain,
     };
@@ -26804,7 +26766,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-DBROJ4yf.js'); });
+                const { formatStellarWallet } = await Promise.resolve().then(function () { return require('./stellarService.client-C4TLBEpm.js'); });
                 const modules = [...initializeAllModules(), new LedgerModule()];
                 const promises = modules.map(async (module) => {
                     const isAvailable = await module.isAvailable();
@@ -27503,7 +27465,6 @@ const useMultiChainWallet = (chain) => {
     const suiAddress = connectedAddresses[squidTypes.ChainType.SUI];
     const xrplAddress = connectedAddresses[squidTypes.ChainType.XRPL];
     const stellarAddress = connectedAddresses[squidTypes.ChainType.STELLAR];
-    const cantonAddress = connectedAddresses[squidTypes.ChainType.CANTON];
     // Cosmos is a special case because the address changes on every chain
     // so we can't use the default cosmos connected address
     const { data: cosmosAddress } = useCosmosForChain(chain);
@@ -27591,16 +27552,6 @@ const useMultiChainWallet = (chain) => {
                         chainType: chain.chainType,
                     }),
                 };
-            case squidTypes.ChainType.CANTON:
-                if (!cantonAddress)
-                    return {};
-                return {
-                    address: cantonAddress,
-                    formatted: formatHash({
-                        hash: cantonAddress,
-                        chainType: chain.chainType,
-                    }),
-                };
         }
     }, [
         chain?.chainType,
@@ -27612,7 +27563,6 @@ const useMultiChainWallet = (chain) => {
         suiAddress,
         xrplAddress,
         stellarAddress,
-        cantonAddress,
     ]);
     /**
      * Change current network for desired chain
@@ -28437,8 +28387,6 @@ async function createClient(chain) {
             return new XrplRpcClient(chain.rpc);
         case squidTypes.ChainType.STELLAR:
             return new StellarRpcClient(chain.rpc);
-        case squidTypes.ChainType.CANTON:
-            return null;
     }
 }
 
@@ -29275,6 +29223,10 @@ const getSolanaTokenBalance = async (userAddress, tokenAddress) => {
     if (tokenAddress.toLowerCase() === nativeSolanaTokenAddress.toLowerCase()) {
         return getSolanaNativeBalance(userAddress);
     }
+    const balances = await getSolanaTokensBalance(userAddress, [tokenAddress]);
+    return balances[tokenAddress] || BigInt(0);
+};
+const getSolanaTokenAccountsByProgram = async (userAddress, programId) => {
     const response = await fetch(SOLANA_RPC_URL, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
@@ -29284,43 +29236,45 @@ const getSolanaTokenBalance = async (userAddress, tokenAddress) => {
             method: "getTokenAccountsByOwner",
             params: [
                 userAddress,
-                { programId: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA" },
+                { programId },
                 { encoding: "jsonParsed" },
             ],
         }),
     });
     const data = await response.json();
-    const tokenAccount = data.result?.value?.find((acc) => acc.account.data.parsed.info.mint.toLowerCase() ===
-        tokenAddress.toLowerCase());
-    return BigInt(tokenAccount?.account.data.parsed.info.tokenAmount.amount || 0);
+    if (data.error) {
+        throw new Error(data.error.message || "Failed to fetch Solana balances");
+    }
+    return data.result?.value || [];
 };
 const getSolanaTokensBalance = async (userAddress, tokenAddresses) => {
-    const response = await fetch(SOLANA_RPC_URL, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-            jsonrpc: "2.0",
-            id: 1,
-            method: "getTokenAccountsByOwner",
-            params: [
-                userAddress,
-                { programId: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA" },
-                { encoding: "jsonParsed" },
-            ],
-        }),
-    });
-    const data = await response.json();
-    return tokenAddresses.reduce((acc, address) => {
-        const tokenAccount = data.result?.value?.find((accountInfo) => accountInfo.account.data.parsed.info.mint.toLowerCase() ===
-            address.toLowerCase());
-        acc[address] = BigInt(tokenAccount?.account.data.parsed.info.tokenAmount.amount || 0);
+    const balancesByAddress = tokenAddresses.reduce((acc, address) => {
+        acc[address] = BigInt(0);
         return acc;
     }, {});
+    if (tokenAddresses.length === 0) {
+        return balancesByAddress;
+    }
+    const addressByLowercase = tokenAddresses.reduce((acc, address) => {
+        acc[address.toLowerCase()] = address;
+        return acc;
+    }, {});
+    const tokenAccountsByProgram = await Promise.all([splToken.TOKEN_PROGRAM_ID, splToken.TOKEN_2022_PROGRAM_ID].map((programId) => getSolanaTokenAccountsByProgram(userAddress, programId.toBase58())));
+    tokenAccountsByProgram.flat().forEach((tokenAccount) => {
+        const tokenInfo = tokenAccount.account?.data?.parsed?.info;
+        const address = tokenInfo?.mint
+            ? addressByLowercase[tokenInfo.mint.toLowerCase()]
+            : undefined;
+        if (!address)
+            return;
+        balancesByAddress[address] += BigInt(tokenInfo?.tokenAmount?.amount || 0);
+    });
+    return balancesByAddress;
 };
 const getAllSolanaTokensBalance = async (solanaTokens, userAddress) => {
     try {
-        const nativeToken = solanaTokens.find((t) => t.address === nativeEvmTokenAddress);
-        const otherTokens = solanaTokens.filter((t) => t.address !== nativeEvmTokenAddress);
+        const nativeToken = solanaTokens.find((t) => t.address.toLowerCase() === nativeSolanaTokenAddress.toLowerCase());
+        const otherTokens = solanaTokens.filter((t) => t.address.toLowerCase() !== nativeSolanaTokenAddress.toLowerCase());
         const [nativeBalance, tokenBalances] = await Promise.all([
             nativeToken
                 ? getSolanaNativeBalance(userAddress)
@@ -29329,7 +29283,7 @@ const getAllSolanaTokensBalance = async (solanaTokens, userAddress) => {
         ]);
         return solanaTokens.map((token) => ({
             ...token,
-            balance: token.address === nativeEvmTokenAddress
+            balance: token.address.toLowerCase() === nativeSolanaTokenAddress.toLowerCase()
                 ? formatBNToReadable(nativeBalance, token.decimals)
                 : formatBNToReadable(tokenBalances[token.address], token.decimals),
         }));
@@ -29631,7 +29585,7 @@ const useStellarBalance = ({ userAddress, chain, enabled, token, refreshInterval
 };
 
 function useNativeTokenForChain(chain) {
-    const { evmTokens, cosmosTokens, solanaTokens, bitcoinTokens, suiTokens, xrplTokens, stellarTokens, cantonTokens, } = useSquidTokens();
+    const { evmTokens, cosmosTokens, solanaTokens, bitcoinTokens, suiTokens, xrplTokens, stellarTokens, } = useSquidTokens();
     const getTokensForChainType = () => {
         if (!chain?.chainType)
             return [];
@@ -29650,8 +29604,6 @@ function useNativeTokenForChain(chain) {
                 return xrplTokens;
             case squidTypes.ChainType.STELLAR:
                 return stellarTokens;
-            case squidTypes.ChainType.CANTON:
-                return cantonTokens;
         }
     };
     const nativeTokenForChainType = React.useMemo(() => {
@@ -29886,11 +29838,6 @@ const useNativeBalance = (chain) => {
                 break;
             case squidTypes.ChainType.STELLAR:
                 balance = nativeStellarBalance;
-                break;
-            case squidTypes.ChainType.CANTON:
-                // TODO: implement canton balance fetching
-                balance = undefined;
-                break;
         }
         const balanceFormatted = !!balance
             ? formatBNToReadable(balance.value, balance.decimals)
@@ -29927,9 +29874,6 @@ const useNativeBalance = (chain) => {
                 return isXrpLoading;
             case squidTypes.ChainType.STELLAR:
                 return isStellarLoading;
-            case squidTypes.ChainType.CANTON:
-                // TODO: implement canton balance fetching
-                return false;
         }
     }, [
         chain?.chainType,
@@ -30154,7 +30098,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-3JPbTFKq.js'); });
+                const { EthereumProvider } = await Promise.resolve().then(function () { return require('./index.es-1XEAWjab.js'); });
                 const rawProvider = await EthereumProvider.init({
                     ...restParameters,
                     disableProviderPing: true,
@@ -30384,8 +30328,6 @@ const useSigner = ({ chain }) => {
                 return isXrplSignerReady;
             case squidTypes.ChainType.STELLAR:
                 return isStellarSignerReady;
-            case squidTypes.ChainType.CANTON:
-                return false;
         }
     }, [
         chain?.chainType,
@@ -30835,21 +30777,21 @@ const useSendTransactionStore = zustand.create((set, get) => ({
 
 const useDepositAddressStore = zustand.create((set) => ({
     deposit: null,
-    selectedPaymentMethod: "connectedWallet",
+    isEnabled: false,
     setDeposit: (data) => {
         set({ deposit: data });
     },
-    setPaymentMethod: (method) => {
-        set({ selectedPaymentMethod: method });
+    toggleDepositFlow: (enabled) => {
+        set({ isEnabled: enabled });
     },
 }));
 
 function useDepositAddress(squidRoute) {
-    const { selectedPaymentMethod, depositAddress } = useDepositAddressStore((state) => ({
-        selectedPaymentMethod: state.selectedPaymentMethod,
+    const { isEnabled, depositAddress } = useDepositAddressStore((state) => ({
+        isEnabled: state.isEnabled,
         depositAddress: state.deposit?.depositAddress,
     }));
-    const { setDeposit, setPaymentMethod, deposit } = useDepositAddressStore();
+    const { setDeposit, toggleDepositFlow, deposit } = useDepositAddressStore();
     const { squid } = useSquidStore();
     const { fromChain } = useSwap();
     const isAvailableAsPaymentMethod = React.useMemo(() => {
@@ -30858,7 +30800,6 @@ function useDepositAddress(squidRoute) {
         const chainsSupportingDepositAddress = [
             CHAIN_IDS.BITCOIN,
             CHAIN_IDS.SOLANA,
-            CHAIN_IDS.CANTON,
         ];
         return chainsSupportingDepositAddress.includes(fromChain.chainId);
     }, [fromChain?.chainId]);
@@ -30866,50 +30807,34 @@ function useDepositAddress(squidRoute) {
         return (squidRoute?.transactionRequest?.type ===
             squidTypes.SquidDataType.ChainflipDepositAddress);
     }, [squidRoute?.transactionRequest?.type]);
-    // Effective payment method: the user's intent clamped by what the current
-    // source chain can actually do. Reading this (instead of raw intent) is what
-    // keeps every consumer in sync — if the source chain can't use a deposit
-    // address, the effective method is "connectedWallet" immediately at read time.
-    const paymentMethod = isAvailableAsPaymentMethod
-        ? selectedPaymentMethod
-        : "connectedWallet";
-    const isDepositAddressActive = paymentMethod === "depositAddress";
+    const enable = React.useCallback(() => {
+        toggleDepositFlow(true);
+    }, [toggleDepositFlow]);
+    const disable = React.useCallback(() => {
+        toggleDepositFlow(false);
+    }, [toggleDepositFlow]);
     const closeDepositChannel = React.useCallback(() => {
+        toggleDepositFlow(false);
         setDeposit(null);
-    }, [setDeposit]);
+    }, [toggleDepositFlow, setDeposit]);
     const getRouteWithDeposit = reactQuery.useMutation(async ({ route }) => {
-        if (!squid || !route.transactionRequest)
-            throw new Error("Missing required params");
-        if (isChainflipDepositRoute(route)) {
-            const depositAddressResponse = (await squid.executeRoute({
-                signer: {},
-                route,
-            }));
-            setDeposit({
-                amount: depositAddressResponse.amount,
-                depositAddress: depositAddressResponse.depositAddress,
-                statusTrackingId: depositAddressResponse.chainflipStatusTrackingId,
-            });
-            return;
-        }
-        else if (isDepositAddressDirectTransferRoute(route.transactionRequest)) {
-            const orderHash = route.transactionRequest.data;
-            setDeposit({
-                amount: route.params.fromAmount ?? "",
-                depositAddress: route.transactionRequest.target,
-                // Squid Scan indexes the Canton tx by the orderHash
-                statusTrackingId: orderHash,
-                memo: orderHash,
-            });
-            return;
-        }
+        if (!squid)
+            throw new Error("Squid SDK not initialized");
+        const depositAddressResponse = (await squid.executeRoute({
+            signer: {},
+            route,
+        }));
+        setDeposit(depositAddressResponse);
+        return {
+            depositAddress: depositAddressResponse,
+        };
     });
     return {
-        paymentMethod,
-        isDepositAddressActive,
+        isEnabled,
         isAvailableAsPaymentMethod,
         swapWillGenerateDepositAddress,
-        setPaymentMethod,
+        enable,
+        disable,
         getRouteWithDeposit,
         depositAddress,
         closeDepositChannel,
@@ -30941,7 +30866,7 @@ const useUrlSwapParams = () => {
 
 const useAllTokensWithBalanceForChainType = ({ chainType, address, direction, queryOptions, }) => {
     const { evmChains, cosmosChains, suiChains, xrplChains, stellarChains } = useSquidChains(direction);
-    const { evmTokens, cosmosTokens, solanaTokens, bitcoinTokens, suiTokens, xrplTokens, stellarTokens, cantonTokens, } = useSquidTokens(direction);
+    const { evmTokens, cosmosTokens, solanaTokens, bitcoinTokens, suiTokens, xrplTokens, stellarTokens, } = useSquidTokens(direction);
     const { keplrTypeWallet } = useCosmosContext();
     const placeholderData = React.useMemo(() => {
         const tokens = {
@@ -30952,7 +30877,6 @@ const useAllTokensWithBalanceForChainType = ({ chainType, address, direction, qu
             [squidTypes.ChainType.SUI]: suiTokens.map((t) => ({ ...t, balance: "0" })),
             [squidTypes.ChainType.XRPL]: xrplTokens.map((t) => ({ ...t, balance: "0" })),
             [squidTypes.ChainType.STELLAR]: stellarTokens.map((t) => ({ ...t, balance: "0" })),
-            [squidTypes.ChainType.CANTON]: cantonTokens.map((t) => ({ ...t, balance: "0" })),
         };
         if (!chainType) {
             // Return all tokens with zero balance
@@ -30974,7 +30898,6 @@ const useAllTokensWithBalanceForChainType = ({ chainType, address, direction, qu
         suiTokens,
         xrplTokens,
         stellarTokens,
-        cantonTokens,
     ]);
     const isQueryEnabled = React.useMemo(() => {
         // Respect the queryOptions.enabled override if provided
@@ -30997,8 +30920,6 @@ const useAllTokensWithBalanceForChainType = ({ chainType, address, direction, qu
                 return xrplTokens.length > 0;
             case squidTypes.ChainType.STELLAR:
                 return stellarTokens.length > 0;
-            case squidTypes.ChainType.CANTON:
-                return cantonTokens.length > 0;
         }
     }, [
         chainType,
@@ -31011,7 +30932,6 @@ const useAllTokensWithBalanceForChainType = ({ chainType, address, direction, qu
         suiTokens.length,
         xrplTokens.length,
         stellarTokens.length,
-        cantonTokens.length,
     ]);
     const query = reactQuery.useQuery(keys().allTokensBalance(address, chainType, direction), async () => {
         // Return zero balances if no address
@@ -31121,12 +31041,6 @@ const useAllConnectedWalletBalances = ({ direction, queryOptions = {
         direction,
         queryOptions,
     });
-    const cantonBalancesQuery = useAllTokensWithBalanceForChainType({
-        chainType: squidTypes.ChainType.CANTON,
-        address: connectedAddresses?.[squidTypes.ChainType.CANTON],
-        direction,
-        queryOptions,
-    });
     // Create a map of chain type to balance query results
     const balanceQueries = React.useMemo(() => ({
         [squidTypes.ChainType.EVM]: evmBalancesQuery,
@@ -31136,7 +31050,6 @@ const useAllConnectedWalletBalances = ({ direction, queryOptions = {
         [squidTypes.ChainType.SUI]: suiBalancesQuery,
         [squidTypes.ChainType.XRPL]: xrplBalancesQuery,
         [squidTypes.ChainType.STELLAR]: stellarBalancesQuery,
-        [squidTypes.ChainType.CANTON]: cantonBalancesQuery,
     }), [
         evmBalancesQuery,
         cosmosBalancesQuery,
@@ -31145,7 +31058,6 @@ const useAllConnectedWalletBalances = ({ direction, queryOptions = {
         suiBalancesQuery,
         xrplBalancesQuery,
         stellarBalancesQuery,
-        cantonBalancesQuery,
     ]);
     // Combine all tokens from different chains
     const allTokens = React.useMemo(() => Object.values(balanceQueries).flatMap((query) => query.data?.tokens ?? []), [balanceQueries]);
@@ -31245,9 +31157,6 @@ const useMultiChainBalance = ({ chain, token, userAddress, enabled = true, }) =>
                 return xrplBalance;
             case squidTypes.ChainType.STELLAR:
                 return stellarBalance;
-            case squidTypes.ChainType.CANTON:
-                // TODO: implement canton balance fetching
-                return "0";
         }
     }, [
         chain?.chainType,
@@ -32356,9 +32265,6 @@ function useSendTransaction({ to, amount, token, chain, }) {
                         chain,
                     });
                     break;
-                case squidTypes.ChainType.CANTON: {
-                    throw new Error("Not implemented");
-                }
             }
             return {
                 amount,
@@ -32562,8 +32468,6 @@ async function getSendTransactionStatus({ chain, txHash, }) {
                 txHash,
                 chain,
             });
-        case squidTypes.ChainType.CANTON:
-            throw new Error("Not implemented");
     }
 }
 
@@ -32587,7 +32491,7 @@ const useHistory = (txType) => {
             fromChain: tx.params.fromChain,
             fromToken: tx.params.fromToken,
             fromAddress: tx.params.fromAddress,
-            fromAmount: tx.params.fromAmount ?? "",
+            fromAmount: tx.params.fromAmount,
             toChain: tx.params.toChain,
             toToken: tx.params.toToken,
             toAddress: tx.params.toAddress,
@@ -33015,129 +32919,6 @@ const useApproval = ({ squidRoute, }) => {
     };
 };
 
-const useSwapStatusQuery = ({ transaction, retry = 25, refetchOnWindowFocus = "always", enabled = true, onStatus, onEndStatus, onNotFound, onError, }) => {
-    const config = useConfigStore((state) => state.config);
-    const isInitialized = useConfigStore((state) => state.isInitialized);
-    const [isTransactionComplete, setIsTransactionComplete] = React.useState(false);
-    const [refetchInterval, setRefetchInterval] = React.useState(getSwapTxStatusRefetchInterval(transaction));
-    const { getChainType } = useSquidChains();
-    const fetchTransactionStatusWithLatestConfig = React.useCallback(async () => {
-        const latestConfig = useConfigStore.getState().config;
-        return fetchSwapTransactionStatus({
-            transaction,
-            integratorId: latestConfig.integratorId,
-            apiUrl: latestConfig.apiUrl,
-        });
-    }, [transaction]);
-    const transactionStatusQuery = reactQuery.useQuery(keys().swapTransactionStatus(transaction?.transactionId), fetchTransactionStatusWithLatestConfig, {
-        enabled: enabled &&
-            transaction?.transactionId !== "0" &&
-            !!transaction?.transactionId &&
-            !!transaction.fromAddress &&
-            !!config.apiUrl &&
-            transaction !== undefined &&
-            !isTransactionComplete &&
-            isInitialized,
-        refetchInterval(statusResponse) {
-            if (statusResponse &&
-                transactionEndStatuses.includes(getTransactionStatus(statusResponse) ?? "")) {
-                return false;
-            }
-            return refetchInterval;
-        },
-        retryDelay: getChainType(transaction?.fromChain) === squidTypes.ChainType.COSMOS ? 5000 : 3000,
-        retry: getChainType(transaction?.fromChain) === squidTypes.ChainType.COSMOS ? 6 : retry,
-        refetchOnWindowFocus,
-        onSuccess: (statusResponse) => {
-            WidgetEvents.getInstance().dispatchSwapStatus(statusResponse.squidTransactionStatus ?? "");
-            onStatus?.({
-                status: getTransactionStatus(statusResponse) ?? "",
-                statusResponse,
-            });
-            const endStatus = getTransactionEndStatus({ statusResponse });
-            if (endStatus) {
-                setIsTransactionComplete(true);
-                onEndStatus?.({ status: endStatus, statusResponse });
-            }
-        },
-        onError: (error) => {
-            if (is404Error(error.cause)) {
-                onNotFound?.();
-                return;
-            }
-            setRefetchInterval(-1);
-            setIsTransactionComplete(true);
-            onError?.();
-        },
-    });
-    return {
-        transactionStatusQuery,
-    };
-};
-
-// Statuses that indicate the source deposit has been received and the swap is
-// now progressing — the point at which it becomes a history-backed transaction.
-const sourceReceivedStatuses = [
-    // Chainflip
-    "DEPOSIT_RECEIVED",
-    "BROADCAST_REQUESTED",
-    "COMPLETE",
-    // Canton (Squid Intents)
-    "awaiting",
-    "success",
-];
-/**
- * Tracks a generated deposit address before it becomes a persisted swap history item.
- *
- * Mirrors the hooks-first pattern of `useExecuteTransaction`: once the source deposit
- * is received, it registers the transaction in the transaction + history stores, then
- * signals the view (via `onReceived`) to navigate. The view never writes to the stores.
- */
-const useDepositTransactionStatus = ({ transaction, route, retry = 25, refetchOnWindowFocus = "always", enabled = true, onReceived, }) => {
-    const { fromChain, toChain } = useSwap();
-    const { addSwapTransaction } = useHistory();
-    const getTransaction = useTransactionStore((state) => state.getTransaction);
-    const setTransactionStoreState = useTransactionStore((state) => state.setTransactionState);
-    return useSwapStatusQuery({
-        transaction,
-        retry,
-        refetchOnWindowFocus,
-        enabled,
-        onStatus: ({ status }) => {
-            if (!sourceReceivedStatuses.includes(status))
-                return;
-            if (!transaction?.transactionId || !route?.transactionRequest)
-                return;
-            const txLocalId = transaction.transactionId;
-            if (getTransaction(txLocalId))
-                return;
-            useTransactionStore.setState({
-                txLocalId,
-                currentTransaction: undefined,
-            });
-            const tx = {
-                routeType: route.transactionRequest.type,
-                fromChain,
-                toChain,
-                fromAddress: transaction.fromAddress,
-                transactionId: txLocalId,
-                transactionIdForStatus: transaction.transactionIdForStatus,
-                quoteId: transaction.quoteId ?? "",
-                status: exports.TransactionStatus.ONGOING,
-                sourceStatus: exports.TransactionStatus.SUCCESS,
-                timestamp: Date.now(),
-            };
-            setTransactionStoreState(txLocalId, tx);
-            addSwapTransaction({
-                ...tx,
-                params: route.params,
-                estimate: route.estimate,
-            });
-            onReceived?.();
-        },
-    });
-};
-
 const DEFAULT_PROVIDER_IMAGE_URL = "https://raw.githubusercontent.com/0xsquid/assets/main/images/webp128/providers/squid.webp";
 const AXELAR_PROVIDER_IMAGE_URL = "https://raw.githubusercontent.com/0xsquid/assets/main/images/webp128/providers/axelar.webp";
 const useEstimate = (squidRoute) => {
@@ -36456,7 +36237,7 @@ const useExecuteTransaction = (squidRoute) => {
             if (!route.params.fromAddress || !route.params.toAddress) {
                 throw new Error("From or to address is required");
             }
-            const isDirectTransfer = isChainflipDepositRoute(route);
+            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) {
@@ -36467,7 +36248,7 @@ const useExecuteTransaction = (squidRoute) => {
                     throw new Error("Deposit address is required");
                 }
                 const signature = await executeSolanaTransfer({
-                    amount: BigInt(route.params.fromAmount ?? ""),
+                    amount: BigInt(route.params.fromAmount),
                     target: depositData.depositAddress,
                     signer: solanaSigner,
                     connection: solanaConnection,
@@ -36477,7 +36258,7 @@ const useExecuteTransaction = (squidRoute) => {
                         const txParams = setTransactionState({
                             route,
                             txHash,
-                            transactionIdForStatus: depositData.statusTrackingId,
+                            transactionIdForStatus: depositData.chainflipStatusTrackingId,
                             userAddress: sourceUserAddress,
                             status: exports.TransactionStatus.INITIAL_LOADING,
                             sourceStatus: exports.TransactionStatus.ONGOING,
@@ -36528,7 +36309,7 @@ const useExecuteTransaction = (squidRoute) => {
         }
     });
     const swapMutationBitcoin = reactQuery.useMutation(async ({ id, route }) => {
-        const { depositAddress, amount: sendAmount, statusTrackingId, } = useDepositAddressStore.getState().deposit ?? {};
+        const { depositAddress, amount: sendAmount, chainflipStatusTrackingId, } = useDepositAddressStore.getState().deposit ?? {};
         if (!depositAddress) {
             throw new Error(`Invalid deposit address: ${depositAddress}`);
         }
@@ -36551,7 +36332,7 @@ const useExecuteTransaction = (squidRoute) => {
                     txHash,
                     // When bridging from Bitcoin we need to send the chainflipId to the status endpoint
                     // instead of the Bitcoin transaction hash
-                    transactionIdForStatus: statusTrackingId,
+                    transactionIdForStatus: chainflipStatusTrackingId,
                     userAddress: sourceUserAddress,
                     status: exports.TransactionStatus.INITIAL_LOADING,
                     sourceStatus: exports.TransactionStatus.ONGOING,
@@ -36999,7 +36780,7 @@ refetchIntervalInBackground = false, refetchInterval = 30000, quoteOnly = true,
     const squid = useSquidStore((state) => state.squid);
     const fallbackAddress = useSwapRoutePersistStore((store) => store.swapRoute?.fallbackAddress);
     const depositRefundAddress = useSwapRoutePersistStore((store) => store.swapRoute?.depositRefundAddress);
-    const { isDepositAddressActive } = useDepositAddress();
+    const { isAvailableAsPaymentMethod, isEnabled: isDepositAddressEnabled } = useDepositAddress();
     const getRouteMutation = useGetRoute();
     const { fromChain, toChain, fromPrice, destinationAddress: { address: destinationAddress } = {}, fromToken, toToken, } = useSwap();
     const { connectedAddress: { address: sourceConnectedAddress }, } = useMultiChainWallet(fromChain);
@@ -37007,7 +36788,7 @@ refetchIntervalInBackground = false, refetchInterval = 30000, quoteOnly = true,
     // Tokens will be sent to this address in case of swap failure
     //
     // If deposit address is not selected, we use the connected address as the source address instead
-    const sourceUserAddress = isDepositAddressActive
+    const sourceUserAddress = isDepositAddressEnabled && isAvailableAsPaymentMethod
         ? depositRefundAddress ?? sourceConnectedAddress
         : sourceConnectedAddress;
     const squidRouteQueryKeys = React.useMemo(() => keys().transaction(fromChain?.chainId, toChain?.chainId, toToken?.address, fromToken?.address, fromPrice, config.slippage, sourceUserAddress, config.degenMode, destinationAddress, fallbackAddress, quoteOnly, fromChain?.chainType, config.preHook, config.postHook, config.overrideGasRefundAddress), [
@@ -37152,50 +36933,94 @@ function useSendTransactionStatus({ chain, txHash, }) {
  * Fetch status of a Swap transaction
  */
 const useSwapTransactionStatus = ({ transaction, retry = 25, refetchOnWindowFocus = "always", enabled = true, }) => {
+    const config = useConfigStore((state) => state.config);
+    const isInitialized = useConfigStore((state) => state.isInitialized);
     const { replaceSwapTransactionStatus } = useHistory();
     const findTransaction = useHistoryStore((state) => state.findTransaction);
+    const [isTransactionComplete, setIsTransactionComplete] = React.useState(false);
+    const [refetchInterval, setRefetchInterval] = React.useState(getSwapTxStatusRefetchInterval(transaction));
+    const { getChainType } = useSquidChains();
     const currentHistoryItem = React.useMemo(() => findTransaction({
         transactionId: transaction?.transactionId,
         txType: exports.HistoryTxType.SWAP,
     }), [findTransaction, transaction?.transactionId]);
-    const transactionStatusQuery = useSwapStatusQuery({
-        transaction,
-        retry,
-        refetchOnWindowFocus,
+    /**
+     * Transaction status endpoint
+     * Squid api is using axelar endpoint and parsing the response
+     * @returns {StatusResponse} Status response
+     */
+    const fetchTransactionStatusWithLatestConfig = React.useCallback(async () => {
+        const latestConfig = useConfigStore.getState().config;
+        return fetchSwapTransactionStatus({
+            transaction,
+            integratorId: latestConfig.integratorId,
+            apiUrl: latestConfig.apiUrl,
+        });
+    }, [transaction]);
+    const transactionStatusQuery = reactQuery.useQuery(keys().swapTransactionStatus(transaction?.transactionId), fetchTransactionStatusWithLatestConfig, {
         enabled: enabled &&
+            transaction?.transactionId !== "0" &&
+            !!transaction?.transactionId &&
+            !!transaction.fromAddress &&
+            !!config.apiUrl &&
+            transaction !== undefined &&
+            !isTransactionComplete &&
+            isInitialized &&
             !!currentHistoryItem &&
             !isHistoryTransactionEnded({
                 data: currentHistoryItem?.data,
                 txType: exports.HistoryTxType.SWAP,
             }),
-        onEndStatus: ({ status, statusResponse }) => {
-            if (!transaction?.transactionId)
-                return;
-            replaceSwapTransactionStatus({
-                transactionId: transaction.transactionId,
-                statusResponse,
-                status,
-            });
+        refetchInterval(statusResponse) {
+            // If the status response is something telling that the transaction
+            // is finished, then store transaction history state if success
+            // And return false to indicate refetcher to stop
+            if (statusResponse &&
+                transactionEndStatuses.includes(getTransactionStatus(statusResponse) ?? "")) {
+                return false;
+            }
+            return refetchInterval; // Had to handle a variable here because after onError, we want the interval to stop
         },
-        onNotFound: () => {
-            if (!transaction?.transactionId)
-                return;
-            replaceSwapTransactionStatus({
-                transactionId: transaction.transactionId,
-                statusResponse: undefined,
-                status: exports.TransactionStatus.NOT_FOUND,
-            });
+        // At the moment Cosmos indexing takes more time, so need more time between retries
+        retryDelay: getChainType(transaction?.fromChain) === squidTypes.ChainType.COSMOS ? 5000 : 3000,
+        retry: getChainType(transaction?.fromChain) === squidTypes.ChainType.COSMOS ? 6 : retry,
+        refetchOnWindowFocus,
+        onSuccess: (statusResponse) => {
+            // Dispatch event
+            WidgetEvents.getInstance().dispatchSwapStatus(statusResponse.squidTransactionStatus ?? "");
+            const endStatus = getTransactionEndStatus({ statusResponse });
+            if (endStatus && transaction?.transactionId) {
+                setIsTransactionComplete(true);
+                replaceSwapTransactionStatus({
+                    transactionId: transaction.transactionId,
+                    statusResponse,
+                    status: endStatus,
+                });
+            }
         },
-        onError: () => {
+        onError: (error) => {
+            // `fetchTransactionStatus` throws an error with a cause being an AxiosError
+            const is404 = is404Error(error.cause);
             if (!transaction?.transactionId)
                 return;
-            replaceSwapTransactionStatus({
-                transactionId: transaction.transactionId,
-                statusResponse: undefined,
-                status: exports.TransactionStatus.ERROR,
-            });
+            if (is404) {
+                replaceSwapTransactionStatus({
+                    transactionId: transaction.transactionId,
+                    statusResponse: undefined,
+                    status: exports.TransactionStatus.NOT_FOUND,
+                });
+            }
+            else {
+                setRefetchInterval(-1);
+                setIsTransactionComplete(true);
+                replaceSwapTransactionStatus({
+                    transactionId: transaction.transactionId,
+                    statusResponse: undefined,
+                    status: exports.TransactionStatus.ERROR,
+                });
+            }
         },
-    }).transactionStatusQuery;
+    });
     return {
         transactionStatusQuery,
         latestStatus: transactionStatusQuery.data
@@ -37594,10 +37419,8 @@ const SquidProvider = ({ children, config, placeholder, }) => {
             }
             if (assetsColorsResponse.status === "fulfilled") {
                 useAssetsColorsStore.setState(assetsColorsResponse.value);
+                initializeSquidWithAssetsColors(squid, assetsColorsResponse.value);
             }
-            initializeSquidData(squid, assetsColorsResponse.status === "fulfilled"
-                ? assetsColorsResponse.value
-                : undefined);
             const shouldResetSwapRouteStore = 
             // reset swap route if specified in config
             !config?.loadPreviousStateFromLocalStorage ||
@@ -37786,14 +37609,13 @@ exports.getXummClient = getXummClient;
 exports.groupTokensByChainId = groupTokensByChainId;
 exports.groupTokensBySymbol = groupTokensBySymbol;
 exports.handleTransactionErrorEvents = handleTransactionErrorEvents;
-exports.initializeSquidData = initializeSquidData;
+exports.initializeSquidWithAssetsColors = initializeSquidWithAssetsColors;
 exports.is404Error = is404Error;
 exports.isActionCompletedOnSourceTx = isActionCompletedOnSourceTx;
 exports.isChainflipBridgeTransaction = isChainflipBridgeTransaction;
-exports.isChainflipDepositRoute = isChainflipDepositRoute;
 exports.isCoralBridgeAction = isCoralBridgeAction;
 exports.isCosmosAddressValid = isCosmosAddressValid;
-exports.isDepositAddressDirectTransferRoute = isDepositAddressDirectTransferRoute;
+exports.isDepositRoute = isDepositRoute;
 exports.isEmptyObject = isEmptyObject;
 exports.isEvmChainNotSupportedError = isEvmChainNotSupportedError;
 exports.isEvmosChain = isEvmosChain;
@@ -37809,7 +37631,6 @@ exports.isStatusError = isStatusError;
 exports.isStellarAddressValid = isStellarAddressValid;
 exports.isStellarIssuedToken = isStellarIssuedToken;
 exports.isStellarToken = isStellarToken;
-exports.isSupportedChainType = isSupportedChainType;
 exports.isSwapRouteError = isSwapRouteError;
 exports.isUserRejectionError = isUserRejectionError;
 exports.isValidHorizonAsset = isValidHorizonAsset;
@@ -37874,7 +37695,6 @@ exports.useCountryDetails = useCountryDetails;
 exports.useCurrencyDetails = useCurrencyDetails;
 exports.useDebouncedValue = useDebouncedValue;
 exports.useDepositAddress = useDepositAddress;
-exports.useDepositTransactionStatus = useDepositTransactionStatus;
 exports.useEnsDataForAddress = useEnsDataForAddress;
 exports.useEnsSearch = useEnsSearch;
 exports.useEstimate = useEstimate;
@@ -37941,4 +37761,4 @@ exports.useXrplTrustLine = useXrplTrustLine;
 exports.waitForReceiptWithRetry = waitForReceiptWithRetry;
 exports.walletIconBaseUrl = walletIconBaseUrl;
 exports.walletSupportsChainType = walletSupportsChainType;
-//# sourceMappingURL=index-mgE1SeE-.js.map
+//# sourceMappingURL=index-DcBFug8t.js.map