@seams/wallet-server 0.5.0

package/dist/types/wallet-server/src/router/cloudflare/d1/registration/d1RegistrationCeremonyRecordStore.d.ts

@@ -0,0 +1,86 @@
+import type { D1DatabaseLike, D1PreparedStatementLike } from '../../../../storage/tenantRoute';
+export type D1RegistrationCeremonyRecordScope = {
+    readonly namespace: string;
+    readonly orgId: string;
+    readonly projectId: string;
+    readonly envId: string;
+};
+export type D1RegistrationCeremonyRecordStoreOptions = {
+    readonly database: D1DatabaseLike;
+    readonly scope: D1RegistrationCeremonyRecordScope;
+    readonly keyPrefix: string;
+};
+export type D1RegistrationCeremonyStoredRecord = {
+    readonly value: Record<string, unknown>;
+    readonly version: number;
+    readonly expiresAtMs: number;
+};
+export type D1RegistrationCeremonyRecordMutation = {
+    readonly scope: string;
+    readonly id: string;
+    readonly value: Record<string, unknown>;
+    readonly expiresAtMs: number;
+};
+export type D1RegistrationCeremonyAtomicBranchClaim = {
+    readonly value: Record<string, unknown>;
+    readonly version: number;
+    readonly expiresAtMs: number;
+};
+export declare class D1RegistrationCeremonyRecordConflictError extends Error {
+    constructor(message: string);
+}
+export declare class D1RegistrationCeremonyRecordStore {
+    private readonly database;
+    private readonly tenantScope;
+    private readonly keyPrefix;
+    constructor(options: D1RegistrationCeremonyRecordStoreOptions);
+    get(scope: string, id: string): Promise<D1RegistrationCeremonyStoredRecord | null>;
+    putExact(mutation: D1RegistrationCeremonyRecordMutation): Promise<void>;
+    reserveExclusive(mutation: D1RegistrationCeremonyRecordMutation): Promise<boolean>;
+    updateExpected(input: {
+        readonly scope: string;
+        readonly id: string;
+        readonly expected: Record<string, unknown>;
+        readonly next: Record<string, unknown>;
+        readonly expiresAtMs: number;
+    }): Promise<void>;
+    claimEcdsaRegistrationBranch(input: {
+        readonly scope: string;
+        readonly id: string;
+        readonly expectedKind: 'evm_family_ecdsa_prepared' | 'evm_family_ecdsa_pending_activation';
+        readonly binding: {
+            readonly kind: 'strict_registration';
+            readonly strictRegistrationBindingJson: string;
+        } | {
+            readonly kind: 'pending_activation';
+        };
+        readonly patch: Record<string, unknown>;
+    }): Promise<D1RegistrationCeremonyAtomicBranchClaim | null>;
+    updateExpectedVersion(input: {
+        readonly scope: string;
+        readonly id: string;
+        readonly expectedVersion: number;
+        readonly next: Record<string, unknown>;
+        readonly expiresAtMs: number;
+    }): Promise<number>;
+    take(scope: string, id: string): Promise<Record<string, unknown> | null>;
+    delete(scope: string, id: string): Promise<boolean>;
+    /**
+     * The statements `putManyExact` would run, for callers that need these records
+     * to land in someone else's batch rather than their own.
+     *
+     * Returns nothing when every record is already stored exactly as given, which
+     * is the same "already done" outcome `putManyExact` treats as success.
+     */
+    buildPutManyExactStatements(mutations: readonly D1RegistrationCeremonyRecordMutation[]): Promise<readonly D1PreparedStatementLike[]>;
+    private prepareExactMutations;
+    putManyExact(mutations: readonly D1RegistrationCeremonyRecordMutation[]): Promise<void>;
+    private allRecordsMatch;
+    private insert;
+    private prepareInsert;
+    private deleteVersion;
+    private prepareDelete;
+    private bindKey;
+    private normalizeKey;
+}
+//# sourceMappingURL=d1RegistrationCeremonyRecordStore.d.ts.map

package/dist/types/wallet-server/src/router/cloudflare/d1/registration/d1RegistrationCeremonyRecords.d.ts

