@seams/wallet 0.7.3 → 0.8.0

package/dist/esm/react/shared-ts/src/threshold/ed25519OperationFingerprint.js

@@ -1,222 +0,0 @@
-import { base64UrlEncode } from "../utils/base64.js";
-import { coerceNonEmptyString, requireRecord } from "../utils/validation.js";
-import { alphabetizeStringify, sha256BytesUtf8 } from "../utils/digests.js";
-//#region ../shared-ts/src/threshold/ed25519OperationFingerprint.ts
-async function thresholdEd25519NearTransactionPlanningOperationFingerprint(input) {
-	return thresholdEd25519OperationFingerprint({
-		kind: "near:transactions_with_actions:planning",
-		payload: {
-			purpose: "near_transaction",
-			...canonicalScope(input),
-			transactions: canonicalNearTransactions(input.transactions)
-		}
-	});
-}
-async function thresholdEd25519NearTransactionOperationFingerprint(input) {
-	return thresholdEd25519OperationFingerprint({
-		kind: "near:transactions_with_actions",
-		payload: {
-			purpose: "near_transaction",
-			...canonicalScope(input),
-			transactions: canonicalNearTransactions(input.transactions),
-			unsignedTransactionBorshB64u: coerceNonEmptyString(input.unsignedTransactionBorshB64u, "unsignedTransactionBorshB64u"),
-			signingDigestB64u: coerceNonEmptyString(input.signingDigestB64u, "signingDigestB64u")
-		}
-	});
-}
-async function thresholdEd25519Nep413OperationFingerprint(input) {
-	return thresholdEd25519OperationFingerprint({
-		kind: "near:nep413",
-		payload: {
-			purpose: "nep413_message",
-			...canonicalScope(input),
-			message: coerceNonEmptyString(input.message, "message"),
-			recipient: coerceNonEmptyString(input.recipient, "recipient"),
-			nonce: coerceNonEmptyString(input.nonce, "nonce"),
-			state: input.state ? String(input.state) : null
-		}
-	});
-}
-async function thresholdEd25519DelegateActionOperationFingerprint(input) {
-	return thresholdEd25519OperationFingerprint({
-		kind: "near:delegate_action",
-		payload: {
-			purpose: "delegate_action",
-			...canonicalScope(input),
-			delegate: canonicalDelegate(input.delegate)
-		}
-	});
-}
-async function thresholdEd25519OperationFingerprint(input) {
-	return `sha256:${base64UrlEncode(await sha256BytesUtf8(alphabetizeStringify({
-		kind: coerceNonEmptyString(input.kind, "kind"),
-		payload: normalizeFingerprintValue(input.payload)
-	})))}`;
-}
-function canonicalScope(input) {
-	return {
-		nearAccountId: coerceNonEmptyString(input.nearAccountId, "nearAccountId"),
-		nearNetworkId: coerceNonEmptyString(input.nearNetworkId, "nearNetworkId"),
-		relayerKeyId: coerceNonEmptyString(input.relayerKeyId, "relayerKeyId"),
-		signerPublicKey: coerceNonEmptyString(input.signerPublicKey, "signerPublicKey")
-	};
-}
-function canonicalNearTransactions(transactions) {
-	if (!Array.isArray(transactions) || transactions.length < 1) throw new Error("transactions must be a non-empty array");
-	return transactions.map((transaction, index) => parseThresholdEd25519NearTransaction(transaction, `transactions[${index}]`));
-}
-function canonicalDelegate(delegate) {
-	return {
-		senderId: coerceNonEmptyString(delegate.senderId, "delegate.senderId"),
-		receiverId: coerceNonEmptyString(delegate.receiverId, "delegate.receiverId"),
-		actions: canonicalActions(delegate.actions, "delegate.actions"),
-		nonce: coerceNonEmptyString(delegate.nonce, "delegate.nonce"),
-		maxBlockHeight: coerceNonEmptyString(delegate.maxBlockHeight, "delegate.maxBlockHeight"),
-		publicKey: coerceNonEmptyString(delegate.publicKey, "delegate.publicKey")
-	};
-}
-function parseThresholdEd25519NearTransaction(raw, label) {
-	const record = requireRecord(raw, label);
-	return {
-		nearAccountId: coerceNonEmptyString(record.nearAccountId, `${label}.nearAccountId`),
-		receiverId: coerceNonEmptyString(record.receiverId, `${label}.receiverId`),
-		actions: canonicalActions(record.actions, `${label}.actions`)
-	};
-}
-function canonicalActions(actions, label) {
-	if (!Array.isArray(actions)) throw new Error(`${label} must be an array`);
-	return actions.map((action, index) => parseThresholdEd25519NearAction(action, `${label}[${index}]`));
-}
-function parseThresholdEd25519NearAction(action, label) {
-	const record = requireRecord(action, label);
-	const actionType = coerceNonEmptyString(record.action_type, `${label}.action_type`);
-	switch (actionType) {
-		case "CreateAccount": return { action_type: actionType };
-		case "DeployContract": return {
-			action_type: actionType,
-			code: requiredNumberArray(record.code, `${label}.code`)
-		};
-		case "FunctionCall": return {
-			action_type: actionType,
-			method_name: coerceNonEmptyString(record.method_name, `${label}.method_name`),
-			args: coerceNonEmptyString(record.args, `${label}.args`),
-			gas: coerceNonEmptyString(record.gas, `${label}.gas`),
-			deposit: coerceNonEmptyString(record.deposit, `${label}.deposit`)
-		};
-		case "Transfer": return {
-			action_type: actionType,
-			deposit: coerceNonEmptyString(record.deposit, `${label}.deposit`)
-		};
-		case "Stake": return {
-			action_type: actionType,
-			stake: coerceNonEmptyString(record.stake, `${label}.stake`),
-			public_key: coerceNonEmptyString(record.public_key, `${label}.public_key`)
-		};
-		case "AddKey": return {
-			action_type: actionType,
-			public_key: coerceNonEmptyString(record.public_key, `${label}.public_key`),
-			access_key: coerceNonEmptyString(record.access_key, `${label}.access_key`)
-		};
-		case "DeleteKey": return {
-			action_type: actionType,
-			public_key: coerceNonEmptyString(record.public_key, `${label}.public_key`)
-		};
-		case "DeleteAccount": return {
-			action_type: actionType,
-			beneficiary_id: coerceNonEmptyString(record.beneficiary_id, `${label}.beneficiary_id`)
-		};
-		case "SignedDelegate": return {
-			action_type: actionType,
-			delegate_action: parseThresholdEd25519SignedDelegateAction(record.delegate_action, `${label}.delegate_action`),
-			signature: parseThresholdEd25519NearSignature(record.signature, `${label}.signature`)
-		};
-		case "DeployGlobalContract": return {
-			action_type: actionType,
-			code: requiredNumberArray(record.code, `${label}.code`),
-			deploy_mode: requiredDeployMode(record.deploy_mode, `${label}.deploy_mode`)
-		};
-		case "UseGlobalContract": return parseThresholdEd25519UseGlobalContractAction(record, label);
-	}
-	throw new Error(`${label}.action_type is unsupported`);
-}
-function parseThresholdEd25519SignedDelegateAction(raw, label) {
-	const record = requireRecord(raw, label);
-	return {
-		senderId: coerceNonEmptyString(record.senderId, `${label}.senderId`),
-		receiverId: coerceNonEmptyString(record.receiverId, `${label}.receiverId`),
-		actions: canonicalActions(record.actions, `${label}.actions`),
-		nonce: requiredIntegerLike(record.nonce, `${label}.nonce`),
-		maxBlockHeight: requiredIntegerLike(record.maxBlockHeight, `${label}.maxBlockHeight`),
-		publicKey: parseThresholdEd25519NearPublicKey(record.publicKey, `${label}.publicKey`)
-	};
-}
-function parseThresholdEd25519NearPublicKey(raw, label) {
-	const record = requireRecord(raw, label);
-	return {
-		keyType: requiredSafeInteger(record.keyType, `${label}.keyType`),
-		keyData: requiredNumberArray(record.keyData, `${label}.keyData`)
-	};
-}
-function parseThresholdEd25519NearSignature(raw, label) {
-	const record = requireRecord(raw, label);
-	return {
-		keyType: requiredSafeInteger(record.keyType, `${label}.keyType`),
-		signatureData: requiredNumberArray(record.signatureData, `${label}.signatureData`)
-	};
-}
-function parseThresholdEd25519UseGlobalContractAction(record, label) {
-	const accountId = optionalString(record.account_id);
-	const codeHash = optionalString(record.code_hash);
-	if (accountId && codeHash) throw new Error(`${label} requires exactly one of account_id or code_hash`);
-	if (accountId) return {
-		action_type: "UseGlobalContract",
-		account_id: accountId
-	};
-	if (codeHash) return {
-		action_type: "UseGlobalContract",
-		code_hash: codeHash
-	};
-	throw new Error(`${label} requires exactly one of account_id or code_hash`);
-}
-function requiredNumberArray(value, label) {
-	if (!Array.isArray(value)) throw new Error(`${label} must be an array`);
-	return value.map((entry, index) => {
-		if (typeof entry !== "number" || !Number.isInteger(entry) || entry < 0 || entry > 255) throw new Error(`${label}[${index}] must be a byte`);
-		return entry;
-	});
-}
-function requiredSafeInteger(value, label) {
-	if (typeof value !== "number" || !Number.isSafeInteger(value)) throw new Error(`${label} must be a safe integer`);
-	return value;
-}
-function requiredIntegerLike(value, label) {
-	if (typeof value === "bigint") return value;
-	if (typeof value === "number" && Number.isSafeInteger(value)) return value;
-	return coerceNonEmptyString(value, label);
-}
-function requiredDeployMode(value, label) {
-	const deployMode = coerceNonEmptyString(value, label);
-	if (deployMode === "CodeHash" || deployMode === "AccountId") return deployMode;
-	throw new Error(`${label} is invalid`);
-}
-function optionalString(value) {
-	return String(value || "").trim() || null;
-}
-function normalizeFingerprintValue(value) {
-	if (typeof value === "bigint") return value.toString(10);
-	if (value instanceof Uint8Array) return { __bytesB64u: base64UrlEncode(value) };
-	if (ArrayBuffer.isView(value)) return { __bytesB64u: base64UrlEncode(new Uint8Array(value.buffer, value.byteOffset, value.byteLength)) };
-	if (value instanceof ArrayBuffer) return { __bytesB64u: base64UrlEncode(new Uint8Array(value)) };
-	if (Array.isArray(value)) return value.map(normalizeFingerprintValue);
-	if (!value || typeof value !== "object") return value;
-	const out = {};
-	for (const key of Object.keys(value).sort()) {
-		const next = normalizeFingerprintValue(value[key]);
-		if (next !== void 0) out[key] = next;
-	}
-	return out;
-}
-//#endregion
-export { parseThresholdEd25519NearAction, parseThresholdEd25519NearTransaction, thresholdEd25519DelegateActionOperationFingerprint, thresholdEd25519NearTransactionOperationFingerprint, thresholdEd25519NearTransactionPlanningOperationFingerprint, thresholdEd25519Nep413OperationFingerprint };
-
-//# sourceMappingURL=ed25519OperationFingerprint.js.map

