VOPRF

https://docs.rs/voprf/0.5.0
Admin
VOPRF is a Rust implementation of verifiable oblivious pseudorandom functions that enables secure...
Tokens:146,362
Snippets:1,320
Trust Score:9.1
Update:2 months ago
Show doc for...
Tokens:
Raw
### Base Mode: Server Setup

Source: https://docs.rs/voprf/0.5.0/index.html

Initializes an OprfServer instance, which must be persisted for subsequent client evaluations.

```APIDOC
## Base Mode: Server Setup

Initializes an `OprfServer` instance, which must be persisted for subsequent client evaluations.

```rust
use rand::rngs::OsRng;
use rand::RngCore;
use voprf::OprfServer;

let mut server_rng = OsRng;
let server = OprfServer::<CipherSuite>::new(&mut server_rng);
```
```

--------------------------------

### Client Batching Setup

Source: https://docs.rs/voprf/0.5.0/src/voprf/lib.rs.html

Initializes the client for batch VOPRF evaluations by generating multiple blindings.

```rust
# #[cfg(feature = "ristretto255")]
# type CipherSuite = voprf::Ristretto255;
# #[cfg(not(feature = "ristretto255"))]
# type CipherSuite = p256::NistP256;
# use voprf::VoprfClient;
# use rand::{rngs::OsRng, RngCore};
# 
# let mut client_rng = OsRng;

```

--------------------------------

### Server Setup (Base Mode)

Source: https://docs.rs/voprf/0.5.0/src/voprf/lib.rs.html

Initializes a new VOPRF server instance. This instance should be persisted and reused for subsequent client evaluations.

```APIDOC
## Server Setup

### Description

The protocol begins with a setup phase, in which the server must run `OprfServer::new()` to produce an instance of itself. This instance must be persisted on the server and used for online client evaluations.

### Method

`OprfServer::new()`

### Parameters

- `rng`: A mutable reference to a random number generator implementing `RngCore`.

### Request Example

```rust
# #[cfg(feature = "ristretto255")]
# type CipherSuite = voprf::Ristretto255;
# #[cfg(not(feature = "ristretto255"))]
# type CipherSuite = p256::NistP256;
use rand::rngs::OsRng;
use rand::RngCore;
use voprf::OprfServer;

let mut server_rng = OsRng;
let server = OprfServer::<CipherSuite>::new(&mut server_rng);
```
```

--------------------------------

### Server Setup for Base Mode

Source: https://docs.rs/voprf/0.5.0/src/voprf/lib.rs.html

Initialize an OprfServer instance. This instance should be persisted and reused for subsequent client evaluations.

```rust
# #[cfg(feature = "ristretto255")]
type CipherSuite = voprf::Ristretto255;
# #[cfg(not(feature = "ristretto255"))]
type CipherSuite = p256::NistP256;
use rand::rngs::OsRng;
use rand::RngCore;
use voprf::OprfServer;

let mut server_rng = OsRng;
let server = OprfServer::<CipherSuite>::new(&mut server_rng);

```

--------------------------------

### Base Mode: Server Setup

Source: https://docs.rs/voprf/0.5.0/voprf

Initializes a new VOPRF server instance. This instance should be persisted and reused for client evaluations.

```APIDOC
## Base Mode: Server Setup

### Description
Initializes a new VOPRF server instance. This instance should be persisted and reused for client evaluations.

### Method
`OprfServer::new()`

### Parameters
- `server_rng`: A mutable reference to a random number generator implementing `RngCore`.

### Request Example
```rust
use rand::rngs::OsRng;
use rand::RngCore;
use voprf::OprfServer;

let mut server_rng = OsRng;
let server = OprfServer::<CipherSuite>::new(&mut server_rng);
```
```

--------------------------------

### Verifiable Mode: Server Setup

Source: https://docs.rs/voprf/0.5.0/index.html

Initializes a `VoprfServer` instance for verifiable mode. The server's public key must be shared with the client.

```APIDOC
## Verifiable Mode: Server Setup

Initializes a `VoprfServer` instance for verifiable mode. The server's public key must be shared with the client.

```rust
use rand::rngs::OsRng;
use rand::RngCore;
use voprf::VoprfServer;

let mut server_rng = OsRng;
let server = VoprfServer::<CipherSuite>::new(&mut server_rng).unwrap();

// To be sent to the client
println!("Server public key: {:?}", server.get_public_key());
```
```

--------------------------------

### CipherSuite Implementations

Source: https://docs.rs/voprf/0.5.0/voprf/trait.CipherSuite.html

Provides examples of how the CipherSuite trait is implemented, specifically for Ristretto255 and generic implementations based on VoprfParameters.

```APIDOC
## Implementors

### impl CipherSuite for Ristretto255

Available on `crate features`ristretto255` and `ristretto255-ciphersuite` only.

#### const ID: &'static str = "ristretto255-SHA512"

#### type Group = Ristretto255

#### type Hash = CoreWrapper<CtVariableCoreWrapper<Sha512VarCore, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, OidSha512>>

### impl<T> CipherSuite for T

where T: Group + VoprfParameters, T::Hash: BlockSizeUser + Default + FixedOutput + HashMarker, <T::Hash as OutputSizeUser>::OutputSize: IsLess<U256> + IsLessOrEqual<<T::Hash as BlockSizeUser>::BlockSize>

#### const ID: &'static str = T::ID

#### type Group = T

#### type Hash = <T as VoprfParameters>::Hash
```

--------------------------------

### step_by

Source: https://docs.rs/voprf/0.5.0/voprf/type.PoprfClientBatchFinalizeResult.html

Creates an iterator starting at the same point, but stepping by the given amount at each iteration.

```APIDOC
## step_by

### Description
Creates an iterator starting at the same point, but stepping by the given amount at each iteration.

### Method Signature
`fn step_by(self, step: usize) -> StepBy<Self>`

