@seams/wallet 0.7.3 → 0.8.0

package/dist/esm/react/shared-ts/src/utils/routerAbEd25519YaoDigests.js

@@ -1,76 +0,0 @@
-//#region ../shared-ts/src/utils/routerAbEd25519YaoDigests.ts
-const APPLICATION_BINDING_DOMAIN = "seams/router-ab/ed25519-yao/application-binding/v1";
-const UTF8 = new TextEncoder();
-function requireVisibleIdentifier(value, label) {
-	if (typeof value !== "string" || value.length === 0) throw new Error(`${label} must be a non-empty visible ASCII string`);
-	for (let index = 0; index < value.length; index += 1) {
-		const code = value.charCodeAt(index);
-		if (code < 33 || code > 126) throw new Error(`${label} must contain visible ASCII bytes`);
-	}
-	return value;
-}
-function requireByte(value, label) {
-	if (typeof value !== "number" || !Number.isInteger(value) || value < 0 || value > 255) throw new Error(`${label} must be a byte`);
-	return value;
-}
-function requireBytes(value, label, minimumLength, maximumLength) {
-	if (!Array.isArray(value)) throw new Error(`${label} must be a byte array`);
-	if (value.length < minimumLength || value.length > maximumLength) throw new Error(`${label} has an invalid length`);
-	const parsed = [];
-	for (let index = 0; index < value.length; index += 1) parsed.push(requireByte(value[index], `${label}[${index}]`));
-	return parsed;
-}
-function requireBytes32(value, label, nonzero) {
-	const parsed = requireBytes(value, label, 32, 32);
-	if (nonzero && isZeroBytes(parsed)) throw new Error(`${label} must be nonzero`);
-	return parsed;
-}
-function isZeroBytes(value) {
-	for (const byte of value) if (byte !== 0) return false;
-	return true;
-}
-function equalBytes(left, right) {
-	if (left.length !== right.length) return false;
-	for (let index = 0; index < left.length; index += 1) if (left[index] !== right[index]) return false;
-	return true;
-}
-function u32BigEndian(value) {
-	const bytes = new Uint8Array(4);
-	new DataView(bytes.buffer).setUint32(0, value, false);
-	return bytes;
-}
-function concatenateBytes(chunks) {
-	let length = 0;
-	for (const chunk of chunks) length += chunk.length;
-	const output = new Uint8Array(length);
-	let offset = 0;
-	for (const chunk of chunks) {
-		output.set(chunk, offset);
-		offset += chunk.length;
-	}
-	return output;
-}
-function lengthDelimited(value) {
-	return concatenateBytes([u32BigEndian(value.length), value]);
-}
-function labeledField(label, value) {
-	return concatenateBytes([lengthDelimited(UTF8.encode(label)), lengthDelimited(value)]);
-}
-async function sha256(value) {
-	const digest = await globalThis.crypto.subtle.digest("SHA-256", value);
-	return new Uint8Array(digest);
-}
-async function deriveRouterAbEd25519YaoApplicationBindingDigestV1(facts) {
-	const encoded = concatenateBytes([
-		lengthDelimited(UTF8.encode(APPLICATION_BINDING_DOMAIN)),
-		labeledField("walletId", UTF8.encode(facts.wallet_id)),
-		labeledField("nearEd25519SigningKeyId", UTF8.encode(facts.near_ed25519_signing_key_id)),
-		labeledField("signingRootId", UTF8.encode(facts.signing_root_id)),
-		labeledField("keyCreationSignerSlot", u32BigEndian(facts.key_creation_signer_slot))
-	]);
-	return Array.from(await sha256(encoded));
-}
-//#endregion
-export { deriveRouterAbEd25519YaoApplicationBindingDigestV1, equalBytes, requireBytes, requireBytes32, requireVisibleIdentifier };
-
-//# sourceMappingURL=routerAbEd25519YaoDigests.js.map

package/dist/esm/react/shared-ts/src/utils/routerAbNormalSigningIdentity.js