package/dist/esm/react/shared-ts/src/threshold/keyMaterialBrands.js

@@ -1,25 +0,0 @@
-//#region ../shared-ts/src/threshold/keyMaterialBrands.ts
-function parseNonEmptyBrand(value, label) {
-	const normalized = String(value ?? "").trim();
-	if (!normalized) throw new Error(`${label} must be a non-empty string`);
-	return normalized;
-}
-function parseSigningSessionSealKeyVersion(value) {
-	return parseNonEmptyBrand(value, "signing-session seal key version");
-}
-function parseEcdsaClientVerifyingShareB64u(value) {
-	return parseNonEmptyBrand(value, "ECDSA client verifying share");
-}
-function parseEcdsaRelayerKeyId(value) {
-	return parseNonEmptyBrand(value, "ECDSA relayer key id");
-}
-function parseEcdsaKeyHandle(value) {
-	return parseNonEmptyBrand(value, "ECDSA key handle");
-}
-function formatEcdsaKeyHandleForWire(value) {
-	return value;
-}
-//#endregion
-export { formatEcdsaKeyHandleForWire, parseEcdsaClientVerifyingShareB64u, parseEcdsaKeyHandle, parseEcdsaRelayerKeyId, parseNonEmptyBrand, parseSigningSessionSealKeyVersion };
-
-//# sourceMappingURL=keyMaterialBrands.js.map

