@tronweb3/tronwallet-adapter-trust 1.0.3 → 1.2.0

package/src/adapter.ts

@@ -1,5 +1,4 @@
 import {
-    Adapter,
     AdapterState,
     isInBrowser,
     WalletReadyState,
@@ -9,6 +8,9 @@ import {
     WalletConnectionError,
     WalletSignTransactionError,
     WalletGetNetworkError,
+    AddonAdapter,
+    WalletError,
+    assertConnectAddress,
 } from '@tronweb3/tronwallet-abstract-adapter';
 import type {
     Transaction,
@@ -33,23 +35,11 @@ declare global {
     }
 }
 
-export interface TrustAdapterConfig extends BaseAdapterConfig {
-    /**
-     * Timeout in millisecond for checking if Trust wallet exists.
-     * Default is 2 * 1000ms
-     */
-    checkTimeout?: number;
-
-    /**
-     * Set if open app using DeepLink.
-     * Default is true.
-     */
-    openAppWithDeeplink?: boolean;
-}
+export type TrustAdapterConfig = BaseAdapterConfig;
 
 export const TrustAdapterName = 'Trust' as AdapterName<'Trust'>;
 
-export class TrustAdapter extends Adapter {
+export class TrustAdapter extends AddonAdapter {
     name = TrustAdapterName;
     url = 'https://trustwallet.com';
     icon =
@@ -64,17 +54,10 @@ export class TrustAdapter extends Adapter {
     private _address: string | null;
 
     constructor(config: TrustAdapterConfig = {}) {
-        super();
-        const { checkTimeout = 2 * 1000, openUrlWhenWalletNotFound = true, openAppWithDeeplink = true } = config;
-
-        if (typeof checkTimeout !== 'number') {
-            throw new Error('[TrustAdapter] config.checkTimeout should be a number');
-        }
+        super(config);
 
         this.config = {
-            checkTimeout,
-            openAppWithDeeplink,
-            openUrlWhenWalletNotFound,
+            ...this.commonConfig,
         };
         this._connecting = false;
         this._wallet = null;
@@ -87,7 +70,11 @@ export class TrustAdapter extends Adapter {
         }
         if (supportTrust()) {
             this._readyState = WalletReadyState.Found;
-            this._updateWallet();
+            this._updateWallet().then(() => {
+                if (this.connected) {
+                    this.emit('connect', this.address || '');
+                }
+            });
         } else {
             this._checkWallet().then(() => {
                 if (this.connected) {
@@ -134,45 +121,34 @@ export class TrustAdapter extends Adapter {
         }
     }
 
-    async connect(): Promise<void> {
+    protected async _connect(): Promise<void> {
         try {
-            this.checkIfopenTrustWallet();
-            if (this.connected || this.connecting) return;
-            await this._checkWallet();
-            if (this.state === AdapterState.NotFound) {
-                if (this.config.openUrlWhenWalletNotFound !== false && isInBrowser()) {
-                    window.open(this.url, '_blank');
-                }
-                throw new WalletNotFoundError();
-            }
+            if (!(await this._beforeConnect())) return;
             if (!this._wallet) return;
             this._connecting = true;
             const wallet = this._wallet as TronLinkWallet;
-            try {
-                const res = await wallet.request({ method: 'tron_requestAccounts' });
-                if (!res) {
-                    throw new WalletConnectionError('Request connect error.');
-                }
-                if (res.code === 4000) {
-                    throw new 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 WalletConnectionError('The user rejected connection.');
-                }
-            } catch (error: any) {
-                throw new WalletConnectionError(error?.message, error);
+            const res = await wallet.request({ method: 'tron_requestAccounts' });
+            if (!res) {
+                throw new WalletConnectionError('Request connect error.');
+            }
+            if (res.code === 4000) {
+                throw new 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 WalletConnectionError('The user rejected connection.');
             }
 
-            const address = wallet.tronWeb.defaultAddress?.base58 || '';
+            const address = assertConnectAddress(wallet.tronWeb.defaultAddress?.base58);
             this.setAddress(address);
             this.setState(AdapterState.Connected);
             this._listenEvent();
             this.connected && this.emit('connect', this.address || '');
         } catch (error: any) {
-            this.emit('error', error);
-            throw error;
+            const err = error instanceof WalletError ? error : new WalletConnectionError(error?.message, error);
+            this.emit('error', err);
+            throw err;
         } finally {
             this._connecting = false;
         }
@@ -265,20 +241,59 @@ export class TrustAdapter extends Adapter {
     }
 
     private _stopListenEvent() {
+        this._eventGeneration++;
+        if (this._accountsChangedTimer) {
+            clearTimeout(this._accountsChangedTimer);
+            this._accountsChangedTimer = null;
+        }
         window.removeEventListener('message', this.messageHandler);
     }
 
-    private messageHandler = (e: TronLinkMessageEvent) => {
+    private _accountsChangedTimer: ReturnType<typeof setTimeout> | null = 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.
+     */
+    private _eventGeneration = 0;
+
+    private messageHandler = async (e: TronLinkMessageEvent) => {
+        if (e.origin !== window.location.origin) {
+            return;
+        }
+
         const message = e.data?.message;
         if (!message) {
             return;
         }
         if (message.action === 'accountsChanged') {
-            setTimeout(() => {
+            if (this._accountsChangedTimer) {
+                clearTimeout(this._accountsChangedTimer);
+            }
+            const generation = this._eventGeneration;
+            this._accountsChangedTimer = setTimeout(async () => {
+                this._accountsChangedTimer = null;
+                if (generation !== this._eventGeneration) return;
                 const preAddr = this.address || '';
-                if ((this._wallet as TronLinkWallet)?.ready) {
-                    const address = (message.data as AccountsChangedEventData).address;
-                    this.setAddress(address);
+                const curAddr = (message.data as AccountsChangedEventData).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 && (this._wallet as TronLinkWallet)?.ready) {
+                    try {
+                        await this.checkSecurity();
+                    } catch {
+                        if (generation !== this._eventGeneration) return;
+                        this.setAddress(null);
+                        this.setState(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(AdapterState.Connected);
                 } else {
                     this.setAddress(null);
@@ -295,9 +310,31 @@ export class TrustAdapter extends Adapter {
                 }
             }, 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 (!(this._wallet as TronLinkWallet).tronWeb?.defaultAddress?.base58) {
+                return;
+            }
+            try {
+                await this.checkSecurity();
+            } catch {
+                // 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(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 = (this._wallet as TronLinkWallet).tronWeb?.defaultAddress?.base58 || '';
+            if (!address) return;
             const isCurConnected = this.connected;
             const preAddress = this.address || '';
-            const address = (this._wallet as TronLinkWallet).tronWeb?.defaultAddress?.base58 || '';
             this.setAddress(address);
             this.setState(AdapterState.Connected);
             if (!isCurConnected) {
@@ -321,12 +358,24 @@ export class TrustAdapter extends Adapter {
         }
     }
 
+    protected _openAppByDeepLinkIfNeed(): boolean {
+        if (this.config.openAppWithDeeplink === false) {
+            return false;
+        }
+        return openTrustWallet();
+    }
+
     private _checkPromise: Promise<boolean> | null = null;
+    /**
+     * 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.
+     */
+    private _hasRunInitialDetection = false;
     /**
      * check if wallet exists by interval, the promise only resolve when wallet detected or timeout
      * @returns if trustwallet exists
      */
-    private _checkWallet(): Promise<boolean> {
+    protected _checkWallet(): Promise<boolean> {
         if (this.readyState === WalletReadyState.Found) {
             return Promise.resolve(true);
         }
@@ -334,10 +383,11 @@ export class TrustAdapter extends Adapter {
             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: ReturnType<typeof setInterval>;
-        this._checkPromise = new Promise((resolve) => {
+        const detection = new Promise<boolean>((resolve) => {
             const check = () => {
                 times++;
                 const isSupport = supportTrust();
@@ -352,17 +402,38 @@ export class TrustAdapter extends Adapter {
             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;
     }
 
-    private _updateWallet = () => {
-        let state = this.state;
-        let address = this.address;
+    private _updateWallet = async () => {
+        let state;
+        let address;
         if (supportTrust()) {
             this._wallet = window.trustwallet!.tronLink;
             this._listenEvent();
             address = this._wallet.tronWeb?.defaultAddress?.base58 || null;
-            state = this._wallet.ready ? AdapterState.Connected : AdapterState.Disconnect;
+            if (address) {
+                // Only run the security check once the wallet is actually connected.
+                try {
+                    await this.checkSecurity();
+                } catch {
+                    this.setAddress(null);
+                    this.setState(AdapterState.Disconnect);
+                    return;
+                }
+                state = AdapterState.Connected;
+            } else {
+                state = AdapterState.Disconnect;
+            }
         } else {
             this._wallet = null;
             address = null;