@tronweb3/tronwallet-adapter-trust 1.0.3 → 1.2.0

package/lib/umd/index.js

@@ -363,82 +363,7 @@
 		return eventemitter3.exports;
 	}
 
-	var hasRequiredAdapter$2;
-
-	function requireAdapter$2 () {
-		if (hasRequiredAdapter$2) return adapter$1;
-		hasRequiredAdapter$2 = 1;
-		var __importDefault = (adapter$1 && adapter$1.__importDefault) || function (mod) {
-		    return (mod && mod.__esModule) ? mod : { "default": mod };
-		};
-		Object.defineProperty(adapter$1, "__esModule", { value: true });
-		adapter$1.Adapter = adapter$1.AdapterState = adapter$1.WalletReadyState = adapter$1.EventEmitter = void 0;
-		const eventemitter3_1 = __importDefault(requireEventemitter3());
-		adapter$1.EventEmitter = eventemitter3_1.default;
-		/**
-		 * Wallet ready state.
-		 */
-		var WalletReadyState;
-		(function (WalletReadyState) {
-		    /**
-		     * Adapter will start to check if wallet exists after adapter instance is created.
-		     */
-		    WalletReadyState["Loading"] = "Loading";
-		    /**
-		     * When checking ends and wallet is not found, readyState will be NotFound.
-		     */
-		    WalletReadyState["NotFound"] = "NotFound";
-		    /**
-		     * When checking ends and wallet is found, readyState will be Found.
-		     */
-		    WalletReadyState["Found"] = "Found";
-		})(WalletReadyState || (adapter$1.WalletReadyState = WalletReadyState = {}));
-		/**
-		 * Adapter state
-		 */
-		var AdapterState;
-		(function (AdapterState) {
-		    /**
-		     * If adapter is checking the wallet, the state is Loading.
-		     */
-		    AdapterState["Loading"] = "Loading";
-		    /**
-		     * If wallet is not installed, the state is NotFound.
-		     */
-		    AdapterState["NotFound"] = "NotFound";
-		    /**
-		     * If wallet is installed but is not connected to current Dapp, the state is Disconnected.
-		     */
-		    AdapterState["Disconnect"] = "Disconnected";
-		    /**
-		     * Wallet is connected to current Dapp.
-		     */
-		    AdapterState["Connected"] = "Connected";
-		})(AdapterState || (adapter$1.AdapterState = AdapterState = {}));
-		class Adapter extends eventemitter3_1.default {
-		    get connected() {
-		        return this.state === AdapterState.Connected;
-		    }
-		    /**
-		     * Some wallets such as TronLink don't support disconnect() method.
-		     */
-		    disconnect() {
-		        console.info("The current adapter doesn't support disconnect by DApp.");
-		        return Promise.resolve();
-		    }
-		    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-		    multiSign(transaction, options = {}) {
-		        return Promise.reject("The current wallet doesn't support multiSign.");
-		    }
-		    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-		    switchChain(_chainId) {
-		        return Promise.reject("The current wallet doesn't support switch chain.");
-		    }
-		}
-		adapter$1.Adapter = Adapter;
-		
-		return adapter$1;
-	}
+	var typedData = {};
 
 	var errors = {};
 
@@ -448,7 +373,7 @@
 		if (hasRequiredErrors) return errors;
 		hasRequiredErrors = 1;
 		Object.defineProperty(errors, "__esModule", { value: true });
-		errors.WalletGetNetworkError = errors.WalletSwitchChainError = errors.WalletWindowClosedError = errors.WalletWalletLoadError = errors.WalletSignTransactionError = errors.WalletSignMessageError = errors.WalletDisconnectionError = errors.WalletConnectionError = errors.WalletDisconnectedError = errors.WalletNotSelectedError = errors.WalletNotFoundError = errors.WalletError = void 0;
+		errors.WalletSignTypedDataError = errors.WalletGetNetworkError = errors.WalletSwitchChainError = errors.WalletWindowClosedError = errors.WalletWalletLoadError = errors.WalletSignTransactionError = errors.WalletSignMessageError = errors.WalletDisconnectionError = errors.WalletConnectionError = errors.WalletDisconnectedError = errors.WalletNotSelectedError = errors.WalletNotFoundError = errors.WalletError = void 0;
 		class WalletError extends Error {
 		    constructor(message, error) {
 		        super(message);
@@ -569,10 +494,113 @@
 		    }
 		}
 		errors.WalletGetNetworkError = WalletGetNetworkError;
+		/**
+		 * Occurs when call `signTypedData()`.
+		 */
+		class WalletSignTypedDataError extends WalletError {
+		    constructor() {
+		        super(...arguments);
+		        this.name = 'WalletSignTypedDataError';
+		    }
+		}
+		errors.WalletSignTypedDataError = WalletSignTypedDataError;
 		
 		return errors;
 	}
 
+	var hasRequiredTypedData;
+
+	function requireTypedData () {
+		if (hasRequiredTypedData) return typedData;
+		hasRequiredTypedData = 1;
+		Object.defineProperty(typedData, "__esModule", { value: true });
+		typedData.normalizeAndValidateTypedData = normalizeAndValidateTypedData;
+		const errors_js_1 = requireErrors();
+		function isPlainObject(value) {
+		    return typeof value === 'object' && value !== null && !Array.isArray(value);
+		}
+		/** Non-negative decimal integer, e.g. `1`, `728126428`. */
+		const DECIMAL_INTEGER = /^[0-9]+$/;
+		/** Non-negative hex integer, e.g. `0x2b6653dc`. `BigInt` accepts either prefix case. */
+		const HEX_INTEGER = /^0[xX][0-9a-fA-F]+$/;
+		/**
+		 * Convert a `domain.chainId` to the `number` wallets expect, refusing anything
+		 * that cannot survive the trip.
+		 *
+		 * EIP-712 declares `chainId` as `uint256`, but `Number()` maps that domain onto
+		 * IEEE-754 doubles and quietly accepts values that are not integers at all:
+		 * `Number('9007199254740993')` yields `9007199254740992`, and `'1.5'`, `'-1'`,
+		 * `'1e3'` and `''` all pass `Number.isFinite()`. Each of those makes the wallet
+		 * sign a domain that differs from what the caller supplied, so the signature no
+		 * longer corresponds to the original payload. Parsing through `BigInt` keeps the
+		 * value exact and lets the unrepresentable cases fail loudly instead.
+		 */
+		function toChainIdNumber(chainId) {
+		    // Reject anything that is not an integer literal before converting. `Number()`
+		    // happily turns `'1.5'`, `'-1'`, `'1e3'` and `''` into finite numbers, none of
+		    // which is a uint256.
+		    if (typeof chainId === 'string') {
+		        const value = chainId.trim();
+		        if (!DECIMAL_INTEGER.test(value) && !HEX_INTEGER.test(value)) {
+		            throw new errors_js_1.WalletSignTypedDataError(`Invalid domain.chainId: ${chainId}. Expected a non-negative decimal or 0x-prefixed hex integer.`);
+		        }
+		    }
+		    const parsed = Number(chainId);
+		    // Catches NaN, Infinity and fractions, which only a number/bigint input can
+		    // still be at this point — the string form was already gated by the regexes.
+		    if (!Number.isInteger(parsed)) {
+		        throw new errors_js_1.WalletSignTypedDataError(`Invalid domain.chainId: ${chainId}. Expected a non-negative integer.`);
+		    }
+		    if (parsed < 0) {
+		        throw new errors_js_1.WalletSignTypedDataError(`Invalid domain.chainId: ${chainId}. Expected a non-negative integer.`);
+		    }
+		    // With integrality established, `isSafeInteger` is an exact bound check rather
+		    // than an approximation: every integer up to MAX_SAFE_INTEGER converts
+		    // losslessly, and anything larger necessarily rounds to 2^53 or beyond, which is
+		    // never "safe". So a value that survives this equals what the caller supplied.
+		    if (!Number.isSafeInteger(parsed)) {
+		        throw new errors_js_1.WalletSignTypedDataError(`domain.chainId ${chainId} exceeds Number.MAX_SAFE_INTEGER (${Number.MAX_SAFE_INTEGER}) and cannot be represented as a number without losing precision.`);
+		    }
+		    return parsed;
+		}
+		/**
+		 * Validate a TypedData payload and return a normalized copy safe to pass to wallets.
+		 *
+		 * Current normalization: convert `domain.chainId` to a number (some wallets,
+		 * e.g. TronLink, require a numeric chainId). `null`/`undefined` are left alone
+		 * because `chainId` is optional, as are values of other types — a `BigNumber`
+		 * instance is a legitimate `BigNumberish` and is passed through untouched.
+		 *
+		 * Throws {@link WalletSignTypedDataError} if the payload is not a valid TypedData
+		 * object, or if `domain.chainId` cannot be represented exactly as a number.
+		 */
+		function normalizeAndValidateTypedData(typedData) {
+		    if (!isPlainObject(typedData)) {
+		        throw new errors_js_1.WalletSignTypedDataError('typedData must be an object.');
+		    }
+		    if (!isPlainObject(typedData.domain)) {
+		        throw new errors_js_1.WalletSignTypedDataError('typedData.domain must be an object.');
+		    }
+		    if (!isPlainObject(typedData.types)) {
+		        throw new errors_js_1.WalletSignTypedDataError('typedData.types must be an object.');
+		    }
+		    if (!isPlainObject(typedData.message)) {
+		        throw new errors_js_1.WalletSignTypedDataError('typedData.message must be an object.');
+		    }
+		    const { chainId } = typedData.domain;
+		    if (typeof chainId === 'string' || typeof chainId === 'number' || typeof chainId === 'bigint') {
+		        const parsed = toChainIdNumber(chainId);
+		        if (parsed === chainId) {
+		            return typedData;
+		        }
+		        return Object.assign(Object.assign({}, typedData), { domain: Object.assign(Object.assign({}, typedData.domain), { chainId: parsed }) });
+		    }
+		    return typedData;
+		}
+		
+		return typedData;
+	}
+
 	var types$1 = {};
 
 	var hasRequiredTypes$1;
