@seams/wallet 0.21.0 → 0.23.0

package/dist/esm/externalNear/controller.js

@@ -0,0 +1,187 @@
+import { createNearWalletProvider, nearWalletName } from "./wallets.js";
+import { connectedNear } from "./types.js";
+import { executionStatus, parseAccounts, parseSubmission, validateTransaction } from "./boundary.js";
+//#region src/externalNear/controller.ts
+function failure(code, message) {
+	return {
+		ok: false,
+		code,
+		message
+	};
+}
+var ExternalNearController = class {
+	snapshot;
+	enabledWallets;
+	network;
+	rpcUrl;
+	listeners = /* @__PURE__ */ new Set();
+	generation = 0;
+	provider = null;
+	pending = false;
+	constructor(config) {
+		if (config.network !== "mainnet" && config.network !== "testnet") throw new Error("Use mainnet or testnet for the NEAR network.");
+		const url = new URL(config.rpcUrl);
+		if (url.protocol !== "https:" && url.protocol !== "http:") throw new Error("Use an HTTP NEAR RPC URL.");
+		this.network = config.network;
+		this.rpcUrl = config.rpcUrl;
+		this.enabledWallets = normalizeWallets(config.wallets);
+		this.snapshot = Object.freeze({
+			connection: { kind: "disconnected" },
+			busy: false,
+			wallets: this.enabledWallets
+		});
+	}
+	setWallets(wallets) {
+		this.enabledWallets = normalizeWallets(wallets);
+		const connection = this.snapshot.connection;
+		if (connection.kind !== "disconnected" && !this.enabledWallets.includes(connection.wallet)) {
+			this.disconnect();
+			return;
+		}
+		this.publish(connection);
+	}
+	getSnapshot = () => this.snapshot;
+	subscribe = (listener) => {
+		this.listeners.add(listener);
+		return this.unsubscribe.bind(this, listener);
+	};
+	unsubscribe(listener) {
+		this.listeners.delete(listener);
+	}
+	publish(connection) {
+		this.snapshot = Object.freeze({
+			connection,
+			busy: this.pending,
+			wallets: this.enabledWallets
+		});
+		for (const listener of this.listeners) listener();
+	}
+	async connect(wallet) {
+		if (!this.enabledWallets.includes(wallet)) return failure("unavailable", "This wallet is disabled for this application.");
+		if (this.pending) return failure("pending_request", "Complete the pending wallet request.");
+		if (wallet === "hot" && this.network !== "mainnet") return failure("unavailable", "HOT Wallet is available on mainnet only.");
+		this.disconnect();
+		this.pending = true;
+		const generation = ++this.generation;
+		this.publish({
+			kind: "connecting",
+			wallet
+		});
+		try {
+			if (generation !== this.generation) return failure("connection_changed", "Wallet selection changed.");
+			const provider = await createNearWalletProvider(wallet, this.rpcUrl);
+			if (generation !== this.generation) {
+				provider.dispose();
+				return failure("connection_changed", "Wallet selection changed.");
+			}
+			this.provider = provider;
+			const accounts = parseAccounts(await provider.connect(this.network));
+			if (generation !== this.generation) return failure("connection_changed", "Wallet selection changed.");
+			const accountId = accounts[0];
+			if (!accountId) return failure("unavailable", "No wallet account is available.");
+			const connection = connectedNear(wallet, accountId, this.network, generation);
+			this.publish(connection);
+			return {
+				ok: true,
+				value: connection
+			};
+		} catch {
+			if (generation !== this.generation) return failure("connection_changed", "Wallet selection changed.");
+			this.disconnect();
+			return failure("unavailable", `${nearWalletName(wallet)} did not connect. Check the wallet and network, then try again.`);
+		} finally {
+			if (generation === this.generation) {
+				this.pending = false;
+				this.publish(this.snapshot.connection);
+			}
+		}
+	}
+	disconnect() {
+		++this.generation;
+		const provider = this.provider;
+		this.provider = null;
+		this.pending = false;
+		provider?.dispose();
+		this.publish({ kind: "disconnected" });
+	}
+	async sendTransaction(connection, input) {
+		if (this.pending) return failure("pending_request", "Complete the pending wallet request.");
+		if (connection !== this.snapshot.connection || !this.provider) return failure("connection_changed", "Reconnect the wallet before signing.");
+		const provider = this.provider;
+		const generation = this.generation;
+		let transaction;
+		try {
+			transaction = validateTransaction(input);
+		} catch {
+			return failure("invalid_input", "Provide a valid transfer or function call.");
+		}
+		this.pending = true;
+		this.publish(connection);
+		let dispatched = false;
+		try {
+			const accounts = parseAccounts(await provider.accounts(this.network));
+			if (connection !== this.snapshot.connection || !accounts.includes(connection.accountId)) return failure("connection_changed", "Wallet account changed. Reconnect before signing.");
+			dispatched = true;
+			return {
+				ok: true,
+				value: parseSubmission(await provider.send(connection, transaction), connection)
+			};
+		} catch {
+			return dispatched ? failure("submission_unknown", "Submission is unknown. Check wallet activity before sending again.") : failure("unavailable", "Wallet account is unavailable.");
+		} finally {
+			if (generation === this.generation) {
+				this.pending = false;
+				this.publish(this.snapshot.connection);
+			}
+		}
+	}
+	async checkOutcome(submission) {
+		if (submission.network !== this.network) return {
+			kind: "unresolved",
+			submission
+		};
+		try {
+			const response = await fetch(this.rpcUrl, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				signal: AbortSignal.timeout(15e3),
+				body: JSON.stringify({
+					jsonrpc: "2.0",
+					id: "external-near",
+					method: "tx",
+					params: {
+						tx_hash: submission.hash,
+						sender_account_id: submission.accountId,
+						wait_until: "FINAL"
+					}
+				})
+			});
+			if (!response.ok) return {
+				kind: "unresolved",
+				submission
+			};
+			return {
+				kind: executionStatus(await response.json(), submission),
+				submission
+			};
+		} catch {
+			return {
+				kind: "unresolved",
+				submission
+			};
+		}
+	}
+};
+function normalizeWallets(wallets) {
+	if (!Array.isArray(wallets)) throw new Error("Provide an explicit wallet list.");
+	const enabled = [];
+	for (const wallet of wallets) {
+		nearWalletName(wallet);
+		if (!enabled.includes(wallet)) enabled.push(wallet);
+	}
+	return Object.freeze(enabled);
+}
+//#endregion
+export { ExternalNearController };
+
+//# sourceMappingURL=controller.js.map

