@noble/curves 2.0.0 → 2.2.0

package/abstract/oprf.d.ts

@@ -34,10 +34,12 @@ OPRF allows to interactively create an `Output = PRF(Input, serverSecretKey)`:
 ## Modes
 
 - OPRF: simple mode, client doesn't need to know server public key
-- VOPRF: verifable mode, allows client to verify that server used secret key corresponding to known public key
+- VOPRF: verifiable mode. It lets the client verify that the server used the
+  secret key corresponding to a known public key
 - POPRF: partially oblivious mode, VOPRF + domain separation
 
-There is also non-interactive mode (Evaluate) that supports creating Output in non-interactive mode with knowledge of secret key.
+There is also non-interactive mode (Evaluate), which creates Output
+non-interactively with knowledge of the secret key.
 
 Flow:
 - (once) Server generates secret and public keys, distributes public keys to clients
@@ -49,42 +51,92 @@ Flow:
  * @module
  */
 /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-import { randomBytes } from '../utils.ts';
+import { randomBytes, type TArg, type TRet } from '../utils.ts';
 import { type CurvePoint, type CurvePointCons } from './curve.ts';
 import { type H2CDSTOpts } from './hash-to-curve.ts';
+/** Serialized group element passed between OPRF participants. */
 export type PointBytes = Uint8Array;
+/** Serialized scalar used for blinds and server secret keys. */
 export type ScalarBytes = Uint8Array;
+/** Arbitrary byte input or output used by the OPRF protocol. */
 export type Bytes = Uint8Array;
+/** Cryptographically secure byte generator used for blinds and proofs. */
 export type RNG = typeof randomBytes;
+/** Curve and hash hooks required to instantiate one OPRF ciphersuite. */
 export type OPRFOpts<P extends CurvePoint<any, P>> = {
+    /** Human-readable suite identifier used for domain separation. */
     name: string;
+    /**
+     * Prime-order group used by the OPRF construction.
+     * Kept generic because the suite returns serialized points.
+     */
     Point: CurvePointCons<P>;
-    hash(msg: Bytes): Bytes;
-    hashToScalar(msg: Uint8Array, options: H2CDSTOpts): bigint;
-    hashToGroup(msg: Uint8Array, options: H2CDSTOpts): P;
+    /**
+     * Hash function used for transcripts, proofs, and outputs.
+     * @param msg - Message bytes to hash.
+     * @returns Digest bytes.
+     */
+    hash(msg: TArg<Bytes>): TRet<Bytes>;
+    /**
+     * Hash arbitrary bytes into one scalar in the suite order.
+     * @param msg - Message bytes to map.
+     * @param options - Hash-to-field domain-separation options. See {@link H2CDSTOpts}.
+     * Implementations MUST treat `msg` and `options` as read-only.
+     * @returns Scalar in the suite order.
+     */
+    hashToScalar(msg: TArg<Uint8Array>, options: TArg<H2CDSTOpts>): bigint;
+    /**
+     * Hash arbitrary bytes directly onto one curve point.
+     * @param msg - Message bytes to map.
+     * @param options - Hash-to-curve domain-separation options. See {@link H2CDSTOpts}.
+     * Implementations MUST treat `msg` and `options` as read-only.
+     * @returns Point on the suite curve.
+     */
+    hashToGroup(msg: TArg<Uint8Array>, options: TArg<H2CDSTOpts>): P;
 };
+/** Server keypair for one OPRF suite. */
 export type OPRFKeys = {
-    secretKey: ScalarBytes;
-    publicKey: PointBytes;
+    /** Secret scalar kept by the server. */
+    secretKey: TRet<ScalarBytes>;
+    /** Public point distributed to clients in verifiable modes. */
+    publicKey: TRet<PointBytes>;
 };
+/** Result of the client-side blind step. */
 export type OPRFBlind = {
-    blind: Uint8Array;
-    blinded: Uint8Array;
+    /** Secret blind scalar that the client keeps locally. */
+    blind: TRet<ScalarBytes>;
+    /** Blinded group element sent to the server. */
+    blinded: TRet<PointBytes>;
 };
+/** Server response for one verifiable OPRF evaluation. */
 export type OPRFBlindEval = {
-    evaluated: PointBytes;
-    proof: Bytes;
+    /** Evaluated group element returned by the server. */
+    evaluated: TRet<PointBytes>;
+    /** DLEQ proof binding the evaluation to the server public key. */
+    proof: TRet<Bytes>;
 };