### Type Constraints
`where Self: Sized`
```

--------------------------------

### Server Setup for Verifiable Mode

Source: https://docs.rs/voprf/0.5.0/src/voprf/lib.rs.html

Initializes a VOPRF server instance for verifiable mode. The generated public key must be shared with clients.

```rust
# #[cfg(feature = "ristretto255")]
# type CipherSuite = voprf::Ristretto255;
# #[cfg(not(feature = "ristretto255"))]
# type CipherSuite = p256::NistP256;
use rand::rngs::OsRng;
use rand::RngCore;
use voprf::VoprfServer;

let mut server_rng = OsRng;
let server = VoprfServer::<CipherSuite>::new(&mut server_rng).unwrap();

// To be sent to the client
println!("Server public key: {:?}", server.get_public_key());

```

--------------------------------

### Verifiable Mode: Server Setup

Source: https://docs.rs/voprf/0.5.0/voprf

Initializes a new Verifiable VOPRF server instance. This instance should be persisted and reused for client evaluations. The public key must be shared with the client.

```APIDOC
## Verifiable Mode: Server Setup

### Description
Initializes a new Verifiable VOPRF server instance. This instance should be persisted and reused for client evaluations. The public key must be shared with the client.

### Method
`VoprfServer::new()`

### Parameters
- `server_rng`: A mutable reference to a random number generator implementing `RngCore`.

### Request Example
```rust
use rand::rngs::OsRng;
use rand::RngCore;
use voprf::VoprfServer;

let mut server_rng = OsRng;
let server = VoprfServer::<CipherSuite>::new(&mut server_rng).unwrap();

// To be sent to the client
println!("Server public key: {:?}", server.get_public_key());
```
```

--------------------------------

### Verifiable Batch Retrieval Test Setup

Source: https://docs.rs/voprf/0.5.0/src/voprf/voprf.rs.html

Sets up the necessary structures for testing verifiable batch retrieval in the VOPRF scheme. This involves initializing a random number generator and preparing vectors for inputs and client states.

```rust
fn verifiable_batch_retrieval<CS: CipherSuite>()
where
    <CS::Hash as OutputSizeUser>::OutputSize:
        IsLess<U256> + IsLessOrEqual<<CS::Hash as BlockSizeUser>::BlockSize>,
{
    let mut rng = OsRng;
    let mut inputs = vec![];
    let mut client_states = vec![];
```

--------------------------------

### Checking Result Status

Source: https://docs.rs/voprf/0.5.0/voprf/type.Result.html

Examples of checking if a Result is Ok or Err.

```rust
let x: Result<i32, &str> = Ok(-3);
assert_eq!(x.is_ok(), true);

let x: Result<i32, &str> = Err("Some error message");
assert_eq!(x.is_ok(), false);
```

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.is_ok_and(|x| x > 1), true);

let x: Result<u32, &str> = Ok(0);
assert_eq!(x.is_ok_and(|x| x > 1), false);

let x: Result<u32, &str> = Err("hey");
assert_eq!(x.is_ok_and(|x| x > 1), false);

let x: Result<String, &str> = Ok("ownership".to_string());
assert_eq!(x.as_ref().is_ok_and(|x| x.len() > 1), true);
println!("still alive {:?}", x);
```

```rust
let x: Result<i32, &str> = Ok(-3);
assert_eq!(x.is_err(), false);

let x: Result<i32, &str> = Err("Some error message");
assert_eq!(x.is_err(), true);
```

--------------------------------

### Transposing Result

Source: https://docs.rs/voprf/0.5.0/voprf/type.Result.html

Example of transposing a Result of an Option into an Option of a Result.

```rust
#[derive(Debug, Eq, PartialEq)]
struct SomeErr;

let x: Result<Option<i32>, SomeErr> = Ok(Some(5));
let y: Option<Result<i32, SomeErr>> = Some(Ok(5));
assert_eq!(x.transpose(), y);
```

--------------------------------

### Flattening Nested Results

Source: https://docs.rs/voprf/0.5.0/voprf/type.Result.html

Examples of using flatten to remove one level of nesting from a Result.

```rust
let x: Result<Result<&'static str, u32>, u32> = Ok(Ok("hello"));
assert_eq!(Ok("hello"), x.flatten());

let x: Result<Result<&'static str, u32>, u32> = Ok(Err(6));
assert_eq!(Err(6), x.flatten());

let x: Result<Result<&'static str, u32>, u32> = Err(6);
assert_eq!(Err(6), x.flatten());
```

```rust
let x: Result<Result<Result<&'static str, u32>, u32>, u32> = Ok(Ok(Ok("hello")));
assert_eq!(Ok(Ok("hello")), x.flatten());
assert_eq!(Ok("hello"), x.flatten().flatten());
```

--------------------------------

### Get Result references with as_ref and as_mut

Source: https://docs.rs/voprf/0.5.0/voprf/type.Result.html

Converts a Result to a Result containing references to the original values.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.as_ref(), Ok(&2));

let x: Result<u32, &str> = Err("Error");
assert_eq!(x.as_ref(), Err(&"Error"));
```

```rust
fn mutate(r: &mut Result<i32, i32>) {
    match r.as_mut() {
        Ok(v) => *v = 42,
        Err(e) => *e = 0,
    }
}

let mut x: Result<i32, i32> = Ok(2);
mutate(&mut x);
assert_eq!(x.unwrap(), 42);

