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

package/dist/{index-nTqoaD0B.js → index-BBJD55XX.js}

@@ -80,7 +80,6 @@ const suiZeroAddress = "0x0000000000000000000000000000000000000000";
 const xrplZeroAddress = "rrrrrrrrrrrrrrrrrrrrrhoLvTp";
 const stellarZeroAddress = "GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWHF";
 const cantonZeroAddress = "none::12200000000000000000000000000000000000000000000000000000000000000000";
-const danalZeroAddress = "PCI00000000000000000000000000000000000000000000000000";
 const chainTypeToZeroAddressMap = {
     [squidTypes.ChainType.EVM]: viem.zeroAddress,
     [squidTypes.ChainType.COSMOS]: cosmosZeroAddress,
@@ -90,7 +89,6 @@ const chainTypeToZeroAddressMap = {
     [squidTypes.ChainType.XRPL]: xrplZeroAddress,
     [squidTypes.ChainType.STELLAR]: stellarZeroAddress,
     [squidTypes.ChainType.CANTON]: cantonZeroAddress,
-    [squidTypes.ChainType.DANAL]: danalZeroAddress,
 };
 const nativeEvmTokenAddress = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
 const nativeCosmosTokenAddress = "uosmo";
@@ -100,7 +98,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";
@@ -156,6 +153,7 @@ const CHAIN_IDS = {
     MANTRA: "5888",
     CITREA: "4114",
     TEMPO: "4217",
+    ARC: "5042",
     // others
     BITCOIN: "bitcoin",
     SOLANA: "solana-mainnet-beta",
@@ -166,7 +164,6 @@ const CHAIN_IDS = {
     STELLAR: "stellar-mainnet",
     STELLAR_TESTNET: "stellar-testnet",
     CANTON: "canton",
-    DANAL_TESTNET: "danal-testnet",
 };
 const chainTypeToDefaultChainIdMap = {
     [squidTypes.ChainType.EVM]: CHAIN_IDS.ETHEREUM,
@@ -177,7 +174,6 @@ const chainTypeToDefaultChainIdMap = {
     [squidTypes.ChainType.XRPL]: CHAIN_IDS.XRPL,
     [squidTypes.ChainType.STELLAR]: CHAIN_IDS.STELLAR,
     [squidTypes.ChainType.CANTON]: CHAIN_IDS.CANTON,
-    [squidTypes.ChainType.DANAL]: CHAIN_IDS.DANAL_TESTNET,
 };
 const chainTypeToNativeTokenAddressMap = {
     [squidTypes.ChainType.EVM]: nativeEvmTokenAddress,
@@ -188,7 +184,6 @@ const chainTypeToNativeTokenAddressMap = {
     [squidTypes.ChainType.XRPL]: nativeXrplTokenAddress,
     [squidTypes.ChainType.STELLAR]: nativeStellarTokenAddress,
     [squidTypes.ChainType.CANTON]: nativeCantonTokenAddress,
-    [squidTypes.ChainType.DANAL]: nativeDanalTokenAddress,
 };
 const defaultConfigValues = {
     integratorId: INTEGRATOR_ID,
@@ -20970,6 +20965,27 @@ const isBitcoinAddressValid = (address) => {
     }
 };
 
+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.
@@ -21120,51 +21136,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 = {
@@ -21503,15 +21484,6 @@ function isOnChainTxData(squidData) {
 function isDepositAddressDirectTransferRoute(squidData) {
     return squidData.type === squidTypes.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 === squidTypes.SquidDataType.DepositAddressWithMemo);
-}
 function getHistoryTransactionId(tx) {
     switch (tx.txType) {
         case exports.HistoryTxType.SWAP:
@@ -22036,11 +22008,6 @@ const chainTypeToTrimLength = {
         start: 3,
         end: 3,
     },
-    // PCI0180...E77E
-    [squidTypes.ChainType.DANAL]: {
-        start: 7,
-        end: 4,
-    },
 };
 const truncateWithEllipsis = (value, startLength, endLength) => value.length <= startLength + endLength
     ? value
@@ -22089,8 +22056,6 @@ const isWalletAddressValid = (chainData, address) => {
             return isStellarAddressValid(address);
         case squidTypes.ChainType.CANTON:
             return isCantonAddressValid(address);
-        case squidTypes.ChainType.DANAL:
-            return isDanalAddressValid(address);
     }
 };
 const redirectToExtensionsStore = (wallet) => {
@@ -22254,7 +22219,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;
@@ -22375,8 +22340,6 @@ const connectByChainType = async (chainType, wallet, defaultChain, params) => {
                     connector,
                 },
             });
-        case squidTypes.ChainType.DANAL:
-            return null;
     }
 };
 const getChainTypesToConnect = (selectedChainTypes, defaultChain, supportedChains) => {
@@ -22501,6 +22464,8 @@ const cancelConnectWallet = (wallet) => {
         return;
     }
     switch (wallet.type) {
+        case squidTypes.ChainType.CANTON:
+            return wallet.connector.cancelConnect?.();
         case squidTypes.ChainType.XRPL:
             return wallet.connector.cancelConnect?.();
         default:
@@ -23066,22 +23031,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, squidTypes.ChainType.EVM, direction))
+            : undefined;
         // get cached balance from key
-        const cache = queryCache?.find(keys().allTokensBalance(fetchCachedBalance?.address, !isNaN(Number(chainId)) ? squidTypes.ChainType.EVM : squidTypes.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)) ? squidTypes.ChainType.EVM : squidTypes.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);
                 }
             }
         }
