@seams/wallet 0.6.2 → 0.7.1

package/dist/esm/core/platform/browser/createBrowserPlatformRuntime.js

@@ -35,22 +35,6 @@ function signerCryptoCommandFailure(code, message) {
 		message
 	};
 }
-function requiredString(value, field) {
-	if (typeof value !== "string") throw new Error(`ECDSA client bootstrap state is missing ${field}`);
-	const normalized = value.trim();
-	if (!normalized) throw new Error(`ECDSA client bootstrap state is missing ${field}`);
-	return normalized;
-}
-function requiredNonNegativeInteger(value, field) {
-	if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) throw new Error(`${field} must be a non-negative safe integer`);
-	return value;
-}
-function requireBase64UrlBytes(value, field, byteLength) {
-	const normalized = String(value || "").trim();
-	if (!normalized) throw new Error(`${field} is required`);
-	if (base64UrlDecode(normalized).length !== byteLength) throw new Error(`${field} must decode to ${byteLength} bytes`);
-	return normalized;
-}
 function decodeBase64UrlArrayBuffer(value) {
 	const decoded = base64UrlDecode(value);
 	const out = new ArrayBuffer(decoded.byteLength);
@@ -86,17 +70,6 @@ function browserPasskeyCreationOptions(options) {
 		} } }
 	};
 }
-function parsePublicKey33B64u(value, field) {
-	return requireBase64UrlBytes(value, field, 33);
-}
-function parseRelayerEcdsaDerivationPublicKey33B64u(value) {
-	return parsePublicKey33B64u(value, "ECDSA relayer DERIVATION public key");
-}
-function parseEthereumAddress(value) {
-	const normalized = String(value || "").trim();
-	if (!/^0x[0-9a-fA-F]{40}$/.test(normalized)) throw new Error("ECDSA relayer public identity has invalid ethereumAddress");
-	return normalized;
-}
 function isNativeBindingFailureMessage(message) {
 	return /wasm (initialization|initialize|instantiation)|webassembly|module_or_path|failed to (load|compile|instantiate) wasm|derivation client wasm initialization failed/i.test(message);
 }
@@ -122,17 +95,6 @@ function mapFinalizeEcdsaCommandError(error) {
 	if (/relayer|public identity|group public key|ethereum address|threshold public key/i.test(message)) return signerCryptoCommandFailure("public_identity_mismatch", message);
 	return signerCryptoCommandFailure("invalid_pending_state", message);
 }
