@0xsquid/react-hooks 8.11.1-beta-danal.1 → 8.12.0

package/dist/{index-BT6G_mgr.js → index-CJVX-7hj.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";
@@ -166,7 +163,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 +173,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 +183,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 +20964,9 @@ const isBitcoinAddressValid = (address) => {
     }
 };
 
+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 +21117,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 +21465,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 +21989,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 +22037,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) => {
@@ -22375,8 +22321,6 @@ const connectByChainType = async (chainType, wallet, defaultChain, params) => {
                     connector,
                 },
             });
-        case squidTypes.ChainType.DANAL:
-            return null;
     }
 };
 const getChainTypesToConnect = (selectedChainTypes, defaultChain, supportedChains) => {
@@ -22501,6 +22445,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:
@@ -23361,7 +23307,7 @@ 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;
@@ -23413,7 +23359,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) {
@@ -23735,7 +23681,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-TP5V9Jwg.js'); });
+    const { fetchAllSecretBalances } = await Promise.resolve().then(function () { return require('./secretService-GHdReJBs.js'); });
     return fetchAllSecretBalances(chainData, cosmosAddress, squidSecretTokens, keplrTypeWallet);
 };
 function getTokenAssetsKey(token) {
@@ -25729,7 +25675,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:
@@ -25756,9 +25702,6 @@ const useSquidTokens = (direction) => {
                 case squidTypes.ChainType.CANTON:
                     acc.cantonTokens.push(token);
                     break;
-                case squidTypes.ChainType.DANAL:
-                    acc.danalTokens.push(token);
-                    break;
             }
             return acc;
         }, {
@@ -25770,7 +25713,6 @@ const useSquidTokens = (direction) => {
             xrplTokens: [],
             stellarTokens: [],
             cantonTokens: [],
-            danalTokens: [],
         });
     }, [tokens]);
     const findToken = React.useCallback((address, chainId) => {
@@ -25789,7 +25731,6 @@ const useSquidTokens = (direction) => {
         xrplTokens,
         stellarTokens,
         cantonTokens,
-        danalTokens,
     };
 };
 
@@ -26326,7 +26267,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
@@ -26593,7 +26533,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:
@@ -26614,9 +26554,6 @@ const useSquidChains = (direction) => {
                 case squidTypes.ChainType.CANTON:
                     acc.cantonChains.push(chain);
                     break;
-                case squidTypes.ChainType.DANAL:
-                    acc.danalChains.push(chain);
-                    break;
             }
             return acc;
         }, {
@@ -26626,7 +26563,6 @@ const useSquidChains = (direction) => {
             xrplChains: [],
             stellarChains: [],
             cantonChains: [],
-            danalChains: [],
         });
     }, [chains]);
     const { supportedSourceChains, supportedDestinationChains } = React.useMemo(() => {
@@ -26648,7 +26584,6 @@ const useSquidChains = (direction) => {
         xrplChains,
         stellarChains,
         cantonChains,
-        danalChains,
         getChainType,
         findChain,
     };
@@ -26962,7 +26897,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;
 }
@@ -26971,6 +27242,7 @@ function pickAddress(accounts) {
  * (bound to its announce `target`) and exposes the lifecycle methods.
  */
 class CantonBrowserConnector {
+    kind = "cip103";
     providerId;
     name;
     target;
@@ -26985,7 +27257,7 @@ class CantonBrowserConnector {
             client ??
                 dapp.createCantonClient(new dapp.WindowTransport(win, {
                     target: this.target,
-                    timeout: REQUEST_TIMEOUT_MS,
+                    timeout: REQUEST_TIMEOUT_MS$1,
                 }));
     }
     get accounts() {
@@ -27031,6 +27303,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);
     }
@@ -27137,6 +27431,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
@@ -27183,7 +27784,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();
@@ -27214,7 +27827,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();
         }
@@ -27236,8 +27851,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) {
@@ -27494,7 +28108,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-WTkVJJhn.js'); });
+                const { formatStellarWallet } = await Promise.resolve().then(function () { return require('./stellarService.client-DvA-2pXq.js'); });
                 const modules = [...initializeAllModules(), new LedgerModule()];
                 const promises = modules.map(async (module) => {
                     const isAvailable = await module.isAvailable();
@@ -28073,6 +28687,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;
@@ -28304,8 +28923,6 @@ const useMultiChainWallet = (chain) => {
                         chainType: chain.chainType,
                     }),
                 };
-            case squidTypes.ChainType.DANAL:
-                return {};
         }
     }, [
         chain?.chainType,
@@ -29144,8 +29761,6 @@ async function createClient(chain) {
             return new StellarRpcClient(chain.rpc);
         case squidTypes.ChainType.CANTON:
             return null;
-        case squidTypes.ChainType.DANAL:
-            return null;
     }
 }
 