package/dist/esm/react/shared-ts/src/threshold/participants.js

@@ -1,67 +0,0 @@
-import { normalizeOptionalTrimmedString } from "../utils/normalize.js";
-import "../utils/validation.js";
-const THRESHOLD_ED25519_2P_PARTICIPANT_IDS = [1, 2];
-function normalizeThresholdEd25519ParticipantId(id) {
-	const n = Number(id);
-	if (!Number.isSafeInteger(n) || n < 1 || n > 65535) return null;
-	return n;
-}
-function normalizeThresholdEd25519ParticipantIds(input) {
-	if (!Array.isArray(input) || input.length === 0) return null;
-	const out = [];
-	const seen = /* @__PURE__ */ new Set();
-	for (const v of input) {
-		const id = normalizeThresholdEd25519ParticipantId(v);
-		if (!id) return null;
-		if (!seen.has(id)) {
-			seen.add(id);
-			out.push(id);
-		}
-	}
-	out.sort((a, b) => a - b);
-	return out.length ? out : null;
-}
-function parseThresholdEd25519ParticipantsV1(input) {
-	if (!Array.isArray(input) || input.length === 0) return null;
-	const out = [];
-	for (const item of input) {
-		if (!item || typeof item !== "object" || Array.isArray(item)) return null;
-		const rec = item;
-		const id = normalizeThresholdEd25519ParticipantId(rec.id);
-		const role = normalizeOptionalTrimmedString(rec.role);
-		if (!id || role !== "client" && role !== "relayer") return null;
-		const participant = {
-			id,
-			role
-		};
-		const relayerUrl = normalizeOptionalTrimmedString(rec.relayerUrl);
-		if (relayerUrl) participant.relayerUrl = relayerUrl;
-		const relayerKeyId = normalizeOptionalTrimmedString(rec.relayerKeyId);
-		if (relayerKeyId) participant.relayerKeyId = relayerKeyId;
-		const shareDerivation = normalizeOptionalTrimmedString(rec.shareDerivation);
-		if (shareDerivation === "prf_first_v1" || shareDerivation === "derived_master_secret_v1" || shareDerivation === "kv_random_v1" || shareDerivation === "unknown") participant.shareDerivation = shareDerivation;
-		out.push(participant);
-	}
-	return out.length ? out : null;
-}
-function buildThresholdEd25519Participants2pV1(input) {
-	const relayerKeyId = normalizeOptionalTrimmedString(input.relayerKeyId);
-	const relayerUrl = normalizeOptionalTrimmedString(input.relayerUrl);
-	const clientParticipantId = normalizeThresholdEd25519ParticipantId(input.clientParticipantId) ?? 1;
-	const relayerParticipantId = normalizeThresholdEd25519ParticipantId(input.relayerParticipantId) ?? 2;
-	return [{
-		id: clientParticipantId,
-		role: "client",
-		shareDerivation: input.clientShareDerivation || "prf_first_v1"
-	}, {
-		id: relayerParticipantId,
-		role: "relayer",
-		...relayerUrl ? { relayerUrl } : {},
-		...relayerKeyId ? { relayerKeyId } : {},
-		...input.relayerShareDerivation ? { shareDerivation: input.relayerShareDerivation } : {}
-	}];
-}
-//#endregion
-export { THRESHOLD_ED25519_2P_PARTICIPANT_IDS, buildThresholdEd25519Participants2pV1, normalizeThresholdEd25519ParticipantIds, parseThresholdEd25519ParticipantsV1 };
-
-//# sourceMappingURL=participants.js.map

