@seams/wallet-server 0.5.0

package/dist/types/wallet-server/src/core/signingLanes/LaneLifecycleStore.d.ts

@@ -0,0 +1,229 @@
+import type { AggregateLaneActivationReceiptV1, AggregateLaneRevocationReceiptV1, CommitLaneEnrollmentActivationV1, CompleteSigningLaneRevocationV1, LaneEnrollmentLifecycleV1, LaneEnrollmentManifestV1, LaneProductEpochRecordV1, LaneProtocolLifecycle, LaneProtocolRecordV1, LaneProtocolCasResultV1, RevokeLaneEnrollmentV1, LaneProtocolCommitReceiptV1, LaneHolderDeliveryReceiptV1, LaneServerActivationReceiptV1, LaneServerRetirementReceiptV1, RevokeSigningLaneV1 } from '../../../../shared-ts/src/signing-lanes';
+import type { LaneEnrollmentId, LaneOperationId, LaneShareEpoch, SigningLaneId, WalletKeyId } from '../../../../shared-ts/src/signing-lanes';
+import type { MpcMaterialActivationRef, WalletId } from '../../../../shared-ts/src/utils/domainIds';
+/** A version is monotonic inside one immutable protocol or enrollment row. */
+export type LaneVersionedRecord<T> = {
+    readonly version: number;
+    readonly commandDigestB64u: string;
+    readonly value: T;
+};
+export type LaneEnrollmentAdmissionRecord = LaneVersionedRecord<{
+    readonly manifest: LaneEnrollmentManifestV1;
+    readonly lifecycle: LaneEnrollmentLifecycleV1;
+}>;
+export type LaneProtocolAdmissionRecord = LaneVersionedRecord<LaneProtocolRecordV1>;
+export type LaneAdmissionMutationResult<T> = {
+    readonly outcome: 'applied';
+    readonly version: number;
+    readonly commandDigestB64u: string;
+    readonly value: T;
+} | {
+    readonly outcome: 'replayed';
+    readonly version: number;
+    readonly commandDigestB64u: string;
+    readonly value: T;
+} | {
+    readonly outcome: 'conflict';
+    readonly expectedVersion: number | null;
+    readonly actualVersion: number;
+    readonly requestedCommandDigestB64u: string;
+    readonly storedCommandDigestB64u: string;
+};
+export type LaneEnrollmentAdmissionInput = {
+    readonly manifest: LaneEnrollmentManifestV1;
+    readonly children: readonly LaneProtocolRecordV1[];
+    readonly commandDigestB64u: string;
+    readonly lifecycle: Extract<LaneEnrollmentLifecycleV1, {
+        state: 'preparing';
+    }>;
+};
+export type LaneProtocolAdmissionInput = {
+    readonly record: LaneProtocolRecordV1;
+    readonly commandDigestB64u: string;
+};
+export type LaneProtocolLifecycleCasInput = {
+    readonly operationId: LaneOperationId;
+    readonly expectedVersion: number;
+    readonly commandDigestB64u: string;
+    readonly lifecycle: LaneProtocolLifecycle;
+};
+export type LaneEnrollmentLifecycleCasInput = {
+    readonly enrollmentId: LaneEnrollmentId;
+    readonly expectedVersion: number;
+    readonly commandDigestB64u: string;
+    readonly lifecycle: LaneEnrollmentLifecycleV1;
+};
+export type LaneEnrollmentVisibilityCommitResult = {
+    readonly outcome: 'applied' | 'replayed';
+    readonly version: number;
+    readonly commandDigestB64u: string;
+    readonly receipt: AggregateLaneActivationReceiptV1;
+    readonly lifecycle: Extract<LaneEnrollmentLifecycleV1, {
+        state: 'active';
+    }>;
+    readonly productEpochs: readonly [LaneProductEpochRecordV1, ...LaneProductEpochRecordV1[]];
+} | {
+    readonly outcome: 'conflict';
+    readonly enrollmentId: LaneEnrollmentId;
+    readonly expectedVersion: number;
+    readonly actualVersion: number;
+    readonly requestedCommandDigestB64u: string;
+    readonly storedCommandDigestB64u: string;
+};
+export type LaneEnrollmentRevocationCommitResult = {
+    readonly outcome: 'applied' | 'replayed';
+    readonly version: number;
+    readonly commandDigestB64u: string;
+    readonly receipt: AggregateLaneRevocationReceiptV1;
+    readonly lifecycle: Extract<LaneEnrollmentLifecycleV1, {
+        state: 'revoked';
+    }>;
+    readonly productEpochs: readonly [LaneProductEpochRecordV1, ...LaneProductEpochRecordV1[]];
+} | {
+    readonly outcome: 'conflict';
+    readonly enrollmentId: LaneEnrollmentId;
+    readonly expectedVersion: number;
+    readonly actualVersion: number;
+    readonly requestedCommandDigestB64u: string;
+    readonly storedCommandDigestB64u: string;
+};
+export type LaneProductEpochLookup = {
+    readonly walletId: WalletId;
+    readonly walletKeyId: WalletKeyId;
+    readonly laneId: SigningLaneId;
+    readonly laneShareEpoch: LaneShareEpoch;
+};
+export type LaneActiveProductEpochLookup = LaneProductEpochLookup & {
+    readonly materialActivation: MpcMaterialActivationRef;
+};
+export type LaneLock = {
+    readonly lockKey: string;
+    readonly lockKind: 'wallet_key';
+    readonly walletKeyId: WalletKeyId;
+    readonly enrollmentId?: never;
+    readonly laneId?: never;
+    readonly lockId: string;
+    readonly acquiredAtMs: number;
+    readonly expiresAtMs: number;
+} | {
+    readonly lockKey: string;
+    readonly lockKind: 'enrollment';
+    readonly enrollmentId: LaneEnrollmentId;
+    readonly walletKeyId?: never;
+    readonly laneId?: never;
+    readonly lockId: string;
+    readonly acquiredAtMs: number;
+    readonly expiresAtMs: number;
+};
+export type LaneLockResult = {
+    readonly outcome: 'applied';
+    readonly lock: LaneLock;
+} | {
+    readonly outcome: 'replayed';
+    readonly lock: LaneLock;
+} | {
+    readonly outcome: 'conflict';
+    readonly actual: LaneLock | null;
+};
+export interface LaneLockStore {
+    acquireWalletKeyLock(input: {
+        readonly walletKeyId: WalletKeyId;
+        readonly lockId: string;
+        readonly ttlMs: number;
+        readonly nowMs: number;
+    }): Promise<LaneLockResult>;
+    acquireEnrollmentLock(input: {
+        readonly enrollmentId: LaneEnrollmentId;
+        readonly lockId: string;
+        readonly ttlMs: number;
+        readonly nowMs: number;
+    }): Promise<LaneLockResult>;
+    releaseLock(input: {
+        readonly lockKey: string;
+        readonly lockId: string;
+    }): Promise<boolean>;
+}
+/**
+ * Gateway-owned lane lifecycle persistence. Implementations must perform
+ * compare-and-set writes in the database transaction itself; callers cannot
+ * turn a read into an authorization decision.
+ */
+export interface LaneLifecycleStore {
+    getEnrollment(enrollmentId: LaneEnrollmentId): Promise<LaneEnrollmentAdmissionRecord | null>;
+    getProtocol(operationId: LaneOperationId): Promise<LaneProtocolAdmissionRecord | null>;
+    putEnrollmentAdmission(input: LaneEnrollmentAdmissionInput): Promise<LaneAdmissionMutationResult<LaneEnrollmentAdmissionRecord['value']>>;
+    putProtocolAdmission(input: LaneProtocolAdmissionInput): Promise<LaneAdmissionMutationResult<LaneProtocolRecordV1>>;
+    compareAndSetProtocolLifecycle(input: LaneProtocolLifecycleCasInput): Promise<LaneProtocolCasResultV1>;
+    putProtocolCommitReceipt(receipt: LaneProtocolCommitReceiptV1, commandDigestB64u: string): Promise<LaneAdmissionMutationResult<LaneProtocolCommitReceiptV1>>;
+    putHolderDeliveryReceipt(receipt: LaneHolderDeliveryReceiptV1, commandDigestB64u: string): Promise<LaneAdmissionMutationResult<LaneHolderDeliveryReceiptV1>>;
+    putServerActivationReceipt(receipt: LaneServerActivationReceiptV1, commandDigestB64u: string): Promise<LaneAdmissionMutationResult<LaneServerActivationReceiptV1>>;
+    putProductEpochPending(productEpoch: Extract<LaneProductEpochRecordV1, {
+        state: 'pending_visibility';
+    }>, commandDigestB64u: string): Promise<LaneAdmissionMutationResult<LaneProductEpochRecordV1>>;
+    compareAndSetEnrollmentLifecycle(input: LaneEnrollmentLifecycleCasInput): Promise<LaneAdmissionMutationResult<LaneEnrollmentAdmissionRecord['value']>>;
+    getProductEpoch(lookup: LaneProductEpochLookup): Promise<LaneProductEpochRecordV1 | null>;
+    getActiveProductEpoch(lookup: LaneActiveProductEpochLookup): Promise<Extract<LaneProductEpochRecordV1, {
+        state: 'active';
+    }> | null>;
+    listEnrollmentProductEpochs(enrollmentId: LaneEnrollmentId): Promise<readonly LaneProductEpochRecordV1[]>;
+    commitEnrollmentVisibility(input: CommitLaneEnrollmentActivationV1): Promise<LaneEnrollmentVisibilityCommitResult>;
+    fenceLaneRevocation(input: RevokeSigningLaneV1): Promise<LaneSigningLaneRevocationFenceMutationResult>;
+    fenceEnrollmentRevocation(input: RevokeLaneEnrollmentV1): Promise<LaneAdmissionMutationResult<LaneEnrollmentAdmissionRecord['value']>>;
+    commitEnrollmentRevocation(input: LaneEnrollmentRevocationCommitInput): Promise<LaneEnrollmentRevocationCommitResult>;
+    commitLaneRevocation(input: LaneSigningLaneRevocationCommitInput): Promise<LaneSigningLaneRevocationMutationResult>;
+}
+export type LaneSigningLaneRevocationFenceMutationResult = {
+    readonly outcome: 'applied' | 'replayed';
+    readonly version: number;
+    readonly commandDigestB64u: string;
+    readonly productEpoch: Extract<LaneProductEpochRecordV1, {
+        state: 'revocation_pending';
+    }>;
+} | {
+    readonly outcome: 'already_completed';
+    readonly version: number;
+    readonly commandDigestB64u: string;
+    readonly productEpoch: Extract<LaneProductEpochRecordV1, {
+        state: 'revoked';
+    }>;
+    readonly retirementReceipt: LaneServerRetirementReceiptV1;
+} | {
+    readonly outcome: 'conflict';
+    readonly expectedVersion: number;
+    readonly actualVersion: number;
+    readonly requestedCommandDigestB64u: string;
+    readonly storedCommandDigestB64u: string;
+};
+export type LaneSigningLaneRevocationMutationResult = {
+    readonly outcome: 'applied' | 'replayed';
+    readonly version: number;
+    readonly commandDigestB64u: string;
+    readonly productEpoch: Extract<LaneProductEpochRecordV1, {
+        state: 'revoked';
+    }>;
+    readonly retirementReceipt: LaneServerRetirementReceiptV1;
+} | {
+    readonly outcome: 'conflict';
+    readonly expectedVersion: number;
+    readonly actualVersion: number;
+    readonly requestedCommandDigestB64u: string;
+    readonly storedCommandDigestB64u: string;
+};
+export type LaneSigningLaneRevocationCommitInput = {
+    readonly completion: CompleteSigningLaneRevocationV1;
+};
+export type LaneEnrollmentRevocationCommitInput = {
+    readonly command: {
+        readonly kind: 'commit_lane_enrollment_revocation_v1';
+        readonly enrollmentId: LaneEnrollmentId;
+        readonly walletId: WalletId;
+        readonly manifestDigestB64u: string;
+        readonly receipt: AggregateLaneRevocationReceiptV1;
+        readonly revokedAtMs: number;
+    };
+    readonly expectedVersion: number;
+    readonly commandDigestB64u: string;
+};
+export declare function protocolCasResultToAdmissionResult(result: LaneProtocolCasResultV1): LaneAdmissionMutationResult<LaneProtocolRecordV1>;
+export declare function assertNonEmptyVersion(value: number, label: string): number;
+//# sourceMappingURL=LaneLifecycleStore.d.ts.map

