@seams/wallet 0.22.0 → 0.23.0

package/THIRD_PARTY_NOTICES.md

@@ -5,7 +5,7 @@ distributed Seams Wallet SDK, server runtime, Wasm, strict Workers, and CLI.
 Dependency license expressions come from their package metadata. Packaged
 license and notice wording is reproduced below with normalized whitespace.
 
-Inventory: 450 dependency records (41 npm, 409 Cargo).
+Inventory: 451 dependency records (42 npm, 409 Cargo).
 
 ## Dependency inventory
 
@@ -446,6 +446,7 @@ Inventory: 450 dependency records (41 npm, 409 Cargo).
 | npm | abitype | 1.2.3 | MIT | awkweb.eth <t@wevm.dev>; jxom.eth <j@wevm.dev> |
 | npm | asn1js | 3.0.7 | BSD-3-Clause | Ryan Hurst rmh@unmitigatedrisk.com; Yury Strozhevsky yury@strozhevsky.com |
 | npm | base-x | 5.0.1 | MIT | Daniel Cousens |
+| npm | borsh | 1.0.0 | Apache-2.0 | Near Inc |
 | npm | bs58 | 6.0.0 | MIT |  |
 | npm | eventemitter3 | 5.0.1 | MIT | Arnout Kazemier |
 | npm | idb | 8.0.3 | ISC | Jake Archibald |
@@ -2767,7 +2768,7 @@ Applies to:
 
 ### 23f18e03dc49df91
 
-Packaged as: LICENSE, LICENSE-MIT
+Packaged as: LICENSE, LICENSE-MIT, LICENSE-MIT.txt
 
 Applies to:
 
@@ -2837,6 +2838,7 @@ Applies to:
 - cargo:zmij@1.0.21
 - cargo:zmij@1.0.23
 - npm:@near-js/types@2.4.0
+- npm:borsh@1.0.0
 
     Permission is hereby granted, free of charge, to any
     person obtaining a copy of this software and associated
@@ -7353,6 +7355,7 @@ Applies to:
 - cargo:borsh@1.6.1
 - cargo:borsh@1.8.0
 - cargo:borsh@1.8.1
+- npm:borsh@1.0.0
 
                                      Apache License
                                Version 2.0, January 2004

package/dist/.build-inputs.sha256

@@ -1 +1 @@
-457a3a44df7bb82ea046daa003a51f06837f317a1ab7bbe92293931ea7e74773
+1338f3f6f35ca0a9209fea6d25a3fa10bac28bba32ba928546abfac7a06b84a3

package/dist/esm/externalNear/actions.js

@@ -0,0 +1,26 @@
+import { ActionType, toActionArgsWasm } from "../shared-ts/src/near/actions.js";
+//#region src/externalNear/actions.ts
+/** Wallet Selector's JSON action format, shared by HOT and Intear. */
+function externalNearAction(action) {
+	const normalized = toActionArgsWasm(action);
+	switch (normalized.action_type) {
+		case ActionType.Transfer: return {
+			type: "Transfer",
+			params: { deposit: normalized.deposit }
+		};
+		case ActionType.FunctionCall: return {
+			type: "FunctionCall",
+			params: {
+				methodName: normalized.method_name,
+				args: JSON.parse(normalized.args),
+				gas: normalized.gas,
+				deposit: normalized.deposit
+			}
+		};
+		default: throw new Error("Unsupported external NEAR action.");
+	}
+}
+//#endregion
+export { externalNearAction };
+
+//# sourceMappingURL=actions.js.map

package/dist/esm/externalNear/boundary.js

@@ -0,0 +1,53 @@
+import { isPlainObject } from "../shared-ts/src/utils/validation.js";
+import { isValidAccountId } from "../shared-ts/src/utils/near.js";
+import { ActionType, toActionArgsWasm } from "../shared-ts/src/near/actions.js";
+import bs58 from "bs58";
+//#region src/externalNear/boundary.ts
+function parseAccounts(raw) {
+	if (!Array.isArray(raw) || raw.length === 0) throw new Error("The wallet has no connected accounts.");
+	const accounts = [];
+	for (const account of raw) {
+		if (!isValidAccountId(account)) throw new Error("The wallet returned an invalid account.");
+		accounts.push(account);
+	}
+	return Object.freeze(accounts);
+}
+function validateTransaction(input) {
+	if (!isValidAccountId(input.receiverId) || input.actions.length === 0) throw new Error("Provide a receiver and at least one action.");
+	for (const action of input.actions) {
+		const normalized = toActionArgsWasm(action);
+		if (normalized.action_type !== ActionType.FunctionCall && normalized.action_type !== ActionType.Transfer) throw new Error("External NEAR supports function calls and transfers.");
+		if (!/^\d+$/.test(normalized.deposit)) throw new Error("Deposit must be an unsigned integer.");
+		if (normalized.action_type === ActionType.FunctionCall && (!/^\d+$/.test(normalized.gas) || BigInt(normalized.gas) === 0n || !normalized.method_name)) throw new Error("Provide a method and positive gas amount.");
+	}
+	return structuredClone(input);
+}
+function parseSubmission(raw, connection) {
+	if (!Array.isArray(raw) || raw.length !== 1) throw new Error("Missing transaction outcome.");
+	const outcome = raw[0];
+	if (!isPlainObject(outcome) || !isPlainObject(outcome.transaction)) throw new Error("Invalid transaction outcome.");
+	const { hash, signer_id } = outcome.transaction;
+	if (typeof hash !== "string" || bs58.decode(hash).length !== 32 || signer_id !== connection.accountId) throw new Error("Transaction identity does not match the request.");
+	return Object.freeze({
+		hash,
+		accountId: connection.accountId,
+		network: connection.network
+	});
+}
+function executionStatus(raw, submission) {
+	if (!isPlainObject(raw) || !isPlainObject(raw.result)) return "unresolved";
+	const result = raw.result;
+	if (!isPlainObject(result.transaction) || result.transaction.hash !== submission.hash || result.transaction.signer_id !== submission.accountId || result.final_execution_status !== "FINAL") return "unresolved";
+	if (!isPlainObject(result.status)) return "unresolved";
+	if ("Failure" in result.status) return "failed";
+	if (!("SuccessValue" in result.status) || !Array.isArray(result.receipts_outcome)) return "unresolved";
+	for (const receipt of result.receipts_outcome) {
+		if (!isPlainObject(receipt) || !isPlainObject(receipt.outcome) || !isPlainObject(receipt.outcome.status)) return "unresolved";
+		if ("Failure" in receipt.outcome.status) return "failed";
+	}
+	return "confirmed";
+}
+//#endregion
+export { executionStatus, parseAccounts, parseSubmission, validateTransaction };
+
+//# sourceMappingURL=boundary.js.map

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