package/dist/esm/externalNear/hot.js

@@ -0,0 +1,40 @@
+import { isObject } from "../shared-ts/src/utils/validation.js";
+import { externalNearAction } from "./actions.js";
+//#region src/externalNear/hot.ts
+/** Direct extension API documented by hot-dao/hot-sdk-js. No iframe fallback. */
+var HotExtensionProvider = class {
+	lifecycle = "active";
+	transport = Reflect.get(window, "hotExtension");
+	async request(method, params) {
+		if (this.lifecycle !== "active" || !isObject(this.transport) || Reflect.get(window, "hotExtension") !== this.transport) throw new Error("Install HOT Wallet or reconnect after the extension changes.");
+		const request = this.transport.request;
+		if (typeof request !== "function") throw new Error("HOT extension API is unavailable.");
+		return Reflect.apply(request, this.transport, [method, params]);
+	}
+	async connect(network) {
+		if (network !== "mainnet") throw new Error("HOT testnet support is not qualified.");
+		const response = await this.request("near:signIn", {});
+		if (!isObject(response)) throw new Error("Invalid HOT account response.");
+		return [response.accountId];
+	}
+	async accounts(network) {
+		return this.connect(network);
+	}
+	async send(connection, transaction) {
+		if (connection.network !== "mainnet") throw new Error("HOT requires mainnet.");
+		const response = await this.request("near:signAndSendTransactions", { transactions: [{
+			signerId: connection.accountId,
+			receiverId: transaction.receiverId,
+			actions: transaction.actions.map(externalNearAction)
+		}] });
+		if (!isObject(response)) throw new Error("Invalid HOT transaction response.");
+		return response.transactions;
+	}
+	dispose() {
+		this.lifecycle = "disposed";
+	}
+};
+//#endregion
+export { HotExtensionProvider };
+
+//# sourceMappingURL=hot.js.map