+/** Server response for a batch of verifiable OPRF evaluations. */
 export type OPRFBlindEvalBatch = {
-    evaluated: PointBytes[];
-    proof: Bytes;
+    /** Evaluated group elements returned for each blinded input. */
+    evaluated: TRet<PointBytes[]>;
+    /** Batch proof covering all evaluated elements. */
+    proof: TRet<Bytes>;
 };
+/** One finalized transcript item used by batch verification helpers. */
 export type OPRFFinalizeItem = {
+    /** Original client input. */
     input: Bytes;
+    /** Secret blind scalar used for the input. */
     blind: ScalarBytes;
+    /** Evaluated point returned by the server. */
     evaluated: PointBytes;
+    /** Blinded point originally sent to the server. */
     blinded: PointBytes;
 };
+/** Result of the POPRF client-side blind step with the tweaked server public key. */
+export type OPRFBlindTweaked = OPRFBlind & {
+    tweakedKey: TRet<PointBytes>;
+};
 /**
  * Represents a full OPRF ciphersuite implementation according to RFC 9497.
  * This object bundles the three protocol variants (OPRF, VOPRF, POPRF) for a specific
@@ -112,39 +164,39 @@ export type OPRF = {
          * (Server-side) Generates a new random private/public key pair for the server.
          * @returns A new key pair.
          */
-        generateKeyPair(): OPRFKeys;
+        generateKeyPair(): TRet<OPRFKeys>;
         /**
          * (Server-side) Deterministically derives a private/public key pair from a seed.
-         * @param seed A 32-byte cryptographically secure random seed.
-         * @param keyInfo An optional byte string for domain separation.
+         * @param seed - A 32-byte cryptographically secure random seed.
+         * @param keyInfo - An optional byte string for domain separation.
          * @returns The derived key pair.
          */
-        deriveKeyPair(seed: Bytes, keyInfo: Bytes): OPRFKeys;
+        deriveKeyPair(seed: TArg<Bytes>, keyInfo: TArg<Bytes>): TRet<OPRFKeys>;
         /**
          * (Client-side) The first step of the protocol. The client blinds its private input.
-         * @param input The client's private input bytes.
-         * @param rng An optional cryptographically secure random number generator.
+         * @param input - The client's private input bytes.
+         * @param rng - An optional cryptographically secure random number generator.
          * @returns An object containing the `blind` scalar (which the client MUST keep secret)
          * and the `blinded` element (which the client sends to the server).
          */
-        blind(input: Bytes, rng?: RNG): OPRFBlind;
+        blind(input: TArg<Bytes>, rng?: RNG): TRet<OPRFBlind>;
         /**
          * (Server-side) The second step. The server evaluates the client's blinded element
          * using its secret key.
-         * @param secretKey The server's private key.
-         * @param blinded The blinded group element received from the client.
+         * @param secretKey - The server's private key.
+         * @param blinded - The blinded group element received from the client.
          * @returns The evaluated group element, to be sent back to the client.
          */
-        blindEvaluate(secretKey: ScalarBytes, blinded: PointBytes): PointBytes;
+        blindEvaluate(secretKey: TArg<ScalarBytes>, blinded: TArg<PointBytes>): TRet<PointBytes>;
         /**
          * (Client-side) The final step. The client unblinds the server's response to
          * compute the final OPRF output.
-         * @param input The original private input from the `blind` step.
-         * @param blind The secret scalar from the `blind` step.
-         * @param evaluated The evaluated group element received from the server.
+         * @param input - The original private input from the `blind` step.
+         * @param blind - The secret scalar from the `blind` step.
+         * @param evaluated - The evaluated group element received from the server.
          * @returns The final OPRF output, `Hash(len(input)||input||len(unblinded)||unblinded||"Finalize")`.
          */
