Struct BlockTemplate

pub struct BlockTemplate {

    pub version: Version,
    pub compact_target: Uint32,
    pub current_time: Timestamp,
    pub number: BlockNumber,
    pub epoch: EpochNumberWithFraction,
    pub parent_hash: H256,
    pub cycles_limit: Cycle,
    pub bytes_limit: Uint64,
    pub uncles_count_limit: Uint64,
    pub uncles: Vec<UncleTemplate>,
    pub transactions: Vec<TransactionTemplate>,
    pub proposals: Vec<ProposalShortId>,
    pub cellbase: CellbaseTemplate,
    pub work_id: Uint64,
    pub dao: Byte32,
    pub extension: Option<JsonBytes>,
}

A block template for miners.

Miners optional pick transactions and then assemble the final block.

Fields

version: Version

Block version.

Miners must use it unchanged in the assembled block.

compact_target: Uint32

The compacted difficulty target for the new block.

Miners must use it unchanged in the assembled block.

current_time: Timestamp

The timestamp for the new block.

CKB node guarantees that this timestamp is larger than the median of the previous 37 blocks.

Miners can increase it to the current time. It is not recommended to decrease it, since it may violate the median block timestamp consensus rule.

number: BlockNumber

The block number for the new block.

Miners must use it unchanged in the assembled block.

epoch: EpochNumberWithFraction

The epoch progress information for the new block.

Miners must use it unchanged in the assembled block.

parent_hash: H256

The parent block hash of the new block.

Miners must use it unchanged in the assembled block.

cycles_limit: Cycle

The cycles limit.

Miners must keep the total cycles below this limit, otherwise, the CKB node will reject the block submission.

It is guaranteed that the block does not exceed the limit if miners do not add new transactions to the block.

bytes_limit: Uint64

The block serialized size limit.

Miners must keep the block size below this limit, otherwise, the CKB node will reject the block submission.

It is guaranteed that the block does not exceed the limit if miners do not add new transaction commitments.

uncles_count_limit: Uint64

The uncle count limit.

Miners must keep the uncles count below this limit, otherwise, the CKB node will reject the block submission.

uncles: Vec<UncleTemplate>

Provided valid uncle blocks candidates for the new block.

Miners must include the uncles marked as required in the assembled new block.

transactions: Vec<TransactionTemplate>

Provided valid transactions which can be committed in the new block.

Miners must include the transactions marked as required in the assembled new block.

proposals: Vec<ProposalShortId>

Provided proposal ids list of transactions for the new block.

cellbase: CellbaseTemplate

Provided cellbase transaction template.

Miners must use it as the cellbase transaction without changes in the assembled block.

work_id: Uint64

Work ID. The miner must submit the new assembled and resolved block using the same work ID.

dao: Byte32

Reference DAO field.

This field is only valid when miners use all and only use the provided transactions in the template. Two fields must be updated when miners want to select transactions:

• S_i, bytes 16 to 23
• U_i, bytes 24 to 31

See RFC Deposit and Withdraw in Nervos DAO.

extension: Option<JsonBytes>

The extension for the new block.

This is a field introduced in CKB RFC 0031. Since the activation of CKB RFC 0044, this field is at least 32 bytes, and at most 96 bytes. The consensus rule of first 32 bytes is defined in the RFC 0044.

Trait Implementations

impl Clone for BlockTemplate

fn clone(&self) -> BlockTemplate

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for BlockTemplate

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

Formats the value using the given formatter.

impl Default for BlockTemplate

fn default() -> BlockTemplate

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for BlockTemplate

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<BlockTemplate> for Block

fn from(block_template: BlockTemplate) -> Block

Converts to this type from the input type.

impl Hash for BlockTemplate

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 JsonSchema for BlockTemplate

fn schema_name() -> String

The name of the generated JSON Schema.

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

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(gen: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn is_referenceable() -> bool

Whether JSON Schemas generated for this type should be re-used where possible using the $ref keyword.

impl PartialEq for BlockTemplate

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

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 BlockTemplate

impl StructuralPartialEq for BlockTemplate