let mut x: Result<i32, i32> = Err(13);
mutate(&mut x);
assert_eq!(x.unwrap_err(), 0);
```

--------------------------------

### Copying Result Contents

Source: https://docs.rs/voprf/0.5.0/voprf/type.Result.html

Examples of using the copied method to map Result<&T, E> or Result<&mut T, E> to Result<T, E>.

```rust
let val = 12;
let x: Result<&i32, i32> = Ok(&val);
assert_eq!(x, Ok(&12));
let copied = x.copied();
assert_eq!(copied, Ok(12));
```

```rust
let mut val = 12;
let x: Result<&mut i32, i32> = Ok(&mut val);
assert_eq!(x, Ok(&mut 12));
let copied = x.copied();
assert_eq!(copied, Ok(12));
```

--------------------------------

### Cloning Result Contents

Source: https://docs.rs/voprf/0.5.0/voprf/type.Result.html

Examples of using the cloned method to map Result<&T, E> or Result<&mut T, E> to Result<T, E>.

```rust
let val = 12;
let x: Result<&i32, i32> = Ok(&val);
assert_eq!(x, Ok(&12));
let cloned = x.cloned();
assert_eq!(cloned, Ok(12));
```

```rust
let mut val = 12;
let x: Result<&mut i32, i32> = Ok(&mut val);
assert_eq!(x, Ok(&mut 12));
let cloned = x.cloned();
assert_eq!(cloned, Ok(12));
```

--------------------------------

### TypeId

Source: https://docs.rs/voprf/0.5.0/voprf/struct.PoprfClient.html

Gets the `TypeId` of `self`.

```APIDOC
## type_id

### Description
Gets the `TypeId` of `self`.

### Method
`type_id(&self) -> TypeId`
```

--------------------------------

### base_elem

Source: https://docs.rs/voprf/0.5.0/voprf/trait.Group.html

Get the base point for the group.

```APIDOC
## base_elem

### Description
Get the base point for the group.

### Method Signature
`fn base_elem() -> Self::Elem`
```

--------------------------------

### type_id Method

Source: https://docs.rs/voprf/0.5.0/voprf/struct.VoprfServer.html

Gets the `TypeId` of `self`. This is part of the Any trait implementation.

```APIDOC
#### fn type_id(&self) -> TypeId
Gets the `TypeId` of `self`. Read more
```

--------------------------------

### VoprfServer::new

Source: https://docs.rs/voprf/0.5.0/src/voprf/lib.rs.html

Initializes a new VOPRF server instance.

```APIDOC
## VoprfServer::new

### Description
Initializes a new VOPRF server. This instance should be persisted and used for all subsequent client evaluations.

### Method
```rust
VoprfServer::<CipherSuite>::new(&mut server_rng)
```

### Parameters
* `server_rng`: A mutable reference to a random number generator for the server.

### Request Example
```rust
let server = VoprfServer::<CipherSuite>::new(&mut server_rng).unwrap();
```

### Response
* `server`: A new instance of `VoprfServer`.
```

--------------------------------

### Get Public Key

Source: https://docs.rs/voprf/0.5.0/voprf/struct.VoprfServer.html

Retrieves the server's public key.

```rust
pub fn get_public_key(&self) -> <CS::Group as Group>::Elem

```

--------------------------------

### PoPRF Server Get Public Key

Source: https://docs.rs/voprf/0.5.0/src/voprf/poprf.rs.html

Retrieves the server's public key.

```APIDOC
## get_public_key

### Description
Retrieves the server's public key.

### Method
`get_public_key(&self) -> <CS::Group as Group>::Elem`

### Parameters
None

### Request Example
```rust
// let public_key = server.get_public_key();
```

### Response
#### Success Response (200)
- Returns the server's public key as a group element.
```

--------------------------------

### Initialize VOPRF Server (Base Mode)

Source: https://docs.rs/voprf/0.5.0/index.html

Sets up a new VOPRF server instance for Base Mode. The server instance should be persisted for subsequent client evaluations.

```rust
use rand::rngs::OsRng;
use rand::RngCore;
use voprf::OprfServer;

let mut server_rng = OsRng;
let server = OprfServer::<CipherSuite>::new(&mut server_rng);
```

--------------------------------

### PoprfServer Initialization

Source: https://docs.rs/voprf/0.5.0/voprf/struct.PoprfServer.html

Methods for creating a new PoprfServer instance.

```APIDOC
## `new`

### Description
Produces a new instance of a PoprfServer using a supplied RNG.

### Method
`pub fn new<R: RngCore + CryptoRng>(rng: &mut R) -> Result<Self>`

### Errors
`Error::Protocol` if the protocol fails and can’t be completed.
```

```APIDOC
## `new_with_key`

### Description
Produces a new instance of a PoprfServer using a supplied set of bytes to represent the server’s private key.

### Method
`pub fn new_with_key(key: &[u8]) -> Result<Self>`

### Errors
`Error::Deserialization` if the private key is not a valid point on the group or zero.
```

```APIDOC
## `new_from_seed`

### Description
Produces a new instance of a PoprfServer using a supplied set of bytes which are used as a seed to derive the server’s private key. Corresponds to DeriveKeyPair() function from the VOPRF specification.

### Method
`pub fn new_from_seed(seed: &[u8], info: &[u8]) -> Result<Self>`

### Errors
* `Error::DeriveKeyPair` if the `input` and `seed` together are longer then `u16::MAX - 3`.
* `Error::Protocol` if the protocol fails and can’t be completed.
```

--------------------------------

### Initialize VOPRF Server (Verifiable Mode)

Source: https://docs.rs/voprf/0.5.0/index.html

Sets up a new VOPRF server instance for Verifiable Mode. This includes generating a public key that must be shared with the client for verification.

```rust
use rand::rngs::OsRng;
use rand::RngCore;
use voprf::VoprfServer;

let mut server_rng = OsRng;
let server = VoprfServer::<CipherSuite>::new(&mut server_rng).unwrap();

// To be sent to the client
println!("Server public key: {:?}", server.get_public_key());
```

--------------------------------

### Any Trait Implementation

Source: https://docs.rs/voprf/0.5.0/voprf/struct.VoprfClient.html

Provides a way to get the `TypeId` of a VoprfClient instance, useful for runtime type introspection.

```APIDOC
## fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`.
```

--------------------------------

### Initialize OPRF Server with Private Key Bytes

Source: https://docs.rs/voprf/0.5.0/src/voprf/oprf.rs.html

Creates a new OPRF server instance from a byte slice representing the server's private key. Ensures the key is a valid scalar.

```rust
pub fn new_with_key(private_key_bytes: &[u8]) -> Result<Self> {
        let sk = CS::Group::deserialize_scalar(private_key_bytes)?;
        Ok(Self { sk })
    }
