@prosopo/provider 1.0.1 → 2.0.0

package/dist/cjs/api/authMiddleware.cjs

@@ -1,8 +1,7 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const common = require("@prosopo/common");
-const contract = require("@prosopo/contract");
 const util = require("@polkadot/util");
+const common = require("@prosopo/common");
 const authMiddleware = (tasks, env) => {
   return async (req, res, next) => {
     try {
@@ -11,7 +10,6 @@ const authMiddleware = (tasks, env) => {
         throw new common.ProsopoEnvError("CONTRACT.CANNOT_FIND_KEYPAIR");
       }
       verifyEnvironmentKeyPair(env);
-      await verifyBlockNumber(blocknumber, tasks);
       verifySignature(signature, blocknumber, env.pair);
       next();
     } catch (err) {
@@ -40,18 +38,6 @@ const verifyEnvironmentKeyPair = (env) => {
     throw new common.ProsopoEnvError("CONTRACT.CANNOT_FIND_KEYPAIR");
   }
 };
-const verifyBlockNumber = async (blockNumber, tasks) => {
-  const parsedBlockNumber = parseInt(blockNumber);
-  const currentBlockNumber = await contract.getCurrentBlockNumber(tasks.contract.api);
-  if (isNaN(parsedBlockNumber) || parsedBlockNumber < currentBlockNumber - 500 || parsedBlockNumber > currentBlockNumber) {
-    throw new common.ProsopoApiError("API.BAD_REQUEST", {
-      context: {
-        error: `Invalid block number ${parsedBlockNumber}, current block number is ${currentBlockNumber}`,
-        code: 400
-      }
-    });
-  }
-};
 const verifySignature = (signature, blockNumber, pair) => {
   const u8Sig = util.hexToU8a(signature);
   if (!pair.verify(blockNumber, u8Sig, pair.publicKey)) {

package/dist/cjs/api/captcha.cjs

@@ -1,14 +1,13 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const types = require("@prosopo/types");
+const address = require("@polkadot/util-crypto/address");
 const common = require("@prosopo/common");
-const tasks = require("../tasks/tasks.cjs");
-const errorHandler = require("./errorHandler.cjs");
-const util = require("../util.cjs");
 const datasets = require("@prosopo/datasets");
-const address = require("@polkadot/util-crypto/address");
-const util$1 = require("@prosopo/util");
+const types = require("@prosopo/types");
+const util = require("@prosopo/util");
 const express = require("express");
+const tasks = require("../tasks/tasks.cjs");
+const errorHandler = require("./errorHandler.cjs");
 function prosopoRouter(env) {
   const router = express.Router();
   const tasks$1 = new tasks.Tasks(env);
@@ -16,30 +15,35 @@ function prosopoRouter(env) {
     `${types.ApiPaths.GetImageCaptchaChallenge}/:${types.ApiParams.datasetId}/:${types.ApiParams.user}/:${types.ApiParams.dapp}/:${types.ApiParams.blockNumber}`,
     async (req, res, next) => {
       try {
-        const { blockNumber, datasetId, user, dapp } = types.CaptchaRequestBody.parse(req.params);
-        const api = env.api;
-        if (api === void 0) {
-          throw new common.ProsopoApiError("DEVELOPER.METHOD_NOT_IMPLEMENTED", {
-            context: { error: "api not setup", env }
-          });
-        }
-        address.validateAddress(user, false, api.registry.chainSS58);
-        const blockNumberParsed = util.parseBlockNumber(blockNumber);
-        const taskData = await tasks$1.getRandomCaptchasAndRequestHash(datasetId, user);
+        const { datasetId, user } = types.CaptchaRequestBody.parse(req.params);
+        address.validateAddress(user, false, 42);
+        const taskData = await tasks$1.imgCaptchaManager.getRandomCaptchasAndRequestHash(
+          datasetId,
+          user
+        );
         const captchaResponse = {
-          captchas: taskData.captchas.map((cwp) => ({
-            ...cwp,
-            captcha: {
-              ...cwp.captcha,
-              items: cwp.captcha.items.map((item) => datasets.parseCaptchaAssets(item, env.assetsResolver))
-            }
+          captchas: taskData.captchas.map((captcha) => ({
+            ...captcha,
+            items: captcha.items.map(
+              (item) => datasets.parseCaptchaAssets(item, env.assetsResolver)
+            )
           })),
-          requestHash: taskData.requestHash
+          [types.ApiParams.requestHash]: taskData.requestHash,
+          [types.ApiParams.timestamp]: taskData.timestamp.toString(),
+          [types.ApiParams.signature]: {
+            [types.ApiParams.provider]: {
+              [types.ApiParams.timestamp]: taskData.signedTimestamp
+            }
+          }
         };
         return res.json(captchaResponse);
       } catch (err) {
         tasks$1.logger.error(err);
-        return next(new common.ProsopoApiError("API.BAD_REQUEST", { context: { error: err, code: 400 } }));
+        return next(
+          new common.ProsopoApiError("API.BAD_REQUEST", {
+            context: { error: err, code: 400 }
+          })
+        );
       }
     }
   );
@@ -48,24 +52,36 @@ function prosopoRouter(env) {
     try {
       parsed = types.CaptchaSolutionBody.parse(req.body);
     } catch (err) {
-      return next(new common.ProsopoApiError("CAPTCHA.PARSE_ERROR", { context: { code: 400, error: err } }));
+      return next(
+        new common.ProsopoApiError("CAPTCHA.PARSE_ERROR", {
+          context: { code: 400, error: err }
+        })
+      );
     }
     try {
-      const result = await tasks$1.dappUserSolution(
+      const result = await tasks$1.imgCaptchaManager.dappUserSolution(
         parsed[types.ApiParams.user],
         parsed[types.ApiParams.dapp],
         parsed[types.ApiParams.requestHash],
         parsed[types.ApiParams.captchas],
-        parsed[types.ApiParams.signature]
+        parsed[types.ApiParams.signature].user.requestHash,
+        parseInt(parsed[types.ApiParams.timestamp]),
+        parsed[types.ApiParams.signature].provider.timestamp
       );
       const returnValue = {
-        status: req.i18n.t(result.verified ? "API.CAPTCHA_PASSED" : "API.CAPTCHA_FAILED"),
+        status: req.i18n.t(
+          result.verified ? "API.CAPTCHA_PASSED" : "API.CAPTCHA_FAILED"
+        ),
         ...result
       };
       return res.json(returnValue);
     } catch (err) {
       tasks$1.logger.error(err);
-      return next(new common.ProsopoApiError("API.UNKNOWN", { context: { code: 400, error: err } }));
+      return next(
+        new common.ProsopoApiError("API.UNKNOWN", {
+          context: { code: 400, error: err }
+        })
+      );
     }
   });
   router.post(types.ApiPaths.GetPowCaptchaChallenge, async (req, res, next) => {
@@ -77,57 +93,78 @@ function prosopoRouter(env) {
           context: { code: 400, error: "origin header not found" }
         });
       }
-      const challenge = await tasks$1.getPowCaptchaChallenge(user, dapp, origin);
-      return res.json(challenge);
+      const challenge = await tasks$1.powCaptchaManager.getPowCaptchaChallenge(
+        user,
+        dapp,
+        origin
+      );
+      const getPowCaptchaResponse = {
+        challenge: challenge.challenge,
+        difficulty: challenge.difficulty,
+        timestamp: challenge.timestamp.toString(),
+        signature: {
+          provider: {
+            timestamp: challenge.timestampSignature,
+            challenge: challenge.signature
+          }
+        }
+      };
+      return res.json(getPowCaptchaResponse);
     } catch (err) {
       tasks$1.logger.error(err);
-      return next(new common.ProsopoApiError("API.BAD_REQUEST", { context: { code: 400, error: err } }));
+      return next(
+        new common.ProsopoApiError("API.BAD_REQUEST", {
+          context: { code: 400, error: err }
+        })
+      );
     }
   });
   router.post(types.ApiPaths.SubmitPowCaptchaSolution, async (req, res, next) => {
     try {
-      const { blockNumber, challenge, difficulty, signature, nonce, verifiedTimeout } = types.SubmitPowCaptchaSolutionBody.parse(req.body);
-      const verified = await tasks$1.verifyPowCaptchaSolution(
-        blockNumber,
+      const { challenge, difficulty, signature, nonce, verifiedTimeout } = types.SubmitPowCaptchaSolutionBody.parse(req.body);
+      const verified = await tasks$1.powCaptchaManager.verifyPowCaptchaSolution(
         challenge,
         difficulty,
-        signature,
+        signature.provider.challenge,
         nonce,
-        verifiedTimeout
+        verifiedTimeout,
+        signature.user.timestamp
       );
       const response = { verified };
       return res.json(response);
     } catch (err) {
       tasks$1.logger.error(err);
-      return next(new common.ProsopoApiError("API.BAD_REQUEST", { context: { code: 400, error: err } }));
+      return next(
+        new common.ProsopoApiError("API.BAD_REQUEST", {
+          context: { code: 400, error: err }
+        })
+      );
     }
   });
   router.post(types.ApiPaths.SubmitUserEvents, async (req, res, next) => {
     try {
       const { events, accountId } = req.body;
-      await tasks$1.saveCaptchaEvent(events, accountId);
+      await tasks$1.datasetManager.saveCaptchaEvent(events, accountId);
       return res.json({ status: "success" });
     } catch (err) {
       tasks$1.logger.error(err);
-      return next(new common.ProsopoApiError("API.BAD_REQUEST", { context: { code: 400, error: err } }));
-    }
-  });
-  router.get(types.ApiPaths.GetProviderStatus, async (req, res, next) => {
-    try {
-      const status = await tasks$1.providerStatus();
-      return res.json({ status });
-    } catch (err) {
-      tasks$1.logger.error(err);
-      return next(new common.ProsopoApiError("API.BAD_REQUEST", { context: { code: 400, error: err } }));
+      return next(
+        new common.ProsopoApiError("API.BAD_REQUEST", {
+          context: { code: 400, error: err }
+        })
+      );
     }
   });
   router.get(types.ApiPaths.GetProviderDetails, async (req, res, next) => {
     try {
-      const details = await tasks$1.getProviderDetails();
-      return res.json({ version: util$1.version, ...details });
+      return res.json({ version: util.version, ...{ message: "Provider online" } });
     } catch (err) {
       tasks$1.logger.error(err);
-      return next(new common.ProsopoApiError("API.BAD_REQUEST", { context: { code: 400, error: err } }));
+      return next(
+        new common.ProsopoApiError("API.BAD_REQUEST", {
+          context: { code: 400, error: err }
+        })
+      );
     }
   });
   router.use(errorHandler.handleErrors);

package/dist/cjs/api/captchaScheduler.cjs

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const env = require("@prosopo/env");
+const cron = require("cron");
+const tasks = require("../tasks/tasks.cjs");
+async function storeCaptchasExternally(pair, config) {
+  const env$1 = new env.ProviderEnvironment(config, pair);
+  await env$1.isReady();
+  const tasks$1 = new tasks.Tasks(env$1);
+  const defaultSchedule = "0 * * * *";
+  const cronSchedule = config.captchaScheduler ? config.captchaScheduler.schedule ? config.captchaScheduler.schedule : defaultSchedule : defaultSchedule;
+  const job = new cron.CronJob(cronSchedule, async () => {
+    env$1.logger.log("storeCommitmentsExternal task....");
+    await tasks$1.datasetManager.storeCommitmentsExternal().catch((err) => {
+      env$1.logger.error(err);
+    });
+  });
+  job.start();
+}
+exports.storeCaptchasExternally = storeCaptchasExternally;

package/dist/cjs/api/errorHandler.cjs

@@ -7,6 +7,8 @@ const handleErrors = (err, request, response, next) => {
     err = err.context.error;
   }
   const message = err.message;
-  response.writeHead(code, JSON.stringify(message), { "content-type": "application/json" }).end();
+  response.writeHead(code, JSON.stringify(message), {
+    "content-type": "application/json"
+  }).end();
 };
 exports.handleErrors = handleErrors;

package/dist/cjs/api/verify.cjs

@@ -1,13 +1,11 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const types = require("@prosopo/types");
-const typesReturns = require("@prosopo/captcha-contract/types-returns");
 const common = require("@prosopo/common");
+const types = require("@prosopo/types");
+const express = require("express");
 const tasks = require("../tasks/tasks.cjs");
-const contract = require("@prosopo/contract");
-const errorHandler = require("./errorHandler.cjs");
 const authMiddleware = require("./authMiddleware.cjs");
-const express = require("express");
+const errorHandler = require("./errorHandler.cjs");
 function prosopoVerifyRouter(env) {
   const router = express.Router();
   const tasks$1 = new tasks.Tasks(env);
@@ -18,7 +16,7 @@ function prosopoVerifyRouter(env) {
       const { user, dapp, blockNumber, commitmentId } = types.decodeProcaptchaOutput(token);
       const keyPair = isDapp ? env.keyring.addFromAddress(dapp) : env.keyring.addFromAddress(user);
       authMiddleware.verifySignature(dappUserSignature, blockNumber.toString(), keyPair);
-      const solution = await (commitmentId ? tasks$1.getDappUserCommitmentById(commitmentId) : tasks$1.getDappUserCommitmentByAccount(user));
+      const solution = await (commitmentId ? tasks$1.imgCaptchaManager.getDappUserCommitmentById(commitmentId) : tasks$1.imgCaptchaManager.getDappUserCommitmentByAccount(user));
       if (!solution) {
         tasks$1.logger.debug("Not verified - no solution found");
         const noSolutionResponse = {
@@ -27,17 +25,17 @@ function prosopoVerifyRouter(env) {
         };
         return res.json(noSolutionResponse);
       }
-      if (solution.status === typesReturns.CaptchaStatus.disapproved) {
+      if (solution.status === types.CaptchaStatus.disapproved) {
         const disapprovedResponse = {
           [types.ApiParams.status]: req.t("API.USER_NOT_VERIFIED"),
           [types.ApiParams.verified]: false
         };
         return res.json(disapprovedResponse);
       }
-      if (parsed.maxVerifiedTime) {
-        const currentBlockNumber = await contract.getCurrentBlockNumber(tasks$1.contract.api);
-        const blockTimeMs = contract.getBlockTimeMs(tasks$1.contract.api);
-        const timeSinceCompletion = (currentBlockNumber - solution.completedAt) * blockTimeMs;
+      const maxVerifiedTime = parsed.maxVerifiedTime || 60 * 1e3;
+      if (maxVerifiedTime) {
+        const currentTime = Date.now();
+        const timeSinceCompletion = currentTime - solution.requestedAtTimestamp;
         if (timeSinceCompletion > parsed.maxVerifiedTime) {
           const expiredResponse = {
             [types.ApiParams.status]: req.t("API.USER_NOT_VERIFIED_TIME_EXPIRED"),
@@ -47,32 +45,52 @@ function prosopoVerifyRouter(env) {
           return res.json(expiredResponse);
         }
       }
-      const isApproved = solution.status === typesReturns.CaptchaStatus.approved;
+      const isApproved = solution.status === types.CaptchaStatus.approved;
       const response = {
-        [types.ApiParams.status]: req.t(isApproved ? "API.USER_VERIFIED" : "API.USER_NOT_VERIFIED"),
+        [types.ApiParams.status]: req.t(
+          isApproved ? "API.USER_VERIFIED" : "API.USER_NOT_VERIFIED"
+        ),
         [types.ApiParams.verified]: isApproved,
         [types.ApiParams.commitmentId]: solution.id.toString(),
         [types.ApiParams.blockNumber]: solution.requestedAt
       };
       return res.json(response);
     } catch (err) {
-      return next(new common.ProsopoApiError("API.BAD_REQUEST", { context: { code: 400, error: err } }));
+      return next(
+        new common.ProsopoApiError("API.BAD_REQUEST", {
+          context: { code: 400, error: err }
+        })
+      );
     }
   }
-  router.post(types.ApiPaths.VerifyImageCaptchaSolutionDapp, async (req, res, next) => {
-    try {
-      await verifyImageSolution(res, req, next, true);
-    } catch (err) {
-      return next(new common.ProsopoApiError("CAPTCHA.PARSE_ERROR", { context: { code: 400, error: err } }));
+  router.post(
+    types.ApiPaths.VerifyImageCaptchaSolutionDapp,
+    async (req, res, next) => {
+      try {
+        await verifyImageSolution(res, req, next, true);
+      } catch (err) {
+        return next(
+          new common.ProsopoApiError("CAPTCHA.PARSE_ERROR", {
+            context: { code: 400, error: err }
+          })
+        );
+      }
     }
-  });
-  router.post(types.ApiPaths.VerifyImageCaptchaSolutionUser, async (req, res, next) => {
-    try {
-      await verifyImageSolution(res, req, next, false);
-    } catch (err) {
-      return next(new common.ProsopoApiError("CAPTCHA.PARSE_ERROR", { context: { code: 400, error: err } }));
+  );
+  router.post(
+    types.ApiPaths.VerifyImageCaptchaSolutionUser,
+    async (req, res, next) => {
+      try {
+        await verifyImageSolution(res, req, next, false);
+      } catch (err) {
+        return next(
+          new common.ProsopoApiError("CAPTCHA.PARSE_ERROR", {
+            context: { code: 400, error: err }
+          })
+        );
+      }
     }
-  });
+  );
   router.post(types.ApiPaths.VerifyPowCaptchaSolution, async (req, res, next) => {
     try {
       const { token, dappSignature, verifiedTimeout } = types.ServerPowCaptchaVerifyRequestBody.parse(req.body);
@@ -86,7 +104,11 @@ function prosopoVerifyRouter(env) {
       }
       const dappPair = env.keyring.addFromAddress(dapp);
       authMiddleware.verifySignature(dappSignature, blockNumber.toString(), dappPair);
-      const approved = await tasks$1.serverVerifyPowCaptchaSolution(dapp, challenge, verifiedTimeout);
+      const approved = await tasks$1.powCaptchaManager.serverVerifyPowCaptchaSolution(
+        dapp,
+        challenge,
+        verifiedTimeout
+      );
       const verificationResponse = {
         status: req.t(approved ? "API.USER_VERIFIED" : "API.USER_NOT_VERIFIED"),
         [types.ApiParams.verified]: approved
@@ -94,7 +116,11 @@ function prosopoVerifyRouter(env) {
       return res.json(verificationResponse);
     } catch (err) {
       tasks$1.logger.error(err);
-      return next(new common.ProsopoApiError("API.BAD_REQUEST", { context: { code: 400, error: err } }));
+      return next(
+        new common.ProsopoApiError("API.BAD_REQUEST", {
+          context: { code: 400, error: err }
+        })
+      );
     }
   });
   router.use(errorHandler.handleErrors);

package/dist/cjs/index.cjs

@@ -2,13 +2,12 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 require("./tasks/index.cjs");
 const util = require("./util.cjs");
-require("./batch/index.cjs");
 const captcha = require("./api/captcha.cjs");
 const verify = require("./api/verify.cjs");
 const admin = require("./api/admin.cjs");
 const errorHandler = require("./api/errorHandler.cjs");
+const captchaScheduler = require("./api/captchaScheduler.cjs");
 const tasks = require("./tasks/tasks.cjs");
-const commitments = require("./batch/commitments.cjs");
 exports.checkIfTaskIsRunning = util.checkIfTaskIsRunning;
 exports.encodeStringAddress = util.encodeStringAddress;
 exports.parseBlockNumber = util.parseBlockNumber;
@@ -18,5 +17,5 @@ exports.prosopoRouter = captcha.prosopoRouter;
 exports.prosopoVerifyRouter = verify.prosopoVerifyRouter;
 exports.prosopoAdminRouter = admin.prosopoAdminRouter;
 exports.handleErrors = errorHandler.handleErrors;
+exports.storeCaptchasExternally = captchaScheduler.storeCaptchasExternally;
 exports.Tasks = tasks.Tasks;
-exports.BatchCommitmentsTask = commitments.BatchCommitmentsTask;

package/dist/cjs/tasks/dataset/datasetTasks.cjs

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const database = require("@prosopo/database");
+const datasets = require("@prosopo/datasets");
+const datasetTasksUtils = require("./datasetTasksUtils.cjs");
+class DatasetManager {
+  constructor(config, logger, captchaConfig, db) {
+    this.config = config;
+    this.logger = logger;
+    this.captchaConfig = captchaConfig;
+    this.db = db;
+  }
+  /**
+   * @description Set the provider dataset from a file
+   *
+   * @param file JSON of the captcha dataset
+   */
+  async providerSetDatasetFromFile(file) {
+    const datasetRaw = datasets.parseCaptchaDataset(file);
+    return await this.providerSetDataset(datasetRaw);
+  }
+  async providerSetDataset(datasetRaw) {
+    const dataset = await datasetTasksUtils.providerValidateDataset(
+      datasetRaw,
+      this.captchaConfig.solved.count,
+      this.captchaConfig.unsolved.count
+    );
+    await this.db?.storeDataset(dataset);
+  }
+  /**
+   * @description Save captcha user events to external db
+   *
+   * **Note:** This is only used in development mode
+   *
+   * @param events
+   * @param accountId
+   * @returns
+   */
+  async saveCaptchaEvent(events, accountId) {
+    if (!this.config.devOnlyWatchEvents || !this.config.mongoEventsUri) {
+      this.logger.info("Dev watch events not set to true, not saving events");
+      return;
+    }
+    await database.saveCaptchaEvent(events, accountId, this.config.mongoEventsUri);
+  }
+  /**
+   * @description Store commitments externally in the database, clear them from local cache
+   * @returns
+   */
+  async storeCommitmentsExternal() {
+    if (!this.config.mongoCaptchaUri) {
+      this.logger.info("Mongo env not set");
+      return;
+    }
+    const commitments = await this.db.getUnstoredDappUserCommitments();
+    this.logger.info(`Storing ${commitments.length} commitments externally`);
+    const powRecords = await this.db.getUnstoredDappUserPoWCommitments();
+    this.logger.info(`Storing ${powRecords.length} pow challenges externally`);
+    await database.saveCaptchas(commitments, powRecords, this.config.mongoCaptchaUri);
+    await this.db.markDappUserCommitmentsStored(
+      commitments.map((commitment) => commitment.id)
+    );
+    await this.db.markDappUserPoWCommitmentsStored(
+      powRecords.map((powRecords2) => powRecords2.challenge)
+    );
+  }
+}
+exports.DatasetManager = DatasetManager;

package/dist/cjs/tasks/dataset/datasetTasksUtils.cjs

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const common = require("@prosopo/common");
+const datasets = require("@prosopo/datasets");
+const providerValidateDataset = async (datasetRaw, minSolvedCaptchas, minUnsolvedCaptchas) => {
+  if (datasetRaw.captchas.length < minSolvedCaptchas + minUnsolvedCaptchas) {
+    throw new common.ProsopoEnvError("DATASET.CAPTCHAS_COUNT_LESS_THAN_CONFIGURED", {
+      context: { failedFuncName: providerValidateDataset.name }
+    });
+  }
+  const solutions = datasetRaw.captchas.map((captcha) => captcha.solution ? 1 : 0).reduce((partialSum, b) => partialSum + b, 0);
+  if (solutions < minSolvedCaptchas) {
+    throw new common.ProsopoEnvError("DATASET.SOLUTIONS_COUNT_LESS_THAN_CONFIGURED", {
+      context: { failedFuncName: providerValidateDataset.name }
+    });
+  }
+  if (solutions < minUnsolvedCaptchas) {
+    throw new common.ProsopoEnvError("DATASET.SOLUTIONS_COUNT_LESS_THAN_CONFIGURED", {
+      context: { failedFuncName: providerValidateDataset.name }
+    });
+  }
+  const dataset = await datasets.buildDataset(datasetRaw);
+  if (!dataset.datasetId || !dataset.datasetContentId) {
+    throw new common.ProsopoEnvError("DATASET.DATASET_ID_UNDEFINED", {
+      context: {
+        failedFuncName: providerValidateDataset.name,
+        datasetId: dataset.datasetId,
+        datasetContentId: dataset.datasetContentId
+      }
+    });
+  }
+  return dataset;
+};
+exports.providerValidateDataset = providerValidateDataset;