@@ -0,0 +1,121 @@
+import { type EcdsaClientRootPublicKey33B64u } from '../../../../../../shared-ts/src/threshold/ecdsaDerivationRoleLocalBootstrap';
+import { type AddAuthMethodIntentCallerV1, type AddAuthMethodInput, type AddAuthMethodIntentV1, type AddSignerIntentV1, type AddSignerSelection, type ServerAllocatedWalletId, type RegistrationAuthority, type RegistrationAuthMethodInput, type RegistrationIntentV1, type RegistrationSignerSetSelection, type RuntimePolicyScopeLike, type WalletId } from '../../../../../../shared-ts/src/utils/registrationIntent';
+import { type WalletAuthMethodId } from '../../../../../../shared-ts/src/utils/domainIds';
+import type { RuntimePolicyScope } from '../../../../../../shared-ts/src/threshold/signingRootScope';
+import { deriveEvmFamilySigningKeySlotId } from '../../../../../../shared-ts/src/signing-lanes';
+import { type RouterAbEcdsaDerivationPublicCapabilityV1, type RouterAbEcdsaRegistrationActivationReceiptV1 } from '../../../../../../shared-ts/src/utils/routerAbEcdsaDerivation';
+import type { EcdsaDerivationClientBootstrapRequest, EcdsaDerivationServerBootstrapResponse } from '../../../../core/types';
+import type { WalletRegistrationCommittedInstallationProjectionV1 } from '../../../../core/threeRouteRegistrationContracts';
+import type { WalletRegistrationEcdsaClientBootstrap, WalletRegistrationEcdsaPrepareContext, WalletRegistrationEcdsaWalletKey, WalletRegistrationFinalizeResponse, WalletAddSignerFinalizeResponse } from '../../../../core/registrationContracts';
+import { type StoredWalletRegistrationNearEd25519YaoAuthorizedBranch, StoredAddAuthMethodIntent, StoredAddSignerIntent, StoredWalletAddAuthMethodCeremony, StoredWalletAddSignerCeremony, StoredWalletAddSignerFinalizeReplay, StoredWalletAddAuthMethodFinalizeReplay, StoredWalletAddSignerFinalizeRequest, StoredWalletRegistrationCeremony } from '../../../../core/RegistrationCeremonyStore';
+import { type ThresholdEcdsaChainTarget } from '../../../../core/thresholdEcdsaChainTarget';
+import { type WalletEcdsaSignerRecord, type WalletRecord } from '../../../../core/d1WalletStore';
+type D1WalletRegistrationFinalizeSuccess = Extract<WalletRegistrationFinalizeResponse, {
+    ok: true;
+}>;
+type D1WalletRegistrationFinalizeReplaySuccess = D1WalletRegistrationFinalizeSuccess;
+export declare function createD1ServerAllocatedWalletId(): ServerAllocatedWalletId;
+export declare function inferRuntimePolicyScopeFromSigningRoot(input: {
+    readonly orgId: string;
+    readonly signingRootId?: string;
+    readonly signingRootVersion?: string;
+}): RuntimePolicyScope | undefined;
+export declare function buildRegistrationIntent(input: {
+    readonly walletId: WalletId;
+    readonly authMethod: RegistrationAuthMethodInput;
+    readonly signerSelection: RegistrationSignerSetSelection;
+    readonly foundingWalletAuthMethodId: WalletAuthMethodId;
+    readonly runtimePolicyScope?: RuntimePolicyScope;
+}): RegistrationIntentV1;
+export declare function buildAddSignerIntent(input: {
+    readonly walletId: WalletId;
+    readonly signerSelection: AddSignerSelection;
+    readonly runtimePolicyScope?: RuntimePolicyScope;
+}): AddSignerIntentV1;
+/**
+ * Mints the intent, including the target method id the source proof will sign.
+ *
+ * The id is allocated here rather than in `start` so a fresh proof can name the
+ * method it authorizes creating. The caller branch is carried through
+ * unchanged: it decides what the source has to present, and it is part of the
+ * digest so a proof taken over one branch cannot start the other.
+ */
+export declare function buildAddAuthMethodIntent(input: {
+    readonly walletId: WalletId;
+    readonly authMethod: AddAuthMethodInput;
+    readonly targetWalletAuthMethodId: AddAuthMethodIntentV1['targetWalletAuthMethodId'];
+    readonly caller: AddAuthMethodIntentCallerV1;
+    readonly runtimePolicyScope?: RuntimePolicyScope;
+}): AddAuthMethodIntentV1;
+export declare function addAuthMethodInputMatches(left: AddAuthMethodInput, right: AddAuthMethodInput): boolean;
+export declare function addSignerSelectionMatches(left: AddSignerSelection, right: AddSignerSelection): boolean;
+export declare function parseWalletIdForIntent(raw: unknown): WalletId | null;
+export declare function parseD1RegistrationIntent(raw: unknown): RegistrationIntentV1 | null;
+export declare function parseD1StoredWalletRegistrationCeremony(raw: unknown): StoredWalletRegistrationCeremony | null;
+export declare function parseD1StoredWalletAddAuthMethodFinalizeReplay(raw: unknown): StoredWalletAddAuthMethodFinalizeReplay | null;
+export declare function parseD1StoredWalletAddSignerFinalizeReplay(raw: unknown): StoredWalletAddSignerFinalizeReplay | null;
+export declare function parseD1WalletAddSignerFinalizeTerminalResponse(raw: unknown): WalletAddSignerFinalizeResponse | null;
+export declare function parseD1WalletRegistrationFinalizeReplayResponse(raw: unknown): D1WalletRegistrationFinalizeReplaySuccess | null;
+export declare function parseD1StoredNearEd25519YaoAuthorizedBranch(record: Record<string, unknown>): StoredWalletRegistrationNearEd25519YaoAuthorizedBranch | null;
+export declare function parseD1WalletRegistrationCommittedInstallationProjection(raw: unknown): WalletRegistrationCommittedInstallationProjectionV1 | null;
+export declare function parseD1StoredAddSignerIntent(raw: unknown): StoredAddSignerIntent | null;
+export declare function parseD1AddSignerIntent(raw: unknown): AddSignerIntentV1 | null;
+export declare function parseD1StoredWalletAddSignerCeremony(raw: unknown): StoredWalletAddSignerCeremony | null;
+export declare function parseD1StoredAddSignerAuth(raw: unknown): StoredWalletAddSignerCeremony['auth'] | null;
+export declare function parseD1WalletAddSignerFinalizeRequest(raw: unknown): StoredWalletAddSignerFinalizeRequest | null;
+export declare function parseD1EcdsaDerivationServerBootstrapResponse(raw: unknown): EcdsaDerivationServerBootstrapResponse | null;
+export declare function runtimePolicyScopeMatches(left: RuntimePolicyScopeLike | undefined, right: RuntimePolicyScopeLike | undefined): boolean;
+export declare function positiveIntegerArraysEqual(left: readonly number[], right: readonly number[]): boolean;
+export declare function thresholdEcdsaChainTargetsEqual(left: readonly unknown[], right: readonly unknown[]): boolean;
+export declare function isMatchingD1EcdsaClientBootstrap(input: {
+    readonly expected: WalletRegistrationEcdsaPrepareContext;
+    readonly actual: WalletRegistrationEcdsaClientBootstrap;
+}): boolean;
+export declare function toD1EcdsaDerivationClientBootstrapRequest(clientBootstrap: WalletRegistrationEcdsaClientBootstrap): EcdsaDerivationClientBootstrapRequest;
+export type D1EcdsaWalletKeyBuildResult = {
+    readonly ok: true;
+    readonly walletKeys: WalletRegistrationEcdsaWalletKey[];
+} | {
+    readonly ok: false;
+    readonly code: 'incomplete_ecdsa_wallet_key';
+    readonly message: string;
+};
+export declare function buildD1EcdsaWalletKeysFromBootstrap(input: {
+    readonly bootstraps: readonly {
+        readonly chainTarget: ThresholdEcdsaChainTarget;
+        readonly bootstrap: EcdsaDerivationServerBootstrapResponse;
+    }[];
+    readonly publicCapability: RouterAbEcdsaDerivationPublicCapabilityV1;
+    readonly errorContext: string;
+}): D1EcdsaWalletKeyBuildResult;
+export declare function buildD1WalletRecord(input: {
+    readonly walletId: WalletId;
+    readonly now: number;
+}): WalletRecord;
+export declare function buildD1WalletEcdsaSignerRecords(input: {
+    readonly walletId: WalletId;
+    readonly walletKeys: readonly WalletRegistrationEcdsaWalletKey[];
+    readonly activationReceipt: RouterAbEcdsaRegistrationActivationReceiptV1;
+    readonly runtimePolicyScope: RuntimePolicyScope;
+    readonly custodyKeyManifestDigestB64u: string;
+    readonly custodyClientRootPublicKey33B64u: EcdsaClientRootPublicKey33B64u;
+    readonly now: number;
+}): WalletEcdsaSignerRecord[];
+export { deriveEvmFamilySigningKeySlotId };
+export declare function parseD1PositiveIntegerArray(raw: unknown): number[] | null;
+export declare function parseD1StoredAddAuthMethodIntent(raw: unknown): StoredAddAuthMethodIntent | null;
+export declare function parseD1StoredWalletAddAuthMethodCeremony(raw: unknown): StoredWalletAddAuthMethodCeremony | null;
+export declare function parseD1AddAuthMethodIntent(raw: unknown): AddAuthMethodIntentV1 | null;
+export declare function parseD1RuntimePolicyScope(raw: unknown): RuntimePolicyScope | undefined;
+export declare function parseD1RegistrationAuthority(raw: unknown): RegistrationAuthority | null;
+export declare function normalizeThresholdEcdsaChainTargets(input: readonly unknown[]): ThresholdEcdsaChainTarget[] | null;
+export declare function intentScopeMetadata(input: {
+    readonly signingRootId?: string;
+    readonly signingRootVersion?: string;
+    readonly expectedOrigin?: string;
+}): {
+    readonly signingRootId?: string;
+    readonly signingRootVersion?: string;
+    readonly expectedOrigin?: string;
+};
+//# sourceMappingURL=d1RegistrationCeremonyRecords.d.ts.map

