@seams/wallet 0.7.1 → 0.8.0

package/dist/esm/react/core/rpcClients/evm/nonceBackend.js

@@ -1,279 +0,0 @@
-import { chainFamilyFromNetwork } from "../../config/chains.js";
-import { thresholdEcdsaChainTargetFromChainFamily, thresholdEcdsaChainTargetFromRequest, toWalletId } from "../../signingEngine/interfaces/ecdsaChainTarget.js";
-import { createEvmClient } from "./EvmClient.js";
-//#region src/core/rpcClients/evm/nonceBackend.ts
-function toManagedNonceReservationSnapshot(input) {
-	const subjectId = toWalletId(input.subjectId);
-	const leaseId = normalizeSessionStatusRequiredString(input.leaseId, "leaseId");
-	const operationId = normalizeSessionStatusRequiredString(input.operationId, "operationId");
-	const operationFingerprint = normalizeSessionStatusRequiredString(input.operationFingerprint, "operationFingerprint");
-	const snapshot = {
-		chainTarget: input.chainTarget,
-		subjectId,
-		sender: normalizeSender(input.sender),
-		nonce: normalizeBigint(input.nonce, "nonce").toString(),
-		leaseId,
-		operationId,
-		operationFingerprint
-	};
-	if (input.nonceKey != null) snapshot.nonceKey = normalizeBigint(input.nonceKey, "nonceKey").toString();
-	if (Number.isSafeInteger(input.reservedAtMs)) snapshot.reservedAtMs = input.reservedAtMs;
-	if (Number.isSafeInteger(input.expiresAtMs)) snapshot.expiresAtMs = input.expiresAtMs;
-	return snapshot;
-}
-function fromManagedNonceReservationSnapshot(snapshot) {
-	if (!snapshot || typeof snapshot !== "object") throw new Error("[evmNonceBackend] invalid managed nonce snapshot: object");
-	const chainTarget = parseManagedNonceSnapshotChainTarget(snapshot);
-	const subjectId = toWalletId(snapshot.subjectId ?? snapshot.walletId);
-	const sender = normalizeSender(snapshot.sender);
-	const nonce = normalizeBigint(snapshot.nonce, "nonce");
-	const parsedNonceKey = snapshot.nonceKey == null ? void 0 : normalizeBigint(snapshot.nonceKey, "nonceKey");
-	const leaseId = normalizeSessionStatusRequiredString(snapshot.leaseId, "leaseId");
-	const operationId = normalizeSessionStatusRequiredString(snapshot.operationId, "operationId");
-	const operationFingerprint = normalizeSessionStatusRequiredString(snapshot.operationFingerprint, "operationFingerprint");
-	const reservedAtMs = normalizeOptionalSafeInteger(snapshot.reservedAtMs);
-	const expiresAtMs = normalizeOptionalSafeInteger(snapshot.expiresAtMs);
-	return {
-		chainTarget,
-		subjectId,
-		sender,
-		...parsedNonceKey != null ? { nonceKey: parsedNonceKey } : {},
-		nonce,
-		leaseId,
-		operationId,
-		operationFingerprint,
-		...reservedAtMs != null ? { reservedAtMs } : {},
-		...expiresAtMs != null ? { expiresAtMs } : {}
-	};
-}
-function reserveNonceInputFromBoundary(input) {
-	const reservationInput = {
-		chainTarget: thresholdEcdsaChainTargetFromChainFamily({
-			chain: input.chain,
-			chainId: input.chainId,
-			networkSlug: input.networkKey
-		}),
-		subjectId: toWalletId(input.walletId),
-		sender: normalizeSender(input.sender)
-	};
-	if (input.nonceKey != null) reservationInput.nonceKey = normalizeBigint(input.nonceKey, "nonceKey");
-	return reservationInput;
-}
-const DEFAULT_RPC_TIMEOUT_MS = 15e3;
-function createEvmNonceBackendWithFetcher(args) {
-	return {
-		async fetchChainNonce(input) {
-			const normalized = normalizeInput(input);
-			return await args.fetchChainNonce(normalized);
-		},
-		async fetchBroadcastTransactionStatus(input) {
-			const normalized = normalizeInput(input);
-			return await args.fetchBroadcastTransactionStatus({
-				...normalized,
-				txHash: normalizeTxHash(input.txHash)
-			});
-		}
-	};
-}
-function createEvmNonceBackend(args) {
-	const fetchImpl = args.fetchImpl || fetch.bind(globalThis);
-	return createEvmNonceBackendWithFetcher({
-		fetchChainNonce: async (input) => await fetchChainNonceFromRpc({
-			chains: args.chains,
-			input,
-			fetchImpl
-		}),
-		fetchBroadcastTransactionStatus: async (input) => await fetchBroadcastTransactionStatusFromRpc({
-			chains: args.chains,
-			input,
-			fetchImpl
-		})
-	});
-}
-async function fetchBroadcastTransactionStatusFromRpc(args) {
-	const rpcUrl = resolveRpcUrlForInput(args.chains, args.input);
-	const receipt = await fetchEvmRpcResult({
-		rpcUrl,
-		method: "eth_getTransactionReceipt",
-		params: [args.input.txHash],
-		fetchImpl: args.fetchImpl
-	});
-	if (receipt && typeof receipt === "object") return { kind: "finalized" };
-	const transaction = await fetchEvmRpcResult({
-		rpcUrl,
-		method: "eth_getTransactionByHash",
-		params: [args.input.txHash],
-		fetchImpl: args.fetchImpl
-	});
-	return transaction && typeof transaction === "object" ? { kind: "pending" } : { kind: "missing" };
-}
-async function fetchEvmRpcResult(args) {
-	return await createEvmClient({
-		rpcUrl: args.rpcUrl,
-		fetchImpl: args.fetchImpl,
-		requestTimeoutMs: DEFAULT_RPC_TIMEOUT_MS
-	}).request({
-		method: args.method,
-		params: args.params
-	});
-}
-async function fetchChainNonceFromRpc(args) {
-	return parseRpcHexQuantity(await createEvmClient({
-		rpcUrl: resolveRpcUrlForInput(args.chains, args.input),
-		fetchImpl: args.fetchImpl,
-		requestTimeoutMs: DEFAULT_RPC_TIMEOUT_MS
-	}).request({
-		method: "eth_getTransactionCount",
-		params: [args.input.sender, "pending"]
-	}), "eth_getTransactionCount");
-}
-function resolveRpcUrlForInput(chains, input) {
-	const requestedChain = input.chain;
-	const targetChainId = input.chainId;
-	const networkKey = String(input.networkKey || "").trim().toLowerCase();
-	const byChainId = (source) => source.filter((chain) => {
-		const chainId = getOptionalConfigChainId(chain);
-		return typeof chainId === "number" && chainId === targetChainId;
-	});
-	const byNetworkKey = (source) => source.filter((chain) => String(chain.network || "").trim().toLowerCase() === networkKey);
-	const supportedChains = chains.filter((chain) => isSupportedNonceRoutingChain(chain));
-	if (!supportedChains.length) throw new Error("[evmNonceBackend] missing RPC config for nonce-enabled chains");
-	const networkMatches = byNetworkKey(supportedChains);
-	if (networkMatches.length === 1) {
-		const only = networkMatches[0];
-		assertChainSupportsRequestedRoute({
-			chain: only,
-			requestedChain,
-			networkKey: input.networkKey,
-			chainId: targetChainId
-		});
-		assertConfiguredChainIdMatchesInput({
-			chain: only,
-			chainId: targetChainId,
-			networkKey: input.networkKey
-		});
-		return mustTrimmedRpcUrl(only.rpcUrl, only.network);
-	}
-	if (networkMatches.length > 1) {
-		const chainIdMatched = byChainId(networkMatches).filter((chain) => isChainCompatibleWithRequestChain(chain, requestedChain));
-		if (chainIdMatched.length === 1) {
-			const only = chainIdMatched[0];
-			return mustTrimmedRpcUrl(only.rpcUrl, only.network);
-		}
-		throw new Error(`[evmNonceBackend] ambiguous networkKey mapping for ${input.networkKey} (chainId=${String(targetChainId)})`);
-	}
-	const chainIdMatches = byChainId(supportedChains);
-	const compatibleMatches = chainIdMatches.filter((chain) => isChainCompatibleWithRequestChain(chain, requestedChain));
-	if (compatibleMatches.length === 1) {
-		const only = compatibleMatches[0];
-		return mustTrimmedRpcUrl(only.rpcUrl, only.network);
-	}
-	if (compatibleMatches.length > 1) {
-		const candidates = compatibleMatches.map((chain) => String(chain.network || "").trim()).join(", ");
-		throw new Error(`[evmNonceBackend] ambiguous chainId routing for ${requestedChain} chainId=${String(targetChainId)} across [${candidates}]`);
-	}
-	if (chainIdMatches.length > 0) {
-		const families = Array.from(new Set(chainIdMatches.map((chain) => chainFamilyFromNetwork(chain.network))));
-		throw new Error(`[evmNonceBackend] chainId=${String(targetChainId)} is configured for [${families.join(", ")}] but is incompatible with ${requestedChain} routing`);
-	}
-	throw new Error(`[evmNonceBackend] unable to resolve RPC URL for ${requestedChain} ${input.networkKey} (chainId=${String(targetChainId)})`);
-}
-function isSupportedNonceRoutingChain(chain) {
-	const family = chainFamilyFromNetwork(chain.network);
-	return family === "evm" || family === "tempo";
-}
-function isChainCompatibleWithRequestChain(chain, requestedChain) {
-	const family = chainFamilyFromNetwork(chain.network);
-	if (requestedChain === "tempo") return family === "tempo";
-	return family === "evm" || family === "tempo";
-}
-function assertConfiguredChainIdMatchesInput(args) {
-	const configuredChainId = getOptionalConfigChainId(args.chain);
-	if (typeof configuredChainId !== "number") throw new Error(`[evmNonceBackend] configured network ${args.chain.network} is missing numeric chainId`);
-	if (configuredChainId !== args.chainId) throw new Error(`[evmNonceBackend] chainId mismatch for network ${args.networkKey}: expected ${configuredChainId}, received ${String(args.chainId)}`);
-}
-function assertChainSupportsRequestedRoute(args) {
-	if (isChainCompatibleWithRequestChain(args.chain, args.requestedChain)) return;
-	const resolvedFamily = chainFamilyFromNetwork(args.chain.network);
-	throw new Error(`[evmNonceBackend] network ${args.networkKey} (family=${resolvedFamily}) is incompatible with ${args.requestedChain} request (chainId=${String(args.chainId)})`);
-}
-function getOptionalConfigChainId(chain) {
-	return isChainWithChainId(chain) ? chain.chainId : void 0;
-}
-function isChainWithChainId(chain) {
-	return chainFamilyFromNetwork(chain.network) !== "near";
-}
-function mustTrimmedRpcUrl(rpcUrl, network) {
-	const trimmed = String(rpcUrl || "").trim();
-	if (!trimmed) throw new Error(`[evmNonceBackend] missing rpcUrl for ${network}`);
-	return trimmed;
-}
-function normalizeInput(input) {
-	const chain = input.chainTarget.kind;
-	if (chain !== "evm" && chain !== "tempo") throw new Error(`[evmNonceBackend] invalid chain '${String(chain)}'`);
-	const networkKey = String(input.chainTarget.networkSlug || "").trim().toLowerCase();
-	if (!networkKey) throw new Error("[evmNonceBackend] networkKey is required");
-	return {
-		chain,
-		networkKey,
-		chainId: input.chainTarget.chainId,
-		sender: normalizeAddress(input.sender, "sender"),
-		nonceKey: chain === "tempo" ? normalizeBigint(input.nonceKey, "nonceKey") : 0n,
-		walletId: String(toWalletId(input.subjectId))
-	};
-}
-function parseManagedNonceSnapshotChainTarget(snapshot) {
-	if (snapshot.chainTarget) return thresholdEcdsaChainTargetFromRequest(snapshot.chainTarget);
-	const chain = snapshot.chain;
-	if (chain !== "evm" && chain !== "tempo") throw new Error("[evmNonceBackend] invalid managed nonce snapshot: chain");
-	const networkKey = String(snapshot.networkKey || "").trim();
-	if (!networkKey) throw new Error("[evmNonceBackend] invalid managed nonce snapshot: networkKey");
-	const chainId = snapshot.chainId;
-	if (typeof chainId !== "number" || !Number.isSafeInteger(chainId) || chainId <= 0) throw new Error("[evmNonceBackend] invalid managed nonce snapshot: chainId");
-	return thresholdEcdsaChainTargetFromChainFamily({
-		chain,
-		chainId,
-		networkSlug: networkKey
-	});
-}
-function normalizeAddress(value, label) {
-	const normalized = String(value || "").trim().toLowerCase();
-	if (!/^0x[0-9a-f]{40}$/.test(normalized)) throw new Error(`[evmNonceBackend] invalid ${label}: expected 20-byte 0x-prefixed hex`);
-	return normalized;
-}
-function normalizeSender(value) {
-	return normalizeAddress(value, "sender");
-}
-function normalizeTxHash(value) {
-	const normalized = String(value || "").trim().toLowerCase();
-	if (!/^0x[0-9a-f]{64}$/.test(normalized)) throw new Error("[evmNonceBackend] invalid txHash: expected 32-byte 0x-prefixed hex");
-	return normalized;
-}
-function normalizeBigint(value, label) {
-	try {
-		const parsed = BigInt(value);
-		if (parsed < 0n) throw new Error(`[evmNonceBackend] ${label} must be non-negative`);
-		return parsed;
-	} catch {
-		throw new Error(`[evmNonceBackend] invalid ${label}: expected bigint-compatible value`);
-	}
-}
-function normalizeSessionStatusRequiredString(value, label) {
-	const normalized = String(value || "").trim();
-	if (!normalized) throw new Error(`[evmNonceBackend] invalid managed nonce snapshot: ${label}`);
-	return normalized;
-}
-function normalizeOptionalSafeInteger(value) {
-	if (value == null) return void 0;
-	const parsed = Math.floor(Number(value));
-	return Number.isSafeInteger(parsed) ? parsed : void 0;
-}
-function parseRpcHexQuantity(value, method) {
-	const raw = String(value || "").trim();
-	if (!/^0x[0-9a-fA-F]+$/.test(raw)) throw new Error(`[evmNonceBackend] invalid ${method} result: expected hex quantity`);
-	return BigInt(raw);
-}
-//#endregion
-export { createEvmNonceBackend, fromManagedNonceReservationSnapshot, reserveNonceInputFromBoundary, toManagedNonceReservationSnapshot };
-
-//# sourceMappingURL=nonceBackend.js.map

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

