@seams/wallet 0.22.0 → 0.24.0

package/dist/esm/core/signingEngine/walletCustody/resealedEnvelopeResult.js

@@ -0,0 +1,24 @@
+import { requireRecord } from "../../../shared-ts/src/utils/validation.js";
+import { parseDigestField, parseEnvelopeCiphertextB64u, parseEnvelopeNonceB64u } from "../../../shared-ts/src/passkey-custody/primitives.js";
+import { rejectUnknownFields } from "../../../shared-ts/src/utils/exactRecord.js";
+import "../../../shared-ts/src/passkey-custody/index.js";
+//#region src/core/signingEngine/walletCustody/resealedEnvelopeResult.ts
+function parseResealedEnvelopeResult(raw) {
+	const record = requireRecord(raw, "wallet custody worker reseal");
+	rejectUnknownFields(record, [
+		"nonceB64u",
+		"sealedCustodySecretB64u",
+		"aadHashB64u",
+		"ciphertextDigestB64u"
+	], "wallet custody worker reseal");
+	return {
+		nonceB64u: parseEnvelopeNonceB64u(record.nonceB64u),
+		sealedCustodySecretB64u: parseEnvelopeCiphertextB64u(record.sealedCustodySecretB64u),
+		aadHashB64u: parseDigestField(record.aadHashB64u, "aadHashB64u"),
+		ciphertextDigestB64u: parseDigestField(record.ciphertextDigestB64u, "ciphertextDigestB64u")
+	};
+}
+//#endregion
+export { parseResealedEnvelopeResult };
+
+//# sourceMappingURL=resealedEnvelopeResult.js.map

package/dist/esm/core/signingEngine/walletCustody/unlockedEd25519ExportRootCapability.js

@@ -0,0 +1,74 @@
+import "../../../shared-ts/src/authorization/capabilityKinds.js";
+import "../../../shared-ts/src/passkey-custody/index.js";
+import { requestWalletCustodyCeremonyOperation } from "./ceremonyStepRunner.js";
+//#region src/core/signingEngine/walletCustody/unlockedEd25519ExportRootCapability.ts
+let currentCapability = null;
+let currentCapabilityTransport = null;
+let currentCapabilityExpiryTimer = null;
+function walletCustodyCeremonyTransportFromWorkerContextV1(workerContext) {
+	return { requestOperation: requestWalletCustodyCeremonyOperation.bind(void 0, workerContext) };
+}
+function clearCurrentCapabilityExpiryTimer() {
+	if (currentCapabilityExpiryTimer === null) return;
+	clearTimeout(currentCapabilityExpiryTimer);
+	currentCapabilityExpiryTimer = null;
+}
+function clearCurrentCapabilityReference() {
+	clearCurrentCapabilityExpiryTimer();
+	currentCapability = null;
+	currentCapabilityTransport = null;
+}
+/**
+* The current seed-backed capability for this exact wallet, or undefined when
+* the wallet has none — never a prompt, and never a stale or expired
+* reference. A linked device's Client-root capability is never returned here:
+* seed reseals and auth-method additions cannot use it.
+*/
+function readUnlockedWalletEd25519ExportRootCapabilityV1(walletId) {
+	const capability = readUnlockedEd25519ExportRootLinkingCapabilityV1(walletId);
+	return capability?.kind === "unlocked_wallet_ed25519_export_root_capability_v1" ? capability : void 0;
+}
+/**
+* The current capability a device approving a link seals the export root
+* from, of either kind, for this exact wallet — never a prompt, and never a
+* stale or expired reference.
+*/
+function readUnlockedEd25519ExportRootLinkingCapabilityV1(walletId) {
+	const capability = currentCapability;
+	if (!capability) return void 0;
+	if (capability.walletId !== walletId) return void 0;
+	if (capability.expiresAtMs <= Date.now()) {
+		const transport = currentCapabilityTransport;
+		if (transport) destroyUnlockedWalletEd25519ExportRootCapabilitiesV1(transport, {
+			kind: "capability",
+			capabilityHandleId: capability.capabilityHandleId
+		});
+		else clearCurrentCapabilityReference();
+		return;
+	}
+	return capability;
+}
+/**
+* Destroys worker-held capabilities in the given scope and drops the local
+* reference when it falls inside that scope. Failures to reach the worker are
+* absorbed after dropping the local reference: a torn-down or resetting worker
+* has already lost its handle memory, which is the destruction this call
+* wants.
+*/
+async function destroyUnlockedWalletEd25519ExportRootCapabilitiesV1(transport, scope) {
+	const capability = currentCapability;
+	if (capability !== null && (scope.kind === "all" || scope.kind === "capability" && scope.capabilityHandleId === capability.capabilityHandleId || scope.kind === "wallet" && scope.walletId === capability.walletId || scope.kind === "wallet_session" && scope.walletSessionId === capability.walletSessionId)) clearCurrentCapabilityReference();
+	try {
+		await transport.requestOperation({
+			kind: "walletCustodyCeremony",
+			request: {
+				type: "destroyUnlockedWalletEd25519ExportRootCapabilities",
+				payload: { scope }
+			}
+		});
+	} catch {}
+}
+//#endregion
+export { readUnlockedWalletEd25519ExportRootCapabilityV1, walletCustodyCeremonyTransportFromWorkerContextV1 };
+
+//# sourceMappingURL=unlockedEd25519ExportRootCapability.js.map

package/dist/esm/core/signingEngine/workerManager/workerDeferred.js

