# package octez-libs

`include module type of struct include Bls12_381.G1 end`

Elliptic curve built over the field `Fq`

and the equation `y^2 = x^3 + 4`

`include Bls12_381.CURVE`

`exception Not_on_curve of Bytes.t`

`type t = Bls12_381.G1.t`

The type of the element on the curve and in the prime subgroup. The point is given in jacobian coordinates

`type affine = Bls12_381.G1.affine`

An element on the curve and in the prime subgroup, in affine coordinates

`affine_of_jacobian p`

creates a new value of type `affine`

representing the point `p`

in affine coordinates

`jacobian_of_affine p`

creates a new value of type `t`

representing the point `p`

in jacobian coordinates

`type affine_array = Bls12_381.G1.affine_array`

Contiguous C array containing points in affine coordinates

`val to_affine_array : t array -> affine_array`

`to_affine_array pts`

builds a contiguous C array and populate it with the points `pts`

in affine coordinates. Use it with `pippenger_with_affine_array`

to get better performance.

`val of_affine_array : affine_array -> t array`

Build a OCaml array of `t`

values from the contiguous C array

`val size_of_affine_array : affine_array -> int`

Return the number of elements in the array

`module Scalar = Bls12_381.G1.Scalar`

`val check_bytes : Bytes.t -> bool`

Check if a point, represented as a byte array, is on the curve and in the prime subgroup. The bytes must be of length `size_in_bytes`

.

Attempt to construct a point from a byte array of length `size_in_bytes`

. Return `None`

if the bytes do not represent a point on the curve and in the prime subgroup.

Attempt to construct a point from a byte array of length `size_in_bytes`

. Raise `Not_on_curve`

if the point is not on the curve and in the prime subgroup.

Allocates a new point from a byte of length `size_in_bytes / 2`

array representing a point in compressed form. Return `None`

if the bytes do not represent a point on the curve and in the prime subgroup.

Allocates a new point from a byte array of length `size_in_bytes / 2`

representing a point in compressed form. Raise `Not_on_curve`

if the point is not on the curve and in the prime subgroup.

`val zero : t`

Zero of the elliptic curve

`val one : t`

A fixed generator of the elliptic curve

`val is_zero : t -> bool`

Return `true`

if the given element is zero

`val random : ?state:Random.State.t -> unit -> t`

Generate a random element. The function ensures the element is on the curve and in the prime subgroup.

The routines in the module `Random.State`

are used to generate the elements. A state can be given to the function to be used. If no state is given, `Random.get_state`

is used.

To create a value of type `Random.State.t`

, you can use ```
Random.State.make
[|42|]
```

.

`add_inplace a b`

is the same than `add`

but writes the output in `a`

. No allocation happens.

`add_bulk xs`

returns the sum of the elements of `xs`

by performing only one allocation for the output. This method is recommended to save the allocation overhead of using `n`

times `add`

.

`mul_inplace g x`

is the same than `mul`

but writes the output in `g`

. No allocation happens.

`hash_to_curve msg dst`

follows the standard Hashing to Elliptic Curves applied to BLS12-381

`pippenger ?start ?len pts scalars`

computes the multi scalar exponentiation/multiplication. The scalars are given in `scalars`

and the points in `pts`

. If `pts`

and `scalars`

are not of the same length, perform the computation on the first `n`

points where `n`

is the smallest size. Arguments `start`

and `len`

can be used to take advantages of multicore OCaml. Default value for `start`

(resp. `len`

) is `0`

(resp. the length of the array `scalars`

).

```
val pippenger_with_affine_array :
?start:int ->
?len:int ->
affine_array ->
Scalar.t array ->
t
```

`pippenger_with_affine_array ?start ?len pts scalars`

computes the multi scalar exponentiation/multiplication. The scalars are given in `scalars`

and the points in `pts`

. If `pts`

and `scalars`

are not of the same length, perform the computation on the first `n`

points where `n`

is the smallest length. The differences with `pippenger`

are 1. the points are loaded in a contiguous C array to speed up the access to the elements by relying on the CPU cache 2. and the points are in affine coordinates, the form expected by the algorithm implementation, avoiding new allocations and field inversions required to convert from jacobian (representation of a points of type `t`

, as expected by `pippenger`

) to affine coordinates. Expect a speed improvement around 20% compared to `pippenger`

, and less allocation on the C heap. A value of `affine_array`

can be built using `to_affine_array`

. Arguments `start`

and `len`

can be used to take advantages of multicore OCaml. Default value for `start`

(resp. `len`

) is `0`

(resp. the length of the array `scalars`

).

`val encoding : t Data_encoding.encoding`