@seams/wallet-server 0.5.0

package/dist/types/shared-ts/src/threshold/ed25519OperationFingerprint.d.ts

@@ -0,0 +1,130 @@
+type ThresholdEd25519CanonicalScope = {
+    nearAccountId: string;
+    nearNetworkId: string;
+    relayerKeyId: string;
+    signerPublicKey: string;
+};
+export type ThresholdEd25519NearTransaction = {
+    nearAccountId: string;
+    receiverId: string;
+    actions: readonly ThresholdEd25519NearAction[];
+};
+export type ThresholdEd25519NearPublicKey = {
+    keyType: number;
+    keyData: readonly number[];
+};
+export type ThresholdEd25519NearSignature = {
+    keyType: number;
+    signatureData: readonly number[];
+};
+export type ThresholdEd25519SignedDelegateAction = {
+    senderId: string;
+    receiverId: string;
+    actions: readonly ThresholdEd25519NearAction[];
+    nonce: string | number | bigint;
+    maxBlockHeight: string | number | bigint;
+    publicKey: ThresholdEd25519NearPublicKey;
+};
+export type ThresholdEd25519NearAction = {
+    action_type: 'CreateAccount';
+} | {
+    action_type: 'DeployContract';
+    code: readonly number[];
+} | {
+    action_type: 'FunctionCall';
+    method_name: string;
+    args: string;
+    gas: string;
+    deposit: string;
+} | {
+    action_type: 'Transfer';
+    deposit: string;
+} | {
+    action_type: 'Stake';
+    stake: string;
+    public_key: string;
+} | {
+    action_type: 'AddKey';
+    public_key: string;
+    access_key: string;
+} | {
+    action_type: 'DeleteKey';
+    public_key: string;
+} | {
+    action_type: 'DeleteAccount';
+    beneficiary_id: string;
+} | {
+    action_type: 'SignedDelegate';
+    delegate_action: ThresholdEd25519SignedDelegateAction;
+    signature: ThresholdEd25519NearSignature;
+} | {
+    action_type: 'DeployGlobalContract';
+    code: readonly number[];
+    deploy_mode: 'CodeHash' | 'AccountId';
+} | {
+    action_type: 'UseGlobalContract';
+    account_id: string;
+    code_hash?: never;
+} | {
+    action_type: 'UseGlobalContract';
+    code_hash: string;
+    account_id?: never;
+};
+export type ThresholdEd25519NearTransactionPlanningFingerprintInput = ThresholdEd25519CanonicalScope & {
+    transactions: readonly ThresholdEd25519NearTransaction[];
+};
+export type ThresholdEd25519NearTransactionFingerprintInput = ThresholdEd25519NearTransactionPlanningFingerprintInput & {
+    unsignedTransactionBorshB64u: string;
+    signingDigestB64u: string;
+};
+export type ThresholdEd25519Nep413FingerprintInput = ThresholdEd25519CanonicalScope & {
+    message: string;
+    recipient: string;
+    nonce: string;
+    state?: string | null;
+};
+export type ThresholdEd25519DelegateActionFingerprintInput = ThresholdEd25519CanonicalScope & {
+    delegate: {
+        senderId: string;
+        receiverId: string;
+        actions: readonly ThresholdEd25519NearAction[];
+        nonce: string;
+        maxBlockHeight: string;
+        publicKey: string;
+    };
+};
+type ThresholdEd25519FinalizeRequestIntegrityCommonInput = {
+    operation: {
+        kind: 'threshold_ed25519_signing_operation_v1';
+        operationId: string;
+        operationFingerprint: string;
+        purpose: 'near_transaction' | 'nep413_message' | 'delegate_action';
+    };
+    presignId: string;
+    relayerKeyId: string;
+    nearAccountId: string;
+    nearNetworkId: string;
+    expectedSignerPublicKey: string;
+    clientSignatureShareB64u: string;
+};
+export type ThresholdEd25519FinalizeRequestIntegrityInput = (ThresholdEd25519FinalizeRequestIntegrityCommonInput & {
+    kind: 'threshold_ed25519_finalize_signature_only_v1';
+    intent: unknown;
+}) | (ThresholdEd25519FinalizeRequestIntegrityCommonInput & {
+    kind: 'threshold_ed25519_finalize_and_dispatch_near_tx_v1';
+    transactions: unknown;
+    unsignedTransactionBorshB64u: string;
+    signingDigestB64u: string;
+    dispatch: {
+        kind: 'near_rpc_configured_default_v1';
+    };
+});
+export declare function thresholdEd25519NearTransactionPlanningOperationFingerprint(input: ThresholdEd25519NearTransactionPlanningFingerprintInput): Promise<string>;
+export declare function thresholdEd25519NearTransactionOperationFingerprint(input: ThresholdEd25519NearTransactionFingerprintInput): Promise<string>;
+export declare function thresholdEd25519Nep413OperationFingerprint(input: ThresholdEd25519Nep413FingerprintInput): Promise<string>;
+export declare function thresholdEd25519DelegateActionOperationFingerprint(input: ThresholdEd25519DelegateActionFingerprintInput): Promise<string>;
+export declare function thresholdEd25519FinalizeRequestIntegrityHash(input: ThresholdEd25519FinalizeRequestIntegrityInput): Promise<string>;
+export declare function parseThresholdEd25519NearTransaction(raw: unknown, label: string): ThresholdEd25519NearTransaction;
+export declare function parseThresholdEd25519NearAction(action: unknown, label: string): ThresholdEd25519NearAction;
+export {};
+//# sourceMappingURL=ed25519OperationFingerprint.d.ts.map

