Struct PlonkProofSol

pub struct PlonkProofSol {

    pub wire0: <G1Point as SolType>::RustType,
    pub wire1: <G1Point as SolType>::RustType,
    pub wire2: <G1Point as SolType>::RustType,
    pub wire3: <G1Point as SolType>::RustType,
    pub wire4: <G1Point as SolType>::RustType,
    pub prodPerm: <G1Point as SolType>::RustType,
    pub split0: <G1Point as SolType>::RustType,
    pub split1: <G1Point as SolType>::RustType,
    pub split2: <G1Point as SolType>::RustType,
    pub split3: <G1Point as SolType>::RustType,
    pub split4: <G1Point as SolType>::RustType,
    pub zeta: <G1Point as SolType>::RustType,
    pub zetaOmega: <G1Point as SolType>::RustType,
    pub wireEval0: <ScalarField as SolType>::RustType,
    pub wireEval1: <ScalarField as SolType>::RustType,
    pub wireEval2: <ScalarField as SolType>::RustType,
    pub wireEval3: <ScalarField as SolType>::RustType,
    pub wireEval4: <ScalarField as SolType>::RustType,
    pub sigmaEval0: <ScalarField as SolType>::RustType,
    pub sigmaEval1: <ScalarField as SolType>::RustType,
    pub sigmaEval2: <ScalarField as SolType>::RustType,
    pub sigmaEval3: <ScalarField as SolType>::RustType,
    pub prodPermZetaOmegaEval: <ScalarField as SolType>::RustType,
}

What to re-export, what to hide?

