Crate fvm_std

Expand description

fvm-std is a crate that supply base tool for developer to write contract with RUST more convenient

Types

Here some simple types that we provide for developers to write contract easier.

H256

H256 is a 32-length bytes, in order to express block hash. There are methods implement

fn as_ref(&self) -> &H256
pub const fn new(val: [u8; 32]) -> Self
pub fn to_hex_string(&self) -> String

H160

H160 is a 20-length bytes, in order to express address, there are methods implement

fn as_ref(&self) -> &H160
pub const fn new(val: [u8; 20]) -> Self

Address

Address is a alias for H160, also a method implement

pub fn to_hex_string(&self) -> String

Notice: to_hex_string is different to to_string, the latter will only print part of the content, if it is too long

Log level

level for developer to use with event log. more details see in section log

// CRITICAL ERROR WARNING NOTICE INFO DEBUG
pub enum LogLevel {
    CRITICAL,
    ERROR,
    WARNING,
    NOTICE,
    INFO,
    DEBUG,
}

Log

we have supplied several tool macros method for developer to print log in contract, include critical!(), error!(), warning!(), notice!(), info!(), debug!()

Demo

pub fn add(&mut self) -> u64 {
    info!("info {}", "hello");
    warning!("warning {}", "hello");
    notice!("notice {}", "hello");
    1
}

Event

supply event for developer used in contract.

#[derive(Debug, Serialize)]
pub struct Event<T> where T: Serialize {
    address: Address,
    data: T,
    topics: Vec<H256>,
}

demo

#[derive(Debug, Serialize)]
struct Temp {
    amount: u64,
}


#[storage]
pub struct SetHash {
    map: HyperMap<String, String>,
}

#[contract]
impl SetHash {
    fn new() -> Self {
        Self { map: HyperMap::new() }
    }

    pub fn set_hash(&mut self, key: String, value: String) {
        let temp = Temp { amount: 1 };
        let ev = Event::new(temp, "set_hash".to_string(), vec!["test".to_string()]);
        ev.emit();
        self.map.insert(key, value);
    }

    pub fn get_hash(&mut self, key: String) -> &String {
        self.map.get(&key).unwrap()
    }
}

Modules

collections

event

The event module provides method to throw event in the contract.

normal

prelude

The prelude module provides common data types in the contract, and introduces some functions in the rust core library.

runtime

The database module provides the interface to save the data in the contract to the chain and query the data from the chain. The runtime module provides an interface to interact with the chain in the contract

spread

types

The types module provides common data types such as address, U128, hash, etc.

Macros

critical

CRITICAL ERROR WARNING NOTICE INFO DEBUG

Examples

Examples

Examples

Examples

Examples