package/dist/types/wallet-server/src/core/signingLanes/SigningLaneStore.d.ts

@@ -0,0 +1,15 @@
+import type { SigningLaneId, SigningLaneRecord, WalletKeyId } from '../../../../shared-ts/src/signing-lanes';
+import type { WalletId } from '../../../../shared-ts/src/utils/domainIds';
+export type SigningLaneLookup = {
+    walletId: WalletId;
+    walletKeyId: WalletKeyId;
+    laneId: SigningLaneId;
+};
+export interface SigningLaneStore {
+    getSigningLane(lookup: SigningLaneLookup): Promise<SigningLaneRecord | null>;
+    listSigningLanes(args: {
+        walletId: WalletId;
+        walletKeyId: WalletKeyId;
+    }): Promise<readonly SigningLaneRecord[]>;
+}
+//# sourceMappingURL=SigningLaneStore.d.ts.map

package/dist/types/wallet-server/src/core/signingLanes/WalletExecutionLaneProjection.d.ts

@@ -0,0 +1,59 @@
+import { type SigningLaneRecord, type WalletKeyRecord } from '../../../../shared-ts/src/signing-lanes';
+import { type DigestB64u } from '../../../../shared-ts/src/utils/canonicalPrimitives';
+import type { MpcMaterialActivationRef, ProviderSubject, WalletAuthMethodId, WalletId } from '../../../../shared-ts/src/utils/domainIds';
+import { type WalletAuthMethodRecordV2 } from '../../../../shared-ts/src/utils/registrationIntent';
+import { type WalletAuthAuthorityRef } from '../../../../shared-ts/src/utils/walletAuthAuthority';
+import type { WalletSignerRecord } from '../WalletStore';
+export type ActiveOwnerWalletExecutionLaneProjection = {
+    readonly kind: 'active_owner_wallet_execution_lane_projection_v1';
+    readonly walletKey: WalletKeyRecord;
+    readonly lane: Extract<SigningLaneRecord, {
+        readonly laneKind: 'owner_passkey' | 'owner_email_otp';
+    }>;
+    readonly materialActivation: MpcMaterialActivationRef;
+    readonly verifiedActivationReceiptDigestB64u: DigestB64u;
+};
+export type WalletExecutionLaneProjectionRefusalReason = 'auth_method_missing' | 'auth_method_ambiguous' | 'auth_method_inactive' | 'auth_method_mismatch' | 'signer_missing' | 'signer_ambiguous' | 'signer_conflict' | 'signer_invalid';
+export type WalletExecutionLaneProjectionResult = {
+    readonly kind: 'projected';
+    readonly projection: ActiveOwnerWalletExecutionLaneProjection;
+} | {
+    readonly kind: 'refused';
+    readonly reason: WalletExecutionLaneProjectionRefusalReason;
+};
+export interface WalletExecutionLaneProjectionSource {
+    listWalletAuthMethods(input: {
+        readonly walletId: WalletId;
+    }): Promise<readonly WalletAuthMethodRecordV2[]>;
+    listWalletSigners(input: {
+        readonly walletId: WalletId;
+    }): Promise<readonly WalletSignerRecord[]>;
+}
+export type WalletExecutionLaneAuthSource = {
+    readonly kind: 'passkey';
+    readonly credentialIdB64u: string;
+} | {
+    readonly kind: 'oidc_provider';
+    readonly providerId: 'google_oidc' | 'oidc';
+    readonly providerSubject: ProviderSubject;
+};
+export declare function resolveWalletAuthMethodIdForAuthority(input: {
+    readonly walletId: WalletId;
+    readonly authorityRef: WalletAuthAuthorityRef;
+    readonly authSource: WalletExecutionLaneAuthSource;
+    readonly authMethods: readonly WalletAuthMethodRecordV2[];
+}): Promise<WalletAuthMethodId | null>;
+export declare function resolveActiveOwnerWalletExecutionLane(input: {
+    readonly source: WalletExecutionLaneProjectionSource;
+    readonly walletId: WalletId;
+    readonly walletAuthMethodId: WalletAuthMethodId;
+    readonly expectedMaterialActivation: MpcMaterialActivationRef;
+}): Promise<WalletExecutionLaneProjectionResult>;
+export declare function projectActiveOwnerWalletExecutionLane(input: {
+    readonly walletId: WalletId;
+    readonly walletAuthMethodId: WalletAuthMethodId;
+    readonly authMethod: WalletAuthMethodRecordV2;
+    readonly signers: readonly WalletSignerRecord[];
+    readonly expectedMaterialActivation: MpcMaterialActivationRef;
+}): Promise<ActiveOwnerWalletExecutionLaneProjection>;
+//# sourceMappingURL=WalletExecutionLaneProjection.d.ts.map

