@seams/wallet 0.22.0 → 0.24.0

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/message.js

@@ -0,0 +1,60 @@
+import { isPlainObject } from "../shared-ts/src/utils/validation.js";
+import { base64Decode, base64Encode } from "../shared-ts/src/utils/base64.js";
+import { base58Decode } from "../shared-ts/src/utils/base58.js";
+import { serialize } from "../node_modules/borsh/lib/esm/index.js";
+//#region src/externalNear/message.ts
+const messageBrand = Symbol("validated NEP-413 message");
+const utf8StringSchema = { array: { type: "u8" } };
+const messageSchema = { struct: {
+	tag: "u32",
+	message: utf8StringSchema,
+	nonce: { array: {
+		type: "u8",
+		len: 32
+	} },
+	recipient: utf8StringSchema,
+	callbackUrl: { option: utf8StringSchema }
+} };
+function validateMessage(input) {
+	if (!isPlainObject(input) || typeof input.message !== "string" || typeof input.recipient !== "string" || !input.recipient.trim() || !(input.nonce instanceof Uint8Array) || input.nonce.length !== 32 || input.callbackUrl !== void 0 && typeof input.callbackUrl !== "string" || input.state !== void 0 && typeof input.state !== "string") throw new Error("Provide a message, recipient, and 32-byte nonce.");
+	return Object.freeze({
+		[messageBrand]: true,
+		message: input.message,
+		recipient: input.recipient,
+		nonce: new Uint8Array(input.nonce),
+		callbackUrl: input.callbackUrl ?? null,
+		state: input.state ?? null
+	});
+}
+async function parseSignedMessage(raw, connection, message) {
+	if (!isPlainObject(raw) || raw.accountId !== connection.accountId || typeof raw.publicKey !== "string" || !raw.publicKey.startsWith("ed25519:") || typeof raw.signature !== "string" || raw.state !== void 0 && raw.state !== message.state) throw new Error("Message identity does not match the request.");
+	const publicKey = base58Decode(raw.publicKey.slice(8));
+	const signature = base64Decode(raw.signature);
+	if (publicKey.length !== 32 || signature.length !== 64 || base64Encode(signature) !== raw.signature) throw new Error("Invalid NEP-413 key or signature.");
+	const encoder = new TextEncoder();
+	const payload = serialize(messageSchema, {
+		tag: 2 ** 31 + 413,
+		message: encoder.encode(message.message),
+		nonce: message.nonce,
+		recipient: encoder.encode(message.recipient),
+		callbackUrl: message.callbackUrl === null ? null : encoder.encode(message.callbackUrl)
+	});
+	const digest = await crypto.subtle.digest("SHA-256", new Uint8Array(payload));
+	const key = await crypto.subtle.importKey("raw", new Uint8Array(publicKey), "Ed25519", false, ["verify"]);
+	if (!await crypto.subtle.verify("Ed25519", key, signature, digest)) throw new Error("The signature does not match the requested NEP-413 message.");
+	if (message.state !== null) return Object.freeze({
+		accountId: connection.accountId,
+		publicKey: raw.publicKey,
+		signature: raw.signature,
+		state: message.state
+	});
+	return Object.freeze({
+		accountId: connection.accountId,
+		publicKey: raw.publicKey,
+		signature: raw.signature
+	});
+}
+//#endregion
+export { parseSignedMessage, validateMessage };
+
+//# sourceMappingURL=message.js.map

package/dist/esm/externalNear/meteor.js

