@seams/wallet 0.6.1 → 0.7.1

package/dist/types/wallet/src/core/indexedDB/accountKeyMaterial.d.ts

@@ -9,19 +9,19 @@ export type AccountKeyMaterialDeps = {
     clientDB: ProfileAccountContextPort;
     keyMaterialStore: AccountKeyMaterialStorePort;
 };
-export type MappedAccountKeyMaterialTargetInput = {
+type MappedAccountKeyMaterialTargetInput = {
     accountRefs: AccountRef[];
     explicitProfileId?: never;
     explicitChainIdKey?: never;
     explicitAccountAddress?: never;
 };
-export type ExplicitAccountKeyMaterialTargetInput = {
+type ExplicitAccountKeyMaterialTargetInput = {
     accountRefs: AccountRef[];
     explicitProfileId: string;
     explicitChainIdKey: string;
     explicitAccountAddress: string;
 };
-export type ResolveAccountKeyMaterialTargetInput = MappedAccountKeyMaterialTargetInput | ExplicitAccountKeyMaterialTargetInput;
+type ResolveAccountKeyMaterialTargetInput = MappedAccountKeyMaterialTargetInput | ExplicitAccountKeyMaterialTargetInput;
 export type StoreAccountKeyMaterialInput = ResolveAccountKeyMaterialTargetInput & {
     signerSlot: number;
     keyKind: KeyMaterialKind;
@@ -33,7 +33,7 @@ export type StoreAccountKeyMaterialInput = ResolveAccountKeyMaterialTargetInput
     timestamp?: number;
     schemaVersion?: number;
 };
-export type ResolvedAccountKeyMaterialTarget = {
+type ResolvedAccountKeyMaterialTarget = {
     profileId: string;
     chainIdKey: string;
     accountAddress: string;
@@ -46,4 +46,5 @@ export declare function getAccountKeyMaterial(args: {
     keyKind: KeyMaterialKind;
 }): Promise<KeyMaterialRecord | null>;
 export declare function storeAccountKeyMaterial(deps: AccountKeyMaterialDeps, input: StoreAccountKeyMaterialInput): Promise<void>;
+export {};
 //# sourceMappingURL=accountKeyMaterial.d.ts.map

package/dist/types/wallet/src/core/indexedDB/accountSignerLifecycle.d.ts

@@ -22,7 +22,7 @@ export type SignerActivationPolicy = {
     replacedSignerKind: SignerKind;
     revocationReason: string;
 };
-export type PlanAccountSignerActivationInput = {
+type PlanAccountSignerActivationInput = {
     activeSigners: readonly Pick<AccountSignerRecord, 'signerId' | 'signerSlot' | 'signerType' | 'signerKind' | 'signerAuthMethod' | 'signerSource' | 'metadata'>[];
     signer: {
         signerId: string;

package/dist/types/wallet/src/core/indexedDB/index.d.ts

@@ -21,7 +21,7 @@ export type { UserPreferences, ProfileAuthenticatorRecord, ProfileContinuitySnap
 export type { LocalAuthorityActivationFinalizationInputV1, LocalAuthorityActivationFinalizationResultV1, LocalAuthorityActivationPublicationInputV1, LocalAuthorityActivationPublicationResultV1, WalletLockGenerationAdvanceInputV1, PublishPendingWalletRecoveryCommitInputV1, } from './seamsWalletDB/repositories';
 export type { KeyMaterialAlgorithm, KeyMaterialKind, KeyMaterialPayloadEnvelope, KeyMaterialPayloadEnvelopeAAD, KeyMaterialRecord, } from './keyMaterial.types';
 import { UnifiedIndexedDBManager } from './unifiedIndexedDBManager';
-export type IndexedDBMode = 'app' | 'wallet' | 'disabled';
+type IndexedDBMode = 'app' | 'wallet' | 'disabled';
 /**
  * Configure IndexedDB database names for the current runtime.
  *
@@ -36,9 +36,5 @@ export declare function configureIndexedDB(args: {
 }): {
     walletDbName: string;
 };
-export declare function getIndexedDBNames(): {
-    walletDbName: string;
-};
-export declare function isIndexedDBPersistenceDisabled(): boolean;
 export declare const IndexedDBManager: UnifiedIndexedDBManager;
 //# sourceMappingURL=index.d.ts.map

package/dist/types/wallet/src/core/indexedDB/keyMaterialEnvelope.d.ts

@@ -1,4 +1,4 @@
-import type { KeyMaterialPayloadEnvelope, KeyMaterialPayloadEnvelopeAAD, KeyMaterialRecord } from './keyMaterial.types';
+import type { KeyMaterialPayloadEnvelope, KeyMaterialPayloadEnvelopeAAD } from './keyMaterial.types';
 export declare const KEY_PAYLOAD_ENC_VERSION = 1;
 export declare function sanitizePayload(value: unknown): Record<string, unknown> | undefined;
 export declare function buildEnvelopeAAD(args: {
@@ -11,5 +11,4 @@ export declare function buildEnvelopeAAD(args: {
     signerId: string;
 }): KeyMaterialPayloadEnvelopeAAD;
 export declare function normalizePayloadEnvelope(raw: unknown, expectedAAD: KeyMaterialPayloadEnvelopeAAD, context: string): KeyMaterialPayloadEnvelope | undefined;
-export declare function normalizeStoredPayloadRecord(rec: KeyMaterialRecord): KeyMaterialRecord | null;
 //# sourceMappingURL=keyMaterialEnvelope.d.ts.map

package/dist/types/wallet/src/core/indexedDB/linkedAuthoritySignerMaterial.d.ts

@@ -9,7 +9,7 @@ export type LinkedSignerPackageForMaterialV1 = {
     readonly keyFamily: 'ecdsa_secp256k1';
     readonly package: CommittedEcdsaSignerPackageV1;
 };
-export type LinkedAuthorityMaterialSealInputV1 = {
+type LinkedAuthorityMaterialSealInputV1 = {
     readonly authorityId: WalletAuthorityId;
     readonly walletId: WalletId;
     readonly walletAuthMethodId: WalletAuthMethodId;
@@ -18,7 +18,7 @@ export type LinkedAuthorityMaterialSealInputV1 = {
     readonly materialActivation: MpcMaterialActivationRef;
     readonly keyFamily: 'ed25519' | 'ecdsa_secp256k1';
 };
-export type OpenWalletAuthorityLinkedSignerMaterialInputV1 = {
+type OpenWalletAuthorityLinkedSignerMaterialInputV1 = {
     readonly record: WalletAuthorityLinkedSignerMaterialRecordV1;
     readonly factorSecret: Uint8Array;
     readonly expected: LinkedAuthorityMaterialSealInputV1;
@@ -47,7 +47,6 @@ export type OpenWalletAuthorityLinkedSignerMaterialResultV1 = {
     readonly kind: 'wallet_authority_linked_signer_material_open_failed_v1';
     readonly reason: 'identity_mismatch' | 'target_factor_mismatch' | 'package_digest_mismatch' | 'factor_secret_invalid' | 'sealed_material_invalid' | 'sealed_material_digest_mismatch' | 'sealed_material_authentication_failed';
 };
-export declare function linkedAuthorityMaterialSealAadV1(input: LinkedAuthorityMaterialSealInputV1): string;
 export declare function sealWalletAuthorityLinkedSignerMaterialV1(input: {
     readonly factorSecret: Uint8Array;
     readonly aad: LinkedAuthorityMaterialSealInputV1;
@@ -65,4 +64,5 @@ export declare function walletAuthorityLinkedSignerMaterialRecordFromPackageV1(i
 }): WalletAuthorityLinkedSignerMaterialRecordV1;
 export declare function parseWalletAuthorityLinkedSignerMaterialRecordV1(value: unknown): WalletAuthorityLinkedSignerMaterialRecordV1;
 export declare function openWalletAuthorityLinkedSignerMaterialV1(input: OpenWalletAuthorityLinkedSignerMaterialInputV1): Promise<OpenWalletAuthorityLinkedSignerMaterialResultV1>;
+export {};
 //# sourceMappingURL=linkedAuthoritySignerMaterial.d.ts.map

package/dist/types/wallet/src/core/indexedDB/normalization.d.ts

@@ -3,8 +3,5 @@ export declare function normalizeLastUserScope(scope: unknown): string | null;
 export declare function normalizeIndexedDbChainIdKey(chainIdKey: unknown): string;
 export declare function normalizeIndexedDbAccountAddress(address: unknown): string;
 export declare function normalizeIndexedDbAccountModel<T extends string = string>(model: unknown): T;
-export declare function normalizeIndexedDbOptionalChainIdNumber(value: unknown, options?: {
-    allowChainIdKeySuffix?: boolean;
-}): number | undefined;
 export declare function toIndexedDbChainTargetKey(chainTarget: ThresholdEcdsaChainTarget): string;
 //# sourceMappingURL=normalization.d.ts.map

package/dist/types/wallet/src/core/indexedDB/passkeyClientDB.types.d.ts

@@ -3,7 +3,7 @@ import type { NearProvisioningState } from '../types/seams';
 import type { ConfirmationConfig } from '../types/signer-worker';
 import type { ThresholdEcdsaChainTarget, WalletId } from '../signingEngine/interfaces/ecdsaChainTarget';
 import type { SignerAuthMethod, SignerKind, SignerSource } from '../../../../shared-ts/src/utils';
-import type { WalletAuthMethodRecord, WalletAuthMethodRecordV2 } from '../../../../shared-ts/src/utils/registrationIntent';
+import type { EmailOtpWalletAuthMethodRecordV2, PasskeyWalletAuthMethodRecordV2, WalletAuthMethodRecord, WalletAuthMethodRecordV2 } from '../../../../shared-ts/src/utils/walletAuthMethodRecord';
 import type { EmailOtpWalletAuthAuthority } from '../../../../shared-ts/src/utils/walletAuthAuthority';
 import type { DigestB64u } from '../../../../shared-ts/src/utils/canonicalPrimitives';
 import type { PasskeyCustodyEnvelopeRecord } from '../../../../shared-ts/src/passkey-custody';
@@ -41,15 +41,6 @@ export interface ProfileAuthenticatorRecord {
     registered: string;
     syncedAt: string;
 }
-export type WalletPasskeyAuthenticatorLookup = {
-    kind: 'all_for_wallet';
-    walletId: WalletId;
-    credentialId?: never;
-} | {
-    kind: 'by_credential';
-    walletId: WalletId;
-    credentialId: string;
-};
 export type WalletSignerLookup = {
     kind: 'active_by_family';
     walletId: WalletId;
@@ -76,8 +67,8 @@ export interface AccountRef {
     chainIdKey: ChainIdKey;
     accountAddress: AccountAddress;
 }
-export type AccountModel = 'near-native' | 'threshold-ecdsa' | string;
-export type AccountSignerType = 'passkey' | 'threshold' | 'session' | 'recovery' | string;
+type AccountModel = 'near-native' | 'threshold-ecdsa' | string;
+type AccountSignerType = 'passkey' | 'threshold' | 'session' | 'recovery' | string;
 export type AccountSignerStatus = 'active' | 'pending' | 'revoked';
 export type { SignerAuthMethod, SignerKind, SignerSource };
 export interface AccountModelCapabilities {
@@ -153,17 +144,13 @@ export type WalletAuthMethodLocalPresentationV1 = {
 };
 export type LocalWalletAuthMethodProjectionV2 = Readonly<{
     kind: 'passkey';
-    record: Extract<LocalWalletAuthMethodRecordV2, {
-        readonly kind: 'passkey';
-    }>;
+    record: PasskeyWalletAuthMethodRecordV2;
     presentation: Extract<WalletAuthMethodLocalPresentationV1, {
         readonly kind: 'passkey';
     }>;
 }> | Readonly<{
     kind: 'email_otp';
-    record: Extract<LocalWalletAuthMethodRecordV2, {
-        readonly kind: 'email_otp';
-    }>;
+    record: EmailOtpWalletAuthMethodRecordV2;
     presentation: Extract<WalletAuthMethodLocalPresentationV1, {
         readonly kind: 'email_otp';
     }>;

package/dist/types/wallet/src/core/indexedDB/pendingWalletRegistrationCommit.d.ts

@@ -3,10 +3,10 @@ import { type WalletAuthMethodId, type WalletId, type EmailOtpChallengeId, type
 import { type CorrelationId, type DigestB64u } from '../../../../shared-ts/src/utils/canonicalPrimitives';
 import { type WalletAuthAuthority } from '../../../../shared-ts/src/utils/walletAuthAuthority';
 import { type WalletCustodyCeremonyCommitPayload } from '../../../../shared-ts/src/passkey-custody';
-import type { WalletEmailOtpEnrollmentMaterialV1 } from '../../../../shared-ts/src/utils/registrationIntent';
+import type { WalletEmailOtpEnrollmentMaterialV1 } from '../../../../shared-ts/src/utils/registrationAuthMethodInput';
 import type { RouterAbEd25519YaoBytes32V1 } from '../../../../shared-ts/src/utils/routerAbEd25519Yao';
 import { type RouterAbEcdsaVerifiedClientActivationFactsV1 } from '../../../../shared-ts/src/utils/routerAbEcdsaDerivation';
-export type PendingWalletRegistrationEcdsaReplayV1 = {
+type PendingWalletRegistrationEcdsaReplayV1 = {
     readonly activationJournalId: CorrelationId;
     readonly clientActivation: RouterAbEcdsaVerifiedClientActivationFactsV1;
     readonly activationRequestDigestB64u: DigestB64u;
@@ -79,7 +79,6 @@ export type PendingWalletRegistrationLocalMaterialV1 = {
     readonly ecdsa?: never;
     readonly activationReference?: never;
 };
-export type PendingWalletRegistrationSignerPlanKind = 'near_ed25519' | 'evm_family_ecdsa' | 'near_ed25519_and_evm_family_ecdsa';
 type PendingWalletRegistrationCommitCommonV1 = {
     readonly kind: 'pending_wallet_registration_commit_v1';
     readonly registrationCeremonyId: string;
@@ -164,7 +163,6 @@ export type PendingNearRegistrationContinuationV1 = PendingWalletRegistrationCom
     readonly admissionReceipt: RouterAbEd25519YaoActivationAdmissionReceiptV1<'registration'>;
     readonly checkpointJson: string;
 });
-export declare function pendingRegistrationIdentity(record: PendingWalletRegistrationCommitCommonV1): PendingWalletRegistrationCommitCommonV1;
 export declare function planPendingNearRegistration(activation: Extract<PendingWalletRegistrationCommitV1, {
     readonly operation: 'registration_activate';
     readonly signerPlanKind: 'near_ed25519_and_evm_family_ecdsa';

package/dist/types/wallet/src/core/indexedDB/profileAccountProjection.d.ts

@@ -1,5 +1,5 @@
 import type { AccountRef, AccountSignerRecord, ChainAccountRecord, LastProfileState, ProfileRecord } from './passkeyClientDB.types';
-export type ResolvedProfileAccountContext = {
+type ResolvedProfileAccountContext = {
     profileId: string;
     accountRef: AccountRef;
 };
@@ -18,14 +18,8 @@ export type ProfileLastSelectionPort = {
     getLastProfileState: () => Promise<LastProfileState | null>;
     listChainAccountsByProfile: (profileId: string) => Promise<ChainAccountRecord[]>;
 };
-export declare function selectPrimaryChainAccount(chainAccounts: ChainAccountRecord[]): ChainAccountRecord | null;
-export declare function selectAccountSigner(args: {
-    profile: ProfileRecord;
-    activeSigners: AccountSignerRecord[];
-    signerSlot?: number;
-}): AccountSignerRecord | null;
 export declare function resolveProfileAccountContextFromCandidates(clientDB: ProfileAccountContextPort, accountRefs: AccountRef[]): Promise<ResolvedProfileAccountContext | null>;
-export type ResolvedProfileAccountProjection = {
+type ResolvedProfileAccountProjection = {
     context: ResolvedProfileAccountContext;
     profile: ProfileRecord;
     activeSigners: AccountSignerRecord[];
@@ -35,12 +29,6 @@ export declare function resolveProfileAccountProjection(clientDB: ProfileAccount
     accountRefs: AccountRef[];
     signerSlot?: number;
 }): Promise<ResolvedProfileAccountProjection | null>;
-export declare function getPrimaryProfileAccountByChain(clientDB: {
-    listChainAccountsByProfile: (profileId: string) => Promise<ChainAccountRecord[]>;
-}, args: {
-    profileId: string;
-    chainIdKeys: string[];
-}): Promise<ChainAccountRecord | null>;
 export declare function getLastSelectedProfileAccountByChain(clientDB: ProfileLastSelectionPort, args: {
     chainIdKeys: string[];
 }): Promise<{
@@ -48,4 +36,5 @@ export declare function getLastSelectedProfileAccountByChain(clientDB: ProfileLa
     signerSlot: number;
     chainAccount: ChainAccountRecord;
 } | null>;
+export {};
 //# sourceMappingURL=profileAccountProjection.d.ts.map

package/dist/types/wallet/src/core/indexedDB/schemaNames.d.ts

@@ -107,7 +107,7 @@ export declare const SEAMS_WALLET_INDEXES: {
     readonly walletMaterialActivationId: "wallet_material_activation_id";
 };
 export type SeamsWalletStoreName = (typeof SEAMS_WALLET_STORES)[keyof typeof SEAMS_WALLET_STORES];
-export type SeamsWalletIndexDefinition = {
+type SeamsWalletIndexDefinition = {
     name: (typeof SEAMS_WALLET_INDEXES)[keyof typeof SEAMS_WALLET_INDEXES];
     keyPath: string | readonly string[];
     unique: boolean;
@@ -652,4 +652,5 @@ export declare const SEAMS_WALLET_SCHEMA_MANIFEST: readonly [{
 }];
 export declare function assertCanonicalIndexedDBName(name: string): void;
 export declare function createSeamsTestWalletDbName(suffix: string): `seams_test_wallet_${string}`;
+export {};
 //# sourceMappingURL=schemaNames.d.ts.map

package/dist/types/wallet/src/core/indexedDB/seamsWalletDB/ecdsaCapabilityManifestLookups.d.ts

@@ -0,0 +1,177 @@
+import { type CorrelationId, type DigestB64u } from '../../../../../shared-ts/src/utils/canonicalPrimitives';
+import { type CapabilityInstanceRef, type MpcMaterialActivationRef, type WalletId } from '../../../../../shared-ts/src/utils/domainIds';
+import type { WalletAuthAuthorityRef } from '../../../../../shared-ts/src/utils/walletAuthAuthority';
+import { parseEcdsaThresholdKeyId } from '../../signingEngine/session/keyMaterialBrands';
+import type { ActiveEcdsaCapabilityManifest, EcdsaCapabilityActivationCommitJournal, ReplacedEcdsaCapabilityManifest, ValidatedEncryptedEcdsaReadyMaterial } from '../../signingEngine/session/material/ecdsaCapabilityManifest';
+import type { SeamsWalletTransactionContext } from './manager';
+import { type EcdsaCapabilitySelector } from './ecdsaCapabilityManifestRecords';
+export type ActiveEcdsaWalletCapabilitySubject = EcdsaCapabilitySelector & {
+    readonly ecdsaThresholdKeyId: ReturnType<typeof parseEcdsaThresholdKeyId>;
+};
+export type ActiveEcdsaWalletCapabilitySubjectListResult = {
+    readonly kind: 'resolved';
+    readonly subjects: readonly ActiveEcdsaWalletCapabilitySubject[];
+} | {
+    readonly kind: 'invalid_current_state';
+    readonly subjects?: never;
+} | {
+    readonly kind: 'persistence_unavailable';
+    readonly subjects?: never;
+};
+export type EcdsaWalletActivationSelectorListResult = {
+    readonly kind: 'resolved';
+    readonly selectors: readonly EcdsaCapabilitySelector[];
+} | {
+    readonly kind: 'invalid_current_state';
+    readonly selectors?: never;
+} | {
+    readonly kind: 'persistence_unavailable';
+    readonly selectors?: never;
+};
+type LookupFailureExclusions = {
+    readonly manifest?: never;
+    readonly material?: never;
+};
+type EcdsaSelectorFailure = ({
+    readonly kind: 'exact_record_conflict';
+    readonly selector: EcdsaCapabilitySelector;
+    readonly conflictDigest: DigestB64u;
+} & LookupFailureExclusions) | ({
+    readonly kind: 'corrupt';
+    readonly selector: EcdsaCapabilitySelector;
+    readonly corruptionDigest: DigestB64u;
+} & LookupFailureExclusions) | ({
+    readonly kind: 'persistence_unavailable';
+    readonly selector: EcdsaCapabilitySelector;
+    readonly retryCorrelation: CorrelationId;
+} & LookupFailureExclusions);
+export type EcdsaCapabilityManifestLookup = {
+    readonly kind: 'active';
+    readonly manifest: ActiveEcdsaCapabilityManifest;
+    readonly material: ValidatedEncryptedEcdsaReadyMaterial;
+} | {
+    readonly kind: 'retired';
+    readonly manifest: ReplacedEcdsaCapabilityManifest;
+    readonly material?: never;
+} | ({
+    readonly kind: 'missing';
+    readonly selector: EcdsaCapabilitySelector;
+    readonly subject: 'capability' | 'material';
+} & LookupFailureExclusions) | ({
+    readonly kind: 'exact_binding_mismatch';
+    readonly selector: EcdsaCapabilitySelector;
+    readonly failureDigest: DigestB64u;
+} & LookupFailureExclusions) | EcdsaSelectorFailure;
+export type EcdsaActivationJournalWriteResult<TJournal extends EcdsaCapabilityActivationCommitJournal = EcdsaCapabilityActivationCommitJournal> = {
+    readonly kind: 'stored';
+    readonly journal: TJournal;
+} | {
+    readonly kind: 'exact_record_conflict';
+    readonly conflictDigest: DigestB64u;
+    readonly journal?: never;
+} | {
+    readonly kind: 'corrupt';
+    readonly corruptionDigest: DigestB64u;
+    readonly journal?: never;
+} | {
+    readonly kind: 'persistence_unavailable';
+    readonly retryCorrelation: CorrelationId;
+    readonly journal?: never;
+};
+export type EcdsaActivationJournalReadResult = {
+    readonly kind: 'found';
+    readonly journal: EcdsaCapabilityActivationCommitJournal;
+} | {
+    readonly kind: 'missing' | 'corrupt' | 'persistence_unavailable';
+    readonly journal?: never;
+};
+export type EcdsaPreparedActivationOpenResult = {
+    readonly kind: 'found';
+    readonly journal: EcdsaCapabilityActivationCommitJournal;
+    readonly pendingPayloadB64u: string;
+} | {
+    readonly kind: 'missing' | 'corrupt' | 'persistence_unavailable';
+    readonly journal?: never;
+    readonly pendingPayloadB64u?: never;
+};
+type OpenedEcdsaActiveMaterial = {
+    readonly kind: 'active';
+    readonly manifest: ActiveEcdsaCapabilityManifest;
+    readonly readyStateBlobB64u: string;
+};
+export type EcdsaActiveMaterialOpenResult = OpenedEcdsaActiveMaterial | Exclude<EcdsaCapabilityManifestLookup, {
+    readonly kind: 'active';
+}>;
+export type EcdsaActiveMaterialRefOpenResult = OpenedEcdsaActiveMaterial | {
+    readonly kind: 'missing' | 'binding_mismatch' | 'corrupt' | 'persistence_unavailable';
+    readonly manifest?: never;
+    readonly readyStateBlobB64u?: never;
+};
+type EcdsaCapabilityMaterialRefLookupFailure = {
+    readonly kind: 'missing';
+    readonly subject: 'capability' | 'material';
+    readonly capability: CapabilityInstanceRef;
+} | {
+    readonly kind: 'exact_binding_mismatch' | 'exact_record_conflict' | 'corrupt' | 'persistence_unavailable';
+    readonly capability: CapabilityInstanceRef;
+    readonly subject?: never;
+};
+export type EcdsaCapabilityMaterialRefLookup = Extract<EcdsaCapabilityManifestLookup, {
+    readonly kind: 'active' | 'retired';
+}> | EcdsaCapabilityMaterialRefLookupFailure;
+/**
+ * One cryptographic activation can back several exact method-bound
+ * access projections, one per wallet auth method installed on the same wallet
+ * authority. A material activation therefore no longer names one manifest.
+ * A caller that does not say which method it is acting as gets
+ * `ambiguous_authority` and must ask again with the exact authority; picking a
+ * sibling here would silently sign under a credential the caller never named.
+ */
+export type EcdsaCapabilityActivationLookup = EcdsaCapabilityMaterialRefLookup | {
+    readonly kind: 'ambiguous_authority';
+    readonly capability: CapabilityInstanceRef;
+    readonly authorities: readonly WalletAuthAuthorityRef[];
+    readonly subject?: never;
+};
+export type EcdsaCapabilityActivationFinalizationResult = {
+    readonly kind: 'committed';
+    readonly manifest: ActiveEcdsaCapabilityManifest;
+    readonly material: ValidatedEncryptedEcdsaReadyMaterial;
+} | EcdsaSelectorFailure;
+export type LookupTransactionObservation = {
+    readonly kind: 'active';
+    readonly manifest: ActiveEcdsaCapabilityManifest;
+    readonly material: ValidatedEncryptedEcdsaReadyMaterial;
+} | {
+    readonly kind: 'retired';
+    readonly manifest: ReplacedEcdsaCapabilityManifest;
+} | {
+    readonly kind: 'missing';
+    readonly subject: 'capability' | 'material';
+    readonly detail: string;
+} | {
+    readonly kind: 'exact_binding_mismatch' | 'exact_record_conflict' | 'corrupt';
+    readonly detail: string;
+};
+export declare function persistenceDigest(category: string, selector: EcdsaCapabilitySelector, detail: string): Promise<DigestB64u>;
+export declare function journalConstraintConflict(selector: EcdsaCapabilitySelector, error: unknown): Promise<{
+    readonly kind: 'exact_record_conflict';
+    readonly conflictDigest: DigestB64u;
+}>;
+export declare function retryCorrelation(): CorrelationId;
+export declare function ecdsaManifestErrorMessage(error: unknown): string;
+export declare function isConstraintError(error: unknown): boolean;
+export declare function readPointerRowsForWallet(context: SeamsWalletTransactionContext, walletId: WalletId): Promise<readonly unknown[]>;
+export declare function readActivationJournalRows(context: SeamsWalletTransactionContext): Promise<readonly unknown[]>;
+export declare function readActiveManifestRows(context: SeamsWalletTransactionContext, selector: EcdsaCapabilitySelector): Promise<readonly unknown[]>;
+export declare function activeLookupUsesMaterialActivation(lookup: Extract<EcdsaCapabilityManifestLookup, {
+    readonly kind: 'active';
+}>, materialActivation: MpcMaterialActivationRef): boolean;
+export declare function materialRefOpenFailure(failure: Exclude<EcdsaCapabilityMaterialRefLookup, {
+    readonly kind: 'active';
+}> | Exclude<EcdsaActiveMaterialOpenResult, {
+    readonly kind: 'active';
+}>): EcdsaActiveMaterialRefOpenResult;
+export declare function lookupInTransaction(context: SeamsWalletTransactionContext, selector: EcdsaCapabilitySelector): Promise<LookupTransactionObservation>;
+export {};
+//# sourceMappingURL=ecdsaCapabilityManifestLookups.d.ts.map

package/dist/types/wallet/src/core/indexedDB/seamsWalletDB/ecdsaCapabilityManifestRecords.d.ts

@@ -0,0 +1,155 @@
+import { type IsoTimestamp } from '../../../../../shared-ts/src/utils/canonicalPrimitives';
+import { type CapabilityInstanceRef } from '../../../../../shared-ts/src/utils/domainIds';
+import { parseEcdsaCiphertextB64u, parseEcdsaIv12B64u, type EcdsaCapabilityManifestId, type EcdsaCapabilityManifestRevision, type EcdsaMaterialSealingKeyId } from '../../../../../shared-ts/src/utils/ecdsaCapabilityActivation';
+import { type RuntimePolicyScope } from '../../../../../shared-ts/src/threshold/signingRootScope';
+import { type WalletAuthAuthorityRef } from '../../../../../shared-ts/src/utils/walletAuthAuthority';
+import { type EcdsaRoleLocalPublicFacts } from '../../platform';
+import { parseEcdsaRoleLocalBindingDigest, parseEcdsaRoleLocalDurableMaterialRef } from '../../signingEngine/session/keyMaterialBrands';
+import { type ActiveEcdsaCapabilityManifest, type BuildPreparedEcdsaActivationJournalInput, type DurableEcdsaMaterialBinding, type EcdsaActivationBinding, type EcdsaCapabilityActivationCommitJournal, type EcdsaCapabilityScope, type EcdsaRoleLocalMaterialBinding, type EncryptedEcdsaPendingCandidate, type EcdsaServerActivationCommit, type PreparedEcdsaActivationJournal, type ReplacedEcdsaCapabilityManifest, type ServerCommittedEcdsaActivationJournal, type ValidatedEncryptedEcdsaReadyMaterial } from '../../signingEngine/session/material/ecdsaCapabilityManifest';
+import type { VerifiedEcdsaPublicFacts } from '../../signingEngine/session/identity/evmFamilyEcdsaIdentity';
+export declare const MANIFEST_RECORD_VERSION: "ecdsa_capability_manifest_v3";
+export declare const MANIFEST_STORE: "ecdsa_capability_manifests";
+export declare const POINTER_STORE: "ecdsa_current_capability_manifests";
+export declare const MATERIAL_STORE: "ecdsa_role_local_material";
+export declare const JOURNAL_STORE: "ecdsa_activation_commit_journals";
+export declare const SEALING_KEY_STORE: "ecdsa_material_sealing_keys";
+export declare const PRESIGNATURE_STORE: "ecdsa_client_presignatures";
+export declare const AES_GCM_IV_BYTES = 12;
+export type EcdsaCapabilitySelector = {
+    readonly capability: CapabilityInstanceRef;
+    readonly authority: WalletAuthAuthorityRef;
+};
+type PreparedJournalInputWithoutCandidate<T> = T extends unknown ? Omit<T, 'candidate'> : never;
+export type PrepareEcdsaCapabilityActivationInput = PreparedJournalInputWithoutCandidate<BuildPreparedEcdsaActivationJournalInput> & {
+    readonly activationBinding: EcdsaActivationBinding;
+    readonly pendingPayloadB64u: string;
+};
+export type ParsedActiveManifestProof = {
+    readonly activationBinding: EcdsaActivationBinding;
+    readonly serverActivation: EcdsaServerActivationCommit;
+    readonly durableMaterial: DurableEcdsaMaterialBinding;
+    readonly activeManifest: ActiveEcdsaCapabilityManifest;
+    readonly committedAt: IsoTimestamp;
+};
+export type ParsedManifestRow = {
+    readonly state: 'active';
+    readonly selector: EcdsaCapabilitySelector;
+    readonly manifest: ActiveEcdsaCapabilityManifest;
+    readonly activeProof: ParsedActiveManifestProof;
+} | {
+    readonly state: 'replaced';
+    readonly selector: EcdsaCapabilitySelector;
+    readonly manifest: ReplacedEcdsaCapabilityManifest;
+    readonly activeProof: ParsedActiveManifestProof;
+    readonly replacementProof: ParsedActiveManifestProof;
+};
+export type ParsedPointerRow = {
+    readonly selector: EcdsaCapabilitySelector;
+    readonly manifestId: EcdsaCapabilityManifestId;
+    readonly manifestRevision: EcdsaCapabilityManifestRevision;
+};
+type ParsedSealingKeyRow = {
+    readonly keyId: EcdsaMaterialSealingKeyId;
+    readonly key: CryptoKey;
+};
+export declare function requireExactKeys(record: Record<string, unknown>, label: string, expectedKeys: readonly string[]): void;
+export declare function normalizeSelector(selector: EcdsaCapabilitySelector): EcdsaCapabilitySelector;
+export declare function selectorFromSigner(signer: EcdsaCapabilitySelector): EcdsaCapabilitySelector;
+export declare function selectorFromJournal(journal: EcdsaCapabilityActivationCommitJournal): EcdsaCapabilitySelector;
+export declare function selectorFromManifest(manifest: ActiveEcdsaCapabilityManifest): EcdsaCapabilitySelector;
+export declare function selectorKey(selector: EcdsaCapabilitySelector): readonly [string, string, string];
+export declare function selectorColumns(selector: EcdsaCapabilitySelector): {
+    capability_ref: CapabilityInstanceRef;
+    wallet_id: import("../../../../../shared-ts/src/utils").WalletId;
+    authority_digest: import("../../../../../shared-ts/src/utils").WalletAuthorityBindingDigest;
+    wallet_auth_method_id: import("../../../../../shared-ts/src/utils").WalletAuthMethodId;
+};
+export declare function walletAuthAuthorityRefsMatch(left: WalletAuthAuthorityRef, right: WalletAuthAuthorityRef): boolean;
+export declare function selectorsMatch(left: EcdsaCapabilitySelector, right: EcdsaCapabilitySelector): boolean;
+export declare function runtimePolicyScopesMatch(left: RuntimePolicyScope, right: RuntimePolicyScope): boolean;
+export declare function ecdsaCapabilityScopesMatch(left: EcdsaCapabilityScope, right: EcdsaCapabilityScope): boolean;
+export declare function ecdsaRoleLocalMaterialBindingsMatch(left: EcdsaRoleLocalMaterialBinding, right: EcdsaRoleLocalMaterialBinding): boolean;
+export declare function ecdsaRoleLocalPublicFactsMatch(left: EcdsaRoleLocalPublicFacts, right: EcdsaRoleLocalPublicFacts): boolean;
+export declare function ecdsaRegisteredPublicFactsMatch(left: VerifiedEcdsaPublicFacts, right: VerifiedEcdsaPublicFacts): boolean;
+export declare function ecdsaServerActivationCommitsMatch(left: EcdsaServerActivationCommit, right: EcdsaServerActivationCommit): boolean;
+export declare function ecdsaActivationCommitJournalsMatch(left: EcdsaCapabilityActivationCommitJournal, right: EcdsaCapabilityActivationCommitJournal): boolean;
+export declare function ecdsaDurableMaterialBindingsMatch(left: DurableEcdsaMaterialBinding, right: DurableEcdsaMaterialBinding): boolean;
+export declare function ecdsaActiveCapabilityManifestsMatch(left: ActiveEcdsaCapabilityManifest, right: ActiveEcdsaCapabilityManifest): boolean;
+export declare function buildPreparedJournalFromEncryptedCandidate(input: {
+    readonly preparation: PrepareEcdsaCapabilityActivationInput;
+    readonly encryptedPending: EncryptedEcdsaPendingCandidate;
+}): PreparedEcdsaActivationJournal;
+export declare function additionalData(projection: unknown): Uint8Array;
+export declare function generateMaterialSealingKey(): Promise<CryptoKey>;
+export declare function encryptStateBlob(input: {
+    readonly key: CryptoKey;
+    readonly stateBlobB64u: string;
+    readonly aadProjection: unknown;
+}): Promise<{
+    readonly iv12B64u: ReturnType<typeof parseEcdsaIv12B64u>;
+    readonly ciphertextB64u: ReturnType<typeof parseEcdsaCiphertextB64u>;
+    readonly digestB64u: string;
+}>;
+export declare function ciphertextDigestB64u(ciphertextB64u: string): Promise<string>;
+export declare function decryptStateBlob(input: {
+    readonly key: CryptoKey;
+    readonly iv12B64u: string;
+    readonly ciphertextB64u: string;
+    readonly aadProjection: unknown;
+}): Promise<string>;
+export declare function preparedJournalProjection(journal: EcdsaCapabilityActivationCommitJournal): PreparedEcdsaActivationJournal;
+export declare function parseCommittedJournal(value: unknown): ServerCommittedEcdsaActivationJournal;
+export declare function parseActiveProof(value: unknown): ParsedActiveManifestProof;
+export declare function parseManifestRow(value: unknown): ParsedManifestRow;
+export declare function storedPointerRow(manifest: ActiveEcdsaCapabilityManifest): {
+    manifest_id: EcdsaCapabilityManifestId;
+    manifest_revision: EcdsaCapabilityManifestRevision;
+    capability_ref: CapabilityInstanceRef;
+    wallet_id: import("../../../../../shared-ts/src/utils").WalletId;
+    authority_digest: import("../../../../../shared-ts/src/utils").WalletAuthorityBindingDigest;
+    wallet_auth_method_id: import("../../../../../shared-ts/src/utils").WalletAuthMethodId;
+    record_version: "ecdsa_current_capability_manifest_v2";
+};
+export declare function parsePointerRow(value: unknown): ParsedPointerRow;
+export declare function storedMaterialRow(material: ValidatedEncryptedEcdsaReadyMaterial, manifest: ActiveEcdsaCapabilityManifest): {
+    sealing_key_id: EcdsaMaterialSealingKeyId;
+    iv: import("../../../../../shared-ts/src/utils").EcdsaIv12B64u;
+    ciphertext: import("../../../../../shared-ts/src/utils").EcdsaCiphertextB64u;
+    capability_ref: CapabilityInstanceRef;
+    wallet_id: import("../../../../../shared-ts/src/utils").WalletId;
+    authority_digest: import("../../../../../shared-ts/src/utils").WalletAuthorityBindingDigest;
+    wallet_auth_method_id: import("../../../../../shared-ts/src/utils").WalletAuthMethodId;
+    record_version: "ecdsa_role_local_material_v2";
+    durable_material_ref: import("../../signingEngine/session/keyMaterialBrands").EcdsaRoleLocalDurableMaterialRef;
+    binding_digest: import("../../signingEngine/session/keyMaterialBrands").EcdsaRoleLocalBindingDigest;
+};
+export type ParsedMaterialLocator = {
+    readonly durableMaterialRef: ReturnType<typeof parseEcdsaRoleLocalDurableMaterialRef>;
+    readonly bindingDigest: ReturnType<typeof parseEcdsaRoleLocalBindingDigest>;
+    readonly selector: EcdsaCapabilitySelector;
+};
+export declare function parseMaterialLocator(value: unknown): ParsedMaterialLocator;
+export declare function parseMaterialRow(value: unknown, activeProof: ParsedActiveManifestProof): ValidatedEncryptedEcdsaReadyMaterial;
+export declare function materialMatchesManifest(material: ValidatedEncryptedEcdsaReadyMaterial, manifest: ActiveEcdsaCapabilityManifest): boolean;
+export declare function storedJournalRow(journal: EcdsaCapabilityActivationCommitJournal): {
+    journal: EcdsaCapabilityActivationCommitJournal;
+    capability_ref: CapabilityInstanceRef;
+    wallet_id: import("../../../../../shared-ts/src/utils").WalletId;
+    authority_digest: import("../../../../../shared-ts/src/utils").WalletAuthorityBindingDigest;
+    wallet_auth_method_id: import("../../../../../shared-ts/src/utils").WalletAuthMethodId;
+    record_version: "ecdsa_activation_commit_journal_v1";
+    journal_id: import("../../../../../shared-ts/src/utils").CorrelationId;
+};
+export declare function parseJournalRow(value: unknown): {
+    journal: EcdsaCapabilityActivationCommitJournal;
+    selector: EcdsaCapabilitySelector;
+};
+export declare function storedSealingKeyRow(keyId: EcdsaMaterialSealingKeyId, key: CryptoKey): {
+    record_version: "ecdsa_material_sealing_key_v1";
+    key_id: EcdsaMaterialSealingKeyId;
+    key: CryptoKey;
+};
+export declare function parseSealingKeyRow(value: unknown): ParsedSealingKeyRow;
+export declare function assertNever(value: never): never;
+export {};
+//# sourceMappingURL=ecdsaCapabilityManifestRecords.d.ts.map