@0xsquid/react-hooks 8.9.0 → 8.9.1-beta-canton-wallet-connection.0

package/dist/{index-DcBFug8t.js → index-doLvokYY.js}

@@ -11,13 +11,13 @@ var axios = require('axios');
 var modal = require('@walletconnect/modal');
 var UniversalProvider = require('@walletconnect/universal-provider');
 var rippleAddressCodec = require('ripple-address-codec');
+var BigNumber = require('bignumber.js');
 var splToken = require('@solana/spl-token');
 var walletStandardWalletAdapterBase = require('@solana/wallet-standard-wallet-adapter-base');
 var web3_js = require('@solana/web3.js');
 var stellarSdk = require('@stellar/stellar-sdk');
 var walletStandard = require('@mysten/wallet-standard');
 var ethers = require('ethers');
-var BigNumber = require('bignumber.js');
 var countriesList = require('countries-list');
 var getSymbolFromCurrency = require('currency-symbol-map');
 var Fuse = require('fuse.js');
@@ -25,6 +25,7 @@ var zustand = require('zustand');
 var middleware = require('zustand/middleware');
 var wagmi = require('wagmi');
 var SafeAppsSDK = require('@safe-global/safe-apps-sdk');
+var dapp = require('@sigilry/dapp');
 var core$1 = require('@wallet-standard/core');
 var slushWallet = require('@mysten/slush-wallet');
 var stargate = require('@cosmjs/stargate');
@@ -78,6 +79,7 @@ const solanaZeroAddress = "11111111111111111111111111111111";
 const suiZeroAddress = "0x0000000000000000000000000000000000000000";
 const xrplZeroAddress = "rrrrrrrrrrrrrrrrrrrrrhoLvTp";
 const stellarZeroAddress = "GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWHF";
