@prosopo/provider 0.1.14

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAaA,cAAc,SAAS,CAAA;AACvB,cAAc,QAAQ,CAAA;AACtB,cAAc,SAAS,CAAA;AACvB,cAAc,OAAO,CAAA"}

package/dist/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+// Copyright 2021-2022 Prosopo (UK) Ltd.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+tslib_1.__exportStar(require("./tasks"), exports);
+tslib_1.__exportStar(require("./util"), exports);
+tslib_1.__exportStar(require("./batch"), exports);
+tslib_1.__exportStar(require("./api"), exports);
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAAA,wCAAwC;AACxC,EAAE;AACF,kEAAkE;AAClE,mEAAmE;AACnE,0CAA0C;AAC1C,EAAE;AACF,iDAAiD;AACjD,EAAE;AACF,sEAAsE;AACtE,oEAAoE;AACpE,2EAA2E;AAC3E,sEAAsE;AACtE,iCAAiC;AACjC,kDAAuB;AACvB,iDAAsB;AACtB,kDAAuB;AACvB,gDAAqB"}

package/dist/scheduler.d.ts

@@ -0,0 +1,4 @@
+import { KeyringPair } from '@polkadot/keyring/types';
+import { ProsopoConfig } from '@prosopo/types';
+export default function (pair: KeyringPair, config: ProsopoConfig): Promise<void>;
+//# sourceMappingURL=scheduler.d.ts.map

package/dist/scheduler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduler.d.ts","sourceRoot":"","sources":["../src/scheduler.ts"],"names":[],"mappings":"AAkBA,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAA;AACrD,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AAI9C,yBAA+B,IAAI,EAAE,WAAW,EAAE,MAAM,EAAE,aAAa,iBActE"}

package/dist/scheduler.js

@@ -0,0 +1,34 @@
+"use strict";
+// Copyright 2021-2022 Prosopo (UK) Ltd.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// [object Object]
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+const cron_1 = require("cron");
+const env_1 = require("@prosopo/env");
+const tasks_1 = require("./tasks/tasks");
+async function default_1(pair, config) {
+    const env = new env_1.ProviderEnvironment(pair, config);
+    await env.isReady();
+    const tasks = new tasks_1.Tasks(env);
+    const job = new cron_1.CronJob(process.argv[2], () => {
+        env.logger.debug('It works....');
+        tasks.calculateCaptchaSolutions().catch((err) => {
+            env.logger.error(err);
+        });
+    });
+    job.start();
+}
+exports.default = default_1;
+//# sourceMappingURL=scheduler.js.map

package/dist/scheduler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduler.js","sourceRoot":"","sources":["../src/scheduler.ts"],"names":[],"mappings":";AAAA,wCAAwC;AACxC,EAAE;AACF,kEAAkE;AAClE,mEAAmE;AACnE,0CAA0C;AAC1C,EAAE;AACF,iDAAiD;AACjD,EAAE;AACF,sEAAsE;AACtE,oEAAoE;AACpE,2EAA2E;AAC3E,sEAAsE;AACtE,iCAAiC;AACjC,kBAAkB;AAClB,sCAAsC;;AAEtC,+BAA8B;AAI9B,sCAAkD;AAClD,yCAAqC;AAEtB,KAAK,oBAAW,IAAiB,EAAE,MAAqB;IACnE,MAAM,GAAG,GAAG,IAAI,yBAAmB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAA;IAEjD,MAAM,GAAG,CAAC,OAAO,EAAE,CAAA;IAEnB,MAAM,KAAK,GAAG,IAAI,aAAK,CAAC,GAAG,CAAC,CAAA;IAC5B,MAAM,GAAG,GAAG,IAAI,cAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE;QAC1C,GAAG,CAAC,MAAM,CAAC,KAAK,CAAC,cAAc,CAAC,CAAA;QAChC,KAAK,CAAC,yBAAyB,EAAE,CAAC,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE;YAC5C,GAAG,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;QACzB,CAAC,CAAC,CAAA;IACN,CAAC,CAAC,CAAA;IAEF,GAAG,CAAC,KAAK,EAAE,CAAA;AACf,CAAC;AAdD,4BAcC"}