@@ -0,0 +1,25 @@
+//#region src/core/signingEngine/workerManager/workerDeferred.ts
+var WorkerDeferred = class {
+	promise;
+	resolveValue = null;
+	rejectValue = null;
+	constructor() {
+		this.promise = new Promise(this.capture);
+	}
+	resolve(value) {
+		if (!this.resolveValue) throw new Error("Worker deferred resolver is unavailable");
+		this.resolveValue(value);
+	}
+	reject(error) {
+		if (!this.rejectValue) throw new Error("Worker deferred rejecter is unavailable");
+		this.rejectValue(error);
+	}
+	capture = (resolve, reject) => {
+		this.resolveValue = resolve;
+		this.rejectValue = reject;
+	};
+};
+//#endregion
+export { WorkerDeferred };
+
+//# sourceMappingURL=workerDeferred.js.map

package/dist/esm/core/ui/messages.js

@@ -69,6 +69,14 @@ const walletMessages = [
 	["Creating your wallet", "ウォレットを作成中"],
 	["Continue with your passkey", "パスキーで続ける"],
 	["Accounts", "アカウント"],
+	["View or add accounts", "アカウントの表示・追加"],
+	["Add EVM account", "EVM アカウントを追加"],
+	["Adding EVM account…", "EVM アカウントを追加中…"],
+	["EVM account added.", "EVM アカウントを追加しました。"],
+	["Account added. Open this wallet again to finish setup.", "アカウントを追加しました。このウォレットを開き直して設定を完了してください。"],
+	["Enable this app’s EVM networks with your passkey.", "パスキーでこのアプリの EVM ネットワークを有効にします。"],
+	["Add a passkey in Authentication methods first.", "先に「認証方法」でパスキーを追加してください。"],
+	["The account could not be added. Try again.", "アカウントを追加できませんでした。もう一度お試しください。"],
 	["View accounts on block explorers", "ブロックエクスプローラーでアカウントを表示"],
 	["Export keys", "鍵をエクスポート"],
 	["Export wallet signing keys", "ウォレットの署名鍵をエクスポート"],
@@ -338,8 +346,6 @@ const walletMessages = [
 	["Adding Email OTP…", "メール認証を追加中…"],
 	["Passkey added.", "パスキーを追加しました。"],
 	["Email OTP added.", "メール認証を追加しました。"],
-	["Unlocking wallet management…", "ウォレット管理のロックを解除中…"],
-	["Wallet management unlocked.", "ウォレット管理のロックを解除しました。"],
 	["Checking authentication methods…", "認証方法を確認中…"],
 	["Unable to load authentication methods:", "認証方法を読み込めません："],
 	["Active authentication methods", "有効な認証方法"],
@@ -350,8 +356,13 @@ const walletMessages = [
 	["Add passkey", "パスキーを追加"],
 	["Use a passkey from this device to unlock the wallet.", "このデバイスのパスキーでウォレットのロックを解除します。"],
 	["Add Email OTP", "メール認証を追加"],
-	["Unlock to manage methods", "ロックを解除して認証方法を管理"],
-	["Confirm your current authentication method to add or remove methods.", "認証方法を追加・削除するには、現在の認証方法を確認してください。"],
+	["Add", "追加"],
+	["Use a one-time code from your email to unlock the wallet.", "メールに届くワンタイムコードでウォレットのロックを解除します。"],
+	["Next, confirm with your passkey. Then enter the code that we email to this address.", "次にパスキーで確認します。その後、このアドレスに届くコードを入力してください。"],
+	["Send code", "コードを送信"],
+	["Sending code…", "コードを送信中…"],
+	["Enter a valid email address.", "有効なメールアドレスを入力してください。"],
+	["Codes go to the email address you verified.", "確認済みのメールアドレスにコードを送信します。"],
 	["Transfer", "送金"],
 	["Warnings", "警告"],
 	["No operations", "操作なし"],

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,223 @@
+import { createNearWalletProvider, nearWalletName } from "./wallets.js";
+import { connectedNear } from "./types.js";
+import { executionStatus, parseAccounts, parseSubmission, validateTransaction } from "./boundary.js";
+import { parseSignedMessage, validateMessage } from "./message.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 signMessage(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;
+		if (provider.messageSigning === "unsupported") return failure("unavailable", "This wallet does not support NEP-413 message signing in Seams.");
+		let message;
+		try {
+			message = validateMessage(input);
+		} catch {
+			return failure("invalid_input", "Provide a message, recipient, and 32-byte nonce.");
+		}
+		const generation = this.generation;
+		this.pending = true;
+		this.publish(connection);
+		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.");
+			const raw = await provider.signMessage(connection, message);
+			if (connection !== this.snapshot.connection) return failure("connection_changed", "Wallet selection changed.");
+			const signed = await parseSignedMessage(raw, connection, message);
+			if (connection !== this.snapshot.connection) return failure("connection_changed", "Wallet selection changed.");
+			return {
+				ok: true,
+				value: signed
+			};
+		} catch {
+			if (connection !== this.snapshot.connection) return failure("connection_changed", "Wallet selection changed.");
+			return failure("unavailable", "The wallet did not return a valid NEP-413 message signature.");
+		} finally {
+			if (generation === this.generation) {
+				this.pending = false;
+				this.publish(this.snapshot.connection);
+			}
+		}
+	}
+	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,41 @@
+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 {
+	messageSigning = "unsupported";
+	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,110 @@
+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 {
+	messageSigning = "unsupported";
+	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