@0xsquid/react-hooks 8.9.1-beta.0 → 8.10.0

package/dist/{index-Ypw6i6uY.js → index-BlB3yIoX.js}

@@ -3,7 +3,6 @@ import { zeroAddress as zeroAddress$1, parseUnits, formatUnits, isAddress, Switc
 import React, { useMemo, useCallback, useState, useEffect, createContext, useContext, useRef } from 'react';
 import { useQuery, useMutation, useQueries, useQueryClient, QueryClient, QueryClientProvider } from '@tanstack/react-query';
 import { fromBech32 } from '@cosmjs/encoding';
-import { getWallets } from '@wallet-standard/core';
 import * as bitcoin from 'bitcoinjs-lib';
 import { address } from 'bitcoinjs-lib';
 import * as ecc from '@bitcoinerlab/secp256k1';
@@ -11,13 +10,13 @@ import axios, { AxiosError } from 'axios';
 import { WalletConnectModal } from '@walletconnect/modal';
 import UniversalProvider from '@walletconnect/universal-provider';
 import { isValidXAddress, isValidClassicAddress } from 'ripple-address-codec';
+import BigNumber, { BigNumber as BigNumber$1 } from 'bignumber.js';
 import { TOKEN_2022_PROGRAM_ID, TOKEN_PROGRAM_ID, getAssociatedTokenAddress, createAssociatedTokenAccountInstruction, createTransferInstruction } from '@solana/spl-token';
 import { StandardWalletAdapter } from '@solana/wallet-standard-wallet-adapter-base';
 import { PublicKey, Transaction, SystemProgram, VersionedTransaction, Connection } from '@solana/web3.js';
 import { StrKey, Networks, nativeToScVal, Address, rpc, TransactionBuilder, BASE_FEE, Contract, TimeoutInfinite, scValToNative, Asset, Operation, Transaction as Transaction$1, xdr } from '@stellar/stellar-sdk';
 import { SUI_TESTNET_CHAIN, SUI_MAINNET_CHAIN } from '@mysten/wallet-standard';
 import { CloudflareProvider, JsonRpcProvider, ethers, Interface, BrowserProvider, JsonRpcSigner, Contract as Contract$1, isError } from 'ethers';
-import BigNumber$1, { BigNumber } from 'bignumber.js';
 import { countries } from 'countries-list';
 import getSymbolFromCurrency from 'currency-symbol-map';
 import Fuse from 'fuse.js';
@@ -25,6 +24,8 @@ import { create } from 'zustand';
 import { persist } from 'zustand/middleware';
 import { useAccount, useConnectors, useConnect, useDisconnect, useSwitchChain, useBalance, useReadContract, createConfig, http, useWalletClient, usePublicClient, WagmiProvider } from 'wagmi';
 import SafeAppsSDK, { TransactionStatus as TransactionStatus$1 } from '@safe-global/safe-apps-sdk';
+import { createCantonClient, WindowTransport } from '@sigilry/dapp';
+import { getWallets } from '@wallet-standard/core';
 import { SlushWallet } from '@mysten/slush-wallet';
 import { StargateClient, SigningStargateClient } from '@cosmjs/stargate';
 import { SuiClient } from '@mysten/sui/client';
@@ -57,6 +58,7 @@ const solanaZeroAddress = "11111111111111111111111111111111";
 const suiZeroAddress = "0x0000000000000000000000000000000000000000";
 const xrplZeroAddress = "rrrrrrrrrrrrrrrrrrrrrhoLvTp";
 const stellarZeroAddress = "GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWHF";
+const cantonZeroAddress = "none::12200000000000000000000000000000000000000000000000000000000000000000";
 const chainTypeToZeroAddressMap = {
     [ChainType.EVM]: zeroAddress$1,
     [ChainType.COSMOS]: cosmosZeroAddress,
@@ -65,6 +67,7 @@ const chainTypeToZeroAddressMap = {
     [ChainType.SUI]: suiZeroAddress,
     [ChainType.XRPL]: xrplZeroAddress,
     [ChainType.STELLAR]: stellarZeroAddress,
+    [ChainType.CANTON]: cantonZeroAddress,
 };
 const nativeEvmTokenAddress = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
 const nativeCosmosTokenAddress = "uosmo";
@@ -73,6 +76,7 @@ const nativeBitcoinTokenAddress = "satoshi";
 const nativeSuiTokenAddress = "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI";
 const nativeXrplTokenAddress = "xrp";
 const nativeStellarTokenAddress = "CAS3J7GYLGXMF6TDJBBYYSE3HQ6BBSMLNUQ34T6TZMYMW2EVH34XOWMA";
+const nativeCantonTokenAddress = "DSO::1220b1431ef217342db44d516bb9befde802be7d8899637d290895fa58880f19accc";
 // by setting slippage to undefined, it's set to "auto"
 const defaultSlippage = undefined;
 const destinationAddressResetValue = "null";
@@ -81,6 +85,7 @@ const gasRefundMultiplier = 25;
 const internalSquidApiBaseUrl = "https://app.squidrouter.com/api";
 const XAMAN_API_URL = `${internalSquidApiBaseUrl}/xaman/`;
 const TOKEN_PRICE_API_URL = `${internalSquidApiBaseUrl}/coingecko`;
+const CANTON_AMULET_REGISTRY_URL = `${internalSquidApiBaseUrl}/canton/scan-proxy`;
 const DEFAULT_ROUTE_REFETCH_INTERVAL = 30_000;
 const SOLANA_RPC_URL = "https://meredith-ute2ko-fast-mainnet.helius-rpc.com";
 const INTEGRATOR_ID = "squid-widget-playground-local-cd33cba6-7e12-4fcc-8d5d-35e286f655ea";
@@ -136,6 +141,7 @@ const CHAIN_IDS = {
     XRPL_TESTNET: "xrpl-testnet",
     STELLAR: "stellar-mainnet",
     STELLAR_TESTNET: "stellar-testnet",
+    CANTON: "canton",
 };
 const chainTypeToDefaultChainIdMap = {
     [ChainType.EVM]: CHAIN_IDS.ETHEREUM,
@@ -145,6 +151,7 @@ const chainTypeToDefaultChainIdMap = {
     [ChainType.SUI]: CHAIN_IDS.SUI,
     [ChainType.XRPL]: CHAIN_IDS.XRPL,
     [ChainType.STELLAR]: CHAIN_IDS.STELLAR,
+    [ChainType.CANTON]: CHAIN_IDS.CANTON,
 };
 const chainTypeToNativeTokenAddressMap = {
     [ChainType.EVM]: nativeEvmTokenAddress,
@@ -154,6 +161,7 @@ const chainTypeToNativeTokenAddressMap = {
     [ChainType.SUI]: nativeSuiTokenAddress,
     [ChainType.XRPL]: nativeXrplTokenAddress,
     [ChainType.STELLAR]: nativeStellarTokenAddress,
+    [ChainType.CANTON]: nativeCantonTokenAddress,
 };
 const defaultConfigValues = {
     integratorId: INTEGRATOR_ID,
@@ -4709,11 +4717,6 @@ class BitcoinConnectorInvalidAccountError extends BitcoinConnectorError {
         super("Bitcoin account is invalid");
     }
 }
-class BitcoinConnectorFeatureNotSupportedError extends BitcoinConnectorError {
-    constructor(providerName, feature) {
-        super(`Bitcoin provider ${providerName} does not support ${feature}`);
-    }
-}
 
 class KeplrConnector {
     get getProvider() {
@@ -4742,20 +4745,6 @@ class KeplrConnector {
     }
 }
 
-const BitcoinConnect = "bitcoin:connect";
-const BitcoinSignTransaction = "bitcoin:signTransaction";
-const REQUIRED_BITCOIN_FEATURES = [
-    BitcoinConnect,
-    BitcoinSignTransaction,
-];
-/**
- * Type guard: the wallet exposes the Bitcoin features this SDK needs (connect +
- * signTransaction). Wallets advertising only a subset are treated as unsupported.
- */
-function hasBitcoinFeatures(wallet) {
-    return REQUIRED_BITCOIN_FEATURES.every((feature) => feature in wallet.features);
-}
-
 bitcoin.initEccLib(ecc);
 const network = bitcoin.networks.bitcoin;
 const fromHexString = (hexString) => {
@@ -4845,100 +4834,55 @@ async function getTransactionStatus$1(txHash) {
 }
 
 const MAINNET = bitcoin.networks.bitcoin;
-/**
- * Bitcoin connector backed by the Bitcoin Wallet Standard.
- *
- * Discovers the wallet from the Wallet Standard registry at call time (mirroring
- * how Solana/Sui wallets are resolved) and connects/signs through the
- * `bitcoin:connect` and `bitcoin:signTransaction` features instead of a
- * wallet-specific injected provider. Configure it with a `walletName` to support
- * any wallet exposing the Bitcoin Wallet Standard — Phantom is the first consumer.
- */
-class BitcoinStandardConnector {
-    walletName;
-    constructor({ walletName }) {
-        this.walletName = walletName;
-    }
-    getWallet() {
-        const wallet = getWallets()
-            .get()
-            .find((candidate) => candidate.name.toLowerCase() === this.walletName.toLowerCase());
-        if (!wallet) {
-            throw new BitcoinConnectorProviderNotFoundError(this.walletName);
-        }
-        const bitcoinWallet = wallet;
-        if (!hasBitcoinFeatures(bitcoinWallet)) {
-            throw new BitcoinConnectorFeatureNotSupportedError(this.walletName, "Bitcoin Wallet Standard");
+class PhantomConnector {
+    get getProvider() {
+        const provider = window?.phantom?.bitcoin;
+        if (!provider) {
+            throw new BitcoinConnectorProviderNotFoundError("Phantom");
         }
-        return bitcoinWallet;
+        return provider;
     }
-    async connectAccount(purpose) {
-        const wallet = this.getWallet();
-        const connect = wallet.features[BitcoinConnect]?.connect;
-        if (!connect) {
-            throw new BitcoinConnectorFeatureNotSupportedError(this.walletName, BitcoinConnect);
-        }
-        const { accounts } = await connect({ purposes: [purpose] });
-        // `purpose` is a user preference, not a guarantee (per Phantom's docs), but
-        // requesting a single purpose returns the matching account first.
-        const account = accounts[0];
-        if (typeof account?.address !== "string") {
+    async requestAccount() {
+        const phantomAccounts = await this.getProvider.requestAccounts();
+        if (!phantomAccounts)
+            throw new BitcoinConnectorInvalidAccountError();
+        const paymentAccount = phantomAccounts.find((account) => account.purpose === "payment");
+        if (typeof paymentAccount?.address !== "string") {
             throw new BitcoinConnectorInvalidAccountError();
         }
-        return account;
-    }
-    async requestAccount() {
-        const account = await this.connectAccount("payment");
         return {
-            address: account.address,
+            address: paymentAccount.address,
         };
     }
     async sendBTC(to, amount) {
-        const account = await this.connectAccount("payment");
-        const { psbtHex } = await createSendBtcPsbt(account.address, to, amount);
-        const txId = await this.signAndBroadcast(psbtHex, account);
+        const { address } = await this.requestAccount();
+        const { psbtHex } = await createSendBtcPsbt(address, to, amount);
+        const { txId } = await this.signPsbt(psbtHex);
         if (!txId)
             throw new BitcoinConnectorTransactionFailedError();
         return { txHash: txId };
     }
-    async signAndBroadcast(psbtHex, account) {
-        const wallet = this.getWallet();
-        const signTransaction = wallet.features[BitcoinSignTransaction]?.signTransaction;
-        if (!signTransaction) {
-            throw new BitcoinConnectorFeatureNotSupportedError(this.walletName, BitcoinSignTransaction);
-        }
-        const unsignedPsbt = bitcoin.Psbt.fromHex(psbtHex, { network: MAINNET });
-        const signingIndexes = unsignedPsbt.data.inputs.map((_, index) => index);
-        const [result] = await signTransaction({
-            psbt: fromHexString(psbtHex),
-            inputsToSign: [
-                {
-                    // All inputs are funded from the payment account.
-                    account,
-                    signingIndexes,
-                },
-            ],
+    async signPsbt(psbtHex) {
+        const { address: paymentAddress } = await this.requestAccount();
+        const toSignPsbt = bitcoin.Psbt.fromHex(String(psbtHex), {
+            network: MAINNET,
         });
-        if (!result?.signedPsbt) {
-            throw new BitcoinConnectorTransactionFailedError();
-        }
-        const signedPsbt = bitcoin.Psbt.fromBuffer(result.signedPsbt);
+        const inputs = toSignPsbt.data.inputs;
+        const inputsToSign = [
+            {
+                // Need to sign each input with the payment address
+                address: paymentAddress,
+                signingIndexes: inputs.map((_, index) => index),
+            },
+        ];
+        const signedPsbtBytes = await this.getProvider.signPSBT(fromHexString(psbtHex), {
+            inputsToSign,
+        });
+        const signedPsbt = bitcoin.Psbt.fromBuffer(signedPsbtBytes);
         signedPsbt.finalizeAllInputs();
         const tx = signedPsbt.extractTransaction();
-        return broadcastTx(tx.toHex());
-    }
-}
-
-/**
- * Phantom Bitcoin connector via the Bitcoin Wallet Standard.
- *
- * Phantom deprecated the injected `window.phantom.bitcoin` provider in favour of
- * the Wallet Standard; this resolves Phantom from the registry by name and signs
- * through the standard Bitcoin features. See {@link BitcoinStandardConnector}.
- */
-class PhantomConnector extends BitcoinStandardConnector {
-    constructor() {
-        super({ walletName: "Phantom" });
+        const txId = await broadcastTx(tx.toHex());
+        return { txId };
     }
 }
 
@@ -20600,6 +20544,17 @@ var WindowWalletFlag;
 })(WindowWalletFlag || (WindowWalletFlag = {}));
 
 const walletIconBaseUrl = "https://raw.githubusercontent.com/0xsquid/assets/main/images/webp128/wallets";
+/**
+ * Dynamically accesses a nested property of an object based on a dot-separated string path.
+ * Returns the value of the property if found, otherwise undefined.
+ */
+const accessProperty = (object, path) => {
+    const value = get$2(object, path);
+    if (value === undefined) {
+        console.error(`Property "${path}" not found while reading object`, object);
+    }
+    return value;
+};
 const bitcoinWallets = [
     {
         name: "Unisat",
@@ -20896,6 +20851,34 @@ const walletStoreLinks = {
     },
 };
 
+/**
+ * Wallets to show regardless of whether they're detected.
+ * Useful when we want to link to the browser extension store
+ * for wallets that are automatically discovered (i.e. EVM, SOLANA, CANTON...)
+ */
+const fallbackWallets = [
+    {
+        chainType: ChainType.CANTON,
+        id: "ldmohiccoioolenadmogclhoklmanpgi",
+        name: "Send Connect",
+        connectorName: "Send Connect",
+        icon: `${walletIconBaseUrl}/canton-send.webp`,
+        links: {
+            chrome: "https://chromewebstore.google.com/detail/send-connect/ldmohiccoioolenadmogclhoklmanpgi",
+        },
+    },
+    {
+        chainType: ChainType.CANTON,
+        id: "lpnfhpbpmlobjlgkdmnjieeihjmihhjd",
+        name: "Console Wallet",
+        connectorName: "Console Wallet",
+        icon: `${walletIconBaseUrl}/canton-console.webp`,
+        links: {
+            chrome: "https://chromewebstore.google.com/detail/console-wallet/lpnfhpbpmlobjlgkdmnjieeihjmihhjd",
+        },
+    },
+];
+
 // Validation taken from Squid API repo
 const isBitcoinAddressValid = (address$1) => {
     try {
@@ -20915,6 +20898,142 @@ const isBitcoinAddressValid = (address$1) => {
     }
 };
 
+// Canton PartyID = address
+const CANTON_PARTY_ID_SEPARATOR = "::";
+/** Canton Coin's well-known token-standard instrument id (its address carries no id prefix). */
+const CANTON_AMULET_INSTRUMENT_ID = "Amulet";
+function isCantonAddressValid(address) {
+    // Canton address format: `name::fingerprint`, where name is an arbitrary string
+    // and fingerprint is a 64-character hex string with a 1220 prefix (SHA-256 hash of the public key)
+    const parts = address.split(CANTON_PARTY_ID_SEPARATOR);
+    if (parts.length !== 2)
+        return false;
+    const [name, fingerprint] = parts;
+    return name.length > 0 && /^1220[0-9a-f]{64}$/.test(fingerprint);
+}
+/**
+ * Splice token-standard Holding interface id. A party's balance for an
+ * instrument is the sum of `amount` across active contracts implementing this interface.
+ */
+const CANTON_HOLDING_INTERFACE_ID = "#splice-api-token-holding-v1:Splice.Api.Token.HoldingV1:Holding";
+/**
+ * Derive the token-standard instrument `{ admin, id }` from a Squid Canton token
+ * address (use the case-sensitive `originalAddress`), or `null` when the address
+ * is not a valid Canton token address.
+ *
+ * The admin party is the last two `::` segments (`name::fingerprint`); the
+ * instrument id is everything before that. Canton Coin has no id prefix
+ * (`DSO::1220…`) and uses the well-known id `Amulet`.
+ *   - `DSO::1220…`                                  -> { admin: "DSO::1220…", id: "Amulet" }
+ *   - `USDCx::decentralized-usdc-…::12208…`         -> { admin: "decentralized-usdc-…::12208…", id: "USDCx" }
+ */
+function parseCantonInstrument(address) {
+    const segments = address.split(CANTON_PARTY_ID_SEPARATOR);
+    if (segments.length < 2) {
+        return null;
+    }
+    const admin = segments.slice(-2).join(CANTON_PARTY_ID_SEPARATOR);
+    const idPrefix = segments.slice(0, -2).join(CANTON_PARTY_ID_SEPARATOR);
+    return {
+        admin,
+        id: idPrefix.length > 0 ? idPrefix : CANTON_AMULET_INSTRUMENT_ID,
+    };
+}
+/**
+ * Body for `POST /v2/state/active-contracts`, filtered to the party's Holding
+ * contracts with the interface view included (so we can read amount/instrument).
+ *
+ * ACS: Active Contract Set — the ledger's currently-active contracts (created and
+ * not yet archived) as of a ledger offset.
+ */
+function buildHoldingsAcsRequestBody(partyId, activeAtOffset) {
+    return {
+        activeAtOffset,
+        eventFormat: {
+            verbose: true,
+            filtersByParty: {
+                [partyId]: {
+                    cumulative: [
+                        {
+                            identifierFilter: {
+                                InterfaceFilter: {
+                                    value: {
+                                        interfaceId: CANTON_HOLDING_INTERFACE_ID,
+                                        includeInterfaceView: true,
+                                        includeCreatedEventBlob: false,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+            },
+        },
+    };
+}
+/**
+ * Parse the party's Holding contracts (with contract ids) from a raw
+ * `/v2/state/active-contracts` response
+ *  Defensive: skips entries it can't parse.
+ */
+function parseCantonHoldings(acsResponse) {
+    if (!Array.isArray(acsResponse))
+        return [];
+    const holdings = [];
+    for (const entry of acsResponse) {
+        const createdEvent = entry?.contractEntry?.JsActiveContract
+            ?.createdEvent;
+        const contractId = createdEvent?.contractId;
+        const views = createdEvent?.interfaceViews;
+        if (!contractId || !Array.isArray(views))
+            continue;
+        for (const view of views) {
+            const value = view?.viewValue;
+            const instrumentId = value?.instrumentId;
+            if (!instrumentId?.admin ||
+                instrumentId.id == null ||
+                value.amount == null) {
+                continue;
+            }
+            holdings.push({
+                contractId,
+                instrument: { admin: instrumentId.admin, id: instrumentId.id },
+                amount: String(value.amount),
+                // Locked holdings are not spendable, skip them
+                locked: value.lock != null,
+            });
+        }
+    }
+    return holdings;
+}
+/**
+ * Key used to group holdings by instrument.
+ */
+function instrumentKey(admin, id) {
+    return `${admin}|${id}`;
+}
+function cantonInstrumentKey(instrument) {
+    return instrumentKey(instrument.admin, instrument.id);
+}
+/**
+ * Group the (unlocked) Holding amounts by instrument from a raw
+ * `/v2/state/active-contracts` response. Returns a map of instrument key
+ * (`admin|id`) -> human-readable decimal string (the token-standard `amount`
+ * is already a Decimal, not base units).
+ */
+function groupCantonHoldingBalances(acsResponse) {
+    const totals = {};
+    for (const holding of parseCantonHoldings(acsResponse)) {
+        // Locked holdings are not spendable, skip them
+        if (holding.locked)
+            continue;
+        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)]));
+}
+
 const solanaTokenProgramIdByAddress = {
     [TOKEN_PROGRAM_ID.toBase58()]: TOKEN_PROGRAM_ID,
     [TOKEN_2022_PROGRAM_ID.toBase58()]: TOKEN_2022_PROGRAM_ID,
@@ -21054,6 +21173,7 @@ const getSourceExplorerTxUrl = (chain, txID) => {
         case CHAIN_IDS.AGORIC:
         case CHAIN_IDS.XRPL:
         case CHAIN_IDS.XRPL_TESTNET:
+        case CHAIN_IDS.CANTON:
             txSuffix = "/transactions/";
             break;
         case CHAIN_IDS.HEDERA:
@@ -21163,10 +21283,16 @@ const simplifyRouteAction = (action) => {
 };
 const fetchSwapTransactionStatus = async ({ transaction, integratorId, apiUrl, }) => {
     const statusEndpoint = `${apiUrl}/v2/status`;
+    const isCanton = transaction?.fromChain === CHAIN_IDS.CANTON;
+    // For Canton, the backend handles all tx detection/submission from the quoteId
+    // alone, so no transactionId is sent — only the quoteId param below.
+    const transactionId = isCanton
+        ? undefined
+        : (transaction?.transactionIdForStatus ?? transaction?.transactionId);
     try {
         const response = await axios.get(statusEndpoint, {
             params: {
-                transactionId: transaction?.transactionIdForStatus ?? transaction?.transactionId,
+                transactionId,
                 fromChainId: transaction?.fromChain,
                 toChainId: transaction?.toChain,
                 bridgeType: transaction?.bridgeType,
@@ -21213,7 +21339,7 @@ function isActionCompletedOnSourceTx(action, fromChainId) {
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
-const isDepositRoute = (route) => {
+const isChainflipDepositRoute = (route) => {
     return (!!route &&
         route.transactionRequest?.type === SquidDataType.ChainflipDepositAddress);
 };
@@ -21238,6 +21364,12 @@ function isOnChainTxData(squidData) {
         SquidDataType.DepositAddressWithMemo,
     ].includes(squidData.type);
 }
+/**
+ * Checks if a route is of type DepositAddressDirectTransfer
+ */
+function isDepositAddressDirectTransferRoute(squidData) {
+    return squidData.type === SquidDataType.DepositAddressDirectTransfer;
+}
 function getHistoryTransactionId(tx) {
     switch (tx.txType) {
         case HistoryTxType.SWAP:
@@ -21757,7 +21889,17 @@ const chainTypeToTrimLength = {
         start: 4,
         end: 4,
     },
+    // abc...123::abc...123
+    [ChainType.CANTON]: {
+        start: 3,
+        end: 3,
+    },
 };
+const truncateWithEllipsis = (value, startLength, endLength) => value.length <= startLength + endLength
+    ? value
+    : value.slice(0, startLength) +
+        "..." +
+        value.slice(value.length - endLength);
 const formatHash = ({ chainType, hash }) => {
     if (!hash)
         return "";
@@ -21770,14 +21912,15 @@ const formatHash = ({ chainType, hash }) => {
             chainTypeFormat = ChainType.COSMOS;
         }
     }
-    const trimLengthStart = chainTypeToTrimLength[chainTypeFormat].start;
-    const trimLengthEnd = chainTypeToTrimLength[chainTypeFormat].end;
-    // return the same hash if its length is less than the trim length
-    if (hash.length <= trimLengthStart + trimLengthEnd)
-        return hash;
-    return (hash.slice(0, trimLengthStart) +
-        "..." +
-        hash.slice(hash.length - trimLengthEnd, hash.length));
+    const { start, end } = chainTypeToTrimLength[chainTypeFormat];
+    if (chainTypeFormat === ChainType.CANTON &&
+        hash.includes(CANTON_PARTY_ID_SEPARATOR)) {
+        const [namespace, identifier] = hash.split(CANTON_PARTY_ID_SEPARATOR);
+        return (truncateWithEllipsis(namespace, start, end) +
+            CANTON_PARTY_ID_SEPARATOR +
+            truncateWithEllipsis(identifier, start, end));
+    }
+    return truncateWithEllipsis(hash, start, end);
 };
 const isWalletAddressValid = (chainData, address) => {
     if (!address || !chainData?.chainType)
@@ -21797,33 +21940,25 @@ const isWalletAddressValid = (chainData, address) => {
             return isXrplAddressValid(address);
         case ChainType.STELLAR:
             return isStellarAddressValid(address);
+        case ChainType.CANTON:
+            return isCantonAddressValid(address);
     }
 };
 const redirectToExtensionsStore = (wallet) => {
     const { userAgent } = navigator;
     let link;
     if (userAgent.indexOf("Firefox") > -1) {
-        link = wallet.url || walletStoreLinks[wallet.connectorId]?.firefox;
+        link =
+            wallet.links?.firefox || walletStoreLinks[wallet.connectorId]?.firefox;
     }
     else if (userAgent.indexOf("Chrome") > -1) {
-        link = wallet.url || walletStoreLinks[wallet.connectorId]?.chrome;
+        link = wallet.links?.chrome || walletStoreLinks[wallet.connectorId]?.chrome;
     }
+    link = link || wallet.links?.website;
     if (link && link !== "") {
         window?.open(link, "_blank")?.focus();
     }
 };
-/**
- * Dynamically accesses a nested property of an object based on a dot-separated string path.
- * Returns the value of the property if found, otherwise undefined.
- * e.g. "xfi.keplr" will return window.xfi.keplr
- */
-const accessProperty = (object, path) => {
-    const value = get$2(object, path);
-    if (value === undefined) {
-        console.error(`Property "${path}" not found while reading object`, object);
-    }
-    return value;
-};
 const definedInWindow = (path, clientWindow) => {
     if (!path || !clientWindow)
         return false;
@@ -21852,6 +21987,32 @@ const populateWallets = (window, wallets) => {
         return wallet;
     });
 };
+const createUninstalledConnector = () => new Proxy({}, {
+    get(_target, prop) {
+        throw new Error(`Cannot use connector of an uninstalled wallet (accessed "${String(prop)}")`);
+    },
+});
+const buildFallbackWallets = (discovered) => {
+    const fallbackKey = (chainType, connectorId) => `${chainType}:${connectorId}`;
+    const discoveredKeys = new Set(discovered.flatMap((wallet) => wallet.isMultiChain
+        ? wallet.supportedNetworks.map((network) => fallbackKey(network.chainType, wallet.connectorId))
+        : [fallbackKey(wallet.type, wallet.connectorId)]));
+    return fallbackWallets
+        .filter((config) => !discoveredKeys.has(fallbackKey(config.chainType, config.id)))
+        .map((config) => ({
+        name: config.name,
+        connectorId: config.id,
+        connectorName: config.connectorName,
+        icon: config.icon,
+        windowFlag: config.id,
+        links: config.links,
+        isInstalled: () => false,
+        skipInstallCheck: false,
+        isMultiChain: false,
+        type: config.chainType,
+        connector: createUninstalledConnector(),
+    }));
+};
 /**
  * Get the base chain to connect to
  * If only one chain type is selected, use that chain type
@@ -22058,6 +22219,13 @@ const connectByChainType = async (chainType, wallet, defaultChain, params) => {
                     connector,
                 },
             });
+        case ChainType.CANTON:
+            return params.connectCanton.mutateAsync({
+                wallet: {
+                    ...wallet,
+                    connector,
+                },
+            });
     }
 };
 const getChainTypesToConnect = (selectedChainTypes, defaultChain, supportedChains) => {
@@ -22094,6 +22262,7 @@ const connectMultiChainWallet = async (params) => {
                 connectSui: params.connectSui,
                 connectXrpl: params.connectXrpl,
                 connectStellar: params.connectStellar,
+                connectCanton: params.connectCanton,
             });
             if (result) {
                 results.push({
@@ -22127,6 +22296,7 @@ const connectSingleChainWallet = async (params) => {
         connectSui: params.connectSui,
         connectXrpl: params.connectXrpl,
         connectStellar: params.connectStellar,
+        connectCanton: params.connectCanton,
     });
     return result
         ? {
@@ -22917,8 +23087,8 @@ function convertTokenAmountToUSD(tokenAmount, tokenPrice, maxDecimals = 4) {
     if (!tokenAmount || !tokenPrice)
         return "";
     try {
-        const amount = new BigNumber(cleanAmount(tokenAmount));
-        const price = new BigNumber(cleanAmount(tokenPrice));
+        const amount = new BigNumber$1(cleanAmount(tokenAmount));
+        const price = new BigNumber$1(cleanAmount(tokenPrice));
         return amount.multipliedBy(price).decimalPlaces(maxDecimals).toString();
     }
     catch {
@@ -22935,8 +23105,8 @@ function convertTokenAmountToUSD(tokenAmount, tokenPrice, maxDecimals = 4) {
 function convertUSDToTokenAmount(usdAmount, tokenPrice, maxDecimals) {
     if (!usdAmount || !tokenPrice || !maxDecimals)
         return "0";
-    const amount = new BigNumber(cleanAmount(usdAmount));
-    const price = new BigNumber(cleanAmount(tokenPrice));
+    const amount = new BigNumber$1(cleanAmount(usdAmount));
+    const price = new BigNumber$1(cleanAmount(tokenPrice));
     return amount.dividedBy(price).decimalPlaces(maxDecimals).toString();
 }
 const calculateTotal24hChange = (tokensWithBalance, totalUSDAmount) => {
@@ -23040,7 +23210,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;
@@ -23092,7 +23262,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) {
@@ -23132,7 +23302,10 @@ const getNewSwapParamsFromInput = ({ inputParams, initialSwapRoute, tokens, chai
     else {
         newFallbackAddress = fallbackAddress ?? initialSwapRoute?.fallbackAddress;
     }
-    const newDepositRefundAddress = depositRefundAddress || initialSwapRoute?.depositRefundAddress;
+    const sourceChainChanged = fromChainId !== undefined && fromChainId !== initialSwapRoute?.fromChainId;
+    const newDepositRefundAddress = sourceChainChanged
+        ? undefined
+        : depositRefundAddress || initialSwapRoute?.depositRefundAddress;
     return {
         fromChainId: srcChainId,
         fromTokenAddress: sourceTokenAddress,
@@ -23290,11 +23463,11 @@ const groupTokensBySymbol = (tokens, chainType) => {
             };
         }
         groups[groupKey].tokens.push(token);
-        groups[groupKey].totalBalance = new BigNumber$1(groups[groupKey].totalBalance)
+        groups[groupKey].totalBalance = new BigNumber(groups[groupKey].totalBalance)
             .plus(token.balance)
             .toString();
         const tokenUsdValue = convertTokenAmountToUSD(token.balance, token.usdPrice || 0);
-        groups[groupKey].totalBalanceUsd = new BigNumber$1(groups[groupKey].totalBalanceUsd ?? "0")
+        groups[groupKey].totalBalanceUsd = new BigNumber(groups[groupKey].totalBalanceUsd ?? "0")
             .plus(tokenUsdValue)
             .toString();
     });
@@ -23316,11 +23489,11 @@ const groupTokensBySymbol = (tokens, chainType) => {
         else {
             // Combine tokens and sum up total balance for existing groups
             mergedGroups[mergeKey].tokens.push(...group.tokens);
-            mergedGroups[mergeKey].totalBalance = new BigNumber$1(mergedGroups[mergeKey].totalBalance)
+            mergedGroups[mergeKey].totalBalance = new BigNumber(mergedGroups[mergeKey].totalBalance)
                 .plus(group.totalBalance)
                 .toString();
             // Add this line to properly merge USD values
-            mergedGroups[mergeKey].totalBalanceUsd = new BigNumber$1(mergedGroups[mergeKey].totalBalanceUsd ?? "0")
+            mergedGroups[mergeKey].totalBalanceUsd = new BigNumber(mergedGroups[mergeKey].totalBalanceUsd ?? "0")
                 .plus(group.totalBalanceUsd ?? "0")
                 .toString();
         }
@@ -23365,13 +23538,13 @@ const groupTokensByChainId = (tokens, chains) => {
             };
         }
         groups[groupKey].tokens.push(token);
-        groups[groupKey].totalBalance = new BigNumber$1(groups[groupKey].totalBalance)
+        groups[groupKey].totalBalance = new BigNumber(groups[groupKey].totalBalance)
             .plus(token.balance)
             .toString();
         // Only add to USD total if token has a valid price
         if (token.usdPrice && token.usdPrice > 0) {
             const tokenUsdValue = convertTokenAmountToUSD(token.balance, token.usdPrice);
-            groups[groupKey].totalBalanceUsd = new BigNumber$1(groups[groupKey].totalBalanceUsd ?? "0")
+            groups[groupKey].totalBalanceUsd = new BigNumber(groups[groupKey].totalBalanceUsd ?? "0")
                 .plus(tokenUsdValue)
                 .toString();
         }
@@ -23411,7 +23584,7 @@ const filterViewableTokens = (tokens, config, direction) => {
 };
 const getSecretNetworkBalances = async (chainData, cosmosAddress, squidTokens, keplrTypeWallet) => {
     const squidSecretTokens = squidTokens.filter((t) => t.chainId === CHAIN_IDS.SECRET);
-    const { fetchAllSecretBalances } = await import('./secretService-BAK4sBb7.js');
+    const { fetchAllSecretBalances } = await import('./secretService-eiBnD7dI.js');
     return fetchAllSecretBalances(chainData, cosmosAddress, squidSecretTokens, keplrTypeWallet);
 };
 function getTokenAssetsKey(token) {
@@ -23438,9 +23611,29 @@ async function fetchAssetsColors() {
         };
     }
 }
-function initializeSquidWithAssetsColors(squid, assetsColors) {
-    const evmosChainIds = squid.chains.filter(isEvmosChain).map((c) => c.chainId);
-    squid.tokens = squid.tokens.map((token) => {
+const supportedChainTypes = new Set(Object.values(ChainType));
+function isSupportedChainType(chainType) {
+    return supportedChainTypes.has(chainType);
+}
+/**
+ * Normalizes SDK data after each init/refetch before the rest of hooks consumes it.
+ *
+ * - Removes chains whose chainType is not supported by the local package.
+ * - Drops tokens for those removed chains.
+ * - Converts Evmos chains/tokens to EVM.
+ * - Applies optional asset colors.
+ */
+function initializeSquidData(squid, assetsColors = {
+    chains: {},
+    tokens: {},
+}) {
+    const supportedChains = squid.chains.filter((chain) => isSupportedChainType(chain.chainType));
+    const supportedChainIds = new Set(supportedChains.map((chain) => chain.chainId));
+    const evmosChainIds = supportedChains
+        .filter(isEvmosChain)
+        .map((c) => c.chainId);
+    const supportedTokens = squid.tokens.filter((token) => supportedChainIds.has(token.chainId));
+    squid.tokens = supportedTokens.map((token) => {
         const isEvmosToken = evmosChainIds.includes(token.chainId);
         return {
             ...token,
@@ -23449,7 +23642,7 @@ function initializeSquidWithAssetsColors(squid, assetsColors) {
             textColor: assetsColors.tokens[getTokenAssetsKey(token)]?.textColor,
         };
     });
-    squid.chains = squid.chains.map((chain) => {
+    squid.chains = supportedChains.map((chain) => {
         const bgColor = assetsColors.chains[chain.chainId]?.bgColor;
         // convert evmos cosmos chains to evm chains
         // TODO: this will be fixed in the backend
@@ -25102,7 +25295,7 @@ class OnrampService {
         });
         return data;
     }
-    async getConfiguration({ chains, tokens, }) {
+    async getConfiguration({ tokens, }) {
         const { data } = await axios.get(`${this.baseUrl}/config`);
         // Filter supportedCryptos to only include tokens that match our provided tokens
         const filteredCryptos = data.supportedCryptos.filter((supportedCrypto) => tokens.some((token) => token.address.toLowerCase() ===
@@ -25326,7 +25519,7 @@ const useSquid = () => {
         queryFn: async () => {
             if (squid) {
                 await squid?.init();
-                initializeSquidWithAssetsColors(squid, assetsColors);
+                initializeSquidData(squid, assetsColors);
                 return squid;
             }
             return null;
@@ -25385,7 +25578,7 @@ const useSquidTokens = (direction) => {
         config.availableChains,
         direction,
     ]);
-    const { evmTokens, cosmosTokens, solanaTokens, bitcoinTokens, suiTokens, xrplTokens, stellarTokens, } = useMemo(() => {
+    const { evmTokens, cosmosTokens, solanaTokens, bitcoinTokens, suiTokens, xrplTokens, stellarTokens, cantonTokens, } = useMemo(() => {
         return tokens?.reduce((acc, token) => {
             switch (token.type) {
                 case ChainType.EVM:
@@ -25409,6 +25602,9 @@ const useSquidTokens = (direction) => {
                 case ChainType.STELLAR:
                     acc.stellarTokens.push(token);
                     break;
+                case ChainType.CANTON:
+                    acc.cantonTokens.push(token);
+                    break;
             }
             return acc;
         }, {
@@ -25419,6 +25615,7 @@ const useSquidTokens = (direction) => {
             suiTokens: [],
             xrplTokens: [],
             stellarTokens: [],
+            cantonTokens: [],
         });
     }, [tokens]);
     const findToken = useCallback((address, chainId) => {
@@ -25436,6 +25633,7 @@ const useSquidTokens = (direction) => {
         suiTokens,
         xrplTokens,
         stellarTokens,
+        cantonTokens,
     };
 };
 
@@ -25536,12 +25734,10 @@ const useGetFiatQuote = ({ fiatCurrency, cryptoCurrencyID, amount, region, payme
  */
 const useGetOnRampConfig = () => {
     const service = useMemo(() => new OnrampService(), []);
-    const { chains } = useSquidChains();
     const { tokens } = useSquidTokens();
     return useQuery({
         queryKey: keys().fiatToCryptoConfig(),
         queryFn: () => service.getConfiguration({
-            chains,
             tokens,
         }),
         cacheTime: 1000 * 60 * 60,
@@ -25973,6 +26169,7 @@ const chainTypeToRefetchInterval = {
     [ChainType.SUI]: 1_000,
     [ChainType.XRPL]: 1_000,
     [ChainType.STELLAR]: 1_000,
+    [ChainType.CANTON]: 1_000,
 };
 /**
  * Returns the status refetch interval of a Send transaction
@@ -26239,7 +26436,7 @@ const useSquidChains = (direction) => {
         const chain = findChain(chainId);
         return chain?.chainType;
     }, [findChain]);
-    const { evmChains, cosmosChains, suiChains, stellarChains, xrplChains } = useMemo(() => {
+    const { evmChains, cosmosChains, suiChains, stellarChains, xrplChains, cantonChains, } = useMemo(() => {
         return chains.reduce((acc, chain) => {
             switch (chain.chainType) {
                 case ChainType.EVM:
@@ -26257,6 +26454,9 @@ const useSquidChains = (direction) => {
                 case ChainType.STELLAR:
                     acc.stellarChains.push(chain);
                     break;
+                case ChainType.CANTON:
+                    acc.cantonChains.push(chain);
+                    break;
             }
             return acc;
         }, {
@@ -26265,6 +26465,7 @@ const useSquidChains = (direction) => {
             suiChains: [],
             xrplChains: [],
             stellarChains: [],
+            cantonChains: [],
         });
     }, [chains]);
     const { supportedSourceChains, supportedDestinationChains } = useMemo(() => {
@@ -26285,6 +26486,7 @@ const useSquidChains = (direction) => {
         suiChains,
         xrplChains,
         stellarChains,
+        cantonChains,
         getChainType,
         findChain,
     };
@@ -26598,6 +26800,253 @@ const useBitcoinContext = () => {
     return context;
 };
 
+const REQUEST_TIMEOUT_MS = 60_000;
+function pickAddress(accounts) {
+    return (accounts.find((a) => a.primary) ?? accounts[0])?.partyId;
+}
+/**
+ * Browser-extension Canton connector: wraps one discovered CIP-103 provider
+ * (bound to its announce `target`) and exposes the lifecycle methods.
+ */
+class CantonBrowserConnector {
+    providerId;
+    name;
+    target;
+    client;
+    listeners = { connect: new Set(), disconnect: new Set() };
+    _accounts = [];
+    constructor(provider, win = window) {
+        this.providerId = provider.id;
+        this.name = provider.name;
+        this.target = provider.target ?? provider.id;
+        this.client = createCantonClient(new WindowTransport(win, {
+            target: this.target,
+            timeout: REQUEST_TIMEOUT_MS,
+        }));
+    }
+    get accounts() {
+        return this._accounts;
+    }
+    get address() {
+        return pickAddress(this._accounts);
+    }
+    async connect() {
+        await this.client.connect();
+        const result = await this.refreshAccounts();
+        this.emit("connect", result.address);
+        return result;
+    }
+    /** Silent connect: read accounts without prompting; throws if not connected. */
+    async autoConnect() {
+        const accounts = await this.client.listAccounts();
+        if (!accounts.length) {
+            throw new Error("Canton wallet not connected");
+        }
+        this._accounts = accounts;
+        const address = pickAddress(accounts);
+        this.emit("connect", address);
+        return { address, accounts };
+    }
+    async disconnect() {
+        try {
+            await this.client.disconnect();
+        }
+        finally {
+            this._accounts = [];
+            this.emit("disconnect");
+        }
+    }
+    async ledgerApi(params) {
+        const result = await this.client.ledgerApi(params);
+        return result;
+    }
+    async prepareExecuteAndWait(params) {
+        return this.client.prepareExecuteAndWait(params);
+    }
+    async getAccounts() {
+        this._accounts = await this.client.listAccounts();
+        return this._accounts;
+    }
+    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));
+    }
+    async refreshAccounts() {
+        const accounts = await this.client.listAccounts();
+        this._accounts = accounts;
+        const address = pickAddress(accounts);
+        if (!address) {
+            throw new Error("Canton wallet returned no accounts");
+        }
+        return { address, accounts };
+    }
+}
+
+const CANTON_REQUEST_PROVIDER_EVENT = "canton:requestProvider";
+const CANTON_ANNOUNCE_PROVIDER_EVENT = "canton:announceProvider";
+const DEFAULT_DISCOVERY_TIMEOUT_MS = 300;
+/**
+ * CIP-103 browser-wallet discovery (EIP-6963-style).
+ * The wallet dispatches `canton:announceProvider` and dApps
+ * dispatch `canton:requestProvider` to ask installed wallets to re-announce.
+ * Each announcement carries a `target` we route through Sigilry's `WindowTransport`,
+ * so multiple extensions coexist without contending on the `window.canton` global.
+ */
+async function discoverCantonProviders(timeoutMs = DEFAULT_DISCOVERY_TIMEOUT_MS, win = window) {
+    if (typeof win === "undefined")
+        return [];
+    const discovered = new Map();
+    const handler = (event) => {
+        const detail = event.detail;
+        if (!detail?.id || !detail.name || discovered.has(detail.id))
+            return;
+        discovered.set(detail.id, {
+            id: detail.id,
+            name: detail.name,
+            icon: detail.icon,
+            target: detail.target ?? detail.id,
+        });
+    };
+    win.addEventListener(CANTON_ANNOUNCE_PROVIDER_EVENT, handler);
+    try {
+        win.dispatchEvent(new CustomEvent(CANTON_REQUEST_PROVIDER_EVENT, { detail: {} }));
+        await new Promise((resolve) => setTimeout(resolve, timeoutMs));
+    }
+    finally {
+        win.removeEventListener(CANTON_ANNOUNCE_PROVIDER_EVENT, handler);
+    }
+    return Array.from(discovered.values());
+}
+
+/**
+ * Discovers Canton browser-extension wallets via the CIP-103 announce protocol
+ * (on mount and on window focus) and maps each to a {@link CantonWallet}.
+ */
+function useCantonWallets() {
+    const [wallets, setWallets] = useState([]);
+    const connectorCache = useRef(new Map());
+    const toWallet = useCallback((provider) => {
+        let connector = connectorCache.current.get(provider.id);
+        if (!connector) {
+            connector = new CantonBrowserConnector(provider);
+            connectorCache.current.set(provider.id, connector);
+        }
+        return {
+            name: provider.name,
+            connectorId: provider.id,
+            connectorName: provider.name,
+            icon: provider.icon,
+            windowFlag: provider.id,
+            skipInstallCheck: true,
+            isInstalled: () => true,
+            isMultiChain: false,
+            type: ChainType.CANTON,
+            connector,
+        };
+    }, []);
+    const refresh = useCallback(async () => {
+        if (typeof window === "undefined")
+            return;
+        const providers = await discoverCantonProviders();
+        setWallets(providers.map(toWallet));
+    }, [toWallet]);
+    useEffect(() => {
+        refresh();
+        if (typeof window === "undefined")
+            return;
+        const onFocus = () => refresh();
+        window.addEventListener("focus", onFocus);
+        return () => window.removeEventListener("focus", onFocus);
+    }, [refresh]);
+    return { wallets };
+}
+
+function useCanton() {
+    const disconnectWallet = useWalletStore((store) => store.disconnectWallet);
+    const setConnectedWallet = useWalletStore((store) => store.setConnectedWallet);
+    const { wallets } = useCantonWallets();
+    const connectedCantonWallet = useWalletStore((store) => store.connectedWalletsByChainType[ChainType.CANTON]);
+    const recentCantonWalletId = useWalletStore((store) => store.recentConnectorIds[ChainType.CANTON]);
+    const connectCanton = useMutation(async ({ wallet, }) => {
+        let result;
+        try {
+            // Try to reconnect silently first (existing session, no popup)
+            result = await wallet.connector.autoConnect();
+        }
+        catch {
+            // Otherwise prompt the wallet to connect
+            result = await wallet.connector.connect();
+        }
+        return {
+            wallet,
+            address: result.address,
+        };
+    });
+    const disconnectCanton = useCallback(async () => {
+        await connectedCantonWallet.wallet?.connector.disconnect();
+    }, [connectedCantonWallet.wallet?.connector]);
+    const autoConnectCanton = useCallback(async () => {
+        const recentCantonWallet = wallets.find((w) => w.connectorId === recentCantonWalletId);
+        if (!recentCantonWallet) {
+            return;
+        }
+        const { address } = await recentCantonWallet.connector.autoConnect();
+        setConnectedWallet(ChainType.CANTON, {
+            wallet: recentCantonWallet,
+            address,
+        });
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [wallets.map((w) => w.connectorId), recentCantonWalletId]);
+    useEffect(() => {
+        const wallet = connectedCantonWallet.wallet;
+        if (!wallet) {
+            return;
+        }
+        function onConnect(newAddress) {
+            if (wallet) {
+                setConnectedWallet(ChainType.CANTON, {
+                    wallet,
+                    address: newAddress,
+                });
+            }
+        }
+        function onDisconnect() {
+            disconnectWallet(ChainType.CANTON);
+        }
+        wallet.connector.on("connect", onConnect);
+        wallet.connector.on("disconnect", onDisconnect);
+        return () => {
+            wallet.connector.off("connect", onConnect);
+            wallet.connector.off("disconnect", onDisconnect);
+        };
+    }, [disconnectWallet, setConnectedWallet, connectedCantonWallet.wallet]);
+    return {
+        connectCanton,
+        disconnectCanton,
+        autoConnectCanton,
+        signer: connectedCantonWallet.wallet?.connector,
+        wallets,
+    };
+}
+
+const CantonContext = createContext(undefined);
+const CantonProvider = ({ children, }) => {
+    const cantonHook = useCanton();
+    return (React.createElement(CantonContext.Provider, { value: cantonHook }, children));
+};
+const useCantonContext = () => {
+    const context = useContext(CantonContext);
+    if (!context) {
+        throw new Error("useCantonContext must be used within a CantonProvider");
+    }
+    return context;
+};
+
 function useEvmWallets() {
     const connectors = useConnectors();
     const wallets = useMemo(() => {
@@ -26809,7 +27258,7 @@ function useStellarWallets() {
             try {
                 const { allowAllModules: initializeAllModules } = await import('@creit.tech/stellar-wallets-kit');
                 const { LedgerModule } = await import('@creit.tech/stellar-wallets-kit/modules/ledger.module.mjs');
-                const { formatStellarWallet } = await import('./stellarService.client-DkJ6WAdl.js');
+                const { formatStellarWallet } = await import('./stellarService.client-VOmCOPzL.js');
                 const modules = [...initializeAllModules(), new LedgerModule()];
                 const promises = modules.map(async (module) => {
                     const isAvailable = await module.isAvailable();
@@ -27282,17 +27731,24 @@ const useWallets = () => {
     const { wallets: suiWallets } = useSuiContext();
     const { wallets: xrplWallets } = useXrplContext();
     const { wallets: stellarWallets } = useStellarContext();
+    const { wallets: cantonWallets } = useCantonContext();
     const wallets = useMemo(() => {
         const singleChainWallets$1 = populateWallets(clientWindow, singleChainWallets);
         const multiChainWallets$1 = populateWallets(clientWindow, multiChainWallets);
+        const discoveredWallets = [
+            ...evmWallets,
+            ...solanaWallets,
+            ...suiWallets,
+            ...cantonWallets,
+        ];
+        const fallbackWallets = buildFallbackWallets(discoveredWallets);
         return mergeWallets({
             singleChainWallets: [
                 ...singleChainWallets$1,
-                ...evmWallets,
-                ...solanaWallets,
-                ...suiWallets,
+                ...discoveredWallets,
                 ...xrplWallets,
                 ...stellarWallets,
+                ...fallbackWallets,
             ],
             multiChainWallets: multiChainWallets$1,
         });
@@ -27303,6 +27759,7 @@ const useWallets = () => {
         suiWallets,
         xrplWallets,
         stellarWallets,
+        cantonWallets,
     ]);
     return {
         wallets,
@@ -27318,6 +27775,7 @@ const useWallet = () => {
     const { connectSui, disconnectSui } = useSuiContext();
     const { connectXrpl, disconnectXrpl } = useXrplContext();
     const { connectStellar, disconnectStellar } = useStellarContext();
+    const { connectCanton, disconnectCanton } = useCantonContext();
     const { findChain } = useSquidChains();
     const { isGnosisConnected, gnosisAddress } = useGnosisContext();
     const destinationAddress = useSwapRoutePersistStore((state) => state.swapRoute?.destinationAddress);
@@ -27354,6 +27812,7 @@ const useWallet = () => {
                     connectSui,
                     connectXrpl,
                     connectStellar,
+                    connectCanton,
                     selectedChainTypes,
                     findChain,
                 });
@@ -27402,6 +27861,9 @@ const useWallet = () => {
                 case ChainType.STELLAR:
                     await disconnectStellar();
                     break;
+                case ChainType.CANTON:
+                    await disconnectCanton();
+                    break;
                 default:
                     // TODO: Implement disconnect for other chains
                     break;
@@ -27508,6 +27970,7 @@ const useMultiChainWallet = (chain) => {
     const suiAddress = connectedAddresses[ChainType.SUI];
     const xrplAddress = connectedAddresses[ChainType.XRPL];
     const stellarAddress = connectedAddresses[ChainType.STELLAR];
+    const cantonAddress = connectedAddresses[ChainType.CANTON];
     // Cosmos is a special case because the address changes on every chain
     // so we can't use the default cosmos connected address
     const { data: cosmosAddress } = useCosmosForChain(chain);
@@ -27595,6 +28058,16 @@ const useMultiChainWallet = (chain) => {
                         chainType: chain.chainType,
                     }),
                 };
+            case ChainType.CANTON:
+                if (!cantonAddress)
+                    return {};
+                return {
+                    address: cantonAddress,
+                    formatted: formatHash({
+                        hash: cantonAddress,
+                        chainType: chain.chainType,
+                    }),
+                };
         }
     }, [
         chain?.chainType,
@@ -27606,6 +28079,7 @@ const useMultiChainWallet = (chain) => {
         suiAddress,
         xrplAddress,
         stellarAddress,
+        cantonAddress,
     ]);
     /**
      * Change current network for desired chain
@@ -28430,6 +28904,8 @@ async function createClient(chain) {
             return new XrplRpcClient(chain.rpc);
         case ChainType.STELLAR:
             return new StellarRpcClient(chain.rpc);
+        case ChainType.CANTON:
+            return null;
     }
 }
 
@@ -29442,6 +29918,54 @@ const getAllStellarTokensBalance = async (userAddress, stellarTokens, stellarCha
     const allResults = await Promise.all(stellarChains.map(getBalancesForChain));
     return allResults.flat();
 };
+/**
+ * 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
+ * only for that wallet's party — there's no address-only read.
+ */
+const getCantonTokenBalance = async (userAddress, token, cantonConnector) => {
+    if (!token.originalAddress)
+        return "0";
+    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);
+    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`.
+ */
+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);
+    return tokens.map((token) => {
+        const instrument = token.originalAddress
+            ? parseCantonInstrument(token.originalAddress)
+            : null;
+        return {
+            ...token,
+            balance: instrument
+                ? grouped[cantonInstrumentKey(instrument)] ?? "0"
+                : "0",
+        };
+    });
+}
 /**
  * Returns a promise that resolves when the given promise resolves or after the given timeout
  * @param ms - timeout in milliseconds
@@ -29626,9 +30150,29 @@ const useStellarBalance = ({ userAddress, chain, enabled, token, refreshInterval
     });
     return { balance, isLoading };
 };
+const useCantonBalance = ({ chain, token, userAddress, enabled = true, refreshIntervalMs = DEFAULT_REFRESH_INTERVAL_MS$1, }) => {
+    const cantonConnector = useWalletStore((store) => store.connectedWalletsByChainType[ChainType.CANTON]?.wallet?.connector);
+    const { data: balance = "0", isLoading } = useQuery({
+        queryKey: keys().balance(chain?.chainId, token?.address, userAddress),
+        queryFn: async () => {
+            if (!cantonConnector || !userAddress || !token)
+                return "0";
+            return getCantonTokenBalance(userAddress, token, cantonConnector);
+        },
+        enabled: enabled &&
+            !!cantonConnector &&
+            !!userAddress &&
+            !!token &&
+            chain?.chainType === ChainType.CANTON &&
+            isCantonAddressValid(userAddress),
+        refetchInterval: refreshIntervalMs,
+        retry: 2,
+    });
+    return { balance, isLoading };
+};
 
 function useNativeTokenForChain(chain) {
-    const { evmTokens, cosmosTokens, solanaTokens, bitcoinTokens, suiTokens, xrplTokens, stellarTokens, } = useSquidTokens();
+    const { evmTokens, cosmosTokens, solanaTokens, bitcoinTokens, suiTokens, xrplTokens, stellarTokens, cantonTokens, } = useSquidTokens();
     const getTokensForChainType = () => {
         if (!chain?.chainType)
             return [];
@@ -29647,6 +30191,8 @@ function useNativeTokenForChain(chain) {
                 return xrplTokens;
             case ChainType.STELLAR:
                 return stellarTokens;
+            case ChainType.CANTON:
+                return cantonTokens;
         }
     };
     const nativeTokenForChainType = useMemo(() => {
@@ -29828,6 +30374,24 @@ const useStellarNativeBalance = ({ address, chain, }) => {
         isLoading,
     };
 };
+const useCantonNativeBalance = ({ address, chain, }) => {
+    const { nativeToken } = useNativeTokenForChain(chain);
+    const { balance: rawBalance, isLoading } = useCantonBalance({
+        chain,
+        token: nativeToken,
+        userAddress: address,
+        enabled: chain?.chainType === ChainType.CANTON,
+    });
+    const balance = useMemo(() => {
+        if (nativeToken?.decimals && rawBalance) {
+            return {
+                decimals: nativeToken.decimals,
+                value: parseToBigInt(rawBalance, nativeToken.decimals),
+            };
+        }
+    }, [nativeToken?.decimals, rawBalance]);
+    return { balance, isLoading };
+};
 const useNativeBalance = (chain) => {
     const { connectedAddresses } = useWallet();
     const { data: cosmosAddressForChain } = useCosmosForChain(chain);
@@ -29858,6 +30422,10 @@ const useNativeBalance = (chain) => {
         address: connectedAddresses[ChainType.STELLAR],
         chain,
     });
+    const { balance: nativeCantonBalance, isLoading: isCantonLoading } = useCantonNativeBalance({
+        address: connectedAddresses[ChainType.CANTON],
+        chain,
+    });
     const { nativeBalance, nativeBalanceFormatted } = useMemo(() => {
         let balance;
         switch (chain?.chainType) {
@@ -29881,6 +30449,10 @@ const useNativeBalance = (chain) => {
                 break;
             case ChainType.STELLAR:
                 balance = nativeStellarBalance;
+                break;
+            case ChainType.CANTON:
+                balance = nativeCantonBalance;
+                break;
         }
         const balanceFormatted = !!balance
             ? formatBNToReadable(balance.value, balance.decimals)
@@ -29898,6 +30470,7 @@ const useNativeBalance = (chain) => {
         nativeSuiBalance,
         nativeXrplBalance,
         nativeStellarBalance,
+        nativeCantonBalance,
     ]);
     const isLoading = useMemo(() => {
         if (!chain?.chainType)
@@ -29917,6 +30490,8 @@ const useNativeBalance = (chain) => {
                 return isXrpLoading;
             case ChainType.STELLAR:
                 return isStellarLoading;
+            case ChainType.CANTON:
+                return isCantonLoading;
         }
     }, [
         chain?.chainType,
@@ -29927,6 +30502,7 @@ const useNativeBalance = (chain) => {
         isSuiLoading,
         isXrpLoading,
         isStellarLoading,
+        isCantonLoading,
     ]);
     return { nativeBalance, nativeBalanceFormatted, isLoading };
 };
@@ -30141,7 +30717,7 @@ function hederaWalletConnect(parameters) {
                 const optionalChains = config.chains.map((x) => x.id);
                 if (!optionalChains.length)
                     return;
-                const { EthereumProvider } = await import('./index.es-Bot12hgd.js');
+                const { EthereumProvider } = await import('./index.es-DwtZr7bN.js');
                 const rawProvider = await EthereumProvider.init({
                     ...restParameters,
                     disableProviderPing: true,
@@ -30346,6 +30922,7 @@ const useSigner = ({ chain }) => {
     const { signer: suiSigner } = useSuiContext();
     const { signer: xrplSigner } = useXrplContext();
     const { signer: stellarSigner } = useStellarContext();
+    const { signer: cantonSigner } = useCantonContext();
     const isEvmSignerReady = !!evmSigner;
     const isSolanaSignerReady = !!solanaSigner;
     const isCosmosSignerReady = !!cosmosSigner;
@@ -30353,6 +30930,7 @@ const useSigner = ({ chain }) => {
     const isSuiSignerReady = !!suiSigner;
     const isXrplSignerReady = !!xrplSigner;
     const isStellarSignerReady = !!stellarSigner;
+    const isCantonSignerReady = !!cantonSigner;
     const isSignerReady = useMemo(() => {
         if (!chain?.chainType)
             return false;
@@ -30371,6 +30949,8 @@ const useSigner = ({ chain }) => {
                 return isXrplSignerReady;
             case ChainType.STELLAR:
                 return isStellarSignerReady;
+            case ChainType.CANTON:
+                return isCantonSignerReady;
         }
     }, [
         chain?.chainType,
@@ -30381,6 +30961,7 @@ const useSigner = ({ chain }) => {
         isSuiSignerReady,
         isXrplSignerReady,
         isStellarSignerReady,
+        isCantonSignerReady,
     ]);
     return {
         isSignerReady,
@@ -30391,6 +30972,7 @@ const useSigner = ({ chain }) => {
         suiSigner,
         xrplSigner,
         stellarSigner,
+        cantonSigner,
     };
 };
 
@@ -30726,10 +31308,10 @@ function useStellarTrustLine({ address, chain, token, amount }) {
             if (!amount) {
                 throw new Error("Amount is required");
             }
-            const limitBn = BigNumber$1(trustLineQuery.data?.limit || "0");
-            const balanceBn = BigNumber$1(trustLineQuery.data?.balance || "0");
+            const limitBn = BigNumber(trustLineQuery.data?.limit || "0");
+            const balanceBn = BigNumber(trustLineQuery.data?.balance || "0");
             const availableAllowanceBn = limitBn.minus(balanceBn);
-            const amountBn = BigNumber$1(formatBNToReadable(amount, token.decimals));
+            const amountBn = BigNumber(formatBNToReadable(amount, token.decimals));
             return availableAllowanceBn.gte(amountBn);
         },
         enabled: !!address &&
@@ -30820,21 +31402,21 @@ const useSendTransactionStore = create((set, get) => ({
 
 const useDepositAddressStore = create((set) => ({
     deposit: null,
-    isEnabled: false,
+    selectedPaymentMethod: "connectedWallet",
     setDeposit: (data) => {
         set({ deposit: data });
     },
-    toggleDepositFlow: (enabled) => {
-        set({ isEnabled: enabled });
+    setPaymentMethod: (method) => {
+        set({ selectedPaymentMethod: method });
     },
 }));
 
 function useDepositAddress(squidRoute) {
-    const { isEnabled, depositAddress } = useDepositAddressStore((state) => ({
-        isEnabled: state.isEnabled,
+    const { selectedPaymentMethod, depositAddress } = useDepositAddressStore((state) => ({
+        selectedPaymentMethod: state.selectedPaymentMethod,
         depositAddress: state.deposit?.depositAddress,
     }));
-    const { setDeposit, toggleDepositFlow, deposit } = useDepositAddressStore();
+    const { setDeposit, setPaymentMethod, deposit } = useDepositAddressStore();
     const { squid } = useSquidStore();
     const { fromChain } = useSwap();
     const isAvailableAsPaymentMethod = useMemo(() => {
@@ -30843,41 +31425,55 @@ function useDepositAddress(squidRoute) {
         const chainsSupportingDepositAddress = [
             CHAIN_IDS.BITCOIN,
             CHAIN_IDS.SOLANA,
+            CHAIN_IDS.CANTON,
         ];
         return chainsSupportingDepositAddress.includes(fromChain.chainId);
     }, [fromChain?.chainId]);
-    const swapWillGenerateDepositAddress = useMemo(() => {
-        return (squidRoute?.transactionRequest?.type ===
-            SquidDataType.ChainflipDepositAddress);
-    }, [squidRoute?.transactionRequest?.type]);
-    const enable = useCallback(() => {
-        toggleDepositFlow(true);
-    }, [toggleDepositFlow]);
-    const disable = useCallback(() => {
-        toggleDepositFlow(false);
-    }, [toggleDepositFlow]);
+    const routeProvidesDirectDepositAddress = !!squidRoute?.transactionRequest &&
+        isDepositAddressDirectTransferRoute(squidRoute.transactionRequest);
+    const swapWillGenerateDepositAddress = isChainflipDepositRoute(squidRoute) || routeProvidesDirectDepositAddress;
+    const paymentMethod = isAvailableAsPaymentMethod
+        ? selectedPaymentMethod
+        : "connectedWallet";
+    const routeSupportsDepositAddress = !squidRoute?.transactionRequest || swapWillGenerateDepositAddress;
+    const isDepositAddressActive = paymentMethod === "depositAddress" && routeSupportsDepositAddress;
     const closeDepositChannel = useCallback(() => {
-        toggleDepositFlow(false);
         setDeposit(null);
-    }, [toggleDepositFlow, setDeposit]);
+    }, [setDeposit]);
     const getRouteWithDeposit = useMutation(async ({ route }) => {
-        if (!squid)
-            throw new Error("Squid SDK not initialized");
-        const depositAddressResponse = (await squid.executeRoute({
-            signer: {},
-            route,
-        }));
-        setDeposit(depositAddressResponse);
-        return {
-            depositAddress: depositAddressResponse,
-        };
+        if (!squid || !route.transactionRequest) {
+            throw new Error("Missing required params");
+        }
+        if (isChainflipDepositRoute(route)) {
+            const depositAddressResponse = (await squid.executeRoute({
+                signer: {},
+                route,
+            }));
+            setDeposit({
+                amount: depositAddressResponse.amount,
+                depositAddress: depositAddressResponse.depositAddress,
+                statusTrackingId: depositAddressResponse.chainflipStatusTrackingId,
+            });
+            return;
+        }
+        else if (isDepositAddressDirectTransferRoute(route.transactionRequest)) {
+            // Canton case
+            const orderHash = route.transactionRequest.data;
+            setDeposit({
+                amount: route.params.fromAmount ?? "",
+                depositAddress: route.transactionRequest.target,
+                statusTrackingId: orderHash,
+                memo: orderHash,
+            });
+            return;
+        }
     });
     return {
-        isEnabled,
+        paymentMethod,
+        isDepositAddressActive,
         isAvailableAsPaymentMethod,
         swapWillGenerateDepositAddress,
-        enable,
-        disable,
+        setPaymentMethod,
         getRouteWithDeposit,
         depositAddress,
         closeDepositChannel,
@@ -30909,8 +31505,9 @@ const useUrlSwapParams = () => {
 
 const useAllTokensWithBalanceForChainType = ({ chainType, address, direction, queryOptions, }) => {
     const { evmChains, cosmosChains, suiChains, xrplChains, stellarChains } = useSquidChains(direction);
-    const { evmTokens, cosmosTokens, solanaTokens, bitcoinTokens, suiTokens, xrplTokens, stellarTokens, } = useSquidTokens(direction);
+    const { evmTokens, cosmosTokens, solanaTokens, bitcoinTokens, suiTokens, xrplTokens, stellarTokens, cantonTokens, } = useSquidTokens(direction);
     const { keplrTypeWallet } = useCosmosContext();
+    const cantonConnector = useWalletStore((store) => store.connectedWalletsByChainType[ChainType.CANTON]?.wallet?.connector);
     const placeholderData = useMemo(() => {
         const tokens = {
             [ChainType.EVM]: evmTokens.map((t) => ({ ...t, balance: "0" })),
@@ -30920,6 +31517,7 @@ const useAllTokensWithBalanceForChainType = ({ chainType, address, direction, qu
             [ChainType.SUI]: suiTokens.map((t) => ({ ...t, balance: "0" })),
             [ChainType.XRPL]: xrplTokens.map((t) => ({ ...t, balance: "0" })),
             [ChainType.STELLAR]: stellarTokens.map((t) => ({ ...t, balance: "0" })),
+            [ChainType.CANTON]: cantonTokens.map((t) => ({ ...t, balance: "0" })),
         };
         if (!chainType) {
             // Return all tokens with zero balance
@@ -30941,6 +31539,7 @@ const useAllTokensWithBalanceForChainType = ({ chainType, address, direction, qu
         suiTokens,
         xrplTokens,
         stellarTokens,
+        cantonTokens,
     ]);
     const isQueryEnabled = useMemo(() => {
         // Respect the queryOptions.enabled override if provided
@@ -30963,6 +31562,8 @@ const useAllTokensWithBalanceForChainType = ({ chainType, address, direction, qu
                 return xrplTokens.length > 0;
             case ChainType.STELLAR:
                 return stellarTokens.length > 0;
+            case ChainType.CANTON:
+                return cantonTokens.length > 0;
         }
     }, [
         chainType,
@@ -30975,6 +31576,7 @@ const useAllTokensWithBalanceForChainType = ({ chainType, address, direction, qu
         suiTokens.length,
         xrplTokens.length,
         stellarTokens.length,
+        cantonTokens.length,
     ]);
     const query = useQuery(keys().allTokensBalance(address, chainType, direction), async () => {
         // Return zero balances if no address
@@ -31014,6 +31616,15 @@ const useAllTokensWithBalanceForChainType = ({ chainType, address, direction, qu
             case ChainType.STELLAR:
                 fetchedTokens = await getAllStellarTokensBalance(address, stellarTokens, stellarChains);
                 break;
+            case ChainType.CANTON:
+                fetchedTokens = cantonConnector
+                    ? await getAllCantonTokensBalance({
+                        connector: cantonConnector,
+                        partyId: address,
+                        tokens: cantonTokens,
+                    })
+                    : placeholderData.tokens;
+                break;
             default:
                 fetchedTokens = placeholderData.tokens;
                 break;
@@ -31084,6 +31695,12 @@ const useAllConnectedWalletBalances = ({ direction, queryOptions = {
         direction,
         queryOptions,
     });
+    const cantonBalancesQuery = useAllTokensWithBalanceForChainType({
+        chainType: ChainType.CANTON,
+        address: connectedAddresses?.[ChainType.CANTON],
+        direction,
+        queryOptions,
+    });
     // Create a map of chain type to balance query results
     const balanceQueries = useMemo(() => ({
         [ChainType.EVM]: evmBalancesQuery,
@@ -31093,6 +31710,7 @@ const useAllConnectedWalletBalances = ({ direction, queryOptions = {
         [ChainType.SUI]: suiBalancesQuery,
         [ChainType.XRPL]: xrplBalancesQuery,
         [ChainType.STELLAR]: stellarBalancesQuery,
+        [ChainType.CANTON]: cantonBalancesQuery,
     }), [
         evmBalancesQuery,
         cosmosBalancesQuery,
@@ -31101,6 +31719,7 @@ const useAllConnectedWalletBalances = ({ direction, queryOptions = {
         suiBalancesQuery,
         xrplBalancesQuery,
         stellarBalancesQuery,
+        cantonBalancesQuery,
     ]);
     // Combine all tokens from different chains
     const allTokens = useMemo(() => Object.values(balanceQueries).flatMap((query) => query.data?.tokens ?? []), [balanceQueries]);
@@ -31111,9 +31730,9 @@ const useAllConnectedWalletBalances = ({ direction, queryOptions = {
             const balanceStr = query?.data?.totalUsdBalance;
             if (!balanceStr)
                 return total;
-            const balance = new BigNumber$1(balanceStr);
+            const balance = new BigNumber(balanceStr);
             return balance.isFinite() ? total.plus(balance) : total;
-        }, new BigNumber$1(0))
+        }, new BigNumber(0))
             .toString();
     }, [balanceQueries]);
     // Aggregate loading states
@@ -31182,6 +31801,12 @@ const useMultiChainBalance = ({ chain, token, userAddress, enabled = true, }) =>
         userAddress,
         enabled: chain?.chainType === ChainType.STELLAR && enabled,
     });
+    const { balance: cantonBalance } = useCantonBalance({
+        chain,
+        token,
+        userAddress,
+        enabled: chain?.chainType === ChainType.CANTON && enabled,
+    });
     const balance = useMemo(() => {
         if (!chain?.chainType)
             return "0";
@@ -31200,6 +31825,8 @@ const useMultiChainBalance = ({ chain, token, userAddress, enabled = true, }) =>
                 return xrplBalance;
             case ChainType.STELLAR:
                 return stellarBalance;
+            case ChainType.CANTON:
+                return cantonBalance;
         }
     }, [
         chain?.chainType,
@@ -31210,6 +31837,7 @@ const useMultiChainBalance = ({ chain, token, userAddress, enabled = true, }) =>
         suiBalance,
         xrplBalance,
         stellarBalance,
+        cantonBalance,
     ]);
     return { balance };
 };
@@ -31679,7 +32307,7 @@ const calculateEstimateResults = ({ squidRoute, tokens, fromChain, toChain, coll
     });
     // gas fees + fromAmount (if fromToken is gas token)
     const totalGasBalanceNeeded = networkFeesWei +
-        BigInt(chainFeeParams?.fromTokenPaysGasFees ? fromAmount ?? 0 : 0);
+        BigInt(chainFeeParams?.fromTokenPaysGasFees ? (fromAmount ?? 0) : 0);
     const gasBalanceNeeded = gasToken
         ? formatBNToReadable(totalGasBalanceNeeded, gasToken.decimals)
         : undefined;
@@ -31856,7 +32484,7 @@ function useEstimateSendTransaction({ chain, token, amount, balance, from, }) {
             return undefined;
         // gas fees + fromAmount (if fromToken is gas token)
         const totalGasBalanceNeeded = estimatedGas +
-            parseToBigInt(chainFeeParams?.fromTokenPaysGasFees ? amount ?? "0" : "0", token.decimals);
+            parseToBigInt(chainFeeParams?.fromTokenPaysGasFees ? (amount ?? "0") : "0", token.decimals);
         return formatBNToReadable(totalGasBalanceNeeded, gasToken.decimals);
     }, [
         amount,
@@ -32308,6 +32936,9 @@ function useSendTransaction({ to, amount, token, chain, }) {
                         chain,
                     });
                     break;
+                case ChainType.CANTON: {
+                    throw new Error("Not implemented");
+                }
             }
             return {
                 amount,
@@ -32511,6 +33142,8 @@ async function getSendTransactionStatus({ chain, txHash, }) {
                 txHash,
                 chain,
             });
+        case ChainType.CANTON:
+            throw new Error("Not implemented");
     }
 }
 
@@ -32534,7 +33167,7 @@ const useHistory = (txType) => {
             fromChain: tx.params.fromChain,
             fromToken: tx.params.fromToken,
             fromAddress: tx.params.fromAddress,
-            fromAmount: tx.params.fromAmount,
+            fromAmount: tx.params.fromAmount ?? "",
             toChain: tx.params.toChain,
             toToken: tx.params.toToken,
             toAddress: tx.params.toAddress,
@@ -32962,6 +33595,129 @@ const useApproval = ({ squidRoute, }) => {
     };
 };
 
+const useSwapStatusQuery = ({ transaction, retry = 25, refetchOnWindowFocus = "always", enabled = true, onStatus, onEndStatus, onNotFound, onError, }) => {
+    const config = useConfigStore((state) => state.config);
+    const isInitialized = useConfigStore((state) => state.isInitialized);
+    const [isTransactionComplete, setIsTransactionComplete] = useState(false);
+    const [refetchInterval, setRefetchInterval] = useState(getSwapTxStatusRefetchInterval(transaction));
+    const { getChainType } = useSquidChains();
+    const fetchTransactionStatusWithLatestConfig = useCallback(async () => {
+        const latestConfig = useConfigStore.getState().config;
+        return fetchSwapTransactionStatus({
+            transaction,
+            integratorId: latestConfig.integratorId,
+            apiUrl: latestConfig.apiUrl,
+        });
+    }, [transaction]);
+    const transactionStatusQuery = useQuery(keys().swapTransactionStatus(transaction?.transactionId), fetchTransactionStatusWithLatestConfig, {
+        enabled: enabled &&
+            transaction?.transactionId !== "0" &&
+            !!transaction?.transactionId &&
+            !!transaction.fromAddress &&
+            !!config.apiUrl &&
+            transaction !== undefined &&
+            !isTransactionComplete &&
+            isInitialized,
+        refetchInterval(statusResponse) {
+            if (statusResponse &&
+                transactionEndStatuses.includes(getTransactionStatus(statusResponse) ?? "")) {
+                return false;
+            }
+            return refetchInterval;
+        },
+        retryDelay: getChainType(transaction?.fromChain) === ChainType.COSMOS ? 5000 : 3000,
+        retry: getChainType(transaction?.fromChain) === ChainType.COSMOS ? 6 : retry,
+        refetchOnWindowFocus,
+        onSuccess: (statusResponse) => {
+            WidgetEvents.getInstance().dispatchSwapStatus(statusResponse.squidTransactionStatus ?? "");
+            onStatus?.({
+                status: getTransactionStatus(statusResponse) ?? "",
+                statusResponse,
+            });
+            const endStatus = getTransactionEndStatus({ statusResponse });
+            if (endStatus) {
+                setIsTransactionComplete(true);
+                onEndStatus?.({ status: endStatus, statusResponse });
+            }
+        },
+        onError: (error) => {
+            if (is404Error(error.cause)) {
+                onNotFound?.();
+                return;
+            }
+            setRefetchInterval(-1);
+            setIsTransactionComplete(true);
+            onError?.();
+        },
+    });
+    return {
+        transactionStatusQuery,
+    };
+};
+
+// Statuses that indicate the source deposit has been received
+// and the swap is now progressing.
+const sourceReceivedStatuses = [
+    // Chainflip
+    "DEPOSIT_RECEIVED",
+    "BROADCAST_REQUESTED",
+    "COMPLETE",
+    "SWAPPING",
+    // Canton (Squid Intents)
+    "awaiting",
+    "success",
+];
+/**
+ * Tracks a deposit address intent before it becomes a persisted swap history item.
+ *
+ * Once the source deposit is received, it registers the transaction in the transaction
+ * and history stores, then signals the view via `onReceived` to navigate.
+ */
+const useDepositTransactionStatus = ({ transaction, route, retry = 25, refetchOnWindowFocus = "always", enabled = true, onReceived, }) => {
+    const { fromChain, toChain } = useSwap();
+    const { addSwapTransaction } = useHistory();
+    const getTransaction = useTransactionStore((state) => state.getTransaction);
+    const setTransactionStoreState = useTransactionStore((state) => state.setTransactionState);
+    return useSwapStatusQuery({
+        transaction,
+        retry,
+        refetchOnWindowFocus,
+        enabled,
+        onStatus: ({ status }) => {
+            if (!sourceReceivedStatuses.includes(status))
+                return;
+            if (!transaction?.transactionId || !route?.transactionRequest)
+                return;
+            const { transactionId } = transaction;
+            if (getTransaction(transactionId))
+                return;
+            useTransactionStore.setState({
+                txLocalId: transactionId,
+                currentTransaction: undefined,
+            });
+            const tx = {
+                routeType: route.transactionRequest.type,
+                fromChain,
+                toChain,
+                fromAddress: transaction.fromAddress,
+                transactionId,
+                transactionIdForStatus: transaction.transactionIdForStatus,
+                quoteId: transaction.quoteId ?? "",
+                status: TransactionStatus.ONGOING,
+                sourceStatus: TransactionStatus.SUCCESS,
+                timestamp: Date.now(),
+            };
+            setTransactionStoreState(transactionId, tx);
+            addSwapTransaction({
+                ...tx,
+                params: route.params,
+                estimate: route.estimate,
+            });
+            onReceived?.();
+        },
+    });
+};
+
 const DEFAULT_PROVIDER_IMAGE_URL = "https://raw.githubusercontent.com/0xsquid/assets/main/images/webp128/providers/squid.webp";
 const AXELAR_PROVIDER_IMAGE_URL = "https://raw.githubusercontent.com/0xsquid/assets/main/images/webp128/providers/axelar.webp";
 const useEstimate = (squidRoute) => {
@@ -36008,6 +36764,342 @@ 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
@@ -36016,7 +37108,7 @@ const useExecuteTransaction = (squidRoute) => {
         !!fromChain &&
         !!squidRoute &&
         squidRoute.estimate.actions.every((a) => isActionCompletedOnSourceTx(a, fromChain.chainId));
-    const { evmSigner, cosmosSigner, solanaSigner, bitcoinSigner, suiSigner, xrplSigner, stellarSigner, } = useSigner({
+    const { evmSigner, cosmosSigner, solanaSigner, bitcoinSigner, suiSigner, xrplSigner, stellarSigner, cantonSigner, } = useSigner({
         chain: fromChain,
     });
     const { findToken } = useSquidTokens();
@@ -36271,7 +37363,7 @@ const useExecuteTransaction = (squidRoute) => {
     });
     const swapMutationSolana = useMutation(async ({ id, route }) => {
         try {
-            if (!route) {
+            if (!route?.transactionRequest) {
                 throw new Error("Route is required");
             }
             if (!solanaSigner) {
@@ -36280,10 +37372,10 @@ const useExecuteTransaction = (squidRoute) => {
             if (!route.params.fromAddress || !route.params.toAddress) {
                 throw new Error("From or to address is required");
             }
-            const isDirectTransfer = isDepositRoute(route);
+            const isChainflipDirectTransfer = isChainflipDepositRoute(route);
             // Means it's a transfer to a deposit address
             // Instead of a Swap/Contract call using a DEX like Jupiter
-            if (isDirectTransfer) {
+            if (isChainflipDirectTransfer) {
                 // Get the deposit address from the squidRoute
                 const depositData = useDepositAddressStore.getState().deposit;
                 // Validate params
@@ -36291,7 +37383,7 @@ const useExecuteTransaction = (squidRoute) => {
                     throw new Error("Deposit address is required");
                 }
                 const signature = await executeSolanaTransfer({
-                    amount: BigInt(route.params.fromAmount),
+                    amount: BigInt(route.params.fromAmount ?? ""),
                     target: depositData.depositAddress,
                     signer: solanaSigner,
                     connection: solanaConnection,
@@ -36301,7 +37393,7 @@ const useExecuteTransaction = (squidRoute) => {
                         const txParams = setTransactionState({
                             route,
                             txHash,
-                            transactionIdForStatus: depositData.chainflipStatusTrackingId,
+                            transactionIdForStatus: depositData.statusTrackingId,
                             userAddress: sourceUserAddress,
                             status: TransactionStatus.INITIAL_LOADING,
                             sourceStatus: TransactionStatus.ONGOING,
@@ -36352,7 +37444,7 @@ const useExecuteTransaction = (squidRoute) => {
         }
     });
     const swapMutationBitcoin = useMutation(async ({ id, route }) => {
-        const { depositAddress, amount: sendAmount, chainflipStatusTrackingId, } = useDepositAddressStore.getState().deposit ?? {};
+        const { depositAddress, amount: sendAmount, statusTrackingId, } = useDepositAddressStore.getState().deposit ?? {};
         if (!depositAddress) {
             throw new Error(`Invalid deposit address: ${depositAddress}`);
         }
@@ -36375,7 +37467,7 @@ const useExecuteTransaction = (squidRoute) => {
                     txHash,
                     // When bridging from Bitcoin we need to send the chainflipId to the status endpoint
                     // instead of the Bitcoin transaction hash
-                    transactionIdForStatus: chainflipStatusTrackingId,
+                    transactionIdForStatus: statusTrackingId,
                     userAddress: sourceUserAddress,
                     status: TransactionStatus.INITIAL_LOADING,
                     sourceStatus: TransactionStatus.ONGOING,
@@ -36567,6 +37659,56 @@ const useExecuteTransaction = (squidRoute) => {
         const sentTransaction = await client.sendTransaction(signedTransaction);
         await client.waitForTransaction(sentTransaction.hash);
     }, {});
+    const swapMutationCanton = useMutation(async ({ id, route }) => {
+        if (!route?.transactionRequest) {
+            throw new Error("Route is required");
+        }
+        if (!cantonSigner) {
+            throw new Error("Canton signer is required");
+        }
+        if (!isDepositAddressDirectTransferRoute(route.transactionRequest)) {
+            throw new Error("Invalid Canton route type");
+        }
+        const receiver = route.transactionRequest.target;
+        const orderHash = route.transactionRequest.data;
+        const fromAmount = route.params.fromAmount;
+        const token = findToken(route.params.fromToken, route.params.fromChain);
+        if (!sourceUserAddress || !fromAmount || !token) {
+            throw new Error("Need all parameters");
+        }
+        const amount = formatBNToReadable(fromAmount, token.decimals);
+        dispatchSignatureRequestEvent(route);
+        const transferParams = await buildCantonTransfer(cantonSigner, {
+            sender: sourceUserAddress,
+            receiver,
+            amount,
+            token,
+            memo: orderHash,
+            nowMs: Date.now(),
+        });
+        const result = await cantonSigner.prepareExecuteAndWait(transferParams);
+        const txHash = result.tx?.payload?.updateId ?? "";
+        if (txHash) {
+            resetQueriesAfterTxSigned();
+        }
+        WidgetEvents.getInstance().dispatchSwapExecuteCall(route, txHash);
+        const txParams = setTransactionState({
+            route,
+            txHash: txHash,
+            userAddress: sourceUserAddress,
+            status: TransactionStatus.INITIAL_LOADING,
+            sourceStatus: TransactionStatus.ONGOING,
+            id,
+        });
+        if (txParams) {
+            addSwapTransaction({
+                ...txParams,
+                params: route.params,
+                estimate: route.estimate,
+            });
+        }
+        return txHash;
+    });
     const handleTransactionSuccess = useCallback((id) => {
         const currentTx = getTransaction(id);
         queryClient.invalidateQueries(getPrefixKey(QueryKeys.Balances));
@@ -36625,7 +37767,7 @@ const useExecuteTransaction = (squidRoute) => {
         if (!mutationParams.route?.transactionRequest) {
             throw new Error("Route is required");
         }
-        const sourceChain = findChain(mutationParams.route.params?.fromChain);
+        const sourceChain = findChain(mutationParams.route.params.fromChain);
         if (!sourceChain)
             throw new Error("Could not find source chain");
         // After getting signature (if needed), continue with the swap flow
@@ -36651,6 +37793,9 @@ const useExecuteTransaction = (squidRoute) => {
             case ChainType.STELLAR: {
                 return swapMutationStellar.mutateAsync(mutationParams);
             }
+            case ChainType.CANTON: {
+                return swapMutationCanton.mutateAsync(mutationParams);
+            }
             default:
                 throw new Error(`Swap mutation not implemented for chain type: ${sourceChain.chainType}`);
         }
@@ -36823,7 +37968,7 @@ refetchIntervalInBackground = false, refetchInterval = 30000, quoteOnly = true,
     const squid = useSquidStore((state) => state.squid);
     const fallbackAddress = useSwapRoutePersistStore((store) => store.swapRoute?.fallbackAddress);
     const depositRefundAddress = useSwapRoutePersistStore((store) => store.swapRoute?.depositRefundAddress);
-    const { isAvailableAsPaymentMethod, isEnabled: isDepositAddressEnabled } = useDepositAddress();
+    const { isDepositAddressActive } = useDepositAddress();
     const getRouteMutation = useGetRoute();
     const { fromChain, toChain, fromPrice, destinationAddress: { address: destinationAddress } = {}, fromToken, toToken, } = useSwap();
     const { connectedAddress: { address: sourceConnectedAddress }, } = useMultiChainWallet(fromChain);
@@ -36831,8 +37976,8 @@ refetchIntervalInBackground = false, refetchInterval = 30000, quoteOnly = true,
     // Tokens will be sent to this address in case of swap failure
     //
     // If deposit address is not selected, we use the connected address as the source address instead
-    const sourceUserAddress = isDepositAddressEnabled && isAvailableAsPaymentMethod
-        ? depositRefundAddress ?? sourceConnectedAddress
+    const sourceUserAddress = isDepositAddressActive
+        ? (depositRefundAddress ?? sourceConnectedAddress)
         : sourceConnectedAddress;
     const squidRouteQueryKeys = useMemo(() => keys().transaction(fromChain?.chainId, toChain?.chainId, toToken?.address, fromToken?.address, fromPrice, config.slippage, sourceUserAddress, config.degenMode, destinationAddress, fallbackAddress, quoteOnly, fromChain?.chainType, config.preHook, config.postHook, config.overrideGasRefundAddress), [
         fromChain?.chainId,
@@ -36976,94 +38121,50 @@ function useSendTransactionStatus({ chain, txHash, }) {
  * Fetch status of a Swap transaction
  */
 const useSwapTransactionStatus = ({ transaction, retry = 25, refetchOnWindowFocus = "always", enabled = true, }) => {
-    const config = useConfigStore((state) => state.config);
-    const isInitialized = useConfigStore((state) => state.isInitialized);
     const { replaceSwapTransactionStatus } = useHistory();
     const findTransaction = useHistoryStore((state) => state.findTransaction);
-    const [isTransactionComplete, setIsTransactionComplete] = useState(false);
-    const [refetchInterval, setRefetchInterval] = useState(getSwapTxStatusRefetchInterval(transaction));
-    const { getChainType } = useSquidChains();
     const currentHistoryItem = useMemo(() => findTransaction({
         transactionId: transaction?.transactionId,
         txType: HistoryTxType.SWAP,
     }), [findTransaction, transaction?.transactionId]);
-    /**
-     * Transaction status endpoint
-     * Squid api is using axelar endpoint and parsing the response
-     * @returns {StatusResponse} Status response
-     */
-    const fetchTransactionStatusWithLatestConfig = useCallback(async () => {
-        const latestConfig = useConfigStore.getState().config;
-        return fetchSwapTransactionStatus({
-            transaction,
-            integratorId: latestConfig.integratorId,
-            apiUrl: latestConfig.apiUrl,
-        });
-    }, [transaction]);
-    const transactionStatusQuery = useQuery(keys().swapTransactionStatus(transaction?.transactionId), fetchTransactionStatusWithLatestConfig, {
+    const transactionStatusQuery = useSwapStatusQuery({
+        transaction,
+        retry,
+        refetchOnWindowFocus,
         enabled: enabled &&
-            transaction?.transactionId !== "0" &&
-            !!transaction?.transactionId &&
-            !!transaction.fromAddress &&
-            !!config.apiUrl &&
-            transaction !== undefined &&
-            !isTransactionComplete &&
-            isInitialized &&
             !!currentHistoryItem &&
             !isHistoryTransactionEnded({
                 data: currentHistoryItem?.data,
                 txType: HistoryTxType.SWAP,
             }),
-        refetchInterval(statusResponse) {
-            // If the status response is something telling that the transaction
-            // is finished, then store transaction history state if success
-            // And return false to indicate refetcher to stop
-            if (statusResponse &&
-                transactionEndStatuses.includes(getTransactionStatus(statusResponse) ?? "")) {
-                return false;
-            }
-            return refetchInterval; // Had to handle a variable here because after onError, we want the interval to stop
+        onEndStatus: ({ status, statusResponse }) => {
+            if (!transaction?.transactionId)
+                return;
+            replaceSwapTransactionStatus({
+                transactionId: transaction.transactionId,
+                statusResponse,
+                status,
+            });
         },
-        // At the moment Cosmos indexing takes more time, so need more time between retries
-        retryDelay: getChainType(transaction?.fromChain) === ChainType.COSMOS ? 5000 : 3000,
-        retry: getChainType(transaction?.fromChain) === ChainType.COSMOS ? 6 : retry,
-        refetchOnWindowFocus,
-        onSuccess: (statusResponse) => {
-            // Dispatch event
-            WidgetEvents.getInstance().dispatchSwapStatus(statusResponse.squidTransactionStatus ?? "");
-            const endStatus = getTransactionEndStatus({ statusResponse });
-            if (endStatus && transaction?.transactionId) {
-                setIsTransactionComplete(true);
-                replaceSwapTransactionStatus({
-                    transactionId: transaction.transactionId,
-                    statusResponse,
-                    status: endStatus,
-                });
-            }
+        onNotFound: () => {
+            if (!transaction?.transactionId)
+                return;
+            replaceSwapTransactionStatus({
+                transactionId: transaction.transactionId,
+                statusResponse: undefined,
+                status: TransactionStatus.NOT_FOUND,
+            });
         },
-        onError: (error) => {
-            // `fetchTransactionStatus` throws an error with a cause being an AxiosError
-            const is404 = is404Error(error.cause);
+        onError: () => {
             if (!transaction?.transactionId)
                 return;
-            if (is404) {
-                replaceSwapTransactionStatus({
-                    transactionId: transaction.transactionId,
-                    statusResponse: undefined,
-                    status: TransactionStatus.NOT_FOUND,
-                });
-            }
-            else {
-                setRefetchInterval(-1);
-                setIsTransactionComplete(true);
-                replaceSwapTransactionStatus({
-                    transactionId: transaction.transactionId,
-                    statusResponse: undefined,
-                    status: TransactionStatus.ERROR,
-                });
-            }
+            replaceSwapTransactionStatus({
+                transactionId: transaction.transactionId,
+                statusResponse: undefined,
+                status: TransactionStatus.ERROR,
+            });
         },
-    });
+    }).transactionStatusQuery;
     return {
         transactionStatusQuery,
         latestStatus: transactionStatusQuery.data
@@ -37374,10 +38475,10 @@ function useXrplTrustLine({ address, chain, token, amount }) {
             if (!amount) {
                 throw new Error("Amount is required");
             }
-            const limitBn = BigNumber$1(trustLineQuery.data?.limit || "0");
-            const balanceBn = BigNumber$1(trustLineQuery.data?.balance || "0");
+            const limitBn = BigNumber(trustLineQuery.data?.limit || "0");
+            const balanceBn = BigNumber(trustLineQuery.data?.balance || "0");
             const availableAllowanceBn = limitBn.minus(balanceBn);
-            const amountBn = BigNumber$1(formatBNToReadable(amount, token.decimals));
+            const amountBn = BigNumber(formatBNToReadable(amount, token.decimals));
             return availableAllowanceBn.gte(amountBn);
         },
         enabled: !!address &&
@@ -37462,8 +38563,10 @@ const SquidProvider = ({ children, config, placeholder, }) => {
             }
             if (assetsColorsResponse.status === "fulfilled") {
                 useAssetsColorsStore.setState(assetsColorsResponse.value);
-                initializeSquidWithAssetsColors(squid, assetsColorsResponse.value);
             }
+            initializeSquidData(squid, assetsColorsResponse.status === "fulfilled"
+                ? assetsColorsResponse.value
+                : undefined);
             const shouldResetSwapRouteStore = 
             // reset swap route if specified in config
             !config?.loadPreviousStateFromLocalStorage ||
@@ -37495,8 +38598,8 @@ const SquidProvider = ({ children, config, placeholder, }) => {
                 error instanceof Error;
             if (isBackendDown) {
                 const maintenanceMessage = isAxios503Error
-                    ? error.response?.data
-                        ?.message ?? undefined
+                    ? (error.response?.data
+                        ?.message ?? undefined)
                     : "Unable to connect to Squid. Please check your connection or try again later.";
                 // Even with an error, we want wagmi to be defined so that we can display the maintenance mode layout
                 // Create wagmi config with mainnet as fallback in maintenance mode
@@ -37531,14 +38634,15 @@ const SquidProvider = ({ children, config, placeholder, }) => {
     }, [initializeSdk]);
     return wagmiConfig ? (React.createElement(WagmiProvider, { reconnectOnMount: false, config: wagmiConfig },
         React.createElement(QueryClientProvider, { client: queryClient },
-            React.createElement(StellarProvider, null,
-                React.createElement(EvmProvider, null,
-                    React.createElement(XrplProvider, null,
-                        React.createElement(SuiProvider, null,
-                            React.createElement(SolanaProvider, null,
-                                React.createElement(BitcoinProvider, null,
-                                    React.createElement(CosmosProvider, null, children)))))))))) : (placeholder);
-};
-
-export { useDepositAddress as $, AxelarStatusResponseType as A, useHederaTokenAssociations as B, CHAIN_IDS as C, DEFAULT_LOCALE as D, useKeyboardNavigation as E, useSquidQueryClient as F, useSquid as G, HistoryTxType as H, useStellarAccountActivation as I, useStellarTrustLine as J, useAddressBookStore as K, useAssetsColorsStore as L, useFavoriteTokensStore as M, Nr as N, useHistoryStore as O, useSendTransactionStore as P, QueryKeys as Q, useConfigStore as R, SquidStatusErrorType as S, TransactionErrorType as T, useSquidStore as U, useSwapRoutePersistStore as V, Wo as W, XamanXrplNetwork as X, useTransactionStore as Y, ConnectingWalletStatus as Z, useWalletStore as _, WindowWalletFlag as a, useGetOnrampPaymentTypes as a$, useSwap as a0, buildUrlSearchParamsFromSwapEvent as a1, parseInitialAssetsFromUrl as a2, useUrlSwapParams as a3, useAllConnectedWalletBalances as a4, useAllTokensWithBalanceForChainType as a5, useCosmosBalance as a6, useEvmBalance as a7, useMultiChainBalance as a8, useMultipleTokenPrices as a9, useSwapTransactionStatus as aA, useAvatar as aB, useHistory as aC, useDebouncedValue as aD, useAddToken as aE, useAutoConnect as aF, useEnsDataForAddress as aG, useEnsSearch as aH, useGnosisContext as aI, useIsSameAddressAndGnosisContext as aJ, useIntegratorContext as aK, useMultiChainWallet as aL, useSigner as aM, useWallet as aN, useWallets as aO, useXrplTrustLine as aP, TX_STATUS_CONSTANTS as aQ, FINAL_TRANSACTION_STATUSES as aR, useGetFiatQuote as aS, useGetOnRampConfig as aT, useExecuteFiatQuote as aU, useFiatOnRampTxStatus as aV, useFiatTransactions as aW, useCurrencyDetails as aX, useCountryDetails as aY, useAvailableQuotes as aZ, useRecommendedQuote as a_, useBitcoinNativeBalance as aa, useCosmosNativeBalance as ab, useEvmNativeBalance as ac, useNativeBalance as ad, useSolanaNativeBalance as ae, useStellarNativeBalance as af, useSuiNativeBalance as ag, useXrplNativeBalance as ah, useNativeTokenForChain as ai, useSingleTokenPrice as aj, useSourceChainGasToken as ak, useSquidTokens as al, useHistoricalData as am, useTokensData as an, useEstimateSendTransaction as ao, useSendTransaction as ap, useSendTransactionGas as aq, useAllTransactionsStatus as ar, useApproval as as, useEstimate as at, useEstimatePriceImpact as au, useExecuteTransaction as av, useGetRoute as aw, useGetRouteWrapper as ax, useRouteWarnings as ay, useSendTransactionStatus as az, chainTypeToZeroAddressMap as b, filterWagmiConnector as b$, useSuggestedFiatAmounts as b0, SquidProvider as b1, EnsService as b2, getXummClient as b3, isXamanXAppContext as b4, getQueryHeaders as b5, getStatusCode as b6, is404Error as b7, assetsBaseUrl as b8, shareSubgraphId as b9, fetchHighestBalanceToken as bA, getInitialOrDefaultTokenAddressForChain as bB, getInitialTokenAddressForChain as bC, filterTokensForDestination as bD, getInitialChainIdFromConfig as bE, getCosmosKey as bF, getKeysSettled as bG, getAllKeysForSupportedCosmosChains as bH, isCosmosAddressValid as bI, getCosmosSigningClient as bJ, getCosmosChainInfosObject as bK, connectCosmosWallet as bL, isFallbackAddressNeeded as bM, suggestChainOrThrow as bN, normalizeError as bO, transactionErrorCode as bP, isUserRejectionError as bQ, getTransactionError as bR, handleTransactionErrorEvents as bS, isSwapRouteError as bT, isStatusError as bU, createQuoteRequestParamsHash as bV, WidgetEvents as bW, EvmNetworkNotSupportedErrorCode as bX, addEthereumChain as bY, parseEvmAddress as bZ, formatEvmWallet as b_, sortTokensBySharedSubgraphIds as ba, getSupportedChainIdsForDirection as bb, filterChains as bc, filterTokens as bd, getTokenImage as be, getNewSwapParamsFromInput as bf, sortAllTokens as bg, findToken as bh, findNativeToken as bi, normalizeIbcAddress as bj, groupTokensBySymbol as bk, groupTokensByChainId as bl, filterViewableTokens as bm, getSecretNetworkBalances as bn, getTokenAssetsKey as bo, fetchAssetsColors as bp, initializeSquidWithAssetsColors as bq, isEmptyObject as br, normalizeTokenSymbol as bs, areTokenSymbolsCompatible as bt, isEvmosChain as bu, resolveChainIdFromAsset as bv, getConfigWithDefaults as bw, randomIntFromInterval as bx, getTokensForChain as by, getFirstAvailableChainId as bz, chainTypeToNativeTokenAddressMap as c, isHistoryTransactionPending as c$, waitForReceiptWithRetry as c0, getUserCountry as c1, getCountryData as c2, getCurrencyData as c3, adaptiveRound as c4, getSuggestedAmountsForCurrency as c5, HederaExtensionHelper as c6, convertHederaAccountIdToEvmAddress as c7, convertEvmAddressToHederaAccountId as c8, scaleHbarToWei as c9, isValidHorizonAsset as cA, formatTransactionHistoryDate as cB, getAxelarExplorerTxUrl as cC, getSourceExplorerTxUrl as cD, getMainExplorerUrl as cE, formatDistance as cF, formatSeconds as cG, formatSwapTxStatusResponseForStorage as cH, simplifyRouteAction as cI, fetchSwapTransactionStatus as cJ, compareTransactionIds as cK, isCoralBridgeAction as cL, isActionCompletedOnSourceTx as cM, sleep as cN, isDepositRoute as cO, isChainflipBridgeTransaction as cP, isOnChainTxData as cQ, getHistoryTransactionId as cR, getStepStatuses as cS, getHalfSuccessState as cT, getStepsInfos as cU, getSwapTxStatusRefetchInterval as cV, getSendTxStatusRefetchInterval as cW, chainflipMultihopBridgeType as cX, getBridgeType as cY, getTransactionStatus as cZ, getTransactionEndStatus as c_, scaleWeiToHbar as ca, parseToBigInt as cb, roundNumericValue as cc, formatUnitsRounded as cd, formatTokenAmount as ce, formatUsdAmount as cf, trimExtraDecimals as cg, getNumericValue as ch, cleanAmount as ci, convertTokenAmountToUSD as cj, convertUSDToTokenAmount as ck, calculateTotal24hChange as cl, getRouteExpiry as cm, searchTokens as cn, filterSolanaWallets as co, isSolanaAddressValid as cp, executeSolanaSwap as cq, executeSolanaTransfer as cr, isStellarAddressValid as cs, getStellarNetwork as ct, stellarAddressToScVal as cu, getStellarTrustLineAsset as cv, isStellarToken as cw, isStellarIssuedToken as cx, getStellarHorizonApiUrl as cy, isValidIssuedAsset as cz, definedInWindow as d, isHistoryTransactionFailed as d0, isHistoryTransactionWarning as d1, isHistoryTransactionEnded as d2, formatHash as d3, isWalletAddressValid as d4, redirectToExtensionsStore as d5, accessProperty as d6, populateWallets as d7, getDefaultChain as d8, sortWallets as d9, areSameAddress as da, sortAddressBook as db, calculateTotalUsdBalanceUSD as dc, addTokenToWallet as dd, isEvmChainNotSupportedError as de, getWalletSupportedChainTypes as df, getConnectorForChainType as dg, walletSupportsChainType as dh, connectWallet as di, cancelConnectWallet as dj, isProblematicConnector as dk, mergeWallets as dl, isXionSmartContractAddress as dm, isXrplAddressValid as dn, buildXrplTrustSetTx as dp, getXrplNetwork as dq, parseXrplPaymentTx as dr, parseXrplTokenAddress as ds, er as e, formatBNToReadable as f, DEFAULT_ROUTE_REFETCH_INTERVAL as g, destinationAddressResetValue as h, fallbackAddressResetValue as i, nativeCosmosTokenAddress as j, nativeEvmTokenAddress as k, nativeSolanaTokenAddress as l, nativeStellarTokenAddress as m, nativeBitcoinTokenAddress as n, nativeSuiTokenAddress as o, nativeXrplTokenAddress as p, CosmosProvider as q, SendTransactionStatus as r, TransactionStatus as s, useTrackSearchEmpty as t, useCosmosContext as u, useSquidChains as v, walletIconBaseUrl as w, useClient as x, useCosmosForChain as y, useHederaAccountActivation as z };
-//# sourceMappingURL=index-Ypw6i6uY.js.map
+            React.createElement(CantonProvider, null,
+                React.createElement(StellarProvider, null,
+                    React.createElement(EvmProvider, null,
+                        React.createElement(XrplProvider, null,
+                            React.createElement(SuiProvider, null,
+                                React.createElement(SolanaProvider, null,
+                                    React.createElement(BitcoinProvider, null,
+                                        React.createElement(CosmosProvider, null, children))))))))))) : (placeholder);
+};
+
+export { useDepositAddress as $, AxelarStatusResponseType as A, useHederaTokenAssociations as B, CHAIN_IDS as C, DEFAULT_LOCALE as D, useKeyboardNavigation as E, useSquidQueryClient as F, useSquid as G, HistoryTxType as H, useStellarAccountActivation as I, useStellarTrustLine as J, useAddressBookStore as K, useAssetsColorsStore as L, useFavoriteTokensStore as M, Nr as N, useHistoryStore as O, useSendTransactionStore as P, QueryKeys as Q, useConfigStore as R, SquidStatusErrorType as S, TransactionErrorType as T, useSquidStore as U, useSwapRoutePersistStore as V, Wo as W, XamanXrplNetwork as X, useTransactionStore as Y, ConnectingWalletStatus as Z, useWalletStore as _, WindowWalletFlag as a, useRecommendedQuote as a$, useSwap as a0, buildUrlSearchParamsFromSwapEvent as a1, parseInitialAssetsFromUrl as a2, useUrlSwapParams as a3, useAllConnectedWalletBalances as a4, useAllTokensWithBalanceForChainType as a5, useCosmosBalance as a6, useEvmBalance as a7, useMultiChainBalance as a8, useMultipleTokenPrices as a9, useSendTransactionStatus as aA, useSwapTransactionStatus as aB, useAvatar as aC, useHistory as aD, useDebouncedValue as aE, useAddToken as aF, useAutoConnect as aG, useEnsDataForAddress as aH, useEnsSearch as aI, useGnosisContext as aJ, useIsSameAddressAndGnosisContext as aK, useIntegratorContext as aL, useMultiChainWallet as aM, useSigner as aN, useWallet as aO, useWallets as aP, useXrplTrustLine as aQ, TX_STATUS_CONSTANTS as aR, FINAL_TRANSACTION_STATUSES as aS, useGetFiatQuote as aT, useGetOnRampConfig as aU, useExecuteFiatQuote as aV, useFiatOnRampTxStatus as aW, useFiatTransactions as aX, useCurrencyDetails as aY, useCountryDetails as aZ, useAvailableQuotes as a_, useBitcoinNativeBalance as aa, useCosmosNativeBalance as ab, useEvmNativeBalance as ac, useNativeBalance as ad, useSolanaNativeBalance as ae, useStellarNativeBalance as af, useSuiNativeBalance as ag, useXrplNativeBalance as ah, useNativeTokenForChain as ai, useSingleTokenPrice as aj, useSourceChainGasToken as ak, useSquidTokens as al, useHistoricalData as am, useTokensData as an, useEstimateSendTransaction as ao, useSendTransaction as ap, useSendTransactionGas as aq, useAllTransactionsStatus as ar, useApproval as as, useDepositTransactionStatus as at, useEstimate as au, useEstimatePriceImpact as av, useExecuteTransaction as aw, useGetRoute as ax, useGetRouteWrapper as ay, useRouteWarnings as az, chainTypeToZeroAddressMap as b, parseEvmAddress as b$, useGetOnrampPaymentTypes as b0, useSuggestedFiatAmounts as b1, SquidProvider as b2, EnsService as b3, getXummClient as b4, isXamanXAppContext as b5, getQueryHeaders as b6, getStatusCode as b7, is404Error as b8, assetsBaseUrl as b9, getTokensForChain as bA, getFirstAvailableChainId as bB, fetchHighestBalanceToken as bC, getInitialOrDefaultTokenAddressForChain as bD, getInitialTokenAddressForChain as bE, filterTokensForDestination as bF, getInitialChainIdFromConfig as bG, getCosmosKey as bH, getKeysSettled as bI, getAllKeysForSupportedCosmosChains as bJ, isCosmosAddressValid as bK, getCosmosSigningClient as bL, getCosmosChainInfosObject as bM, connectCosmosWallet as bN, isFallbackAddressNeeded as bO, suggestChainOrThrow as bP, normalizeError as bQ, transactionErrorCode as bR, isUserRejectionError as bS, getTransactionError as bT, handleTransactionErrorEvents as bU, isSwapRouteError as bV, isStatusError as bW, createQuoteRequestParamsHash as bX, WidgetEvents as bY, EvmNetworkNotSupportedErrorCode as bZ, addEthereumChain as b_, shareSubgraphId as ba, sortTokensBySharedSubgraphIds as bb, getSupportedChainIdsForDirection as bc, filterChains as bd, filterTokens as be, getTokenImage as bf, getNewSwapParamsFromInput as bg, sortAllTokens as bh, findToken as bi, findNativeToken as bj, normalizeIbcAddress as bk, groupTokensBySymbol as bl, groupTokensByChainId as bm, filterViewableTokens as bn, getSecretNetworkBalances as bo, getTokenAssetsKey as bp, fetchAssetsColors as bq, isSupportedChainType as br, initializeSquidData as bs, isEmptyObject as bt, normalizeTokenSymbol as bu, areTokenSymbolsCompatible as bv, isEvmosChain as bw, resolveChainIdFromAsset as bx, getConfigWithDefaults as by, randomIntFromInterval as bz, chainTypeToNativeTokenAddressMap as c, getBridgeType as c$, formatEvmWallet as c0, filterWagmiConnector as c1, waitForReceiptWithRetry as c2, getUserCountry as c3, getCountryData as c4, getCurrencyData as c5, adaptiveRound as c6, getSuggestedAmountsForCurrency as c7, HederaExtensionHelper as c8, convertHederaAccountIdToEvmAddress as c9, getStellarHorizonApiUrl as cA, isValidIssuedAsset as cB, isValidHorizonAsset as cC, formatTransactionHistoryDate as cD, getAxelarExplorerTxUrl as cE, getSourceExplorerTxUrl as cF, getMainExplorerUrl as cG, formatDistance as cH, formatSeconds as cI, formatSwapTxStatusResponseForStorage as cJ, simplifyRouteAction as cK, fetchSwapTransactionStatus as cL, compareTransactionIds as cM, isCoralBridgeAction as cN, isActionCompletedOnSourceTx as cO, sleep as cP, isChainflipDepositRoute as cQ, isChainflipBridgeTransaction as cR, isOnChainTxData as cS, isDepositAddressDirectTransferRoute as cT, getHistoryTransactionId as cU, getStepStatuses as cV, getHalfSuccessState as cW, getStepsInfos as cX, getSwapTxStatusRefetchInterval as cY, getSendTxStatusRefetchInterval as cZ, chainflipMultihopBridgeType as c_, convertEvmAddressToHederaAccountId as ca, scaleHbarToWei as cb, scaleWeiToHbar as cc, parseToBigInt as cd, roundNumericValue as ce, formatUnitsRounded as cf, formatTokenAmount as cg, formatUsdAmount as ch, trimExtraDecimals as ci, getNumericValue as cj, cleanAmount as ck, convertTokenAmountToUSD as cl, convertUSDToTokenAmount as cm, calculateTotal24hChange as cn, getRouteExpiry as co, searchTokens as cp, filterSolanaWallets as cq, isSolanaAddressValid as cr, executeSolanaSwap as cs, executeSolanaTransfer as ct, isStellarAddressValid as cu, getStellarNetwork as cv, stellarAddressToScVal as cw, getStellarTrustLineAsset as cx, isStellarToken as cy, isStellarIssuedToken as cz, definedInWindow as d, getTransactionStatus as d0, getTransactionEndStatus as d1, isHistoryTransactionPending as d2, isHistoryTransactionFailed as d3, isHistoryTransactionWarning as d4, isHistoryTransactionEnded as d5, formatHash as d6, isWalletAddressValid as d7, redirectToExtensionsStore as d8, populateWallets as d9, buildFallbackWallets as da, getDefaultChain as db, sortWallets as dc, areSameAddress as dd, sortAddressBook as de, calculateTotalUsdBalanceUSD as df, addTokenToWallet as dg, isEvmChainNotSupportedError as dh, getWalletSupportedChainTypes as di, getConnectorForChainType as dj, walletSupportsChainType as dk, connectWallet as dl, cancelConnectWallet as dm, isProblematicConnector as dn, mergeWallets as dp, isXionSmartContractAddress as dq, isXrplAddressValid as dr, buildXrplTrustSetTx as ds, getXrplNetwork as dt, parseXrplPaymentTx as du, parseXrplTokenAddress as dv, er as e, formatBNToReadable as f, DEFAULT_ROUTE_REFETCH_INTERVAL as g, destinationAddressResetValue as h, fallbackAddressResetValue as i, nativeCosmosTokenAddress as j, nativeEvmTokenAddress as k, nativeSolanaTokenAddress as l, nativeStellarTokenAddress as m, nativeBitcoinTokenAddress as n, nativeSuiTokenAddress as o, nativeXrplTokenAddress as p, CosmosProvider as q, SendTransactionStatus as r, TransactionStatus as s, useTrackSearchEmpty as t, useCosmosContext as u, useSquidChains as v, walletIconBaseUrl as w, useClient as x, useCosmosForChain as y, useHederaAccountActivation as z };
+//# sourceMappingURL=index-BlB3yIoX.js.map