package/dist/types/shared-ts/src/threshold/index.d.ts

@@ -0,0 +1,7 @@
+export * from './ecdsaDerivationRoleLocalBootstrap';
+export * from './ed25519OperationFingerprint';
+export * from './participants';
+export * from './secp256k1';
+export * from './sessionPolicy';
+export * from './signingRootScope';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/shared-ts/src/threshold/participants.d.ts

@@ -0,0 +1,38 @@
+export type ThresholdParticipantRole = 'client' | 'relayer';
+export declare const THRESHOLD_ED25519_CLIENT_PARTICIPANT_ID: 1;
+export declare const THRESHOLD_ED25519_RELAYER_PARTICIPANT_ID: 2;
+export declare const THRESHOLD_ED25519_2P_PARTICIPANT_IDS: readonly [1, 2];
+/**
+ * Metadata describing how a participant share is derived/stored.
+ * This is informational in v1 and may be used for validation/policy later.
+ */
+export type ThresholdEd25519ShareDerivation = 'prf_first_v1' | 'derived_master_secret_v1' | 'kv_random_v1' | 'unknown';
+export interface ThresholdEd25519ParticipantV1 {
+    /** FROST identifier (1-indexed). */
+    id: number;
+    role: ThresholdParticipantRole;
+    /** Optional relayer endpoint for this participant (future multi-relayer support). */
+    relayerUrl?: string;
+    /** Key/share identifier understood by this participant (e.g. relayerKeyId). */
+    relayerKeyId?: string;
+    shareDerivation?: ThresholdEd25519ShareDerivation;
+}
+export declare const THRESHOLD_ED25519_PARTICIPANT_SET_V1: "threshold_ed25519_participants_v1";
+export interface ThresholdEd25519ParticipantSetV1 {
+    version: typeof THRESHOLD_ED25519_PARTICIPANT_SET_V1;
+    groupPublicKey: string;
+    participants: ThresholdEd25519ParticipantV1[];
+}
+export declare function normalizeThresholdEd25519ParticipantId(id: unknown): number | null;
+export declare function normalizeThresholdEd25519ParticipantIds(input: unknown): number[] | null;
+export declare function areThresholdEd25519ParticipantIds2p(participantIds: number[] | null | undefined, expected?: readonly number[]): boolean;
+export declare function parseThresholdEd25519ParticipantsV1(input: unknown): ThresholdEd25519ParticipantV1[] | null;
+export declare function buildThresholdEd25519Participants2pV1(input: {
+    clientParticipantId?: number | null;
+    relayerParticipantId?: number | null;
+    relayerKeyId: string;
+    relayerUrl?: string | null;
+    clientShareDerivation?: ThresholdEd25519ShareDerivation | null;
+    relayerShareDerivation?: ThresholdEd25519ShareDerivation | null;
+}): ThresholdEd25519ParticipantV1[];
+//# sourceMappingURL=participants.d.ts.map