```

--------------------------------

### Get Minimum of Two BlindedElements

Source: https://docs.rs/voprf/0.5.0/voprf/struct.BlindedElement.html

Implements the min method for BlindedElement, returning the lesser of two elements.

```rust
fn min(self, other: Self) -> Self
where
    Self: Sized,

```

--------------------------------

### Get Maximum of Two BlindedElements

Source: https://docs.rs/voprf/0.5.0/voprf/struct.BlindedElement.html

Implements the max method for BlindedElement, returning the greater of two elements.

```rust
fn max(self, other: Self) -> Self
where
    Self: Sized,

```

--------------------------------

### OprfServer::new

Source: https://docs.rs/voprf/0.5.0/src/voprf/oprf.rs.html

Produces a new instance of a [OprfServer] using a supplied RNG. This is the primary method for initializing the server with a random private key.

```APIDOC
## OprfServer::new<R: RngCore + CryptoRng>(rng: &mut R) -> Result<Self>

### Description
Produces a new instance of a [OprfServer] using a supplied RNG.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```rust
use rand::rngs::OsRng;
let mut rng = OsRng;
let server = OprfServer::<CS>::new(&mut rng)?;
```

### Response
#### Success Response (200)
- **Self** (OprfServer<CS>) - A new instance of OprfServer.

#### Response Example
```rust
// Successful initialization returns an OprfServer instance
```

### Errors
- [`Error::Protocol`] if the protocol fails and can't be completed.
```

--------------------------------

### VoprfServer::new_with_key

Source: https://docs.rs/voprf/0.5.0/voprf/struct.VoprfServer.html

Produces a new instance of a VoprfServer using a supplied set of bytes to represent the server’s private key.

```APIDOC
## pub fn new_with_key(key: &[u8]) -> Result<Self>

### Description
Produces a new instance of a VoprfServer using a supplied set of bytes to represent the server’s private key.

### Parameters
#### Path Parameters
- **key** (*&[u8]*) - Required - A byte slice representing the server's private key.

### Returns
- **Result<Self>** - A Result containing the new VoprfServer instance or an Error.

### Errors
- `Error::Deserialization` if the private key is not a valid point on the group or zero.
```

--------------------------------

### Initialize VOPRF Server with Private Key

Source: https://docs.rs/voprf/0.5.0/src/voprf/voprf.rs.html

Produces a new instance of a VOPRF server using a supplied byte slice representing the server's private key. Errors can occur during deserialization if the key is invalid.

```rust
pub fn new_with_key(key: &[u8]) -> Result<Self> {
        let sk = CS::Group::deserialize_scalar(key)?;
        let pk = CS::Group::base_elem() * &sk;
        Ok(Self { sk, pk })
    }
```

--------------------------------

### Get Server Private Key

Source: https://docs.rs/voprf/0.5.0/src/voprf/poprf.rs.html

Retrieves the server's private scalar key. Primarily used for testing purposes.

```rust
pub fn get_private_key(&self) -> <CS::Group as Group>::Scalar {
        self.sk
    }
```

--------------------------------

### VoprfServer::new_with_key

Source: https://docs.rs/voprf/0.5.0/src/voprf/voprf.rs.html

Produces a new instance of a VOPRF server using a supplied byte slice representing the server's private key. This allows for deterministic server initialization if the private key is known.

```APIDOC
## VoprfServer::new_with_key

### Description
Produces a new instance of a [VoprfServer] using a supplied set of bytes to represent the server's private key.

### Parameters
- `key` (&[u8]): A byte slice representing the server's private key.

### Returns
Result<Self>: A new VOPRF server instance or an error if the provided key is invalid or cannot be deserialized.
```

--------------------------------

### Initialize OPRF Server from Seed and Info

Source: https://docs.rs/voprf/0.5.0/src/voprf/oprf.rs.html

Creates a new OPRF server instance using a seed and optional info bytes to derive the server's private key, following the VOPRF specification's DeriveKeyPair function. Errors if the combined input length exceeds u16::MAX - 3.

```rust
pub fn new_from_seed(seed: &[u8], info: &[u8]) -> Result<Self> {
        let sk = derive_key_internal::<CS>(seed, info, Mode::Oprf)?;
        Ok(Self { sk })
    }
```

--------------------------------

### OprfServer::new_with_key

Source: https://docs.rs/voprf/0.5.0/src/voprf/oprf.rs.html

Produces a new instance of a [OprfServer] using a supplied set of bytes to represent the server's private key. This allows for deterministic key generation.

```APIDOC
## OprfServer::new_with_key(private_key_bytes: &[u8]) -> Result<Self>

### Description
Produces a new instance of a [OprfServer] using a supplied set of bytes to represent the server's private key.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```rust
let private_key_bytes = hex::decode("...")?;
let server = OprfServer::<CS>::new_with_key(&private_key_bytes)?;
```

### Response
#### Success Response (200)
- **Self** (OprfServer<CS>) - A new instance of OprfServer.

#### Response Example
```rust
// Successful initialization returns an OprfServer instance
```

### Errors
- [`Error::Deserialization`] if the private key is not a valid point on the group or zero.
```

--------------------------------

### OprfServer::new_with_key

Source: https://docs.rs/voprf/0.5.0/voprf/struct.OprfServer.html

Produces a new instance of a OprfServer using a supplied set of bytes to represent the server’s private key.