+const cantonZeroAddress = "none::12200000000000000000000000000000000000000000000000000000000000000000";
 const chainTypeToZeroAddressMap = {
     [squidTypes.ChainType.EVM]: viem.zeroAddress,
     [squidTypes.ChainType.COSMOS]: cosmosZeroAddress,
@@ -86,6 +88,7 @@ const chainTypeToZeroAddressMap = {
     [squidTypes.ChainType.SUI]: suiZeroAddress,
     [squidTypes.ChainType.XRPL]: xrplZeroAddress,
     [squidTypes.ChainType.STELLAR]: stellarZeroAddress,
+    [squidTypes.ChainType.CANTON]: cantonZeroAddress,
 };
 const nativeEvmTokenAddress = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
 const nativeCosmosTokenAddress = "uosmo";
@@ -94,6 +97,7 @@ const nativeBitcoinTokenAddress = "satoshi";
 const nativeSuiTokenAddress = "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI";
 const nativeXrplTokenAddress = "xrp";
 const nativeStellarTokenAddress = "CAS3J7GYLGXMF6TDJBBYYSE3HQ6BBSMLNUQ34T6TZMYMW2EVH34XOWMA";
+const nativeCantonTokenAddress = "DSO::1220b1431ef217342db44d516bb9befde802be7d8899637d290895fa58880f19accc";
 // by setting slippage to undefined, it's set to "auto"
 const defaultSlippage = undefined;
 const destinationAddressResetValue = "null";
@@ -106,6 +110,8 @@ 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";
 const DEFAULT_COUNTRY_CODE = "US";
+// TODO: pending confirmation with Backend team on final URL
+const CANTON_AMULET_REGISTRY_URL = "/api/canton/scan-proxy";
 const CHAIN_IDS = {
     // Cosmos
     OSMOSIS: "osmosis-1",
@@ -157,6 +163,7 @@ const CHAIN_IDS = {
     XRPL_TESTNET: "xrpl-testnet",
     STELLAR: "stellar-mainnet",
     STELLAR_TESTNET: "stellar-testnet",
+    CANTON: "canton",
 };
 const chainTypeToDefaultChainIdMap = {
     [squidTypes.ChainType.EVM]: CHAIN_IDS.ETHEREUM,
@@ -166,6 +173,7 @@ const chainTypeToDefaultChainIdMap = {
     [squidTypes.ChainType.SUI]: CHAIN_IDS.SUI,
     [squidTypes.ChainType.XRPL]: CHAIN_IDS.XRPL,
     [squidTypes.ChainType.STELLAR]: CHAIN_IDS.STELLAR,
+    [squidTypes.ChainType.CANTON]: CHAIN_IDS.CANTON,
 };
 const chainTypeToNativeTokenAddressMap = {
     [squidTypes.ChainType.EVM]: nativeEvmTokenAddress,
@@ -175,6 +183,7 @@ const chainTypeToNativeTokenAddressMap = {
     [squidTypes.ChainType.SUI]: nativeSuiTokenAddress,
     [squidTypes.ChainType.XRPL]: nativeXrplTokenAddress,
     [squidTypes.ChainType.STELLAR]: nativeStellarTokenAddress,
+    [squidTypes.ChainType.CANTON]: nativeCantonTokenAddress,
 };
 const defaultConfigValues = {
     integratorId: INTEGRATOR_ID,
@@ -20557,6 +20566,17 @@ exports.WindowWalletFlag = void 0;
 })(exports.WindowWalletFlag || (exports.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",
@@ -20853,6 +20873,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: squidTypes.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: squidTypes.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) => {
     try {
@@ -20872,6 +20920,142 @@ const isBitcoinAddressValid = (address) => {
     }
 };
 
+// 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 = {
     [splToken.TOKEN_PROGRAM_ID.toBase58()]: splToken.TOKEN_PROGRAM_ID,
     [splToken.TOKEN_2022_PROGRAM_ID.toBase58()]: splToken.TOKEN_2022_PROGRAM_ID,
@@ -21011,6 +21195,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:
@@ -21120,10 +21305,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,
@@ -21170,7 +21361,7 @@ function isActionCompletedOnSourceTx(action, fromChainId) {
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
-const isDepositRoute = (route) => {
+const isChainflipDepositRoute = (route) => {
     return (!!route &&
         route.transactionRequest?.type === squidTypes.SquidDataType.ChainflipDepositAddress);
 };
@@ -21195,6 +21386,12 @@ function isOnChainTxData(squidData) {
         squidTypes.SquidDataType.DepositAddressWithMemo,
     ].includes(squidData.type);
 }
+/**
+ * Checks if a route is of type DepositAddressDirectTransfer
+ */
+function isDepositAddressDirectTransferRoute(squidData) {
+    return squidData.type === squidTypes.SquidDataType.DepositAddressDirectTransfer;
+}
 function getHistoryTransactionId(tx) {
     switch (tx.txType) {
         case exports.HistoryTxType.SWAP:
@@ -21714,7 +21911,17 @@ const chainTypeToTrimLength = {
         start: 4,
         end: 4,
     },
+    // abc...123::abc...123
+    [squidTypes.ChainType.CANTON]: {
+        start: 3,
+        end: 3,
+    },
 };
+const truncateWithEllipsis = (value, startLength, endLength) => value.length <= startLength + endLength
+    ? value
+    : value.slice(0, startLength) +
+        "..." +
+        value.slice(value.length - endLength);
 const formatHash = ({ chainType, hash }) => {
     if (!hash)
         return "";
@@ -21727,14 +21934,15 @@ const formatHash = ({ chainType, hash }) => {
             chainTypeFormat = squidTypes.ChainType.COSMOS;
         }
     }
-    const trimLengthStart = chainTypeToTrimLength[chainTypeFormat].start;
-    const trimLengthEnd = chainTypeToTrimLength[chainTypeFormat].end;
-    // return the same hash if its length is less than the trim length
-    if (hash.length <= trimLengthStart + trimLengthEnd)
-        return hash;
-    return (hash.slice(0, trimLengthStart) +
-        "..." +
-        hash.slice(hash.length - trimLengthEnd, hash.length));
+    const { start, end } = chainTypeToTrimLength[chainTypeFormat];
+    if (chainTypeFormat === squidTypes.ChainType.CANTON &&
+        hash.includes(CANTON_PARTY_ID_SEPARATOR)) {
+        const [namespace, identifier] = hash.split(CANTON_PARTY_ID_SEPARATOR);
+        return (truncateWithEllipsis(namespace, start, end) +
+            CANTON_PARTY_ID_SEPARATOR +
+            truncateWithEllipsis(identifier, start, end));
+    }
+    return truncateWithEllipsis(hash, start, end);
 };
 const isWalletAddressValid = (chainData, address) => {
     if (!address || !chainData?.chainType)
@@ -21754,33 +21962,25 @@ const isWalletAddressValid = (chainData, address) => {
             return isXrplAddressValid(address);
         case squidTypes.ChainType.STELLAR:
             return isStellarAddressValid(address);
+        case squidTypes.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;
@@ -21809,6 +22009,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
@@ -22015,6 +22241,13 @@ const connectByChainType = async (chainType, wallet, defaultChain, params) => {
                     connector,
                 },
             });
+        case squidTypes.ChainType.CANTON:
+            return params.connectCanton.mutateAsync({
+                wallet: {
+                    ...wallet,
+                    connector,
+                },
+            });
     }
 };
 const getChainTypesToConnect = (selectedChainTypes, defaultChain, supportedChains) => {
@@ -22051,6 +22284,7 @@ const connectMultiChainWallet = async (params) => {
                 connectSui: params.connectSui,
                 connectXrpl: params.connectXrpl,
                 connectStellar: params.connectStellar,
+                connectCanton: params.connectCanton,
             });
             if (result) {
                 results.push({
@@ -22084,6 +22318,7 @@ const connectSingleChainWallet = async (params) => {
         connectSui: params.connectSui,
         connectXrpl: params.connectXrpl,
         connectStellar: params.connectStellar,
+        connectCanton: params.connectCanton,
     });
     return result
         ? {
@@ -22997,7 +23232,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;
@@ -23049,7 +23284,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) {
@@ -23089,7 +23324,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,
@@ -23368,7 +23606,7 @@ const filterViewableTokens = (tokens, config, direction) => {
 };
 const getSecretNetworkBalances = async (chainData, cosmosAddress, squidTokens, keplrTypeWallet) => {
     const squidSecretTokens = squidTokens.filter((t) => t.chainId === CHAIN_IDS.SECRET);
-    const { fetchAllSecretBalances } = await Promise.resolve().then(function () { return require('./secretService-B1SDXLS1.js'); });
+    const { fetchAllSecretBalances } = await Promise.resolve().then(function () { return require('./secretService-3g7QoMaM.js'); });
     return fetchAllSecretBalances(chainData, cosmosAddress, squidSecretTokens, keplrTypeWallet);
 };
 function getTokenAssetsKey(token) {
@@ -23395,9 +23633,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(squidTypes.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,
@@ -23406,7 +23664,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
@@ -25059,7 +25317,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() ===
@@ -25283,7 +25541,7 @@ const useSquid = () => {
         queryFn: async () => {
             if (squid) {
                 await squid?.init();
-                initializeSquidWithAssetsColors(squid, assetsColors);
+                initializeSquidData(squid, assetsColors);
                 return squid;
             }
             return null;
@@ -25342,7 +25600,7 @@ const useSquidTokens = (direction) => {
         config.availableChains,
         direction,
     ]);
-    const { evmTokens, cosmosTokens, solanaTokens, bitcoinTokens, suiTokens, xrplTokens, stellarTokens, } = React.useMemo(() => {
+    const { evmTokens, cosmosTokens, solanaTokens, bitcoinTokens, suiTokens, xrplTokens, stellarTokens, cantonTokens, } = React.useMemo(() => {
         return tokens?.reduce((acc, token) => {
             switch (token.type) {
                 case squidTypes.ChainType.EVM:
@@ -25366,6 +25624,9 @@ const useSquidTokens = (direction) => {
                 case squidTypes.ChainType.STELLAR:
                     acc.stellarTokens.push(token);
                     break;
+                case squidTypes.ChainType.CANTON:
+                    acc.cantonTokens.push(token);
+                    break;
             }
             return acc;
         }, {
@@ -25376,6 +25637,7 @@ const useSquidTokens = (direction) => {
             suiTokens: [],
             xrplTokens: [],
             stellarTokens: [],
+            cantonTokens: [],
         });
     }, [tokens]);
     const findToken = React.useCallback((address, chainId) => {
@@ -25393,6 +25655,7 @@ const useSquidTokens = (direction) => {
         suiTokens,
         xrplTokens,
         stellarTokens,
+        cantonTokens,
     };
 };
 
@@ -25493,12 +25756,10 @@ const useGetFiatQuote = ({ fiatCurrency, cryptoCurrencyID, amount, region, payme
  */
 const useGetOnRampConfig = () => {
     const service = React.useMemo(() => new OnrampService(), []);
-    const { chains } = useSquidChains();
     const { tokens } = useSquidTokens();
     return reactQuery.useQuery({
         queryKey: keys().fiatToCryptoConfig(),
         queryFn: () => service.getConfiguration({
-            chains,
             tokens,
         }),
         cacheTime: 1000 * 60 * 60,
@@ -25930,6 +26191,7 @@ const chainTypeToRefetchInterval = {
     [squidTypes.ChainType.SUI]: 1_000,
     [squidTypes.ChainType.XRPL]: 1_000,
     [squidTypes.ChainType.STELLAR]: 1_000,
+    [squidTypes.ChainType.CANTON]: 1_000,
 };
 /**
  * Returns the status refetch interval of a Send transaction
@@ -26196,7 +26458,7 @@ const useSquidChains = (direction) => {
         const chain = findChain(chainId);
         return chain?.chainType;
     }, [findChain]);
-    const { evmChains, cosmosChains, suiChains, stellarChains, xrplChains } = React.useMemo(() => {
+    const { evmChains, cosmosChains, suiChains, stellarChains, xrplChains, cantonChains, } = React.useMemo(() => {
         return chains.reduce((acc, chain) => {
             switch (chain.chainType) {
                 case squidTypes.ChainType.EVM:
@@ -26214,6 +26476,9 @@ const useSquidChains = (direction) => {
                 case squidTypes.ChainType.STELLAR:
                     acc.stellarChains.push(chain);
                     break;
+                case squidTypes.ChainType.CANTON:
+                    acc.cantonChains.push(chain);
+                    break;
             }
             return acc;
         }, {
@@ -26222,6 +26487,7 @@ const useSquidChains = (direction) => {
             suiChains: [],
             xrplChains: [],
             stellarChains: [],
+            cantonChains: [],
         });
     }, [chains]);
     const { supportedSourceChains, supportedDestinationChains } = React.useMemo(() => {
@@ -26242,6 +26508,7 @@ const useSquidChains = (direction) => {
         suiChains,
         xrplChains,
         stellarChains,
+        cantonChains,
         getChainType,
         findChain,
     };
@@ -26555,6 +26822,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 = dapp.createCantonClient(new dapp.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] = React.useState([]);
+    const connectorCache = React.useRef(new Map());
+    const toWallet = React.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: squidTypes.ChainType.CANTON,
+            connector,
+        };
+    }, []);
+    const refresh = React.useCallback(async () => {
+        if (typeof window === "undefined")
+            return;
+        const providers = await discoverCantonProviders();
+        setWallets(providers.map(toWallet));
+    }, [toWallet]);
+    React.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[squidTypes.ChainType.CANTON]);
+    const recentCantonWalletId = useWalletStore((store) => store.recentConnectorIds[squidTypes.ChainType.CANTON]);
+    const connectCanton = reactQuery.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 = React.useCallback(async () => {
+        await connectedCantonWallet.wallet?.connector.disconnect();
+    }, [connectedCantonWallet.wallet?.connector]);
+    const autoConnectCanton = React.useCallback(async () => {
+        const recentCantonWallet = wallets.find((w) => w.connectorId === recentCantonWalletId);
+        if (!recentCantonWallet) {
+            return;
+        }
+        const { address } = await recentCantonWallet.connector.autoConnect();
+        setConnectedWallet(squidTypes.ChainType.CANTON, {
+            wallet: recentCantonWallet,
+            address,
+        });
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [wallets.map((w) => w.connectorId), recentCantonWalletId]);
+    React.useEffect(() => {
+        const wallet = connectedCantonWallet.wallet;
+        if (!wallet) {
+            return;
+        }
+        function onConnect(newAddress) {
+            if (wallet) {
+                setConnectedWallet(squidTypes.ChainType.CANTON, {
+                    wallet,
+                    address: newAddress,
+                });
+            }
+        }
+        function onDisconnect() {
+            disconnectWallet(squidTypes.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 = React.createContext(undefined);
+const CantonProvider = ({ children, }) => {
+    const cantonHook = useCanton();
+    return (React.createElement(CantonContext.Provider, { value: cantonHook }, children));
+};
+const useCantonContext = () => {
+    const context = React.useContext(CantonContext);
+    if (!context) {
+        throw new Error("useCantonContext must be used within a CantonProvider");
+    }
+    return context;
+};
+
 function useEvmWallets() {
     const connectors = wagmi.useConnectors();
     const wallets = React.useMemo(() => {
@@ -26766,7 +27280,7 @@ function useStellarWallets() {
             try {
                 const { allowAllModules: initializeAllModules } = await import('@creit.tech/stellar-wallets-kit');
                 const { LedgerModule } = await import('@creit.tech/stellar-wallets-kit/modules/ledger.module.mjs');
-                const { formatStellarWallet } = await Promise.resolve().then(function () { return require('./stellarService.client-C4TLBEpm.js'); });
+                const { formatStellarWallet } = await Promise.resolve().then(function () { return require('./stellarService.client-DLPxIX3n.js'); });
                 const modules = [...initializeAllModules(), new LedgerModule()];
                 const promises = modules.map(async (module) => {
                     const isAvailable = await module.isAvailable();
@@ -27239,17 +27753,24 @@ const useWallets = () => {
     const { wallets: suiWallets } = useSuiContext();
     const { wallets: xrplWallets } = useXrplContext();
     const { wallets: stellarWallets } = useStellarContext();
+    const { wallets: cantonWallets } = useCantonContext();
     const wallets = React.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,
         });
@@ -27260,6 +27781,7 @@ const useWallets = () => {
         suiWallets,
         xrplWallets,
         stellarWallets,
+        cantonWallets,
     ]);
     return {
         wallets,
@@ -27275,6 +27797,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);
@@ -27311,6 +27834,7 @@ const useWallet = () => {
                     connectSui,
                     connectXrpl,
                     connectStellar,
+                    connectCanton,
                     selectedChainTypes,
                     findChain,
                 });
@@ -27359,6 +27883,9 @@ const useWallet = () => {
                 case squidTypes.ChainType.STELLAR:
                     await disconnectStellar();
                     break;
+                case squidTypes.ChainType.CANTON:
+                    await disconnectCanton();
+                    break;
                 default:
                     // TODO: Implement disconnect for other chains
                     break;
@@ -27465,6 +27992,7 @@ const useMultiChainWallet = (chain) => {
     const suiAddress = connectedAddresses[squidTypes.ChainType.SUI];
     const xrplAddress = connectedAddresses[squidTypes.ChainType.XRPL];
     const stellarAddress = connectedAddresses[squidTypes.ChainType.STELLAR];
+    const cantonAddress = connectedAddresses[squidTypes.ChainType.CANTON];
     // Cosmos is a special case because the address changes on every chain
     // so we can't use the default cosmos connected address
     const { data: cosmosAddress } = useCosmosForChain(chain);
@@ -27552,6 +28080,16 @@ const useMultiChainWallet = (chain) => {
                         chainType: chain.chainType,
                     }),
                 };
+            case squidTypes.ChainType.CANTON:
+                if (!cantonAddress)
+                    return {};
+                return {
+                    address: cantonAddress,
+                    formatted: formatHash({
+                        hash: cantonAddress,
+                        chainType: chain.chainType,
+                    }),
+                };
         }
     }, [
         chain?.chainType,
@@ -27563,6 +28101,7 @@ const useMultiChainWallet = (chain) => {
         suiAddress,
         xrplAddress,
         stellarAddress,
+        cantonAddress,
     ]);
     /**
      * Change current network for desired chain
@@ -28387,6 +28926,8 @@ async function createClient(chain) {
             return new XrplRpcClient(chain.rpc);
         case squidTypes.ChainType.STELLAR:
             return new StellarRpcClient(chain.rpc);
+        case squidTypes.ChainType.CANTON:
+            return null;
     }
 }
 
@@ -29399,6 +29940,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
@@ -29583,9 +30172,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[squidTypes.ChainType.CANTON]?.wallet?.connector);
+    const { data: balance = "0", isLoading } = reactQuery.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 === squidTypes.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 [];
@@ -29604,6 +30213,8 @@ function useNativeTokenForChain(chain) {
                 return xrplTokens;
             case squidTypes.ChainType.STELLAR:
                 return stellarTokens;
+            case squidTypes.ChainType.CANTON:
+                return cantonTokens;
         }
     };
     const nativeTokenForChainType = React.useMemo(() => {
@@ -29785,6 +30396,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 === squidTypes.ChainType.CANTON,
+    });
+    const balance = React.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);
@@ -29815,6 +30444,10 @@ const useNativeBalance = (chain) => {
         address: connectedAddresses[squidTypes.ChainType.STELLAR],
         chain,
     });
+    const { balance: nativeCantonBalance, isLoading: isCantonLoading } = useCantonNativeBalance({
+        address: connectedAddresses[squidTypes.ChainType.CANTON],
+        chain,
+    });
     const { nativeBalance, nativeBalanceFormatted } = React.useMemo(() => {
         let balance;
         switch (chain?.chainType) {
@@ -29838,6 +30471,10 @@ const useNativeBalance = (chain) => {
                 break;
             case squidTypes.ChainType.STELLAR:
                 balance = nativeStellarBalance;
+                break;
+            case squidTypes.ChainType.CANTON:
+                balance = nativeCantonBalance;
+                break;
         }
         const balanceFormatted = !!balance
             ? formatBNToReadable(balance.value, balance.decimals)
@@ -29855,6 +30492,7 @@ const useNativeBalance = (chain) => {
         nativeSuiBalance,
         nativeXrplBalance,
         nativeStellarBalance,
+        nativeCantonBalance,
     ]);
     const isLoading = React.useMemo(() => {
         if (!chain?.chainType)
@@ -29874,6 +30512,8 @@ const useNativeBalance = (chain) => {
                 return isXrpLoading;
             case squidTypes.ChainType.STELLAR:
                 return isStellarLoading;
+            case squidTypes.ChainType.CANTON:
+                return isCantonLoading;
         }
     }, [
         chain?.chainType,
@@ -29884,6 +30524,7 @@ const useNativeBalance = (chain) => {
         isSuiLoading,
         isXrpLoading,
         isStellarLoading,
+        isCantonLoading,
     ]);
     return { nativeBalance, nativeBalanceFormatted, isLoading };
 };
@@ -30098,7 +30739,7 @@ function hederaWalletConnect(parameters) {
                 const optionalChains = config.chains.map((x) => x.id);
                 if (!optionalChains.length)
                     return;
-                const { EthereumProvider } = await Promise.resolve().then(function () { return require('./index.es-1XEAWjab.js'); });
+                const { EthereumProvider } = await Promise.resolve().then(function () { return require('./index.es-CuIvGVFi.js'); });
                 const rawProvider = await EthereumProvider.init({
                     ...restParameters,
                     disableProviderPing: true,
@@ -30303,6 +30944,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;
@@ -30310,6 +30952,7 @@ const useSigner = ({ chain }) => {
     const isSuiSignerReady = !!suiSigner;
     const isXrplSignerReady = !!xrplSigner;
     const isStellarSignerReady = !!stellarSigner;
+    const isCantonSignerReady = !!cantonSigner;
     const isSignerReady = React.useMemo(() => {
         if (!chain?.chainType)
             return false;
@@ -30328,6 +30971,8 @@ const useSigner = ({ chain }) => {
                 return isXrplSignerReady;
             case squidTypes.ChainType.STELLAR:
                 return isStellarSignerReady;
+            case squidTypes.ChainType.CANTON:
+                return isCantonSignerReady;
         }
     }, [
         chain?.chainType,
@@ -30338,6 +30983,7 @@ const useSigner = ({ chain }) => {
         isSuiSignerReady,
         isXrplSignerReady,
         isStellarSignerReady,
+        isCantonSignerReady,
     ]);
     return {
         isSignerReady,
@@ -30348,6 +30994,7 @@ const useSigner = ({ chain }) => {
         suiSigner,
         xrplSigner,
         stellarSigner,
+        cantonSigner,
     };
 };
 
@@ -30777,21 +31424,21 @@ const useSendTransactionStore = zustand.create((set, get) => ({
 
 const useDepositAddressStore = zustand.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 = React.useMemo(() => {
@@ -30800,41 +31447,55 @@ function useDepositAddress(squidRoute) {
         const chainsSupportingDepositAddress = [
             CHAIN_IDS.BITCOIN,
             CHAIN_IDS.SOLANA,
+            CHAIN_IDS.CANTON,
         ];
         return chainsSupportingDepositAddress.includes(fromChain.chainId);
     }, [fromChain?.chainId]);
-    const swapWillGenerateDepositAddress = React.useMemo(() => {
-        return (squidRoute?.transactionRequest?.type ===
-            squidTypes.SquidDataType.ChainflipDepositAddress);
-    }, [squidRoute?.transactionRequest?.type]);
-    const enable = React.useCallback(() => {
-        toggleDepositFlow(true);
-    }, [toggleDepositFlow]);
-    const disable = React.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 = React.useCallback(() => {
-        toggleDepositFlow(false);
         setDeposit(null);
-    }, [toggleDepositFlow, setDeposit]);
+    }, [setDeposit]);
     const getRouteWithDeposit = reactQuery.useMutation(async ({ route }) => {
-        if (!squid)
-            throw new Error("Squid SDK not initialized");
-        const depositAddressResponse = (await squid.executeRoute({
-            signer: {},
-            route,
-        }));
-        setDeposit(depositAddressResponse);
-        return {
-            depositAddress: depositAddressResponse,
-        };
+        if (!squid || !route.transactionRequest) {
+            throw new Error("Missing required params");
+        }
+        if (isChainflipDepositRoute(route)) {
+            const depositAddressResponse = (await squid.executeRoute({
+                signer: {},
+                route,
+            }));
+            setDeposit({
+                amount: depositAddressResponse.amount,
+                depositAddress: depositAddressResponse.depositAddress,
+                statusTrackingId: depositAddressResponse.chainflipStatusTrackingId,
+            });
+            return;
+        }
+        else if (isDepositAddressDirectTransferRoute(route.transactionRequest)) {
+            // 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,
@@ -30866,8 +31527,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[squidTypes.ChainType.CANTON]?.wallet?.connector);
     const placeholderData = React.useMemo(() => {
         const tokens = {
             [squidTypes.ChainType.EVM]: evmTokens.map((t) => ({ ...t, balance: "0" })),
@@ -30877,6 +31539,7 @@ const useAllTokensWithBalanceForChainType = ({ chainType, address, direction, qu
             [squidTypes.ChainType.SUI]: suiTokens.map((t) => ({ ...t, balance: "0" })),
             [squidTypes.ChainType.XRPL]: xrplTokens.map((t) => ({ ...t, balance: "0" })),
             [squidTypes.ChainType.STELLAR]: stellarTokens.map((t) => ({ ...t, balance: "0" })),
+            [squidTypes.ChainType.CANTON]: cantonTokens.map((t) => ({ ...t, balance: "0" })),
         };
         if (!chainType) {
             // Return all tokens with zero balance
@@ -30898,6 +31561,7 @@ const useAllTokensWithBalanceForChainType = ({ chainType, address, direction, qu
         suiTokens,
         xrplTokens,
         stellarTokens,
+        cantonTokens,
     ]);
     const isQueryEnabled = React.useMemo(() => {
         // Respect the queryOptions.enabled override if provided
@@ -30920,6 +31584,8 @@ const useAllTokensWithBalanceForChainType = ({ chainType, address, direction, qu
                 return xrplTokens.length > 0;
             case squidTypes.ChainType.STELLAR:
                 return stellarTokens.length > 0;
+            case squidTypes.ChainType.CANTON:
+                return cantonTokens.length > 0;
         }
     }, [
         chainType,
@@ -30932,6 +31598,7 @@ const useAllTokensWithBalanceForChainType = ({ chainType, address, direction, qu
         suiTokens.length,
         xrplTokens.length,
         stellarTokens.length,
+        cantonTokens.length,
     ]);
     const query = reactQuery.useQuery(keys().allTokensBalance(address, chainType, direction), async () => {
         // Return zero balances if no address
@@ -30971,6 +31638,15 @@ const useAllTokensWithBalanceForChainType = ({ chainType, address, direction, qu
             case squidTypes.ChainType.STELLAR:
                 fetchedTokens = await getAllStellarTokensBalance(address, stellarTokens, stellarChains);
                 break;
+            case squidTypes.ChainType.CANTON:
+                fetchedTokens = cantonConnector
+                    ? await getAllCantonTokensBalance({
+                        connector: cantonConnector,
+                        partyId: address,
+                        tokens: cantonTokens,
+                    })
+                    : placeholderData.tokens;
+                break;
             default:
                 fetchedTokens = placeholderData.tokens;
                 break;
@@ -31041,6 +31717,12 @@ const useAllConnectedWalletBalances = ({ direction, queryOptions = {
         direction,
         queryOptions,
     });
+    const cantonBalancesQuery = useAllTokensWithBalanceForChainType({
+        chainType: squidTypes.ChainType.CANTON,
+        address: connectedAddresses?.[squidTypes.ChainType.CANTON],
+        direction,
+        queryOptions,
+    });
     // Create a map of chain type to balance query results
     const balanceQueries = React.useMemo(() => ({
         [squidTypes.ChainType.EVM]: evmBalancesQuery,
@@ -31050,6 +31732,7 @@ const useAllConnectedWalletBalances = ({ direction, queryOptions = {
         [squidTypes.ChainType.SUI]: suiBalancesQuery,
         [squidTypes.ChainType.XRPL]: xrplBalancesQuery,
         [squidTypes.ChainType.STELLAR]: stellarBalancesQuery,
+        [squidTypes.ChainType.CANTON]: cantonBalancesQuery,
     }), [
         evmBalancesQuery,
         cosmosBalancesQuery,
@@ -31058,6 +31741,7 @@ const useAllConnectedWalletBalances = ({ direction, queryOptions = {
         suiBalancesQuery,
         xrplBalancesQuery,
         stellarBalancesQuery,
+        cantonBalancesQuery,
     ]);
     // Combine all tokens from different chains
     const allTokens = React.useMemo(() => Object.values(balanceQueries).flatMap((query) => query.data?.tokens ?? []), [balanceQueries]);
@@ -31139,6 +31823,12 @@ const useMultiChainBalance = ({ chain, token, userAddress, enabled = true, }) =>
         userAddress,
         enabled: chain?.chainType === squidTypes.ChainType.STELLAR && enabled,
     });
+    const { balance: cantonBalance } = useCantonBalance({
+        chain,
+        token,
+        userAddress,
+        enabled: chain?.chainType === squidTypes.ChainType.CANTON && enabled,
+    });
     const balance = React.useMemo(() => {
         if (!chain?.chainType)
             return "0";
@@ -31157,6 +31847,8 @@ const useMultiChainBalance = ({ chain, token, userAddress, enabled = true, }) =>
                 return xrplBalance;
             case squidTypes.ChainType.STELLAR:
                 return stellarBalance;
+            case squidTypes.ChainType.CANTON:
+                return cantonBalance;
         }
     }, [
         chain?.chainType,
@@ -31167,6 +31859,7 @@ const useMultiChainBalance = ({ chain, token, userAddress, enabled = true, }) =>
         suiBalance,
         xrplBalance,
         stellarBalance,
+        cantonBalance,
     ]);
     return { balance };
 };
@@ -31636,7 +32329,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;
@@ -31813,7 +32506,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,
@@ -32265,6 +32958,9 @@ function useSendTransaction({ to, amount, token, chain, }) {
                         chain,
                     });
                     break;
+                case squidTypes.ChainType.CANTON: {
+                    throw new Error("Not implemented");
+                }
             }
             return {
                 amount,
@@ -32468,6 +33164,8 @@ async function getSendTransactionStatus({ chain, txHash, }) {
                 txHash,
                 chain,
             });
+        case squidTypes.ChainType.CANTON:
+            throw new Error("Not implemented");
     }
 }
 
@@ -32491,7 +33189,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,
@@ -32919,6 +33617,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] = React.useState(false);
+    const [refetchInterval, setRefetchInterval] = React.useState(getSwapTxStatusRefetchInterval(transaction));
+    const { getChainType } = useSquidChains();
+    const fetchTransactionStatusWithLatestConfig = React.useCallback(async () => {
+        const latestConfig = useConfigStore.getState().config;
+        return fetchSwapTransactionStatus({
+            transaction,
+            integratorId: latestConfig.integratorId,
+            apiUrl: latestConfig.apiUrl,
+        });
+    }, [transaction]);
+    const transactionStatusQuery = reactQuery.useQuery(keys().swapTransactionStatus(transaction?.transactionId), fetchTransactionStatusWithLatestConfig, {
+        enabled: enabled &&
+            transaction?.transactionId !== "0" &&
+            !!transaction?.transactionId &&
+            !!transaction.fromAddress &&
+            !!config.apiUrl &&
+            transaction !== undefined &&
+            !isTransactionComplete &&
+            isInitialized,
+        refetchInterval(statusResponse) {
+            if (statusResponse &&
+                transactionEndStatuses.includes(getTransactionStatus(statusResponse) ?? "")) {
+                return false;
+            }
+            return refetchInterval;
+        },
+        retryDelay: getChainType(transaction?.fromChain) === squidTypes.ChainType.COSMOS ? 5000 : 3000,
+        retry: getChainType(transaction?.fromChain) === squidTypes.ChainType.COSMOS ? 6 : retry,
+        refetchOnWindowFocus,
+        onSuccess: (statusResponse) => {
+            WidgetEvents.getInstance().dispatchSwapStatus(statusResponse.squidTransactionStatus ?? "");
+            onStatus?.({
+                status: getTransactionStatus(statusResponse) ?? "",
+                statusResponse,
+            });
+            const endStatus = getTransactionEndStatus({ statusResponse });
+            if (endStatus) {
+                setIsTransactionComplete(true);
+                onEndStatus?.({ status: endStatus, statusResponse });
+            }
+        },
+        onError: (error) => {
+            if (is404Error(error.cause)) {
+                onNotFound?.();
+                return;
+            }
+            setRefetchInterval(-1);
+            setIsTransactionComplete(true);
+            onError?.();
+        },
+    });
+    return {
+        transactionStatusQuery,
+    };
+};
+
+// Statuses that indicate the source deposit has been received
+// and the swap is now progressing.
+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: exports.TransactionStatus.ONGOING,
+                sourceStatus: exports.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) => {
@@ -35965,6 +36786,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
@@ -35973,7 +37130,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();
@@ -36228,7 +37385,7 @@ const useExecuteTransaction = (squidRoute) => {
     });
     const swapMutationSolana = reactQuery.useMutation(async ({ id, route }) => {
         try {
-            if (!route) {
+            if (!route?.transactionRequest) {
                 throw new Error("Route is required");
             }
             if (!solanaSigner) {
@@ -36237,10 +37394,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
@@ -36248,7 +37405,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,
@@ -36258,7 +37415,7 @@ const useExecuteTransaction = (squidRoute) => {
                         const txParams = setTransactionState({
                             route,
                             txHash,
-                            transactionIdForStatus: depositData.chainflipStatusTrackingId,
+                            transactionIdForStatus: depositData.statusTrackingId,
                             userAddress: sourceUserAddress,
                             status: exports.TransactionStatus.INITIAL_LOADING,
                             sourceStatus: exports.TransactionStatus.ONGOING,
@@ -36309,7 +37466,7 @@ const useExecuteTransaction = (squidRoute) => {
         }
     });
     const swapMutationBitcoin = reactQuery.useMutation(async ({ id, route }) => {
-        const { depositAddress, amount: sendAmount, chainflipStatusTrackingId, } = useDepositAddressStore.getState().deposit ?? {};
+        const { depositAddress, amount: sendAmount, statusTrackingId, } = useDepositAddressStore.getState().deposit ?? {};
         if (!depositAddress) {
             throw new Error(`Invalid deposit address: ${depositAddress}`);
         }
@@ -36332,7 +37489,7 @@ const useExecuteTransaction = (squidRoute) => {
                     txHash,
                     // When bridging from Bitcoin we need to send the chainflipId to the status endpoint
                     // instead of the Bitcoin transaction hash
-                    transactionIdForStatus: chainflipStatusTrackingId,
+                    transactionIdForStatus: statusTrackingId,
                     userAddress: sourceUserAddress,
                     status: exports.TransactionStatus.INITIAL_LOADING,
                     sourceStatus: exports.TransactionStatus.ONGOING,
@@ -36524,6 +37681,56 @@ const useExecuteTransaction = (squidRoute) => {
         const sentTransaction = await client.sendTransaction(signedTransaction);
         await client.waitForTransaction(sentTransaction.hash);
     }, {});
+    const swapMutationCanton = reactQuery.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: exports.TransactionStatus.INITIAL_LOADING,
+            sourceStatus: exports.TransactionStatus.ONGOING,
+            id,
+        });
+        if (txParams) {
+            addSwapTransaction({
+                ...txParams,
+                params: route.params,
+                estimate: route.estimate,
+            });
+        }
+        return txHash;
+    });
     const handleTransactionSuccess = React.useCallback((id) => {
         const currentTx = getTransaction(id);
         queryClient.invalidateQueries(getPrefixKey(exports.QueryKeys.Balances));
@@ -36582,7 +37789,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
@@ -36608,6 +37815,9 @@ const useExecuteTransaction = (squidRoute) => {
             case squidTypes.ChainType.STELLAR: {
                 return swapMutationStellar.mutateAsync(mutationParams);
             }
+            case squidTypes.ChainType.CANTON: {
+                return swapMutationCanton.mutateAsync(mutationParams);
+            }
             default:
                 throw new Error(`Swap mutation not implemented for chain type: ${sourceChain.chainType}`);
         }
@@ -36780,7 +37990,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);
@@ -36788,8 +37998,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 = React.useMemo(() => keys().transaction(fromChain?.chainId, toChain?.chainId, toToken?.address, fromToken?.address, fromPrice, config.slippage, sourceUserAddress, config.degenMode, destinationAddress, fallbackAddress, quoteOnly, fromChain?.chainType, config.preHook, config.postHook, config.overrideGasRefundAddress), [
         fromChain?.chainId,
@@ -36933,94 +38143,50 @@ function useSendTransactionStatus({ chain, txHash, }) {
  * Fetch status of a Swap transaction
  */
 const useSwapTransactionStatus = ({ transaction, retry = 25, refetchOnWindowFocus = "always", enabled = true, }) => {
-    const config = useConfigStore((state) => state.config);
-    const isInitialized = useConfigStore((state) => state.isInitialized);
     const { replaceSwapTransactionStatus } = useHistory();
     const findTransaction = useHistoryStore((state) => state.findTransaction);
-    const [isTransactionComplete, setIsTransactionComplete] = React.useState(false);
-    const [refetchInterval, setRefetchInterval] = React.useState(getSwapTxStatusRefetchInterval(transaction));
-    const { getChainType } = useSquidChains();
     const currentHistoryItem = React.useMemo(() => findTransaction({
         transactionId: transaction?.transactionId,
         txType: exports.HistoryTxType.SWAP,
     }), [findTransaction, transaction?.transactionId]);
-    /**
-     * Transaction status endpoint
-     * Squid api is using axelar endpoint and parsing the response
-     * @returns {StatusResponse} Status response
-     */
-    const fetchTransactionStatusWithLatestConfig = React.useCallback(async () => {
-        const latestConfig = useConfigStore.getState().config;
-        return fetchSwapTransactionStatus({
-            transaction,
-            integratorId: latestConfig.integratorId,
-            apiUrl: latestConfig.apiUrl,
-        });
-    }, [transaction]);
-    const transactionStatusQuery = reactQuery.useQuery(keys().swapTransactionStatus(transaction?.transactionId), fetchTransactionStatusWithLatestConfig, {
+    const transactionStatusQuery = useSwapStatusQuery({
+        transaction,
+        retry,
+        refetchOnWindowFocus,
         enabled: enabled &&
-            transaction?.transactionId !== "0" &&
-            !!transaction?.transactionId &&
-            !!transaction.fromAddress &&
-            !!config.apiUrl &&
-            transaction !== undefined &&
-            !isTransactionComplete &&
-            isInitialized &&
             !!currentHistoryItem &&
             !isHistoryTransactionEnded({
                 data: currentHistoryItem?.data,
                 txType: exports.HistoryTxType.SWAP,
             }),
-        refetchInterval(statusResponse) {
-            // If the status response is something telling that the transaction
-            // is finished, then store transaction history state if success
-            // And return false to indicate refetcher to stop
-            if (statusResponse &&
-                transactionEndStatuses.includes(getTransactionStatus(statusResponse) ?? "")) {
-                return false;
-            }
-            return refetchInterval; // Had to handle a variable here because after onError, we want the interval to stop
+        onEndStatus: ({ status, statusResponse }) => {
+            if (!transaction?.transactionId)
+                return;
+            replaceSwapTransactionStatus({
+                transactionId: transaction.transactionId,
+                statusResponse,
+                status,
+            });
         },
-        // At the moment Cosmos indexing takes more time, so need more time between retries
-        retryDelay: getChainType(transaction?.fromChain) === squidTypes.ChainType.COSMOS ? 5000 : 3000,
-        retry: getChainType(transaction?.fromChain) === squidTypes.ChainType.COSMOS ? 6 : retry,
-        refetchOnWindowFocus,
-        onSuccess: (statusResponse) => {
-            // Dispatch event
-            WidgetEvents.getInstance().dispatchSwapStatus(statusResponse.squidTransactionStatus ?? "");
-            const endStatus = getTransactionEndStatus({ statusResponse });
-            if (endStatus && transaction?.transactionId) {
-                setIsTransactionComplete(true);
-                replaceSwapTransactionStatus({
-                    transactionId: transaction.transactionId,
-                    statusResponse,
-                    status: endStatus,
-                });
-            }
+        onNotFound: () => {
+            if (!transaction?.transactionId)
+                return;
+            replaceSwapTransactionStatus({
+                transactionId: transaction.transactionId,
+                statusResponse: undefined,
+                status: exports.TransactionStatus.NOT_FOUND,
+            });
         },
-        onError: (error) => {
-            // `fetchTransactionStatus` throws an error with a cause being an AxiosError
-            const is404 = is404Error(error.cause);
+        onError: () => {
             if (!transaction?.transactionId)
                 return;
-            if (is404) {
-                replaceSwapTransactionStatus({
-                    transactionId: transaction.transactionId,
-                    statusResponse: undefined,
-                    status: exports.TransactionStatus.NOT_FOUND,
-                });
-            }
-            else {
-                setRefetchInterval(-1);
-                setIsTransactionComplete(true);
-                replaceSwapTransactionStatus({
-                    transactionId: transaction.transactionId,
-                    statusResponse: undefined,
-                    status: exports.TransactionStatus.ERROR,
-                });
-            }
+            replaceSwapTransactionStatus({
+                transactionId: transaction.transactionId,
+                statusResponse: undefined,
+                status: exports.TransactionStatus.ERROR,
+            });
         },
-    });
+    }).transactionStatusQuery;
     return {
         transactionStatusQuery,
         latestStatus: transactionStatusQuery.data
@@ -37419,8 +38585,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 ||
@@ -37452,8 +38620,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
@@ -37488,13 +38656,14 @@ const SquidProvider = ({ children, config, placeholder, }) => {
     }, [initializeSdk]);
     return wagmiConfig ? (React.createElement(wagmi.WagmiProvider, { reconnectOnMount: false, config: wagmiConfig },
         React.createElement(reactQuery.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);
+            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);
 };
 
 exports.CHAIN_IDS = CHAIN_IDS;
@@ -37510,13 +38679,13 @@ exports.SquidProvider = SquidProvider;
 exports.TX_STATUS_CONSTANTS = TX_STATUS_CONSTANTS;
 exports.WidgetEvents = WidgetEvents;
 exports.Wo = Wo;
-exports.accessProperty = accessProperty;
 exports.adaptiveRound = adaptiveRound;
 exports.addEthereumChain = addEthereumChain;
 exports.addTokenToWallet = addTokenToWallet;
 exports.areSameAddress = areSameAddress;
 exports.areTokenSymbolsCompatible = areTokenSymbolsCompatible;
 exports.assetsBaseUrl = assetsBaseUrl;
+exports.buildFallbackWallets = buildFallbackWallets;
 exports.buildUrlSearchParamsFromSwapEvent = buildUrlSearchParamsFromSwapEvent;
 exports.buildXrplTrustSetTx = buildXrplTrustSetTx;
 exports.calculateTotal24hChange = calculateTotal24hChange;
@@ -37609,13 +38778,14 @@ exports.getXummClient = getXummClient;
 exports.groupTokensByChainId = groupTokensByChainId;
 exports.groupTokensBySymbol = groupTokensBySymbol;
 exports.handleTransactionErrorEvents = handleTransactionErrorEvents;
-exports.initializeSquidWithAssetsColors = initializeSquidWithAssetsColors;
+exports.initializeSquidData = initializeSquidData;
 exports.is404Error = is404Error;
 exports.isActionCompletedOnSourceTx = isActionCompletedOnSourceTx;
 exports.isChainflipBridgeTransaction = isChainflipBridgeTransaction;
+exports.isChainflipDepositRoute = isChainflipDepositRoute;
 exports.isCoralBridgeAction = isCoralBridgeAction;
 exports.isCosmosAddressValid = isCosmosAddressValid;
-exports.isDepositRoute = isDepositRoute;
+exports.isDepositAddressDirectTransferRoute = isDepositAddressDirectTransferRoute;
 exports.isEmptyObject = isEmptyObject;
 exports.isEvmChainNotSupportedError = isEvmChainNotSupportedError;
 exports.isEvmosChain = isEvmosChain;
@@ -37631,6 +38801,7 @@ exports.isStatusError = isStatusError;
 exports.isStellarAddressValid = isStellarAddressValid;
 exports.isStellarIssuedToken = isStellarIssuedToken;
 exports.isStellarToken = isStellarToken;
+exports.isSupportedChainType = isSupportedChainType;
 exports.isSwapRouteError = isSwapRouteError;
 exports.isUserRejectionError = isUserRejectionError;
 exports.isValidHorizonAsset = isValidHorizonAsset;
@@ -37695,6 +38866,7 @@ exports.useCountryDetails = useCountryDetails;
 exports.useCurrencyDetails = useCurrencyDetails;
 exports.useDebouncedValue = useDebouncedValue;
 exports.useDepositAddress = useDepositAddress;
+exports.useDepositTransactionStatus = useDepositTransactionStatus;
 exports.useEnsDataForAddress = useEnsDataForAddress;
 exports.useEnsSearch = useEnsSearch;
 exports.useEstimate = useEstimate;
@@ -37761,4 +38933,4 @@ exports.useXrplTrustLine = useXrplTrustLine;
 exports.waitForReceiptWithRetry = waitForReceiptWithRetry;
 exports.walletIconBaseUrl = walletIconBaseUrl;
 exports.walletSupportsChainType = walletSupportsChainType;
-//# sourceMappingURL=index-DcBFug8t.js.map
+//# sourceMappingURL=index-doLvokYY.js.map