@solana-mobile/mobile-wallet-adapter-protocol 2.2.9 → 2.3.0

package/lib/esm/index.browser.js

@@ -1,4 +1,7 @@
 import { c as utf8FromUint8Array, d as base64ToBase58, f as encode, l as utf8ToUint8Array, m as toUint8Array, p as fromUint8Array, u as arrayBufferToBase64String } from "./chunks/encoding.js";
+import { schnorr } from "@noble/curves/secp256k1.js";
+import { sha256 } from "@noble/hashes/sha2.js";
+import { bytesToHex, hexToBytes } from "@noble/hashes/utils.js";
 import { createSignInMessageText } from "@solana/wallet-standard-util";
 //#region src/errors.ts
 const SolanaMobileWalletAdapterErrorCode = {
@@ -12,7 +15,8 @@ const SolanaMobileWalletAdapterErrorCode = {
 	ERROR_INVALID_PROTOCOL_VERSION: "ERROR_INVALID_PROTOCOL_VERSION",
 	ERROR_BROWSER_NOT_SUPPORTED: "ERROR_BROWSER_NOT_SUPPORTED",
 	ERROR_LOOPBACK_ACCESS_BLOCKED: "ERROR_LOOPBACK_ACCESS_BLOCKED",
-	ERROR_ASSOCIATION_CANCELLED: "ERROR_ASSOCIATION_CANCELLED"
+	ERROR_ASSOCIATION_CANCELLED: "ERROR_ASSOCIATION_CANCELLED",
+	ERROR_ILLEGAL_TRANSPORT_STATE: "ERROR_ILLEGAL_TRANSPORT_STATE"
 };
 var SolanaMobileWalletAdapterError = class extends Error {
 	data;
@@ -47,6 +51,57 @@ var SolanaMobileWalletAdapterProtocolError = class extends Error {
 	}
 };
 //#endregion
+//#region src/nostr.ts
+const NOSTR_EVENT_KIND_MWA = 20012;
+function generateNostrKeypair() {
+	const privateKey = schnorr.utils.randomSecretKey();
+	return {
+		privateKey,
+		publicKey: bytesToHex(schnorr.getPublicKey(privateKey))
+	};
+}
+async function deriveSessionIdentifier(associationPublicKey) {
+	const rawKey = await crypto.subtle.exportKey("raw", associationPublicKey);
+	const hash = sha256(new Uint8Array(rawKey));
+	return bytesToHex(hash);
+}
+function serializeEvent(pubkey, createdAt, kind, tags, content) {
+	return JSON.stringify([
+		0,
+		pubkey,
+		createdAt,
+		kind,
+		tags,
+		content
+	]);
+}
+function computeEventId(pubkey, createdAt, kind, tags, content) {
+	const serialized = serializeEvent(pubkey, createdAt, kind, tags, content);
+	return bytesToHex(sha256(new TextEncoder().encode(serialized)));
+}
+function createNostrEvent(kind, content, tags, privateKey) {
+	const pubkey = bytesToHex(schnorr.getPublicKey(privateKey));
+	const createdAt = Math.floor(Date.now() / 1e3);
+	const id = computeEventId(pubkey, createdAt, kind, tags, content);
+	return {
+		id,
+		pubkey,
+		created_at: createdAt,
+		kind,
+		tags,
+		content,
+		sig: bytesToHex(schnorr.sign(hexToBytes(id), privateKey))
+	};
+}
+function verifyNostrEvent(event) {
+	if (computeEventId(event.pubkey, event.created_at, event.kind, event.tags, event.content) !== event.id) return false;
+	try {
+		return schnorr.verify(hexToBytes(event.sig), hexToBytes(event.id), hexToBytes(event.pubkey));
+	} catch {
+		return false;
+	}
+}
+//#endregion
 //#region src/createHelloReq.ts
 async function createHelloReq(ecdhPublicKey, associationKeypairPrivateKey) {
 	const publicKeyBuffer = await crypto.subtle.exportKey("raw", ecdhPublicKey);
@@ -138,9 +193,7 @@ function handleMobileWalletRequest(methodName, methodParams, protocolVersion) {
 					case "devnet":
 						chain = `solana:${chain}`;
 						break;
-					case "mainnet-beta":
-						chain = "solana:mainnet";
-						break;
+					case "mainnet-beta": chain = "solana:mainnet";
 				}
 				authorizeParams.chain = chain;
 				params = authorizeParams;
@@ -156,9 +209,7 @@ function handleMobileWalletRequest(methodName, methodParams, protocolVersion) {
 						identity
 					};
 					break;
-				default:
-					method = "authorize";
-					break;
+				default: method = "authorize";
 			}
 			break;
 		}
