wevm-core 0.4.1

Waves Enterprise Virtual Machine for WASM smart-contracts
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
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

use crate::{error::RuntimeError, node::Node, runtime::Runtime};
use blake2::{digest::consts::U32, Blake2b, Digest};
use sha2::Sha256;
use sha3::Keccak256;
use wasmi::Caller;

pub fn fast_hash(
    offset_bytes: u32,
    length_bytes: u32,
    mut caller: Caller<Runtime>,
) -> (i32, u32, u32) {
    let (memory, ctx) = match caller.data().memory() {
        Some(memory) => memory.data_and_store_mut(&mut caller),
        None => return (RuntimeError::MemoryNotFound.as_i32(), 0, 0),
    };
    let offset_memory = ctx.heap_base() as usize;

    let bytes = &memory[offset_bytes as usize..offset_bytes as usize + length_bytes as usize];

    match ctx.vm.fast_hash(bytes) {
        Ok(result) => crate::env::write_memory(ctx, memory, offset_memory, result),
        Err(error) => (error.as_i32(), 0, 0),
    }
}

pub fn secure_hash(
    offset_bytes: u32,
    length_bytes: u32,
    mut caller: Caller<Runtime>,
) -> (i32, u32, u32) {
    let (memory, ctx) = match caller.data().memory() {
        Some(memory) => memory.data_and_store_mut(&mut caller),
        None => return (RuntimeError::MemoryNotFound.as_i32(), 0, 0),
    };
    let offset_memory = ctx.heap_base() as usize;

    let bytes = &memory[offset_bytes as usize..offset_bytes as usize + length_bytes as usize];

    match ctx.vm.secure_hash(bytes) {
        Ok(result) => crate::env::write_memory(ctx, memory, offset_memory, result),
        Err(error) => (error.as_i32(), 0, 0),
    }
}

pub fn blake2b256(
    offset_bytes: u32,
    length_bytes: u32,
    mut caller: Caller<Runtime>,
) -> (i32, u32, u32) {
    let (memory, ctx) = match caller.data().memory() {
        Some(memory) => memory.data_and_store_mut(&mut caller),
        None => return (RuntimeError::MemoryNotFound.as_i32(), 0, 0),
    };
    let offset_memory = ctx.heap_base() as usize;

    let mut hasher: Blake2b<U32> = Blake2b::new();
    hasher.update(&memory[offset_bytes as usize..offset_bytes as usize + length_bytes as usize]);

    crate::env::write_memory(ctx, memory, offset_memory, hasher.finalize().to_vec())
}

pub fn keccak256(
    offset_bytes: u32,
    length_bytes: u32,
    mut caller: Caller<Runtime>,
) -> (i32, u32, u32) {
    let (memory, ctx) = match caller.data().memory() {
        Some(memory) => memory.data_and_store_mut(&mut caller),
        None => return (RuntimeError::MemoryNotFound.as_i32(), 0, 0),
    };
    let offset_memory = ctx.heap_base() as usize;

    let mut hasher = Keccak256::new();
    hasher.update(&memory[offset_bytes as usize..offset_bytes as usize + length_bytes as usize]);

    crate::env::write_memory(ctx, memory, offset_memory, hasher.finalize().to_vec())
}

pub fn sha256(
    offset_bytes: u32,
    length_bytes: u32,
    mut caller: Caller<Runtime>,
) -> (i32, u32, u32) {
    let (memory, ctx) = match caller.data().memory() {
        Some(memory) => memory.data_and_store_mut(&mut caller),
        None => return (RuntimeError::MemoryNotFound.as_i32(), 0, 0),
    };
    let offset_memory = ctx.heap_base() as usize;

    let mut hasher = Sha256::new();
    hasher.update(&memory[offset_bytes as usize..offset_bytes as usize + length_bytes as usize]);

    crate::env::write_memory(ctx, memory, offset_memory, hasher.finalize().to_vec())
}

pub fn sig_verify(
    offset_message: u32,
    length_message: u32,
    offset_signature: u32,
    length_signature: u32,
    offset_public_key: u32,
    length_public_key: u32,
    mut caller: Caller<Runtime>,
) -> (i32, i32) {
    let (memory, ctx) = match caller.data().memory() {
        Some(memory) => memory.data_and_store_mut(&mut caller),
        None => return (RuntimeError::MemoryNotFound.as_i32(), 0),
    };

    let message =
        &memory[offset_message as usize..offset_message as usize + length_message as usize];
    let signature =
        &memory[offset_signature as usize..offset_signature as usize + length_signature as usize];
    let public_key = &memory
        [offset_public_key as usize..offset_public_key as usize + length_public_key as usize];

    match ctx.vm.sig_verify(message, signature, public_key) {
        Ok(result) => (0, result as i32),
        Err(error) => (error.as_i32(), 0),
    }
}