@tezos-x/octez.connect-dapp 5.0.0-beta.6 → 5.0.1

package/dist/cjs/dapp-client/DAppClient.js

@@ -16,17 +16,20 @@ exports.DAppClient = void 0;
 const bs58check_1 = __importDefault(require("bs58check"));
 const octez_connect_types_1 = require("@tezos-x/octez.connect-types");
 const octez_connect_core_1 = require("@tezos-x/octez.connect-core");
+const octez_connect_blockchain_tezos_1 = require("@tezos-x/octez.connect-blockchain-tezos");
 const octez_connect_utils_1 = require("@tezos-x/octez.connect-utils");
+const octez_connect_transport_postmessage_1 = require("@tezos-x/octez.connect-transport-postmessage");
+const octez_connect_ui_1 = require("@tezos-x/octez.connect-ui");
+const octez_connect_transport_walletconnect_1 = require("@tezos-x/octez.connect-transport-walletconnect");
 const beacon_message_events_1 = require("../beacon-message-events");
 const events_1 = require("../events");
 const tzkt_blockexplorer_1 = require("../utils/tzkt-blockexplorer");
 const DappPostMessageTransport_1 = require("../transports/DappPostMessageTransport");
 const DappP2PTransport_1 = require("../transports/DappP2PTransport");
 const DappWalletConnectTransport_1 = require("../transports/DappWalletConnectTransport");
-const octez_connect_transport_postmessage_1 = require("@tezos-x/octez.connect-transport-postmessage");
-const octez_connect_ui_1 = require("@tezos-x/octez.connect-ui");
-const octez_connect_transport_walletconnect_1 = require("@tezos-x/octez.connect-transport-walletconnect");
 const logger = new octez_connect_core_1.Logger('DAppClient');