package/dist/types/shared-ts/src/threshold/secp256k1.d.ts

@@ -0,0 +1,39 @@
+/**
+ * secp256k1 group order `n`.
+ *
+ * This is the order of the prime-order subgroup generated by `G` (the base point),
+ * as specified by SEC 2 (Recommended Elliptic Curve Domain Parameters).
+ *
+ * Important:
+ * - This is **not** the field modulus `p` (used for x/y coordinate arithmetic).
+ * - Scalars for secp256k1 signing/keygen are interpreted modulo `n`.
+ *
+ * Used by the threshold-secp256k1 ECDSA stack to reduce HKDF-derived bytes into a
+ * non-zero scalar in `[1, n-1]`.
+ */
+export declare const SECP256K1_ORDER: bigint;
+export type ThresholdSecp256k1Ecdsa2pTopologyV1 = {
+    readonly kind: 'threshold_secp256k1_ecdsa_2p_v1';
+};
+export type ThresholdSecp256k1Ecdsa2pTopologyParseResult = {
+    readonly ok: true;
+    readonly value: ThresholdSecp256k1Ecdsa2pTopologyV1;
+} | {
+    readonly ok: false;
+    readonly message: string;
+};
+export type ThresholdSecp256k1Ecdsa2pParticipantIdsParseResult = {
+    readonly ok: true;
+    readonly value: readonly [1, 2];
+} | {
+    readonly ok: false;
+    readonly message: string;
+};
+export declare const THRESHOLD_SECP256K1_ECDSA_2P_TOPOLOGY_V1: ThresholdSecp256k1Ecdsa2pTopologyV1;
+export declare const THRESHOLD_SECP256K1_ECDSA_2P_CLIENT_ID_V1: 1;
+export declare const THRESHOLD_SECP256K1_ECDSA_2P_RELAYER_ID_V1: 2;
+export declare const THRESHOLD_SECP256K1_ECDSA_2P_THRESHOLD_V1: 2;
+export declare const THRESHOLD_SECP256K1_ECDSA_2P_PARTICIPANT_IDS_V1: readonly [1, 2];
+export declare function parseThresholdSecp256k1Ecdsa2pTopologyV1(value: unknown): ThresholdSecp256k1Ecdsa2pTopologyParseResult;
+export declare function parseThresholdSecp256k1Ecdsa2pParticipantIdsV1(value: unknown): ThresholdSecp256k1Ecdsa2pParticipantIdsParseResult;
+//# sourceMappingURL=secp256k1.d.ts.map

package/dist/types/shared-ts/src/threshold/sessionPolicy.d.ts

@@ -0,0 +1,5 @@
+export declare const DEFAULT_WALLET_SESSION_TTL_MS: number;
+export declare const DEFAULT_WALLET_SESSION_REMAINING_USES = 3;
+export declare const MAX_WALLET_SESSION_TTL_MS: number;
+export declare const MAX_WALLET_SESSION_REMAINING_USES = 1000000;
+//# sourceMappingURL=sessionPolicy.d.ts.map

package/dist/types/shared-ts/src/threshold/signingRootScope.d.ts