@@ -23092,6 +23071,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
@@ -23109,6 +23103,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 &&
@@ -23152,6 +23165,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;
@@ -23361,12 +23391,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
@@ -23378,10 +23440,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,
@@ -23413,7 +23484,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) {
@@ -23457,15 +23528,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.
@@ -23523,8 +23599,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;
@@ -23594,9 +23672,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];
@@ -23672,7 +23748,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]) {
@@ -23720,6 +23796,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];
@@ -23735,7 +23813,7 @@ const filterViewableTokens = (tokens, config, direction) => {
 };
 const getSecretNetworkBalances = async (chainData, cosmosAddress, squidTokens, keplrTypeWallet) => {
     const squidSecretTokens = squidTokens.filter((t) => t.chainId === CHAIN_IDS.SECRET);
-    const { fetchAllSecretBalances } = await Promise.resolve().then(function () { return require('./secretService-29Ak2qp5.js'); });
+    const { fetchAllSecretBalances } = await Promise.resolve().then(function () { return require('./secretService-BZ06HTOJ.js'); });
     return fetchAllSecretBalances(chainData, cosmosAddress, squidSecretTokens, keplrTypeWallet);
 };
 function getTokenAssetsKey(token) {
@@ -25316,8 +25394,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);
@@ -25730,7 +25807,7 @@ const useSquidTokens = (direction) => {
         config.availableChains,
         direction,
     ]);