package/dist/esm/react/shared-ts/src/threshold/secp256k1.js

@@ -1,6 +0,0 @@
-//#region ../shared-ts/src/threshold/secp256k1.ts
-const THRESHOLD_SECP256K1_ECDSA_2P_PARTICIPANT_IDS_V1 = [1, 2];
-//#endregion
-export { THRESHOLD_SECP256K1_ECDSA_2P_PARTICIPANT_IDS_V1 };
-
-//# sourceMappingURL=secp256k1.js.map

package/dist/esm/react/shared-ts/src/threshold/sessionPolicy.js

@@ -1,8 +0,0 @@
-//#region ../shared-ts/src/threshold/sessionPolicy.ts
-const DEFAULT_WALLET_SESSION_TTL_MS = 1440 * 6e4;
-const MAX_WALLET_SESSION_TTL_MS = 720 * 60 * 6e4;
-const MAX_WALLET_SESSION_REMAINING_USES = 1e6;
-//#endregion
-export { DEFAULT_WALLET_SESSION_TTL_MS, MAX_WALLET_SESSION_REMAINING_USES, MAX_WALLET_SESSION_TTL_MS };
-
-//# sourceMappingURL=sessionPolicy.js.map

package/dist/esm/react/shared-ts/src/threshold/signingRootScope.js