@@ -0,0 +1,24 @@
+export type RuntimePolicyScope = {
+    readonly orgId: string;
+    readonly projectId: string;
+    readonly envId: string;
+    readonly signingRootVersion: string;
+};
+export type SigningRootScope = {
+    readonly signingRootId: string;
+    readonly signingRootVersion?: string;
+};
+export declare function deriveSigningRootId(input: {
+    readonly projectId: unknown;
+    readonly envId: unknown;
+}): string;
+export declare function normalizeRuntimePolicyScope(input: unknown): RuntimePolicyScope;
+export declare function normalizeRuntimePolicyScopeFields(input: unknown): Omit<RuntimePolicyScope, 'signingRootVersion'> & {
+    readonly signingRootVersion?: string;
+};
+export declare function signingRootScopeFromRuntimePolicyScope(scope: RuntimePolicyScope): SigningRootScope;
+export declare function normalizeSigningRootScope(input: {
+    readonly signingRootId: unknown;
+    readonly signingRootVersion?: unknown;
+}): SigningRootScope;
+//# sourceMappingURL=signingRootScope.d.ts.map

package/dist/types/shared-ts/src/utils/addAuthMethodRegistration.d.ts

@@ -0,0 +1,63 @@
+/**
+ * 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 — since Refactor 103 Phase 8 — 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.
+ */
+import { type WebAuthnRpId } from './domainIds';
+export type WalletAddAuthMethodRegistrationOptions = {
+    readonly kind: 'webauthn_add_auth_method_registration_v1';
+    readonly challengeId: string;
+    readonly challengeB64u: string;
+    readonly rpId: WebAuthnRpId;
+    readonly user: {
+        readonly idB64u: string;
+        readonly name: string;
+        readonly displayName: string;
+    };
+    readonly pubKeyCredParams: readonly [
+        {
+            readonly type: 'public-key';
+            readonly alg: -7;
+        },
+        {
+            readonly type: 'public-key';
+            readonly alg: -257;
+        }
+    ];
+    readonly authenticatorSelection: {
+        readonly residentKey: 'required';
+        readonly userVerification: 'preferred';
+    };
+    readonly timeoutMs: number;
+    readonly attestation: 'none';
+    readonly extensions: {
+        readonly prf: {
+            readonly eval: {
+                readonly firstB64u: string;
+                readonly secondB64u: string;
+            };
+        };
+    };
+    readonly excludeCredentials: readonly {
+        readonly type: 'public-key';
+        readonly id: string;
+    }[];
+};
+/**
+ * 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.
+ */
+export declare function parseWalletAddAuthMethodRegistrationOptions(raw: unknown): WalletAddAuthMethodRegistrationOptions;
+//# sourceMappingURL=addAuthMethodRegistration.d.ts.map

package/dist/types/shared-ts/src/utils/addWalletAuthMethod.d.ts

