@prosopo/database 3.0.8 → 3.0.10

package/dist/databases/provider.js

@@ -1,1073 +1,1278 @@
 import { isHex } from "@polkadot/util/is";
 import { ProsopoDBError } from "@prosopo/common";
-import { ApiParams, CaptchaStates, CaptchaStatus, DatasetWithIdsAndTreeSchema, StoredStatusNames, } from "@prosopo/types";
-import { CaptchaRecordSchema, ClientRecordSchema, DatasetRecordSchema, DetectorRecordSchema, FrictionlessTokenRecordSchema, PendingRecordSchema, PoWCaptchaRecordSchema, ScheduledTaskRecordSchema, ScheduledTaskSchema, SessionRecordSchema, SolutionRecordSchema, UserCommitmentRecordSchema, UserCommitmentSchema, UserSolutionRecordSchema, } from "@prosopo/types-database";
-import { createRedisAccessRulesIndex, createRedisAccessRulesStorage, } from "@prosopo/user-access-policy";
+import { DatasetWithIdsAndTreeSchema, StoredStatusNames, CaptchaStatus, ApiParams, CaptchaStates } from "@prosopo/types";
+import { CaptchaRecordSchema, PoWCaptchaRecordSchema, DatasetRecordSchema, SolutionRecordSchema, UserCommitmentRecordSchema, UserSolutionRecordSchema, PendingRecordSchema, ScheduledTaskRecordSchema, ClientRecordSchema, FrictionlessTokenRecordSchema, SessionRecordSchema, DetectorRecordSchema, UserCommitmentSchema, ScheduledTaskSchema } from "@prosopo/types-database";
+import { createRedisAccessRulesIndex, createRedisAccessRulesStorage } from "@prosopo/user-access-policy";
 import { createClient } from "redis";
 import { MongoDatabase } from "../base/mongo.js";
-var TableNames;
-(function (TableNames) {
-    TableNames["captcha"] = "captcha";
-    TableNames["dataset"] = "dataset";
-    TableNames["solution"] = "solution";
-    TableNames["commitment"] = "commitment";
-    TableNames["usersolution"] = "usersolution";
-    TableNames["pending"] = "pending";
-    TableNames["scheduler"] = "scheduler";
-    TableNames["powcaptcha"] = "powcaptcha";
-    TableNames["client"] = "client";
-    TableNames["frictionlessToken"] = "frictionlessToken";
-    TableNames["session"] = "session";
-    TableNames["detector"] = "detector";
-})(TableNames || (TableNames = {}));
+var TableNames = /* @__PURE__ */ ((TableNames2) => {
+  TableNames2["captcha"] = "captcha";
+  TableNames2["dataset"] = "dataset";
+  TableNames2["solution"] = "solution";
+  TableNames2["commitment"] = "commitment";
+  TableNames2["usersolution"] = "usersolution";
+  TableNames2["pending"] = "pending";
+  TableNames2["scheduler"] = "scheduler";
+  TableNames2["powcaptcha"] = "powcaptcha";
+  TableNames2["client"] = "client";
+  TableNames2["frictionlessToken"] = "frictionlessToken";
+  TableNames2["session"] = "session";
+  TableNames2["detector"] = "detector";
+  return TableNames2;
+})(TableNames || {});
 const PROVIDER_TABLES = [
-    {
-        collectionName: TableNames.captcha,
-        modelName: "Captcha",
-        schema: CaptchaRecordSchema,
-    },
-    {
-        collectionName: TableNames.powcaptcha,
-        modelName: "PowCaptcha",
-        schema: PoWCaptchaRecordSchema,
-    },
-    {
-        collectionName: TableNames.dataset,
-        modelName: "Dataset",
-        schema: DatasetRecordSchema,
-    },
-    {
-        collectionName: TableNames.solution,
-        modelName: "Solution",
-        schema: SolutionRecordSchema,
-    },
-    {
-        collectionName: TableNames.commitment,
-        modelName: "UserCommitment",
-        schema: UserCommitmentRecordSchema,
-    },
-    {
-        collectionName: TableNames.usersolution,
-        modelName: "UserSolution",
-        schema: UserSolutionRecordSchema,
-    },
-    {
-        collectionName: TableNames.pending,
-        modelName: "Pending",
-        schema: PendingRecordSchema,
-    },
-    {
-        collectionName: TableNames.scheduler,
-        modelName: "Scheduler",
-        schema: ScheduledTaskRecordSchema,
-    },
-    {
-        collectionName: TableNames.client,
-        modelName: "Client",
-        schema: ClientRecordSchema,
-    },
-    {
-        collectionName: TableNames.frictionlessToken,
-        modelName: "FrictionlessToken",
-        schema: FrictionlessTokenRecordSchema,
-    },
-    {
-        collectionName: TableNames.session,
-        modelName: "Session",
-        schema: SessionRecordSchema,
-    },
-    {
-        collectionName: TableNames.detector,
-        modelName: "Detector",
-        schema: DetectorRecordSchema,
-    },
+  {
+    collectionName: "captcha",
+    modelName: "Captcha",
+    schema: CaptchaRecordSchema
+  },
+  {
+    collectionName: "powcaptcha",
+    modelName: "PowCaptcha",
+    schema: PoWCaptchaRecordSchema
+  },
+  {
+    collectionName: "dataset",
+    modelName: "Dataset",
+    schema: DatasetRecordSchema
+  },
+  {
+    collectionName: "solution",
+    modelName: "Solution",
+    schema: SolutionRecordSchema
+  },
+  {
+    collectionName: "commitment",
+    modelName: "UserCommitment",
+    schema: UserCommitmentRecordSchema
+  },
+  {
+    collectionName: "usersolution",
+    modelName: "UserSolution",
+    schema: UserSolutionRecordSchema
+  },
+  {
+    collectionName: "pending",
+    modelName: "Pending",
+    schema: PendingRecordSchema
+  },
+  {
+    collectionName: "scheduler",
+    modelName: "Scheduler",
+    schema: ScheduledTaskRecordSchema
+  },
+  {
+    collectionName: "client",
+    modelName: "Client",
+    schema: ClientRecordSchema
+  },
+  {
+    collectionName: "frictionlessToken",
+    modelName: "FrictionlessToken",
+    schema: FrictionlessTokenRecordSchema
+  },
+  {
+    collectionName: "session",
+    modelName: "Session",
+    schema: SessionRecordSchema
+  },
+  {
+    collectionName: "detector",
+    modelName: "Detector",
+    schema: DetectorRecordSchema
+  }
 ];
