Struct clarity_repl::clarity::contexts::GlobalContext

pub struct GlobalContext<'a> {
    pub event_batches: Vec<EventBatch>,
    pub database: ClarityDatabase<'a>,
    pub cost_track: LimitedCostTracker,
    pub mainnet: bool,
    // some fields omitted
}

GlobalContext represents the outermost context for a single transaction’s execution. It tracks an asset changes that occurred during the processing of the transaction, whether or not the current context is read_only, and is responsible for committing/rolling-back transactions as they error or abort.

Fields

event_batches: Vec<EventBatch>

database: ClarityDatabase<'a>

cost_track: LimitedCostTracker

mainnet: bool

Implementations

impl<'a> GlobalContext<'a>

pub fn new(
    mainnet: bool,
    database: ClarityDatabase<'_>,
    cost_track: LimitedCostTracker
) -> GlobalContext<'_>

pub fn is_top_level(&self) -> bool

pub fn log_asset_transfer(
    &mut self,
    sender: &PrincipalData,
    contract_identifier: &QualifiedContractIdentifier,
    asset_name: &ClarityName,
    transfered: Value
)

pub fn log_token_transfer(
    &mut self,
    sender: &PrincipalData,
    contract_identifier: &QualifiedContractIdentifier,
    asset_name: &ClarityName,
    transfered: u128
) -> Result<()>

pub fn log_stx_transfer(
    &mut self,
    sender: &PrincipalData,
    transfered: u128
) -> Result<()>

pub fn log_stx_burn(
    &mut self,
    sender: &PrincipalData,
    transfered: u128
) -> Result<()>

pub fn execute<F, T>(&mut self, f: F) -> Result<T> where
    F: FnOnce(&mut Self) -> Result<T>, 

pub fn is_read_only(&self) -> bool

pub fn begin(&mut self)

pub fn begin_read_only(&mut self)

pub fn commit(&mut self) -> Result<(Option<AssetMap>, Option<EventBatch>)>

pub fn roll_back(&mut self)

pub fn handle_tx_result(&mut self, result: Result<Value>) -> Result<Value>

pub fn destruct(self) -> Option<(ClarityDatabase<'a>, LimitedCostTracker)>

Destroys this context, returning ownership of its database reference. If the context wasn’t top-level (i.e., it had uncommitted data), return None, because the database is not guaranteed to be in a sane state.

Trait Implementations

impl CostTracker for GlobalContext<'_>

fn compute_cost(
    &mut self,
    cost_function: ClarityCostFunction,
    input: &[u64]
) -> Result<ExecutionCost, CostErrors>

fn add_cost(&mut self, cost: ExecutionCost) -> Result<(), CostErrors>

fn add_memory(&mut self, memory: u64) -> Result<(), CostErrors>

fn drop_memory(&mut self, memory: u64)

fn reset_memory(&mut self)

fn short_circuit_contract_call(
    &mut self,
    contract: &QualifiedContractIdentifier,
    function: &ClarityName,
    input: &[u64]
) -> Result<bool, CostErrors>

Check if the given contract-call should be short-circuited. If so: this charges the cost to the CostTracker, and return true If not: return false