@@ -1,43 +0,0 @@
-import { normalizeOptionalTrimmedString } from "../utils/normalize.js";
-import "../utils/validation.js";
-//#region ../shared-ts/src/threshold/signingRootScope.ts
-function requireScopeField(label, value) {
-	const normalized = normalizeOptionalTrimmedString(value);
-	if (!normalized) throw new Error(`${label} is required`);
-	return normalized;
-}
-function deriveSigningRootId(input) {
-	return `${requireScopeField("projectId", input.projectId)}:${requireScopeField("envId", input.envId)}`;
-}
-function normalizeRuntimePolicyScope(input) {
-	const scope = normalizeRuntimePolicyScopeFields(input);
-	return {
-		...scope,
-		signingRootVersion: requireScopeField("signingRootVersion", scope.signingRootVersion)
-	};
-}
-function normalizeRuntimePolicyScopeFields(input) {
-	if (!input || typeof input !== "object" || Array.isArray(input)) throw new Error("runtimePolicyScope must be an object");
-	const scope = input;
-	if (Object.prototype.hasOwnProperty.call(scope, "environmentId")) throw new Error("runtimePolicyScope.environmentId is stale; use envId");
-	if (Object.prototype.hasOwnProperty.call(scope, "runtimeSnapshotScope")) throw new Error("runtimePolicyScope.runtimeSnapshotScope is stale; use runtimePolicyScope");
-	return {
-		orgId: requireScopeField("orgId", scope.orgId),
-		projectId: requireScopeField("projectId", scope.projectId),
-		envId: requireScopeField("envId", scope.envId),
-		...normalizeOptionalTrimmedString(scope.signingRootVersion) ? { signingRootVersion: normalizeOptionalTrimmedString(scope.signingRootVersion) } : {}
-	};
-}
-function sameRuntimePolicyScope(left, right) {
-	return left.orgId === right.orgId && left.projectId === right.projectId && left.envId === right.envId && left.signingRootVersion === right.signingRootVersion;
-}
-function signingRootScopeFromRuntimePolicyScope(scope) {
-	return {
-		signingRootId: deriveSigningRootId(scope),
-		signingRootVersion: requireScopeField("signingRootVersion", scope.signingRootVersion)
-	};
-}
-//#endregion
-export { deriveSigningRootId, normalizeRuntimePolicyScope, sameRuntimePolicyScope, signingRootScopeFromRuntimePolicyScope };
-
-//# sourceMappingURL=signingRootScope.js.map

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