package/dist/types/wallet-server/src/core/signingLanes/WalletKeyStore.d.ts

@@ -0,0 +1,13 @@
+import type { WalletKeyId, WalletKeyRecord } from '../../../../shared-ts/src/signing-lanes';
+import type { WalletId } from '../../../../shared-ts/src/utils/domainIds';
+export type WalletKeyLookup = {
+    readonly walletId: WalletId;
+    readonly walletKeyId: WalletKeyId;
+};
+export interface WalletKeyStore {
+    getWalletKey(lookup: WalletKeyLookup): Promise<WalletKeyRecord | null>;
+    listWalletKeys(input: {
+        readonly walletId: WalletId;
+    }): Promise<readonly WalletKeyRecord[]>;
+}
+//# sourceMappingURL=WalletKeyStore.d.ts.map

package/dist/types/wallet-server/src/core/signingLanes/ecdsaServerRetirement.d.ts

@@ -0,0 +1,58 @@
+import type { EcdsaManifestIdentity, EcdsaServerRetirementReceiptV1, RevokeSigningLaneV1 } from '../../../../shared-ts/src/signing-lanes';
+import type { CorrelationId, DigestB64u } from '../../../../shared-ts/src/utils/canonicalPrimitives';
+import { type LaneShareEpoch, type MpcMaterialActivationRef, type SigningLaneId, type WalletKeyId } from '../../../../shared-ts/src/utils/domainIds';
+import type { EcdsaLifecycleId, EcdsaServerGeneration } from '../../../../shared-ts/src/utils/ecdsaCapabilityActivation';
+import type { EcdsaSigningWorkerLaneMaterialIdentityV1 } from './signingWorkerLaneMaterialIdentity';
+export type EcdsaServerRetirementBindingV1 = {
+    readonly identity: EcdsaSigningWorkerLaneMaterialIdentityV1;
+    readonly manifest: EcdsaManifestIdentity;
+    readonly materialActivation: MpcMaterialActivationRef;
+    readonly serverGeneration: EcdsaServerGeneration;
+    readonly lifecycleId: EcdsaLifecycleId;
+};
+export type EcdsaServerRetirementExpectationV1 = {
+    readonly manifest: EcdsaManifestIdentity;
+    readonly materialActivation: MpcMaterialActivationRef;
+    readonly walletKeyId: WalletKeyId;
+    readonly laneId: SigningLaneId;
+    readonly laneShareEpoch: LaneShareEpoch;
+    readonly revocationEpoch: number;
+    readonly retirementReason: EcdsaServerRetirementReceiptV1['retirementReason'];
+    readonly retirementCorrelationId: CorrelationId;
+    readonly retirementRequestDigestB64u: DigestB64u;
+    readonly serverGeneration: EcdsaServerGeneration;
+    readonly lifecycleId: EcdsaLifecycleId;
+    /** Gateway's pre-authorized effect fence. It is distinct from receiptDigestB64u. */
+    readonly retirementEffectBindingDigestB64u: DigestB64u;
+};
+export type EcdsaServerRetirementRequestV1 = {
+    readonly identity: EcdsaSigningWorkerLaneMaterialIdentityV1;
+    readonly manifest: EcdsaManifestIdentity;
+    readonly materialActivation: MpcMaterialActivationRef;
+    readonly revocationEpoch: number;
+    readonly retirementReason: EcdsaServerRetirementReceiptV1['retirementReason'];
+    readonly retirementCorrelationId: CorrelationId;
+    readonly retirementRequestDigestB64u: DigestB64u;
+    readonly retirementEffectBindingDigestB64u: DigestB64u;
+    readonly serverGeneration: EcdsaServerGeneration;
+    readonly lifecycleId: EcdsaLifecycleId;
+};
+export type EcdsaServerRetirementEffectV1 = {
+    readonly outcome: 'applied' | 'replayed';
+    readonly receipt: EcdsaServerRetirementReceiptV1;
+    /** The effect fence authorized by the Gateway command. */
+    readonly retirementEffectBindingDigestB64u: DigestB64u;
+    /** The exact self-digest emitted by the server retirement receipt. */
+    readonly retirementReceiptDigestB64u: DigestB64u;
+};
+export declare function buildEcdsaServerRetirementRequestV1(input: {
+    readonly command: RevokeSigningLaneV1;
+    readonly binding: EcdsaServerRetirementBindingV1;
+}): EcdsaServerRetirementRequestV1;
+export declare function parseAndVerifyEcdsaServerRetirementEffectV1(input: {
+    readonly raw: unknown;
+    readonly expectation: EcdsaServerRetirementExpectationV1;
+    readonly label?: string;
+}): Promise<EcdsaServerRetirementEffectV1>;
+export declare function assertEcdsaServerRetirementReceiptMatchesExpectationV1(receipt: EcdsaServerRetirementReceiptV1, expectation: EcdsaServerRetirementExpectationV1): void;
+//# sourceMappingURL=ecdsaServerRetirement.d.ts.map