```APIDOC
## pub fn new_with_key(private_key_bytes: &[u8]) -> Result<Self>

### Description
Produces a new instance of a OprfServer using a supplied set of bytes to represent the server’s private key.

### Parameters
* `private_key_bytes` (&[u8]): A slice of bytes representing the server's private key.

### Returns
Result<Self>: A new instance of OprfServer or an error if deserialization fails.
```

--------------------------------

### Create New VoprfServer with Private Key

Source: https://docs.rs/voprf/0.5.0/voprf/struct.VoprfServer.html

Creates a new VoprfServer instance using a provided byte slice representing the server's private key. Errors occur if the key is invalid or not on the group.

```rust
pub fn new_with_key(key: &[u8]) -> Result<Self>

```

--------------------------------

### Get Array Length as U2 Bytes

Source: https://docs.rs/voprf/0.5.0/src/voprf/common.rs.html

Retrieves the length of a GenericArray as a U2 (2-byte) big-endian representation. This is useful for fixed-size array operations.

```rust
pub(crate) fn i2osp_2_array<L: ArrayLength<u8> + IsLess<U256>>(
    _: &GenericArray<u8, L>,
) -> GenericArray<u8, U2> {
    L::U16.to_be_bytes().into()
}
```

--------------------------------

### PoprfServer::new_with_key

Source: https://docs.rs/voprf/0.5.0/src/voprf/poprf.rs.html

Produces a new instance of a PoprfServer using a supplied byte slice representing the server's private key.

```APIDOC
## new_with_key

### Description
Produces a new instance of a [PoprfServer] using a supplied set of bytes to represent the server's private key.

### Method
`pub fn new_with_key(key: &[u8]) -> Result<Self>`

### Parameters
- `key`: A byte slice representing the server's private key.

### Errors
- `Error::Deserialization`: if the private key is not a valid point on the group or zero.
```

--------------------------------

### VoprfServer::new

Source: https://docs.rs/voprf/0.5.0/voprf/struct.VoprfServer.html

Produces a new instance of a VoprfServer using a supplied RNG.

```APIDOC
## pub fn new<R: RngCore + CryptoRng>(rng: &mut R) -> Result<Self>

### Description
Produces a new instance of a VoprfServer using a supplied RNG.

### Parameters
#### Path Parameters
- **rng** (*R*) - Required - A mutable reference to a random number generator implementing RngCore and CryptoRng.

### Returns
- **Result<Self>** - A Result containing the new VoprfServer instance or an Error.

### Errors
- `Error::Protocol` if the protocol fails and can’t be completed.
```

--------------------------------

### Get Server Public Key

Source: https://docs.rs/voprf/0.5.0/voprf/struct.PoprfServer.html

Retrieves the server's public key, which is used in verifiable mode to allow clients to verify OPRF outputs.

```rust
pub fn get_public_key(&self) -> <CS::Group as Group>::Elem
```

--------------------------------

### OprfServer::new

Source: https://docs.rs/voprf/0.5.0/voprf/struct.OprfServer.html

Produces a new instance of a OprfServer using a supplied RNG.

```APIDOC
## pub fn new<R: RngCore + CryptoRng>(rng: &mut R) -> Result<Self>

### Description
Produces a new instance of a OprfServer using a supplied RNG.

### Parameters
* `rng` (&mut R): A mutable reference to a random number generator implementing RngCore and CryptoRng.

### Returns
Result<Self>: A new instance of OprfServer or an error if the protocol fails.
```

--------------------------------

### CloneToUninit Implementation

Source: https://docs.rs/voprf/0.5.0/voprf/struct.PreparedEvaluationElement.html

Provides experimental functionality to clone PreparedEvaluationElement into uninitialized memory.

```APIDOC
#### unsafe fn clone_to_uninit(&self, dest: *mut u8)
🔬This is a nightly-only experimental API. (`clone_to_uninit`)
Performs copy-assignment from `self` to `dest`.
```

--------------------------------

### Get Blind Scalar from VOPRF Client (Test)

Source: https://docs.rs/voprf/0.5.0/src/voprf/voprf.rs.html

Helper function used only for test functions to retrieve the blind scalar from a VOPRF client instance.

```rust
pub fn get_blind(&self) -> <CS::Group as Group>::Scalar {
        self.blind
    }
```

--------------------------------

### rfold Method for DoubleEndedIterator

Source: https://docs.rs/voprf/0.5.0/voprf/type.VoprfServerBatchEvaluateFinishedMessages.html

Implements the rfold method for the DoubleEndedIterator trait on Map. This method reduces iterator elements to a single value, starting from the back.

```rust
fn rfold<Acc, G>(self, init: Acc, g: G) -> Acc
where G: FnMut(Acc, <Map<I, F> as Iterator>::Item) -> Acc,
```

--------------------------------

### Verifiable Server Evaluation

Source: https://docs.rs/voprf/0.5.0/src/voprf/voprf.rs.html

Initiates a verifiable server evaluation process. This snippet shows the client blinding step, which is the precursor to the server's evaluation.

```rust
fn verifiable_server_evaluate<CS: CipherSuite>()
where
    <CS::Hash as OutputSizeUser>::OutputSize:
        IsLess<U256> + IsLessOrEqual<<CS::Hash as BlockSizeUser>::BlockSize>,
{
    let input = b"input";
    let mut rng = OsRng;
    let client_blind_result = VoprfClient::<CS>::blind(input, &mut rng).unwrap();

```

--------------------------------

### Get Server Public Key

Source: https://docs.rs/voprf/0.5.0/src/voprf/voprf.rs.html

Retrieves the server's public key. This is a direct getter for the public key stored within the server's context.

```rust
pub fn get_public_key(&self) -> <CS::Group as Group>::Elem {
        self.pk
    }
```

--------------------------------

### VoprfServer::batch_blind_evaluate_prepare

Source: https://docs.rs/voprf/0.5.0/voprf/struct.VoprfServer.html

Alternative version of `batch_blind_evaluate` without memory allocation. Returned `PreparedEvaluationElement` have to be `collect`ed and passed into `batch_blind_evaluate_finish`.

