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

package/lib/cjs/index.js

@@ -1,5 +1,8 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-let _solana_codecs_strings = require("@solana/codecs-strings");
+const require_encoding = require("./chunks/encoding.js");
+let _noble_curves_secp256k1_js = require("@noble/curves/secp256k1.js");
+let _noble_hashes_sha2_js = require("@noble/hashes/sha2.js");
+let _noble_hashes_utils_js = require("@noble/hashes/utils.js");
 let _solana_wallet_standard_util = require("@solana/wallet-standard-util");
 //#region src/errors.ts
 const SolanaMobileWalletAdapterErrorCode = {
@@ -13,7 +16,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;
@@ -48,17 +52,55 @@ var SolanaMobileWalletAdapterProtocolError = class extends Error {
 	}
 };
 //#endregion
-//#region src/base64Utils.ts
-function encode(input) {
-	return window.btoa(input);
+//#region src/nostr.ts
+const NOSTR_EVENT_KIND_MWA = 20012;
+function generateNostrKeypair() {
+	const privateKey = _noble_curves_secp256k1_js.schnorr.utils.randomSecretKey();
+	return {
+		privateKey,
+		publicKey: (0, _noble_hashes_utils_js.bytesToHex)(_noble_curves_secp256k1_js.schnorr.getPublicKey(privateKey))
+	};
+}
+async function deriveSessionIdentifier(associationPublicKey) {
+	const rawKey = await crypto.subtle.exportKey("raw", associationPublicKey);
+	const hash = (0, _noble_hashes_sha2_js.sha256)(new Uint8Array(rawKey));
+	return (0, _noble_hashes_utils_js.bytesToHex)(hash);
+}
+function serializeEvent(pubkey, createdAt, kind, tags, content) {
+	return JSON.stringify([
+		0,
+		pubkey,
+		createdAt,
+		kind,
+		tags,
+		content
+	]);
 }
-function fromUint8Array$1(byteArray, urlsafe) {
-	const base64 = window.btoa(String.fromCharCode.call(null, ...byteArray));
-	if (urlsafe) return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
-	else return base64;
+function computeEventId(pubkey, createdAt, kind, tags, content) {
+	const serialized = serializeEvent(pubkey, createdAt, kind, tags, content);
+	return (0, _noble_hashes_utils_js.bytesToHex)((0, _noble_hashes_sha2_js.sha256)(new TextEncoder().encode(serialized)));
 }
-function toUint8Array(base64EncodedByteArray) {
-	return new Uint8Array(window.atob(base64EncodedByteArray).split("").map((c) => c.charCodeAt(0)));
+function createNostrEvent(kind, content, tags, privateKey) {
+	const pubkey = (0, _noble_hashes_utils_js.bytesToHex)(_noble_curves_secp256k1_js.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: (0, _noble_hashes_utils_js.bytesToHex)(_noble_curves_secp256k1_js.schnorr.sign((0, _noble_hashes_utils_js.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 _noble_curves_secp256k1_js.schnorr.verify((0, _noble_hashes_utils_js.hexToBytes)(event.sig), (0, _noble_hashes_utils_js.hexToBytes)(event.id), (0, _noble_hashes_utils_js.hexToBytes)(event.pubkey));
+	} catch {
+		return false;
+	}
 }
 //#endregion
 //#region src/createHelloReq.ts
@@ -74,20 +116,12 @@ async function createHelloReq(ecdhPublicKey, associationKeypairPrivateKey) {
 	return response;
 }
 //#endregion
-//#region src/base58Utils.ts
-function fromUint8Array(byteArray) {
-	return (0, _solana_codecs_strings.getBase58Decoder)().decode(byteArray);
-}
-function base64ToBase58(base64EncodedString) {
-	return fromUint8Array(toUint8Array(base64EncodedString));
-}
-//#endregion
 //#region src/createSIWSMessage.ts
 function createSIWSMessage(payload) {
 	return (0, _solana_wallet_standard_util.createSignInMessageText)(payload);
 }
 function createSIWSMessageBase64Url(payload) {
-	return encode(createSIWSMessage(payload)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+	return require_encoding.encode(createSIWSMessage(payload)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
 }
 //#endregion
 //#region src/types.ts
@@ -160,9 +194,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;
@@ -178,9 +210,7 @@ function handleMobileWalletRequest(methodName, methodParams, protocolVersion) {
 						identity
 					};
 					break;
-				default:
-					method = "authorize";
-					break;
+				default: method = "authorize";
 			}
 			break;
 		}
@@ -227,14 +257,15 @@ async function signInFallback(signInPayload, authorizationResult, protocolReques
 	const siwsMessage = createSIWSMessageBase64Url({
 		...signInPayload,
 		domain,
-		address: base64ToBase58(address)
+		address: require_encoding.base64ToBase58$1(address)
 	});
-	const signedPayload = toUint8Array((await protocolRequestHandler("sign_messages", {
+	const signMessageResult = await protocolRequestHandler("sign_messages", {
 		addresses: [address],
 		payloads: [siwsMessage]
-	})).signed_payloads[0]);
-	const signedMessage = fromUint8Array$1(signedPayload.slice(0, signedPayload.length - 64));
-	const signature = fromUint8Array$1(signedPayload.slice(signedPayload.length - 64));
+	});
+	const signedPayload = require_encoding.toUint8Array(signMessageResult.signed_payloads[0]);
+	const signedMessage = require_encoding.fromUint8Array(signedPayload.slice(0, signedPayload.length - 64));
+	const signature = require_encoding.fromUint8Array(signedPayload.slice(signedPayload.length - 64));
 	return {
 		address,
 		signed_message: signedMessage.length == 0 ? siwsMessage : signedMessage,
@@ -254,7 +285,7 @@ async function encryptMessage(plaintext, sequenceNumber, sharedSecret) {
 	const sequenceNumberVector = createSequenceNumberVector(sequenceNumber);
 	const initializationVector = new Uint8Array(INITIALIZATION_VECTOR_BYTES);
 	crypto.getRandomValues(initializationVector);
-	const ciphertext = await crypto.subtle.encrypt(getAlgorithmParams(sequenceNumberVector, initializationVector), sharedSecret, new TextEncoder().encode(plaintext));
+	const ciphertext = await crypto.subtle.encrypt(getAlgorithmParams(sequenceNumberVector, initializationVector), sharedSecret, require_encoding.utf8ToUint8Array(plaintext));
 	const response = new Uint8Array(sequenceNumberVector.byteLength + initializationVector.byteLength + ciphertext.byteLength);
 	response.set(new Uint8Array(sequenceNumberVector), 0);
 	response.set(new Uint8Array(initializationVector), sequenceNumberVector.byteLength);
@@ -263,10 +294,10 @@ 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 getUtf8Decoder().decode(plaintextBuffer);
+	return require_encoding.utf8FromUint8Array(new Uint8Array(plaintextBuffer));
 }
 function getAlgorithmParams(sequenceNumber, initializationVector) {
 	return {
@@ -276,11 +307,6 @@ function getAlgorithmParams(sequenceNumber, initializationVector) {
 		tagLength: 128
 	};
 }
-let _utf8Decoder;
-function getUtf8Decoder() {
-	if (_utf8Decoder === void 0) _utf8Decoder = new TextDecoder("utf-8");
-	return _utf8Decoder;
-}
 //#endregion
 //#region src/generateAssociationKeypair.ts
 async function generateAssociationKeypair() {
@@ -298,15 +324,6 @@ async function generateECDHKeypair() {
 	}, false, ["deriveKey", "deriveBits"]);
 }
 //#endregion
-//#region src/arrayBufferToBase64String.ts
-function arrayBufferToBase64String(buffer) {
-	let binary = "";
-	const bytes = new Uint8Array(buffer);
-	const len = bytes.byteLength;
-	for (let ii = 0; ii < len; ii++) binary += String.fromCharCode(bytes[ii]);
-	return window.btoa(binary);
-}
-//#endregion
 //#region src/associationPort.ts
 function getRandomAssociationPort() {
 	return assertAssociationPort(49152 + Math.floor(Math.random() * 16384));
@@ -317,7 +334,7 @@ function assertAssociationPort(port) {
 }
 //#endregion
 //#region src/getStringWithURLUnsafeBase64CharactersReplaced.ts
-function getStringWithURLUnsafeCharactersReplaced(unsafeBase64EncodedString) {
+function getStringWithURLUnsafeBase64CharactersReplaced(unsafeBase64EncodedString) {
 	return unsafeBase64EncodedString.replace(/[/+=]/g, (m) => ({
 		"/": "_",
 		"+": "-",
@@ -344,9 +361,10 @@ 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 = require_encoding.arrayBufferToBase64String(exportedKey);
 	const url = getIntentURL("v1/associate/local", associationURLBase);
-	url.searchParams.set("association", getStringWithURLUnsafeCharactersReplaced(encodedKey));
+	url.searchParams.set("association", getStringWithURLUnsafeBase64CharactersReplaced(encodedKey));
 	url.searchParams.set("port", `${associationPort}`);
 	protocolVersions.forEach((version) => {
 		url.searchParams.set("v", version);
@@ -354,11 +372,24 @@ 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 = require_encoding.arrayBufferToBase64String(exportedKey);
 	const url = getIntentURL("v1/associate/remote", associationURLBase);
-	url.searchParams.set("association", getStringWithURLUnsafeCharactersReplaced(encodedKey));
+	url.searchParams.set("association", getStringWithURLUnsafeBase64CharactersReplaced(encodedKey));
 	url.searchParams.set("reflector", `${hostAuthority}`);
-	url.searchParams.set("id", `${fromUint8Array$1(reflectorId, true)}`);
+	url.searchParams.set("id", `${require_encoding.fromUint8Array(reflectorId, true)}`);
+	protocolVersions.forEach((version) => {
+		url.searchParams.set("v", version);
+	});
+	return url;
+}
+async function getNostrAssociateAndroidIntentURL(associationPublicKey, connectionType, relayDomain, dappNostrPubkey, associationURLBase, protocolVersions = ["v1"]) {
+	const exportedKey = await crypto.subtle.exportKey("raw", associationPublicKey);
+	const encodedKey = require_encoding.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);
 	});
@@ -393,7 +424,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
@@ -424,9 +455,6 @@ const Browser = {
 	Firefox: 0,
 	Other: 1
 };
-function assertUnreachable(x) {
-	return x;
-}
 function getBrowser() {
 	return navigator.userAgent.indexOf("Firefox/") !== -1 ? Browser.Firefox : Browser.Other;
 }
@@ -449,7 +477,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);
@@ -459,8 +487,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;
@@ -470,7 +497,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.");
@@ -481,9 +507,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,
@@ -597,7 +638,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 = {
@@ -610,7 +654,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];
@@ -639,7 +683,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" };
@@ -735,8 +783,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 require_encoding.toUint8Array(message).buffer;
+		} else return await evt.data.arrayBuffer();
 	};
 	const associationUrl = await new Promise((resolve, reject) => {
 		const handleOpen = async () => {
@@ -767,7 +817,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",
@@ -815,10 +869,14 @@ 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$1(binaryMsg));
+						if (encoding == "base64") socket.send(require_encoding.fromUint8Array(binaryMsg));
 						else socket.send(binaryMsg);
 						state = {
 							__type: "hello_req_sent",
@@ -830,7 +888,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];
@@ -849,7 +907,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" };
@@ -866,7 +928,7 @@ async function startRemoteScenario(config) {
 								method,
 								params: params ?? {}
 							}, sharedSecret);
-							if (encoding == "base64") socket.send(fromUint8Array$1(binaryMsg));
+							if (encoding == "base64") socket.send(require_encoding.fromUint8Array(binaryMsg));
 							else socket.send(binaryMsg);
 							return new Promise((resolve, reject) => {
 								jsonRpcResponsePromises[id] = {
@@ -909,7 +971,239 @@ 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 = require_encoding.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 = require_encoding.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(require_encoding.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 = require_encoding.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
+exports.NOSTR_EVENT_KIND_MWA = NOSTR_EVENT_KIND_MWA;
 exports.SolanaCloneAuthorization = SolanaCloneAuthorization;
 exports.SolanaMobileWalletAdapterError = SolanaMobileWalletAdapterError;
 exports.SolanaMobileWalletAdapterErrorCode = SolanaMobileWalletAdapterErrorCode;
@@ -917,8 +1211,13 @@ exports.SolanaMobileWalletAdapterProtocolError = SolanaMobileWalletAdapterProtoc
 exports.SolanaMobileWalletAdapterProtocolErrorCode = SolanaMobileWalletAdapterProtocolErrorCode;
 exports.SolanaSignInWithSolana = SolanaSignInWithSolana;
 exports.SolanaSignTransactions = SolanaSignTransactions;
+exports.createNostrEvent = createNostrEvent;
+exports.deriveSessionIdentifier = deriveSessionIdentifier;
+exports.generateNostrKeypair = generateNostrKeypair;
+exports.startNostrScenario = startNostrScenario;
 exports.startRemoteScenario = startRemoteScenario;
 exports.startScenario = startScenario;
 exports.transact = transact;
+exports.verifyNostrEvent = verifyNostrEvent;
 
 //# sourceMappingURL=index.js.map