@taquito/wallet-connect 24.3.0-beta.0 → 24.3.0-beta.2

package/dist/lib/taquito-utils/src/taquito-utils.js

@@ -0,0 +1,42 @@
+"use strict";
+/**
+ * @packageDocumentation
+ * @module @taquito/utils
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.format = exports.POP_DST = exports.BLS12_381_DST = exports.verifySignature = exports.payloadLength = exports.PrefixV2 = exports.VERSION = void 0;
+// Re-export everything from encoding
+__exportStar(require("./encoding"), exports);
+// Re-export everything from validators
+__exportStar(require("./validators"), exports);
+// Re-export version
+var version_1 = require("./version");
+Object.defineProperty(exports, "VERSION", { enumerable: true, get: function () { return version_1.VERSION; } });
+// Re-export constants
+var constants_1 = require("./constants");
+Object.defineProperty(exports, "PrefixV2", { enumerable: true, get: function () { return constants_1.PrefixV2; } });
+Object.defineProperty(exports, "payloadLength", { enumerable: true, get: function () { return constants_1.payloadLength; } });
+// Re-export from verify-signature
+var verify_signature_1 = require("./verify-signature");
+Object.defineProperty(exports, "verifySignature", { enumerable: true, get: function () { return verify_signature_1.verifySignature; } });
+Object.defineProperty(exports, "BLS12_381_DST", { enumerable: true, get: function () { return verify_signature_1.BLS12_381_DST; } });
+Object.defineProperty(exports, "POP_DST", { enumerable: true, get: function () { return verify_signature_1.POP_DST; } });
+// Re-export errors
+__exportStar(require("./errors"), exports);
+// Re-export format
+var format_1 = require("./format");
+Object.defineProperty(exports, "format", { enumerable: true, get: function () { return format_1.format; } });

package/dist/lib/taquito-utils/src/validators.js

@@ -0,0 +1,236 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationResult = void 0;
+exports.isValidPrefixedValue = isValidPrefixedValue;
+exports.validateAddress = validateAddress;
+exports.validateChain = validateChain;
+exports.validateContractAddress = validateContractAddress;
+exports.validateKeyHash = validateKeyHash;
+exports.validateSignature = validateSignature;
+exports.validatePublicKey = validatePublicKey;
+exports.validateOperation = validateOperation;
+exports.validateProtocol = validateProtocol;
+exports.validateBlock = validateBlock;
+exports.validateSpendingKey = validateSpendingKey;
+exports.validateSmartRollupAddress = validateSmartRollupAddress;
+const constants_1 = require("./constants");
+const encoding_1 = require("./encoding");
+const core_1 = require("@taquito/core");
+var core_2 = require("@taquito/core");
+Object.defineProperty(exports, "ValidationResult", { enumerable: true, get: function () { return core_2.ValidationResult; } });
+/**
+ * Used to check if a value has one of the allowed prefixes.
+ * @returns true if the value has one of the allowed prefixes, false otherwise
+ * @example
+ * ```
+ * import { isValidPrefixedValue } from '@taquito/utils';
+ * const value = 'tz1L9r8mWmRPndRhuvMCWESLGSVeFzQ9NAWx'
+ * const isValid = isValidPrefixedValue(value, [PrefixV2.Ed25519PublicKeyHash])
+ * console.log(isValid) // true
+ * ```
+ */
+function isValidPrefixedValue(value, prefixes) {
+    return validatePrefixedValue(value, prefixes) === core_1.ValidationResult.VALID;
+}
+/**
+ * This function is called by the validation functions ([[validateAddress]], [[validateChain]], [[validateContractAddress]], [[validateKeyHash]], [[validateSignature]], [[validatePublicKey]]).
+ * Verify if the value can be decoded or return `1` (INVALID_CHECKSUM) / `5` (INVALID_ENCODING), then check if the prefix is valid or allowed or return `0` (NO_PREFIX_MATCHED) / `4` (PREFIX_NOT_ALLOWED)
+ * If all checks pass, return `3` (VALID).
+ * @param value Value to validate
+ * @param prefixes prefix the value should have
+ * @returns 0 = NO_PREFIX_MATCHED, 1 = INVALID_CHECKSUM, 2 = INVALID_LENGTH, 3 = VALID, 4 = PREFIX_NOT_ALLOWED, 5 = INVALID_ENCODING, 6 = OTHER,
+ * @example
+ * ```
+ * import { validatePrefixedValue } from '@taquito/utils';
+ * const value = 'tz1L9r8mWmRPndRhuvMCWESLGSVeFzQ9NAWx'
+ * const validation = validatePrefixedValue(value, [PrefixV2.Ed25519PublicKeyHash])
+ * console.log(validation) // 3
+ * ```
+ */
+function validatePrefixedValue(value, prefixes) {
+    try {
+        (0, encoding_1.b58DecodeAndCheckPrefix)(value, prefixes);
+    }
+    catch (err) {
+        if (err instanceof core_1.ParameterValidationError && err.result !== undefined) {
+            return err.result;
+        }
+        return core_1.ValidationResult.OTHER;
+    }
+    return core_1.ValidationResult.VALID;
+}
+/**
+ * Used to check if an address or a contract address is valid.
+ *
+ * @returns
+ * 0 = NO_PREFIX_MATCHED, 1 = INVALID_CHECKSUM, 2 = INVALID_LENGTH, 3 = VALID, 4 = PREFIX_NOT_ALLOWED, 5 = INVALID_ENCODING, 6 = OTHER,
+ *
+ * @example
+ * ```
+ * import { validateAddress } from '@taquito/utils';
+ * const pkh = 'tz1L9r8mWmRPndRhuvMCWESLGSVeFzQ9NAWx'
+ * const validation = validateAddress(pkh)
+ * console.log(validation)
+ * // This example return 3 which correspond to VALID
+ * ```
+ */
+function validateAddress(value) {
+    const [addr] = (0, encoding_1.splitAddress)(value ?? '');
+    return validatePrefixedValue(addr, encoding_1.addressPrefixes);
+}
+/**
+ * Used to check if a chain id is valid.
+ *
+ * @returns
+ * 0 = NO_PREFIX_MATCHED, 1 = INVALID_CHECKSUM, 2 = INVALID_LENGTH, 3 = VALID, 4 = PREFIX_NOT_ALLOWED, 5 = INVALID_ENCODING, 6 = OTHER,
+ *
+ * @example
+ * ```
+ * import { validateChain } from '@taquito/utils';
+ * const chainId = 'NetXdQprcVkpaWU'
+ * const validation = validateChain(chainId)
+ * console.log(validation)
+ * // This example return 3 which correspond to VALID
+ * ```
+ */
+function validateChain(value) {
+    return validatePrefixedValue(value, [constants_1.PrefixV2.ChainID]);
+}
+/**
+ * Used to check if a contract address is valid.
+ *
+ * @returns
+ * 0 = NO_PREFIX_MATCHED, 1 = INVALID_CHECKSUM, 2 = INVALID_LENGTH, 3 = VALID, 4 = PREFIX_NOT_ALLOWED, 5 = INVALID_ENCODING, 6 = OTHER,
+ *
+ * @example
+ * ```
+ * import { validateContractAddress } from '@taquito/utils';
+ * const contractAddress = 'KT1JVErLYTgtY8uGGZ4mso2npTSxqVLDRVbC'
+ * const validation = validateContractAddress(contractAddress)
+ * console.log(validation)
+ * // This example return 3 which correspond to VALID
+ * ```
+ */
+function validateContractAddress(value) {
+    return validatePrefixedValue(value, [constants_1.PrefixV2.ContractHash]);
+}
+/**
+ * Used to check if a key hash is valid.
+ *
+ * @returns
+ * 0 = NO_PREFIX_MATCHED, 1 = INVALID_CHECKSUM, 2 = INVALID_LENGTH, 3 = VALID, 4 = PREFIX_NOT_ALLOWED, 5 = INVALID_ENCODING, 6 = OTHER,
+ *
+ * @example
+ * ```
+ * import { validateKeyHash } from '@taquito/utils';
+ * const keyHashWithoutPrefix = '1L9r8mWmRPndRhuvMCWESLGSVeFzQ9NAWx'
+ * const validation = validateKeyHash(keyHashWithoutPrefix)
+ * console.log(validation)
+ * // This example return 0 which correspond to NO_PREFIX_MATCHED
+ * ```
+ */
+function validateKeyHash(value) {
+    return validatePrefixedValue(value, encoding_1.publicKeyHashPrefixes);
+}
+/**
+ * Used to check if a signature is valid.
+ *
+ * @returns
+ * 0 = NO_PREFIX_MATCHED, 1 = INVALID_CHECKSUM, 2 = INVALID_LENGTH, 3 = VALID, 4 = PREFIX_NOT_ALLOWED, 5 = INVALID_ENCODING, 6 = OTHER,
+ *
+ * @example
+ * ```
+ * import { validateSignature } from '@taquito/utils';
+ * const signature = 'edsigtkpiSSschcaCt9pUVrpNPf7TTcgvgDEDD6NCEHMy8NNQJCGnMfLZzYoQj74yLjo9wx6MPVV29CvVzgi7qEcEUok3k7AuMg'
+ * const validation = validateSignature(signature)
+ * console.log(validation)
+ * // This example return 3 which correspond to VALID
+ * ```
+ */
+function validateSignature(value) {
+    return validatePrefixedValue(value, encoding_1.signaturePrefixes);
+}
+/**
+ * Used to check if a public key is valid.
+ *
+ * @returns
+ * 0 = NO_PREFIX_MATCHED, 1 = INVALID_CHECKSUM, 2 = INVALID_LENGTH, 3 = VALID, 4 = PREFIX_NOT_ALLOWED, 5 = INVALID_ENCODING, 6 = OTHER,
+ *
+ * @example
+ * ```
+ * import { validatePublicKey } from '@taquito/utils';
+ * const publicKey = 'edpkvS5QFv7KRGfa3b87gg9DBpxSm3NpSwnjhUjNBQrRUUR66F7C9g'
+ * const validation = validatePublicKey(publicKey)
+ * console.log(validation)
+ * // This example return 3 which correspond to VALID
+ * ```
+ */
+function validatePublicKey(value) {
+    return validatePrefixedValue(value, encoding_1.publicKeyPrefixes);
+}
+/**
+ * Used to check if an operation hash is valid.
+ *
+ * @returns
+ * 0 = NO_PREFIX_MATCHED, 1 = INVALID_CHECKSUM, 2 = INVALID_LENGTH, 3 = VALID, 4 = PREFIX_NOT_ALLOWED, 5 = INVALID_ENCODING, 6 = OTHER,
+ *
+ * @example
+ * ```
+ * import { validateOperation } from '@taquito/utils';
+ * const operationHash = 'oo6JPEAy8VuMRGaFuMmLNFFGdJgiaKfnmT1CpHJfKP3Ye5ZahiP'
+ * const validation = validateOperation(operationHash)
+ * console.log(validation)
+ * // This example return 3 which correspond to VALID
+ * ```
+ */
+function validateOperation(value) {
+    return validatePrefixedValue(value, [constants_1.PrefixV2.OperationHash]);
+}
+/**
+ * Used to check if a protocol hash is valid.
+ *
+ * @returns
+ * 0 = NO_PREFIX_MATCHED, 1 = INVALID_CHECKSUM, 2 = INVALID_LENGTH, 3 = VALID, 4 = PREFIX_NOT_ALLOWED, 5 = INVALID_ENCODING, 6 = OTHER,
+ *
+ * @example
+ * ```
+ * import { validateProtocol } from '@taquito/utils';
+ * const protocolHash = 'PtHangz2aRngywmSRGGvrcTyMbbdpWdpFKuS4uMWxg2RaH9i1qx'
+ * const validation = validateProtocol(protocolHash)
+ * console.log(validation)
+ * // This example return 3 which correspond to VALID
+ * ```
+ */
+function validateProtocol(value) {
+    return validatePrefixedValue(value, [constants_1.PrefixV2.ProtocolHash]);
+}
+/**
+ * Used to check if a block hash is valid.
+ *
+ * @returns
+ * 0 = NO_PREFIX_MATCHED, 1 = INVALID_CHECKSUM, 2 = INVALID_LENGTH, 3 = VALID, 4 = PREFIX_NOT_ALLOWED, 5 = INVALID_ENCODING, 6 = OTHER,
+ *
+ * @example
+ * ```
+ * import { validateBlock } from '@taquito/utils';
+ * const blockHash = 'PtHangz2aRngywmSRGGvrcTyMbbdpWdpFKuS4uMWxg2RaH9i1qx'
+ * const validation = validateBlock(blockHash)
+ * console.log(validation)
+ * // This example return 3 which correspond to VALID
+ * ```
+ */
+function validateBlock(value) {
+    return validatePrefixedValue(value, [constants_1.PrefixV2.BlockHash]);
+}
+/**
+ * Used to check if a spending key is valid.
+ * @returns
+ * 0 = NO_PREFIX_MATCHED, 1 = INVALID_CHECKSUM, 2 = INVALID_LENGTH, 3 = VALID, 4 = PREFIX_NOT_ALLOWED, 5 = INVALID_ENCODING, 6 = OTHER,
+ *
+ */
+function validateSpendingKey(value) {
+    return validatePrefixedValue(value, [constants_1.PrefixV2.SaplingSpendingKey]);
+}
+function validateSmartRollupAddress(value) {
+    return validatePrefixedValue(value, [constants_1.PrefixV2.SmartRollupHash]);
+}