-    const { evmTokens, cosmosTokens, solanaTokens, bitcoinTokens, suiTokens, xrplTokens, stellarTokens, cantonTokens, danalTokens, } = React.useMemo(() => {
+    const { evmTokens, cosmosTokens, solanaTokens, bitcoinTokens, suiTokens, xrplTokens, stellarTokens, cantonTokens, } = React.useMemo(() => {
         return tokens?.reduce((acc, token) => {
             switch (token.type) {
                 case squidTypes.ChainType.EVM:
@@ -25757,9 +25834,6 @@ const useSquidTokens = (direction) => {
                 case squidTypes.ChainType.CANTON:
                     acc.cantonTokens.push(token);
                     break;
-                case squidTypes.ChainType.DANAL:
-                    acc.danalTokens.push(token);
-                    break;
             }
             return acc;
         }, {
@@ -25771,7 +25845,6 @@ const useSquidTokens = (direction) => {
             xrplTokens: [],
             stellarTokens: [],
             cantonTokens: [],
-            danalTokens: [],
         });
     }, [tokens]);
     const findToken = React.useCallback((address, chainId) => {
@@ -25790,7 +25863,6 @@ const useSquidTokens = (direction) => {
         xrplTokens,
         stellarTokens,
         cantonTokens,
-        danalTokens,
     };
 };
 
@@ -26327,7 +26399,6 @@ const chainTypeToRefetchInterval = {
     [squidTypes.ChainType.XRPL]: 1_000,
     [squidTypes.ChainType.STELLAR]: 1_000,
     [squidTypes.ChainType.CANTON]: 1_000,
-    [squidTypes.ChainType.DANAL]: 1_000,
 };
 /**
  * Returns the status refetch interval of a Send transaction
@@ -26594,7 +26665,7 @@ const useSquidChains = (direction) => {
         const chain = findChain(chainId);
         return chain?.chainType;
     }, [findChain]);
-    const { evmChains, cosmosChains, suiChains, stellarChains, xrplChains, cantonChains, danalChains, } = React.useMemo(() => {
+    const { evmChains, cosmosChains, suiChains, stellarChains, xrplChains, cantonChains, } = React.useMemo(() => {
         return chains.reduce((acc, chain) => {
             switch (chain.chainType) {
                 case squidTypes.ChainType.EVM:
@@ -26615,9 +26686,6 @@ const useSquidChains = (direction) => {
                 case squidTypes.ChainType.CANTON:
                     acc.cantonChains.push(chain);
                     break;
-                case squidTypes.ChainType.DANAL:
-                    acc.danalChains.push(chain);
-                    break;
             }
             return acc;
         }, {
@@ -26627,7 +26695,6 @@ const useSquidChains = (direction) => {
             xrplChains: [],
             stellarChains: [],
             cantonChains: [],
-            danalChains: [],
         });
     }, [chains]);
     const { supportedSourceChains, supportedDestinationChains } = React.useMemo(() => {
@@ -26649,7 +26716,6 @@ const useSquidChains = (direction) => {
         xrplChains,
         stellarChains,
         cantonChains,
-        danalChains,
         getChainType,
         findChain,
     };
@@ -26963,7 +27029,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;
 }
@@ -26972,6 +27374,7 @@ function pickAddress(accounts) {
  * (bound to its announce `target`) and exposes the lifecycle methods.
  */
 class CantonBrowserConnector {
+    kind = "cip103";
     providerId;
     name;
     target;
@@ -26986,7 +27389,7 @@ class CantonBrowserConnector {
             client ??
                 dapp.createCantonClient(new dapp.WindowTransport(win, {
                     target: this.target,
-                    timeout: REQUEST_TIMEOUT_MS,
+                    timeout: REQUEST_TIMEOUT_MS$1,
                 }));
     }
     get accounts() {
@@ -27032,6 +27435,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);
     }
@@ -27138,6 +27563,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
@@ -27184,7 +27916,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]);
     React.useEffect(() => {
         refresh();
@@ -27215,7 +27959,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();
         }
@@ -27237,8 +27983,7 @@ function useCanton() {
             wallet: recentCantonWallet,
             address,
         });
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [wallets.map((w) => w.connectorId), recentCantonWalletId]);
+    }, [wallets, recentCantonWalletId, setConnectedWallet]);
     React.useEffect(() => {
         const wallet = connectedCantonWallet.wallet;
         if (!wallet) {
@@ -27495,7 +28240,7 @@ function useStellarWallets() {
             try {
                 const { allowAllModules: initializeAllModules } = await import('@creit.tech/stellar-wallets-kit');
                 const { LedgerModule } = await import('@creit.tech/stellar-wallets-kit/modules/ledger.module.mjs');
-                const { formatStellarWallet } = await Promise.resolve().then(function () { return require('./stellarService.client-D-zkMI5s.js'); });
+                const { formatStellarWallet } = await Promise.resolve().then(function () { return require('./stellarService.client-fnyXRadt.js'); });
                 const modules = [...initializeAllModules(), new LedgerModule()];
                 const promises = modules.map(async (module) => {
                     const isAvailable = await module.isAvailable();
@@ -28074,6 +28819,11 @@ const useWallet = () => {
                 }
             }
             catch (error) {
+                const connecting = useWalletStore.getState().connectingWalletState;
+                if (connecting.wallet !== wallet ||
+                    connecting.status !== exports.ConnectingWalletStatus.CONNECTING) {
+                    return false;
+                }
                 console.error("Failed to connect wallet", error);
                 walletConnectionError(wallet, error);
                 return false;
@@ -28305,8 +29055,6 @@ const useMultiChainWallet = (chain) => {
                         chainType: chain.chainType,
                     }),
                 };
-            case squidTypes.ChainType.DANAL:
-                return {};
         }
     }, [
         chain?.chainType,
@@ -28420,12 +29168,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 = reactQuery.useQueryClient();
     const { chains, supportedDestinationChains, supportedSourceChains } = useSquidChains();
+    const swapRoute = React.useMemo(() => storedSwapRoute
+        ? normalizeSwapParamsForSelection({
+            swapParams: storedSwapRoute,
+            tokens,
+            chains,
+            config: { disabledChains, availableChains, availableTokens },
+        })
+        : undefined, [
+        storedSwapRoute,
+        tokens,
+        chains,
+        disabledChains,
+        availableChains,
+        availableTokens,
+    ]);
     const sourceChainId = React.useMemo(() => swapRoute?.fromChainId ??
         (initialAssets?.from
             ? resolveChainIdFromAsset(initialAssets.from, supportedSourceChains)
@@ -28436,13 +29199,23 @@ const useSwap = () => {
             : undefined), [swapRoute?.toChainId, supportedDestinationChains, initialAssets?.to]);
     const fromChain = React.useMemo(() => supportedSourceChains.find((c) => c.chainId === swapRoute?.fromChainId), [swapRoute?.fromChainId, supportedSourceChains]);
     const toChain = React.useMemo(() => supportedDestinationChains.find((c) => c.chainId === swapRoute?.toChainId), [swapRoute?.toChainId, supportedDestinationChains]);
-    const fromTokens = React.useMemo(() => getTokensForChain(tokens, sourceChainId), [tokens, sourceChainId]);
+    const fromTokens = React.useMemo(() => {
+        const chainTokens = getTokensForChain(tokens, sourceChainId);
+        return isArcChain(sourceChainId)
+            ? filterViewableTokens(chainTokens, { availableTokens }, "from")
+            : chainTokens;
+    }, [tokens, sourceChainId, availableTokens]);
     const fromToken = React.useMemo(() => fromTokens.find((t) => t.address.toLowerCase() === swapRoute?.fromTokenAddress?.toLowerCase()), [fromTokens, swapRoute?.fromTokenAddress]);
-    const toTokens = React.useMemo(() => filterTokensForDestination({
-        tokens: getTokensForChain(tokens, destChainId),
-        selectedDestinationChain: toChain,
-        selectedSourceToken: fromToken,
-    }), [destChainId, toChain, fromToken, tokens]);
+    const toTokens = React.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 = React.useMemo(() => toTokens.find((t) => t.address.toLowerCase() === swapRoute?.toTokenAddress?.toLowerCase()), [toTokens, swapRoute?.toTokenAddress]);
     const isSameChain = sourceChainId === destChainId;
     const tokenItems = React.useMemo(() => ({ from: fromTokens, to: toTokens }), [fromTokens, toTokens]);
@@ -28490,6 +29263,7 @@ const useSwap = () => {
                 defaultTokensPerChain,
                 disabledChains,
                 availableChains,
+                availableTokens,
             },
             queryClient,
             connectedSourceAddress: connectedSourceAddress.address,
@@ -28529,6 +29303,7 @@ const useSwap = () => {
         defaultTokensPerChain,
         disabledChains,
         availableChains,
+        availableTokens,
         initialAssets,
         queryClient,
         swapRoute,
@@ -28584,6 +29359,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: {
@@ -28591,6 +29370,7 @@ const useSwap = () => {
                     defaultTokensPerChain,
                     disabledChains,
                     availableChains,
+                    availableTokens,
                 },
                 chainId: defaultFromChainId,
                 direction: "from",
@@ -28602,6 +29382,7 @@ const useSwap = () => {
                     defaultTokensPerChain,
                     disabledChains,
                     availableChains,
+                    availableTokens,
                 },
                 chainId: defaultToChainId,
                 direction: "to",
@@ -28626,6 +29407,7 @@ const useSwap = () => {
         initialAssets,
         disabledChains,
         availableChains,
+        availableTokens,
         defaultTokensPerChain,
         tokens,
     ]);
@@ -29145,8 +29927,6 @@ async function createClient(chain) {
             return new StellarRpcClient(chain.rpc);
         case squidTypes.ChainType.CANTON:
             return null;
-        case squidTypes.ChainType.DANAL:
-            return null;
     }
 }
 
@@ -30161,8 +30941,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) => {
@@ -30171,30 +30950,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)
@@ -30413,7 +31176,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 [];
@@ -30434,21 +31197,20 @@ function useNativeTokenForChain(chain) {
                 return stellarTokens;
             case squidTypes.ChainType.CANTON:
                 return cantonTokens;
-            case squidTypes.ChainType.DANAL:
-                return danalTokens;
         }
     };
+    const tokens = getTokensForChainType();
     const nativeTokenForChainType = React.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 } = wagmi.useBalance({
+    const { data: nativeEvmBalance, isLoading, isError, } = wagmi.useBalance({
         address: address,
         chainId: Number(chain?.chainId),
         query: {
@@ -30460,6 +31222,8 @@ const useEvmNativeBalance = ({ address, chain, }) => {
         },
     });
     const balance = React.useMemo(() => {
+        if (isArcChain(chain?.chainId) && isError)
+            return undefined;
         if (nativeEvmBalance?.decimals != null && nativeEvmBalance?.value != null) {
             if (chain?.chainId === CHAIN_IDS.HEDERA) {
                 return {
@@ -30473,7 +31237,12 @@ const useEvmNativeBalance = ({ address, chain, }) => {
             };
         }
         return;
-    }, [nativeEvmBalance?.decimals, nativeEvmBalance?.value, chain?.chainId]);
+    }, [
+        nativeEvmBalance?.decimals,
+        nativeEvmBalance?.value,
+        chain?.chainId,
+        isError,
+    ]);
     return {
         balance,
         isLoading,
@@ -30696,9 +31465,6 @@ const useNativeBalance = (chain) => {
             case squidTypes.ChainType.CANTON:
                 balance = nativeCantonBalance;
                 break;
-            case squidTypes.ChainType.DANAL:
-                balance = undefined;
-                break;
         }
         const balanceFormatted = !!balance
             ? formatBNToReadable(balance.value, balance.decimals)
@@ -30738,8 +31504,6 @@ const useNativeBalance = (chain) => {
                 return isStellarLoading;
             case squidTypes.ChainType.CANTON:
                 return isCantonLoading;
-            case squidTypes.ChainType.DANAL:
-                return false;
         }
     }, [
         chain?.chainType,
@@ -30965,7 +31729,7 @@ function hederaWalletConnect(parameters) {
                 const optionalChains = config.chains.map((x) => x.id);
                 if (!optionalChains.length)
                     return;
-                const { EthereumProvider } = await Promise.resolve().then(function () { return require('./index.es-DtFDz6qc.js'); });
+                const { EthereumProvider } = await Promise.resolve().then(function () { return require('./index.es-BVCh4tlV.js'); });
                 const rawProvider = await EthereumProvider.init({
                     ...restParameters,
                     disableProviderPing: true,
@@ -31199,8 +31963,6 @@ const useSigner = ({ chain }) => {
                 return isStellarSignerReady;
             case squidTypes.ChainType.CANTON:
                 return isCantonSignerReady;
-            case squidTypes.ChainType.DANAL:
-                return false;
         }
     }, [
         chain?.chainType,
@@ -31653,12 +32415,8 @@ const useSendTransactionStore = zustand.create((set, get) => ({
 const useDepositAddressStore = zustand.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 });
@@ -31670,7 +32428,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 = React.useMemo(() => {
@@ -31680,13 +32438,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
@@ -31712,19 +32468,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;
@@ -31747,8 +32490,6 @@ function useDepositAddress(squidRoute) {
         depositAddress,
         closeDepositChannel,
         depositData: deposit,
-        userDepositTxId,
-        setUserDepositTxId,
     };
 }
 
@@ -31776,7 +32517,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[squidTypes.ChainType.CANTON]?.wallet?.connector);
     const placeholderData = React.useMemo(() => {
@@ -31789,7 +32530,6 @@ const useAllTokensWithBalanceForChainType = ({ chainType, address, direction, qu
             [squidTypes.ChainType.XRPL]: xrplTokens.map((t) => ({ ...t, balance: "0" })),
             [squidTypes.ChainType.STELLAR]: stellarTokens.map((t) => ({ ...t, balance: "0" })),
             [squidTypes.ChainType.CANTON]: cantonTokens.map((t) => ({ ...t, balance: "0" })),
-            [squidTypes.ChainType.DANAL]: danalTokens.map((t) => ({ ...t, balance: "0" })),
         };
         if (!chainType) {
             // Return all tokens with zero balance
@@ -31812,7 +32552,6 @@ const useAllTokensWithBalanceForChainType = ({ chainType, address, direction, qu
         xrplTokens,
         stellarTokens,
         cantonTokens,
-        danalTokens,
     ]);
     const isQueryEnabled = React.useMemo(() => {
         // Respect the queryOptions.enabled override if provided
@@ -31837,8 +32576,6 @@ const useAllTokensWithBalanceForChainType = ({ chainType, address, direction, qu
                 return stellarTokens.length > 0;
             case squidTypes.ChainType.CANTON:
                 return cantonTokens.length > 0;
-            case squidTypes.ChainType.DANAL:
-                return danalTokens.length > 0;
         }
     }, [
         chainType,
@@ -31852,7 +32589,6 @@ const useAllTokensWithBalanceForChainType = ({ chainType, address, direction, qu
         xrplTokens.length,
         stellarTokens.length,
         cantonTokens.length,
-        danalTokens.length,
     ]);
     const query = reactQuery.useQuery(keys().allTokensBalance(address, chainType, direction), async () => {
         // Return zero balances if no address
@@ -31977,12 +32713,6 @@ const useAllConnectedWalletBalances = ({ direction, queryOptions = {
         direction,
         queryOptions,
     });
-    const danalBalancesQuery = useAllTokensWithBalanceForChainType({
-        chainType: squidTypes.ChainType.DANAL,
-        address: connectedAddresses?.[squidTypes.ChainType.DANAL],
-        direction,
-        queryOptions,
-    });
     // Create a map of chain type to balance query results
     const balanceQueries = React.useMemo(() => ({
         [squidTypes.ChainType.EVM]: evmBalancesQuery,
@@ -31993,7 +32723,6 @@ const useAllConnectedWalletBalances = ({ direction, queryOptions = {
         [squidTypes.ChainType.XRPL]: xrplBalancesQuery,
         [squidTypes.ChainType.STELLAR]: stellarBalancesQuery,
         [squidTypes.ChainType.CANTON]: cantonBalancesQuery,
-        [squidTypes.ChainType.DANAL]: danalBalancesQuery,
     }), [
         evmBalancesQuery,
         cosmosBalancesQuery,
@@ -32003,7 +32732,6 @@ const useAllConnectedWalletBalances = ({ direction, queryOptions = {
         xrplBalancesQuery,
         stellarBalancesQuery,
         cantonBalancesQuery,
-        danalBalancesQuery,
     ]);
     // Combine all tokens from different chains
     const allTokens = React.useMemo(() => Object.values(balanceQueries).flatMap((query) => query.data?.tokens ?? []), [balanceQueries]);
@@ -32111,8 +32839,6 @@ const useMultiChainBalance = ({ chain, token, userAddress, enabled = true, }) =>
                 return stellarBalance;
             case squidTypes.ChainType.CANTON:
                 return cantonBalance;
-            case squidTypes.ChainType.DANAL:
-                return "0";
         }
     }, [
         chain?.chainType,
@@ -32318,6 +33044,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(),
@@ -32325,10 +33072,10 @@ function useSourceChainGasToken({ fromChain, fromToken, }) {
             normalizeFee: (fee) => fee,
         };
     }, [
-        fromToken?.address,
-        fromToken?.type,
+        fromToken,
         fromChain?.chainId,
         nativeBalance?.value,
+        nativeBalance?.decimals,
         tempoFeeData,
     ]);
     /**
@@ -32343,9 +33090,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,
@@ -32504,22 +33262,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
@@ -32568,14 +33361,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,
@@ -32591,10 +33392,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 {
@@ -32616,7 +33419,7 @@ const calculateEstimateResults = ({ squidRoute, tokens, fromChain, toChain, coll
         expectedGasRefundCostUSD,
         sameTokenBetweenFees,
         fromTokenPaysGasFees: chainFeeParams?.fromTokenPaysGasFees ?? false,
-        totalNativeFees,
+        totalNativeFees: totalNativeFees ?? 0n,
         isGasBalanceEnough,
         minAmountValueWarnMsg,
         estimatedRouteDuration,
@@ -32665,8 +33468,12 @@ function useSendTransactionGas({ chain, token, from, }) {
                 case squidTypes.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));
@@ -32686,6 +33493,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 ethers.Interface(viem.erc20Abi);
@@ -32700,6 +33510,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) {
@@ -32747,35 +33560,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 = React.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 = React.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,
     ]);
@@ -32786,20 +33609,22 @@ function useEstimateSendTransaction({ chain, token, amount, balance, from, }) {
             parseToBigInt(amount, token.decimals));
     }, [amount, balance, token?.decimals]);
     const minAmountValueWarnMsg = React.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,
     };
@@ -33222,9 +34047,8 @@ function useSendTransaction({ to, amount, token, chain, }) {
                         chain,
                     });
                     break;
-                case squidTypes.ChainType.CANTON:
-                case squidTypes.ChainType.DANAL: {
-                    throw new Error(`Send not implemented for chain type ${chain.chainType}`);
+                case squidTypes.ChainType.CANTON: {
+                    throw new Error("Not implemented");
                 }
             }
             return {
@@ -33430,8 +34254,7 @@ async function getSendTransactionStatus({ chain, txHash, }) {
                 chain,
             });
         case squidTypes.ChainType.CANTON:
-        case squidTypes.ChainType.DANAL:
-            throw new Error(`Send not implemented for chain type ${chain.chainType}`);
+            throw new Error("Not implemented");
     }
 }
 
@@ -33702,6 +34525,19 @@ const useApproval = ({ squidRoute, }) => {
     const { getChainType } = useSquidChains();
     const { switchChainAsync } = wagmi.useSwitchChain();
     const { connectedAddress: { address: sourceUserAddress }, } = useMultiChainWallet(fromChain);
+    const arcNativeBalanceQuery = wagmi.useBalance({
+        address: sourceUserAddress,
+        chainId: Number(fromChain?.chainId),
+        query: { enabled: false },
+    });
+    const arcTokenBalanceQuery = wagmi.useReadContract({
+        address: fromToken?.address,
+        abi: viem.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.
@@ -33862,13 +34698,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(exports.QueryKeys.AllTokensBalance));
+            }
             await allowanceQuery?.refetch();
             queryClient.invalidateQueries(getPrefixKey(exports.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),
@@ -37052,342 +37895,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
@@ -38002,7 +38509,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,
@@ -38010,15 +38517,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: exports.TransactionStatus.INITIAL_LOADING,
             sourceStatus: exports.TransactionStatus.ONGOING,
@@ -38301,7 +38807,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 = React.useMemo(() => keys().transaction(fromChain?.chainId, toChain?.chainId, toToken?.address, fromToken?.address, fromPrice, config.slippage, sourceUserAddress, config.degenMode, destinationAddress, fallbackAddress, quoteOnly, fromChain?.chainType, config.preHook, config.postHook, config.overrideGasRefundAddress), [
         fromChain?.chainId,
@@ -38593,6 +39099,10 @@ const useAutoConnect = () => {
     const { chains } = useSquidChains();
     const { isInitialized } = useConfigStore();
     const hasAttemptedReconnect = React.useRef(false);
+    const hasAttemptedCantonReconnect = React.useRef(false);
+    const { autoConnectCanton, wallets: cantonWallets } = useCantonContext();
+    const recentCantonWalletId = useWalletStore((state) => state.recentConnectorIds[squidTypes.ChainType.CANTON]);
+    const hasRecentCantonWallet = cantonWallets.some((wallet) => wallet.connectorId === recentCantonWalletId);
     const { autoConnectEvm } = useEvmContext();
     const { autoConnectSolana } = useSolanaContext();
     const { autoConnectSui } = useSuiContext();
@@ -38660,6 +39170,15 @@ const useAutoConnect = () => {
     React.useEffect(() => {
         autoConnect();
     }, [autoConnect]);
+    React.useEffect(() => {
+        if (!isInitialized ||
+            chains.length === 0 ||
+            !hasRecentCantonWallet ||
+            hasAttemptedCantonReconnect.current)
+            return;
+        hasAttemptedCantonReconnect.current = true;
+        autoConnectCanton().catch(() => undefined);
+    }, [autoConnectCanton, hasRecentCantonWallet, isInitialized, chains.length]);
     return { autoConnect };
 };
 
@@ -39067,6 +39586,7 @@ exports.getStepsInfos = getStepsInfos;
 exports.getSuggestedAmountsForCurrency = getSuggestedAmountsForCurrency;
 exports.getSupportedChainIdsForDirection = getSupportedChainIdsForDirection;
 exports.getSwapTxStatusRefetchInterval = getSwapTxStatusRefetchInterval;
+exports.getTokenAddressForSelection = getTokenAddressForSelection;
 exports.getTokenAssetsKey = getTokenAssetsKey;
 exports.getTokenImage = getTokenImage;
 exports.getTokensForChain = getTokensForChain;
@@ -39087,9 +39607,6 @@ exports.isChainflipBridgeTransaction = isChainflipBridgeTransaction;
 exports.isChainflipDepositRoute = isChainflipDepositRoute;
 exports.isCoralBridgeAction = isCoralBridgeAction;
 exports.isCosmosAddressValid = isCosmosAddressValid;
-exports.isDanalAddressValid = isDanalAddressValid;
-exports.isDanalDepositRoute = isDanalDepositRoute;
-exports.isDanalTxHashValid = isDanalTxHashValid;
 exports.isDepositAddressDirectTransferRoute = isDepositAddressDirectTransferRoute;
 exports.isEmptyObject = isEmptyObject;
 exports.isEvmChainNotSupportedError = isEvmChainNotSupportedError;
@@ -39126,8 +39643,8 @@ exports.nativeSuiTokenAddress = nativeSuiTokenAddress;
 exports.nativeXrplTokenAddress = nativeXrplTokenAddress;
 exports.normalizeError = normalizeError;
 exports.normalizeIbcAddress = normalizeIbcAddress;
+exports.normalizeSwapParamsForSelection = normalizeSwapParamsForSelection;
 exports.normalizeTokenSymbol = normalizeTokenSymbol;
-exports.parseDanalTransferBody = parseDanalTransferBody;
 exports.parseEvmAddress = parseEvmAddress;
 exports.parseInitialAssetsFromUrl = parseInitialAssetsFromUrl;
 exports.parseToBigInt = parseToBigInt;
@@ -39240,4 +39757,4 @@ exports.useXrplTrustLine = useXrplTrustLine;
 exports.waitForReceiptWithRetry = waitForReceiptWithRetry;
 exports.walletIconBaseUrl = walletIconBaseUrl;
 exports.walletSupportsChainType = walletSupportsChainType;
-//# sourceMappingURL=index-nTqoaD0B.js.map
+//# sourceMappingURL=index-BBJD55XX.js.map