blstrs

https://docs.rs/blstrs/0.7.1
Admin
blstrs is a Rust implementation of the BLS12-381 pairing-friendly elliptic curve construction for...
Tokens:198,193
Snippets:1,270
Trust Score:9.1
Update:5 months ago
Show doc for...
Tokens:
Raw
### Fp2 Square Root Calculation

Source: https://docs.rs/blstrs/0.7.1/src/blstrs/fp2.rs.html

Demonstrates the calculation of square roots for Fp2 elements. It includes examples for both a general Fp2 element and a specific case involving Fp::ZERO.

```rust
Fp2::new(
                Fp::from_u64s_le(&[
                    0xdb4a116b5bf74aa1,
                    0x1e58b2159dfe10e2,
                    0x7ca7da1f13606ac
                ])
                .unwrap(),
                Fp::from_u64s_le(&[
                    0xfa8de88b7516d2c3,
                    0x371a75ed14f41629,
                    0x4cec2dca577a3eb6,
                    0x212611bca4e99121,
                    0x8ee5394d77afb3d,
                    0xec92336650e49d5
                ])
                .unwrap()
            )
            .sqrt()
            .unwrap()
```

```rust
Fp2::new(
                Fp::from_u64s_le(&[
                    0x40b299b2704258c5,
                    0x6ef7de92e8c68b63,
                    0x6d2ddbe552203e82,
                    0x8d7f1f723d02c1d3,
                    0x881b3e01b611c070,
                    0x10f6963bbad2ebc5
                ])
                .unwrap(),
                Fp::from_u64s_le(&[
                    0xc099534fc209e752,
                    0x7670594665676447,
                    0x28a20faed211efe7,
                    0x6b852aeaf2afcb1b,
                    0xa4c93b08105d71a9,
                    0x8d7cfff94216330
                ])
                .unwrap()
            )
            .neg()
```

```rust
assert_eq!(
            Fp2::new(
                Fp::from_u64s_le(&[
                    0xb9f78429d1517a6b,
                    0x1eabfffeb153ffff,
                    0x6730d2a0f6b0f624,
                    0x64774b84f38512bf,
                    0x4b1ba7b6434bacd7,
                    0x1a0111ea397fe69a
                ])
                .unwrap(),
                Fp::ZERO,
            )
            .sqrt()
            .unwrap(),
            Fp2::new(
                Fp::ZERO,
                Fp::from_u64s_le(&[
                    0xb9fefffffd4357a3,
                    0x1eabfffeb153ffff,
                    0x6730d2a0f6b0f624,
                    0x64774b84f38512bf,
                    0x4b1ba7b6434bacd7,
                    0x1a0111ea397fe69a
                ])
                .unwrap()
            )
        );
```

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

### recommended_wnaf_for_num_scalars

Source: https://docs.rs/blstrs/0.7.1/blstrs/struct.G1Projective.html

Recommends a wNAF window size given the number of scalars.

```APIDOC
## recommended_wnaf_for_num_scalars

### Description
Recommends a wNAF window size given the number of scalars you intend to multiply a base by. Always returns a number between 2 and 22, inclusive.

### Method
`recommended_wnaf_for_num_scalars`

### Parameters
#### Path Parameters
- `num_scalars` (usize) - Description not available
```

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

### Get TypeId of G2Prepared

Source: https://docs.rs/blstrs/0.7.1/blstrs/struct.G2Prepared.html

Gets the `TypeId` of the G2Prepared struct. This is useful for runtime type identification and dynamic dispatch.

```rust
fn type_id(&self) -> TypeId
```

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

### type_id

Source: https://docs.rs/blstrs/0.7.1/blstrs/struct.G1Projective.html

Gets the `TypeId` of `self`.

```APIDOC
## type_id

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

### Method
`type_id`

### Parameters
#### Path Parameters
- `self` - Description not available
```

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

### PairingG1G2::init

Source: https://docs.rs/blstrs/0.7.1/blstrs/struct.PairingG1G2.html

Initializes an existing PairingG1G2 context. This method allows re-initializing the context with new parameters for hashing/encoding and a destination.

```APIDOC
## PairingG1G2::init

### Description
Initializes an existing PairingG1G2 context. This method allows re-initializing the context with new parameters for hashing/encoding and a destination.

### Signature
```rust
pub fn init(&mut self, hash_or_encode: bool, dst: &[u8])
```

### Parameters
* `hash_or_encode` (bool): A flag indicating whether to use hashing or encoding.
* `dst` (&[u8]): The destination byte slice.

### Behavior
Modifies the `PairingG1G2` instance in place.
```

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

### Get Y Coordinate of G1Projective

Source: https://docs.rs/blstrs/0.7.1/blstrs/struct.G1Projective.html

Retrieves the y-coordinate of the G1Projective element.

```rust
pub fn y(&self) -> Fp
```

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

### impl<T> CloneToUninit for T

Source: https://docs.rs/blstrs/0.7.1/blstrs/struct.G2Compressed.html

Nightly-only experimental API for cloning to uninitialized memory.

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

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

### Method
`clone_to_uninit`
```

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

### PairingG2G1::init

Source: https://docs.rs/blstrs/0.7.1/blstrs/struct.PairingG2G1.html

Initializes an existing PairingG2G1 instance. This method allows re-initializing the pairing context with new parameters, similar to `new` but operates on a mutable reference.

```APIDOC
## PairingG2G1::init

