ribaunt 0.1.3 → 0.1.6

package/dist/cjs/index.cjs

@@ -1,200 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createChallenge = createChallenge;
-exports.solveChallenge = solveChallenge;
-exports.verifySolution = verifySolution;
-const crypto_1 = __importDefault(require("crypto"));
-const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
-function generateChallenge(length = 8) {
-    const buffer = crypto_1.default.randomBytes(length);
-    return buffer.toString('base64').slice(0, length);
-}
-function createChallengePayload(difficulty, ttlSeconds) {
-    return {
-        challenge: generateChallenge(),
-        difficulty,
-        expires: Math.floor(Date.now() / 1000) + ttlSeconds,
-    };
-}
-function getSecret() {
-    const secret = process.env.RIBAUNT_SECRET;
-    if (!secret) {
-        throw new Error('RIBAUNT_SECRET environment variable is not set!');
-    }
-    return secret;
-}
-function signChallenge(payload) {
-    return jsonwebtoken_1.default.sign(payload, getSecret());
-}
-function assertValidAmount(amount) {
-    if (!Number.isFinite(amount)) {
-        throw new Error('Challenge amount must be a finite number');
-    }
-    const normalized = Math.floor(amount);
-    if (normalized < 1) {
-        throw new Error('Challenge amount must be at least 1');
-    }
-    return normalized;
-}
-function assertValidDifficulty(difficulty) {
-    if (!Number.isFinite(difficulty)) {
-        throw new Error('Challenge difficulty must be a finite number');
-    }
-    const normalized = Math.floor(difficulty);
-    if (normalized < 1) {
-        throw new Error('Challenge difficulty must be at least 1');
-    }
-    return normalized;
-}
-function assertValidTtl(ttlSeconds) {
-    if (!Number.isFinite(ttlSeconds)) {
-        throw new Error('Challenge TTL must be a finite number');
-    }
-    const normalized = Math.floor(ttlSeconds);
-    if (normalized < 1) {
-        throw new Error('Challenge TTL must be at least 1 second');
-    }
-    return normalized;
-}
-function createSingleChallenge(difficulty, ttlSeconds) {
-    const payload = createChallengePayload(difficulty, ttlSeconds);
-    return signChallenge(payload);
-}
-/**
- * Creates one or more PoW challenges and returns them as signed JWT tokens.
- *
- * @param difficulty - Number of leading zeros required in the hash (default 6)
- * @param amount - Number of challenges to create (default 4)
- * @param ttlSeconds - Time to live for each challenge in seconds (default 30)
- * @returns An array of JWT challenge tokens
- */
-function createChallenge(difficulty = 5, amount = 4, ttlSeconds = 30) {
-    const normalizedDifficulty = assertValidDifficulty(difficulty);
-    const normalizedAmount = assertValidAmount(amount);
-    const normalizedTtl = assertValidTtl(ttlSeconds);
-    const challenges = Array.from({ length: normalizedAmount }, () => createSingleChallenge(normalizedDifficulty, normalizedTtl));
-    return challenges;
-}
-function solveSingleChallenge(token) {
-    try {
-        const payload = jsonwebtoken_1.default.decode(token);
-        if (!payload)
-            return undefined;
-        const { challenge, difficulty } = payload;
-        const prefix = '0'.repeat(difficulty);
-        let nonce = 0;
-        while (true) {
-            const hash = crypto_1.default
-                .createHash('sha256')
-                .update(`${challenge}${nonce}`)
-                .digest('hex');
-            if (hash.startsWith(prefix)) {
-                return { nonce: String(nonce), hash };
-            }
-            nonce++;
-        }
-    }
-    catch (err) {
-        return undefined;
-    }
-}
-function verifySingleSolution(token, nonce) {
-    if (nonce === undefined || nonce === null) {
-        return false;
-    }
-    try {
-        const payload = jsonwebtoken_1.default.verify(token, getSecret());
-        const now = Math.floor(Date.now() / 1000);
-        if (payload.expires < now)
-            return false;
-        const nonceValue = typeof nonce === 'number' ? String(nonce) : nonce;
-        const hash = crypto_1.default
-            .createHash('sha256')
-            .update(`${payload.challenge}${nonceValue}`)
-            .digest('hex');
-        const prefix = '0'.repeat(payload.difficulty);
-        return hash.startsWith(prefix);
-    }
-    catch (err) {
-        return false;
-    }
-}
-function solveChallenge(token) {
-    if (Array.isArray(token)) {
-        const solutions = [];
-        for (const singleToken of token) {
-            const solution = solveSingleChallenge(singleToken);
-            if (!solution) {
-                return undefined;
-            }
-            solutions.push(solution);
-        }
-        return solutions;
-    }
-    const solution = solveSingleChallenge(token);
-    return solution;
-}
-/**
- * Verifies a PoW solution returned by the client.
- *
- * @param token - The original JWT issued as the challenge (single token or array of tokens)
- * @param nonce - The nonce/answer submitted by the client (single nonce, array of nonces, or array of solution objects)
- * @returns true only if every provided solution is valid; otherwise false
- */
-function verifySolution(token, nonce) {
-    if (Array.isArray(token)) {
-        let nonces;
-        if (Array.isArray(nonce)) {
-            if (nonce.length !== token.length) {
-                return false;
-            }
-            if (nonce.length > 0 && typeof nonce[0] === 'object' && 'nonce' in nonce[0]) {
-                nonces = nonce.map(s => s.nonce);
-            }
-            else {
-                nonces = nonce;
-            }
-        }
-        else {
-            return false;
-        }
-        for (let index = 0; index < token.length; index++) {
-            const challengeToken = token[index];
-            const nonceEntry = nonces[index];
-            if (challengeToken === undefined || nonceEntry === undefined) {
-                return false;
-            }
-            if (!verifySingleSolution(challengeToken, nonceEntry)) {
-                return false;
-            }
-        }
-        return true;
-    }
-    let effectiveNonce;
-    if (Array.isArray(nonce)) {
-        if (nonce.length === 0) {
-            return false;
-        }
-        if (typeof nonce[0] === 'object' && 'nonce' in nonce[0]) {
-            effectiveNonce = nonce[0].nonce;
-        }
-        else {
-            effectiveNonce = nonce[0];
-        }
-    }
-    else if (typeof nonce === 'object' && 'nonce' in nonce) {
-        effectiveNonce = nonce.nonce;
-    }
-    else {
-        effectiveNonce = nonce;
-    }
-    if (effectiveNonce === undefined) {
-        return false;
-    }
-    const result = verifySingleSolution(token, effectiveNonce);
-    return result;
-}
-//# sourceMappingURL=index.js.map