package/dist/types/wallet-server/src/core/signingLanes/ed25519ServerRetirement.d.ts

@@ -0,0 +1,30 @@
+import type { Ed25519ServerRetirementReceiptV1, RevokeSigningLaneV1, SigningWorkerLaneMaterialIdentityV1 } from '../../../../shared-ts/src/signing-lanes';
+import { type DigestB64u } from '../../../../shared-ts/src/utils/canonicalPrimitives';
+export type Ed25519ServerRetirementBindingV1 = {
+    readonly identity: SigningWorkerLaneMaterialIdentityV1<'ed25519'>;
+};
+export type Ed25519ServerRetirementRequestV1 = {
+    readonly identity: SigningWorkerLaneMaterialIdentityV1<'ed25519'>;
+    readonly revocationEpoch: number;
+    readonly retirementReason: Ed25519ServerRetirementReceiptV1['retirementReason'];
+    readonly retirementCorrelationId: RevokeSigningLaneV1['retirementCorrelationId'];
+    readonly retirementRequestDigestB64u: DigestB64u;
+    readonly retirementEffectBindingDigestB64u: DigestB64u;
+};
+export type Ed25519ServerRetirementEffectV1 = {
+    readonly outcome: 'applied' | 'replayed';
+    readonly receipt: Ed25519ServerRetirementReceiptV1;
+    readonly retirementEffectBindingDigestB64u: DigestB64u;
+    readonly retirementReceiptDigestB64u: DigestB64u;
+};
+export declare function buildEd25519ServerRetirementRequestV1(input: {
+    readonly command: RevokeSigningLaneV1;
+    readonly binding: Ed25519ServerRetirementBindingV1;
+}): Ed25519ServerRetirementRequestV1;
+export declare function parseAndVerifyEd25519ServerRetirementEffectV1(input: {
+    readonly raw: unknown;
+    readonly request: Ed25519ServerRetirementRequestV1;
+    readonly label?: string;
+}): Promise<Ed25519ServerRetirementEffectV1>;
+export declare function assertEd25519ServerRetirementReceiptMatchesRequestV1(receipt: Ed25519ServerRetirementReceiptV1, request: Ed25519ServerRetirementRequestV1): void;
+//# sourceMappingURL=ed25519ServerRetirement.d.ts.map