@@ -1,103 +0,0 @@
-import { parseWebAuthnRpId } from "./domainIds.js";
-//#region ../shared-ts/src/utils/addAuthMethodRegistration.ts
-/**
-* The canonical WebAuthn registration options for adding a wallet auth method.
-*
-* This lives in the shared package because three parties read the same record:
-* the server that mints it, the browser that passes it to
-* `navigator.credentials.create`, and the linked-device target preparation that
-* carries it to Device 2. One declaration, so a change to the ceremony cannot
-* silently diverge from what a linked device creates its passkey against.
-*
-* Everything here is fixed by the canonical add-auth-method ceremony: two
-* algorithms in a fixed order, a resident key, no attestation, and PRF
-* evaluation. Encoding them as literal types rather than open unions is what
-* makes a registration that drifted from the ceremony fail to parse instead of
-* producing a credential nothing can finalize.
-*/
-function record(value, label) {
-	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error(`${label} must be an object`);
-	return value;
-}
-function token(value, label) {
-	if (typeof value !== "string") throw new Error(`${label} must be a string`);
-	const trimmed = value.trim();
-	if (!trimmed) throw new Error(`${label} must not be empty`);
-	if (trimmed !== value) throw new Error(`${label} must not be padded with whitespace`);
-	return trimmed;
-}
-/**
-* The relying party is branded at the boundary rather than at each use, so a
-* consumer cannot verify a credential against an unvalidated host string.
-*/
-function rpId(value, label) {
-	const parsed = parseWebAuthnRpId(token(value, label));
-	if (!parsed.ok) throw new Error(`${label} is invalid: ${parsed.error.message}`);
-	return parsed.value;
-}
-function literal(value, expected, label) {
-	if (value !== expected) throw new Error(`${label} must be ${String(expected)}`);
-	return expected;
-}
-/**
-* Throws on anything that is not exactly a canonical add-auth-method
-* registration. Callers that need a nullable result wrap this rather than
-* writing a second, looser reading of the same record.
-*/
-function parseWalletAddAuthMethodRegistrationOptions(raw) {
-	const label = "WalletAddAuthMethodRegistrationOptions";
-	const value = record(raw, label);
-	literal(value.kind, "webauthn_add_auth_method_registration_v1", `${label}.kind`);
-	const user = record(value.user, `${label}.user`);
-	const selection = record(value.authenticatorSelection, `${label}.authenticatorSelection`);
-	const prfEval = record(record(record(value.extensions, `${label}.extensions`).prf, `${label}.extensions.prf`).eval, `${label}.extensions.prf.eval`);
-	if (!Array.isArray(value.pubKeyCredParams) || value.pubKeyCredParams.length !== 2) throw new Error(`${label}.pubKeyCredParams must list exactly two algorithms`);
-	const [first, second] = value.pubKeyCredParams;
-	literal(record(first, `${label}.pubKeyCredParams[0]`).type, "public-key", `${label}.pubKeyCredParams[0].type`);
-	literal(record(first, `${label}.pubKeyCredParams[0]`).alg, -7, `${label}.pubKeyCredParams[0].alg`);
-	literal(record(second, `${label}.pubKeyCredParams[1]`).type, "public-key", `${label}.pubKeyCredParams[1].type`);
-	literal(record(second, `${label}.pubKeyCredParams[1]`).alg, -257, `${label}.pubKeyCredParams[1].alg`);
-	if (!Array.isArray(value.excludeCredentials)) throw new Error(`${label}.excludeCredentials must be an array`);
-	const excludeCredentials = value.excludeCredentials.map((entry, index) => {
-		const credential = record(entry, `${label}.excludeCredentials[${index}]`);
-		return {
-			type: literal(credential.type, "public-key", `${label}.excludeCredentials[${index}].type`),
-			id: token(credential.id, `${label}.excludeCredentials[${index}].id`)
-		};
-	});
-	const timeoutMs = value.timeoutMs;
-	if (typeof timeoutMs !== "number" || !Number.isSafeInteger(timeoutMs) || timeoutMs <= 0) throw new Error(`${label}.timeoutMs must be a positive safe integer`);
-	return {
-		kind: "webauthn_add_auth_method_registration_v1",
-		challengeId: token(value.challengeId, `${label}.challengeId`),
-		challengeB64u: token(value.challengeB64u, `${label}.challengeB64u`),
-		rpId: rpId(value.rpId, `${label}.rpId`),
-		user: {
-			idB64u: token(user.idB64u, `${label}.user.idB64u`),
-			name: token(user.name, `${label}.user.name`),
-			displayName: token(user.displayName, `${label}.user.displayName`)
-		},
-		pubKeyCredParams: [{
-			type: "public-key",
-			alg: -7
-		}, {
-			type: "public-key",
-			alg: -257
-		}],
-		authenticatorSelection: {
-			residentKey: literal(selection.residentKey, "required", `${label}.authenticatorSelection.residentKey`),
-			userVerification: literal(selection.userVerification, "preferred", `${label}.authenticatorSelection.userVerification`)
-		},
-		timeoutMs,
-		attestation: literal(value.attestation, "none", `${label}.attestation`),
-		extensions: { prf: { eval: {
-			firstB64u: token(prfEval.firstB64u, `${label}.extensions.prf.eval.firstB64u`),
-			secondB64u: token(prfEval.secondB64u, `${label}.extensions.prf.eval.secondB64u`)
-		} } },
-		excludeCredentials
-	};
-}
-//#endregion
-export { parseWalletAddAuthMethodRegistrationOptions };
-
-//# sourceMappingURL=addAuthMethodRegistration.js.map

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

