@prosopo/provider 4.15.13 → 4.15.15

package/dist/util.js

@@ -1,378 +1,341 @@
-import { hexToU8a } from "@polkadot/util/hex";
-import { isHex } from "@polkadot/util/is";
+import { compareIPs } from "./services/ipComparison.js";
 import { ProsopoContractError, ProsopoEnvError } from "@prosopo/common";
-import { ScheduledTaskStatus, IPValidationAction } from "@prosopo/types";
+import { IPValidationAction, ScheduledTaskStatus } from "@prosopo/types";
 import { at } from "@prosopo/util";
-import { encodeAddress, decodeAddress } from "@prosopo/util-crypto";
+import { decodeAddress, encodeAddress } from "@prosopo/util-crypto";
 import { Address4, Address6 } from "ip-address";
-import { compareIPs } from "./services/ipComparison.js";
+import { hexToU8a } from "@polkadot/util/hex";
+import { isHex } from "@polkadot/util/is";
+//#region src/util.ts
 function encodeStringAddress(address) {
-  try {
-    return encodeAddress(
-      isHex(address) ? hexToU8a(address) : decodeAddress(address)
-    );
-  } catch (err) {
-    throw new ProsopoContractError("CONTRACT.INVALID_ADDRESS", {
-      context: { address }
-    });
-  }
+	try {
+		return encodeAddress(isHex(address) ? hexToU8a(address) : decodeAddress(address));
+	} catch (err) {
+		throw new ProsopoContractError("CONTRACT.INVALID_ADDRESS", { context: { address } });
+	}
 }
 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;
+	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;
 }
+/**
+* Check if there is a scheduled task running.
+* If the scheduled task is running and not completed, return true.
+* If the scheduled task is running and completed, return false.
+* Otherwise, the scheduled task is not running, 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.getTime() > twoMinutesAgo) {
-    const completedTask = await db.getScheduledTaskStatus(
-      runningTask._id,
-      ScheduledTaskStatus.Completed
-    );
-    return !completedTask;
-  }
-  return false;
+	const runningTask = await db.getLastScheduledTaskStatus(taskName, ScheduledTaskStatus.Running);
+	const twoMinutesAgo = (/* @__PURE__ */ new Date()).getTime() - 1e3 * 60 * 2;
+	if (runningTask && runningTask.datetime.getTime() > twoMinutesAgo) return !await db.getScheduledTaskStatus(runningTask._id, ScheduledTaskStatus.Completed);
+	return false;
 }
-const getIPAddress = (ipAddressString) => {
-  try {
-    try {
-      return new Address4(ipAddressString);
-    } catch (e) {
-      return new Address6(ipAddressString);
-    }
-  } 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");
-  }
+var getIPAddress$1 = (ipAddressString) => {
+	try {
+		try {
+			return new Address4(ipAddressString);
+		} catch (e) {
+			return new Address6(ipAddressString);
+		}
+	} catch (e) {
+		throw new ProsopoEnvError("API.INVALID_IP");
+	}
 };
