altcha-lib 1.4.1 → 2.0.0-beta.2

package/LICENSE.txt

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2023 Daniel Regeci
+Copyright (c) 2023-2026 Daniel Regeci
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -1,179 +1,75 @@
 # ALTCHA JS Library
 
-ALTCHA JS Library is a lightweight, zero-dependency library designed for creating and verifying [ALTCHA](https://altcha.org) challenges.
+ALTCHA TS/JS Library is a lightweight library for creating and verifying [ALTCHA](https://altcha.org) challenges on the server.
 
-## Compatibility
+## Get Started
 
-This library utilizes [Web Crypto](https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto).
+The library includes plugins for several popular frameworks to simplify integration.
 
-- Node.js 16+
-- Bun 1+
-- Deno 1+
-- WinterCG-compatible runtimes
-- All modern browsers
+- **Express:** [`/docs/express.md`](/docs/express.md)
+- **Fastify:** [`/docs/fastify.md`](/docs/fastify.md)
+- **Hono:** [`/docs/hono.md`](/docs/hono.md)
+- **NestJS:** [`/docs/nestjs.md`](/docs/nestjs.md)
+- **Next.js:** [`/docs/nextjs.md`](/docs/nextjs.md)
+- **Nuxt:** [`/docs/nuxt.md`](/docs/nuxt.md)
+- **SvelteKit:** [`/docs/sveltekit.md`](/docs/sveltekit.md)
 
-## Usage
+If your framework is not listed, see the [Advanced Usage](/docs/advanced-usage.md) guide for custom integrations.
 
-```ts
-import { createChallenge, verifySolution } from 'altcha-lib';
+## Documentation
 
-const hmacKey = 'secret hmac key';
+- Advanced Usage: [`/docs/advanced-usage.md`](/docs/advanced-usage.md)
+- Algorithms: [`/docs/algorithms.md`](/docs/algorithms.md)
+- Configuration Options: [`/docs/configuration-options.md`](/docs/configuration-options.md)
+- Obfuscation: [`/docs/obfuscation.md`](/docs/obfuscation.md)
+- Store: [`/docs/store.md`](/docs/store.md)
+- Usage with ALTCHA Sentinel: [`/docs/server-signatures.md`](/docs/server-signatures.md)
+- Using the `/verify` Route: [`/docs/verify-route.md`](/docs/verify-route.md)
+- Workers: [`/docs/workers.md`](/docs/workers.md)
 
-// Create a new challenge and send it to the client:
-const challenge = await createChallenge({
-  hmacKey,
-  maxNumber: 100000, // the maximum random number
-});
+## Compatibility
 
-// When submitted, verify the payload:
-const ok = await verifySolution(payload, hmacKey);
-```
+| Runtime           | Version | Notes                                           |
+| ----------------- | ------: | ----------------------------------------------- |
+| Node.js           |     20+ | Argon2 available natively in 24.7+              |
+| Bun               |      1+ | Argon2 not available natively                   |
+| Deno              |      2+ | Argon2 not available natively                   |
+| WinterCG runtimes |       — | Use WebCrypto [algorithms](/docs/algorithms.md) |
 
-### Usage with Node.js 16
+### Run examples
 
-In Node.js version 16, there is no global reference to crypto by default. To use this library, you need to add the following code to your codebase:
+**Express example (Node.js with `tsx`):**
 
-```ts
-globalThis.crypto = require('node:crypto').webcrypto;
+```sh
+npx tsx examples/express-example.ts
 ```
 
-Or with `import` syntax:
+**Hono example (Bun):**
 
-```ts
-import { webcrypto } from 'node:crypto';
-
-globalThis.crypto = webcrypto;
+```sh
+bun run --port 3000 examples/hono-example.ts
 ```
 
-## API
-
-### `createChallenge(options)`
-
-Creates a new challenge for ALTCHA.
-
-Parameters:
-
-- `options: ChallengeOptions`:
-  - `algorithm?: string`: Algorithm to use (`SHA-1`, `SHA-256`, `SHA-512`, default: `SHA-256`).
-  - `expires?: Date`: Optional `expires` time (as `Date` set into the future date).
-  - `hmacKey: string` (required): Signature HMAC key.
-  - `maxnumber?: number`: Optional maximum number for the random number generator (defaults to 1,000,000).
-  - `number?: number`: Optional number to use. If not provided, a random number will be generated.
-  - `params?: Record<string, string>`: Optional parameters to be added to the salt as URL-encoded query string. Use `extractParams()` to read them.
-  - `salt?: string`: Optional salt string. If not provided, a random salt will be generated.
-  - `saltLength?: number`: Optional maximum lenght of the random salt (in bytes, defaults to 12).
-
-Returns: `Promise<Challenge>`
-
-### `extractParams(payload)`
-
-Extracts optional parameters from the challenge or payload.
-
-Parameters:
-
-- `payload: string | Payload | Challenge`
-
-Returns: `Record<string, string>`
-
-### `verifySolution(payload, hmacKey, checkExpires = true)`
-
-Verifies an ALTCHA solution. The payload can be a Base64-encoded JSON payload (as submitted by the widget) or an object.
-
-Parameters:
-
-- `payload: string | Payload`
-- `hmacKey: string`
-- `checkExpires: boolean = true`: Whether to perform a check on the optional `expires` parameter. Will return `false` if challenge expired.
-
-Returns: `Promise<boolean>`
+**Hono example (Deno):**
 
-### `verifyServerSignature(payload, hmacKey)`
-
-Verifies the server signature returned by the API. The payload can be a Base64-encoded JSON payload or an object.
-
-Parameters:
-
-- `payload: string | ServerSignaturePayload`
-- `hmacKey: string`
-
-Returns: `Promise<{ verificationData: ServerSignatureVerificationData | null, verified: boolean }>`
-
-### `verifyFieldsHash(formData, fields, fieldsHash, algorithm?)`
-
-Verifies the hash of form fields returned by the Spam Filter.
-
-Parameters:
-
-- `formData: FormData | Record<string, unknown>`
-- `fields: string[]`
-- `fieldsHash: string`
-- `algorithm: Algorithm = 'SHA-256'`
-
-Returns: `Promise<boolean>`
-
-### `solveChallenge(challenge, salt, algorithm?, max?, start?)`
-
-Finds a solution to the given challenge. 
-
-Parameters:
-
-- `challenge: string` (required): The challenge hash.
-- `salt: string` (required): The challenge salt.
-- `algorithm?: string`: Optional algorithm (default: `SHA-256`).
-- `maxnumber?: string`: Optional `maxnumber` to iterate to (default: 1e6).
-- `start?: string`: Optional starting number (default: 0).
-
-Returns: `{ controller: AbortController, promise: Promise<Solution | null> }`
-
-### `solveChallengeWorkers(workerScript, concurrency, challenge, salt, algorithm?, max?, start?)`
+```sh
+deno serve --allow-net --sloppy-imports --port 3000 examples/hono-example.ts
+```
 
-Finds a solution to the given challenge with [Web Workers](https://developer.mozilla.org/en-US/docs/Web/API/Worker/Worker) running concurrently. 
+## Breaking Changes (v2)
 
-Parameters:
+Version 2 introduces a new proof-of-work mechanism and challenge format. See the [PoW documentation](https://playground.altcha.org/#/about) for details.
 
-- `workerScript: string` (required): The path or URL of the worker script.
-- `concurrency: number` (required): The concurrency (number of workers).
-- `challenge: string` (required): The challenge hash.
-- `salt: string` (required): The challenge salt.
-- `algorithm?: string`: Optional algorithm (default: `SHA-256`).
-- `maxnumber?: string`: Optional `maxnumber` to iterate to (default: 1e6).
-- `start?: string`: Optional starting number (default: 0).
+While the overall usage remains similar, the library has been refactored and several function signatures have changed. Using the provided framework plugins is recommended. For unsupported frameworks or custom setups, refer to the [Advanced Usage](/docs/advanced-usage.md) guide.
 
-Returns: `Promise<Solution | null>`
+### Compatibility with v1
 
-Usage with `altcha-lib/worker`:
+The API for the previous PoW version (v1) remains available under the `altcha-lib/v1` path:
 
 ```ts
-import { solveChallengeWorkers } from 'altcha-lib';
-
-const solution = await solveChallengeWorkers(
-  'altcha-lib/worker', // Worker script URL or path
-  8, // Spawn 8 workers
-  challenge,
-  salt,
-);
+import { createChallenge } from 'altcha-lib/v1';
 ```
 
-## Benchmarks
-
-```
-> solveChallenge()
-- n = 1,000...............................        312 ops/s ±2.90%
-- n = 10,000..............................         31 ops/s ±1.50%
-- n = 50,000..............................          6 ops/s ±0.82%
-- n = 100,000.............................          3 ops/s ±0.37%
-- n = 500,000.............................          0 ops/s ±0.31%
-
-> solveChallengeWorkers() (8 workers)
-- n = 1,000...............................         62 ops/s ±3.99%
-- n = 10,000..............................         31 ops/s ±6.83%
-- n = 50,000..............................         11 ops/s ±4.00%
-- n = 100,000.............................          7 ops/s ±2.32%
-- n = 500,000.............................          1 ops/s ±1.89%
-```
-
-Run with Bun on MacBook Pro M3-Pro. See [/benchmark](/benchmark/) folder for more details.
-
 ## License
 
-MIT
+MIT

package/bin/cli.mjs

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+
+import { obfuscate, deobfuscate } from 'altcha-lib/obfuscation';
+
+const [command, ...rest] = process.argv.slice(2);
+
+if (!command || !['obfuscate', 'deobfuscate'].includes(command)) {
+  console.error('Usage: altcha-lib <obfuscate|deobfuscate> [data]');
+  process.exit(1);
+}
+
+function readStdin() {
+  return new Promise((resolve, reject) => {
+    let buf = '';
+    process.stdin.setEncoding('utf-8');
+    process.stdin.on('data', (chunk) => buf += chunk);
+    process.stdin.on('end', () => resolve(buf.trim()));
+    process.stdin.on('error', reject);
+  });
+}
+
+try {
+  const data = rest.length ? rest.join(' ') : await readStdin();
+
+  if (!data) {
+    console.error(`Error: No data provided for ${command}`);
+    process.exit(1);
+  }
+
+  const result = command === 'obfuscate' ? await obfuscate(data) : await deobfuscate(data);
+  console.log(result);
+} catch (err) {
+  console.error(`Error during ${command}: ${err.message}`);
+  process.exit(1);
+}

package/dist/cjs/tsconfig.cjs.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../../src/v1/helpers.ts","../../src/v1/index.ts","../../src/v1/types.ts","../../src/v1/worker.ts","../../src/v2/capped-map.ts","../../src/v2/helpers.ts","../../src/v2/index.ts","../../src/v2/obfuscation.ts","../../src/v2/pow.ts","../../src/v2/server-signature.ts","../../src/v2/types.ts","../../src/v2/algorithms/argon2id.ts","../../src/v2/algorithms/pbkdf2.ts","../../src/v2/algorithms/scrypt.ts","../../src/v2/algorithms/sha.ts","../../src/v2/algorithms/web/pbkdf2.ts","../../src/v2/algorithms/web/sha.ts","../../src/v2/frameworks/express.ts","../../src/v2/frameworks/fastify.ts","../../src/v2/frameworks/h3.ts","../../src/v2/frameworks/hono.ts","../../src/v2/frameworks/nestjs.ts","../../src/v2/frameworks/nextjs.ts","../../src/v2/frameworks/shared.ts","../../src/v2/frameworks/sveltekit.ts","../../src/v2/frameworks/types.ts","../../src/v2/workers/argon2id.ts","../../src/v2/workers/pbkdf2.ts","../../src/v2/workers/scrypt.ts","../../src/v2/workers/sha.ts","../../src/v2/workers/shared.ts"],"version":"5.9.3"}

package/dist/cjs/v2/algorithms/argon2id.d.ts

@@ -0,0 +1,2 @@
+import type { ChallengeParameters, DeriveKeyFunctionResult } from '../types.js';
+export declare function deriveKey(parameters: ChallengeParameters, salt: Uint8Array, password: Uint8Array): Promise<DeriveKeyFunctionResult>;

package/dist/cjs/v2/algorithms/argon2id.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveKey = deriveKey;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const node_util_1 = require("node:util");
+const argon2Async = 'argon2' in node_crypto_1.default
+    ? (0, node_util_1.promisify)(node_crypto_1.default.argon2)
+    : async () => {
+        throw new Error('Argon2 not supported in node:crypto.');
+    };
+async function deriveKey(parameters, salt, password) {
+    return {
+        parameters: {},
+        derivedKey: await argon2Async('argon2id', {
+            memory: parameters.memoryCost,
+            parallelism: parameters.parallelism || 1,
+            nonce: salt,
+            message: password,
+            passes: parameters.cost,
+            tagLength: parameters.keyLength,
+        }),
+    };
+}

package/dist/cjs/v2/algorithms/pbkdf2.d.ts

@@ -0,0 +1,2 @@
+import type { ChallengeParameters, DeriveKeyFunctionResult } from '../types.js';
+export declare function deriveKey(parameters: ChallengeParameters, salt: Uint8Array, password: Uint8Array): Promise<DeriveKeyFunctionResult>;

package/dist/cjs/v2/algorithms/pbkdf2.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveKey = deriveKey;
+const node_crypto_1 = require("node:crypto");
+const node_util_1 = require("node:util");
+const pbkdf2Async = (0, node_util_1.promisify)(node_crypto_1.pbkdf2);
+function getDigest(algorithm) {
+    switch (algorithm) {
+        case 'PBKDF2/SHA-512':
+            return 'sha512';
+        case 'PBKDF2/SHA-384':
+            return 'sha384';
+        case 'PBKDF2/SHA-256':
+        default:
+            return 'sha256';
+    }
+}
+async function deriveKey(parameters, salt, password) {
+    return {
+        parameters: {},
+        derivedKey: await pbkdf2Async(password, salt, parameters.cost, parameters.keyLength, getDigest(parameters.algorithm)),
+    };
+}

package/dist/cjs/v2/algorithms/scrypt.d.ts

@@ -0,0 +1,2 @@
+import type { ChallengeParameters, DeriveKeyFunctionResult } from '../types.js';
+export declare function deriveKey(parameters: ChallengeParameters, salt: Uint8Array, password: Uint8Array): Promise<DeriveKeyFunctionResult>;

package/dist/cjs/v2/algorithms/scrypt.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveKey = deriveKey;
+const node_crypto_1 = require("node:crypto");
+const node_util_1 = require("node:util");
+const scryptAsync = (0, node_util_1.promisify)(node_crypto_1.scrypt);
+async function deriveKey(parameters, salt, password) {
+    return {
+        parameters: {},
+        derivedKey: await scryptAsync(password, salt, parameters.keyLength, {
+            blockSize: parameters.memoryCost,
+            cost: parameters.cost,
+            maxmem: 2 * 128 * parameters.cost * parameters.memoryCost,
+            parallelization: parameters.parallelism || 1,
+        }),
+    };
+}

package/dist/cjs/v2/algorithms/sha.d.ts

@@ -0,0 +1,2 @@
+import type { ChallengeParameters, DeriveKeyFunctionResult } from '../types.js';
+export declare function deriveKey(parameters: ChallengeParameters, salt: Uint8Array, password: Uint8Array): Promise<DeriveKeyFunctionResult>;

package/dist/cjs/v2/algorithms/sha.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveKey = deriveKey;
+const node_crypto_1 = require("node:crypto");
+const helpers_js_1 = require("../helpers.js");
+function getDigest(algorithm) {
+    switch (algorithm) {
+        case 'SHA-512':
+            return 'sha512';
+        case 'SHA-384':
+            return 'sha384';
+        case 'SHA-256':
+        default:
+            return 'sha256';
+    }
+}
+async function deriveKey(parameters, salt, password) {
+    const { algorithm, keyLength = 32 } = parameters;
+    const iterations = Math.max(1, parameters.cost);
+    let data = undefined;
+    let derivedKey = undefined;
+    for (let i = 0; i < iterations; i++) {
+        if (i === 0) {
+            data = (0, helpers_js_1.concatBuffers)(salt, password);
+        }
+        else {
+            data = derivedKey;
+        }
+        derivedKey = (0, node_crypto_1.createHash)(getDigest(algorithm)).update(data).digest();
+    }
+    return {
+        parameters: {},
+        derivedKey: derivedKey.subarray(0, keyLength),
+    };
+}

package/dist/cjs/v2/algorithms/web/pbkdf2.d.ts

@@ -0,0 +1,2 @@
+import type { ChallengeParameters, DeriveKeyFunctionResult } from '../../types.js';
+export declare function deriveKey(parameters: ChallengeParameters, salt: Uint8Array, password: Uint8Array): Promise<DeriveKeyFunctionResult>;

package/dist/cjs/v2/algorithms/web/pbkdf2.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveKey = deriveKey;
+async function deriveKey(parameters, salt, password) {
+    const { cost, keyLength = 32 } = parameters;
+    const hash = parameters.algorithm.startsWith('PBKDF2/')
+        ? parameters.algorithm.slice(7)
+        : 'SHA-256';
+    const passwordKey = await crypto.subtle.importKey('raw', password, { name: 'PBKDF2' }, false, ['deriveKey']);
+    const derivedKey = await crypto.subtle.deriveKey({
+        name: 'PBKDF2',
+        salt: salt,
+        iterations: cost,
+        hash,
+    }, passwordKey, { name: 'AES-GCM', length: keyLength * 8 }, true, ['encrypt']);
+    return {
+        derivedKey: new Uint8Array(await crypto.subtle.exportKey('raw', derivedKey)),
+    };
+}

package/dist/cjs/v2/algorithms/web/sha.d.ts

@@ -0,0 +1,2 @@
+import type { ChallengeParameters, DeriveKeyFunctionResult } from '../../types.js';
+export declare function deriveKey(parameters: ChallengeParameters, salt: Uint8Array, password: Uint8Array): Promise<DeriveKeyFunctionResult>;

package/dist/cjs/v2/algorithms/web/sha.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveKey = deriveKey;
+const helpers_js_1 = require("../../helpers.js");
+async function deriveKey(parameters, salt, password) {
+    const { algorithm, keyLength = 32 } = parameters;
+    const iterations = Math.max(1, parameters.cost);
+    let data = undefined;
+    let derivedKey = undefined;
+    for (let i = 0; i < iterations; i++) {
+        if (i === 0) {
+            data = (0, helpers_js_1.concatBuffers)(salt, password);
+        }
+        else {
+            data = derivedKey;
+        }
+        derivedKey = new Uint8Array((await crypto.subtle.digest(algorithm, data)).slice(0, keyLength));
+    }
+    return {
+        parameters: {},
+        derivedKey: derivedKey,
+    };
+}

package/dist/cjs/v2/capped-map.d.ts

@@ -0,0 +1,7 @@
+export declare class CappedMap<K = unknown, V = unknown> extends Map {
+    readonly maxSize: number;
+    constructor(options: {
+        maxSize: number;
+    });
+    set(key: K, value: V): this;
+}

package/dist/cjs/v2/capped-map.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CappedMap = void 0;
+class CappedMap extends Map {
+    constructor(options) {
+        super();
+        const { maxSize } = options;
+        this.maxSize = maxSize;
+    }
+    set(key, value) {
+        if (this.size >= this.maxSize && !this.has(key)) {
+            this.delete(this.keys().next().value);
+        }
+        super.set(key, value);
+        return this;
+    }
+}
+exports.CappedMap = CappedMap;

package/dist/cjs/v2/frameworks/express.d.ts

@@ -0,0 +1,21 @@
+import { Request, Response, NextFunction } from 'express';
+import { randomInt } from '../helpers.js';
+import { deriveHmacKeySecret, verify } from './shared.js';
+import { CappedMap } from '../capped-map.js';
+import type { AltchaMiddlewareOptions, AltchaOptions, AltchaResult } from './types.js';
+export { CappedMap, deriveHmacKeySecret, randomInt };
+export type { AltchaOptions, AltchaResult };
+export declare function create(options: AltchaOptions): {
+    challengeHandler: (req: Request, res: Response, next: NextFunction) => void;
+    verifyHandler: (req: Request, res: Response, next: NextFunction) => void;
+    getPayloadFromRequest: (req: Request, cookieName?: string) => Promise<string | undefined>;
+    middleware: (options?: AltchaMiddlewareOptions) => (req: Request, res: Response, next: NextFunction) => void;
+    verify: typeof verify;
+};
+declare const _default: {
+    CappedMap: typeof CappedMap;
+    create: typeof create;
+    deriveHmacKeySecret: typeof deriveHmacKeySecret;
+    randomInt: typeof randomInt;
+};
+export default _default;

package/dist/cjs/v2/frameworks/express.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.randomInt = exports.deriveHmacKeySecret = exports.CappedMap = void 0;
+exports.create = create;
+const pow_js_1 = require("../pow.js");
+const helpers_js_1 = require("../helpers.js");
+Object.defineProperty(exports, "randomInt", { enumerable: true, get: function () { return helpers_js_1.randomInt; } });
+const shared_js_1 = require("./shared.js");
+Object.defineProperty(exports, "deriveHmacKeySecret", { enumerable: true, get: function () { return shared_js_1.deriveHmacKeySecret; } });
+const capped_map_js_1 = require("../capped-map.js");
+Object.defineProperty(exports, "CappedMap", { enumerable: true, get: function () { return capped_map_js_1.CappedMap; } });
+const asyncHandler = (fn) => (req, res, next) => {
+    fn(req, res, next).catch(next);
+};
+function create(options) {
+    const { createChallengeParameters, deriveKey, fieldName = 'altcha', hmacSignatureSecret, hmacKeySignatureSecret, setCookie, store, } = options;
+    const challengeHandler = asyncHandler(async (req, res) => {
+        const challenge = await (0, pow_js_1.createChallenge)({
+            deriveKey,
+            hmacSignatureSecret,
+            hmacKeySignatureSecret,
+            ...createChallengeParameters(),
+        });
+        res.json({
+            configuration: setCookie
+                ? {
+                    setCookie,
+                }
+                : undefined,
+            ...challenge,
+        });
+    });
+    const verifyHandler = asyncHandler(async (req, res) => {
+        const payload = await getPayloadFromRequest(req);
+        const result = await (0, shared_js_1.verify)(payload, deriveKey, hmacSignatureSecret, hmacKeySignatureSecret, store);
+        res.json(result);
+    });
+    const getPayloadFromRequest = async (req, cookieName) => {
+        if (cookieName) {
+            return req.cookies?.[cookieName];
+        }
+        return req.body?.[fieldName];
+    };
+    const middleware = (options = {}) => {
+        const { throwOnFailure = true } = options;
+        return asyncHandler(async (req, res, next) => {
+            const payload = await getPayloadFromRequest(req, setCookie?.name);
+            const { error, payload: resultPayload, verification, } = await (0, shared_js_1.verify)(payload, deriveKey, hmacSignatureSecret, hmacKeySignatureSecret, store);
+            res.locals.altcha = {
+                error,
+                payload: resultPayload,
+                verification,
+            };
+            if (setCookie) {
+                res.clearCookie(setCookie.name);
+            }
+            if (error && throwOnFailure) {
+                res.status(403).json({ error });
+                return;
+            }
+            next();
+        });
+    };
+    return {
+        challengeHandler,
+        verifyHandler,
+        getPayloadFromRequest,
+        middleware,
+        verify: shared_js_1.verify,
+    };
+}
+exports.default = {
+    CappedMap: capped_map_js_1.CappedMap,
+    create,
+    deriveHmacKeySecret: shared_js_1.deriveHmacKeySecret,
+    randomInt: helpers_js_1.randomInt,
+};

package/dist/cjs/v2/frameworks/fastify.d.ts

@@ -0,0 +1,26 @@
+import { randomInt } from '../helpers.js';
+import { deriveHmacKeySecret, verify } from './shared.js';
+import { CappedMap } from '../capped-map.js';
+import type { AltchaMiddlewareOptions, AltchaOptions, AltchaResult } from './types.js';
+import type { FastifyRequest, FastifyReply } from 'fastify';
+export { CappedMap, deriveHmacKeySecret, randomInt };
+export type { AltchaOptions, AltchaResult };
+declare module 'fastify' {
+    interface FastifyRequest {
+        altcha?: AltchaResult;
+    }
+}
+export declare function create(options: AltchaOptions): {
+    challengeHandler: (request: FastifyRequest, reply: FastifyReply) => Promise<never>;
+    verifyHandler: (request: FastifyRequest, reply: FastifyReply) => Promise<never>;
+    getPayloadFromRequest: (request: FastifyRequest, cookieName?: string) => Promise<string | undefined>;
+    middleware: (options?: AltchaMiddlewareOptions) => (request: FastifyRequest, reply: FastifyReply) => Promise<undefined>;
+    verify: typeof verify;
+};
+declare const _default: {
+    CappedMap: typeof CappedMap;
+    create: typeof create;
+    deriveHmacKeySecret: typeof deriveHmacKeySecret;
+    randomInt: typeof randomInt;
+};
+export default _default;