package/dist/esm/externalNear/index.js

@@ -0,0 +1,3 @@
+import { nearWalletName } from "./wallets.js";
+import { ExternalNearController } from "./controller.js";
+export { ExternalNearController, nearWalletName };

package/dist/esm/externalNear/intear.js

@@ -0,0 +1,109 @@
+import { isPlainObject } from "../shared-ts/src/utils/validation.js";
+import { base58Encode } from "../shared-ts/src/utils/base58.js";
+import { isValidAccountId } from "../shared-ts/src/utils/near.js";
+import { externalNearAction } from "./actions.js";
+import { IntearPopup } from "./intearPopup.js";
+//#region src/externalNear/intear.ts
+/** The ephemeral key authenticates requests only. It is never installed on chain. */
+async function authenticate(key, payload) {
+	const nonce = Date.now();
+	const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(`${nonce}|${payload}`));
+	return {
+		nonce,
+		signature: `ed25519:${base58Encode(await crypto.subtle.sign("Ed25519", key.privateKey, digest))}`
+	};
+}
+var IntearWalletProvider = class {
+	lifecycle = "active";
+	popup = null;
+	session = null;
+	async connect(network) {
+		if (this.lifecycle !== "active") throw new Error("Intear connection disposed.");
+		const popup = new IntearPopup("/connect", "connected");
+		this.popup = popup;
+		const response = popup.result;
+		response.catch(ignorePopupFailure);
+		try {
+			const key = await crypto.subtle.generateKey({ name: "Ed25519" }, false, ["sign", "verify"]);
+			const publicKey = `ed25519:${base58Encode(await crypto.subtle.exportKey("raw", key.publicKey))}`;
+			const message = "{}";
+			const proof = await authenticate(key, message);
+			popup.send({
+				type: "signIn",
+				data: {
+					publicKey,
+					networkId: network,
+					message,
+					nonce: proof.nonce,
+					signature: proof.signature,
+					version: "V3",
+					actualOrigin: location.origin
+				}
+			});
+			const result = await response;
+			if (!isPlainObject(result) || !isValidAccountId(result.accountId) || result.functionCallKeyAdded !== false || result.useBridge !== false || result.walletUrl !== "https://wallet.intear.tech") throw new Error("Unsupported Intear connection response.");
+			this.session = {
+				accountId: result.accountId,
+				network,
+				key,
+				publicKey
+			};
+			return [result.accountId];
+		} catch (error) {
+			popup.fail(/* @__PURE__ */ new Error("Intear connection failed."));
+			throw error;
+		} finally {
+			if (this.popup === popup) this.popup = null;
+		}
+	}
+	async accounts(network) {
+		return this.session?.network === network ? [this.session.accountId] : [];
+	}
+	async send(connection, transaction) {
+		const session = this.session;
+		if (!session || session.network !== connection.network || session.accountId !== connection.accountId) throw new Error("Reconnect Intear.");
+		if (this.lifecycle !== "active") throw new Error("Intear connection disposed.");
+		const popup = new IntearPopup("/send-transactions", "sent");
+		this.popup = popup;
+		const response = popup.result;
+		response.catch(ignorePopupFailure);
+		try {
+			const transactions = JSON.stringify([{
+				signerId: session.accountId,
+				receiverId: transaction.receiverId,
+				actions: transaction.actions.map(externalNearAction)
+			}]);
+			const proof = await authenticate(session.key, transactions);
+			popup.send({
+				type: "signAndSendTransactions",
+				data: {
+					accountId: session.accountId,
+					publicKey: session.publicKey,
+					nonce: proof.nonce,
+					signature: proof.signature,
+					transactions,
+					mode: "Send"
+				}
+			});
+			const result = await response;
+			if (!isPlainObject(result)) throw new Error("Invalid Intear outcome.");
+			return result.outcomes;
+		} catch (error) {
+			popup.fail(/* @__PURE__ */ new Error("Intear transaction outcome is unknown."));
+			throw error;
+		} finally {
+			if (this.popup === popup) this.popup = null;
+		}
+	}
+	dispose() {
+		this.lifecycle = "disposed";
+		this.popup?.fail(/* @__PURE__ */ new Error("Intear disconnected. Check wallet activity for pending submissions."));
+		this.popup = null;
+		this.session = null;
+	}
+};
+function ignorePopupFailure() {}
+//#endregion
+export { IntearWalletProvider };
+
+//# sourceMappingURL=intear.js.map