@@ -1,115 +0,0 @@
-import { requireRecord } from "./validation.js";
-import { parseMpcMaterialActivationRef } from "./domainIds.js";
-//#region ../shared-ts/src/utils/routerAbNormalSigningIdentity.ts
-function requireExactFields(record, expectedFields, label) {
-	const actualFields = Object.keys(record).sort();
-	const expected = [...expectedFields].sort();
-	if (actualFields.length !== expected.length || actualFields.some((field, index) => field !== expected[index])) throw new Error(`${label} has invalid fields`);
-}
-function requireAsciiString(value, label) {
-	if (typeof value !== "string" || value.trim() !== value || !value) throw new Error(`${label} is required`);
-	if (!/^[\x20-\x7e]+$/.test(value)) throw new Error(`${label} must be printable ASCII`);
-	return value;
-}
-function parseRouterAbNormalSigningAuthorization(value) {
-	const authorization = requireRecord(value, "authorization");
-	switch (authorization.kind) {
-		case "reusable_wallet_session":
-			requireExactFields(authorization, ["kind", "wallet_session_id"], "authorization");
-			return {
-				kind: "reusable_wallet_session",
-				wallet_session_id: requireAsciiString(authorization.wallet_session_id, "authorization.wallet_session_id")
-			};
-		case "operation_step_up":
-			requireExactFields(authorization, ["kind"], "authorization");
-			return { kind: "operation_step_up" };
-		default: throw new Error("authorization.kind is not supported");
-	}
-}
-function parseRouterAbMpcMaterialActivationRef(value) {
-	const activation = requireRecord(value, "material_activation");
-	requireExactFields(activation, [
-		"kind",
-		"activation_id",
-		"capability",
-		"material_owner",
-		"key_binding",
-		"lifecycle_binding",
-		"signing_worker"
-	], "material_activation");
-	if (activation.kind !== "mpc_material_activation_ref") throw new Error("material_activation.kind is not supported");
-	return {
-		kind: "mpc_material_activation_ref",
-		activation_id: requireAsciiString(activation.activation_id, "material_activation.activation_id"),
-		capability: requireAsciiString(activation.capability, "material_activation.capability"),
-		material_owner: requireAsciiString(activation.material_owner, "material_activation.material_owner"),
-		key_binding: requireAsciiString(activation.key_binding, "material_activation.key_binding"),
-		lifecycle_binding: requireAsciiString(activation.lifecycle_binding, "material_activation.lifecycle_binding"),
-		signing_worker: requireAsciiString(activation.signing_worker, "material_activation.signing_worker")
-	};
-}
-function routerAbMpcMaterialActivationRefToWire(input) {
-	return parseRouterAbMpcMaterialActivationRef({
-		kind: input.kind,
-		activation_id: input.activationId,
-		capability: input.capability,
-		material_owner: input.materialOwner,
-		key_binding: input.keyBinding,
-		lifecycle_binding: input.lifecycleBinding,
-		signing_worker: input.signingWorker
-	});
-}
-function routerAbMpcMaterialActivationRefFromWire(value) {
-	const wire = parseRouterAbMpcMaterialActivationRef(value);
-	const parsed = parseMpcMaterialActivationRef({
-		kind: wire.kind,
-		activationId: wire.activation_id,
-		capability: wire.capability,
-		materialOwner: wire.material_owner,
-		keyBinding: wire.key_binding,
-		lifecycleBinding: wire.lifecycle_binding,
-		signingWorker: wire.signing_worker
-	});
-	if (!parsed.ok) throw new Error(`material_activation is invalid: ${parsed.error.message}`);
-	return parsed.value;
-}
-function asciiBytes(value) {
-	return new TextEncoder().encode(value);
-}
-function appendLen32(out, value) {
-	const bytes = asciiBytes(value);
-	const length = bytes.length >>> 0;
-	out.push(length >>> 24 & 255, length >>> 16 & 255, length >>> 8 & 255, length & 255);
-	out.push(...bytes);
-}
-function canonicalRouterAbNormalSigningAuthorizationBytes(value) {
-	const authorization = parseRouterAbNormalSigningAuthorization(value);
-	const out = [];
-	appendLen32(out, authorization.kind);
-	switch (authorization.kind) {
-		case "reusable_wallet_session":
-			appendLen32(out, authorization.wallet_session_id);
-			break;
-		case "operation_step_up": break;
-	}
-	return new Uint8Array(out);
-}
-function canonicalRouterAbMpcMaterialActivationRefBytes(value) {
-	const activation = parseRouterAbMpcMaterialActivationRef(value);
-	const out = [];
-	appendLen32(out, activation.kind);
-	appendLen32(out, activation.activation_id);
-	appendLen32(out, activation.capability);
-	appendLen32(out, activation.material_owner);
-	appendLen32(out, activation.key_binding);
-	appendLen32(out, activation.lifecycle_binding);
-	appendLen32(out, activation.signing_worker);
-	return new Uint8Array(out);
-}
-function sameRouterAbMpcMaterialActivationRef(left, right) {
-	return left.kind === right.kind && left.activation_id === right.activation_id && left.capability === right.capability && left.material_owner === right.material_owner && left.key_binding === right.key_binding && left.lifecycle_binding === right.lifecycle_binding && left.signing_worker === right.signing_worker;
-}
-//#endregion
-export { canonicalRouterAbMpcMaterialActivationRefBytes, canonicalRouterAbNormalSigningAuthorizationBytes, parseRouterAbMpcMaterialActivationRef, parseRouterAbNormalSigningAuthorization, routerAbMpcMaterialActivationRefFromWire, routerAbMpcMaterialActivationRefToWire, sameRouterAbMpcMaterialActivationRef };
-
-//# sourceMappingURL=routerAbNormalSigningIdentity.js.map