-function parseRelayerPublicIdentity(input) {
-	if (input === null || typeof input !== "object" || Array.isArray(input)) throw new Error("ECDSA relayer public identity must be an object");
-	if (Object.keys(input).sort().join(",") !== "ethereumAddress,groupPublicKey33B64u,relayerKeyId,relayerPublicKey33B64u,relayerShareRetryCounter") throw new Error("ECDSA relayer public identity fields are invalid");
-	return {
-		relayerKeyId: requiredString(Reflect.get(input, "relayerKeyId"), "relayerKeyId"),
-		relayerPublicKey33B64u: parseRelayerEcdsaDerivationPublicKey33B64u(requiredString(Reflect.get(input, "relayerPublicKey33B64u"), "relayerPublicKey33B64u")),
-		groupPublicKey33B64u: parsePublicKey33B64u(requiredString(Reflect.get(input, "groupPublicKey33B64u"), "groupPublicKey33B64u"), "groupPublicKey33B64u"),
-		ethereumAddress: parseEthereumAddress(Reflect.get(input, "ethereumAddress")),
-		relayerShareRetryCounter: requiredNonNegativeInteger(Reflect.get(input, "relayerShareRetryCounter"), "relayerShareRetryCounter")
-	};
-}
 function createBrowserDurableRecordStore(indexedDB) {
 	return {
 		kind: "durable_record_store",
@@ -479,11 +441,6 @@ function createBrowserSignerCryptoPort(workerCtx) {
 		},
 		async finalizeEcdsaClientBootstrap(input) {
 			if (input.pendingStateBlob.kind !== "ecdsa_role_local_pending_state_blob_v1" || input.pendingStateBlob.curve !== "secp256k1" || input.pendingStateBlob.encoding !== "base64url" || input.pendingStateBlob.producer !== "signer_core") return signerCryptoCommandFailure("invalid_pending_state", "ECDSA client bootstrap pending blob envelope is invalid");
-			try {
-				parseRelayerPublicIdentity(input.relayerPublicIdentity);
-			} catch (error) {
-				return signerCryptoCommandFailure("invalid_relayer_public_identity", errorMessage(error));
-			}
 			if (!workerCtx) return signerCryptoInvocationFailure("unavailable", "ECDSA client bootstrap worker context is unavailable");
 			try {
 				return {

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

@@ -1,28 +1,8 @@
-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 as SignedTransaction$1 } from "../../../shared-ts/src/near/nearClient.js";
 import { NearRpcError } from "./NearRpcError.js";
-import { DEFAULT_WAIT_STATUS } from "../../types/rpc.js";
 //#region src/core/rpcClients/near/NearClient.ts
-let RpcCallType = /* @__PURE__ */ function(RpcCallType) {
-	RpcCallType["Query"] = "query";
-	RpcCallType["View"] = "view";
-	RpcCallType["Send"] = "send_tx";
-	RpcCallType["Block"] = "block";
-	RpcCallType["Call"] = "call_function";
-	return RpcCallType;
-}({});
-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 SignedTransaction = class SignedTransaction extends SignedTransaction$1 {
 	static fromPlain(input) {
 		return new SignedTransaction({
 			transaction: input.transaction,
@@ -32,168 +12,33 @@ var SignedTransaction = class SignedTransaction {
 			...input.serverDispatch ? { serverDispatch: input.serverDispatch } : {}
 		});
 	}
-	encode() {
-		return new Uint8Array(this.borsh_bytes).buffer;
-	}
-	base64Encode() {
-		return base64Encode(this.encode());
-	}
-	static decode(bytes) {
+	static decode() {
 		throw new Error("SignedTransaction.decode(): borsh deserialization not implemented");
 	}
 };
-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) {
-				const message = errorMessage(err) || `Invalid NEAR RPC URL: ${url}`;
-				throw new Error(message);
-			}
+var MinimalNearClient = class extends NearJsonRpcClient {
+	errorFromRpc(operationName, error) {
+		return NearRpcError.fromRpcError(operationName, error);
+	}
+	errorFromWrappedResult(message) {
+		return new NearRpcError({
+			message,
+			short: "RpcError",
+			type: "RpcError"
 		});
-		if (!normalized.length) throw new Error("NEAR RPC URL cannot be empty");
-		return Array.from(new Set(normalized));
 	}
-	/** Build a JSON-RPC 2.0 POST body (stringified). */
-	buildRequestBody(method, params) {
-		return JSON.stringify({
-			jsonrpc: "2.0",
-			id: secureRandomId("near-rpc", 32, "NEAR JSON-RPC request IDs"),
-			method,
-			params
-		});
+	errorFromOutcome(operationName, outcome, failure) {
+		return NearRpcError.fromOutcome(operationName, outcome, failure);
 	}
-	/** Perform a single POST to one endpoint and decode its JSON-RPC envelope. */
-	async postOnce(url, requestBody) {
-		const response = await fetch(url, {
-			method: "POST",
-			headers: { "Content-Type": "application/json" },
-			body: requestBody
-		});
-		if (response.status === 429) throw new Error("RPC throttled; retry shortly");
-		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;
-	}
-	/** Try each configured RPC endpoint in order and return the first decoded envelope. */
-	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");
-	}
-	/** Unwrap an envelope while keeping the method result unknown. */
-	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",
-				type: "RpcError"
-			});
-		}
-		return rpc.result;
+	errorFromHttpStatus(response) {
+		if (response.status === 429) return /* @__PURE__ */ new Error("RPC throttled; retry shortly");
+		return super.errorFromHttpStatus(response);
 	}
-	/**
-	* Execute RPC call with proper error handling and result extraction
-	*/
-	async makeRpcCall(method, params, operationName, decodeResult) {
-		const requestBody = this.buildRequestBody(method, params);
-		const rpc = await this.requestWithFallback(requestBody);
-		return decodeResult(this.unwrapRpcResult(rpc, operationName));
-	}
-	async query(params, decodeResult) {
-		return this.makeRpcCall(RpcCallType.Query, params, "Query", decodeResult);
-	}
-	async viewAccessKey(accountId, publicKey, finalityQuery) {
-		const publicKeyStr = publicKey;
-		const params = {
-			request_type: "view_access_key",
-			finality: finalityQuery?.finality || "final",
-			account_id: accountId,
-			public_key: publicKeyStr
-		};
-		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
-		};
+	async sendWithRetry(send) {
 		const maxAttempts = 5;
 		let lastError = null;
 		for (let attempt = 1; attempt <= maxAttempts; attempt++) try {
-			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;
+			return await send();
 		} catch (err) {
 			lastError = err;
 			const msg = errorMessage(err);
@@ -204,48 +49,8 @@ var MinimalNearClient = class MinimalNearClient {
 		}
 		throw lastError instanceof Error ? lastError : new Error(String(lastError));
 	}
-	async txStatus(txHash, senderAccountId) {
-		const params = {
-			tx_hash: txHash,
-			sender_account_id: senderAccountId
-		};
-		return this.makeRpcCall("EXPERIMENTAL_tx_status", params, "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;
-			delete params.finality;
-		}
-		const accessKeyList = await this.makeRpcCall(RpcCallType.Query, params, "View Access Key List", decodeNearAccessKeyList);
-		const fullAccessKeys = [];
-		const functionCallAccessKeys = [];
-		for (const key of accessKeyList.keys) if (key.access_key.permission === "FullAccess") fullAccessKeys.push(key);
-		else if (key.access_key.permission && typeof key.access_key.permission === "object" && "FunctionCall" in key.access_key.permission) functionCallAccessKeys.push(key);
-		return {
-			fullAccessKeys,
-			functionCallAccessKeys
-		};
-	}
 };
 //#endregion
-export { MinimalNearClient, SignedTransaction, encodeSignedTransactionBase64 };
+export { MinimalNearClient, SignedTransaction };
 
 //# sourceMappingURL=NearClient.js.map

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

@@ -1,15 +1,15 @@
 import { mpcMaterialActivationRefsEqual, parseThresholdEd25519SessionId } from "../../../shared-ts/src/utils/domainIds.js";
 import { parseMpcWalletSigningQuotaId, parseWalletSessionAuthorizationId, parseWalletSessionId } from "../../../shared-ts/src/authorization/capabilityKinds.js";
-import { routerAbMpcMaterialActivationRefFromWire } from "../../../shared-ts/src/utils/routerAbNormalSigningIdentity.js";
 import { joinNormalizedUrl } from "../../../shared-ts/src/utils/normalize.js";
 import { isObject, requireTrimmedString } from "../../../shared-ts/src/utils/validation.js";
-import { normalizeRuntimePolicyScope } from "../../../shared-ts/src/threshold/signingRootScope.js";
-import { parseRouterAbEcdsaCredentialFreeSessionActivationResponseV1, parseRouterAbEcdsaDerivationPublicCapabilityV1, parseRouterAbEcdsaPostRegistrationSessionActivationPolicyV1, parseRouterAbEcdsaPostRegistrationSessionActivationResponseV1, parseRouterAbEcdsaRegistrationActivationReceiptV1 } from "../../../shared-ts/src/utils/routerAbEcdsaDerivation.js";
-import { parseActiveWalletSessionV1, parseWalletSessionOperationCredentialV1 } from "../../../shared-ts/src/device-linking/parsers.js";
+import { parseActiveWalletSessionV1, parseWalletSessionOperationCredentialV1 } from "../../../shared-ts/src/device-linking/activeWalletSession.js";
 import { requireRouterAbEd25519NormalSigningState } from "../../../shared-ts/src/utils/signingSessionSeal.js";
+import { normalizeRuntimePolicyScope } from "../../../shared-ts/src/threshold/signingRootScope.js";
 import { parsePasskeyCustodyEnvelopeRecord } from "../../../shared-ts/src/passkey-custody/custodyEnvelope.js";
 import "../../../shared-ts/src/passkey-custody/index.js";
+import { routerAbMpcMaterialActivationRefFromWire } from "../../../shared-ts/src/utils/routerAbNormalSigningIdentity.js";
 import { redactCredentialExtensionOutputs } from "../../signingEngine/webauthnAuth/credentials/credentialExtensions.js";
+import { parseRouterAbEcdsaCredentialFreeSessionActivationResponseV1, parseRouterAbEcdsaDerivationPublicCapabilityV1, parseRouterAbEcdsaPostRegistrationSessionActivationPolicyV1, parseRouterAbEcdsaPostRegistrationSessionActivationResponseV1, parseRouterAbEcdsaRegistrationActivationReceiptV1 } from "../../../shared-ts/src/utils/routerAbEcdsaDerivation.js";
 import "../../../shared-ts/src/device-linking/index.js";
 import { errorMessage } from "../../../shared-ts/src/utils/errors.js";
 import { parseWalletSessionAlreadyCommittedResponseV1, parseWalletUnlockAlreadyCommittedResponseV1 } from "../../../shared-ts/src/authorization/walletSessionIssuance.js";