+// Surfaced when a permission response yields zero account records.
+const EMPTY_PERMISSION_ACCOUNTS_MESSAGE = 'Wallet permission response did not include any accounts. Please re-pair the wallet and try again.';
 /**
  * @publicapi
  *
@@ -40,6 +43,12 @@ class DAppClient extends octez_connect_core_1.Client {
         var _a, _b, _c, _d, _e, _f, _g, _h;
         super(Object.assign({ storage: config && config.storage ? config.storage : new octez_connect_core_1.LocalStorage() }, config));
         this.events = new events_1.BeaconEventHandler();
+        /**
+         * WalletConnect is opt-in: only enabled when `walletConnectOptions` is provided
+         * and `disableWalletConnect` is not set. When false, no WC transport is built,
+         * listened to, or offered for pairing, and no default projectId is applied.
+         */
+        this.isWalletConnectEnabled = false;
         this.isGetActiveAccountHandled = false;
         this.openRequestsOtherTabs = new Set();
         /**
@@ -60,8 +69,14 @@ class DAppClient extends octez_connect_core_1.Client {
         this.debounceSetActiveAccount = false;
         this.multiTabChannel = new octez_connect_core_1.MultiTabChannel('octez.connect-sdk-channel', this.onBCMessageHandler.bind(this), this.onElectedLeaderhandler.bind(this));
         this.description = config.description;
-        this.wcProjectId = ((_a = config.walletConnectOptions) === null || _a === void 0 ? void 0 : _a.projectId) || '24469fd0a06df227b6e5f7dc7de0ff4f';
-        this.wcRelayUrl = (_b = config.walletConnectOptions) === null || _b === void 0 ? void 0 : _b.relayUrl;
+        // WalletConnect is opt-in: only when walletConnectOptions is provided and not
+        // explicitly disabled. Don't apply the default projectId otherwise (#32).
+        this.isWalletConnectEnabled =
+            Boolean(config.walletConnectOptions) && !config.disableWalletConnect;
+        this.wcProjectId = this.isWalletConnectEnabled
+            ? ((_a = config.walletConnectOptions) === null || _a === void 0 ? void 0 : _a.projectId) || '24469fd0a06df227b6e5f7dc7de0ff4f'
+            : undefined;
+        this.wcRelayUrl = this.isWalletConnectEnabled ? (_b = config.walletConnectOptions) === null || _b === void 0 ? void 0 : _b.relayUrl : undefined;
         this.featuredWallets = config.featuredWallets;
         this.events = new events_1.BeaconEventHandler(config.eventHandlers, (_c = config.disableDefaultEvents) !== null && _c !== void 0 ? _c : false);
         this.blockExplorer = (_d = config.blockExplorer) !== null && _d !== void 0 ? _d : new tzkt_blockexplorer_1.TzktBlockExplorer();
@@ -73,8 +88,14 @@ class DAppClient extends octez_connect_core_1.Client {
         this.appMetadataManager = new octez_connect_core_1.AppMetadataManager(this.storage);
         this.storageValidator = new octez_connect_core_1.StorageValidator(this.storage);
         this.enableAppSwitching =
-            config.enableAppSwitching === undefined ? true : !!config.enableAppSwitching;
+            config.enableAppSwitching === undefined ? true : Boolean(config.enableAppSwitching);
         this.enableMetrics = config.enableMetrics ? true : false;
+        this.requiredMinimumVersion = (0, octez_connect_core_1.resolveRequiredMinimumVersion)(config.requiredMinimumVersion);
+        // Tezos is the default chain: the wrapped-only pipeline routes every
+        // request/response through the registry handler, so registration is no
+        // longer a consumer obligation. addBlockchain stays public — a later
+        // registration under 'tezos' overrides this default.
+        this.addBlockchain(new octez_connect_blockchain_tezos_1.TezosBlockchain());
         // Subscribe to storage changes and update the active account if it changes on other tabs
         this.storage.subscribeToStorageChanged((event) => __awaiter(this, void 0, void 0, function* () {
             if (event.eventType === 'storageCleared') {
@@ -94,7 +115,7 @@ class DAppClient extends octez_connect_core_1.Client {
                     return;
                 }
                 if (event.key === this.storage.getPrefixedKey(octez_connect_types_1.StorageKey.ENABLE_METRICS)) {
-                    this.enableMetrics = !!(yield this.storage.get(octez_connect_types_1.StorageKey.ENABLE_METRICS));
+                    this.enableMetrics = Boolean(yield this.storage.get(octez_connect_types_1.StorageKey.ENABLE_METRICS));
                     return;
                 }
                 if (event.key === this.storage.getPrefixedKey(octez_connect_types_1.StorageKey.BEACON_SDK_SECRET_SEED)) {
@@ -124,15 +145,31 @@ class DAppClient extends octez_connect_core_1.Client {
             this.events.emit(events_1.BeaconEvent.INVALID_ACCOUNT_DEACTIVATED);
             return undefined;
         }));
-        this.handleResponse = (message, connectionInfo) => __awaiter(this, void 0, void 0, function* () {
+        this.handleResponse = (wireMessage, connectionInfo) => __awaiter(this, void 0, void 0, function* () {
             var _a;
-            const typedMessage = (0, octez_connect_core_1.usesWrappedMessages)(message.version)
-                ? message.message
-                : message;
-            let appMetadata = (0, octez_connect_core_1.usesWrappedMessages)(message.version)
-                ? (_a = typedMessage.blockchainData) === null || _a === void 0 ? void 0 : _a.appMetadata
-                : typedMessage.appMetadata;
-            if (!appMetadata && (0, octez_connect_core_1.usesWrappedMessages)(message.version)) {
+            // Negotiated wire: a flat arrival is the legacy v2 dialect (from a
+            // v4.8.x wallet answering a flat request) and is already the shape the
+            // pipeline consumes. Wrapped arrivals carry Tezos payloads that are
+            // normalized back to those same flat shapes — the wire dialect stays
+            // invisible to integrators. Non-Tezos wrapped payloads keep the
+            // pass-through of the generic permissionRequest/request API.
+            const isWrapped = (0, octez_connect_core_1.usesWrappedMessages)(wireMessage.version);
+            // Issue #33: a V3-versioned message can arrive without its wrapped payload.
+            // Drop it safely instead of dereferencing an undefined payload, which would
+            // throw an unhandled rejection inside the transport subscription callback.
+            if (isWrapped && !wireMessage.message) {
+                logger.log('handleResponse', 'Received wrapped message with undefined payload; dropping', wireMessage);
+                return;
+            }
+            const normalized = isWrapped
+                ? this.normalizeWrappedTezosMessage(wireMessage)
+                : wireMessage;
+            const message = normalized !== null && normalized !== void 0 ? normalized : wireMessage;
+            const typedMessage = normalized !== null && normalized !== void 0 ? normalized : wireMessage.message;
+            let appMetadata = normalized
+                ? typedMessage.appMetadata
+                : (_a = typedMessage.blockchainData) === null || _a === void 0 ? void 0 : _a.appMetadata;
+            if (!appMetadata && !normalized) {
                 const storedMetadata = yield Promise.all([
                     this.storage.get(octez_connect_types_1.StorageKey.TRANSPORT_P2P_PEERS_DAPP),
                     this.storage.get(octez_connect_types_1.StorageKey.TRANSPORT_WALLETCONNECT_PEERS_DAPP),
@@ -153,10 +190,15 @@ class DAppClient extends octez_connect_core_1.Client {
                 }
             }
             if (this.openRequestsOtherTabs.has(message.id)) {
+                // Relay the ORIGINAL wrapped envelope, not the normalized flat
+                // message: the receiving tab funnels this straight back into its own
+                // handleResponse, whose wrapped-only contract would drop a flat
+                // arrival (version '4' with no `.message` payload) and leave the
+                // other tab's request pending forever.
                 this.multiTabChannel.postMessage({
                     type: 'RESPONSE',
                     data: {
-                        message,
+                        message: wireMessage,
                         connectionInfo
                     },
                     id: message.id
@@ -278,7 +320,7 @@ class DAppClient extends octez_connect_core_1.Client {
             }
         }))
             .catch((err) => logger.error(err.message));
-        this.sendMetrics('enable-metrics?' + this.addQueryParam('version', octez_connect_core_1.SDK_VERSION), undefined, (res) => {
+        this.sendMetrics(`enable-metrics?${this.addQueryParam('version', octez_connect_core_1.SDK_VERSION)}`, undefined, (res) => {
             if (!res.ok) {
                 res.status === 426
                     ? console.error('Metrics are no longer supported for this version, please upgrade.')
@@ -402,22 +444,32 @@ class DAppClient extends octez_connect_core_1.Client {
             yield this.addListener(this.postMessageTransport);
             this.p2pTransport = new DappP2PTransport_1.DappP2PTransport(this.name, keyPair, this.storage, this.matrixNodes, this.iconUrl, this.appUrl);
             yield this.addListener(this.p2pTransport);
-            const wcOptions = {
-                projectId: this.wcProjectId,
-                relayUrl: this.wcRelayUrl,
-                metadata: {
-                    name: this.name,
-                    description: (_a = this.description) !== null && _a !== void 0 ? _a : '',
-                    url: (_b = this.appUrl) !== null && _b !== void 0 ? _b : '',
-                    icons: this.iconUrl ? [this.iconUrl] : []
+            // WalletConnect is opt-in (#32): skip building/listening the transport when
+            // no walletConnectOptions were provided or it was explicitly disabled.
+            if (this.isWalletConnectEnabled) {
+                const wcOptions = {
+                    projectId: this.wcProjectId,
+                    relayUrl: this.wcRelayUrl,
+                    metadata: {
+                        name: this.name,
+                        description: (_a = this.description) !== null && _a !== void 0 ? _a : '',
+                        url: (_b = this.appUrl) !== null && _b !== void 0 ? _b : '',
+                        icons: this.iconUrl ? [this.iconUrl] : []
+                    }
+                };
+                this.walletConnectTransport = new DappWalletConnectTransport_1.DappWalletConnectTransport(this.name, keyPair, this.storage, {
+                    network: this.network.type,
+                    opts: wcOptions
+                }, this.checkIfBCLeaderExists.bind(this));
+                // Apply proposal networks requested before the transport existed
+                // (requestPermissions runs before init creates the transport).
+                if (this.pendingWcProposalNetworks) {
+                    this.walletConnectTransport.setProposalNetworks(this.pendingWcProposalNetworks);
+                    this.pendingWcProposalNetworks = undefined;
                 }
-            };
-            this.walletConnectTransport = new DappWalletConnectTransport_1.DappWalletConnectTransport(this.name, keyPair, this.storage, {
-                network: this.network.type,
-                opts: wcOptions
-            }, this.checkIfBCLeaderExists.bind(this));
-            this.initEvents();
-            yield this.addListener(this.walletConnectTransport);
+                this.initEvents();
+                yield this.addListener(this.walletConnectTransport);
+            }
         });
     }
     initEvents() {
@@ -531,7 +583,9 @@ class DAppClient extends octez_connect_core_1.Client {
                         }
                     };
                     yield this.initInternalTransports();
-                    if (!this.postMessageTransport || !this.p2pTransport || !this.walletConnectTransport) {
+                    if (!this.postMessageTransport ||
+                        !this.p2pTransport ||
+                        (this.isWalletConnectEnabled && !this.walletConnectTransport)) {
                         return;
                     }
                     this.postMessageTransport.connect().then().catch(console.error);
@@ -544,9 +598,20 @@ class DAppClient extends octez_connect_core_1.Client {
                         else if (origin === octez_connect_types_1.Origin.P2P) {
                             resolve(yield _super.init.call(this, this.p2pTransport));
                         }
-                        else if (origin === octez_connect_types_1.Origin.WALLETCONNECT) {
+                        else if (origin === octez_connect_types_1.Origin.WALLETCONNECT && this.walletConnectTransport) {
                             resolve(yield _super.init.call(this, this.walletConnectTransport));
                         }
+                        else {
+                            // The persisted active account was paired over WalletConnect but WC
+                            // is now opt-out/disabled (#32), so there is no matching transport to
+                            // restore. Without this branch none of the conditions above call
+                            // resolve() and the init promise created above never settles, so
+                            // init() (and every later call awaiting it) hangs forever. Resolve on
+                            // the always-available P2P transport so the SDK stays usable and the
+                            // stale WC account can be re-paired.
+                            logger.warn('init', 'Active account was paired over WalletConnect but WC is disabled; falling back to the P2P transport');
+                            resolve(yield _super.init.call(this, this.p2pTransport));
+                        }
                     }
                     else {
                         const p2pTransport = this.p2pTransport;
@@ -582,8 +647,7 @@ class DAppClient extends octez_connect_core_1.Client {
                             resolve(octez_connect_types_1.TransportType.P2P);
                         })
                             .catch(console.error);
-                        walletConnectTransport
-                            .listenForNewPeer((peer) => {
+                        walletConnectTransport === null || walletConnectTransport === void 0 ? void 0 : walletConnectTransport.listenForNewPeer((peer) => {
                             logger.log('init', 'walletconnect transport peer connected', peer);
                             this.analytics.track('event', 'DAppClient', 'WalletConnect Wallet connected', {
                                 peerName: peer.name
@@ -595,8 +659,7 @@ class DAppClient extends octez_connect_core_1.Client {
                             this.setTransport(this.walletConnectTransport).catch(console.error);
                             stopListening();
                             resolve(octez_connect_types_1.TransportType.WALLETCONNECT);
-                        })
-                            .catch(console.error);
+                        }).catch(console.error);
                         octez_connect_transport_postmessage_1.PostMessageTransport.getAvailableExtensions()
                             .then((extensions) => __awaiter(this, void 0, void 0, function* () {
                             this.analytics.track('event', 'DAppClient', 'Extensions detected', { extensions });
@@ -612,7 +675,7 @@ class DAppClient extends octez_connect_core_1.Client {
                             yield Promise.all([
                                 postMessageTransport.disconnect(),
                                 // p2pTransport.disconnect(), do not abort connection manually
-                                walletConnectTransport.disconnect()
+                                walletConnectTransport === null || walletConnectTransport === void 0 ? void 0 : walletConnectTransport.disconnect()
                             ]);
                             this.postMessageTransport = this.walletConnectTransport = this.p2pTransport = undefined;
                             this._activeAccount.isResolved() && this.clearActiveAccount();
@@ -647,7 +710,10 @@ class DAppClient extends octez_connect_core_1.Client {
                             resolve(yield serializer.serialize(yield p2pTransport.getPairingRequestInfo()));
                         }));
                         const walletConnectPeerInfo = new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
-                            resolve((yield walletConnectTransport.getPairingRequestInfo()).uri);
+                            // When WC is disabled there is no transport to pair through (#32).
+                            resolve(walletConnectTransport
+                                ? (yield walletConnectTransport.getPairingRequestInfo()).uri
+                                : '');
                         }));
                         const postmessagePeerInfo = new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
                             resolve(yield serializer.serialize(yield postMessageTransport.getPairingRequestInfo()));
@@ -713,7 +779,6 @@ class DAppClient extends octez_connect_core_1.Client {
      */
     setActiveAccount(account) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
             if (!this.isGetActiveAccountHandled) {
                 console.warn(`An active account has been received, but no active subscription was found for BeaconEvent.ACTIVE_ACCOUNT_SET.
         For more information, visit: https://octez-connect.tezos.com/guides/migration-guide`);
@@ -753,7 +818,9 @@ class DAppClient extends octez_connect_core_1.Client {
                             errorType: octez_connect_types_1.BeaconErrorType.ABORTED_ERROR,
                             id,
                             senderId: '',
-                            version: '2'
+                            // SDK-synthesized rejection consumed in-process (never hits the
+                            // wire); stamped with the wrapped baseline for consistency.
+                            version: (0, octez_connect_core_1.negotiateEnvelopeVersion)(undefined)
                         });
                     });
                     this.openRequests.clear();