package/dist/cjs/index.d.cts

@@ -1,31 +0,0 @@
-export type ChallengeToken = string;
-export interface ChallengeSolution {
-    nonce: string;
-    hash: string;
-}
-/**
- * Creates one or more PoW challenges and returns them as signed JWT tokens.
- *
- * @param difficulty - Number of leading zeros required in the hash (default 6)
- * @param amount - Number of challenges to create (default 4)
- * @param ttlSeconds - Time to live for each challenge in seconds (default 30)
- * @returns An array of JWT challenge tokens
- */
-export declare function createChallenge(difficulty?: number, amount?: number, ttlSeconds?: number): ChallengeToken[];
-/**
- * Solves one or more PoW challenges encoded in JWT tokens.
- *
- * @param token - The JWT challenge token or an array of tokens
- * @returns The nonce/hash pair for single input or an array of them for multiple tokens
- */
-export declare function solveChallenge(token: ChallengeToken): ChallengeSolution | undefined;
-export declare function solveChallenge(token: ChallengeToken[]): ChallengeSolution[] | undefined;
-/**
- * Verifies a PoW solution returned by the client.
- *
- * @param token - The original JWT issued as the challenge (single token or array of tokens)
- * @param nonce - The nonce/answer submitted by the client (single nonce, array of nonces, or array of solution objects)
- * @returns true only if every provided solution is valid; otherwise false
- */
-export declare function verifySolution(token: ChallengeToken | ChallengeToken[], nonce: number | string | Array<number | string> | ChallengeSolution | ChallengeSolution[]): boolean;
-//# sourceMappingURL=index.d.ts.map

package/scripts/prepare-cjs.mjs

@@ -1,11 +0,0 @@
-import { mkdir, writeFile } from 'node:fs/promises';
-import { resolve } from 'node:path';
-
-const cjsDir = resolve(process.cwd(), 'dist/cjs');
-
-await mkdir(cjsDir, { recursive: true });
-await writeFile(
-  resolve(cjsDir, 'package.json'),
-  `${JSON.stringify({ type: 'commonjs' }, null, 2)}\n`,
-  'utf8'
-);