Struct Context

pub struct Context {
    pub cells: HashMap<OutPoint, (CellOutput, Bytes)>,
    pub transaction_infos: HashMap<OutPoint, TransactionInfo>,
    pub headers: HashMap<Byte32, HeaderView>,
    pub epoches: HashMap<Byte32, EpochExt>,
    pub block_extensions: HashMap<Byte32, Bytes>,
    pub cells_by_data_hash: HashMap<Byte32, OutPoint>,
    pub cells_by_type_hash: HashMap<Byte32, OutPoint>,
    /* private fields */
}

Verification Context

Fields

cells: HashMap<OutPoint, (CellOutput, Bytes)>

transaction_infos: HashMap<OutPoint, TransactionInfo>

headers: HashMap<Byte32, HeaderView>

epoches: HashMap<Byte32, EpochExt>

block_extensions: HashMap<Byte32, Bytes>

cells_by_data_hash: HashMap<Byte32, OutPoint>

cells_by_type_hash: HashMap<Byte32, OutPoint>

Implementations

impl Context

pub fn new_with_deterministic_rng() -> Self

Create a new context with a deterministic random number generator, which can be used to generate deterministic out point of deployed contract

pub fn add_contract_dir(&mut self, path: &str)

pub fn deploy_contract(&mut self, data: Bytes) -> OutPoint

👎Deprecated since 0.1.1: Please use the deploy_cell function instead

pub fn deploy_cell(&mut self, data: Bytes) -> OutPoint

Deploy a cell return the out-point of the cell

pub fn deploy_cell_by_name(&mut self, filename: &str) -> OutPoint

pub fn insert_header(&mut self, header: HeaderView)

Insert a block header into context

pub fn link_cell_with_block( &mut self, out_point: OutPoint, block_hash: Byte32, tx_index: usize, )

Link a cell with a block to make the load_header_by_cell syscalls works

pub fn get_contract_out_point(&self, data_hash: &Byte32) -> Option<OutPoint>

👎Deprecated since 0.1.1: Please use the get_cell_by_data_hash function instead

pub fn get_cell_by_data_hash(&self, data_hash: &Byte32) -> Option<OutPoint>

Get the out-point of a cell by data_hash the cell must has deployed to this context

pub fn create_cell(&mut self, cell: CellOutput, data: Bytes) -> OutPoint

Create a cell with data return the out-point

pub fn create_cell_with_out_point( &mut self, out_point: OutPoint, cell: CellOutput, data: Bytes, )

Create cell with specified out-point and cell data

pub fn insert_cell( &mut self, out_point: OutPoint, cell: CellOutput, data: Bytes, )

👎Deprecated since 0.1.1: Please use the create_cell_with_out_point function instead

pub fn get_cell(&self, out_point: &OutPoint) -> Option<(CellOutput, Bytes)>

Get cell output and data by out-point

pub fn build_script_with_hash_type( &mut self, out_point: &OutPoint, hash_type: ScriptHashType, args: Bytes, ) -> Option<Script>

Build script with out_point, hash_type, args return none if the out-point is not exist

pub fn build_script( &mut self, out_point: &OutPoint, args: Bytes, ) -> Option<Script>

Build script with out_point, args and hash_type(ScriptHashType::Type) return none if the out-point is not exist

pub fn complete_tx(&mut self, tx: TransactionView) -> TransactionView

Complete cell deps for a transaction this function searches context cells; generate cell dep for referenced scripts.

pub fn capture_debug(&self) -> bool

pub fn set_capture_debug(&mut self, capture_debug: bool)

Capture debug output, default value is false

pub fn captured_messages(&self) -> Vec<Message>

return captured messages

pub fn verify_tx( &self, tx: &TransactionView, max_cycles: u64, ) -> Result<Cycle, CKBError>

Verify the transaction in CKB-VM

pub fn dump_tx( &self, tx: &TransactionView, ) -> Result<ReprMockTransaction, CKBError>

Dump the transaction in mock transaction format, so we can offload it to ckb debugger

Trait Implementations

impl CellDataProvider for Context

fn load_cell_data(&self, cell: &CellMeta) -> Option<Bytes>

Load cell_data from memory, fallback to storage access

fn get_cell_data(&self, out_point: &OutPoint) -> Option<Bytes>

Fetch cell_data from storage

fn get_cell_data_hash(&self, out_point: &OutPoint) -> Option<Byte32>

Fetch cell_data_hash from storage, please note that loading a large amount of cell data and calculating hash may be a performance bottleneck, so here is a separate fn designed to facilitate caching.

fn load_cell_data_hash(&self, cell: &CellMeta) -> Option<Byte32>

Load cell_data_hash from memory, fallback to storage access

impl Clone for Context

fn clone(&self) -> Context

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Default for Context

fn default() -> Self

Returns the “default value” for a type.

impl ExtensionProvider for Context

fn get_block_extension(&self, hash: &Byte32) -> Option<Bytes>

Get the extension field of the given block hash

impl HeaderProvider for Context

fn get_header(&self, block_hash: &Byte32) -> Option<HeaderView>

Get the header of the given block hash