package/dist/esm/react/shared-ts/src/utils/routerAbPublicKeyset.js

@@ -1,11 +0,0 @@
-import { coerceNonEmptyString } from "./validation.js";
-//#region ../shared-ts/src/utils/routerAbPublicKeyset.ts
-function requireRouterAbX25519PublicKey(value, label) {
-	const publicKey = coerceNonEmptyString(value, label);
-	if (!/^x25519:[0-9a-f]{64}$/.test(publicKey)) throw new Error(`${label} must use x25519:<64 lowercase hex chars> encoding`);
-	return publicKey;
-}
-//#endregion
-export { requireRouterAbX25519PublicKey };
-
-//# sourceMappingURL=routerAbPublicKeyset.js.map

package/dist/esm/react/shared-ts/src/utils/routerAbTraceContext.js

@@ -1,36 +0,0 @@
-//#region ../shared-ts/src/utils/routerAbTraceContext.ts
-const ROUTER_AB_TRACE_ID_HEADER_V1 = "x-seams-trace-id";
-const TRACE_ID_PATTERN = /^[0-9a-f]{32}$/;
-function parseRouterAbTraceContextV1(raw) {
-	if (raw === null || raw === void 0 || raw === "") return {
-		ok: false,
-		reason: "missing",
-		message: "Router trace ID is missing"
-	};
-	if (typeof raw !== "string" || !TRACE_ID_PATTERN.test(raw)) return {
-		ok: false,
-		reason: "invalid",
-		message: "Router trace ID must be 32 lowercase hexadecimal characters"
-	};
-	return {
-		ok: true,
-		value: {
-			kind: "router_ab_trace_context_v1",
-			value: raw
-		}
-	};
-}
-function createRouterAbTraceContextV1() {
-	const bytes = new Uint8Array(16);
-	globalThis.crypto.getRandomValues(bytes);
-	let value = "";
-	for (const byte of bytes) value += byte.toString(16).padStart(2, "0");
-	return {
-		kind: "router_ab_trace_context_v1",
-		value
-	};
-}
-//#endregion
-export { ROUTER_AB_TRACE_ID_HEADER_V1, createRouterAbTraceContextV1, parseRouterAbTraceContextV1 };
-
-//# sourceMappingURL=routerAbTraceContext.js.map

package/dist/esm/react/shared-ts/src/utils/secureRandomId.js

