@seams/wallet-server 0.6.2 → 0.7.3

package/dist/esm/core/nearRelayerAccountProvisioning.js

@@ -3,10 +3,14 @@ import { sha256Bytes } from "../shared-ts/src/utils/digests.js";
 import { base58Encode } from "../shared-ts/src/utils/base58.js";
 import "../shared-ts/src/utils/encoders.js";
 import { deriveImplicitNearAccountIdFromEd25519PublicKey, parseImplicitNearAccountId, parseNamedNearAccountId } from "../shared-ts/src/utils/near.js";
+import { coerceNonEmptyString, requireRecordOrArray } from "../shared-ts/src/utils/validation.js";
+import { failure } from "../shared-ts/src/utils/failure.js";
 import { ActionType, validateActionArgsWasm } from "../shared-ts/src/near/actions.js";
 import { errorMessage } from "../shared-ts/src/utils/errors.js";
-import { decodeNearSecretKey, toPublicKeyStringFromSecretKey } from "./nearKeys.js";
-import { MinimalNearClient, NearRpcError, SignedTransaction } from "./rpcClients/near/NearClient.js";
+import { toPublicKeyStringFromSecretKey } from "./nearKeys.js";
+import { SignedTransaction } from "../shared-ts/src/near/nearClient.js";
+import { MinimalNearClient, NearRpcError } from "./rpcClients/near/NearClient.js";
+import { requireFinalizeNearTxFromSignatureOutput, requireSingleUnsignedNearTxBorshOutput, signNearDigestWithSecretKey } from "./authService/nearPrivateKeySigning.js";
 import { threshold_ed25519_build_near_tx_unsigned_borsh, threshold_ed25519_decode_signed_near_tx_borsh, threshold_ed25519_finalize_near_tx_from_signature } from "../wasm/near_signer/pkg/wasm_signer_worker.js";
 import { ensureNearSignerWasm } from "./nearSignerWasmRuntime.js";
 //#region src/core/nearRelayerAccountProvisioning.ts
@@ -26,48 +30,6 @@ const NEAR_IMPLICIT_ACCOUNT_FUND_WAIT_UNTIL = "EXECUTED_OPTIMISTIC";
 * terminal state.
 */
 const NEAR_SPONSORED_ACCOUNT_CREATION_WAIT_UNTIL = "FINAL";