package/dist/types/wallet-server/src/router/cloudflare/d1/registration/d1RegistrationCeremonyStore.d.ts

@@ -0,0 +1,84 @@
+import type { D1PreparedStatementLike } from '../../../../storage/tenantRoute';
+import { StoredAddAuthMethodIntent, StoredAddSignerIntent, StoredWalletAddAuthMethodCeremony, StoredWalletAddSignerCeremony, StoredWalletAddSignerFinalizeReplay, StoredWalletAddAuthMethodFinalizeReplay, StoredWalletRegistrationCeremony, type StoredWalletRegistrationEvmFamilyEcdsaActivationClaimedBranch, type StoredWalletRegistrationEvmFamilyEcdsaResponseClaimedBranch, type TerminalRegistrationCeremonyCancellationResult } from '../../../../core/RegistrationCeremonyStore';
+import type { WalletId } from '../../../../core/registrationContracts';
+import type { D1DatabaseLike } from '../../../../storage/tenantRoute';
+import { type D1RegistrationCeremonyRecordScope } from './d1RegistrationCeremonyRecordStore';
+export type RegistrationCeremonyIntentStoreConfig = {
+    readonly kind: 'partitioned_d1';
+    readonly database: D1DatabaseLike;
+    readonly scope: D1RegistrationCeremonyRecordScope;
+    readonly keyPrefix: string;
+};
+export type D1WalletRegistrationEcdsaCeremonyClaimV1 = {
+    readonly ceremony: StoredWalletRegistrationCeremony;
+    readonly version: number;
+};
+export declare class CloudflareD1RegistrationCeremonyIntentStore {
+    private readonly storage;
+    constructor(input: RegistrationCeremonyIntentStoreConfig);
+    putCeremony(ceremony: StoredWalletRegistrationCeremony): Promise<void>;
+    getCeremony(registrationCeremonyId: string): Promise<StoredWalletRegistrationCeremony | null>;
+    getCeremonySnapshot(registrationCeremonyId: string): Promise<D1WalletRegistrationEcdsaCeremonyClaimV1 | null>;
+    updateCeremony(input: {
+        readonly expected: StoredWalletRegistrationCeremony;
+        readonly next: StoredWalletRegistrationCeremony;
+    }): Promise<void>;
+    claimEcdsaRespond(input: {
+        readonly registrationCeremonyId: string;
+        readonly strictRegistrationBindingJson: string;
+        readonly registrationRequest: StoredWalletRegistrationEvmFamilyEcdsaResponseClaimedBranch['registrationRequest'];
+    }): Promise<D1WalletRegistrationEcdsaCeremonyClaimV1 | null>;
+    claimEcdsaActivation(input: {
+        readonly registrationCeremonyId: string;
+        readonly publicFacts: StoredWalletRegistrationEvmFamilyEcdsaActivationClaimedBranch['publicFacts'];
+        readonly activationRequestDigestB64u: string;
+        readonly activationOwner: string;
+    }): Promise<D1WalletRegistrationEcdsaCeremonyClaimV1 | null>;
+    commitEcdsaClaim(input: {
+        readonly expected: D1WalletRegistrationEcdsaCeremonyClaimV1;
+        readonly next: StoredWalletRegistrationCeremony;
+    }): Promise<void>;
+    takeCeremony(registrationCeremonyId: string): Promise<StoredWalletRegistrationCeremony | null>;
+    deleteCeremony(registrationCeremonyId: string): Promise<boolean>;
+    cancelTerminalCeremony(input: {
+        readonly registrationCeremonyId: string;
+        readonly walletId: WalletId;
+    }): Promise<TerminalRegistrationCeremonyCancellationResult>;
+    putAddSignerFinalizeReplay(replay: StoredWalletAddSignerFinalizeReplay): Promise<void>;
+    /**
+     * The statements that record a completed add-auth-method finalize.
+     *
+     * Returned rather than executed so the caller can put them in the same batch
+     * as the credential, custody envelope, auth method, and owner binding — a
+     * stored response must never outlive, or precede, the work it describes.
+     */
+    buildAddAuthMethodFinalizeReplayStatements(replay: StoredWalletAddAuthMethodFinalizeReplay): Promise<readonly D1PreparedStatementLike[]>;
+    getAddAuthMethodFinalizeReplay(addAuthMethodCeremonyId: string): Promise<StoredWalletAddAuthMethodFinalizeReplay | null>;
+    getAddSignerFinalizeReplay(input: {
+        readonly addSignerCeremonyId: string;
+        readonly idempotencyKey: string;
+    }): Promise<StoredWalletAddSignerFinalizeReplay | null>;
+    getAddSignerFinalizeReplayForCeremony(addSignerCeremonyId: string): Promise<StoredWalletAddSignerFinalizeReplay | null>;
+    putAddSignerIntent(intent: StoredAddSignerIntent): Promise<void>;
+    getAddSignerIntent(grant: string): Promise<StoredAddSignerIntent | null>;
+    takeAddSignerIntent(grant: string): Promise<StoredAddSignerIntent | null>;
+    putAddSignerCeremony(ceremony: StoredWalletAddSignerCeremony): Promise<void>;
+    getAddSignerCeremony(addSignerCeremonyId: string): Promise<StoredWalletAddSignerCeremony | null>;
+    updateAddSignerCeremony(input: {
+        readonly expected: StoredWalletAddSignerCeremony;
+        readonly next: StoredWalletAddSignerCeremony;
+    }): Promise<void>;
+    takeAddSignerCeremony(addSignerCeremonyId: string): Promise<StoredWalletAddSignerCeremony | null>;
+    putAddAuthMethodIntent(intent: StoredAddAuthMethodIntent): Promise<void>;
+    getAddAuthMethodIntent(grant: string): Promise<StoredAddAuthMethodIntent | null>;
+    takeAddAuthMethodIntent(grant: string): Promise<StoredAddAuthMethodIntent | null>;
+    putAddAuthMethodCeremony(ceremony: StoredWalletAddAuthMethodCeremony): Promise<void>;
+    getAddAuthMethodCeremony(addAuthMethodCeremonyId: string): Promise<StoredWalletAddAuthMethodCeremony | null>;
+    takeAddAuthMethodCeremony(addAuthMethodCeremonyId: string): Promise<StoredWalletAddAuthMethodCeremony | null>;
+    private put;
+    private claimEcdsaBranch;
+    private get;
+    private getDel;
+    private del;
+}
+//# sourceMappingURL=d1RegistrationCeremonyStore.d.ts.map