@@ -1,35 +0,0 @@
-import { base64UrlEncode } from "./base64.js";
-//#region ../shared-ts/src/utils/secureRandomId.ts
-const DEFAULT_SECURE_RANDOM_ID_BYTES = 32;
-const BASE36_ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyz";
-function secureRandomBytes(length = DEFAULT_SECURE_RANDOM_ID_BYTES, label = "secure random bytes") {
-	const byteLength = Math.max(1, Math.floor(Number(length) || 0));
-	const cryptoApi = globalThis.crypto;
-	if (typeof cryptoApi?.getRandomValues !== "function") throw new Error(`WebCrypto getRandomValues is required for ${label}`);
-	return cryptoApi.getRandomValues(new Uint8Array(byteLength));
-}
-function secureRandomBase64Url(byteLength = DEFAULT_SECURE_RANDOM_ID_BYTES, label = "secure random id") {
-	return base64UrlEncode(secureRandomBytes(byteLength, label));
-}
-function secureRandomId(prefix, byteLength = DEFAULT_SECURE_RANDOM_ID_BYTES, label = `${prefix} id`) {
-	return `${String(prefix || "").trim() || "id"}-${secureRandomBase64Url(byteLength, label)}`;
-}
-function secureRandomUintBelow(maxExclusive, label = "bounded random integer") {
-	const max = Math.floor(Number(maxExclusive) || 0);
-	if (max <= 0 || max > 256) throw new Error(`Invalid upper bound for ${label}`);
-	const rejectionLimit = Math.floor(256 / max) * max;
-	for (;;) {
-		const candidate = secureRandomBytes(1, label)[0] ?? 0;
-		if (candidate < rejectionLimit) return candidate % max;
-	}
-}
-function secureRandomBase36(length, label = "base36 random id") {
-	const outputLength = Math.max(1, Math.floor(Number(length) || 0));
-	let value = "";
-	for (let i = 0; i < outputLength; i++) value += BASE36_ALPHABET[secureRandomUintBelow(36, label)] || "0";
-	return value;
-}
-//#endregion
-export { secureRandomBase36, secureRandomBase64Url, secureRandomId };
-
-//# sourceMappingURL=secureRandomId.js.map

package/dist/esm/react/shared-ts/src/utils/signerDomain.js

@@ -1,37 +0,0 @@
-import { normalizeOptionalTrimmedString } from "./normalize.js";
-import { EMAIL_OTP_CHANNEL } from "./emailOtpDomain.js";
-//#region ../shared-ts/src/utils/signerDomain.ts
-const SIGNER_KINDS = {
-	thresholdEd25519: "threshold-ed25519",
-	thresholdEcdsa: "threshold-ecdsa"
-};
-const SIGNER_AUTH_METHODS = {
-	passkey: "passkey",
-	emailOtp: EMAIL_OTP_CHANNEL
-};
-const WALLET_AUTH_METHODS = {
-	passkey: "passkey",
-	emailOtp: EMAIL_OTP_CHANNEL
-};
-const SENSITIVE_OPERATION_POLICIES = {
-	inheritSessionPolicy: "inherit_session_policy",
-	requireFreshSameMethod: "require_fresh_same_method",
-	requirePasskey: "require_passkey",
-	denyEmailOtp: "deny_email_otp"
-};
-const SIGNER_SOURCES = {
-	passkeyRegistration: "passkey_registration",
-	emailOtpRegistration: "email_otp_registration",
-	selfHostedImport: "self_hosted_import"
-};
-const WALLET_AUTH_METHOD_VALUES = Object.values(WALLET_AUTH_METHODS);
-function normalized(value) {
-	return normalizeOptionalTrimmedString(value)?.toLowerCase() || "";
-}
-function isWalletAuthMethod(value) {
-	return WALLET_AUTH_METHOD_VALUES.includes(normalized(value));
-}
-//#endregion
-export { SENSITIVE_OPERATION_POLICIES, SIGNER_AUTH_METHODS, SIGNER_KINDS, SIGNER_SOURCES, WALLET_AUTH_METHODS, isWalletAuthMethod };
-
-//# sourceMappingURL=signerDomain.js.map

package/dist/esm/react/shared-ts/src/utils/signerSlot.js

@@ -1,12 +0,0 @@
-//#region ../shared-ts/src/utils/signerSlot.ts
-function parseSignerSlot(value, options = {}) {
-	const signerSlot = Number(value);
-	const minRaw = options.min;
-	const min = Number.isSafeInteger(minRaw) && Number(minRaw) >= 1 ? Number(minRaw) : 1;
-	if (!Number.isSafeInteger(signerSlot) || signerSlot < min) return null;
-	return signerSlot;
-}
-//#endregion
-export { parseSignerSlot };
-
-//# sourceMappingURL=signerSlot.js.map

package/dist/esm/react/shared-ts/src/utils/signingSessionSeal.js