package/dist/types/wallet-server/src/core/signingLanes/index.d.ts

@@ -0,0 +1,11 @@
+export * from './SigningLaneStore';
+export * from './WalletKeyStore';
+export * from './WalletExecutionLaneProjection';
+export * from './LaneLifecycleStore';
+export * from './LaneEffectJournalStore';
+export * from './LaneEnrollmentActivation';
+export * from './LaneEnrollmentRevocation';
+export * from './LaneAggregateRevocationApplicationService';
+export * from './LaneLifecycleApplicationService';
+export * from './ecdsaServerRetirement';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/wallet-server/src/core/signingLanes/signingWorkerLaneMaterialIdentity.d.ts

@@ -0,0 +1,21 @@
+import type { LaneEnrollmentId, LaneOperationId, LaneShareEpoch, SigningLaneId, WalletKeyId } from '../../../../shared-ts/src/signing-lanes';
+import type { DigestB64u } from '../../../../shared-ts/src/utils/canonicalPrimitives';
+import type { MpcMaterialActivationId, WalletId } from '../../../../shared-ts/src/utils/domainIds';
+export type SigningWorkerLaneMaterialIdentityV1<TKeyFamily extends 'ed25519' | 'ecdsa_secp256k1' = 'ed25519' | 'ecdsa_secp256k1'> = {
+    readonly operationId: LaneOperationId;
+    readonly enrollmentId: LaneEnrollmentId;
+    readonly walletId: WalletId;
+    readonly walletKeyId: WalletKeyId;
+    readonly targetLaneId: SigningLaneId;
+    readonly targetLaneShareEpoch: LaneShareEpoch;
+    readonly targetMaterialActivationId: MpcMaterialActivationId;
+    readonly keyFamily: TKeyFamily;
+    readonly holderParticipantBindingDigestB64u: DigestB64u;
+    readonly signingWorkerParticipantBindingDigestB64u: DigestB64u;
+    readonly holderRecipientKeyDigestB64u: DigestB64u;
+    readonly serverRecipientKeyDigestB64u: DigestB64u;
+    readonly transcriptHashB64u: DigestB64u;
+    readonly protocolCommitReceiptDigestB64u: DigestB64u;
+};
+export type EcdsaSigningWorkerLaneMaterialIdentityV1 = SigningWorkerLaneMaterialIdentityV1<'ecdsa_secp256k1'>;
+//# sourceMappingURL=signingWorkerLaneMaterialIdentity.d.ts.map