-const validateIpAddress = (ip, challengeIpAddress, 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 };
-  }
-  ipV4orV6Address = "address4" in ipV4orV6Address && ipV4orV6Address.address4 ? ipV4orV6Address.address4 : ipV4orV6Address;
-  challengeIpAddress = "address4" in challengeIpAddress && challengeIpAddress.address4 ? challengeIpAddress.address4 : challengeIpAddress;
-  if (ipV4orV6Address.v4 && !challengeIpAddress.v4) {
-    challengeIpAddress = new Address4(
-      challengeIpAddress.to4().correctForm()
-    );
-  }
-  if (challengeIpAddress.bigInt() - ipV4orV6Address.bigInt() !== 0n) {
-    const errorMessage = `IP address mismatch: ${challengeIpAddress.address} !== ${ipV4orV6Address.address}`;
-    logger.info(() => ({
-      msg: errorMessage,
-      data: {
-        challengeIp: challengeIpAddress.address,
-        providedIp: ipV4orV6Address.address
-      }
-    }));
-    return { isValid: false, errorMessage };
-  }
-  return { isValid: true };
+var 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 evaluateIpValidationRules = (comparison, rules, logger) => {
-  if (!comparison.comparison) {
-    return { action: IPValidationAction.Allow };
-  }
-  const conditions = [];
-  const rejectActions = Object.values(rules.actions).filter(
-    (action) => action === IPValidationAction.Reject
-  );
-  const ip1Country = comparison.comparison.ip1Details?.country;
-  const ip2Country = comparison.comparison.ip2Details?.country;
-  const ip1CountryCode = comparison.comparison.ip1Details?.countryCode;
-  const ip2CountryCode = comparison.comparison.ip2Details?.countryCode;
-  let effectiveRules = rules;
-  let countryOverride = void 0;
-  if (ip1CountryCode && rules.countryOverrides?.[ip1CountryCode]) {
-    countryOverride = rules.countryOverrides[ip1CountryCode];
-  }
-  if (ip2CountryCode && rules.countryOverrides?.[ip2CountryCode]) {
-    countryOverride = rules.countryOverrides[ip2CountryCode];
-  }
-  if (countryOverride) {
-    effectiveRules = {
-      ...rules,
-      actions: {
-        ...rules.actions,
-        ...countryOverride.actions
-      },
-      distanceThresholdKm: countryOverride.distanceThresholdKm ?? rules.distanceThresholdKm,
-      abuseScoreThreshold: countryOverride.abuseScoreThreshold ?? rules.abuseScoreThreshold,
-      requireAllConditions: countryOverride.requireAllConditions ?? rules.requireAllConditions
-    };
-  }
-  if (ip1Country !== ip2Country) {
-    conditions.push({
-      met: true,
-      action: effectiveRules.actions.countryChangeAction,
-      message: `Country changed from ${ip1Country} to ${ip2Country}`
-    });
-  }
-  const ip1Provider = comparison.comparison.ip1Details?.provider;
-  const ip2Provider = comparison.comparison.ip2Details?.provider;
-  const ip1ConnectionType = comparison.comparison.ip1Details?.connectionType;
-  const ip2ConnectionType = comparison.comparison.ip2Details?.connectionType;
-  const sameTrustedProvider = !comparison.comparison.differentProviders && !!ip1Provider && ip1Provider !== "Unknown" && ip1CountryCode === ip2CountryCode && ip1ConnectionType !== "datacenter" && ip2ConnectionType !== "datacenter";
-  if (sameTrustedProvider) {
-    logger.info(() => ({
-      msg: "Skipping city and distance IP validation rules for same trusted provider",
-      data: {
-        provider: ip1Provider,
-        countryCode: ip1CountryCode
-      }
-    }));
-  }
-  const ip1City = comparison.comparison.ip1Details?.city;
-  const ip2City = comparison.comparison.ip2Details?.city;
-  if (!sameTrustedProvider && ip1City !== ip2City) {
-    conditions.push({
-      met: true,
-      action: effectiveRules.actions.cityChangeAction,
-      message: `City changed from ${ip1City} to ${ip2City}`
-    });
-  }
-  if (comparison.comparison.differentProviders) {
-    conditions.push({
-      met: true,
-      action: effectiveRules.actions.ispChangeAction,
-      message: `ISP changed from ${ip1Provider} to ${ip2Provider}`
-    });
-  }
-  const distanceKm = comparison.comparison.distanceKm;
-  if (!sameTrustedProvider && distanceKm !== void 0 && distanceKm > effectiveRules.distanceThresholdKm) {
-    conditions.push({
-      met: true,
-      action: effectiveRules.actions.distanceExceedAction,
-      message: `IP addresses are ${distanceKm.toFixed(2)}km apart (>${effectiveRules.distanceThresholdKm}km limit)`
-    });
-  }
-  const ip2AbuseScore = comparison.comparison.ip2Details?.abuserScore;
-  if (ip2AbuseScore !== void 0 && ip2AbuseScore > effectiveRules.abuseScoreThreshold) {
-    conditions.push({
-      met: true,
-      action: effectiveRules.actions.abuseScoreExceedAction,
-      message: `Abuse score ${ip2AbuseScore.toFixed(4)} exceeds threshold ${effectiveRules.abuseScoreThreshold}`
-    });
-  }
-  const ip1AbuseScore = comparison.comparison.ip1Details?.abuserScore;
-  if (ip1AbuseScore !== void 0 && ip1AbuseScore > effectiveRules.abuseScoreThreshold) {
-    conditions.push({
-      met: true,
-      action: effectiveRules.actions.abuseScoreExceedAction,
-      message: `Abuse score ${ip1AbuseScore.toFixed(4)} exceeds threshold ${effectiveRules.abuseScoreThreshold}`
-    });
-  }
-  if (conditions.length === 0) {
-    return { action: IPValidationAction.Allow };
-  }
-  const errorMessages = [];
-  let finalAction = IPValidationAction.Allow;
-  let shouldFlag = false;
-  if (effectiveRules.requireAllConditions) {
-    const rejectConditions = conditions.filter(
-      (c) => c.action === IPValidationAction.Reject
-    );
-    if (rejectConditions.length > 0 && rejectConditions.length >= rejectActions.length) {
-      finalAction = IPValidationAction.Reject;
-    }
-    for (const condition of conditions) {
-      if (condition.action === IPValidationAction.Reject || condition.action === IPValidationAction.Flag) {
-        errorMessages.push(condition.message);
-      }
-    }
-  } else {
-    for (const condition of conditions) {
-      if (condition.action === IPValidationAction.Reject) {
-        finalAction = IPValidationAction.Reject;
-        errorMessages.push(condition.message);
-        break;
-      }
-      if (condition.action === IPValidationAction.Flag) {
-        finalAction = IPValidationAction.Flag;
-        shouldFlag = true;
-      }
-      errorMessages.push(condition.message);
-    }
-  }
-  logger.info(() => ({
-    msg: `IP validation rules evaluated: ${finalAction}`,
-    data: {
-      conditions,
-      finalAction,
-      requireAllConditions: effectiveRules.requireAllConditions
-    }
-  }));
-  return {
-    action: finalAction,
-    errorMessage: errorMessages.length > 0 ? errorMessages.join("; ") : void 0,
-    shouldFlag
-  };
+/**
+* Validates that the provided IP address matches the challenge record's IP address
+* @param ip - The IP address string to validate
+* @param challengeIpAddress - The IP address from the challenge record
+* @param logger - Logger instance for debug messages
+* @returns Object with validation result and optional error message
+*/
+var validateIpAddress = (ip, challengeIpAddress, logger) => {
+	if (!ip) return { isValid: true };
+	let ipV4orV6Address;
+	try {
+		ipV4orV6Address = getIPAddress$1(ip);
+		logger.info(() => ({ data: { ipV4orV6Address } }));
+	} catch (e) {
+		const errorMessage = `Invalid IP address: ${ip}`;
+		logger.info(() => ({ msg: errorMessage }));
+		return {
+			isValid: false,
+			errorMessage
+		};
+	}
+	ipV4orV6Address = "address4" in ipV4orV6Address && ipV4orV6Address.address4 ? ipV4orV6Address.address4 : ipV4orV6Address;
+	challengeIpAddress = "address4" in challengeIpAddress && challengeIpAddress.address4 ? challengeIpAddress.address4 : challengeIpAddress;
+	if (ipV4orV6Address.v4 && !challengeIpAddress.v4) challengeIpAddress = new Address4(challengeIpAddress.to4().correctForm());
+	if (challengeIpAddress.bigInt() - ipV4orV6Address.bigInt() !== 0n) {
+		const errorMessage = `IP address mismatch: ${challengeIpAddress.address} !== ${ipV4orV6Address.address}`;
+		logger.info(() => ({
+			msg: errorMessage,
+			data: {
+				challengeIp: challengeIpAddress.address,
+				providedIp: ipV4orV6Address.address
+			}
+		}));
+		return {
+			isValid: false,
+			errorMessage
+		};
+	}
+	return { isValid: true };
 };
-const deepValidateIpAddress = async (ip, challengeIpAddress, logger, ipInfoService, ipValidationRules, dnsPeerIp) => {
-  if (ipValidationRules?.forceConsistentIp === true && dnsPeerIp && dnsPeerIp !== ip) {
-    logger.info(() => ({
-      msg: "IP validation failed - dnsEvent.peerIp does not match client IP",
-      data: { clientIp: ip, dnsPeerIp }
-    }));
-    return {
-      isValid: false,
-      errorMessage: `Client IP ${ip} does not match dnsEvent.peerIp ${dnsPeerIp}`
-    };
-  }
-  const standardValidation = validateIpAddress(ip, challengeIpAddress, logger);
-  if (!standardValidation.isValid) {
-    if (standardValidation.errorMessage?.includes("Invalid IP address")) {
-      return standardValidation;
-    }
-    if (ipValidationRules?.forceConsistentIp === true) {
-      logger.info(() => ({
-        msg: "IP validation failed - forceConsistentIp is true",
-        data: {
-          challengeIp: challengeIpAddress.address,
-          providedIp: ip
-        }
-      }));
-      return {
-        isValid: false,
-        errorMessage: standardValidation.errorMessage
-      };
-    }
-  } else {
-    return { isValid: true };
-  }
-  try {
-    const challengeIpString = challengeIpAddress.address;
-    const comparison = await compareIPs(challengeIpString, ip, ipInfoService);
-    if ("error" in comparison) {
-      logger.error(() => ({
-        msg: "Failed to get IP distance comparison",
-        data: {
-          error: comparison.error,
-          challengeIp: challengeIpString,
-          providedIp: ip
-        }
-      }));
-      return {
-        isValid: true,
-        errorMessage: "Could not determine IP distance"
-      };
-    }
-    if (comparison.ipsMatch) {
-      return { isValid: true };
-    }
-    const distanceKm = comparison.comparison?.distanceKm;
-    if (!ipValidationRules) {
-      logger.info(() => ({
-        msg: "No IP validation rules provided, using legacy logic",
-        data: {
-          challengeIp: challengeIpString,
-          providedIp: ip,
-          distanceKm
-        }
-      }));
-      if (distanceKm !== void 0 && distanceKm > 1e3) {
-        const errorMessage = `IP addresses are too far apart: ${distanceKm.toFixed(2)}km (>1000km limit)`;
-        logger.info(() => ({
-          msg: "IP validation failed - distance too great",
-          data: {
-            challengeIp: challengeIpString,
-            providedIp: ip,
-            distanceKm,
-            comparison: comparison.comparison
-          }
-        }));
-        return {
-          isValid: false,
-          errorMessage,
-          distanceKm
-        };
-      }
-      logger.info(() => ({
-        msg: "IP addresses differ but within acceptable distance",
-        data: {
-          challengeIp: challengeIpString,
-          providedIp: ip,
-          distanceKm,
-          comparison: comparison.comparison
-        }
-      }));
-      return {
-        isValid: true,
-        distanceKm,
-        shouldFlag: true
-      };
-    }
-    const ruleEvaluation = evaluateIpValidationRules(
-      comparison,
-      ipValidationRules,
-      logger
-    );
-    switch (ruleEvaluation.action) {
-      case IPValidationAction.Reject:
-        return {
-          isValid: false,
-          errorMessage: ruleEvaluation.errorMessage,
-          distanceKm
-        };
-      case IPValidationAction.Flag:
-        return {
-          isValid: true,
-          distanceKm,
-          shouldFlag: true,
-          errorMessage: ruleEvaluation.errorMessage
-        };
-      default:
-        return {
-          isValid: true,
-          distanceKm
-        };
-    }
-  } catch (error) {
-    logger.error(() => ({
-      msg: "Error during IP distance validation",
-      err: error,
-      data: { challengeIp: challengeIpAddress.address, providedIp: ip }
-    }));
-    return {
-      isValid: true,
-      shouldFlag: true,
-      errorMessage: "IP distance validation error"
-    };
-  }
+/**
+* Evaluates IP validation rules based on IP comparison results
+* @param comparison - IP comparison results from compareIPs
+* @param rules - IP validation rules configuration
+* @param logger - Logger instance
+* @returns Validation result with action to take
+*/
+var evaluateIpValidationRules = (comparison, rules, logger) => {
+	if (!comparison.comparison) return { action: IPValidationAction.Allow };
+	const conditions = [];
+	const rejectActions = Object.values(rules.actions).filter((action) => action === IPValidationAction.Reject);
+	const ip1Country = comparison.comparison.ip1Details?.country;
+	const ip2Country = comparison.comparison.ip2Details?.country;
+	const ip1CountryCode = comparison.comparison.ip1Details?.countryCode;
+	const ip2CountryCode = comparison.comparison.ip2Details?.countryCode;
+	let effectiveRules = rules;
+	let countryOverride = void 0;
+	if (ip1CountryCode && rules.countryOverrides?.[ip1CountryCode]) countryOverride = rules.countryOverrides[ip1CountryCode];
+	if (ip2CountryCode && rules.countryOverrides?.[ip2CountryCode]) countryOverride = rules.countryOverrides[ip2CountryCode];
+	if (countryOverride) effectiveRules = {
+		...rules,
+		actions: {
+			...rules.actions,
+			...countryOverride.actions
+		},
+		distanceThresholdKm: countryOverride.distanceThresholdKm ?? rules.distanceThresholdKm,
+		abuseScoreThreshold: countryOverride.abuseScoreThreshold ?? rules.abuseScoreThreshold,
+		requireAllConditions: countryOverride.requireAllConditions ?? rules.requireAllConditions
+	};
+	if (ip1Country !== ip2Country) conditions.push({
+		met: true,
+		action: effectiveRules.actions.countryChangeAction,
+		message: `Country changed from ${ip1Country} to ${ip2Country}`
+	});
+	const ip1Provider = comparison.comparison.ip1Details?.provider;
+	const ip2Provider = comparison.comparison.ip2Details?.provider;
+	const ip1ConnectionType = comparison.comparison.ip1Details?.connectionType;
+	const ip2ConnectionType = comparison.comparison.ip2Details?.connectionType;
+	const sameTrustedProvider = !comparison.comparison.differentProviders && !!ip1Provider && ip1Provider !== "Unknown" && ip1CountryCode === ip2CountryCode && ip1ConnectionType !== "datacenter" && ip2ConnectionType !== "datacenter";
+	if (sameTrustedProvider) logger.info(() => ({
+		msg: "Skipping city and distance IP validation rules for same trusted provider",
+		data: {
+			provider: ip1Provider,
+			countryCode: ip1CountryCode
+		}
+	}));
+	const ip1City = comparison.comparison.ip1Details?.city;
+	const ip2City = comparison.comparison.ip2Details?.city;
+	if (!sameTrustedProvider && ip1City !== ip2City) conditions.push({
+		met: true,
+		action: effectiveRules.actions.cityChangeAction,
+		message: `City changed from ${ip1City} to ${ip2City}`
+	});
+	if (comparison.comparison.differentProviders) conditions.push({
+		met: true,
+		action: effectiveRules.actions.ispChangeAction,
+		message: `ISP changed from ${ip1Provider} to ${ip2Provider}`
+	});
+	const distanceKm = comparison.comparison.distanceKm;
+	if (!sameTrustedProvider && distanceKm !== void 0 && distanceKm > effectiveRules.distanceThresholdKm) conditions.push({
+		met: true,
+		action: effectiveRules.actions.distanceExceedAction,
+		message: `IP addresses are ${distanceKm.toFixed(2)}km apart (>${effectiveRules.distanceThresholdKm}km limit)`
+	});
+	const ip2AbuseScore = comparison.comparison.ip2Details?.abuserScore;
+	if (ip2AbuseScore !== void 0 && ip2AbuseScore > effectiveRules.abuseScoreThreshold) conditions.push({
+		met: true,
+		action: effectiveRules.actions.abuseScoreExceedAction,
+		message: `Abuse score ${ip2AbuseScore.toFixed(4)} exceeds threshold ${effectiveRules.abuseScoreThreshold}`
+	});
+	const ip1AbuseScore = comparison.comparison.ip1Details?.abuserScore;
+	if (ip1AbuseScore !== void 0 && ip1AbuseScore > effectiveRules.abuseScoreThreshold) conditions.push({
+		met: true,
+		action: effectiveRules.actions.abuseScoreExceedAction,
+		message: `Abuse score ${ip1AbuseScore.toFixed(4)} exceeds threshold ${effectiveRules.abuseScoreThreshold}`
+	});
+	if (conditions.length === 0) return { action: IPValidationAction.Allow };
+	const errorMessages = [];
+	let finalAction = IPValidationAction.Allow;
+	let shouldFlag = false;
+	if (effectiveRules.requireAllConditions) {
+		const rejectConditions = conditions.filter((c) => c.action === IPValidationAction.Reject);
+		if (rejectConditions.length > 0 && rejectConditions.length >= rejectActions.length) finalAction = IPValidationAction.Reject;
+		for (const condition of conditions) if (condition.action === IPValidationAction.Reject || condition.action === IPValidationAction.Flag) errorMessages.push(condition.message);
+	} else for (const condition of conditions) {
+		if (condition.action === IPValidationAction.Reject) {
+			finalAction = IPValidationAction.Reject;
+			errorMessages.push(condition.message);
+			break;
+		}
+		if (condition.action === IPValidationAction.Flag) {
+			finalAction = IPValidationAction.Flag;
+			shouldFlag = true;
+		}
+		errorMessages.push(condition.message);
+	}
+	logger.info(() => ({
+		msg: `IP validation rules evaluated: ${finalAction}`,
+		data: {
+			conditions,
+			finalAction,
+			requireAllConditions: effectiveRules.requireAllConditions
+		}
+	}));
+	return {
+		action: finalAction,
+		errorMessage: errorMessages.length > 0 ? errorMessages.join("; ") : void 0,
+		shouldFlag
+	};
 };
-export {
-  checkIfTaskIsRunning,
-  deepValidateIpAddress,
-  encodeStringAddress,
-  evaluateIpValidationRules,
-  getIPAddress,
-  getIPAddressFromBigInt,
-  shuffleArray,
-  validateIpAddress
+/**
+* @param ip - The IP address string to validate
+* @param challengeIpAddress - The IP address from the challenge record
+* @param logger - Logger instance for debug messages
+* @param ipInfoService - IP info service for local lookups
+* @param ipValidationRules - IP validation rules configuration
+* @returns Object with validation result, optional error message, and distance info
+*/
+var deepValidateIpAddress = async (ip, challengeIpAddress, logger, ipInfoService, ipValidationRules, dnsPeerIp) => {
+	if (ipValidationRules?.forceConsistentIp === true && dnsPeerIp && dnsPeerIp !== ip) {
+		logger.info(() => ({
+			msg: "IP validation failed - dnsEvent.peerIp does not match client IP",
+			data: {
+				clientIp: ip,
+				dnsPeerIp
+			}
+		}));
+		return {
+			isValid: false,
+			errorMessage: `Client IP ${ip} does not match dnsEvent.peerIp ${dnsPeerIp}`
+		};
+	}
+	const standardValidation = validateIpAddress(ip, challengeIpAddress, logger);
+	if (!standardValidation.isValid) {
+		if (standardValidation.errorMessage?.includes("Invalid IP address")) return standardValidation;
+		if (ipValidationRules?.forceConsistentIp === true) {
+			logger.info(() => ({
+				msg: "IP validation failed - forceConsistentIp is true",
+				data: {
+					challengeIp: challengeIpAddress.address,
+					providedIp: ip
+				}
+			}));
+			return {
+				isValid: false,
+				errorMessage: standardValidation.errorMessage
+			};
+		}
+	} else return { isValid: true };
+	try {
+		const challengeIpString = challengeIpAddress.address;
+		const comparison = await compareIPs(challengeIpString, ip, ipInfoService);
+		if ("error" in comparison) {
+			logger.error(() => ({
+				msg: "Failed to get IP distance comparison",
+				data: {
+					error: comparison.error,
+					challengeIp: challengeIpString,
+					providedIp: ip
+				}
+			}));
+			return {
+				isValid: true,
+				errorMessage: "Could not determine IP distance"
+			};
+		}
+		if (comparison.ipsMatch) return { isValid: true };
+		const distanceKm = comparison.comparison?.distanceKm;
+		if (!ipValidationRules) {
+			logger.info(() => ({
+				msg: "No IP validation rules provided, using legacy logic",
+				data: {
+					challengeIp: challengeIpString,
+					providedIp: ip,
+					distanceKm
+				}
+			}));
+			if (distanceKm !== void 0 && distanceKm > 1e3) {
+				const errorMessage = `IP addresses are too far apart: ${distanceKm.toFixed(2)}km (>1000km limit)`;
+				logger.info(() => ({
+					msg: "IP validation failed - distance too great",
+					data: {
+						challengeIp: challengeIpString,
+						providedIp: ip,
+						distanceKm,
+						comparison: comparison.comparison
+					}
+				}));
+				return {
+					isValid: false,
+					errorMessage,
+					distanceKm
+				};
+			}
+			logger.info(() => ({
+				msg: "IP addresses differ but within acceptable distance",
+				data: {
+					challengeIp: challengeIpString,
+					providedIp: ip,
+					distanceKm,
+					comparison: comparison.comparison
+				}
+			}));
+			return {
+				isValid: true,
+				distanceKm,
+				shouldFlag: true
+			};
+		}
+		const ruleEvaluation = evaluateIpValidationRules(comparison, ipValidationRules, logger);
+		switch (ruleEvaluation.action) {
+			case IPValidationAction.Reject: return {
+				isValid: false,
+				errorMessage: ruleEvaluation.errorMessage,
+				distanceKm
+			};
+			case IPValidationAction.Flag: return {
+				isValid: true,
+				distanceKm,
+				shouldFlag: true,
+				errorMessage: ruleEvaluation.errorMessage
+			};
+			default: return {
+				isValid: true,
+				distanceKm
+			};
+		}
+	} catch (error) {
+		logger.error(() => ({
+			msg: "Error during IP distance validation",
+			err: error,
+			data: {
+				challengeIp: challengeIpAddress.address,
+				providedIp: ip
+			}
+		}));
+		return {
+			isValid: true,
+			shouldFlag: true,
+			errorMessage: "IP distance validation error"
+		};
+	}
 };
+//#endregion
+export { checkIfTaskIsRunning, deepValidateIpAddress, encodeStringAddress, evaluateIpValidationRules, getIPAddress$1 as getIPAddress, getIPAddressFromBigInt, shuffleArray, validateIpAddress };