@0xsquid/react-hooks 8.11.1-beta-danal.2 → 8.12.1-beta-arc.0

package/dist/{index-ByakOYXP.js → index-CLzjMzS_.js}

@@ -59,7 +59,6 @@ const suiZeroAddress = "0x0000000000000000000000000000000000000000";
 const xrplZeroAddress = "rrrrrrrrrrrrrrrrrrrrrhoLvTp";
 const stellarZeroAddress = "GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWHF";
 const cantonZeroAddress = "none::12200000000000000000000000000000000000000000000000000000000000000000";
-const danalZeroAddress = "PCI00000000000000000000000000000000000000000000000000";
 const chainTypeToZeroAddressMap = {
     [ChainType.EVM]: zeroAddress$1,
     [ChainType.COSMOS]: cosmosZeroAddress,
@@ -69,7 +68,6 @@ const chainTypeToZeroAddressMap = {
     [ChainType.XRPL]: xrplZeroAddress,
     [ChainType.STELLAR]: stellarZeroAddress,
     [ChainType.CANTON]: cantonZeroAddress,
-    [ChainType.DANAL]: danalZeroAddress,
 };
 const nativeEvmTokenAddress = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
 const nativeCosmosTokenAddress = "uosmo";
@@ -79,7 +77,6 @@ const nativeSuiTokenAddress = "0x00000000000000000000000000000000000000000000000
 const nativeXrplTokenAddress = "xrp";
 const nativeStellarTokenAddress = "CAS3J7GYLGXMF6TDJBBYYSE3HQ6BBSMLNUQ34T6TZMYMW2EVH34XOWMA";
 const nativeCantonTokenAddress = "DSO::1220b1431ef217342db44d516bb9befde802be7d8899637d290895fa58880f19accc";
-const nativeDanalTokenAddress = "pci";
 // by setting slippage to undefined, it's set to "auto"
 const defaultSlippage = undefined;
 const destinationAddressResetValue = "null";
@@ -135,6 +132,7 @@ const CHAIN_IDS = {
     MANTRA: "5888",
     CITREA: "4114",
     TEMPO: "4217",
+    ARC: "5042",
     // others
     BITCOIN: "bitcoin",
     SOLANA: "solana-mainnet-beta",
@@ -145,7 +143,6 @@ const CHAIN_IDS = {
     STELLAR: "stellar-mainnet",
     STELLAR_TESTNET: "stellar-testnet",
     CANTON: "canton",
-    DANAL_TESTNET: "danal-testnet",
 };
 const chainTypeToDefaultChainIdMap = {
     [ChainType.EVM]: CHAIN_IDS.ETHEREUM,
@@ -156,7 +153,6 @@ const chainTypeToDefaultChainIdMap = {
     [ChainType.XRPL]: CHAIN_IDS.XRPL,
     [ChainType.STELLAR]: CHAIN_IDS.STELLAR,
     [ChainType.CANTON]: CHAIN_IDS.CANTON,
-    [ChainType.DANAL]: CHAIN_IDS.DANAL_TESTNET,
 };
 const chainTypeToNativeTokenAddressMap = {
     [ChainType.EVM]: nativeEvmTokenAddress,
@@ -167,7 +163,6 @@ const chainTypeToNativeTokenAddressMap = {
     [ChainType.XRPL]: nativeXrplTokenAddress,
     [ChainType.STELLAR]: nativeStellarTokenAddress,
     [ChainType.CANTON]: nativeCantonTokenAddress,
-    [ChainType.DANAL]: nativeDanalTokenAddress,
 };
 const defaultConfigValues = {
     integratorId: INTEGRATOR_ID,
@@ -20949,6 +20944,27 @@ const isBitcoinAddressValid = (address$1) => {
     }
 };
 
+const arcUsdcTokenAddress = "0x3600000000000000000000000000000000000000";
+const isArcChain = (chainId) => chainId === CHAIN_IDS.ARC;
+const isArcUsdcToken = (token) => isArcChain(token?.chainId) &&
+    token?.address.toLowerCase() === arcUsdcTokenAddress;
+const isArcNativeToken = (token) => isArcChain(token?.chainId) &&
+    token?.address.toLowerCase() === nativeEvmTokenAddress;
+const normalizeArcTokenAddress = (chainId, address) => isArcChain(chainId) && address?.toLowerCase() === nativeEvmTokenAddress
+    ? arcUsdcTokenAddress
+    : address;
+const deduplicateArcBalances = (tokens) => {
+    const canonicalChains = new Set(tokens
+        .filter((token) => isArcChain(token.chainId) &&
+        token.address?.toLowerCase() === arcUsdcTokenAddress)
+        .map((token) => token.chainId));
+    return tokens.filter((token) => !(canonicalChains.has(token.chainId) &&
+        token.address?.toLowerCase() === nativeEvmTokenAddress));
+};
+
+function getCantonCommandId(memo) {
+    return `canton-${memo}`;
+}
 /**
  * Format a Canton connector into a Squid {@link CantonWallet}. Shared by the
  * announce-discovery and injected-provider paths.
@@ -21099,51 +21115,16 @@ function cantonInstrumentKey(instrument) {
  * is already a Decimal, not base units).
  */
 function groupCantonHoldingBalances(acsResponse) {
+    return sumCantonHoldingBalances(parseCantonHoldings(acsResponse).filter((holding) => !holding.locked));
+}
+function sumCantonHoldingBalances(holdings) {
     const totals = {};
-    for (const holding of parseCantonHoldings(acsResponse)) {
-        // Locked holdings are not spendable, skip them
-        if (holding.locked)
-            continue;
+    for (const holding of holdings) {
         const key = cantonInstrumentKey(holding.instrument);
         const total = totals[key] ?? new BigNumber(0);
         totals[key] = total.plus(new BigNumber(holding.amount));
     }
-    return Object.fromEntries(Object.entries(totals).map(([key, total]) => [key, total.toString(10)]));
-}
-
-// Matches the backend validation: "PCI" + 50 uppercase-hex chars, case-sensitive.
-const DANAL_ADDRESS_REGEX = /^PCI[0-9A-F]{50}$/;
-function isDanalAddressValid(address) {
-    if (!address)
-        return false;
-    return DANAL_ADDRESS_REGEX.test(address);
-}
-// Fabric transaction id: 64 hex chars, no 0x prefix
-const DANAL_TX_HASH_REGEX = /^[0-9a-fA-F]{64}$/;
-function isDanalTxHashValid(hash) {
-    if (!hash)
-        return false;
-    return DANAL_TX_HASH_REGEX.test(hash);
-}
-function isDanalTransferRequestBody(value) {
-    if (typeof value !== "object" || value === null)
-        return false;
-    const { receiver, amount, memo } = value;
-    return (typeof receiver === "string" &&
-        receiver.length > 0 &&
-        typeof amount === "string" &&
-        amount.length > 0 &&
-        typeof memo === "string" &&
-        memo.length > 0);
-}
-function parseDanalTransferBody(data) {
-    try {
-        const parsed = JSON.parse(data);
-        return isDanalTransferRequestBody(parsed) ? parsed : null;
-    }
-    catch {
-        return null;
-    }
+    return Object.fromEntries(Object.entries(totals).map(([key, total]) => [key, total.toFixed()]));
 }
 
 const solanaTokenProgramIdByAddress = {
@@ -21482,15 +21463,6 @@ function isOnChainTxData(squidData) {
 function isDepositAddressDirectTransferRoute(squidData) {
     return squidData.type === SquidDataType.DepositAddressDirectTransfer;
 }
-/**
- * Danal keeps SquidDataType.DepositAddressWithMemo, which XRPL/Stellar use for
- * wallet-signed transactions — so the deposit treatment is gated on the chain,
- * not just the type
- */
-function isDanalDepositRoute(route) {
-    return (route.params.fromChain === CHAIN_IDS.DANAL_TESTNET &&
-        route.transactionRequest?.type === SquidDataType.DepositAddressWithMemo);
-}
 function getHistoryTransactionId(tx) {
     switch (tx.txType) {
         case HistoryTxType.SWAP:
@@ -22015,11 +21987,6 @@ const chainTypeToTrimLength = {
         start: 3,
         end: 3,
     },
-    // PCI0180...E77E
-    [ChainType.DANAL]: {
-        start: 7,
-        end: 4,
-    },
 };
 const truncateWithEllipsis = (value, startLength, endLength) => value.length <= startLength + endLength
     ? value
@@ -22068,8 +22035,6 @@ const isWalletAddressValid = (chainData, address) => {
             return isStellarAddressValid(address);
         case ChainType.CANTON:
             return isCantonAddressValid(address);
-        case ChainType.DANAL:
-            return isDanalAddressValid(address);
     }
 };
 const redirectToExtensionsStore = (wallet) => {
@@ -22233,7 +22198,7 @@ function sortAddressBook(a, b, selectedAddress) {
     return 0;
 }
 const calculateTotalUsdBalanceUSD = (tokens) => {
-    const totalUsd = tokens.reduce((total, token) => {
+    const totalUsd = deduplicateArcBalances(tokens).reduce((total, token) => {
         const balance = parseFloat(token.balance);
         const usdPrice = token.usdPrice ?? 0;
         const balanceUsd = balance * usdPrice;
@@ -22354,8 +22319,6 @@ const connectByChainType = async (chainType, wallet, defaultChain, params) => {
                     connector,
                 },
             });
-        case ChainType.DANAL:
-            return null;
     }
 };
 const getChainTypesToConnect = (selectedChainTypes, defaultChain, supportedChains) => {
@@ -22480,6 +22443,8 @@ const cancelConnectWallet = (wallet) => {
         return;
     }
     switch (wallet.type) {
+        case ChainType.CANTON:
+            return wallet.connector.cancelConnect?.();
         case ChainType.XRPL:
             return wallet.connector.cancelConnect?.();
         default:
@@ -23045,22 +23010,36 @@ const getFirstAvailableChainId = (config, direction, chains = []) => {
     // if no initial chain ID is found in config, return the first available chain ID
     return availableChains.length > 0 ? availableChains[0].chainId : undefined;
 };
-const fetchHighestBalanceToken = (fetchCachedBalance, chainId) => {
+const fetchHighestBalanceToken = (fetchCachedBalance, chainId, selectableTokens, direction) => {
     let address = undefined;
     if (fetchCachedBalance) {
         const queryCache = fetchCachedBalance?.queryClient?.getQueryCache();
+        const directionCache = isArcChain(chainId) && direction
+            ? queryCache?.find(keys().allTokensBalance(fetchCachedBalance.address, ChainType.EVM, direction))
+            : undefined;
         // get cached balance from key
-        const cache = queryCache?.find(keys().allTokensBalance(fetchCachedBalance?.address, !isNaN(Number(chainId)) ? ChainType.EVM : ChainType.COSMOS));
-        // Parse result to TokenWithBalance[]
-        const cacheResult = cache?.state.data ?? [];
+        const cache = directionCache?.state.data !== undefined
+            ? directionCache
+            : queryCache?.find(keys().allTokensBalance(fetchCachedBalance?.address, !isNaN(Number(chainId)) ? ChainType.EVM : ChainType.COSMOS));
+        const cacheData = cache?.state.data;
+        const cacheResult = Array.isArray(cacheData)
+            ? cacheData
+            : isArcChain(chainId)
+                ? (cacheData?.tokens ?? [])
+                : [];
         if (cacheResult.length > 0) {
-            const tokensWithBalance = cacheResult.filter((t) => t.chainId === chainId && Number(t.balance) > 0);
+            const tokensWithBalance = deduplicateArcBalances(cacheResult).filter((t) => t.chainId === chainId &&
+                Number(t.balance) > 0 &&
+                (!selectableTokens ||
+                    selectableTokens.some((token) => token.chainId === t.chainId &&
+                        token.address.toLowerCase() ===
+                            normalizeArcTokenAddress(t.chainId, t.address)?.toLowerCase())));
             if (tokensWithBalance.length > 0) {
                 // Return the token with the highest balance
                 // TODO: At the moment we're not taking into account usd price
                 const tokenWithHighestBalance = tokensWithBalance.reduce((prev, current) => Number(prev.balance) > Number(current.balance) ? prev : current);
                 if (tokenWithHighestBalance) {
-                    address = tokenWithHighestBalance.address;
+                    address = normalizeArcTokenAddress(tokenWithHighestBalance.chainId, tokenWithHighestBalance.address);
                 }
             }
         }
@@ -23071,6 +23050,21 @@ const findNativeTokenForChainType = (tokens) => {
     return tokens.find((t) => t.address.toLowerCase() ===
         chainTypeToNativeTokenAddressMap[t.type].toLowerCase());
 };
+const getTokenAddressForSelection = ({ tokens, config, chainId, address, direction, excludeToken, }) => {
+    if (!isArcChain(chainId))
+        return address;
+    const normalizedAddress = normalizeArcTokenAddress(chainId, address);
+    const excludedAddress = normalizeArcTokenAddress(excludeToken?.chainId, excludeToken?.address);
+    if (!chainId ||
+        !normalizedAddress ||
+        (excludeToken?.chainId === chainId &&
+            normalizedAddress.toLowerCase() === excludedAddress?.toLowerCase()) ||
+        !getSupportedChainIdsForDirection([chainId], config, direction).includes(chainId)) {
+        return undefined;
+    }
+    return filterViewableTokens(tokens, config, direction).find((token) => token.chainId === chainId &&
+        token.address.toLowerCase() === normalizedAddress.toLowerCase())?.address;
+};
 /**
  * Returns the default token address for a specific chain and direction based on config.
  * If no default tokens are set in config, returns the native token for the specified chain
@@ -23088,6 +23082,25 @@ const getInitialOrDefaultTokenAddressForChain = ({ tokens, config, chainId, dire
     const supportedChainIds = getSupportedChainIdsForDirection([chainId], config, direction);
     if (!supportedChainIds.includes(chainId))
         return;
+    if (isArcChain(chainId)) {
+        const selectAddress = (address) => getTokenAddressForSelection({
+            tokens,
+            config,
+            chainId,
+            address,
+            direction,
+            excludeToken,
+        });
+        const selectableTokens = tokens.filter((token) => token.chainId === chainId &&
+            !isArcNativeToken(token) &&
+            selectAddress(token.address) !== undefined);
+        return (selectAddress(config.defaultTokensPerChain?.find((token) => token.chainId === chainId)
+            ?.address) ??
+            selectAddress(getInitialTokenAddressForChain({ tokens, config, chainId, direction })) ??
+            selectAddress(fetchHighestBalanceToken(fetchCachedBalance, chainId, selectableTokens, direction)) ??
+            selectAddress(arcUsdcTokenAddress) ??
+            selectableTokens[0]?.address);
+    }
     const configDefaultTokenForChain = config.defaultTokensPerChain?.find((token) => token.chainId == chainId);
     // get default token from config
     if (configDefaultTokenForChain &&
@@ -23131,6 +23144,23 @@ const getInitialTokenAddressForChain = ({ chainId, config, direction, tokens, un
     const initialAsset = config.initialAssets?.[direction];
     if (!initialAsset)
         return undefined;
+    if (isArcChain(chainId)) {
+        const address = isNamedTokenConfig(initialAsset)
+            ? tokens.find((token) => token.chainId === chainId &&
+                !isArcNativeToken(token) &&
+                token.symbol.toLowerCase() === initialAsset.symbol?.toLowerCase())?.address
+            : initialAsset.chainId === chainId
+                ? initialAsset.address
+                : undefined;
+        return getTokenAddressForSelection({
+            tokens,
+            config,
+            chainId,
+            address,
+            direction,
+            excludeToken: { chainId, address: unavailableTokenAddress },
+        });
+    }
     if (isNamedTokenConfig(initialAsset)) {
         if (!initialAsset.symbol)
             return undefined;
@@ -23340,12 +23370,44 @@ const handleDestinationAddressOnSwapChange = ({ fromChainId, fromTokenAddress, t
     });
     let destinationTokenAddress = toChainId && !toTokenAddress
         ? defaultToAddress
-        : toTokenAddress ?? swapRoute?.toTokenAddress;
+        : (toTokenAddress ?? swapRoute?.toTokenAddress);
     const lowerCaseDestinationTokenAddress = destinationTokenAddress?.toLowerCase();
     if (destinationTokensFiltered.find((t) => t.address === lowerCaseDestinationTokenAddress) === undefined) {
         destinationTokenAddress = defaultToAddress;
     }
-    return lowerCaseDestinationTokenAddress;
+    return isArcChain(toChainId ?? swapRoute?.toChainId)
+        ? destinationTokenAddress?.toLowerCase()
+        : lowerCaseDestinationTokenAddress;
+};
+const normalizeSwapParamsForSelection = ({ swapParams, tokens, chains, config, }) => {
+    const fromTokenAddress = getTokenAddressForSelection({
+        tokens,
+        config,
+        chainId: swapParams.fromChainId,
+        address: swapParams.fromTokenAddress,
+        direction: "from",
+    });
+    const fromToken = tokens.find((token) => token.chainId === swapParams.fromChainId &&
+        token.address.toLowerCase() === fromTokenAddress?.toLowerCase());
+    const toTokenAddress = getTokenAddressForSelection({
+        tokens: isArcChain(swapParams.toChainId)
+            ? filterTokensForDestination({
+                tokens,
+                selectedDestinationChain: chains.find((chain) => chain.chainId === swapParams.toChainId),
+                selectedSourceToken: fromToken,
+                removeSourceToken: true,
+            })
+            : tokens,
+        config,
+        chainId: swapParams.toChainId,
+        address: swapParams.toTokenAddress,
+        direction: "to",
+        excludeToken: {
+            chainId: swapParams.fromChainId,
+            address: fromTokenAddress,
+        },
+    });
+    return { ...swapParams, fromTokenAddress, toTokenAddress };
 };
 /**
  * When user changes something from the SwapView
@@ -23357,10 +23419,19 @@ const handleDestinationAddressOnSwapChange = ({ fromChainId, fromTokenAddress, t
  * If only destination token is changed but source is not, and they were the same, then source token updates to something else
  *
  */
-const getNewSwapParamsFromInput = ({ inputParams, initialSwapRoute, tokens, chains, config, queryClient, connectedSourceAddress, }) => {
-    const { fromChainId, fromTokenAddress, toChainId, toTokenAddress, destinationAddress, fallbackAddress, depositRefundAddress, } = inputParams;
+const getNewSwapParamsFromInput = ({ inputParams, initialSwapRoute: storedSwapRoute, tokens, chains, config, queryClient, connectedSourceAddress, }) => {
+    const initialSwapRoute = storedSwapRoute
+        ? {
+            ...storedSwapRoute,
+            fromTokenAddress: normalizeArcTokenAddress(storedSwapRoute.fromChainId, storedSwapRoute.fromTokenAddress),
+            toTokenAddress: normalizeArcTokenAddress(storedSwapRoute.toChainId, storedSwapRoute.toTokenAddress),
+        }
+        : undefined;
+    const { fromChainId, toChainId, destinationAddress, fallbackAddress, depositRefundAddress, } = inputParams;
     const srcChainId = fromChainId ?? initialSwapRoute?.fromChainId;
     const destinationChainId = toChainId ?? initialSwapRoute?.toChainId;
+    const fromTokenAddress = normalizeArcTokenAddress(srcChainId, inputParams.fromTokenAddress);
+    const toTokenAddress = normalizeArcTokenAddress(destinationChainId, inputParams.toTokenAddress);
     const defaultFromAddress = getInitialOrDefaultTokenAddressForChain({
         tokens,
         config,
@@ -23392,7 +23463,7 @@ const getNewSwapParamsFromInput = ({ inputParams, initialSwapRoute, tokens, chai
         toTokenAddress === initialSwapRoute?.fromTokenAddress;
     const sourceTokenAddress = sameNewDestAndInitialSource || onlySourceChainIdChanged
         ? defaultFromAddress
-        : fromTokenAddress ?? initialSwapRoute?.fromTokenAddress;
+        : (fromTokenAddress ?? initialSwapRoute?.fromTokenAddress);
     let destinationTokenAddress = undefined;
     if (!sameNewSourceAndInitialDest) {
         if (onlySourceChainIdChanged) {
@@ -23436,15 +23507,20 @@ const getNewSwapParamsFromInput = ({ inputParams, initialSwapRoute, tokens, chai
     const newDepositRefundAddress = sourceChainChanged
         ? undefined
         : depositRefundAddress || initialSwapRoute?.depositRefundAddress;
-    return {
-        fromChainId: srcChainId,
-        fromTokenAddress: sourceTokenAddress,
-        toChainId: destinationChainId,
-        toTokenAddress: destinationTokenAddress,
-        destinationAddress: newDestinationAddress,
-        fallbackAddress: newFallbackAddress,
-        depositRefundAddress: newDepositRefundAddress,
-    };
+    return normalizeSwapParamsForSelection({
+        swapParams: {
+            fromChainId: srcChainId,
+            fromTokenAddress: sourceTokenAddress,
+            toChainId: destinationChainId,
+            toTokenAddress: destinationTokenAddress,
+            destinationAddress: newDestinationAddress,
+            fallbackAddress: newFallbackAddress,
+            depositRefundAddress: newDepositRefundAddress,
+        },
+        tokens,
+        chains,
+        config,
+    });
 };
 /* Sorts tokens based on the following order:
  * 1. Native token on chain ID "1" (Ethereum) comes first.
@@ -23502,8 +23578,10 @@ const sortAllTokens = (tokenA, tokenB) => {
     return 0;
 };
 const findToken = (tokens, chainId, address) => tokens.find((t) => t.chainId === chainId && t.address === address);
-const findNativeToken = (tokens, chain) => tokens.find((t) => t.symbol.toUpperCase() === chain.nativeCurrency.symbol.toUpperCase() &&
-    t.chainId == chain.chainId);
+const findNativeToken = (tokens, chain) => tokens.find((t) => t.chainId === chain.chainId &&
+    (isArcChain(chain.chainId)
+        ? isArcNativeToken(t)
+        : t.symbol.toUpperCase() === chain.nativeCurrency.symbol.toUpperCase()));
 const normalizeIbcAddress = (address) => {
     if (!address.toLowerCase().startsWith("ibc/")) {
         return address;
@@ -23573,9 +23651,7 @@ function selectGroupDefaultInfo(tokens) {
 const groupTokensBySymbol = (tokens, chainType) => {
     const groups = {};
     // Filter tokens by chain type if specified
-    const filteredTokens = chainType
-        ? tokens.filter((token) => token.type === chainType)
-        : tokens;
+    const filteredTokens = deduplicateArcBalances(chainType ? tokens.filter((token) => token.type === chainType) : tokens);
     // First pass: group by coingeckoId or symbol
     filteredTokens.forEach((token) => {
         const groupKey = token.coingeckoId || token.symbol.split(".")[0];
@@ -23651,7 +23727,7 @@ const groupTokensBySymbol = (tokens, chainType) => {
  */
 const groupTokensByChainId = (tokens, chains) => {
     const groups = {};
-    tokens.forEach((token) => {
+    deduplicateArcBalances(tokens).forEach((token) => {
         const chainData = chains.find((chain) => chain.chainId === token.chainId);
         const groupKey = token.chainId;
         if (!groups[groupKey]) {
@@ -23699,6 +23775,8 @@ const filterViewableTokens = (tokens, config, direction) => {
         { chainId: CHAIN_IDS.DCHAIN, address: nativeEvmTokenAddress },
     ];
     return (tokens.filter((token) => {
+        if (isArcNativeToken(token))
+            return false;
         if (direction) {
             const parsedDirection = getParsedDirection(direction);
             const availableTokensForDirection = config.availableTokens?.[parsedDirection];
@@ -23714,7 +23792,7 @@ const filterViewableTokens = (tokens, config, direction) => {
 };
 const getSecretNetworkBalances = async (chainData, cosmosAddress, squidTokens, keplrTypeWallet) => {
     const squidSecretTokens = squidTokens.filter((t) => t.chainId === CHAIN_IDS.SECRET);
-    const { fetchAllSecretBalances } = await import('./secretService-cgr3P1zw.js');
+    const { fetchAllSecretBalances } = await import('./secretService-DkE9yz1o.js');
     return fetchAllSecretBalances(chainData, cosmosAddress, squidSecretTokens, keplrTypeWallet);
 };
 function getTokenAssetsKey(token) {
@@ -25295,8 +25373,7 @@ const searchTokens = (query, tokens, chains) => {
         .filter((chain) => chain.nativeCurrency.symbol.toLowerCase() === query.toLowerCase() ||
         chain.nativeCurrency.name.toLowerCase().includes(query.toLowerCase()) ||
         chain.networkName.toLowerCase().includes(query.toLowerCase()) ||
-        (chain.axelarChainName?.toLowerCase().includes(query.toLowerCase()) ??
-            false))
+        chain.axelarChainName.toLowerCase().includes(query.toLowerCase()))
         .map((chain) => tokens.find((token) => token.chainId === chain.chainId &&
         token.address.toLowerCase() === nativeEvmTokenAddress))
         .filter((token) => token !== undefined);
@@ -25709,7 +25786,7 @@ const useSquidTokens = (direction) => {
         config.availableChains,
         direction,
     ]);
-    const { evmTokens, cosmosTokens, solanaTokens, bitcoinTokens, suiTokens, xrplTokens, stellarTokens, cantonTokens, danalTokens, } = useMemo(() => {
+    const { evmTokens, cosmosTokens, solanaTokens, bitcoinTokens, suiTokens, xrplTokens, stellarTokens, cantonTokens, } = useMemo(() => {
         return tokens?.reduce((acc, token) => {
             switch (token.type) {
                 case ChainType.EVM:
@@ -25736,9 +25813,6 @@ const useSquidTokens = (direction) => {
                 case ChainType.CANTON:
                     acc.cantonTokens.push(token);
                     break;
-                case ChainType.DANAL:
-                    acc.danalTokens.push(token);
-                    break;
             }
             return acc;
         }, {
@@ -25750,7 +25824,6 @@ const useSquidTokens = (direction) => {
             xrplTokens: [],
             stellarTokens: [],
             cantonTokens: [],
-            danalTokens: [],
         });
     }, [tokens]);
     const findToken = useCallback((address, chainId) => {
@@ -25769,7 +25842,6 @@ const useSquidTokens = (direction) => {
         xrplTokens,
         stellarTokens,
         cantonTokens,
-        danalTokens,
     };
 };
 
@@ -26306,7 +26378,6 @@ const chainTypeToRefetchInterval = {
     [ChainType.XRPL]: 1_000,
     [ChainType.STELLAR]: 1_000,
     [ChainType.CANTON]: 1_000,
-    [ChainType.DANAL]: 1_000,
 };
 /**
  * Returns the status refetch interval of a Send transaction
@@ -26573,7 +26644,7 @@ const useSquidChains = (direction) => {
         const chain = findChain(chainId);
         return chain?.chainType;
     }, [findChain]);
-    const { evmChains, cosmosChains, suiChains, stellarChains, xrplChains, cantonChains, danalChains, } = useMemo(() => {
+    const { evmChains, cosmosChains, suiChains, stellarChains, xrplChains, cantonChains, } = useMemo(() => {
         return chains.reduce((acc, chain) => {
             switch (chain.chainType) {
                 case ChainType.EVM:
@@ -26594,9 +26665,6 @@ const useSquidChains = (direction) => {
                 case ChainType.CANTON:
                     acc.cantonChains.push(chain);
                     break;
-                case ChainType.DANAL:
-                    acc.danalChains.push(chain);
-                    break;
             }
             return acc;
         }, {
@@ -26606,7 +26674,6 @@ const useSquidChains = (direction) => {
             xrplChains: [],
             stellarChains: [],
             cantonChains: [],
-            danalChains: [],
         });
     }, [chains]);
     const { supportedSourceChains, supportedDestinationChains } = useMemo(() => {
@@ -26628,7 +26695,6 @@ const useSquidChains = (direction) => {
         xrplChains,
         stellarChains,
         cantonChains,
-        danalChains,
         getChainType,
         findChain,
     };
@@ -26942,7 +27008,343 @@ const useBitcoinContext = () => {
     return context;
 };
 
-const REQUEST_TIMEOUT_MS = 60_000;
+const vParty = (party) => ({ party });
+const vText = (text) => ({ text });
+const vNumeric = (numeric) => ({ numeric });
+const vContractId = (contractId) => ({
+    contractId,
+});
+const vList = (elements) => ({
+    list: { elements },
+});
+const vRecord = (fields) => ({
+    record: { fields: fields.map(([label, value]) => ({ label, value })) },
+});
+const vTextMap = (entries) => ({ textMap: { entries } });
+const vTimestamp = (isoString) => ({
+    timestamp: String(Math.floor(new Date(isoString).getTime() * 1000)),
+});
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeChoiceContextValue(value) {
+    if (typeof value === "string")
+        return value;
+    if (!isRecord(value) || typeof value.tag !== "string")
+        return null;
+    switch (value.tag) {
+        case "AV_Text":
+        case "AV_ContractId":
+            return typeof value.value === "string"
+                ? { tag: value.tag, value: value.value }
+                : null;
+        case "AV_Bool":
+            return typeof value.value === "boolean"
+                ? { tag: value.tag, value: value.value }
+                : null;
+        case "AV_List":
+            if (!Array.isArray(value.value))
+                return null;
+            return {
+                tag: value.tag,
+                value: value.value.flatMap((entry) => {
+                    const normalized = normalizeChoiceContextValue(entry);
+                    return normalized ? [normalized] : [];
+                }),
+            };
+        default: {
+            const inner = value.value;
+            if (typeof inner === "string" ||
+                typeof inner === "number" ||
+                typeof inner === "boolean" ||
+                inner === null) {
+                return { tag: value.tag, value: inner };
+            }
+            if (Array.isArray(inner)) {
+                return {
+                    tag: value.tag,
+                    value: inner.flatMap((entry) => {
+                        const normalized = normalizeChoiceContextValue(entry);
+                        return normalized ? [normalized] : [];
+                    }),
+                };
+            }
+            if (!isRecord(inner))
+                return null;
+            const normalizedObject = {};
+            for (const [key, entry] of Object.entries(inner)) {
+                if (typeof entry !== "string" &&
+                    typeof entry !== "number" &&
+                    typeof entry !== "boolean" &&
+                    entry !== null) {
+                    return null;
+                }
+                normalizedObject[key] = entry;
+            }
+            return { tag: value.tag, value: normalizedObject };
+        }
+    }
+}
+function stringifyChoiceContextValue(value) {
+    return typeof value === "string" ? value : String(value);
+}
+function choiceContextValueToAnyValue(value) {
+    if (typeof value === "string") {
+        return {
+            variant: { constructor: "AV_Text", value: vText(value) },
+        };
+    }
+    switch (value.tag) {
+        case "AV_ContractId":
+            if (typeof value.value !== "string") {
+                throw new TypeError("AV_ContractId values must be strings");
+            }
+            return {
+                variant: { constructor: value.tag, value: vContractId(value.value) },
+            };
+        case "AV_Bool":
+            if (typeof value.value !== "boolean") {
+                throw new TypeError("AV_Bool values must be booleans");
+            }
+            return {
+                variant: { constructor: value.tag, value: { bool: value.value } },
+            };
+        case "AV_List":
+            if (!Array.isArray(value.value)) {
+                throw new TypeError("AV_List values must be arrays");
+            }
+            return {
+                variant: {
+                    constructor: value.tag,
+                    value: vList(value.value.map(choiceContextValueToAnyValue)),
+                },
+            };
+        default:
+            return {
+                variant: {
+                    constructor: value.tag,
+                    value: vText(stringifyChoiceContextValue(value.value)),
+                },
+            };
+    }
+}
+
+/** Metadata key used by Splice token-standard transfers to carry our Squid orderhash memo. */
+const CANTON_MEMO_KEY = "splice.lfdecentralizedtrust.org/reason";
+/** Interface id for the transfer factory contract returned by the token registry. */
+const TRANSFER_FACTORY_INTERFACE_ID = "#splice-api-token-transfer-instruction-v1:Splice.Api.Token.TransferInstructionV1:TransferFactory";
+/** Choice exercised on the transfer factory to create the token-standard transfer. */
+const TRANSFER_FACTORY_CHOICE = "TransferFactory_Transfer";
+/** CIP-056 (non-Amulet) tokens expose a registrar parameterized by admin party. */
+const CIP056_REGISTRAR_BASE = "https://api.utilities.digitalasset.com/api/token-standard/v0/registrars";
+const TRANSFER_REQUESTED_AT_SKEW_MS = 60_000;
+const TRANSFER_EXECUTE_WINDOW_MS = 24 * 60 * 60 * 1000;
+function resolveCantonRegistryUrl(instrument) {
+    if (instrument.id === CANTON_AMULET_INSTRUMENT_ID) {
+        return CANTON_AMULET_REGISTRY_URL;
+    }
+    return `${CIP056_REGISTRAR_BASE}/${encodeURIComponent(instrument.admin)}`;
+}
+/**
+ * Build the plain JSON arguments expected by the registry transfer-factory
+ * endpoint before it adds choice context and disclosed contracts.
+ */
+function buildTransferChoiceArgs({ sender, receiver, amount, instrument, inputHoldingCids, memo, nowMs, }) {
+    return {
+        expectedAdmin: instrument.admin,
+        transfer: {
+            sender,
+            receiver,
+            amount,
+            instrumentId: { admin: instrument.admin, id: instrument.id },
+            requestedAt: new Date(nowMs - TRANSFER_REQUESTED_AT_SKEW_MS).toISOString(),
+            executeBefore: new Date(nowMs + TRANSFER_EXECUTE_WINDOW_MS).toISOString(),
+            inputHoldingCids,
+            meta: { values: { [CANTON_MEMO_KEY]: memo } },
+        },
+        extraArgs: { context: { values: {} }, meta: { values: {} } },
+    };
+}
+/**
+ * Canton's Holding contracts follow Bitcoin-style UTXOs model.
+ *
+ * Pick Holding contract ids covering `amount` for the instrument: prefer a
+ * single exact-amount holding, else accumulate largest-first.
+ */
+function selectInputHoldingCids(holdings, instrument, amount) {
+    const spendableHoldings = holdings.filter((h) => !h.locked &&
+        h.instrument.admin === instrument.admin &&
+        h.instrument.id === instrument.id);
+    const target = new BigNumber(amount);
+    const exact = spendableHoldings.find((h) => new BigNumber(h.amount).eq(target));
+    if (exact)
+        return [exact.contractId];
+    const sorted = [...spendableHoldings].sort((a, b) => new BigNumber(b.amount).comparedTo(new BigNumber(a.amount)));
+    const selected = [];
+    let sum = new BigNumber(0);
+    for (const holding of sorted) {
+        selected.push(holding.contractId);
+        sum = sum.plus(holding.amount);
+        if (sum.gte(target))
+            break;
+    }
+    if (sum.lt(target)) {
+        throw new Error("Insufficient Canton holdings to cover transfer amount");
+    }
+    return selected;
+}
+async function fetchInputHoldingCids(connector, party, instrument, amount) {
+    const ledgerEnd = await connector.ledgerApi({
+        requestMethod: "get",
+        resource: "/v2/state/ledger-end",
+    });
+    const activeContracts = await connector.ledgerApi({
+        requestMethod: "post",
+        resource: "/v2/state/active-contracts",
+        body: buildHoldingsAcsRequestBody(party, String(ledgerEnd.offset)),
+    });
+    return selectInputHoldingCids(parseCantonHoldings(activeContracts), instrument, amount);
+}
+/**
+ * Ask the token registry for the transfer factory contract and extra context
+ * required to exercise its transfer choice.
+ */
+async function fetchTransferFactory(registryUrl, choiceArgs) {
+    const response = await fetch(`${registryUrl}/registry/transfer-instruction/v1/transfer-factory`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+            choiceArguments: choiceArgs,
+            excludeDebugFields: true,
+        }),
+    });
+    if (!response.ok) {
+        throw new Error(`Canton transfer-factory request failed (${response.status})`);
+    }
+    return response.json();
+}
+/**
+ * Convert transfer choice args into strict Daml Value JSON for the wallet's
+ * prepareExecute ExerciseCommand.
+ */
+function buildPrepareChoiceArgument(choiceArgs) {
+    const contextValues = Object.entries(choiceArgs.extraArgs.context?.values ?? {})
+        .map(([key, value]) => {
+        const normalized = normalizeChoiceContextValue(value);
+        return normalized
+            ? { key, value: choiceContextValueToAnyValue(normalized) }
+            : undefined;
+    })
+        .filter((entry) => Boolean(entry));
+    return vRecord([
+        ["expectedAdmin", vParty(choiceArgs.expectedAdmin)],
+        [
+            "transfer",
+            vRecord([
+                ["sender", vParty(choiceArgs.transfer.sender)],
+                ["receiver", vParty(choiceArgs.transfer.receiver)],
+                ["amount", vNumeric(choiceArgs.transfer.amount)],
+                [
+                    "instrumentId",
+                    vRecord([
+                        ["admin", vParty(choiceArgs.transfer.instrumentId.admin)],
+                        ["id", vText(choiceArgs.transfer.instrumentId.id)],
+                    ]),
+                ],
+                ["requestedAt", vTimestamp(choiceArgs.transfer.requestedAt)],
+                ["executeBefore", vTimestamp(choiceArgs.transfer.executeBefore)],
+                [
+                    "inputHoldingCids",
+                    vList(choiceArgs.transfer.inputHoldingCids.map(vContractId)),
+                ],
+                [
+                    "meta",
+                    vRecord([
+                        [
+                            "values",
+                            vTextMap(Object.entries(choiceArgs.transfer.meta.values).map(([key, value]) => ({ key, value: vText(value) }))),
+                        ],
+                    ]),
+                ],
+            ]),
+        ],
+        [
+            "extraArgs",
+            vRecord([
+                ["context", vRecord([["values", vTextMap(contextValues)]])],
+                ["meta", vRecord([["values", vTextMap([])]])],
+            ]),
+        ],
+    ]);
+}
+/**
+ * Convert a registry disclosed contract into the wallet submission shape,
+ * dropping debug fields and entries without a usable createdEventBlob.
+ */
+function toDisclosedContract(raw) {
+    if (typeof raw.createdEventBlob !== "string")
+        return null;
+    return {
+        createdEventBlob: raw.createdEventBlob,
+        contractId: typeof raw.contractId === "string" ? raw.contractId : undefined,
+        synchronizerId: typeof raw.synchronizerId === "string" ? raw.synchronizerId : undefined,
+    };
+}
+/**
+ * Build a Splice token-standard transfer of `amount` of `token` from `sender`
+ * to `receiver`, carrying `memo`, ready to hand to a wallet's prepareExecute.
+ * Returns the full prepareExecute params (commandId + commands + actAs +
+ * disclosedContracts).
+ */
+async function buildCantonTransfer(connector, { sender, receiver, amount, token, memo, nowMs, }) {
+    if (!token.originalAddress) {
+        throw new Error("Canton token originalAddress is required");
+    }
+    const instrument = parseCantonInstrument(token.originalAddress);
+    if (!instrument) {
+        throw new Error(`Invalid Canton token address: ${token.originalAddress}`);
+    }
+    const registryUrl = resolveCantonRegistryUrl(instrument);
+    const inputHoldingCids = await fetchInputHoldingCids(connector, sender, instrument, amount);
+    const choiceArgs = buildTransferChoiceArgs({
+        sender,
+        receiver,
+        amount,
+        instrument,
+        inputHoldingCids,
+        memo,
+        nowMs,
+    });
+    const factory = await fetchTransferFactory(registryUrl, choiceArgs);
+    const choiceContextData = factory.choiceContext.choiceContextData;
+    if (!choiceContextData) {
+        throw new Error("Transfer factory choice context is missing");
+    }
+    choiceArgs.extraArgs.context = choiceContextData;
+    const disclosedContracts = (factory.choiceContext?.disclosedContracts ?? []).flatMap((raw) => {
+        const disclosedContract = toDisclosedContract(raw);
+        return disclosedContract ? [disclosedContract] : [];
+    });
+    // Command ID: client-supplied identifier used to deduplicate submissions
+    const commandId = getCantonCommandId(memo);
+    return {
+        commandId,
+        commands: [
+            {
+                ExerciseCommand: {
+                    templateId: TRANSFER_FACTORY_INTERFACE_ID,
+                    contractId: factory.factoryId,
+                    choice: TRANSFER_FACTORY_CHOICE,
+                    choiceArgument: buildPrepareChoiceArgument(choiceArgs),
+                },
+            },
+        ],
+        actAs: [sender],
+        disclosedContracts,
+    };
+}
+
+const REQUEST_TIMEOUT_MS$1 = 60_000;
 function pickAddress(accounts) {
     return (accounts.find((a) => a.primary) ?? accounts[0])?.partyId;
 }
@@ -26951,6 +27353,7 @@ function pickAddress(accounts) {
  * (bound to its announce `target`) and exposes the lifecycle methods.
  */
 class CantonBrowserConnector {
+    kind = "cip103";
     providerId;
     name;
     target;
@@ -26965,7 +27368,7 @@ class CantonBrowserConnector {
             client ??
                 createCantonClient(new WindowTransport(win, {
                     target: this.target,
-                    timeout: REQUEST_TIMEOUT_MS,
+                    timeout: REQUEST_TIMEOUT_MS$1,
                 }));
     }
     get accounts() {
@@ -27011,6 +27414,28 @@ class CantonBrowserConnector {
         this._accounts = await this.client.listAccounts();
         return this._accounts;
     }
+    async getBalances(partyId) {
+        const { offset } = await this.ledgerApi({
+            requestMethod: "get",
+            resource: "/v2/state/ledger-end",
+        });
+        const contracts = await this.ledgerApi({
+            requestMethod: "post",
+            resource: "/v2/state/active-contracts",
+            body: buildHoldingsAcsRequestBody(partyId, String(offset)),
+        });
+        return groupCantonHoldingBalances(contracts);
+    }
+    async transfer(params) {
+        const payload = await buildCantonTransfer(this, params);
+        const result = await this.prepareExecuteAndWait(payload);
+        const updateId = result.tx?.payload?.updateId ?? "";
+        return {
+            status: "completed",
+            commandId: getCantonCommandId(params.memo),
+            updateId,
+        };
+    }
     on(event, handler) {
         this.listeners[event].add(handler);
     }
@@ -27117,6 +27542,313 @@ function discoverInjectedCantonWallets(win) {
     });
 }
 
+class CantonConnectionCancelledError extends Error {
+    code = 4001;
+    constructor() {
+        super("Wallet connection cancelled");
+    }
+}
+
+const REQUEST_TIMEOUT_MS = 5 * 60_000;
+const OVERLAY_ID = "loop-sdk-connect-overlay";
+class LoopSubmissionUnknownError extends Error {
+    constructor(cause) {
+        super("Loop transfer outcome is unknown. Check Loop before trying again.", {
+            cause,
+        });
+    }
+}
+function parseLoopTransferUpdate(value, commandId) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const response = value;
+    if (response.command_id !== commandId)
+        return undefined;
+    if (response.status === "failed" || response.error) {
+        const error = response.error;
+        return {
+            status: "failed",
+            commandId,
+            message: typeof error?.error_message === "string"
+                ? error.error_message
+                : "Loop transaction failed",
+        };
+    }
+    if (typeof response.update_id === "string" && response.update_id) {
+        return { status: "completed", commandId, updateId: response.update_id };
+    }
+    return undefined;
+}
+class LoopCantonConnector {
+    loadSdk;
+    kind = "loop";
+    providerId = "canton-loop";
+    name = "Loop";
+    target = undefined;
+    module;
+    initialization;
+    provider;
+    pendingConnection;
+    connectionStart = Promise.resolve();
+    transfers = new Map();
+    listeners = { connect: new Set(), disconnect: new Set() };
+    constructor(loadSdk = () => import('@fivenorth/loop-sdk')) {
+        this.loadSdk = loadSdk;
+    }
+    get accounts() {
+        return this.provider
+            ? [{ partyId: this.provider.party_id, primary: true }]
+            : [];
+    }
+    get address() {
+        return this.provider?.party_id;
+    }
+    connect() {
+        return this.startConnection(true);
+    }
+    autoConnect() {
+        return this.startConnection(false);
+    }
+    cancelConnect() {
+        if (!this.pendingConnection)
+            return;
+        this.rejectConnection(new CantonConnectionCancelledError());
+        this.module?.loop.logout();
+    }
+    async disconnect() {
+        this.cancelConnect();
+        this.module?.loop.logout();
+        this.provider = undefined;
+        this.emit("disconnect");
+    }
+    async getAccounts() {
+        const provider = this.requireProvider();
+        try {
+            const account = await provider.getAccount();
+            if (account.party_id !== provider.party_id) {
+                await this.disconnect();
+                throw new Error("Loop account changed. Connect again.");
+            }
+            return this.accounts;
+        }
+        catch (error) {
+            if (this.module && error instanceof this.module.UnauthorizedError) {
+                await this.disconnect();
+            }
+            throw error;
+        }
+    }
+    async getBalances(partyId) {
+        const provider = this.requireProvider();
+        if (partyId !== provider.party_id) {
+            throw new Error("Loop balances require the connected account");
+        }
+        const holdings = await provider.getHolding();
+        return sumCantonHoldingBalances(holdings.map((holding) => {
+            const amount = new BigNumber(holding.total_unlocked_coin);
+            if (!amount.isFinite() || amount.isNegative()) {
+                throw new Error("Loop returned an invalid balance");
+            }
+            return {
+                instrument: holding.instrument_id,
+                amount: holding.total_unlocked_coin,
+            };
+        }));
+    }
+    transfer(params) {
+        const commandId = getCantonCommandId(params.memo);
+        const existing = this.transfers.get(commandId);
+        if (existing)
+            return existing;
+        const request = this.submitTransfer(params, commandId).catch((error) => {
+            if (!(error instanceof LoopSubmissionUnknownError))
+                this.transfers.delete(commandId);
+            throw error;
+        });
+        this.transfers.set(commandId, request);
+        return request;
+    }
+    on(event, handler) {
+        this.listeners[event].add(handler);
+    }
+    off(event, handler) {
+        this.listeners[event].delete(handler);
+    }
+    emit(event, ...args) {
+        this.listeners[event].forEach((handler) => handler(...args));
+    }
+    initialize() {
+        if (!this.initialization) {
+            this.initialization = this.loadSdk()
+                .then((module) => {
+                module.loop.init({
+                    appName: SQUID_METADATA.name,
+                    network: "mainnet",
+                    onAccept: (provider) => this.acceptConnection(provider),
+                    onReject: () => {
+                        this.rejectConnection(new CantonConnectionCancelledError());
+                        this.provider = undefined;
+                        this.emit("disconnect");
+                    },
+                });
+                this.module = module;
+            })
+                .catch((error) => {
+                this.initialization = undefined;
+                throw error;
+            });
+        }
+        return this.initialization;
+    }
+    startConnection(interactive) {
+        if (this.pendingConnection)
+            return this.pendingConnection.promise;
+        let resolve;
+        let reject;
+        const promise = new Promise((accept, decline) => {
+            resolve = accept;
+            reject = decline;
+        });
+        const timer = setTimeout(() => {
+            this.rejectConnection(new Error("Loop connection timed out"));
+            this.module?.loop.logout();
+        }, REQUEST_TIMEOUT_MS);
+        let observer;
+        const pending = {
+            promise,
+            resolve,
+            reject,
+            cleanup: () => {
+                clearTimeout(timer);
+                observer?.disconnect();
+            },
+        };
+        this.pendingConnection = pending;
+        this.connectionStart = this.connectionStart
+            .then(async () => {
+            await this.initialize();
+            if (this.pendingConnection !== pending)
+                return;
+            if (interactive && typeof MutationObserver !== "undefined") {
+                let sawOverlay = false;
+                observer = new MutationObserver(() => {
+                    const overlay = document.getElementById(OVERLAY_ID);
+                    if (overlay)
+                        sawOverlay = true;
+                    if (sawOverlay && !overlay && this.pendingConnection === pending) {
+                        this.cancelConnect();
+                    }
+                });
+                observer.observe(document.body, { childList: true });
+            }
+            const sdk = this.module.loop;
+            if (interactive)
+                await sdk.connect();
+            else
+                await sdk.autoConnect();
+            if (!interactive && this.pendingConnection === pending) {
+                this.rejectConnection(new Error("No saved Loop connection"));
+            }
+            else if (interactive &&
+                this.pendingConnection !== pending &&
+                !this.provider) {
+                sdk.logout();
+            }
+        })
+            .catch((error) => {
+            if (this.pendingConnection === pending)
+                this.rejectConnection(error);
+        });
+        return promise;
+    }
+    acceptConnection(provider) {
+        const pending = this.pendingConnection;
+        if (!pending)
+            return;
+        if (!provider.party_id) {
+            this.rejectConnection(new Error("Loop returned no account"));
+            return;
+        }
+        this.provider = provider;
+        this.pendingConnection = undefined;
+        pending.cleanup();
+        pending.resolve({ address: provider.party_id, accounts: this.accounts });
+        this.emit("connect", provider.party_id);
+    }
+    rejectConnection(error) {
+        const pending = this.pendingConnection;
+        if (!pending)
+            return;
+        this.pendingConnection = undefined;
+        pending.cleanup();
+        pending.reject(error);
+    }
+    requireProvider() {
+        if (!this.provider)
+            throw new Error("Loop wallet is not connected");
+        return this.provider;
+    }
+    async submitTransfer(params, commandId) {
+        const provider = this.requireProvider();
+        if (params.sender !== provider.party_id)
+            throw new Error("Loop account does not match the sender");
+        const instrument = params.token.originalAddress
+            ? parseCantonInstrument(params.token.originalAddress)
+            : null;
+        if (!instrument)
+            throw new Error("Canton token originalAddress is required");
+        if (!new BigNumber(params.amount).isFinite() ||
+            !new BigNumber(params.amount).isPositive()) {
+            throw new Error("Canton transfer amount must be positive");
+        }
+        const payload = await provider.connection.prepareTransfer(provider.getAuthToken(), {
+            recipient: params.receiver,
+            amount: params.amount,
+            instrument: {
+                instrument_admin: instrument.admin,
+                instrument_id: instrument.id,
+            },
+            memo: params.memo,
+            requested_at: new Date(params.nowMs - 60_000).toISOString(),
+            execute_before: new Date(params.nowMs + 24 * 60 * 60_000).toISOString(),
+        });
+        if (this.provider !== provider)
+            throw new Error("Loop account disconnected before submission");
+        let response;
+        let timer;
+        try {
+            const submission = { ...payload, commandId };
+            const submitted = provider.submitAndWaitForTransaction(submission, {
+                requestTimeout: REQUEST_TIMEOUT_MS,
+            });
+            response = await Promise.race([
+                submitted,
+                new Promise((_, reject) => {
+                    timer = setTimeout(() => reject(new Error("Loop submission timed out")), REQUEST_TIMEOUT_MS);
+                }),
+            ]);
+        }
+        catch (error) {
+            if (this.module && error instanceof this.module.RejectRequestError) {
+                throw Object.assign(new Error("Loop transaction rejected"), {
+                    code: 4001,
+                });
+            }
+            throw new LoopSubmissionUnknownError(error);
+        }
+        finally {
+            clearTimeout(timer);
+        }
+        const update = parseLoopTransferUpdate(response, commandId);
+        if (update?.status === "failed")
+            throw new Error(update.message);
+        if (!update)
+            throw new LoopSubmissionUnknownError();
+        return update;
+    }
+}
+const loopCantonConnector = new LoopCantonConnector();
+
 /**
  * Discovers Canton browser-extension wallets and maps each to a
  * {@link CantonWallet}: CIP-103 announce-protocol wallets (on mount and on
@@ -27163,7 +27895,19 @@ function useCantonWallets() {
             return;
         const announced = (await discoverCantonProviders()).map(toAnnouncedWallet);
         const injected = discoverInjectedCantonWallets().map(toInjectedWallet);
-        setWallets(mergeInjectedCantonWallets(announced, injected));
+        const loopWallet = {
+            ...formatCantonWallet({
+                connectorId: "canton-loop",
+                name: "Loop",
+                icon: "https://raw.githubusercontent.com/0xsquid/assets/main/images/master/wallets/canton-loop.svg",
+                connector: loopCantonConnector,
+            }),
+            links: { website: "https://cantonloop.com" },
+            isInstalled: () => false,
+            skipInstallCheck: true,
+            isMobile: true,
+        };
+        setWallets(mergeInjectedCantonWallets(announced, [...injected, loopWallet]));
     }, [toAnnouncedWallet, toInjectedWallet]);
     useEffect(() => {
         refresh();
@@ -27194,7 +27938,9 @@ function useCanton() {
             // Try to reconnect silently first (existing session, no popup)
             result = await wallet.connector.autoConnect();
         }
-        catch {
+        catch (error) {
+            if (error instanceof CantonConnectionCancelledError)
+                throw error;
             // Otherwise prompt the wallet to connect
             result = await wallet.connector.connect();
         }
@@ -27216,8 +27962,7 @@ function useCanton() {
             wallet: recentCantonWallet,
             address,
         });
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [wallets.map((w) => w.connectorId), recentCantonWalletId]);
+    }, [wallets, recentCantonWalletId, setConnectedWallet]);
     useEffect(() => {
         const wallet = connectedCantonWallet.wallet;
         if (!wallet) {
@@ -27474,7 +28219,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 import('./stellarService.client-B__dTUBZ.js');
+                const { formatStellarWallet } = await import('./stellarService.client-DtA9zkRt.js');
                 const modules = [...initializeAllModules(), new LedgerModule()];
                 const promises = modules.map(async (module) => {
                     const isAvailable = await module.isAvailable();
@@ -28053,6 +28798,11 @@ const useWallet = () => {
                 }
             }
             catch (error) {
+                const connecting = useWalletStore.getState().connectingWalletState;
+                if (connecting.wallet !== wallet ||
+                    connecting.status !== ConnectingWalletStatus.CONNECTING) {
+                    return false;
+                }
                 console.error("Failed to connect wallet", error);
                 walletConnectionError(wallet, error);
                 return false;
@@ -28284,8 +29034,6 @@ const useMultiChainWallet = (chain) => {
                         chainType: chain.chainType,
                     }),
                 };
-            case ChainType.DANAL:
-                return {};
         }
     }, [
         chain?.chainType,
@@ -28399,12 +29147,27 @@ const useMultiChainWallet = (chain) => {
 };
 
 const useSwap = () => {
-    const { initialAssets, defaultTokensPerChain, disabledChains, availableChains, } = useConfigStore((state) => state.config);
+    const { initialAssets, defaultTokensPerChain, disabledChains, availableChains, availableTokens, } = useConfigStore((state) => state.config);
     const fromPrice = useTransactionStore((state) => state.fromPrice);
-    const { swapRoute } = useSwapRoutePersistStore();
+    const { swapRoute: storedSwapRoute } = useSwapRoutePersistStore();
     const { tokens } = useSquidTokens();
     const queryClient = useQueryClient();
     const { chains, supportedDestinationChains, supportedSourceChains } = useSquidChains();
+    const swapRoute = useMemo(() => storedSwapRoute
+        ? normalizeSwapParamsForSelection({
+            swapParams: storedSwapRoute,
+            tokens,
+            chains,
+            config: { disabledChains, availableChains, availableTokens },
+        })
+        : undefined, [
+        storedSwapRoute,
+        tokens,
+        chains,
+        disabledChains,
+        availableChains,
+        availableTokens,
+    ]);
     const sourceChainId = useMemo(() => swapRoute?.fromChainId ??
         (initialAssets?.from
             ? resolveChainIdFromAsset(initialAssets.from, supportedSourceChains)
@@ -28415,13 +29178,23 @@ const useSwap = () => {
             : undefined), [swapRoute?.toChainId, supportedDestinationChains, initialAssets?.to]);
     const fromChain = useMemo(() => supportedSourceChains.find((c) => c.chainId === swapRoute?.fromChainId), [swapRoute?.fromChainId, supportedSourceChains]);
     const toChain = useMemo(() => supportedDestinationChains.find((c) => c.chainId === swapRoute?.toChainId), [swapRoute?.toChainId, supportedDestinationChains]);
-    const fromTokens = useMemo(() => getTokensForChain(tokens, sourceChainId), [tokens, sourceChainId]);
+    const fromTokens = useMemo(() => {
+        const chainTokens = getTokensForChain(tokens, sourceChainId);
+        return isArcChain(sourceChainId)
+            ? filterViewableTokens(chainTokens, { availableTokens }, "from")
+            : chainTokens;
+    }, [tokens, sourceChainId, availableTokens]);
     const fromToken = useMemo(() => fromTokens.find((t) => t.address.toLowerCase() === swapRoute?.fromTokenAddress?.toLowerCase()), [fromTokens, swapRoute?.fromTokenAddress]);
-    const toTokens = useMemo(() => filterTokensForDestination({
-        tokens: getTokensForChain(tokens, destChainId),
-        selectedDestinationChain: toChain,
-        selectedSourceToken: fromToken,
-    }), [destChainId, toChain, fromToken, tokens]);
+    const toTokens = useMemo(() => {
+        const destinationTokens = filterTokensForDestination({
+            tokens: getTokensForChain(tokens, destChainId),
+            selectedDestinationChain: toChain,
+            selectedSourceToken: fromToken,
+        });
+        return isArcChain(destChainId)
+            ? filterViewableTokens(destinationTokens, { availableTokens }, "to")
+            : destinationTokens;
+    }, [destChainId, toChain, fromToken, tokens, availableTokens]);
     const toToken = useMemo(() => toTokens.find((t) => t.address.toLowerCase() === swapRoute?.toTokenAddress?.toLowerCase()), [toTokens, swapRoute?.toTokenAddress]);
     const isSameChain = sourceChainId === destChainId;
     const tokenItems = useMemo(() => ({ from: fromTokens, to: toTokens }), [fromTokens, toTokens]);
@@ -28469,6 +29242,7 @@ const useSwap = () => {
                 defaultTokensPerChain,
                 disabledChains,
                 availableChains,
+                availableTokens,
             },
             queryClient,
             connectedSourceAddress: connectedSourceAddress.address,
@@ -28508,6 +29282,7 @@ const useSwap = () => {
         defaultTokensPerChain,
         disabledChains,
         availableChains,
+        availableTokens,
         initialAssets,
         queryClient,
         swapRoute,
@@ -28563,6 +29338,10 @@ const useSwap = () => {
                 },
                 direction: "to",
             });
+            if ([defaultFromChainId, defaultToChainId].some((chainId) => isArcChain(chainId) &&
+                !tokens.some((token) => token.chainId === chainId && !isArcNativeToken(token)))) {
+                return;
+            }
             const fromTokenAddress = getInitialOrDefaultTokenAddressForChain({
                 tokens,
                 config: {
@@ -28570,6 +29349,7 @@ const useSwap = () => {
                     defaultTokensPerChain,
                     disabledChains,
                     availableChains,
+                    availableTokens,
                 },
                 chainId: defaultFromChainId,
                 direction: "from",
@@ -28581,6 +29361,7 @@ const useSwap = () => {
                     defaultTokensPerChain,
                     disabledChains,
                     availableChains,
+                    availableTokens,
                 },
                 chainId: defaultToChainId,
                 direction: "to",
@@ -28605,6 +29386,7 @@ const useSwap = () => {
         initialAssets,
         disabledChains,
         availableChains,
+        availableTokens,
         defaultTokensPerChain,
         tokens,
     ]);
@@ -29124,8 +29906,6 @@ async function createClient(chain) {
             return new StellarRpcClient(chain.rpc);
         case ChainType.CANTON:
             return null;
-        case ChainType.DANAL:
-            return null;
     }
 }
 
@@ -30140,8 +30920,7 @@ const getAllStellarTokensBalance = async (userAddress, stellarTokens, stellarCha
 };
 /**
  * Canton balances are private: they can only be read with a wallet-authorized
- * `ledgerApi` session (the connected wallet supplies a JWT that can read as the
- * party). So balance is fetchable only when a Canton wallet is connected, and
+ * session. Balance is fetchable only when a Canton wallet is connected, and
  * only for that wallet's party — there's no address-only read.
  */
 const getCantonTokenBalance = async (userAddress, token, cantonConnector) => {
@@ -30150,30 +30929,14 @@ const getCantonTokenBalance = async (userAddress, token, cantonConnector) => {
     const instrument = parseCantonInstrument(token.originalAddress);
     if (!instrument)
         return "0";
-    const ledgerEnd = await cantonConnector.ledgerApi({ requestMethod: "get", resource: "/v2/state/ledger-end" });
-    const activeContracts = await cantonConnector.ledgerApi({
-        requestMethod: "post",
-        resource: "/v2/state/active-contracts",
-        body: buildHoldingsAcsRequestBody(userAddress, String(ledgerEnd.offset)),
-    });
-    const grouped = groupCantonHoldingBalances(activeContracts);
+    const grouped = await cantonConnector.getBalances(userAddress);
     return grouped[cantonInstrumentKey(instrument)] ?? "0";
 };
 /**
- * Fetch balances for all Canton tokens in one ACS query. Canton balances are
- * private, so this requires a connected wallet's authorized `ledgerApi`.
+ * Fetch balances for all Canton tokens through the connected wallet.
  */
 async function getAllCantonTokensBalance({ connector, partyId, tokens, }) {
-    const ledgerEnd = await connector.ledgerApi({
-        requestMethod: "get",
-        resource: "/v2/state/ledger-end",
-    });
-    const activeContracts = await connector.ledgerApi({
-        requestMethod: "post",
-        resource: "/v2/state/active-contracts",
-        body: buildHoldingsAcsRequestBody(partyId, String(ledgerEnd.offset)),
-    });
-    const grouped = groupCantonHoldingBalances(activeContracts);
+    const grouped = await connector.getBalances(partyId);
     return tokens.map((token) => {
         const instrument = token.originalAddress
             ? parseCantonInstrument(token.originalAddress)
@@ -30392,7 +31155,7 @@ const useCantonBalance = ({ chain, token, userAddress, enabled = true, refreshIn
 };
 
 function useNativeTokenForChain(chain) {
-    const { evmTokens, cosmosTokens, solanaTokens, bitcoinTokens, suiTokens, xrplTokens, stellarTokens, cantonTokens, danalTokens, } = useSquidTokens();
+    const { evmTokens, cosmosTokens, solanaTokens, bitcoinTokens, suiTokens, xrplTokens, stellarTokens, cantonTokens, } = useSquidTokens();
     const getTokensForChainType = () => {
         if (!chain?.chainType)
             return [];
@@ -30413,21 +31176,20 @@ function useNativeTokenForChain(chain) {
                 return stellarTokens;
             case ChainType.CANTON:
                 return cantonTokens;
-            case ChainType.DANAL:
-                return danalTokens;
         }
     };
+    const tokens = getTokensForChainType();
     const nativeTokenForChainType = useMemo(() => {
         if (!chain)
             return undefined;
-        return findNativeToken(getTokensForChainType(), chain);
-    }, [chain]);
+        return findNativeToken(tokens, chain);
+    }, [chain, tokens]);
     return { nativeToken: nativeTokenForChainType };
 }
 
 const useEvmNativeBalance = ({ address, chain, }) => {
     const { isChainTypeConnected } = useWallet();
-    const { data: nativeEvmBalance, isLoading } = useBalance({
+    const { data: nativeEvmBalance, isLoading, isError, } = useBalance({
         address: address,
         chainId: Number(chain?.chainId),
         query: {
@@ -30439,6 +31201,8 @@ const useEvmNativeBalance = ({ address, chain, }) => {
         },
     });
     const balance = useMemo(() => {
+        if (isArcChain(chain?.chainId) && isError)
+            return undefined;
         if (nativeEvmBalance?.decimals != null && nativeEvmBalance?.value != null) {
             if (chain?.chainId === CHAIN_IDS.HEDERA) {
                 return {
@@ -30452,7 +31216,12 @@ const useEvmNativeBalance = ({ address, chain, }) => {
             };
         }
         return;
-    }, [nativeEvmBalance?.decimals, nativeEvmBalance?.value, chain?.chainId]);
+    }, [
+        nativeEvmBalance?.decimals,
+        nativeEvmBalance?.value,
+        chain?.chainId,
+        isError,
+    ]);
     return {
         balance,
         isLoading,
@@ -30675,9 +31444,6 @@ const useNativeBalance = (chain) => {
             case ChainType.CANTON:
                 balance = nativeCantonBalance;
                 break;
-            case ChainType.DANAL:
-                balance = undefined;
-                break;
         }
         const balanceFormatted = !!balance
             ? formatBNToReadable(balance.value, balance.decimals)
@@ -30717,8 +31483,6 @@ const useNativeBalance = (chain) => {
                 return isStellarLoading;
             case ChainType.CANTON:
                 return isCantonLoading;
-            case ChainType.DANAL:
-                return false;
         }
     }, [
         chain?.chainType,
@@ -30944,7 +31708,7 @@ function hederaWalletConnect(parameters) {
                 const optionalChains = config.chains.map((x) => x.id);
                 if (!optionalChains.length)
                     return;
-                const { EthereumProvider } = await import('./index.es--AR2n7a0.js');
+                const { EthereumProvider } = await import('./index.es-BiK_wjSb.js');
                 const rawProvider = await EthereumProvider.init({
                     ...restParameters,
                     disableProviderPing: true,
@@ -31178,8 +31942,6 @@ const useSigner = ({ chain }) => {
                 return isStellarSignerReady;
             case ChainType.CANTON:
                 return isCantonSignerReady;
-            case ChainType.DANAL:
-                return false;
         }
     }, [
         chain?.chainType,
@@ -31632,12 +32394,8 @@ const useSendTransactionStore = create((set, get) => ({
 const useDepositAddressStore = create((set) => ({
     deposit: null,
     selectedPaymentMethod: "connectedWallet",
-    userDepositTxId: null,
     setDeposit: (data) => {
-        set({ deposit: data, userDepositTxId: null });
-    },
-    setUserDepositTxId: (txId) => {
-        set({ userDepositTxId: txId });
+        set({ deposit: data });
     },
     setPaymentMethod: (method) => {
         set({ selectedPaymentMethod: method });
@@ -31649,7 +32407,7 @@ function useDepositAddress(squidRoute) {
         selectedPaymentMethod: state.selectedPaymentMethod,
         depositAddress: state.deposit?.depositAddress,
     }));
-    const { setDeposit, setPaymentMethod, deposit, userDepositTxId, setUserDepositTxId, } = useDepositAddressStore();
+    const { setDeposit, setPaymentMethod, deposit } = useDepositAddressStore();
     const { squid } = useSquidStore();
     const { fromChain } = useSwap();
     const isAvailableAsPaymentMethod = useMemo(() => {
@@ -31659,13 +32417,11 @@ function useDepositAddress(squidRoute) {
             CHAIN_IDS.BITCOIN,
             CHAIN_IDS.SOLANA,
             CHAIN_IDS.CANTON,
-            CHAIN_IDS.DANAL_TESTNET,
         ];
         return chainsSupportingDepositAddress.includes(fromChain.chainId);
     }, [fromChain?.chainId]);
-    const routeProvidesDirectDepositAddress = (!!squidRoute?.transactionRequest &&
-        isDepositAddressDirectTransferRoute(squidRoute.transactionRequest)) ||
-        (!!squidRoute && isDanalDepositRoute(squidRoute));
+    const routeProvidesDirectDepositAddress = !!squidRoute?.transactionRequest &&
+        isDepositAddressDirectTransferRoute(squidRoute.transactionRequest);
     const swapWillGenerateDepositAddress = isChainflipDepositRoute(squidRoute) || routeProvidesDirectDepositAddress;
     const paymentMethod = isAvailableAsPaymentMethod
         ? selectedPaymentMethod
@@ -31691,19 +32447,6 @@ function useDepositAddress(squidRoute) {
             });
             return;
         }
-        else if (isDanalDepositRoute(route)) {
-            const transferBody = parseDanalTransferBody(route.transactionRequest.data);
-            if (!transferBody) {
-                throw new Error("Could not parse Danal transfer request body");
-            }
-            setDeposit({
-                amount: transferBody.amount,
-                depositAddress: route.transactionRequest.target,
-                statusTrackingId: transferBody.memo,
-                memo: transferBody.memo,
-            });
-            return;
-        }
         else if (isDepositAddressDirectTransferRoute(route.transactionRequest)) {
             // Canton case
             const orderHash = route.transactionRequest.data;
@@ -31726,8 +32469,6 @@ function useDepositAddress(squidRoute) {
         depositAddress,
         closeDepositChannel,
         depositData: deposit,
-        userDepositTxId,
-        setUserDepositTxId,
     };
 }
 
@@ -31755,7 +32496,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, danalTokens, } = useSquidTokens(direction);
+    const { evmTokens, cosmosTokens, solanaTokens, bitcoinTokens, suiTokens, xrplTokens, stellarTokens, cantonTokens, } = useSquidTokens(direction);
     const { keplrTypeWallet } = useCosmosContext();
     const cantonConnector = useWalletStore((store) => store.connectedWalletsByChainType[ChainType.CANTON]?.wallet?.connector);
     const placeholderData = useMemo(() => {
@@ -31768,7 +32509,6 @@ const useAllTokensWithBalanceForChainType = ({ chainType, address, direction, qu
             [ChainType.XRPL]: xrplTokens.map((t) => ({ ...t, balance: "0" })),
             [ChainType.STELLAR]: stellarTokens.map((t) => ({ ...t, balance: "0" })),
             [ChainType.CANTON]: cantonTokens.map((t) => ({ ...t, balance: "0" })),
-            [ChainType.DANAL]: danalTokens.map((t) => ({ ...t, balance: "0" })),
         };
         if (!chainType) {
             // Return all tokens with zero balance
@@ -31791,7 +32531,6 @@ const useAllTokensWithBalanceForChainType = ({ chainType, address, direction, qu
         xrplTokens,
         stellarTokens,
         cantonTokens,
-        danalTokens,
     ]);
     const isQueryEnabled = useMemo(() => {
         // Respect the queryOptions.enabled override if provided
@@ -31816,8 +32555,6 @@ const useAllTokensWithBalanceForChainType = ({ chainType, address, direction, qu
                 return stellarTokens.length > 0;
             case ChainType.CANTON:
                 return cantonTokens.length > 0;
-            case ChainType.DANAL:
-                return danalTokens.length > 0;
         }
     }, [
         chainType,
@@ -31831,7 +32568,6 @@ const useAllTokensWithBalanceForChainType = ({ chainType, address, direction, qu
         xrplTokens.length,
         stellarTokens.length,
         cantonTokens.length,
-        danalTokens.length,
     ]);
     const query = useQuery(keys().allTokensBalance(address, chainType, direction), async () => {
         // Return zero balances if no address
@@ -31956,12 +32692,6 @@ const useAllConnectedWalletBalances = ({ direction, queryOptions = {
         direction,
         queryOptions,
     });
-    const danalBalancesQuery = useAllTokensWithBalanceForChainType({
-        chainType: ChainType.DANAL,
-        address: connectedAddresses?.[ChainType.DANAL],
-        direction,
-        queryOptions,
-    });
     // Create a map of chain type to balance query results
     const balanceQueries = useMemo(() => ({
         [ChainType.EVM]: evmBalancesQuery,
@@ -31972,7 +32702,6 @@ const useAllConnectedWalletBalances = ({ direction, queryOptions = {
         [ChainType.XRPL]: xrplBalancesQuery,
         [ChainType.STELLAR]: stellarBalancesQuery,
         [ChainType.CANTON]: cantonBalancesQuery,
-        [ChainType.DANAL]: danalBalancesQuery,
     }), [
         evmBalancesQuery,
         cosmosBalancesQuery,
@@ -31982,7 +32711,6 @@ const useAllConnectedWalletBalances = ({ direction, queryOptions = {
         xrplBalancesQuery,
         stellarBalancesQuery,
         cantonBalancesQuery,
-        danalBalancesQuery,
     ]);
     // Combine all tokens from different chains
     const allTokens = useMemo(() => Object.values(balanceQueries).flatMap((query) => query.data?.tokens ?? []), [balanceQueries]);
@@ -32090,8 +32818,6 @@ const useMultiChainBalance = ({ chain, token, userAddress, enabled = true, }) =>
                 return stellarBalance;
             case ChainType.CANTON:
                 return cantonBalance;
-            case ChainType.DANAL:
-                return "0";
         }
     }, [
         chain?.chainType,
@@ -32297,6 +33023,27 @@ function useSourceChainGasToken({ fromChain, fromToken, }) {
                 normalizeFee: convertTempoFeeToStablecoinUnits,
             };
         }
+        if (isArcChain(fromChain.chainId)) {
+            const isUsdc = isArcUsdcToken(fromToken);
+            const isNative = isArcNativeToken(fromToken);
+            if (fromToken.chainId !== fromChain.chainId ||
+                nativeBalance.decimals !== 18 ||
+                (isUsdc && fromToken.decimals !== 6) ||
+                (isNative && fromToken.decimals !== 18)) {
+                return null;
+            }
+            return {
+                fromTokenPaysGasFees: isUsdc || isNative,
+                gasTokenBalanceWei: nativeBalance.value,
+                normalizeFee: (fee) => fee,
+                fromAmountToGasUnits: isUsdc
+                    ? (amount) => amount * 10n ** 12n
+                    : undefined,
+                gasUnitsToFromAmount: isUsdc
+                    ? (amount) => amount / 10n ** 12n
+                    : undefined,
+            };
+        }
         return {
             fromTokenPaysGasFees: fromToken.address.toLowerCase() ===
                 chainTypeToNativeTokenAddressMap[fromToken.type].toLowerCase(),
@@ -32304,10 +33051,10 @@ function useSourceChainGasToken({ fromChain, fromToken, }) {
             normalizeFee: (fee) => fee,
         };
     }, [
-        fromToken?.address,
-        fromToken?.type,
+        fromToken,
         fromChain?.chainId,
         nativeBalance?.value,
+        nativeBalance?.decimals,
         tempoFeeData,
     ]);
     /**
@@ -32322,9 +33069,20 @@ function useSourceChainGasToken({ fromChain, fromToken, }) {
             return evmTokens.find((t) => t.chainId === fromChain.chainId &&
                 t.address.toLowerCase() === tempoFeeData.gasTokenAddress.toLowerCase());
         }
+        if (isArcChain(fromChain.chainId)) {
+            return nativeToken?.decimals === 18
+                ? {
+                    ...nativeToken,
+                    symbol: fromChain.nativeCurrency.symbol,
+                    name: fromChain.nativeCurrency.name,
+                }
+                : undefined;
+        }
         return nativeToken;
     }, [
         fromChain?.chainId,
+        fromChain?.nativeCurrency.symbol,
+        fromChain?.nativeCurrency.name,
         fromToken?.address,
         nativeToken,
         tempoFeeData,
@@ -32483,22 +33241,57 @@ const calculateTotalNativeFees = ({ expressFeeCost, firstFeeCost, firstGasCost,
     (sameTokenBetweenFees
         ? BigInt(firstFeeCost?.amount ?? "0") + BigInt(firstGasCost?.amount ?? "0")
         : BigInt(firstGasCost?.amount ?? "0"));
+const addGasReserve = (fee) => (fee * 110n + 99n) / 100n;
+const calculateArcGasCosts = (gasCosts) => {
+    const sourceGasCosts = gasCosts.filter((cost) => isArcChain(cost.token.chainId));
+    if (sourceGasCosts.length === 0)
+        return undefined;
+    let total = 0n;
+    for (const { amount, token } of sourceGasCosts) {
+        const fee = BigInt(amount);
+        if (fee <= 0n)
+            return undefined;
+        if (isArcUsdcToken(token) && token.decimals === 6) {
+            total += fee * 10n ** 12n;
+        }
+        else if (isArcNativeToken(token) && token.decimals === 18) {
+            total += fee;
+        }
+        else {
+            return undefined;
+        }
+    }
+    return total;
+};
+const calculateTotalGasBalanceNeeded = ({ fromAmount, networkFeesWei, chainFeeParams, }) => {
+    if (!chainFeeParams || networkFeesWei == null)
+        return undefined;
+    if (!chainFeeParams.fromTokenPaysGasFees)
+        return networkFeesWei;
+    const amount = BigInt(fromAmount ?? "0");
+    const amountInGasUnits = chainFeeParams.fromAmountToGasUnits?.(amount) ?? amount;
+    return amountInGasUnits + networkFeesWei;
+};
 const checkIsGasBalanceEnough = ({ fromAmount, networkFeesWei, chainFeeParams, }) => {
     if (!chainFeeParams)
         return false;
-    if (chainFeeParams.fromTokenPaysGasFees) {
-        return (BigInt(fromAmount ?? "0") + networkFeesWei <=
-            chainFeeParams.gasTokenBalanceWei);
-    }
-    return networkFeesWei <= chainFeeParams.gasTokenBalanceWei;
+    const total = calculateTotalGasBalanceNeeded({
+        fromAmount,
+        networkFeesWei,
+        chainFeeParams,
+    });
+    return total != null && total <= chainFeeParams.gasTokenBalanceWei;
 };
 const calculateMinAmountValueWarnMsg = ({ networkFeesWei, chainFeeParams, fromTokenDecimals, }) => {
-    if (!chainFeeParams?.fromTokenPaysGasFees)
+    if (!chainFeeParams?.fromTokenPaysGasFees || networkFeesWei == null)
         return undefined;
     const minAmount = chainFeeParams.gasTokenBalanceWei - networkFeesWei;
     if (minAmount <= BigInt(0))
         return undefined;
-    return formatBNToReadable(minAmount, fromTokenDecimals);
+    const amountInTokenUnits = chainFeeParams.gasUnitsToFromAmount?.(minAmount) ?? minAmount;
+    if (amountInTokenUnits <= 0n)
+        return undefined;
+    return formatBNToReadable(amountInTokenUnits, fromTokenDecimals);
 };
 /**
  * Calculates the estimated duration of a route
@@ -32547,14 +33340,22 @@ const calculateEstimateResults = ({ squidRoute, tokens, fromChain, toChain, coll
     const expectedGasRefundCostUSD = convertTokenAmountToUSD(formatBNToReadable(expectedGasRefundCost, firstFeeCost?.token.decimals ?? 18), firstFeeCost?.token.usdPrice ?? "0");
     const sameTokenBetweenFees = firstFeeCost?.token.address === firstGasCost?.token.address &&
         firstFeeCost?.token.chainId === firstGasCost?.token.chainId;
-    const totalNativeFees = calculateTotalNativeFees({
-        expressFeeCost,
-        firstFeeCost,
-        firstGasCost,
-        sameTokenBetweenFees,
-    });
-    const totalFeesInNativeTokenPlusRatio = (totalNativeFees * BigInt(110)) / BigInt(100);
-    const networkFeesWei = chainFeeParams?.normalizeFee(totalFeesInNativeTokenPlusRatio) ?? BigInt(0);
+    const totalNativeFees = isArcChain(fromChain?.chainId)
+        ? calculateArcGasCosts(allGasCosts)
+        : calculateTotalNativeFees({
+            expressFeeCost,
+            firstFeeCost,
+            firstGasCost,
+            sameTokenBetweenFees,
+        });
+    const totalFeesInNativeTokenPlusRatio = totalNativeFees == null
+        ? undefined
+        : isArcChain(fromChain?.chainId)
+            ? addGasReserve(totalNativeFees)
+            : (totalNativeFees * BigInt(110)) / BigInt(100);
+    const networkFeesWei = totalFeesInNativeTokenPlusRatio == null
+        ? undefined
+        : chainFeeParams?.normalizeFee(totalFeesInNativeTokenPlusRatio);
     const isGasBalanceEnough = checkIsGasBalanceEnough({
         chainFeeParams,
         fromAmount,
@@ -32570,10 +33371,12 @@ const calculateEstimateResults = ({ squidRoute, tokens, fromChain, toChain, coll
         estimatedRouteDuration: squidRoute?.estimate?.estimatedRouteDuration,
         isSingleChainRoute,
     });
-    // gas fees + fromAmount (if fromToken is gas token)
-    const totalGasBalanceNeeded = networkFeesWei +
-        BigInt(chainFeeParams?.fromTokenPaysGasFees ? (fromAmount ?? 0) : 0);
-    const gasBalanceNeeded = gasToken
+    const totalGasBalanceNeeded = calculateTotalGasBalanceNeeded({
+        fromAmount,
+        networkFeesWei,
+        chainFeeParams,
+    });
+    const gasBalanceNeeded = gasToken && totalGasBalanceNeeded != null
         ? formatBNToReadable(totalGasBalanceNeeded, gasToken.decimals)
         : undefined;
     return {
@@ -32595,7 +33398,7 @@ const calculateEstimateResults = ({ squidRoute, tokens, fromChain, toChain, coll
         expectedGasRefundCostUSD,
         sameTokenBetweenFees,
         fromTokenPaysGasFees: chainFeeParams?.fromTokenPaysGasFees ?? false,
-        totalNativeFees,
+        totalNativeFees: totalNativeFees ?? 0n,
         isGasBalanceEnough,
         minAmountValueWarnMsg,
         estimatedRouteDuration,
@@ -32644,8 +33447,12 @@ function useSendTransactionGas({ chain, token, from, }) {
                 case ChainType.EVM: {
                     const client = await getClient(chain);
                     const feeData = await client.getFeeData();
-                    if (!feeData.maxFeePerGas)
+                    if (!feeData.maxFeePerGas) {
+                        if (isArcChain(chain.chainId)) {
+                            throw new Error("Gas price is unavailable");
+                        }
                         return BigInt(0);
+                    }
                     let maxFeePerGas = feeData.maxFeePerGas;
                     if (token.chainId === CHAIN_IDS.HEDERA) {
                         maxFeePerGas = scaleWeiToHbar(BigInt(feeData.maxFeePerGas));
@@ -32665,6 +33472,9 @@ function useSendTransactionGas({ chain, token, from, }) {
                             value: 1,
                             chainId: chain.chainId,
                         });
+                        if (isArcChain(chain.chainId) && gas <= 0n) {
+                            throw new Error("Gas estimate is unavailable");
+                        }
                         return gas * maxFeePerGas;
                     }
                     const erc20Interface = new Interface(erc20Abi);
@@ -32679,6 +33489,9 @@ function useSendTransactionGas({ chain, token, from, }) {
                         chainId: chain.chainId,
                     });
                     const feeWei = gas * maxFeePerGas;
+                    if (isArcChain(chain.chainId) && feeWei <= 0n) {
+                        throw new Error("Gas estimate is unavailable");
+                    }
                     // Tempo gas fees are denominated 18 units,
                     // this value needs to be scaled to 6 decimals
                     if (chain.chainId === CHAIN_IDS.TEMPO) {
@@ -32726,35 +33539,45 @@ function useSendTransactionGas({ chain, token, from, }) {
 }
 
 function useEstimateSendTransaction({ chain, token, amount, balance, from, }) {
-    const { data: estimatedGas = BigInt(0), isLoading } = useSendTransactionGas({
+    const { data, isLoading, isFetching, isError, refetch } = useSendTransactionGas({
         chain,
         token,
         from,
     });
+    const estimatedGas = isError || isFetching ? undefined : data;
+    const networkFeesWei = estimatedGas == null
+        ? undefined
+        : isArcChain(chain?.chainId)
+            ? addGasReserve(estimatedGas)
+            : estimatedGas;
     const { chainFeeParams, gasToken } = useSourceChainGasToken({
         fromChain: chain,
         fromToken: token,
     });
     const isGasBalanceEnough = useMemo(() => {
-        if (!amount || !token?.decimals)
+        if (!amount || token?.decimals == null || !gasToken)
             return false;
         return checkIsGasBalanceEnough({
             fromAmount: parseToBigInt(amount, token.decimals).toString(),
-            networkFeesWei: estimatedGas,
+            networkFeesWei,
             chainFeeParams,
         });
-    }, [amount, estimatedGas, token, chainFeeParams]);
+    }, [amount, networkFeesWei, token, chainFeeParams, gasToken]);
     const gasBalanceNeeded = useMemo(() => {
-        if (!amount || !token?.decimals || !gasToken?.decimals)
+        if (!amount || token?.decimals == null || gasToken?.decimals == null)
+            return undefined;
+        const totalGasBalanceNeeded = calculateTotalGasBalanceNeeded({
+            fromAmount: parseToBigInt(amount, token.decimals).toString(),
+            networkFeesWei,
+            chainFeeParams,
+        });
+        if (totalGasBalanceNeeded == null)
             return undefined;
-        // gas fees + fromAmount (if fromToken is gas token)
-        const totalGasBalanceNeeded = estimatedGas +
-            parseToBigInt(chainFeeParams?.fromTokenPaysGasFees ? (amount ?? "0") : "0", token.decimals);
         return formatBNToReadable(totalGasBalanceNeeded, gasToken.decimals);
     }, [
         amount,
-        chainFeeParams?.fromTokenPaysGasFees,
-        estimatedGas,
+        chainFeeParams,
+        networkFeesWei,
         gasToken?.decimals,
         token?.decimals,
     ]);
@@ -32765,20 +33588,22 @@ function useEstimateSendTransaction({ chain, token, amount, balance, from, }) {
             parseToBigInt(amount, token.decimals));
     }, [amount, balance, token?.decimals]);
     const minAmountValueWarnMsg = useMemo(() => {
-        if (!token?.address || !estimatedGas || !chainFeeParams)
+        if (!token?.address || !gasToken || !chainFeeParams)
             return undefined;
         return calculateMinAmountValueWarnMsg({
             chainFeeParams,
-            networkFeesWei: estimatedGas,
+            networkFeesWei,
             fromTokenDecimals: token.decimals,
         });
-    }, [estimatedGas, token, chainFeeParams]);
+    }, [networkFeesWei, token, chainFeeParams, gasToken]);
     return {
         estimatedGas,
         gasBalanceNeeded,
         isBalanceEnough,
         tokenPaysGasFees: chainFeeParams?.fromTokenPaysGasFees ?? false,
-        isLoading,
+        isLoading: isLoading || isFetching,
+        isError,
+        refetchGasEstimate: refetch,
         isGasBalanceEnough,
         minAmountValueWarnMsg,
     };
@@ -33201,9 +34026,8 @@ function useSendTransaction({ to, amount, token, chain, }) {
                         chain,
                     });
                     break;
-                case ChainType.CANTON:
-                case ChainType.DANAL: {
-                    throw new Error(`Send not implemented for chain type ${chain.chainType}`);
+                case ChainType.CANTON: {
+                    throw new Error("Not implemented");
                 }
             }
             return {
@@ -33409,8 +34233,7 @@ async function getSendTransactionStatus({ chain, txHash, }) {
                 chain,
             });
         case ChainType.CANTON:
-        case ChainType.DANAL:
-            throw new Error(`Send not implemented for chain type ${chain.chainType}`);
+            throw new Error("Not implemented");
     }
 }
 
@@ -33681,6 +34504,19 @@ const useApproval = ({ squidRoute, }) => {
     const { getChainType } = useSquidChains();
     const { switchChainAsync } = useSwitchChain();
     const { connectedAddress: { address: sourceUserAddress }, } = useMultiChainWallet(fromChain);
+    const arcNativeBalanceQuery = useBalance({
+        address: sourceUserAddress,
+        chainId: Number(fromChain?.chainId),
+        query: { enabled: false },
+    });
+    const arcTokenBalanceQuery = useReadContract({
+        address: fromToken?.address,
+        abi: erc20Abi,
+        functionName: "balanceOf",
+        args: [sourceUserAddress],
+        chainId: Number(fromChain?.chainId),
+        query: { enabled: false },
+    });
     const isSagaEvmSameChainSwap = isSameChain &&
         fromChain?.chainId.toString() === CHAIN_IDS.SAGA_EVM.toString();
     // Swaps on SagaEVM are regular EVM transactions, following the standard ERC20 approve/allowance mechanism.
@@ -33841,13 +34677,20 @@ const useApproval = ({ squidRoute, }) => {
             return false;
         }
     }, {
-        onSuccess: async () => {
+        onSuccess: async (approved) => {
+            if (approved && isArcChain(fromChain?.chainId)) {
+                await Promise.all([
+                    arcNativeBalanceQuery.refetch({ throwOnError: true }),
+                    arcTokenBalanceQuery.refetch({ throwOnError: true }),
+                ]);
+                queryClient.invalidateQueries(getPrefixKey(QueryKeys.AllTokensBalance));
+            }
             await allowanceQuery?.refetch();
             queryClient.invalidateQueries(getPrefixKey(QueryKeys.RouteApproved));
             // After an approval, we refetch the transaction query with all required parameters
             // This is to ensure we're using the latest expiry timestamp
             if (squidRoute) {
-                queryClient.refetchQueries({
+                await queryClient.refetchQueries({
                     queryKey: keys().transaction(squidRoute.params.fromChain, squidRoute.params.toChain, squidRoute.params.toToken, squidRoute.params.fromToken, fromPrice, squidRoute.params.slippage, squidRoute.params.fromAddress, squidRoute.params.bypassGuardrails, squidRoute.params.toAddress, squidRoute.params.fallbackAddresses?.[0]?.address, squidRoute.params.quoteOnly, getChainType(squidRoute.params.fromChain), squidRoute.params.preHook, squidRoute.params.postHook, 
                     // TODO: update types
                     squidRoute.params?.overrideGasRefundAddress),
@@ -37031,342 +37874,6 @@ coin.DecProto = {
 	
 } (tx));
 
-const vParty = (party) => ({ party });
-const vText = (text) => ({ text });
-const vNumeric = (numeric) => ({ numeric });
-const vContractId = (contractId) => ({
-    contractId,
-});
-const vList = (elements) => ({
-    list: { elements },
-});
-const vRecord = (fields) => ({
-    record: { fields: fields.map(([label, value]) => ({ label, value })) },
-});
-const vTextMap = (entries) => ({ textMap: { entries } });
-const vTimestamp = (isoString) => ({
-    timestamp: String(Math.floor(new Date(isoString).getTime() * 1000)),
-});
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function normalizeChoiceContextValue(value) {
-    if (typeof value === "string")
-        return value;
-    if (!isRecord(value) || typeof value.tag !== "string")
-        return null;
-    switch (value.tag) {
-        case "AV_Text":
-        case "AV_ContractId":
-            return typeof value.value === "string"
-                ? { tag: value.tag, value: value.value }
-                : null;
-        case "AV_Bool":
-            return typeof value.value === "boolean"
-                ? { tag: value.tag, value: value.value }
-                : null;
-        case "AV_List":
-            if (!Array.isArray(value.value))
-                return null;
-            return {
-                tag: value.tag,
-                value: value.value.flatMap((entry) => {
-                    const normalized = normalizeChoiceContextValue(entry);
-                    return normalized ? [normalized] : [];
-                }),
-            };
-        default: {
-            const inner = value.value;
-            if (typeof inner === "string" ||
-                typeof inner === "number" ||
-                typeof inner === "boolean" ||
-                inner === null) {
-                return { tag: value.tag, value: inner };
-            }
-            if (Array.isArray(inner)) {
-                return {
-                    tag: value.tag,
-                    value: inner.flatMap((entry) => {
-                        const normalized = normalizeChoiceContextValue(entry);
-                        return normalized ? [normalized] : [];
-                    }),
-                };
-            }
-            if (!isRecord(inner))
-                return null;
-            const normalizedObject = {};
-            for (const [key, entry] of Object.entries(inner)) {
-                if (typeof entry !== "string" &&
-                    typeof entry !== "number" &&
-                    typeof entry !== "boolean" &&
-                    entry !== null) {
-                    return null;
-                }
-                normalizedObject[key] = entry;
-            }
-            return { tag: value.tag, value: normalizedObject };
-        }
-    }
-}
-function stringifyChoiceContextValue(value) {
-    return typeof value === "string" ? value : String(value);
-}
-function choiceContextValueToAnyValue(value) {
-    if (typeof value === "string") {
-        return {
-            variant: { constructor: "AV_Text", value: vText(value) },
-        };
-    }
-    switch (value.tag) {
-        case "AV_ContractId":
-            if (typeof value.value !== "string") {
-                throw new TypeError("AV_ContractId values must be strings");
-            }
-            return {
-                variant: { constructor: value.tag, value: vContractId(value.value) },
-            };
-        case "AV_Bool":
-            if (typeof value.value !== "boolean") {
-                throw new TypeError("AV_Bool values must be booleans");
-            }
-            return {
-                variant: { constructor: value.tag, value: { bool: value.value } },
-            };
-        case "AV_List":
-            if (!Array.isArray(value.value)) {
-                throw new TypeError("AV_List values must be arrays");
-            }
-            return {
-                variant: {
-                    constructor: value.tag,
-                    value: vList(value.value.map(choiceContextValueToAnyValue)),
-                },
-            };
-        default:
-            return {
-                variant: {
-                    constructor: value.tag,
-                    value: vText(stringifyChoiceContextValue(value.value)),
-                },
-            };
-    }
-}
-
-/** Metadata key used by Splice token-standard transfers to carry our Squid orderhash memo. */
-const CANTON_MEMO_KEY = "splice.lfdecentralizedtrust.org/reason";
-/** Interface id for the transfer factory contract returned by the token registry. */
-const TRANSFER_FACTORY_INTERFACE_ID = "#splice-api-token-transfer-instruction-v1:Splice.Api.Token.TransferInstructionV1:TransferFactory";
-/** Choice exercised on the transfer factory to create the token-standard transfer. */
-const TRANSFER_FACTORY_CHOICE = "TransferFactory_Transfer";
-/** CIP-056 (non-Amulet) tokens expose a registrar parameterized by admin party. */
-const CIP056_REGISTRAR_BASE = "https://api.utilities.digitalasset.com/api/token-standard/v0/registrars";
-const TRANSFER_REQUESTED_AT_SKEW_MS = 60_000;
-const TRANSFER_EXECUTE_WINDOW_MS = 24 * 60 * 60 * 1000;
-function resolveCantonRegistryUrl(instrument) {
-    if (instrument.id === CANTON_AMULET_INSTRUMENT_ID) {
-        return CANTON_AMULET_REGISTRY_URL;
-    }
-    return `${CIP056_REGISTRAR_BASE}/${encodeURIComponent(instrument.admin)}`;
-}
-/**
- * Build the plain JSON arguments expected by the registry transfer-factory
- * endpoint before it adds choice context and disclosed contracts.
- */
-function buildTransferChoiceArgs({ sender, receiver, amount, instrument, inputHoldingCids, memo, nowMs, }) {
-    return {
-        expectedAdmin: instrument.admin,
-        transfer: {
-            sender,
-            receiver,
-            amount,
-            instrumentId: { admin: instrument.admin, id: instrument.id },
-            requestedAt: new Date(nowMs - TRANSFER_REQUESTED_AT_SKEW_MS).toISOString(),
-            executeBefore: new Date(nowMs + TRANSFER_EXECUTE_WINDOW_MS).toISOString(),
-            inputHoldingCids,
-            meta: { values: { [CANTON_MEMO_KEY]: memo } },
-        },
-        extraArgs: { context: { values: {} }, meta: { values: {} } },
-    };
-}
-/**
- * Canton's Holding contracts follow Bitcoin-style UTXOs model.
- *
- * Pick Holding contract ids covering `amount` for the instrument: prefer a
- * single exact-amount holding, else accumulate largest-first.
- */
-function selectInputHoldingCids(holdings, instrument, amount) {
-    const spendableHoldings = holdings.filter((h) => !h.locked &&
-        h.instrument.admin === instrument.admin &&
-        h.instrument.id === instrument.id);
-    const target = new BigNumber(amount);
-    const exact = spendableHoldings.find((h) => new BigNumber(h.amount).eq(target));
-    if (exact)
-        return [exact.contractId];
-    const sorted = [...spendableHoldings].sort((a, b) => new BigNumber(b.amount).comparedTo(new BigNumber(a.amount)));
-    const selected = [];
-    let sum = new BigNumber(0);
-    for (const holding of sorted) {
-        selected.push(holding.contractId);
-        sum = sum.plus(holding.amount);
-        if (sum.gte(target))
-            break;
-    }
-    if (sum.lt(target)) {
-        throw new Error("Insufficient Canton holdings to cover transfer amount");
-    }
-    return selected;
-}
-async function fetchInputHoldingCids(connector, party, instrument, amount) {
-    const ledgerEnd = await connector.ledgerApi({
-        requestMethod: "get",
-        resource: "/v2/state/ledger-end",
-    });
-    const activeContracts = await connector.ledgerApi({
-        requestMethod: "post",
-        resource: "/v2/state/active-contracts",
-        body: buildHoldingsAcsRequestBody(party, String(ledgerEnd.offset)),
-    });
-    return selectInputHoldingCids(parseCantonHoldings(activeContracts), instrument, amount);
-}
-/**
- * Ask the token registry for the transfer factory contract and extra context
- * required to exercise its transfer choice.
- */
-async function fetchTransferFactory(registryUrl, choiceArgs) {
-    const response = await fetch(`${registryUrl}/registry/transfer-instruction/v1/transfer-factory`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-            choiceArguments: choiceArgs,
-            excludeDebugFields: true,
-        }),
-    });
-    if (!response.ok) {
-        throw new Error(`Canton transfer-factory request failed (${response.status})`);
-    }
-    return response.json();
-}
-/**
- * Convert transfer choice args into strict Daml Value JSON for the wallet's
- * prepareExecute ExerciseCommand.
- */
-function buildPrepareChoiceArgument(choiceArgs) {
-    const contextValues = Object.entries(choiceArgs.extraArgs.context?.values ?? {})
-        .map(([key, value]) => {
-        const normalized = normalizeChoiceContextValue(value);
-        return normalized
-            ? { key, value: choiceContextValueToAnyValue(normalized) }
-            : undefined;
-    })
-        .filter((entry) => Boolean(entry));
-    return vRecord([
-        ["expectedAdmin", vParty(choiceArgs.expectedAdmin)],
-        [
-            "transfer",
-            vRecord([
-                ["sender", vParty(choiceArgs.transfer.sender)],
-                ["receiver", vParty(choiceArgs.transfer.receiver)],
-                ["amount", vNumeric(choiceArgs.transfer.amount)],
-                [
-                    "instrumentId",
-                    vRecord([
-                        ["admin", vParty(choiceArgs.transfer.instrumentId.admin)],
-                        ["id", vText(choiceArgs.transfer.instrumentId.id)],
-                    ]),
-                ],
-                ["requestedAt", vTimestamp(choiceArgs.transfer.requestedAt)],
-                ["executeBefore", vTimestamp(choiceArgs.transfer.executeBefore)],
-                [
-                    "inputHoldingCids",
-                    vList(choiceArgs.transfer.inputHoldingCids.map(vContractId)),
-                ],
-                [
-                    "meta",
-                    vRecord([
-                        [
-                            "values",
-                            vTextMap(Object.entries(choiceArgs.transfer.meta.values).map(([key, value]) => ({ key, value: vText(value) }))),
-                        ],
-                    ]),
-                ],
-            ]),
-        ],
-        [
-            "extraArgs",
-            vRecord([
-                ["context", vRecord([["values", vTextMap(contextValues)]])],
-                ["meta", vRecord([["values", vTextMap([])]])],
-            ]),
-        ],
-    ]);
-}
-/**
- * Convert a registry disclosed contract into the wallet submission shape,
- * dropping debug fields and entries without a usable createdEventBlob.
- */
-function toDisclosedContract(raw) {
-    if (typeof raw.createdEventBlob !== "string")
-        return null;
-    return {
-        createdEventBlob: raw.createdEventBlob,
-        contractId: typeof raw.contractId === "string" ? raw.contractId : undefined,
-        synchronizerId: typeof raw.synchronizerId === "string" ? raw.synchronizerId : undefined,
-    };
-}
-/**
- * Build a Splice token-standard transfer of `amount` of `token` from `sender`
- * to `receiver`, carrying `memo`, ready to hand to a wallet's prepareExecute.
- * Returns the full prepareExecute params (commandId + commands + actAs +
- * disclosedContracts).
- */
-async function buildCantonTransfer(connector, { sender, receiver, amount, token, memo, nowMs, }) {
-    if (!token.originalAddress) {
-        throw new Error("Canton token originalAddress is required");
-    }
-    const instrument = parseCantonInstrument(token.originalAddress);
-    if (!instrument) {
-        throw new Error(`Invalid Canton token address: ${token.originalAddress}`);
-    }
-    const registryUrl = resolveCantonRegistryUrl(instrument);
-    const inputHoldingCids = await fetchInputHoldingCids(connector, sender, instrument, amount);
-    const choiceArgs = buildTransferChoiceArgs({
-        sender,
-        receiver,
-        amount,
-        instrument,
-        inputHoldingCids,
-        memo,
-        nowMs,
-    });
-    const factory = await fetchTransferFactory(registryUrl, choiceArgs);
-    const choiceContextData = factory.choiceContext.choiceContextData;
-    if (!choiceContextData) {
-        throw new Error("Transfer factory choice context is missing");
-    }
-    choiceArgs.extraArgs.context = choiceContextData;
-    const disclosedContracts = (factory.choiceContext?.disclosedContracts ?? []).flatMap((raw) => {
-        const disclosedContract = toDisclosedContract(raw);
-        return disclosedContract ? [disclosedContract] : [];
-    });
-    // Command ID: client-supplied identifier used to deduplicate submissions
-    const commandId = `canton-${memo}`;
-    return {
-        commandId,
-        commands: [
-            {
-                ExerciseCommand: {
-                    templateId: TRANSFER_FACTORY_INTERFACE_ID,
-                    contractId: factory.factoryId,
-                    choice: TRANSFER_FACTORY_CHOICE,
-                    choiceArgument: buildPrepareChoiceArgument(choiceArgs),
-                },
-            },
-        ],
-        actAs: [sender],
-        disclosedContracts,
-    };
-}
-
 const useExecuteTransaction = (squidRoute) => {
     const { fromChain, toChain, fromToken, toToken, isSameChain } = useSwap();
     // A route completes on source tx only if it's same-chain AND
@@ -37981,7 +38488,7 @@ const useExecuteTransaction = (squidRoute) => {
         }
         const amount = formatBNToReadable(fromAmount, token.decimals);
         dispatchSignatureRequestEvent(route);
-        const transferParams = await buildCantonTransfer(cantonSigner, {
+        const result = await cantonSigner.transfer({
             sender: sourceUserAddress,
             receiver,
             amount,
@@ -37989,15 +38496,14 @@ const useExecuteTransaction = (squidRoute) => {
             memo: orderHash,
             nowMs: Date.now(),
         });
-        const result = await cantonSigner.prepareExecuteAndWait(transferParams);
-        const txHash = result.tx?.payload?.updateId ?? "";
+        const txHash = result.updateId;
         if (txHash) {
             resetQueriesAfterTxSigned();
         }
         WidgetEvents.getInstance().dispatchSwapExecuteCall(route, txHash);
         const txParams = setTransactionState({
             route,
-            txHash: txHash,
+            txHash,
             userAddress: sourceUserAddress,
             status: TransactionStatus.INITIAL_LOADING,
             sourceStatus: TransactionStatus.ONGOING,
@@ -38280,7 +38786,7 @@ refetchIntervalInBackground = false, refetchInterval = 30000, quoteOnly = true,
     //
     // If deposit address is not selected, we use the connected address as the source address instead
     const sourceUserAddress = isDepositAddressActive
-        ? depositRefundAddress ?? sourceConnectedAddress
+        ? (depositRefundAddress ?? sourceConnectedAddress)
         : sourceConnectedAddress;
     const squidRouteQueryKeys = 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), [
         fromChain?.chainId,
@@ -38572,6 +39078,10 @@ const useAutoConnect = () => {
     const { chains } = useSquidChains();
     const { isInitialized } = useConfigStore();
     const hasAttemptedReconnect = useRef(false);
+    const hasAttemptedCantonReconnect = useRef(false);
+    const { autoConnectCanton, wallets: cantonWallets } = useCantonContext();
+    const recentCantonWalletId = useWalletStore((state) => state.recentConnectorIds[ChainType.CANTON]);
+    const hasRecentCantonWallet = cantonWallets.some((wallet) => wallet.connectorId === recentCantonWalletId);
     const { autoConnectEvm } = useEvmContext();
     const { autoConnectSolana } = useSolanaContext();
     const { autoConnectSui } = useSuiContext();
@@ -38639,6 +39149,15 @@ const useAutoConnect = () => {
     useEffect(() => {
         autoConnect();
     }, [autoConnect]);
+    useEffect(() => {
+        if (!isInitialized ||
+            chains.length === 0 ||
+            !hasRecentCantonWallet ||
+            hasAttemptedCantonReconnect.current)
+            return;
+        hasAttemptedCantonReconnect.current = true;
+        autoConnectCanton().catch(() => undefined);
+    }, [autoConnectCanton, hasRecentCantonWallet, isInitialized, chains.length]);
     return { autoConnect };
 };
 
@@ -38947,5 +39466,5 @@ const SquidProvider = ({ children, config, placeholder, }) => {
                                         React.createElement(CosmosProvider, null, children))))))))))) : (placeholder);
 };
 
-export { useWalletStore as $, AxelarStatusResponseType as A, useHederaAccountActivation as B, CHAIN_IDS as C, DEFAULT_LOCALE as D, useHederaTokenAssociations as E, useKeyboardNavigation as F, useSquidQueryClient as G, HistoryTxType as H, useSquid as I, useStellarAccountActivation as J, useStellarTrustLine as K, useAddressBookStore as L, useAssetsColorsStore as M, Nr as N, useFavoriteTokensStore as O, useHistoryStore as P, QueryKeys as Q, useSendTransactionStore as R, SquidStatusErrorType as S, TransactionErrorType as T, useConfigStore as U, useSquidStore as V, Wo as W, XamanXrplNetwork as X, useSwapRoutePersistStore as Y, useTransactionStore as Z, ConnectingWalletStatus as _, WindowWalletFlag as a, useAvailableQuotes as a$, useDepositAddress as a0, useSwap as a1, buildUrlSearchParamsFromSwapEvent as a2, parseInitialAssetsFromUrl as a3, useUrlSwapParams as a4, useAllConnectedWalletBalances as a5, useAllTokensWithBalanceForChainType as a6, useCosmosBalance as a7, useEvmBalance as a8, useMultiChainBalance as a9, useRouteWarnings as aA, useSendTransactionStatus as aB, useSwapTransactionStatus as aC, useAvatar as aD, useHistory as aE, useDebouncedValue as aF, useAddToken as aG, useAutoConnect as aH, useEnsDataForAddress as aI, useEnsSearch as aJ, useGnosisContext as aK, useIsSameAddressAndGnosisContext as aL, useIntegratorContext as aM, useMultiChainWallet as aN, useSigner as aO, useWallet as aP, useWallets as aQ, useXrplTrustLine as aR, TX_STATUS_CONSTANTS as aS, FINAL_TRANSACTION_STATUSES as aT, useGetFiatQuote as aU, useGetOnRampConfig as aV, useExecuteFiatQuote as aW, useFiatOnRampTxStatus as aX, useFiatTransactions as aY, useCurrencyDetails as aZ, useCountryDetails as a_, useMultipleTokenPrices as aa, useBitcoinNativeBalance as ab, useCosmosNativeBalance as ac, useEvmNativeBalance as ad, useNativeBalance as ae, useSolanaNativeBalance as af, useStellarNativeBalance as ag, useSuiNativeBalance as ah, useXrplNativeBalance as ai, useNativeTokenForChain as aj, useSingleTokenPrice as ak, useSourceChainGasToken as al, useSquidTokens as am, useHistoricalData as an, useTokensData as ao, useEstimateSendTransaction as ap, useSendTransaction as aq, useSendTransactionGas as ar, useAllTransactionsStatus as as, useApproval as at, useDepositTransactionStatus as au, useEstimate as av, useEstimatePriceImpact as aw, useExecuteTransaction as ax, useGetRoute as ay, useGetRouteWrapper as az, DEFAULT_ROUTE_REFETCH_INTERVAL as b, createQuoteRequestParamsHash as b$, useRecommendedQuote as b0, useGetOnrampPaymentTypes as b1, useSuggestedFiatAmounts as b2, SquidProvider as b3, EnsService as b4, getXummClient as b5, isXamanXAppContext as b6, getQueryHeaders as b7, getStatusCode as b8, is404Error as b9, randomIntFromInterval as bA, getTokensForChain as bB, getFirstAvailableChainId as bC, fetchHighestBalanceToken as bD, getInitialOrDefaultTokenAddressForChain as bE, getInitialTokenAddressForChain as bF, filterTokensForDestination as bG, getInitialChainIdFromConfig as bH, getCosmosKey as bI, getKeysSettled as bJ, getAllKeysForSupportedCosmosChains as bK, isCosmosAddressValid as bL, getCosmosSigningClient as bM, getCosmosChainInfosObject as bN, connectCosmosWallet as bO, isFallbackAddressNeeded as bP, suggestChainOrThrow as bQ, isDanalAddressValid as bR, isDanalTxHashValid as bS, parseDanalTransferBody as bT, normalizeError as bU, transactionErrorCode as bV, isUserRejectionError as bW, getTransactionError as bX, handleTransactionErrorEvents as bY, isSwapRouteError as bZ, isStatusError as b_, assetsBaseUrl as ba, shareSubgraphId as bb, sortTokensBySharedSubgraphIds as bc, getSupportedChainIdsForDirection as bd, filterChains as be, filterTokens as bf, getTokenImage as bg, getNewSwapParamsFromInput as bh, sortAllTokens as bi, findToken as bj, findNativeToken as bk, normalizeIbcAddress as bl, groupTokensBySymbol as bm, groupTokensByChainId as bn, filterViewableTokens as bo, getSecretNetworkBalances as bp, getTokenAssetsKey as bq, fetchAssetsColors as br, isSupportedChainType as bs, initializeSquidData as bt, isEmptyObject as bu, normalizeTokenSymbol as bv, areTokenSymbolsCompatible as bw, isEvmosChain as bx, resolveChainIdFromAsset as by, getConfigWithDefaults as bz, chainTypeToNativeTokenAddressMap as c, getHalfSuccessState as c$, WidgetEvents as c0, EvmNetworkNotSupportedErrorCode as c1, addEthereumChain as c2, parseEvmAddress as c3, formatEvmWallet as c4, filterWagmiConnector as c5, waitForReceiptWithRetry as c6, getUserCountry as c7, getCountryData as c8, getCurrencyData as c9, stellarAddressToScVal as cA, getStellarTrustLineAsset as cB, isStellarToken as cC, isStellarIssuedToken as cD, getStellarHorizonApiUrl as cE, isValidIssuedAsset as cF, isValidHorizonAsset as cG, formatTransactionHistoryDate as cH, getAxelarExplorerTxUrl as cI, getSourceExplorerTxUrl as cJ, getMainExplorerUrl as cK, formatDistance as cL, formatSeconds as cM, formatSwapTxStatusResponseForStorage as cN, simplifyRouteAction as cO, fetchSwapTransactionStatus as cP, compareTransactionIds as cQ, isCoralBridgeAction as cR, isActionCompletedOnSourceTx as cS, sleep as cT, isChainflipDepositRoute as cU, isChainflipBridgeTransaction as cV, isOnChainTxData as cW, isDepositAddressDirectTransferRoute as cX, isDanalDepositRoute as cY, getHistoryTransactionId as cZ, getStepStatuses as c_, adaptiveRound as ca, getSuggestedAmountsForCurrency as cb, HederaExtensionHelper as cc, convertHederaAccountIdToEvmAddress as cd, convertEvmAddressToHederaAccountId as ce, scaleHbarToWei as cf, scaleWeiToHbar as cg, parseToBigInt as ch, roundNumericValue as ci, formatUnitsRounded as cj, formatTokenAmount as ck, formatUsdAmount as cl, trimExtraDecimals as cm, getNumericValue as cn, cleanAmount as co, convertTokenAmountToUSD as cp, convertUSDToTokenAmount as cq, calculateTotal24hChange as cr, getRouteExpiry as cs, searchTokens as ct, filterSolanaWallets as cu, isSolanaAddressValid as cv, executeSolanaSwap as cw, executeSolanaTransfer as cx, isStellarAddressValid as cy, getStellarNetwork as cz, definedInWindow as d, getStepsInfos as d0, getSwapTxStatusRefetchInterval as d1, getSendTxStatusRefetchInterval as d2, chainflipMultihopBridgeType as d3, getBridgeType as d4, getTransactionStatus as d5, getTransactionEndStatus as d6, isHistoryTransactionPending as d7, isHistoryTransactionFailed as d8, isHistoryTransactionWarning as d9, parseXrplTokenAddress as dA, isHistoryTransactionEnded as da, formatHash as db, isWalletAddressValid as dc, redirectToExtensionsStore as dd, populateWallets as de, buildFallbackWallets as df, getDefaultChain as dg, sortWallets as dh, areSameAddress as di, sortAddressBook as dj, calculateTotalUsdBalanceUSD as dk, addTokenToWallet as dl, isEvmChainNotSupportedError as dm, getWalletSupportedChainTypes as dn, getConnectorForChainType as dp, walletSupportsChainType as dq, connectWallet as dr, cancelConnectWallet as ds, isProblematicConnector as dt, mergeWallets as du, isXionSmartContractAddress as dv, isXrplAddressValid as dw, buildXrplTrustSetTx as dx, getXrplNetwork as dy, parseXrplPaymentTx as dz, er as e, formatBNToReadable as f, chainTypeToZeroAddressMap as g, destinationAddressResetValue as h, fallbackAddressResetValue as i, nativeCantonTokenAddress as j, nativeCosmosTokenAddress as k, nativeEvmTokenAddress as l, nativeSolanaTokenAddress as m, nativeBitcoinTokenAddress as n, nativeStellarTokenAddress as o, nativeSuiTokenAddress as p, nativeXrplTokenAddress as q, CosmosProvider as r, SendTransactionStatus as s, TransactionStatus as t, useCosmosContext as u, useTrackSearchEmpty as v, walletIconBaseUrl as w, useSquidChains as x, useClient as y, useCosmosForChain as z };
-//# sourceMappingURL=index-ByakOYXP.js.map
+export { useWalletStore as $, AxelarStatusResponseType as A, useHederaAccountActivation as B, CHAIN_IDS as C, DEFAULT_LOCALE as D, useHederaTokenAssociations as E, useKeyboardNavigation as F, useSquidQueryClient as G, HistoryTxType as H, useSquid as I, useStellarAccountActivation as J, useStellarTrustLine as K, useAddressBookStore as L, useAssetsColorsStore as M, Nr as N, useFavoriteTokensStore as O, useHistoryStore as P, QueryKeys as Q, useSendTransactionStore as R, SquidStatusErrorType as S, TransactionErrorType as T, useConfigStore as U, useSquidStore as V, Wo as W, XamanXrplNetwork as X, useSwapRoutePersistStore as Y, useTransactionStore as Z, ConnectingWalletStatus as _, WindowWalletFlag as a, useAvailableQuotes as a$, useDepositAddress as a0, useSwap as a1, buildUrlSearchParamsFromSwapEvent as a2, parseInitialAssetsFromUrl as a3, useUrlSwapParams as a4, useAllConnectedWalletBalances as a5, useAllTokensWithBalanceForChainType as a6, useCosmosBalance as a7, useEvmBalance as a8, useMultiChainBalance as a9, useRouteWarnings as aA, useSendTransactionStatus as aB, useSwapTransactionStatus as aC, useAvatar as aD, useHistory as aE, useDebouncedValue as aF, useAddToken as aG, useAutoConnect as aH, useEnsDataForAddress as aI, useEnsSearch as aJ, useGnosisContext as aK, useIsSameAddressAndGnosisContext as aL, useIntegratorContext as aM, useMultiChainWallet as aN, useSigner as aO, useWallet as aP, useWallets as aQ, useXrplTrustLine as aR, TX_STATUS_CONSTANTS as aS, FINAL_TRANSACTION_STATUSES as aT, useGetFiatQuote as aU, useGetOnRampConfig as aV, useExecuteFiatQuote as aW, useFiatOnRampTxStatus as aX, useFiatTransactions as aY, useCurrencyDetails as aZ, useCountryDetails as a_, useMultipleTokenPrices as aa, useBitcoinNativeBalance as ab, useCosmosNativeBalance as ac, useEvmNativeBalance as ad, useNativeBalance as ae, useSolanaNativeBalance as af, useStellarNativeBalance as ag, useSuiNativeBalance as ah, useXrplNativeBalance as ai, useNativeTokenForChain as aj, useSingleTokenPrice as ak, useSourceChainGasToken as al, useSquidTokens as am, useHistoricalData as an, useTokensData as ao, useEstimateSendTransaction as ap, useSendTransaction as aq, useSendTransactionGas as ar, useAllTransactionsStatus as as, useApproval as at, useDepositTransactionStatus as au, useEstimate as av, useEstimatePriceImpact as aw, useExecuteTransaction as ax, useGetRoute as ay, useGetRouteWrapper as az, DEFAULT_ROUTE_REFETCH_INTERVAL as b, WidgetEvents as b$, useRecommendedQuote as b0, useGetOnrampPaymentTypes as b1, useSuggestedFiatAmounts as b2, SquidProvider as b3, EnsService as b4, getXummClient as b5, isXamanXAppContext as b6, getQueryHeaders as b7, getStatusCode as b8, is404Error as b9, getConfigWithDefaults as bA, randomIntFromInterval as bB, getTokensForChain as bC, getFirstAvailableChainId as bD, fetchHighestBalanceToken as bE, getTokenAddressForSelection as bF, getInitialOrDefaultTokenAddressForChain as bG, getInitialTokenAddressForChain as bH, filterTokensForDestination as bI, getInitialChainIdFromConfig as bJ, getCosmosKey as bK, getKeysSettled as bL, getAllKeysForSupportedCosmosChains as bM, isCosmosAddressValid as bN, getCosmosSigningClient as bO, getCosmosChainInfosObject as bP, connectCosmosWallet as bQ, isFallbackAddressNeeded as bR, suggestChainOrThrow as bS, normalizeError as bT, transactionErrorCode as bU, isUserRejectionError as bV, getTransactionError as bW, handleTransactionErrorEvents as bX, isSwapRouteError as bY, isStatusError as bZ, createQuoteRequestParamsHash as b_, assetsBaseUrl as ba, shareSubgraphId as bb, sortTokensBySharedSubgraphIds as bc, getSupportedChainIdsForDirection as bd, filterChains as be, filterTokens as bf, getTokenImage as bg, normalizeSwapParamsForSelection as bh, getNewSwapParamsFromInput as bi, sortAllTokens as bj, findToken as bk, findNativeToken as bl, normalizeIbcAddress as bm, groupTokensBySymbol as bn, groupTokensByChainId as bo, filterViewableTokens as bp, getSecretNetworkBalances as bq, getTokenAssetsKey as br, fetchAssetsColors as bs, isSupportedChainType as bt, initializeSquidData as bu, isEmptyObject as bv, normalizeTokenSymbol as bw, areTokenSymbolsCompatible as bx, isEvmosChain as by, resolveChainIdFromAsset as bz, chainTypeToNativeTokenAddressMap as c, getSwapTxStatusRefetchInterval as c$, EvmNetworkNotSupportedErrorCode as c0, addEthereumChain as c1, parseEvmAddress as c2, formatEvmWallet as c3, filterWagmiConnector as c4, waitForReceiptWithRetry as c5, getUserCountry as c6, getCountryData as c7, getCurrencyData as c8, adaptiveRound as c9, getStellarTrustLineAsset as cA, isStellarToken as cB, isStellarIssuedToken as cC, getStellarHorizonApiUrl as cD, isValidIssuedAsset as cE, isValidHorizonAsset as cF, formatTransactionHistoryDate as cG, getAxelarExplorerTxUrl as cH, getSourceExplorerTxUrl as cI, getMainExplorerUrl as cJ, formatDistance as cK, formatSeconds as cL, formatSwapTxStatusResponseForStorage as cM, simplifyRouteAction as cN, fetchSwapTransactionStatus as cO, compareTransactionIds as cP, isCoralBridgeAction as cQ, isActionCompletedOnSourceTx as cR, sleep as cS, isChainflipDepositRoute as cT, isChainflipBridgeTransaction as cU, isOnChainTxData as cV, isDepositAddressDirectTransferRoute as cW, getHistoryTransactionId as cX, getStepStatuses as cY, getHalfSuccessState as cZ, getStepsInfos as c_, getSuggestedAmountsForCurrency as ca, HederaExtensionHelper as cb, convertHederaAccountIdToEvmAddress as cc, convertEvmAddressToHederaAccountId as cd, scaleHbarToWei as ce, scaleWeiToHbar as cf, parseToBigInt as cg, roundNumericValue as ch, formatUnitsRounded as ci, formatTokenAmount as cj, formatUsdAmount as ck, trimExtraDecimals as cl, getNumericValue as cm, cleanAmount as cn, convertTokenAmountToUSD as co, convertUSDToTokenAmount as cp, calculateTotal24hChange as cq, getRouteExpiry as cr, searchTokens as cs, filterSolanaWallets as ct, isSolanaAddressValid as cu, executeSolanaSwap as cv, executeSolanaTransfer as cw, isStellarAddressValid as cx, getStellarNetwork as cy, stellarAddressToScVal as cz, definedInWindow as d, getSendTxStatusRefetchInterval as d0, chainflipMultihopBridgeType as d1, getBridgeType as d2, getTransactionStatus as d3, getTransactionEndStatus as d4, isHistoryTransactionPending as d5, isHistoryTransactionFailed as d6, isHistoryTransactionWarning as d7, isHistoryTransactionEnded as d8, formatHash as d9, isWalletAddressValid as da, redirectToExtensionsStore as db, populateWallets as dc, buildFallbackWallets as dd, getDefaultChain as de, sortWallets as df, areSameAddress as dg, sortAddressBook as dh, calculateTotalUsdBalanceUSD as di, addTokenToWallet as dj, isEvmChainNotSupportedError as dk, getWalletSupportedChainTypes as dl, getConnectorForChainType as dm, walletSupportsChainType as dn, connectWallet as dp, cancelConnectWallet as dq, isProblematicConnector as dr, mergeWallets as ds, isXionSmartContractAddress as dt, isXrplAddressValid as du, buildXrplTrustSetTx as dv, getXrplNetwork as dw, parseXrplPaymentTx as dx, parseXrplTokenAddress as dy, er as e, formatBNToReadable as f, chainTypeToZeroAddressMap as g, destinationAddressResetValue as h, fallbackAddressResetValue as i, nativeCantonTokenAddress as j, nativeCosmosTokenAddress as k, nativeEvmTokenAddress as l, nativeSolanaTokenAddress as m, nativeBitcoinTokenAddress as n, nativeStellarTokenAddress as o, nativeSuiTokenAddress as p, nativeXrplTokenAddress as q, CosmosProvider as r, SendTransactionStatus as s, TransactionStatus as t, useCosmosContext as u, useTrackSearchEmpty as v, walletIconBaseUrl as w, useSquidChains as x, useClient as y, useCosmosForChain as z };
+//# sourceMappingURL=index-CLzjMzS_.js.map