package/dist/tasks/index.d.ts

@@ -0,0 +1,2 @@
+export * from './tasks';
+//# sourceMappingURL=index.d.ts.map

package/dist/tasks/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tasks/index.ts"],"names":[],"mappings":"AAaA,cAAc,SAAS,CAAA"}

package/dist/tasks/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+// Copyright 2021-2022 Prosopo (UK) Ltd.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+tslib_1.__exportStar(require("./tasks"), exports);
+//# sourceMappingURL=index.js.map

package/dist/tasks/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/tasks/index.ts"],"names":[],"mappings":";;;AAAA,wCAAwC;AACxC,EAAE;AACF,kEAAkE;AAClE,mEAAmE;AACnE,0CAA0C;AAC1C,EAAE;AACF,iDAAiD;AACjD,EAAE;AACF,sEAAsE;AACtE,oEAAoE;AACpE,2EAA2E;AAC3E,sEAAsE;AACtE,iCAAiC;AACjC,kDAAuB"}

package/dist/tasks/tasks.d.ts

@@ -0,0 +1,108 @@
+import { ArgumentTypes, Captcha, CaptchaConfig, CaptchaSolution, CaptchaSolutionConfig, CaptchaWithProof, DappUserSolutionResult, DatasetRaw, Hash, PendingCaptchaRequest } from '@prosopo/types';
+import { CaptchaMerkleTree } from '@prosopo/datasets';
+import { Database, UserCommitmentRecord } from '@prosopo/types-database';
+import { Header } from '@polkadot/types/interfaces/runtime/index';
+import { Logger } from '@prosopo/common';
+import { ProsopoCaptchaContract } from '@prosopo/contract';
+import { ProviderEnvironment } from '@prosopo/types-env';
+import { SubmittableResult } from '@polkadot/api';
+/**
+ * @description Tasks that are shared by the API and CLI
+ */
+export declare class Tasks {
+    contract: ProsopoCaptchaContract;
+    db: Database;
+    captchaConfig: CaptchaConfig;
+    captchaSolutionConfig: CaptchaSolutionConfig;
+    logger: Logger;
+    constructor(env: ProviderEnvironment);
+    providerSetDatasetFromFile(file: JSON): Promise<SubmittableResult | undefined>;
+    providerSetDataset(datasetRaw: DatasetRaw): Promise<SubmittableResult | undefined>;
+    /**
+     * @description Get random captchas that are solved or not solved, along with the merkle proof for each
+     * @param {string}   datasetId  the id of the data set
+     * @param {boolean}  solved    `true` when captcha is solved
+     * @param {number}   size       the number of records to be returned
+     */
+    getCaptchaWithProof(datasetId: ArgumentTypes.Hash, solved: boolean, size: number): Promise<CaptchaWithProof[]>;
+    /**
+     * Validate and store the text captcha solution(s) from the Dapp User in a web2 environment
+     * @param {string} userAccount
+     * @param {string} dappAccount
+     * @param {string} requestHash
+     * @param {JSON} captchas
+     * @param {string} signature
+     * @return {Promise<DappUserSolutionResult>} result containing the contract event
+     */
+    dappUserSolution(userAccount: string, dappAccount: string, requestHash: string, captchas: CaptchaSolution[], signature: string): Promise<DappUserSolutionResult>;
+    /**
+     * Validate that the dapp is active in the contract
+     */
+    dappIsActive(dappAccount: string): Promise<boolean>;
+    /**
+     * Validate that the provider is active in the contract
+     */
+    providerIsActive(providerAccount: string): Promise<boolean>;
+    /**
+     * Validate length of received captchas array matches length of captchas found in database
+     * Validate that the datasetId is the same for all captchas and is equal to the datasetId on the stored captchas
+     */
+    validateReceivedCaptchasAgainstStoredCaptchas(captchas: CaptchaSolution[]): Promise<{
+        storedCaptchas: Captcha[];
+        receivedCaptchas: CaptchaSolution[];
+        captchaIds: string[];
+    }>;
+    /**
+     * Build merkle tree and get commitment from contract, returning the tree, commitment, and commitmentId
+     * @param {CaptchaSolution[]} captchaSolutions
+     * @returns {Promise<{ tree: CaptchaMerkleTree, commitment: CaptchaSolutionCommitment, commitmentId: string }>}
+     */
+    buildTreeAndGetCommitmentId(captchaSolutions: CaptchaSolution[]): Promise<{
+        tree: CaptchaMerkleTree;
+        commitmentId: string;
+    }>;
+    /**
+     * Validate that a Dapp User is responding to their own pending captcha request
+     * @param {string} requestHash
+     * @param {PendingCaptchaRequest} pendingRecord
+     * @param {string} userAccount
+     * @param {string[]} captchaIds
+     */
+    validateDappUserSolutionRequestIsPending(requestHash: string, pendingRecord: PendingCaptchaRequest, userAccount: string, captchaIds: string[]): Promise<boolean>;
+    /**
+     * Get two random captchas from specified dataset, create the response and store a hash of it, marked as pending
+     * @param {string} datasetId
+     * @param {string} userAccount
+     */
+    getRandomCaptchasAndRequestHash(datasetId: string, userAccount: string): Promise<{
+        captchas: CaptchaWithProof[];
+        requestHash: string;
+    }>;
+    /**
+     * Apply new captcha solutions to captcha dataset and recalculate merkle tree
+     */
+    calculateCaptchaSolutions(): Promise<number>;
+    /**
+     * Block by block search for blockNo
+     */
+    isRecentBlock(contract: any, header: Header, blockNo: number, depth?: number): any;
+    /**
+     * Validate that provided `datasetId` was a result of calling `get_random_provider` method
+     * @param {string} userAccount - Same user that called `get_random_provider`
+     * @param {string} dappContractAccount - account of dapp that is requesting captcha
+     * @param {string} datasetId - `captcha_dataset_id` from the result of `get_random_provider`
+     * @param {string} blockNumber - Block on which `get_random_provider` was called
+     */
+    validateProviderWasRandomlyChosen(userAccount: string, dappContractAccount: string, datasetId: string | Hash, blockNumber: number): Promise<void>;
+    /**
+     * Get payment info for a transaction
+     * @param {string} userAccount
+     * @param {string} blockHash
+     * @param {string} txHash
+     * @returns {Promise<RuntimeDispatchInfo|null>}
+     */
+    private getPaymentInfo;
+    getDappUserCommitmentById(commitmentId: string): Promise<UserCommitmentRecord>;
+    getDappUserCommitmentByAccount(userAccount: string): Promise<UserCommitmentRecord | undefined>;
+}
+//# sourceMappingURL=tasks.d.ts.map