```APIDOC
## pub fn batch_blind_evaluate_prepare<'a, I: Iterator<Item = &'a BlindedElement<CS>>>( &self, blinded_elements: I, ) -> VoprfServerBatchEvaluatePreparedEvaluationElements<CS, I>
where CS: 'a,

### Description
Alternative version of `batch_blind_evaluate` without memory allocation. Returned `PreparedEvaluationElement` have to be `collect`ed and passed into `batch_blind_evaluate_finish`.

### Parameters
#### Path Parameters
- **blinded_elements** (*I*) - Required - An iterator over blinded elements.

### Returns
- **VoprfServerBatchEvaluatePreparedEvaluationElements<CS, I>** - Prepared evaluation elements for batch evaluation.
```

--------------------------------

### Initialize VOPRF Server from Seed

Source: https://docs.rs/voprf/0.5.0/src/voprf/voprf.rs.html

Produces a new instance of a VOPRF server using a supplied seed and info bytes to derive the server's private key, corresponding to the VOPRF specification's DeriveKeyPair function. Errors can occur if the combined input and seed are too long or if the protocol fails.

```rust
pub fn new_from_seed(seed: &[u8], info: &[u8]) -> Result<Self> {
        let (sk, pk) = derive_keypair::<CS>(seed, info, Mode::Voprf)?;
        Ok(Self { sk, pk })
    }
```

--------------------------------

### Min Implementation for OprfServer

Source: https://docs.rs/voprf/0.5.0/voprf/struct.OprfServer.html

Compares two OprfServer instances and returns the minimum.

```rust
fn min(self, other: Self) -> Self
where Self: Sized,

```

--------------------------------

### VoprfServer::batch_blind_evaluate_finish

Source: https://docs.rs/voprf/0.5.0/voprf/struct.VoprfServer.html

See `batch_blind_evaluate_prepare` for more details.

```APIDOC
## pub fn batch_blind_evaluate_finish<'a, 'b, R: RngCore + CryptoRng, IB: Iterator<Item = &'a BlindedElement<CS>> + ExactSizeIterator, IE>( &self, rng: &mut R, blinded_elements: IB, evaluation_elements: &'b IE, ) -> Result<VoprfServerBatchEvaluateFinishResult<'b, CS, IE>>
where CS: 'a + 'b, &'b IE: IntoIterator<Item = &'b PreparedEvaluationElement<CS>>, <&'b IE as IntoIterator>::IntoIter: ExactSizeIterator,

### Description
See `batch_blind_evaluate_prepare` for more details.

### Parameters
#### Path Parameters
- **rng** (*&mut R*) - Required - A mutable reference to a random number generator.
- **blinded_elements** (*IB*) - Required - An iterator over blinded elements.
- **evaluation_elements** (*&'b IE*) - Required - An iterator over prepared evaluation elements.

### Returns
- **Result<VoprfServerBatchEvaluateFinishResult<'b, CS, IE>>** - A Result containing the batch evaluation finish result or an Error.

### Errors
- `Error::Batch` if the number of `blinded_elements` and `evaluation_elements` don’t match or is longer then `u16::MAX`.
```

--------------------------------

### OprfClient::blind and finalize

Source: https://docs.rs/voprf/0.5.0/src/voprf/lib.rs.html

Demonstrates the client-side blinding and finalization process in the VOPRF protocol.

```APIDOC
## OprfClient::blind and finalize

### Description
This snippet shows how a client blinds an input, sends it to the server, and then finalizes the VOPRF computation using the server's response.

### Method
```rust
OprfClient::<CipherSuite>::blind(...)
client_blind_result.state.finalize(...)
```

### Parameters
* `input`: The message to be processed by the VOPRF.
* `client_rng`: A mutable reference to a random number generator for the client.
* `message`: The message received from the server after blind evaluation.

### Request Example
```rust
let client_blind_result = OprfClient::<CipherSuite>::blind(b"input", &mut client_rng).expect("Unable to construct client");
let client_finalize_result = client_blind_result.state.finalize(b"input", &message).expect("Unable to perform client finalization");
```

### Response
* `client_finalize_result`: The final VOPRF output computed by the client.
```

--------------------------------

### New OprfServer with Private Key Bytes

Source: https://docs.rs/voprf/0.5.0/voprf/struct.OprfServer.html

Produces a new instance of an OprfServer using a supplied set of bytes to represent the server’s private key. Errors if the private key is invalid.

```rust
pub fn new_with_key(private_key_bytes: &[u8]) -> Result<Self>

```

--------------------------------

### Batch Server Blind Evaluation Prepare

Source: https://docs.rs/voprf/0.5.0/voprf

The server prepares for batch evaluation by processing client messages.

```APIDOC
## Batch Server Blind Evaluation Prepare

### Description
The server calls `VoprfServer::batch_blind_evaluate_prepare` on a set of client messages to prepare for batch evaluation.

### Method
`VoprfServer::batch_blind_evaluate_prepare`

### Parameters
- `client_messages` (Iterator<BlindedElement>): An iterator over the blinded messages from the clients.

### Response
An iterator yielding `PreparedEvaluationElement`.
```

--------------------------------

### Prepare for Batched PoPRF Evaluation (No Allocation)

Source: https://docs.rs/voprf/0.5.0/src/voprf/poprf.rs.html

Prepares for batched PoPRF evaluation without memory allocation. Returned PreparedEvaluationElements must be collected and passed to batch_blind_evaluate_finish. Errors can occur if info is too long or the protocol fails.