-        finalize(input: Bytes, blind: ScalarBytes, evaluated: PointBytes): Bytes;
+        finalize(input: TArg<Bytes>, blind: TArg<ScalarBytes>, evaluated: TArg<PointBytes>): TRet<Bytes>;
     };
     /**
      * The Verifiable Oblivious Pseudorandom Function (VOPRF) mode (mode 0x01).
@@ -153,130 +205,151 @@ export type OPRF = {
      */
     readonly voprf: {
         /** (Server-side) Generates a key pair for the VOPRF mode. */
-        generateKeyPair(): OPRFKeys;
+        generateKeyPair(): TRet<OPRFKeys>;
         /** (Server-side) Deterministically derives a key pair for the VOPRF mode. */
-        deriveKeyPair(seed: Bytes, keyInfo: Bytes): OPRFKeys;
+        deriveKeyPair(seed: TArg<Bytes>, keyInfo: TArg<Bytes>): TRet<OPRFKeys>;
         /** (Client-side) Blinds the client's private input for the VOPRF protocol. */
-        blind(input: Bytes, rng?: RNG): OPRFBlind;
+        blind(input: TArg<Bytes>, rng?: RNG): TRet<OPRFBlind>;
         /**
          * (Server-side) Evaluates the client's blinded element and generates a DLEQ proof
          * of correctness.
-         * @param secretKey The server's private key.
-         * @param publicKey The server's public key, used in proof generation.
-         * @param blinded The blinded group element received from the client.
-         * @param rng An optional cryptographically secure random number generator for the proof.
+         * @param secretKey - The server's private key.
+         * @param publicKey - The server's public key, used in proof generation.
+         * @param blinded - The blinded group element received from the client.
+         * @param rng - An optional cryptographically secure random number generator for the proof.
          * @returns The evaluated element and a proof of correct computation.
          */
-        blindEvaluate(secretKey: ScalarBytes, publicKey: PointBytes, blinded: PointBytes, rng?: RNG): OPRFBlindEval;
+        blindEvaluate(secretKey: TArg<ScalarBytes>, publicKey: TArg<PointBytes>, blinded: TArg<PointBytes>, rng?: RNG): TRet<OPRFBlindEval>;
         /**
          * (Server-side) An optimized batch version of `blindEvaluate`. It evaluates multiple
          * blinded elements and produces a single, constant-size proof for the entire batch,
          * amortizing the cost of proof generation.
-         * @param secretKey The server's private key.
-         * @param publicKey The server's public key.
-         * @param blinded An array of blinded group elements from one or more clients.
-         * @param rng An optional cryptographically secure random number generator for the proof.
+         * @param secretKey - The server's private key.
+         * @param publicKey - The server's public key.
+         * @param blinded - An array of blinded group elements from one or more clients.
+         * @param rng - An optional cryptographically secure random number generator for the proof.
          * @returns An array of evaluated elements and a single proof for the batch.
          */
-        blindEvaluateBatch(secretKey: ScalarBytes, publicKey: PointBytes, blinded: PointBytes[], rng?: RNG): OPRFBlindEvalBatch;
+        blindEvaluateBatch(secretKey: TArg<ScalarBytes>, publicKey: TArg<PointBytes>, blinded: TArg<PointBytes[]>, rng?: RNG): TRet<OPRFBlindEvalBatch>;
         /**
          * (Client-side) The final step. The client verifies the server's proof, and if valid,
          * unblinds the result to compute the final VOPRF output.
-         * @param input The original private input.
-         * @param blind The secret scalar from the `blind` step.
-         * @param evaluated The evaluated element from the server.
-         * @param blinded The blinded element sent to the server (needed for proof verification).
-         * @param publicKey The server's public key against which the proof is verified.
-         * @param proof The DLEQ proof from the server.
+         * @param input - The original private input.
+         * @param blind - The secret scalar from the `blind` step.
+         * @param evaluated - The evaluated element from the server.
+         * @param blinded - The blinded element sent to the server (needed for proof verification).
+         * @param publicKey - The server's public key against which the proof is verified.
+         * @param proof - The DLEQ proof from the server.
          * @returns The final VOPRF output.
-         * @throws If the proof verification fails.
+         * @throws If the proof verification fails. {@link Error}
          */
-        finalize(input: Bytes, blind: ScalarBytes, evaluated: PointBytes, blinded: PointBytes, publicKey: PointBytes, proof: Bytes): Bytes;
+        finalize(input: TArg<Bytes>, blind: TArg<ScalarBytes>, evaluated: TArg<PointBytes>, blinded: TArg<PointBytes>, publicKey: TArg<PointBytes>, proof: TArg<Bytes>): TRet<Bytes>;
         /**
          * (Client-side) The batch-aware version of `finalize`. It verifies a single batch proof
          * against a list of corresponding inputs and outputs.
-         * @param items An array of objects, each containing the parameters for a single finalization.
-         * @param publicKey The server's public key.
-         * @param proof The single DLEQ proof for the entire batch.
+         * @param items - An array of objects, each containing the parameters for a single finalization.
+         * @param publicKey - The server's public key.
+         * @param proof - The single DLEQ proof for the entire batch.
          * @returns An array of final VOPRF outputs, one for each item in the input.
-         * @throws If the proof verification fails.
+         * @throws If the proof verification fails. {@link Error}
          */
-        finalizeBatch(items: OPRFFinalizeItem[], publicKey: PointBytes, proof: Bytes): Bytes[];
+        finalizeBatch(items: TArg<OPRFFinalizeItem[]>, publicKey: TArg<PointBytes>, proof: TArg<Bytes>): TRet<Bytes[]>;
     };
     /**
      * A factory for the Partially Oblivious Pseudorandom Function (POPRF) mode (mode 0x02).
      * This mode extends VOPRF to include a public `info` parameter, known to both client and
      * server, which is cryptographically bound to the final output.
      * This is useful for domain separation at the application level.
-     * @param info A public byte string to be mixed into the computation.
+     * @param info - A public byte string to be mixed into the computation.
      * @returns An object with the POPRF protocol functions.
      */