@@ -1,98 +0,0 @@
-//#region ../shared-ts/src/utils/signingSessionSeal.ts
-const SIGNING_SESSION_SEAL_ALG = "shamir3pass-v2";
-const SIGNING_SESSION_SEAL_GROUP_ID = "rfc2409-group2";
-const SIGNING_SESSION_SEAL_STORAGE_SCOPE = "iframe_origin_indexeddb";
-const SIGNING_SESSION_SECRET_KIND = "signing_session_secret32";
-const ROUTER_AB_ED25519_NORMAL_SIGNING_STATE_KIND = "router_ab_ed25519_normal_signing_v1";
-const ROUTER_AB_ED25519_WALLET_SESSION_PATH = "/router-ab/wallet-session/ed25519";
-const PASSKEY_PRF_FIRST_SALT_V1 = new Uint8Array([
-	64,
-	12,
-	49,
-	139,
-	102,
-	149,
-	151,
-	54,
-	89,
-	161,
-	105,
-	138,
-	229,
-	128,
-	223,
-	216,
-	0,
-	29,
-	153,
-	81,
-	186,
-	50,
-	198,
-	149,
-	230,
-	52,
-	153,
-	71,
-	80,
-	79,
-	63,
-	132
-]);
-const PASSKEY_PRF_SECOND_SALT_V1 = new Uint8Array([
-	38,
-	218,
-	80,
-	229,
-	172,
-	150,
-	74,
-	126,
-	160,
-	132,
-	82,
-	127,
-	182,
-	71,
-	246,
-	51,
-	11,
-	50,
-	222,
-	81,
-	169,
-	175,
-	70,
-	82,
-	75,
-	0,
-	109,
-	143,
-	127,
-	231,
-	244,
-	209
-]);
-function normalizeRouterAbNonEmptyString(value) {
-	return String(value || "").trim() || null;
-}
-function parseRouterAbEd25519NormalSigningState(value) {
-	const record = value && typeof value === "object" ? value : null;
-	if (!record) return null;
-	if (record.kind !== "router_ab_ed25519_normal_signing_v1") return null;
-	const signingWorkerId = normalizeRouterAbNonEmptyString(record.signingWorkerId);
-	if (!signingWorkerId) throw new Error("Invalid Router A/B Ed25519 normal-signing state: missing signingWorkerId");
-	return {
-		kind: ROUTER_AB_ED25519_NORMAL_SIGNING_STATE_KIND,
-		signingWorkerId
-	};
-}
-function requireRouterAbEd25519NormalSigningState(value) {
-	const parsed = parseRouterAbEd25519NormalSigningState(value);
-	if (!parsed) throw new Error("Router A/B Ed25519 normal-signing state is required");
-	return parsed;
-}
-//#endregion
-export { PASSKEY_PRF_FIRST_SALT_V1, PASSKEY_PRF_SECOND_SALT_V1, ROUTER_AB_ED25519_NORMAL_SIGNING_STATE_KIND, ROUTER_AB_ED25519_WALLET_SESSION_PATH, SIGNING_SESSION_SEAL_ALG, SIGNING_SESSION_SEAL_GROUP_ID, SIGNING_SESSION_SEAL_STORAGE_SCOPE, SIGNING_SESSION_SECRET_KIND, parseRouterAbEd25519NormalSigningState, requireRouterAbEd25519NormalSigningState };
-
-//# sourceMappingURL=signingSessionSeal.js.map

package/dist/esm/react/shared-ts/src/utils/theme.js

@@ -1,8 +0,0 @@
-//#region ../shared-ts/src/utils/theme.ts
-function coerceThemeMode(input) {
-	return input === "light" || input === "dark" ? input : void 0;
-}
-//#endregion
-export { coerceThemeMode };
-
-//# sourceMappingURL=theme.js.map

package/dist/esm/react/shared-ts/src/utils/thresholdEcdsaChainTarget.js

@@ -1,9 +0,0 @@
-//#region ../shared-ts/src/utils/thresholdEcdsaChainTarget.ts
-function thresholdEcdsaChainTargetKey(target) {
-	if (target.kind === "evm") return `evm:eip155:${target.chainId}`;
-	return `tempo:${target.chainId}`;
-}
-//#endregion
-export { thresholdEcdsaChainTargetKey };
-
-//# sourceMappingURL=thresholdEcdsaChainTarget.js.map

package/dist/esm/react/shared-ts/src/utils/thresholdEcdsaKeyHandle.js

