@prosopo/client-example-server 2.7.121 → 2.7.123

package/dist/cjs/controllers/auth.cjs

@@ -1,255 +1,189 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const blake2b = require("@noble/hashes/blake2b");
-const util = require("@polkadot/util");
-const utilCrypto = require("@polkadot/util-crypto");
-const common = require("@prosopo/common");
-const keyring = require("@prosopo/keyring");
-const logger$1 = require("@prosopo/logger");
-const server = require("@prosopo/server");
-const types = require("@prosopo/types");
-const util$1 = require("@prosopo/util");
-const jwt = require("jsonwebtoken");
-const zod = require("zod");
-const logger = logger$1.getLogger("info", "client-example-server:auth");
-const SubscribeBodySpec = types.ProcaptchaResponse.merge(
-  zod.z.object({
-    email: zod.z.string().email(),
-    password: zod.z.string(),
-    siteKey: zod.z.string()
-  })
-);
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+let _prosopo_common = require("@prosopo/common");
+let _prosopo_logger = require("@prosopo/logger");
+let _prosopo_server = require("@prosopo/server");
+let _prosopo_util = require("@prosopo/util");
+let _noble_hashes_blake2b = require("@noble/hashes/blake2b");
+let _polkadot_util = require("@polkadot/util");
+let _polkadot_util_crypto = require("@polkadot/util-crypto");
+let _prosopo_keyring = require("@prosopo/keyring");
+let _prosopo_types = require("@prosopo/types");
+let jsonwebtoken = require("jsonwebtoken");
+jsonwebtoken = require_runtime.__toESM(jsonwebtoken, 1);
+let zod = require("zod");
+//#region src/controllers/auth.ts
+var logger = (0, _prosopo_logger.getLogger)("info", "client-example-server:auth");
+var SubscribeBodySpec = _prosopo_types.ProcaptchaResponse.merge(zod.z.object({
+	email: zod.z.string().email(),
+	password: zod.z.string(),
+	siteKey: zod.z.string()
+}));
 function hashPassword(password) {
-  return util.u8aToHex(blake2b.blake2b(password));
+	return (0, _polkadot_util.u8aToHex)((0, _noble_hashes_blake2b.blake2b)(password));
 }
