Struct CallProof

#[non_exhaustive]
pub struct CallProof {
    pub block_proof: BlockProof,
    pub call_proof: MapProof<CallInBlock, ExecutionError>,
    pub error_description: Option<String>,
}

Proof of authenticity for a single top-level call in a block, such as a transaction.

The proof consists of two parts:

• block_proof: block header with the proof of authenticity
• call_proof: proof from the error aggregator (i.e., a ProofMapIndex the Merkle root of which is recorded in the block header as error_hash).

For an execution that resulted in an error, call_proof will be a proof of existence. If a transaction was executed successfully, call_proof will be a proof of absence. Since the number of transactions in a block is mentioned in the block header, the user will be able to distinguish absence of error (meaning successful execution) from the absence of a transaction with such an index. Indeed, if the index is less than amount of transactions in block, the proof denotes successful execution; otherwise, the transaction with the given index does not exist in the block.

Similarly, execution errors of the before_transactions / after_transactions hooks can be proven to external clients. Discerning successful execution from a non-existing service requires prior knowledge though.

CallProofs should not be confused with a proof of transaction commitment. To verify that a certain transaction was committed, use a proof from the block_transactions index of the core schema.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

block_proof: BlockProof

Proof of authenticity for the block header.

call_proof: MapProof<CallInBlock, ExecutionError>

Proof of authenticity for the call status. Must contain a single key corresponding to the CallInBlock in question. The root hash of the proof must be equal to the error_hash mentioned in block_proof.

error_description: Option<String>

Human-readable description of an error if the call status is erroneous. This description is not authenticated and thus should be used for diagnostic purposes only. If the call is successful, the error description should be None.

Implementations

impl CallProof

pub fn verify( &self, validator_keys: &[PublicKey], ) -> Result<(CallInBlock, Result<(), ExecutionError>), ProofError>

Verifies this proof, returning the location of the proven call together with its status.

Note that a successful status is indistinguishable from the point of view of a proof from a non-existing one. It is up to caller to discern between these two possibilities.

Trait Implementations

impl BinaryValue for CallProof

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

Serializes the given value to the vector of bytes.

fn from_bytes(value: Cow<'_, [u8]>) -> Result<Self, Error>

Deserializes the value from the given bytes array.

fn into_bytes(self) -> Vec<u8>

Consumes and serializes the given value to the vector of bytes. This method is faster with the wrapped values, thus if you wouldn’t use value after serialization use it.

impl Clone for CallProof

fn clone(&self) -> CallProof

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for CallProof

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CallProof

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl ProtobufConvert for CallProof

type ProtoStruct = CallProof

Type generated from the Protobuf definition.

fn to_pb(&self) -> Self::ProtoStruct

Performs conversion to the type generated from Protobuf.

fn from_pb(pb: Self::ProtoStruct) -> Result<Self, Error>

Performs conversion from the type generated from Protobuf.

impl Serialize for CallProof

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

where __S: Serializer,

Serialize this value into the given Serde serializer.