Struct Block

pub struct Block {
    pub chain_id: ChainId,
    pub epoch: Epoch,
    pub incoming_bundles: Vec<IncomingBundle>,
    pub operations: Vec<Operation>,
    pub height: BlockHeight,
    pub timestamp: Timestamp,
    pub authenticated_signer: Option<Owner>,
    pub previous_block_hash: Option<CryptoHash>,
}

A block containing operations to apply on a given chain, as well as the acknowledgment of a number of incoming messages from other chains.

• Incoming messages must be selected in the order they were produced by the sending chain, but can be skipped.
• When a block is proposed to a validator, all cross-chain messages must have been received ahead of time in the inbox of the chain.
• This constraint does not apply to the execution of confirmed blocks.

Fields

chain_id: ChainId

The chain to which this block belongs.

epoch: Epoch

The number identifying the current configuration.

incoming_bundles: Vec<IncomingBundle>

A selection of incoming messages to be executed first. Successive messages of same sender and height are grouped together for conciseness.

operations: Vec<Operation>

The operations to execute.

height: BlockHeight

The block height.

timestamp: Timestamp

The timestamp when this block was created. This must be later than all messages received in this block, but no later than the current time.

authenticated_signer: Option<Owner>

The user signing for the operations in the block and paying for their execution fees. If set, this must be the owner in the block proposal. None means that the default account of the chain is used. This value is also used as recipient of potential refunds for the message grants created by the operations.

previous_block_hash: Option<CryptoHash>

Certified hash (see Certificate below) of the previous block in the chain, if any.

Implementations

impl Block

pub async fn chain_id(&self, ctx: &Context<'_>) -> Result<&ChainId>

pub async fn epoch(&self, ctx: &Context<'_>) -> Result<&Epoch>

pub async fn incoming_bundles( &self, ctx: &Context<'_>, ) -> Result<&Vec<IncomingBundle>>

pub async fn operations(&self, ctx: &Context<'_>) -> Result<&Vec<Operation>>

pub async fn height(&self, ctx: &Context<'_>) -> Result<&BlockHeight>

pub async fn timestamp(&self, ctx: &Context<'_>) -> Result<&Timestamp>

pub async fn authenticated_signer( &self, ctx: &Context<'_>, ) -> Result<&Option<Owner>>

pub async fn previous_block_hash( &self, ctx: &Context<'_>, ) -> Result<&Option<CryptoHash>>

impl Block

pub fn published_blob_ids(&self) -> HashSet<BlobId>

Returns all the published blob IDs in this block’s operations.

pub fn has_only_rejected_messages(&self) -> bool

Returns whether the block contains only rejected incoming messages, which makes it admissible even on closed chains.

pub fn incoming_messages(&self) -> impl Iterator<Item = &PostedMessage>

Returns an iterator over all incoming PostedMessages in this block.

pub fn message_count(&self) -> usize

Returns the number of incoming messages.

pub fn transactions(&self) -> impl Iterator<Item = (u32, Transaction<'_>)>

Returns an iterator over all transactions, by index.

pub fn starts_with_open_chain_message( &self, ) -> Option<(&IncomingBundle, &PostedMessage, &OpenChainConfig)>

If the block’s first message is OpenChain, returns the bundle, the message and the configuration for the new chain.

Trait Implementations

impl Clone for Block

fn clone(&self) -> Block

Returns a copy of the value.

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

Performs copy-assignment from source.

impl ContainerType for Block

async fn resolve_field(&self, ctx: &Context<'_>) -> ServerResult<Option<Value>>

Resolves a field value and outputs it as a json value async_graphql::Value.

fn collect_all_fields<'a>( &'a self, ctx: &ContextBase<'a, &'a Positioned<SelectionSet>>, fields: &mut Fields<'a>, ) -> Result<(), ServerError>

where Self: Send + Sync,

Collect all the fields of the container that are queried in the selection set.

fn find_entity( &self, _: &ContextBase<'_, &Positioned<Field>>, _params: &ConstValue, ) -> impl Future<Output = Result<Option<ConstValue>, ServerError>> + Send

Find the GraphQL entity with the given name from the parameter.

impl Debug for Block

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Block

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for Block

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl OutputType for Block

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

Type the name.

fn create_type_info(registry: &mut Registry) -> String

Create type information in the registry and return qualified typename.

async fn resolve( &self, ctx: &ContextSelectionSet<'_>, _field: &Positioned<Field>, ) -> ServerResult<Value>

Resolve an output value to async_graphql::Value.

fn qualified_type_name() -> String

Qualified typename.

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

Introspection type name

impl PartialEq for Block

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

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 Block

impl ObjectType for Block

impl StructuralPartialEq for Block