@@ -30160,8 +30775,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) => {
@@ -30170,30 +30784,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)
@@ -30412,7 +31010,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 [];
@@ -30433,8 +31031,6 @@ function useNativeTokenForChain(chain) {
                 return stellarTokens;
             case squidTypes.ChainType.CANTON:
                 return cantonTokens;
-            case squidTypes.ChainType.DANAL:
-                return danalTokens;
         }
     };
     const nativeTokenForChainType = React.useMemo(() => {
@@ -30695,9 +31291,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)
@@ -30737,8 +31330,6 @@ const useNativeBalance = (chain) => {
                 return isStellarLoading;
             case squidTypes.ChainType.CANTON:
                 return isCantonLoading;
-            case squidTypes.ChainType.DANAL:
-                return false;
         }
     }, [
         chain?.chainType,
@@ -30964,7 +31555,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-BZb8tg2z.js'); });
+                const { EthereumProvider } = await Promise.resolve().then(function () { return require('./index.es-CTKuR0LC.js'); });
                 const rawProvider = await EthereumProvider.init({
                     ...restParameters,
                     disableProviderPing: true,
@@ -31198,8 +31789,6 @@ const useSigner = ({ chain }) => {
                 return isStellarSignerReady;
             case squidTypes.ChainType.CANTON:
                 return isCantonSignerReady;
-            case squidTypes.ChainType.DANAL:
-                return false;
         }
     }, [
         chain?.chainType,
@@ -31652,12 +32241,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 });
@@ -31669,7 +32254,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(() => {
@@ -31679,13 +32264,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
@@ -31711,19 +32294,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;
@@ -31746,8 +32316,6 @@ function useDepositAddress(squidRoute) {
         depositAddress,
         closeDepositChannel,
         depositData: deposit,
-        userDepositTxId,
-        setUserDepositTxId,
     };
 }
 
@@ -31775,7 +32343,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(() => {
@@ -31788,7 +32356,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
@@ -31811,7 +32378,6 @@ const useAllTokensWithBalanceForChainType = ({ chainType, address, direction, qu
         xrplTokens,
         stellarTokens,
         cantonTokens,
-        danalTokens,
     ]);
     const isQueryEnabled = React.useMemo(() => {
         // Respect the queryOptions.enabled override if provided
@@ -31836,8 +32402,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,
@@ -31851,7 +32415,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
@@ -31976,12 +32539,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,
@@ -31992,7 +32549,6 @@ const useAllConnectedWalletBalances = ({ direction, queryOptions = {
         [squidTypes.ChainType.XRPL]: xrplBalancesQuery,
         [squidTypes.ChainType.STELLAR]: stellarBalancesQuery,
         [squidTypes.ChainType.CANTON]: cantonBalancesQuery,
-        [squidTypes.ChainType.DANAL]: danalBalancesQuery,
     }), [
         evmBalancesQuery,
         cosmosBalancesQuery,
@@ -32002,7 +32558,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]);
@@ -32110,8 +32665,6 @@ const useMultiChainBalance = ({ chain, token, userAddress, enabled = true, }) =>
                 return stellarBalance;
             case squidTypes.ChainType.CANTON:
                 return cantonBalance;
-            case squidTypes.ChainType.DANAL:
-                return "0";
         }
     }, [
         chain?.chainType,
@@ -33221,9 +33774,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 {
@@ -33429,8 +33981,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");
     }
 }
 
@@ -37051,342 +37602,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
@@ -38001,7 +38216,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,
@@ -38009,15 +38224,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,
@@ -38300,7 +38514,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,
@@ -38592,6 +38806,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();
@@ -38659,6 +38877,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 };
 };
 
@@ -39086,9 +39313,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,7 +39350,6 @@ exports.nativeXrplTokenAddress = nativeXrplTokenAddress;
 exports.normalizeError = normalizeError;
 exports.normalizeIbcAddress = normalizeIbcAddress;
 exports.normalizeTokenSymbol = normalizeTokenSymbol;
-exports.parseDanalTransferBody = parseDanalTransferBody;
 exports.parseEvmAddress = parseEvmAddress;
 exports.parseInitialAssetsFromUrl = parseInitialAssetsFromUrl;
 exports.parseToBigInt = parseToBigInt;
@@ -39239,4 +39462,4 @@ exports.useXrplTrustLine = useXrplTrustLine;
 exports.waitForReceiptWithRetry = waitForReceiptWithRetry;
 exports.walletIconBaseUrl = walletIconBaseUrl;
 exports.walletSupportsChainType = walletSupportsChainType;
-//# sourceMappingURL=index-BT6G_mgr.js.map
+//# sourceMappingURL=index-CJVX-7hj.js.map