@taquito/wallet-connect 24.3.0-beta.1 → 24.3.0-beta.3

package/README.md

@@ -10,6 +10,7 @@ _Documentation can be found [here](https://taquito.io/docs/walletconnect)_
 
 `@taquito/wallet-connect` is an npm package that provides developers a way to connect a dapp built with Taquito to a wallet giving the freedom to the users of the dapp to choose the wallet via the WalletConnect/Reown protocol. The `WalletConnect` class implements the `WalletProvider` interface, providing an alternative to `BeaconWallet`.
 Note: Currently, a QR code is displayed to establish a connection with a wallet. As more Tezos wallets integrate with WalletConnect, we plan showing a list of available wallets alongside the QR code.
+Note: The current QR pairing flow still relies on the legacy WalletConnect modal package. We plan to replace that modal integration in a future release.
 
 ## Install
 
@@ -39,7 +40,7 @@ const wallet = await WalletConnect.init({
 
 await wallet.requestPermissions({
     permissionScope: {
-        networks: [NetworkType.GHOSTNET],
+        networks: [NetworkType.SHADOWNET],
         events: [],
         methods: [
             PermissionScopeMethods.TEZOS_SEND,
@@ -53,6 +54,8 @@ const Tezos = new TezosToolkit('https://YOUR_PREFERRED_RPC_URL');
 Tezos.setWalletProvider(wallet);
 ```
 
+Existing sessions can be restored with `configureWithExistingSessionKey()`. Restored sessions are validated before activation, so invalid or stale non-Tezos session data may be rejected during restore.
+
 ## Additional Info
 
 See the top-level [https://github.com/ecadlabs/taquito](https://github.com/ecadlabs/taquito) file for details on reporting issues, contributing and versioning.

package/dist/lib/taquito-wallet-connect.js

@@ -40,18 +40,20 @@ class WalletConnect {
         this.walletConnectModal = WalletConnectModal;
         this.signClient.on('session_delete', ({ topic }) => {
             if (this.session?.topic === topic) {
-                this.session = undefined;
+                this.clearState();
             }
         });
         this.signClient.on('session_expire', ({ topic }) => {
             if (this.session?.topic === topic) {
-                this.session = undefined;
+                this.clearState();
             }
         });
         this.signClient.on('session_update', ({ params, topic }) => {
             if (this.session?.topic === topic) {
-                this.session.namespaces = params.namespaces;
-                // TODO determine if we need validation on the namespace here
+                this.activateSession({
+                    ...this.session,
+                    namespaces: params.namespaces,
+                }, undefined, false);
             }
         });
         this.signClient.on('session_event', () => {
@@ -95,10 +97,11 @@ class WalletConnect {
      */
     async requestPermissions(connectParams) {
         // TODO when Tezos wallets will officially support wallet connect, we need to provide a default value for registryUrl
+        let approvedSession;
         try {
             const chains = connectParams.permissionScope.networks.map((network) => `${TEZOS_PLACEHOLDER}:${network}`);
             const { uri, approval } = await this.signClient.connect({
-                requiredNamespaces: {
+                optionalNamespaces: {
                     [TEZOS_PLACEHOLDER]: {
                         chains,
                         methods: connectParams.permissionScope.methods,
@@ -113,7 +116,7 @@ class WalletConnect {
                     chains,
                 });
             }
-            this.session = await approval();
+            approvedSession = await approval();
         }
         catch (error) {
             throw new errors_1.ConnectionFailed(error);
@@ -121,8 +124,7 @@ class WalletConnect {
         finally {
             this.walletConnectModal.closeModal();
         }
-        this.validateReceivedNamespace(connectParams.permissionScope, this.session.namespaces);
-        this.setDefaultAccountAndNetwork();
+        this.activateSession(approvedSession, connectParams.permissionScope);
     }
     /**
      * Access all existing active pairings
@@ -147,8 +149,7 @@ class WalletConnect {
         if (!sessions.includes(key)) {
             throw new errors_1.InvalidSessionKey(key);
         }
-        this.session = this.signClient.session.get(key);
-        this.setDefaultAccountAndNetwork();
+        this.activateSession(this.signClient.session.get(key));
     }
     async disconnect() {
         if (this.session) {
@@ -304,14 +305,28 @@ class WalletConnect {
         }
         return this.activeNetwork;
     }
-    setDefaultAccountAndNetwork() {
-        const activeAccount = this.getAccounts();
-        if (activeAccount.length === 1) {
-            this.activeAccount = activeAccount[0];
+    activateSession(session, permissionScope, resetActiveState = true) {
+        this.session = session;
+        if (permissionScope) {
+            this.validateReceivedNamespace(permissionScope, session.namespaces);
         }
-        const activeNetwork = this.getNetworks();
-        if (activeNetwork.length === 1) {
-            this.activeNetwork = activeNetwork[0];
+        else {
+            this.validateRestoredNamespace(session.namespaces);
+        }
+        if (resetActiveState) {
+            this.activeAccount = undefined;
+            this.activeNetwork = undefined;
+        }
+        this.reconcileActiveAccountAndNetwork();
+    }
+    reconcileActiveAccountAndNetwork() {
+        const accounts = this.getAccounts();
+        if (!this.activeAccount || !accounts.includes(this.activeAccount)) {
+            this.activeAccount = accounts.length === 1 ? accounts[0] : undefined;
+        }
+        const networks = this.getNetworks();
+        if (!this.activeNetwork || !networks.includes(this.activeNetwork)) {
+            this.activeNetwork = networks.length === 1 ? networks[0] : undefined;
         }
     }
     clearState() {
@@ -358,6 +373,14 @@ class WalletConnect {
             throw new errors_1.InvalidReceivedSessionNamespace('All methods must be approved', (0, utils_1.getSdkError)('USER_REJECTED_METHODS').code, 'incomplete', missingMethods);
         }
     }
+    validateRestoredNamespace(receivedNamespaces) {
+        const tezosNamespace = receivedNamespaces[TEZOS_PLACEHOLDER];
+        if (!tezosNamespace) {
+            this.clearState();
+            throw new errors_1.InvalidSession('Tezos not found in namespaces');
+        }
+        this.validateAccounts(this.getChainsFromAccounts(tezosNamespace.accounts), tezosNamespace.accounts);
+    }
     validateEvents(requiredEvents, receivedEvents) {
         const missingEvents = [];
         requiredEvents.forEach((method) => {
@@ -375,7 +398,6 @@ class WalletConnect {
             this.clearState();
             throw new errors_1.InvalidReceivedSessionNamespace('Accounts must not be empty', (0, utils_1.getSdkError)('USER_REJECTED_CHAINS').code, 'incomplete');
         }
-        const receivedChains = [];
         const invalidChains = [];
         const missingChains = [];
         const invalidChainsNamespace = [];
@@ -387,10 +409,6 @@ class WalletConnect {
             if (accountId[0] !== TEZOS_PLACEHOLDER) {
                 invalidChainsNamespace.push(chain);
             }
-            const network = accountId[1];
-            if (!receivedChains.includes(network)) {
-                receivedChains.push(network);
-            }
         });
         if (invalidChains.length > 0) {
             this.clearState();
@@ -400,6 +418,7 @@ class WalletConnect {
             this.clearState();
             throw new errors_1.InvalidReceivedSessionNamespace('Accounts must be defined in matching namespace', (0, utils_1.getSdkError)('UNSUPPORTED_ACCOUNTS').code, 'invalid', invalidChainsNamespace);
         }
+        const receivedChains = this.getChainsFromAccounts(receivedAccounts);
         requiredNetwork.forEach((network) => {
             if (!receivedChains.includes(network)) {
                 missingChains.push(network);
@@ -418,24 +437,19 @@ class WalletConnect {
             throw new errors_1.InvalidSession('Tezos not found in namespaces');
         }
     }
-    getTezosRequiredNamespace() {
-        if (TEZOS_PLACEHOLDER in this.getSession().requiredNamespaces) {
-            return this.getSession().requiredNamespaces[TEZOS_PLACEHOLDER];
-        }
-        else {
-            throw new errors_1.InvalidSession('Tezos not found in requiredNamespaces');
-        }
-    }
     validateNetworkAndAccount(network, account) {
         if (!this.getTezosNamespace().accounts.includes(`${TEZOS_PLACEHOLDER}:${network}:${account}`)) {
             throw new errors_1.InvalidNetworkOrAccount(network, account);
         }
     }
     getPermittedMethods() {
-        return this.getTezosRequiredNamespace().methods;
+        return this.getTezosNamespace().methods;
     }
     getPermittedNetwork() {
-        return this.getTezosRequiredNamespace().chains.map((chain) => chain.split(':')[1]);
+        return this.getChainsFromAccounts(this.getTezosNamespace().accounts);
+    }
+    getChainsFromAccounts(accounts) {
+        return [...new Set(accounts.map((account) => account.split(':')[1]))];
     }
     formatParameters(params) {
         const formatedParams = params;

package/dist/lib/version.js

@@ -3,6 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION = void 0;
 // IMPORTANT: THIS FILE IS AUTO GENERATED! DO NOT MANUALLY EDIT!
 exports.VERSION = {
-    "commitHash": "05df48fee92f846cba793920d6fa829afd6a1847",
-    "version": "24.3.0-beta.1"
+    "commitHash": "a312cd3f4fc0ab0fb3351bfffe6ad855772cb077",
+    "version": "24.3.0-beta.3"
 };

package/dist/taquito-wallet-connect.es6.js

@@ -181,18 +181,20 @@ class WalletConnect {
         this.walletConnectModal = WalletConnectModal;
         this.signClient.on('session_delete', ({ topic }) => {
             if (this.session?.topic === topic) {
-                this.session = undefined;
+                this.clearState();
             }
         });
         this.signClient.on('session_expire', ({ topic }) => {
             if (this.session?.topic === topic) {
-                this.session = undefined;
+                this.clearState();
             }
         });
         this.signClient.on('session_update', ({ params, topic }) => {
             if (this.session?.topic === topic) {
-                this.session.namespaces = params.namespaces;
-                // TODO determine if we need validation on the namespace here
+                this.activateSession({
+                    ...this.session,
+                    namespaces: params.namespaces,
+                }, undefined, false);
             }
         });
         this.signClient.on('session_event', () => {
@@ -236,10 +238,11 @@ class WalletConnect {
      */
     async requestPermissions(connectParams) {
         // TODO when Tezos wallets will officially support wallet connect, we need to provide a default value for registryUrl
+        let approvedSession;
         try {
             const chains = connectParams.permissionScope.networks.map((network) => `${TEZOS_PLACEHOLDER}:${network}`);
             const { uri, approval } = await this.signClient.connect({
-                requiredNamespaces: {
+                optionalNamespaces: {
                     [TEZOS_PLACEHOLDER]: {
                         chains,
                         methods: connectParams.permissionScope.methods,
@@ -254,7 +257,7 @@ class WalletConnect {
                     chains,
                 });
             }
-            this.session = await approval();
+            approvedSession = await approval();
         }
         catch (error) {
             throw new ConnectionFailed(error);
@@ -262,8 +265,7 @@ class WalletConnect {
         finally {
             this.walletConnectModal.closeModal();
         }
-        this.validateReceivedNamespace(connectParams.permissionScope, this.session.namespaces);
-        this.setDefaultAccountAndNetwork();
+        this.activateSession(approvedSession, connectParams.permissionScope);
     }
     /**
      * Access all existing active pairings
@@ -288,8 +290,7 @@ class WalletConnect {
         if (!sessions.includes(key)) {
             throw new InvalidSessionKey(key);
         }
-        this.session = this.signClient.session.get(key);
-        this.setDefaultAccountAndNetwork();
+        this.activateSession(this.signClient.session.get(key));
     }
     async disconnect() {
         if (this.session) {
@@ -445,14 +446,28 @@ class WalletConnect {
         }
         return this.activeNetwork;
     }
-    setDefaultAccountAndNetwork() {
-        const activeAccount = this.getAccounts();
-        if (activeAccount.length === 1) {
-            this.activeAccount = activeAccount[0];
+    activateSession(session, permissionScope, resetActiveState = true) {
+        this.session = session;
+        if (permissionScope) {
+            this.validateReceivedNamespace(permissionScope, session.namespaces);
         }
-        const activeNetwork = this.getNetworks();
-        if (activeNetwork.length === 1) {
-            this.activeNetwork = activeNetwork[0];
+        else {
+            this.validateRestoredNamespace(session.namespaces);
+        }
+        if (resetActiveState) {
+            this.activeAccount = undefined;
+            this.activeNetwork = undefined;
+        }
+        this.reconcileActiveAccountAndNetwork();
+    }
+    reconcileActiveAccountAndNetwork() {
+        const accounts = this.getAccounts();
+        if (!this.activeAccount || !accounts.includes(this.activeAccount)) {
+            this.activeAccount = accounts.length === 1 ? accounts[0] : undefined;
+        }
+        const networks = this.getNetworks();
+        if (!this.activeNetwork || !networks.includes(this.activeNetwork)) {
+            this.activeNetwork = networks.length === 1 ? networks[0] : undefined;
         }
     }
     clearState() {
@@ -499,6 +514,14 @@ class WalletConnect {
             throw new InvalidReceivedSessionNamespace('All methods must be approved', getSdkError('USER_REJECTED_METHODS').code, 'incomplete', missingMethods);
         }
     }
+    validateRestoredNamespace(receivedNamespaces) {
+        const tezosNamespace = receivedNamespaces[TEZOS_PLACEHOLDER];
+        if (!tezosNamespace) {
+            this.clearState();
+            throw new InvalidSession('Tezos not found in namespaces');
+        }
+        this.validateAccounts(this.getChainsFromAccounts(tezosNamespace.accounts), tezosNamespace.accounts);
+    }
     validateEvents(requiredEvents, receivedEvents) {
         const missingEvents = [];
         requiredEvents.forEach((method) => {
@@ -516,7 +539,6 @@ class WalletConnect {
             this.clearState();
             throw new InvalidReceivedSessionNamespace('Accounts must not be empty', getSdkError('USER_REJECTED_CHAINS').code, 'incomplete');
         }
-        const receivedChains = [];
         const invalidChains = [];
         const missingChains = [];
         const invalidChainsNamespace = [];
@@ -528,10 +550,6 @@ class WalletConnect {
             if (accountId[0] !== TEZOS_PLACEHOLDER) {
                 invalidChainsNamespace.push(chain);
             }
-            const network = accountId[1];
-            if (!receivedChains.includes(network)) {
-                receivedChains.push(network);
-            }
         });
         if (invalidChains.length > 0) {
             this.clearState();
@@ -541,6 +559,7 @@ class WalletConnect {
             this.clearState();
             throw new InvalidReceivedSessionNamespace('Accounts must be defined in matching namespace', getSdkError('UNSUPPORTED_ACCOUNTS').code, 'invalid', invalidChainsNamespace);
         }
+        const receivedChains = this.getChainsFromAccounts(receivedAccounts);
         requiredNetwork.forEach((network) => {
             if (!receivedChains.includes(network)) {
                 missingChains.push(network);
@@ -559,24 +578,19 @@ class WalletConnect {
             throw new InvalidSession('Tezos not found in namespaces');
         }
     }
-    getTezosRequiredNamespace() {
-        if (TEZOS_PLACEHOLDER in this.getSession().requiredNamespaces) {
-            return this.getSession().requiredNamespaces[TEZOS_PLACEHOLDER];
-        }
-        else {
-            throw new InvalidSession('Tezos not found in requiredNamespaces');
-        }
-    }
     validateNetworkAndAccount(network, account) {
         if (!this.getTezosNamespace().accounts.includes(`${TEZOS_PLACEHOLDER}:${network}:${account}`)) {
             throw new InvalidNetworkOrAccount(network, account);
         }
     }
     getPermittedMethods() {
-        return this.getTezosRequiredNamespace().methods;
+        return this.getTezosNamespace().methods;
     }
     getPermittedNetwork() {
-        return this.getTezosRequiredNamespace().chains.map((chain) => chain.split(':')[1]);
+        return this.getChainsFromAccounts(this.getTezosNamespace().accounts);
+    }
+    getChainsFromAccounts(accounts) {
+        return [...new Set(accounts.map((account) => account.split(':')[1]))];
     }
     formatParameters(params) {
         const formatedParams = params;

package/dist/taquito-wallet-connect.es6.js.map

@@ -1 +1 @@
-{"version":3,"file":"taquito-wallet-connect.es6.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"taquito-wallet-connect.es6.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/taquito-wallet-connect.umd.js

@@ -182,18 +182,20 @@
           this.walletConnectModal = WalletConnectModal;
           this.signClient.on('session_delete', ({ topic }) => {
               if (this.session?.topic === topic) {
-                  this.session = undefined;
+                  this.clearState();
               }
           });
           this.signClient.on('session_expire', ({ topic }) => {
               if (this.session?.topic === topic) {
-                  this.session = undefined;
+                  this.clearState();
               }
           });
           this.signClient.on('session_update', ({ params, topic }) => {
               if (this.session?.topic === topic) {
-                  this.session.namespaces = params.namespaces;
-                  // TODO determine if we need validation on the namespace here
+                  this.activateSession({
+                      ...this.session,
+                      namespaces: params.namespaces,
+                  }, undefined, false);
               }
           });
           this.signClient.on('session_event', () => {
@@ -237,10 +239,11 @@
        */
       async requestPermissions(connectParams) {
           // TODO when Tezos wallets will officially support wallet connect, we need to provide a default value for registryUrl
+          let approvedSession;
           try {
               const chains = connectParams.permissionScope.networks.map((network) => `${TEZOS_PLACEHOLDER}:${network}`);
               const { uri, approval } = await this.signClient.connect({
-                  requiredNamespaces: {
+                  optionalNamespaces: {
                       [TEZOS_PLACEHOLDER]: {
                           chains,
                           methods: connectParams.permissionScope.methods,
@@ -255,7 +258,7 @@
                       chains,
                   });
               }
-              this.session = await approval();
+              approvedSession = await approval();
           }
           catch (error) {
               throw new ConnectionFailed(error);
@@ -263,8 +266,7 @@
           finally {
               this.walletConnectModal.closeModal();
           }
-          this.validateReceivedNamespace(connectParams.permissionScope, this.session.namespaces);
-          this.setDefaultAccountAndNetwork();
+          this.activateSession(approvedSession, connectParams.permissionScope);
       }
       /**
        * Access all existing active pairings
@@ -289,8 +291,7 @@
           if (!sessions.includes(key)) {
               throw new InvalidSessionKey(key);
           }
-          this.session = this.signClient.session.get(key);
-          this.setDefaultAccountAndNetwork();
+          this.activateSession(this.signClient.session.get(key));
       }
       async disconnect() {
           if (this.session) {
@@ -446,14 +447,28 @@
           }
           return this.activeNetwork;
       }
-      setDefaultAccountAndNetwork() {
-          const activeAccount = this.getAccounts();
-          if (activeAccount.length === 1) {
-              this.activeAccount = activeAccount[0];
+      activateSession(session, permissionScope, resetActiveState = true) {
+          this.session = session;
+          if (permissionScope) {
+              this.validateReceivedNamespace(permissionScope, session.namespaces);
           }
-          const activeNetwork = this.getNetworks();
-          if (activeNetwork.length === 1) {
-              this.activeNetwork = activeNetwork[0];
+          else {
+              this.validateRestoredNamespace(session.namespaces);
+          }
+          if (resetActiveState) {
+              this.activeAccount = undefined;
+              this.activeNetwork = undefined;
+          }
+          this.reconcileActiveAccountAndNetwork();
+      }
+      reconcileActiveAccountAndNetwork() {
+          const accounts = this.getAccounts();
+          if (!this.activeAccount || !accounts.includes(this.activeAccount)) {
+              this.activeAccount = accounts.length === 1 ? accounts[0] : undefined;
+          }
+          const networks = this.getNetworks();
+          if (!this.activeNetwork || !networks.includes(this.activeNetwork)) {
+              this.activeNetwork = networks.length === 1 ? networks[0] : undefined;
           }
       }
       clearState() {
@@ -500,6 +515,14 @@
               throw new InvalidReceivedSessionNamespace('All methods must be approved', utils.getSdkError('USER_REJECTED_METHODS').code, 'incomplete', missingMethods);
           }
       }
+      validateRestoredNamespace(receivedNamespaces) {
+          const tezosNamespace = receivedNamespaces[TEZOS_PLACEHOLDER];
+          if (!tezosNamespace) {
+              this.clearState();
+              throw new InvalidSession('Tezos not found in namespaces');
+          }
+          this.validateAccounts(this.getChainsFromAccounts(tezosNamespace.accounts), tezosNamespace.accounts);
+      }
       validateEvents(requiredEvents, receivedEvents) {
           const missingEvents = [];
           requiredEvents.forEach((method) => {
@@ -517,7 +540,6 @@
               this.clearState();
               throw new InvalidReceivedSessionNamespace('Accounts must not be empty', utils.getSdkError('USER_REJECTED_CHAINS').code, 'incomplete');
           }
-          const receivedChains = [];
           const invalidChains = [];
           const missingChains = [];
           const invalidChainsNamespace = [];
@@ -529,10 +551,6 @@
               if (accountId[0] !== TEZOS_PLACEHOLDER) {
                   invalidChainsNamespace.push(chain);
               }
-              const network = accountId[1];
-              if (!receivedChains.includes(network)) {
-                  receivedChains.push(network);
-              }
           });
           if (invalidChains.length > 0) {
               this.clearState();
@@ -542,6 +560,7 @@
               this.clearState();
               throw new InvalidReceivedSessionNamespace('Accounts must be defined in matching namespace', utils.getSdkError('UNSUPPORTED_ACCOUNTS').code, 'invalid', invalidChainsNamespace);
           }
+          const receivedChains = this.getChainsFromAccounts(receivedAccounts);
           requiredNetwork.forEach((network) => {
               if (!receivedChains.includes(network)) {
                   missingChains.push(network);
@@ -560,24 +579,19 @@
               throw new InvalidSession('Tezos not found in namespaces');
           }
       }
-      getTezosRequiredNamespace() {
-          if (TEZOS_PLACEHOLDER in this.getSession().requiredNamespaces) {
-              return this.getSession().requiredNamespaces[TEZOS_PLACEHOLDER];
-          }
-          else {
-              throw new InvalidSession('Tezos not found in requiredNamespaces');
-          }
-      }
       validateNetworkAndAccount(network, account) {
           if (!this.getTezosNamespace().accounts.includes(`${TEZOS_PLACEHOLDER}:${network}:${account}`)) {
               throw new InvalidNetworkOrAccount(network, account);
           }
       }
       getPermittedMethods() {
-          return this.getTezosRequiredNamespace().methods;
+          return this.getTezosNamespace().methods;
       }
       getPermittedNetwork() {
-          return this.getTezosRequiredNamespace().chains.map((chain) => chain.split(':')[1]);
+          return this.getChainsFromAccounts(this.getTezosNamespace().accounts);
+      }
+      getChainsFromAccounts(accounts) {
+          return [...new Set(accounts.map((account) => account.split(':')[1]))];
       }
       formatParameters(params) {
           const formatedParams = params;

package/dist/taquito-wallet-connect.umd.js.map

@@ -1 +1 @@
-{"version":3,"file":"taquito-wallet-connect.umd.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"taquito-wallet-connect.umd.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/types/taquito-wallet-connect.d.ts

@@ -122,20 +122,22 @@ export declare class WalletConnect implements WalletProvider {
      \* @throws ActiveNetworkUnspecified thorwn when there are multiple Tezos netwroks in the session and none is set as the active one
      */
     getActiveNetwork(): string;
-    private setDefaultAccountAndNetwork;
+    private activateSession;
+    private reconcileActiveAccountAndNetwork;
     private clearState;
     getSession(): SessionTypes.Struct;
     isActiveSession(): boolean;
     ping(): void;
     private validateReceivedNamespace;
     private validateMethods;
+    private validateRestoredNamespace;
     private validateEvents;
     private validateAccounts;
     private getTezosNamespace;
-    private getTezosRequiredNamespace;
     private validateNetworkAndAccount;
     private getPermittedMethods;
     private getPermittedNetwork;
+    private getChainsFromAccounts;
     private formatParameters;
     private removeDefaultLimits;
     mapTransferParamsToWalletParams(params: () => Promise<WalletTransferParams>): Promise<Partial<RPCTransferOperation> | Partial<RPCTransferTicketOperation> | Partial<RPCOriginationOperation> | Partial<RPCDelegateOperation> | Partial<RPCIncreasePaidStorageOperation> | Partial<RPCRegisterGlobalConstantOperation>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taquito/wallet-connect",
-  "version": "24.3.0-beta.1",
+  "version": "24.3.0-beta.3",
   "description": "WalletConnect integration for Taquito applications.",
   "keywords": [
     "taquito",
@@ -14,7 +14,6 @@
   "module": "dist/taquito-wallet-connect.es6.js",
   "typings": "dist/types/taquito-wallet-connect.d.ts",
   "files": [
-    "signature.json",
     "dist"
   ],
   "publishConfig": {
@@ -39,9 +38,9 @@
     "node": ">=22"
   },
   "scripts": {
-    "test": "jest --coverage",
-    "test:watch": "jest --coverage --watch",
-    "test:prod": "npm run lint && npm run test -- --no-cache",
+    "test": "vitest run --config ./vitest.config.ts",
+    "test:watch": "vitest --config ./vitest.config.ts",
+    "test:prod": "npm run lint && npm run test",
     "lint": "eslint --ext .js,.ts .",
     "precommit": "lint-staged",
     "prebuild": "rimraf dist",
@@ -55,62 +54,35 @@
       "eslint --fix"
     ]
   },
-  "jest": {
-    "transform": {
-      ".(ts|tsx)": "ts-jest"
-    },
-    "testEnvironment": "node",
-    "testRegex": "(/__tests__/.*|\\.(test|spec))\\.(ts|tsx|js)$",
-    "moduleFileExtensions": [
-      "ts",
-      "tsx",
-      "js"
-    ],
-    "moduleNameMapper": {
-      "^@taquito/taquito$": "<rootDir>/../taquito/src/taquito.ts"
-    },
-    "coveragePathIgnorePatterns": [
-      "/node_modules/",
-      "/test/"
-    ],
-    "collectCoverageFrom": [
-      "src/**/*.{js,ts}"
-    ]
-  },
   "dependencies": {
-    "@taquito/taquito": "^24.3.0-beta.1",
+    "@taquito/taquito": "^24.3.0-beta.3",
     "@walletconnect/modal": "^2.7.0",
-    "@walletconnect/sign-client": "^2.16.2",
-    "@walletconnect/types": "^2.16.2",
-    "@walletconnect/utils": "^2.16.2"
+    "@walletconnect/sign-client": "^2.23.9",
+    "@walletconnect/types": "^2.23.9",
+    "@walletconnect/utils": "^2.23.9"
   },
   "devDependencies": {
     "@types/bluebird": "^3.5.42",
-    "@types/chrome": "0.0.171",
-    "@types/jest": "^29.5.12",
-    "@types/node": "^20",
+    "@types/chrome": "0.1.40",
+    "@types/node": "^22.0.0",
     "@types/pino": "^7.0.5",
     "@types/ws": "^8.5.12",
     "@typescript-eslint/eslint-plugin": "^6.21.0",
     "@typescript-eslint/parser": "^6.21.0",
     "colors": "^1.4.0",
-    "coveralls": "^3.1.1",
     "cross-env": "^7.0.3",
     "eslint": "^8.57.0",
-    "jest": "^29.7.0",
-    "jest-config": "^29.7.0",
     "lint-staged": "^15.2.7",
     "lodash.camelcase": "^4.3.0",
     "prettier": "^3.3.3",
     "prompt": "^1.3.0",
     "replace-in-file": "^8.1.0",
     "rimraf": "^6.0.1",
-    "rollup": "^4.19.1",
+    "rollup": "^4.60.1",
     "rollup-plugin-json": "^4.0.0",
     "rollup-plugin-polyfill-node": "^0.13.0",
-    "rollup-plugin-typescript2": "^0.36.0",
+    "rollup-plugin-typescript2": "^0.37.0",
     "shelljs": "^0.8.5",
-    "ts-jest": "^29.2.3",
     "ts-node": "^10.9.2",
     "ts-toolbelt": "^9.6.0",
     "typescript": "^5.9.3"