@@ -1 +0,0 @@
-import "../authorization/capabilityKinds.js";

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

@@ -1,22 +0,0 @@
-//#region ../shared-ts/src/utils/authenticatorOptions.ts
-let UserVerificationPolicy = /* @__PURE__ */ function(UserVerificationPolicy) {
-	UserVerificationPolicy["Required"] = "required";
-	UserVerificationPolicy["Preferred"] = "preferred";
-	UserVerificationPolicy["Discouraged"] = "discouraged";
-	return UserVerificationPolicy;
-}({});
-function cloneAuthenticatorOptions(options) {
-	const multiple = options.originPolicy?.multiple;
-	return {
-		userVerification: options.userVerification,
-		originPolicy: {
-			single: options.originPolicy?.single,
-			all_subdomains: options.originPolicy?.all_subdomains,
-			multiple: Array.isArray(multiple) ? [...multiple] : void 0
-		}
-	};
-}
-//#endregion
-export { UserVerificationPolicy, cloneAuthenticatorOptions };
-
-//# sourceMappingURL=authenticatorOptions.js.map

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

@@ -1,28 +0,0 @@
-import bs58 from "bs58";
-//#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 bs58.encode(new Uint8Array(data));
-	if (Array.isArray(data)) return bs58.encode(new Uint8Array(data));
-	return bs58.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 bs58.decode(base58String);
-};
-//#endregion
-export { base58Decode, base58Encode };
-
-//# sourceMappingURL=base58.js.map

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