-export class ProviderDatabase extends MongoDatabase {
-    constructor(options) {
-        super(options.mongo.url, options.mongo.dbname, options.mongo.authSource, options.logger);
-        this.options = options;
-        this.tables = {};
-        this.tables = {};
-        this.userAccessRulesStorage = null;
+class ProviderDatabase extends MongoDatabase {
+  constructor(options) {
+    super(
+      options.mongo.url,
+      options.mongo.dbname,
+      options.mongo.authSource,
+      options.logger
+    );
+    this.options = options;
+    this.tables = {};
+    this.tables = {};
+    this.userAccessRulesStorage = null;
+  }
+  async connect() {
+    await super.connect();
+    this.loadTables();
+    await this.setupRedis();
+  }
+  async setupRedis() {
+    const redisClient = await this.createRedisClient();
+    await createRedisAccessRulesIndex(redisClient);
+    this.userAccessRulesStorage = createRedisAccessRulesStorage(
+      redisClient,
+      this.logger
+    );
+  }
+  async createRedisClient() {
+    return await createClient({
+      url: this.options.redis?.url,
+      password: this.options.redis?.password
+    }).on("error", (error) => {
+      this.logger.error(() => ({
+        err: error,
+        msg: "Redis client error"
+      }));
+    }).connect();
+  }
+  loadTables() {
+    const tables = {};
+    PROVIDER_TABLES.map(({ collectionName, modelName, schema }) => {
+      if (this.connection) {
+        tables[collectionName] = this.connection.model(modelName, schema);
+      }
+    });
+    this.tables = tables;
+  }
+  getTables() {
+    if (!this.tables) {
+      throw new ProsopoDBError("DATABASE.TABLES_UNDEFINED", {
+        context: { failedFuncName: this.getTables.name },
+        logger: this.logger
+      });
     }
-    async connect() {
-        await super.connect();
-        this.loadTables();
-        await this.setupRedis();
+    return this.tables;
+  }
+  getUserAccessRulesStorage() {
+    if (null === this.userAccessRulesStorage) {
+      throw new ProsopoDBError("DATABASE.USER_ACCESS_RULES_STORAGE_UNDEFINED");
     }
-    async setupRedis() {
-        const redisClient = await this.createRedisClient();
-        await createRedisAccessRulesIndex(redisClient);
-        this.userAccessRulesStorage = createRedisAccessRulesStorage(redisClient, this.logger);
-    }
-    async createRedisClient() {
-        return (await createClient({
-            url: this.options.redis?.url,
-            password: this.options.redis?.password,
-        })
-            .on("error", (error) => {
-            this.logger.error(() => ({
-                err: error,
-                msg: "Redis client error",
-            }));
+    return this.userAccessRulesStorage;
+  }
+  /**
+   * @description Load a dataset to the database
+   * @param {Dataset}  dataset
+   */
+  async storeDataset(dataset) {
+    try {
+      this.logger.debug(() => ({
+        data: { datasetId: dataset.datasetId },
+        msg: "Storing dataset in database"
+      }));
+      const parsedDataset = DatasetWithIdsAndTreeSchema.parse(dataset);
+      const datasetDoc = {
+        datasetId: parsedDataset.datasetId,
+        datasetContentId: parsedDataset.datasetContentId,
+        format: parsedDataset.format,
+        contentTree: parsedDataset.contentTree,
+        solutionTree: parsedDataset.solutionTree
+      };
+      const filter = {
+        datasetId: parsedDataset.datasetId
+      };
+      await this.tables.dataset?.updateOne(
+        filter,
+        { $set: datasetDoc },
+        { upsert: true }
+      );
+      const captchaDocs = parsedDataset.captchas.map(
+        ({ solution, ...captcha }, index) => ({
+          ...captcha,
+          datasetId: parsedDataset.datasetId,
+          datasetContentId: parsedDataset.datasetContentId,
+          index,
+          solved: !!solution?.length
         })
-            .connect());
-    }
-    loadTables() {
-        const tables = {};
-        PROVIDER_TABLES.map(({ collectionName, modelName, schema }) => {
-            if (this.connection) {
-                tables[collectionName] = this.connection.model(modelName, schema);
-            }
-        });
-        this.tables = tables;
-    }
-    getTables() {
-        if (!this.tables) {
-            throw new ProsopoDBError("DATABASE.TABLES_UNDEFINED", {
-                context: { failedFuncName: this.getTables.name },
-                logger: this.logger,
-            });
-        }
-        return this.tables;
-    }
-    getUserAccessRulesStorage() {
-        if (null === this.userAccessRulesStorage) {
-            throw new ProsopoDBError("DATABASE.USER_ACCESS_RULES_STORAGE_UNDEFINED");
-        }
-        return this.userAccessRulesStorage;
-    }
-    async storeDataset(dataset) {
-        try {
-            this.logger.debug(() => ({
-                data: { datasetId: dataset.datasetId },
-                msg: "Storing dataset in database",
-            }));
-            const parsedDataset = DatasetWithIdsAndTreeSchema.parse(dataset);
-            const datasetDoc = {
-                datasetId: parsedDataset.datasetId,
-                datasetContentId: parsedDataset.datasetContentId,
-                format: parsedDataset.format,
-                contentTree: parsedDataset.contentTree,
-                solutionTree: parsedDataset.solutionTree,
-            };
-            const filter = {
-                datasetId: parsedDataset.datasetId,
-            };
-            await this.tables.dataset?.updateOne(filter, { $set: datasetDoc }, { upsert: true });
-            const captchaDocs = parsedDataset.captchas.map(({ solution, ...captcha }, index) => ({
-                ...captcha,
-                datasetId: parsedDataset.datasetId,
-                datasetContentId: parsedDataset.datasetContentId,
-                index,
-                solved: !!solution?.length,
-            }));
-            this.logger.debug(() => ({
-                msg: "Inserting captcha records",
-            }));
-            if (captchaDocs.length) {
-                await this.tables?.captcha.bulkWrite(captchaDocs.map((captchaDoc) => ({
-                    updateOne: {
-                        filter: { captchaId: captchaDoc.captchaId },
-                        update: { $set: captchaDoc },
-                        upsert: true,
-                    },
-                })));
+      );
+      this.logger.debug(() => ({
+        msg: "Inserting captcha records"
+      }));
+      if (captchaDocs.length) {
+        await this.tables?.captcha.bulkWrite(
+          captchaDocs.map((captchaDoc) => ({
+            updateOne: {
+              filter: { captchaId: captchaDoc.captchaId },
+              update: { $set: captchaDoc },
+              upsert: true
             }
-            const captchaSolutionDocs = parsedDataset.captchas
-                .filter(({ solution }) => solution?.length)
-                .map((captcha) => ({
-                captchaId: captcha.captchaId,
-                captchaContentId: captcha.captchaContentId,
-                solution: captcha.solution,
-                salt: captcha.salt,
-                datasetId: parsedDataset.datasetId,
-                datasetContentId: parsedDataset.datasetContentId,
-            }));
-            this.logger.debug(() => ({
-                msg: "Inserting solution records",
-            }));
-            if (captchaSolutionDocs.length) {
-                await this.tables?.solution.bulkWrite(captchaSolutionDocs.map((captchaSolutionDoc) => ({
-                    updateOne: {
-                        filter: { captchaId: captchaSolutionDoc.captchaId },
-                        update: { $set: captchaSolutionDoc },
-                        upsert: true,
-                    },
-                })));
+          }))
+        );
+      }
+      const captchaSolutionDocs = parsedDataset.captchas.filter(({ solution }) => solution?.length).map((captcha) => ({
+        captchaId: captcha.captchaId,
+        captchaContentId: captcha.captchaContentId,
+        solution: captcha.solution,
+        salt: captcha.salt,
+        datasetId: parsedDataset.datasetId,
+        datasetContentId: parsedDataset.datasetContentId
+      }));
+      this.logger.debug(() => ({
+        msg: "Inserting solution records"
+      }));
+      if (captchaSolutionDocs.length) {
+        await this.tables?.solution.bulkWrite(
+          captchaSolutionDocs.map((captchaSolutionDoc) => ({
+            updateOne: {
+              filter: { captchaId: captchaSolutionDoc.captchaId },
+              update: { $set: captchaSolutionDoc },
+              upsert: true
             }
-            this.logger.debug(() => ({
-                msg: "Dataset stored in database",
-            }));
-        }
-        catch (err) {
-            throw new ProsopoDBError("DATABASE.DATASET_LOAD_FAILED", {
-                context: { failedFuncName: this.storeDataset.name, error: err },
-                logger: this.logger,
-            });
-        }
-    }
-    async getSolutions(datasetId) {
-        const filter = { datasetId };
-        const docs = await this.tables?.solution
-            .find(filter)
-            .lean();
-        return docs ? docs : [];
-    }
-    async getSolutionByCaptchaId(captchaId) {
-        const filter = { captchaId };
-        const doc = await this.tables?.solution
-            .findOne(filter)
-            .lean();
-        return doc || null;
+          }))
+        );
+      }
+      this.logger.debug(() => ({
+        msg: "Dataset stored in database"
+      }));
+    } catch (err) {
+      throw new ProsopoDBError("DATABASE.DATASET_LOAD_FAILED", {
+        context: { failedFuncName: this.storeDataset.name, error: err },
+        logger: this.logger
+      });
     }
-    async getDataset(datasetId) {
-        const filter = { datasetId };
-        const datasetDoc = await this.tables?.dataset.findOne(filter).lean();
-        if (datasetDoc) {
-            const { datasetContentId, format, contentTree, solutionTree } = datasetDoc;
-            const captchas = (await this.tables?.captcha.find(filter).lean()) || [];
-            const solutions = (await this.tables?.solution.find(filter).lean()) ||
-                [];
-            const solutionsKeyed = {};
-            for (const solution of solutions) {
-                solutionsKeyed[solution.captchaId] = solution;
-            }
-            return {
-                datasetId,
-                datasetContentId,
-                format,
-                contentTree: contentTree || [],
-                solutionTree: solutionTree || [],
-                captchas: captchas.map((captchaDoc) => {
-                    const { captchaId, captchaContentId, items, target, salt, solved } = captchaDoc;
-                    const solution = solutionsKeyed[captchaId];
-                    return {
-                        captchaId,
-                        captchaContentId,
-                        solved: !!solved,
-                        salt,
-                        items,
-                        target,
-                        solution: solved && solution ? solution.solution : [],
-                    };
-                }),
-            };
-        }
-        throw new ProsopoDBError("DATABASE.DATASET_GET_FAILED", {
-            context: { failedFuncName: this.getDataset.name, datasetId },
-        });
-    }
-    async getRandomCaptcha(solved, datasetId, size) {
-        if (!isHex(datasetId)) {
-            throw new ProsopoDBError("DATABASE.INVALID_HASH", {
-                context: { failedFuncName: this.getRandomCaptcha.name, datasetId },
-            });
-        }
-        const sampleSize = size ? Math.abs(Math.trunc(size)) : 1;
-        const filter = { datasetId, solved };
-        const cursor = this.tables?.captcha.aggregate([
-            { $match: filter },
-            { $sample: { size: sampleSize } },
-            {
-                $project: {
-                    datasetId: 1,
-                    datasetContentId: 1,
-                    captchaId: 1,
-                    captchaContentId: 1,
-                    items: 1,
-                    target: 1,
-                },
-            },
-        ]);
-        const docs = await cursor;
-        if (docs?.length) {
-            return docs.map(({ _id, ...keepAttrs }) => keepAttrs);
-        }
-        throw new ProsopoDBError("DATABASE.CAPTCHA_GET_FAILED", {
-            context: {
-                failedFuncName: this.getRandomCaptcha.name,
-                solved,
-                datasetId,
-                size,
-            },
-        });
+  }
+  /** @description Get solutions for a dataset
+   * @param {string} datasetId
+   */
+  async getSolutions(datasetId) {
+    const filter = { datasetId };
+    const docs = await this.tables?.solution.find(filter).lean();
+    return docs ? docs : [];
+  }
+  /** @description Get a solution by captcha id
+   * @param {string} captchaId
+   */
+  async getSolutionByCaptchaId(captchaId) {
+    const filter = { captchaId };
+    const doc = await this.tables?.solution.findOne(filter).lean();
+    return doc || null;
+  }
+  /** @description Get a dataset from the database
+   * @param {string} datasetId
+   */
+  async getDataset(datasetId) {
+    const filter = { datasetId };
+    const datasetDoc = await this.tables?.dataset.findOne(filter).lean();
+    if (datasetDoc) {
+      const { datasetContentId, format, contentTree, solutionTree } = datasetDoc;
+      const captchas = await this.tables?.captcha.find(filter).lean() || [];
+      const solutions = await this.tables?.solution.find(filter).lean() || [];
+      const solutionsKeyed = {};
+      for (const solution of solutions) {
+        solutionsKeyed[solution.captchaId] = solution;
+      }
+      return {
+        datasetId,
+        datasetContentId,
+        format,
+        contentTree: contentTree || [],
+        solutionTree: solutionTree || [],
+        captchas: captchas.map((captchaDoc) => {
+          const { captchaId, captchaContentId, items, target, salt, solved } = captchaDoc;
+          const solution = solutionsKeyed[captchaId];
+          return {
+            captchaId,
+            captchaContentId,
+            solved: !!solved,
+            salt,
+            items,
+            target,
+            solution: solved && solution ? solution.solution : []
+          };
+        })
+      };
     }
-    async getCaptchaById(captchaId) {
-        const filter = { captchaId: { $in: captchaId } };
-        const cursor = this.tables?.captcha
-            .find(filter)
-            .lean();
-        const docs = await cursor;
-        if (docs?.length) {
-            return docs.map(({ _id, ...keepAttrs }) => keepAttrs);
-        }
-        throw new ProsopoDBError("DATABASE.CAPTCHA_GET_FAILED", {
-            context: { failedFuncName: this.getCaptchaById.name, captchaId },
-        });
+    throw new ProsopoDBError("DATABASE.DATASET_GET_FAILED", {
+      context: { failedFuncName: this.getDataset.name, datasetId }
+    });
+  }
+  /**
+   * @description Get random captchas that are solved or not solved
+   * @param {boolean}  solved    `true` when captcha is solved
+   * @param {string}   datasetId  the id of the data set
+   * @param {number}   size       the number of records to be returned
+   */
+  async getRandomCaptcha(solved, datasetId, size) {
+    if (!isHex(datasetId)) {
+      throw new ProsopoDBError("DATABASE.INVALID_HASH", {
+        context: { failedFuncName: this.getRandomCaptcha.name, datasetId }
+      });
     }
-    async updateCaptcha(captcha, datasetId) {
-        if (!isHex(datasetId)) {
-            throw new ProsopoDBError("DATABASE.INVALID_HASH", {
-                context: { failedFuncName: this.updateCaptcha.name, datasetId },
-            });
-        }
-        try {
-            const filter = { datasetId };
-            await this.tables?.captcha.updateOne(filter, { $set: captcha }, { upsert: false });
-        }
-        catch (err) {
-            throw new ProsopoDBError("DATABASE.CAPTCHA_UPDATE_FAILED", {
-                context: { failedFuncName: this.getDatasetDetails.name, error: err },
-            });
+    const sampleSize = size ? Math.abs(Math.trunc(size)) : 1;
+    const filter = { datasetId, solved };
+    const cursor = this.tables?.captcha.aggregate([
+      { $match: filter },
+      { $sample: { size: sampleSize } },
+      {
+        $project: {
+          datasetId: 1,
+          datasetContentId: 1,
+          captchaId: 1,
+          captchaContentId: 1,
+          items: 1,
+          target: 1
         }
+      }
+    ]);
+    const docs = await cursor;
+    if (docs?.length) {
+      return docs.map(({ _id, ...keepAttrs }) => keepAttrs);
     }
-    async removeCaptchas(captchaIds) {
-        const filter = { captchaId: { $in: captchaIds } };
-        await this.tables?.captcha.deleteMany(filter);
+    throw new ProsopoDBError("DATABASE.CAPTCHA_GET_FAILED", {
+      context: {
+        failedFuncName: this.getRandomCaptcha.name,
+        solved,
+        datasetId,
+        size
+      }
+    });
+  }
+  /**
+   * @description Get captchas by id
+   * @param {string[]} captchaId
+   */
+  async getCaptchaById(captchaId) {
+    const filter = { captchaId: { $in: captchaId } };
+    const cursor = this.tables?.captcha.find(filter).lean();
+    const docs = await cursor;
+    if (docs?.length) {
+      return docs.map(({ _id, ...keepAttrs }) => keepAttrs);
     }
-    async getDatasetDetails(datasetId) {
-        if (!isHex(datasetId)) {
-            throw new ProsopoDBError("DATABASE.INVALID_HASH", {
-                context: { failedFuncName: this.getDatasetDetails.name, datasetId },
-            });
-        }
-        const filter = { datasetId };
-        const doc = await this.tables?.dataset
-            .findOne(filter)
-            .lean();
-        if (doc) {
-            return doc;
-        }
-        throw new ProsopoDBError("DATABASE.DATASET_GET_FAILED", {
-            context: {
-                failedFuncName: this.getDatasetDetails.name,
-                datasetId,
-            },
-        });
+    throw new ProsopoDBError("DATABASE.CAPTCHA_GET_FAILED", {
+      context: { failedFuncName: this.getCaptchaById.name, captchaId }
+    });
+  }
+  /**
+   * @description Update a captcha
+   * @param {Captcha}  captcha
+   * @param {string}   datasetId  the id of the data set
+   */
+  async updateCaptcha(captcha, datasetId) {
+    if (!isHex(datasetId)) {
+      throw new ProsopoDBError("DATABASE.INVALID_HASH", {
+        context: { failedFuncName: this.updateCaptcha.name, datasetId }
+      });
     }
-    async storeUserImageCaptchaSolution(captchas, commit) {
-        const commitmentRecord = UserCommitmentSchema.parse({
-            ...commit,
-            lastUpdatedTimestamp: Date.now(),
-        });
-        if (captchas.length) {
-            const filter = {
-                id: commit.id,
-            };
-            await this.tables?.commitment.updateOne(filter, commitmentRecord, {
-                upsert: true,
-            });
-            const ops = captchas.map((captcha) => ({
-                updateOne: {
-                    filter: {
-                        commitmentId: commit.id,
-                        captchaId: captcha.captchaId,
-                    },
-                    update: {
-                        $set: {
-                            captchaId: captcha.captchaId,
-                            captchaContentId: captcha.captchaContentId,
-                            salt: captcha.salt,
-                            solution: captcha.solution,
-                            commitmentId: commit.id,
-                            processed: false,
-                        },
-                    },
-                    upsert: true,
-                },
-            }));
-            await this.tables?.usersolution.bulkWrite(ops);
-        }
+    try {
+      const filter = { datasetId };
+      await this.tables?.captcha.updateOne(
+        filter,
+        { $set: captcha },
+        { upsert: false }
+      );
+    } catch (err) {
+      throw new ProsopoDBError("DATABASE.CAPTCHA_UPDATE_FAILED", {
+        context: { failedFuncName: this.getDatasetDetails.name, error: err }
+      });
     }
-    async storePowCaptchaRecord(challenge, components, difficulty, providerSignature, ipAddress, headers, ja4, frictionlessTokenId, serverChecked = false, userSubmitted = false, storedStatus = StoredStatusNames.notStored, userSignature) {
-        const tables = this.getTables();
-        const powCaptchaRecord = {
-            challenge,
-            ...components,
-            ipAddress,
-            headers,
-            ja4,
-            result: { status: CaptchaStatus.pending },
-            userSubmitted,
-            serverChecked,
-            difficulty,
-            providerSignature,
-            userSignature,
-            lastUpdatedTimestamp: Date.now(),
-            frictionlessTokenId,
-        };
-        try {
-            await tables.powcaptcha.create(powCaptchaRecord);
-            this.logger.info(() => ({
-                data: {
-                    challenge,
-                    userSubmitted,
-                    serverChecked,
-                    storedStatus,
-                },
-                msg: "PowCaptcha record added successfully",
-            }));
-        }
-        catch (error) {
-            const err = new ProsopoDBError("DATABASE.CAPTCHA_UPDATE_FAILED", {
-                context: {
-                    error,
-                    challenge,
-                    userSubmitted,
-                    serverChecked,
-                    storedStatus,
-                },
-                logger: this.logger,
-            });
-            this.logger.error(() => ({
-                err: error,
-                msg: "Failed to add PowCaptcha record",
-            }));
-            throw err;
-        }
+  }
+  /**
+   * @description Remove captchas
+   */
+  async removeCaptchas(captchaIds) {
+    const filter = { captchaId: { $in: captchaIds } };
+    await this.tables?.captcha.deleteMany(filter);
+  }
+  /**
+   * @description Get a dataset by Id
+   */
+  async getDatasetDetails(datasetId) {
+    if (!isHex(datasetId)) {
+      throw new ProsopoDBError("DATABASE.INVALID_HASH", {
+        context: { failedFuncName: this.getDatasetDetails.name, datasetId }
+      });
     }
-    async getPowCaptchaRecordByChallenge(challenge) {
-        if (!this.tables) {
-            throw new ProsopoDBError("DATABASE.DATABASE_UNDEFINED", {
-                context: { failedFuncName: this.getPowCaptchaRecordByChallenge.name },
-                logger: this.logger,
-            });
-        }
-        try {
-            const filter = { challenge };
-            const record = await this.tables.powcaptcha.findOne(filter).lean();
-            if (record) {
-                this.logger.info(() => ({
-                    data: { challenge },
-                    msg: "PowCaptcha record retrieved successfully",
-                }));
-                return record;
-            }
-            this.logger.info(() => ({
-                data: { challenge },
-                msg: "No PowCaptcha record found",
-            }));
-            return null;
-        }
-        catch (error) {
-            const err = new ProsopoDBError("DATABASE.CAPTCHA_GET_FAILED", {
-                context: { error, challenge },
-                logger: this.logger,
-            });
-            this.logger.error(() => ({
-                err: err,
-                msg: "Failed to retrieve PowCaptcha record",
-            }));
-            throw err;
-        }
+    const filter = { datasetId };
+    const doc = await this.tables?.dataset.findOne(filter).lean();
+    if (doc) {
+      return doc;
     }
-    async updatePowCaptchaRecord(challenge, result, serverChecked = false, userSubmitted = false, userSignature) {
-        const tables = this.getTables();
-        const timestamp = Date.now();
-        const update = {
-            result,
-            serverChecked,
-            userSubmitted,
-            userSignature,
-            lastUpdatedTimestamp: timestamp,
-        };
-        try {
-            const updateResult = await tables.powcaptcha.updateOne({ challenge }, {
-                $set: update,
-            });
-            if (updateResult.matchedCount === 0) {
-                const err = new ProsopoDBError("DATABASE.CAPTCHA_GET_FAILED", {
-                    context: {
-                        challenge,
-                        ...update,
-                    },
-                    logger: this.logger,
-                });
-                this.logger.info(() => ({
-                    err: err,
-                    msg: "No PowCaptcha record found to update",
-                }));
-                throw err;
+    throw new ProsopoDBError("DATABASE.DATASET_GET_FAILED", {
+      context: {
+        failedFuncName: this.getDatasetDetails.name,
+        datasetId
+      }
+    });
+  }
+  /**
+   * @description Store a Dapp User's captcha solution commitment
+   */
+  async storeUserImageCaptchaSolution(captchas, commit) {
+    const commitmentRecord = UserCommitmentSchema.parse({
+      ...commit,
+      lastUpdatedTimestamp: Date.now()
+    });
+    if (captchas.length) {
+      const filter = {
+        id: commit.id
+      };
+      await this.tables?.commitment.updateOne(filter, commitmentRecord, {
+        upsert: true
+      });
+      const ops = captchas.map((captcha) => ({
+        updateOne: {
+          filter: {
+            commitmentId: commit.id,
+            captchaId: captcha.captchaId
+          },
+          update: {
+            $set: {
+              captchaId: captcha.captchaId,
+              captchaContentId: captcha.captchaContentId,
+              salt: captcha.salt,
+              solution: captcha.solution,
+              commitmentId: commit.id,
+              processed: false
             }
-            this.logger.info(() => ({
-                data: {
-                    challenge,
-                    ...update,
-                },
-                msg: "PowCaptcha record updated successfully",
-            }));
+          },
+          upsert: true
         }
-        catch (error) {
-            const err = new ProsopoDBError("DATABASE.CAPTCHA_UPDATE_FAILED", {
-                context: {
-                    error,
-                    challenge,
-                    ...update,
-                },
-                logger: this.logger,
-            });
-            this.logger.error(() => ({
-                err: err,
-                msg: "Failed to update PowCaptcha record",
-            }));
-            throw err;
-        }
-    }
-    async getCheckedDappUserCommitments() {
-        const filter = { [StoredStatusNames.serverChecked]: true };
-        const docs = await this.tables?.commitment
-            .find(filter)
-            .lean();
-        return docs || [];
-    }
-    async getUnstoredDappUserCommitments(limit = 1000, skip = 0) {
-        const filterNoStoredTimestamp = { storedAtTimestamp: { $exists: false } };
-        const docs = await this.tables?.commitment.aggregate([
-            {
-                $match: {
-                    $or: [
-                        filterNoStoredTimestamp,
-                        {
-                            $expr: {
-                                $lt: ["$storedAtTimestamp", "$lastUpdatedTimestamp"],
-                            },
-                        },
-                    ],
-                },
-            },
-            {
-                $sort: { _id: 1 },
-            },
-            {
-                $skip: skip,
-            },
-            {
-                $limit: limit,
-            },
-        ]);
-        return docs || [];
+      }));
+      await this.tables?.usersolution.bulkWrite(ops);
     }
-    async markDappUserCommitmentsStored(commitmentIds) {
-        const updateDoc = {
-            storedAtTimestamp: Date.now(),
-        };
-        await this.tables?.commitment.updateMany({ id: { $in: commitmentIds } }, { $set: updateDoc }, { upsert: false });
-    }
-    async markDappUserCommitmentsChecked(commitmentIds) {
-        const updateDoc = {
-            [StoredStatusNames.serverChecked]: true,
-            lastUpdatedTimestamp: Date.now(),
-        };
-        await this.tables?.commitment.updateMany({ id: { $in: commitmentIds } }, { $set: updateDoc }, { upsert: false });
-    }
-    async getUnstoredDappUserPoWCommitments(limit = 1000, skip = 0) {
-        const filterNoStoredTimestamp = { storedAtTimestamp: { $exists: false } };
-        const docs = await this.tables?.powcaptcha.aggregate([
-            {
-                $match: {
-                    $or: [
-                        filterNoStoredTimestamp,
-                        {
-                            $expr: {
-                                $lt: [
-                                    {
-                                        $convert: {
-                                            input: "$storedAtTimestamp",
-                                            to: "date",
-                                        },
-                                    },
-                                    {
-                                        $convert: {
-                                            input: "$lastUpdatedTimestamp",
-                                            to: "date",
-                                        },
-                                    },
-                                ],
-                            },
-                        },
-                    ],
-                },
-            },
-            {
-                $sort: { _id: 1 },
-            },
-            {
-                $skip: skip,
-            },
-            {
-                $limit: limit,
-            },
-        ]);
-        return docs || [];
+  }
+  /**
+   * @description Adds a new PoW Captcha record to the database.
+   * @param {string} challenge The challenge string for the captcha.
+   * @param components The components of the PoW challenge.
+   * @param difficulty
+   * @param providerSignature
+   * @param ipAddress
+   * @param headers
+   * @param ja4
+   * @param frictionlessTokenId
+   * @param serverChecked
+   * @param userSubmitted
+   * @param storedStatus
+   * @param userSignature
+   * @returns {Promise<void>} A promise that resolves when the record is added.
+   */
+  async storePowCaptchaRecord(challenge, components, difficulty, providerSignature, ipAddress, headers, ja4, frictionlessTokenId, serverChecked = false, userSubmitted = false, storedStatus = StoredStatusNames.notStored, userSignature) {
+    const tables = this.getTables();
+    const powCaptchaRecord = {
+      challenge,
+      ...components,
+      ipAddress,
+      headers,
+      ja4,
+      result: { status: CaptchaStatus.pending },
+      userSubmitted,
+      serverChecked,
+      difficulty,
+      providerSignature,
+      userSignature,
+      lastUpdatedTimestamp: Date.now(),
+      frictionlessTokenId
+    };
+    try {
+      await tables.powcaptcha.create(powCaptchaRecord);
+      this.logger.info(() => ({
+        data: {
+          challenge,
+          userSubmitted,
+          serverChecked,
+          storedStatus
+        },
+        msg: "PowCaptcha record added successfully"
+      }));
+    } catch (error) {
+      const err = new ProsopoDBError("DATABASE.CAPTCHA_UPDATE_FAILED", {
+        context: {
+          error,
+          challenge,
+          userSubmitted,
+          serverChecked,
+          storedStatus
+        },
+        logger: this.logger
+      });
+      this.logger.error(() => ({
+        err: error,
+        msg: "Failed to add PowCaptcha record"
+      }));
+      throw err;
     }
-    async markDappUserPoWCommitmentsStored(challenges) {
-        const updateDoc = {
-            storedAtTimestamp: Date.now(),
-        };
-        await this.tables?.powcaptcha.updateMany({ challenge: { $in: challenges } }, { $set: updateDoc }, { upsert: false });
+  }
+  /**
+   * @description Retrieves a PoW Captcha record by its challenge string.
+   * @param {string} challenge The challenge string to search for.
+   * @returns {Promise<PoWCaptchaRecord | null>} A promise that resolves with the found record or null if not found.
+   */
+  async getPowCaptchaRecordByChallenge(challenge) {
+    if (!this.tables) {
+      throw new ProsopoDBError("DATABASE.DATABASE_UNDEFINED", {
+        context: { failedFuncName: this.getPowCaptchaRecordByChallenge.name },
+        logger: this.logger
+      });
     }
-    async markDappUserPoWCommitmentsChecked(challenges) {
-        const updateDoc = {
-            [StoredStatusNames.serverChecked]: true,
-            lastUpdatedTimestamp: Date.now(),
-        };
-        await this.tables?.powcaptcha.updateMany({ challenge: { $in: challenges } }, {
-            $set: updateDoc,
-        }, { upsert: false });
-    }
-    async storeFrictionlessTokenRecord(tokenRecord) {
-        const doc = await this.tables.frictionlessToken.create(tokenRecord);
-        return doc._id;
-    }
-    async updateFrictionlessTokenRecord(tokenId, updates) {
-        const filter = { _id: tokenId };
-        await this.tables.frictionlessToken.updateOne(filter, updates);
-    }
-    async getFrictionlessTokenRecordByTokenId(tokenId) {
-        const filter = { _id: tokenId };
-        const doc = await this.tables.frictionlessToken.findOne(filter);
-        return doc ? doc : undefined;
-    }
-    async getFrictionlessTokenRecordsByTokenIds(tokenId) {
-        const filter = {
-            _id: { $in: tokenId },
-        };
-        return this.tables.frictionlessToken.find(filter);
-    }
-    async getFrictionlessTokenRecordByToken(token) {
-        const filter = { token };
-        const record = await this.tables.frictionlessToken.findOne(filter);
-        return record || undefined;
-    }
-    async storeSessionRecord(sessionRecord) {
-        try {
-            this.logger.debug(() => ({
-                data: { action: "storing", sessionRecord },
-            }));
-            await this.tables.session.create(sessionRecord);
-        }
-        catch (err) {
-            throw new ProsopoDBError("DATABASE.SESSION_STORE_FAILED", {
-                context: { error: err, sessionId: sessionRecord.sessionId },
-                logger: this.logger,
-            });
-        }
-    }
-    async checkAndRemoveSession(sessionId) {
-        this.logger.debug(() => ({
-            data: { action: "checking and removing", sessionId },
+    try {
+      const filter = { challenge };
+      const record = await this.tables.powcaptcha.findOne(filter).lean();
+      if (record) {
+        this.logger.info(() => ({
+          data: { challenge },
+          msg: "PowCaptcha record retrieved successfully"
         }));
-        const filter = {
-            sessionId,
-            deleted: { $exists: false },
-        };
-        try {
-            const session = await this.tables.session
-                .findOneAndUpdate(filter, {
-                deleted: true,
-                lastUpdatedTimestamp: Date.now(),
-            })
-                .lean();
-            return session || undefined;
-        }
-        catch (err) {
-            throw new ProsopoDBError("DATABASE.SESSION_CHECK_REMOVE_FAILED", {
-                context: { error: err, sessionId },
-                logger: this.logger,
-            });
-        }
+        return record;
+      }
+      this.logger.info(() => ({
+        data: { challenge },
+        msg: "No PowCaptcha record found"
+      }));
+      return null;
+    } catch (error) {
+      const err = new ProsopoDBError("DATABASE.CAPTCHA_GET_FAILED", {
+        context: { error, challenge },
+        logger: this.logger
+      });
+      this.logger.error(() => ({
+        err,
+        msg: "Failed to retrieve PowCaptcha record"
+      }));
+      throw err;
     }
-    getUnstoredSessionRecords(limit = 1000, skip = 0) {
-        const filterNoStoredTimestamp = { storedAtTimestamp: { $exists: false } };
-        return this.tables?.session
-            .aggregate([
-            {
-                $match: {
-                    $or: [
-                        filterNoStoredTimestamp,
-                        {
-                            $expr: {
-                                $lt: [
-                                    {
-                                        $convert: {
-                                            input: "$storedAtTimestamp",
-                                            to: "date",
-                                        },
-                                    },
-                                    {
-                                        $convert: {
-                                            input: "$lastUpdatedTimestamp",
-                                            to: "date",
-                                        },
-                                    },
-                                ],
-                            },
-                        },
-                    ],
-                },
-            },
-            {
-                $sort: { _id: 1 },
-            },
-            {
-                $skip: skip,
-            },
-            {
-                $limit: limit,
-            },
-        ])
-            .then((docs) => docs || []);
-    }
-    async markSessionRecordsStored(sessionIds) {
-        const updateDoc = {
-            storedAtTimestamp: Date.now(),
-        };
-        await this.tables?.session.updateMany({ sessionId: { $in: sessionIds } }, { $set: updateDoc }, { upsert: false });
-    }
-    async storePendingImageCommitment(userAccount, requestHash, salt, deadlineTimestamp, requestedAtTimestamp, ipAddress, threshold, frictionlessTokenId) {
-        if (!isHex(requestHash)) {
-            throw new ProsopoDBError("DATABASE.INVALID_HASH", {
-                context: {
-                    failedFuncName: this.storePendingImageCommitment.name,
-                    requestHash,
-                },
-            });
-        }
-        const pendingRecord = {
-            accountId: userAccount,
-            pending: true,
-            salt,
-            requestHash,
-            deadlineTimestamp,
-            requestedAtTimestamp: new Date(requestedAtTimestamp),
-            ipAddress,
-            frictionlessTokenId,
-            threshold,
-        };
-        await this.tables?.pending.updateOne({ requestHash: requestHash }, { $set: pendingRecord }, { upsert: true });
-    }
-    async getPendingImageCommitment(requestHash) {
-        if (!isHex(requestHash)) {
-            throw new ProsopoDBError("DATABASE.INVALID_HASH", {
-                context: {
-                    failedFuncName: this.getPendingImageCommitment.name,
-                    requestHash,
-                },
-            });
-        }
-        const filter = {
-            [ApiParams.requestHash]: requestHash,
-        };
-        const doc = await this.tables?.pending.findOne(filter).lean();
-        if (doc) {
-            return doc;
+  }
+  /**
+   * @description Updates a PoW Captcha record in the database.
+   * @param {string} challenge The challenge string of the captcha to be updated.
+   * @param result
+   * @param serverChecked
+   * @param userSubmitted
+   * @param userSignature
+   * @returns {Promise<void>} A promise that resolves when the record is updated.
+   */
+  async updatePowCaptchaRecord(challenge, result, serverChecked = false, userSubmitted = false, userSignature) {
+    const tables = this.getTables();
+    const timestamp = Date.now();
+    const update = {
+      result,
+      serverChecked,
+      userSubmitted,
+      userSignature,
+      lastUpdatedTimestamp: timestamp
+    };
+    try {
+      const updateResult = await tables.powcaptcha.updateOne(
+        { challenge },
+        {
+          $set: update
         }
-        throw new ProsopoDBError("DATABASE.PENDING_RECORD_NOT_FOUND", {
-            context: {
-                failedFuncName: this.getPendingImageCommitment.name,
-                requestHash,
-            },
+      );
+      if (updateResult.matchedCount === 0) {
+        const err = new ProsopoDBError("DATABASE.CAPTCHA_GET_FAILED", {
+          context: {
+            challenge,
+            ...update
+          },
+          logger: this.logger
         });
+        this.logger.info(() => ({
+          err,
+          msg: "No PowCaptcha record found to update"
+        }));
+        throw err;
+      }
+      this.logger.info(() => ({
+        data: {
+          challenge,
+          ...update
+        },
+        msg: "PowCaptcha record updated successfully"
+      }));
+    } catch (error) {
+      const err = new ProsopoDBError("DATABASE.CAPTCHA_UPDATE_FAILED", {
+        context: {
+          error,
+          challenge,
+          ...update
+        },
+        logger: this.logger
+      });
+      this.logger.error(() => ({
+        err,
+        msg: "Failed to update PowCaptcha record"
+      }));
+      throw err;
     }
-    async updatePendingImageCommitmentStatus(requestHash) {
-        if (!isHex(requestHash)) {
-            throw new ProsopoDBError("DATABASE.INVALID_HASH", {
-                context: {
-                    failedFuncName: this.updatePendingImageCommitmentStatus.name,
-                    requestHash,
-                },
-            });
+  }
+  /** @description Get serverChecked Dapp User image captcha commitments from the commitments table
+   */
+  async getCheckedDappUserCommitments() {
+    const filter = { [StoredStatusNames.serverChecked]: true };
+    const docs = await this.tables?.commitment.find(filter).lean();
+    return docs || [];
+  }
+  /** @description Get Dapp User captcha commitments from the commitments table that have not been counted towards the
+   * client's total
+   */
+  async getUnstoredDappUserCommitments(limit = 1e3, skip = 0) {
+    const filterNoStoredTimestamp = { storedAtTimestamp: { $exists: false } };
+    const docs = await this.tables?.commitment.aggregate([
+      {
+        $match: {
+          $or: [
+            filterNoStoredTimestamp,
+            {
+              $expr: {
+                $lt: ["$storedAtTimestamp", "$lastUpdatedTimestamp"]
+              }
+            }
+          ]
         }
-        const filter = {
-            [ApiParams.requestHash]: requestHash,
-        };
-        await this.tables?.pending.updateOne(filter, {
-            $set: {
-                [CaptchaStatus.pending]: false,
-            },
-        }, { upsert: true });
-    }
-    async getAllCaptchasByDatasetId(datasetId, state) {
-        const filter = {
-            datasetId,
-            solved: state === CaptchaStates.Solved,
-        };
-        const cursor = this.tables?.captcha
-            .find(filter)
-            .lean();
-        const docs = await cursor;
-        if (docs) {
-            return docs.map(({ _id, ...keepAttrs }) => keepAttrs);
+      },
+      {
+        $sort: { _id: 1 }
+      },
+      {
+        $skip: skip
+      },
+      {
+        $limit: limit
+      }
+    ]);
+    return docs || [];
+  }
+  /** @description Mark a list of captcha commits as stored
+   */
+  async markDappUserCommitmentsStored(commitmentIds) {
+    const updateDoc = {
+      storedAtTimestamp: Date.now()
+    };
+    await this.tables?.commitment.updateMany(
+      { id: { $in: commitmentIds } },
+      { $set: updateDoc },
+      { upsert: false }
+    );
+  }
+  /** @description Mark a list of captcha commits as checked
+   */
+  async markDappUserCommitmentsChecked(commitmentIds) {
+    const updateDoc = {
+      [StoredStatusNames.serverChecked]: true,
+      lastUpdatedTimestamp: Date.now()
+    };
+    await this.tables?.commitment.updateMany(
+      { id: { $in: commitmentIds } },
+      { $set: updateDoc },
+      { upsert: false }
+    );
+  }
+  /**
+   * @description Get Dapp User PoW captcha commitments that have not been counted towards the client's total
+   * @param {number} limit Maximum number of records to return
+   * @param {number} skip Number of records to skip (for pagination)
+   * @returns {Promise<PoWCaptchaRecord[]>} Array of PoW captcha records
+   */
+  async getUnstoredDappUserPoWCommitments(limit = 1e3, skip = 0) {
+    const filterNoStoredTimestamp = { storedAtTimestamp: { $exists: false } };
+    const docs = await this.tables?.powcaptcha.aggregate([
+      {
+        $match: {
+          $or: [
+            filterNoStoredTimestamp,
+            {
+              $expr: {
+                $lt: [
+                  {
+                    $convert: {
+                      input: "$storedAtTimestamp",
+                      to: "date"
+                    }
+                  },
+                  {
+                    $convert: {
+                      input: "$lastUpdatedTimestamp",
+                      to: "date"
+                    }
+                  }
+                ]
+              }
+            }
+          ]
         }
-        throw new ProsopoDBError("DATABASE.CAPTCHA_GET_FAILED");
+      },
+      {
+        $sort: { _id: 1 }
+      },
+      {
+        $skip: skip
+      },
+      {
+        $limit: limit
+      }
+    ]);
+    return docs || [];
+  }
+  /** @description Mark a list of PoW captcha commits as stored
+   */
+  async markDappUserPoWCommitmentsStored(challenges) {
+    const updateDoc = {
+      storedAtTimestamp: Date.now()
+    };
+    await this.tables?.powcaptcha.updateMany(
+      { challenge: { $in: challenges } },
+      { $set: updateDoc },
+      { upsert: false }
+    );
+  }
+  /** @description Mark a list of PoW captcha commits as checked by the server
+   */
+  async markDappUserPoWCommitmentsChecked(challenges) {
+    const updateDoc = {
+      [StoredStatusNames.serverChecked]: true,
+      lastUpdatedTimestamp: Date.now()
+    };
+    await this.tables?.powcaptcha.updateMany(
+      { challenge: { $in: challenges } },
+      {
+        $set: updateDoc
+      },
+      { upsert: false }
+    );
+  }
+  /**
+   * Store a new frictionless token record
+   */
+  async storeFrictionlessTokenRecord(tokenRecord) {
+    const doc = await this.tables.frictionlessToken.create(
+      tokenRecord
+    );
+    return doc._id;
+  }
+  /** Update a frictionless token record */
+  async updateFrictionlessTokenRecord(tokenId, updates) {
+    const filter = { _id: tokenId };
+    await this.tables.frictionlessToken.updateOne(filter, updates);
+  }
+  /** Get a frictionless token record */
+  async getFrictionlessTokenRecordByTokenId(tokenId) {
+    const filter = { _id: tokenId };
+    const doc = await this.tables.frictionlessToken.findOne(
+      filter
+    );
+    return doc ? doc : void 0;
+  }
+  /** Get many frictionless token records */
+  async getFrictionlessTokenRecordsByTokenIds(tokenId) {
+    const filter = {
+      _id: { $in: tokenId }
+    };
+    return this.tables.frictionlessToken.find(filter);
+  }
+  /**
+   * Check if a frictionless token record exists.
+   * Used to ensure that a token is not used more than once.
+   */
+  async getFrictionlessTokenRecordByToken(token) {
+    const filter = { token };
+    const record = await this.tables.frictionlessToken.findOne(
+      filter
+    );
+    return record || void 0;
+  }
+  /**
+   * Store a new session record
+   */
+  async storeSessionRecord(sessionRecord) {
+    try {
+      this.logger.debug(() => ({
+        data: { action: "storing", sessionRecord }
+      }));
+      await this.tables.session.create(sessionRecord);
+    } catch (err) {
+      throw new ProsopoDBError("DATABASE.SESSION_STORE_FAILED", {
+        context: { error: err, sessionId: sessionRecord.sessionId },
+        logger: this.logger
+      });
     }
-    async getAllDappUserSolutions(captchaId) {
-        const filter = {
-            captchaId: { $in: captchaId },
-        };
-        const cursor = this.tables?.usersolution
-            ?.find(filter)
-            .lean();
-        const docs = await cursor;
-        if (docs) {
-            return docs.map(({ _id, ...keepAttrs }) => keepAttrs);
-        }
-        throw new ProsopoDBError("DATABASE.SOLUTION_GET_FAILED");
+  }
+  /**
+   * Check if a session exists and mark it as removed
+   * @returns The session record if it existed, undefined otherwise
+   */
+  async checkAndRemoveSession(sessionId) {
+    this.logger.debug(() => ({
+      data: { action: "checking and removing", sessionId }
+    }));
+    const filter = {
+      sessionId,
+      deleted: { $exists: false }
+    };
+    try {
+      const session = await this.tables.session.findOneAndUpdate(filter, {
+        deleted: true,
+        lastUpdatedTimestamp: Date.now()
+      }).lean();
+      return session || void 0;
+    } catch (err) {
+      throw new ProsopoDBError("DATABASE.SESSION_CHECK_REMOVE_FAILED", {
+        context: { error: err, sessionId },
+        logger: this.logger
+      });
     }
-    async getDatasetIdWithSolvedCaptchasOfSizeN(solvedCaptchaCount) {
-        const cursor = this.tables?.solution.aggregate([
-            {
-                $match: {},
-            },
+  }
+  /** Get unstored session records
+   * @description Get session records that have not been stored yet
+   * @param limit
+   * @param skip
+   */
+  getUnstoredSessionRecords(limit = 1e3, skip = 0) {
+    const filterNoStoredTimestamp = { storedAtTimestamp: { $exists: false } };
+    return this.tables?.session.aggregate([
+      {
+        $match: {
+          $or: [
+            filterNoStoredTimestamp,
             {
-                $group: {
-                    _id: "$datasetId",
-                    count: { $sum: 1 },
-                },
-            },
-            {
-                $match: {
-                    count: { $gte: solvedCaptchaCount },
-                },
-            },
-            {
-                $sample: { size: 1 },
-            },
-        ]);
-        const docs = await cursor;
-        if (docs?.length) {
-            return docs[0]._id;
-        }
-        throw new ProsopoDBError("DATABASE.DATASET_WITH_SOLUTIONS_GET_FAILED");
-    }
-    async getRandomSolvedCaptchasFromSingleDataset(datasetId, size) {
-        if (!isHex(datasetId)) {
-            throw new ProsopoDBError("DATABASE.INVALID_HASH", {
-                context: {
-                    failedFuncName: this.getRandomSolvedCaptchasFromSingleDataset.name,
-                    datasetId,
-                },
-            });
+              $expr: {
+                $lt: [
+                  {
+                    $convert: {
+                      input: "$storedAtTimestamp",
+                      to: "date"
+                    }
+                  },
+                  {
+                    $convert: {
+                      input: "$lastUpdatedTimestamp",
+                      to: "date"
+                    }
+                  }
+                ]
+              }
+            }
+          ]
         }
-        const sampleSize = size ? Math.abs(Math.trunc(size)) : 1;
-        const cursor = this.tables?.solution.aggregate([
-            { $match: { datasetId } },
-            { $sample: { size: sampleSize } },
-            {
-                $project: {
-                    captchaId: 1,
-                    captchaContentId: 1,
-                    solution: 1,
-                },
-            },
-        ]);
-        const docs = await cursor;
-        if (docs?.length) {
-            return docs;
+      },
+      {
+        $sort: { _id: 1 }
+      },
+      {
+        $skip: skip
+      },
+      {
+        $limit: limit
+      }
+    ]).then((docs) => docs || []);
+  }
+  /** Mark a list of session records as stored */
+  async markSessionRecordsStored(sessionIds) {
+    const updateDoc = {
+      storedAtTimestamp: Date.now()
+    };
+    await this.tables?.session.updateMany(
+      { sessionId: { $in: sessionIds } },
+      { $set: updateDoc },
+      { upsert: false }
+    );
+  }
+  /**
+   * @description Store a Dapp User's pending record
+   */
+  async storePendingImageCommitment(userAccount, requestHash, salt, deadlineTimestamp, requestedAtTimestamp, ipAddress, threshold, frictionlessTokenId) {
+    if (!isHex(requestHash)) {
+      throw new ProsopoDBError("DATABASE.INVALID_HASH", {
+        context: {
+          failedFuncName: this.storePendingImageCommitment.name,
+          requestHash
         }
-        throw new ProsopoDBError("DATABASE.SOLUTION_GET_FAILED", {
-            context: {
-                failedFuncName: this.getRandomSolvedCaptchasFromSingleDataset.name,
-                datasetId,
-                size,
-            },
-        });
+      });
     }
-    async getDappUserSolutionById(commitmentId) {
-        const filter = {
-            commitmentId: commitmentId,
-        };
-        const project = { projection: { _id: 0 } };
-        const cursor = this.tables?.usersolution?.findOne(filter, project).lean();
-        const doc = await cursor;
-        if (doc) {
-            return doc;
+    const pendingRecord = {
+      accountId: userAccount,
+      pending: true,
+      salt,
+      requestHash,
+      deadlineTimestamp,
+      requestedAtTimestamp: new Date(requestedAtTimestamp),
+      ipAddress,
+      frictionlessTokenId,
+      threshold
+    };
+    await this.tables?.pending.updateOne(
+      { requestHash },
+      { $set: pendingRecord },
+      { upsert: true }
+    );
+  }
+  /**
+   * @description Get a Dapp user's pending record
+   */
+  async getPendingImageCommitment(requestHash) {
+    if (!isHex(requestHash)) {
+      throw new ProsopoDBError("DATABASE.INVALID_HASH", {
+        context: {
+          failedFuncName: this.getPendingImageCommitment.name,
+          requestHash
         }
-        throw new ProsopoDBError("DATABASE.SOLUTION_GET_FAILED", {
-            context: { failedFuncName: this.getCaptchaById.name, commitmentId },
-        });
-    }
-    async getDappUserCommitmentById(commitmentId) {
-        const filter = { id: commitmentId };
-        const commitmentCursor = this.tables?.commitment
-            ?.findOne(filter)
-            .lean();
-        const doc = await commitmentCursor;
-        return doc ? doc : undefined;
+      });
     }
-    async getDappUserCommitmentByAccount(userAccount, dappAccount) {
-        const filter = {
-            userAccount,
-            dappAccount,
-        };
-        const project = { _id: 0 };
-        const sort = { sort: { _id: -1 } };
-        const docs = await this.tables?.commitment
-            ?.find(filter, project, sort)
-            .lean();
-        return docs ? docs : [];
+    const filter = {
+      [ApiParams.requestHash]: requestHash
+    };
+    const doc = await this.tables?.pending.findOne(filter).lean();
+    if (doc) {
+      return doc;
     }
-    async approveDappUserCommitment(commitmentId) {
-        try {
-            const result = { status: CaptchaStatus.approved };
-            const updateDoc = {
-                result,
-                lastUpdatedTimestamp: Date.now(),
-            };
-            const filter = { id: commitmentId };
-            await this.tables?.commitment
-                ?.findOneAndUpdate(filter, { $set: updateDoc }, { upsert: false })
-                .lean();
-        }
-        catch (err) {
-            throw new ProsopoDBError("DATABASE.SOLUTION_APPROVE_FAILED", {
-                context: { error: err, commitmentId },
-            });
+    throw new ProsopoDBError("DATABASE.PENDING_RECORD_NOT_FOUND", {
+      context: {
+        failedFuncName: this.getPendingImageCommitment.name,
+        requestHash
+      }
+    });
+  }
+  /**
+   * @description Mark a pending request as used
+   */
+  async updatePendingImageCommitmentStatus(requestHash) {
+    if (!isHex(requestHash)) {
+      throw new ProsopoDBError("DATABASE.INVALID_HASH", {
+        context: {
+          failedFuncName: this.updatePendingImageCommitmentStatus.name,
+          requestHash
         }
+      });
     }
-    async disapproveDappUserCommitment(commitmentId, reason) {
-        try {
-            const updateDoc = {
-                result: { status: CaptchaStatus.disapproved, reason },
-                lastUpdatedTimestamp: Date.now(),
-            };
-            const filter = { id: commitmentId };
-            await this.tables?.commitment
-                ?.findOneAndUpdate(filter, { $set: updateDoc }, { upsert: false })
-                .lean();
-        }
-        catch (err) {
-            throw new ProsopoDBError("DATABASE.SOLUTION_APPROVE_FAILED", {
-                context: { error: err, commitmentId },
-            });
+    const filter = {
+      [ApiParams.requestHash]: requestHash
+    };
+    await this.tables?.pending.updateOne(
+      filter,
+      {
+        $set: {
+          [CaptchaStatus.pending]: false
         }
+      },
+      { upsert: true }
+    );
+  }
+  /**
+   * @description Get all unsolved captchas
+   */
+  async getAllCaptchasByDatasetId(datasetId, state) {
+    const filter = {
+      datasetId,
+      solved: state === CaptchaStates.Solved
+    };
+    const cursor = this.tables?.captcha.find(filter).lean();
+    const docs = await cursor;
+    if (docs) {
+      return docs.map(({ _id, ...keepAttrs }) => keepAttrs);
     }
-    async flagProcessedDappUserSolutions(captchaIds) {
-        try {
-            await this.tables?.usersolution
-                ?.updateMany({ captchaId: { $in: captchaIds } }, { $set: { processed: true } }, { upsert: false })
-                .lean();
-        }
-        catch (err) {
-            throw new ProsopoDBError("DATABASE.SOLUTION_FLAG_FAILED", {
-                context: { error: err, captchaIds },
-            });
-        }
+    throw new ProsopoDBError("DATABASE.CAPTCHA_GET_FAILED");
+  }
+  /**
+   * @description Get all dapp user solutions by captchaIds
+   */
+  async getAllDappUserSolutions(captchaId) {
+    const filter = {
+      captchaId: { $in: captchaId }
+    };
+    const cursor = this.tables?.usersolution?.find(filter).lean();
+    const docs = await cursor;
+    if (docs) {
+      return docs.map(
+        ({ _id, ...keepAttrs }) => keepAttrs
+      );
     }
-    async flagProcessedDappUserCommitments(commitmentIds) {
-        try {
-            const distinctCommitmentIds = [...new Set(commitmentIds)];
-            await this.tables?.commitment
-                ?.updateMany({ id: { $in: distinctCommitmentIds } }, { $set: { processed: true } }, { upsert: false })
-                .lean();
+    throw new ProsopoDBError("DATABASE.SOLUTION_GET_FAILED");
+  }
+  async getDatasetIdWithSolvedCaptchasOfSizeN(solvedCaptchaCount) {
+    const cursor = this.tables?.solution.aggregate([
+      {
+        $match: {}
+      },
+      {
+        $group: {
+          _id: "$datasetId",
+          count: { $sum: 1 }
         }
-        catch (err) {
-            throw new ProsopoDBError("DATABASE.COMMITMENT_FLAG_FAILED", {
-                context: { error: err, commitmentIds },
-            });
+      },
+      {
+        $match: {
+          count: { $gte: solvedCaptchaCount }
         }
+      },
+      {
+        $sample: { size: 1 }
+      }
+    ]);
+    const docs = await cursor;
+    if (docs?.length) {
+      return docs[0]._id;
     }
-    async getScheduledTaskStatus(taskId, status) {
-        const filter = {
-            _id: taskId,
-            status: status,
-        };
-        const cursor = await this.tables?.scheduler
-            ?.findOne(filter)
-            .lean();
-        return cursor ? cursor : undefined;
-    }
-    async getLastScheduledTaskStatus(task, status) {
-        const filter = { processName: task };
-        if (status) {
-            filter.status = status;
+    throw new ProsopoDBError("DATABASE.DATASET_WITH_SOLUTIONS_GET_FAILED");
+  }
+  async getRandomSolvedCaptchasFromSingleDataset(datasetId, size) {
+    if (!isHex(datasetId)) {
+      throw new ProsopoDBError("DATABASE.INVALID_HASH", {
+        context: {
+          failedFuncName: this.getRandomSolvedCaptchasFromSingleDataset.name,
+          datasetId
         }
-        const sort = {
-            datetime: -1,
-        };
-        const cursor = await this.tables?.scheduler
-            ?.findOne(filter)
-            .sort(sort)
-            .limit(1)
-            .lean();
-        return cursor ? cursor : undefined;
-    }
-    async createScheduledTaskStatus(taskName, status) {
-        const now = new Date().getTime();
-        const doc = ScheduledTaskSchema.parse({
-            processName: taskName,
-            datetime: now,
-            status,
-        });
-        const taskRecord = await this.tables?.scheduler.create(doc);
-        return taskRecord._id;
+      });
     }
-    async updateScheduledTaskStatus(taskId, status, result) {
-        const update = {
-            status,
-            updated: new Date().getTime(),
-            ...(result && { result }),
-        };
-        const filter = { _id: taskId };
-        await this.tables?.scheduler.updateOne(filter, { $set: update }, {
-            upsert: false,
-        });
+    const sampleSize = size ? Math.abs(Math.trunc(size)) : 1;
+    const cursor = this.tables?.solution.aggregate([
+      { $match: { datasetId } },
+      { $sample: { size: sampleSize } },
+      {
+        $project: {
+          captchaId: 1,
+          captchaContentId: 1,
+          solution: 1
+        }
+      }
+    ]);
+    const docs = await cursor;
+    if (docs?.length) {
+      return docs;
     }
-    async cleanupScheduledTaskStatus(status) {
-        const filter = {
-            status,
-        };
-        await this.tables?.scheduler.deleteMany(filter);
+    throw new ProsopoDBError("DATABASE.SOLUTION_GET_FAILED", {
+      context: {
+        failedFuncName: this.getRandomSolvedCaptchasFromSingleDataset.name,
+        datasetId,
+        size
+      }
+    });
+  }
+  /**
+   * @description Get dapp user solution by ID
+   * @param {string[]} commitmentId
+   */
+  async getDappUserSolutionById(commitmentId) {
+    const filter = {
+      commitmentId
+    };
+    const project = { projection: { _id: 0 } };
+    const cursor = this.tables?.usersolution?.findOne(filter, project).lean();
+    const doc = await cursor;
+    if (doc) {
+      return doc;
     }
-    async updateClientRecords(clientRecords) {
-        const ops = clientRecords.map((record) => {
-            const clientRecord = {
-                account: record.account,
-                settings: record.settings,
-                tier: record.tier,
-            };
-            const filter = {
-                account: record.account,
-            };
-            return {
-                updateOne: {
-                    filter,
-                    update: {
-                        $set: clientRecord,
-                    },
-                    upsert: true,
-                },
-            };
-        });
-        await this.tables?.client.bulkWrite(ops);
+    throw new ProsopoDBError("DATABASE.SOLUTION_GET_FAILED", {
+      context: { failedFuncName: this.getCaptchaById.name, commitmentId }
+    });
+  }
+  /**
+   * @description Get dapp user commitment by user account
+   * @param commitmentId
+   */
+  async getDappUserCommitmentById(commitmentId) {
+    const filter = { id: commitmentId };
+    const commitmentCursor = this.tables?.commitment?.findOne(filter).lean();
+    const doc = await commitmentCursor;
+    return doc ? doc : void 0;
+  }
+  /**
+   * @description Get dapp user commitment by user account
+   * @param {string} userAccount
+   * @param {string} dappAccount
+   */
+  async getDappUserCommitmentByAccount(userAccount, dappAccount) {
+    const filter = {
+      userAccount,
+      dappAccount
+    };
+    const project = { _id: 0 };
+    const sort = { sort: { _id: -1 } };
+    const docs = await this.tables?.commitment?.find(filter, project, sort).lean();
+    return docs ? docs : [];
+  }
+  /**
+   * @description Approve a dapp user's solution
+   * @param {string[]} commitmentId
+   */
+  async approveDappUserCommitment(commitmentId) {
+    try {
+      const result = { status: CaptchaStatus.approved };
+      const updateDoc = {
+        result,
+        lastUpdatedTimestamp: Date.now()
+      };
+      const filter = { id: commitmentId };
+      await this.tables?.commitment?.findOneAndUpdate(filter, { $set: updateDoc }, { upsert: false }).lean();
+    } catch (err) {
+      throw new ProsopoDBError("DATABASE.SOLUTION_APPROVE_FAILED", {
+        context: { error: err, commitmentId }
+      });
     }
-    async getClientRecord(account) {
-        const filter = { account };
-        const doc = await this.tables?.client.findOne(filter).lean();
-        return doc ? doc : undefined;
+  }
+  /**
+   * @description Disapprove a dapp user's solution
+   * @param {string} commitmentId
+   * @param reason
+   */
+  async disapproveDappUserCommitment(commitmentId, reason) {
+    try {
+      const updateDoc = {
+        result: { status: CaptchaStatus.disapproved, reason },
+        lastUpdatedTimestamp: Date.now()
+      };
+      const filter = { id: commitmentId };
+      await this.tables?.commitment?.findOneAndUpdate(filter, { $set: updateDoc }, { upsert: false }).lean();
+    } catch (err) {
+      throw new ProsopoDBError("DATABASE.SOLUTION_APPROVE_FAILED", {
+        context: { error: err, commitmentId }
+      });
     }
-    async storeDetectorKey(detectorKey) {
-        return this.tables?.detector.create({
-            detectorKey,
-            createdAt: new Date(),
-        });
+  }
+  /**
+   * @description Flag a dapp user's solutions as used by calculated solution
+   * @param {string[]} captchaIds
+   */
+  async flagProcessedDappUserSolutions(captchaIds) {
+    try {
+      await this.tables?.usersolution?.updateMany(
+        { captchaId: { $in: captchaIds } },
+        { $set: { processed: true } },
+        { upsert: false }
+      ).lean();
+    } catch (err) {
+      throw new ProsopoDBError("DATABASE.SOLUTION_FLAG_FAILED", {
+        context: { error: err, captchaIds }
+      });
     }
-    async removeDetectorKey(detectorKey) {
-        const filter = { detectorKey };
-        const expiresAt = new Date(Date.now() + 10 * 60 * 1000);
-        await this.tables?.detector.updateOne(filter, {
-            $set: { expiresAt },
-        });
+  }
+  /**
+   * @description Flag dapp users' commitments as used by calculated solution
+   * @param {string[]} commitmentIds
+   */
+  async flagProcessedDappUserCommitments(commitmentIds) {
+    try {
+      const distinctCommitmentIds = [...new Set(commitmentIds)];
+      await this.tables?.commitment?.updateMany(
+        { id: { $in: distinctCommitmentIds } },
+        { $set: { processed: true } },
+        { upsert: false }
+      ).lean();
+    } catch (err) {
+      throw new ProsopoDBError("DATABASE.COMMITMENT_FLAG_FAILED", {
+        context: { error: err, commitmentIds }
+      });
     }
-    async getDetectorKeys() {
-        const keyRecords = await this.tables?.detector
-            .find({
-            $or: [{ expiresAt: { $exists: false } }, { expiresAt: null }],
-        }, { detectorKey: 1 })
-            .sort({ createdAt: -1 })
-            .lean();
-        return (keyRecords || []).map((record) => record.detectorKey);
+  }
+  /**
+   * @description Get a scheduled task status record by task ID and status
+   */
+  async getScheduledTaskStatus(taskId, status) {
+    const filter = {
+      _id: taskId,
+      status
+    };
+    const cursor = await this.tables?.scheduler?.findOne(filter).lean();
+    return cursor ? cursor : void 0;
+  }
+  /**
+   * @description Get the most recent scheduled task status record for a given task
+   */
+  async getLastScheduledTaskStatus(task, status) {
+    const filter = { processName: task };
+    if (status) {
+      filter.status = status;
     }
+    const sort = {
+      datetime: -1
+    };
+    const cursor = await this.tables?.scheduler?.findOne(filter).sort(sort).limit(1).lean();
+    return cursor ? cursor : void 0;
+  }
+  /**
+   * @description Create the status of a scheduled task
+   */
+  async createScheduledTaskStatus(taskName, status) {
+    const now = (/* @__PURE__ */ new Date()).getTime();
+    const doc = ScheduledTaskSchema.parse({
+      processName: taskName,
+      datetime: now,
+      status
+    });
+    const taskRecord = await this.tables?.scheduler.create(doc);
+    return taskRecord._id;
+  }
+  /**
+   * @description Update the status of a scheduled task and an optional result
+   */
+  async updateScheduledTaskStatus(taskId, status, result) {
+    const update = {
+      status,
+      updated: (/* @__PURE__ */ new Date()).getTime(),
+      ...result && { result }
+    };
+    const filter = { _id: taskId };
+    await this.tables?.scheduler.updateOne(
+      filter,
+      { $set: update },
+      {
+        upsert: false
+      }
+    );
+  }
+  /**
+   * @description Clean up the scheduled task status records
+   */
+  async cleanupScheduledTaskStatus(status) {
+    const filter = {
+      status
+    };
+    await this.tables?.scheduler.deleteMany(filter);
+  }
+  /**
+   * @description Update the client records
+   */
+  async updateClientRecords(clientRecords) {
+    const ops = clientRecords.map((record) => {
+      const clientRecord = {
+        account: record.account,
+        settings: record.settings,
+        tier: record.tier
+      };
+      const filter = {
+        account: record.account
+      };
+      return {
+        updateOne: {
+          filter,
+          update: {
+            $set: clientRecord
+          },
+          upsert: true
+        }
+      };
+    });
+    await this.tables?.client.bulkWrite(ops);
+  }
+  /**
+   * @description Get a client record
+   */
+  async getClientRecord(account) {
+    const filter = { account };
+    const doc = await this.tables?.client.findOne(filter).lean();
+    return doc ? doc : void 0;
+  }
+  /**
+   * @description Store a detector key
+   */
+  async storeDetectorKey(detectorKey) {
+    return this.tables?.detector.create({
+      detectorKey,
+      createdAt: /* @__PURE__ */ new Date()
+    });
+  }
+  /** @description Remove a detector key */
+  async removeDetectorKey(detectorKey) {
+    const filter = { detectorKey };
+    const expiresAt = new Date(Date.now() + 10 * 60 * 1e3);
+    await this.tables?.detector.updateOne(filter, {
+      $set: { expiresAt }
+    });
+  }
+  /**
+   * @description Get valid detector keys
+   */
+  async getDetectorKeys() {
+    const keyRecords = await this.tables?.detector.find(
+      {
+        $or: [{ expiresAt: { $exists: false } }, { expiresAt: null }]
+      },
+      { detectorKey: 1 }
+    ).sort({ createdAt: -1 }).lean();
+    return (keyRecords || []).map((record) => record.detectorKey);
+  }
 }
-//# sourceMappingURL=provider.js.map
+export {
+  ProviderDatabase
+};