package/dist/esm/externalNear/intearPopup.js

@@ -0,0 +1,83 @@
+import { isPlainObject } from "../shared-ts/src/utils/validation.js";
+//#region src/externalNear/intearPopup.ts
+const INTEAR_ORIGIN = "https://wallet.intear.tech";
+/** One popup per request; origin and WindowProxy together bind every response. */
+var IntearPopup = class {
+	popup;
+	sent = false;
+	settled = false;
+	ready = false;
+	payload = null;
+	resolveResult = ignoreResult;
+	rejectResult = ignoreError;
+	interval;
+	timeout;
+	result;
+	constructor(path, successType) {
+		this.successType = successType;
+		this.popup = window.open(`${INTEAR_ORIGIN}${path}`, "_blank", "popup,width=420,height=720");
+		this.result = new Promise(this.captureResolvers);
+		window.addEventListener("message", this.receive);
+		this.interval = setInterval(this.checkClosed, 250);
+		this.timeout = setTimeout(this.expire, 12e4);
+		if (!this.popup) this.fail(/* @__PURE__ */ new Error("Allow popups to connect Intear Wallet."));
+	}
+	captureResolvers = (resolve, reject) => {
+		this.resolveResult = resolve;
+		this.rejectResult = reject;
+	};
+	send(payload) {
+		this.payload = payload;
+		this.dispatch();
+	}
+	dispatch() {
+		if (!this.settled && this.ready && !this.sent && this.payload && this.popup) {
+			this.sent = true;
+			this.popup.postMessage(this.payload, INTEAR_ORIGIN);
+		}
+	}
+	receive = (event) => {
+		if (this.settled || event.origin !== "https://wallet.intear.tech" || event.source !== this.popup || !isPlainObject(event.data)) return;
+		if (event.data.type === "ready") {
+			this.ready = true;
+			this.dispatch();
+			return;
+		}
+		if (!this.sent) return;
+		if (event.data.type === "error") {
+			this.fail(/* @__PURE__ */ new Error("Intear declined the request."));
+			return;
+		}
+		if (event.data.type === this.successType) {
+			this.cleanup();
+			this.resolveResult(event.data);
+		}
+	};
+	checkClosed = () => {
+		if (this.popup?.closed) this.fail(/* @__PURE__ */ new Error("Intear popup closed."));
+	};
+	expire = () => {
+		this.fail(/* @__PURE__ */ new Error("Intear request timed out."));
+	};
+	fail(error) {
+		if (!this.settled) {
+			this.cleanup();
+			this.rejectResult(error);
+		}
+	}
+	cleanup() {
+		this.settled = true;
+		clearInterval(this.interval);
+		clearTimeout(this.timeout);
+		window.removeEventListener("message", this.receive);
+		this.popup?.close();
+		this.popup = null;
+		this.payload = null;
+	}
+};
+function ignoreResult(_value) {}
+function ignoreError(_error) {}
+//#endregion
+export { INTEAR_ORIGIN, IntearPopup };
+
+//# sourceMappingURL=intearPopup.js.map

package/dist/esm/externalNear/meteor.js

