Struct ckb_jsonrpc_types::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 field is optional. It’s a reserved field, please leave it blank. More details can be found in CKB RFC 0031.

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

Performs the conversion.

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, 

Feeds a slice of this type into the given Hasher.

impl PartialEq<BlockTemplate> for BlockTemplate

fn eq(&self, other: &BlockTemplate) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &BlockTemplate) -> bool

This method tests for !=.

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

impl StructuralPartialEq for BlockTemplate