```rust
pub fn batch_blind_evaluate_prepare<'a, I: Iterator<Item = &'a BlindedElement<CS>>>(
        &self,
        blinded_elements: I,
        info: Option<&[u8]>,
    ) -> Result<PoprfServerBatchEvaluatePrepareResult<CS, I>>
    where
        CS: 'a,
    {
        let tweak = compute_tweak::<CS>(self.sk, info)?;

        Ok(PoprfServerBatchEvaluatePrepareResult {
            prepared_evaluation_elements: blinded_elements.zip(iter::repeat(tweak)).map(
                |(blinded_element, tweak)| {
                    PreparedEvaluationElement(EvaluationElement(
                        blinded_element.0 * &CS::Group::invert_scalar(tweak),
                    ))
                },
            ),
            prepared_tweak: PoprfPreparedTweak(tweak),
        })
    }
```

--------------------------------

### CloneToUninit

Source: https://docs.rs/voprf/0.5.0/voprf/struct.PoprfClient.html

Performs copy-assignment to an uninitialized memory location. This is a nightly-only experimental API.

```APIDOC
## clone_to_uninit

### Description
Performs copy-assignment from `self` to `dest`.

### Method
`unsafe fn clone_to_uninit(&self, dest: *mut u8)`

### Note
This is a nightly-only experimental API.
```

--------------------------------

### batch_blind_evaluate_prepare

Source: https://docs.rs/voprf/0.5.0/src/voprf/voprf.rs.html

Prepares the evaluation elements for batch blinded evaluation without memory allocation. The returned elements need to be collected and passed to batch_blind_evaluate_finish.

```APIDOC
## batch_blind_evaluate_prepare

### Description
Alternative version of `batch_blind_evaluate` without memory allocation. Returned [`PreparedEvaluationElement`] have to be [`collect`](Iterator::collect)ed and passed into [`batch_blind_evaluate_finish`](Self::batch_blind_evaluate_finish).

### Method
`batch_blind_evaluate_prepare`

### Parameters
- `blinded_elements`: An iterator over references to `BlindedElement<CS>` messages from the client.

### Returns
- `VoprfServerBatchEvaluatePreparedEvaluationElements<CS, I>`: An iterator yielding prepared evaluation elements.
```

--------------------------------

### Ordering and Comparison for VoprfClient

Source: https://docs.rs/voprf/0.5.0/voprf/struct.VoprfClient.html

Defines how VoprfClient instances can be ordered and compared, including methods for comparison, finding minimum/maximum values, and clamping.

```APIDOC
## fn cmp(&self, __other: &Self) -> Ordering

This method returns an `Ordering` between `self` and `other`.

## fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

## fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

## fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

## fn partial_cmp(&self, __other: &Self) -> Option<Ordering>

This method returns an ordering between `self` and `other` values if one exists.

## fn lt(&self, other: &Rhs) -> bool

Tests less than (for `self` and `other`) and is used by the `<` operator.

## fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for `self` and `other`) and is used by the `<=` operator.

## fn gt(&self, other: &Rhs) -> bool

Tests greater than (for `self` and `other`) and is used by the `>` operator.

## fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator.
```

--------------------------------

### CloneToUninit

Source: https://docs.rs/voprf/0.5.0/voprf/struct.VoprfClient.html

Performs copy-assignment from `self` to `dest`. This is a nightly-only experimental API.

```APIDOC
## unsafe fn clone_to_uninit(&self, dest: *mut u8)

### Description
Performs copy-assignment from `self` to `dest`.

### Safety
This function is unsafe because the `dest` pointer must be valid for writes and must point to a buffer of sufficient size to hold `self`.
```

--------------------------------

### Client Batch Blinding Preparation

Source: https://docs.rs/voprf/0.5.0/index.html

Prepares multiple VOPRF evaluations by generating blindings for each input. The client states and messages must be stored for batch finalization.

```rust
let mut client_rng = OsRng;
let mut client_states = vec![];
let mut client_messages = vec![];
for _ in 0..10 {
    let client_blind_result = VoprfClient::<CipherSuite>::blind(b"input", &mut client_rng)
        .expect("Unable to construct client");
    client_states.push(client_blind_result.state);
    client_messages.push(client_blind_result.message);
}

```

--------------------------------

### Fmt for VoprfServer

Source: https://docs.rs/voprf/0.5.0/voprf/struct.VoprfServer.html

Implementation of the fmt method for VoprfServer, allowing it to be formatted for display.

```APIDOC
## fn fmt(&self, __f: &mut Formatter<'_>) -> Result

### Description
Formats the value using the given formatter.

### Parameters
* `__f`: The formatter to use.
```

--------------------------------

### PartialEq Implementation for OprfClient

Source: https://docs.rs/voprf/0.5.0/voprf/struct.OprfClient.html

Provides methods for comparing OprfClient instances for equality.

```APIDOC
## fn eq(&self, __other: &Self) -> bool

Tests for `self` and `other` values to be equal, and is used by `==`.
```

```APIDOC
## fn ne(&self, other: &Rhs) -> bool

Tests for `!=`. The default implementation is almost always sufficient, and should not be overridden without very good reason.
```

--------------------------------

### Batch Blind Evaluate Prepare

Source: https://docs.rs/voprf/0.5.0/voprf/struct.VoprfServer.html

An alternative to `batch_blind_evaluate` that avoids memory allocation. It returns `PreparedEvaluationElement`s that must be collected and passed to `batch_blind_evaluate_finish`.

```rust
pub fn batch_blind_evaluate_prepare<'a, I: Iterator<Item = &'a BlindedElement<CS>>>(
    &self,
    blinded_elements: I,
) -> VoprfServerBatchEvaluatePreparedEvaluationElements<CS, I>
where CS: 'a,

```

--------------------------------

### Base Mode: Client Blinding

Source: https://docs.rs/voprf/0.5.0/index.html

Client prepares for the OPRF evaluation by blinding an input. It produces a `BlindedElement` to send to the server and retains client state for finalization.

```APIDOC
## Base Mode: Client Blinding

Client prepares for the OPRF evaluation by blinding an input. It produces a `BlindedElement` to send to the server and retains client state for finalization.

```rust
use rand::rngs::OsRng;
use rand::RngCore;
use voprf::OprfClient;

