Merge pull request #3659 from superhero-com/release/v2.9.0

Release v2.9.0

Author: CedrikNikita

CHANGELOG.md

@@ -2,6 +2,42 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+## [2.9.0](https://github.com/Superhero-com/superhero-wallet/compare/v2.8.1...v2.9.0) (2025-10-07)
+
+
+### Features
+
+* **address-book:** add ability to sort by chain ([73ba0b4](https://github.com/Superhero-com/superhero-wallet/commit/73ba0b4e07a7003bdfe93366e1e021f16ee1884c))
+* be able to search a protocol ([817a8f1](https://github.com/Superhero-com/superhero-wallet/commit/817a8f108ae91ce10df18bc4f0f8562e61edc809))
+* collapse AccountDetailsBase header on transaction list scroll ([3ad4bc8](https://github.com/Superhero-com/superhero-wallet/commit/3ad4bc8c974fb7596c3a18052244d7503b9a3393))
+* **evm:** propogate active account to the dApp ([0bd90db](https://github.com/Superhero-com/superhero-wallet/commit/0bd90dbebf497954901bbc09ae8f376fe555aa1b))
+* search by input and chain in account selector ([8be540f](https://github.com/Superhero-com/superhero-wallet/commit/8be540f359cbcbe03e312928958b38be399b09a3))
+* show spinner in AssetSelector on tokens loading ([97f6470](https://github.com/Superhero-com/superhero-wallet/commit/97f6470b38f181b357530aa50776f022297f21be))
+* update Chinese translation ([66b641c](https://github.com/Superhero-com/superhero-wallet/commit/66b641c9a61881b9c1471574347467e14edbb79d))
+* **wallet-connect:** propagate account change ([9b819e8](https://github.com/Superhero-com/superhero-wallet/commit/9b819e80aab1652fe367ca2d578e24702243ac61))
+
+
+### Bug Fixes
+
+* webApp wallet connect link redirection ([ea87fb5](https://github.com/Superhero-com/superhero-wallet/commit/ea87fb56fe1d9838f063ef9eda0cd5d79fd5eecc))
+
+
+### Maintenance
+
+* enable transitions on chrome ([61ebb72](https://github.com/Superhero-com/superhero-wallet/commit/61ebb72bf7467270d9b9052dc6773a88f018a0b9))
+
+
+### Tests
+
+* add several walletConnect tests ([9c7061b](https://github.com/Superhero-com/superhero-wallet/commit/9c7061be1fa2942a748f64d9d7715b7c27dd469f))
+* be able to login using password ([bb9d89a](https://github.com/Superhero-com/superhero-wallet/commit/bb9d89a50ba6c9feb51393f3f77b16ef821b1f90))
+
+
+### Performance
+
+* do not store all aeternity tokens in localStorage ([6f2c99a](https://github.com/Superhero-com/superhero-wallet/commit/6f2c99aa1ec1d39e66e4b4ef6a51ced125c74ffb))
+* optimize infiniteScroll component ([abc1f9b](https://github.com/Superhero-com/superhero-wallet/commit/abc1f9ba824637961cf8c719a2020b0eb69ca6be))
+
 ### [2.8.1](https://github.com/Superhero-com/superhero-wallet/compare/v2.8.0...v2.8.1) (2025-09-19)
 
 

android/app/build.gradle

@@ -7,8 +7,8 @@ android {
         applicationId "com.superhero.cordova"
         minSdkVersion rootProject.ext.minSdkVersion
         targetSdkVersion rootProject.ext.targetSdkVersion
-        versionCode 20801
-        versionName "2.8.1"
+        versionCode 20900
+        versionName "2.9.0"
         testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
         aaptOptions {
              // Files and dirs to omit from the packaged assets dir, modified to accommodate modern web apps.

ios/App/App.xcodeproj/project.pbxproj

@@ -365,7 +365,7 @@
 					"$(inherited)",
 					"@executable_path/Frameworks",
 				);
-				MARKETING_VERSION = 2.8.1;
+				MARKETING_VERSION = 2.9.0;
 				OTHER_SWIFT_FLAGS = "$(inherited) \"-D\" \"COCOAPODS\" \"-DDEBUG\"";
 				PRODUCT_BUNDLE_IDENTIFIER = com.superhero.cordova;
 				PRODUCT_NAME = "$(TARGET_NAME)";
@@ -390,7 +390,7 @@
 					"$(inherited)",
 					"@executable_path/Frameworks",
 				);
-				MARKETING_VERSION = 2.8.1;
+				MARKETING_VERSION = 2.9.0;
 				PRODUCT_BUNDLE_IDENTIFIER = com.superhero.cordova;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SWIFT_ACTIVE_COMPILATION_CONDITIONS = "";

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "superhero-wallet",
-  "version": "2.8.1",
+  "version": "2.9.0",
   "description": "Superhero wallet",
   "author": "Superhero",
   "license": "ISC",

package.json

@@ -59,6 +59,18 @@ const handleMessage: Parameters<typeof browser.runtime.onMessage.addListener>[0]
           }
         });
         break;
+      case 'accountsChanged':
+        browser.tabs.query({ active: true, lastFocusedWindow: true }).then(([tab]) => {
+          if (tab.id) {
+            browser.tabs.sendMessage(tab.id, {
+              superheroWalletApproved: true,
+              method: msg.method,
+              result: msg.params?.rpcMethodParams?.result,
+              type: 'result',
+            });
+          }
+        });
+        break;
       case 'openPopup':
         openPopup(popupType!, aepp!, popupProps).then((popupConfig) => {
           sendResponse(popupConfig);

src/background/index.ts

@@ -1,6 +1,6 @@
 /* eslint-disable no-param-reassign */
 
-import { computed, watch } from 'vue';
+import { computed, ref, watch } from 'vue';
 import { uniqBy, isEmpty } from 'lodash-es';
 import BigNumber from 'bignumber.js';
 import { Contract, Encoding, Tag } from '@aeternity/aepp-sdk';
@@ -46,6 +46,12 @@ const defaultTokensAvailable = useStorageRef<ProtocolRecord<AssetList>>(
   STORAGE_KEYS.fungibleTokenList,
 );
 
+/**
+ * Ephemeral (in-memory) list of available tokens per protocol.
+ * Used to avoid persisting large lists (notably Aeternity) into localStorage.
+ */
+const ephemeralTokensAvailable = ref<ProtocolRecord<AssetList>>({});
+
 /**
  * List of user account's token asset balances.
  */
@@ -59,6 +65,11 @@ const lastAvailableTokensLoadTime = useStorageRef<number>(
   STORAGE_KEYS.lastAvailableTokensLoadTime,
 );
 
+/**
+ * Loading state for available tokens fetch per session.
+ */
+const isAvailableTokensLoading = ref(false);
+
 /**
  * List of all fungible tokens available on user's protocols.
  * Includes tokens from the user's account that are not on the main list.
@@ -90,7 +101,10 @@ const tokensAvailable = computed((): ProtocolRecord<AssetList> => {
 
   return Object.values(PROTOCOLS).reduce((allTokens, protocol) => {
     allTokens[protocol] = {
+      // Persisted tokens
       ...(defaultTokensAvailable.value[protocol] ?? {}),
+      // Ephemeral tokens (e.g., Aeternity full list)
+      ...(ephemeralTokensAvailable.value[protocol] ?? {}),
       ...customTokensAvailable[protocol],
     };
     return allTokens;
@@ -177,35 +191,48 @@ export function useFungibleTokens() {
     if (Date.now() - lastAvailableTokensLoadTime.value < 1000 * 60) {
       return;
     }
-    const tokensFetchPromises = protocolsInUse.value.map(
-      (protocol) => ProtocolAdapterFactory.getAdapter(protocol).fetchAvailableTokens?.(),
-    );
-    const currentNetworkName = activeNetwork.value.name;
-    // for each promise check if it returned null, if so, use cached data
-    // because it means that we couldn't fetch new data
-    const tokens: IToken[] = (await Promise.all(tokensFetchPromises)).map(
-      (protocolTokens, index) => (
-        protocolTokens
-        || Object.values(defaultTokensAvailable.value[protocolsInUse.value[index]] || {})
-      ),
-    ).flat();
-
-    // This is necessary in case the user switches between networks faster,
-    // than the available tokens are returned (limitations of the free Ethereum middleware)
-    if (currentNetworkName !== activeNetwork.value.name) {
-      return;
-    }
-
-    defaultTokensAvailable.value = tokens.reduce((accumulator, token) => {
-      const { contractId, protocol } = token;
-      if (!accumulator[protocol]) {
-        accumulator[protocol] = {} as AssetList;
+    isAvailableTokensLoading.value = true;
+    try {
+      const tokensFetchPromises = protocolsInUse.value.map(
+        (protocol) => ProtocolAdapterFactory.getAdapter(protocol).fetchAvailableTokens?.(),
+      );
+      const currentNetworkName = activeNetwork.value.name;
+      // for each promise check if it returned null, if so, use cached data
+      // because it means that we couldn't fetch new data
+      const results = await Promise.all(tokensFetchPromises);
+      const tokensByProtocol: ProtocolRecord<IToken[]> = {} as any;
+      results.forEach((protocolTokens, index) => {
+        const protocol = protocolsInUse.value[index];
+        const persistedFallback = Object.values(defaultTokensAvailable.value[protocol] || {});
+        const ephemeralFallback = Object.values(ephemeralTokensAvailable.value[protocol] || {});
+        tokensByProtocol[protocol] = (protocolTokens as IToken[] | null)
+        || (protocol === PROTOCOLS.aeternity ? ephemeralFallback : persistedFallback);
+      });
+
+      // This is necessary in case the user switches between networks faster,
+      // than the available tokens are returned (limitations of the free Ethereum middleware)
+      if (currentNetworkName !== activeNetwork.value.name) {
+        return;
       }
-      accumulator[protocol]![contractId] = token;
-      return accumulator;
-    }, {} as typeof defaultTokensAvailable.value);
 
-    lastAvailableTokensLoadTime.value = Date.now();
+      // Store fetched tokens per protocol
+      Object.entries(tokensByProtocol).forEach(([protocol, tokens]) => {
+        const pr = protocol as Protocol;
+        const target = pr === PROTOCOLS.aeternity
+          ? ephemeralTokensAvailable
+          : defaultTokensAvailable;
+        const currentMap = (target.value[pr] ?? {}) as AssetList;
+        const nextMap = (tokens as IToken[]).reduce((acc, token) => {
+          acc[token.contractId] = token;
+          return acc;
+        }, { ...currentMap } as AssetList);
+        target.value[pr] = nextMap;
+      });
+
+      lastAvailableTokensLoadTime.value = Date.now();
+    } finally {
+      isAvailableTokensLoading.value = false;
+    }
   }
 
   async function loadTokenBalances() {
@@ -370,6 +397,7 @@ export function useFungibleTokens() {
       if (newMiddlewareUrl !== oldMiddlewareUrl) {
         tokenBalances.value = [];
         defaultTokensAvailable.value = {};
+        ephemeralTokensAvailable.value = {};
         lastAvailableTokensLoadTime.value = 0;
         await loadTokenBalances();
       }
@@ -380,6 +408,7 @@ export function useFungibleTokens() {
     accountsTotalTokenBalance,
     tokenBalances,
     tokensAvailable,
+    isAvailableTokensLoading,
     createOrChangeAllowance,
     loadSingleToken,
     getAccountTokenBalance,

src/composables/fungibleTokens.ts

@@ -24,16 +24,16 @@ export const useViewport = () => {
   }
 
   function onViewportScroll(onScrollMethod: OnViewportScrollCallback) {
-    if (viewportElement.value) {
-      viewportElement.value.addEventListener('scroll', () => viewportScroll(onScrollMethod));
-    }
-    window.addEventListener('scroll', () => viewportScroll(onScrollMethod));
+    const handler = () => viewportScroll(onScrollMethod);
+    const target = viewportElement.value ?? window;
+    // Prefer passive listener to avoid layout thrash
+    target.addEventListener('scroll', handler as EventListener, { passive: true } as any);
+
     onBeforeUnmount(() => {
-      if (viewportElement.value) {
-        viewportElement.value.removeEventListener('scroll', () => viewportScroll(onScrollMethod));
+      target.removeEventListener('scroll', handler as EventListener);
+      if (viewportElement.value === target) {
         viewportElement.value = undefined;
       }
-      window.removeEventListener('scroll', () => viewportScroll(onScrollMethod));
     });
   }
 

src/composables/viewport.ts

@@ -352,28 +352,58 @@ export function useWalletConnect({ offscreen } = { offscreen: false }) {
    * Notify the DAPP about the active wallet account change.
    */
   function monitorActiveAccountAndNetwork() {
-    const unwatch = watch([activeAccount, activeNetwork], async ([newAccount]) => {
-      if (!EVM_PROTOCOLS.includes(newAccount.protocol)) {
-        return;
-      }
-      if (web3wallet && wcSession.value) {
+    const unwatch = watch(
+      [activeAccount, activeNetwork],
+      async ([newAccount], [oldAccount]) => {
+        if (!EVM_PROTOCOLS.includes(newAccount.protocol)) return;
+        if (!web3wallet || !wcSession.value) { unwatch(); return; }
+
         const { accounts, chains } = getFormattedAccountsAndChains();
 
         wcSession.value.namespaces[ETH_CHAIN_NAMESPACE].chains = chains;
         wcSession.value.namespaces[ETH_CHAIN_NAMESPACE].accounts = accounts;
 
         try {
           const activeProtocols = (networks.value[activeNetwork.value.name].protocols as any);
-          const preferredChainId = `${ETH_CHAIN_NAMESPACE}:${activeProtocols[newAccount.protocol].chainId}`;
-          await web3wallet.emitSessionEvent({
+          const preferredChainIdDec = activeProtocols[newAccount.protocol].chainId.toString();
+          const preferredChainId = `${ETH_CHAIN_NAMESPACE}:${preferredChainIdDec}`;
+
+          // Reorder accounts so the active address is first for every chain group
+          // Dapps (like Uniswap) often pick the first account for the chain they're using
+          const byChain: Record<string, string[]> = {};
+          accounts.forEach((acc) => {
+            const [, chainId] = acc.split(':');
+            if (!byChain[chainId]) byChain[chainId] = [];
+            byChain[chainId].push(acc);
+          });
+          const reorderedAccounts = Object.entries(byChain).flatMap(([chainId, accs]) => {
+            const target = `${ETH_CHAIN_NAMESPACE}:${chainId}:${newAccount.address}`;
+            const first = accs.filter((a) => a === target);
+            const rest = accs.filter((a) => a !== target);
+            return [...first, ...rest];
+          });
+          wcSession.value.namespaces[ETH_CHAIN_NAMESPACE].accounts = reorderedAccounts;
+
+          // Update session first so dapps relying on session_update pick the correct account
+          const { acknowledged } = await web3wallet.updateSession({
             topic: wcSession.value.topic,
-            event: {
-              name: 'accountsChanged',
-              data: [newAccount.address],
-            },
-            chainId: preferredChainId,
+            namespaces: wcSession.value.namespaces,
           });
+          await acknowledged();
 
+          // Emit accountsChanged only when address actually changes
+          if (!oldAccount || oldAccount.address !== newAccount.address) {
+            await web3wallet.emitSessionEvent({
+              topic: wcSession.value.topic,
+              event: {
+                name: 'accountsChanged',
+                data: [newAccount.address],
+              },
+              chainId: preferredChainId,
+            });
+          }
+
+          // Keep chain in sync for the selected protocol
           await web3wallet.emitSessionEvent({
             topic: wcSession.value.topic,
             event: {
@@ -382,24 +412,11 @@ export function useWalletConnect({ offscreen } = { offscreen: false }) {
             },
             chainId: preferredChainId,
           });
-
-          const { acknowledged } = await web3wallet.updateSession({
-            topic: wcSession.value.topic,
-            namespaces: wcSession.value.namespaces,
-          });
-
-          // Even if the session update is acknowledged some DAPPS does not update the UI
-          // to match the change. For example Uniswap does not switch the account if user did it
-          // on the wallet side.
-          await acknowledged();
         } catch (error) {
           disconnect();
         }
-      } else {
-        unwatch();
-        disconnect();
-      }
-    });
+      },
+    );
   }
 
   /**
@@ -466,7 +483,11 @@ export function useWalletConnect({ offscreen } = { offscreen: false }) {
                 [ETH_CHAIN_NAMESPACE]: {
                   accounts,
                   chains,
-                  events: uniq([...proposal.requiredNamespaces[ETH_CHAIN_NAMESPACE]?.events || [], 'accountsChanged']),
+                  events: uniq([
+                    ...proposal.requiredNamespaces[ETH_CHAIN_NAMESPACE]?.events || [],
+                    'accountsChanged',
+                    'chainChanged',
+                  ]),
                   methods,
                 },
               },

src/composables/walletConnect.ts

@@ -75,5 +75,3 @@ export const ETHERSCAN_API_KEY = process.env.ETHERSCAN_API_KEY!;
 export const ETHPLORER_API_KEY = process.env.ETHPLORER_API_KEY!;
 
 export const WALLET_CONNECT_PROJECT_ID = process.env.WALLET_CONNECT_PROJECT_ID!;
-
-export const IS_TRANSITIONS_DISABLED = IS_CHROME_BASED && !IS_ANDROID && !IS_IOS;