package/dist/lib/taquito-utils/src/verify-signature.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.POP_DST = exports.BLS12_381_DST = void 0;
+exports.verifySignature = verifySignature;
+const ed25519_1 = require("@noble/curves/ed25519");
+const blake2_js_1 = require("@noble/hashes/blake2.js");
+const encoding_1 = require("./encoding");
+const constants_1 = require("./constants");
+const secp256k1_1 = require("@noble/curves/secp256k1");
+const nist_1 = require("@noble/curves/nist");
+const core_1 = require("@taquito/core");
+const bls12_381_1 = require("@noble/curves/bls12-381");
+exports.BLS12_381_DST = 'BLS_SIG_BLS12381G2_XMD:SHA-256_SSWU_RO_POP_';
+exports.POP_DST = 'BLS_POP_BLS12381G2_XMD:SHA-256_SSWU_RO_POP_';
+/**
+ * Verify signature of a payload
+ * @param message The forged message including the magic byte (11 for block, 12 for preattestation, 13 for attestation, 3 for generic, 5 for the PACK format of michelson) in string or Uint8Array
+ * @param publicKey The public key to verify the signature against
+ * @param signature The signature to verify
+ * @param watermark Optional if not included in the message
+ * @param pop Optional if verifying proof of possession signature
+ * @returns A boolean indicating if the signature matches
+ * @throws InvalidPublicKeyError | InvalidSignatureError | InvalidMessageError
+ * @example
+ * ```
+ * const message = '03d0c10e3ed11d7c6e3357f6ef335bab9e8f2bd54d0ce20c482e241191a6e4b8ce6c01be917311d9ac46959750e405d57e268e2ed9e174a80794fbd504e12a4a000141eb3781afed2f69679ff2bbe1c5375950b0e40d00ff000000005e05050505050507070100000024747a32526773486e74516b72794670707352466261313652546656503539684b72654a4d07070100000024747a315a6672455263414c42776d4171776f6e525859565142445439426a4e6a42484a750001';
+ * const pk = 'sppk7c7hkPj47yjYFEHX85q46sFJGw6RBrqoVSHwAJAT4e14KJwzoey';
+ * const sig = 'spsig1cdLkp1RLgUHAp13aRFkZ6MQDPp7xCnjAExGL3MBSdMDmT6JgQSX8cufyDgJRM3sinFtiCzLbsyP6d365EHoNevxhT47nx'
+ *
+ * const response = verifySignature(message, pk, sig);
+ * ```
+ *
+ */
+function verifySignature(message, publicKey, signature, watermark, pop) {
+    const [pk, pre] = (() => {
+        try {
+            return (0, encoding_1.b58DecodeAndCheckPrefix)(publicKey, encoding_1.publicKeyPrefixes);
+        }
+        catch (err) {
+            if (err instanceof core_1.ParameterValidationError) {
+                throw new core_1.InvalidPublicKeyError(publicKey, err.result);
+            }
+            else {
+                throw err;
+            }
+        }
+    })();
+    const sig = (() => {
+        try {
+            const [sig] = (0, encoding_1.b58DecodeAndCheckPrefix)(signature, encoding_1.signaturePrefixes);
+            return sig;
+        }
+        catch (err) {
+            if (err instanceof core_1.ParameterValidationError) {
+                throw new core_1.InvalidSignatureError(signature, err.result);
+            }
+            else {
+                throw err;
+            }
+        }
+    })();
+    let msg;
+    if (typeof message === 'string') {
+        msg = (0, encoding_1.hex2buf)(message);
+    }
+    else {
+        msg = message;
+    }
+    if (msg.length === 0) {
+        throw new core_1.InvalidMessageError((0, encoding_1.buf2hex)(msg), `can't be empty`);
+    }
+    if (typeof watermark !== 'undefined') {
+        msg = (0, encoding_1.mergebuf)(watermark, msg);
+    }
+    if (pop) {
+        return verifyBLSPopSignature(sig, msg, pk);
+    }
+    else {
+        switch (pre) {
+            case constants_1.PrefixV2.P256PublicKey:
+                return verifyP2Signature(sig, msg, pk);
+            case constants_1.PrefixV2.Secp256k1PublicKey:
+                return verifySpSignature(sig, msg, pk);
+            case constants_1.PrefixV2.Ed25519PublicKey:
+                return verifyEdSignature(sig, msg, pk);
+            default:
+                return verifyBLSSignature(sig, msg, pk);
+        }
+    }
+}
+function verifyEdSignature(sig, msg, publicKey) {
+    const hash = (0, blake2_js_1.blake2b)(msg, { dkLen: 32 });
+    try {
+        return ed25519_1.ed25519.verify(sig, hash, publicKey);
+    }
+    catch {
+        return false;
+    }
+}
+function verifySpSignature(sig, msg, publicKey) {
+    const hash = (0, blake2_js_1.blake2b)(msg, { dkLen: 32 });
+    try {
+        return secp256k1_1.secp256k1.verify(sig, hash, publicKey);
+    }
+    catch {
+        return false;
+    }
+}
+function verifyP2Signature(sig, msg, publicKey) {
+    const hash = (0, blake2_js_1.blake2b)(msg, { dkLen: 32 });
+    try {
+        return nist_1.p256.verify(sig, hash, publicKey);
+    }
+    catch {
+        return false;
+    }
+}
+const bls = bls12_381_1.bls12_381.longSignatures; // AKA MinPK
+function verifyBLSSignature(sig, msg, publicKey) {
+    try {
+        const point = bls.hash(msg, exports.BLS12_381_DST);
+        return bls.verify(sig, point, publicKey);
+    }
+    catch {
+        return false;
+    }
+}
+function verifyBLSPopSignature(sig, msg, publicKey) {
+    try {
+        const point = bls.hash(msg, exports.POP_DST);
+        return bls.verify(sig, point, publicKey);
+    }
+    catch {
+        return false;
+    }
+}

