Struct stacks_rpc_client::clarity::vm::analysis::ContractAnalysis

pub struct ContractAnalysis {

    pub contract_identifier: QualifiedContractIdentifier,
    pub private_function_types: BTreeMap<ClarityName, FunctionType>,
    pub variable_types: BTreeMap<ClarityName, TypeSignature>,
    pub public_function_types: BTreeMap<ClarityName, FunctionType>,
    pub read_only_function_types: BTreeMap<ClarityName, FunctionType>,
    pub map_types: BTreeMap<ClarityName, (TypeSignature, TypeSignature)>,
    pub persisted_variable_types: BTreeMap<ClarityName, TypeSignature>,
    pub fungible_tokens: BTreeSet<ClarityName>,
    pub non_fungible_tokens: BTreeMap<ClarityName, TypeSignature>,
    pub defined_traits: BTreeMap<ClarityName, BTreeMap<ClarityName, FunctionSignature>>,
    pub implemented_traits: BTreeSet<TraitIdentifier>,
    pub contract_interface: Option<ContractInterface>,
    pub is_cost_contract_eligible: bool,
    pub epoch: StacksEpochId,
    pub clarity_version: ClarityVersion,
    pub expressions: Vec<SymbolicExpression>,
    pub type_map: Option<TypeMap>,
    pub cost_track: Option<LimitedCostTracker>,
}

Fields

contract_identifier: QualifiedContractIdentifier

private_function_types: BTreeMap<ClarityName, FunctionType>

variable_types: BTreeMap<ClarityName, TypeSignature>

public_function_types: BTreeMap<ClarityName, FunctionType>

read_only_function_types: BTreeMap<ClarityName, FunctionType>

map_types: BTreeMap<ClarityName, (TypeSignature, TypeSignature)>

persisted_variable_types: BTreeMap<ClarityName, TypeSignature>

fungible_tokens: BTreeSet<ClarityName>

non_fungible_tokens: BTreeMap<ClarityName, TypeSignature>

defined_traits: BTreeMap<ClarityName, BTreeMap<ClarityName, FunctionSignature>>

implemented_traits: BTreeSet<TraitIdentifier>

contract_interface: Option<ContractInterface>

is_cost_contract_eligible: bool

epoch: StacksEpochId

clarity_version: ClarityVersion

expressions: Vec<SymbolicExpression>

type_map: Option<TypeMap>

cost_track: Option<LimitedCostTracker>

Implementations

impl ContractAnalysis

pub fn new( contract_identifier: QualifiedContractIdentifier, expressions: Vec<SymbolicExpression>, cost_track: LimitedCostTracker, epoch: StacksEpochId, clarity_version: ClarityVersion ) -> ContractAnalysis

pub fn take_contract_cost_tracker(&mut self) -> LimitedCostTracker

pub fn replace_contract_cost_tracker(&mut self, cost_track: LimitedCostTracker)

pub fn add_map_type( &mut self, name: ClarityName, key_type: TypeSignature, map_type: TypeSignature )

pub fn add_variable_type( &mut self, name: ClarityName, variable_type: TypeSignature )

pub fn add_persisted_variable_type( &mut self, name: ClarityName, persisted_variable_type: TypeSignature )

pub fn add_read_only_function( &mut self, name: ClarityName, function_type: FunctionType )

pub fn add_public_function( &mut self, name: ClarityName, function_type: FunctionType )

pub fn add_private_function( &mut self, name: ClarityName, function_type: FunctionType )

pub fn add_non_fungible_token( &mut self, name: ClarityName, nft_type: TypeSignature )

pub fn add_fungible_token(&mut self, name: ClarityName)

pub fn add_defined_trait( &mut self, name: ClarityName, function_types: BTreeMap<ClarityName, FunctionSignature> )

pub fn add_implemented_trait(&mut self, trait_identifier: TraitIdentifier)

pub fn get_public_function_type(&self, name: &str) -> Option<&FunctionType>

pub fn get_read_only_function_type(&self, name: &str) -> Option<&FunctionType>

pub fn get_private_function(&self, name: &str) -> Option<&FunctionType>

pub fn get_map_type( &self, name: &str ) -> Option<&(TypeSignature, TypeSignature)>

pub fn get_variable_type(&self, name: &str) -> Option<&TypeSignature>

pub fn get_persisted_variable_type(&self, name: &str) -> Option<&TypeSignature>

pub fn get_defined_trait( &self, name: &str ) -> Option<&BTreeMap<ClarityName, FunctionSignature>>

pub fn canonicalize_types(&mut self, epoch: &StacksEpochId)

Canonicalize all types in the contract analysis.

pub fn check_trait_compliance( &self, epoch: &StacksEpochId, trait_identifier: &TraitIdentifier, trait_definition: &BTreeMap<ClarityName, FunctionSignature> ) -> Result<(), CheckError>

Trait Implementations

impl ClarityDeserializable<ContractAnalysis> for ContractAnalysis

fn deserialize(json: &str) -> ContractAnalysis

impl ClaritySerializable for ContractAnalysis

fn serialize(&self) -> String

impl Clone for ContractAnalysis

fn clone(&self) -> ContractAnalysis

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ContractAnalysis

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ContractAnalysis

fn deserialize<__D>( __deserializer: __D ) -> Result<ContractAnalysis, <__D as Deserializer<'de>>::Error>where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ContractAnalysis

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ContractAnalysis

fn serialize<__S>( &self, __serializer: __S ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ContractAnalysis