@@ -1,56 +0,0 @@
-import { errorMessage } from "../../../shared-ts/src/utils/errors.js";
-import { NearJsonRpcClient, SignedTransaction as SignedTransaction$1 } from "../../../shared-ts/src/near/nearClient.js";
-import { NearRpcError } from "./NearRpcError.js";
-//#region src/core/rpcClients/near/NearClient.ts
-var SignedTransaction = class SignedTransaction extends SignedTransaction$1 {
-	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 } : {}
-		});
-	}
-	static decode() {
-		throw new Error("SignedTransaction.decode(): borsh deserialization not implemented");
-	}
-};
-var MinimalNearClient = class extends NearJsonRpcClient {
-	errorFromRpc(operationName, error) {
-		return NearRpcError.fromRpcError(operationName, error);
-	}
-	errorFromWrappedResult(message) {
-		return new NearRpcError({
-			message,
-			short: "RpcError",
-			type: "RpcError"
-		});
-	}
-	errorFromOutcome(operationName, outcome, failure) {
-		return NearRpcError.fromOutcome(operationName, outcome, failure);
-	}
-	errorFromHttpStatus(response) {
-		if (response.status === 429) return /* @__PURE__ */ new Error("RPC throttled; retry shortly");
-		return super.errorFromHttpStatus(response);
-	}
-	async sendWithRetry(send) {
-		const maxAttempts = 5;
-		let lastError = null;
-		for (let attempt = 1; attempt <= maxAttempts; attempt++) try {
-			return await send();
-		} catch (err) {
-			lastError = err;
-			const msg = errorMessage(err);
-			if (!/server error|internal|temporar|timeout|throttl|too many requests|429|unavailable|bad gateway|gateway timeout/i.test(msg || "") || attempt === maxAttempts) throw err;
-			const base = 200 * Math.pow(2, attempt - 1);
-			const jitter = Math.floor(Math.random() * 150);
-			await new Promise((r) => setTimeout(r, base + jitter));
-		}
-		throw lastError instanceof Error ? lastError : new Error(String(lastError));
-	}
-};
-//#endregion
-export { MinimalNearClient, SignedTransaction };
-
-//# sourceMappingURL=NearClient.js.map