@@ -0,0 +1,121 @@
+import { isPlainObject } from "../shared-ts/src/utils/validation.js";
+import { base64Encode } from "../shared-ts/src/utils/base64.js";
+import { base58Decode } from "../shared-ts/src/utils/base58.js";
+import { isValidAccountId } from "../shared-ts/src/utils/near.js";
+import { ActionType, toActionArgsWasm } from "../shared-ts/src/near/actions.js";
+import { serialize } from "../node_modules/borsh/lib/esm/index.js";
+import { MeteorRequest, meteorTransportFromWindow } from "./meteorRequest.js";
+//#region src/externalNear/meteor.ts
+const transactionSchema = { struct: {
+	signerId: "string",
+	publicKey: { struct: {
+		keyType: "u8",
+		data: { array: {
+			type: "u8",
+			len: 32
+		} }
+	} },
+	nonce: "u64",
+	receiverId: "string",
+	blockHash: { array: {
+		type: "u8",
+		len: 32
+	} },
+	actions: { array: { type: { enum: [
+		{ struct: { createAccount: { struct: {} } } },
+		{ struct: { deployContract: { struct: { code: { array: { type: "u8" } } } } } },
+		{ struct: { functionCall: { struct: {
+			methodName: "string",
+			args: { array: { type: "u8" } },
+			gas: "u64",
+			deposit: "u128"
+		} } } },
+		{ struct: { transfer: { struct: { deposit: "u128" } } } }
+	] } } }
+} };
+function meteorAction(action) {
+	const value = toActionArgsWasm(action);
+	switch (value.action_type) {
+		case ActionType.Transfer: return { transfer: { deposit: BigInt(value.deposit) } };
+		case ActionType.FunctionCall: return { functionCall: {
+			methodName: value.method_name,
+			args: new TextEncoder().encode(value.args),
+			gas: BigInt(value.gas),
+			deposit: BigInt(value.deposit)
+		} };
+		default: throw new Error("Unsupported external NEAR action.");
+	}
+}
+var MeteorExtensionProvider = class {
+	lifecycle = "active";
+	transport = meteorTransportFromWindow();
+	request = null;
+	account = null;
+	constructor(rpcUrl) {
+		this.rpcUrl = rpcUrl;
+	}
+	async execute(network, action, inputs) {
+		if (this.lifecycle !== "active") throw new Error("Meteor connection disposed.");
+		const request = new MeteorRequest(this.transport, network, action, inputs);
+		this.request = request;
+		try {
+			return await request.result;
+		} finally {
+			if (this.request === request) this.request = null;
+		}
+	}
+	async connect(network) {
+		const response = await this.execute(network, "login", { methods: [] });
+		if (!isPlainObject(response) || !isValidAccountId(response.accountId)) throw new Error("Invalid Meteor account.");
+		this.account = {
+			accountId: response.accountId,
+			network
+		};
+		return [response.accountId];
+	}
+	async accounts(network) {
+		return this.account?.network === network ? [this.account.accountId] : [];
+	}
+	async send(connection, transaction) {
+		if (this.account?.accountId !== connection.accountId || this.account.network !== connection.network) throw new Error("Meteor account changed.");
+		const response = await fetch(this.rpcUrl, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			signal: AbortSignal.timeout(15e3),
+			body: JSON.stringify({
+				jsonrpc: "2.0",
+				id: "meteor-block",
+				method: "block",
+				params: { finality: "final" }
+			})
+		});
+		const block = await response.json();
+		if (!response.ok || !isPlainObject(block) || !isPlainObject(block.result) || !isPlainObject(block.result.header) || typeof block.result.header.hash !== "string") throw new Error("Cannot read NEAR block.");
+		const blockHash = base58Decode(block.result.header.hash);
+		if (blockHash.length !== 32) throw new Error("Invalid NEAR block hash.");
+		const encoded = serialize(transactionSchema, {
+			signerId: connection.accountId,
+			publicKey: {
+				keyType: 0,
+				data: new Uint8Array(32)
+			},
+			nonce: 0n,
+			receiverId: transaction.receiverId,
+			blockHash,
+			actions: transaction.actions.map(meteorAction)
+		});
+		const outcome = await this.execute(connection.network, "sign", { transactions: base64Encode(encoded) });
+		if (!isPlainObject(outcome)) throw new Error("Invalid Meteor response.");
+		return outcome.executionOutcomes;
+	}
+	dispose() {
+		this.lifecycle = "disposed";
+		this.request?.cancel();
+		this.request = null;
+		this.account = null;
+	}
+};
+//#endregion
+export { MeteorExtensionProvider };
+
+//# sourceMappingURL=meteor.js.map

package/dist/esm/externalNear/meteorRequest.js