@@ -581,7 +609,47 @@
 		if (hasRequiredTypes$1) return types$1;
 		hasRequiredTypes$1 = 1;
 		Object.defineProperty(types$1, "__esModule", { value: true });
-		types$1.TIP6963RequestProviderEventName = types$1.TIP6963AnnounceProviderEventName = types$1.ChainNetwork = types$1.NetworkType = void 0;
+		types$1.TIP6963RequestProviderEventName = types$1.TIP6963AnnounceProviderEventName = types$1.ChainNetwork = types$1.NetworkType = types$1.AdapterState = types$1.WalletReadyState = void 0;
+		/**
+		 * Wallet ready state.
+		 */
+		var WalletReadyState;
+		(function (WalletReadyState) {
+		    /**
+		     * Adapter will start to check if wallet exists after adapter instance is created.
+		     */
+		    WalletReadyState["Loading"] = "Loading";
+		    /**
+		     * When checking ends and wallet is not found, readyState will be NotFound.
+		     */
+		    WalletReadyState["NotFound"] = "NotFound";
+		    /**
+		     * When checking ends and wallet is found, readyState will be Found.
+		     */
+		    WalletReadyState["Found"] = "Found";
+		})(WalletReadyState || (types$1.WalletReadyState = WalletReadyState = {}));
+		/**
+		 * Adapter state
+		 */
+		var AdapterState;
+		(function (AdapterState) {
+		    /**
+		     * If adapter is checking the wallet, the state is Loading.
+		     */
+		    AdapterState["Loading"] = "Loading";
+		    /**
+		     * If wallet is not installed, the state is NotFound.
+		     */
+		    AdapterState["NotFound"] = "NotFound";
+		    /**
+		     * If wallet is installed but is not connected to current Dapp, the state is Disconnected.
+		     */
+		    AdapterState["Disconnect"] = "Disconnected";
+		    /**
+		     * Wallet is connected to current Dapp.
+		     */
+		    AdapterState["Connected"] = "Connected";
+		})(AdapterState || (types$1.AdapterState = AdapterState = {}));
 		var NetworkType;
 		(function (NetworkType) {
 		    NetworkType["Mainnet"] = "Mainnet";
@@ -604,6 +672,59 @@
 		return types$1;
 	}
 
+	var hasRequiredAdapter$2;
+
+	function requireAdapter$2 () {
+		if (hasRequiredAdapter$2) return adapter$1;
+		hasRequiredAdapter$2 = 1;
+		var __importDefault = (adapter$1 && adapter$1.__importDefault) || function (mod) {
+		    return (mod && mod.__esModule) ? mod : { "default": mod };
+		};
+		Object.defineProperty(adapter$1, "__esModule", { value: true });
+		adapter$1.Adapter = adapter$1.EventEmitter = void 0;
+		const eventemitter3_1 = __importDefault(requireEventemitter3());
+		adapter$1.EventEmitter = eventemitter3_1.default;
+		const typedData_js_1 = requireTypedData();
+		const types_js_1 = requireTypes$1();
+		class Adapter extends eventemitter3_1.default {
+		    get connected() {
+		        return this.state === types_js_1.AdapterState.Connected;
+		    }
+		    /**
+		     * Some wallets such as TronLink don't support disconnect() method.
+		     */
+		    disconnect() {
+		        console.info("The current adapter doesn't support disconnect by DApp.");
+		        return Promise.resolve();
+		    }
+		    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+		    multiSign(transaction, options = {}) {
+		        return Promise.reject("The current wallet doesn't support multiSign.");
+		    }
+		    signTypedData(typedData) {
+		        let normalized;
+		        try {
+		            normalized = (0, typedData_js_1.normalizeAndValidateTypedData)(typedData);
+		        }
+		        catch (error) {
+		            return Promise.reject(error);
+		        }
+		        return this._signTypedData(normalized);
+		    }
+		    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+		    _signTypedData(_typedData) {
+		        return Promise.reject("The current wallet doesn't support signTypedData.");
+		    }
+		    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+		    switchChain(_chainId) {
+		        return Promise.reject("The current wallet doesn't support switch chain.");
+		    }
+		}
+		adapter$1.Adapter = Adapter;
+		
+		return adapter$1;
+	}
+
 	var utils$2 = {};
 
 	var hasRequiredUtils$2;
@@ -611,59 +732,543 @@
 	function requireUtils$2 () {
 		if (hasRequiredUtils$2) return utils$2;
 		hasRequiredUtils$2 = 1;
-		Object.defineProperty(utils$2, "__esModule", { value: true });
-		utils$2.isInBrowser = isInBrowser;
-		utils$2.checkAdapterState = checkAdapterState;
-		utils$2.isInMobileBrowser = isInMobileBrowser;
-		/**
-		 * check simply if current environment is browser or not
-		 * @returns boolean
-		 */
-		function isInBrowser() {
-		    return typeof window !== 'undefined' && typeof document !== 'undefined' && typeof navigator !== 'undefined';
-		}
+		(function (exports$1) {
+			Object.defineProperty(exports$1, "__esModule", { value: true });
+			exports$1.MAX_CHECK_TIMEOUT = void 0;
+			exports$1.validateCheckTimeout = validateCheckTimeout;
+			exports$1.omitUndefined = omitUndefined;
+			exports$1.assertConnectAddress = assertConnectAddress;
+			exports$1.isInBrowser = isInBrowser;
+			exports$1.checkAdapterState = checkAdapterState;
+			exports$1.isInMobileBrowser = isInMobileBrowser;
+			const errors_js_1 = requireErrors();
+			/**
+			 * Upper bound for `config.checkTimeout`, in milliseconds.
+			 *
+			 * Wallet detection polls on a fixed interval and gives up after
+			 * `checkTimeout / interval` ticks. An unbounded value makes that loop
+			 * indistinguishable from one that never stops, so it is capped. Ten minutes is
+			 * far beyond any realistic detection window.
+			 */
+			exports$1.MAX_CHECK_TIMEOUT = 10 * 60 * 1000;
+			/**
+			 * Validate `config.checkTimeout` and throw when it cannot produce a terminating
+			 * detection loop.
+			 *
+			 * `typeof value === 'number'` is not enough on its own: `NaN` and `Infinity` are
+			 * numbers, and adapters derive their polling bound from
+			 * `Math.floor(checkTimeout / interval)`. With `NaN` that bound is `NaN`, so
+			 * `times > maxTimes` is never true — the interval is never cleared and the
+			 * detection promise never settles, hanging `connect()` for the life of the page.
+			 * TypeScript cannot prevent this because adapters are also constructed from
+			 * plain JavaScript, JSON config and `as any`.
+			 *
+			 * @param value the raw value taken from the adapter config
+			 * @param prefix prefix used in the thrown message, e.g. `[TronLinkAdapter]`
+			 */
+			function validateCheckTimeout(value, prefix = '[WalletAdapter]') {
+			    if (typeof value !== 'number') {
+			        throw new Error(`${prefix} config.checkTimeout should be a number`);
+			    }
+			    if (!Number.isFinite(value) || value < 0 || value > exports$1.MAX_CHECK_TIMEOUT) {
+			        throw new Error(`${prefix} config.checkTimeout should be a finite number between 0 and ${exports$1.MAX_CHECK_TIMEOUT}, but got ${value}`);
+			    }
+			}
+			/**
+			 * Copy an object without the keys whose value is exactly `undefined`.
+			 *
+			 * Spreading a caller's config over a set of defaults is only safe when explicit
+			 * `undefined`s have been dropped first: `{ ...defaults, ...{ checkTimeout: undefined } }`
+			 * yields `checkTimeout: undefined`, which defeats the default and every validation
+			 * that ran against it. Callers routinely produce such objects by spreading their own
+			 * optional config, so adapters must sanitise before merging rather than trusting the
+			 * `Required<...>` type on the resulting field.
+			 *
+			 * @param params the raw config object, possibly `undefined`
+			 * @returns a shallow copy containing only the keys that were actually set
+			 */
+			function omitUndefined(params) {
+			    return Object.fromEntries(Object.entries(params !== null && params !== void 0 ? params : {}).filter(([, value]) => value !== undefined));
+			}
+			/**
+			 * Guard the transition into `AdapterState.Connected`.
+			 *
+			 * A resolved account request is not the same thing as a connection. Wallets
+			 * answer `tron_requestAccounts`/`eth_requestAccounts` with a success code while
+			 * still returning an empty account list, and injected `tronWeb.defaultAddress`
+			 * is frequently not populated yet at the moment the request resolves. Treating
+			 * either as "connected" leaves the adapter reporting `connected === true` with
+			 * no address, and emits `connect('')` to the dapp; every later signMessage or
+			 * signTransaction then passes the state guard only to fail inside the provider.
+			 *
+			 * @param address the address the adapter is about to store. `false` is accepted
+			 * because tronweb types `tronWeb.defaultAddress.base58` as `string | false`.
+			 * @returns the same address, narrowed to a non-empty string
+			 * @throws {WalletConnectionError} when no usable address was obtained
+			 */
+			function assertConnectAddress(address) {
+			    if (!address) {
+			        throw new errors_js_1.WalletConnectionError('Request connect error.');
+			    }
+			    return address;
+			}
+			/**
+			 * check simply if current environment is browser or not
+			 * @returns boolean
+			 */
+			function isInBrowser() {
+			    return typeof window !== 'undefined' && typeof document !== 'undefined' && typeof navigator !== 'undefined';
+			}
+			/**
+			 *
+			 * @param {Function} check funcion to check if wallet is installed. return true if wallet is detected.
+			 * @returns
+			 */
+			function checkAdapterState(check) {
+			    if (!isInBrowser())
+			        return;
+			    const disposers = [];
+			    function dispose() {
+			        for (const dispose of disposers) {
+			            dispose();
+			        }
+			    }
+			    function checkAndDispose() {
+			        if (check()) {
+			            dispose();
+			        }
+			    }
+			    const interval = setInterval(checkAndDispose, 500);
+			    disposers.push(() => clearInterval(interval));
+			    if (document.readyState === 'loading') {
+			        document.addEventListener('DOMContentLoaded', checkAndDispose, { once: true });
+			        disposers.push(() => document.removeEventListener('DOMContentLoaded', checkAndDispose));
+			    }
+			    if (document.readyState !== 'complete') {
+			        window.addEventListener('load', checkAndDispose, { once: true });
+			        disposers.push(() => window.removeEventListener('load', checkAndDispose));
+			    }
+			    checkAndDispose();
+			    // stop all task after 1min
+			    setTimeout(dispose, 60 * 1000);
+			}
+			/**
+			 * Simplily detect mobile device
+			 */
+			function isInMobileBrowser() {
+			    return (typeof navigator !== 'undefined' &&
+			        navigator.userAgent.match(/Android|webOS|iPhone|iPad|iPod|BlackBerry|Windows Phone/i));
+			}
+			
+		} (utils$2));
+		return utils$2;
+	}
+
+	var addonAdapter = {};
+
+	var security = {};
+
+	var hasRequiredSecurity;
+
+	function requireSecurity () {
+		if (hasRequiredSecurity) return security;
+		hasRequiredSecurity = 1;
+		(function (exports$1) {
+			var __awaiter = (security && security.__awaiter) || function (thisArg, _arguments, P, generator) {
+			    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+			    return new (P || (P = Promise))(function (resolve, reject) {
+			        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+			        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+			        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+			        step((generator = generator.apply(thisArg, _arguments || [])).next());
+			    });
+			};
+			Object.defineProperty(exports$1, "__esModule", { value: true });
+			exports$1.defaultSecurityOptions = void 0;
+			exports$1.validateSecurityOptions = validateSecurityOptions;
+			exports$1.clearCache = clearCache;
+			exports$1.fetchJsonWithCache = fetchJsonWithCache;
+			exports$1.defaultSecurityOptions = {
+			    onRiskDetected: (result) => __awaiter(void 0, void 0, void 0, function* () {
+			        console.log(`[WalletAdapter] Risk detected:`, result);
+			    }),
+			    configUrls: [],
+			    enabled: false,
+			    timeout: 2000,
+			    retries: 0,
+			    cacheTTL: 10 * 60 * 1000,
+			};
+			/** A config fetch that takes longer than this is never worth waiting for. */
+			const MAX_SECURITY_TIMEOUT = 60 * 1000;
+			/** `retries` multiplies the time `connect()` can block, so it is capped. */
+			const MAX_SECURITY_RETRIES = 10;
+			function assertFiniteNumber(value, field, min, max) {
+			    if (typeof value !== 'number' || !Number.isFinite(value) || value < min || value > max) {
+			        throw new Error(`[WalletAdapter] config.securityOptions.${field} should be a finite number between ${min} and ${max}, but got ${String(value)}`);
+			    }
+			}
+			function parseAbsoluteUrl(url) {
+			    try {
+			        return new URL(url);
+			    }
+			    catch (_a) {
+			        // Not absolute — a relative path, which `fetch` resolves against the page.
+			        return null;
+			    }
+			}
+			function validateConfigUrls(configUrls) {
+			    if (!Array.isArray(configUrls)) {
+			        throw new Error(`[WalletAdapter] config.securityOptions.configUrls should be an array of URLs, but got ${typeof configUrls}`);
+			    }
+			    for (const url of configUrls) {
+			        if (typeof url !== 'string' || url.trim() === '') {
+			            throw new Error(`[WalletAdapter] config.securityOptions.configUrls should only contain non-empty URL strings, but got ${String(url)}`);
+			        }
+			        // Relative paths are legitimate — they resolve against the page and `new URL`
+			        // rejects them — so only values that parse as an absolute URL are checked,
+			        // and then only for the scheme `fetch` can actually retrieve.
+			        const parsed = parseAbsoluteUrl(url);
+			        if (parsed && parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+			            throw new Error(`[WalletAdapter] config.securityOptions.configUrls only supports http(s) URLs, but got ${url}`);
+			        }
+			    }
+			}
+			/**
+			 * Validate `config.securityOptions` at construction time.
+			 *
+			 * Every field here is consumed much later, inside `connect()` — a `configUrls`
+			 * string instead of an array only fails when `fetchJsonWithCache` calls `.map`
+			 * on it, and a `NaN` timeout or a negative `retries` silently changes the fetch
+			 * behaviour rather than reporting anything. Failing fast in the constructor puts
+			 * the error where the caller can act on it.
+			 */
+			function validateSecurityOptions(securityOptions) {
+			    const { enabled, configUrls, timeout, retries, cacheTTL, onRiskDetected, onConfigFallback } = securityOptions;
+			    // `enabled` is read as a plain truthy value in `checkSecurity()` and again just
+			    // below, so a non-boolean silently resolves to the opposite of what it reads like:
+			    // `'false'` is truthy and turns the check on. Check it before the `configUrls`
+			    // requirement below, or `{ enabled: 'false' }` reports a missing `configUrls`
+			    // "when enabled is true" — for a caller who wrote `false`.
+			    if (enabled !== undefined && typeof enabled !== 'boolean') {
+			        throw new Error(`[WalletAdapter] config.securityOptions.enabled should be a boolean, but got ${typeof enabled}`);
+			    }
+			    if (configUrls !== undefined) {
+			        validateConfigUrls(configUrls);
+			    }
+			    if (enabled && (!configUrls || configUrls.length === 0)) {
+			        throw new Error(`[WalletAdapter] config.securityOptions.configUrls is required when securityOptions.enabled is true`);
+			    }
+			    if (timeout !== undefined) {
+			        assertFiniteNumber(timeout, 'timeout', 1, MAX_SECURITY_TIMEOUT);
+			    }
+			    if (cacheTTL !== undefined) {
+			        // No upper bound: caching the risk config for a long time is a valid choice.
+			        assertFiniteNumber(cacheTTL, 'cacheTTL', 0, Number.MAX_SAFE_INTEGER);
+			    }
+			    if (retries !== undefined && (!Number.isInteger(retries) || retries < 0 || retries > MAX_SECURITY_RETRIES)) {
+			        throw new Error(`[WalletAdapter] config.securityOptions.retries should be an integer between 0 and ${MAX_SECURITY_RETRIES}, but got ${String(retries)}`);
+			    }
+			    if (onRiskDetected !== undefined && typeof onRiskDetected !== 'function') {
+			        throw new Error(`[WalletAdapter] config.securityOptions.onRiskDetected should be a function, but got ${typeof onRiskDetected}`);
+			    }
+			    if (onConfigFallback !== undefined && typeof onConfigFallback !== 'function') {
+			        throw new Error(`[WalletAdapter] config.securityOptions.onConfigFallback should be a function, but got ${typeof onConfigFallback}`);
+			    }
+			}
+			function isValidRisk(risk) {
+			    return (!!risk &&
+			        typeof risk === 'object' &&
+			        typeof risk.title === 'string' &&
+			        risk.title.length > 0 &&
+			        (risk.noticeType === 1 || risk.noticeType === 2 || risk.noticeType === 3));
+			}
+			function sanitizeRisk(risk) {
+			    const clean = { title: risk.title, noticeType: risk.noticeType };
+			    if (typeof risk.ext === 'string')
+			        clean.ext = risk.ext;
+			    if (typeof risk.ios === 'string')
+			        clean.ios = risk.ios;
+			    if (typeof risk.and === 'string')
+			        clean.and = risk.and;
+			    return clean;
+			}
+			/**
+			 * Defensively coerce an arbitrary remote payload into a well-formed RiskConfig.
+			 *
+			 * The config comes from a remote URL, so a bad release (or a tampered response)
+			 * must never break the connect flow. Anything malformed is dropped with a
+			 * warning rather than thrown: `wallets` must be a record whose values are
+			 * arrays, and each risk must have a non-empty string `title` and a `noticeType`
+			 * of 1/2/3. Invalid entries are discarded so downstream merging/consumption
+			 * only ever sees clean `Risk[]`.
+			 */
+			function normalizeRiskConfig(data) {
+			    const source = data && typeof data === 'object' ? data : {};
+			    const wallets = {};
+			    if (source.wallets && typeof source.wallets === 'object') {
+			        for (const [walletName, rawRisks] of Object.entries(source.wallets)) {
+			            if (!Array.isArray(rawRisks)) {
+			                console.warn(`[WalletAdapter] Ignoring malformed risks for "${walletName}": expected an array, got ${typeof rawRisks}.`);
+			                continue;
+			            }
+			            const validRisks = [];
+			            for (const risk of rawRisks) {
+			                if (isValidRisk(risk)) {
+			                    validRisks.push(sanitizeRisk(risk));
+			                }
+			                else {
+			                    console.warn(`[WalletAdapter] Dropping malformed risk entry for "${walletName}":`, risk);
+			                }
+			            }
+			            if (validRisks.length > 0) {
+			                wallets[walletName] = validRisks;
+			            }
+			        }
+			    }
+			    return {
+			        v: typeof source.v === 'string' ? source.v : '',
+			        ts: typeof source.ts === 'number' ? source.ts : 0,
+			        wallets,
+			    };
+			}
+			const _jsonCache = {};
+			function clearCache() {
+			    Object.keys(_jsonCache).forEach((key) => {
+			        Reflect.deleteProperty(_jsonCache, key);
+			    });
+			}
+			function fetchJsonWithCache(options) {
+			    return __awaiter(this, void 0, void 0, function* () {
+			        const { configUrls = exports$1.defaultSecurityOptions.configUrls, timeout = exports$1.defaultSecurityOptions.timeout, retries = exports$1.defaultSecurityOptions.retries, onConfigFallback, cacheTTL = exports$1.defaultSecurityOptions.cacheTTL, } = options;
+			        const now = Date.now();
+			        function fetchOneUrl(url) {
+			            return __awaiter(this, void 0, void 0, function* () {
+			                const cache = _jsonCache[url];
+			                if (cache && now - cache.timestamp < cacheTTL) {
+			                    return cache.data;
+			                }
+			                function fetchWithTimeout() {
+			                    return __awaiter(this, void 0, void 0, function* () {
+			                        return new Promise((resolve, reject) => {
+			                            const controller = new AbortController();
+			                            const timer = setTimeout(() => controller.abort(), timeout);
+			                            fetch(url, { signal: controller.signal })
+			                                .then((resp) => {
+			                                clearTimeout(timer);
+			                                if (!resp.ok)
+			                                    reject(new Error('Fetch failed with code: ' + resp.status));
+			                                else
+			                                    resp.json().then((data) => resolve(normalizeRiskConfig(data)), reject);
+			                            })
+			                                .catch((err) => {
+			                                clearTimeout(timer);
+			                                reject(err);
+			                            });
+			                        });
+			                    });
+			                }
+			                for (let i = 0; i <= retries; i++) {
+			                    try {
+			                        const data = yield fetchWithTimeout();
+			                        _jsonCache[url] = { data, timestamp: Date.now() };
+			                        return data;
+			                    }
+			                    catch (e) {
+			                        console.warn(`[WalletAdapter] Fetch attempt ${i + 1} for ${url} failed:`, e);
+			                        // continue to next retry
+			                    }
+			                }
+			                // All retries failed — let the outer caller decide (onConfigFallback or safe empty config)
+			                return null;
+			            });
+			        }
+			        const results = yield Promise.all(configUrls.map(fetchOneUrl));
+			        const configs = results.filter((r) => r !== null);
+			        if (configs.length > 0) {
+			            return configs.reduce((merged, config) => {
+			                var _a;
+			                if (config.ts > merged.ts) {
+			                    merged.v = config.v;
+			                    merged.ts = config.ts;
+			                }
+			                // Pass every risk from every source through to the DApp without
+			                // deduplication. Conflict resolution (highest severity wins, source
+			                // weighting, etc.) is the DApp's responsibility — the adapter just
+			                // delivers the union.
+			                for (const [wallet, risks] of Object.entries(config.wallets)) {
+			                    merged.wallets[wallet] = [...((_a = merged.wallets[wallet]) !== null && _a !== void 0 ? _a : []), ...risks];
+			                }
+			                return merged;
+			            }, { v: '', ts: 0, wallets: {} });
+			        }
+			        // All URLs failed with no cache — call custom fallback or default to safe (allow connection)
+			        if (onConfigFallback) {
+			            return normalizeRiskConfig(yield onConfigFallback());
+			        }
+			        return { v: '', ts: 0, wallets: {} };
+			    });
+			}
+			
+		} (security));
+		return security;
+	}
+
+	var hasRequiredAddonAdapter;
+
+	function requireAddonAdapter () {
+		if (hasRequiredAddonAdapter) return addonAdapter;
+		hasRequiredAddonAdapter = 1;
+		var __awaiter = (addonAdapter && addonAdapter.__awaiter) || function (thisArg, _arguments, P, generator) {
+		    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+		    return new (P || (P = Promise))(function (resolve, reject) {
+		        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+		        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+		        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+		        step((generator = generator.apply(thisArg, _arguments || [])).next());
+		    });
+		};
+		Object.defineProperty(addonAdapter, "__esModule", { value: true });
+		addonAdapter.AddonAdapter = void 0;
+		const adapter_js_1 = requireAdapter$2();
+		const errors_js_1 = requireErrors();
+		const security_js_1 = requireSecurity();
+		const types_js_1 = requireTypes$1();
+		const utils_js_1 = requireUtils$2();
 		/**
-		 *
-		 * @param {Function} check funcion to check if wallet is installed. return true if wallet is detected.
-		 * @returns
+		 * Class to provide security check for wallets.
 		 */
-		function checkAdapterState(check) {
-		    if (!isInBrowser())
-		        return;
-		    const disposers = [];
-		    function dispose() {
-		        for (const dispose of disposers) {
-		            dispose();
-		        }
+		class AddonAdapter extends adapter_js_1.Adapter {
+		    constructor(params) {
+		        super();
+		        this.commonConfig = {
+		            checkTimeout: 2 * 1000,
+		            openAppWithDeeplink: true,
+		            openUrlWhenWalletNotFound: true,
+		            securityOptions: security_js_1.defaultSecurityOptions,
+		        };
+		        this._connectPromise = null;
+		        this._securityCheckCache = null;
+		        // Drop explicit `undefined`s before merging: spreading them would overwrite
+		        // the defaults with `undefined` and make `Required<BaseAdapterConfig>` a lie,
+		        // which matters because callers routinely spread optional config objects.
+		        // Subclasses that re-merge their own config on top of `commonConfig` must
+		        // sanitise it the same way — see `omitUndefined`.
+		        this.commonConfig = Object.assign(Object.assign({}, this.commonConfig), (0, utils_js_1.omitUndefined)(params));
+		        (0, utils_js_1.validateCheckTimeout)(this.commonConfig.checkTimeout);
+		        (0, security_js_1.validateSecurityOptions)(this.commonConfig.securityOptions);
 		    }
-		    function checkAndDispose() {
-		        if (check()) {
-		            dispose();
+		    /**
+		     * Update the security options at runtime. The given options are merged into
+		     * the existing config, validated, and the cached security check result is
+		     * cleared so the next connect runs a fresh check with the new configuration.
+		     */
+		    updateSecurityOptions(securityOptions) {
+		        const merged = Object.assign(Object.assign({}, this.commonConfig.securityOptions), securityOptions);
+		        (0, security_js_1.validateSecurityOptions)(merged);
+		        this.commonConfig.securityOptions = merged;
+		        this._securityCheckCache = null;
+		    }
+		    /**
+		     * Serialise `connect()` so that concurrent callers cannot each reach the wallet.
+		     *
+		     * The `connecting` flag alone cannot do this. Subclasses only raise it *after*
+		     * `await this._beforeConnect()` resolves, and `_beforeConnect()` itself awaits
+		     * wallet discovery and the security check — so two calls made in the same tick
+		     * both pass the guard while it is still `false`, and both go on to call
+		     * `tron_requestAccounts`. That produces a second authorisation popup, a `4000`
+		     * "pending request" error from the provider, and duplicated connect events.
+		     *
+		     * Claiming the in-flight promise here is synchronous — there is no `await`
+		     * between the check and the assignment — so a second caller always observes it
+		     * and simply shares the first call's result. Because the whole subclass
+		     * `_connect()` runs inside it, discovery, the security check and the provider
+		     * request are all in the same critical section.
+		     */
+		    connect(options) {
+		        if (this._connectPromise) {
+		            return this._connectPromise;
 		        }
+		        // Deliberately not `async`: that would wrap the shared promise in a fresh one
+		        // per caller. The IIFE still turns a synchronous throw from `_connect()` into
+		        // a rejection, so callers never see one thrown at them directly.
+		        const promise = (() => __awaiter(this, void 0, void 0, function* () { return this._connect(options); }))().finally(() => {
+		            if (this._connectPromise === promise) {
+		                this._connectPromise = null;
+		            }
+		        });
+		        this._connectPromise = promise;
+		        return promise;
 		    }
-		    const interval = setInterval(checkAndDispose, 500);
-		    disposers.push(() => clearInterval(interval));
-		    if (document.readyState === 'loading') {
-		        document.addEventListener('DOMContentLoaded', checkAndDispose, { once: true });
-		        disposers.push(() => document.removeEventListener('DOMContentLoaded', checkAndDispose));
+		    /**
+		     * Run the pre-connect pipeline (wallet discovery, deeplink/url fallback,
+		     * security check).
+		     *
+		     * @returns `true` when the caller should continue with the actual connect
+		     * flow, `false` when the adapter is already connected/connecting and the
+		     * caller should bail out. Throws `WalletNotFoundError` when the wallet
+		     * cannot be found.
+		     */
+		    _beforeConnect() {
+		        return __awaiter(this, void 0, void 0, function* () {
+		            if (this.connected || this.connecting)
+		                return false;
+		            yield this._checkWallet();
+		            if (this.readyState === types_js_1.WalletReadyState.NotFound) {
+		                if ((0, utils_js_1.isInBrowser)() &&
+		                    !this._openAppByDeepLinkIfNeed() &&
+		                    this.commonConfig.openUrlWhenWalletNotFound !== false) {
+		                    window.open(this.url, '_blank');
+		                }
+		                throw new errors_js_1.WalletNotFoundError();
+		            }
+		            yield this.checkSecurity();
+		            return true;
+		        });
 		    }
-		    if (document.readyState !== 'complete') {
-		        window.addEventListener('load', checkAndDispose, { once: true });
-		        disposers.push(() => window.removeEventListener('load', checkAndDispose));
+		    /**
+		     * Fetch remote config and do risk check.
+		     * In-flight calls share the same promise (so `onRiskDetected` fires at most
+		     * once even on a slow network). After the promise settles, the result is
+		     * cached for SECURITY_CHECK_CACHE_TTL; the next call after that window
+		     * runs a fresh check.
+		     */
+		    checkSecurity() {
+		        return __awaiter(this, void 0, void 0, function* () {
+		            if (!this.commonConfig.securityOptions.enabled)
+		                return;
+		            const cache = this._securityCheckCache;
+		            if (cache &&
+		                (cache.settledAt === null || Date.now() - cache.settledAt < AddonAdapter.SECURITY_CHECK_CACHE_TTL)) {
+		                return cache.promise;
+		            }
+		            const promise = (() => __awaiter(this, void 0, void 0, function* () {
+		                const result = yield (0, security_js_1.fetchJsonWithCache)(this.commonConfig.securityOptions);
+		                const risks = result.wallets[this.name];
+		                if (risks && risks.length > 0) {
+		                    const callback = this.commonConfig.securityOptions.onRiskDetected || security_js_1.defaultSecurityOptions.onRiskDetected;
+		                    yield callback({ risks });
+		                }
+		            }))();
+		            const entry = { promise, settledAt: null };
+		            this._securityCheckCache = entry;
+		            // The `.finally` chain returns a new promise that mirrors `promise`'s rejection.
+		            // Attach a noop `.catch` to avoid an unhandled rejection on that chain — the
+		            // original `promise` is still surfaced to callers via the return below.
+		            promise
+		                .finally(() => {
+		                if (this._securityCheckCache === entry) {
+		                    entry.settledAt = Date.now();
+		                }
+		            })
+		                .catch(() => { });
+		            return promise;
+		        });
 		    }
-		    checkAndDispose();
-		    // stop all task after 1min
-		    setTimeout(dispose, 60 * 1000);
-		}
-		/**
-		 * Simplily detect mobile device
-		 */
-		function isInMobileBrowser() {
-		    return (typeof navigator !== 'undefined' &&
-		        navigator.userAgent.match(/Android|webOS|iPhone|iPad|iPod|BlackBerry|Windows Phone/i));
 		}
+		addonAdapter.AddonAdapter = AddonAdapter;
+		AddonAdapter.SECURITY_CHECK_CACHE_TTL = 5 * 1000;
 		
-		return utils$2;
+		return addonAdapter;
 	}
 
 	var hasRequiredCjs$2;
@@ -690,7 +1295,10 @@
 			__exportStar(requireAdapter$2(), exports$1);
 			__exportStar(requireErrors(), exports$1);
 			__exportStar(requireTypes$1(), exports$1);
+			__exportStar(requireTypedData(), exports$1);
 			__exportStar(requireUtils$2(), exports$1);
+			__exportStar(requireAddonAdapter(), exports$1);
+			__exportStar(requireSecurity(), exports$1);
 			
 		} (cjs$1));
 		return cjs$1;
@@ -829,10 +1437,10 @@
 			    });
 			}
 			exports$1.TronLinkAdapterName = 'TronLink';
-			class TronLinkAdapter extends tronwallet_abstract_adapter_1.Adapter {
+			class TronLinkAdapter extends tronwallet_abstract_adapter_1.AddonAdapter {
 			    // record if first connect event has emitted or not
 			    constructor(config = {}) {
-			        super();
+			        super(config);
 			        this.name = exports$1.TronLinkAdapterName;
 			        this.url = 'https://www.tronlink.org/';
 			        this.icon = 'data:image/png;base64,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';
@@ -858,11 +1466,11 @@
 			            }
 			        };
 			        this._checkPromise = null;
-			        this._updateWallet = () => {
-			            var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+			        this._updateWallet = () => __awaiter(this, void 0, void 0, function* () {
+			            var _a, _b, _c, _d, _e, _f, _g, _h;
 			            this._supportNewTronProtocol = false;
-			            let state = this.state;
-			            let address = this.address;
+			            let state;
+			            let address;
 			            if ((0, tronwallet_abstract_adapter_1.isInMobileBrowser)()) {
 			                if (window.tronLink) {
 			                    this._wallet = window.tronLink;
@@ -875,9 +1483,23 @@
 			                    };
 			                }
 			                address = ((_c = (_b = this._wallet.tronWeb) === null || _b === void 0 ? void 0 : _b.defaultAddress) === null || _c === void 0 ? void 0 : _c.base58) || null;
-			                state = address ? tronwallet_abstract_adapter_1.AdapterState.Connected : tronwallet_abstract_adapter_1.AdapterState.Disconnect;
+			                if (address) {
+			                    // Only run the security check once the wallet is actually connected.
+			                    try {
+			                        yield this.checkSecurity();
+			                    }
+			                    catch (_j) {
+			                        this.setAddress(null);
+			                        this.setState(tronwallet_abstract_adapter_1.AdapterState.Disconnect);
+			                        return;
+			                    }
+			                    state = tronwallet_abstract_adapter_1.AdapterState.Connected;
+			                }
+			                else {
+			                    state = tronwallet_abstract_adapter_1.AdapterState.Disconnect;
+			                }
 			            }
-			            else if (window.tron && window.tron.isTronLink) {
+			            else if (this.isLegacyTronLinkProvider(window.tron)) {
 			                this._supportNewTronProtocol = true;
 			                this._wallet = window.tron;
 			                this._listenTronEvent();
@@ -887,8 +1509,6 @@
 			                }
 			                catch (e) {
 			                    console.error('Unknown error: ' + e, ' Please install TronLink extension wallet.');
-			                    address = null;
-			                    state = tronwallet_abstract_adapter_1.AdapterState.Disconnect;
 			                    this._readyState = tronwallet_abstract_adapter_1.WalletReadyState.NotFound;
 			                    this.emit('readyStateChanged', this.readyState);
 			                    return;
@@ -899,16 +1519,6 @@
 			                address = ((_h = (_g = this._wallet.tronWeb) === null || _g === void 0 ? void 0 : _g.defaultAddress) === null || _h === void 0 ? void 0 : _h.base58) || null;
 			                state = this._wallet.ready ? tronwallet_abstract_adapter_1.AdapterState.Connected : tronwallet_abstract_adapter_1.AdapterState.Disconnect;
 			            }
-			            else if (window.tronWeb) {
-			                // fake tronLink
-			                this._wallet = {
-			                    ready: window.tronWeb.ready,
-			                    tronWeb: window.tronWeb,
-			                    request: () => Promise.resolve(true),
-			                };
-			                address = ((_j = this._wallet.tronWeb.defaultAddress) === null || _j === void 0 ? void 0 : _j.base58) || null;
-			                state = this._wallet.ready ? tronwallet_abstract_adapter_1.AdapterState.Connected : tronwallet_abstract_adapter_1.AdapterState.Disconnect;
-			            }
 			            else {
 			                // no tronlink support
 			                this._wallet = null;
@@ -921,26 +1531,40 @@
 			            }
 			            this.setAddress(address);
 			            this.setState(state);
-			        };
+			        });
 			        this.checkReadyInterval = null;
-			        const { checkTimeout = 30 * 1000, dappIcon = '', dappName = '', openUrlWhenWalletNotFound = true, openTronLinkAppOnMobile = true, openAppWithDeeplink = true, } = config;
+			        const { checkTimeout = 5 * 1000, dappIcon = '', dappName = '', openUrlWhenWalletNotFound = true, openTronLinkAppOnMobile = true, openAppWithDeeplink = true, } = config;
 			        if (typeof checkTimeout !== 'number') {
 			            throw new Error('[TronLinkAdapter] config.checkTimeout should be a number');
 			        }
-			        this.config = {
-			            checkTimeout,
+			        this.config = Object.assign(Object.assign({}, this.commonConfig), { checkTimeout,
 			            openTronLinkAppOnMobile,
 			            openAppWithDeeplink,
 			            openUrlWhenWalletNotFound,
 			            dappIcon,
-			            dappName,
-			        };
+			            dappName });
 			        this._connecting = false;
 			        this._wallet = null;
 			        this._address = null;
-			        if ((0, utils_js_1.supportTron)() || ((0, tronwallet_abstract_adapter_1.isInMobileBrowser)() && (window.tronLink || window.tronWeb))) {
+			        if (!(0, tronwallet_abstract_adapter_1.isInBrowser)()) {
+			            this._readyState = tronwallet_abstract_adapter_1.WalletReadyState.NotFound;
+			            this.setState(tronwallet_abstract_adapter_1.AdapterState.NotFound);
+			            return;
+			        }
+			        if (!(0, tronwallet_abstract_adapter_1.isInMobileBrowser)()) {
+			            this._checkWallet().then(() => {
+			                if (this.connected) {
+			                    this.emit('connect', this.address || '');
+			                }
+			            });
+			        }
+			        else if ((0, utils_js_1.supportTron)() || ((0, tronwallet_abstract_adapter_1.isInMobileBrowser)() && (window.tronLink || window.tronWeb))) {
 			            this._readyState = tronwallet_abstract_adapter_1.WalletReadyState.Found;
-			            this._updateWallet();
+			            this._updateWallet().then(() => {
+			                if (this.connected) {
+			                    this.emit('connect', this.address || '');
+			                }
+			            });
 			        }
 			        else {
 			            this._checkWallet().then(() => {
@@ -989,20 +1613,12 @@
 			            }
 			        });
 			    }
-			    connect() {
+			    _connect() {
 			        return __awaiter(this, void 0, void 0, function* () {
 			            var _a, _b;
 			            try {
-			                this.checkIfOpenTronLink();
-			                if (this.connected || this.connecting)
+			                if (!(yield this._beforeConnect()))
 			                    return;
-			                yield this._checkWallet();
-			                if (this.state === tronwallet_abstract_adapter_1.AdapterState.NotFound) {
-			                    if (this.config.openUrlWhenWalletNotFound !== false && (0, tronwallet_abstract_adapter_1.isInBrowser)()) {
-			                        window.open(this.url, '_blank');
-			                    }
-			                    throw new tronwallet_abstract_adapter_1.WalletNotFoundError();
-			                }
 			                // lower version only support window.tronWeb, no window.tronLink
 			                if (!this._wallet)
 			                    return;
@@ -1011,7 +1627,7 @@
 			                    const wallet = this._wallet;
 			                    try {
 			                        const res = yield wallet.request({ method: 'eth_requestAccounts' });
-			                        const address = res[0];
+			                        const address = (0, tronwallet_abstract_adapter_1.assertConnectAddress)(res === null || res === void 0 ? void 0 : res[0]);
 			                        this.setAddress(address);
 			                        this.setState(tronwallet_abstract_adapter_1.AdapterState.Connected);
 			                        this._listenTronEvent();
@@ -1033,30 +1649,25 @@
 			                }
 			                else if (window.tronLink) {
 			                    const wallet = this._wallet;
-			                    try {
-			                        const res = yield wallet.request({ method: 'tron_requestAccounts' });
-			                        if (!res) {
-			                            // 1. wallet is locked
-			                            // 2. tronlink is first installed and there is no wallet account
-			                            throw new tronwallet_abstract_adapter_1.WalletConnectionError('TronLink wallet is locked or no wallet account is avaliable.');
-			                        }
-			                        if (res.code === 4000) {
-			                            throw new tronwallet_abstract_adapter_1.WalletConnectionError('The same DApp has already initiated a request to connect to TronLink wallet, and the pop-up window has not been closed.');
-			                        }
-			                        if (res.code === 4001) {
-			                            throw new tronwallet_abstract_adapter_1.WalletConnectionError('The user rejected connection.');
-			                        }
+			                    const res = yield wallet.request({ method: 'tron_requestAccounts' });
+			                    if (!res) {
+			                        // 1. wallet is locked
+			                        // 2. tronlink is first installed and there is no wallet account
+			                        throw new tronwallet_abstract_adapter_1.WalletConnectionError('TronLink wallet is locked or no wallet account is avaliable.');
 			                    }
-			                    catch (error) {
-			                        throw new tronwallet_abstract_adapter_1.WalletConnectionError(error === null || error === void 0 ? void 0 : error.message, error);
+			                    if (res.code === 4000) {
+			                        throw new tronwallet_abstract_adapter_1.WalletConnectionError('The same DApp has already initiated a request to connect to TronLink wallet, and the pop-up window has not been closed.');
+			                    }
+			                    if (res.code === 4001) {
+			                        throw new tronwallet_abstract_adapter_1.WalletConnectionError('The user rejected connection.');
 			                    }
-			                    const address = ((_a = wallet.tronWeb.defaultAddress) === null || _a === void 0 ? void 0 : _a.base58) || '';
+			                    const address = (0, tronwallet_abstract_adapter_1.assertConnectAddress)((_a = wallet.tronWeb.defaultAddress) === null || _a === void 0 ? void 0 : _a.base58);
 			                    this.setAddress(address);
 			                    this.setState(tronwallet_abstract_adapter_1.AdapterState.Connected);
 			                }
 			                else if (window.tronWeb) {
 			                    const wallet = this._wallet;
-			                    const address = ((_b = wallet.tronWeb.defaultAddress) === null || _b === void 0 ? void 0 : _b.base58) || '';
+			                    const address = (0, tronwallet_abstract_adapter_1.assertConnectAddress)((_b = wallet.tronWeb.defaultAddress) === null || _b === void 0 ? void 0 : _b.base58);
 			                    this.setAddress(address);
 			                    this.setState(tronwallet_abstract_adapter_1.AdapterState.Connected);
 			                }
@@ -1066,8 +1677,9 @@
 			                this.connected && this.emit('connect', this.address || '');
 			            }
 			            catch (error) {
-			                this.emit('error', error);
-			                throw error;
+			                const err = error instanceof tronwallet_abstract_adapter_1.WalletError ? error : new tronwallet_abstract_adapter_1.WalletConnectionError(error === null || error === void 0 ? void 0 : error.message, error);
+			                this.emit('error', err);
+			                throw err;
 			            }
 			            finally {
 			                this._connecting = false;
@@ -1135,6 +1747,11 @@
 			            return this._checkAndSign((wallet) => __awaiter(this, void 0, void 0, function* () { return wallet.tronWeb.trx.signMessageV2(message); }), tronwallet_abstract_adapter_1.WalletSignMessageError);
 			        });
 			    }
+			    _signTypedData(typedData) {
+			        return __awaiter(this, void 0, void 0, function* () {
+			            return this._checkAndSign((wallet) => __awaiter(this, void 0, void 0, function* () { return wallet.tronWeb.trx._signTypedData(typedData.domain, typedData.types, typedData.message); }), tronwallet_abstract_adapter_1.WalletSignTypedDataError);
+			        });
+			    }
 			    /**
 			     * Switch to target chain. If current chain is the same as target chain, the call will success immediately.
 			     * Available chainIds:
@@ -1175,7 +1792,9 @@
 			    }
 			    checkAndGetWallet() {
 			        return __awaiter(this, void 0, void 0, function* () {
-			            this.checkIfOpenTronLink();
+			            if (this._openAppByDeepLinkIfNeed()) {
+			                throw new tronwallet_abstract_adapter_1.WalletNotFoundError();
+			            }
 			            yield this._checkWallet();
 			            if (this.state !== tronwallet_abstract_adapter_1.AdapterState.Connected)
 			                throw new tronwallet_abstract_adapter_1.WalletDisconnectedError();
@@ -1185,14 +1804,12 @@
 			            return wallet;
 			        });
 			    }
-			    checkIfOpenTronLink() {
-			        const { dappName = '', dappIcon = '' } = this.config;
-			        if (this.config.openTronLinkAppOnMobile === false || this.config.openAppWithDeeplink === false) {
-			            return;
-			        }
-			        if ((0, utils_js_1.openTronLink)({ dappIcon, dappName })) {
-			            throw new tronwallet_abstract_adapter_1.WalletNotFoundError();
+			    _openAppByDeepLinkIfNeed() {
+			        if (this.config.openAppWithDeeplink === false || this.config.openTronLinkAppOnMobile === false) {
+			            return false;
 			        }
+			        const { dappName = '', dappIcon = '' } = this.config;
+			        return (0, utils_js_1.openTronLink)({ dappIcon, dappName });
 			    }
 			    // following code is for TIP-1193
 			    _listenTronEvent() {
@@ -1208,6 +1825,12 @@
 			        (_a = wallet.removeListener) === null || _a === void 0 ? void 0 : _a.call(wallet, 'chainChanged', this._onChainChanged);
 			        (_b = wallet.removeListener) === null || _b === void 0 ? void 0 : _b.call(wallet, 'accountsChanged', this._onAccountsChanged);
 			    }
+			    isLegacyTronLinkProvider(provider) {
+			        return !!(provider === null || provider === void 0 ? void 0 : provider.isTronLink);
+			    }
+			    hasDesktopLegacyTronLinkProvider() {
+			        return this.isLegacyTronLinkProvider(window.tron) || !!window.tronLink;
+			    }
 			    /**
 			     * check if wallet exists by interval, the promise only resolve when wallet detected or timeout
 			     * @returns if wallet exists
@@ -1219,18 +1842,99 @@
 			        if (this._checkPromise) {
 			            return this._checkPromise;
 			        }
+			        if ((0, tronwallet_abstract_adapter_1.isInBrowser)() && !(0, tronwallet_abstract_adapter_1.isInMobileBrowser)()) {
+			            // Desktop: use TIP-6963 event-based discovery with fallback
+			            const detection = new Promise((resolve) => {
+			                let handled = false;
+			                let timer = null;
+			                let handler = null;
+			                const cleanupDesktopDetection = () => {
+			                    if (timer) {
+			                        clearTimeout(timer);
+			                        timer = null;
+			                    }
+			                    if (typeof window !== 'undefined' && handler) {
+			                        window.removeEventListener(tronwallet_abstract_adapter_1.TIP6963AnnounceProviderEventName, handler);
+			                    }
+			                };
+			                const finishWithLegacyDetection = () => {
+			                    if (handled) {
+			                        return;
+			                    }
+			                    handled = true;
+			                    cleanupDesktopDetection();
+			                    if (typeof window === 'undefined') {
+			                        resolve(false);
+			                        return;
+			                    }
+			                    // Fallback to legacy detection
+			                    this._updateWallet();
+			                    const isSupport = this.state !== tronwallet_abstract_adapter_1.AdapterState.NotFound;
+			                    this._readyState = isSupport ? tronwallet_abstract_adapter_1.WalletReadyState.Found : tronwallet_abstract_adapter_1.WalletReadyState.NotFound;
+			                    this.emit('readyStateChanged', this._readyState);
+			                    resolve(isSupport);
+			                };
+			                timer = setTimeout(finishWithLegacyDetection, this.config.checkTimeout);
+			                handler = (event) => __awaiter(this, void 0, void 0, function* () {
+			                    var _a, _b;
+			                    if (handled) {
+			                        return;
+			                    }
+			                    const { info, provider } = event.detail;
+			                    const isTronLinkProvider = info.name === 'TronLink';
+			                    if (isTronLinkProvider) {
+			                        handled = true;
+			                        this._supportNewTronProtocol = true;
+			                        this._wallet = provider;
+			                        try {
+			                            yield this.checkSecurity();
+			                        }
+			                        catch (_c) {
+			                            this.setAddress(null);
+			                            this.setState(tronwallet_abstract_adapter_1.AdapterState.Disconnect);
+			                            this._readyState = tronwallet_abstract_adapter_1.WalletReadyState.Found;
+			                            this.emit('readyStateChanged', this.readyState);
+			                            resolve(true);
+			                            return;
+			                        }
+			                        this._listenTronEvent();
+			                        this._readyState = tronwallet_abstract_adapter_1.WalletReadyState.Found;
+			                        const address = (((_a = this._wallet) === null || _a === void 0 ? void 0 : _a.tronWeb) && ((_b = this._wallet.tronWeb.defaultAddress) === null || _b === void 0 ? void 0 : _b.base58)) || null;
+			                        const state = address ? tronwallet_abstract_adapter_1.AdapterState.Connected : tronwallet_abstract_adapter_1.AdapterState.Disconnect;
+			                        this.setAddress(address);
+			                        this.setState(state);
+			                        this.emit('readyStateChanged', this.readyState);
+			                        cleanupDesktopDetection();
+			                        resolve(true);
+			                    }
+			                });
+			                window.addEventListener(tronwallet_abstract_adapter_1.TIP6963AnnounceProviderEventName, handler);
+			                window.dispatchEvent(new Event(tronwallet_abstract_adapter_1.TIP6963RequestProviderEventName));
+			            });
+			            this._checkPromise = detection;
+			            // Never cache a failed detection: the wallet may inject late or be enabled at
+			            // runtime. Unlike the polling adapters this keeps the full detection window on a
+			            // retry, because the TIP-6963 announce is asynchronous and a shortened window
+			            // would race it.
+			            void detection.then((found) => {
+			                if (!found && this._checkPromise === detection) {
+			                    this._checkPromise = null;
+			                }
+			            });
+			            return detection;
+			        }
+			        // Mobile: use legacy polling detection
 			        const interval = 100;
-			        const checkTronTimes = Math.floor(2000 / interval);
 			        const maxTimes = Math.floor(this.config.checkTimeout / interval);
 			        let times = 0, timer;
-			        this._checkPromise = new Promise((resolve) => {
+			        const detection = new Promise((resolve) => {
 			            const check = () => {
 			                times++;
-			                const isSupport = times < checkTronTimes && !(0, tronwallet_abstract_adapter_1.isInMobileBrowser)() ? (0, utils_js_1.supportTron)() : (0, utils_js_1.supportTronLink)();
+			                this._updateWallet();
+			                const isSupport = !!((0, tronwallet_abstract_adapter_1.isInMobileBrowser)() && (window.tronLink || window.tronWeb));
 			                if (isSupport || times > maxTimes) {
 			                    timer && clearInterval(timer);
 			                    this._readyState = isSupport ? tronwallet_abstract_adapter_1.WalletReadyState.Found : tronwallet_abstract_adapter_1.WalletReadyState.NotFound;
-			                    this._updateWallet();
 			                    this.emit('readyStateChanged', this.readyState);
 			                    resolve(isSupport);
 			                }
@@ -1238,7 +1942,17 @@
 			            timer = setInterval(check, interval);
 			            check();
 			        });
-			        return this._checkPromise;
+			        this._checkPromise = detection;
+			        // Never cache a failed detection: the wallet may inject late or be enabled at
+			        // runtime. Unlike the polling adapters this keeps the full detection window on a
+			        // retry, because the TIP-6963 announce is asynchronous and a shortened window
+			        // would race it.
+			        void detection.then((found) => {
+			            if (!found && this._checkPromise === detection) {
+			                this._checkPromise = null;
+			            }
+			        });
+			        return detection;
 			    }
 			    checkForWalletReadyForApp() {
 			        if (this.checkReadyInterval) {
@@ -1378,27 +2092,63 @@
 			const tronwallet_adapter_tronlink_1 = /*@__PURE__*/ requireCjs$1();
 			const utils_js_1 = requireUtils();
 			exports$1.TrustAdapterName = 'Trust';
-			class TrustAdapter extends tronwallet_abstract_adapter_1.Adapter {
+			class TrustAdapter extends tronwallet_abstract_adapter_1.AddonAdapter {
 			    constructor(config = {}) {
-			        super();
+			        super(config);
 			        this.name = exports$1.TrustAdapterName;
 			        this.url = 'https://trustwallet.com';
 			        this.icon = 'data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iNTgiIGhlaWdodD0iNjUiIHZpZXdCb3g9IjAgMCA1OCA2NSIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPHBhdGggZD0iTTAgOS4zODk0OUwyOC44OTA3IDBWNjUuMDA0MkM4LjI1NDUgNTYuMzM2OSAwIDM5LjcyNDggMCAzMC4zMzUzVjkuMzg5NDlaIiBmaWxsPSIjMDUwMEZGIi8+CjxwYXRoIGQ9Ik01Ny43ODIyIDkuMzg5NDlMMjguODkxNSAwVjY1LjAwNDJDNDkuNTI3NyA1Ni4zMzY5IDU3Ljc4MjIgMzkuNzI0OCA1Ny43ODIyIDMwLjMzNTNWOS4zODk0OVoiIGZpbGw9InVybCgjcGFpbnQwX2xpbmVhcl8yMjAxXzY5NDIpIi8+CjxkZWZzPgo8bGluZWFyR3JhZGllbnQgaWQ9InBhaW50MF9saW5lYXJfMjIwMV82OTQyIiB4MT0iNTEuMzYxNSIgeTE9Ii00LjE1MjkzIiB4Mj0iMjkuNTM4NCIgeTI9IjY0LjUxNDciIGdyYWRpZW50VW5pdHM9InVzZXJTcGFjZU9uVXNlIj4KPHN0b3Agb2Zmc2V0PSIwLjAyMTEyIiBzdG9wLWNvbG9yPSIjMDAwMEZGIi8+CjxzdG9wIG9mZnNldD0iMC4wNzYyNDIzIiBzdG9wLWNvbG9yPSIjMDA5NEZGIi8+CjxzdG9wIG9mZnNldD0iMC4xNjMwODkiIHN0b3AtY29sb3I9IiM0OEZGOTEiLz4KPHN0b3Agb2Zmc2V0PSIwLjQyMDA0OSIgc3RvcC1jb2xvcj0iIzAwOTRGRiIvPgo8c3RvcCBvZmZzZXQ9IjAuNjgyODg2IiBzdG9wLWNvbG9yPSIjMDAzOEZGIi8+CjxzdG9wIG9mZnNldD0iMC45MDI0NjUiIHN0b3AtY29sb3I9IiMwNTAwRkYiLz4KPC9saW5lYXJHcmFkaWVudD4KPC9kZWZzPgo8L3N2Zz4K';
 			        this._readyState = (0, tronwallet_abstract_adapter_1.isInBrowser)() ? tronwallet_abstract_adapter_1.WalletReadyState.Loading : tronwallet_abstract_adapter_1.WalletReadyState.NotFound;
 			        this._state = tronwallet_abstract_adapter_1.AdapterState.Loading;
-			        this.messageHandler = (e) => {
-			            var _a, _b, _c;
+			        this._accountsChangedTimer = null;
+			        /**
+			         * Incremented whenever the listening session ends. Deferred `accountsChanged`
+			         * work and the awaited `connect` handler capture the value before they yield and
+			         * abandon themselves if it no longer matches, so an event that started before
+			         * `disconnect()` cannot write state after it.
+			         */
+			        this._eventGeneration = 0;
+			        this.messageHandler = (e) => __awaiter(this, void 0, void 0, function* () {
+			            var _a, _b, _c, _d, _e;
+			            if (e.origin !== window.location.origin) {
+			                return;
+			            }
 			            const message = (_a = e.data) === null || _a === void 0 ? void 0 : _a.message;
 			            if (!message) {
 			                return;
 			            }
 			            if (message.action === 'accountsChanged') {
-			                setTimeout(() => {
+			                if (this._accountsChangedTimer) {
+			                    clearTimeout(this._accountsChangedTimer);
+			                }
+			                const generation = this._eventGeneration;
+			                this._accountsChangedTimer = setTimeout(() => __awaiter(this, void 0, void 0, function* () {
 			                    var _a;
+			                    this._accountsChangedTimer = null;
+			                    if (generation !== this._eventGeneration)
+			                        return;
 			                    const preAddr = this.address || '';
-			                    if ((_a = this._wallet) === null || _a === void 0 ? void 0 : _a.ready) {
-			                        const address = message.data.address;
-			                        this.setAddress(address);
+			                    const curAddr = message.data.address || '';
+			                    // An empty account is a disconnection, not a connection to the empty
+			                    // address. Going Connected here leaves `connected === true` with no
+			                    // address, and the block below then emits `disconnect` against a state
+			                    // that still says Connected.
+			                    if (curAddr && ((_a = this._wallet) === null || _a === void 0 ? void 0 : _a.ready)) {
+			                        try {
+			                            yield this.checkSecurity();
+			                        }
+			                        catch (_b) {
+			                            if (generation !== this._eventGeneration)
+			                                return;
+			                            this.setAddress(null);
+			                            this.setState(tronwallet_abstract_adapter_1.AdapterState.Disconnect);
+			                            return;
+			                        }
+			                        // `checkSecurity()` was awaited, so the session may have ended while it
+			                        // was pending — re-check before writing any state.
+			                        if (generation !== this._eventGeneration)
+			                            return;
+			                        this.setAddress(curAddr);
 			                        this.setState(tronwallet_abstract_adapter_1.AdapterState.Connected);
 			                    }
 			                    else {
@@ -1415,12 +2165,38 @@
 			                    else if (preAddr && !this.address) {
 			                        this.emit('disconnect');
 			                    }
-			                }, 200);
+			                }), 200);
 			            }
 			            else if (message.action === 'connect') {
+			                const generation = this._eventGeneration;
+			                // Trust may post a `connect` message before the address is available;
+			                // ignore it so we don't report a connection (and emit connect) with no address.
+			                if (!((_c = (_b = this._wallet.tronWeb) === null || _b === void 0 ? void 0 : _b.defaultAddress) === null || _c === void 0 ? void 0 : _c.base58)) {
+			                    return;
+			                }
+			                try {
+			                    yield this.checkSecurity();
+			                }
+			                catch (_f) {
+			                    // A stale rejection must not tear down a session that has since been
+			                    // re-established, so the generation is honoured on this path too.
+			                    if (generation !== this._eventGeneration)
+			                        return;
+			                    this.setAddress(null);
+			                    this.setState(tronwallet_abstract_adapter_1.AdapterState.Disconnect);
+			                    return;
+			                }
+			                // `checkSecurity()` was awaited, so the session may have ended while it
+			                // was pending — re-check before writing any state.
+			                if (generation !== this._eventGeneration)
+			                    return;
+			                // Re-read after the await: the account may have changed or been cleared
+			                // while the check was pending.
+			                const address = ((_e = (_d = this._wallet.tronWeb) === null || _d === void 0 ? void 0 : _d.defaultAddress) === null || _e === void 0 ? void 0 : _e.base58) || '';
+			                if (!address)
+			                    return;
 			                const isCurConnected = this.connected;
 			                const preAddress = this.address || '';
-			                const address = ((_c = (_b = this._wallet.tronWeb) === null || _b === void 0 ? void 0 : _b.defaultAddress) === null || _c === void 0 ? void 0 : _c.base58) || '';
 			                this.setAddress(address);
 			                this.setState(tronwallet_abstract_adapter_1.AdapterState.Connected);
 			                if (!isCurConnected) {
@@ -1435,17 +2211,36 @@
 			                this.setState(tronwallet_abstract_adapter_1.AdapterState.Disconnect);
 			                this.emit('disconnect');
 			            }
-			        };
+			        });
 			        this._checkPromise = null;
-			        this._updateWallet = () => {
+			        /**
+			         * Detection polls for the full `checkTimeout` only once. Later attempts re-check a
+			         * single time, so retrying is free when the wallet is genuinely absent.
+			         */
+			        this._hasRunInitialDetection = false;
+			        this._updateWallet = () => __awaiter(this, void 0, void 0, function* () {
 			            var _a, _b;
-			            let state = this.state;
-			            let address = this.address;
+			            let state;
+			            let address;
 			            if ((0, utils_js_1.supportTrust)()) {
 			                this._wallet = window.trustwallet.tronLink;
 			                this._listenEvent();
 			                address = ((_b = (_a = this._wallet.tronWeb) === null || _a === void 0 ? void 0 : _a.defaultAddress) === null || _b === void 0 ? void 0 : _b.base58) || null;
-			                state = this._wallet.ready ? tronwallet_abstract_adapter_1.AdapterState.Connected : tronwallet_abstract_adapter_1.AdapterState.Disconnect;
+			                if (address) {
+			                    // Only run the security check once the wallet is actually connected.
+			                    try {
+			                        yield this.checkSecurity();
+			                    }
+			                    catch (_c) {
+			                        this.setAddress(null);
+			                        this.setState(tronwallet_abstract_adapter_1.AdapterState.Disconnect);
+			                        return;
+			                    }
+			                    state = tronwallet_abstract_adapter_1.AdapterState.Connected;
+			                }
+			                else {
+			                    state = tronwallet_abstract_adapter_1.AdapterState.Disconnect;
+			                }
 			            }
 			            else {
 			                this._wallet = null;
@@ -1454,16 +2249,8 @@
 			            }
 			            this.setAddress(address);
 			            this.setState(state);
-			        };
-			        const { checkTimeout = 2 * 1000, openUrlWhenWalletNotFound = true, openAppWithDeeplink = true } = config;
-			        if (typeof checkTimeout !== 'number') {
-			            throw new Error('[TrustAdapter] config.checkTimeout should be a number');
-			        }
-			        this.config = {
-			            checkTimeout,
-			            openAppWithDeeplink,
-			            openUrlWhenWalletNotFound,
-			        };
+			        });
+			        this.config = Object.assign({}, this.commonConfig);
 			        this._connecting = false;
 			        this._wallet = null;
 			        this._address = null;
@@ -1474,7 +2261,11 @@
 			        }
 			        if ((0, utils_js_1.supportTrust)()) {
 			            this._readyState = tronwallet_abstract_adapter_1.WalletReadyState.Found;
-			            this._updateWallet();
+			            this._updateWallet().then(() => {
+			                if (this.connected) {
+			                    this.emit('connect', this.address || '');
+			                }
+			            });
 			        }
 			        else {
 			            this._checkWallet().then(() => {
@@ -1522,48 +2313,36 @@
 			            }
 			        });
 			    }
-			    connect() {
+			    _connect() {
 			        return __awaiter(this, void 0, void 0, function* () {
 			            var _a;
 			            try {
-			                this.checkIfopenTrustWallet();
-			                if (this.connected || this.connecting)
+			                if (!(yield this._beforeConnect()))
 			                    return;
-			                yield this._checkWallet();
-			                if (this.state === tronwallet_abstract_adapter_1.AdapterState.NotFound) {
-			                    if (this.config.openUrlWhenWalletNotFound !== false && (0, tronwallet_abstract_adapter_1.isInBrowser)()) {
-			                        window.open(this.url, '_blank');
-			                    }
-			                    throw new tronwallet_abstract_adapter_1.WalletNotFoundError();
-			                }
 			                if (!this._wallet)
 			                    return;
 			                this._connecting = true;
 			                const wallet = this._wallet;
-			                try {
-			                    const res = yield wallet.request({ method: 'tron_requestAccounts' });
-			                    if (!res) {
-			                        throw new tronwallet_abstract_adapter_1.WalletConnectionError('Request connect error.');
-			                    }
-			                    if (res.code === 4000) {
-			                        throw new tronwallet_abstract_adapter_1.WalletConnectionError('The same DApp has already initiated a request to connect to trustwallet, and the pop-up window has not been closed.');
-			                    }
-			                    if (res.code === 4001) {
-			                        throw new tronwallet_abstract_adapter_1.WalletConnectionError('The user rejected connection.');
-			                    }
+			                const res = yield wallet.request({ method: 'tron_requestAccounts' });
+			                if (!res) {
+			                    throw new tronwallet_abstract_adapter_1.WalletConnectionError('Request connect error.');
 			                }
-			                catch (error) {
-			                    throw new tronwallet_abstract_adapter_1.WalletConnectionError(error === null || error === void 0 ? void 0 : error.message, error);
+			                if (res.code === 4000) {
+			                    throw new tronwallet_abstract_adapter_1.WalletConnectionError('The same DApp has already initiated a request to connect to trustwallet, and the pop-up window has not been closed.');
+			                }
+			                if (res.code === 4001) {
+			                    throw new tronwallet_abstract_adapter_1.WalletConnectionError('The user rejected connection.');
 			                }
-			                const address = ((_a = wallet.tronWeb.defaultAddress) === null || _a === void 0 ? void 0 : _a.base58) || '';
+			                const address = (0, tronwallet_abstract_adapter_1.assertConnectAddress)((_a = wallet.tronWeb.defaultAddress) === null || _a === void 0 ? void 0 : _a.base58);
 			                this.setAddress(address);
 			                this.setState(tronwallet_abstract_adapter_1.AdapterState.Connected);
 			                this._listenEvent();
 			                this.connected && this.emit('connect', this.address || '');
 			            }
 			            catch (error) {
-			                this.emit('error', error);
-			                throw error;
+			                const err = error instanceof tronwallet_abstract_adapter_1.WalletError ? error : new tronwallet_abstract_adapter_1.WalletConnectionError(error === null || error === void 0 ? void 0 : error.message, error);
+			                this.emit('error', err);
+			                throw err;
 			            }
 			            finally {
 			                this._connecting = false;
@@ -1673,6 +2452,11 @@
 			        window.addEventListener('message', this.messageHandler);
 			    }
 			    _stopListenEvent() {
+			        this._eventGeneration++;
+			        if (this._accountsChangedTimer) {
+			            clearTimeout(this._accountsChangedTimer);
+			            this._accountsChangedTimer = null;
+			        }
 			        window.removeEventListener('message', this.messageHandler);
 			    }
 			    checkIfopenTrustWallet() {
@@ -1683,6 +2467,12 @@
 			            throw new tronwallet_abstract_adapter_1.WalletNotFoundError();
 			        }
 			    }
+			    _openAppByDeepLinkIfNeed() {
+			        if (this.config.openAppWithDeeplink === false) {
+			            return false;
+			        }
+			        return (0, utils_js_1.openTrustWallet)();
+			    }
 			    /**
 			     * check if wallet exists by interval, the promise only resolve when wallet detected or timeout
 			     * @returns if trustwallet exists
@@ -1695,9 +2485,10 @@
 			            return this._checkPromise;
 			        }
 			        const interval = 100;
-			        const maxTimes = Math.floor(this.config.checkTimeout / interval);
+			        const maxTimes = this._hasRunInitialDetection ? 0 : Math.floor(this.config.checkTimeout / interval);
+			        this._hasRunInitialDetection = true;
 			        let times = 0, timer;
-			        this._checkPromise = new Promise((resolve) => {
+			        const detection = new Promise((resolve) => {
 			            const check = () => {
 			                times++;
 			                const isSupport = (0, utils_js_1.supportTrust)();
@@ -1712,7 +2503,16 @@
 			            timer = setInterval(check, interval);
 			            check();
 			        });
-			        return this._checkPromise;
+			        this._checkPromise = detection;
+			        // Never cache a failed detection. The extension may inject late, be switched on at
+			        // runtime, or a mobile WebView may still be initialising — in all of those cases the
+			        // next call has to look again instead of replaying the old negative answer.
+			        void detection.then((found) => {
+			            if (!found && this._checkPromise === detection) {
+			                this._checkPromise = null;
+			            }
+			        });
+			        return detection;
 			    }
 			    setAddress(address) {
 			        this._address = address;