package/dist/esm/react/core/rpcClients/near/NearRpcError.js

@@ -1,105 +0,0 @@
-//#region src/core/rpcClients/near/NearRpcError.ts
-function isObj(v) {
-	return !!v && typeof v === "object" && !Array.isArray(v);
-}
-function firstKey(o) {
-	if (!o) return void 0;
-	const keys = Object.keys(o);
-	return keys.length ? keys[0] : void 0;
-}
-var NearRpcError = class NearRpcError extends Error {
-	constructor(params) {
-		super(params.message);
-		this.name = params.name || "NearRpcError";
-		this.code = params.code;
-		this.type = params.type || "Unknown";
-		this.kind = params.kind;
-		this.index = params.index;
-		this.short = params.short;
-		this.details = params.details;
-		this.operation = params.operation;
-	}
-	static fromOutcome(operationName, outcome, failure) {
-		const { message, type, kind, index, short } = describeFailure(operationName, failure);
-		return new NearRpcError({
-			message: message || `${operationName} failed`,
-			short: short || kind || "TxExecutionError",
-			type: type || "Failure",
-			kind,
-			index,
-			name: "TxExecutionFailure",
-			operation: operationName,
-			details: {
-				Failure: failure,
-				outcome
-			}
-		});
-	}
-	static fromRpcError(operationName, err) {
-		const details = err.data;
-		const { message, type, kind, index, short } = describeDetails(operationName, details, err.message);
-		return new NearRpcError({
-			message: message || err.message || `${operationName} RPC error`,
-			short: short || kind || "RPC error",
-			type: type || "RpcError",
-			kind,
-			index,
-			code: typeof err.code === "number" ? err.code : void 0,
-			name: err.name || "NearRpcError",
-			operation: operationName,
-			details
-		});
-	}
-};
-function describeDetails(operationName, details, rpcMessage = "") {
-	const d = isObj(details) ? details : void 0;
-	const txExec = isObj(d?.TxExecutionError) ? d.TxExecutionError : void 0;
-	if (!txExec) {
-		const detail = typeof details === "string" && details.trim() ? details.trim() : d ? JSON.stringify(d) : rpcMessage.trim();
-		return { message: `${operationName} RPC error${detail ? `: ${detail}` : ""}` };
-	}
-	return describeTxExecution(operationName, txExec);
-}
-function describeFailure(operationName, failure) {
-	const f = isObj(failure) ? failure : void 0;
-	if (!f) return { message: `${operationName} failed (Unknown Failure)` };
-	return describeTxExecution(operationName, f);
-}
-function describeTxExecution(operationName, exec) {
-	if (isObj(exec.InvalidTxError)) {
-		const inv = exec.InvalidTxError;
-		let kind = firstKey(inv) || "InvalidTxError";
-		if (isObj(inv.ActionsValidation)) kind = `ActionsValidation.${firstKey(inv.ActionsValidation)}`;
-		const short = kind.startsWith("ActionsValidation.") ? `InvalidTxError: ${kind.split(".")[1] || "ActionsValidation"}` : `InvalidTxError: ${kind}`;
-		return {
-			message: `${operationName} failed (InvalidTxError: ${kind})`,
-			type: "InvalidTxError",
-			kind,
-			short
-		};
-	}
-	if (isObj(exec.ActionError)) {
-		const ae = exec.ActionError;
-		const idx = typeof ae.index === "number" ? ae.index : void 0;
-		const kind = firstKey(isObj(ae.kind) ? ae.kind : void 0) || "ActionError";
-		const idxStr = typeof idx === "number" ? ` at action ${idx}` : "";
-		const short = `ActionError: ${kind}`;
-		return {
-			message: `${operationName} failed${idxStr} (ActionError: ${kind})`,
-			type: "ActionError",
-			kind,
-			index: idx,
-			short
-		};
-	}
-	return {
-		message: `${operationName} failed (TxExecutionError)`,
-		type: "TxExecutionError",
-		kind: "TxExecutionError",
-		short: "TxExecutionError"
-	};
-}
-//#endregion
-export { NearRpcError };
-
-//# sourceMappingURL=NearRpcError.js.map