@0xsquid/react-hooks 8.8.0 → 8.8.1-beta-canton.1

package/dist/{index-IxCpRlyV.js → index-BOyZL5gB.js}

@@ -78,6 +78,8 @@ 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,
@@ -86,6 +88,7 @@ const chainTypeToZeroAddressMap = {
     [squidTypes.ChainType.SUI]: suiZeroAddress,
     [squidTypes.ChainType.XRPL]: xrplZeroAddress,
     [squidTypes.ChainType.STELLAR]: stellarZeroAddress,
+    [squidTypes.ChainType.CANTON]: cantonZeroAddress,
 };
 const nativeEvmTokenAddress = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
 const nativeCosmosTokenAddress = "uosmo";
@@ -94,6 +97,7 @@ 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";
@@ -157,6 +161,7 @@ const CHAIN_IDS = {
     XRPL_TESTNET: "xrpl-testnet",
     STELLAR: "stellar-mainnet",
     STELLAR_TESTNET: "stellar-testnet",
+    CANTON: "canton",
 };
 const chainTypeToDefaultChainIdMap = {
     [squidTypes.ChainType.EVM]: CHAIN_IDS.ETHEREUM,
@@ -166,6 +171,7 @@ 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,
@@ -175,6 +181,7 @@ const chainTypeToNativeTokenAddressMap = {
     [squidTypes.ChainType.SUI]: nativeSuiTokenAddress,
     [squidTypes.ChainType.XRPL]: nativeXrplTokenAddress,
     [squidTypes.ChainType.STELLAR]: nativeStellarTokenAddress,
+    [squidTypes.ChainType.CANTON]: nativeCantonTokenAddress,
 };
 const defaultConfigValues = {
     integratorId: INTEGRATOR_ID,
@@ -20872,6 +20879,18 @@ 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);
+}
+
 exports.HistoryTxType = void 0;
 (function (HistoryTxType) {
     HistoryTxType[HistoryTxType["SWAP"] = 0] = "SWAP";
@@ -20985,6 +21004,7 @@ 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:
@@ -21094,10 +21114,16 @@ 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: transaction?.transactionIdForStatus ?? transaction?.transactionId,
+                transactionId,
                 fromChainId: transaction?.fromChain,
                 toChainId: transaction?.toChain,
                 bridgeType: transaction?.bridgeType,
@@ -21144,7 +21170,7 @@ function isActionCompletedOnSourceTx(action, fromChainId) {
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
-const isDepositRoute = (route) => {
+const isChainflipDepositRoute = (route) => {
     return (!!route &&
         route.transactionRequest?.type === squidTypes.SquidDataType.ChainflipDepositAddress);
 };
@@ -21169,6 +21195,12 @@ 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:
@@ -21671,7 +21703,17 @@ 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 "";
@@ -21684,14 +21726,15 @@ const formatHash = ({ chainType, hash }) => {
             chainTypeFormat = squidTypes.ChainType.COSMOS;
         }
     }
-    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 { 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 isWalletAddressValid = (chainData, address) => {
     if (!address || !chainData?.chainType)
@@ -21711,6 +21754,8 @@ const isWalletAddressValid = (chainData, address) => {
             return isXrplAddressValid(address);
         case squidTypes.ChainType.STELLAR:
             return isStellarAddressValid(address);
+        case squidTypes.ChainType.CANTON:
+            return isCantonAddressValid(address);
     }
 };
 const redirectToExtensionsStore = (wallet) => {
@@ -21972,6 +22017,8 @@ const connectByChainType = async (chainType, wallet, defaultChain, params) => {
                     connector,
                 },
             });
+        case squidTypes.ChainType.CANTON:
+            return null;
     }
 };
 const getChainTypesToConnect = (selectedChainTypes, defaultChain, supportedChains) => {
@@ -23046,7 +23093,10 @@ const getNewSwapParamsFromInput = ({ inputParams, initialSwapRoute, tokens, chai
     else {
         newFallbackAddress = fallbackAddress ?? initialSwapRoute?.fallbackAddress;
     }
-    const newDepositRefundAddress = depositRefundAddress || initialSwapRoute?.depositRefundAddress;
+    const sourceChainChanged = fromChainId !== undefined && fromChainId !== initialSwapRoute?.fromChainId;
+    const newDepositRefundAddress = sourceChainChanged
+        ? undefined
+        : depositRefundAddress || initialSwapRoute?.depositRefundAddress;
     return {
         fromChainId: srcChainId,
         fromTokenAddress: sourceTokenAddress,
@@ -23325,7 +23375,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-D0p2T9tf.js'); });
+    const { fetchAllSecretBalances } = await Promise.resolve().then(function () { return require('./secretService-DQhP5g0c.js'); });
     return fetchAllSecretBalances(chainData, cosmosAddress, squidSecretTokens, keplrTypeWallet);
 };
 function getTokenAssetsKey(token) {
@@ -25299,7 +25349,7 @@ const useSquidTokens = (direction) => {
         config.availableChains,
         direction,
     ]);
-    const { evmTokens, cosmosTokens, solanaTokens, bitcoinTokens, suiTokens, xrplTokens, stellarTokens, } = React.useMemo(() => {
+    const { evmTokens, cosmosTokens, solanaTokens, bitcoinTokens, suiTokens, xrplTokens, stellarTokens, cantonTokens, } = React.useMemo(() => {
         return tokens?.reduce((acc, token) => {
             switch (token.type) {
                 case squidTypes.ChainType.EVM:
@@ -25323,6 +25373,9 @@ const useSquidTokens = (direction) => {
                 case squidTypes.ChainType.STELLAR:
                     acc.stellarTokens.push(token);
                     break;
+                case squidTypes.ChainType.CANTON:
+                    acc.cantonTokens.push(token);
+                    break;
             }
             return acc;
         }, {
@@ -25333,6 +25386,7 @@ const useSquidTokens = (direction) => {
             suiTokens: [],
             xrplTokens: [],
             stellarTokens: [],
+            cantonTokens: [],
         });
     }, [tokens]);
     const findToken = React.useCallback((address, chainId) => {
@@ -25350,6 +25404,7 @@ const useSquidTokens = (direction) => {
         suiTokens,
         xrplTokens,
         stellarTokens,
+        cantonTokens,
     };
 };
 
@@ -25887,6 +25942,7 @@ 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
@@ -26153,7 +26209,7 @@ const useSquidChains = (direction) => {
         const chain = findChain(chainId);
         return chain?.chainType;
     }, [findChain]);
-    const { evmChains, cosmosChains, suiChains, stellarChains, xrplChains } = React.useMemo(() => {
+    const { evmChains, cosmosChains, suiChains, stellarChains, xrplChains, cantonChains, } = React.useMemo(() => {
         return chains.reduce((acc, chain) => {
             switch (chain.chainType) {
                 case squidTypes.ChainType.EVM:
@@ -26171,6 +26227,9 @@ const useSquidChains = (direction) => {
                 case squidTypes.ChainType.STELLAR:
                     acc.stellarChains.push(chain);
                     break;
+                case squidTypes.ChainType.CANTON:
+                    acc.cantonChains.push(chain);
+                    break;
             }
             return acc;
         }, {
@@ -26179,6 +26238,7 @@ const useSquidChains = (direction) => {
             suiChains: [],
             xrplChains: [],
             stellarChains: [],
+            cantonChains: [],
         });
     }, [chains]);
     const { supportedSourceChains, supportedDestinationChains } = React.useMemo(() => {
@@ -26199,6 +26259,7 @@ const useSquidChains = (direction) => {
         suiChains,
         xrplChains,
         stellarChains,
+        cantonChains,
         getChainType,
         findChain,
     };
@@ -26723,7 +26784,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-Cia5YJMU.js'); });
+                const { formatStellarWallet } = await Promise.resolve().then(function () { return require('./stellarService.client-BQrRZDwB.js'); });
                 const modules = [...initializeAllModules(), new LedgerModule()];
                 const promises = modules.map(async (module) => {
                     const isAvailable = await module.isAvailable();
@@ -27422,6 +27483,7 @@ 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);
@@ -27509,6 +27571,16 @@ 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,
@@ -27520,6 +27592,7 @@ const useMultiChainWallet = (chain) => {
         suiAddress,
         xrplAddress,
         stellarAddress,
+        cantonAddress,
     ]);
     /**
      * Change current network for desired chain
@@ -28344,6 +28417,8 @@ async function createClient(chain) {
             return new XrplRpcClient(chain.rpc);
         case squidTypes.ChainType.STELLAR:
             return new StellarRpcClient(chain.rpc);
+        case squidTypes.ChainType.CANTON:
+            return null;
     }
 }
 
@@ -29536,7 +29611,7 @@ const useStellarBalance = ({ userAddress, chain, enabled, token, refreshInterval
 };
 
 function useNativeTokenForChain(chain) {
-    const { evmTokens, cosmosTokens, solanaTokens, bitcoinTokens, suiTokens, xrplTokens, stellarTokens, } = useSquidTokens();
+    const { evmTokens, cosmosTokens, solanaTokens, bitcoinTokens, suiTokens, xrplTokens, stellarTokens, cantonTokens, } = useSquidTokens();
     const getTokensForChainType = () => {
         if (!chain?.chainType)
             return [];
@@ -29555,6 +29630,8 @@ function useNativeTokenForChain(chain) {
                 return xrplTokens;
             case squidTypes.ChainType.STELLAR:
                 return stellarTokens;
+            case squidTypes.ChainType.CANTON:
+                return cantonTokens;
         }
     };
     const nativeTokenForChainType = React.useMemo(() => {
@@ -29789,6 +29866,11 @@ 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)
@@ -29825,6 +29907,9 @@ const useNativeBalance = (chain) => {
                 return isXrpLoading;
             case squidTypes.ChainType.STELLAR:
                 return isStellarLoading;
+            case squidTypes.ChainType.CANTON:
+                // TODO: implement canton balance fetching
+                return false;
         }
     }, [
         chain?.chainType,
@@ -30049,7 +30134,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-C1qztDII.js'); });
+                const { EthereumProvider } = await Promise.resolve().then(function () { return require('./index.es-CjEZHrFG.js'); });
                 const rawProvider = await EthereumProvider.init({
                     ...restParameters,
                     disableProviderPing: true,
@@ -30279,6 +30364,8 @@ const useSigner = ({ chain }) => {
                 return isXrplSignerReady;
             case squidTypes.ChainType.STELLAR:
                 return isStellarSignerReady;
+            case squidTypes.ChainType.CANTON:
+                return false;
         }
     }, [
         chain?.chainType,
@@ -30751,6 +30838,7 @@ function useDepositAddress(squidRoute) {
         const chainsSupportingDepositAddress = [
             CHAIN_IDS.BITCOIN,
             CHAIN_IDS.SOLANA,
+            CHAIN_IDS.CANTON,
         ];
         return chainsSupportingDepositAddress.includes(fromChain.chainId);
     }, [fromChain?.chainId]);
@@ -30765,20 +30853,34 @@ function useDepositAddress(squidRoute) {
         toggleDepositFlow(false);
     }, [toggleDepositFlow]);
     const closeDepositChannel = React.useCallback(() => {
-        toggleDepositFlow(false);
         setDeposit(null);
-    }, [toggleDepositFlow, setDeposit]);
+    }, [setDeposit]);
     const getRouteWithDeposit = reactQuery.useMutation(async ({ route }) => {
-        if (!squid)
-            throw new Error("Squid SDK not initialized");
-        const depositAddressResponse = (await squid.executeRoute({
-            signer: {},
-            route,
-        }));
-        setDeposit(depositAddressResponse);
-        return {
-            depositAddress: depositAddressResponse,
-        };
+        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;
+        }
     });
     return {
         isEnabled,
@@ -30817,7 +30919,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, } = useSquidTokens(direction);
+    const { evmTokens, cosmosTokens, solanaTokens, bitcoinTokens, suiTokens, xrplTokens, stellarTokens, cantonTokens, } = useSquidTokens(direction);
     const { keplrTypeWallet } = useCosmosContext();
     const placeholderData = React.useMemo(() => {
         const tokens = {
@@ -30828,6 +30930,7 @@ 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
@@ -30849,6 +30952,7 @@ const useAllTokensWithBalanceForChainType = ({ chainType, address, direction, qu
         suiTokens,
         xrplTokens,
         stellarTokens,
+        cantonTokens,
     ]);
     const isQueryEnabled = React.useMemo(() => {
         // Respect the queryOptions.enabled override if provided
@@ -30871,6 +30975,8 @@ 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,
@@ -30883,6 +30989,7 @@ 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
@@ -30992,6 +31099,12 @@ 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,
@@ -31001,6 +31114,7 @@ const useAllConnectedWalletBalances = ({ direction, queryOptions = {
         [squidTypes.ChainType.SUI]: suiBalancesQuery,
         [squidTypes.ChainType.XRPL]: xrplBalancesQuery,
         [squidTypes.ChainType.STELLAR]: stellarBalancesQuery,
+        [squidTypes.ChainType.CANTON]: cantonBalancesQuery,
     }), [
         evmBalancesQuery,
         cosmosBalancesQuery,
@@ -31009,6 +31123,7 @@ 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]);
@@ -31108,6 +31223,9 @@ 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,
@@ -32216,6 +32334,9 @@ function useSendTransaction({ to, amount, token, chain, }) {
                         chain,
                     });
                     break;
+                case squidTypes.ChainType.CANTON: {
+                    throw new Error("Not implemented");
+                }
             }
             return {
                 amount,
@@ -32419,6 +32540,8 @@ async function getSendTransactionStatus({ chain, txHash, }) {
                 txHash,
                 chain,
             });
+        case squidTypes.ChainType.CANTON:
+            throw new Error("Not implemented");
     }
 }
 
@@ -32442,7 +32565,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,
@@ -32870,6 +32993,128 @@ 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",
+];
+/**
+ * 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) => {
@@ -36188,7 +36433,7 @@ const useExecuteTransaction = (squidRoute) => {
             if (!route.params.fromAddress || !route.params.toAddress) {
                 throw new Error("From or to address is required");
             }
-            const isDirectTransfer = isDepositRoute(route);
+            const isDirectTransfer = isChainflipDepositRoute(route);
             // Means it's a transfer to a deposit address
             // Instead of a Swap/Contract call using a DEX like Jupiter
             if (isDirectTransfer) {
@@ -36199,7 +36444,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,
@@ -36209,7 +36454,7 @@ const useExecuteTransaction = (squidRoute) => {
                         const txParams = setTransactionState({
                             route,
                             txHash,
-                            transactionIdForStatus: depositData.chainflipStatusTrackingId,
+                            transactionIdForStatus: depositData.statusTrackingId,
                             userAddress: sourceUserAddress,
                             status: exports.TransactionStatus.INITIAL_LOADING,
                             sourceStatus: exports.TransactionStatus.ONGOING,
@@ -36260,7 +36505,7 @@ const useExecuteTransaction = (squidRoute) => {
         }
     });
     const swapMutationBitcoin = reactQuery.useMutation(async ({ id, route }) => {
-        const { depositAddress, amount: sendAmount, chainflipStatusTrackingId, } = useDepositAddressStore.getState().deposit ?? {};
+        const { depositAddress, amount: sendAmount, statusTrackingId, } = useDepositAddressStore.getState().deposit ?? {};
         if (!depositAddress) {
             throw new Error(`Invalid deposit address: ${depositAddress}`);
         }
@@ -36283,7 +36528,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: chainflipStatusTrackingId,
+                    transactionIdForStatus: statusTrackingId,
                     userAddress: sourceUserAddress,
                     status: exports.TransactionStatus.INITIAL_LOADING,
                     sourceStatus: exports.TransactionStatus.ONGOING,
@@ -36884,94 +37129,50 @@ 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]);
-    /**
-     * 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, {
+    const transactionStatusQuery = useSwapStatusQuery({
+        transaction,
+        retry,
+        refetchOnWindowFocus,
         enabled: enabled &&
-            transaction?.transactionId !== "0" &&
-            !!transaction?.transactionId &&
-            !!transaction.fromAddress &&
-            !!config.apiUrl &&
-            transaction !== undefined &&
-            !isTransactionComplete &&
-            isInitialized &&
             !!currentHistoryItem &&
             !isHistoryTransactionEnded({
                 data: currentHistoryItem?.data,
                 txType: exports.HistoryTxType.SWAP,
             }),
-        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
+        onEndStatus: ({ status, statusResponse }) => {
+            if (!transaction?.transactionId)
+                return;
+            replaceSwapTransactionStatus({
+                transactionId: transaction.transactionId,
+                statusResponse,
+                status,
+            });
         },
-        // 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,
-                });
-            }
+        onNotFound: () => {
+            if (!transaction?.transactionId)
+                return;
+            replaceSwapTransactionStatus({
+                transactionId: transaction.transactionId,
+                statusResponse: undefined,
+                status: exports.TransactionStatus.NOT_FOUND,
+            });
         },
-        onError: (error) => {
-            // `fetchTransactionStatus` throws an error with a cause being an AxiosError
-            const is404 = is404Error(error.cause);
+        onError: () => {
             if (!transaction?.transactionId)
                 return;
-            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,
-                });
-            }
+            replaceSwapTransactionStatus({
+                transactionId: transaction.transactionId,
+                statusResponse: undefined,
+                status: exports.TransactionStatus.ERROR,
+            });
         },
-    });
+    }).transactionStatusQuery;
     return {
         transactionStatusQuery,
         latestStatus: transactionStatusQuery.data
@@ -37564,9 +37765,10 @@ exports.initializeSquidWithAssetsColors = initializeSquidWithAssetsColors;
 exports.is404Error = is404Error;
 exports.isActionCompletedOnSourceTx = isActionCompletedOnSourceTx;
 exports.isChainflipBridgeTransaction = isChainflipBridgeTransaction;
+exports.isChainflipDepositRoute = isChainflipDepositRoute;
 exports.isCoralBridgeAction = isCoralBridgeAction;
 exports.isCosmosAddressValid = isCosmosAddressValid;
-exports.isDepositRoute = isDepositRoute;
+exports.isDepositAddressDirectTransferRoute = isDepositAddressDirectTransferRoute;
 exports.isEmptyObject = isEmptyObject;
 exports.isEvmChainNotSupportedError = isEvmChainNotSupportedError;
 exports.isEvmosChain = isEvmosChain;
@@ -37646,6 +37848,7 @@ exports.useCountryDetails = useCountryDetails;
 exports.useCurrencyDetails = useCurrencyDetails;
 exports.useDebouncedValue = useDebouncedValue;
 exports.useDepositAddress = useDepositAddress;
+exports.useDepositTransactionStatus = useDepositTransactionStatus;
 exports.useEnsDataForAddress = useEnsDataForAddress;
 exports.useEnsSearch = useEnsSearch;
 exports.useEstimate = useEstimate;
@@ -37712,4 +37915,4 @@ exports.useXrplTrustLine = useXrplTrustLine;
 exports.waitForReceiptWithRetry = waitForReceiptWithRetry;
 exports.walletIconBaseUrl = walletIconBaseUrl;
 exports.walletSupportsChainType = walletSupportsChainType;
-//# sourceMappingURL=index-IxCpRlyV.js.map
+//# sourceMappingURL=index-BOyZL5gB.js.map