### Description
Initializes an existing PairingG2G1 instance. This method allows re-initializing the pairing context with new parameters, similar to `new` but operates on a mutable reference.

### Signature
```rust
pub fn init(&mut self, hash_or_encode: bool, dst: &[u8])
```

### Parameters
- `hash_or_encode` (bool): A flag indicating whether to use hashing or encoding.
- `dst` (&[u8]): The destination byte slice.

### Behavior
Modifies the `self` instance in place.
```

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

### Get Number of Bits

Source: https://docs.rs/blstrs/0.7.1/blstrs/struct.Scalar.html

Returns the number of bits in the scalar representation.

```rust
pub fn num_bits(&self) -> u32
```

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

### Get Scalar Field Representation

Source: https://docs.rs/blstrs/0.7.1/blstrs/struct.Scalar.html

Returns the representation of the scalar field.

```rust
pub fn char() -> <Self as PrimeField>::Repr
```

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

### Initialize PairingG1G2 with Hash or Encode and Destination

Source: https://docs.rs/blstrs/0.7.1/blstrs/struct.PairingG1G2.html

Initializes a new PairingG1G2 instance. Use `hash_or_encode` to specify the encoding method and `dst` for the destination.

```rust
pub fn new(hash_or_encode: bool, dst: &[u8]) -> Self
```

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

### impl<T> CloneToUninit for T

Source: https://docs.rs/blstrs/0.7.1/blstrs/struct.G1Compressed.html

Nightly-only experimental API for cloning data to an uninitialized memory location.

```APIDOC
unsafe fn clone_to_uninit(&self, dest: *mut u8)
Performs copy-assignment from `self` to `dest`. Read more
```

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

### Get Z Coordinate of G1Projective

Source: https://docs.rs/blstrs/0.7.1/blstrs/struct.G1Projective.html

Retrieves the z-coordinate of the G1Projective element.

```rust
pub fn z(&self) -> Fp
```

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

### CloneToUninit

Source: https://docs.rs/blstrs/0.7.1/blstrs/struct.MillerLoopResult.html

Provides a method to clone data into an uninitialized memory location. This is an experimental, nightly-only feature.

```APIDOC
## clone_to_uninit

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

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

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

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

### Get X Coordinate of G1Projective

Source: https://docs.rs/blstrs/0.7.1/blstrs/struct.G1Projective.html

Retrieves the x-coordinate of the G1Projective element.

```rust
pub fn x(&self) -> Fp
```

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

### Get Y Coordinate of G2Affine

Source: https://docs.rs/blstrs/0.7.1/src/blstrs/g2.rs.html

Returns the y-coordinate of the G2Affine point as an Fp2 type.

```rust
pub fn y(&self) -> Fp2 {
        Fp2(self.0.y)
    }
```

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

### TryConv Implementation

Source: https://docs.rs/blstrs/0.7.1/blstrs/struct.PairingG2G1.html

Provides a method to attempt conversion into another type using `TryInto`.

```APIDOC
### impl<T> TryConv for T
#### fn try_conv<T>(self) -> Result<T, Self::Error>
where Self: TryInto<T>,
Attempts to convert `self` into `T` using `TryInto<T>`. Read more
Source§
```

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

### Get modulus representation

Source: https://docs.rs/blstrs/0.7.1/src/blstrs/scalar.rs.html

Returns the modulus representation for the scalar field. This is a constant value.

```rust
pub fn char() -> <Self as PrimeField>::Repr {
        MODULUS_REPR
    }
```

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

### TryFrom::try_from

Source: https://docs.rs/blstrs/0.7.1/blstrs/struct.Bls12.html

Performs the conversion.

```APIDOC
## try_from

### Description
Performs the conversion.

### Signature
`fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>`

### Type Constraints
`where U: Into<T>`
```

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

### Get G2 Generator Point

Source: https://docs.rs/blstrs/0.7.1/src/blstrs/g2.rs.html

Returns the standard generator for the G2 projective group.

```rust
fn generator() -> Self {
        G2Projective(unsafe { *blst_p2_generator() })
    }
```

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

### fmt_list

Source: https://docs.rs/blstrs/0.7.1/blstrs/struct.G1Projective.html

Formats each item in a sequence.

```APIDOC
## fmt_list

### Description
Formats each item in a sequence.

### Method
`fmt_list`

### Parameters
#### Path Parameters
- `self` - Description not available
```

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

### Get G2 Identity Point

Source: https://docs.rs/blstrs/0.7.1/src/blstrs/g2.rs.html

Returns the identity element for the G2 projective group.

```rust
fn identity() -> Self {
        G2Projective(blst_p2::default())
    }
```

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

### Get X Coordinate of G2Affine

Source: https://docs.rs/blstrs/0.7.1/src/blstrs/g2.rs.html

Returns the x-coordinate of the G2Affine point as an Fp2 type.

```rust
pub fn x(&self) -> Fp2 {
        Fp2(self.0.x)
    }
```

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

### Clone From Another G2Prepared Instance

Source: https://docs.rs/blstrs/0.7.1/blstrs/struct.G2Prepared.html