@@ -207,10 +258,11 @@ async function signInFallback(signInPayload, authorizationResult, protocolReques
 		domain,
 		address: base64ToBase58(address)
 	});
-	const signedPayload = toUint8Array((await protocolRequestHandler("sign_messages", {
+	const signMessageResult = await protocolRequestHandler("sign_messages", {
 		addresses: [address],
 		payloads: [siwsMessage]
-	})).signed_payloads[0]);
+	});
+	const signedPayload = toUint8Array(signMessageResult.signed_payloads[0]);
 	const signedMessage = fromUint8Array(signedPayload.slice(0, signedPayload.length - 64));
 	const signature = fromUint8Array(signedPayload.slice(signedPayload.length - 64));
 	return {
@@ -241,8 +293,8 @@ async function encryptMessage(plaintext, sequenceNumber, sharedSecret) {
 }
 async function decryptMessage(message, sharedSecret) {
 	const sequenceNumberVector = message.slice(0, 4);
-	const initializationVector = message.slice(4, 4 + INITIALIZATION_VECTOR_BYTES);
-	const ciphertext = message.slice(4 + INITIALIZATION_VECTOR_BYTES);
+	const initializationVector = message.slice(4, 16);
+	const ciphertext = message.slice(16);
 	const plaintextBuffer = await crypto.subtle.decrypt(getAlgorithmParams(sequenceNumberVector, initializationVector), sharedSecret, ciphertext);
 	return utf8FromUint8Array(new Uint8Array(plaintextBuffer));
 }
@@ -308,7 +360,8 @@ function getIntentURL(methodPathname, intentUrlBase) {
 }
 async function getAssociateAndroidIntentURL(associationPublicKey, putativePort, associationURLBase, protocolVersions = ["v1"]) {
 	const associationPort = assertAssociationPort(putativePort);
-	const encodedKey = arrayBufferToBase64String(await crypto.subtle.exportKey("raw", associationPublicKey));
+	const exportedKey = await crypto.subtle.exportKey("raw", associationPublicKey);
+	const encodedKey = arrayBufferToBase64String(exportedKey);
 	const url = getIntentURL("v1/associate/local", associationURLBase);
 	url.searchParams.set("association", getStringWithURLUnsafeBase64CharactersReplaced(encodedKey));
 	url.searchParams.set("port", `${associationPort}`);
@@ -318,7 +371,8 @@ async function getAssociateAndroidIntentURL(associationPublicKey, putativePort,
 	return url;
 }
 async function getRemoteAssociateAndroidIntentURL(associationPublicKey, hostAuthority, reflectorId, associationURLBase, protocolVersions = ["v1"]) {
-	const encodedKey = arrayBufferToBase64String(await crypto.subtle.exportKey("raw", associationPublicKey));
+	const exportedKey = await crypto.subtle.exportKey("raw", associationPublicKey);
+	const encodedKey = arrayBufferToBase64String(exportedKey);
 	const url = getIntentURL("v1/associate/remote", associationURLBase);
 	url.searchParams.set("association", getStringWithURLUnsafeBase64CharactersReplaced(encodedKey));
 	url.searchParams.set("reflector", `${hostAuthority}`);
@@ -328,6 +382,18 @@ async function getRemoteAssociateAndroidIntentURL(associationPublicKey, hostAuth
 	});
 	return url;
 }
+async function getNostrAssociateAndroidIntentURL(associationPublicKey, connectionType, relayDomain, dappNostrPubkey, associationURLBase, protocolVersions = ["v1"]) {
+	const exportedKey = await crypto.subtle.exportKey("raw", associationPublicKey);
+	const encodedKey = arrayBufferToBase64String(exportedKey);
+	const url = getIntentURL(`v1/associate/${connectionType}/nostr`, associationURLBase);
+	url.searchParams.set("association", getStringWithURLUnsafeBase64CharactersReplaced(encodedKey));
+	url.searchParams.set("relay", relayDomain);
+	url.searchParams.set("pubkey", dappNostrPubkey);
+	protocolVersions.forEach((version) => {
+		url.searchParams.set("v", version);
+	});
+	return url;
+}
 //#endregion
 //#region src/jsonRpcMessage.ts
 async function encryptJsonRpcMessage(jsonRpcMessage, sharedSecret) {
@@ -357,7 +423,7 @@ async function parseHelloRsp(payloadBuffer, associationPublicKey, ecdhPrivateKey
 		name: "HKDF",
 		hash: "SHA-256",
 		salt: new Uint8Array(associationPublicKeyBuffer),
-		info: new Uint8Array()
+		info: /* @__PURE__ */ new Uint8Array()
 	}, ecdhSecretKey, {
 		name: "AES-GCM",
 		length: 128
@@ -388,9 +454,6 @@ const Browser = {
 	Firefox: 0,
 	Other: 1
 };
-function assertUnreachable(x) {
-	return x;
-}
 function getBrowser() {
 	return navigator.userAgent.indexOf("Firefox/") !== -1 ? Browser.Firefox : Browser.Other;
 }
@@ -413,7 +476,7 @@ function getDetectionPromise() {
 }
 let _frame = null;
 function launchUrlThroughHiddenFrame(url) {
-	if (_frame == null) {
+	if (_frame == null || !_frame.isConnected) {
 		_frame = document.createElement("iframe");
 		_frame.style.display = "none";
 		document.body.appendChild(_frame);
@@ -423,8 +486,7 @@ function launchUrlThroughHiddenFrame(url) {
 async function launchAssociation(associationUrl) {
 	if (associationUrl.protocol === "https:") window.location.assign(associationUrl);
 	else try {
-		const browser = getBrowser();
-		switch (browser) {
+		switch (getBrowser()) {
 			case Browser.Firefox:
 				launchUrlThroughHiddenFrame(associationUrl);
 				break;
@@ -434,7 +496,6 @@ async function launchAssociation(associationUrl) {
 				await detectionPromise;
 				break;
 			}
-			default: assertUnreachable(browser);
 		}
 	} catch {
 		throw new SolanaMobileWalletAdapterError(SolanaMobileWalletAdapterErrorCode.ERROR_WALLET_NOT_FOUND, "Found no installed wallet that supports the mobile wallet protocol.");
@@ -445,9 +506,24 @@ async function startSession(associationPublicKey, associationURLBase) {
 	await launchAssociation(await getAssociateAndroidIntentURL(associationPublicKey, randomAssociationPort, associationURLBase));
 	return randomAssociationPort;
 }
+async function startNostrSession(associationPublicKey, connectionType, relayDomain, dappNostrPubkey, associationURLBase) {
+	const associationUrl = await getNostrAssociateAndroidIntentURL(associationPublicKey, connectionType, relayDomain, dappNostrPubkey, associationURLBase);
+	if (connectionType == "local") await launchAssociation(associationUrl);
+	return associationUrl;
+}
 //#endregion
 //#region src/transact.ts
 const WEBSOCKET_CONNECTION_CONFIG = {
+	/**
+	* 300 milliseconds is a generally accepted threshold for what someone
+	* would consider an acceptable response time for a user interface
+	* after having performed a low-attention tapping task. We set the initial
+	* interval at which we wait for the wallet to set up the websocket at
+	* half this, as per the Nyquist frequency, with a progressive backoff
+	* sequence from there. The total wait time is 30s, which allows for the
+	* user to be presented with a disambiguation dialog, select a wallet, and
+	* for the wallet app to subsequently start.
+	*/
 	retryDelayScheduleMs: [
 		150,
 		150,
@@ -561,7 +637,10 @@ async function startScenario(config) {
 				const responseBuffer = await evt.data.arrayBuffer();
 				switch (state.__type) {
 					case "connecting": {
-						if (responseBuffer.byteLength !== 0) throw new Error("Encountered unexpected message while connecting");
+						if (responseBuffer.byteLength !== 0) {
+							reject(new SolanaMobileWalletAdapterError(SolanaMobileWalletAdapterErrorCode.ERROR_ILLEGAL_TRANSPORT_STATE, "Encountered unexpected message while connecting"));
+							return;
+						}
 						const ecdhKeypair = await generateECDHKeypair();
 						socket.send(await createHelloReq(ecdhKeypair.publicKey, associationKeypair.privateKey));
 						state = {
@@ -574,7 +653,7 @@ async function startScenario(config) {
 					case "connected":
 						try {
 							const sequenceNumber = getSequenceNumberFromByteArray(responseBuffer.slice(0, 4));
-							if (sequenceNumber !== lastKnownInboundSequenceNumber + 1) throw new Error("Encrypted message has invalid sequence number");
+							if (sequenceNumber !== lastKnownInboundSequenceNumber + 1) throw new SolanaMobileWalletAdapterError(SolanaMobileWalletAdapterErrorCode.ERROR_ILLEGAL_TRANSPORT_STATE, "Encrypted message has invalid sequence number");
 							lastKnownInboundSequenceNumber = sequenceNumber;
 							const jsonRpcMessage = await decryptJsonRpcMessage(responseBuffer, state.sharedSecret);
 							const responsePromise = jsonRpcResponsePromises[jsonRpcMessage.id];
@@ -603,7 +682,11 @@ async function startScenario(config) {
 						const sessionPropertiesBuffer = responseBuffer.slice(65);
 						const sessionProperties = sessionPropertiesBuffer.byteLength !== 0 ? await (async () => {
 							const sequenceNumber = getSequenceNumberFromByteArray(sessionPropertiesBuffer.slice(0, 4));
-							if (sequenceNumber !== lastKnownInboundSequenceNumber + 1) throw new Error("Encrypted message has invalid sequence number");
+							if (sequenceNumber !== lastKnownInboundSequenceNumber + 1) {
+								reject(new SolanaMobileWalletAdapterError(SolanaMobileWalletAdapterErrorCode.ERROR_ILLEGAL_TRANSPORT_STATE, "Encrypted message has invalid sequence number"));
+								socket.close();
+								return { protocol_version: "v1" };
+							}
 							lastKnownInboundSequenceNumber = sequenceNumber;
 							return parseSessionProps(sessionPropertiesBuffer, sharedSecret);
 						})() : { protocol_version: "legacy" };
@@ -699,8 +782,10 @@ async function startRemoteScenario(config) {
 	let socket;
 	let disposeSocket;
 	const decodeBytes = async (evt) => {
-		if (encoding == "base64") return toUint8Array(await evt.data).buffer;
-		else return await evt.data.arrayBuffer();
+		if (encoding == "base64") {
+			const message = await evt.data;
+			return toUint8Array(message).buffer;
+		} else return await evt.data.arrayBuffer();
 	};
 	const associationUrl = await new Promise((resolve, reject) => {
 		const handleOpen = async () => {
@@ -731,7 +816,11 @@ async function startRemoteScenario(config) {
 		const handleReflectorIdMessage = async (evt) => {
 			const responseBuffer = await decodeBytes(evt);
 			if (state.__type === "connecting") {
-				if (responseBuffer.byteLength == 0) throw new Error("Encountered unexpected message while connecting");
+				if (responseBuffer.byteLength == 0) {
+					reject(new SolanaMobileWalletAdapterError(SolanaMobileWalletAdapterErrorCode.ERROR_ILLEGAL_TRANSPORT_STATE, "Encountered unexpected message while connecting"));
+					socket.close();
+					return;
+				}
 				const reflectorId = getReflectorIdFromByteArray(responseBuffer);
 				state = {
 					__type: "reflector_id_received",
@@ -779,7 +868,11 @@ async function startRemoteScenario(config) {
 				const responseBuffer = await decodeBytes(evt);
 				switch (state.__type) {
 					case "reflector_id_received": {
-						if (responseBuffer.byteLength !== 0) throw new Error("Encountered unexpected message while awaiting reflection");
+						if (responseBuffer.byteLength !== 0) {
+							reject(new SolanaMobileWalletAdapterError(SolanaMobileWalletAdapterErrorCode.ERROR_ILLEGAL_TRANSPORT_STATE, "Encountered unexpected message while awaiting reflection"));
+							socket.close();
+							return;
+						}
 						const ecdhKeypair = await generateECDHKeypair();
 						const binaryMsg = await createHelloReq(ecdhKeypair.publicKey, associationKeypair.privateKey);
 						if (encoding == "base64") socket.send(fromUint8Array(binaryMsg));
@@ -794,7 +887,7 @@ async function startRemoteScenario(config) {
 					case "connected":
 						try {
 							const sequenceNumber = getSequenceNumberFromByteArray(responseBuffer.slice(0, 4));
-							if (sequenceNumber !== lastKnownInboundSequenceNumber + 1) throw new Error("Encrypted message has invalid sequence number");
+							if (sequenceNumber !== lastKnownInboundSequenceNumber + 1) throw new SolanaMobileWalletAdapterError(SolanaMobileWalletAdapterErrorCode.ERROR_ILLEGAL_TRANSPORT_STATE, "Encrypted message has invalid sequence number");
 							lastKnownInboundSequenceNumber = sequenceNumber;
 							const jsonRpcMessage = await decryptJsonRpcMessage(responseBuffer, state.sharedSecret);
 							const responsePromise = jsonRpcResponsePromises[jsonRpcMessage.id];
@@ -813,7 +906,11 @@ async function startRemoteScenario(config) {
 						const sessionPropertiesBuffer = responseBuffer.slice(65);
 						const sessionProperties = sessionPropertiesBuffer.byteLength !== 0 ? await (async () => {
 							const sequenceNumber = getSequenceNumberFromByteArray(sessionPropertiesBuffer.slice(0, 4));
-							if (sequenceNumber !== lastKnownInboundSequenceNumber + 1) throw new Error("Encrypted message has invalid sequence number");
+							if (sequenceNumber !== lastKnownInboundSequenceNumber + 1) {
+								reject(new SolanaMobileWalletAdapterError(SolanaMobileWalletAdapterErrorCode.ERROR_ILLEGAL_TRANSPORT_STATE, "Encrypted message has invalid sequence number"));
+								socket.close();
+								return { protocol_version: "v1" };
+							}
 							lastKnownInboundSequenceNumber = sequenceNumber;
 							return parseSessionProps(sessionPropertiesBuffer, sharedSecret);
 						})() : { protocol_version: "legacy" };
@@ -873,7 +970,238 @@ async function startRemoteScenario(config) {
 		})
 	};
 }
+async function startNostrScenario(config) {
+	assertSecureContext();
+	const associationKeypair = await generateAssociationKeypair();
+	const { privateKey: dappNostrPrivateKey, publicKey: dappNostrPubkey } = generateNostrKeypair();
+	const associationUrl = await startNostrSession(associationKeypair.publicKey, config.connectionType, config.relayDomain, dappNostrPubkey, config.baseUri);
+	const sessionIdentifier = await deriveSessionIdentifier(associationKeypair.publicKey);
+	const subscriptionId = crypto.randomUUID();
+	const webSocketURL = `wss://${config.relayDomain}`;
+	const connectionStartTime = Date.now();
+	const getNextRetryDelayMs = (() => {
+		const schedule = [...WEBSOCKET_CONNECTION_CONFIG.retryDelayScheduleMs];
+		return () => schedule.length > 1 ? schedule.shift() : schedule[0];
+	})();
+	let nextJsonRpcMessageId = 1;
+	let lastKnownInboundSequenceNumber = 0;
+	let state = { __type: "disconnected" };
+	let socket;
+	let sessionEstablished = false;
+	let handleForceClose;
+	const sendNostrEvent = (content, walletPubkey) => {
+		const event = createNostrEvent(NOSTR_EVENT_KIND_MWA, content, [["d", sessionIdentifier], ["p", walletPubkey]], dappNostrPrivateKey);
+		socket.send(JSON.stringify(["EVENT", event]));
+	};
+	const doClose = () => {
+		if (state.__type == "connected" || state.__type == "hello_req_sent") {
+			const event = createNostrEvent(NOSTR_EVENT_KIND_MWA, "", [
+				["d", sessionIdentifier],
+				["p", state.walletNostrPubkey],
+				["msg", "SESSION_END"]
+			], dappNostrPrivateKey);
+			socket.send(JSON.stringify(["EVENT", event]));
+		}
+		socket.close();
+	};
+	const scenario = {
+		close: () => {
+			doClose();
+			handleForceClose();
+		},
+		wallet: new Promise((resolve, reject) => {
+			const jsonRpcResponsePromises = {};
+			const handleOpen = async () => {
+				if (state.__type !== "connecting") {
+					console.warn(`Expected adapter state to be \`connecting\` at the moment the websocket opens. Got \`${state.__type}\`.`);
+					return;
+				}
+				socket.removeEventListener("open", handleOpen);
+				socket.send(JSON.stringify([
+					"REQ",
+					subscriptionId,
+					{
+						kinds: [NOSTR_EVENT_KIND_MWA],
+						"#d": [sessionIdentifier]
+					}
+				]));
+				state = {
+					__type: "subscribed",
+					dappNostrPrivateKey,
+					dappNostrPubkey,
+					sessionIdentifier
+				};
+			};
+			const handleClose = (evt) => {
+				if (evt.wasClean) state = { __type: "disconnected" };
+				else reject(new SolanaMobileWalletAdapterError(SolanaMobileWalletAdapterErrorCode.ERROR_SESSION_CLOSED, `The Nostr subscription dropped unexpectedly (${evt.code}: ${evt.reason}).`, { closeEvent: evt }));
+				disposeSocket();
+			};
+			const handleError = async () => {
+				disposeSocket();
+				if (Date.now() - connectionStartTime >= WEBSOCKET_CONNECTION_CONFIG.timeoutMs) reject(new SolanaMobileWalletAdapterError(SolanaMobileWalletAdapterErrorCode.ERROR_SESSION_TIMEOUT, `Failed to connect to the Nostr relay at ${config.relayDomain}.`));
+				else {
+					await new Promise((resolve) => {
+						const retryDelayMs = getNextRetryDelayMs();
+						retryWaitTimeoutId = window.setTimeout(resolve, retryDelayMs);
+					});
+					attemptSocketConnection();
+				}
+			};
+			const handleMessage = async (evt) => {
+				let msg;
+				try {
+					msg = JSON.parse(evt.data);
+					if (!Array.isArray(msg)) throw new Error();
+				} catch {
+					reject(new SolanaMobileWalletAdapterError(SolanaMobileWalletAdapterErrorCode.ERROR_ILLEGAL_TRANSPORT_STATE, "Invalid Nostr message received: " + evt.data));
+					doClose();
+					return;
+				}
+				const type = msg[0];
+				if (type === "CLOSED") disposeSocket();
+				else if (type === "EVENT") {
+					const event = msg[2];
+					if (!event || !verifyNostrEvent(event)) return;
+					switch (state.__type) {
+						case "subscribed": {
+							if (event.content.length !== 0) {
+								reject(new SolanaMobileWalletAdapterError(SolanaMobileWalletAdapterErrorCode.ERROR_ILLEGAL_TRANSPORT_STATE, "Encountered unexpected message while awaiting reflection"));
+								doClose();
+								return;
+							}
+							const walletNostrPubkey = event.pubkey;
+							const ecdhKeypair = await generateECDHKeypair();
+							const helloReq = await createHelloReq(ecdhKeypair.publicKey, associationKeypair.privateKey);
+							const base64Content = fromUint8Array(helloReq);
+							sendNostrEvent(base64Content, walletNostrPubkey);
+							state = {
+								__type: "hello_req_sent",
+								associationPublicKey: associationKeypair.publicKey,
+								ecdhPrivateKey: ecdhKeypair.privateKey,
+								walletNostrPubkey
+							};
+							break;
+						}
+						case "hello_req_sent": {
+							if (event.pubkey !== state.walletNostrPubkey) return;
+							if (event.content === "") return;
+							const responseBuffer = toUint8Array(event.content).buffer;
+							const sharedSecret = await parseHelloRsp(responseBuffer, state.associationPublicKey, state.ecdhPrivateKey);
+							const sessionPropertiesBuffer = responseBuffer.slice(65);
+							const sessionProperties = sessionPropertiesBuffer.byteLength !== 0 ? await (async () => {
+								const sequenceNumber = getSequenceNumberFromByteArray(sessionPropertiesBuffer.slice(0, 4));
+								if (sequenceNumber !== lastKnownInboundSequenceNumber + 1) {
+									reject(new SolanaMobileWalletAdapterError(SolanaMobileWalletAdapterErrorCode.ERROR_ILLEGAL_TRANSPORT_STATE, "Encrypted message has invalid sequence number"));
+									doClose();
+									return { protocol_version: "v1" };
+								}
+								lastKnownInboundSequenceNumber = sequenceNumber;
+								return parseSessionProps(sessionPropertiesBuffer, sharedSecret);
+							})() : { protocol_version: "legacy" };
+							state = {
+								__type: "connected",
+								sharedSecret,
+								sessionProperties,
+								walletNostrPubkey: state.walletNostrPubkey
+							};
+							const wallet = createMobileWalletProxy(sessionProperties.protocol_version, async (method, params) => {
+								const id = nextJsonRpcMessageId++;
+								const binaryMsg = await encryptJsonRpcMessage({
+									id,
+									jsonrpc: "2.0",
+									method,
+									params: params ?? {}
+								}, sharedSecret);
+								sendNostrEvent(fromUint8Array(binaryMsg), state.walletNostrPubkey);
+								return new Promise((resolve, reject) => {
+									jsonRpcResponsePromises[id] = {
+										resolve(result) {
+											switch (method) {
+												case "authorize":
+												case "reauthorize": {
+													const { wallet_uri_base } = result;
+													if (wallet_uri_base != null) try {
+														assertSecureEndpointSpecificURI(wallet_uri_base);
+													} catch (e) {
+														reject(e);
+														return;
+													}
+													break;
+												}
+											}
+											resolve(result);
+										},
+										reject
+									};
+								});
+							});
+							sessionEstablished = true;
+							try {
+								resolve(wallet);
+							} catch (e) {
+								reject(e);
+							}
+							break;
+						}
+						case "connected":
+							if (event.pubkey !== state.walletNostrPubkey) return;
+							if (event.content === "") return;
+							try {
+								const responseBuffer = toUint8Array(event.content).buffer;
+								const sequenceNumber = getSequenceNumberFromByteArray(responseBuffer.slice(0, 4));
+								if (sequenceNumber !== lastKnownInboundSequenceNumber + 1) throw new SolanaMobileWalletAdapterError(SolanaMobileWalletAdapterErrorCode.ERROR_ILLEGAL_TRANSPORT_STATE, "Encrypted message has invalid sequence number");
+								lastKnownInboundSequenceNumber = sequenceNumber;
+								const jsonRpcMessage = await decryptJsonRpcMessage(responseBuffer, state.sharedSecret);
+								const responsePromise = jsonRpcResponsePromises[jsonRpcMessage.id];
+								delete jsonRpcResponsePromises[jsonRpcMessage.id];
+								responsePromise.resolve(jsonRpcMessage.result);
+							} catch (e) {
+								if (e instanceof SolanaMobileWalletAdapterProtocolError) {
+									const responsePromise = jsonRpcResponsePromises[e.jsonRpcMessageId];
+									delete jsonRpcResponsePromises[e.jsonRpcMessageId];
+									responsePromise.reject(e);
+								} else throw e;
+							}
+					}
+				}
+			};
+			handleForceClose = () => {
+				socket.removeEventListener("message", handleMessage);
+				disposeSocket();
+				if (!sessionEstablished) reject(new SolanaMobileWalletAdapterError(SolanaMobileWalletAdapterErrorCode.ERROR_SESSION_CLOSED, `The wallet session was closed before connection.`, { closeEvent: new CloseEvent("socket was closed before connection") }));
+			};
+			let disposeSocket;
+			let retryWaitTimeoutId;
+			const attemptSocketConnection = () => {
+				if (disposeSocket) disposeSocket();
+				state = {
+					__type: "connecting",
+					associationKeypair
+				};
+				socket = new WebSocket(webSocketURL);
+				socket.addEventListener("open", handleOpen);
+				socket.addEventListener("close", handleClose);
+				socket.addEventListener("error", handleError);
+				socket.addEventListener("message", handleMessage);
+				disposeSocket = () => {
+					window.clearTimeout(retryWaitTimeoutId);
+					socket.removeEventListener("open", handleOpen);
+					socket.removeEventListener("close", handleClose);
+					socket.removeEventListener("error", handleError);
+					socket.removeEventListener("message", handleMessage);
+				};
+			};
+			attemptSocketConnection();
+		})
+	};
+	if (config.connectionType == "local") return scenario;
+	else return {
+		...scenario,
+		associationUrl
+	};
+}
 //#endregion
-export { SolanaCloneAuthorization, SolanaMobileWalletAdapterError, SolanaMobileWalletAdapterErrorCode, SolanaMobileWalletAdapterProtocolError, SolanaMobileWalletAdapterProtocolErrorCode, SolanaSignInWithSolana, SolanaSignTransactions, startRemoteScenario, startScenario, transact };
+export { NOSTR_EVENT_KIND_MWA, SolanaCloneAuthorization, SolanaMobileWalletAdapterError, SolanaMobileWalletAdapterErrorCode, SolanaMobileWalletAdapterProtocolError, SolanaMobileWalletAdapterProtocolErrorCode, SolanaSignInWithSolana, SolanaSignTransactions, createNostrEvent, deriveSessionIdentifier, generateNostrKeypair, startNostrScenario, startRemoteScenario, startScenario, transact, verifyNostrEvent };
 
 //# sourceMappingURL=index.browser.js.map