@@ -0,0 +1,117 @@
+import { isFunction, isPlainObject } from "../shared-ts/src/utils/validation.js";
+//#region src/externalNear/meteorRequest.ts
+function meteorTransportFromWindow() {
+	const raw = Reflect.get(window, "meteorComV2");
+	if (!isPlainObject(raw) || !isFunction(raw.sendMessageDataAndRespond)) throw new Error("Meteor extension is not ready.");
+	const method = raw.sendMessageDataAndRespond;
+	return { sendMessageDataAndRespond: callMeteor.bind(null, raw, method) };
+}
+async function callMeteor(provider, method, request) {
+	if (Reflect.get(window, "meteorComV2") !== provider || Reflect.get(provider, "sendMessageDataAndRespond") !== method) throw new Error("Meteor transport changed.");
+	return Reflect.apply(method, provider, [request]);
+}
+/** Heartbeats carry one request ID; they never create a second signing request. */
+var MeteorRequest = class {
+	uid = crypto.randomUUID();
+	state = "initializing";
+	resolve = ignoreResult;
+	reject = ignoreError;
+	timer;
+	deadline;
+	result;
+	constructor(transport, network, actionType, inputs) {
+		this.transport = transport;
+		this.network = network;
+		this.actionType = actionType;
+		this.inputs = inputs;
+		this.result = new Promise(this.capture);
+		this.timer = setInterval(this.poll, 500);
+		this.deadline = setTimeout(this.expire, 12e4);
+		this.poll();
+	}
+	capture = (resolve, reject) => {
+		this.resolve = resolve;
+		this.reject = reject;
+	};
+	poll = async () => {
+		if (this.state === "settled") return;
+		const envelope = {
+			uid: this.uid,
+			network: this.network,
+			actionType: this.actionType,
+			status: this.state,
+			endTags: []
+		};
+		const request = this.state === "initializing" ? {
+			uid: this.uid,
+			network: this.network,
+			actionType: this.actionType,
+			status: this.state,
+			endTags: [],
+			inputs: this.inputs
+		} : envelope;
+		try {
+			const response = await this.transport.sendMessageDataAndRespond(request);
+			this.receive(response);
+		} catch {
+			this.cancel();
+		}
+	};
+	receive(response) {
+		if (this.state === "settled" || response == null) return;
+		if (!isPlainObject(response) || response.uid !== this.uid) return;
+		switch (response.status) {
+			case "attempting_reconnect": {
+				const needsInputs = this.state !== "initializing";
+				this.state = "initializing";
+				if (needsInputs) this.poll();
+				return;
+			}
+			case "connected":
+				this.state = "connected";
+				return;
+			case "initializing": return;
+			case "closed_success":
+				this.finish();
+				this.acknowledge("closed_success");
+				this.resolve(response.payload);
+				return;
+			case "closed_fail":
+			case "closed_window":
+				this.cancel();
+				return;
+			default: this.cancel();
+		}
+	}
+	async acknowledge(status) {
+		try {
+			await this.transport.sendMessageDataAndRespond({
+				uid: this.uid,
+				network: this.network,
+				actionType: this.actionType,
+				status,
+				endTags: []
+			});
+		} catch {}
+	}
+	expire = () => {
+		this.cancel();
+	};
+	cancel() {
+		if (this.state === "settled") return;
+		this.finish();
+		this.acknowledge("disconnected");
+		this.reject(/* @__PURE__ */ new Error("Meteor request ended without a verified outcome."));
+	}
+	finish() {
+		this.state = "settled";
+		clearInterval(this.timer);
+		clearTimeout(this.deadline);
+	}
+};
+function ignoreResult(_value) {}
+function ignoreError(_error) {}
+//#endregion
+export { MeteorRequest, meteorTransportFromWindow };
+
+//# sourceMappingURL=meteorRequest.js.map

package/dist/esm/externalNear/types.js

@@ -0,0 +1,17 @@
+//#region src/externalNear/types.ts
+const connectionBrand = Symbol("external NEAR connection");
+function connectedNear(wallet, accountId, network, generation) {
+	const connection = {
+		kind: "connected",
+		wallet,
+		accountId,
+		network,
+		generation,
+		[connectionBrand]: true
+	};
+	return Object.freeze(connection);
+}
+//#endregion
+export { connectedNear };
+
+//# sourceMappingURL=types.js.map