package/dist/tasks/tasks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tasks.d.ts","sourceRoot":"","sources":["../../src/tasks/tasks.ts"],"names":[],"mappings":"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"}

package/dist/tasks/tasks.js

@@ -0,0 +1,405 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tasks = void 0;
+const tslib_1 = require("tslib");
+// Copyright 2021-2022 Prosopo (UK) Ltd.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+const types_1 = require("@prosopo/types");
+const datasets_1 = require("@prosopo/datasets");
+const common_1 = require("@prosopo/common");
+const contract_1 = require("@prosopo/contract");
+const util_1 = require("../util");
+const util_2 = require("@polkadot/util");
+const util_crypto_1 = require("@polkadot/util-crypto");
+const contract_2 = require("@prosopo/contract");
+const consola_1 = tslib_1.__importDefault(require("consola"));
+/**
+ * @description Tasks that are shared by the API and CLI
+ */
+class Tasks {
+    contract;
+    db;
+    captchaConfig;
+    captchaSolutionConfig;
+    logger;
+    constructor(env) {
+        if (!env.contractInterface) {
+            throw new common_1.ProsopoEnvError('CONTRACT.CONTRACT_UNDEFINED', this.constructor.name, {}, { contractAddress: env.contractAddress });
+        }
+        this.contract = env.contractInterface;
+        this.db = env.db;
+        this.captchaConfig = env.config.captchas;
+        this.captchaSolutionConfig = env.config.captchaSolutions;
+        this.logger = (0, common_1.logger)(env.config.logLevel, 'Tasks');
+    }
+    async providerSetDatasetFromFile(file) {
+        const datasetRaw = (0, datasets_1.parseCaptchaDataset)(file);
+        return await this.providerSetDataset(datasetRaw);
+    }
+    async providerSetDataset(datasetRaw) {
+        const dataset = await (0, datasets_1.buildDataset)(datasetRaw);
+        if (!dataset.datasetId || !dataset.datasetContentId) {
+            throw new common_1.ProsopoEnvError('DATASET.DATASET_ID_UNDEFINED', this.providerSetDataset.name);
+        }
+        await this.db?.storeDataset(dataset);
+        const txResult = await this.contract.methods.providerSetDataset(dataset.datasetId, dataset.datasetContentId, {
+            value: 0,
+        });
+        return txResult.result;
+    }
+    // Other tasks
+    /**
+     * @description Get random captchas that are solved or not solved, along with the merkle proof for each
+     * @param {string}   datasetId  the id of the data set
+     * @param {boolean}  solved    `true` when captcha is solved
+     * @param {number}   size       the number of records to be returned
+     */
+    async getCaptchaWithProof(datasetId, solved, size) {
+        const captchaDocs = await this.db.getRandomCaptcha(solved, datasetId, size);
+        if (captchaDocs) {
+            const captchas = [];
+            for (const captcha of captchaDocs) {
+                const datasetDetails = await this.db.getDatasetDetails(datasetId);
+                const tree = new datasets_1.CaptchaMerkleTree();
+                if (datasetDetails.contentTree) {
+                    tree.layers = datasetDetails.contentTree;
+                    const proof = tree.proof(captcha.captchaContentId);
+                    // cannot pass solution to dapp user as they are required to solve the captcha!
+                    delete captcha.solution;
+                    captcha.items = (0, util_1.shuffleArray)(captcha.items);
+                    captchas.push({ captcha, proof });
+                }
+            }
+            return captchas;
+        }
+        throw new common_1.ProsopoEnvError('DATABASE.CAPTCHA_GET_FAILED', this.getCaptchaWithProof.name, {}, { datasetId, solved, size });
+    }
+    /**
+     * Validate and store the text captcha solution(s) from the Dapp User in a web2 environment
+     * @param {string} userAccount
+     * @param {string} dappAccount
+     * @param {string} requestHash
+     * @param {JSON} captchas
+     * @param {string} signature
+     * @return {Promise<DappUserSolutionResult>} result containing the contract event
+     */
+    async dappUserSolution(userAccount, dappAccount, requestHash, captchas, signature // the signature to indicate ownership of account (web2 only)
+    ) {
+        if (!(await this.dappIsActive(dappAccount))) {
+            throw new common_1.ProsopoEnvError('CONTRACT.DAPP_NOT_ACTIVE', this.getPaymentInfo.name, {}, { dappAccount });
+        }
+        // check that the signature is valid (i.e. the web2 user has signed the message with their private key, proving they own their account)
+        const verification = (0, util_crypto_1.signatureVerify)((0, util_2.stringToHex)(requestHash), signature, userAccount);
+        if (!verification.isValid) {
+            // the signature is not valid, so the user is not the owner of the account. May have given a false account address with good reputation in an attempt to impersonate
+            throw new common_1.ProsopoEnvError('GENERAL.INVALID_SIGNATURE', this.dappUserSolution.name, {}, { userAccount });
+        }
+        let response = {
+            captchas: [],
+            solutionApproved: false,
+        };
+        const { storedCaptchas, receivedCaptchas, captchaIds } = await this.validateReceivedCaptchasAgainstStoredCaptchas(captchas);
+        const { tree, commitmentId } = await this.buildTreeAndGetCommitmentId(receivedCaptchas);
+        const provider = (await this.contract.methods.getProvider(this.contract.pair.address, {})).value
+            .unwrap()
+            .unwrap();
+        const pendingRecord = await this.db.getDappUserPending(requestHash);
+        const pendingRequest = await this.validateDappUserSolutionRequestIsPending(requestHash, pendingRecord, userAccount, captchaIds);
+        // Only do stuff if the request is in the local DB
+        const userSignature = (0, util_2.hexToU8a)(signature);
+        const blockNumber = (await (0, contract_1.getBlockNumber)(this.contract.api)).toNumber();
+        if (pendingRequest) {
+            const commit = {
+                id: commitmentId,
+                userAccount: userAccount,
+                dappContract: dappAccount,
+                providerAccount: this.contract.pair.address,
+                datasetId: provider.datasetId.toString(),
+                status: types_1.CaptchaStatus.pending,
+                userSignature: Array.from(userSignature),
+                requestedAt: pendingRecord.requestedAtBlock,
+                completedAt: blockNumber,
+                processed: false,
+            };
+            await this.db.storeDappUserSolution(receivedCaptchas, commit);
+            if ((0, datasets_1.compareCaptchaSolutions)(receivedCaptchas, storedCaptchas)) {
+                response = {
+                    captchas: captchaIds.map((id) => ({
+                        captchaId: id,
+                        proof: tree.proof(id),
+                    })),
+                    solutionApproved: true,
+                };
+                await this.db.approveDappUserCommitment(commitmentId);
+            }
+            else {
+                response = {
+                    captchas: captchaIds.map((id) => ({
+                        captchaId: id,
+                        proof: [[]],
+                    })),
+                    solutionApproved: false,
+                };
+            }
+        }
+        return response;
+    }
+    /**
+     * Validate that the dapp is active in the contract
+     */
+    async dappIsActive(dappAccount) {
+        const dapp = await (0, contract_2.wrapQuery)(this.contract.query.getDapp, this.contract.query)(dappAccount);
+        //dapp.status.isActive doesn't work: https://substrate.stackexchange.com/questions/6333/how-do-we-work-with-polkadot-js-enums-in-typescript
+        return dapp.status.toString() === 'Active';
+    }
+    /**
+     * Validate that the provider is active in the contract
+     */
+    async providerIsActive(providerAccount) {
+        const provider = await (0, contract_2.wrapQuery)(this.contract.query.getProvider, this.contract.query)(providerAccount);
+        return provider.status.toString() === 'Active';
+    }
+    /**
+     * Validate length of received captchas array matches length of captchas found in database
+     * Validate that the datasetId is the same for all captchas and is equal to the datasetId on the stored captchas
+     */
+    async validateReceivedCaptchasAgainstStoredCaptchas(captchas) {
+        const receivedCaptchas = (0, datasets_1.parseAndSortCaptchaSolutions)(captchas);
+        const captchaIds = receivedCaptchas.map((captcha) => captcha.captchaId);
+        const storedCaptchas = await this.db.getCaptchaById(captchaIds);
+        if (!storedCaptchas || receivedCaptchas.length !== storedCaptchas.length) {
+            throw new common_1.ProsopoEnvError('CAPTCHA.INVALID_CAPTCHA_ID', this.validateReceivedCaptchasAgainstStoredCaptchas.name, {}, captchas);
+        }
+        if (!storedCaptchas.every((captcha) => captcha.datasetId === storedCaptchas[0].datasetId)) {
+            throw new common_1.ProsopoEnvError('CAPTCHA.DIFFERENT_DATASET_IDS', this.validateReceivedCaptchasAgainstStoredCaptchas.name, {}, captchas);
+        }
+        return { storedCaptchas, receivedCaptchas, captchaIds };
+    }
+    /**
+     * Build merkle tree and get commitment from contract, returning the tree, commitment, and commitmentId
+     * @param {CaptchaSolution[]} captchaSolutions
+     * @returns {Promise<{ tree: CaptchaMerkleTree, commitment: CaptchaSolutionCommitment, commitmentId: string }>}
+     */
+    async buildTreeAndGetCommitmentId(captchaSolutions) {
+        const tree = new datasets_1.CaptchaMerkleTree();
+        const solutionsHashed = captchaSolutions.map((captcha) => (0, datasets_1.computeCaptchaSolutionHash)(captcha));
+        tree.build(solutionsHashed);
+        const commitmentId = tree.root?.hash;
+        if (!commitmentId) {
+            throw new common_1.ProsopoEnvError('CONTRACT.CAPTCHA_SOLUTION_COMMITMENT_DOES_NOT_EXIST', this.buildTreeAndGetCommitmentId.name, {}, { commitmentId: commitmentId });
+        }
+        return { tree, commitmentId };
+    }
+    /**
+     * Validate that a Dapp User is responding to their own pending captcha request
+     * @param {string} requestHash
+     * @param {PendingCaptchaRequest} pendingRecord
+     * @param {string} userAccount
+     * @param {string[]} captchaIds
+     */
+    async validateDappUserSolutionRequestIsPending(requestHash, pendingRecord, userAccount, captchaIds) {
+        const currentTime = Date.now();
+        if (pendingRecord.deadlineTimestamp < currentTime) {
+            // deadline for responding to the captcha has expired
+            this.logger.info('Deadline for responding to captcha has expired');
+            return false;
+        }
+        if (pendingRecord) {
+            const pendingHashComputed = (0, datasets_1.computePendingRequestHash)(captchaIds, userAccount, pendingRecord.salt);
+            return requestHash === pendingHashComputed;
+        }
+        return false;
+    }
+    /**
+     * Get two random captchas from specified dataset, create the response and store a hash of it, marked as pending
+     * @param {string} datasetId
+     * @param {string} userAccount
+     */
+    async getRandomCaptchasAndRequestHash(datasetId, userAccount) {
+        const dataset = await this.db.getDatasetDetails(datasetId);
+        if (!dataset) {
+            throw new common_1.ProsopoEnvError('DATABASE.DATASET_GET_FAILED');
+        }
+        const unsolvedCount = Math.abs(Math.trunc(this.captchaConfig.unsolved.count));
+        const solvedCount = Math.abs(Math.trunc(this.captchaConfig.solved.count));
+        if (!solvedCount) {
+            throw new common_1.ProsopoEnvError('CONFIG.INVALID_CAPTCHA_NUMBER');
+        }
+        const solved = await this.getCaptchaWithProof(datasetId, true, solvedCount);
+        let unsolved = [];
+        if (unsolvedCount) {
+            unsolved = await this.getCaptchaWithProof(datasetId, false, unsolvedCount);
+        }
+        const captchas = (0, util_1.shuffleArray)([...solved, ...unsolved]);
+        const salt = (0, util_crypto_1.randomAsHex)();
+        const requestHash = (0, datasets_1.computePendingRequestHash)(captchas.map((c) => c.captcha.captchaId), userAccount, salt);
+        const currentTime = Date.now();
+        const timeLimit = captchas.map((captcha) => captcha.captcha.timeLimitMs || 30000).reduce((a, b) => a + b, 0);
+        const deadlineTs = timeLimit + currentTime;
+        const currentBlockNumber = await (0, contract_1.getBlockNumber)(this.contract.api);
+        await this.db.storeDappUserPending(userAccount, requestHash, salt, deadlineTs, currentBlockNumber.toNumber());
+        return { captchas, requestHash };
+    }
+    /**
+     * Apply new captcha solutions to captcha dataset and recalculate merkle tree
+     */
+    async calculateCaptchaSolutions() {
+        try {
+            // Get the current datasetId from the contract
+            const provider = (await this.contract.methods.getProvider(this.contract.pair.address, {})).value
+                .unwrap()
+                .unwrap();
+            // Get any unsolved CAPTCHA challenges from the database for this datasetId
+            const unsolvedCaptchas = await this.db.getAllCaptchasByDatasetId(provider.datasetId.toString(), types_1.CaptchaStates.Unsolved);
+            // edge case when a captcha dataset contains no unsolved CAPTCHA challenges
+            if (!unsolvedCaptchas) {
+                return 0;
+            }
+            // Sort the unsolved CAPTCHA challenges by their captchaId
+            const unsolvedSorted = unsolvedCaptchas.sort(datasets_1.captchaSort);
+            consola_1.default.info(`There are ${unsolvedSorted.length} unsolved CAPTCHA challenges`);
+            // Get the solution configuration from the config file
+            const requiredNumberOfSolutions = this.captchaSolutionConfig.requiredNumberOfSolutions;
+            const winningPercentage = this.captchaSolutionConfig.solutionWinningPercentage;
+            const winningNumberOfSolutions = Math.round(requiredNumberOfSolutions * (winningPercentage / 100));
+            if (unsolvedSorted && unsolvedSorted.length > 0) {
+                const captchaIds = unsolvedSorted.map((captcha) => captcha.captchaId);
+                const solutions = (await this.db.getAllDappUserSolutions(captchaIds)) || [];
+                const solutionsToUpdate = (0, util_1.calculateNewSolutions)(solutions, winningNumberOfSolutions);
+                if (solutionsToUpdate.rows().length > 0) {
+                    consola_1.default.info(`There are ${solutionsToUpdate.rows().length} CAPTCHA challenges to update with solutions`);
+                    try {
+                        const captchaIdsToUpdate = [...solutionsToUpdate['captchaId'].values()];
+                        const commitmentIds = solutions
+                            .filter((s) => captchaIdsToUpdate.indexOf(s.captchaId) > -1)
+                            .map((s) => s.commitmentId);
+                        const dataset = await this.db.getDataset(provider.datasetId.toString());
+                        dataset.captchas = (0, util_1.updateSolutions)(solutionsToUpdate, dataset.captchas, this.logger);
+                        // store new solutions in database
+                        await this.providerSetDataset(dataset);
+                        // mark user solutions as used to calculate new solutions
+                        await this.db.flagUsedDappUserSolutions(captchaIdsToUpdate);
+                        // mark user commitments as used to calculate new solutions
+                        await this.db.flagUsedDappUserCommitments(commitmentIds);
+                        // remove old captcha challenges from database
+                        await this.db.removeCaptchas(captchaIdsToUpdate);
+                        return solutionsToUpdate.rows().length;
+                    }
+                    catch (error) {
+                        consola_1.default.error(error);
+                    }
+                }
+                return 0;
+            }
+            else {
+                consola_1.default.info(`There are no CAPTCHA challenges that require their solutions to be updated`);
+                return 0;
+            }
+        }
+        catch (error) {
+            throw new common_1.ProsopoEnvError(error, 'GENERAL.CALCULATE_CAPTCHA_SOLUTION');
+        }
+    }
+    /**
+     * Block by block search for blockNo
+     */
+    async isRecentBlock(contract, header, blockNo, depth = this.captchaSolutionConfig.captchaBlockRecency) {
+        if (depth == 0) {
+            return false;
+        }
+        const headerBlockNo = header.number.toNumber();
+        if (headerBlockNo === blockNo) {
+            return true;
+        }
+        const parent = await contract.api.rpc.chain.getBlock(header.parentHash);
+        return this.isRecentBlock(contract, parent.toHuman().block.header, blockNo, depth - 1);
+    }
+    /**
+     * Validate that provided `datasetId` was a result of calling `get_random_provider` method
+     * @param {string} userAccount - Same user that called `get_random_provider`
+     * @param {string} dappContractAccount - account of dapp that is requesting captcha
+     * @param {string} datasetId - `captcha_dataset_id` from the result of `get_random_provider`
+     * @param {string} blockNumber - Block on which `get_random_provider` was called
+     */
+    async validateProviderWasRandomlyChosen(userAccount, dappContractAccount, datasetId, blockNumber) {
+        const contract = await this.contract.contract;
+        if (!contract) {
+            throw new common_1.ProsopoEnvError('CONTRACT.CONTRACT_UNDEFINED', this.validateProviderWasRandomlyChosen.name);
+        }
+        const header = await contract.api.rpc.chain.getHeader();
+        const isBlockNoValid = await this.isRecentBlock(contract, header, blockNumber);
+        if (!isBlockNoValid) {
+            throw new common_1.ProsopoEnvError('CAPTCHA.INVALID_BLOCK_NO', this.validateProviderWasRandomlyChosen.name, {}, {
+                userAccount,
+                dappContractAccount,
+                datasetId,
+                header,
+                blockNumber,
+            });
+        }
+        const block = (await contract.api.rpc.chain.getBlockHash(blockNumber));
+        const randomProviderAndBlockNo = await this.contract.queryAtBlock(block, 'getRandomActiveProvider', [userAccount, dappContractAccount]);
+        if (datasetId.toString().localeCompare(randomProviderAndBlockNo.provider.datasetId.toString())) {
+            throw new common_1.ProsopoEnvError('DATASET.INVALID_DATASET_ID', this.validateProviderWasRandomlyChosen.name, {}, randomProviderAndBlockNo);
+        }
+    }
+    /**
+     * Get payment info for a transaction
+     * @param {string} userAccount
+     * @param {string} blockHash
+     * @param {string} txHash
+     * @returns {Promise<RuntimeDispatchInfo|null>}
+     */
+    async getPaymentInfo(userAccount, blockHash, txHash) {
+        // Validate block and transaction, checking that the signer matches the userAccount
+        const signedBlock = (await this.contract.api.rpc.chain.getBlock(blockHash));
+        if (!signedBlock) {
+            return null;
+        }
+        const extrinsic = signedBlock.block.extrinsics.find((extrinsic) => extrinsic.hash.toString() === txHash);
+        if (!extrinsic || extrinsic.signer.toString() !== userAccount) {
+            return null;
+        }
+        // Retrieve tx fee for extrinsic
+        const paymentInfo = (await this.contract.api.rpc.payment.queryInfo(extrinsic.toHex(), blockHash));
+        if (!paymentInfo) {
+            return null;
+        }
+        return paymentInfo;
+    }
+    /*
+     * Get dapp user solution from database
+     */
+    async getDappUserCommitmentById(commitmentId) {
+        const dappUserSolution = await this.db.getDappUserCommitmentById(commitmentId);
+        if (!dappUserSolution) {
+            throw new common_1.ProsopoEnvError('CAPTCHA.DAPP_USER_SOLUTION_NOT_FOUND', this.getDappUserCommitmentById.name, {}, { commitmentId: commitmentId });
+        }
+        return dappUserSolution;
+    }
+    /* Check if dapp user has verified solution in cache */
+    async getDappUserCommitmentByAccount(userAccount) {
+        const dappUserSolutions = await this.db.getDappUserCommitmentByAccount(userAccount);
+        if (dappUserSolutions.length > 0) {
+            for (const dappUserSolution of dappUserSolutions) {
+                if (dappUserSolution.status === types_1.ArgumentTypes.CaptchaStatus.approved) {
+                    return dappUserSolution;
+                }
+            }
+        }
+        return undefined;
+    }
+}
+exports.Tasks = Tasks;
+//# sourceMappingURL=tasks.js.map