@@ -1,28 +0,0 @@
-import { base64UrlEncode } from "./base64.js";
-import { alphabetizeStringify, sha256BytesUtf8 } from "./digests.js";
-//#region ../shared-ts/src/utils/thresholdEcdsaKeyHandle.ts
-function parseThresholdEcdsaKeyHandle(value) {
-	const normalized = typeof value === "string" ? value.trim() : "";
-	if (!normalized.startsWith("ederivation-key-")) throw new Error("Threshold ECDSA key handle is invalid");
-	return normalized;
-}
-function requiredString(value, field) {
-	const normalized = String(value ?? "").trim();
-	if (!normalized) throw new Error(`[threshold-ecdsa-key-handle] ${field} is required`);
-	return normalized;
-}
-function normalizedSigningRootVersion(value) {
-	return String(value ?? "").trim() || "default";
-}
-async function deriveThresholdEcdsaKeyHandle(input) {
-	return `ederivation-key-${base64UrlEncode(await sha256BytesUtf8(alphabetizeStringify({
-		domain: "seams.threshold_ecdsa.key_handle.v1",
-		ecdsaThresholdKeyId: requiredString(input.ecdsaThresholdKeyId, "ecdsaThresholdKeyId"),
-		signingRootId: requiredString(input.signingRootId, "signingRootId"),
-		signingRootVersion: normalizedSigningRootVersion(input.signingRootVersion)
-	})))}`;
-}
-//#endregion
-export { deriveThresholdEcdsaKeyHandle, parseThresholdEcdsaKeyHandle };
-
-//# sourceMappingURL=thresholdEcdsaKeyHandle.js.map

package/dist/esm/react/shared-ts/src/utils/validation.js

@@ -1,92 +0,0 @@
-import "./near.js";
-import { normalizeOptionalTrimmedString, normalizeTrimmedString } from "./normalize.js";
-//#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 { asRecord, asRecordOrArray, assertString, coerceNonEmptyString, coerceNonNullishString, extractBorshBytesFromPlainSignedTx, isArray, isBoolean, isFunction, isObject, isPlainObject, isPlainSignedTransactionLike, isString, requireArray, requireCanonicalString, requireNonEmptyString, requireRecord, requireRecordCopy, requireTrimmedString, stripFunctionsShallow, toOptionalTrimmedNonEmptyString };
-
-//# sourceMappingURL=validation.js.map

package/dist/esm/react/shared-ts/src/utils/walletAddSignerActivation.js

@@ -1,32 +0,0 @@
-import { base64UrlEncode } from "./base64.js";
-import { alphabetizeStringify, sha256BytesUtf8 } from "./digests.js";
-import { parseCanonicalEcdsaServerActivationRequest } from "./ecdsaCapabilityActivation.js";
-//#region ../shared-ts/src/utils/walletAddSignerActivation.ts
-/**
-* The canonical wallet add-signer ECDSA activation command — the add-signer
-* counterpart of registration's `wallet_registration_activate_v2` command.
-*
-* The client computes the activation request digest locally over this exact
-* alphabetized JSON and journals both before calling activate; the server
-* recomputes the digest from the same coordinates and rejects a mismatch
-* before claiming the activation. Both sides import this one builder so the
-* encoding cannot drift. Unlike the registration command there is no
-* `idempotencyKey` member: add-signer finalize owns idempotency on its own
-* route, and the activate claim is keyed by these coordinates alone.
-*/
-const WALLET_ADD_SIGNER_ECDSA_ACTIVATE_OPERATION = "wallet_add_signer_activate_v2";
-function buildCanonicalWalletAddSignerEcdsaActivationRequest(input) {
-	return parseCanonicalEcdsaServerActivationRequest(alphabetizeStringify({
-		operation: WALLET_ADD_SIGNER_ECDSA_ACTIVATE_OPERATION,
-		addSignerCeremonyId: input.addSignerCeremonyId,
-		activationCorrelationId: input.activationCorrelationId,
-		publicFacts: input.publicFacts
-	}));
-}
-async function computeWalletAddSignerEcdsaActivationRequestDigestB64u(input) {
-	return base64UrlEncode(await sha256BytesUtf8(String(buildCanonicalWalletAddSignerEcdsaActivationRequest(input))));
-}
-//#endregion
-export { buildCanonicalWalletAddSignerEcdsaActivationRequest, computeWalletAddSignerEcdsaActivationRequestDigestB64u };
-
-//# sourceMappingURL=walletAddSignerActivation.js.map