@prosopo/database 4.1.3 → 4.2.0

package/dist/cjs/databases/provider.cjs

@@ -23,6 +23,16 @@ var PROVIDER_TABLES = [
 		modelName: "PuzzleCaptcha",
 		schema: _prosopo_types_database.PuzzleCaptchaRecordSchema
 	},
+	{
+		collectionName: "audiocaptcha",
+		modelName: "AudioCaptcha",
+		schema: _prosopo_types_database.AudioCaptchaRecordSchema
+	},
+	{
+		collectionName: "iconordercaptcha",
+		modelName: "IconOrderCaptcha",
+		schema: _prosopo_types_database.IconOrderCaptchaRecordSchema
+	},
 	{
 		collectionName: "dataset",
 		modelName: "Dataset",
@@ -640,46 +650,76 @@ var ProviderDatabase = class ProviderDatabase extends require_mongo.MongoDatabas
 			$unset: { pendingStage: 1 }
 		}).then(() => {}));
 	}
-	async storePuzzleCaptchaRecord(challenge, components, targetX, targetY, originX, originY, tolerance, providerSignature, ipAddress, headers, ja4, sessionId, ipInfo) {
-		const tables = this.getTables();
-		const puzzleCaptchaRecord = {
+	interactiveCollection(captchaType) {
+		switch (captchaType) {
+			case _prosopo_types.CaptchaType.puzzle: return {
+				table: "puzzlecaptcha",
+				label: "PuzzleCaptcha",
+				captchaType,
+				answerProjection: {
+					targetX: 1,
+					targetY: 1,
+					originX: 1,
+					originY: 1,
+					tolerance: 1,
+					puzzleEvents: 1
+				},
+				streamRecord: (record, markStored) => this.centralStreamer?.streamPuzzleRecord(record, markStored),
+				streamUpdate: (challenge, markStored) => this.centralStreamer?.streamPuzzleUpdate(() => this.getPuzzleCaptchaRecordByChallenge(challenge), markStored)
+			};
+			case _prosopo_types.CaptchaType.iconOrder: return {
+				table: "iconordercaptcha",
+				label: "IconOrderCaptcha",
+				captchaType,
+				answerProjection: {
+					targets: 1,
+					tolerance: 1,
+					clicks: 1,
+					iconOrderEvents: 1
+				},
+				streamRecord: (record, markStored) => this.centralStreamer?.streamIconOrderRecord(record, markStored),
+				streamUpdate: (challenge, markStored) => this.centralStreamer?.streamIconOrderUpdate(() => this.getIconOrderCaptchaRecordByChallenge(challenge), markStored)
+			};
+			case _prosopo_types.CaptchaType.audio: return {
+				table: "audiocaptcha",
+				label: "AudioCaptcha",
+				captchaType,
+				answerProjection: {
+					answer: 1,
+					submittedAnswer: 1,
+					replays: 1,
+					audioEvents: 1
+				},
+				streamRecord: (record, markStored) => this.centralStreamer?.streamAudioRecord(record, markStored),
+				streamUpdate: (challenge, markStored) => this.centralStreamer?.streamAudioUpdate(() => this.getAudioCaptchaRecordByChallenge(challenge), markStored)
+			};
+		}
+	}
+	markInteractiveRecordStored(collection, challenge) {
+		return (ts) => this.tables[collection.table].updateOne({
 			challenge,
-			userAccount: components.userAccount,
-			dappAccount: components.dappAccount,
-			requestedAtTimestamp: new Date(components.requestedAtTimestamp),
-			ipAddress,
-			headers,
-			ja4,
-			result: { status: _prosopo_types.CaptchaStatus.pending },
-			userSubmitted: false,
-			serverChecked: false,
-			targetX,
-			targetY,
-			originX,
-			originY,
-			tolerance,
-			providerSignature,
-			lastUpdatedTimestamp: /* @__PURE__ */ new Date(),
-			pendingStage: true,
-			sessionId,
-			ipInfo
-		};
+			lastUpdatedTimestamp: { $lte: ts }
+		}, {
+			$set: { storedAtTimestamp: ts },
+			$unset: { pendingStage: 1 }
+		}).then(() => {});
+	}
+	streamInteractiveUpdate(collection, challenge) {
+		collection.streamUpdate(challenge, this.markInteractiveRecordStored(collection, challenge));
+	}
+	async storeInteractiveCaptchaRecord(collection, record) {
+		const tables = this.getTables();
+		const { challenge, ipInfo } = record;
 		try {
-			await tables.puzzlecaptcha.create(puzzleCaptchaRecord);
+			await tables[collection.table].create(record);
 			this.logger.info(() => ({
 				data: {
 					challenge,
 					countryCode: ipInfo?.isValid ? ipInfo.countryCode : void 0
 				},
-				msg: "PuzzleCaptcha record added successfully"
+				msg: `${collection.label} record added successfully`
 			}));
-			this.centralStreamer?.streamPuzzleRecord(puzzleCaptchaRecord, (ts) => this.tables.puzzlecaptcha.updateOne({
-				challenge,
-				lastUpdatedTimestamp: { $lte: ts }
-			}, {
-				$set: { storedAtTimestamp: ts },
-				$unset: { pendingStage: 1 }
-			}).then(() => {}));
+			collection.streamRecord(record, this.markInteractiveRecordStored(collection, challenge));
 		} catch (error) {
 			const err = new _prosopo_common.ProsopoDBError("DATABASE.CAPTCHA_UPDATE_FAILED", {
 				context: {
@@ -691,24 +731,60 @@ var ProviderDatabase = class ProviderDatabase extends require_mongo.MongoDatabas
 			});
 			this.logger.error(() => ({
 				err: error,
-				msg: "Failed to add PuzzleCaptcha record"
+				msg: `Failed to add ${collection.label} record`
 			}));
 			throw err;
 		}
 	}
-	/**
-	* @description Retrieves a Puzzle Captcha record by its challenge string.
-	* @param {string} challenge The challenge string to search for.
-	* @returns {Promise<PuzzleCaptchaRecord | null>} A promise that resolves with the found record or null if not found.
-	*/
-	async getPuzzleCaptchaRecordByChallenge(challenge) {
+	pendingInteractiveRecord(challenge, components, providerSignature, ipAddress, headers, ja4, sessionId, ipInfo) {
+		return {
+			challenge,
+			userAccount: components.userAccount,
+			dappAccount: components.dappAccount,
+			requestedAtTimestamp: new Date(components.requestedAtTimestamp),
+			ipAddress,
+			headers,
+			ja4,
+			result: { status: _prosopo_types.CaptchaStatus.pending },
+			userSubmitted: false,
+			serverChecked: false,
+			providerSignature,
+			lastUpdatedTimestamp: /* @__PURE__ */ new Date(),
+			pendingStage: true,
+			sessionId,
+			ipInfo
+		};
+	}
+	async storePuzzleCaptchaRecord(challenge, components, targetX, targetY, originX, originY, tolerance, providerSignature, ipAddress, headers, ja4, sessionId, ipInfo) {
+		await this.storeInteractiveCaptchaRecord(this.interactiveCollection(_prosopo_types.CaptchaType.puzzle), {
+			...this.pendingInteractiveRecord(challenge, components, providerSignature, ipAddress, headers, ja4, sessionId, ipInfo),
+			tolerance,
+			targetX,
+			targetY,
+			originX,
+			originY
+		});
+	}
+	async storeAudioCaptchaRecord(challenge, components, answer, providerSignature, ipAddress, headers, ja4, sessionId, ipInfo) {
+		await this.storeInteractiveCaptchaRecord(this.interactiveCollection(_prosopo_types.CaptchaType.audio), {
+			...this.pendingInteractiveRecord(challenge, components, providerSignature, ipAddress, headers, ja4, sessionId, ipInfo),
+			answer
+		});
+	}
+	async storeIconOrderCaptchaRecord(challenge, components, targets, tolerance, providerSignature, ipAddress, headers, ja4, sessionId, ipInfo) {
+		await this.storeInteractiveCaptchaRecord(this.interactiveCollection(_prosopo_types.CaptchaType.iconOrder), {
+			...this.pendingInteractiveRecord(challenge, components, providerSignature, ipAddress, headers, ja4, sessionId, ipInfo),
+			targets,
+			tolerance
+		});
+	}
+	async getInteractiveCaptchaRecordByChallenge(collection, challenge, failedFuncName) {
 		if (!this.tables) throw new _prosopo_common.ProsopoDBError("DATABASE.DATABASE_UNDEFINED", {
-			context: { failedFuncName: this.getPuzzleCaptchaRecordByChallenge.name },
+			context: { failedFuncName },
 			logger: this.logger
 		});
 		try {
-			const filter = { challenge };
-			const record = await this.tables.puzzlecaptcha.findOne(filter, {
+			const record = await this.tables[collection.table].findOne({ challenge }, {
 				challenge: 1,
 				userAccount: 1,
 				dappAccount: 1,
@@ -718,12 +794,6 @@ var ProviderDatabase = class ProviderDatabase extends require_mongo.MongoDatabas
 				headers: 1,
 				ja4: 1,
 				result: 1,
-				targetX: 1,
-				targetY: 1,
-				originX: 1,
-				originY: 1,
-				tolerance: 1,
-				puzzleEvents: 1,
 				sessionId: 1,
 				ipInfo: 1,
 				deviceCapability: 1,
@@ -731,18 +801,19 @@ var ProviderDatabase = class ProviderDatabase extends require_mongo.MongoDatabas
 				serverChecked: 1,
 				userSubmitted: 1,
 				coords: 1,
-				clientMetaData: 1
+				clientMetaData: 1,
+				...collection.answerProjection
 			}).lean();
 			if (record) {
 				this.logger.info(() => ({
 					data: { challenge },
-					msg: "PuzzleCaptcha record retrieved successfully"
+					msg: `${collection.label} record retrieved successfully`
 				}));
 				return record;
 			}
 			this.logger.info(() => ({
 				data: { challenge },
-				msg: "No PuzzleCaptcha record found"
+				msg: `No ${collection.label} record found`
 			}));
 			return null;
 		} catch (error) {
@@ -755,23 +826,71 @@ var ProviderDatabase = class ProviderDatabase extends require_mongo.MongoDatabas
 			});
 			this.logger.error(() => ({
 				err,
-				msg: "Failed to retrieve PuzzleCaptcha record"
+				msg: `Failed to retrieve ${collection.label} record`
 			}));
 			throw err;
 		}
 	}
 	/**
-	* @description Updates a Puzzle Captcha record result in the database.
-	* @param {string} challenge The challenge string of the captcha to be updated.
-	* @param result
-	* @param serverChecked
-	* @param userSubmitted
-	* @param userSignature
-	* @param coords
-	* @param lastUpdatedTimestamp
-	* @returns {Promise<void>} A promise that resolves when the record is updated.
+	* @description Retrieves a Puzzle Captcha record by its challenge string.
+	* @param {string} challenge The challenge string to search for.
+	* @returns {Promise<PuzzleCaptchaRecord | null>} A promise that resolves with the found record or null if not found.
 	*/
-	async updatePuzzleCaptchaRecordResult(challenge, result, serverChecked = false, userSubmitted = false, userSignature, coords, lastUpdatedTimestamp) {
+	async getPuzzleCaptchaRecordByChallenge(challenge) {
+		return this.getInteractiveCaptchaRecordByChallenge(this.interactiveCollection(_prosopo_types.CaptchaType.puzzle), challenge, this.getPuzzleCaptchaRecordByChallenge.name);
+	}
+	async getIconOrderCaptchaRecordByChallenge(challenge) {
+		return this.getInteractiveCaptchaRecordByChallenge(this.interactiveCollection(_prosopo_types.CaptchaType.iconOrder), challenge, this.getIconOrderCaptchaRecordByChallenge.name);
+	}
+	async getAudioCaptchaRecordByChallenge(challenge) {
+		return this.getInteractiveCaptchaRecordByChallenge(this.interactiveCollection(_prosopo_types.CaptchaType.audio), challenge, this.getAudioCaptchaRecordByChallenge.name);
+	}
+	/**
+	* The filter is the guard: of N concurrent submitters only one matches
+	* `userSubmitted: { $ne: true }`, where a read-then-check would let them
+	* all through to be graded. `submittedAtTimestamp` is stamped here so the
+	* record is consistent even if the caller dies before writing a result.
+	*/
+	async claimInteractiveCaptchaSubmission(collection, challenge) {
+		const tables = this.getTables();
+		try {
+			const won = (await tables[collection.table].updateOne({
+				challenge,
+				userSubmitted: { $ne: true }
+			}, { $set: {
+				userSubmitted: true,
+				submittedAtTimestamp: /* @__PURE__ */ new Date()
+			} })).modifiedCount === 1;
+			this.logger.info(() => ({
+				data: {
+					challenge,
+					won
+				},
+				msg: won ? `${collection.label} submission claimed` : `${collection.label} submission already claimed`
+			}));
+			return won;
+		} catch (error) {
+			const err = new _prosopo_common.ProsopoDBError("DATABASE.CAPTCHA_UPDATE_FAILED", {
+				context: {
+					error,
+					challenge
+				},
+				logger: this.logger
+			});
+			this.logger.error(() => ({
+				err,
+				msg: `Failed to claim ${collection.label} submission`
+			}));
+			throw err;
+		}
+	}
+	async claimIconOrderCaptchaSubmission(challenge) {
+		return this.claimInteractiveCaptchaSubmission(this.interactiveCollection(_prosopo_types.CaptchaType.iconOrder), challenge);
+	}
+	async claimAudioCaptchaSubmission(challenge) {
+		return this.claimInteractiveCaptchaSubmission(this.interactiveCollection(_prosopo_types.CaptchaType.audio), challenge);
+	}
+	async updateInteractiveCaptchaRecordResult(collection, challenge, result, serverChecked, userSubmitted, userSignature, coords, lastUpdatedTimestamp) {
 		const tables = this.getTables();
 		const timestamp = lastUpdatedTimestamp ?? /* @__PURE__ */ new Date();
 		const isDisapproved = result.status === _prosopo_types.CaptchaStatus.disapproved;
@@ -783,13 +902,13 @@ var ProviderDatabase = class ProviderDatabase extends require_mongo.MongoDatabas
 			userSignature,
 			lastUpdatedTimestamp: timestamp,
 			pendingStage: true,
-			blocked: (0, _prosopo_types.isBlockingCaptchaResult)(_prosopo_types.CaptchaType.puzzle, result),
+			blocked: (0, _prosopo_types.isBlockingCaptchaResult)(collection.captchaType, result),
 			...coords && { coords },
 			...userSubmitted && { submittedAtTimestamp: timestamp },
 			...isDisapproved && { failedAtTimestamp: timestamp }
 		};
 		try {
-			if ((await tables.puzzlecaptcha.updateOne({ challenge }, { $set: setStage })).matchedCount === 0) {
+			if ((await tables[collection.table].updateOne({ challenge }, { $set: setStage })).matchedCount === 0) {
 				const err = new _prosopo_common.ProsopoDBError("DATABASE.CAPTCHA_GET_FAILED", {
 					context: {
 						challenge,
@@ -799,7 +918,7 @@ var ProviderDatabase = class ProviderDatabase extends require_mongo.MongoDatabas
 				});
 				this.logger.info(() => ({
 					err,
-					msg: "No PuzzleCaptcha record found to update"
+					msg: `No ${collection.label} record found to update`
 				}));
 				throw err;
 			}
@@ -808,15 +927,9 @@ var ProviderDatabase = class ProviderDatabase extends require_mongo.MongoDatabas
 					challenge,
 					...setStage
 				},
-				msg: "PuzzleCaptcha record updated successfully"
+				msg: `${collection.label} record updated successfully`
 			}));
-			this.centralStreamer?.streamPuzzleUpdate(() => this.getPuzzleCaptchaRecordByChallenge(challenge), (ts) => this.tables.puzzlecaptcha.updateOne({
-				challenge,
-				lastUpdatedTimestamp: { $lte: ts }
-			}, {
-				$set: { storedAtTimestamp: ts },
-				$unset: { pendingStage: 1 }
-			}).then(() => {}));
+			this.streamInteractiveUpdate(collection, challenge);
 		} catch (error) {
 			const err = new _prosopo_common.ProsopoDBError("DATABASE.CAPTCHA_UPDATE_FAILED", {
 				context: {
@@ -828,12 +941,32 @@ var ProviderDatabase = class ProviderDatabase extends require_mongo.MongoDatabas
 			});
 			this.logger.error(() => ({
 				err,
-				msg: "Failed to update PuzzleCaptcha record"
+				msg: `Failed to update ${collection.label} record`
 			}));
 			throw err;
 		}
 	}
-	async updatePuzzleCaptchaRecord(challenge, updates) {
+	/**
+	* @description Updates a Puzzle Captcha record result in the database.
+	* @param {string} challenge The challenge string of the captcha to be updated.
+	* @param result
+	* @param serverChecked
+	* @param userSubmitted
+	* @param userSignature
+	* @param coords
+	* @param lastUpdatedTimestamp
+	* @returns {Promise<void>} A promise that resolves when the record is updated.
+	*/
+	async updatePuzzleCaptchaRecordResult(challenge, result, serverChecked = false, userSubmitted = false, userSignature, coords, lastUpdatedTimestamp) {
+		await this.updateInteractiveCaptchaRecordResult(this.interactiveCollection(_prosopo_types.CaptchaType.puzzle), challenge, result, serverChecked, userSubmitted, userSignature, coords, lastUpdatedTimestamp);
+	}
+	async updateIconOrderCaptchaRecordResult(challenge, result, serverChecked = false, userSubmitted = false, userSignature, coords, lastUpdatedTimestamp) {
+		await this.updateInteractiveCaptchaRecordResult(this.interactiveCollection(_prosopo_types.CaptchaType.iconOrder), challenge, result, serverChecked, userSubmitted, userSignature, coords, lastUpdatedTimestamp);
+	}
+	async updateAudioCaptchaRecordResult(challenge, result, serverChecked = false, userSubmitted = false, userSignature, coords, lastUpdatedTimestamp) {
+		await this.updateInteractiveCaptchaRecordResult(this.interactiveCollection(_prosopo_types.CaptchaType.audio), challenge, result, serverChecked, userSubmitted, userSignature, coords, lastUpdatedTimestamp);
+	}
+	async updateInteractiveCaptchaRecord(collection, challenge, updates) {
 		const tables = this.getTables();
 		const timestamp = /* @__PURE__ */ new Date();
 		const baseSet = {
@@ -843,19 +976,22 @@ var ProviderDatabase = class ProviderDatabase extends require_mongo.MongoDatabas
 			...updates.userSubmitted === true && { submittedAtTimestamp: timestamp },
 			...updates.result?.status === _prosopo_types.CaptchaStatus.disapproved && { failedAtTimestamp: timestamp }
 		};
-		await tables.puzzlecaptcha.updateOne({ challenge }, { $set: baseSet });
-		this.centralStreamer?.streamPuzzleUpdate(() => this.getPuzzleCaptchaRecordByChallenge(challenge), (ts) => this.tables.puzzlecaptcha.updateOne({
-			challenge,
-			lastUpdatedTimestamp: { $lte: ts }
-		}, {
-			$set: { storedAtTimestamp: ts },
-			$unset: { pendingStage: 1 }
-		}).then(() => {}));
+		await tables[collection.table].updateOne({ challenge }, { $set: baseSet });
+		this.streamInteractiveUpdate(collection, challenge);
 	}
-	async markPuzzleCaptchaRecordChecked(challenge) {
+	async updatePuzzleCaptchaRecord(challenge, updates) {
+		await this.updateInteractiveCaptchaRecord(this.interactiveCollection(_prosopo_types.CaptchaType.puzzle), challenge, updates);
+	}
+	async updateIconOrderCaptchaRecord(challenge, updates) {
+		await this.updateInteractiveCaptchaRecord(this.interactiveCollection(_prosopo_types.CaptchaType.iconOrder), challenge, updates);
+	}
+	async updateAudioCaptchaRecord(challenge, updates) {
+		await this.updateInteractiveCaptchaRecord(this.interactiveCollection(_prosopo_types.CaptchaType.audio), challenge, updates);
+	}
+	async markInteractiveCaptchaRecordChecked(collection, challenge) {
 		const tables = this.getTables();
 		const timestamp = /* @__PURE__ */ new Date();
-		if ((await tables.puzzlecaptcha.updateOne({
+		if ((await tables[collection.table].updateOne({
 			challenge,
 			serverChecked: { $ne: true }
 		}, { $set: {
@@ -864,15 +1000,18 @@ var ProviderDatabase = class ProviderDatabase extends require_mongo.MongoDatabas
 			verifiedAtTimestamp: timestamp,
 			pendingStage: true
 		} })).modifiedCount === 0) return false;
-		this.centralStreamer?.streamPuzzleUpdate(() => this.getPuzzleCaptchaRecordByChallenge(challenge), (ts) => this.tables.puzzlecaptcha.updateOne({
-			challenge,
-			lastUpdatedTimestamp: { $lte: ts }
-		}, {
-			$set: { storedAtTimestamp: ts },
-			$unset: { pendingStage: 1 }
-		}).then(() => {}));
+		this.streamInteractiveUpdate(collection, challenge);
 		return true;
 	}
+	async markIconOrderCaptchaRecordChecked(challenge) {
+		return this.markInteractiveCaptchaRecordChecked(this.interactiveCollection(_prosopo_types.CaptchaType.iconOrder), challenge);
+	}
+	async markAudioCaptchaRecordChecked(challenge) {
+		return this.markInteractiveCaptchaRecordChecked(this.interactiveCollection(_prosopo_types.CaptchaType.audio), challenge);
+	}
+	async markPuzzleCaptchaRecordChecked(challenge) {
+		return this.markInteractiveCaptchaRecordChecked(this.interactiveCollection(_prosopo_types.CaptchaType.puzzle), challenge);
+	}
 	/** @description Get serverChecked Dapp User image captcha commitments from the commitments table
 	*/
 	async getCheckedDappUserCommitments() {
@@ -966,13 +1105,13 @@ var ProviderDatabase = class ProviderDatabase extends require_mongo.MongoDatabas
 		} }], { updatePipeline: true });
 	}
 	/**
-	* Counts server-checked captcha records across image (`commitment`),
-	* PoW and puzzle collections whose `metadata.emailNormalised` matches.
-	* Each collection carries the same partial index
-	* (`spamEmailCount_partial`) so all three counts hit index-only scans.
-	* The three counts are summed — one dapp can mix captcha types over
-	* time, and per-email rate limits should apply across the whole
-	* verified surface, not per-type.
+	* Counts server-checked captcha records across the image (`commitment`),
+	* PoW, puzzle and icon-order collections whose `metadata.emailNormalised`
+	* matches. Each collection carries the same partial index
+	* (`spamEmailCount_partial`) so every count hits an index-only scan. The
+	* counts are summed — one dapp can mix captcha types over time, and
+	* per-email rate limits should apply across the whole verified surface,
+	* not per-type.
 	*/
 	async countCommitmentsByNormalisedEmail(dappAccount, emailNormalised) {
 		if (!emailNormalised) return 0;
@@ -982,12 +1121,13 @@ var ProviderDatabase = class ProviderDatabase extends require_mongo.MongoDatabas
 			serverChecked: true,
 			"metadata.emailNormalised": emailNormalised
 		};
-		const [imgCount, powCount, puzzleCount] = await Promise.all([
+		return (await Promise.all([
 			tables.commitment.countDocuments(filter),
 			tables.powcaptcha.countDocuments(filter),
-			tables.puzzlecaptcha.countDocuments(filter)
-		]);
-		return imgCount + powCount + puzzleCount;
+			tables.puzzlecaptcha.countDocuments(filter),
+			tables.iconordercaptcha.countDocuments(filter),
+			tables.audiocaptcha.countDocuments(filter)
+		])).reduce((total, count) => total + count, 0);
 	}
 	/**
 	* @description Get Dapp User PoW captcha commitments that have not been counted towards the client's total

package/dist/databases/captcha.d.ts

@@ -1,5 +1,5 @@
 import { type Logger } from "@prosopo/logger";
-import { type CaptchaProperties, type ICaptchaDatabase, type PoWCaptchaRecord, type PuzzleCaptchaRecord, type StoredSession, type Tables, type UserCommitmentRecord } from "@prosopo/types-database";
+import { type AudioCaptchaRecord, type CaptchaProperties, type ICaptchaDatabase, type IconOrderCaptchaRecord, type PoWCaptchaRecord, type PuzzleCaptchaRecord, type StoredSession, type Tables, type UserCommitmentRecord } from "@prosopo/types-database";
 import type { QueryFilter } from "mongoose";
 import { type MongoConnectionTimeouts, MongoDatabase } from "../base/index.js";
 declare enum TableNames {
@@ -7,7 +7,9 @@ declare enum TableNames {
     session = "session",
     commitment = "commitment",
     powcaptcha = "powcaptcha",
-    puzzlecaptcha = "puzzlecaptcha"
+    puzzlecaptcha = "puzzlecaptcha",
+    audiocaptcha = "audiocaptcha",
+    iconordercaptcha = "iconordercaptcha"
 }
 export declare class CaptchaDatabase extends MongoDatabase implements ICaptchaDatabase {
     tables: Tables<TableNames>;
@@ -18,11 +20,14 @@ export declare class CaptchaDatabase extends MongoDatabase implements ICaptchaDa
     ensureIndexes(): Promise<void>;
     private static normaliseCompositeIp;
     private static normaliseDocCompositeIps;
-    saveCaptchas(sessionEvents: StoredSession[], imageCaptchaEvents: UserCommitmentRecord[], powCaptchaEvents: PoWCaptchaRecord[], puzzleCaptchaEvents?: PuzzleCaptchaRecord[]): Promise<void>;
+    saveCaptchas(sessionEvents: StoredSession[], imageCaptchaEvents: UserCommitmentRecord[], powCaptchaEvents: PoWCaptchaRecord[], puzzleCaptchaEvents?: PuzzleCaptchaRecord[], iconOrderCaptchaEvents?: IconOrderCaptchaRecord[], audioCaptchaEvents?: AudioCaptchaRecord[]): Promise<void>;
+    private upsertChallengeRecords;
     getCaptchas(filter?: QueryFilter<CaptchaProperties>, limit?: number): Promise<{
         userCommitmentRecords: UserCommitmentRecord[];
         powCaptchaRecords: PoWCaptchaRecord[];
         puzzleCaptchaRecords: PuzzleCaptchaRecord[];
+        audioCaptchaRecords: AudioCaptchaRecord[];
+        iconOrderCaptchaRecords: IconOrderCaptchaRecord[];
     }>;
 }
 export {};

package/dist/databases/captcha.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"captcha.d.ts","sourceRoot":"","sources":["../../src/databases/captcha.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,KAAK,MAAM,EAAa,MAAM,iBAAiB,CAAC;AACzD,OAAO,EACN,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,EAGxB,KAAK,aAAa,EAGlB,KAAK,MAAM,EACX,KAAK,oBAAoB,EACzB,MAAM,yBAAyB,CAAC;AAajC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAC5C,OAAO,EAAE,KAAK,uBAAuB,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAI/E,aAAK,UAAU;IACd,iBAAiB,sBAAsB;IACvC,OAAO,YAAY;IACnB,UAAU,eAAe;IACzB,UAAU,eAAe;IACzB,aAAa,kBAAkB;CAC/B;AAyBD,qBAAa,eAAgB,SAAQ,aAAc,YAAW,gBAAgB;IAC7E,MAAM,EAAE,MAAM,CAAC,UAAU,CAAC,CAAC;IAC3B,OAAO,CAAC,cAAc,CAAS;gBAG9B,GAAG,EAAE,MAAM,EACX,MAAM,CAAC,EAAE,MAAM,EACf,UAAU,CAAC,EAAE,MAAM,EACnB,MAAM,CAAC,EAAE,MAAM,EACf,QAAQ,CAAC,EAAE,uBAAuB;IAMpB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAUvC,SAAS,IAAI,MAAM,CAAC,UAAU,CAAC;IAUzB,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC;IAqDpC,OAAO,CAAC,MAAM,CAAC,oBAAoB;IAoBnC,OAAO,CAAC,MAAM,CAAC,wBAAwB;IAajC,YAAY,CACjB,aAAa,EAAE,aAAa,EAAE,EAC9B,kBAAkB,EAAE,oBAAoB,EAAE,EAC1C,gBAAgB,EAAE,gBAAgB,EAAE,EACpC,mBAAmB,GAAE,mBAAmB,EAAO;IAmI1C,WAAW,CAChB,MAAM,GAAE,WAAW,CAAC,iBAAiB,CAAM,EAC3C,KAAK,SAAM,GACT,OAAO,CAAC;QACV,qBAAqB,EAAE,oBAAoB,EAAE,CAAC;QAC9C,iBAAiB,EAAE,gBAAgB,EAAE,CAAC;QACtC,oBAAoB,EAAE,mBAAmB,EAAE,CAAC;KAC5C,CAAC;CAsCF"}
+{"version":3,"file":"captcha.d.ts","sourceRoot":"","sources":["../../src/databases/captcha.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,KAAK,MAAM,EAAa,MAAM,iBAAiB,CAAC;AACzD,OAAO,EACN,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EACrB,KAAK,sBAAsB,EAC3B,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,EAKxB,KAAK,aAAa,EAGlB,KAAK,MAAM,EACX,KAAK,oBAAoB,EACzB,MAAM,yBAAyB,CAAC;AAajC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAC5C,OAAO,EAAE,KAAK,uBAAuB,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAI/E,aAAK,UAAU;IACd,iBAAiB,sBAAsB;IACvC,OAAO,YAAY;IACnB,UAAU,eAAe;IACzB,UAAU,eAAe;IACzB,aAAa,kBAAkB;IAC/B,YAAY,iBAAiB;IAC7B,gBAAgB,qBAAqB;CACrC;AAmCD,qBAAa,eAAgB,SAAQ,aAAc,YAAW,gBAAgB;IAC7E,MAAM,EAAE,MAAM,CAAC,UAAU,CAAC,CAAC;IAC3B,OAAO,CAAC,cAAc,CAAS;gBAG9B,GAAG,EAAE,MAAM,EACX,MAAM,CAAC,EAAE,MAAM,EACf,UAAU,CAAC,EAAE,MAAM,EACnB,MAAM,CAAC,EAAE,MAAM,EACf,QAAQ,CAAC,EAAE,uBAAuB;IAMpB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAUvC,SAAS,IAAI,MAAM,CAAC,UAAU,CAAC;IAUzB,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC;IAqDpC,OAAO,CAAC,MAAM,CAAC,oBAAoB;IAoBnC,OAAO,CAAC,MAAM,CAAC,wBAAwB;IAajC,YAAY,CACjB,aAAa,EAAE,aAAa,EAAE,EAC9B,kBAAkB,EAAE,oBAAoB,EAAE,EAC1C,gBAAgB,EAAE,gBAAgB,EAAE,EACpC,mBAAmB,GAAE,mBAAmB,EAAO,EAC/C,sBAAsB,GAAE,sBAAsB,EAAO,EACrD,kBAAkB,GAAE,kBAAkB,EAAO;YA0HhC,sBAAsB;IAuC9B,WAAW,CAChB,MAAM,GAAE,WAAW,CAAC,iBAAiB,CAAM,EAC3C,KAAK,SAAM,GACT,OAAO,CAAC;QACV,qBAAqB,EAAE,oBAAoB,EAAE,CAAC;QAC9C,iBAAiB,EAAE,gBAAgB,EAAE,CAAC;QACtC,oBAAoB,EAAE,mBAAmB,EAAE,CAAC;QAC5C,mBAAmB,EAAE,kBAAkB,EAAE,CAAC;QAC1C,uBAAuB,EAAE,sBAAsB,EAAE,CAAC;KAClD,CAAC;CAkDF"}

package/dist/databases/captcha.js

@@ -1,7 +1,7 @@
 import { MongoDatabase } from "../base/mongo.js";
 import { ProsopoDBError } from "@prosopo/common";
 import { getLogger } from "@prosopo/logger";
-import { StoredPoWCaptchaRecordSchema, StoredPuzzleCaptchaRecordSchema, StoredSessionRecordSchema, StoredUserCommitmentRecordSchema } from "@prosopo/types-database";
+import { StoredAudioCaptchaRecordSchema, StoredIconOrderCaptchaRecordSchema, StoredPoWCaptchaRecordSchema, StoredPuzzleCaptchaRecordSchema, StoredSessionRecordSchema, StoredUserCommitmentRecordSchema } from "@prosopo/types-database";
 import { Decimal128, Long } from "bson";
 //#region src/databases/captcha.ts
 var isBsonLong = (value) => typeof value === "object" && value !== null && "_bsontype" in value && value._bsontype === "Long";
@@ -26,6 +26,16 @@ var CAPTCHA_TABLES = [
 		collectionName: "puzzlecaptcha",
 		modelName: "PuzzleCaptcha",
 		schema: StoredPuzzleCaptchaRecordSchema
+	},
+	{
+		collectionName: "audiocaptcha",
+		modelName: "AudioCaptcha",
+		schema: StoredAudioCaptchaRecordSchema
+	},
+	{
+		collectionName: "iconordercaptcha",
+		modelName: "IconOrderCaptcha",
+		schema: StoredIconOrderCaptchaRecordSchema
 	}
 ];
 var CaptchaDatabase = class CaptchaDatabase extends MongoDatabase {
@@ -111,7 +121,7 @@ var CaptchaDatabase = class CaptchaDatabase extends MongoDatabase {
 			providedIp: CaptchaDatabase.normaliseCompositeIp(doc.providedIp)
 		};
 	}
-	async saveCaptchas(sessionEvents, imageCaptchaEvents, powCaptchaEvents, puzzleCaptchaEvents = []) {
+	async saveCaptchas(sessionEvents, imageCaptchaEvents, powCaptchaEvents, puzzleCaptchaEvents = [], iconOrderCaptchaEvents = [], audioCaptchaEvents = []) {
 		await this.connect();
 		if (sessionEvents.length) {
 			const result = await this.tables.session.bulkWrite(sessionEvents.map((document) => {
@@ -173,35 +183,41 @@ var CaptchaDatabase = class CaptchaDatabase extends MongoDatabase {
 				msg: "Mongo Saved PoW Events"
 			}));
 		}
-		if (puzzleCaptchaEvents.length) {
-			const result = await this.tables.puzzlecaptcha.bulkWrite(puzzleCaptchaEvents.map((doc) => {
-				const { _id, ...safeDoc } = doc;
-				const normalised = CaptchaDatabase.normaliseDocCompositeIps(safeDoc);
-				return { updateOne: {
-					filter: { challenge: normalised.challenge },
-					update: { $set: normalised },
-					upsert: true
-				} };
-			}));
-			logger.info(() => ({
-				data: {
-					upsertedCount: result.upsertedCount,
-					matchedCount: result.matchedCount,
-					modifiedCount: result.modifiedCount,
-					totalProcessed: puzzleCaptchaEvents.length
-				},
-				msg: "Mongo Saved Puzzle Events"
-			}));
-		}
+		await this.upsertChallengeRecords("puzzlecaptcha", puzzleCaptchaEvents, "Mongo Saved Puzzle Events");
+		await this.upsertChallengeRecords("audiocaptcha", audioCaptchaEvents, "Mongo Saved Audio Events");
+		await this.upsertChallengeRecords("iconordercaptcha", iconOrderCaptchaEvents, "Mongo Saved Icon Order Events");
 		await this.close();
 	}
+	async upsertChallengeRecords(table, records, msg) {
+		if (!records.length) return;
+		const result = await this.tables[table].bulkWrite(records.map((doc) => {
+			const { _id, ...safeDoc } = doc;
+			const normalised = CaptchaDatabase.normaliseDocCompositeIps(safeDoc);
+			return { updateOne: {
+				filter: { challenge: normalised.challenge },
+				update: { $set: normalised },
+				upsert: true
+			} };
+		}));
+		logger.info(() => ({
+			data: {
+				upsertedCount: result.upsertedCount,
+				matchedCount: result.matchedCount,
+				modifiedCount: result.modifiedCount,
+				totalProcessed: records.length
+			},
+			msg
+		}));
+	}
 	async getCaptchas(filter = {}, limit = 100) {
 		await this.connect();
 		try {
 			return {
 				userCommitmentRecords: await this.tables.commitment.find(filter).limit(limit).lean(),
 				powCaptchaRecords: await this.tables.powcaptcha.find(filter).limit(limit).lean(),
-				puzzleCaptchaRecords: await this.tables.puzzlecaptcha.find(filter).limit(limit).lean()
+				puzzleCaptchaRecords: await this.tables.puzzlecaptcha.find(filter).limit(limit).lean(),
+				audioCaptchaRecords: await this.tables.audiocaptcha.find(filter).limit(limit).lean(),
+				iconOrderCaptchaRecords: await this.tables.iconordercaptcha.find(filter).limit(limit).lean()
 			};
 		} catch (error) {
 			throw new ProsopoDBError("DATABASE.QUERY_ERROR", {