@@ -0,0 +1,295 @@
+/**
+ * Refactor 109C — the internal contract for same-device auth-method addition.
+ *
+ * One product action ("Add authentication method") has exactly two branches:
+ * a Passkey-only authority adds Email OTP, or an Email-OTP-only authority adds
+ * a Passkey. Both fill the missing factor family on an authority that already
+ * exists; neither creates an authority, signer activation, share, public key,
+ * export root, or key manifest.
+ *
+ * Same-family addition is not expressible here. There is no branch for it, so
+ * an attempt to add a family the authority already has is resolved as
+ * `already_configured` at admission — before any target verification or local
+ * write — rather than travelling through the operation as a rejected case.
+ *
+ * Every identity a branch depends on is required and branded. The raw wire and
+ * storage values are parsed once by {@link parseAddWalletAuthMethodSourceV1}
+ * and {@link parseAddWalletAuthMethodIntentIdentityV1} at their boundary; core
+ * code below them receives branded identities and one verified branch, and
+ * never compares raw identity strings.
+ */
+import type { DeviceId, WalletSessionId } from '../authorization/capabilityKinds';
+import type { DigestB64u } from './canonicalPrimitives';
+import { type WalletAuthMethodId, type WalletAuthorityId, type WalletId } from './domainIds';
+import type { EmailOtpWalletAuthMethodDraftV1, PasskeyWalletAuthMethodDraftV1, WalletAuthMethodRecordV2 } from './registrationIntent';
+import type { WalletAuthMethod } from './signerDomain';
+/**
+ * The factor family a method belongs to.
+ *
+ * This is the repo's existing `WalletAuthMethod`, not a new type: a
+ * hand-written `'passkey' | 'email_otp'` would be a second, unversioned
+ * declaration of the same domain fact, which is what the auth-method domain
+ * guard fails on. The alias exists only to name the role the value plays in an
+ * addition — which family a branch fills in — and the assertion below keeps it
+ * from drifting from the canonical record's own discriminant.
+ */
+export type WalletAuthMethodFamilyV1 = WalletAuthMethod;
+/**
+ * The two exhaustive branches. The name reads source-to-target, which is the
+ * order every stage of the operation uses: resolve the source, then verify the
+ * target.
+ */
+export type AddWalletAuthMethodBranchV1 = 'passkey_to_email_otp' | 'email_otp_to_passkey';
+/**
+ * A validated authority generation. Branding it stops a revocation epoch from
+ * being read as any other integer on the authority — a signer slot, a counter,
+ * a timestamp — at the boundaries where all of them arrive as bare numbers.
+ */
+export type WalletAuthorityRevocationEpochV1 = number & {
+    readonly __walletAuthorityRevocationEpochBrand: 'WalletAuthorityRevocationEpochV1';
+};
+/**
+ * One server-allocated addition ceremony. The server mints it, binds the
+ * target method ID to it, and a client request can neither nominate nor
+ * substitute one.
+ */
+export type AddWalletAuthMethodCeremonyIdV1 = string & {
+    readonly __addWalletAuthMethodCeremonyIdBrand: 'AddWalletAuthMethodCeremonyIdV1';
+};
+/**
+ * Everything the active Wallet Session names about the source.
+ *
+ * The caller supplies none of it: the selected session names the exact source
+ * method, and the server resolves the wallet, authority, device, digest, and
+ * epoch from that method. Each field is required, so a branch cannot be built
+ * from a partially resolved session.
+ */
+export type AddWalletAuthMethodSourceV1 = {
+    readonly walletId: WalletId;
+    readonly walletAuthorityId: WalletAuthorityId;
+    readonly sourceWalletAuthMethodId: WalletAuthMethodId;
+    readonly sourceWalletSessionId: WalletSessionId;
+    readonly deviceId: DeviceId;
+    readonly authorityDigestB64u: DigestB64u;
+    readonly revocationEpoch: WalletAuthorityRevocationEpochV1;
+};
+/**
+ * The intent identity every stage revalidates against.
+ *
+ * `targetWalletAuthMethodId` is allocated by the server during preparation and
+ * bound into the Passkey creation options or the Email OTP grant, so a retry
+ * that reuses this intent converges on the same target method instead of
+ * creating a second one.
+ */
+export type AddWalletAuthMethodIntentIdentityV1 = {
+    readonly addAuthMethodCeremonyId: AddWalletAuthMethodCeremonyIdV1;
+    readonly intentDigestB64u: DigestB64u;
+    readonly targetWalletAuthMethodId: WalletAuthMethodId;
+    readonly expiresAtMs: number;
+};
+/**
+ * Fresh source authorization for this exact intent.
+ *
+ * Both variants carry the digest they were collected against, which is what
+ * binds the proof to one wallet, authority, source method, source session,
+ * target method ID, and authority state rather than to the operation kind.
+ */
+export type VerifiedAddWalletAuthMethodSourceProofV1 = {
+    readonly kind: 'verified_passkey_source_proof_v1';
+    readonly walletAuthMethodId: WalletAuthMethodId;
+    readonly boundIntentDigestB64u: DigestB64u;
+    readonly verifiedAtMs: number;
+} | {
+    readonly kind: 'verified_email_otp_source_proof_v1';
+    readonly walletAuthMethodId: WalletAuthMethodId;
+    readonly boundIntentDigestB64u: DigestB64u;
+    readonly verifiedAtMs: number;
+};
+/**
+ * The independently verified target factor plus its exact draft.
+ *
+ * A source proof can never appear here: the target is verified on its own
+ * evidence — a created credential, or a consumed one-use Email OTP grant — and
+ * the two are separate fields on the branch so neither can stand in for the
+ * other.
+ */
+export type VerifiedAddWalletAuthMethodTargetV1 = {
+    readonly kind: 'verified_passkey_target_v1';
+    readonly authMethod: PasskeyWalletAuthMethodDraftV1;
+    readonly verificationDigestB64u: DigestB64u;
+    readonly verifiedAtMs: number;
+} | {
+    readonly kind: 'verified_email_otp_target_v1';
+    readonly authMethod: EmailOtpWalletAuthMethodDraftV1;
+    readonly verificationDigestB64u: DigestB64u;
+    readonly verifiedAtMs: number;
+};
+type VerifiedPasskeySourceProofV1 = Extract<VerifiedAddWalletAuthMethodSourceProofV1, {
+    readonly kind: 'verified_passkey_source_proof_v1';
+}>;
+type VerifiedEmailOtpSourceProofV1 = Extract<VerifiedAddWalletAuthMethodSourceProofV1, {
+    readonly kind: 'verified_email_otp_source_proof_v1';
+}>;
+type VerifiedPasskeyTargetV1 = Extract<VerifiedAddWalletAuthMethodTargetV1, {
+    readonly kind: 'verified_passkey_target_v1';
+}>;
+type VerifiedEmailOtpTargetV1 = Extract<VerifiedAddWalletAuthMethodTargetV1, {
+    readonly kind: 'verified_email_otp_target_v1';
+}>;
+type AddWalletAuthMethodInputCommonV1 = {
+    readonly source: AddWalletAuthMethodSourceV1;
+    readonly intent: AddWalletAuthMethodIntentIdentityV1;
+};
+/**
+ * What core code accepts after verification, and the only shape the activation
+ * stage reads. The proof/target pairing is fixed per branch, so a verified
+ * Passkey source cannot arrive alongside a verified Passkey target.
+ */
+export type VerifiedAddWalletAuthMethodInputV1 = (AddWalletAuthMethodInputCommonV1 & {
+    readonly branch: 'passkey_to_email_otp';
+    readonly sourceProof: VerifiedPasskeySourceProofV1;
+    readonly target: VerifiedEmailOtpTargetV1;
+}) | (AddWalletAuthMethodInputCommonV1 & {
+    readonly branch: 'email_otp_to_passkey';
+    readonly sourceProof: VerifiedEmailOtpSourceProofV1;
+    readonly target: VerifiedPasskeyTargetV1;
+});
+export type AddWalletAuthMethodFailureReasonV1 = 'source_session_not_selected' | 'source_method_not_active' | 'source_authority_not_active' | 'source_authority_not_full_owner' | 'source_authority_changed' | 'local_installation_incomplete' | 'source_proof_rejected' | 'target_factor_rejected' | 'target_family_present' | 'intent_expired' | 'intent_digest_mismatch' | 'identity_mismatch' | 'custody_reseal_failed' | 'local_persistence_failed' | 'activation_conflict';
+/**
+ * The one result union both SDK entry points return. UI control flow switches
+ * on `kind`; `reason` and `message` are display and diagnostic data and never
+ * select a code path.
+ */
+export type AddWalletAuthMethodResultV1 = {
+    readonly kind: 'active';
+    readonly branch: AddWalletAuthMethodBranchV1;
+    readonly walletId: WalletId;
+    readonly walletAuthorityId: WalletAuthorityId;
+    readonly walletAuthMethodId: WalletAuthMethodId;
+    readonly family: WalletAuthMethodFamilyV1;
+    readonly sourceWalletAuthMethodId: WalletAuthMethodId;
+    readonly sourceWalletSessionId: WalletSessionId;
+} | {
+    readonly kind: 'already_configured';
+    readonly walletId: WalletId;
+    readonly walletAuthorityId: WalletAuthorityId;
+    readonly family: WalletAuthMethodFamilyV1;
+    readonly existingWalletAuthMethodId: WalletAuthMethodId;
+} | {
+    readonly kind: 'cancelled';
+    readonly branch: AddWalletAuthMethodBranchV1;
+} | {
+    readonly kind: 'expired';
+    readonly branch: AddWalletAuthMethodBranchV1;
+} | {
+    readonly kind: 'unauthorized';
+    readonly branch: AddWalletAuthMethodBranchV1;
+    readonly reason: AddWalletAuthMethodFailureReasonV1;
+    readonly message: string;
+} | {
+    readonly kind: 'target_verification_failed';
+    readonly branch: AddWalletAuthMethodBranchV1;
+    readonly reason: AddWalletAuthMethodFailureReasonV1;
+    readonly message: string;
+} | {
+    readonly kind: 'integrity_error';
+    readonly branch: AddWalletAuthMethodBranchV1;
+    readonly reason: AddWalletAuthMethodFailureReasonV1;
+    readonly message: string;
+};
+/**
+ * Admission: what the operation does before it verifies anything.
+ *
+ * `already_configured` is a first-class outcome rather than a failure, because
+ * a user whose wallet already has both families asked for a state that already
+ * holds. Resolving it here is what keeps the promise that a present family
+ * never reaches target verification or a local write.
+ */
+export type AddWalletAuthMethodAdmissionV1 = {
+    readonly kind: 'proceed';
+    readonly branch: AddWalletAuthMethodBranchV1;
+} | {
+    readonly kind: 'already_configured';
+    readonly family: WalletAuthMethodFamilyV1;
+    readonly existingWalletAuthMethodId: WalletAuthMethodId;
+};
+export declare function unreachableAddWalletAuthMethodBranch(value: never): never;
+/** The family a branch fills in. */
+export declare function addWalletAuthMethodTargetFamily(branch: AddWalletAuthMethodBranchV1): WalletAuthMethodFamilyV1;
+/** The family the branch authorizes from. */
+export declare function addWalletAuthMethodSourceFamily(branch: AddWalletAuthMethodBranchV1): WalletAuthMethodFamilyV1;
+/**
+ * Resolves the branch from the exact active inventory of one authority.
+ *
+ * The selected session's method decides the source, and the requested target
+ * family decides the rest. Both same-family cases — the target family is the
+ * source's own, or a sibling already holds it — land on `already_configured`,
+ * which is why the operation needs no same-family rejection of its own.
+ */
+export declare function admitAddWalletAuthMethod(input: {
+    readonly sourceMethod: Extract<WalletAuthMethodRecordV2, {
+        readonly status: 'active';
+    }>;
+    readonly targetFamily: WalletAuthMethodFamilyV1;
+    readonly activeMethodsOnAuthority: readonly Extract<WalletAuthMethodRecordV2, {
+        readonly status: 'active';
+    }>[];
+}): AddWalletAuthMethodAdmissionV1;
+export declare function parseWalletAuthorityRevocationEpochV1(value: unknown): WalletAuthorityRevocationEpochV1;
+export declare function parseAddWalletAuthMethodCeremonyIdV1(value: unknown): AddWalletAuthMethodCeremonyIdV1;
+/**
+ * The one place raw source identity becomes branded. Every field is read from
+ * the resolved session and authority, so a caller cannot widen the source by
+ * supplying an extra one.
+ */
+export declare function parseAddWalletAuthMethodSourceV1(raw: {
+    readonly walletId: unknown;
+    readonly walletAuthorityId: unknown;
+    readonly sourceWalletAuthMethodId: unknown;
+    readonly sourceWalletSessionId: unknown;
+    readonly deviceId: unknown;
+    readonly authorityDigestB64u: unknown;
+    readonly revocationEpoch: unknown;
+}): AddWalletAuthMethodSourceV1;
+export declare function parseAddWalletAuthMethodIntentIdentityV1(raw: {
+    readonly addAuthMethodCeremonyId: unknown;
+    readonly intentDigestB64u: unknown;
+    readonly targetWalletAuthMethodId: unknown;
+    readonly expiresAtMs: unknown;
+}): AddWalletAuthMethodIntentIdentityV1;
+/**
+ * Branch-specific builders rather than one constructor with a `branch`
+ * parameter: each accepts only the proof and target its branch can hold, so a
+ * mismatched pair is a compile error at the call site instead of a runtime
+ * check inside the operation.
+ */
+export declare function buildPasskeyToEmailOtpAdditionV1(input: {
+    readonly source: AddWalletAuthMethodSourceV1;
+    readonly intent: AddWalletAuthMethodIntentIdentityV1;
+    readonly sourceProof: VerifiedPasskeySourceProofV1;
+    readonly target: VerifiedEmailOtpTargetV1;
+}): Extract<VerifiedAddWalletAuthMethodInputV1, {
+    readonly branch: 'passkey_to_email_otp';
+}>;
+export declare function buildEmailOtpToPasskeyAdditionV1(input: {
+    readonly source: AddWalletAuthMethodSourceV1;
+    readonly intent: AddWalletAuthMethodIntentIdentityV1;
+    readonly sourceProof: VerifiedEmailOtpSourceProofV1;
+    readonly target: VerifiedPasskeyTargetV1;
+}): Extract<VerifiedAddWalletAuthMethodInputV1, {
+    readonly branch: 'email_otp_to_passkey';
+}>;
+/**
+ * The exact active record the activation stage inserts.
+ *
+ * It reuses the source authority and the server-allocated target method ID,
+ * and it is built from the verified target draft alone — no field is carried
+ * across from the source method, which is what keeps addition from copying
+ * permissions, activations, or credential identity onto the new method.
+ */
+export declare function buildAddedWalletAuthMethodRecordV2Input(input: {
+    readonly verified: VerifiedAddWalletAuthMethodInputV1;
+    readonly nowMs: number;
+}): WalletAuthMethodRecordV2;
+export {};
+//# sourceMappingURL=addWalletAuthMethod.d.ts.map