-const NO_IP = "NO_IP";
-const getPairAndSecretForSiteKey = (baseSecret, siteKey) => {
-  let pair;
-  let secret = baseSecret;
-  pair = keyring.getPair(secret);
-  if (pair.address === siteKey) {
-    logger.info(() => ({
-      msg: "Site key matches the server configuration without captcha type suffix",
-      data: {
-        siteKeyDerived: pair?.address,
-        siteKey
-      }
-    }));
-    return { pair, secret };
-  }
-  for (const captchaType of [
-    types.CaptchaType.pow,
-    types.CaptchaType.image,
-    types.CaptchaType.frictionless,
-    types.CaptchaType.puzzle
-  ]) {
-    const newSecret = `${baseSecret}//${captchaType}`;
-    pair = keyring.getPair(newSecret);
-    console.log(
-      `[PAIR CHECK] Checking pair for ${captchaType}: ${pair?.address} (expected: ${siteKey})`
-    );
-    logger.info(() => ({
-      msg: "Checking pair",
-      data: {
-        captchaType,
-        siteKeyDerived: pair?.address,
-        siteKey
-      }
-    }));
-    if (pair.address === siteKey) {
-      console.log(`[PAIR CHECK] ✅ Match found for ${captchaType}!`);
-      secret = newSecret;
-      break;
-    }
-  }
-  if (!pair || pair.address !== siteKey) {
-    throw new Error(
-      `Site key does not match the server configuration: Provided ${siteKey} vs Server ${pair?.address}`
-    );
-  }
-  return { pair, secret };
+var NO_IP = "NO_IP";
+/**
+* Derives the correct KeyringPair and secret for a given site key by trying different captcha types.
+* @param baseSecret - The base secret from config
+* @param siteKey - The site key to match against
+* @returns Object containing the matched pair and its corresponding secret
+* @throws Error if no matching pair is found
+*/
+var getPairAndSecretForSiteKey = (baseSecret, siteKey) => {
+	let pair;
+	let secret = baseSecret;
+	pair = (0, _prosopo_keyring.getPair)(secret);
+	if (pair.address === siteKey) {
+		logger.info(() => ({
+			msg: "Site key matches the server configuration without captcha type suffix",
+			data: {
+				siteKeyDerived: pair?.address,
+				siteKey
+			}
+		}));
+		return {
+			pair,
+			secret
+		};
+	}
+	for (const captchaType of [
+		_prosopo_types.CaptchaType.pow,
+		_prosopo_types.CaptchaType.image,
+		_prosopo_types.CaptchaType.frictionless,
+		_prosopo_types.CaptchaType.puzzle
+	]) {
+		const newSecret = `${baseSecret}//${captchaType}`;
+		pair = (0, _prosopo_keyring.getPair)(newSecret);
+		console.log(`[PAIR CHECK] Checking pair for ${captchaType}: ${pair?.address} (expected: ${siteKey})`);
+		logger.info(() => ({
+			msg: "Checking pair",
+			data: {
+				captchaType,
+				siteKeyDerived: pair?.address,
+				siteKey
+			}
+		}));
+		if (pair.address === siteKey) {
+			console.log(`[PAIR CHECK] ✅ Match found for ${captchaType}!`);
+			secret = newSecret;
+			break;
+		}
+	}
+	if (!pair || pair.address !== siteKey) throw new Error(`Site key does not match the server configuration: Provided ${siteKey} vs Server ${pair?.address}`);
+	return {
+		pair,
+		secret
+	};
 };
-const getResponse = async (ip, token, secret, verifyEndpoint, email) => {
-  const body = {
-    [types.ApiParams.token]: token,
-    [types.ApiParams.secret]: secret,
-    ...email ? { [types.ApiParams.email]: email } : {}
-  };
-  if (process.env.NODE_ENV !== "development") {
-    body[types.ApiParams.ip] = ip;
-  }
-  logger.info(() => ({
-    data: {
-      body
-    }
-  }));
-  const response = await fetch(verifyEndpoint, {
-    method: "POST",
-    body: JSON.stringify(body)
-  });
-  return response.json();
+var getResponse = async (ip, token, secret, verifyEndpoint, email) => {
+	const body = {
+		[_prosopo_types.ApiParams.token]: token,
+		[_prosopo_types.ApiParams.secret]: secret,
+		...email ? { [_prosopo_types.ApiParams.email]: email } : {}
+	};
+	if (process.env.NODE_ENV !== "development") body[_prosopo_types.ApiParams.ip] = ip;
+	logger.info(() => ({ data: { body } }));
+	return (await fetch(verifyEndpoint, {
+		method: "POST",
+		body: JSON.stringify(body)
+	})).json();
 };
-const verify = async (prosopoServer, verifyType, verifyEndpoint, token, secret, ip, email) => {
-  if (verifyType === "api") {
-    logger.info(() => ({
-      msg: "Verifying using the API endpoint",
-      data: {
-        verifyEndpoint
-      }
-    }));
-    const response = await getResponse(
-      ip,
-      token,
-      secret,
-      verifyEndpoint,
-      email
-    );
-    logger.info(() => ({
-      data: {
-        response
-      }
-    }));
-    return response.verified;
-  }
-  const verified = await prosopoServer.isVerified(token, ip, email);
-  logger.info(() => ({
-    data: {
-      verified
-    }
-  }));
-  return verified[types.ApiParams.verified];
+var verify = async (prosopoServer, verifyType, verifyEndpoint, token, secret, ip, email) => {
+	if (verifyType === "api") {
+		logger.info(() => ({
+			msg: "Verifying using the API endpoint",
+			data: { verifyEndpoint }
+		}));
+		const response = await getResponse(ip, token, secret, verifyEndpoint, email);
+		logger.info(() => ({ data: { response } }));
+		return response.verified;
+	}
+	const verified = await prosopoServer.isVerified(token, ip, email);
+	logger.info(() => ({ data: { verified } }));
+	return verified[_prosopo_types.ApiParams.verified];
 };
-const signup = async (mongoose, config, verifyEndpoint, verifyType, req, res, next) => {
-  try {
-    if (!config.account.secret) {
-      throw new common.ProsopoEnvError("GENERAL.MNEMONIC_UNDEFINED", {
-        context: { missingParams: ["PROSOPO_SITE_PRIVATE_KEY"] }
-      });
-    }
-    const User = mongoose.model("User");
-    const dbUser = await User.findOne({
-      email: { $eq: req.body.email }
-    });
-    const payload = SubscribeBodySpec.parse(req.body);
-    const token = payload[types.ApiParams.procaptchaResponse];
-    const siteKey = payload[types.ApiParams.siteKey];
-    const { pair, secret } = getPairAndSecretForSiteKey(
-      config.account.secret,
-      siteKey
-    );
-    const prosopoServer = new server.ProsopoServer(config, pair);
-    if (dbUser) {
-      return res.status(409).json({ message: "email already exists" });
-    }
-    const email = req.body.email;
-    const verified = await verify(
-      prosopoServer,
-      verifyType,
-      verifyEndpoint,
-      token,
-      secret,
-      req.headers["x-client-ip"]?.toString() || "127.0.0.1",
-      email
-    );
-    if (verified === true) {
-      const salt = utilCrypto.randomAsHex(32);
-      const passwordHash = hashPassword(`${req.body.password}${salt}`);
-      if (passwordHash) {
-        return User.create({
-          email,
-          name: req.body.name,
-          password: passwordHash,
-          salt
-        }).then(() => {
-          res.status(200).json({ message: "user created" });
-        }).catch((err) => {
-          logger.error(() => ({
-            err,
-            msg: "Error creating user in database"
-          }));
-          res.status(502).json({ message: "error while creating the user" });
-        });
-      }
-    } else {
-      res.status(401).json({ message: "user has not completed a captcha", verified });
-    }
-  } catch (err) {
-    console.error("error", err);
-    res.status(500).json({ message: err.message || "internal server error" });
-  }
+var signup = async (mongoose, config, verifyEndpoint, verifyType, req, res, next) => {
+	try {
+		if (!config.account.secret) throw new _prosopo_common.ProsopoEnvError("GENERAL.MNEMONIC_UNDEFINED", { context: { missingParams: ["PROSOPO_SITE_PRIVATE_KEY"] } });
+		const User = mongoose.model("User");
+		const dbUser = await User.findOne({ email: { $eq: req.body.email } });
+		const payload = SubscribeBodySpec.parse(req.body);
+		const token = payload[_prosopo_types.ApiParams.procaptchaResponse];
+		const siteKey = payload[_prosopo_types.ApiParams.siteKey];
+		const { pair, secret } = getPairAndSecretForSiteKey(config.account.secret, siteKey);
+		const prosopoServer = new _prosopo_server.ProsopoServer(config, pair);
+		if (dbUser) return res.status(409).json({ message: "email already exists" });
+		const email = req.body.email;
+		const verified = await verify(prosopoServer, verifyType, verifyEndpoint, token, secret, req.headers["x-client-ip"]?.toString() || "127.0.0.1", email);
+		if (verified === true) {
+			const salt = (0, _polkadot_util_crypto.randomAsHex)(32);
+			const passwordHash = hashPassword(`${req.body.password}${salt}`);
+			if (passwordHash) return User.create({
+				email,
+				name: req.body.name,
+				password: passwordHash,
+				salt
+			}).then(() => {
+				res.status(200).json({ message: "user created" });
+			}).catch((err) => {
+				logger.error(() => ({
+					err,
+					msg: "Error creating user in database"
+				}));
+				res.status(502).json({ message: "error while creating the user" });
+			});
+		} else res.status(401).json({
+			message: "user has not completed a captcha",
+			verified
+		});
+	} catch (err) {
+		console.error("error", err);
+		res.status(500).json({ message: err.message || "internal server error" });
+	}
 };
-const login = async (mongoose, config, verifyEndpoint, verifyType, req, res) => {
-  const User = mongoose.model("User");
-  await User.findOne({
-    email: { $eq: req.body.email }
-  }).then(async (dbUser) => {
-    if (dbUser) {
-      const payload = SubscribeBodySpec.parse(req.body);
-      const token = payload[types.ApiParams.procaptchaResponse];
-      const siteKey = payload[types.ApiParams.siteKey];
-      if (!config.account.secret) {
-        throw new common.ProsopoEnvError("GENERAL.SECRET_MISSING", {
-          context: { missingParams: ["PROSOPO_SITE_PRIVATE_KEY"] }
-        });
-      }
-      const { pair, secret } = getPairAndSecretForSiteKey(
-        config.account.secret,
-        siteKey
-      );
-      const prosopoServer = new server.ProsopoServer(config, pair);
-      const verified = await verify(
-        prosopoServer,
-        verifyType,
-        verifyEndpoint,
-        token,
-        secret,
-        req.headers["x-client-ip"]?.toString() || NO_IP
-      );
-      logger.info(() => ({
-        data: {
-          verified
-        }
-      }));
-      if (verified) {
-        const passwordHash = hashPassword(
-          `${req.body.password}${dbUser.salt}`
-        );
-        if (passwordHash !== dbUser.password) {
-          return res.status(401).json({ message: "invalid credentials" });
-        }
-        const token2 = jwt.sign({ email: req.body.email }, "secret", {
-          expiresIn: "1h"
-        });
-        return res.status(200).json({ message: "user logged in", token: token2 });
-      }
-      return res.status(401).json({ message: "user has not completed a captcha", verified });
-    }
-    return res.status(404).json({ message: "user not found" });
-  }).catch((err) => {
-    console.error("error", err);
-    res.status(500).json({ message: err.message || "internal server error" });
-  });
+var login = async (mongoose, config, verifyEndpoint, verifyType, req, res) => {
+	await mongoose.model("User").findOne({ email: { $eq: req.body.email } }).then(async (dbUser) => {
+		if (dbUser) {
+			const payload = SubscribeBodySpec.parse(req.body);
+			const token = payload[_prosopo_types.ApiParams.procaptchaResponse];
+			const siteKey = payload[_prosopo_types.ApiParams.siteKey];
+			if (!config.account.secret) throw new _prosopo_common.ProsopoEnvError("GENERAL.SECRET_MISSING", { context: { missingParams: ["PROSOPO_SITE_PRIVATE_KEY"] } });
+			const { pair, secret } = getPairAndSecretForSiteKey(config.account.secret, siteKey);
+			const verified = await verify(new _prosopo_server.ProsopoServer(config, pair), verifyType, verifyEndpoint, token, secret, req.headers["x-client-ip"]?.toString() || NO_IP);
+			logger.info(() => ({ data: { verified } }));
+			if (verified) {
+				if (hashPassword(`${req.body.password}${dbUser.salt}`) !== dbUser.password) return res.status(401).json({ message: "invalid credentials" });
+				const token = jsonwebtoken.default.sign({ email: req.body.email }, "secret", { expiresIn: "1h" });
+				return res.status(200).json({
+					message: "user logged in",
+					token
+				});
+			}
+			return res.status(401).json({
+				message: "user has not completed a captcha",
+				verified
+			});
+		}
+		return res.status(404).json({ message: "user not found" });
+	}).catch((err) => {
+		console.error("error", err);
+		res.status(500).json({ message: err.message || "internal server error" });
+	});
 };
-const isAuth = (req, res) => {
-  const authHeader = req.get("Authorization") || "";
-  if (!authHeader) {
-    res.status(401).json({ message: "not authenticated" });
-  }
-  const token = util$1.at(authHeader.split(" "), 1);
-  let decodedToken = "";
-  try {
-    decodedToken = jwt.verify(token, "secret");
-  } catch (err) {
-    res.status(500).json({
-      message: err.message || "could not decode the token"
-    });
-  }
-  if (!decodedToken) {
-    res.status(401).json({ message: "unauthorized" });
-  } else {
-    res.status(200).json({ message: "here is your resource" });
-  }
+var isAuth = (req, res) => {
+	const authHeader = req.get("Authorization") || "";
+	if (!authHeader) res.status(401).json({ message: "not authenticated" });
+	const token = (0, _prosopo_util.at)(authHeader.split(" "), 1);
+	let decodedToken = "";
+	try {
+		decodedToken = jsonwebtoken.default.verify(token, "secret");
+	} catch (err) {
+		res.status(500).json({ message: err.message || "could not decode the token" });
+	}
+	if (!decodedToken) res.status(401).json({ message: "unauthorized" });
+	else res.status(200).json({ message: "here is your resource" });
 };
+//#endregion
 exports.isAuth = isAuth;
 exports.login = login;
 exports.signup = signup;

package/dist/cjs/models/user.cjs

@@ -1,23 +1,22 @@
-"use strict";
-const mongoose = require("mongoose");
-const UserSchema = new mongoose.Schema({
-  email: {
-    type: mongoose.SchemaTypes.String,
-    required: true
-  },
-  name: {
-    type: mongoose.SchemaTypes.String
-  },
-  password: {
-    type: mongoose.SchemaTypes.String,
-    required: true
-  },
-  id: {
-    type: mongoose.SchemaTypes.Number
-  },
-  salt: {
-    type: mongoose.SchemaTypes.String,
-    required: true
-  }
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+let mongoose = require("mongoose");
+mongoose = require_runtime.__toESM(mongoose, 1);
+//#region src/models/user.ts
+var UserSchema = new mongoose.Schema({
+	email: {
+		type: mongoose.default.SchemaTypes.String,
+		required: true
+	},
+	name: { type: mongoose.default.SchemaTypes.String },
+	password: {
+		type: mongoose.default.SchemaTypes.String,
+		required: true
+	},
+	id: { type: mongoose.default.SchemaTypes.Number },
+	salt: {
+		type: mongoose.default.SchemaTypes.String,
+		required: true
+	}
 });
-module.exports = UserSchema;
+//#endregion
+exports.default = UserSchema;

package/dist/cjs/routes/routes.cjs

@@ -1,26 +1,23 @@
-"use strict";
-const express = require("express");
-const auth = require("../controllers/auth.cjs");
-const router = express.Router();
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_auth = require("../controllers/auth.cjs");
+let express = require("express");
+express = require_runtime.__toESM(express, 1);
+//#region src/routes/routes.ts
+var router = express.default.Router();
 function getRoutes(mongoose, config, verifyEndpoint, verifyType) {
-  router.post(
-    "/login",
-    auth.login.bind(null, mongoose, config, verifyEndpoint, verifyType)
-  );
-  router.post(
-    "/signup",
-    auth.signup.bind(null, mongoose, config, verifyEndpoint, verifyType)
-  );
-  router.get("/private", auth.isAuth);
-  router.get("/public", (req, res) => {
-    res.status(200).json({ message: "here is your public resource" });
-  });
-  router.get("/health", (req, res) => {
-    res.status(200).json({ status: "ok" });
-  });
-  router.use("/", (req, res) => {
-    res.status(404).json({ error: "page not found" });
-  });
-  return router;
+	router.post("/login", require_auth.login.bind(null, mongoose, config, verifyEndpoint, verifyType));
+	router.post("/signup", require_auth.signup.bind(null, mongoose, config, verifyEndpoint, verifyType));
+	router.get("/private", require_auth.isAuth);
+	router.get("/public", (req, res) => {
+		res.status(200).json({ message: "here is your public resource" });
+	});
+	router.get("/health", (req, res) => {
+		res.status(200).json({ status: "ok" });
+	});
+	router.use("/", (req, res) => {
+		res.status(404).json({ error: "page not found" });
+	});
+	return router;
 }
-module.exports = getRoutes;
+//#endregion
+exports.default = getRoutes;

package/dist/cjs/utils/connection.cjs

@@ -1,25 +1,22 @@
-"use strict";
-const node_url = require("node:url");
-const database = require("@prosopo/database");
-const autoIncrement = require("@typegoose/auto-increment");
-const mongoose = require("mongoose");
-const user = require("../models/user.cjs");
-var _documentCurrentScript = typeof document !== "undefined" ? document.currentScript : null;
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_user = require("../models/user.cjs");
+let node_url = require("node:url");
+let _prosopo_database = require("@prosopo/database");
+let _typegoose_auto_increment = require("@typegoose/auto-increment");
+let mongoose = require("mongoose");
+mongoose = require_runtime.__toESM(mongoose, 1);
+//#region src/utils/connection.ts
 function connectionFactory(uri) {
-  const appName = node_url.fileURLToPath(typeof document === "undefined" ? require("url").pathToFileURL(__filename).href : _documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === "SCRIPT" && _documentCurrentScript.src || new URL("utils/connection.cjs", document.baseURI).href);
-  const conn = mongoose.createConnection(
-    uri,
-    database.getMongoConnectionOptions({
-      url: uri,
-      appName
-    })
-  );
-  if (!conn.models.user) {
-    user.plugin(autoIncrement.AutoIncrementID, {
-      field: "id"
-    });
-    conn.model("User", user);
-  }
-  return conn;
+	const appName = (0, node_url.fileURLToPath)(require("url").pathToFileURL(__filename).href);
+	const conn = mongoose.default.createConnection(uri, (0, _prosopo_database.getMongoConnectionOptions)({
+		url: uri,
+		appName
+	}));
+	if (!conn.models.user) {
+		require_user.default.plugin(_typegoose_auto_increment.AutoIncrementID, { field: "id" });
+		conn.model("User", require_user.default);
+	}
+	return conn;
 }
-module.exports = connectionFactory;
+//#endregion
+exports.default = connectionFactory;

package/dist/cjs/utils/database.cjs

@@ -1,32 +1,7 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+//#region src/utils/database.ts
 async function memoryServerSetup() {
-  const MongoMemoryServer = (await import("mongodb-memory-server")).MongoMemoryServer;
-  const mongod = MongoMemoryServer.create();
-  const memoryServer = await mongod;
-  return memoryServer.getUri();
+	return (await (await import("mongodb-memory-server")).MongoMemoryServer.create()).getUri();
 }
+//#endregion
 exports.default = memoryServerSetup;
 exports.memoryServerSetup = memoryServerSetup;