@@ -0,0 +1,133 @@
+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 {
+	messageSigning = "nep413";
+	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 signMessage(connection, message) {
+		if (this.account?.accountId !== connection.accountId || this.account.network !== connection.network) throw new Error("Meteor account changed.");
+		return this.execute(connection.network, "sign_message", {
+			accountId: connection.accountId,
+			message: message.message,
+			nonce: Array.from(message.nonce),
+			recipient: message.recipient,
+			callbackUrl: message.callbackUrl ?? void 0,
+			state: message.state ?? void 0
+		});
+	}
+	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

package/dist/esm/externalNear/wallets.js

@@ -0,0 +1,33 @@
+//#region src/externalNear/wallets.ts
+function nearWalletName(wallet) {
+	switch (wallet) {
+		case "meteor": return "Meteor Wallet";
+		case "hot": return "HOT Wallet";
+		case "intear": return "Intear Wallet";
+		default: return assertNever(wallet);
+	}
+}
+function assertNever(value) {
+	throw new Error(`Unknown NEAR wallet: ${value}`);
+}
+async function createNearWalletProvider(wallet, rpcUrl) {
+	switch (wallet) {
+		case "meteor": {
+			const { MeteorExtensionProvider } = await import("./meteor.js");
+			return new MeteorExtensionProvider(rpcUrl);
+		}
+		case "hot": {
+			const { HotExtensionProvider } = await import("./hot.js");
+			return new HotExtensionProvider();
+		}
+		case "intear": {
+			const { IntearWalletProvider } = await import("./intear.js");
+			return new IntearWalletProvider();
+		}
+		default: return assertNever(wallet);
+	}
+}
+//#endregion
+export { createNearWalletProvider, nearWalletName };
+
+//# sourceMappingURL=wallets.js.map

package/dist/esm/node_modules/borsh/lib/esm/buffer.js

@@ -0,0 +1,67 @@
+//#region ../../node_modules/borsh/lib/esm/buffer.js
+var EncodeBuffer = function() {
+	function EncodeBuffer() {
+		this.offset = 0;
+		this.buffer_size = 256;
+		this.buffer = new ArrayBuffer(this.buffer_size);
+		this.view = new DataView(this.buffer);
+	}
+	EncodeBuffer.prototype.resize_if_necessary = function(needed_space) {
+		if (this.buffer_size - this.offset < needed_space) {
+			this.buffer_size = Math.max(this.buffer_size * 2, this.buffer_size + needed_space);
+			var new_buffer = new ArrayBuffer(this.buffer_size);
+			new Uint8Array(new_buffer).set(new Uint8Array(this.buffer));
+			this.buffer = new_buffer;
+			this.view = new DataView(new_buffer);
+		}
+	};
+	EncodeBuffer.prototype.get_used_buffer = function() {
+		return new Uint8Array(this.buffer).slice(0, this.offset);
+	};
+	EncodeBuffer.prototype.store_value = function(value, type) {
+		var bSize = type.substring(1);
+		var size = parseInt(bSize) / 8;
+		this.resize_if_necessary(size);
+		var toCall = type[0] === "f" ? "setFloat".concat(bSize) : type[0] === "i" ? "setInt".concat(bSize) : "setUint".concat(bSize);
+		this.view[toCall](this.offset, value, true);
+		this.offset += size;
+	};
+	EncodeBuffer.prototype.store_bytes = function(from) {
+		this.resize_if_necessary(from.length);
+		new Uint8Array(this.buffer).set(new Uint8Array(from), this.offset);
+		this.offset += from.length;
+	};
+	return EncodeBuffer;
+}();
+var DecodeBuffer = function() {
+	function DecodeBuffer(buf) {
+		this.offset = 0;
+		this.buffer_size = buf.length;
+		this.buffer = new ArrayBuffer(buf.length);
+		new Uint8Array(this.buffer).set(buf);
+		this.view = new DataView(this.buffer);
+	}
+	DecodeBuffer.prototype.assert_enough_buffer = function(size) {
+		if (this.offset + size > this.buffer.byteLength) throw new Error("Error in schema, the buffer is smaller than expected");
+	};
+	DecodeBuffer.prototype.consume_value = function(type) {
+		var bSize = type.substring(1);
+		var size = parseInt(bSize) / 8;
+		this.assert_enough_buffer(size);
+		var toCall = type[0] === "f" ? "getFloat".concat(bSize) : type[0] === "i" ? "getInt".concat(bSize) : "getUint".concat(bSize);
+		var ret = this.view[toCall](this.offset, true);
+		this.offset += size;
+		return ret;
+	};
+	DecodeBuffer.prototype.consume_bytes = function(size) {
+		this.assert_enough_buffer(size);
+		var ret = this.buffer.slice(this.offset, this.offset + size);
+		this.offset += size;
+		return ret;
+	};
+	return DecodeBuffer;
+}();
+//#endregion
+export { DecodeBuffer, EncodeBuffer };
+
+//# sourceMappingURL=buffer.js.map

package/dist/esm/node_modules/borsh/lib/esm/deserialize.js

@@ -0,0 +1,94 @@
+import { integers } from "./types.js";
+import { DecodeBuffer } from "./buffer.js";
+(function() {
+	function BorshDeserializer(bufferArray) {
+		this.buffer = new DecodeBuffer(bufferArray);
+	}
+	BorshDeserializer.prototype.decode = function(schema) {
+		return this.decode_value(schema);
+	};
+	BorshDeserializer.prototype.decode_value = function(schema) {
+		if (typeof schema === "string") {
+			if (integers.includes(schema)) return this.decode_integer(schema);
+			if (schema === "string") return this.decode_string();
+			if (schema === "bool") return this.decode_boolean();
+		}
+		if (typeof schema === "object") {
+			if ("option" in schema) return this.decode_option(schema);
+			if ("enum" in schema) return this.decode_enum(schema);
+			if ("array" in schema) return this.decode_array(schema);
+			if ("set" in schema) return this.decode_set(schema);
+			if ("map" in schema) return this.decode_map(schema);
+			if ("struct" in schema) return this.decode_struct(schema);
+		}
+		throw new Error("Unsupported type: ".concat(schema));
+	};
+	BorshDeserializer.prototype.decode_integer = function(schema) {
+		var size = parseInt(schema.substring(1));
+		if (size <= 32 || schema == "f64") return this.buffer.consume_value(schema);
+		return this.decode_bigint(size, schema.startsWith("i"));
+	};
+	BorshDeserializer.prototype.decode_bigint = function(size, signed) {
+		if (signed === void 0) signed = false;
+		var buffer_len = size / 8;
+		var buffer = new Uint8Array(this.buffer.consume_bytes(buffer_len));
+		var bits = buffer.reduceRight(function(r, x) {
+			return r + x.toString(16).padStart(2, "0");
+		}, "");
+		if (signed && buffer[buffer_len - 1]) return BigInt.asIntN(size, BigInt("0x".concat(bits)));
+		return BigInt("0x".concat(bits));
+	};
+	BorshDeserializer.prototype.decode_string = function() {
+		var len = this.decode_integer("u32");
+		var buffer = new Uint8Array(this.buffer.consume_bytes(len));
+		return String.fromCharCode.apply(null, buffer);
+	};
+	BorshDeserializer.prototype.decode_boolean = function() {
+		return this.buffer.consume_value("u8") > 0;
+	};
+	BorshDeserializer.prototype.decode_option = function(schema) {
+		var option = this.buffer.consume_value("u8");
+		if (option === 1) return this.decode_value(schema.option);
+		if (option !== 0) throw new Error("Invalid option ".concat(option));
+		return null;
+	};
+	BorshDeserializer.prototype.decode_enum = function(schema) {
+		var _a;
+		var valueIndex = this.buffer.consume_value("u8");
+		if (valueIndex > schema["enum"].length) throw new Error("Enum option ".concat(valueIndex, " is not available"));
+		var struct = schema["enum"][valueIndex].struct;
+		var key = Object.keys(struct)[0];
+		return _a = {}, _a[key] = this.decode_value(struct[key]), _a;
+	};
+	BorshDeserializer.prototype.decode_array = function(schema) {
+		var result = [];
+		var len = schema.array.len ? schema.array.len : this.decode_integer("u32");
+		for (var i = 0; i < len; ++i) result.push(this.decode_value(schema.array.type));
+		return result;
+	};
+	BorshDeserializer.prototype.decode_set = function(schema) {
+		var len = this.decode_integer("u32");
+		var result = /* @__PURE__ */ new Set();
+		for (var i = 0; i < len; ++i) result.add(this.decode_value(schema.set));
+		return result;
+	};
+	BorshDeserializer.prototype.decode_map = function(schema) {
+		var len = this.decode_integer("u32");
+		var result = /* @__PURE__ */ new Map();
+		for (var i = 0; i < len; ++i) {
+			var key = this.decode_value(schema.map.key);
+			var value = this.decode_value(schema.map.value);
+			result.set(key, value);
+		}
+		return result;
+	};
+	BorshDeserializer.prototype.decode_struct = function(schema) {
+		var result = {};
+		for (var key in schema.struct) result[key] = this.decode_value(schema.struct[key]);
+		return result;
+	};
+	return BorshDeserializer;
+})();
+//#endregion
+
+//# sourceMappingURL=deserialize.js.map

package/dist/esm/node_modules/borsh/lib/esm/index.js

@@ -0,0 +1,13 @@
+import { validate_schema } from "./utils.js";
+import { BorshSerializer } from "./serialize.js";
+import "./deserialize.js";
+//#region ../../node_modules/borsh/lib/esm/index.js
+function serialize(schema, value, validate) {
+	if (validate === void 0) validate = true;
+	if (validate) validate_schema(schema);
+	return new BorshSerializer(validate).encode(value, schema);
+}
+//#endregion
+export { serialize };
+
+//# sourceMappingURL=index.js.map