Struct Contract 

pub struct Contract {
    pub name: String,
    pub init_params: FieldList,
    pub fields: FieldList,
    pub transitions: TransitionList,
}

The Contract struct represents a parsed contract in Rust, including its name, initialization parameters, fields, and transitions.

Fields

name: String

Name of the parsed contract

init_params: FieldList

List of parameters needed to deploy the contract.

fields: FieldList

List of the contract’s fields.

transitions: TransitionList

List of the contract’s transitions.

Implementations

impl Contract

pub fn parse(contract_path: &Path) -> Result<Self, Error>

Parse a contract from a given path.

Examples

use std::{error::Error, path::PathBuf};
use scilla_parser::{Contract, Field, FieldList, Transition, TransitionList, Type};
let contract_path = PathBuf::from("tests/contracts/chainid.scilla");
let contract = Contract::parse(&contract_path).unwrap();

assert_eq!(
    contract,
    Contract {
        name: "ChainId".to_string(),
        fields: FieldList(vec![Field::new("dummy_field", Type::Uint256)]),
        init_params: FieldList::default(),
        transitions: TransitionList(vec![Transition::new(
            "EventChainID",
            FieldList::default()
        )])
    }
);

Trait Implementations

impl Debug for Contract

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

Formats the value using the given formatter.

impl Default for Contract

fn default() -> Contract

Returns the “default value” for a type.

impl FromStr for Contract

fn from_str(contract: &str) -> Result<Self, Self::Err>

Parse a Contract from a string slice

Example

use std::{error::Error, path::PathBuf};
use scilla_parser::{Contract, Field, FieldList, Transition, TransitionList, Type};
let contract_path = PathBuf::from("tests/contracts/chainid.scilla");
let contract_str = include_str!("../tests/contracts/chainid.scilla");
let contract = contract_str.parse::<Contract>().unwrap();

assert_eq!(
    contract,
    Contract {
        name: "ChainId".to_string(),
        fields: FieldList(vec![Field::new("dummy_field", Type::Uint256)]),
        init_params: FieldList::default(),
        transitions: TransitionList(vec![Transition::new(
            "EventChainID",
            FieldList::default()
        )])
    }
);

type Err = Error

The associated error which can be returned from parsing.

impl PartialEq for Contract

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl StructuralPartialEq for Contract