@seams/wallet 0.7.3 → 0.8.0

package/dist/public/sdk/types-Dx9fczU7.js

@@ -1,111 +0,0 @@
-import { S as parseThresholdEd25519SessionId, o as parseEmailOtpChallengeId, x as parseThresholdEcdsaSessionId } from "./domainIds-lcrFg6Sa.js";
-import { d as parseMpcWalletSigningQuotaId, h as parseWalletSessionId } from "./capabilityKinds-hvYqa6S_.js";
-import { n as SIGNER_AUTH_METHODS } from "./signerDomain-IEAVrOrc.js";
-//#region src/core/signingEngine/session/identity/signingLaneAuthBinding.ts
-function signingLaneAuthMethod(auth) {
-	switch (auth.kind) {
-		case SIGNER_AUTH_METHODS.passkey: return SIGNER_AUTH_METHODS.passkey;
-		case SIGNER_AUTH_METHODS.emailOtp: return SIGNER_AUTH_METHODS.emailOtp;
-	}
-	throw new Error("[SigningSession] unsupported signing lane auth binding");
-}
-function requireSigningLaneAuthKeyPart(value, label) {
-	const normalized = String(value || "").trim();
-	if (!normalized) throw new Error(`[SigningSession] ${label} is required for signing lane authority`);
-	return normalized;
-}
-function signingLaneAuthBindingKey(auth) {
-	switch (auth.kind) {
-		case SIGNER_AUTH_METHODS.passkey: return [
-			SIGNER_AUTH_METHODS.passkey,
-			requireSigningLaneAuthKeyPart(String(auth.rpId), "passkey rpId"),
-			requireSigningLaneAuthKeyPart(auth.credentialIdB64u, "passkey credential")
-		].join(":");
-		case SIGNER_AUTH_METHODS.emailOtp: return [SIGNER_AUTH_METHODS.emailOtp, requireSigningLaneAuthKeyPart(auth.providerSubjectId, "Email OTP provider subject")].join(":");
-	}
-	throw new Error("[SigningSession] unsupported signing lane auth binding");
-}
-//#endregion
-//#region src/core/signingEngine/session/operationState/types.ts
-const SigningOperationIntent = { TransactionSign: "transaction_sign" };
-const SigningKeyRefIntentKind = {
-	Cached: "cached",
-	Reauth: "reauth"
-};
-const SigningSessionPlanKind = {
-	WarmSession: "warm_session",
-	EmailOtpReauth: "email_otp_reauth",
-	PasskeyReauth: "passkey_reauth",
-	NotReady: "not_ready",
-	OperationStepUp: "operation_step_up"
-};
-function toRequiredBrandedString(value, label) {
-	const normalized = String(value || "").trim();
-	if (!normalized) throw new Error(`[SigningSession] ${label} is required`);
-	return normalized;
-}
-function requireDomainId(result, label) {
-	if (!result.ok) throw new Error(`[SigningSession] ${result.error.message || `${label} is required`}`);
-	return result.value;
-}
-function requireAuthorizationId(result, label) {
-	if (!result.ok) throw new Error(`[SigningSession] ${result.error.message || `${label} is required`}`);
-	return result.value;
-}
-const SigningSessionIds = {
-	walletSession(value) {
-		return requireAuthorizationId(parseWalletSessionId(value), "walletSessionId");
-	},
-	walletSessionQuota(value) {
-		return requireAuthorizationId(parseMpcWalletSigningQuotaId(value), "quotaId");
-	},
-	thresholdEd25519Session(value) {
-		return requireDomainId(parseThresholdEd25519SessionId(value), "thresholdEd25519SessionId");
-	},
-	thresholdEcdsaSession(value) {
-		return requireDomainId(parseThresholdEcdsaSessionId(value), "thresholdEcdsaSessionId");
-	},
-	emailOtpChallenge(value) {
-		return requireDomainId(parseEmailOtpChallengeId(value), "emailOtpChallengeId");
-	},
-	signingOperation(value) {
-		return toRequiredBrandedString(value, "signingOperationId");
-	},
-	signingOperationFingerprint(value) {
-		return toRequiredBrandedString(value, "signingOperationFingerprint");
-	}
-};
-function summarizeSigningLane(lane) {
-	const signer = lane.identity.signer;
-	const summary = {
-		authMethod: signingLaneAuthMethod(lane.auth),
-		curve: lane.curve,
-		keyKind: lane.keyKind,
-		chainFamily: lane.chainFamily,
-		sessionOrigin: lane.sessionOrigin,
-		storageSource: lane.storageSource,
-		retention: lane.retention
-	};
-	switch (signer.kind) {
-		case "evm_family_ecdsa_signer": return {
-			...summary,
-			curve: "ecdsa",
-			walletId: signer.walletId
-		};
-		case "near_ed25519_signer": return {
-			...summary,
-			curve: "ed25519",
-			walletId: signer.account.wallet.walletId,
-			nearAccountId: signer.account.nearAccountId,
-			nearEd25519SigningKeyId: signer.nearEd25519SigningKeyId
-		};
-	}
-}
-function summarizeSigningSessionPlan(plan) {
-	return {
-		kind: plan.kind,
-		lane: summarizeSigningLane(plan.lane)
-	};
-}
-//#endregion
-export { summarizeSigningLane as a, signingLaneAuthMethod as c, SigningSessionPlanKind as i, SigningOperationIntent as n, summarizeSigningSessionPlan as o, SigningSessionIds as r, signingLaneAuthBindingKey as s, SigningKeyRefIntentKind as t };