-    readonly poprf: (info: Bytes) => {
+    readonly poprf: (info: TArg<Bytes>) => {
         /** (Server-side) Generates a key pair for the POPRF mode. */
-        generateKeyPair(): OPRFKeys;
+        generateKeyPair(): TRet<OPRFKeys>;
         /** (Server-side) Deterministically derives a key pair for the POPRF mode. */
-        deriveKeyPair(seed: Bytes, keyInfo: Bytes): OPRFKeys;
+        deriveKeyPair(seed: TArg<Bytes>, keyInfo: TArg<Bytes>): TRet<OPRFKeys>;
         /**
          * (Client-side) Blinds the client's private input and computes the "tweaked key".
          * The tweaked key is a public value derived from the server's public key and the public `info`.
-         * @param input The client's private input.
-         * @param publicKey The server's public key.
-         * @param rng An optional cryptographically secure random number generator.
-         * @returns The `blind`, `blinded` element, and the `tweakedKey` which the client uses for verification.
+         * @param input - The client's private input.
+         * @param publicKey - The server's public key.
+         * @param rng - An optional cryptographically secure random number generator.
+         * @returns The `blind`, `blinded` element, and the `tweakedKey`
+         *   the client uses for verification.
          */
-        blind(input: Bytes, publicKey: PointBytes, rng?: RNG): OPRFBlind & {
-            tweakedKey: PointBytes;
-        };
+        blind(input: TArg<Bytes>, publicKey: TArg<PointBytes>, rng?: RNG): TRet<OPRFBlindTweaked>;
         /**
-         * (Server-side) Evaluates the blinded element using a key derived from its secret key and the public `info`.
+         * (Server-side) Evaluates the blinded element using a key derived from
+         * its secret key and the public `info`.
          * It generates a DLEQ proof against the tweaked key.
-         * @param secretKey The server's private key.
-         * @param blinded The blinded element from the client.
-         * @param rng An optional RNG for the proof.
+         * @param secretKey - The server's private key.
+         * @param blinded - The blinded element from the client.
+         * @param rng - An optional RNG for the proof.
          * @returns The evaluated element and a proof of correct computation.
          */
-        blindEvaluate(secretKey: ScalarBytes, blinded: PointBytes, rng?: RNG): OPRFBlindEval;
+        blindEvaluate(secretKey: TArg<ScalarBytes>, blinded: TArg<PointBytes>, rng?: RNG): TRet<OPRFBlindEval>;
         /**
          * (Server-side) A batch-aware version of `blindEvaluate` for the POPRF mode.
-         * @param secretKey The server's private key.
-         * @param blinded An array of blinded elements.
-         * @param rng An optional RNG for the proof.
+         * @param secretKey - The server's private key.
+         * @param blinded - An array of blinded elements.
+         * @param rng - An optional RNG for the proof.
          * @returns An array of evaluated elements and a single proof for the batch.
          */
-        blindEvaluateBatch(secretKey: ScalarBytes, blinded: PointBytes[], rng: RNG): OPRFBlindEvalBatch;
+        blindEvaluateBatch(secretKey: TArg<ScalarBytes>, blinded: TArg<PointBytes[]>, rng: RNG): TRet<OPRFBlindEvalBatch>;
         /**
          * (Client-side) A batch-aware version of `finalize` for the POPRF mode.
          * It verifies the proof against the tweaked key.
-         * @param items An array containing the parameters for each finalization.
-         * @param proof The single DLEQ proof for the batch.
-         * @param tweakedKey The tweaked key corresponding to the proof (all items must share the same `info` and `publicKey`).
+         * @param items - An array containing the parameters for each finalization.
+         * @param proof - The single DLEQ proof for the batch.
+         * @param tweakedKey - The tweaked key corresponding to the proof.
+         *   All items must share the same `info` and `publicKey`.
          * @returns An array of final POPRF outputs.
-         * @throws If proof verification fails.
+         * @throws If proof verification fails. {@link Error}
          */
-        finalizeBatch(items: OPRFFinalizeItem[], proof: Bytes, tweakedKey: PointBytes): Bytes[];
+        finalizeBatch(items: TArg<OPRFFinalizeItem[]>, proof: TArg<Bytes>, tweakedKey: TArg<PointBytes>): TRet<Bytes[]>;
         /**
          * (Client-side) Finalizes the POPRF protocol. It verifies the server's proof against the
          * `tweakedKey` computed in the `blind` step. The final output is bound to the public `info`.
-         * @param input The original private input.
-         * @param blind The secret scalar.
-         * @param evaluated The evaluated element from the server.
-         * @param blinded The blinded element sent to the server.
-         * @param proof The DLEQ proof from the server.
-         * @param tweakedKey The public tweaked key computed by the client during the `blind` step.
+         * @param input - The original private input.
+         * @param blind - The secret scalar.
+         * @param evaluated - The evaluated element from the server.
+         * @param blinded - The blinded element sent to the server.
+         * @param proof - The DLEQ proof from the server.
+         * @param tweakedKey - The public tweaked key computed by the client during the `blind` step.
          * @returns The final POPRF output.
-         * @throws If proof verification fails.
+         * @throws If proof verification fails. {@link Error}
          */
-        finalize(input: Bytes, blind: ScalarBytes, evaluated: PointBytes, blinded: PointBytes, proof: Bytes, tweakedKey: PointBytes): Bytes;
+        finalize(input: TArg<Bytes>, blind: TArg<ScalarBytes>, evaluated: TArg<PointBytes>, blinded: TArg<PointBytes>, proof: TArg<Bytes>, tweakedKey: TArg<PointBytes>): TRet<Bytes>;
         /**
          * A non-interactive evaluation function for an entity that knows all inputs.
          * Computes the final POPRF output directly. Useful for testing or specific applications
          * where the server needs to compute the output for a known input.
-         * @param secretKey The server's private key.
-         * @param input The client's private input.
+         * @param secretKey - The server's private key.
+         * @param input - The client's private input.
          * @returns The final POPRF output.
          */
-        evaluate(secretKey: ScalarBytes, input: Bytes): Bytes;
+        evaluate(secretKey: TArg<ScalarBytes>, input: TArg<Bytes>): TRet<Bytes>;
     };
 };
