Struct G1Affine

pub struct G1Affine(/* private fields */);

G1Affine is a point in the G1 group (subgroup defined over the base field Fq) of the BLS12-381 elliptic curve

Serialization:

• The 96 bytes represent the uncompressed encoding of a point in G1. The Bytes consist of be_byte(X) || be_byte(Y) (|| is concatenation), where ‘X’ and ‘Y’ are the two coordinates, each being a base field element Fp
• The most significant three bits (bits 0-3) of the first byte are reserved for encoding flags:
  • compression_flag (bit 0): Must always be set (1), as only uncompressed points are supported.
  • infinity_flag (bit 1): Set if the point is the point at infinity (zero point), in which case all other bits must be zero.
  • sort_flag (bit 2): Must always be unset (0).

Example Usage:

use soroban_sdk::{Env, bytesn, crypto::bls12_381::{Bls12_381, G1Affine}};
let env = Env::default();
let bls12_381 = env.crypto().bls12_381();
let zero = G1Affine::from_bytes(bytesn!(&env, 0x400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000));
let one = G1Affine::from_bytes(bytesn!(&env, 0x17f1d3a73197d7942695638c4fa9ac0fc3688c4f9774b905a14e3a3f171bac586c55e83ff97a1aeffb3af00adb22c6bb08b3f481e3aaa0f1a09e30ed741d8ae4fcf5e095d5d00af600db18cb2c04b3edd03cc744a2888ae40caa232946c5e7e1));
let res = bls12_381.g1_add(&zero, &one);
assert_eq!(res, one);

Implementations

impl G1Affine

pub fn from_bytes(bytes: BytesN<96>) -> Self

pub fn to_bytes(&self) -> BytesN<96>

pub fn as_bytes(&self) -> &BytesN<96>

pub fn to_array(&self) -> [u8; 96]

pub fn from_array(env: &Env, array: &[u8; 96]) -> Self

pub fn as_val(&self) -> &Val

pub fn to_val(&self) -> Val

pub fn as_object(&self) -> &BytesObject

pub fn to_object(&self) -> BytesObject

impl G1Affine

pub fn env(&self) -> &Env

pub fn is_in_subgroup(&self) -> bool

pub fn checked_add(&self, rhs: &Self) -> Option<Self>

Trait Implementations

impl Add for G1Affine

type Output = G1Affine

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl Clone for G1Affine

fn clone(&self) -> G1Affine

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for G1Affine

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

Formats the value using the given formatter.

impl From<G1Affine> for Bytes

fn from(v: G1Affine) -> Self

Converts to this type from the input type.

impl From<G1Affine> for BytesN<96>

fn from(v: G1Affine) -> Self

Converts to this type from the input type.

impl Into<[u8; 96]> for G1Affine

fn into(self) -> [u8; 96]

Converts this type into the (usually inferred) input type.

impl IntoVal<Env, BytesN<96>> for G1Affine

fn into_val(&self, _e: &Env) -> BytesN<96>

impl IntoVal<Env, Val> for G1Affine

fn into_val(&self, e: &Env) -> Val

impl Mul<Fr> for G1Affine

type Output = G1Affine

The resulting type after applying the * operator.

fn mul(self, rhs: Fr) -> Self::Output

Performs the * operation.

impl PartialEq for G1Affine

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 !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl TryFromVal<Env, Val> for G1Affine

type Error = ConversionError

fn try_from_val(env: &Env, val: &Val) -> Result<Self, Self::Error>

impl Eq for G1Affine