let mut client_rng = OsRng;
let client_blind_result = OprfClient::<CipherSuite>::blind(b"input", &mut client_rng)
    .expect("Unable to construct client");
```
```

--------------------------------

### OprfClient::blind Method

Source: https://docs.rs/voprf/0.5.0/voprf/struct.OprfClient.html

Computes the first step for the multiplicative blinding version of DH-OPRF. Requires a random number generator for the blinding factor. Errors if the input is empty or too long.

```rust
pub fn blind<R: RngCore + CryptoRng>( input: &[u8], blinding_factor_rng: &mut R, ) -> Result<OprfClientBlindResult<CS>>
```

--------------------------------

### Into Implementation

Source: https://docs.rs/voprf/0.5.0/voprf/struct.PreparedEvaluationElement.html

Allows converting a PreparedEvaluationElement into another type that implements From.

```APIDOC
### impl<T, U> Into<U> for T
where U: From<T>,
#### fn into(self) -> U
Calls `U::from(self)`.
```

--------------------------------

### batch_blind_evaluate_prepare

Source: https://docs.rs/voprf/0.5.0/src/voprf/poprf.rs.html

Alternative version of batch_blind_evaluate without memory allocation. Returned PreparedEvaluationElement have to be collected and passed into batch_blind_evaluate_finish.

```APIDOC
## batch_blind_evaluate_prepare

### Description
Alternative version of `batch_blind_evaluate` without memory allocation. Returned `PreparedEvaluationElement` have to be `collect`ed and passed into `batch_blind_evaluate_finish`.

### Method
`pub fn batch_blind_evaluate_prepare<'a, I: Iterator<Item = &'a BlindedElement<CS>>>(
        &self,
        blinded_elements: I,
        info: Option<&[u8]>,
    ) -> Result<PoprfServerBatchEvaluatePrepareResult<CS, I>>
    where
        CS: 'a,
`

### Parameters
- `blinded_elements`: An iterator over `BlindedElement`s to be prepared for evaluation.
- `info`: Optional byte slice providing additional information for the computation.

### Errors
- `Error::Info`: if the `info` is longer than `u16::MAX`.
- `Error::Protocol`: if the protocol fails and can't be completed.
```

--------------------------------

### Create PoprfServer with Private Key

Source: https://docs.rs/voprf/0.5.0/voprf/struct.PoprfServer.html

Creates a new PoprfServer instance from a byte slice representing the server's private key. Ensure the provided key is valid and corresponds to a point on the group.

```rust
pub fn new_with_key(key: &[u8]) -> Result<Self>
```

--------------------------------

### PartialEq for PoprfPreparedTweak

Source: https://docs.rs/voprf/0.5.0/voprf/struct.PoprfPreparedTweak.html

Enables equality comparison for PoprfPreparedTweak instances.

```APIDOC
### impl<CS: CipherSuite> PartialEq for PoprfPreparedTweak<CS>

#### fn eq(&self, __other: &Self) -> bool
Tests for `self` and `other` values to be equal, and is used by `==`.

#### fn ne(&self, other: &Rhs) -> bool
Tests for `!=`.
```

--------------------------------

### PartialEq Implementation

Source: https://docs.rs/voprf/0.5.0/voprf/struct.PoprfServer.html

Defines equality comparison for PoprfServer instances.

```APIDOC
## fn eq(&self, __other: &Self) -> bool

### Description
Tests for `self` and `other` values to be equal, and is used by `==`.

### Method
`eq`
```

```APIDOC
## fn ne(&self, other: &Rhs) -> bool

### Description
Tests for `!=`.

### Method
`ne`
```

--------------------------------

### Initialize OPRF Server with RNG

Source: https://docs.rs/voprf/0.5.0/src/voprf/oprf.rs.html

Creates a new OPRF server instance using a provided random number generator. The server's private key is derived from a random seed.

```rust
pub fn new<R: RngCore + CryptoRng>(rng: &mut R) -> Result<Self> {
        let mut seed = GenericArray::<_, <CS::Group as Group>::ScalarLen>::default();
        rng.fill_bytes(&mut seed);
        Self::new_from_seed(&seed, &[])
    }
```

--------------------------------

### Clone for PoprfPreparedTweak

Source: https://docs.rs/voprf/0.5.0/voprf/struct.PoprfPreparedTweak.html

Provides functionality to create a duplicate of a PoprfPreparedTweak instance.

```APIDOC
### impl<CS: CipherSuite> Clone for PoprfPreparedTweak<CS>

#### fn clone(&self) -> Self
Returns a duplicate of the value.

#### fn clone_from(&mut self, source: &Self)
Performs copy-assignment from `source`.
```

--------------------------------

### Client Blinding (Base Mode)

Source: https://docs.rs/voprf/0.5.0/src/voprf/lib.rs.html

Initiates the VOPRF protocol from the client's perspective. It blinds the input and prepares the client for the server's evaluation.

```APIDOC
## Client Blinding

### Description

In the first step, the client chooses an input, and runs `OprfClient::blind` to produce an `OprfClientBlindResult`, which consists of a `BlindedElement` to be sent to the server and an `OprfClient` which must be persisted on the client for the final step of the VOPRF protocol.

### Method

`OprfClient::blind`

### Parameters

- `input`: The data to be processed by the VOPRF.
- `rng`: A mutable reference to a random number generator implementing `RngCore`.

### Request Example

```rust
# #[cfg(feature = "ristretto255")]
# type CipherSuite = voprf::Ristretto255;
# #[cfg(not(feature = "ristretto255"))]
# type CipherSuite = p256::NistP256;
use rand::rngs::OsRng;
use rand::RngCore;
use voprf::OprfClient;

let mut client_rng = OsRng;
let client_blind_result = OprfClient::<CipherSuite>::blind(b"input", &mut client_rng)
    .expect("Unable to construct client");
```
```
Tokens:
Raw