@didcid/gatekeeper 0.1.3 → 0.3.0

package/dist/cjs/{abstract-json-BJMq-iEa.cjs → abstract-json-DNKwEI6F.cjs}

@@ -141,7 +141,7 @@ class AbstractJson {
                 if (!oldQueue) {
                     return true;
                 }
-                db.queue[registry] = oldQueue.filter(item => !batch.some(op => op.signature?.value === item.signature?.value));
+                db.queue[registry] = oldQueue.filter(item => !batch.some(op => op.proof?.proofValue === item.proof?.proofValue));
                 this.writeDb(db);
                 return true;
             }

package/dist/cjs/db/json-cache.cjs

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var fs = require('fs');
-var abstractJson = require('../abstract-json-BJMq-iEa.cjs');
+var abstractJson = require('../abstract-json-DNKwEI6F.cjs');
 require('../errors-DQaog-FG.cjs');
 
 class DbJsonCache extends abstractJson.AbstractJson {

package/dist/cjs/db/json-memory.cjs

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var abstractJson = require('../abstract-json-BJMq-iEa.cjs');
+var abstractJson = require('../abstract-json-DNKwEI6F.cjs');
 require('../errors-DQaog-FG.cjs');
 
 class DbJsonMemory extends abstractJson.AbstractJson {

package/dist/cjs/db/json.cjs

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var fs = require('fs');
-var abstractJson = require('../abstract-json-BJMq-iEa.cjs');
+var abstractJson = require('../abstract-json-DNKwEI6F.cjs');
 require('../errors-DQaog-FG.cjs');
 
 class DbJson extends abstractJson.AbstractJson {

package/dist/cjs/db/mongo.cjs

@@ -167,15 +167,15 @@ class DbMongo {
             throw new Error(MONGO_NOT_STARTED_ERROR);
         }
         try {
-            const hashes = batch
-                .map(op => op.signature?.hash)
-                .filter((h) => !!h);
-            if (hashes.length === 0) {
+            const proofValues = batch
+                .map(op => op.proof?.proofValue)
+                .filter((p) => !!p);
+            if (proofValues.length === 0) {
                 return true;
             }
             await this.db
                 .collection('queue')
-                .updateOne({ id: registry }, { $pull: { ops: { 'signature.hash': { $in: hashes } } } });
+                .updateOne({ id: registry }, { $pull: { ops: { 'proof.proofValue': { $in: proofValues } } } });
             return true;
         }
         catch (error) {

package/dist/cjs/db/redis.cjs

@@ -165,10 +165,10 @@ class DbRedis {
         if (!this.redis) {
             throw new Error(REDIS_NOT_STARTED_ERROR);
         }
-        const hashes = batch
-            .map(op => op.signature?.hash)
-            .filter((h) => !!h);
-        if (hashes.length === 0) {
+        const proofValues = batch
+            .map(op => op.proof?.proofValue)
+            .filter((p) => !!p);
+        if (proofValues.length === 0) {
             return true;
         }
         const key = this.queueKey(registry);
@@ -186,7 +186,7 @@ class DbRedis {
                       local keep = {}
                       for i=1,#list do
                         local ok, obj = pcall(cjson.decode, list[i])
-                        if ok and obj and obj.signature and obj.signature.hash and want[obj.signature.hash] then
+                        if ok and obj and obj.proof and obj.proof.proofValue and want[obj.proof.proofValue] then
                           -- drop
                         else
                           table.insert(keep, list[i])
@@ -199,7 +199,7 @@ class DbRedis {
                       return #list - #keep
                     `;
         try {
-            await this.redis.eval(script, 1, key, hashes.length.toString(), ...hashes);
+            await this.redis.eval(script, 1, key, proofValues.length.toString(), ...proofValues);
             return true;
         }
         catch (e) {

package/dist/cjs/db/sqlite.cjs

@@ -259,8 +259,8 @@ class DbSqlite {
         }
         return this.runExclusive(async () => this.withTx(async () => {
             const oldQueue = await this.getQueueStrict(registry);
-            const batchHashes = new Set(batch.map(b => b.signature?.hash).filter((h) => h !== undefined));
-            const newQueue = oldQueue.filter(item => !batchHashes.has(item.signature?.hash || ''));
+            const batchProofValues = new Set(batch.map(b => b.proof?.proofValue).filter((p) => p !== undefined));
+            const newQueue = oldQueue.filter(item => !batchProofValues.has(item.proof?.proofValue || ''));
             await this.db.run(`INSERT OR REPLACE INTO queue(id, ops) VALUES(?, ?)`, registry, JSON.stringify(newQueue));
             return true;
         }).catch(err => {

package/dist/cjs/gatekeeper-client.cjs

@@ -364,6 +364,27 @@ class GatekeeperClient {
             throwError(error);
         }
     }
+    async searchDocs(q) {
+        try {
+            const response = await this.axios.get(`${this.API}/search`, { params: { q } });
+            return response.data;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async queryDocs(where) {
+        try {
+            const response = await this.axios.post(`${this.API}/query`, { where });
+            return response.data;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async search(query) {
+        return this.queryDocs(query.where);
+    }
 }
 
 exports.default = GatekeeperClient;

package/dist/cjs/gatekeeper.cjs

@@ -41125,6 +41125,128 @@ async function generateCID(data) {
     return cid.toString(); // CID v1 default: base32 encoding
 }
 
+class SearchIndex {
+    docs = new Map();
+    static ARRAY_WILDCARD_END = /\[\*]$/;
+    static ARRAY_WILDCARD_MID = /\[\*]\./;
+    store(did, doc) {
+        // Only index didDocumentData to focus on actual content
+        const data = doc.didDocumentData;
+        if (data && typeof data === 'object') {
+            this.docs.set(did, JSON.parse(JSON.stringify(data)));
+        }
+        else {
+            this.docs.set(did, {});
+        }
+    }
+    delete(did) {
+        this.docs.delete(did);
+    }
+    clear() {
+        this.docs.clear();
+    }
+    get size() {
+        return this.docs.size;
+    }
+    searchDocs(q) {
+        const out = [];
+        for (const [did, doc] of this.docs.entries()) {
+            if (JSON.stringify(doc).includes(q))
+                out.push(did);
+        }
+        return out;
+    }
+    queryDocs(where) {
+        const entry = Object.entries(where)[0];
+        if (!entry) {
+            return [];
+        }
+        const [rawPath, cond] = entry;
+        if (typeof cond !== 'object' || cond === null || !Array.isArray(cond.$in)) {
+            throw new Error('Only {$in:[...]} supported');
+        }
+        const list = cond.$in;
+        const isKeyWildcard = rawPath.endsWith('.*');
+        const isValueWildcard = rawPath.includes('.*.');
+        const isArrayTail = SearchIndex.ARRAY_WILDCARD_END.test(rawPath);
+        const isArrayMid = SearchIndex.ARRAY_WILDCARD_MID.test(rawPath);
+        const result = [];
+        for (const [did, doc] of this.docs.entries()) {
+            let match = false;
+            if (isArrayTail) {
+                const basePath = rawPath.replace(SearchIndex.ARRAY_WILDCARD_END, '');
+                const arr = this.getPath(doc, basePath);
+                if (Array.isArray(arr)) {
+                    match = arr.some(v => list.includes(v));
+                }
+            }
+            else if (isArrayMid) {
+                const [prefix, suffix] = rawPath.split('[*].');
+                const arr = this.getPath(doc, prefix);
+                if (Array.isArray(arr)) {
+                    match = arr.some(el => list.includes(this.getPath(el, suffix)));
+                }
+            }
+            else if (isKeyWildcard) {
+                const basePath = rawPath.slice(0, -2);
+                const obj = this.getPath(doc, basePath);
+                if (obj && typeof obj === 'object' && !Array.isArray(obj)) {
+                    const keys = Object.keys(obj);
+                    match = keys.some(k => list.includes(k));
+                }
+            }
+            else if (isValueWildcard) {
+                const [prefix, suffix] = rawPath.split('.*.');
+                const obj = this.getPath(doc, prefix);
+                if (obj && typeof obj === 'object' && !Array.isArray(obj)) {
+                    const values = Object.values(obj);
+                    match = values.some(v => list.includes(this.getPath(v, suffix)));
+                }
+            }
+            else {
+                const val = this.getPath(doc, rawPath);
+                match = list.includes(val);
+            }
+            if (match) {
+                result.push(did);
+            }
+        }
+        return result;
+    }
+    getPath(root, path) {
+        if (!path || root == null) {
+            return undefined;
+        }
+        const clean = path.startsWith('$.') ? path.slice(2) : path.startsWith('$') ? path.slice(1) : path;
+        if (!clean) {
+            return root;
+        }
+        const parts = clean.split('.');
+        let cur = root;
+        for (const rawPart of parts) {
+            if (cur == null) {
+                return undefined;
+            }
+            const idx = Number.isInteger(+rawPart) ? +rawPart : null;
+            if (idx !== null && Array.isArray(cur)) {
+                cur = cur[idx];
+                continue;
+            }
+            if (typeof cur === 'object') {
+                cur = cur[rawPart];
+            }
+            else {
+                return undefined;
+            }
+        }
+        return cur;
+    }
+}
+
+function base64urlToHex(b64) {
+    const bytes = base64url.baseDecode(b64);
+    return Buffer.from(bytes).toString('hex');
+}
 const ValidVersions = [1];
 const ValidTypes = ['agent', 'asset'];
 // Registries that are considered valid when importing DIDs from the network
@@ -41134,7 +41256,6 @@ const ValidRegistries = [
     'BTC:mainnet',
     'BTC:testnet4',
     'BTC:signet',
-    'FTC:testnet5',
 ];
 var ImportStatus;
 (function (ImportStatus) {
@@ -41156,6 +41277,7 @@ class Gatekeeper {
     maxQueueSize;
     supportedRegistries;
     didLocks = new Map();
+    searchIndex;
     constructor(options) {
         if (!options || !options.db) {
             throw new errors.InvalidParameterError('missing options.db');
@@ -41183,6 +41305,30 @@ class Gatekeeper {
                 throw new errors.InvalidParameterError(`registry=${registry}`);
             }
         }
+        this.searchIndex = new SearchIndex();
+    }
+    async initSearchIndex() {
+        const dids = await this.getDIDs();
+        for (const did of dids) {
+            try {
+                const doc = await this.resolveDID(did);
+                this.searchIndex.store(did, doc);
+            }
+            catch {
+                // Skip DIDs that can't be resolved
+            }
+        }
+        console.log(`Search index initialized with ${this.searchIndex.size} DIDs`);
+    }
+    async updateSearchIndex(did) {
+        try {
+            const doc = await this.resolveDID(did);
+            this.searchIndex.store(did, doc);
+        }
+        catch {
+            // If DID can't be resolved, remove from index
+            this.searchIndex.delete(did);
+        }
     }
     async withDidLock(did, fn) {
         const prev = this.didLocks.get(did) ?? Promise.resolve();
@@ -41311,7 +41457,7 @@ class Gatekeeper {
                 if (registry) {
                     byRegistry[registry] = (byRegistry[registry] || 0) + 1;
                 }
-                const version = doc.didDocumentMetadata?.version;
+                const version = doc.didDocumentMetadata?.versionSequence;
                 if (version != null) {
                     const versionNum = parseInt(version, 10);
                     if (!isNaN(versionNum)) {
@@ -41333,6 +41479,7 @@ class Gatekeeper {
     async resetDb() {
         await this.db.resetDb();
         this.verifiedDIDs = {};
+        this.searchIndex.clear();
         return true;
     }
     async generateCID(operation, save = false) {
@@ -41372,21 +41519,29 @@ class Gatekeeper {
         const hex64Regex = /^[a-f0-9]{64}$/i;
         return hex64Regex.test(hash);
     }
-    verifySignatureFormat(signature) {
-        if (!signature) {
+    verifyProofFormat(proof) {
+        if (!proof) {
             return false;
         }
-        if (!this.verifyDateFormat(signature.signed)) {
+        if (proof.type !== "EcdsaSecp256k1Signature2019") {
             return false;
         }
-        if (!this.verifyHashFormat(signature.hash)) {
+        if (!this.verifyDateFormat(proof.created)) {
             return false;
         }
-        // eslint-disable-next-line
-        if (signature.signer && !this.verifyDIDFormat(signature.signer)) {
+        if (!proof.proofPurpose || !["assertionMethod", "authentication"].includes(proof.proofPurpose)) {
             return false;
         }
-        return true;
+        // Validate verificationMethod format: did:...#key-N or #key-N (relative reference for create ops)
+        if (!proof.verificationMethod || !proof.verificationMethod.includes('#')) {
+            return false;
+        }
+        const [did] = proof.verificationMethod.split('#');
+        // Empty string is valid (relative reference like #key-1), otherwise must be valid DID
+        if (did !== '' && !this.verifyDIDFormat(did)) {
+            return false;
+        }
+        return !!(proof.proofValue && typeof proof.proofValue === 'string');
     }
     async verifyCreateOperation(operation) {
         if (!operation) {
@@ -41414,8 +41569,12 @@ class Gatekeeper {
         if (!ValidRegistries.includes(operation.registration.registry)) {
             throw new errors.InvalidOperationError(`registration.registry=${operation.registration.registry}`);
         }
-        if (!this.verifySignatureFormat(operation.signature)) {
-            throw new errors.InvalidOperationError('signature');
+        if (!this.verifyProofFormat(operation.proof)) {
+            throw new errors.InvalidOperationError('proof');
+        }
+        // For agent create operations, verificationMethod must be relative #key-1 (no DID exists yet)
+        if (operation.registration.type === 'agent' && operation.proof.verificationMethod !== '#key-1') {
+            throw new errors.InvalidOperationError('proof.verificationMethod must be #key-1 for agent create');
         }
         if (operation.registration.validUntil && !this.verifyDateFormat(operation.registration.validUntil)) {
             throw new errors.InvalidOperationError(`registration.validUntil=${operation.registration.validUntil}`);
@@ -41425,20 +41584,23 @@ class Gatekeeper {
                 throw new errors.InvalidOperationError('publicJwk');
             }
             const operationCopy = copyJSON(operation);
-            delete operationCopy.signature;
+            delete operationCopy.proof;
             const msgHash = this.cipher.hashJSON(operationCopy);
-            return this.cipher.verifySig(msgHash, operation.signature.value, operation.publicJwk);
+            const signatureHex = base64urlToHex(operation.proof.proofValue);
+            return this.cipher.verifySig(msgHash, signatureHex, operation.publicJwk);
         }
         if (operation.registration.type === 'asset') {
-            if (operation.controller !== operation.signature?.signer) {
+            // Extract controller DID from verificationMethod
+            const [controllerDid] = operation.proof.verificationMethod.split('#');
+            if (operation.controller !== controllerDid) {
                 throw new errors.InvalidOperationError('signer is not controller');
             }
-            const doc = await this.resolveDID(operation.signature.signer, { confirm: true, versionTime: operation.signature.signed });
+            const doc = await this.resolveDID(controllerDid, { confirm: true, versionTime: operation.proof.created });
             if (doc.didDocumentRegistration && doc.didDocumentRegistration.registry === 'local' && operation.registration.registry !== 'local') {
                 throw new errors.InvalidOperationError(`non-local registry=${operation.registration.registry}`);
             }
             const operationCopy = copyJSON(operation);
-            delete operationCopy.signature;
+            delete operationCopy.proof;
             const msgHash = this.cipher.hashJSON(operationCopy);
             if (!doc.didDocument ||
                 !doc.didDocument.verificationMethod ||
@@ -41448,7 +41610,8 @@ class Gatekeeper {
             }
             // TBD select the right key here, not just the first one
             const publicJwk = doc.didDocument.verificationMethod[0].publicKeyJwk;
-            return this.cipher.verifySig(msgHash, operation.signature.value, publicJwk);
+            const signatureHex = base64urlToHex(operation.proof.proofValue);
+            return this.cipher.verifySig(msgHash, signatureHex, publicJwk);
         }
         throw new errors.InvalidOperationError(`registration.type=${operation.registration.type}`);
     }
@@ -41456,8 +41619,8 @@ class Gatekeeper {
         if (JSON.stringify(operation).length > this.maxOpBytes) {
             throw new errors.InvalidOperationError('size');
         }
-        if (!this.verifySignatureFormat(operation.signature)) {
-            throw new errors.InvalidOperationError('signature');
+        if (!this.verifyProofFormat(operation.proof)) {
+            throw new errors.InvalidOperationError('proof');
         }
         if (!doc?.didDocument) {
             throw new errors.InvalidOperationError('doc.didDocument');
@@ -41467,26 +41630,24 @@ class Gatekeeper {
         }
         if (doc.didDocument.controller) {
             // This DID is an asset, verify with controller's keys
-            const controllerDoc = await this.resolveDID(doc.didDocument.controller, { confirm: true, versionTime: operation.signature.signed });
+            const controllerDoc = await this.resolveDID(doc.didDocument.controller, { confirm: true, versionTime: operation.proof.created });
             return this.verifyUpdateOperation(operation, controllerDoc);
         }
         if (!doc.didDocument.verificationMethod) {
             throw new errors.InvalidOperationError('doc.didDocument.verificationMethod');
         }
-        const signature = operation.signature;
+        const proof = operation.proof;
         const jsonCopy = copyJSON(operation);
-        delete jsonCopy.signature;
+        delete jsonCopy.proof;
         const msgHash = this.cipher.hashJSON(jsonCopy);
-        if (signature.hash && signature.hash !== msgHash) {
-            return false;
-        }
         if (doc.didDocument.verificationMethod.length === 0 ||
             !doc.didDocument.verificationMethod[0].publicKeyJwk) {
             throw new errors.InvalidOperationError('didDocument missing verificationMethod');
         }
-        // TBD get the right signature, not just the first one
+        // TBD get the right key here, not just the first one
         const publicJwk = doc.didDocument.verificationMethod[0].publicKeyJwk;
-        return this.cipher.verifySig(msgHash, signature.value, publicJwk);
+        const signatureHex = base64urlToHex(proof.proofValue);
+        return this.cipher.verifySig(msgHash, signatureHex, publicJwk);
     }
     async queueOperation(registry, operation) {
         // Don't distribute local DIDs
@@ -41506,7 +41667,7 @@ class Gatekeeper {
     async createDID(operation) {
         const valid = await this.verifyCreateOperation(operation);
         if (!valid) {
-            throw new errors.InvalidOperationError('signature');
+            throw new errors.InvalidOperationError('proof');
         }
         const registry = operation.registration.registry;
         // Reject operations with unsupported registries
@@ -41530,6 +41691,7 @@ class Gatekeeper {
                 did
             });
             await this.queueOperation(registry, operation);
+            await this.updateSearchIndex(did);
             return did;
         });
     }
@@ -41566,6 +41728,9 @@ class Gatekeeper {
                         "authentication": [
                             "#key-1"
                         ],
+                        "assertionMethod": [
+                            "#key-1"
+                        ],
                     },
                     "didDocumentMetadata": {
                         "created": anchor.created,
@@ -41676,14 +41841,14 @@ class Gatekeeper {
                 if (verify) {
                     const valid = await this.verifyCreateOperation(operation);
                     if (!valid) {
-                        throw new errors.InvalidOperationError('signature');
+                        throw new errors.InvalidOperationError('proof');
                     }
                 }
                 doc.didDocumentMetadata = {
                     created,
                     canonicalId,
                     versionId,
-                    version: versionNum.toString(),
+                    versionSequence: versionNum.toString(),
                     confirmed,
                     timestamp,
                 };
@@ -41702,7 +41867,7 @@ class Gatekeeper {
             if (verify) {
                 const valid = await this.verifyUpdateOperation(operation, doc);
                 if (!valid) {
-                    throw new errors.InvalidOperationError('signature');
+                    throw new errors.InvalidOperationError('proof');
                 }
                 if (!operation.previd || operation.previd !== doc.didDocumentMetadata?.versionId) {
                     throw new errors.InvalidOperationError('previd');
@@ -41726,7 +41891,7 @@ class Gatekeeper {
                     updated,
                     canonicalId,
                     versionId,
-                    version: versionNum.toString(),
+                    versionSequence: versionNum.toString(),
                     confirmed,
                     timestamp,
                 };
@@ -41742,7 +41907,7 @@ class Gatekeeper {
                     deleted: updated,
                     canonicalId,
                     versionId,
-                    version: versionNum.toString(),
+                    versionSequence: versionNum.toString(),
                     confirmed,
                     timestamp,
                 };
@@ -41778,13 +41943,14 @@ class Gatekeeper {
             const opid = await this.generateCID(operation, true);
             await this.db.addEvent(operation.did, {
                 registry: 'local',
-                time: operation.signature?.signed || '',
+                time: operation.proof?.created || '',
                 ordinal: [0],
                 operation,
                 opid,
                 did: operation.did
             });
             await this.queueOperation(registry, operation);
+            await this.updateSearchIndex(operation.did);
             return true;
         });
     }
@@ -41853,6 +42019,7 @@ class Gatekeeper {
         }
         for (const did of dids) {
             await this.db.deleteEvents(did);
+            this.searchIndex.delete(did);
         }
         return true;
     }
@@ -41893,7 +42060,7 @@ class Gatekeeper {
                 if (!event.opid) {
                     event.opid = await this.generateCID(event.operation, true);
                 }
-                const opMatch = currentEvents.find(item => item.operation.signature?.value === event.operation.signature?.value);
+                const opMatch = currentEvents.find(item => item.operation.proof?.proofValue === event.operation.proof?.proofValue);
                 if (opMatch) {
                     const index = currentEvents.indexOf(opMatch);
                     const expectedRegistry = expectedRegistryForIndex(currentEvents, index);
@@ -41969,6 +42136,9 @@ class Gatekeeper {
             if (status === ImportStatus.ADDED) {
                 added += 1;
                 console.log(`import ${i}/${total}: added event for ${event.did}`);
+                if (event.did) {
+                    await this.updateSearchIndex(event.did);
+                }
             }
             else if (status === ImportStatus.MERGED) {
                 merged += 1;
@@ -42029,7 +42199,7 @@ class Gatekeeper {
         if (JSON.stringify(operation).length > this.maxOpBytes) {
             return false;
         }
-        if (!this.verifySignatureFormat(operation.signature)) {
+        if (!this.verifyProofFormat(operation.proof)) {
             return false;
         }
         if (operation.type === 'create') {
@@ -42056,7 +42226,9 @@ class Gatekeeper {
             }
             // eslint-disable-next-line
             if (operation.registration.type === 'asset') {
-                if (operation.controller !== operation.signature?.signer) {
+                // Extract controller DID from verificationMethod
+                const [controllerDid] = operation.proof.verificationMethod.split('#');
+                if (operation.controller !== controllerDid) {
                     return false;
                 }
             }
@@ -42098,7 +42270,7 @@ class Gatekeeper {
             const event = batch[i];
             const ok = await this.verifyEvent(event);
             if (ok) {
-                const eventKey = `${event.registry}/${event.operation.signature?.hash}`;
+                const eventKey = `${event.registry}/${event.operation.proof?.proofValue}`;
                 if (!this.eventsSeen[eventKey]) {
                     this.eventsSeen[eventKey] = true;
                     this.eventsQueue.push(event);
@@ -42160,7 +42332,7 @@ class Gatekeeper {
             return false;
         });
         const events = nonlocalDIDs.flat();
-        return events.sort((a, b) => new Date(a.operation.signature?.signed ?? 0).getTime() - new Date(b.operation.signature?.signed ?? 0).getTime());
+        return events.sort((a, b) => new Date(a.operation.proof?.created ?? 0).getTime() - new Date(b.operation.proof?.created ?? 0).getTime());
     }
     async getQueue(registry) {
         if (!ValidRegistries.includes(registry)) {
@@ -42207,6 +42379,15 @@ class Gatekeeper {
     async getJSON(cid) {
         return this.ipfs.getJSON(cid);
     }
+    async searchDocs(q) {
+        return this.searchIndex.searchDocs(q);
+    }
+    async queryDocs(where) {
+        return this.searchIndex.queryDocs(where);
+    }
+    async search(query) {
+        return this.queryDocs(query.where);
+    }
 }
 
 exports.default = Gatekeeper;

package/dist/cjs/index.cjs

@@ -3,7 +3,7 @@
 var gatekeeperClient = require('./gatekeeper-client.cjs');
 var db_jsonMemory = require('./db/json-memory.cjs');
 require('axios');
-require('./abstract-json-BJMq-iEa.cjs');
+require('./abstract-json-DNKwEI6F.cjs');
 require('./errors-DQaog-FG.cjs');
 
 

package/dist/cjs/node.cjs

@@ -11,7 +11,7 @@ var db_mongo = require('./db/mongo.cjs');
 var db_redis = require('./db/redis.cjs');
 var db_sqlite = require('./db/sqlite.cjs');
 require('axios');
-require('./abstract-json-BJMq-iEa.cjs');
+require('./abstract-json-DNKwEI6F.cjs');
 require('./errors-DQaog-FG.cjs');
 require('crypto');
 require('assert');

package/dist/esm/db/abstract-json.js

@@ -138,7 +138,7 @@ export class AbstractJson {
                 if (!oldQueue) {
                     return true;
                 }
-                db.queue[registry] = oldQueue.filter(item => !batch.some(op => op.signature?.value === item.signature?.value));
+                db.queue[registry] = oldQueue.filter(item => !batch.some(op => op.proof?.proofValue === item.proof?.proofValue));
                 this.writeDb(db);
                 return true;
             }