Struct CompoundInclusionProof

pub struct CompoundInclusionProof {
    pub bank_hash_proof: BankHashProof,
    /* private fields */
}

A proof that a specific Solana block contains blobs, and that there are no other blobs in the block.

This proof consists of four parts:

1. A list of blob proofs that prove that the blobs uploaded to the [blober] program hash to the given blob digest.
2. A blober account state proof that proves that the [blober] was invoked exactly as many times as there are blobs.
3. An accounts delta hash proof that proves that the accounts_delta_hash does include the [blober] account.
4. A bank hash proof that proves that the root hash of the accounts_delta_hash is the same as the root in the bank hash.

The proof can then be verified by supplying the blockhash of the block in which the [blober] was invoked, as well as the blobs of data which were published.

Fields

bank_hash_proof: BankHashProof

Implementations

impl CompoundInclusionProof

pub fn new( slot: Slot, blob_proofs: Vec<BlobProof>, blober_account_state_proof: BloberAccountStateProof, blober_inclusion_proof: InclusionProof, bank_hash_proof: BankHashProof, ) -> Self

Creates an inclusion proof.

pub fn verify( &self, blober: Pubkey, blockhash: Hash, blobs: &[ProofBlob<impl AsRef<[u8]>>], ) -> Result<(), CompoundInclusionProofError>

Verifies that a specific Solana block contains the provided blobs, and that no blobs have been excluded.

Trait Implementations

impl Clone for CompoundInclusionProof

fn clone(&self) -> CompoundInclusionProof

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CompoundInclusionProof

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CompoundInclusionProof

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for CompoundInclusionProof

fn eq(&self, other: &CompoundInclusionProof) -> 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 Serialize for CompoundInclusionProof

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for CompoundInclusionProof

impl StructuralPartialEq for CompoundInclusionProof