package/dist/types/wallet-server/src/router/cloudflare/d1/registration/d1RegistrationIntentService.d.ts

@@ -0,0 +1,31 @@
+import type { ThresholdRuntimePolicyScope } from '../../../../core/types';
+import type { CreateAddAuthMethodIntentResponse, CreateAddSignerIntentResponse } from '../../../../core/registrationContracts';
+import { CloudflareD1RegistrationCeremonyIntentStore } from './d1RegistrationCeremonyStore';
+import type { CreateAddAuthMethodIntentCommand, CreateAddSignerIntentCommand } from '../../../framework/authServicePort';
+type CreateAddSignerIntentInput = {
+    readonly command: CreateAddSignerIntentCommand;
+    readonly orgId: string;
+    readonly runtimePolicyScope?: ThresholdRuntimePolicyScope;
+    readonly signingRootId?: string;
+    readonly signingRootVersion?: string;
+    readonly expectedOrigin?: string;
+};
+type CreateAddAuthMethodIntentInput = {
+    readonly command: CreateAddAuthMethodIntentCommand;
+    readonly orgId: string;
+    readonly runtimePolicyScope?: ThresholdRuntimePolicyScope;
+    readonly signingRootId?: string;
+    readonly signingRootVersion?: string;
+    readonly expectedOrigin?: string;
+};
+type RegistrationCeremonyStoreProvider = () => CloudflareD1RegistrationCeremonyIntentStore;
+export declare class CloudflareD1RegistrationIntentService {
+    private readonly getRegistrationCeremonyIntentStore;
+    constructor(input: {
+        readonly getRegistrationCeremonyIntentStore: RegistrationCeremonyStoreProvider;
+    });
+    createAddSignerIntent(input: CreateAddSignerIntentInput): Promise<CreateAddSignerIntentResponse>;
+    createAddAuthMethodIntent(input: CreateAddAuthMethodIntentInput): Promise<CreateAddAuthMethodIntentResponse>;
+}
+export {};
+//# sourceMappingURL=d1RegistrationIntentService.d.ts.map

