Struct clarity_repl::clarity::clarity::ClarityTransactionConnection

pub struct ClarityTransactionConnection<'a> { /* private fields */ }

Interface for Clarity VM interactions within a given transaction.

commit the transaction to the block with .commit() rollback the transaction by dropping this struct.

Implementations

impl<'a> ClarityTransactionConnection<'a>

pub fn with_clarity_db<F, R>(&mut self, to_do: F) -> Result<R, Error>where
    F: FnOnce(&mut ClarityDatabase<'_>) -> Result<R, Error>,

Do something to the underlying DB that involves writing.

pub fn cost_so_far(&self) -> ExecutionCost

What’s our total (block-wide) resource use so far?

pub fn analyze_smart_contract(
    &mut self,
    identifier: &QualifiedContractIdentifier,
    contract_content: &str
) -> Result<(ContractAST, ContractAnalysis), Error>

Analyze a provided smart contract, but do not write the analysis to the AnalysisDatabase

pub fn save_analysis(
    &mut self,
    identifier: &QualifiedContractIdentifier,
    contract_analysis: &ContractAnalysis
) -> Result<(), CheckError>

Save a contract analysis output to the AnalysisDatabase An error here would indicate that something has gone terribly wrong in the processing of a contract insert. the caller should likely abort the whole block or panic

pub fn run_stx_transfer(
    &mut self,
    from: &PrincipalData,
    to: &PrincipalData,
    amount: u128
) -> Result<(Value, AssetMap, Vec<StacksTransactionEvent>), Error>

Execute a STX transfer in the current block. Will throw an error if it tries to spend STX that the ‘from’ principal doesn’t have.

pub fn run_contract_call<F>(
    &mut self,
    sender: &PrincipalData,
    contract: &QualifiedContractIdentifier,
    public_function: &str,
    args: &[Value],
    abort_call_back: F
) -> Result<(Value, AssetMap, Vec<StacksTransactionEvent>), Error>where
    F: FnOnce(&AssetMap, &mut ClarityDatabase<'_>) -> bool,

Execute a contract call in the current block. If an error occurs while processing the transaction, it’s modifications will be rolled back. abort_call_back is called with an AssetMap and a ClarityDatabase reference, if abort_call_back returns true, all modifications from this transaction will be rolled back. otherwise, they will be committed (though they may later be rolled back if the block itself is rolled back).

pub fn initialize_smart_contract<F>(
    &mut self,
    identifier: &QualifiedContractIdentifier,
    contract_ast: &ContractAST,
    contract_str: &str,
    abort_call_back: F
) -> Result<(AssetMap, Vec<StacksTransactionEvent>), Error>where
    F: FnOnce(&AssetMap, &mut ClarityDatabase<'_>) -> bool,

Initialize a contract in the current block. If an error occurs while processing the initialization, it’s modifications will be rolled back. abort_call_back is called with an AssetMap and a ClarityDatabase reference, if abort_call_back returns true, all modifications from this transaction will be rolled back. otherwise, they will be committed (though they may later be rolled back if the block itself is rolled back).

pub fn commit(self)

Commit the changes from the edit log. panics if there is more than one open savepoint

Trait Implementations

impl ClarityConnection for ClarityTransactionConnection<'_>

fn with_clarity_db_readonly_owned<F, R>(&mut self, to_do: F) -> Rwhere
    F: FnOnce(ClarityDatabase<'_>) -> (R, ClarityDatabase<'_>),

Do something with ownership of the underlying DB that involves only reading.

fn with_analysis_db_readonly<F, R>(&mut self, to_do: F) -> Rwhere
    F: FnOnce(&mut AnalysisDatabase<'_>) -> R,

fn with_clarity_db_readonly<F, R>(&mut self, to_do: F) -> Rwhere
    F: FnOnce(&mut ClarityDatabase<'_>) -> R,

fn with_readonly_clarity_env<F, R>(
    &mut self,
    mainnet: bool,
    sender: PrincipalData,
    cost_track: LimitedCostTracker,
    to_do: F
) -> Result<R, InterpreterError>where
    F: FnOnce(&mut Environment<'_, '_>) -> Result<R, InterpreterError>,

impl<'a> Drop for ClarityTransactionConnection<'a>

fn drop(&mut self)

Executes the destructor for this type.