zink 0.1.12

Standard library for zink projects.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

//! Simple getter example to debug dispatcher
#![cfg_attr(target_arch = "wasm32", no_std)]
#![cfg_attr(target_arch = "wasm32", no_main)]

extern crate zink;

use zink::primitives::Bytes32;
use zink::Storage;

#[allow(dead_code)]
#[derive(zink_codegen::Storage)]
pub struct Getter {
    value: Bytes32,
}

impl Getter {
    #[zink::external]
    pub fn get_value(&self) -> Bytes32 {
        self.value()
    }

    #[zink::external]
    pub fn init(&self, value: Bytes32) {
        self.set_value(value);
    }
}

#[cfg(not(target_arch = "wasm32"))]
fn main() {}

#[test]
#[cfg(not(target_arch = "wasm32"))]
fn test_getter() -> anyhow::Result<()> {
    #[allow(unused)]
    use smallvec::SmallVec;
    use zint::{Contract, EVM, U256 as ZintU256};

    let caller_bytes = hex::decode("be862ad9abfe6f22bcb087716c7d89a26051f74c")?;
    let mut caller = [0; 20];
    caller.copy_from_slice(&caller_bytes);

    let mut evm = EVM::default().commit(true).caller(caller);
    let mut contract = Contract::search("getter")?.compile()?;

    let value_bytes = "TestValue".as_bytes();
    let mut value_array = [0u8; 32];
    value_array[..value_bytes.len().min(32)]
        .copy_from_slice(&value_bytes[..value_bytes.len().min(32)]);
    let _value = Bytes32(value_array);

    // Deploy with initial value
    let info = evm.deploy(
        &contract
            .construct(
                [(
                    ZintU256::from(0).to_le_bytes::<32>(),
                    SmallVec::from_slice(&value_array),
                )]
                .into_iter()
                .map(|(k, v)| (SmallVec::from_slice(&k), v))
                .collect(),
            )?
            .bytecode()?,
    )?;
    let address = info.address;

    // Test direct storage read
    let stored_value = evm.storage(address, ZintU256::from(0).to_le_bytes::<32>())?;
    assert_eq!(
        stored_value.to_vec(),
        value_array.to_vec(),
        "Storage mismatch"
    );

    // Test runtime getter
    let info = evm
        .calldata(&contract.encode(&[b"get_value()".to_vec()])?)
        .call(address)?;
    assert_eq!(info.ret, value_array.to_vec(), "Getter failed: {:?}", info);

    Ok(())
}