package/dist/lib/taquito-utils/src/version.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERSION = void 0;
+// IMPORTANT: THIS FILE IS AUTO GENERATED! DO NOT MANUALLY EDIT!
+exports.VERSION = {
+    "commitHash": "fb73f1546d3dff2fbba7741ca6006680212bef16",
+    "version": "24.3.0-beta.2"
+};

package/dist/lib/{taquito-wallet-connect.js → taquito-wallet-connect/src/taquito-wallet-connect.js}

@@ -17,9 +17,12 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
 var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WalletConnect = void 0;
-const sign_client_1 = require("@walletconnect/sign-client");
+const sign_client_1 = __importDefault(require("@walletconnect/sign-client"));
 const modal_1 = require("@walletconnect/modal");
 const taquito_1 = require("@taquito/taquito");
 const utils_1 = require("@walletconnect/utils");
@@ -40,18 +43,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 +100,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 +119,7 @@ class WalletConnect {
                     chains,
                 });
             }
-            this.session = await approval();
+            approvedSession = await approval();
         }
         catch (error) {
             throw new errors_1.ConnectionFailed(error);
@@ -121,8 +127,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 +152,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 +308,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);
+        }
+        else {
+            this.validateRestoredNamespace(session.namespaces);
         }
-        const activeNetwork = this.getNetworks();
-        if (activeNetwork.length === 1) {
-            this.activeNetwork = activeNetwork[0];
+        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 +376,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 +401,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 +412,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 +421,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 +440,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/taquito-wallet-connect/src/version.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERSION = void 0;
+// IMPORTANT: THIS FILE IS AUTO GENERATED! DO NOT MANUALLY EDIT!
+exports.VERSION = {
+    "commitHash": "fb73f1546d3dff2fbba7741ca6006680212bef16",
+    "version": "24.3.0-beta.2"
+};