package/dist/types/shared-ts/src/utils/addWalletAuthMethod.typecheck.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Compile-time fixtures for the Refactor 109C addition contract.
+ *
+ * Every `@ts-expect-error` below is a state R109C forbids. If one of them ever
+ * starts compiling, the branch union has been widened — a same-family
+ * addition, a mixed target draft, an unverified value, or a cast has become
+ * expressible — and this file fails the build rather than the behaviour
+ * failing in a browser.
+ */
+export {};
+//# sourceMappingURL=addWalletAuthMethod.typecheck.d.ts.map

package/dist/types/shared-ts/src/utils/authenticatorOptions.d.ts

@@ -0,0 +1,25 @@
+export declare enum UserVerificationPolicy {
+    Required = "required",
+    Preferred = "preferred",
+    Discouraged = "discouraged"
+}
+export interface OriginPolicyInput {
+    single: boolean | undefined;
+    all_subdomains: boolean | undefined;
+    multiple: string[] | undefined;
+}
+export interface AuthenticatorOptions {
+    userVerification: UserVerificationPolicy;
+    originPolicy: OriginPolicyInput;
+}
+type AuthenticatorOptionsLike = AuthenticatorOptions | {
+    userVerification: UserVerificationPolicy;
+    originPolicy: {
+        single: boolean | undefined;
+        all_subdomains: boolean | undefined;
+        multiple: readonly string[] | string[] | undefined;
+    };
+};
+export declare function cloneAuthenticatorOptions(options: AuthenticatorOptionsLike): AuthenticatorOptions;
+export {};
+//# sourceMappingURL=authenticatorOptions.d.ts.map

package/dist/types/shared-ts/src/utils/base58.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 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
+ */
+export declare const base58Encode: (data: Uint8Array | ArrayBuffer | number[]) => string;
+/**
+ * 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
+ */
+export declare const base58Decode: (base58String: string) => Uint8Array;
+//# sourceMappingURL=base58.d.ts.map