-const ED25519_PKCS8_SEED_PREFIX = Uint8Array.from([
-	48,
-	46,
-	2,
-	1,
-	0,
-	48,
-	5,
-	6,
-	3,
-	43,
-	101,
-	112,
-	4,
-	34,
-	4,
-	32
-]);
-function requireNonEmptyString(value, label) {
-	const text = String(value || "").trim();
-	if (!text) throw new Error(`${label} is required`);
-	return text;
-}
-function requireRecord(value, label) {
-	if (!value || typeof value !== "object") throw new Error(`${label} must be an object`);
-	return value;
-}
-function requireSingleUnsignedNearTxBorshOutput(value) {
-	if (!Array.isArray(value) || value.length !== 1) throw new Error("Expected exactly one unsigned NEAR transaction from signer WASM");
-	const record = requireRecord(value[0], "unsigned NEAR transaction output");
-	return {
-		unsignedTransactionBorshB64u: requireNonEmptyString(record.unsignedTransactionBorshB64u, "unsignedTransactionBorshB64u"),
-		signingDigestB64u: requireNonEmptyString(record.signingDigestB64u, "signingDigestB64u")
-	};
-}
-function requireFinalizeNearTxFromSignatureOutput(value) {
-	const record = requireRecord(value, "finalized NEAR transaction output");
-	return {
-		signedTransactionBorshB64u: requireNonEmptyString(record.signedTransactionBorshB64u, "signedTransactionBorshB64u"),
-		transactionHash: requireNonEmptyString(record.transactionHash, "transactionHash")
-	};
-}
 function requireByteArray(value, label, expectedLength) {
 	if (!Array.isArray(value) || value.some((byte) => !Number.isInteger(byte) || byte < 0 || byte > 255) || expectedLength !== void 0 && value.length !== expectedLength) throw new Error(`${label} must be a${expectedLength ? ` ${expectedLength}-byte` : ""} array`);
 	return value;
@@ -77,33 +39,33 @@ function requireUnsignedIntegerString(value, label) {
 	return String(value);
 }
 function requireDecodedEd25519PublicKey(value, label) {
-	const record = requireRecord(value, label);
+	const record = requireRecordOrArray(value, label);
 	if (record.keyType !== 0) throw new Error(`${label} must be Ed25519`);
 	return `ed25519:${base58Encode(Uint8Array.from(requireByteArray(record.keyData, `${label}.keyData`, 32)))}`;
 }
 function requireDecodedSponsoredNearAccountCreation(value, signedTransactionBorshB64u) {
-	const output = requireRecord(value, "decoded signed NEAR transaction");
-	const transactionHash = requireNonEmptyString(output.transactionHash, "transactionHash");
-	const signed = requireRecord(output.signedTransaction, "signedTransaction");
-	const transaction = requireRecord(signed.transaction, "signedTransaction.transaction");
+	const output = requireRecordOrArray(value, "decoded signed NEAR transaction");
+	const transactionHash = coerceNonEmptyString(output.transactionHash, "transactionHash");
+	const signed = requireRecordOrArray(output.signedTransaction, "signedTransaction");
+	const transaction = requireRecordOrArray(signed.transaction, "signedTransaction.transaction");
 	const decodedBytes = requireByteArray(signed.borshBytes, "signedTransaction.borshBytes");
 	if (base64UrlEncode(Uint8Array.from(decodedBytes)) !== signedTransactionBorshB64u) throw new Error("Decoded NEAR transaction bytes do not match the persisted signed bytes");
 	const actions = signed.transaction && Array.isArray(transaction.actions) ? transaction.actions : [];
 	if (actions.length !== 3 || actions[0] !== "createAccount") throw new Error("Persisted NEAR transaction must contain create-account, transfer, and add-key");
-	const transferBody = requireRecord(requireRecord(actions[1], "signedTransaction.transaction.actions[1]").transfer, "transfer action");
-	const addKeyBody = requireRecord(requireRecord(actions[2], "signedTransaction.transaction.actions[2]").addKey, "add-key action");
-	const accessKey = requireRecord(addKeyBody.access_key, "add-key access key");
+	const transferBody = requireRecordOrArray(requireRecordOrArray(actions[1], "signedTransaction.transaction.actions[1]").transfer, "transfer action");
+	const addKeyBody = requireRecordOrArray(requireRecordOrArray(actions[2], "signedTransaction.transaction.actions[2]").addKey, "add-key action");
+	const accessKey = requireRecordOrArray(addKeyBody.access_key, "add-key access key");
 	if (accessKey.permission !== "FullAccess") throw new Error("Persisted NEAR transaction add-key action must grant full access");
 	return {
 		transactionHash,
-		signerId: requireNonEmptyString(transaction.signerId, "signedTransaction.transaction.signerId"),
+		signerId: coerceNonEmptyString(transaction.signerId, "signedTransaction.transaction.signerId"),
 		signerPublicKey: requireDecodedEd25519PublicKey(transaction.publicKey, "signedTransaction.transaction.publicKey"),
 		nonce: requireUnsignedIntegerString(transaction.nonce, "signedTransaction.transaction.nonce"),
-		receiverId: requireNonEmptyString(transaction.receiverId, "signedTransaction.transaction.receiverId"),
+		receiverId: coerceNonEmptyString(transaction.receiverId, "signedTransaction.transaction.receiverId"),
 		blockHash: base58Encode(Uint8Array.from(requireByteArray(transaction.blockHash, "signedTransaction.transaction.blockHash", 32))),
 		actions: [
 			"createAccount",
-			{ transfer: { deposit: requireNonEmptyString(transferBody.deposit, "transfer.deposit") } },
+			{ transfer: { deposit: coerceNonEmptyString(transferBody.deposit, "transfer.deposit") } },
 			{ addKey: {
 				publicKey: requireDecodedEd25519PublicKey(addKeyBody.public_key, "add-key public key"),
 				accessKey: {
@@ -115,80 +77,20 @@ function requireDecodedSponsoredNearAccountCreation(value, signedTransactionBors
 		signedTransactionBorshB64u
 	};
 }
-function createEd25519Pkcs8FromSeed(seed32) {
-	if (seed32.length !== 32) throw new Error(`Ed25519 seed must be 32 bytes, got ${seed32.length}`);
-	const pkcs8 = new Uint8Array(ED25519_PKCS8_SEED_PREFIX.length + seed32.length);
-	pkcs8.set(ED25519_PKCS8_SEED_PREFIX, 0);
-	pkcs8.set(seed32, ED25519_PKCS8_SEED_PREFIX.length);
-	return pkcs8;
-}
-function copyToArrayBuffer(bytes) {
-	const buffer = new ArrayBuffer(bytes.length);
-	new Uint8Array(buffer).set(bytes);
-	return buffer;
-}
-async function signEd25519MessageWithNodeCrypto(pkcs8, message) {
-	try {
-		const nodeCrypto = await import("node:crypto");
-		const { Buffer } = await import("node:buffer");
-		const key = nodeCrypto.createPrivateKey({
-			key: Buffer.from(pkcs8),
-			format: "der",
-			type: "pkcs8"
-		});
-		return new Uint8Array(nodeCrypto.sign(null, message, key));
-	} catch (error) {
-		return null;
-	}
-}
-async function signEd25519MessageWithWebCrypto(pkcs8, message) {
-	const subtle = globalThis.crypto?.subtle;
-	if (!subtle) return null;
-	try {
-		const key = await subtle.importKey("pkcs8", copyToArrayBuffer(pkcs8), "Ed25519", false, ["sign"]);
-		return new Uint8Array(await subtle.sign("Ed25519", key, copyToArrayBuffer(message)));
-	} catch {
-		return null;
-	}
-}
-async function signEd25519MessageWithPkcs8(pkcs8, message) {
-	const nodeSignature = await signEd25519MessageWithNodeCrypto(pkcs8, message);
-	if (nodeSignature) return nodeSignature;
-	const webCryptoSignature = await signEd25519MessageWithWebCrypto(pkcs8, message);
-	if (webCryptoSignature) return webCryptoSignature;
-	throw new Error("Ed25519 private-key signing is unavailable in this runtime");
-}
-async function signNearDigestWithSecretKey(args) {
-	if (toPublicKeyStringFromSecretKey(args.nearPrivateKey) !== args.expectedSignerPublicKey) throw new Error("NEAR private key does not match expected signer public key");
-	const digest = base64UrlDecode(args.signingDigestB64u);
-	if (digest.length !== 32) throw new Error(`NEAR signing digest must be 32 bytes, got ${digest.length}`);
-	const secretKeyBytes = decodeNearSecretKey(args.nearPrivateKey);
-	const seed32 = new Uint8Array(secretKeyBytes.subarray(0, 32));
-	const pkcs8 = createEd25519Pkcs8FromSeed(seed32);
-	try {
-		const signature = await signEd25519MessageWithPkcs8(pkcs8, digest);
-		if (signature.length !== 64) throw new Error(`Ed25519 signature must be 64 bytes, got ${signature.length}`);
-		return base64UrlEncode(signature);
-	} finally {
-		secretKeyBytes.fill(0);
-		seed32.fill(0);
-		pkcs8.fill(0);
-	}
-}
 function parsePositiveYocto(value, label) {
-	const text = requireNonEmptyString(value, label);
+	const text = coerceNonEmptyString(value, label);
 	const amount = BigInt(text);
 	if (amount <= 0n) throw new Error(`${label} must be positive`);
 	return amount.toString();
 }
 function requireEd25519PublicKey(value, label) {
-	const text = requireNonEmptyString(value, label);
+	const text = coerceNonEmptyString(value, label);
 	if (!text.startsWith("ed25519:")) throw new Error(`${label} must be an ed25519 public key`);
 	return text;
 }
 function validateNearRelayerRuntimeInput(input) {
-	const relayerAccount = requireNonEmptyString(input.relayerAccount, "relayerAccount");
-	const relayerPrivateKey = requireNonEmptyString(input.relayerPrivateKey, "relayerPrivateKey");
+	const relayerAccount = coerceNonEmptyString(input.relayerAccount, "relayerAccount");
+	const relayerPrivateKey = coerceNonEmptyString(input.relayerPrivateKey, "relayerPrivateKey");
 	const derivedRelayerPublicKey = toPublicKeyStringFromSecretKey(relayerPrivateKey);
 	const configuredRelayerPublicKey = String(input.relayerPublicKey || "").trim();
 	if (configuredRelayerPublicKey && configuredRelayerPublicKey !== derivedRelayerPublicKey) throw new Error("relayerPublicKey does not match relayerPrivateKey");
@@ -196,14 +98,14 @@ function validateNearRelayerRuntimeInput(input) {
 		relayerAccount,
 		relayerPrivateKey,
 		relayerPublicKey: derivedRelayerPublicKey,
-		nearRpcUrl: requireNonEmptyString(input.nearRpcUrl, "nearRpcUrl"),
+		nearRpcUrl: coerceNonEmptyString(input.nearRpcUrl, "nearRpcUrl"),
 		nearClient: input.nearClient,
 		ensureSignerWasm: input.ensureSignerWasm
 	};
 }
 function validateFundingInput(input) {
-	const walletId = requireNonEmptyString(input.walletId, "walletId");
-	const nearPublicKeyStr = requireNonEmptyString(input.nearPublicKeyStr, "nearPublicKeyStr");
+	const walletId = coerceNonEmptyString(input.walletId, "walletId");
+	const nearPublicKeyStr = coerceNonEmptyString(input.nearPublicKeyStr, "nearPublicKeyStr");
 	const parsedNearAccountId = parseImplicitNearAccountId(input.nearAccountId);
 	if (!parsedNearAccountId.ok) throw new Error(parsedNearAccountId.message);
 	if (deriveImplicitNearAccountIdFromEd25519PublicKey(nearPublicKeyStr) !== parsedNearAccountId.value) throw new Error("nearAccountId does not match nearPublicKeyStr implicit account ID");
@@ -222,7 +124,7 @@ function validateFundingInput(input) {
 	};
 }
 function validateNamedAccountCreationInput(input) {
-	const parsedAccountId = parseNamedNearAccountId(requireNonEmptyString(input.accountId, "accountId"));
+	const parsedAccountId = parseNamedNearAccountId(coerceNonEmptyString(input.accountId, "accountId"));
 	if (!parsedAccountId.ok) throw new Error(parsedAccountId.message);
 	const runtime = validateNearRelayerRuntimeInput(input);
 	return {
@@ -364,11 +266,7 @@ async function fundImplicitNearAccountWithRelayer(input) {
 			message: "Implicit NEAR account funding transaction submitted"
 		};
 	} catch (error) {
-		return {
-			ok: false,
-			code: "funding_failed",
-			message: errorMessage(error) || "Failed to fund implicit NEAR account"
-		};
+		return failure("funding_failed", errorMessage(error) || "Failed to fund implicit NEAR account");
 	}
 }
 /**
@@ -681,33 +579,7 @@ function isDefinitiveNearRejection(error) {
 		case "unknown": return false;
 	}
 }
-async function createNamedNearAccountWithRelayer(input) {
-	try {
-		const validated = validateNamedAccountCreationInput(input);
-		const prepared = await prepareSponsoredNearAccountCreationWithRelayer(input);
-		if (!prepared.ok) return {
-			success: false,
-			error: prepared.error,
-			message: prepared.message
-		};
-		const broadcast = await broadcastPreparedSponsoredNearAccountCreation({
-			prepared: prepared.prepared,
-			nearRpcUrl: validated.nearRpcUrl,
-			relayerAccountId: validated.relayerAccount,
-			...validated.nearClient ? { nearClient: validated.nearClient } : {}
-		});
-		if (broadcast.kind === "uncertain") throw new Error(broadcast.message);
-		return broadcast.result;
-	} catch (error) {
-		const message = errorMessage(error) || "Failed to create NEAR account";
-		return {
-			success: false,
-			error: message,
-			message
-		};
-	}
-}
 //#endregion
-export { broadcastPreparedSponsoredNearAccountCreation, createNamedNearAccountWithRelayer, fundImplicitNearAccountWithRelayer, prepareSponsoredNearAccountCreationWithRelayer, preparedSponsoredNearAccountCreationArtifactFingerprint };
+export { broadcastPreparedSponsoredNearAccountCreation, fundImplicitNearAccountWithRelayer, prepareSponsoredNearAccountCreationWithRelayer, preparedSponsoredNearAccountCreationArtifactFingerprint };
 
 //# sourceMappingURL=nearRelayerAccountProvisioning.js.map

package/dist/esm/core/nearSignerWasmRuntime.js

@@ -78,10 +78,7 @@ async function ensureNearSignerWasm() {
 	if (!signerWasmInitPromise) signerWasmInitPromise = initializeNearSignerWasm();
 	await signerWasmInitPromise;
 }
-function isNearSignerWasmReady() {
-	return signerWasmReady;
-}
 //#endregion
-export { ensureNearSignerWasm, isNearSignerWasmReady };
+export { ensureNearSignerWasm };
 
 //# sourceMappingURL=nearSignerWasmRuntime.js.map

package/dist/esm/core/rpcClients/near/NearClient.js

@@ -1,9 +1,5 @@
-import { base64Decode, base64Encode } from "../../../shared-ts/src/utils/base64.js";
-import { isFunction } from "../../../shared-ts/src/utils/validation.js";
-import { secureRandomId } from "../../../shared-ts/src/utils/secureRandomId.js";
 import { errorMessage } from "../../../shared-ts/src/utils/errors.js";
-import { decodeJsonRpcEnvelope } from "../../../shared-ts/src/utils/jsonRpc.js";
-import { decodeNearAccessKeyList, decodeNearAccessKeyView, decodeNearAccountView, decodeNearBlockReference, decodeNearCodeBase64, decodeNearContractCallResult, decodeNearFinalExecutionOutcome, parseNearContractResult } from "../../../shared-ts/src/utils/nearRpcResults.js";
+import { NearJsonRpcClient, SignedTransaction } from "../../../shared-ts/src/near/nearClient.js";
 //#region src/core/rpcClients/near/NearClient.ts
 function isObj(v) {
 	return !!v && typeof v === "object" && !Array.isArray(v);
@@ -153,222 +149,23 @@ function classifyInvalidTransaction(kind) {
 		default: return "invalid_transaction";
 	}
 }
-let RpcCallType = /* @__PURE__ */ function(RpcCallType) {
-	RpcCallType["Query"] = "query";
-	RpcCallType["View"] = "view";
-	RpcCallType["Send"] = "send_tx";
-	RpcCallType["Block"] = "block";
-	RpcCallType["Call"] = "call_function";
-	return RpcCallType;
-}({});
-const DEFAULT_WAIT_STATUS = { executeAction: "EXECUTED_OPTIMISTIC" };
-var SignedTransaction = class SignedTransaction {
-	constructor(data) {
-		this.transaction = data.transaction;
-		this.signature = data.signature;
-		this.borsh_bytes = data.borsh_bytes;
-		if (data.nonceLease) this.nonceLease = data.nonceLease;
-		if (data.serverDispatch) this.serverDispatch = data.serverDispatch;
+var MinimalNearClient = class extends NearJsonRpcClient {
+	errorFromRpc(operationName, error) {
+		return NearRpcError.fromRpcError(operationName, error);
 	}
-	static fromPlain(input) {
-		return new SignedTransaction({
-			transaction: input.transaction,
-			signature: input.signature,
-			borsh_bytes: input.borsh_bytes,
-			...input.nonceLease ? { nonceLease: input.nonceLease } : {},
-			...input.serverDispatch ? { serverDispatch: input.serverDispatch } : {}
-		});
-	}
-	encode() {
-		return new Uint8Array(this.borsh_bytes).buffer;
-	}
-	base64Encode() {
-		return base64Encode(this.encode());
-	}
-};
-function toArrayBufferFromUnknownBytes(bytes) {
-	if (!bytes) return null;
-	if (Array.isArray(bytes)) return new Uint8Array(bytes).buffer;
-	if (ArrayBuffer.isView(bytes)) {
-		const view = bytes;
-		return view.buffer.slice(view.byteOffset, view.byteOffset + view.byteLength);
-	}
-	if (bytes instanceof ArrayBuffer) return bytes;
-	return null;
-}
-function encodeSignedTransactionBase64(signed) {
-	const maybeSigned = signed?.signedTransaction;
-	const txPayload = maybeSigned && typeof maybeSigned === "object" ? maybeSigned : signed;
-	const maybeBase64 = txPayload.base64Encode;
-	if (isFunction(maybeBase64)) return maybeBase64.call(txPayload);
-	const maybeEncode = txPayload.encode;
-	if (isFunction(maybeEncode)) return base64Encode(maybeEncode.call(txPayload));
-	const snakeBuf = toArrayBufferFromUnknownBytes(txPayload.borsh_bytes);
-	if (snakeBuf) return base64Encode(snakeBuf);
-	const camelBuf = toArrayBufferFromUnknownBytes(txPayload.borshBytes);
-	if (camelBuf) return base64Encode(camelBuf);
-	throw new Error("Invalid signed transaction payload: cannot serialize to base64");
-}
-var MinimalNearClient = class MinimalNearClient {
-	constructor(rpcUrl) {
-		this.rpcUrls = MinimalNearClient.normalizeRpcUrls(rpcUrl);
-	}
-	static normalizeRpcUrls(input) {
-		const normalized = (Array.isArray(input) ? input : input.split(/[\s,]+/).map((url) => url.trim()).filter(Boolean)).map((url) => {
-			try {
-				return new URL(url).toString();
-			} catch (err) {
-				throw new Error(errorMessage(err) || `Invalid NEAR RPC URL: ${url}`);
-			}
-		});
-		if (!normalized.length) throw new Error("NEAR RPC URL cannot be empty");
-		return Array.from(new Set(normalized));
-	}
-	buildRequestBody(method, params) {
-		return JSON.stringify({
-			jsonrpc: "2.0",
-			id: secureRandomId("near-rpc", 32, "NEAR JSON-RPC request IDs"),
-			method,
-			params
-		});
-	}
-	async postOnce(url, requestBody) {
-		const response = await fetch(url, {
-			method: "POST",
-			headers: { "Content-Type": "application/json" },
-			body: requestBody
+	errorFromWrappedResult(message) {
+		return new NearRpcError({
+			message,
+			short: "RpcError",
+			failureKind: "infrastructure_failure",
+			type: "RpcError"
 		});
-		if (!response.ok) throw new Error(`RPC request failed: ${response.status} ${response.statusText}`);
-		const text = await response.text();
-		if (!text?.trim()) throw new Error("Empty response from RPC server");
-		const decoded = decodeJsonRpcEnvelope(JSON.parse(text));
-		if (!decoded.ok) throw new Error(`Invalid NEAR JSON-RPC response: ${decoded.error}`);
-		return decoded.value;
-	}
-	async requestWithFallback(requestBody) {
-		let lastError;
-		for (const [index, url] of this.rpcUrls.entries()) try {
-			const result = await this.postOnce(url, requestBody);
-			if (index > 0) console.warn(`[NearClient] RPC succeeded via fallback: ${url}`);
-			return result;
-		} catch (err) {
-			lastError = err;
-			const remaining = index < this.rpcUrls.length - 1;
-			console.warn(`[NearClient] RPC call to ${url} failed${remaining ? ", trying next" : ""}: ${errorMessage(err) || "RPC request failed"}`);
-			if (!remaining) throw err instanceof Error ? err : new Error(String(err));
-		}
-		throw new Error(errorMessage(lastError) || "RPC request failed");
-	}
-	unwrapRpcResult(rpc, operationName) {
-		if (rpc.kind === "failure") throw NearRpcError.fromRpcError(operationName, rpc.error);
-		const result = rpc.result;
-		if (typeof result === "object" && result !== null && "error" in result) {
-			const wrappedError = Reflect.get(result, "error");
-			throw new NearRpcError({
-				message: `${operationName} Error: ${typeof wrappedError === "string" ? wrappedError : JSON.stringify(wrappedError)}`,
-				short: "RpcError",
-				failureKind: "infrastructure_failure",
-				type: "RpcError"
-			});
-		}
-		return rpc.result;
-	}
-	async makeRpcCall(method, params, operationName, decodeResult) {
-		const requestBody = this.buildRequestBody(method, params);
-		try {
-			const envelope = await this.requestWithFallback(requestBody);
-			return decodeResult(this.unwrapRpcResult(envelope, operationName));
-		} catch (error) {
-			throw normalizeNearRpcFailure(operationName, error);
-		}
 	}
-	async query(params, decodeResult) {
-		return this.makeRpcCall(RpcCallType.Query, params, "Query", decodeResult);
+	errorFromOutcome(operationName, outcome, failure) {
+		return NearRpcError.fromOutcome(operationName, outcome, failure);
 	}
-	async viewAccessKey(accountId, publicKey, finalityQuery) {
-		const params = {
-			request_type: "view_access_key",
-			finality: finalityQuery?.finality || "final",
-			account_id: accountId,
-			public_key: publicKey
-		};
-		return this.makeRpcCall(RpcCallType.Query, params, "View Access Key", decodeNearAccessKeyView);
-	}
-	async viewAccessKeyList(accountId, finalityQuery) {
-		const params = {
-			request_type: "view_access_key_list",
-			finality: finalityQuery?.finality || "final",
-			account_id: accountId
-		};
-		return this.makeRpcCall(RpcCallType.Query, params, "View Access Key List", decodeNearAccessKeyList);
-	}
-	async viewAccount(accountId) {
-		const params = {
-			request_type: "view_account",
-			finality: "final",
-			account_id: accountId
-		};
-		return this.makeRpcCall(RpcCallType.Query, params, "View Account", decodeNearAccountView);
-	}
-	async viewCode(accountId, finalityQuery) {
-		const params = {
-			request_type: "view_code",
-			finality: finalityQuery?.finality || "final",
-			account_id: accountId
-		};
-		return base64Decode(await this.makeRpcCall(RpcCallType.Query, params, "View Code", decodeNearCodeBase64));
-	}
-	async viewBlock(params) {
-		return this.makeRpcCall(RpcCallType.Block, params, "View Block", decodeNearBlockReference);
-	}
-	async sendTransaction(signedTransaction, waitUntil = DEFAULT_WAIT_STATUS.executeAction) {
-		const params = {
-			signed_tx_base64: encodeSignedTransactionBase64(signedTransaction),
-			wait_until: waitUntil
-		};
-		const outcome = await this.makeRpcCall(RpcCallType.Send, params, "Send Transaction", decodeNearFinalExecutionOutcome);
-		const status = outcome.status;
-		if (status && typeof status === "object" && "Failure" in status) throw NearRpcError.fromOutcome("Send Transaction", outcome, status.Failure);
-		return outcome;
-	}
-	async txStatus(txHash, senderAccountId) {
-		return this.makeRpcCall("EXPERIMENTAL_tx_status", {
-			tx_hash: txHash,
-			sender_account_id: senderAccountId
-		}, "Tx Status", decodeNearFinalExecutionOutcome);
-	}
-	async callFunction(accountId, method, args, decodeResult, blockQuery) {
-		const rpcParams = {
-			request_type: "call_function",
-			...blockQuery ?? { finality: "final" },
-			account_id: accountId,
-			method_name: method,
-			args_base64: base64Encode(new TextEncoder().encode(JSON.stringify(args)).buffer)
-		};
-		return decodeResult(parseNearContractResult((await this.makeRpcCall(RpcCallType.Query, rpcParams, "View Function", decodeNearContractCallResult)).result));
-	}
-	async view(params) {
-		return this.callFunction(params.account, params.method, params.args, params.decodeResult);
-	}
-	async getAccessKeys({ account, block_id }) {
-		const params = {
-			request_type: "view_access_key_list",
-			account_id: account,
-			finality: "final"
-		};
-		if (block_id) params.block_id = block_id;
-		const keys = (await this.makeRpcCall(RpcCallType.Query, params, "Get Access Keys", decodeNearAccessKeyList)).keys || [];
-		const fullAccessKeys = [];
-		const functionCallAccessKeys = [];
-		for (const key of keys) {
-			const permission = key.access_key.permission;
-			if (permission === "FullAccess") fullAccessKeys.push(key);
-			else if (typeof permission === "object" && "FunctionCall" in permission) functionCallAccessKeys.push(key);
-		}
-		return {
-			fullAccessKeys,
-			functionCallAccessKeys
-		};
+	errorFromFailedCall(operationName, error) {
+		return normalizeNearRpcFailure(operationName, error);
 	}
 };
 function normalizeNearRpcFailure(operationName, error) {
@@ -384,6 +181,6 @@ function normalizeNearRpcFailure(operationName, error) {
 	});
 }
 //#endregion
-export { MinimalNearClient, NearRpcError, RpcCallType, SignedTransaction };
+export { MinimalNearClient, NearRpcError, SignedTransaction };
 
 //# sourceMappingURL=NearClient.js.map

package/dist/esm/core/signingLanes/LaneEnrollmentActivation.js

@@ -1,6 +1,6 @@
 import { base64UrlEncode } from "../../shared-ts/src/utils/base64.js";
-import { parseDigestB64u } from "../../shared-ts/src/utils/canonicalPrimitives.js";
 import { sha256Bytes, sha256BytesUtf8 } from "../../shared-ts/src/utils/digests.js";
+import { parseDigestB64u } from "../../shared-ts/src/utils/canonicalPrimitives.js";
 import { buildLaneProtocolRecordV1, parseLaneHolderDeliveryReceiptV1, parseLaneProtocolCommitReceiptV1, parseLaneServerActivationReceiptV1 } from "../../shared-ts/src/signing-lanes/rotationParsers.js";
 import { computeLaneEnrollmentManifestDigestV1, encodeLaneHolderDeliveryReceiptV1, encodeLaneProtocolCommitReceiptV1, encodeLaneServerActivationReceiptV1 } from "../../shared-ts/src/signing-lanes/rotationDigests.js";
 import { transitionLaneProtocolLifecycleV1 } from "../../shared-ts/src/signing-lanes/rotationLifecycle.js";

package/dist/esm/core/signingLanes/LaneLifecycleApplicationService.js

@@ -1,6 +1,4 @@
-import { base64UrlEncode } from "../../shared-ts/src/utils/base64.js";
-import { parseCorrelationId, parseDigestB64u } from "../../shared-ts/src/utils/canonicalPrimitives.js";
-import { sha256Bytes } from "../../shared-ts/src/utils/digests.js";
+import { parseCorrelationId, sha256DigestB64u } from "../../shared-ts/src/utils/canonicalPrimitives.js";
 import { buildRevokeSigningLaneV1, parseLaneProtocolCommitReceiptV1, parseLaneRefreshPredecessorRetirementV1, parseLaneServerActivationReceiptV1, parseRevokeSigningLaneV1 } from "../../shared-ts/src/signing-lanes/rotationParsers.js";
 import { encodeLaneProtocolCommitReceiptV1 } from "../../shared-ts/src/signing-lanes/rotationDigests.js";
 //#region src/core/signingLanes/LaneLifecycleApplicationService.ts
@@ -69,7 +67,7 @@ var LaneLifecycleApplicationService = class {
 	async retireLaneRefreshPredecessorV1(request) {
 		const protocolCommitReceipt = parseLaneProtocolCommitReceiptV1(request.protocolCommitReceipt);
 		assertProtocolReceiptMatchesJob(protocolCommitReceipt, request.job);
-		const retirementRequestDigestB64u = parseDigestB64u(base64UrlEncode(await sha256Bytes(encodeLaneProtocolCommitReceiptV1(protocolCommitReceipt))));
+		const retirementRequestDigestB64u = await sha256DigestB64u(encodeLaneProtocolCommitReceiptV1(protocolCommitReceipt));
 		const command = buildRevokeSigningLaneV1({
 			walletId: request.job.walletId,
 			walletKeyId: request.job.walletKeyId,

package/dist/esm/core/signingLanes/LaneLifecycleStore.js

@@ -1,24 +0,0 @@
-//#region src/core/signingLanes/LaneLifecycleStore.ts
-function protocolCasResultToAdmissionResult(result) {
-	if (result.outcome === "conflict") return {
-		outcome: "conflict",
-		expectedVersion: result.expectedVersion,
-		actualVersion: result.actualVersion,
-		requestedCommandDigestB64u: result.requestedCommandDigestB64u,
-		storedCommandDigestB64u: result.storedCommandDigestB64u
-	};
-	return {
-		outcome: result.outcome,
-		version: result.version,
-		commandDigestB64u: result.commandDigestB64u,
-		value: result.record
-	};
-}
-function assertNonEmptyVersion(value, label) {
-	if (!Number.isSafeInteger(value) || value < 1) throw new Error(`${label} must be a positive safe integer`);
-	return value;
-}
-//#endregion
-export { assertNonEmptyVersion, protocolCasResultToAdmissionResult };
-
-//# sourceMappingURL=LaneLifecycleStore.js.map

package/dist/esm/core/signingLanes/WalletExecutionLaneProjection.js

@@ -1,14 +1,14 @@
-import { parseEmailOtpProviderUserId, parseLaneShareEpoch, parseMpcSigningWorkerRef, parseSigningLaneId, parseWalletKeyId, parseWebAuthnCredentialIdB64u } from "../../shared-ts/src/utils/domainIds.js";
+import { mpcMaterialActivationRefsEqual, parseEmailOtpProviderUserId, parseLaneShareEpoch, parseMpcSigningWorkerRef, parseSigningLaneId, parseWalletKeyId, parseWebAuthnCredentialIdB64u } from "../../shared-ts/src/utils/domainIds.js";
 import { base64UrlEncode } from "../../shared-ts/src/utils/base64.js";
-import { parseDigestB64u } from "../../shared-ts/src/utils/canonicalPrimitives.js";
-import { alphabetizeStringify, sha256BytesUtf8 } from "../../shared-ts/src/utils/digests.js";
+import { alphabetizeStringify } from "../../shared-ts/src/utils/digests.js";
+import { parseDigestB64u, sha256Utf8DigestB64u } from "../../shared-ts/src/utils/canonicalPrimitives.js";
 import { base58Encode } from "../../shared-ts/src/utils/base58.js";
 import { parseEd25519PublicKeyB64u, parseKeyCreationSignerSlot, parseSecp256k1CompressedPublicKeyB64u } from "../../shared-ts/src/passkey-custody/primitives.js";
-import { parseNearEd25519SigningKeyId } from "../../shared-ts/src/utils/registrationIntent.js";
 import { routerAbMpcMaterialActivationRefFromWire, sameRouterAbMpcMaterialActivationRef } from "../../shared-ts/src/utils/routerAbNormalSigningIdentity.js";
 import { deriveEvmFamilySigningKeySlotId } from "../../shared-ts/src/signing-lanes/evmFamilySigningKeySlotId.js";
 import { walletAuthAuthorityRef } from "../../shared-ts/src/utils/walletAuthAuthority.js";
 import { sameRouterAbEcdsaDerivationPublicCapabilityV1, sameRouterAbEcdsaDerivationPublicIdentityV1, sameRouterAbEcdsaRegistrationActivationReceiptV1, sameRouterAbServerIdentityV1 } from "../../shared-ts/src/utils/routerAbEcdsaDerivation.js";
+import { parseNearEd25519SigningKeyId } from "../../shared-ts/src/utils/registrationIds.js";
 import { buildOwnerLaneParticipantContinuityV1, computeOwnerLaneParticipantBindingDigestV1, parseWalletSignerId } from "../../shared-ts/src/signing-lanes/ownerContinuity.js";
 import "../../shared-ts/src/signing-lanes/index.js";
 import { buildActiveSigningLaneLifecycle, buildActiveWalletKeyLifecycle, buildEd25519WalletKeyRecord, buildEvmFamilyWalletKeyRecord, buildOwnerEmailOtpSigningLaneRecord, buildOwnerPasskeySigningLaneRecord, parseWalletKeyVersion } from "../../shared-ts/src/signing-lanes/recordParsers.js";
@@ -218,13 +218,13 @@ function requireOnlyEcdsaSigners(signers) {
 function signerMatchesMaterialActivation(signer, expected) {
 	const wire = signer.version === "wallet_signer_ed25519_v1" ? signer.activeYaoCapability.activationResult.public_receipt.material_activation : signer.walletKey.publicCapability.material_activation;
 	try {
-		return sameMaterialActivation(routerAbMpcMaterialActivationRefFromWire(wire), expected);
+		return mpcMaterialActivationRefsEqual(routerAbMpcMaterialActivationRefFromWire(wire), expected);
 	} catch {
 		return false;
 	}
 }
 function assertExpectedActivation(wire, expected) {
-	if (!sameMaterialActivation(routerAbMpcMaterialActivationRefFromWire(wire), expected)) throw new Error("wallet signer material activation changed");
+	if (!mpcMaterialActivationRefsEqual(routerAbMpcMaterialActivationRefFromWire(wire), expected)) throw new Error("wallet signer material activation changed");
 }
 function assertEcdsaReceiptContinuity(signer) {
 	const capability = signer.walletKey.publicCapability;
@@ -239,10 +239,7 @@ async function digestPublicIdentity(value) {
 	return await digestValue(SOURCE_IDENTITY_DOMAIN, value);
 }
 async function digestValue(domain, value) {
-	return parseDigestB64u(base64UrlEncode(await sha256BytesUtf8(`${domain}\u0000${alphabetizeStringify(value)}`)));
-}
-function sameMaterialActivation(left, right) {
-	return left.activationId === right.activationId && left.capability === right.capability && left.materialOwner === right.materialOwner && left.keyBinding === right.keyBinding && left.lifecycleBinding === right.lifecycleBinding && left.signingWorker === right.signingWorker;
+	return sha256Utf8DigestB64u(`${domain}\u0000${alphabetizeStringify(value)}`);
 }
 function requireParsed(result) {
 	if (result.ok) return result.value;
@@ -291,6 +288,6 @@ function walletAuthorityForAuthMethod(authMethod, authSource) {
 	};
 }
 //#endregion
-export { projectActiveOwnerWalletExecutionLane, resolveActiveOwnerWalletExecutionLane, resolveWalletAuthMethodIdForAuthority };
+export { resolveActiveOwnerWalletExecutionLane, resolveWalletAuthMethodIdForAuthority };
 
 //# sourceMappingURL=WalletExecutionLaneProjection.js.map