package/dist/types/wallet-server/src/core/signingMaterial/ordinaryInactiveSignerMaterialReservation.d.ts

@@ -0,0 +1,155 @@
+import type { ExactAdministeredEcdsaSignerV1, ExactAdministeredEd25519SignerV1 } from '../../../../shared-ts/src/device-linking/delegatedActivationPlan';
+import { type LinkedDeviceEd25519SourceContributionPreparationV1, type LinkedDeviceEd25519SourceContributionV1, type LinkedDeviceEcdsaEncryptedSourceContributionV1, type LinkedDeviceEcdsaSourceContributionPackageV1, type LinkedDeviceEcdsaSourceDerivationV1, type LinkedDeviceEcdsaSourcePreservingActivationReceiptV1 } from '../../../../shared-ts/src/device-linking/sourceContribution';
+import { type RouterAbEd25519YaoActivationPublicReceiptV1, type RouterAbEd25519YaoActivationClientPackageV1, type RouterAbEd25519YaoCeremonyBindingV1 } from '../../../../shared-ts/src/utils/routerAbEd25519Yao';
+import { type MpcMaterialActivationRef } from '../../../../shared-ts/src/utils/domainIds';
+export type OrdinarySignerFamilyV1 = 'ed25519' | 'ecdsa_secp256k1';
+type OrdinarySignerByFamilyV1 = {
+    readonly ed25519: ExactAdministeredEd25519SignerV1;
+    readonly ecdsa_secp256k1: ExactAdministeredEcdsaSignerV1;
+};
+export type OrdinaryEd25519ClientMaterialV1 = {
+    readonly kind: 'ordinary_ed25519_client_material_v1';
+    readonly deriver_a_client_package: RouterAbEd25519YaoActivationClientPackageV1<'deriver_a'>;
+    readonly deriver_b_client_package: RouterAbEd25519YaoActivationClientPackageV1<'deriver_b'>;
+};
+export type OrdinaryEcdsaClientMaterialV1 = {
+    readonly kind: 'ordinary_ecdsa_client_material_v1';
+    readonly encryptedTargetClientShare: LinkedDeviceEcdsaEncryptedSourceContributionV1;
+};
+export type OrdinaryEcdsaInactiveServerMaterialV1 = {
+    readonly kind: 'ordinary_ecdsa_inactive_server_material_v1';
+    readonly reservationId: OrdinaryInactiveServerMaterialReservationIdV1;
+    readonly encryptedTargetServerShare: LinkedDeviceEcdsaEncryptedSourceContributionV1;
+};
+type OrdinaryClientMaterialByFamilyV1 = {
+    readonly ed25519: OrdinaryEd25519ClientMaterialV1;
+    readonly ecdsa_secp256k1: OrdinaryEcdsaClientMaterialV1;
+};
+type OrdinaryServerMaterialByFamilyV1 = {
+    readonly ed25519: OrdinaryInactiveServerMaterialV1;
+    readonly ecdsa_secp256k1: OrdinaryEcdsaInactiveServerMaterialV1;
+};
+type OrdinaryRequestKindByFamilyV1 = {
+    readonly ed25519: 'ordinary_ed25519_signer_material_reservation_request_v1';
+    readonly ecdsa_secp256k1: 'ordinary_ecdsa_signer_material_reservation_request_v1';
+};
+type OrdinaryWorkerKindByFamilyV1 = {
+    readonly ed25519: 'ordinary_ed25519_signer_material_worker_reservation_v1';
+    readonly ecdsa_secp256k1: 'ordinary_ecdsa_signer_material_worker_reservation_v1';
+};
+type OrdinaryReservationKindByFamilyV1 = {
+    readonly ed25519: 'ordinary_ed25519_signer_material_reservation_v1';
+    readonly ecdsa_secp256k1: 'ordinary_ecdsa_signer_material_reservation_v1';
+};
+type OrdinaryReservationFieldsV1<F extends OrdinarySignerFamilyV1> = {
+    readonly keyFamily: F;
+    readonly state: 'inactive';
+    readonly signer: OrdinarySignerByFamilyV1[F];
+    readonly materialActivation: MpcMaterialActivationRef;
+    readonly clientMaterial: OrdinaryClientMaterialByFamilyV1[F];
+} & (F extends 'ed25519' ? {
+    readonly activationReceipt: RouterAbEd25519YaoActivationPublicReceiptV1;
+    readonly participantIds: readonly [number, number];
+} : {
+    readonly activationReceipt: LinkedDeviceEcdsaSourcePreservingActivationReceiptV1;
+    readonly participantIds?: never;
+});
+export type OrdinaryInactiveServerMaterialReservationIdV1 = string & {
+    readonly __ordinaryInactiveServerMaterialReservationIdBrand: unique symbol;
+};
+export type OrdinaryInactiveServerMaterialV1 = {
+    readonly kind: 'ordinary_inactive_server_material_v1';
+    readonly reservationId: OrdinaryInactiveServerMaterialReservationIdV1;
+};
+export type OrdinaryEd25519SignerMaterialReservationPreparationV1 = {
+    readonly kind: 'ordinary_ed25519_signer_material_reservation_preparation_v1';
+    readonly sourceContribution: LinkedDeviceEd25519SourceContributionV1;
+    readonly targetBinding: RouterAbEd25519YaoCeremonyBindingV1;
+    readonly applicationBinding: LinkedDeviceEd25519SourceContributionPreparationV1['applicationBinding'];
+};
+export type OrdinaryEcdsaSignerMaterialReservationPreparationV1 = {
+    readonly kind: 'ordinary_ecdsa_signer_material_reservation_preparation_v1';
+    readonly sourceDerivation: LinkedDeviceEcdsaSourceDerivationV1;
+    readonly sourceContribution: LinkedDeviceEcdsaSourceContributionPackageV1;
+};
+export type OrdinaryEd25519SignerMaterialReservationRequestV1 = OrdinarySignerMaterialReservationRequestV1<'ed25519'>;
+export type OrdinaryEcdsaSignerMaterialReservationRequestV1 = OrdinarySignerMaterialReservationRequestV1<'ecdsa_secp256k1'>;
+export type OrdinaryInactiveSignerMaterialReservationRequestV1 = OrdinaryEd25519SignerMaterialReservationRequestV1 | OrdinaryEcdsaSignerMaterialReservationRequestV1;
+type OrdinarySignerMaterialReservationRequestV1<F extends OrdinarySignerFamilyV1> = {
+    readonly kind: OrdinaryRequestKindByFamilyV1[F];
+    readonly keyFamily: F;
+    readonly signer: OrdinarySignerByFamilyV1[F];
+    readonly plannedActivationRef: MpcMaterialActivationRef;
+    readonly preparation: F extends 'ed25519' ? OrdinaryEd25519SignerMaterialReservationPreparationV1 : OrdinaryEcdsaSignerMaterialReservationPreparationV1;
+};
+export type OrdinaryEd25519SignerMaterialWorkerReservationV1 = OrdinarySignerMaterialWorkerReservationV1<'ed25519'>;
+export type OrdinaryEcdsaSignerMaterialWorkerReservationV1 = OrdinarySignerMaterialWorkerReservationV1<'ecdsa_secp256k1'>;
+type OrdinarySignerMaterialWorkerReservationV1<F extends OrdinarySignerFamilyV1> = OrdinaryReservationFieldsV1<F> & {
+    readonly kind: OrdinaryWorkerKindByFamilyV1[F];
+    readonly serverMaterial: OrdinaryServerMaterialByFamilyV1[F];
+    readonly activatedAtMs?: never;
+};
+export type OrdinaryEd25519SignerMaterialReservationV1 = OrdinarySignerMaterialReservationV1<'ed25519'>;
+export type OrdinaryEcdsaSignerMaterialReservationV1 = OrdinarySignerMaterialReservationV1<'ecdsa_secp256k1'>;
+export type OrdinaryInactiveSignerMaterialReservationV1 = OrdinaryEd25519SignerMaterialReservationV1 | OrdinaryEcdsaSignerMaterialReservationV1;
+type OrdinarySignerMaterialReservationV1<F extends OrdinarySignerFamilyV1> = OrdinaryReservationFieldsV1<F> & {
+    readonly kind: OrdinaryReservationKindByFamilyV1[F];
+    readonly serverMaterial: OrdinaryServerMaterialByFamilyV1[F];
+    readonly activatedAtMs?: never;
+} & (F extends 'ed25519' ? {
+    readonly targetBinding: RouterAbEd25519YaoCeremonyBindingV1;
+    readonly applicationBinding: LinkedDeviceEd25519SourceContributionPreparationV1['applicationBinding'];
+} : {
+    readonly targetBinding?: never;
+    readonly applicationBinding?: never;
+});
+/** The worker adapter must reserve by the exact ref and leave material inactive. */
+export type OrdinaryInactiveSignerMaterialReservationWorkerPortV1 = {
+    reserveInactiveEd25519SignerMaterialV1(input: OrdinaryEd25519SignerMaterialReservationRequestV1): Promise<OrdinaryEd25519SignerMaterialWorkerReservationV1>;
+    reserveInactiveEcdsaSignerMaterialV1(input: OrdinaryEcdsaSignerMaterialReservationRequestV1): Promise<OrdinaryEcdsaSignerMaterialWorkerReservationV1>;
+};
+type OrdinarySignerMaterialDeactivationKindByFamilyV1 = {
+    readonly ed25519: 'ordinary_ed25519_signer_material_deactivation_v1';
+    readonly ecdsa_secp256k1: 'ordinary_ecdsa_signer_material_deactivation_v1';
+};
+type OrdinarySignerMaterialDeactivationRequestV1<F extends OrdinarySignerFamilyV1> = {
+    readonly keyFamily: F;
+    readonly materialActivation: MpcMaterialActivationRef;
+    readonly requestedAtMs: number;
+};
+export type OrdinaryEd25519SignerMaterialDeactivationRequestV1 = OrdinarySignerMaterialDeactivationRequestV1<'ed25519'>;
+export type OrdinaryEcdsaSignerMaterialDeactivationRequestV1 = OrdinarySignerMaterialDeactivationRequestV1<'ecdsa_secp256k1'>;
+export type OrdinaryInactiveSignerMaterialDeactivationRequestV1 = OrdinaryEd25519SignerMaterialDeactivationRequestV1 | OrdinaryEcdsaSignerMaterialDeactivationRequestV1;
+type OrdinarySignerMaterialDeactivationResultV1<F extends OrdinarySignerFamilyV1> = {
+    readonly kind: OrdinarySignerMaterialDeactivationKindByFamilyV1[F];
+    readonly keyFamily: F;
+    readonly state: 'revoked';
+    readonly materialActivation: MpcMaterialActivationRef;
+    readonly serverMaterialReservationId: OrdinaryInactiveServerMaterialReservationIdV1;
+    readonly revokedAtMs: number;
+};
+export type OrdinaryEd25519SignerMaterialDeactivationResultV1 = OrdinarySignerMaterialDeactivationResultV1<'ed25519'>;
+export type OrdinaryEcdsaSignerMaterialDeactivationResultV1 = OrdinarySignerMaterialDeactivationResultV1<'ecdsa_secp256k1'>;
+export type OrdinaryInactiveSignerMaterialDeactivationResultV1 = OrdinaryEd25519SignerMaterialDeactivationResultV1 | OrdinaryEcdsaSignerMaterialDeactivationResultV1;
+/** Deactivation is a terminal exact-family/ref operation; it never activates material. */
+export type OrdinaryInactiveSignerMaterialDeactivationPortV1 = {
+    deactivateOrdinarySignerMaterialV1(input: OrdinaryInactiveSignerMaterialDeactivationRequestV1): Promise<void>;
+};
+export declare function validateOrdinaryInactiveSignerMaterialDeactivationRequestV1(request: OrdinaryInactiveSignerMaterialDeactivationRequestV1): void;
+export declare function parseOrdinaryEd25519SignerMaterialDeactivationResultV1(request: OrdinaryEd25519SignerMaterialDeactivationRequestV1, raw: unknown): OrdinaryEd25519SignerMaterialDeactivationResultV1;
+export declare function parseOrdinaryEcdsaSignerMaterialDeactivationResultV1(request: OrdinaryEcdsaSignerMaterialDeactivationRequestV1, raw: unknown): OrdinaryEcdsaSignerMaterialDeactivationResultV1;
+export declare class OrdinaryInactiveSignerMaterialReservationServiceV1 {
+    private readonly worker;
+    constructor(worker: OrdinaryInactiveSignerMaterialReservationWorkerPortV1);
+    reserveOrdinaryInactiveSignerMaterialV1(request: OrdinaryInactiveSignerMaterialReservationRequestV1): Promise<OrdinaryInactiveSignerMaterialReservationV1>;
+    private reserveEd25519V1;
+    private reserveEcdsaV1;
+}
+export declare function validateOrdinaryInactiveSignerMaterialReservationRequestV1(request: OrdinaryInactiveSignerMaterialReservationRequestV1): void;
+export declare function createOrdinaryInactiveSignerMaterialReservationServiceV1(input: {
+    readonly worker: OrdinaryInactiveSignerMaterialReservationWorkerPortV1;
+}): OrdinaryInactiveSignerMaterialReservationServiceV1;
+export declare function parseOrdinaryEd25519SignerMaterialWorkerReservationV1(request: OrdinaryEd25519SignerMaterialReservationRequestV1, raw: unknown): OrdinaryEd25519SignerMaterialWorkerReservationV1;
+export declare function parseOrdinaryEcdsaSignerMaterialWorkerReservationV1(request: OrdinaryEcdsaSignerMaterialReservationRequestV1, raw: unknown): OrdinaryEcdsaSignerMaterialWorkerReservationV1;
+export {};
+//# sourceMappingURL=ordinaryInactiveSignerMaterialReservation.d.ts.map