@xyo-network/sdk-js 3.12.3 → 3.12.5

package/packages/modules-mongo/packages/diviner/dist/node/index.mjs

@@ -0,0 +1,1100 @@
+// src/MongoDBAddressHistoryDiviner.ts
+import { assertEx } from "@xylabs/assert";
+import { exists } from "@xylabs/exists";
+import { hexFromHexString } from "@xylabs/hex";
+import {
+  AddressHistoryDiviner,
+  AddressHistoryDivinerConfigSchema,
+  isAddressHistoryQueryPayload
+} from "@xyo-network/diviner-address-history";
+import {
+  DefaultLimit,
+  DefaultMaxTimeMS,
+  MongoDBModuleMixin
+} from "@xyo-network/module-abstract-mongodb";
+import { fromDbRepresentation } from "@xyo-network/payload-mongodb";
+var MongoDBDivinerBase = MongoDBModuleMixin(AddressHistoryDiviner);
+var MongoDBAddressHistoryDiviner = class extends MongoDBDivinerBase {
+  static configSchemas = [...super.configSchemas, AddressHistoryDivinerConfigSchema];
+  static defaultConfigSchema = AddressHistoryDivinerConfigSchema;
+  async divineHandler(payloads) {
+    const query = payloads?.find(isAddressHistoryQueryPayload);
+    if (!query) return [];
+    const { address, limit } = query;
+    const addresses = sanitizeAddress(address);
+    assertEx(addresses, () => "MongoDBAddressHistoryDiviner: Missing address for query");
+    const blocks = await this.getBlocks(addresses, limit || DefaultLimit);
+    return blocks.map(fromDbRepresentation);
+  }
+  async startHandler() {
+    await super.startHandler();
+    await this.ensureIndexes();
+    return true;
+  }
+  getBlocks = async (address, limit) => {
+    let nextHash = void 0;
+    const blocks = [];
+    const defaultFilter = { addresses: address };
+    const sort = { _sequence: -1 };
+    for (let i = 0; i < limit; i++) {
+      let block = void 0;
+      const byDataHash = { ...defaultFilter };
+      if (nextHash) byDataHash._hash = nextHash;
+      const foundByDataHash = (await (await this.boundWitnesses.find(byDataHash)).sort(sort).limit(1).maxTimeMS(DefaultMaxTimeMS).toArray()).pop();
+      if (foundByDataHash) {
+        block = foundByDataHash;
+      } else {
+        const byRootHash = { ...defaultFilter };
+        if (nextHash) byRootHash._dataHash = nextHash;
+        const foundByRootHash = (await (await this.boundWitnesses.find(byRootHash)).sort(sort).limit(1).maxTimeMS(DefaultMaxTimeMS).toArray()).pop();
+        if (foundByRootHash) {
+          block = foundByRootHash;
+        }
+      }
+      if (!block) break;
+      blocks.push(block);
+      const addressIndex = block.addresses.indexOf(address);
+      const previousHash = block.previous_hashes[addressIndex];
+      if (!previousHash) break;
+      nextHash = previousHash;
+    }
+    return blocks;
+  };
+};
+var sanitizeAddress = (a) => {
+  return assertEx(
+    [].concat(a).filter(exists).map((x) => x.toLowerCase()).map((z) => hexFromHexString(z, { prefix: false })).findLast(exists),
+    () => "MongoDBAddressHistoryDiviner: Invalid address"
+  );
+};
+
+// src/MongoDBAddressSpaceBatchDiviner.ts
+import { assertEx as assertEx2 } from "@xylabs/assert";
+import { exists as exists2 } from "@xylabs/exists";
+import { difference, union } from "@xylabs/set";
+import { Account } from "@xyo-network/account";
+import { ArchivistWrapper } from "@xyo-network/archivist-wrapper";
+import { BoundWitnessPointerSchema } from "@xyo-network/boundwitness-model";
+import { AddressSpaceDiviner } from "@xyo-network/diviner-address-space-abstract";
+import { AddressSpaceBatchDivinerConfigSchema } from "@xyo-network/diviner-models";
+import {
+  COLLECTIONS,
+  DATABASES,
+  DefaultMaxTimeMS as DefaultMaxTimeMS2,
+  MongoDBModuleMixin as MongoDBModuleMixin2
+} from "@xyo-network/module-abstract-mongodb";
+import { AddressSchema } from "@xyo-network/module-model";
+import { PayloadBuilder } from "@xyo-network/payload-builder";
+var moduleName = "MongoDBAddressSpaceBatchDiviner";
+var MongoDBDivinerBase2 = MongoDBModuleMixin2(AddressSpaceDiviner);
+var MongoDBAddressSpaceBatchDiviner = class extends MongoDBDivinerBase2 {
+  static configSchemas = [...super.configSchemas, AddressSpaceBatchDivinerConfigSchema];
+  static defaultConfigSchema = AddressSpaceBatchDivinerConfigSchema;
+  // TODO: Get via config or default
+  batchSize = 50;
+  currentlyRunning = false;
+  response;
+  witnessedAddresses = /* @__PURE__ */ new Set();
+  _paginationAccount;
+  async backgroundDivine() {
+    if (this.currentlyRunning) return;
+    try {
+      this.currentlyRunning = true;
+      if (await this.initializeArchivist()) {
+        const result = await this.boundWitnesses.useMongo((db) => {
+          return db.db(DATABASES.Archivist).command(
+            {
+              distinct: COLLECTIONS.BoundWitnesses,
+              key: "addresses"
+            },
+            { maxTimeMS: DefaultMaxTimeMS2 }
+          );
+        });
+        const addresses = new Set(result?.values?.map((address) => address?.toLowerCase()).filter(exists2));
+        const newAddresses = difference(addresses, this.witnessedAddresses);
+        if (newAddresses.size === 0) return;
+        const toStore = [...newAddresses].map((address) => {
+          return { address, schema: AddressSchema };
+        });
+        const archivistMod = await this.archivistInstance();
+        const archivist = ArchivistWrapper.wrap(archivistMod, await this.getPaginationAccount());
+        for (let j = 0; j < toStore.length; j += this.batchSize) {
+          const batch = toStore.slice(j, j + this.batchSize);
+          await archivist.insert(batch);
+        }
+        this.witnessedAddresses = union(this.witnessedAddresses, newAddresses);
+      }
+    } catch (error) {
+      this.logger?.error(`${moduleName}.BackgroundDivine: ${error}`);
+    } finally {
+      this.currentlyRunning = false;
+    }
+  }
+  divineHandler(_payloads) {
+    void this.backgroundDivine();
+    return this.response ? Promise.resolve([this.response]) : Promise.resolve([]);
+  }
+  async getPaginationAccount() {
+    this._paginationAccount = this._paginationAccount ?? await Account.random();
+    return this._paginationAccount;
+  }
+  async initializeArchivist() {
+    try {
+      const archivistMod = await this.archivistInstance();
+      assertEx2(archivistMod, () => `${moduleName}.Start: No archivists found`);
+      const archivist = ArchivistWrapper.wrap(archivistMod, this.account);
+      const divinedAnswerPointer = new PayloadBuilder({ schema: BoundWitnessPointerSchema }).fields({ reference: [[{ address: (await this.getPaginationAccount()).address }], [{ schema: AddressSchema }]] }).build();
+      const divinedAnswerPointerExists = (await archivist.get([await PayloadBuilder.dataHash(divinedAnswerPointer)]))?.length > 0;
+      if (!divinedAnswerPointerExists) await archivist.insert([divinedAnswerPointer]);
+      this.response = divinedAnswerPointer;
+      return true;
+    } catch {
+      this.response = void 0;
+    }
+    return false;
+  }
+  async startHandler() {
+    await super.startHandler();
+    await this.ensureIndexes();
+    void this.backgroundDivine();
+    return true;
+  }
+};
+
+// src/MongoDBAddressSpaceDiviner.ts
+import { exists as exists3 } from "@xylabs/exists";
+import { AddressSpaceDiviner as AddressSpaceDiviner2 } from "@xyo-network/diviner-address-space-abstract";
+import { AddressSpaceDivinerConfigSchema } from "@xyo-network/diviner-models";
+import { DefaultMaxTimeMS as DefaultMaxTimeMS3, MongoDBModuleMixin as MongoDBModuleMixin3 } from "@xyo-network/module-abstract-mongodb";
+import { AddressSchema as AddressSchema2 } from "@xyo-network/module-model";
+var MongoDBDivinerBase3 = MongoDBModuleMixin3(AddressSpaceDiviner2);
+var MongoDBAddressSpaceDiviner = class extends MongoDBDivinerBase3 {
+  static configSchemas = [...super.configSchemas, AddressSpaceDivinerConfigSchema];
+  static defaultConfigSchema = AddressSpaceDivinerConfigSchema;
+  async divineHandler(_payloads) {
+    const result = await this.boundWitnesses.useCollection(async (collection) => {
+      return await collection.distinct("addresses", {}, { maxTimeMS: DefaultMaxTimeMS3 });
+    });
+    const addresses = new Set(result?.map((address) => address?.toLowerCase()).filter(exists3));
+    return [...addresses].map((address) => {
+      return { address, schema: AddressSchema2 };
+    });
+  }
+  async startHandler() {
+    await super.startHandler();
+    await this.ensureIndexes();
+    return true;
+  }
+};
+
+// src/MongoDBBoundWitnessDiviner.ts
+import { flatten } from "@xylabs/array";
+import { exists as exists4 } from "@xylabs/exists";
+import { hexFromHexString as hexFromHexString2 } from "@xylabs/hex";
+import { BoundWitnessDiviner } from "@xyo-network/diviner-boundwitness-abstract";
+import {
+  BoundWitnessDivinerConfigSchema,
+  isBoundWitnessDivinerQueryPayload
+} from "@xyo-network/diviner-boundwitness-model";
+import {
+  DefaultLimit as DefaultLimit2,
+  DefaultMaxTimeMS as DefaultMaxTimeMS4,
+  DefaultOrder,
+  MongoDBModuleMixin as MongoDBModuleMixin4
+} from "@xyo-network/module-abstract-mongodb";
+import {
+  SequenceConstants
+} from "@xyo-network/payload-model";
+import { fromDbRepresentation as fromDbRepresentation2 } from "@xyo-network/payload-mongodb";
+var MongoDBDivinerBase4 = MongoDBModuleMixin4(BoundWitnessDiviner);
+var MongoDBBoundWitnessDiviner = class extends MongoDBDivinerBase4 {
+  static configSchemas = [...super.configSchemas, BoundWitnessDivinerConfigSchema];
+  static defaultConfigSchema = BoundWitnessDivinerConfigSchema;
+  // eslint-disable-next-line complexity
+  async divineHandler(payloads) {
+    const query = payloads?.find(isBoundWitnessDivinerQueryPayload);
+    if (!query) return [];
+    const {
+      address,
+      addresses,
+      destination,
+      limit = DefaultLimit2,
+      cursor = (query.order ?? DefaultOrder) === "asc" ? SequenceConstants.minLocalSequence : SequenceConstants.maxLocalSequence,
+      order = DefaultOrder,
+      payload_hashes,
+      payload_schemas,
+      sourceQuery
+    } = query;
+    const direction = order === "asc" ? 1 : -1;
+    const sort = { _sequence: direction };
+    const filter = {};
+    if (cursor) {
+      filter._sequence = order === "desc" ? { $exists: true, $lt: cursor } : { $exists: true, $gt: cursor };
+    }
+    const allAddresses = flatten(address, addresses).map((x) => hexFromHexString2(x, { prefix: false })).filter(exists4);
+    if (allAddresses.length > 0) filter.addresses = allAddresses.length === 1 ? allAddresses[0] : { $all: allAddresses };
+    if (payload_hashes?.length) filter.payload_hashes = { $in: payload_hashes };
+    if (payload_schemas?.length) filter.payload_schemas = { $all: payload_schemas };
+    if (sourceQuery) filter["_$sourceQuery"] = sourceQuery;
+    if (destination?.length) filter["_$destination"] = { $in: destination };
+    const result = (await (await this.boundWitnesses.find(filter)).sort(sort).limit(limit).maxTimeMS(DefaultMaxTimeMS4).toArray()).map(
+      fromDbRepresentation2
+    );
+    return result;
+  }
+  async startHandler() {
+    await super.startHandler();
+    await this.ensureIndexes();
+    return true;
+  }
+};
+
+// src/MongoDBBoundWitnessStatsDiviner.ts
+import { assertEx as assertEx3 } from "@xylabs/assert";
+import { delay } from "@xylabs/delay";
+import { MongoClientWrapper } from "@xylabs/mongo";
+import { fulfilled, rejected } from "@xylabs/promise";
+import { BoundWitnessStatsDiviner } from "@xyo-network/diviner-boundwitness-stats-abstract";
+import {
+  asDivinerInstance,
+  BoundWitnessStatsDivinerConfigSchema,
+  BoundWitnessStatsDivinerSchema,
+  isBoundWitnessStatsQueryPayload
+} from "@xyo-network/diviner-models";
+import {
+  COLLECTIONS as COLLECTIONS2,
+  DATABASES as DATABASES2,
+  MongoDBModuleMixin as MongoDBModuleMixin5
+} from "@xyo-network/module-abstract-mongodb";
+import { AddressSchema as AddressSchema3 } from "@xyo-network/module-model";
+import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/payload-builder";
+
+// src/JobQueue/defineJobs.ts
+var options = { lockLifetime: 1e4 };
+var defineJobs = (jobQueue, jobs) => {
+  for (const job of jobs) {
+    const { name, task } = job;
+    jobQueue.define(name, options, task);
+    if (job.onComplete) jobQueue.on(`complete:${name}`, job.onComplete);
+    if (job.onFail) jobQueue.on(`fail:${name}`, job.onFail);
+    if (job.onStart) jobQueue.on(`start:${name}`, job.onStart);
+    if (job.onSuccess) jobQueue.on(`success:${name}`, job.onSuccess);
+  }
+};
+
+// src/JobQueue/scheduleJobs.ts
+var scheduleJobs = async (jobQueue, jobs) => {
+  await Promise.all(jobs.map(async (job) => await jobQueue.every(job.schedule, job.name)));
+};
+
+// src/SetIterator/BatchSetIterator.ts
+import {
+  difference as difference2,
+  intersection,
+  union as union2
+} from "@xylabs/set";
+var BatchSetIterator = class {
+  batchSize;
+  done;
+  todo;
+  constructor(values, batchSize) {
+    this.todo = new Set(values);
+    this.done = /* @__PURE__ */ new Set();
+    this.batchSize = batchSize;
+  }
+  [Symbol.iterator]() {
+    return this;
+  }
+  addValues(values) {
+    const incoming = new Set(values);
+    const knownTodo = intersection(this.todo, incoming);
+    const knownDone = intersection(this.done, incoming);
+    const known = union2(knownTodo, knownDone);
+    const unknown = difference2(incoming, known);
+    this.todo = union2(this.todo, unknown);
+    return unknown.size;
+  }
+  next() {
+    if (this.todo.size === 0) {
+      if (this.done.size === 0) {
+        return {
+          done: true,
+          value: []
+        };
+      }
+      this.todo = new Set(this.done);
+      this.done = /* @__PURE__ */ new Set();
+    }
+    const todo = [...this.todo];
+    const batch = todo.slice(0, this.batchSize);
+    const remaining = todo.slice(this.batchSize);
+    this.todo = new Set(remaining);
+    this.done = union2(this.done, new Set(batch));
+    return {
+      done: false,
+      value: batch
+    };
+  }
+};
+
+// src/SetIterator/SetIterator.ts
+import {
+  difference as difference3,
+  intersection as intersection2,
+  union as union3
+} from "@xylabs/set";
+var SetIterator = class {
+  done;
+  todo;
+  constructor(values) {
+    this.todo = new Set(values);
+    this.done = /* @__PURE__ */ new Set();
+  }
+  [Symbol.iterator]() {
+    return this;
+  }
+  addValues(values) {
+    const incoming = new Set(values);
+    const knownTodo = intersection2(this.todo, incoming);
+    const knownDone = intersection2(this.done, incoming);
+    const known = union3(knownTodo, knownDone);
+    const unknown = difference3(incoming, known);
+    this.todo = union3(this.todo, unknown);
+    return unknown.size;
+  }
+  next() {
+    if (this.todo.size === 0) {
+      if (this.done.size === 0) {
+        return {
+          done: true,
+          value: void 0
+        };
+      }
+      this.todo = new Set(this.done);
+      this.done = /* @__PURE__ */ new Set();
+    }
+    const value = this.todo.values().next().value;
+    if (value !== void 0) {
+      this.todo.delete(value);
+      this.done.add(value);
+      return {
+        done: false,
+        value
+      };
+    }
+    return {
+      done: true,
+      value
+    };
+  }
+};
+
+// src/MongoDBBoundWitnessStatsDiviner.ts
+var updateOptions = { upsert: true };
+var MongoDBDivinerBase5 = MongoDBModuleMixin5(BoundWitnessStatsDiviner);
+var moduleName2 = "MongoDBBoundWitnessStatsDiviner";
+var MongoDBBoundWitnessStatsDiviner = class extends MongoDBDivinerBase5 {
+  static configSchemas = [...super.configSchemas, BoundWitnessStatsDivinerConfigSchema];
+  static defaultConfigSchema = BoundWitnessStatsDivinerConfigSchema;
+  /**
+   * Iterates over know addresses obtained from AddressDiviner
+   */
+  addressIterator = new SetIterator([]);
+  /**
+   * The interval at which the background divine task will run. Prevents
+   * continuously iterating over DB and exhausting DB resources
+   */
+  backgroundDivineIntervalMs = 250;
+  /**
+   * A reference to the background task to ensure that the
+   * continuous background divine stays running
+   */
+  backgroundDivineTask;
+  changeStream = void 0;
+  pendingCounts = {};
+  resumeAfter = void 0;
+  get jobs() {
+    return [
+      {
+        name: `${moduleName2}.UpdateChanges`,
+        onSuccess: () => {
+          this.pendingCounts = {};
+        },
+        schedule: "1 minute",
+        task: async () => await this.updateChanges()
+      },
+      {
+        name: `${moduleName2}.DivineAddressesBatch`,
+        schedule: "5 minute",
+        task: async () => await this.divineAddressesBatch()
+      }
+    ];
+  }
+  async divineHandler(payloads) {
+    const query = payloads?.find(isBoundWitnessStatsQueryPayload);
+    const addresses = query?.address ? Array.isArray(query?.address) ? query.address : [query.address] : void 0;
+    const counts = addresses ? await Promise.all(addresses.map((address) => this.divineAddress(address))) : [await this.divineAllAddresses()];
+    return counts.map(
+      (count) => new PayloadBuilder2({ schema: BoundWitnessStatsDivinerSchema }).fields({ count }).build()
+    );
+  }
+  async startHandler() {
+    await super.startHandler();
+    await this.ensureIndexes();
+    await this.registerWithChangeStream();
+    defineJobs(this.jobQueue, this.jobs);
+    this.jobQueue.once("ready", async () => await scheduleJobs(this.jobQueue, this.jobs));
+    return true;
+  }
+  async stopHandler() {
+    await this.changeStream?.close();
+    return await super.stopHandler();
+  }
+  backgroundDivine = async () => {
+    for (const address of this.addressIterator) {
+      try {
+        await this.divineAddressFull(address);
+      } catch (error) {
+        this.logger?.error(`${moduleName2}.BackgroundDivine: ${error}`);
+      }
+      await delay(this.backgroundDivineIntervalMs);
+    }
+    this.backgroundDivineTask = void 0;
+  };
+  divineAddress = async (address) => {
+    const stats = await this.boundWitnesses.useMongo(async (mongo) => {
+      return await mongo.db(DATABASES2.Archivist).collection(COLLECTIONS2.ArchivistStats).findOne({ address });
+    });
+    const remote = stats?.bound_witnesses?.count || 0;
+    const local = this.pendingCounts[address] || 0;
+    return remote + local;
+  };
+  divineAddressFull = async (address) => {
+    const count = await this.boundWitnesses.useCollection((collection) => collection.countDocuments({ addresses: { $in: [address] } }));
+    await this.storeDivinedResult(address, count);
+    return count;
+  };
+  divineAddressesBatch = async () => {
+    this.logger?.log(`${moduleName2}.DivineAddressesBatch: Updating Addresses`);
+    const addressSpaceDiviners = await this.upResolver.resolve(assertEx3("AddressSpaceDiviner"));
+    const addressSpaceDiviner = asDivinerInstance(addressSpaceDiviners, `${moduleName2}.DivineAddressesBatch: Missing AddressSpaceDiviner`);
+    const result = await addressSpaceDiviner.divine([]) || [];
+    const addresses = result.filter((x) => x.schema === AddressSchema3).map((x) => x.address);
+    const additions = this.addressIterator.addValues(addresses);
+    this.logger?.log(`${moduleName2}.DivineAddressesBatch: Incoming Addresses Total: ${addresses.length} New: ${additions}`);
+    if (addresses.length > 0 && !this.backgroundDivineTask) this.backgroundDivineTask = this.backgroundDivine();
+    this.logger?.log(`${moduleName2}.DivineAddressesBatch: Updated Addresses`);
+  };
+  divineAllAddresses = () => this.boundWitnesses.useCollection((collection) => collection.estimatedDocumentCount());
+  processChange = (change) => {
+    this.resumeAfter = change._id;
+    const addresses = change?.fullDocument?.addresses;
+    for (const address of addresses) {
+      if (address) this.pendingCounts[address] = (this.pendingCounts[address] || 0) + 1;
+    }
+  };
+  registerWithChangeStream = async () => {
+    this.logger?.log(`${moduleName2}.RegisterWithChangeStream: Registering`);
+    const wrapper = MongoClientWrapper.get(this.boundWitnesses.uri, this.boundWitnesses.config.maxPoolSize);
+    const connection = await wrapper.connect();
+    assertEx3(connection, () => `${moduleName2}.RegisterWithChangeStream: Connection failed`);
+    const collection = connection.db(DATABASES2.Archivist).collection(COLLECTIONS2.BoundWitnesses);
+    const opts = this.resumeAfter ? { resumeAfter: this.resumeAfter } : {};
+    this.changeStream = collection.watch([], opts);
+    this.changeStream.on("change", this.processChange);
+    this.changeStream.on("error", this.registerWithChangeStream);
+    this.logger?.log(`${moduleName2}.RegisterWithChangeStream: Registered`);
+  };
+  storeDivinedResult = async (address, count) => {
+    await this.boundWitnesses.useMongo(async (mongo) => {
+      await mongo.db(DATABASES2.Archivist).collection(COLLECTIONS2.ArchivistStats).updateOne({ address }, { $set: { [`${COLLECTIONS2.BoundWitnesses}.count`]: count } }, updateOptions);
+    });
+    this.pendingCounts[address] = 0;
+  };
+  updateChanges = async () => {
+    this.logger?.log(`${moduleName2}.UpdateChanges: Updating`);
+    const updates = Object.keys(this.pendingCounts).map((address) => {
+      const count = this.pendingCounts[address];
+      this.pendingCounts[address] = 0;
+      const $inc = { [`${COLLECTIONS2.BoundWitnesses}.count`]: count };
+      return this.boundWitnesses.useMongo(async (mongo) => {
+        await mongo.db(DATABASES2.Archivist).collection(COLLECTIONS2.ArchivistStats).updateOne({ address }, { $inc }, updateOptions);
+      });
+    });
+    const results = await Promise.allSettled(updates);
+    const succeeded = results.filter(fulfilled).length;
+    const failed = results.filter(rejected).length;
+    this.logger?.log(`${moduleName2}.UpdateChanges: Updated - Succeeded: ${succeeded} Failed: ${failed}`);
+  };
+};
+
+// src/MongoDBPayloadDiviner.ts
+import { PayloadDiviner } from "@xyo-network/diviner-payload-abstract";
+import { isPayloadDivinerQueryPayload, PayloadDivinerConfigSchema } from "@xyo-network/diviner-payload-model";
+import {
+  DefaultLimit as DefaultLimit3,
+  DefaultMaxTimeMS as DefaultMaxTimeMS5,
+  DefaultOrder as DefaultOrder2,
+  MongoDBModuleMixin as MongoDBModuleMixin6
+} from "@xyo-network/module-abstract-mongodb";
+import {
+  SequenceConstants as SequenceConstants2
+} from "@xyo-network/payload-model";
+import { fromDbRepresentation as fromDbRepresentation3 } from "@xyo-network/payload-mongodb";
+var MongoDBDivinerBase6 = MongoDBModuleMixin6(PayloadDiviner);
+var MongoDBPayloadDiviner = class extends MongoDBDivinerBase6 {
+  static configSchemas = [...super.configSchemas, PayloadDivinerConfigSchema];
+  static defaultConfigSchema = PayloadDivinerConfigSchema;
+  async divineHandler(payloads) {
+    const query = payloads?.find(isPayloadDivinerQueryPayload);
+    if (!query) throw new Error("Received payload is not a Query");
+    const {
+      limit = DefaultLimit3,
+      cursor = (query.order ?? DefaultOrder2) === "asc" ? SequenceConstants2.minLocalSequence : SequenceConstants2.maxLocalSequence,
+      order = DefaultOrder2,
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      schema,
+      schemas,
+      ...props
+    } = query;
+    const direction = order === "asc" ? 1 : -1;
+    const sort = { _sequence: direction };
+    const filter = {};
+    if (cursor) {
+      filter._sequence = order === "desc" ? { $lt: cursor } : { $gt: cursor };
+    }
+    if (schemas?.length) filter.schema = { $in: schemas };
+    if (Object.keys(props).length > 0) {
+      const additionalFilterCriteria = Object.entries(props);
+      for (const [prop, propFilter] of additionalFilterCriteria) {
+        if (`${prop}`?.startsWith("$")) continue;
+        filter[prop] = Array.isArray(propFilter) ? { $in: propFilter } : propFilter;
+      }
+    }
+    let result;
+    const filtered = await this.payloads.find(filter);
+    result = (await filtered.sort(sort).limit(limit).maxTimeMS(DefaultMaxTimeMS5).toArray()).map(fromDbRepresentation3);
+    return result.map(fromDbRepresentation3);
+  }
+  async startHandler() {
+    await super.startHandler();
+    await this.ensureIndexes();
+    return true;
+  }
+};
+
+// src/MongoDBPayloadStatsDiviner.ts
+import { assertEx as assertEx4 } from "@xylabs/assert";
+import { delay as delay2 } from "@xylabs/delay";
+import { MongoClientWrapper as MongoClientWrapper2 } from "@xylabs/mongo";
+import { fulfilled as fulfilled2, rejected as rejected2 } from "@xylabs/promise";
+import { asDivinerInstance as asDivinerInstance2 } from "@xyo-network/diviner-model";
+import { PayloadStatsDiviner } from "@xyo-network/diviner-payload-stats-abstract";
+import {
+  isPayloadStatsQueryPayload,
+  PayloadStatsDivinerConfigSchema,
+  PayloadStatsDivinerSchema
+} from "@xyo-network/diviner-payload-stats-model";
+import {
+  COLLECTIONS as COLLECTIONS3,
+  DATABASES as DATABASES3,
+  MongoDBModuleMixin as MongoDBModuleMixin7
+} from "@xyo-network/module-abstract-mongodb";
+import { AddressSchema as AddressSchema4 } from "@xyo-network/module-model";
+import { PayloadBuilder as PayloadBuilder3 } from "@xyo-network/payload-builder";
+var updateOptions2 = { upsert: true };
+var MongoDBDivinerBase7 = MongoDBModuleMixin7(PayloadStatsDiviner);
+var moduleName3 = "MongoDBPayloadStatsDiviner";
+var MongoDBPayloadStatsDiviner = class extends MongoDBDivinerBase7 {
+  static configSchemas = [...super.configSchemas, PayloadStatsDivinerConfigSchema];
+  static defaultConfigSchema = PayloadStatsDivinerConfigSchema;
+  /**
+   * Iterates over know addresses obtained from AddressDiviner
+   */
+  addressIterator = new SetIterator([]);
+  /**
+   * The max number of records to search during the aggregate query
+   */
+  aggregateLimit = 1e3;
+  /**
+   * The max number of iterations of aggregate queries to allow when
+   * divining the schema stats for a single address
+   */
+  aggregateMaxIterations = 1e6;
+  /**
+   * The amount of time to allow the aggregate query to execute
+   */
+  aggregateTimeoutMs = 1e4;
+  /**
+   * The interval at which the background divine task will run. Prevents
+   * continuously iterating over DB and exhausting DB resources
+   */
+  backgroundDivineIntervalMs = 250;
+  /**
+   * A reference to the background task to ensure that the
+   * continuous background divine stays running
+   */
+  backgroundDivineTask;
+  changeStream = void 0;
+  pendingCounts = {};
+  resumeAfter = void 0;
+  get jobs() {
+    return [
+      {
+        name: `${moduleName3}.UpdateChanges`,
+        onSuccess: () => {
+          this.pendingCounts = {};
+        },
+        schedule: "1 minute",
+        task: async () => await this.updateChanges()
+      },
+      {
+        name: `${moduleName3}.DivineAddressesBatch`,
+        schedule: "5 minute",
+        task: async () => await this.divineAddressesBatch()
+      }
+    ];
+  }
+  async divineHandler(payloads) {
+    const query = payloads?.find(isPayloadStatsQueryPayload);
+    const addresses = query?.address ? Array.isArray(query?.address) ? query.address : [query.address] : void 0;
+    const counts = addresses ? await Promise.all(addresses.map((address) => this.divineAddress(address))) : [await this.divineAllAddresses()];
+    return await Promise.all(
+      counts.map((count) => new PayloadBuilder3({ schema: PayloadStatsDivinerSchema }).fields({ count }).build())
+    );
+  }
+  async startHandler() {
+    await super.startHandler();
+    await this.ensureIndexes();
+    await this.registerWithChangeStream();
+    defineJobs(this.jobQueue, this.jobs);
+    this.jobQueue.once("ready", async () => await scheduleJobs(this.jobQueue, this.jobs));
+    return true;
+  }
+  async stopHandler() {
+    await this.changeStream?.close();
+    return await super.stopHandler();
+  }
+  backgroundDivine = async () => {
+    for (const address of this.addressIterator) {
+      try {
+        await this.divineAddressFull(address);
+      } catch (error) {
+        this.logger?.error(`${moduleName3}.BackgroundDivine: ${error}`);
+      }
+      await delay2(this.backgroundDivineIntervalMs);
+    }
+    this.backgroundDivineTask = void 0;
+  };
+  divineAddress = async (address) => {
+    const stats = await this.payloads.useMongo(async (mongo) => {
+      return await mongo.db(DATABASES3.Archivist).collection(COLLECTIONS3.ArchivistStats).findOne({ address });
+    });
+    const remote = stats?.payloads?.count || 0;
+    const local = this.pendingCounts[address] || 0;
+    return remote + local;
+  };
+  divineAddressFull = async (address) => {
+    let total = 0;
+    for (let iteration = 0; iteration < this.aggregateMaxIterations; iteration++) {
+      const count = await this.boundWitnesses.useCollection((collection) => {
+        return collection.aggregate([
+          { $sort: { _timestamp: -1, addresses: 1 } },
+          // Find all BoundWitnesses containing this address
+          { $match: { addresses: { $in: [address] } } },
+          // In batches
+          { $skip: iteration * this.aggregateLimit },
+          { $limit: this.aggregateLimit },
+          // Flatten the payload_hashes to individual documents
+          { $unwind: { path: "$payload_hashes" } },
+          // Count all the payload hashes witnessed for this address
+          { $count: "payload_hashes" }
+        ]).maxTimeMS(this.aggregateTimeoutMs).next();
+      });
+      if (count != null) {
+        total += count.payload_hashes;
+        continue;
+      }
+      break;
+    }
+    await this.storeDivinedResult(address, total);
+    return total;
+  };
+  divineAddressesBatch = async () => {
+    this.logger?.log(`${moduleName3}.DivineAddressesBatch: Updating Addresses`);
+    const addressSpaceDiviners = await this.upResolver.resolve("AddressSpaceDiviner");
+    const addressSpaceDiviner = asDivinerInstance2(addressSpaceDiviners, `${moduleName3}.DivineAddressesBatch: Missing AddressSpaceDiviner`);
+    const result = await addressSpaceDiviner.divine() ?? [];
+    const addresses = result.filter((x) => x.schema === AddressSchema4).map((x) => x.address);
+    const additions = this.addressIterator.addValues(addresses);
+    this.logger?.log(`${moduleName3}.DivineAddressesBatch: Incoming Addresses Total: ${addresses.length} New: ${additions}`);
+    if (addresses.length > 0 && !this.backgroundDivineTask) this.backgroundDivineTask = this.backgroundDivine();
+    this.logger?.log(`${moduleName3}.DivineAddressesBatch: Updated Addresses`);
+  };
+  divineAllAddresses = () => this.payloads.useCollection((collection) => collection.estimatedDocumentCount());
+  processChange = (change) => {
+    this.resumeAfter = change._id;
+    const addresses = change.fullDocument.addresses;
+    const count = change.fullDocument?.payload_hashes?.length || 0;
+    if (addresses?.length && count) {
+      for (const address of addresses) {
+        if (address) this.pendingCounts[address] = (this.pendingCounts[address] || 0) + count;
+      }
+    }
+  };
+  registerWithChangeStream = async () => {
+    this.logger?.log(`${moduleName3}.RegisterWithChangeStream: Registering`);
+    const wrapper = MongoClientWrapper2.get(this.boundWitnesses.uri, this.boundWitnesses.config.maxPoolSize);
+    const connection = await wrapper.connect();
+    assertEx4(connection, () => `${moduleName3}.RegisterWithChangeStream: Connection failed`);
+    const collection = connection.db(DATABASES3.Archivist).collection(COLLECTIONS3.BoundWitnesses);
+    const opts = this.resumeAfter ? { resumeAfter: this.resumeAfter } : {};
+    this.changeStream = collection.watch([], opts);
+    this.changeStream.on("change", this.processChange);
+    this.changeStream.on("error", this.registerWithChangeStream);
+    this.logger?.log(`${moduleName3}.RegisterWithChangeStream: Registered`);
+  };
+  storeDivinedResult = async (address, count) => {
+    await this.payloads.useMongo(async (mongo) => {
+      await mongo.db(DATABASES3.Archivist).collection(COLLECTIONS3.ArchivistStats).updateOne({ address }, { $set: { [`${COLLECTIONS3.Payloads}.count`]: count } }, updateOptions2);
+    });
+    this.pendingCounts[address] = 0;
+  };
+  updateChanges = async () => {
+    this.logger?.log(`${moduleName3}.UpdateChanges: Updating`);
+    const updates = Object.keys(this.pendingCounts).map((address) => {
+      const count = this.pendingCounts[address];
+      this.pendingCounts[address] = 0;
+      const $inc = { [`${COLLECTIONS3.Payloads}.count`]: count };
+      return this.payloads.useMongo(async (mongo) => {
+        await mongo.db(DATABASES3.Archivist).collection(COLLECTIONS3.ArchivistStats).updateOne({ address }, { $inc }, updateOptions2);
+      });
+    });
+    const results = await Promise.allSettled(updates);
+    const succeeded = results.filter(fulfilled2).length;
+    const failed = results.filter(rejected2).length;
+    this.logger?.log(`${moduleName3}.UpdateChanges: Updated - Succeeded: ${succeeded} Failed: ${failed}`);
+  };
+};
+
+// src/MongoDBSchemaListDiviner.ts
+import { SchemaListDiviner } from "@xyo-network/diviner-schema-list-abstract";
+import {
+  isSchemaListQueryPayload,
+  SchemaListDivinerConfigSchema,
+  SchemaListDivinerSchema
+} from "@xyo-network/diviner-schema-list-model";
+import { MongoDBModuleMixin as MongoDBModuleMixin8 } from "@xyo-network/module-abstract-mongodb";
+import { PayloadBuilder as PayloadBuilder4 } from "@xyo-network/payload-builder";
+import {
+  isSchema
+} from "@xyo-network/payload-model";
+var MongoDBDivinerBase8 = MongoDBModuleMixin8(SchemaListDiviner);
+var MongoDBSchemaListDiviner = class extends MongoDBDivinerBase8 {
+  static configSchemas = [...super.configSchemas, SchemaListDivinerConfigSchema];
+  static defaultConfigSchema = SchemaListDivinerConfigSchema;
+  async divineHandler(payloads) {
+    const query = payloads?.find(isSchemaListQueryPayload);
+    const addresses = query?.address ? Array.isArray(query?.address) ? query.address : [query.address] : void 0;
+    const counts = addresses ? await Promise.all(addresses.map((address) => this.divineAddress(address))) : [await this.divineAllAddresses()];
+    return await Promise.all(
+      counts.map((schemas) => new PayloadBuilder4({ schema: SchemaListDivinerSchema }).fields({ schemas }).build())
+    );
+  }
+  async startHandler() {
+    await super.startHandler();
+    await this.ensureIndexes();
+    return true;
+  }
+  divineAddress = async (archive) => {
+    const result = await this.boundWitnesses.useCollection((collection) => {
+      return collection.distinct("payload_schemas", { addresses: { $in: [archive] } });
+    });
+    return result.filter(isSchema);
+  };
+  divineAllAddresses = async () => {
+    const result = await this.boundWitnesses.useCollection((collection) => {
+      return collection.distinct("payload_schemas");
+    });
+    return result.filter(isSchema);
+  };
+};
+
+// src/MongoDBSchemaStatsDiviner.ts
+import { assertEx as assertEx5 } from "@xylabs/assert";
+import { delay as delay3 } from "@xylabs/delay";
+import { MongoClientWrapper as MongoClientWrapper3 } from "@xylabs/mongo";
+import { fulfilled as fulfilled3, rejected as rejected3 } from "@xylabs/promise";
+import { asDivinerInstance as asDivinerInstance3 } from "@xyo-network/diviner-model";
+import { SchemaStatsDiviner } from "@xyo-network/diviner-schema-stats-abstract";
+import {
+  isSchemaStatsQueryPayload,
+  SchemaStatsDivinerConfigSchema,
+  SchemaStatsDivinerSchema
+} from "@xyo-network/diviner-schema-stats-model";
+import {
+  COLLECTIONS as COLLECTIONS4,
+  DATABASES as DATABASES4,
+  fromDbProperty,
+  MongoDBModuleMixin as MongoDBModuleMixin9,
+  toDbProperty
+} from "@xyo-network/module-abstract-mongodb";
+import { AddressSchema as AddressSchema5 } from "@xyo-network/module-model";
+import { PayloadBuilder as PayloadBuilder5 } from "@xyo-network/payload-builder";
+var updateOptions3 = { upsert: true };
+var MongoDBDivinerBase9 = MongoDBModuleMixin9(SchemaStatsDiviner);
+var moduleName4 = "MongoDBSchemaStatsDiviner";
+var MongoDBSchemaStatsDiviner = class extends MongoDBDivinerBase9 {
+  static configSchemas = [...super.configSchemas, SchemaStatsDivinerConfigSchema];
+  static defaultConfigSchema = SchemaStatsDivinerConfigSchema;
+  /**
+   * Iterates over know addresses obtained from AddressDiviner
+   */
+  addressIterator = new SetIterator([]);
+  /**
+   * The max number of records to search during the aggregate query
+   */
+  aggregateLimit = 1e3;
+  /**
+   * The max number of iterations of aggregate queries to allow when
+   * divining the schema stats for a single address
+   */
+  aggregateMaxIterations = 1e6;
+  /**
+   * The amount of time to allow the aggregate query to execute
+   */
+  aggregateTimeoutMs = 1e4;
+  /**
+   * The interval at which the background divine task will run. Prevents
+   * continuously iterating over DB and exhausting DB resources
+   */
+  backgroundDivineIntervalMs = 250;
+  /**
+   * A reference to the background task to ensure that the
+   * continuous background divine stays running
+   */
+  backgroundDivineTask;
+  /**
+   * The stream with which the diviner is notified of insertions
+   * to the payloads collection
+   */
+  changeStream = void 0;
+  /**
+   * The counts per schema to update on the next update interval
+   */
+  pendingCounts = {};
+  /**
+   * The resume token for listening to insertions into the payload collection
+   */
+  resumeAfter = void 0;
+  get jobs() {
+    return [
+      {
+        name: `${moduleName4}.UpdateChanges`,
+        onSuccess: () => {
+          this.pendingCounts = {};
+        },
+        schedule: "1 minute",
+        task: async () => await this.updateChanges()
+      },
+      {
+        name: `${moduleName4}.DivineAddressesBatch`,
+        schedule: "5 minute",
+        task: async () => await this.divineAddressesBatch()
+      }
+    ];
+  }
+  async divineHandler(payloads) {
+    const query = payloads?.find(isSchemaStatsQueryPayload);
+    const addresses = query?.address ? Array.isArray(query?.address) ? query.address : [query.address] : void 0;
+    const counts = addresses ? await Promise.all(addresses.map((address) => this.divineAddress(address))) : [this.divineAllAddresses()];
+    return await Promise.all(
+      counts.map((count) => new PayloadBuilder5({ schema: SchemaStatsDivinerSchema }).fields({ count }).build())
+    );
+  }
+  async startHandler() {
+    await super.startHandler();
+    await this.ensureIndexes();
+    await this.registerWithChangeStream();
+    defineJobs(this.jobQueue, this.jobs);
+    this.jobQueue.once("ready", async () => await scheduleJobs(this.jobQueue, this.jobs));
+    return true;
+  }
+  async stopHandler() {
+    await this.changeStream?.close();
+    return await super.stopHandler();
+  }
+  backgroundDivine = async () => {
+    for (const address of this.addressIterator) {
+      try {
+        await this.divineAddressFull(address);
+      } catch (error) {
+        this.logger?.error(`${moduleName4}.BackgroundDivine: ${error}`);
+      }
+      await delay3(this.backgroundDivineIntervalMs);
+    }
+    this.backgroundDivineTask = void 0;
+  };
+  divineAddress = async (address) => {
+    const stats = await this.boundWitnesses.useMongo(async (mongo) => {
+      return await mongo.db(DATABASES4.Archivist).collection(COLLECTIONS4.ArchivistStats).findOne({ address });
+    });
+    const remote = Object.fromEntries(
+      Object.entries(stats?.schema?.count || {}).map(([schema, count]) => {
+        return [fromDbProperty(schema), count];
+      })
+    );
+    const local = this.pendingCounts[address] || {};
+    const keys = [...Object.keys(local), ...Object.keys(remote).map(fromDbProperty)];
+    const ret = Object.fromEntries(
+      keys.map((key) => {
+        const localSchemaCount = local[key] || 0;
+        const remoteSchemaCount = remote[key] || 0;
+        const value = localSchemaCount + remoteSchemaCount;
+        return [key, value];
+      })
+    );
+    return ret;
+  };
+  divineAddressFull = async (address) => {
+    const sortStartTime = Date.now();
+    const totals = {};
+    for (let iteration = 0; iteration < this.aggregateMaxIterations; iteration++) {
+      const result = await this.boundWitnesses.useCollection((collection) => {
+        return collection.aggregate().sort({ _timestamp: 1 }).match({ _timestamp: { $lt: sortStartTime }, addresses: { $in: [address] } }).skip(iteration * this.aggregateLimit).limit(this.aggregateLimit).unwind({ path: "$payload_schemas" }).group({ _id: "$payload_schemas", count: { $sum: 1 } }).maxTimeMS(this.aggregateTimeoutMs).toArray();
+      });
+      if (result.length === 0) break;
+      for (const schema of result) {
+        totals[schema._id] = totals[schema._id] || 0 + schema.count;
+      }
+    }
+    await this.storeDivinedResult(address, totals);
+    return totals;
+  };
+  divineAddressesBatch = async () => {
+    this.logger?.log(`${moduleName4}.DivineAddressesBatch: Updating Addresses`);
+    const addressSpaceDiviners = await this.upResolver.resolve("AddressSpaceDiviner");
+    const addressSpaceDiviner = asDivinerInstance3(addressSpaceDiviners, `${moduleName4}.DivineAddressesBatch: Missing AddressSpaceDiviner`);
+    const result = await addressSpaceDiviner.divine() ?? [];
+    const addresses = result.filter((x) => x.schema === AddressSchema5).map((x) => x.address);
+    const additions = this.addressIterator.addValues(addresses);
+    this.logger?.log(`${moduleName4}.DivineAddressesBatch: Incoming Addresses Total: ${addresses.length} New: ${additions}`);
+    if (addresses.length > 0 && !this.backgroundDivineTask) this.backgroundDivineTask = this.backgroundDivine();
+    this.logger?.log(`${moduleName4}.DivineAddressesBatch: Updated Addresses`);
+  };
+  divineAllAddresses = () => {
+    throw new Error("Not Implemented");
+  };
+  processChange = (change) => {
+    this.resumeAfter = change._id;
+    const addresses = change.fullDocument.addresses;
+    const schemas = change.fullDocument.payload_schemas;
+    if (addresses?.length) {
+      for (const address of addresses) {
+        for (const schema of schemas) {
+          if (!this.pendingCounts[address]) this.pendingCounts[address] = {};
+          this.pendingCounts[address][schema] = (this.pendingCounts[address][schema] || 0) + 1;
+        }
+      }
+    }
+  };
+  registerWithChangeStream = async () => {
+    this.logger?.log(`${moduleName4}.RegisterWithChangeStream: Registering`);
+    const wrapper = MongoClientWrapper3.get(this.boundWitnesses.uri, this.boundWitnesses.config.maxPoolSize);
+    const connection = await wrapper.connect();
+    assertEx5(connection, () => `${moduleName4}.RegisterWithChangeStream: Connection failed`);
+    const collection = connection.db(DATABASES4.Archivist).collection(COLLECTIONS4.BoundWitnesses);
+    const opts = this.resumeAfter ? { resumeAfter: this.resumeAfter } : {};
+    this.changeStream = collection.watch([], opts);
+    this.changeStream.on("change", this.processChange);
+    this.changeStream.on("error", this.registerWithChangeStream);
+    this.logger?.log(`${moduleName4}.RegisterWithChangeStream: Registered`);
+  };
+  storeDivinedResult = async (address, counts) => {
+    const sanitizedCounts = Object.fromEntries(
+      Object.entries(counts).map(([schema, count]) => {
+        return [toDbProperty(schema), count];
+      })
+    );
+    await this.boundWitnesses.useMongo(async (mongo) => {
+      await mongo.db(DATABASES4.Archivist).collection(COLLECTIONS4.ArchivistStats).updateOne({ address }, { $set: { ["schema.count"]: sanitizedCounts } }, updateOptions3);
+    });
+    this.pendingCounts[address] = {};
+  };
+  updateChanges = async () => {
+    this.logger?.log(`${moduleName4}.UpdateChanges: Updating`);
+    const updates = Object.keys(this.pendingCounts).map((address) => {
+      const $inc = Object.keys(this.pendingCounts[address]).map((schema) => {
+        return { [`schema.count.${toDbProperty(schema)}`]: this.pendingCounts[address][schema] };
+      }).reduce((prev, curr) => Object.assign(prev, curr), {});
+      this.pendingCounts[address] = {};
+      return this.boundWitnesses.useMongo(async (mongo) => {
+        await mongo.db(DATABASES4.Archivist).collection(COLLECTIONS4.ArchivistStats).updateOne({ address }, { $inc }, updateOptions3);
+      });
+    });
+    const results = await Promise.allSettled(updates);
+    const succeeded = results.filter(fulfilled3).length;
+    const failed = results.filter(rejected3).length;
+    this.logger?.log(`${moduleName4}.UpdateChanges: Updated - Succeeded: ${succeeded} Failed: ${failed}`);
+  };
+};
+
+// src/UserLocationsDiviner.ts
+import "reflect-metadata";
+import { assertEx as assertEx6 } from "@xylabs/assert";
+import { compact } from "@xylabs/lodash";
+import { ArchivistPayloadDivinerConfigSchema } from "@xyo-network/diviner-archivist";
+import { BoundWitnessDivinerQuerySchema } from "@xyo-network/diviner-boundwitness-model";
+import { CoinUserLocationsDiviner } from "@xyo-network/diviner-coin-user-locations-abstract";
+import { LocationSchema } from "@xyo-network/location-payload-plugin";
+import { PayloadWrapper } from "@xyo-network/payload-wrapper";
+var CoinCurrentUserWitnessSchema = "co.coinapp.current.user.witness";
+var CoinCurrentLocationWitnessSchema = "co.coinapp.current.location.witness";
+var isLocationPayload = (x) => x?.schema === LocationSchema;
+var MemoryCoinUserLocationsDiviner = class extends CoinUserLocationsDiviner {
+  static configSchemas = [...super.configSchemas, ArchivistPayloadDivinerConfigSchema];
+  static defaultConfigSchema = ArchivistPayloadDivinerConfigSchema;
+  async divineHandler(payloads) {
+    const user = payloads?.find(
+      (payload) => payload?.schema === CoinCurrentUserWitnessSchema
+    );
+    if (user) {
+      const wrapper = PayloadWrapper.wrap(user);
+      this.logger?.log("CoinUserLocationsDiviner.Divine: Processing query");
+      const diviner = this.params.bws;
+      const filter = { payload_hashes: [await wrapper.dataHash()], schema: BoundWitnessDivinerQuerySchema };
+      const bwList = await diviner.divine([filter]) || [];
+      const locationHashes = bwList.flatMap((bw) => {
+        const locations2 = [];
+        for (let i = 0; i < bwList.length; i++) {
+          if (bw?.payload_schemas[i] === CoinCurrentLocationWitnessSchema) {
+            locations2.push(assertEx6(bw?.payload_hashes[i], () => "Missing hash"));
+          }
+        }
+        return locations2;
+      });
+      const locations = compact(await this.params.archivist.get(locationHashes));
+      this.logger?.log("CoinUserLocationsDiviner.Divine: Processed query");
+      return locations;
+    }
+    return [];
+  }
+};
+export {
+  BatchSetIterator,
+  CoinCurrentLocationWitnessSchema,
+  CoinCurrentUserWitnessSchema,
+  MemoryCoinUserLocationsDiviner,
+  MongoDBAddressHistoryDiviner,
+  MongoDBAddressSpaceBatchDiviner,
+  MongoDBAddressSpaceDiviner,
+  MongoDBBoundWitnessDiviner,
+  MongoDBBoundWitnessStatsDiviner,
+  MongoDBPayloadDiviner,
+  MongoDBPayloadStatsDiviner,
+  MongoDBSchemaListDiviner,
+  MongoDBSchemaStatsDiviner,
+  SetIterator,
+  isLocationPayload
+};
+//# sourceMappingURL=index.mjs.map