Performs copy-assignment from a source G2Prepared instance to the current one. This is an efficient way to update an existing instance.

```rust
fn clone_from(&mut self, source: &Self)
```

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

### try_into

Source: https://docs.rs/blstrs/0.7.1/blstrs/struct.G2Prepared.html

Performs the conversion.

```APIDOC
## fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
where U: TryFrom<T>,
Performs the conversion.
```

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

### Get Fp Modulus as Bytes

Source: https://docs.rs/blstrs/0.7.1/src/blstrs/fp.rs.html

Returns the modulus of the Fp field as a 48-byte array.

```rust
pub fn char() -> [u8; 48] {
        MODULUS_REPR
    }
```

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

### Get Z Coordinate of G2

Source: https://docs.rs/blstrs/0.7.1/src/blstrs/g2.rs.html

Returns the z coordinate of the G2Projective point as an Fp2 element.

```rust
pub fn z(&self) -> Fp2 {
        Fp2(self.0.z)
    }
```

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

### G2Prepared Point Preparation

Source: https://docs.rs/blstrs/0.7.1/src/blstrs/g2.rs.html

Prepares a G2Affine point for efficient pairing operations by precomputing lines. Handles the identity point case.

```rust
impl From<G2Affine> for G2Prepared {
    fn from(affine: G2Affine) -> Self {
        if affine.is_identity().into() {
            G2Prepared {
                lines: Vec::new(),
                infinity: true,
            }
        } else {
            let mut lines = vec![blst_fp6::default(); 68];
            unsafe { blst_precompute_lines(lines.as_mut_ptr(), &affine.0) }
            G2Prepared {
                lines,
                infinity: false,
            }
        }
    }
}

```

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

### PairingG2G1::new

Source: https://docs.rs/blstrs/0.7.1/blstrs/struct.PairingG2G1.html

Constructs a new PairingG2G1 instance. This method is used to initialize the pairing context with specific encoding or hashing preferences and a destination identifier.

```APIDOC
## PairingG2G1::new

### Description
Constructs a new PairingG2G1 instance. This method is used to initialize the pairing context with specific encoding or hashing preferences and a destination identifier.

### Signature
```rust
pub fn new(hash_or_encode: bool, dst: &[u8]) -> Self
```

### Parameters
- `hash_or_encode` (bool): A flag indicating whether to use hashing or encoding.
- `dst` (&[u8]): The destination byte slice.

### Returns
- `Self`: A new PairingG2G1 instance.
```

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

### G2Affine Identity and Generator

Source: https://docs.rs/blstrs/0.7.1/src/blstrs/g2.rs.html

Provides methods to get the identity element and the generator for G2Affine points.

```rust
fn identity() -> Self {
    G2Affine(blst_p2_affine::default())
}

fn generator() -> Self {
    G2Affine(unsafe { *blst_p2_affine_generator() })
}
```

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

### Fp12 Construction and Basic Operations

Source: https://docs.rs/blstrs/0.7.1/src/blstrs/fp12.rs.html

Provides methods for constructing Fp12 elements, accessing their components, and performing basic operations like conjugation.

```APIDOC
## Fp12::new

### Description
Constructs an element of `Fp12` from two `Fp6` elements.

### Signature
`pub const fn new(c0: Fp6, c1: Fp6) -> Fp12`

## Fp12::c0

### Description
Returns the first `Fp6` component of the `Fp12` element.

### Signature
`pub fn c0(&self) -> Fp6`

## Fp12::c1

### Description
Returns the second `Fp6` component of the `Fp12` element.

### Signature
`pub fn c1(&self) -> Fp6`

## Fp12::conjugate

### Description
Computes the conjugate of an `Fp12` element in-place.

### Signature
`pub fn conjugate(&mut self)`
```

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

### Get GPU Field Name for Fp

Source: https://docs.rs/blstrs/0.7.1/src/blstrs/fp.rs.html

Returns the name of the Fp field for GPU operations.

```rust
fn name() -> String {
        ec_gpu::name!()
    }
```

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

### Get Y Coordinate of G2Projective

Source: https://docs.rs/blstrs/0.7.1/blstrs/struct.G2Projective.html

Retrieves the y-coordinate of the G2Projective point. The coordinate is represented as an Fp2 element.

```rust
pub fn y(&self) -> Fp2
```

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

### G2 Operations

Source: https://docs.rs/blstrs/0.7.1/src/blstrs/lib.rs.html

Documentation for G2 affine, projective, and prepared points, including compression and uncompression.

```APIDOC
## G2 Affine, Projective, and Prepared Points

### Description
Provides types for representing points on the G2 curve in affine, projective, and prepared formats,
as well as compressed and uncompressed forms.

### Types
- `G2Affine`: Represents a point on the G2 curve in affine coordinates.
- `G2Projective`: Represents a point on the G2 curve in projective coordinates.
- `G2Prepared`: Represents a G2 point precomputed for efficient Miller loop calculations.
- `G2Compressed`: Represents a G2 point in compressed form.
- `G2Uncompressed`: Represents a G2 point in uncompressed form.

### Traits
- `Compress`: Implemented for G2 types to allow compression and uncompression.
```

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

### Get GPU Field Modulus