package/dist/public/sdk/validation-gat4LEKm.js

@@ -1,409 +0,0 @@
-import { B as normalizeTrimmedString, z as normalizeOptionalTrimmedString } from "./domainIds-lcrFg6Sa.js";
-//#region ../../node_modules/base-x/src/esm/index.js
-function base(ALPHABET) {
-	if (ALPHABET.length >= 255) throw new TypeError("Alphabet too long");
-	const BASE_MAP = new Uint8Array(256);
-	for (let j = 0; j < BASE_MAP.length; j++) BASE_MAP[j] = 255;
-	for (let i = 0; i < ALPHABET.length; i++) {
-		const x = ALPHABET.charAt(i);
-		const xc = x.charCodeAt(0);
-		if (BASE_MAP[xc] !== 255) throw new TypeError(x + " is ambiguous");
-		BASE_MAP[xc] = i;
-	}
-	const BASE = ALPHABET.length;
-	const LEADER = ALPHABET.charAt(0);
-	const FACTOR = Math.log(BASE) / Math.log(256);
-	const iFACTOR = Math.log(256) / Math.log(BASE);
-	function encode(source) {
-		if (source instanceof Uint8Array) {} else if (ArrayBuffer.isView(source)) source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
-		else if (Array.isArray(source)) source = Uint8Array.from(source);
-		if (!(source instanceof Uint8Array)) throw new TypeError("Expected Uint8Array");
-		if (source.length === 0) return "";
-		let zeroes = 0;
-		let length = 0;
-		let pbegin = 0;
-		const pend = source.length;
-		while (pbegin !== pend && source[pbegin] === 0) {
-			pbegin++;
-			zeroes++;
-		}
-		const size = (pend - pbegin) * iFACTOR + 1 >>> 0;
-		const b58 = new Uint8Array(size);
-		while (pbegin !== pend) {
-			let carry = source[pbegin];
-			let i = 0;
-			for (let it1 = size - 1; (carry !== 0 || i < length) && it1 !== -1; it1--, i++) {
-				carry += 256 * b58[it1] >>> 0;
-				b58[it1] = carry % BASE >>> 0;
-				carry = carry / BASE >>> 0;
-			}
-			if (carry !== 0) throw new Error("Non-zero carry");
-			length = i;
-			pbegin++;
-		}
-		let it2 = size - length;
-		while (it2 !== size && b58[it2] === 0) it2++;
-		let str = LEADER.repeat(zeroes);
-		for (; it2 < size; ++it2) str += ALPHABET.charAt(b58[it2]);
-		return str;
-	}
-	function decodeUnsafe(source) {
-		if (typeof source !== "string") throw new TypeError("Expected String");
-		if (source.length === 0) return new Uint8Array();
-		let psz = 0;
-		let zeroes = 0;
-		let length = 0;
-		while (source[psz] === LEADER) {
-			zeroes++;
-			psz++;
-		}
-		const size = (source.length - psz) * FACTOR + 1 >>> 0;
-		const b256 = new Uint8Array(size);
-		while (psz < source.length) {
-			const charCode = source.charCodeAt(psz);
-			if (charCode > 255) return;
-			let carry = BASE_MAP[charCode];
-			if (carry === 255) return;
-			let i = 0;
-			for (let it3 = size - 1; (carry !== 0 || i < length) && it3 !== -1; it3--, i++) {
-				carry += BASE * b256[it3] >>> 0;
-				b256[it3] = carry % 256 >>> 0;
-				carry = carry / 256 >>> 0;
-			}
-			if (carry !== 0) throw new Error("Non-zero carry");
-			length = i;
-			psz++;
-		}
-		let it4 = size - length;
-		while (it4 !== size && b256[it4] === 0) it4++;
-		const vch = new Uint8Array(zeroes + (size - it4));
-		let j = zeroes;
-		while (it4 !== size) vch[j++] = b256[it4++];
-		return vch;
-	}
-	function decode(string) {
-		const buffer = decodeUnsafe(string);
-		if (buffer) return buffer;
-		throw new Error("Non-base" + BASE + " character");
-	}
-	return {
-		encode,
-		decodeUnsafe,
-		decode
-	};
-}
-var esm_default = base("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz");
-//#endregion
-//#region ../shared-ts/src/utils/base58.ts
-/**
-* Encodes binary data to base58 string using Bitcoin's base58 alphabet.
-*
-* @param data - Binary data to encode (Uint8Array, ArrayBuffer, or number[])
-* @returns Base58-encoded string
-*/
-const base58Encode = (data) => {
-	if (data instanceof ArrayBuffer) return esm_default.encode(new Uint8Array(data));
-	if (Array.isArray(data)) return esm_default.encode(new Uint8Array(data));
-	return esm_default.encode(data);
-};
-/**
-* Decodes a base58 string to binary data using Bitcoin's base58 alphabet.
-* Returns a Uint8Array containing the decoded bytes.
-*
-* @param base58String - Base58-encoded string to decode
-* @returns Uint8Array containing the decoded bytes
-* @throws Error if input contains invalid base58 characters
-*/
-const base58Decode = (base58String) => {
-	return esm_default.decode(base58String);
-};
-//#endregion
-//#region ../shared-ts/src/utils/near.ts
-/**
-* NEAR-specific utility helpers.
-*
-* Keep chain-specific parsing and validation logic here so generic utility
-* modules (`validation`, `errors`, `encoders`, etc.) stay chain-agnostic.
-*/
-/**
-* Ensure a key string has the NEAR Ed25519 prefix (`ed25519:`).
-*
-* - Accepts either `ed25519:<base58>` or a bare `<base58>` string.
-* - Canonicalizes `ED25519:` -> `ed25519:`.
-* - If a different prefix is present (e.g. `secp256k1:`), returns the input unchanged.
-*/
-function ensureEd25519Prefix(value) {
-	const raw = String(value ?? "").trim();
-	if (!raw) return "";
-	if (/^[a-z0-9_]+:/i.test(raw)) {
-		if (/^ed25519:/i.test(raw)) return `ed25519:${raw.replace(/^ed25519:/i, "")}`;
-		return raw;
-	}
-	return `ed25519:${raw}`;
-}
-/**
-* Validate NEAR account ID format with optional suffix restrictions.
-*/
-function validateNearAccountId(nearAccountId, options = {
-	allowedSuffixes: ["testnet", "near"],
-	requireTopLevelDomain: false
-}) {
-	if (!nearAccountId || typeof nearAccountId !== "string") return {
-		valid: false,
-		error: "Account ID must be a non-empty string"
-	};
-	if (isImplicitNearAccountId(nearAccountId)) return { valid: true };
-	const parts = nearAccountId.split(".");
-	if (parts.length < 2) return {
-		valid: false,
-		error: "Account ID must be a named account containing a dot or a 64-character implicit account hex ID"
-	};
-	if (options.requireTopLevelDomain && parts.length !== 2) return {
-		valid: false,
-		error: `Invalid NEAR account ID format. Expected format: <username>.<suffix> where suffix is one of: ${options.allowedSuffixes?.join(", ") || "valid suffixes"}`
-	};
-	const username = parts[0];
-	const suffix = parts[parts.length - 1];
-	const domain = parts.slice(1).join(".");
-	if (!username || username.length === 0) return {
-		valid: false,
-		error: "Username part cannot be empty"
-	};
-	if (!/^[a-z0-9_-]+$/.test(username)) return {
-		valid: false,
-		error: "Username can only contain lowercase letters, numbers, underscores, and hyphens"
-	};
-	if (!domain || domain.length === 0) return {
-		valid: false,
-		error: "Domain part cannot be empty"
-	};
-	if (options.allowedSuffixes && options.allowedSuffixes.length > 0) {
-		if (!options.allowedSuffixes.some((allowedSuffix) => {
-			if (!allowedSuffix.includes(".")) return suffix === allowedSuffix;
-			return nearAccountId.endsWith(`.${allowedSuffix}`);
-		})) return {
-			valid: false,
-			error: `Invalid NEAR account ID suffix. Expected account to end with one of: ${options.allowedSuffixes.join(", ")}`
-		};
-	}
-	return { valid: true };
-}
-/**
-* Lightweight NEAR account ID validation used by server-side helpers.
-* - length: 2..64
-* - chars: lowercase letters, digits, `_`, `.`, `-`
-*/
-function isValidAccountId(accountId) {
-	if (typeof accountId !== "string") return false;
-	if (!accountId || accountId.length < 2 || accountId.length > 64) return false;
-	return /^[a-z0-9_.-]+$/.test(accountId);
-}
-function isImplicitNearAccountId(value) {
-	return typeof value === "string" && /^[0-9a-f]{64}$/.test(value);
-}
-function compactImplicitNearAccountId(value) {
-	if (!isImplicitNearAccountId(value)) return null;
-	return `${value.slice(0, 8)}...${value.slice(-6)}`;
-}
-function parseImplicitNearAccountId(raw) {
-	const value = typeof raw === "string" ? raw.trim() : "";
-	if (!value) return {
-		ok: false,
-		code: "missing",
-		message: "implicit NEAR account ID is required"
-	};
-	if (!isImplicitNearAccountId(value)) return {
-		ok: false,
-		code: "invalid",
-		message: "implicit NEAR account ID must be 64 lowercase hex characters"
-	};
-	return {
-		ok: true,
-		value
-	};
-}
-function parseNamedNearAccountId(raw) {
-	const value = typeof raw === "string" ? raw.trim() : "";
-	if (!value) return {
-		ok: false,
-		code: "missing",
-		message: "named NEAR account ID is required"
-	};
-	if (isImplicitNearAccountId(value) || !isValidAccountId(value) || !value.includes(".")) return {
-		ok: false,
-		code: "invalid",
-		message: "named NEAR account ID must be a valid named account containing a dot"
-	};
-	return {
-		ok: true,
-		value
-	};
-}
-function parseNearAccountId(raw) {
-	const value = typeof raw === "string" ? raw.trim() : "";
-	if (!value) return {
-		ok: false,
-		code: "missing",
-		message: "NEAR account ID is required"
-	};
-	if (isImplicitNearAccountId(value)) return {
-		ok: true,
-		value
-	};
-	return parseNamedNearAccountId(value);
-}
-function bytesToLowerHex(bytes) {
-	return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
-}
-function deriveImplicitNearAccountIdFromEd25519PublicKey(publicKey) {
-	const normalized = ensureEd25519Prefix(publicKey);
-	const encoded = normalized.startsWith("ed25519:") ? normalized.slice(8) : "";
-	if (!encoded) throw new Error("Ed25519 public key is required");
-	const decoded = base58Decode(encoded);
-	if (decoded.length !== 32) throw new Error("Ed25519 public key must decode to 32 bytes");
-	return bytesToLowerHex(decoded);
-}
-/**
-* Extract a short NEAR error label for UI display, e.g.:
-*   "InvalidTxError: UnsuitableStakingKey"
-* Falls back to undefined when structure is not recognized.
-*/
-function getNearShortErrorMessage(error) {
-	try {
-		const details = error?.details;
-		const isObj = (v) => !!v && typeof v === "object" && !Array.isArray(v);
-		if (!isObj(details)) return void 0;
-		const txExec = details.TxExecutionError;
-		if (isObj(txExec)) {
-			if (isObj(txExec.InvalidTxError)) {
-				const inv = txExec.InvalidTxError;
-				if (isObj(inv.ActionsValidation)) {
-					const kind = Object.keys(inv.ActionsValidation)[0];
-					if (kind) return `InvalidTxError: ${kind}`;
-				}
-				const first = Object.keys(inv)[0];
-				if (first) return `InvalidTxError: ${first}`;
-				return "InvalidTxError";
-			}
-			if (isObj(txExec.ActionError)) {
-				const ae = txExec.ActionError;
-				const kindObj = isObj(ae.kind) ? ae.kind : void 0;
-				const kind = kindObj ? Object.keys(kindObj)[0] : void 0;
-				if (kind) return `ActionError: ${kind}`;
-				return "ActionError";
-			}
-		}
-		const failure = details.Failure;
-		if (isObj(failure)) {
-			if (isObj(failure.InvalidTxError)) {
-				const inv = failure.InvalidTxError;
-				if (isObj(inv.ActionsValidation)) {
-					const kind = Object.keys(inv.ActionsValidation)[0];
-					if (kind) return `InvalidTxError: ${kind}`;
-				}
-				const first = Object.keys(inv)[0];
-				if (first) return `InvalidTxError: ${first}`;
-				return "InvalidTxError";
-			}
-			if (isObj(failure.ActionError)) {
-				const ae = failure.ActionError;
-				const kindObj = isObj(ae.kind) ? ae.kind : void 0;
-				const kind = kindObj ? Object.keys(kindObj)[0] : void 0;
-				if (kind) return `ActionError: ${kind}`;
-				return "ActionError";
-			}
-		}
-		return;
-	} catch {
-		return;
-	}
-}
-//#endregion
-//#region ../shared-ts/src/utils/validation.ts
-function requireTrimmedString(value, label, message = "is required") {
-	const parsed = normalizeOptionalTrimmedString(value);
-	if (!parsed) throw new Error(`${label} ${message}`);
-	return parsed;
-}
-function toOptionalTrimmedNonEmptyString(value) {
-	return normalizeOptionalTrimmedString(value) || void 0;
-}
-function requireNonEmptyString(value, label) {
-	return requireTrimmedString(value, label, "must be a non-empty string");
-}
-function requireCanonicalString(value, label, message = "is invalid") {
-	if (typeof value !== "string" || value.length === 0 || value.trim() !== value) throw new Error(`${label} ${message}`);
-	return value;
-}
-function coerceNonEmptyString(value, label) {
-	const normalized = String(value || "").trim();
-	if (!normalized) throw new Error(`${label} is required`);
-	return normalized;
-}
-function coerceNonNullishString(value, label) {
-	const normalized = normalizeTrimmedString(value);
-	if (!normalized) throw new Error(`${label} is required`);
-	return normalized;
-}
-function isObject(x) {
-	return x !== null && typeof x === "object";
-}
-function isPlainObject(x) {
-	return isObject(x) && !Array.isArray(x);
-}
-function isString(x) {
-	return typeof x === "string";
-}
-function isFunction(x) {
-	return typeof x === "function";
-}
-function isBoolean(x) {
-	return typeof x === "boolean";
-}
-function isArray(x) {
-	return Array.isArray(x);
-}
-function asRecord(value) {
-	return isPlainObject(value) ? value : null;
-}
-function asRecordOrArray(value) {
-	return isObject(value) ? value : null;
-}
-function requireRecord(value, label) {
-	if (!isPlainObject(value)) throw new Error(`${label} must be an object`);
-	return value;
-}
-function requireRecordCopy(value, label) {
-	return Object.fromEntries(Object.entries(requireRecord(value, label)));
-}
-function requireArray(value, label) {
-	if (!Array.isArray(value)) throw new Error(`${label} must be an array`);
-	return value;
-}
-function assertString(val, name = "value") {
-	if (typeof val !== "string") throw new Error(`Invalid ${name}: expected string`);
-	return val;
-}
-function stripFunctionsShallow(obj) {
-	if (!obj || !isObject(obj)) return void 0;
-	const out = {};
-	for (const [k, v] of Object.entries(obj)) if (!isFunction(v)) out[k] = v;
-	return out;
-}
-function isPlainSignedTransactionLike(x) {
-	if (!isObject(x)) return false;
-	const hasTx = "transaction" in x;
-	const hasSig = "signature" in x;
-	const bytes = x;
-	const hasBytes = Array.isArray(bytes.borsh_bytes) || bytes.borshBytes instanceof Uint8Array;
-	const hasMethod = typeof x.base64Encode === "function";
-	return hasTx && hasSig && hasBytes && !hasMethod;
-}
-function extractBorshBytesFromPlainSignedTx(x) {
-	const asArray = Array.isArray(x.borsh_bytes) ? x.borsh_bytes : void 0;
-	if (asArray) return asArray;
-	const asU8 = x.borshBytes instanceof Uint8Array ? x.borshBytes : void 0;
-	return Array.from(asU8 || new Uint8Array());
-}
-//#endregion
-export { validateNearAccountId as A, deriveImplicitNearAccountIdFromEd25519PublicKey as C, parseImplicitNearAccountId as D, isImplicitNearAccountId as E, base58Encode as M, parseNamedNearAccountId as O, compactImplicitNearAccountId as S, getNearShortErrorMessage as T, requireRecord as _, coerceNonNullishString as a, stripFunctionsShallow as b, isBoolean as c, isPlainObject as d, isPlainSignedTransactionLike as f, requireNonEmptyString as g, requireCanonicalString as h, coerceNonEmptyString as i, base58Decode as j, parseNearAccountId as k, isFunction as l, requireArray as m, asRecordOrArray as n, extractBorshBytesFromPlainSignedTx as o, isString as p, assertString as r, isArray as s, asRecord as t, isObject as u, requireRecordCopy as v, ensureEd25519Prefix as w, toOptionalTrimmedNonEmptyString as x, requireTrimmedString as y };