wallet-storage-client
Version:
Client only Wallet Storage
103 lines • 5.5 kB
TypeScript
import { AbortActionArgs, AbortActionResult, InternalizeActionArgs, InternalizeActionResult, ListActionsResult, ListCertificatesResult, ListOutputsResult, RelinquishCertificateArgs, RelinquishOutputArgs } from '@bsv/sdk';
import { sdk, StorageProvider, StorageSyncReader, table } from "../index.client";
/**
* The `SignerStorage` class delivers authentication checking storage access to the wallet.
*
* If manages multiple `StorageBase` derived storage services: one actice, the rest as backups.
*
* Of the storage services, one is 'active' at any one time.
* On startup, and whenever triggered by the wallet, `SignerStorage` runs a syncrhonization sequence:
*
* 1. While synchronizing, all other access to storage is blocked waiting.
* 2. The active service is confirmed, potentially triggering a resolution process if there is disagreement.
* 3. Changes are pushed from the active storage service to each inactive, backup service.
*
* Some storage services do not support multiple writers. `SignerStorage` manages wait-blocking write requests
* for these services.
*/
export declare class WalletStorageManager implements sdk.WalletStorage {
stores: sdk.WalletStorageProvider[];
_authId: sdk.AuthId;
_services?: sdk.WalletServices;
_userIdentityKeyToId: Record<string, number>;
_readerCount: number;
_writerCount: number;
/**
* if true, allow only a single writer to proceed at a time.
* queue the blocked requests so they get executed in order when released.
*/
_isSingleWriter: boolean;
/**
* if true, allow no new reader or writers to proceed.
* queue the blocked requests so they get executed in order when released.
*/
_syncLocked: boolean;
/**
* if true, allow no new reader or writers or sync to proceed.
* queue the blocked requests so they get executed in order when released.
*/
_storageProviderLocked: boolean;
constructor(identityKey: string, active?: sdk.WalletStorageProvider, backups?: sdk.WalletStorageProvider[]);
isStorageProvider(): boolean;
getUserId(): Promise<number>;
getAuth(mustBeActive?: boolean): Promise<sdk.AuthId>;
getActive(): sdk.WalletStorageProvider;
getActiveForWriter(): Promise<sdk.WalletStorageWriter>;
getActiveForReader(): Promise<sdk.WalletStorageReader>;
getActiveForSync(): Promise<sdk.WalletStorageSync>;
getActiveForStorageProvider(): Promise<StorageProvider>;
runAsWriter<R>(writer: (active: sdk.WalletStorageWriter) => Promise<R>): Promise<R>;
runAsReader<R>(reader: (active: sdk.WalletStorageReader) => Promise<R>): Promise<R>;
/**
*
* @param sync the function to run with sync access lock
* @param activeSync from chained sync functions, active storage already held under sync access lock.
* @returns
*/
runAsSync<R>(sync: (active: sdk.WalletStorageSync) => Promise<R>, activeSync?: sdk.WalletStorageSync): Promise<R>;
runAsStorageProvider<R>(sync: (active: StorageProvider) => Promise<R>): Promise<R>;
/**
*
* @returns true if the active `WalletStorageProvider` also implements `StorageProvider`
*/
isActiveStorageProvider(): boolean;
isAvailable(): boolean;
addWalletStorageProvider(provider: sdk.WalletStorageProvider): Promise<void>;
setServices(v: sdk.WalletServices): void;
getServices(): sdk.WalletServices;
getSettings(): table.Settings;
makeAvailable(): Promise<table.Settings>;
migrate(storageName: string, storageIdentityKey: string): Promise<string>;
destroy(): Promise<void>;
findOrInsertUser(identityKey: string): Promise<{
user: table.User;
isNew: boolean;
}>;
abortAction(args: AbortActionArgs): Promise<AbortActionResult>;
createAction(vargs: sdk.ValidCreateActionArgs): Promise<sdk.StorageCreateActionResult>;
internalizeAction(args: InternalizeActionArgs): Promise<InternalizeActionResult>;
relinquishCertificate(args: RelinquishCertificateArgs): Promise<number>;
relinquishOutput(args: RelinquishOutputArgs): Promise<number>;
processAction(args: sdk.StorageProcessActionArgs): Promise<sdk.StorageProcessActionResults>;
insertCertificate(certificate: table.Certificate): Promise<number>;
listActions(vargs: sdk.ValidListActionsArgs): Promise<ListActionsResult>;
listCertificates(args: sdk.ValidListCertificatesArgs): Promise<ListCertificatesResult>;
listOutputs(vargs: sdk.ValidListOutputsArgs): Promise<ListOutputsResult>;
findCertificates(args: sdk.FindCertificatesArgs): Promise<table.Certificate[]>;
findOutputBaskets(args: sdk.FindOutputBasketsArgs): Promise<table.OutputBasket[]>;
findOutputs(args: sdk.FindOutputsArgs): Promise<table.Output[]>;
findProvenTxReqs(args: sdk.FindProvenTxReqsArgs): Promise<table.ProvenTxReq[]>;
syncFromReader(identityKey: string, reader: StorageSyncReader): Promise<void>;
updateBackups(activeSync?: sdk.WalletStorageSync): Promise<void>;
syncToWriter(auth: sdk.AuthId, writer: sdk.WalletStorageProvider, activeSync?: sdk.WalletStorageSync): Promise<{
inserts: number;
updates: number;
}>;
/**
* Updates backups and switches to new active storage provider from among current backup providers.
*
* @param storageIdentityKey of current backup storage provider that is to become the new active provider.
*/
setActive(storageIdentityKey: string): Promise<void>;
}
//# sourceMappingURL=WalletStorageManager.d.ts.map