Source: https://docs.rs/blstrs/0.7.1/src/blstrs/fp.rs.html

Returns the modulus for the Fp field as a `Vec<u32>` for GPU operations.

```rust
fn modulus() -> Vec<u32> {
        crate::u64_to_u32(&MODULUS[..])
    }
```

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

### Fp6::new

Source: https://docs.rs/blstrs/0.7.1/src/blstrs/fp6.rs.html

Constructs a new Fp6 element from three Fp2 elements.

```APIDOC
## Fp6::new

### Description
Constructs a new Fp6 element from three Fp2 elements representing the coefficients c0, c1, and c2.

### Signature
```rust
pub const fn new(c0: Fp2, c1: Fp2, c2: Fp2) -> Fp6
```

### Parameters
* `c0` (Fp2) - The coefficient for the first term.
* `c1` (Fp2) - The coefficient for the second term.
* `c2` (Fp2) - The coefficient for the third term.

### Returns
An `Fp6` element.
```

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

### Clone G2Prepared Instance

Source: https://docs.rs/blstrs/0.7.1/blstrs/struct.G2Prepared.html

Returns a duplicate of the G2Prepared value. This allows for creating independent copies of the elliptic curve point.

```rust
fn clone(&self) -> G2Prepared
```

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

### Get Z Coordinate of G2Projective

Source: https://docs.rs/blstrs/0.7.1/blstrs/struct.G2Projective.html

Retrieves the z-coordinate of the G2Projective point. The coordinate is represented as an Fp2 element.

```rust
pub fn z(&self) -> Fp2
```

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

### Get X Coordinate of G2Projective

Source: https://docs.rs/blstrs/0.7.1/blstrs/struct.G2Projective.html

Retrieves the x-coordinate of the G2Projective point. The coordinate is represented as an Fp2 element.

```rust
pub fn x(&self) -> Fp2
```

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

### CloneToUninit Method

Source: https://docs.rs/blstrs/0.7.1/blstrs/struct.G2Uncompressed.html

Unsafe method for cloning data to an uninitialized memory location.

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

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

### Parameters
- `dest`: A raw pointer to the destination memory location.
```

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

### Get Compressed Size of G2Affine

Source: https://docs.rs/blstrs/0.7.1/src/blstrs/g2.rs.html

Returns the constant size in bytes required for a compressed representation of a G2Affine point.

```rust
pub const fn compressed_size() -> usize {
        COMPRESSED_SIZE
    }
```

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

### Conversion Methods

Source: https://docs.rs/blstrs/0.7.1/blstrs/struct.PairingG1G2.html

Provides methods for attempting conversions between types using `TryInto` and `TryFrom` traits.

```APIDOC
## Conversion Methods

### impl<T> TryConv for T

#### fn try_conv<T>(self) -> Result<T, Self::Error>
where Self: TryInto<T>,
Attempts to convert `self` into `T` using `TryInto<T>`.

### impl<T, U> TryFrom<U> for T
where U: Into<T>,

#### type Error = Infallible
The type returned in the event of a conversion error.

#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
Performs the conversion.

### impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

#### type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.

#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
Performs the conversion.
```

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

### Get Uncompressed Size of G2Affine

Source: https://docs.rs/blstrs/0.7.1/src/blstrs/g2.rs.html

Returns the constant size in bytes required for an uncompressed representation of a G2Affine point.

```rust
pub const fn uncompressed_size() -> usize {
        UNCOMPRESSED_SIZE
    }
```

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

### From<G2Affine> for G2Prepared

Source: https://docs.rs/blstrs/0.7.1/blstrs/struct.G2Prepared.html

Converts a G2Affine element into a G2Prepared element.

```APIDOC
## From<G2Affine> for G2Prepared

### Description
Converts a G2Affine element into a G2Prepared element, optimizing it for specific operations.

### Method
`from(affine: G2Affine) -> Self`

### Parameters
- `affine`: The G2Affine element to convert.

### Returns
- `Self`: The resulting G2Prepared element.
```

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

### Get GPU Field R2 Constant

Source: https://docs.rs/blstrs/0.7.1/src/blstrs/fp.rs.html

Returns the R2 constant for the Fp field as a `Vec<u32>` for GPU operations.

```rust
fn r2() -> Vec<u32> {
        crate::u64_to_u32(&R2.0.l[..])
    }
```

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

### G1 Projective Multi-Scalar Exponentiation

Source: https://docs.rs/blstrs/0.7.1/src/blstrs/g1.rs.html

Compares the results of a naive multi-scalar exponentiation implementation with the optimized `multi_exp` function for G1Projective points. This test ensures the correctness of the Pippenger algorithm implementation.

```rust
const SIZE: usize = 10;
let mut rng = XorShiftRng::from_seed([
    0x59, 0x62, 0xbe, 0x5d, 0x76, 0x3d, 0x31, 0x8d, 0x17, 0xdb, 0x37, 0x32, 0x54, 0x06,
    0xbc, 0xe5,
]);

let points: Vec<G1Projective> = (0..SIZE).map(|_| G1Projective::random(&mut rng)).collect();
let scalars: Vec<Scalar> = (0..SIZE).map(|_| Scalar::random(&mut rng)).collect();