@@ -1,70 +0,0 @@
-//#region ../shared-ts/src/utils/base64.ts
-/**
-* Encodes binary data to standard base64 format.
-* Uses standard base64 characters (+, /, =) rather than base64url encoding.
-*
-* Important: Avoids spreading large arrays into String.fromCharCode(...) which
-* can overflow the JS call stack when encoding big WASM binaries.
-*
-* @param value - ArrayBufferLike or ArrayBufferView containing the binary data to encode
-* @returns Standard base64-encoded string with padding
-*/
-const base64Encode = (value) => {
-	const bytes = ArrayBuffer.isView(value) ? new Uint8Array(value.buffer, value.byteOffset, value.byteLength) : new Uint8Array(value);
-	let binary = "";
-	for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i]);
-	return btoa(binary);
-};
-/**
-* Decodes a standard base64-encoded string into a Uint8Array.
-* Handles standard base64 format with +, /, and = characters.
-*
-* @param base64 - The base64-encoded string to decode
-* @returns Uint8Array containing the decoded bytes
-* @throws Error if decoding fails due to invalid base64 input
-*/
-function base64Decode(base64) {
-	const normalized = String(base64 || "").trim();
-	if (!normalized) return new Uint8Array();
-	if (typeof atob === "function") {
-		const binaryString = atob(normalized);
-		const bytes = new Uint8Array(binaryString.length);
-		for (let i = 0; i < binaryString.length; i++) bytes[i] = binaryString.charCodeAt(i);
-		return bytes;
-	}
-	if (typeof Buffer !== "undefined") return Uint8Array.from(Buffer.from(normalized, "base64"));
-	throw new Error("base64Decode is unavailable in this runtime");
-}
-/**
-* Encodes an ArrayBuffer into a base64url string.
-* Converts binary data to base64 then replaces standard base64 characters with URL-safe ones:
-* + -> -
-* / -> _
-* Removes padding = characters
-*
-* Used for WebAuthn API compatibility in browser environments.
-* Equivalent to Buffer.from(value).toString('base64url') in Node.js.
-*
-* @param value - The ArrayBufferLike or ArrayBufferView to encode
-* @returns A base64url-encoded string without padding
-*/
-const base64UrlEncode = (value) => {
-	return base64Encode(value).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
-};
-/**
-* Decodes a base64url-encoded string into a Uint8Array.
-* Handles base64url format by replacing URL-safe characters and adding padding.
-*
-* @param base64Url - The base64url-encoded string to decode
-* @returns Uint8Array containing the decoded bytes
-* @throws Error if decoding fails due to invalid base64url input
-*/
-function base64UrlDecode(base64Url) {
-	const normalized = String(base64Url || "").trim().replace(/-/g, "+").replace(/_/g, "/");
-	if (!normalized) return new Uint8Array();
-	return base64Decode(normalized + "=".repeat((4 - normalized.length % 4) % 4));
-}
-//#endregion
-export { base64Decode, base64Encode, base64UrlDecode, base64UrlEncode };
-
-//# sourceMappingURL=base64.js.map

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

@@ -1,38 +0,0 @@
-import { base64UrlDecode, base64UrlEncode } from "./base64.js";
-import { sha256Bytes, sha256BytesUtf8 } from "./digests.js";
-//#region ../shared-ts/src/utils/canonicalPrimitives.ts
-function parseCorrelationId(value) {
-	if (typeof value !== "string" || value.trim() !== value || value.length === 0) throw new Error("correlation id must be a non-empty canonical string");
-	return value;
-}
-function parseDigestB64u(value) {
-	if (typeof value !== "string" || !/^[A-Za-z0-9_-]+$/.test(value)) throw new Error("digest must be unpadded base64url");
-	let bytes;
-	try {
-		bytes = base64UrlDecode(value);
-	} catch {
-		throw new Error("digest must be valid base64url");
-	}
-	if (bytes.length !== 32 || base64UrlEncode(bytes) !== value) throw new Error("digest must be canonical base64url for 32 bytes");
-	return value;
-}
-function parseIsoTimestamp(value) {
-	if (typeof value !== "string") throw new Error("timestamp must be an ISO timestamp");
-	const timestampMs = Date.parse(value);
-	if (!Number.isFinite(timestampMs) || new Date(timestampMs).toISOString() !== value) throw new Error("timestamp must be canonical ISO-8601 UTC");
-	return value;
-}
-function isoTimestampFromUnixMs(value) {
-	if (!Number.isSafeInteger(value) || Number(value) <= 0) throw new Error("timestamp milliseconds must be a positive safe integer");
-	return parseIsoTimestamp(new Date(Number(value)).toISOString());
-}
-async function sha256DigestB64u(bytes) {
-	return parseDigestB64u(base64UrlEncode(await sha256Bytes(bytes)));
-}
-async function sha256Utf8DigestB64u(text) {
-	return parseDigestB64u(base64UrlEncode(await sha256BytesUtf8(text)));
-}
-//#endregion
-export { isoTimestampFromUnixMs, parseCorrelationId, parseDigestB64u, parseIsoTimestamp, sha256DigestB64u, sha256Utf8DigestB64u };
-
-//# sourceMappingURL=canonicalPrimitives.js.map