package/dist/types/wallet-server/src/router/cloudflare/d1/registration/d1WalletRegistrationCommitStore.d.ts

@@ -0,0 +1,49 @@
+import type { ActiveWalletAuthorityV1 } from '../../../../../../shared-ts/src/authorization/walletAuthority';
+import { type RegistrationAuthority, type WalletAuthMethodRecordV2 } from '../../../../../../shared-ts/src/utils/registrationIntent';
+import type { WalletRecord, WalletSignerRecord } from '../../../../core/WalletStore';
+import type { D1DatabaseLike } from '../../../../storage/tenantRoute';
+import type { D1EmailOtpRegistrationCommitPlan } from '../emailOtp/d1EmailOtpRegistrationEnrollmentFinalizer';
+type D1WalletRegistrationCommitBase = {
+    readonly wallet: WalletRecord;
+    readonly walletSigners: readonly WalletSignerRecord[];
+    readonly now: number;
+};
+type D1WalletRegistrationFoundingFields = {
+    readonly foundingAuthority?: never;
+    readonly foundingAuthMethod?: never;
+} | {
+    readonly foundingAuthority: ActiveWalletAuthorityV1;
+    readonly foundingAuthMethod: Extract<WalletAuthMethodRecordV2, {
+        readonly status: 'active';
+    }>;
+};
+export type D1WalletRegistrationCommitInput = (D1WalletRegistrationCommitBase & D1WalletRegistrationFoundingFields & {
+    readonly kind: 'passkey_wallet_registration_commit_v1';
+    readonly authority: Extract<RegistrationAuthority, {
+        readonly kind: 'passkey';
+    }>;
+    readonly emailOtp?: never;
+}) | (D1WalletRegistrationCommitBase & D1WalletRegistrationFoundingFields & {
+    readonly kind: 'email_otp_wallet_registration_commit_v1';
+    readonly authority: Extract<RegistrationAuthority, {
+        readonly kind: 'email_otp';
+    }>;
+    readonly emailOtp: D1EmailOtpRegistrationCommitPlan;
+});
+export interface D1WalletRegistrationCommitStore {
+    commit(input: D1WalletRegistrationCommitInput): Promise<void>;
+}
+export declare class CloudflareD1WalletRegistrationCommitStore implements D1WalletRegistrationCommitStore {
+    private readonly database;
+    private readonly scope;
+    constructor(input: {
+        readonly database: D1DatabaseLike;
+        readonly namespace: string;
+        readonly orgId: string;
+        readonly projectId: string;
+        readonly envId: string;
+    });
+    commit(input: D1WalletRegistrationCommitInput): Promise<void>;
+}
+export {};
+//# sourceMappingURL=d1WalletRegistrationCommitStore.d.ts.map