let mut naive = points[0] * scalars[0];
for i in 1..SIZE {
    naive += points[i] * scalars[i];
}

let pippenger = G1Projective::multi_exp(points.as_slice(), scalars.as_slice());

assert_eq!(naive, pippenger);
```

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

### Get GPU Field One Constant

Source: https://docs.rs/blstrs/0.7.1/src/blstrs/fp.rs.html

Returns the 'one' constant for the Fp field as a `Vec<u32>` for GPU operations.

```rust
fn one() -> Vec<u32> {
        crate::u64_to_u32(&R.0.l[..])
    }
```

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

### into

Source: https://docs.rs/blstrs/0.7.1/blstrs/struct.G1Projective.html

Calls `U::from(self)`. This conversion is whatever the implementation of `From<T> for U` chooses to do.

```APIDOC
## into

### Description
Calls `U::from(self)`. That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

### Method
`into`

### Parameters
#### Path Parameters
- `self` - Description not available
```

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

### Fp Multiplication and Zero Check

Source: https://docs.rs/blstrs/0.7.1/src/blstrs/fp.rs.html

Demonstrates Fp multiplication and checks for zero elements. Ensure Fp is correctly initialized before use.

```rust
let mut a = Fp::from_u64s_le(&[
            0xd59fd94ee4572cfa,
            0x1f607186d5bb0059,
            0xb13955f5ac7f6a3,
        ])
        .unwrap();
        let b = Fp::from_u64s_le(&[
            0xf5f70713b717914c,
            0x355ea5ac64cbbab1,
            0xce60dd43417ec960,
            0xf16b9d77b0ad7d10,
            0xa44c204c1de7cdb7,
            0x1684487772bc9a5a,
        ])
        .unwrap();
        a.mul_assign(&b);
        assert_eq!(a, c);

        // Zero should be in the field.
        assert!(bool::from(Fp::from(0).is_zero()));
