## fvm-std

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

### 1. 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

```rust
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

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

#### Address

`Address` is a alias for `H160`, also a method implement

```rust
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](#Log)

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

### 2. Log

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

#### Demo

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

### 3. Event

supply event for developer used in contract.

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

**demo**

```rust
#[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()
    }
}

```