-export declare function createORPF<P extends CurvePoint<any, P>>(opts: OPRFOpts<P>): OPRF;
+/**
+ * @param opts - OPRF ciphersuite options. See {@link OPRFOpts}.
+ * @returns OPRF helper namespace.
+ * @example
+ * Instantiate an OPRF suite from curve-specific hashing hooks.
+ *
+ * ```ts
+ * import { createOPRF } from '@noble/curves/abstract/oprf.js';
+ * import { p256, p256_hasher } from '@noble/curves/nist.js';
+ * import { sha256 } from '@noble/hashes/sha2.js';
+ * const oprf = createOPRF({
+ *   name: 'P256-SHA256',
+ *   Point: p256.Point,
+ *   hash: sha256,
+ *   hashToGroup: p256_hasher.hashToCurve,
+ *   hashToScalar: p256_hasher.hashToScalar,
+ * });
+ * const keys = oprf.oprf.generateKeyPair();
+ * ```
+ */
+export declare function createOPRF<P extends CurvePoint<any, P>>(opts: OPRFOpts<P>): TRet<OPRF>;
 //# sourceMappingURL=oprf.d.ts.map

package/abstract/oprf.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"oprf.d.ts","sourceRoot":"","sources":["../src/abstract/oprf.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"oprf.d.ts","sourceRoot":"","sources":["../src/abstract/oprf.ts"],"names":[],"mappings":"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"}