@prosopo/provider 3.2.0 → 3.2.2

package/dist/tasks/imgCaptcha/imgCaptchaTasksUtils.js

@@ -1,18 +1,25 @@
 import { ProsopoEnvError } from "@prosopo/common";
-import { CaptchaMerkleTree, computeCaptchaSolutionHash, } from "@prosopo/datasets";
-export const buildTreeAndGetCommitmentId = (captchaSolutions) => {
-    const tree = new CaptchaMerkleTree();
-    const solutionsHashed = captchaSolutions.map((captcha) => computeCaptchaSolutionHash(captcha));
-    tree.build(solutionsHashed);
-    const commitmentId = tree.root?.hash;
-    if (!commitmentId) {
-        throw new ProsopoEnvError("CONTRACT.CAPTCHA_SOLUTION_COMMITMENT_DOES_NOT_EXIST", {
-            context: {
-                failedFuncName: buildTreeAndGetCommitmentId.name,
-                commitmentId: commitmentId,
-            },
-        });
-    }
-    return { tree, commitmentId };
+import { CaptchaMerkleTree, computeCaptchaSolutionHash } from "@prosopo/datasets";
+const buildTreeAndGetCommitmentId = (captchaSolutions) => {
+  const tree = new CaptchaMerkleTree();
+  const solutionsHashed = captchaSolutions.map(
+    (captcha) => computeCaptchaSolutionHash(captcha)
+  );
+  tree.build(solutionsHashed);
+  const commitmentId = tree.root?.hash;
+  if (!commitmentId) {
+    throw new ProsopoEnvError(
+      "CONTRACT.CAPTCHA_SOLUTION_COMMITMENT_DOES_NOT_EXIST",
+      {
+        context: {
+          failedFuncName: buildTreeAndGetCommitmentId.name,
+          commitmentId
+        }
+      }
+    );
+  }
+  return { tree, commitmentId };
+};
+export {
+  buildTreeAndGetCommitmentId
 };
-//# sourceMappingURL=imgCaptchaTasksUtils.js.map

package/dist/tasks/index.js

@@ -1,2 +1,4 @@
-export * from "./tasks.js";
-//# sourceMappingURL=index.js.map
+import { Tasks } from "./tasks.js";
+export {
+  Tasks
+};

package/dist/tasks/powCaptcha/powTasks.js

@@ -1,111 +1,171 @@
-import { stringToHex, u8aToHex } from "@polkadot/util";
+import { u8aToHex, stringToHex } from "@polkadot/util";
 import { ProsopoApiError, ProsopoEnvError } from "@prosopo/common";
-import { ApiParams, CaptchaStatus, POW_SEPARATOR, } from "@prosopo/types";
+import { POW_SEPARATOR, ApiParams, CaptchaStatus } from "@prosopo/types";
 import { at, verifyRecency } from "@prosopo/util";
 import { validateIpAddress } from "../../util.js";
 import { CaptchaManager } from "../captchaManager.js";
 import { computeFrictionlessScore } from "../frictionless/frictionlessTasksUtils.js";
 import { checkPowSignature, validateSolution } from "./powTasksUtils.js";
 const DEFAULT_POW_DIFFICULTY = 4;
-export class PowCaptchaManager extends CaptchaManager {
-    constructor(db, pair, logger) {
-        super(db, pair, logger);
-        this.POW_SEPARATOR = POW_SEPARATOR;
+class PowCaptchaManager extends CaptchaManager {
+  constructor(db, pair, logger) {
+    super(db, pair, logger);
+    this.POW_SEPARATOR = POW_SEPARATOR;
+  }
+  /**
+   * @description Generates a PoW Captcha for a given user and dapp
+   *
+   * @param {string} userAccount - user that is solving the captcha
+   * @param {string} dappAccount - dapp that is requesting the captcha
+   * @param origin - not currently used
+   * @param powDifficulty
+   */
+  async getPowCaptchaChallenge(userAccount, dappAccount, origin, powDifficulty) {
+    const difficulty = powDifficulty || DEFAULT_POW_DIFFICULTY;
+    const requestedAtTimestamp = Date.now();
+    const nonce = Math.floor(Math.random() * 1e6);
+    const challenge = `${requestedAtTimestamp}___${userAccount}___${dappAccount}___${nonce}`;
+    const challengeSignature = u8aToHex(this.pair.sign(stringToHex(challenge)));
+    return {
+      challenge,
+      difficulty,
+      providerSignature: challengeSignature,
+      requestedAtTimestamp
+    };
+  }
+  /**
+   * @description Verifies a PoW Captcha for a given user and dapp
+   *
+   * @param {string} challenge - the starting string for the PoW challenge
+   * @param {string} difficulty - how many leading zeroes the solution must have
+   * @param {string} providerChallengeSignature - proof that the Provider provided the challenge
+   * @param {string} nonce - the string that the user has found that satisfies the PoW challenge
+   * @param {number} timeout - the time in milliseconds since the Provider was selected to provide the PoW captcha
+   * @param {string} userTimestampSignature
+   * @param ipAddress
+   * @param headers
+   */
+  async verifyPowCaptchaSolution(challenge, difficulty, providerChallengeSignature, nonce, timeout, userTimestampSignature, ipAddress, headers) {
+    checkPowSignature(
+      challenge,
+      providerChallengeSignature,
+      this.pair.address,
+      ApiParams.challenge
+    );
+    const challengeSplit = challenge.split(this.POW_SEPARATOR);
+    const timestamp = Number.parseInt(at(challengeSplit, 0));
+    const userAccount = at(challengeSplit, 1);
+    checkPowSignature(
+      timestamp.toString(),
+      userTimestampSignature,
+      userAccount,
+      ApiParams.timestamp
+    );
+    const challengeRecord = await this.db.getPowCaptchaRecordByChallenge(challenge);
+    if (!challengeRecord) {
+      this.logger.debug(() => ({
+        msg: `No record of this challenge: ${challenge}`
+      }));
+      return false;
     }
-    async getPowCaptchaChallenge(userAccount, dappAccount, origin, powDifficulty) {
-        const difficulty = powDifficulty || DEFAULT_POW_DIFFICULTY;
-        const requestedAtTimestamp = Date.now();
-        const nonce = Math.floor(Math.random() * 1000000);
-        const challenge = `${requestedAtTimestamp}___${userAccount}___${dappAccount}___${nonce}`;
-        const challengeSignature = u8aToHex(this.pair.sign(stringToHex(challenge)));
-        return {
-            challenge,
-            difficulty,
-            providerSignature: challengeSignature,
-            requestedAtTimestamp,
-        };
+    if (!verifyRecency(challenge, timeout)) {
+      await this.db.updatePowCaptchaRecord(
+        challenge,
+        {
+          status: CaptchaStatus.disapproved,
+          reason: "CAPTCHA.INVALID_TIMESTAMP"
+        },
+        false,
+        //serverchecked
+        true,
+        // usersubmitted
+        userTimestampSignature
+      );
+      return false;
     }
-    async verifyPowCaptchaSolution(challenge, difficulty, providerChallengeSignature, nonce, timeout, userTimestampSignature, ipAddress, headers) {
-        checkPowSignature(challenge, providerChallengeSignature, this.pair.address, ApiParams.challenge);
-        const challengeSplit = challenge.split(this.POW_SEPARATOR);
-        const timestamp = Number.parseInt(at(challengeSplit, 0));
-        const userAccount = at(challengeSplit, 1);
-        checkPowSignature(timestamp.toString(), userTimestampSignature, userAccount, ApiParams.timestamp);
-        const challengeRecord = await this.db.getPowCaptchaRecordByChallenge(challenge);
-        if (!challengeRecord) {
-            this.logger.debug(() => ({
-                msg: `No record of this challenge: ${challenge}`,
-            }));
-            return false;
-        }
-        if (!verifyRecency(challenge, timeout)) {
-            await this.db.updatePowCaptchaRecord(challenge, {
-                status: CaptchaStatus.disapproved,
-                reason: "CAPTCHA.INVALID_TIMESTAMP",
-            }, false, true, userTimestampSignature);
-            return false;
-        }
-        const correct = validateSolution(nonce, challenge, difficulty);
-        let result = { status: CaptchaStatus.approved };
-        if (!correct) {
-            result = {
-                status: CaptchaStatus.disapproved,
-                reason: "CAPTCHA.INVALID_SOLUTION",
-            };
-        }
-        await this.db.updatePowCaptchaRecord(challenge, result, false, true, userTimestampSignature);
-        return correct;
+    const correct = validateSolution(nonce, challenge, difficulty);
+    let result = { status: CaptchaStatus.approved };
+    if (!correct) {
+      result = {
+        status: CaptchaStatus.disapproved,
+        reason: "CAPTCHA.INVALID_SOLUTION"
+      };
     }
-    async serverVerifyPowCaptchaSolution(dappAccount, challenge, timeout, ip) {
-        const challengeRecord = await this.db.getPowCaptchaRecordByChallenge(challenge);
-        if (!challengeRecord) {
-            this.logger.debug(() => ({
-                msg: `No record of this challenge: ${challenge}`,
-            }));
-            return { verified: false };
-        }
-        const ipValidation = validateIpAddress(ip, challengeRecord.ipAddress, this.logger);
-        if (!ipValidation.isValid) {
-            return { verified: false };
-        }
-        if (challengeRecord.result.status !== CaptchaStatus.approved) {
-            throw new ProsopoApiError("CAPTCHA.INVALID_SOLUTION", {
-                context: {
-                    failedFuncName: this.serverVerifyPowCaptchaSolution.name,
-                    challenge,
-                },
-            });
-        }
-        if (challengeRecord.serverChecked)
-            return { verified: false };
-        const challengeDappAccount = challengeRecord.dappAccount;
-        if (dappAccount !== challengeDappAccount) {
-            throw new ProsopoEnvError("CAPTCHA.DAPP_USER_SOLUTION_NOT_FOUND", {
-                context: {
-                    failedFuncName: this.serverVerifyPowCaptchaSolution.name,
-                    dappAccount,
-                    challengeDappAccount,
-                },
-            });
+    await this.db.updatePowCaptchaRecord(
+      challenge,
+      result,
+      false,
+      true,
+      userTimestampSignature
+    );
+    return correct;
+  }
+  /**
+   * @description Verifies a PoW Captcha for a given user and dapp. This is called by the server to verify the user's solution
+   * and update the record in the database to show that the user has solved the captcha
+   *
+   * @param {string} dappAccount - the dapp that is requesting the captcha
+   * @param {string} challenge - the starting string for the PoW challenge
+   * @param {number} timeout - the time in milliseconds since the Provider was selected to provide the PoW captcha
+   * @param ip
+   */
+  async serverVerifyPowCaptchaSolution(dappAccount, challenge, timeout, ip) {
+    const challengeRecord = await this.db.getPowCaptchaRecordByChallenge(challenge);
+    if (!challengeRecord) {
+      this.logger.debug(() => ({
+        msg: `No record of this challenge: ${challenge}`
+      }));
+      return { verified: false };
+    }
+    const ipValidation = validateIpAddress(
+      ip,
+      challengeRecord.ipAddress,
+      this.logger
+    );
+    if (!ipValidation.isValid) {
+      return { verified: false };
+    }
+    if (challengeRecord.result.status !== CaptchaStatus.approved) {
+      throw new ProsopoApiError("CAPTCHA.INVALID_SOLUTION", {
+        context: {
+          failedFuncName: this.serverVerifyPowCaptchaSolution.name,
+          challenge
         }
-        verifyRecency(challenge, timeout);
-        await this.db.markDappUserPoWCommitmentsChecked([
-            challengeRecord.challenge,
-        ]);
-        let score;
-        if (challengeRecord.frictionlessTokenId) {
-            const tokenRecord = await this.db.getFrictionlessTokenRecordByTokenId(challengeRecord.frictionlessTokenId);
-            if (tokenRecord) {
-                score = computeFrictionlessScore(tokenRecord?.scoreComponents);
-                this.logger.info(() => ({
-                    data: {
-                        tscoreComponents: { ...(tokenRecord?.scoreComponents || {}) },
-                        score,
-                    },
-                }));
-            }
+      });
+    }
+    if (challengeRecord.serverChecked) return { verified: false };
+    const challengeDappAccount = challengeRecord.dappAccount;
+    if (dappAccount !== challengeDappAccount) {
+      throw new ProsopoEnvError("CAPTCHA.DAPP_USER_SOLUTION_NOT_FOUND", {
+        context: {
+          failedFuncName: this.serverVerifyPowCaptchaSolution.name,
+          dappAccount,
+          challengeDappAccount
         }
-        return { verified: true, ...(score ? { score } : {}) };
+      });
+    }
+    verifyRecency(challenge, timeout);
+    await this.db.markDappUserPoWCommitmentsChecked([
+      challengeRecord.challenge
+    ]);
+    let score;
+    if (challengeRecord.frictionlessTokenId) {
+      const tokenRecord = await this.db.getFrictionlessTokenRecordByTokenId(
+        challengeRecord.frictionlessTokenId
+      );
+      if (tokenRecord) {
+        score = computeFrictionlessScore(tokenRecord?.scoreComponents);
+        this.logger.info(() => ({
+          data: {
+            tscoreComponents: { ...tokenRecord?.scoreComponents || {} },
+            score
+          }
+        }));
+      }
     }
+    return { verified: true, ...score ? { score } : {} };
+  }
 }
-//# sourceMappingURL=powTasks.js.map
+export {
+  PowCaptchaManager
+};

package/dist/tasks/powCaptcha/powTasksUtils.js

@@ -1,24 +1,28 @@
 import { sha256 } from "@noble/hashes/sha256";
 import { stringToHex } from "@polkadot/util";
-import { ProsopoContractError } from "@prosopo/common";
+import { ProsopoApiError } from "@prosopo/common";
 import { signatureVerify } from "@prosopo/util-crypto";
-export const validateSolution = (nonce, challenge, difficulty) => Array.from(sha256(new TextEncoder().encode(nonce + challenge)))
-    .map((byte) => byte.toString(16).padStart(2, "0"))
-    .join("")
-    .startsWith("0".repeat(difficulty));
-export const checkPowSignature = (message, signature, address, signatureType) => {
-    const signatureVerification = signatureVerify(stringToHex(message), signature, address);
-    if (!signatureVerification.isValid) {
-        throw new ProsopoContractError("GENERAL.INVALID_SIGNATURE", {
-            context: {
-                ERROR: `Signature is invalid for this message: ${signatureType}`,
-                failedFuncName: checkPowSignature.name,
-                address,
-                message,
-                signature,
-                signatureType,
-            },
-        });
-    }
+const validateSolution = (nonce, challenge, difficulty) => Array.from(sha256(new TextEncoder().encode(nonce + challenge))).map((byte) => byte.toString(16).padStart(2, "0")).join("").startsWith("0".repeat(difficulty));
+const checkPowSignature = (message, signature, address, signatureType) => {
+  const signatureVerification = signatureVerify(
+    stringToHex(message),
+    signature,
+    address
+  );
+  if (!signatureVerification.isValid) {
+    throw new ProsopoApiError("GENERAL.INVALID_SIGNATURE", {
+      context: {
+        ERROR: `Signature is invalid for this message: ${signatureType}`,
+        failedFuncName: checkPowSignature.name,
+        address,
+        message,
+        signature,
+        signatureType
+      }
+    });
+  }
+};
+export {
+  checkPowSignature,
+  validateSolution
 };
-//# sourceMappingURL=powTasksUtils.js.map

package/dist/tasks/tasks.js

@@ -1,36 +1,60 @@
-import { ProsopoEnvError, getLogger, parseLogLevel, } from "@prosopo/common";
+import { getLogger, parseLogLevel, ProsopoEnvError } from "@prosopo/common";
 import { ClientTaskManager } from "./client/clientTasks.js";
 import { DatasetManager } from "./dataset/datasetTasks.js";
 import { FrictionlessManager } from "./frictionless/frictionlessTasks.js";
 import { ImgCaptchaManager } from "./imgCaptcha/imgCaptchaTasks.js";
 import { PowCaptchaManager } from "./powCaptcha/powTasks.js";
-export class Tasks {
-    constructor(env, logger) {
-        this.config = env.config;
-        this.db = env.getDb();
-        this.captchaConfig = env.config.captchas;
-        this.logger =
-            logger || getLogger(parseLogLevel(env.config.logLevel), "Tasks");
-        if (!env.pair) {
-            throw new ProsopoEnvError("DEVELOPER.MISSING_PROVIDER_PAIR", {
-                context: { failedFuncName: "Tasks.constructor" },
-            });
-        }
-        this.pair = env.pair;
-        this.powCaptchaManager = new PowCaptchaManager(this.db, this.pair, this.logger);
-        this.datasetManager = new DatasetManager(this.config, this.logger, this.captchaConfig, this.db);
-        this.imgCaptchaManager = new ImgCaptchaManager(this.db, this.pair, this.config, this.logger);
-        this.clientTaskManager = new ClientTaskManager(this.config, this.logger, this.db);
-        this.frictionlessManager = new FrictionlessManager(this.db, this.pair, this.config, this.logger);
-    }
-    setLogger(logger) {
-        this.logger = logger;
-        this.powCaptchaManager.logger = logger;
-        this.datasetManager.logger = logger;
-        this.imgCaptchaManager.logger = logger;
-        this.clientTaskManager.logger = logger;
-        this.frictionlessManager.logger = logger;
-        this.db.logger = logger;
+class Tasks {
+  constructor(env, logger) {
+    this.config = env.config;
+    this.db = env.getDb();
+    this.captchaConfig = env.config.captchas;
+    this.logger = logger || getLogger(parseLogLevel(env.config.logLevel), "Tasks");
+    if (!env.pair) {
+      throw new ProsopoEnvError("DEVELOPER.MISSING_PROVIDER_PAIR", {
+        context: { failedFuncName: "Tasks.constructor" }
+      });
     }
+    this.pair = env.pair;
+    this.powCaptchaManager = new PowCaptchaManager(
+      this.db,
+      this.pair,
+      this.logger
+    );
+    this.datasetManager = new DatasetManager(
+      this.config,
+      this.logger,
+      this.captchaConfig,
+      this.db
+    );
+    this.imgCaptchaManager = new ImgCaptchaManager(
+      this.db,
+      this.pair,
+      this.config,
+      this.logger
+    );
+    this.clientTaskManager = new ClientTaskManager(
+      this.config,
+      this.logger,
+      this.db
+    );
+    this.frictionlessManager = new FrictionlessManager(
+      this.db,
+      this.pair,
+      this.config,
+      this.logger
+    );
+  }
+  setLogger(logger) {
+    this.logger = logger;
+    this.powCaptchaManager.logger = logger;
+    this.datasetManager.logger = logger;
+    this.imgCaptchaManager.logger = logger;
+    this.clientTaskManager.logger = logger;
+    this.frictionlessManager.logger = logger;
+    this.db.logger = logger;
+  }
 }
-//# sourceMappingURL=tasks.js.map
+export {
+  Tasks
+};

package/dist/util.js

@@ -1,102 +1,112 @@
 import { hexToU8a } from "@polkadot/util/hex";
 import { isHex } from "@polkadot/util/is";
-import { ProsopoContractError, ProsopoEnvError, } from "@prosopo/common";
-import { ScheduledTaskStatus, } from "@prosopo/types";
+import { ProsopoContractError, ProsopoEnvError } from "@prosopo/common";
+import { ScheduledTaskStatus } from "@prosopo/types";
 import { at } from "@prosopo/util";
-import { decodeAddress, encodeAddress } from "@prosopo/util-crypto";
+import { encodeAddress, decodeAddress } from "@prosopo/util-crypto";
 import { Address4, Address6 } from "ip-address";
-export function encodeStringAddress(address) {
-    try {
-        return encodeAddress(isHex(address) ? hexToU8a(address) : decodeAddress(address));
-    }
-    catch (err) {
-        throw new ProsopoContractError("CONTRACT.INVALID_ADDRESS", {
-            context: { address },
-        });
-    }
+function encodeStringAddress(address) {
+  try {
+    return encodeAddress(
+      isHex(address) ? hexToU8a(address) : decodeAddress(address)
+    );
+  } catch (err) {
+    throw new ProsopoContractError("CONTRACT.INVALID_ADDRESS", {
+      context: { address }
+    });
+  }
 }
-export function shuffleArray(array) {
-    for (let arrayIndex = array.length - 1; arrayIndex > 0; arrayIndex--) {
-        const randIndex = Math.floor(Math.random() * (arrayIndex + 1));
-        const tmp = at(array, randIndex);
-        array[randIndex] = at(array, arrayIndex);
-        array[arrayIndex] = tmp;
-    }
-    return array;
+function shuffleArray(array) {
+  for (let arrayIndex = array.length - 1; arrayIndex > 0; arrayIndex--) {
+    const randIndex = Math.floor(Math.random() * (arrayIndex + 1));
+    const tmp = at(array, randIndex);
+    array[randIndex] = at(array, arrayIndex);
+    array[arrayIndex] = tmp;
+  }
+  return array;
 }
-export async function checkIfTaskIsRunning(taskName, db) {
-    const runningTask = await db.getLastScheduledTaskStatus(taskName, ScheduledTaskStatus.Running);
-    const twoMinutesAgo = new Date().getTime() - 1000 * 60 * 2;
-    if (runningTask && runningTask.datetime > twoMinutesAgo) {
-        const completedTask = await db.getScheduledTaskStatus(runningTask._id, ScheduledTaskStatus.Completed);
-        return !completedTask;
-    }
-    return false;
+async function checkIfTaskIsRunning(taskName, db) {
+  const runningTask = await db.getLastScheduledTaskStatus(
+    taskName,
+    ScheduledTaskStatus.Running
+  );
+  const twoMinutesAgo = (/* @__PURE__ */ new Date()).getTime() - 1e3 * 60 * 2;
+  if (runningTask && runningTask.datetime > twoMinutesAgo) {
+    const completedTask = await db.getScheduledTaskStatus(
+      runningTask._id,
+      ScheduledTaskStatus.Completed
+    );
+    return !completedTask;
+  }
+  return false;
 }
-export const getIPAddress = (ipAddressString) => {
+const getIPAddress = (ipAddressString) => {
+  try {
     try {
-        try {
-            return new Address4(ipAddressString);
-        }
-        catch (e) {
-            return new Address6(ipAddressString);
-        }
-    }
-    catch (e) {
-        throw new ProsopoEnvError("API.INVALID_IP");
+      return new Address4(ipAddressString);
+    } catch (e) {
+      return new Address6(ipAddressString);
     }
+  } catch (e) {
+    throw new ProsopoEnvError("API.INVALID_IP");
+  }
 };
-export const getIPAddressFromBigInt = (ipAddressBigInt) => {
-    try {
-        if (ipAddressBigInt > 4228250626n) {
-            return Address6.fromBigInt(BigInt(ipAddressBigInt));
-        }
-        return Address4.fromBigInt(BigInt(ipAddressBigInt));
-    }
-    catch (e) {
-        throw new ProsopoEnvError("API.INVALID_IP");
+const getIPAddressFromBigInt = (ipAddressBigInt) => {
+  try {
+    if (ipAddressBigInt > 4228250626n) {
+      return Address6.fromBigInt(BigInt(ipAddressBigInt));
     }
+    return Address4.fromBigInt(BigInt(ipAddressBigInt));
+  } catch (e) {
+    throw new ProsopoEnvError("API.INVALID_IP");
+  }
 };
-export const validateIpAddress = (ip, challengeRecordIpAddress, logger) => {
-    if (!ip) {
-        return { isValid: true };
-    }
-    let ipV4orV6Address;
-    try {
-        ipV4orV6Address = getIPAddress(ip);
-        logger.info(() => ({ data: { ipV4orV6Address } }));
-    }
-    catch (e) {
-        const errorMessage = `Invalid IP address: ${ip}`;
-        logger.info(() => ({ msg: errorMessage }));
-        return { isValid: false, errorMessage };
-    }
-    let challengeIpV4orV6Address = getIPAddressFromBigInt(challengeRecordIpAddress);
-    ipV4orV6Address =
-        "address4" in ipV4orV6Address && ipV4orV6Address.address4
-            ? ipV4orV6Address.address4
-            : ipV4orV6Address;
-    challengeIpV4orV6Address =
-        "address4" in challengeIpV4orV6Address && challengeIpV4orV6Address.address4
-            ? challengeIpV4orV6Address.address4
-            : challengeIpV4orV6Address;
-    if (ipV4orV6Address.v4 && !challengeIpV4orV6Address.v4) {
-        challengeIpV4orV6Address = new Address4(challengeIpV4orV6Address.to4().correctForm());
-    }
-    if (!ipV4orV6Address.v4 && challengeIpV4orV6Address.v4) {
-        ipV4orV6Address = new Address6(ipV4orV6Address.to4().correctForm());
-    }
-    if (challengeIpV4orV6Address.bigInt() - ipV4orV6Address.bigInt() !== 0n) {
-        const errorMessage = `IP address mismatch: ${challengeIpV4orV6Address.address} !== ${ipV4orV6Address.address}`;
-        logger.info(() => ({
-            msg: errorMessage,
-            data: {
-                challengeIp: challengeIpV4orV6Address.address,
-                providedIp: ipV4orV6Address.address,
-            },
-        }));
-        return { isValid: false, errorMessage };
-    }
+const validateIpAddress = (ip, challengeRecordIpAddress, logger) => {
+  if (!ip) {
     return { isValid: true };
+  }
+  let ipV4orV6Address;
+  try {
+    ipV4orV6Address = getIPAddress(ip);
+    logger.info(() => ({ data: { ipV4orV6Address } }));
+  } catch (e) {
+    const errorMessage = `Invalid IP address: ${ip}`;
+    logger.info(() => ({ msg: errorMessage }));
+    return { isValid: false, errorMessage };
+  }
+  let challengeIpV4orV6Address = getIPAddressFromBigInt(
+    challengeRecordIpAddress
+  );
+  ipV4orV6Address = "address4" in ipV4orV6Address && ipV4orV6Address.address4 ? ipV4orV6Address.address4 : ipV4orV6Address;
+  challengeIpV4orV6Address = "address4" in challengeIpV4orV6Address && challengeIpV4orV6Address.address4 ? challengeIpV4orV6Address.address4 : challengeIpV4orV6Address;
+  if (ipV4orV6Address.v4 && !challengeIpV4orV6Address.v4) {
+    challengeIpV4orV6Address = new Address4(
+      challengeIpV4orV6Address.to4().correctForm()
+    );
+  }
+  if (!ipV4orV6Address.v4 && challengeIpV4orV6Address.v4) {
+    ipV4orV6Address = new Address6(
+      ipV4orV6Address.to4().correctForm()
+    );
+  }
+  if (challengeIpV4orV6Address.bigInt() - ipV4orV6Address.bigInt() !== 0n) {
+    const errorMessage = `IP address mismatch: ${challengeIpV4orV6Address.address} !== ${ipV4orV6Address.address}`;
+    logger.info(() => ({
+      msg: errorMessage,
+      data: {
+        challengeIp: challengeIpV4orV6Address.address,
+        providedIp: ipV4orV6Address.address
+      }
+    }));
+    return { isValid: false, errorMessage };
+  }
+  return { isValid: true };
+};
+export {
+  checkIfTaskIsRunning,
+  encodeStringAddress,
+  getIPAddress,
+  getIPAddressFromBigInt,
+  shuffleArray,
+  validateIpAddress
 };
-//# sourceMappingURL=util.js.map