• export contract struct itself, but try to avoid export instance type (instead, use ::new() to get a handle)
• avoid exporting xxCall and xxReturn types, they usually can be converted/transmuted from existing struct
• Event types should be exported
• structs should be exported and renamed with xxSol suffix to avoid confusion with other rust types
  • see module doc for more explanation on types duplication issue in alloy

    struct PlonkProof { BN254.G1Point wire0; BN254.G1Point wire1; BN254.G1Point wire2; BN254.G1Point wire3; BN254.G1Point wire4; BN254.G1Point prodPerm; BN254.G1Point split0; BN254.G1Point split1; BN254.G1Point split2; BN254.G1Point split3; BN254.G1Point split4; BN254.G1Point zeta; BN254.G1Point zetaOmega; BN254.ScalarField wireEval0; BN254.ScalarField wireEval1; BN254.ScalarField wireEval2; BN254.ScalarField wireEval3; BN254.ScalarField wireEval4; BN254.ScalarField sigmaEval0; BN254.ScalarField sigmaEval1; BN254.ScalarField sigmaEval2; BN254.ScalarField sigmaEval3; BN254.ScalarField prodPermZetaOmegaEval; }
    ```

Fields

wire0: <G1Point as SolType>::RustType

wire1: <G1Point as SolType>::RustType

wire2: <G1Point as SolType>::RustType

wire3: <G1Point as SolType>::RustType

wire4: <G1Point as SolType>::RustType

prodPerm: <G1Point as SolType>::RustType

split0: <G1Point as SolType>::RustType

split1: <G1Point as SolType>::RustType

split2: <G1Point as SolType>::RustType

split3: <G1Point as SolType>::RustType

split4: <G1Point as SolType>::RustType

zeta: <G1Point as SolType>::RustType

zetaOmega: <G1Point as SolType>::RustType

wireEval0: <ScalarField as SolType>::RustType

wireEval1: <ScalarField as SolType>::RustType

wireEval2: <ScalarField as SolType>::RustType

wireEval3: <ScalarField as SolType>::RustType

wireEval4: <ScalarField as SolType>::RustType

sigmaEval0: <ScalarField as SolType>::RustType

sigmaEval1: <ScalarField as SolType>::RustType

sigmaEval2: <ScalarField as SolType>::RustType

sigmaEval3: <ScalarField as SolType>::RustType

prodPermZetaOmegaEval: <ScalarField as SolType>::RustType

Implementations

impl PlonkProofSol

pub fn dummy_with_rand_proof_evals<R: Rng>(rng: &mut R) -> Self

return a dummy proof instance with random ProofEvaluations fields.

pub fn dummy<R: Rng>(rng: &mut R) -> Self

return a dummy proof instance with all random fields

Trait Implementations

impl Clone for PlonkProof

fn clone(&self) -> PlonkProof

Returns a copy of the value.

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

Performs copy-assignment from source.

impl EventTopic for PlonkProof

fn topic_preimage_length(rust: &Self::RustType) -> usize

The number of bytes this type occupies in another topic’s preimage, usually a multiple of 32.

fn encode_topic_preimage(rust: &Self::RustType, out: &mut Vec<u8>)

Encodes this type as preimage bytes which are then hashed in complex types’ [encode_topic][EventTopic::encode_topic].

fn encode_topic(rust: &Self::RustType) -> WordToken

Indexed event parameter encoding.

impl From<PlonkProof> for PlonkProof

fn from(v: PlonkProofSol) -> Self

Converts to this type from the input type.

impl From<PlonkProof> for PlonkProof

fn from(v: PlonkProofSol) -> Self

Converts to this type from the input type.

impl From<PlonkProof> for Proof<Bn254>

fn from(proof: PlonkProofSol) -> Self

Converts to this type from the input type.

impl From<Proof<Bn<Config>>> for PlonkProofSol

fn from(proof: Proof<Bn254>) -> Self

Converts to this type from the input type.

impl SolStruct for PlonkProof

const NAME: &'static str = "PlonkProof"

The struct name.

fn eip712_root_type() -> Cow<'static, str>

Return the root EIP-712 type. This type is used to construct the encodeType string.

fn eip712_components() -> Vec<Cow<'static, str>>

Returns component EIP-712 types. These types are used to construct the encodeType string. These are the types of the struct’s fields, and should not include the root type.

fn eip712_encode_data(&self) -> Vec<u8>

Encodes this domain using EIP-712 encodeData.

fn eip712_encode_type() -> Cow<'static, str>

The EIP-712-encoded type string.

fn eip712_type_hash(&self) -> FixedBytes<32>

Calculates the EIP-712 typeHash for this struct.

fn eip712_hash_struct(&self) -> FixedBytes<32>

Hashes this struct according to EIP-712 hashStruct.

fn eip712_signing_hash(&self, domain: &Eip712Domain) -> FixedBytes<32>

Does something.

impl SolType for PlonkProof

const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME

The name of this type in Solidity.

const ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple as alloy_sol_types::SolType>::ENCODED_SIZE

The statically-known ABI-encoded size of the type.

const PACKED_ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE

The statically-known Non-standard Packed Mode ABI-encoded size of the type.

type RustType = PlonkProof

The corresponding Rust type.

type Token<'a> = <(G1Point, G1Point, G1Point, G1Point, G1Point, G1Point, G1Point, G1Point, G1Point, G1Point, G1Point, G1Point, G1Point, ScalarField, ScalarField, ScalarField, ScalarField, ScalarField, ScalarField, ScalarField, ScalarField, ScalarField, ScalarField) as SolType>::Token<'a>

The corresponding ABI token type.

fn valid_token(token: &Self::Token<'_>) -> bool

Returns true if the given token can be detokenized with this type.

fn detokenize(token: Self::Token<'_>) -> Self::RustType

Detokenize this type’s value from the given token.

const DYNAMIC: bool = _

Whether the ABI-encoded size is dynamic.

fn sol_type_name() -> Cow<'static, str>

👎Deprecated since 0.6.3: use SOL_NAME instead

Returns the name of this type in Solidity.

fn abi_encoded_size<E>(rust: &E) -> usize

where E: SolTypeValue<Self> + ?Sized,

Calculate the ABI-encoded size of the data, counting both head and tail words. For a single-word type this will always be 32.

fn type_check(token: &Self::Token<'_>) -> Result<(), Error>

Returns an error if the given token cannot be detokenized with this type.

fn tokenize<E>(rust: &E) -> Self::Token<'_>

where E: SolTypeValue<Self> + ?Sized,

Tokenizes the given value into this type’s token.

fn eip712_data_word<E>(rust: &E) -> FixedBytes<32>

where E: SolTypeValue<Self> + ?Sized,

Encode this data according to EIP-712 encodeData rules, and hash it if necessary.

fn abi_packed_encoded_size<E>(rust: &E) -> usize

where E: SolTypeValue<Self> + ?Sized,

Returns the length of this value when ABI-encoded in Non-standard Packed Mode.

fn abi_encode_packed_to<E>(rust: &E, out: &mut Vec<u8>)

where E: SolTypeValue<Self> + ?Sized,

Non-standard Packed Mode ABI encoding.

fn abi_encode_packed<E>(rust: &E) -> Vec<u8>

where E: SolTypeValue<Self> + ?Sized,

Non-standard Packed Mode ABI encoding.

fn abi_encode<E>(rust: &E) -> Vec<u8>

where E: SolTypeValue<Self> + ?Sized,

Tokenizes and ABI-encodes the given value by wrapping it in a single-element sequence.

fn abi_encode_params<E>(rust: &E) -> Vec<u8>

where E: SolTypeValue<Self> + ?Sized, Self::Token<'a>: for<'a> TokenSeq<'a>,

Tokenizes and ABI-encodes the given value as function parameters.

fn abi_encode_sequence<E>(rust: &E) -> Vec<u8>

where E: SolTypeValue<Self> + ?Sized, Self::Token<'a>: for<'a> TokenSeq<'a>,

Tokenizes and ABI-encodes the given value as a sequence.

fn abi_decode(data: &[u8], validate: bool) -> Result<Self::RustType, Error>

Decodes this type’s value from an ABI blob by interpreting it as a single-element sequence.

fn abi_decode_params<'de>( data: &'de [u8], validate: bool, ) -> Result<Self::RustType, Error>

where Self::Token<'de>: TokenSeq<'de>,

Decodes this type’s value from an ABI blob by interpreting it as function parameters.

fn abi_decode_sequence<'de>( data: &'de [u8], validate: bool, ) -> Result<Self::RustType, Error>

where Self::Token<'de>: TokenSeq<'de>,

Decodes this type’s value from an ABI blob by interpreting it as a sequence.

impl SolTypeValue<PlonkProof> for PlonkProof

fn stv_to_tokens(&self) -> <Self as SolType>::Token<'_>

fn stv_abi_encoded_size(&self) -> usize

fn stv_eip712_data_word(&self) -> Word

fn stv_abi_encode_packed_to(&self, out: &mut Vec<u8>)

fn stv_abi_packed_encoded_size(&self) -> usize

impl SolValue for PlonkProof

type SolType = PlonkProof

The Solidity type that this type corresponds to.

fn sol_name(&self) -> &'static str

The name of the associated Solidity type.

fn sol_type_name(&self) -> Cow<'static, str>

👎Deprecated since 0.6.3: use sol_name instead

The name of the associated Solidity type.

fn tokenize(&self) -> <Self::SolType as SolType>::Token<'_>

Tokenizes the given value into this type’s token.

fn detokenize(token: <Self::SolType as SolType>::Token<'_>) -> Self

where Self: From<<Self::SolType as SolType>::RustType>,

Detokenize a value from the given token.

fn abi_encoded_size(&self) -> usize

Calculate the ABI-encoded size of the data.

fn eip712_data_word(&self) -> FixedBytes<32>

Encode this data according to EIP-712 encodeData rules, and hash it if necessary.

fn abi_encode_packed_to(&self, out: &mut Vec<u8>)

Non-standard Packed Mode ABI encoding.

fn abi_encode_packed(&self) -> Vec<u8>

Non-standard Packed Mode ABI encoding.

fn abi_encode(&self) -> Vec<u8>

ABI-encodes the value.

fn abi_encode_sequence(&self) -> Vec<u8>

where <Self::SolType as SolType>::Token<'a>: for<'a> TokenSeq<'a>,

Encodes an ABI sequence.

fn abi_encode_params(&self) -> Vec<u8>

where <Self::SolType as SolType>::Token<'a>: for<'a> TokenSeq<'a>,

Encodes an ABI sequence suitable for function parameters.

fn abi_decode(data: &[u8], validate: bool) -> Result<Self, Error>

where Self: From<<Self::SolType as SolType>::RustType>,

ABI-decode this type from the given data.

fn abi_decode_params<'de>( data: &'de [u8], validate: bool, ) -> Result<Self, Error>

where Self: From<<Self::SolType as SolType>::RustType>, <Self::SolType as SolType>::Token<'de>: TokenSeq<'de>,

ABI-decode this type from the given data.

fn abi_decode_sequence<'de>( data: &'de [u8], validate: bool, ) -> Result<Self, Error>

where Self: From<<Self::SolType as SolType>::RustType>, <Self::SolType as SolType>::Token<'de>: TokenSeq<'de>,

ABI-decode this type from the given data.