```

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

### Test Scalar Legendre Symbol

Source: https://docs.rs/blstrs/0.7.1/src/blstrs/scalar.rs.html

This test snippet appears incomplete. It starts by asserting the square roots of zero and one, similar to `test_sqrt`, but the subsequent code for checking the Legendre symbol is truncated.

```rust
    #[test]
    fn test_scalar_legendre() {
        assert_eq!(Scalar::ZERO.sqrt().unwrap(), Scalar::ZERO);
        assert_eq!(Scalar::ONE.sqrt().unwrap(), Scalar::ONE);

        let e = Scalar::from_u64s_le(&[
            0x0dbc5349cd5664da,

```

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

### clone_to_uninit

Source: https://docs.rs/blstrs/0.7.1/blstrs/struct.Scalar.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`. Read more

### Method
`clone_to_uninit`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
None
```

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

### PairingG1G2::new

Source: https://docs.rs/blstrs/0.7.1/blstrs/struct.PairingG1G2.html

Constructs a new PairingG1G2 context. This method is used to initialize the pairing context with specific settings for hashing or encoding and a destination.

```APIDOC
## PairingG1G2::new

### Description
Constructs a new PairingG1G2 context. This method is used to initialize the pairing context with specific settings for hashing or encoding and a destination.

### Signature
```rust
pub fn new(hash_or_encode: bool, dst: &[u8]) -> Self
```

### Parameters
* `hash_or_encode` (bool): A flag indicating whether to use hashing or encoding.
* `dst` (&[u8]): The destination byte slice.

### Returns
A new `PairingG1G2` instance.
```

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

### CloneToUninit Method

Source: https://docs.rs/blstrs/0.7.1/blstrs/struct.G1Uncompressed.html

Provides an unsafe method for cloning the struct into uninitialized memory.

```APIDOC
## clone_to_uninit

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

### Safety
This method is unsafe and requires `unsafe` block. The caller must ensure that `dest` is valid for writes and points to enough space to hold the value.

### Parameters
- **dest**: A raw pointer to the destination memory location.
```

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

### Initialize PairingG1G2 Instance

Source: https://docs.rs/blstrs/0.7.1/blstrs/struct.PairingG1G2.html

Initializes or re-initializes an existing PairingG1G2 instance with the specified encoding method and destination.

```rust
pub fn init(&mut self, hash_or_encode: bool, dst: &[u8])
```

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

### Initialize PairingG2G1 Context

Source: https://docs.rs/blstrs/0.7.1/blstrs/struct.PairingG2G1.html

Initializes a PairingG2G1 context for aggregate pairings. This can be done either by hashing or encoding, and requires a destination slice for data.

```rust
pub fn new(hash_or_encode: bool, dst: &[u8]) -> Self
```

```rust
pub fn init(&mut self, hash_or_encode: bool, dst: &[u8])
```

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

### G2Affine Methods

Source: https://docs.rs/blstrs/0.7.1/blstrs/struct.G2Affine.html

Provides documentation for various methods available on the G2Affine type.

```APIDOC
## as_ref

### Description
Converts this type into a shared reference of the (usually inferred) input type.

### Signature
`fn as_ref(&self) -> &blst_p2_affine`
```

```APIDOC
## clone

### Description
Returns a duplicate of the value.

### Signature
`fn clone(&self) -> G2Affine`
```

```APIDOC
## clone_from

### Description
Performs copy-assignment from `source`.

### Signature
`fn clone_from(&mut self, source: &Self)`
```

```APIDOC
## conditional_select

### Description
Select `a` or `b` according to `choice`.

### Signature
`fn conditional_select(a: &Self, b: &Self, choice: Choice) -> Self`
```

```APIDOC
## conditional_assign

### Description
Conditionally assign `other` to `self`, according to `choice`.

### Signature
`fn conditional_assign(&mut self, other: &Self, choice: Choice)`
```

```APIDOC
## conditional_swap

### Description
Conditionally swap `self` and `other` if `choice == 1`; otherwise, reassign both unto themselves.

### Signature
`fn conditional_swap(a: &mut Self, b: &mut Self, choice: Choice)`
```

```APIDOC
## fmt (Debug)

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

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

```APIDOC
## default

### Description
Returns the “default value” for a type.

### Signature
`fn default() -> G2Affine`
```

```APIDOC
## deserialize

### Description
Deserialize this value from the given Serde deserializer.

### Signature
`fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error>`
```

```APIDOC
## fmt (Display)

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

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

```APIDOC
## from (G2Affine to G2Projective)

### Description
Converts to this type from the input type.

### Signature
`fn from(p: &G2Affine) -> G2Projective`
```

```APIDOC
## from (G2Projective to G2Affine)

### Description
Converts to this type from the input type.

### Signature
`fn from(p: &G2Projective) -> G2Affine`
```

```APIDOC
## from (G2Affine to G2Prepared)

### Description
Converts to this type from the input type.

### Signature
`fn from(affine: G2Affine) -> Self`
```

```APIDOC
## from (G2Affine to G2Projective - owned)

### Description
Converts to this type from the input type.

### Signature
`fn from(p: G2Affine) -> G2Projective`
```

```APIDOC
## from (G2Projective to G2Affine - owned)

### Description
Converts to this type from the input type.

### Signature
`fn from(p: G2Projective) -> G2Affine`
```

```APIDOC
## from_bytes

### Description
Attempts to deserialize a group element from its encoding.

### Signature
`fn from_bytes(bytes: &Self::Repr) -> CtOption<Self>`
```

```APIDOC
## from_bytes_unchecked

### Description
Attempts to deserialize a group element, not checking if the element is valid.

### Signature
`fn from_bytes_unchecked(bytes: &Self::Repr) -> CtOption<Self>`
```

```APIDOC
## to_bytes

### Description
Converts this element into its byte encoding. This may or may not support encoding the identity.

### Signature
`fn to_bytes(&self) -> Self::Repr`
```

```APIDOC
## mul (G2Affine * &Scalar)

### Description
Performs the `*` operation.

### Signature
`fn mul(self, scalar: &Scalar) -> Self::Output`
```

```APIDOC
## mul (G2Affine * &Scalar - owned)

### Description
Performs the `*` operation.

### Signature
`fn mul(self, rhs: &Scalar) -> G2Projective`
```

```APIDOC
## mul (&G2Affine * Scalar)

### Description
Performs the `*` operation.

### Signature
`fn mul(self, rhs: Scalar) -> G2Projective`
```

```APIDOC
## mul (G2Affine * Scalar)

### Description
Performs the `*` operation.

### Signature
`fn mul(self, rhs: Scalar) -> G2Projective`
```

```APIDOC
## mul_assign

### Description
Performs the `*=` operation.

### Signature
`fn mul_assign(&mut self, rhs: &Scalar)`
```

```APIDOC
## neg (&G2Affine)

### Description
Performs the unary `-` operation.

### Signature
`fn neg(self) -> G2Affine`
```

```APIDOC
## neg (G2Affine)

### Description
Performs the unary `-` operation.

### Signature
`fn neg(self) -> G2Affine`
```

```APIDOC
## pairing_with

### Description
Perform a pairing.

### Signature
`fn pairing_with(&self, other: &Self::Pair) -> Self::PairingResult`
```

```APIDOC
## eq

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

### Signature
`fn eq(&self, other: &Self) -> bool`
```

```APIDOC
## ne

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

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

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

### G2Prepared

Source: https://docs.rs/blstrs/0.7.1/src/blstrs/g2.rs.html

Precomputed data for G2 points to optimize Miller's algorithm in pairings.

```APIDOC
## G2Prepared

Precomputed data for G2 points used in pairings.

### Methods

- `is_identity()`: Checks if the prepared point represents the identity element.

### Conversions

- `From<G2Affine>`: Can be created from a `G2Affine` point.
```

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

### Equality and Inequality Checks

Source: https://docs.rs/blstrs/0.7.1/blstrs/struct.G1Projective.html

Provides information on checking for equality and inequality between G1Projective instances.

```APIDOC
## Equality and Inequality Checks

### `impl PartialEq for G1Projective`
Tests for equality (`==`) and inequality (`!=`) between G1Projective values.
```

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

### Multi-Exponentiation (MSM) for G1Projective Points

Source: https://docs.rs/blstrs/0.7.1/blstrs/struct.G1Projective.html

Performs a multi-scalar-multiplication (MSM) operation on a slice of G1Projective points and scalars using Pippenger's algorithm. Note that the scalars are cloned internally.

```rust
pub fn multi_exp(points: &[Self], scalars: &[Scalar]) -> Self
```

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

### Cloning and Copying

Source: https://docs.rs/blstrs/0.7.1/blstrs/struct.G1Projective.html

Methods for creating copies and performing copy-assignment.

```APIDOC
## fn clone(&self) -> G1Projective

Returns a duplicate of the value.

### Method
`clone`

### Returns
- G1Projective - A cloned G1Projective element.
```

```APIDOC
## fn clone_from(&mut self, source: &Self)

Performs copy-assignment from `source`.

### Method
`clone_from`

### Parameters
- **source** (&Self) - The source element to copy from.
```

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

### Fp2 Addition in Rust

Source: https://docs.rs/blstrs/0.7.1/src/blstrs/fp2.rs.html

Demonstrates adding two Fp2 numbers. Ensure Fp and Fp2 types are correctly initialized before use.

```rust
fn test_fp2_addition() {
        let mut a = Fp2::new(
            Fp::from_u64s_le(&[
                0x2d0078036923ffc7,
                0x11e59ea221a3b6d2,
                0x8b1a52e0a90f59ed,
                0xb966ce3bc2108b13,
                0xccc649c4b9532bf3,
                0xf8d295b2ded9dc,
            ])
            .unwrap(),
            Fp::from_u64s_le(&[
                0x977df6efcdaee0db,
                0x946ae52d684fa7ed,
                0xbe203411c66fb3a5,
                0xb3f8afc0ee248cad,
                0x4e464dea5bcfd41e,
                0x12d1137b8a6a837,
            ])
            .unwrap(),
        );
        a += &Fp2::new(
            Fp::from_u64s_le(&[
                0x619a02d78dc70ef2,
                0xb93adfc9119e33e8,
                0x4bf0b99a9f0dca12,
                0x3b88899a42a6318f,
                0x986a4a62fa82a49d,
                0x13ce433fa26027f5,
            ])
            .unwrap(),
            Fp::from_u64s_le(&[
                0x66323bf80b58b9b9,
                0xa1379b6facf6e596,
                0x402aef1fb797e32f,
                0x2236f55246d0d44d,
                0x4c8c1800eb104566,
                0x11d6e20e986c2085,
            ])
            .unwrap(),
        );
        assert_eq!(
            a,
            Fp2::new(
                Fp::from_u64s_le(&[
                    0x8e9a7adaf6eb0eb9,
                    0xcb207e6b3341eaba,
                    0xd70b0c7b481d23ff,
                    0xf4ef57d604b6bca2,
                    0x65309427b3d5d090,
                    0x14c715d5553f01d2
                ])
                .unwrap(),
                Fp::from_u64s_le(&[
                    0xfdb032e7d9079a94,
                    0x35a2809d15468d83,
                    0xfe4b23317e0796d5,
                    0xd62fa51334f560fa,
                    0x9ad265eb46e01984,
                    0x1303f3465112c8bc
                ])
                .unwrap(),
            )
        );
    }
```

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

### tap_borrow_dbg

Source: https://docs.rs/blstrs/0.7.1/blstrs/struct.G2Compressed.html

Calls `.tap_borrow()` only in debug builds, and is erased in release builds.

```APIDOC
## fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,
Calls `.tap_borrow()` only in debug builds, and is erased in release builds.
Source§
```

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

### tap_borrow_dbg

Source: https://docs.rs/blstrs/0.7.1/blstrs/struct.G1Compressed.html

Calls `.tap_borrow()` only in debug builds, and is erased in release builds.

```APIDOC
## fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,
Calls `.tap_borrow()` only in debug builds, and is erased in release builds. Read more
```

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

### G2Affine Formatting

Source: https://docs.rs/blstrs/0.7.1/src/blstrs/g2.rs.html

Provides `Debug` and `Display` implementations for `G2Affine` for easy inspection and logging.

```APIDOC
## G2Affine Formatting

### Description
Implements `fmt::Debug` and `fmt::Display` for `G2Affine` to provide human-readable representations.

### `fmt::Debug`
Formats the `G2Affine` element showing its x and y coordinates and whether it represents the point at infinity.

### `fmt::Display`
Formats the `G2Affine` element as `G2Affine(Infinity)` if it's the identity, or `G2Affine(x=<x_coord>, y=<y_coord>)` otherwise.
```

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

### Pipe G2Prepared via AsRef

Source: https://docs.rs/blstrs/0.7.1/blstrs/struct.G2Prepared.html

Borrows the G2Prepared value into a reference `U` using `AsRef` and passes that reference into a closure. Useful for accessing underlying data structures.

```rust
fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
where Self: AsRef<U>, U: 'a + ?Sized, R: 'a
```

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

### Test Fp From/Into Representation

Source: https://docs.rs/blstrs/0.7.1/src/blstrs/fp.rs.html

Checks conversion from byte representations and verifies that `q + 1` is not in the field.

```rust
// q + 1 should not be in the field
        assert!(bool::from(
            Fp::from_u64s_le(&[
                0xb9feffffffffaaac,
                0x1eabfffeb153ffff,
                0x6730d2a0f6b0f624,
                0x64774b84f38512bf,
                0x4b1ba7b6434bacd7,
                0x1a0111ea397fe69a
            ])
            .is_none()
        ));

        // Multiply some arbitrary representations to see if the result is as expected.
        let mut a = Fp::from_u64s_le(&[
            0x4a49dad4ff6cde2d,
            0xac62a82a8f51cd50,
            0x2b1f41ab9f36d640,
            0x908a387f480735f1,
            0xae30740c08a875d7,
            0x6c80918a365ef78,
        ])
        .unwrap();
        let b = Fp::from_u64s_le(&[
            0xbba57917c32f0cf0,
            0xe7f878cf87f05e5d,
            0x9498b4292fd27459,

```

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

### Any for T

Source: https://docs.rs/blstrs/0.7.1/blstrs/struct.G2Projective.html

Provides runtime type information for any type T.

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

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

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

### Format G2Prepared as a List

Source: https://docs.rs/blstrs/0.7.1/blstrs/struct.G2Prepared.html

Formats each item in a sequence represented by G2Prepared. Requires the type to be convertible into an iterator.

```rust
fn fmt_list(self) -> FmtList<Self>
where &'a Self: for<'a> IntoIterator
```

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

### Serialization and Deserialization

Source: https://docs.rs/blstrs/0.7.1/blstrs/struct.G2Projective.html

Methods for converting G2Projective elements to and from compressed and uncompressed byte formats.

```APIDOC
## G2Projective Serialization and Deserialization

### `to_compressed()`

Serializes this element into compressed form.

#### Returns
- `[u8; 96]`: The compressed byte representation of the G2Projective element.

### `to_uncompressed()`

Serializes this element into uncompressed form.

#### Returns
- `[u8; 192]`: The uncompressed byte representation of the G2Projective element.

### `from_uncompressed(bytes: &[u8; 192]) -> CtOption<Self>`

Attempts to deserialize an uncompressed element.

#### Parameters
- `bytes` (`&[u8; 192]`): The uncompressed byte slice to deserialize.

#### Returns
- `CtOption<Self>`: A `CtOption` containing the deserialized `G2Projective` element if successful, otherwise `None`.

### `from_uncompressed_unchecked(bytes: &[u8; 192]) -> CtOption<Self>`

Attempts to deserialize an uncompressed element without checking if the element is on the curve or in the correct subgroup. **This is dangerous to call unless you trust the bytes you are reading; otherwise, API invariants may be broken.** Please consider using `from_uncompressed()` instead.

#### Parameters
- `bytes` (`&[u8; 192]`): The uncompressed byte slice to deserialize.

#### Returns
- `CtOption<Self>`: A `CtOption` containing the deserialized `G2Projective` element if successful, otherwise `None`.

### `from_compressed(bytes: &[u8; 96]) -> CtOption<Self>`

Attempts to deserialize a compressed element.

#### Parameters
- `bytes` (`&[u8; 96]`): The compressed byte slice to deserialize.

#### Returns
- `CtOption<Self>`: A `CtOption` containing the deserialized `G2Projective` element if successful, otherwise `None`.

### `from_compressed_unchecked(bytes: &[u8; 96]) -> CtOption<Self>`

Attempts to deserialize an uncompressed element, not checking if the element is in the correct subgroup. **This is dangerous to call unless you trust the bytes you are reading; otherwise, API invariants may be broken.** Please consider using `from_compressed()` instead.

#### Parameters
- `bytes` (`&[u8; 96]`): The compressed byte slice to deserialize.

#### Returns
- `CtOption<Self>`: A `CtOption` containing the deserialized `G2Projective` element if successful, otherwise `None`.
```

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

### Implement Add/Sub for Types

Source: https://docs.rs/blstrs/0.7.1/src/blstrs/macros.rs.html

Generates implementations for Add and Sub traits for various reference and owned types. Requires manual implementation of the core Add/Sub operations.

```rust
macro_rules! impl_add_sub {
    ($t:ident) => {
        impl_add_sub!($t, $t, $t);
    };
    ($lhs:ident, $rhs:ident) => {
        impl_add_sub!($lhs, $rhs, $lhs);
    };
    ($lhs:ident, $rhs:ident, $output:ident) => {
        impl Add<&$rhs> for $lhs {
            type Output = $output;

            #[inline]
            fn add(self, rhs: &$rhs) -> $output {
                &self + rhs
            }
        }

        impl Add<$rhs> for &$lhs {
            type Output = $output;

            #[inline]
            fn add(self, rhs: $rhs) -> $output {
                self + &rhs
            }
        }

        impl Add<$rhs> for $lhs {
            type Output = $output;

            #[inline]
            fn add(self, rhs: $rhs) -> $output {
                &self + &rhs
            }
        }

        impl Sub<&$rhs> for $lhs {
            type Output = $output;

            #[inline]
            fn sub(self, rhs: &$rhs) -> $output {
                &self - rhs
            }
        }

        impl Sub<$rhs> for &$lhs {
            type Output = $output;

            #[inline]
            fn sub(self, rhs: $rhs) -> $output {
                self - &rhs
            }
        }

        impl Sub<$rhs> for $lhs {
            type Output = $output;

            #[inline]
            fn sub(self, rhs: $rhs) -> $output {
                &self - &rhs
            }
        }
    };
}
```
Tokens:
Raw