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
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

extern crate alloc;
extern crate wasm_rpc;
extern crate wasm_rpc_macros;

pub use wasm_rpc::{Bytes, Dereferenceable, FromBytes, Referenceable, ToBytes, Value};
pub use wasm_rpc_macros::export;
use std::mem::transmute;
pub mod error;

extern "C" {
    fn __address() -> *const u8;
    fn __sender() -> *const u8;
    fn __block_hash() -> *const u8;
    fn __block_number() -> *const u8;
    fn __block_winner() -> *const u8;
    fn __contract_address() -> *const u8;
    fn __caller() -> *const u8;
    fn __call(
        contract_address: *const u8,
        function_name: *const u8,
        arguments: *const u8,
    ) -> *const u8;
    fn __get_memory(key: *const u8) -> *const u8;
    fn __set_memory(key: *const u8, value: *const u8);
    fn __get_storage(key: *const u8) -> *const u8;
    fn __set_storage(key: *const u8, value: *const u8);

}

pub trait Keyable {
    fn to_key(self: Self) -> Vec<u8>;
}

impl Keyable for Vec<u8> {
    fn to_key(self: Self) -> Vec<u8> {
        self
    }
}

impl Keyable for &str {
    fn to_key(self: Self) -> Vec<u8> {
        self.as_bytes().to_vec()
    }
}


pub fn get_memory<K: Keyable,V: FromBytes,>(key: K) -> V {
    let v: Vec<u8> = unsafe { __get_memory(key.to_key().as_pointer()) }.as_raw_bytes();
    FromBytes::from_bytes(v)
}

pub fn set_memory<K: Keyable, V: ToBytes>(key: K, value: V) {
    unsafe { __set_memory(key.to_key().as_pointer(), value.to_bytes().as_pointer()) }
}

pub fn get_storage<V: FromBytes, K: Keyable>(key: K) -> V {
    let v: Vec<u8> = unsafe { __get_storage(key.to_key().as_pointer()) }.as_raw_bytes();
    FromBytes::from_bytes(v)
}

pub fn set_storage<K: Keyable, V: ToBytes>(key: K, value: V) {
    unsafe { __set_storage(key.to_key().as_pointer(), value.to_bytes().as_pointer()) }
}

pub fn address() -> Vec<u8> {
    let v: Vec<u8> = unsafe { __block_winner() }.as_raw_bytes();
    v
}

pub fn block_winner() -> Vec<u8> {
    let v: Vec<u8> = unsafe { __block_winner() }.as_raw_bytes();
    v
}


pub fn contract_address() -> Vec<u8> {
    unsafe { __contract_address().as_raw_bytes() }
}

pub fn sender() -> Vec<u8> {
    unsafe { __sender().as_raw_bytes() }
}


pub fn caller() -> Vec<u8> {
    unsafe { __caller().as_raw_bytes() }
}

pub fn block_number() -> u64 {
    unsafe { __block_number() }.to_i64() as u64
}


pub fn call(contract_address: Vec<u8>, function_name: &str, arguments: Vec<Value>) -> (u32, Value) {
    from_bytes(unsafe {
        __call(
            contract_address.as_pointer(),
            function_name.to_string().as_pointer(),
            arguments.as_pointer(),
        )
    }.as_raw_bytes())
}

pub type Result = (u32, Value);
pub fn vm_panic() -> Result {
    (1, "vm panic 2".to_string().into())
}

pub fn from_bytes(bytes: Vec<u8>) -> Result {
    if bytes.len() == 0 {
        (1, "vm bytes length is zero".to_string().into())
    } else {
        let bytes_clone = bytes.clone();
        let (return_code_bytes, return_value_bytes) = bytes_clone.split_at(4);
        let mut return_code_bytes_fixed: [u8; 4] = Default::default();
        if bytes.len() == 0 {
            (1, "vm error".to_string().into())
        } else {
            return_code_bytes_fixed.copy_from_slice(&return_code_bytes[0..4]);
            let return_code: u32 = unsafe { transmute(return_code_bytes_fixed) };

            let return_value: Value = wasm_rpc::from_slice(return_value_bytes).expect("failed to parse return_value");

            (return_code, return_value)
        }
    }
}