@bopen-io/wallet-toolbox 2.1.21-parity-fix.2 → 2.6.2-brc153.2

package/out/src/storage/WalletStorageManager.js

@@ -38,6 +38,11 @@ const sdk_1 = require("@bsv/sdk");
 const entities_1 = require("../storage/schema/entities");
 const sdk = __importStar(require("../sdk"));
 class ManagedStorage {
+    storage;
+    isAvailable;
+    isStorageProvider;
+    settings;
+    user;
     constructor(storage) {
         this.storage = storage;
         this.isStorageProvider = storage.isStorageProvider();
@@ -60,6 +65,34 @@ class ManagedStorage {
  * for these services.
  */
 class WalletStorageManager {
+    /**
+     * All configured stores including current active, backups, and conflicting actives.
+     */
+    _stores = [];
+    /**
+     * True if makeAvailable has been run and access to managed stores (active) is allowed
+     */
+    _isAvailable = false;
+    /**
+     * The current active store which is only enabled if the store's user record activeStorage property matches its settings record storageIdentityKey property
+     */
+    _active;
+    /**
+     * Stores to which state is pushed by updateBackups.
+     */
+    _backups;
+    /**
+     * Stores whose user record activeStorage property disagrees with the active store's user record activeStorage property.
+     */
+    _conflictingActives;
+    /**
+     * identityKey is always valid, userId and isActive are valid only if _isAvailable
+     */
+    _authId;
+    /**
+     * Configured services if any. If valid, shared with stores (which may ignore it).
+     */
+    _services;
     /**
      * Creates a new WalletStorageManager with the given identityKey and optional active and backup storage providers.
      *
@@ -68,20 +101,8 @@ class WalletStorageManager {
      * @param backups An optional array of backup storage providers. If not provided, no backups will be set.
      */
     constructor(identityKey, active, backups) {
-        /**
-         * All configured stores including current active, backups, and conflicting actives.
-         */
-        this._stores = [];
-        /**
-         * True if makeAvailable has been run and access to managed stores (active) is allowed
-         */
-        this._isAvailable = false;
-        this.readerLocks = [];
-        this.writerLocks = [];
-        this.syncLocks = [];
-        this.spLocks = [];
-        const stores = [...(backups || [])];
-        if (active)
+        const stores = [...(backups ?? [])];
+        if (active != null)
             stores.unshift(active);
         this._stores = stores.map(s => new ManagedStorage(s));
         this._authId = { identityKey };
@@ -103,8 +124,7 @@ class WalletStorageManager {
     get isActiveEnabled() {
         return (this._active !== undefined &&
             this._active.settings.storageIdentityKey === this._active.user.activeStorage &&
-            this._conflictingActives !== undefined &&
-            this._conflictingActives.length === 0);
+            this._conflictingActives?.length === 0);
     }
     /**
      * @returns true if at least one WalletStorageProvider has been added.
@@ -122,47 +142,47 @@ class WalletStorageManager {
      *
      * @returns {TableSettings} from the active storage.
      */
+    async ensureStoreAvailable(store) {
+        if (store.isAvailable && store.settings != null && store.user != null)
+            return;
+        store.settings = await store.storage.makeAvailable();
+        const r = await store.storage.findOrInsertUser(this._authId.identityKey);
+        store.user = r.user;
+        store.isAvailable = true;
+    }
+    selectActiveFromStore(store, backups) {
+        if (this._active == null) {
+            // _stores[0] becomes the default active store.
+            this._active = store;
+            return;
+        }
+        const ua = store.user.activeStorage;
+        const si = store.settings.storageIdentityKey;
+        if (ua === si && !this.isActiveEnabled) {
+            // This store's user record selects it as the enabled active storage — swap.
+            backups.push(this._active);
+            this._active = store;
+        }
+        else {
+            backups.push(store);
+        }
+    }
     async makeAvailable() {
-        var _a;
         if (this._isAvailable)
             return this._active.settings;
         this._active = undefined;
         this._backups = [];
         this._conflictingActives = [];
-        if (this._stores.length < 1)
+        if (this._stores.length < 1) {
             throw new sdk.WERR_INVALID_PARAMETER('active', 'valid. Must add active storage provider to wallet.');
-        // Initial backups. conflictingActives will be removed.
+        }
         const backups = [];
-        let i = -1;
         for (const store of this._stores) {
-            i++;
-            if (!store.isAvailable || !store.settings || !store.user) {
-                // Validate all ManagedStorage properties.
-                store.settings = await store.storage.makeAvailable();
-                const r = await store.storage.findOrInsertUser(this._authId.identityKey);
-                store.user = r.user;
-                store.isAvailable = true;
-            }
-            if (!this._active)
-                // _stores[0] becomes the default active store. It may be replaced if it is not the user's "enabled" activeStorage and that store is found among the remainder (backups).
-                this._active = store;
-            else {
-                const ua = store.user.activeStorage;
-                const si = store.settings.storageIdentityKey;
-                if (ua === si && !this.isActiveEnabled) {
-                    // This store's user record selects it as an enabled active storage...
-                    // swap the current not-enabled active for this storeage.
-                    backups.push(this._active);
-                    this._active = store;
-                }
-                else {
-                    // This store is a backup: Its user record selects some other storage as active.
-                    backups.push(store);
-                }
-            }
+            await this.ensureStoreAvailable(store);
+            this.selectActiveFromStore(store, backups);
         }
-        // Review backups, partition out conflicting actives.
-        const si = (_a = this._active.settings) === null || _a === void 0 ? void 0 : _a.storageIdentityKey;
+        // Partition backups into proper backups vs conflicting actives.
+        const si = this._active.settings?.storageIdentityKey;
         for (const store of backups) {
             if (store.user.activeStorage !== si)
                 this._conflictingActives.push(store);
@@ -170,19 +190,20 @@ class WalletStorageManager {
                 this._backups.push(store);
         }
         this._isAvailable = true;
-        this._authId.userId = this._active.user.userId;
+        this._authId.userId = this._active.user?.userId;
         this._authId.isActive = this.isActiveEnabled;
         return this._active.settings;
     }
     verifyActive() {
-        if (!this._active || !this._isAvailable)
+        if (this._active == null || !this._isAvailable) {
             throw new sdk.WERR_INVALID_OPERATION('An active WalletStorageProvider must be added to this WalletStorageManager and makeAvailable must be called.');
+        }
         return this._active;
     }
     async getAuth(mustBeActive) {
         if (!this.isAvailable())
             await this.makeAvailable();
-        if (mustBeActive && !this._authId.isActive)
+        if (mustBeActive === true && this._authId.isActive !== true)
             throw new sdk.WERR_NOT_ACTIVE();
         return this._authId;
     }
@@ -216,6 +237,10 @@ class WalletStorageManager {
         this.verifyActive();
         return this._stores.map(b => b.settings.storageIdentityKey);
     }
+    readerLocks = [];
+    writerLocks = [];
+    syncLocks = [];
+    spLocks = [];
     async getActiveLock(lockQueue) {
         if (!this.isAvailable())
             await this.makeAvailable();
@@ -269,8 +294,9 @@ class WalletStorageManager {
         await this.getActiveLock(this.spLocks);
         const active = this.getActive();
         // We can finally confirm that active storage is still able to support `StorageProvider`
-        if (!active.isStorageProvider())
+        if (!active.isStorageProvider()) {
             throw new sdk.WERR_INVALID_OPERATION('Active "WalletStorageProvider" does not support "StorageProvider" interface.');
+        }
         // Allow the sync to proceed on the active store.
         return active;
     }
@@ -308,12 +334,12 @@ class WalletStorageManager {
      */
     async runAsSync(sync, activeSync) {
         try {
-            const active = activeSync || (await this.getActiveForSync());
+            const active = activeSync ?? (await this.getActiveForSync());
             const r = await sync(active);
             return r;
         }
         finally {
-            if (!activeSync)
+            if (activeSync == null)
                 this.releaseActiveForSync();
         }
     }
@@ -336,7 +362,7 @@ class WalletStorageManager {
     }
     async addWalletStorageProvider(provider) {
         await provider.makeAvailable();
-        if (this._services)
+        if (this._services != null)
             provider.setServices(this._services);
         this._stores.push(new ManagedStorage(provider));
         this._isAvailable = false;
@@ -348,7 +374,7 @@ class WalletStorageManager {
             store.storage.setServices(v);
     }
     getServices() {
-        if (!this._services)
+        if (this._services == null)
             throw new sdk.WERR_INVALID_OPERATION('Must setServices first.');
         return this._services;
     }
@@ -357,25 +383,26 @@ class WalletStorageManager {
     }
     async migrate(storageName, storageIdentityKey) {
         return await this.runAsWriter(async (writer) => {
-            return writer.migrate(storageName, storageIdentityKey);
+            return await writer.migrate(storageName, storageIdentityKey);
         });
     }
     async destroy() {
         if (this._stores.length < 1)
             return;
-        return await this.runAsWriter(async (writer) => {
+        return await this.runAsWriter(async (_writer) => {
             for (const store of this._stores)
                 await store.storage.destroy();
         });
     }
     async findOrInsertUser(identityKey) {
         const auth = await this.getAuth();
-        if (identityKey != auth.identityKey)
+        if (identityKey !== auth.identityKey)
             throw new sdk.WERR_UNAUTHORIZED();
         return await this.runAsWriter(async (writer) => {
             const r = await writer.findOrInsertUser(identityKey);
-            if (auth.userId && auth.userId !== r.user.userId)
+            if (auth.userId != null && auth.userId !== 0 && auth.userId !== r.user.userId) {
                 throw new sdk.WERR_INTERNAL('userId may not change for given identityKey');
+            }
             this._authId.userId = r.user.userId;
             return r;
         });
@@ -420,6 +447,46 @@ class WalletStorageManager {
             return await writer.processAction(auth, args);
         });
     }
+    async getCapabilities() {
+        return await this.runAsReader(async () => await this.getActive().getCapabilities());
+    }
+    async beginActionBatch(args) {
+        return await this.runAsWriter(async (writer) => await writer.beginActionBatch(await this.getAuth(true), args));
+    }
+    async extendActionBatch(args) {
+        return await this.runAsWriter(async (writer) => await writer.extendActionBatch(await this.getAuth(true), args));
+    }
+    async renewActionBatch(batchId) {
+        return await this.runAsWriter(async (writer) => await writer.renewActionBatch(await this.getAuth(true), batchId));
+    }
+    async prepareActionBatchCommit(manifest) {
+        return await this.runAsWriter(async (writer) => await writer.prepareActionBatchCommit(await this.getAuth(true), manifest));
+    }
+    async putActionBatchBlob(args) {
+        return await this.runAsWriter(async (writer) => await writer.putActionBatchBlob(await this.getAuth(true), args));
+    }
+    async putActionBatchPack(args) {
+        return await this.runAsWriter(async (writer) => {
+            if (writer.putActionBatchPack == null) {
+                throw new sdk.WERR_NOT_IMPLEMENTED('packed action batch uploads are not available');
+            }
+            await writer.putActionBatchPack(await this.getAuth(true), args);
+        });
+    }
+    async commitActionBatch(manifest) {
+        return await this.runAsWriter(async (writer) => await writer.commitActionBatch(await this.getAuth(true), manifest));
+    }
+    async commitActionBatchByDigest(args) {
+        return await this.runAsWriter(async (writer) => {
+            if (writer.commitActionBatchByDigest == null) {
+                throw new sdk.WERR_NOT_IMPLEMENTED('digest-only action batch commit is not available');
+            }
+            return await writer.commitActionBatchByDigest(await this.getAuth(true), args);
+        });
+    }
+    async abortActionBatch(batchId) {
+        return await this.runAsWriter(async (writer) => await writer.abortActionBatch(await this.getAuth(true), batchId));
+    }
     async insertCertificate(certificate) {
         return await this.runAsWriter(async (writer) => {
             const auth = await this.getAuth(true);
@@ -491,7 +558,7 @@ class WalletStorageManager {
                 r.unavailable.push(ptx);
             if (rp.unchanged)
                 r.unchanged.push(ptx);
-            if (rp.updated)
+            if (rp.updated != null)
                 r.updated.push({ was: ptx, update: rp.updated.update, logUpdate: rp.updated.logUpdate });
         }
         if (r.updated.length > 0) {
@@ -524,7 +591,7 @@ class WalletStorageManager {
                 r.unavailable.push(ptx);
             if (rp.unchanged)
                 r.unchanged.push(ptx);
-            if (rp.updated)
+            if (rp.updated != null)
                 r.updated.push({ was: ptx, update: rp.updated.update, logUpdate: rp.updated.logUpdate });
         }
         if (r.updated.length > 0) {
@@ -547,16 +614,37 @@ class WalletStorageManager {
      * @param noUpdate
      * @returns
      */
+    async evaluateNewMerkleLeaf(ptx, mp, leaf, blockHash, chaintracker, r, update) {
+        if (blockHash === ptx.blockHash) {
+            r.log += `    txid ${ptx.txid} merkle path update still based on deactivated header ${ptx.blockHash}\n`;
+            r.unchanged = true;
+            return;
+        }
+        const merkleRoot = mp.computeRoot(ptx.txid);
+        const isValid = await chaintracker.isValidRootForHeight(merkleRoot, update.height);
+        const heightChange = ptx.height === update.height ? 'unchanged' : `-> ${String(update.height)}`;
+        const logUpdate = `      height ${ptx.height} ${heightChange}\n`;
+        r.log += `      blockHash ${ptx.blockHash} -> ${String(update.blockHash)}\n`;
+        r.log += `      merkleRoot ${ptx.merkleRoot} -> ${String(update.merkleRoot)}\n`;
+        r.log += `      index ${ptx.index} -> ${String(update.index)}\n`;
+        if (isValid) {
+            r.updated = { update, logUpdate };
+        }
+        else {
+            r.log += `    txid ${ptx.txid} chaintracker fails to confirm updated merkle path update invalid\n` + logUpdate;
+            r.unavailable = true;
+        }
+    }
     async reproveProven(ptx, noUpdate) {
         const r = { log: '', updated: undefined, unchanged: false, unavailable: false };
         const services = this.getServices();
         const chaintracker = await services.getChainTracker();
         const mpr = await services.getMerklePath(ptx.txid);
-        if (mpr.merklePath && mpr.header) {
+        if (mpr.merklePath != null && mpr.header != null) {
             const mp = mpr.merklePath;
             const h = mpr.header;
             const leaf = mp.path[0].find(leaf => leaf.txid === true && leaf.hash === ptx.txid);
-            if (leaf) {
+            if (leaf != null) {
                 const update = {
                     height: mp.blockHeight,
                     index: leaf.offset,
@@ -564,27 +652,7 @@ class WalletStorageManager {
                     merkleRoot: h.merkleRoot,
                     blockHash: h.hash
                 };
-                if (update.blockHash === ptx.blockHash) {
-                    r.log += `    txid ${ptx.txid} merkle path update still based on deactivated header ${ptx.blockHash}\n`;
-                    r.unchanged = true;
-                }
-                else {
-                    // Verify the new proof's validity.
-                    const merkleRoot = mp.computeRoot(ptx.txid);
-                    const isValid = await chaintracker.isValidRootForHeight(merkleRoot, update.height);
-                    const logUpdate = `      height ${ptx.height} ${ptx.height === update.height ? 'unchanged' : `-> ${update.height}`}\n`;
-                    r.log += `      blockHash ${ptx.blockHash} -> ${update.blockHash}\n`;
-                    r.log += `      merkleRoot ${ptx.merkleRoot} -> ${update.merkleRoot}\n`;
-                    r.log += `      index ${ptx.index} -> ${update.index}\n`;
-                    if (isValid) {
-                        r.updated = { update, logUpdate };
-                    }
-                    else {
-                        r.log +=
-                            `    txid ${ptx.txid} chaintracker fails to confirm updated merkle path update invalid\n` + logUpdate;
-                        r.unavailable = true;
-                    }
-                }
+                await this.evaluateNewMerkleLeaf(ptx, mp, leaf, h.hash, chaintracker, r, update);
             }
             else {
                 r.log += `    txid ${ptx.txid} merkle path update doesn't include txid\n`;
@@ -595,10 +663,11 @@ class WalletStorageManager {
             r.log += `    txid ${ptx.txid} merkle path update unavailable\n`;
             r.unavailable = true;
         }
-        if (r.updated && !noUpdate) {
+        if (r.updated != null && noUpdate !== true) {
+            const updatedSnapshot = r.updated;
             await this.runAsStorageProvider(async (sp) => {
-                await sp.updateProvenTx(ptx.provenTxId, r.updated.update);
-                r.log += `    txid ${ptx.txid} proof data updated\n` + r.updated.logUpdate;
+                await sp.updateProvenTx(ptx.provenTxId, updatedSnapshot.update);
+                r.log += `    txid ${ptx.txid} proof data updated\n` + updatedSnapshot.logUpdate;
             });
         }
         return r;
@@ -608,7 +677,8 @@ class WalletStorageManager {
         if (identityKey !== auth.identityKey)
             throw new sdk.WERR_UNAUTHORIZED();
         const readerSettings = await reader.makeAvailable();
-        let inserts = 0, updates = 0;
+        let inserts = 0;
+        let updates = 0;
         log = await this.runAsSync(async (sync) => {
             const writer = sync;
             const writerSettings = this.getSettings();
@@ -619,14 +689,14 @@ class WalletStorageManager {
                 const ss = await entities_1.EntitySyncState.fromStorage(writer, identityKey, readerSettings);
                 const args = ss.makeRequestSyncChunkArgs(identityKey, writerSettings.storageIdentityKey);
                 const chunk = await reader.getSyncChunk(args);
-                if (chunk.user) {
+                if (chunk.user != null) {
                     // Merging state from a reader cannot update activeStorage
                     chunk.user.activeStorage = this._active.user.activeStorage;
                 }
                 const r = await writer.processSyncChunk(args, chunk);
                 inserts += r.inserts;
                 updates += r.updates;
-                log += `chunk ${i} inserted ${r.inserts} updated ${r.updates} ${r.maxUpdated_at}\n`;
+                log += `chunk ${i} inserted ${r.inserts} updated ${r.updates} ${String(r.maxUpdated_at)}\n`;
                 if (r.done)
                     break;
             }
@@ -636,10 +706,11 @@ class WalletStorageManager {
         return { inserts, updates, log };
     }
     async syncToWriter(auth, writer, activeSync, log = '', progLog) {
-        progLog || (progLog = s => s);
+        progLog ||= s => s;
         const identityKey = auth.identityKey;
         const writerSettings = await writer.makeAvailable();
-        let inserts = 0, updates = 0;
+        let inserts = 0;
+        let updates = 0;
         log = await this.runAsSync(async (sync) => {
             const reader = sync;
             const readerSettings = reader.getSettings();
@@ -654,7 +725,7 @@ class WalletStorageManager {
                 const r = await writer.processSyncChunk(args, chunk);
                 inserts += r.inserts;
                 updates += r.updates;
-                log += progLog(`chunk ${i} inserted ${r.inserts} updated ${r.updates} ${r.maxUpdated_at}\n`);
+                log += progLog(`chunk ${i} inserted ${r.inserts} updated ${r.updates} ${String(r.maxUpdated_at)}\n`);
                 if (r.done)
                     break;
             }
@@ -664,7 +735,7 @@ class WalletStorageManager {
         return { inserts, updates, log };
     }
     async updateBackups(activeSync, progLog) {
-        progLog || (progLog = s => s);
+        progLog ||= s => s;
         const auth = await this.getAuth(true);
         return await this.runAsSync(async (sync) => {
             let log = progLog(`BACKUP CURRENT ACTIVE TO ${this._backups.length} STORES\n`);
@@ -683,26 +754,29 @@ class WalletStorageManager {
      * @param storageIdentityKey of current backup storage provider that is to become the new active provider.
      */
     async setActive(storageIdentityKey, progLog) {
-        progLog || (progLog = s => s);
+        progLog ||= s => s;
         if (!this.isAvailable())
             await this.makeAvailable();
         // Confirm a valid storageIdentityKey: must match one of the _stores.
         const newActiveIndex = this._stores.findIndex(s => s.settings.storageIdentityKey === storageIdentityKey);
-        if (newActiveIndex < 0)
+        if (newActiveIndex < 0) {
             throw new sdk.WERR_INVALID_PARAMETER('storageIdentityKey', `registered with this "WalletStorageManager". ${storageIdentityKey} does not match any managed store.`);
+        }
         const identityKey = (await this.getAuth()).identityKey;
         const newActive = this._stores[newActiveIndex];
         let log = progLog(`setActive to ${newActive.settings.storageName}`);
-        if (storageIdentityKey === this.getActiveStore() && this.isActiveEnabled)
+        if (storageIdentityKey === this.getActiveStore() && this.isActiveEnabled) {
             /** Setting the current active as the new active is a permitted no-op. */
-            return log + progLog(` unchanged\n`);
+            return log + progLog(' unchanged\n');
+        }
         log += progLog('\n');
-        log += await this.runAsSync(async (sync) => {
+        log += await this.runAsSync(async (_sync) => {
             let log = '';
             if (this._conflictingActives.length > 0) {
                 // Merge state from conflicting actives into `newActive`.
                 // Handle case where new active is current active to resolve conflicts.
                 // And where new active is one of the current conflict actives.
+                ;
                 this._conflictingActives.push(this._active);
                 // Remove the new active from conflicting actives and
                 // set new active as the conflicting active that matches the target `storageIdentityKey`
@@ -731,8 +805,10 @@ class WalletStorageManager {
             await backupSource.storage.setActive({ identityKey, userId: backupSource.user.userId }, storageIdentityKey);
             for (const store of this._stores) {
                 // Update cached user.activeStorage of all stores
+                ;
                 store.user.activeStorage = storageIdentityKey;
-                if (store.settings.storageIdentityKey !== backupSource.settings.storageIdentityKey) {
+                if (store.settings.storageIdentityKey !==
+                    backupSource.settings.storageIdentityKey) {
                     // If this store is not the backupSource store push state from backupSource to this store.
                     const stwr = await this.syncToWriter({ identityKey, userId: store.user.userId, isActive: false }, store.storage, backupSource.storage, undefined, progLog);
                     log += stwr.log;
@@ -751,7 +827,7 @@ class WalletStorageManager {
     }
     getStores() {
         const stores = [];
-        if (this._active) {
+        if (this._active != null) {
             stores.push({
                 isActive: true,
                 isEnabled: this.isActiveEnabled,
@@ -764,7 +840,7 @@ class WalletStorageManager {
                 endpointURL: this.getStoreEndpointURL(this._active)
             });
         }
-        for (const store of this._conflictingActives || []) {
+        for (const store of this._conflictingActives ?? []) {
             stores.push({
                 isActive: true,
                 isEnabled: false,
@@ -777,7 +853,7 @@ class WalletStorageManager {
                 endpointURL: this.getStoreEndpointURL(store)
             });
         }
-        for (const store of this._backups || []) {
+        for (const store of this._backups ?? []) {
             stores.push({
                 isActive: false,
                 isEnabled: false,