@@ -784,9 +851,18 @@ class DAppClient extends octez_connect_core_1.Client {
                 else if (origin === octez_connect_types_1.Origin.P2P) {
                     yield this.setTransport(this.p2pTransport);
                 }
-                else if (origin === octez_connect_types_1.Origin.WALLETCONNECT) {
+                else if (origin === octez_connect_types_1.Origin.WALLETCONNECT && this.walletConnectTransport) {
                     yield this.setTransport(this.walletConnectTransport);
-                    (_a = this.walletConnectTransport) === null || _a === void 0 ? void 0 : _a.forceUpdate('INIT');
+                    this.walletConnectTransport.forceUpdate('INIT');
+                }
+                else if (origin === octez_connect_types_1.Origin.WALLETCONNECT) {
+                    // WalletConnect is opt-out/disabled (#32) but this persisted account was
+                    // paired over WC. There is no WC transport to bind; setting the transport
+                    // to `undefined` would leave the client unable to send any request. Fall
+                    // back to the always-available P2P transport so the SDK stays usable
+                    // (the stale WC account can be re-paired).
+                    logger.warn('setActiveAccount', 'Active account was paired over WalletConnect but WC is disabled; falling back to the P2P transport');
+                    yield this.setTransport(this.p2pTransport);
                 }
                 if (this._transport.isResolved()) {
                     const transport = yield this.transport;
@@ -867,7 +943,7 @@ class DAppClient extends octez_connect_core_1.Client {
         });
     }
     addQueryParam(paramName, paramValue) {
-        return paramName + '=' + paramValue;
+        return `${paramName}=${paramValue}`;
     }
     buildPayload(action, status) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -1080,6 +1156,7 @@ class DAppClient extends octez_connect_core_1.Client {
     }
     permissionRequest(input) {
         return __awaiter(this, void 0, void 0, function* () {
+            var _a;
             logger.log('permissionRequest', input);
             const blockchain = this.blockchains.get(input.blockchainIdentifier);
             if (!blockchain) {
@@ -1094,21 +1171,32 @@ class DAppClient extends octez_connect_core_1.Client {
             logger.time(false, logId);
             this.sendMetrics('performance-metrics/save', yield this.buildPayload('connect', 'start'));
             logger.log('RESPONSE V3', response, connectionInfo);
-            const partialAccountInfos = yield blockchain.getAccountInfosFromPermissionResponse(response.message);
-            const accountInfo = {
-                accountIdentifier: partialAccountInfos[0].accountId,
+            // The version stamp lives on the wrapper envelope, not the inner payload;
+            // reading response.message.version would always miss and collapse to '0',
+            // misrouting v4 responses when no peer is persisted yet.
+            const walletPeerV3 = yield this.getPeer();
+            const walletPeerVersionV3 = (_a = walletPeerV3 === null || walletPeerV3 === void 0 ? void 0 : walletPeerV3.version) !== null && _a !== void 0 ? _a : response.version;
+            const partialAccountInfos = yield blockchain.getAccountInfosFromPermissionResponse(response.message, walletPeerVersionV3);
+            const blockchainDataScopes = response.message.blockchainData.scopes;
+            const accountInfos = partialAccountInfos.map((p) => ({
+                accountIdentifier: p.accountId,
                 senderId: response.senderId,
                 origin: {
                     type: connectionInfo.origin,
                     id: connectionInfo.id
                 },
-                address: partialAccountInfos[0].address, // Store all addresses
-                publicKey: partialAccountInfos[0].publicKey,
-                scopes: response.message.blockchainData.scopes,
+                address: p.address,
+                publicKey: p.publicKey,
+                network: p.network,
+                scopes: blockchainDataScopes !== null && blockchainDataScopes !== void 0 ? blockchainDataScopes : p.scopes,
                 connectedAt: new Date().getTime(),
                 chainData: response.message.blockchainData
-            };
-            yield this.accountManager.addAccount(accountInfo);
+            }));
+            yield this.accountManager.addAccounts(accountInfos);
+            const accountInfo = accountInfos[0];
+            if (!accountInfo) {
+                throw new Error(EMPTY_PERMISSION_ACCOUNTS_MESSAGE);
+            }
             yield this.setActiveAccount(accountInfo);
             yield blockchain.handleResponse({
                 request,
@@ -1121,7 +1209,7 @@ class DAppClient extends octez_connect_core_1.Client {
             yield this.notifySuccess(request, {
                 account: accountInfo,
                 output: {
-                    address: partialAccountInfos[0].address,
+                    address: accountInfo.address,
                     network: { type: 'substrate' },
                     scopes: []
                 },
@@ -1178,6 +1266,7 @@ class DAppClient extends octez_connect_core_1.Client {
      */
     requestPermissions(input) {
         return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
             if (input === null || input === void 0 ? void 0 : input.network) {
                 throw new Error('[BEACON] the "network" property is no longer accepted in input. Please provide it when instantiating DAppClient.');
             }
@@ -1189,6 +1278,39 @@ class DAppClient extends octez_connect_core_1.Client {
                     ? input.scopes
                     : [octez_connect_types_1.PermissionScope.OPERATION_REQUEST, octez_connect_types_1.PermissionScope.SIGN]
             };
+            // Dedupe by the normalized CAIP-2 chainId so equivalent input entries
+            // ('NetX…' and 'tezos:NetX…') collapse to one canonical wire entry.
+            if ((input === null || input === void 0 ? void 0 : input.networks) && input.networks.length > 0) {
+                const dedupedNetworks = Array.from(new Map(input.networks.map((n) => {
+                    const chainId = (0, octez_connect_core_1.normalizeTezosCaip2)(n.chainId);
+                    return [chainId, Object.assign(Object.assign({}, n), { chainId })];
+                })).values());
+                request.networks = dedupedNetworks;
+                // Multi-network over WalletConnect travels via the session proposal,
+                // not the wire payload (WC peers have no beacon version handshake).
+                // Map each requested chain id to its named network for the proposal;
+                // ids without a static genesis mapping are skipped here (the
+                // NetworksUnsupportedBeaconError guard above reports them when the
+                // dApp opted into requiredMinimumVersion '4').
+                const proposalNetworkTypes = [];
+                for (const { chainId } of dedupedNetworks) {
+                    const networkType = (0, octez_connect_core_1.networkTypeFromTezosCaip2)(chainId);
+                    if (networkType === undefined) {
+                        logger.debug('requestPermissions', `No static network mapping for "${chainId}"; excluded from the WalletConnect proposal`);
+                        continue;
+                    }
+                    proposalNetworkTypes.push(networkType);
+                }
+                if (this.walletConnectTransport) {
+                    this.walletConnectTransport.setProposalNetworks(proposalNetworkTypes);
+                }
+                else {
+                    // The WalletConnect transport is created lazily inside init() (run
+                    // by makeRequest below, before the pairing proposal is built); stash
+                    // the networks and apply them right after creation.
+                    this.pendingWcProposalNetworks = proposalNetworkTypes;
+                }
+            }
             this.analytics.track('event', 'DAppClient', 'Permission requested');
             this.sendMetrics('performance-metrics/save', yield this.buildPayload('connect', 'start'));
             const logId = `makeRequest ${Date.now()}`;
@@ -1201,10 +1323,60 @@ class DAppClient extends octez_connect_core_1.Client {
             this.sendMetrics('performance-metrics/save', yield this.buildPayload('connect', 'success'));
             logger.log('requestPermissions', '######## MESSAGE #######');
             logger.log('requestPermissions', message);
-            const accountInfo = yield this.onNewAccount(message, connectionInfo);
-            logger.log('requestPermissions', '######## ACCOUNT INFO #######');
-            logger.log('requestPermissions', JSON.stringify(accountInfo));
-            yield this.accountManager.addAccount(accountInfo);
+            // walletPeer.version is the negotiated pairing version; fall back to the
+            // response envelope version when no peer is persisted yet.
+            const walletPeer = yield this.getPeer();
+            const walletPeerVersion = (_a = walletPeer === null || walletPeer === void 0 ? void 0 : walletPeer.version) !== null && _a !== void 0 ? _a : message.version;
+            // Gate the freshly-paired wallet against the dApp's required minimum (a
+            // no-op under the default, permissive minimum). Throws
+            // VersionUnsupportedBeaconError when the wallet is too old.
+            this.assertWalletVersionMeetsMinimum(walletPeerVersion);
+            const isV4Session = (0, octez_connect_core_1.isMultiNetworkVersion)(walletPeerVersion);
+            const messageAccounts = message.accounts;
+            const multiNetworkAccounts = isV4Session &&
+                messageAccounts &&
+                typeof messageAccounts === 'object' &&
+                !Array.isArray(messageAccounts)
+                ? messageAccounts
+                : null;
+            let accountInfo;
+            if (isV4Session) {
+                const requestedNetworks = ((_b = request.networks) !== null && _b !== void 0 ? _b : []).map((n) => (0, octez_connect_core_1.normalizeTezosCaip2)(n.chainId));
+                const servedChainIds = multiNetworkAccounts
+                    ? Object.keys(multiNetworkAccounts).map(octez_connect_core_1.normalizeTezosCaip2)
+                    : [];
+                const isMinimumVersionV4OrHigher = (0, octez_connect_core_1.isMultiNetworkVersion)(this.requiredMinimumVersion);
+                // Reject silently-degraded responses: a v4 session with >=2 networks
+                // requested but no accounts fanout returned.
+                if (requestedNetworks.length >= 2 && isMinimumVersionV4OrHigher) {
+                    const missing = requestedNetworks.filter((c) => !servedChainIds.includes(c));
+                    if (missing.length > 0) {
+                        throw new octez_connect_core_1.NetworksUnsupportedBeaconError({
+                            requestedNetworks,
+                            unsupportedNetworks: missing
+                        });
+                    }
+                }
+            }
+            if (isV4Session && multiNetworkAccounts) {
+                const builtAccounts = yield this.buildAccountInfosFromV4Fanout(message, multiNetworkAccounts, walletPeerVersion !== null && walletPeerVersion !== void 0 ? walletPeerVersion : '0', connectionInfo);
+                yield this.accountManager.addAccounts(builtAccounts);
+                accountInfo = builtAccounts[0];
+                if (!accountInfo) {
+                    throw new Error(EMPTY_PERMISSION_ACCOUNTS_MESSAGE);
+                }
+                yield this.setActiveAccount(accountInfo);
+                logger.log('requestPermissions', '######## MULTI-NETWORK ACCOUNTS #######', builtAccounts.length);
+            }
+            else {
+                accountInfo = yield this.onNewAccount(message, connectionInfo);
+                logger.log('requestPermissions', '######## ACCOUNT INFO #######');
+                logger.log('requestPermissions', JSON.stringify(accountInfo));
+                yield this.accountManager.addAccount(accountInfo);
+            }
+            if (!accountInfo) {
+                throw new Error(EMPTY_PERMISSION_ACCOUNTS_MESSAGE);
+            }
             const output = Object.assign(Object.assign({}, message), { walletKey: accountInfo.walletKey, address: accountInfo.address, accountInfo });
             yield this.notifySuccess(request, {
                 account: accountInfo,
@@ -1230,11 +1402,13 @@ class DAppClient extends octez_connect_core_1.Client {
     requestProofOfEventChallenge(input) {
         return __awaiter(this, void 0, void 0, function* () {
             const activeAccount = yield this.getActiveAccount();
-            if (!activeAccount)
+            if (!activeAccount) {
                 throw new Error('Please request permissions before doing a proof of event challenge');
+            }
             if (activeAccount.walletType !== 'abstracted_account' &&
-                activeAccount.verificationType !== 'proof_of_event')
+                activeAccount.verificationType !== 'proof_of_event') {
                 throw new Error('This wallet is not an abstracted account and thus cannot perform proof of event');
+            }
             const request = {
                 type: octez_connect_types_1.BeaconMessageType.ProofOfEventChallengeRequest,
                 contractAddress: activeAccount.address,
@@ -1271,8 +1445,9 @@ class DAppClient extends octez_connect_core_1.Client {
     requestSimulatedProofOfEventChallenge(input) {
         return __awaiter(this, void 0, void 0, function* () {
             const activeAccount = yield this.getActiveAccount();
-            if (!activeAccount)
+            if (!activeAccount) {
                 throw new Error('Please request permissions before doing a proof of event challenge');
+            }
             if (activeAccount.walletType !== 'abstracted_account' &&
                 activeAccount.verificationType !== 'proof_of_event') {
                 throw new Error('This wallet is not an abstracted account and thus cannot perform a simulated proof of event');
@@ -1422,9 +1597,10 @@ class DAppClient extends octez_connect_core_1.Client {
             if (!activeAccount) {
                 throw yield this.sendInternalError('No active account!');
             }
+            const resolvedNetwork = yield this.resolveOperationNetwork(input.network, activeAccount);
             const request = {
                 type: octez_connect_types_1.BeaconMessageType.OperationRequest,
-                network: activeAccount.network || this.network,
+                network: resolvedNetwork,
                 operationDetails: input.operationDetails,
                 sourceAddress: activeAccount.address || ''
             };
@@ -1624,7 +1800,10 @@ class DAppClient extends octez_connect_core_1.Client {
                         // if the account we requested is not available, we remove it locally
                         let accountInfo;
                         if (operationRequest.sourceAddress && operationRequest.network) {
-                            const accountIdentifier = yield (0, octez_connect_core_1.getAccountIdentifier)(operationRequest.sourceAddress, operationRequest.network);
+                            const networkForId = typeof operationRequest.network === 'string'
+                                ? (0, octez_connect_core_1.networkFromTezosCaip2)((0, octez_connect_core_1.normalizeTezosCaip2)(operationRequest.network))
+                                : operationRequest.network;
+                            const accountIdentifier = yield (0, octez_connect_core_1.getAccountIdentifier)(operationRequest.sourceAddress, networkForId);
                             accountInfo = yield this.getAccount(accountIdentifier);
                             if (accountInfo) {
                                 yield this.removeAccount(accountInfo.accountIdentifier);
@@ -1736,14 +1915,18 @@ class DAppClient extends octez_connect_core_1.Client {
                 web: { app: browser, type: 'web' }
             };
             const defaultType = () => {
-                if ((0, octez_connect_ui_1.isBrowser)(window) && browser)
+                if ((0, octez_connect_ui_1.isBrowser)(window) && browser) {
                     return { app: browser, type: 'web' };
-                if ((0, octez_connect_ui_1.isDesktop)(window) && desktop)
+                }
+                if ((0, octez_connect_ui_1.isDesktop)(window) && desktop) {
                     return { app: desktop, type: 'desktop' };
-                if ((0, octez_connect_ui_1.isBrowser)(window) && extension)
+                }
+                if ((0, octez_connect_ui_1.isBrowser)(window) && extension) {
                     return { app: extension, type: 'extension' };
-                if (mobile)
+                }
+                if (mobile) {
                     return { app: mobile, type: 'mobile' };
+                }
                 return { app: undefined, type: undefined };
             };
             const { app, type } = storageWallet ? appTypeMap[storageWallet.type] : defaultType();
@@ -1765,6 +1948,85 @@ class DAppClient extends octez_connect_core_1.Client {
             return walletInfo;
         });
     }
+    // Throws VersionUnsupportedBeaconError when a wallet that reported a version
+    // is below requiredMinimumVersion (or reports a malformed one). A peer that
+    // never reported a version (legacy pairing predating versioning) is treated
+    // as unknown and allowed through, so raising the minimum never retroactively
+    // breaks an already-paired session on a pure read.
+    assertWalletVersionMeetsMinimum(walletVersion) {
+        if (walletVersion === undefined) {
+            return;
+        }
+        const min = this.requiredMinimumVersion;
+        let cmp;
+        try {
+            cmp = (0, octez_connect_core_1.compareBeaconVersion)(walletVersion, min);
+        }
+        catch (_a) {
+            // A present-but-malformed version cannot be shown to meet the minimum.
+            throw new octez_connect_core_1.VersionUnsupportedBeaconError(min, walletVersion);
+        }
+        if (cmp < 0) {
+            throw new octez_connect_core_1.VersionUnsupportedBeaconError(min, walletVersion);
+        }
+    }
+    // Distinct CAIP-2 chain ids across all session accounts. Reads the account
+    // store, so callers should avoid it on paths that can decide without it.
+    getSessionChainIds() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const allAccounts = yield this.accountManager.getAccounts();
+            return Array.from(new Set(allAccounts
+                .map((a) => { var _a; return (_a = a.network) === null || _a === void 0 ? void 0 : _a.chainId; })
+                .filter((c) => typeof c === 'string' && c.length > 0)));
+        });
+    }
+    // Resolves the network for an outgoing operation. Returns the supplied
+    // CAIP-2 string (validated and confirmed in-session), or the active
+    // account's Network when there is no ambiguity. Throws on a multi-network
+    // session when no network is supplied.
+    resolveOperationNetwork(inputNetwork, activeAccount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (inputNetwork) {
+                if (!(0, octez_connect_core_1.isValidTezosCaip2)(inputNetwork)) {
+                    throw new octez_connect_core_1.NetworksUnsupportedBeaconError({
+                        requestedNetworks: [inputNetwork],
+                        unsupportedNetworks: [inputNetwork],
+                        customMessage: `Malformed CAIP-2 string: "${inputNetwork}". Expected format: tezos:<NetID>.`
+                    });
+                }
+                // Fast path: the active account is already on the requested network, so
+                // it is trivially in-session — skip the account-store read.
+                if (inputNetwork === ((_a = activeAccount.network) === null || _a === void 0 ? void 0 : _a.chainId)) {
+                    return inputNetwork;
+                }
+                const knownChainIds = yield this.getSessionChainIds();
+                // Tolerate pre-multi-network sessions with no recorded chain ids: such a
+                // wallet (v2/v3) expects a Network object, not a bare CAIP-2 string it
+                // cannot interpret, so return the active account's Network rather than the
+                // string. (There is exactly one network in a session with no chain ids.)
+                if (knownChainIds.length === 0) {
+                    return activeAccount.network || this.network;
+                }
+                if (!knownChainIds.includes(inputNetwork)) {
+                    throw new octez_connect_core_1.NetworksUnsupportedBeaconError({
+                        requestedNetworks: [inputNetwork],
+                        unsupportedNetworks: [inputNetwork]
+                    });
+                }
+                return inputNetwork;
+            }
+            // No explicit network: a session spanning more than one chain is ambiguous.
+            const sessionChainIds = yield this.getSessionChainIds();
+            if (sessionChainIds.length > 1) {
+                throw new octez_connect_core_1.NetworksUnsupportedBeaconError({
+                    requestedNetworks: [],
+                    unsupportedNetworks: []
+                });
+            }
+            return activeAccount.network || this.network;
+        });
+    }
     getPeer(account) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, _b, _c, _d, _e, _f;
@@ -1786,12 +2048,84 @@ class DAppClient extends octez_connect_core_1.Client {
                 peer = yield this._activePeer.promise;
                 logger.log('getPeer', 'Active peer', peer);
             }
+            // NB: getPeer() is a pure read used during session resumption, error
+            // handling and wallet-info lookups, so it must not throw on an
+            // under-minimum peer (that would wipe a resumed session or mask the real
+            // wallet error). The version gate is enforced at the pairing response and
+            // at request-send time instead — see assertWalletVersionMeetsMinimum.
             return peer;
         });
     }
+    // Build the wrapped Tezos wire message for a flat request input. The v4
+    // multi-network `networks` field is stripped for peers negotiated below
+    // v4 — a v3 peer must never see v4 payload fields.
+    wrapTezosRequest(flat, envelope, account) {
+        var _a;
+        if (flat.type === octez_connect_types_1.BeaconMessageType.PermissionRequest) {
+            const blockchainData = Object.assign({}, flat);
+            delete blockchainData.type;
+            if (!(0, octez_connect_core_1.isMultiNetworkVersion)(envelope.version)) {
+                delete blockchainData.networks;
+            }
+            return (0, octez_connect_core_1.wrapBeaconMessage)(envelope, {
+                blockchainIdentifier: 'tezos',
+                type: octez_connect_types_1.BeaconMessageType.PermissionRequest,
+                blockchainData
+            });
+        }
+        const payloadMeta = DAppClient.FLAT_REQUEST_PAYLOAD_TYPES[flat.type];
+        if (!payloadMeta) {
+            throw new Error(`Cannot send a "${flat.type}" message: not a Tezos request type`);
+        }
+        const payload = Object.assign({}, flat);
+        delete payload.type;
+        return (0, octez_connect_core_1.wrapBeaconMessage)(envelope, {
+            blockchainIdentifier: 'tezos',
+            type: octez_connect_types_1.BeaconMessageType.BlockchainRequest,
+            accountId: (_a = account === null || account === void 0 ? void 0 : account.accountIdentifier) !== null && _a !== void 0 ? _a : '',
+            blockchainData: Object.assign({ type: payloadMeta.type, scope: payloadMeta.scope }, payload)
+        });
+    }
+    // Normalize a wrapped Tezos wire message back to the flat shape the
+    // pre-fork pipeline (request* methods, onNewAccount, integrator events)
+    // consumes. Returns undefined for non-Tezos payloads, which keep the
+    // wrapped pass-through of the generic permissionRequest/request API.
+    normalizeWrappedTezosMessage(wrapper) {
+        var _a, _b, _c, _d, _e, _f;
+        const inner = wrapper.message;
+        const envelope = { id: wrapper.id, version: wrapper.version, senderId: wrapper.senderId };
+        // Chain-agnostic control messages.
+        if (inner.type === octez_connect_types_1.BeaconMessageType.Acknowledge || inner.type === octez_connect_types_1.BeaconMessageType.Disconnect) {
+            return Object.assign(Object.assign({}, envelope), { type: inner.type });
+        }
+        if (inner.type === octez_connect_types_1.BeaconMessageType.Error) {
+            return Object.assign(Object.assign({}, envelope), { type: octez_connect_types_1.BeaconMessageType.Error, errorType: (_b = (_a = inner.error) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : octez_connect_types_1.BeaconErrorType.UNKNOWN_ERROR, errorData: (_c = inner.error) === null || _c === void 0 ? void 0 : _c.data, description: inner.description });
+        }
+        if (inner.blockchainIdentifier === undefined ||
+            !DAppClient.TEZOS_IDENTIFIERS.includes(inner.blockchainIdentifier)) {
+            return undefined;
+        }
+        if (inner.type === octez_connect_types_1.BeaconMessageType.PermissionResponse ||
+            inner.type === octez_connect_types_1.BeaconMessageType.ChangeAccountRequest) {
+            return Object.assign(Object.assign(Object.assign({}, envelope), { type: inner.type }), ((_d = inner.blockchainData) !== null && _d !== void 0 ? _d : {}));
+        }
+        if (inner.type === octez_connect_types_1.BeaconMessageType.BlockchainResponse) {
+            const payloadType = (_e = inner.blockchainData) === null || _e === void 0 ? void 0 : _e.type;
+            const flatType = typeof payloadType === 'string'
+                ? DAppClient.TEZOS_PAYLOAD_TO_FLAT_TYPE[payloadType]
+                : undefined;
+            if (!flatType) {
+                return undefined;
+            }
+            const payload = Object.assign({}, ((_f = inner.blockchainData) !== null && _f !== void 0 ? _f : {}));
+            delete payload.type;
+            return Object.assign(Object.assign(Object.assign({}, envelope), { type: flatType }), payload);
+        }
+        return undefined;
+    }
     makeRequest(requestInput, skipResponse, otherTabMessageId) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d;
+            var _a, _b, _c, _d, _e;
             const messageId = otherTabMessageId !== null && otherTabMessageId !== void 0 ? otherTabMessageId : (yield (0, octez_connect_utils_1.generateGUID)());
             if (this._initPromise && this.isInitPending) {
                 if (this._initPromiseReject) {
@@ -1823,25 +2157,44 @@ class DAppClient extends octez_connect_core_1.Client {
             if (!this.beaconId) {
                 throw yield this.sendInternalError('octez.connect ID not defined');
             }
-            const request = Object.assign({ id: messageId, version: '2', senderId: yield (0, octez_connect_core_1.getSenderId)(yield this.beaconId) }, requestInput);
+            const account = yield this.getActiveAccount();
+            const peer = yield this.getPeer(account);
+            // Enforce the dApp's required minimum before a request leaves the SDK.
+            // No-op under the default (permissive) minimum; otherwise rejects an
+            // under-minimum wallet with VersionUnsupportedBeaconError.
+            this.assertWalletVersionMeetsMinimum(peer === null || peer === void 0 ? void 0 : peer.version);
+            // The wire dialect is negotiated per peer — min(peer.version,
+            // BEACON_VERSION), floor '2'. A wrapped-capable peer (>= 3) receives the
+            // flat requestInput (the unchanged public shape) mapped onto the wrapped
+            // Tezos payload; a legacy peer receives the flat v2 message it has
+            // always spoken. Integrators never see either dialect.
+            const negotiatedVersion = (0, octez_connect_core_1.negotiateEnvelopeVersion)(peer === null || peer === void 0 ? void 0 : peer.version);
+            const requestSenderId = yield (0, octez_connect_core_1.getSenderId)(yield this.beaconId);
+            let request;
+            if ((0, octez_connect_core_1.usesWrappedMessages)(negotiatedVersion)) {
+                const wrapped = this.wrapTezosRequest(requestInput, { id: messageId, version: negotiatedVersion, senderId: requestSenderId }, account);
+                yield ((_c = this.blockchains.get('tezos')) === null || _c === void 0 ? void 0 : _c.validateRequest(wrapped.message));
+                request = wrapped;
+            }
+            else {
+                request = Object.assign({ id: messageId, version: negotiatedVersion, senderId: requestSenderId }, requestInput);
+            }
             let exposed;
             if (!skipResponse) {
                 exposed = new octez_connect_utils_1.ExposedPromise();
                 this.addOpenRequest(request.id, exposed);
             }
-            const account = yield this.getActiveAccount();
-            const peer = yield this.getPeer(account);
             const payload = yield new octez_connect_core_1.Serializer(this.getPeerProtocolVersion(peer)).serialize(request);
             const walletInfo = yield this.getWalletInfo(peer, account);
             logger.log('makeRequest', 'sending message', request);
             try {
                 // Hook for performance measurement
-                if ((_c = window.__beaconPerf) === null || _c === void 0 ? void 0 : _c.onBeforeSend) {
+                if ((_d = window.__beaconPerf) === null || _d === void 0 ? void 0 : _d.onBeforeSend) {
                     window.__beaconPerf.onBeforeSend();
                 }
                 ;
                 (yield this.transport).send(payload, peer);
-                if (request.type !== octez_connect_types_1.BeaconMessageType.PermissionRequest ||
+                if (requestInput.type !== octez_connect_types_1.BeaconMessageType.PermissionRequest ||
                     (this._activeAccount.isResolved() && (yield this._activeAccount.promise))) {
                     this.tryToAppSwitch();
                 }
@@ -1868,7 +2221,7 @@ class DAppClient extends octez_connect_core_1.Client {
             if (!otherTabMessageId) {
                 this.events
                     .emit(beacon_message_events_1.messageEvents[requestInput.type].sent, {
-                    walletInfo: Object.assign(Object.assign({}, walletInfo), { name: (_d = walletInfo.name) !== null && _d !== void 0 ? _d : 'Wallet' }),
+                    walletInfo: Object.assign(Object.assign({}, walletInfo), { name: (_e = walletInfo.name) !== null && _e !== void 0 ? _e : 'Wallet' }),
                     extraInfo: {
                         resetCallback: () => __awaiter(this, void 0, void 0, function* () {
                             this.disconnect();
@@ -1919,16 +2272,22 @@ class DAppClient extends octez_connect_core_1.Client {
             if (!this.beaconId) {
                 throw yield this.sendInternalError('octez.connect ID not defined');
             }
+            const account = yield this.getActiveAccount();
+            const peer = yield this.getPeer(account);
+            // Enforce the dApp's required minimum before a request leaves the SDK.
+            this.assertWalletVersionMeetsMinimum(peer === null || peer === void 0 ? void 0 : peer.version);
             const request = {
                 id: messageId,
-                version: '3',
+                // The envelope carries the version negotiated against the peer:
+                // min(peer.version, BEACON_VERSION), floor '3'. A v3 wallet treats any
+                // version >= 3 as a wrapped message; a v4 wallet reaches its
+                // multi-network branch only when it declared v4 at pairing.
+                version: (0, octez_connect_core_1.negotiateEnvelopeVersion)(peer === null || peer === void 0 ? void 0 : peer.version),
                 senderId: yield (0, octez_connect_core_1.getSenderId)(yield this.beaconId),
                 message: requestInput
             };
             const exposed = new octez_connect_utils_1.ExposedPromise();
             this.addOpenRequest(request.id, exposed);
-            const account = yield this.getActiveAccount();
-            const peer = yield this.getPeer(account);
             const payload = yield new octez_connect_core_1.Serializer(this.getPeerProtocolVersion(peer)).serialize(request);
             const walletInfo = yield this.getWalletInfo(peer, account);
             logger.log('makeRequest', 'sending message', request);
@@ -2084,7 +2443,7 @@ class DAppClient extends octez_connect_core_1.Client {
                 payload
             ].join(' ');
             const bytes = (0, octez_connect_utils_1.toHex)(constructedString);
-            const payloadBytes = '05' + '01' + bytes.length.toString(16).padStart(8, '0') + bytes;
+            const payloadBytes = `05` + `01${bytes.length.toString(16).padStart(8, '0')}${bytes}`;
             const signature = yield (0, octez_connect_utils_1.signMessage)(payloadBytes, {
                 secretKey: Buffer.from(keypair.secretKey)
             });
@@ -2112,6 +2471,59 @@ class DAppClient extends octez_connect_core_1.Client {
             return notificationResponse.json();
         });
     }
+    // Delegate the per-network unpacking to the Tezos blockchain plug-in (the
+    // single owner of the v4 fanout shape) and enrich each returned record with
+    // the envelope-level AccountInfo metadata that the parser doesn't see.
+    buildAccountInfosFromV4Fanout(message, fanout, peerVersion, connectionInfo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            // Keyed by the CAIP-2 namespace `'tezos'`, which is also the wire-format
+            // `blockchainIdentifier` carried by PermissionRequestV3/Response. The
+            // dApp must have registered `new TezosBlockchain()` via `addBlockchain`
+            // before requesting permissions on the v4 path.
+            const tezosBlockchain = this.blockchains.get('tezos');
+            if (!tezosBlockchain) {
+                throw new Error('Tezos blockchain handler is required to parse v4 permission responses');
+            }
+            // Normalize the legacy `pubkey`/`pubKey` aliases and prefix any raw key
+            // before handing the fanout to the parser. The parser keeps publicKey
+            // strings verbatim, so prefixing here keeps stored records canonical.
+            const envelopePublicKey = (_a = message.publicKey) !== null && _a !== void 0 ? _a : message.pubkey;
+            const prefixedEnvelopePk = envelopePublicKey ? (0, octez_connect_utils_1.prefixPublicKey)(envelopePublicKey) : undefined;
+            const prefixedFanout = Object.fromEntries(Object.entries(fanout).map(([cid, raw]) => [
+                cid,
+                Object.assign(Object.assign({}, raw), { publicKey: (raw === null || raw === void 0 ? void 0 : raw.publicKey) ? (0, octez_connect_utils_1.prefixPublicKey)(raw.publicKey) : undefined })
+            ]));
+            const synthesizedResponse = {
+                blockchainIdentifier: 'tezos',
+                type: octez_connect_types_1.BeaconMessageType.PermissionResponse,
+                blockchainData: Object.assign(Object.assign({}, message), { publicKey: prefixedEnvelopePk, accounts: prefixedFanout })
+            };
+            const partials = yield tezosBlockchain.getAccountInfosFromPermissionResponse(synthesizedResponse, peerVersion);
+            const walletKey = (_b = (yield this.storage.get(octez_connect_types_1.StorageKey.LAST_SELECTED_WALLET))) === null || _b === void 0 ? void 0 : _b.key;
+            return Promise.all(partials.map((p) => __awaiter(this, void 0, void 0, function* () {
+                var _a, _b;
+                if (!p.publicKey && !p.address) {
+                    throw new Error('PublicKey or Address must be defined for multi-network account');
+                }
+                const address = p.address || (yield (0, octez_connect_utils_1.getAddressFromPublicKey)(p.publicKey));
+                // The parser keys by the address it saw; re-derive accountId if we
+                // synthesized the address from a publicKey above.
+                const accountIdentifier = p.address || !p.network ? p.accountId : yield (0, octez_connect_core_1.getAccountIdentifier)(address, p.network);
+                return Object.assign({ accountIdentifier, senderId: message.senderId, origin: {
+                        type: connectionInfo.origin,
+                        id: connectionInfo.id
+                    }, walletKey,
+                    address, publicKey: p.publicKey || undefined, 
+                    // The v4 fanout parser always sets a Network (networkFromTezosCaip2);
+                    // the `?? this.network` fallback keeps the type `Network` (required by
+                    // AccountInfo) without an `as AccountInfo` assertion.
+                    network: (_a = p.network) !== null && _a !== void 0 ? _a : this.network, scopes: message.scopes, threshold: message.threshold, notification: message.notification, connectedAt: new Date().getTime(), walletType: (_b = message.walletType) !== null && _b !== void 0 ? _b : 'implicit', verificationType: message.verificationType }, (message.verificationType === 'proof_of_event'
+                    ? { hasVerifiedChallenge: false }
+                    : {}));
+            })));
+        });
+    }
     onNewAccount(message, connectionInfo) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, _b, _c;
@@ -2147,4 +2559,39 @@ class DAppClient extends octez_connect_core_1.Client {
     }
 }
 exports.DAppClient = DAppClient;
+/**
+ * This method handles sending of requests to the DApp. It makes sure that the DAppClient is initialized and connected
+ * to the transport. After that rate limits and permissions will be checked, an ID is attached and the request is sent
+ * to the DApp over the transport.
+ *
+ * @param requestInput The BeaconMessage to be sent to the wallet
+ * @param account The account that the message will be sent to
+ * @param skipResponse If true, the function return as soon as the message is sent
+ */
+// Maps each flat Tezos request type to its wrapped blockchainData
+// discriminator + scope (the pre-fork flat wire strings, kept verbatim;
+// mirrored by the wallet-side flat-output normalization).
+DAppClient.FLAT_REQUEST_PAYLOAD_TYPES = {
+    [octez_connect_types_1.BeaconMessageType.OperationRequest]: { type: 'operation_request', scope: 'operation_request' },
+    [octez_connect_types_1.BeaconMessageType.SignPayloadRequest]: { type: 'sign_payload_request', scope: 'sign' },
+    [octez_connect_types_1.BeaconMessageType.BroadcastRequest]: { type: 'broadcast_request', scope: 'broadcast' },
+    [octez_connect_types_1.BeaconMessageType.ProofOfEventChallengeRequest]: {
+        type: 'proof_of_event_challenge_request',
+        scope: 'proof_of_event'
+    },
+    [octez_connect_types_1.BeaconMessageType.SimulatedProofOfEventChallengeRequest]: {
+        type: 'simulated_proof_of_event_challenge_request',
+        scope: 'proof_of_event'
+    }
+};
+// Wrapped Tezos response blockchainData discriminators → the flat
+// BeaconMessageType the request* methods (and integrators) consume.
+DAppClient.TEZOS_PAYLOAD_TO_FLAT_TYPE = {
+    operation_response: octez_connect_types_1.BeaconMessageType.OperationResponse,
+    sign_payload_response: octez_connect_types_1.BeaconMessageType.SignPayloadResponse,
+    broadcast_response: octez_connect_types_1.BeaconMessageType.BroadcastResponse,
+    proof_of_event_challenge_response: octez_connect_types_1.BeaconMessageType.ProofOfEventChallengeResponse,
+    simulated_proof_of_event_challenge_response: octez_connect_types_1.BeaconMessageType.SimulatedProofOfEventChallengeResponse
+};
+DAppClient.TEZOS_IDENTIFIERS = ['tezos', 'xtz'];
 //# sourceMappingURL=DAppClient.js.map