Skip to content

Commit feb6acb

Browse files
colmaziacolmazia
committed
split calls.rs to imports.rs & store.rs
1 parent 28b0158 commit feb6acb

File tree

4 files changed

+173
-157
lines changed

4 files changed

+173
-157
lines changed

‎packages/vm/src/calls.rs‎

Lines changed: 7 additions & 157 deletions
Original file line numberDiff line numberDiff line change
@@ -1,180 +1,30 @@
11
use crate::cache::Cache;
2+
use crate::imports::create_import_object;
3+
use crate::store::make_store;
24
use crate::vm::{self, Environment};
35

46
pub use crate::error::Error;
57
pub use std::ptr::NonNull;
6-
use std::sync::Arc;
7-
use wasmer::Universal;
88
use wasmer_middlewares::metering::{get_remaining_points, MeteringPoints};
99

10-
use wasmer::Singlepass;
11-
12-
use wasmer::{imports, wasmparser::Operator, CompilerConfig, Function, Store};
13-
use wasmer_middlewares::Metering;
14-
15-
// use owasm_crypto::ecvrf;
16-
17-
fn require_mem_range(max_range: usize, require_range: usize) -> Result<(), Error> {
18-
if max_range < require_range {
19-
return Err(Error::MemoryOutOfBoundError);
20-
}
21-
Ok(())
22-
}
23-
24-
fn cost(_operator: &Operator) -> u64 {
25-
// A flat fee for each operation
26-
1
27-
}
28-
2910
pub fn run<E>(
3011
cache: &mut Cache,
3112
code: &[u8],
32-
gas: u64,
13+
gas_limit: u64,
3314
is_prepare: bool,
3415
env: E,
3516
) -> Result<u64, Error>
3617
where
3718
E: vm::Env + 'static,
3819
{
3920
let owasm_env = Environment::new(env);
40-
41-
let mut compiler = Singlepass::new();
42-
let metering = Arc::new(Metering::new(0, cost));
43-
compiler.push_middleware(metering);
44-
let engine = Universal::new(compiler).engine();
45-
let store = Store::new(&engine);
46-
47-
let import_object = imports! {
48-
"env" => {
49-
"gas" => Function::new_native_with_env(&store, owasm_env.clone(), |env: &Environment<E>, _gas: u32| {
50-
env.decrease_gas_left(1)
51-
}),
52-
"get_span_size" => Function::new_native_with_env(&store, owasm_env.clone(), |env: &Environment<E>| {
53-
env.with_vm(|vm| {
54-
vm.env.get_span_size()
55-
})
56-
}),
57-
"read_calldata" => Function::new_native_with_env(&store, owasm_env.clone(), |env: &Environment<E>, ptr: i64| {
58-
env.with_mut_vm(|vm| -> Result<i64, Error>{
59-
let span_size = vm.env.get_span_size();
60-
// consume gas equal size of span when read calldata
61-
env.decrease_gas_left(span_size as u64)?;
62-
63-
let memory = env.memory()?;
64-
require_mem_range(memory.size().bytes().0, (ptr + span_size) as usize)?;
65-
66-
let data = vm.env.get_calldata()?;
67-
68-
for (idx, byte) in data.iter().enumerate() {
69-
memory.view()[ptr as usize + idx].set(*byte);
70-
}
71-
72-
Ok(data.len() as i64)
73-
})
74-
}),
75-
"set_return_data" => Function::new_native_with_env(&store, owasm_env.clone(), |env: &Environment<E>, ptr: i64, len: i64| {
76-
env.with_mut_vm(|vm| {
77-
let span_size = vm.env.get_span_size();
78-
79-
if len > span_size {
80-
return Err(Error::SpanTooSmallError);
81-
}
82-
83-
// consume gas equal size of span when save data to memory
84-
env.decrease_gas_left(span_size as u64)?;
85-
86-
let memory = env.memory()?;
87-
require_mem_range(memory.size().bytes().0, (ptr + span_size) as usize)?;
88-
89-
let data: Vec<u8> = memory.view()[ptr as usize..(ptr + len) as usize].iter().map(|cell| cell.get()).collect();
90-
vm.env.set_return_data(&data)
91-
})
92-
}),
93-
"get_ask_count" => Function::new_native_with_env(&store, owasm_env.clone(), |env: &Environment<E>| {
94-
env.with_vm(|vm| {
95-
vm.env.get_ask_count()
96-
})
97-
}),
98-
"get_min_count" => Function::new_native_with_env(&store, owasm_env.clone(), |env: &Environment<E>| {
99-
env.with_vm(|vm| {
100-
vm.env.get_min_count()
101-
})
102-
}),
103-
"get_prepare_time" => Function::new_native_with_env(&store, owasm_env.clone(), |env: &Environment<E>| {
104-
env.with_vm(|vm| {
105-
vm.env.get_prepare_time()
106-
})
107-
}),
108-
"get_execute_time" => Function::new_native_with_env(&store, owasm_env.clone(), |env: &Environment<E>| {
109-
env.with_vm(|vm| {
110-
vm.env.get_execute_time()
111-
})
112-
}),
113-
"get_ans_count" => Function::new_native_with_env(&store, owasm_env.clone(), |env: &Environment<E>| {
114-
env.with_vm(|vm| {
115-
vm.env.get_ans_count()
116-
})
117-
}),
118-
"ask_external_data" => Function::new_native_with_env(&store, owasm_env.clone(), |env: &Environment<E>, eid: i64, did: i64, ptr: i64, len: i64| {
119-
env.with_mut_vm(|vm| {
120-
let span_size = vm.env.get_span_size();
121-
122-
if len > span_size {
123-
return Err(Error::SpanTooSmallError);
124-
}
125-
126-
// consume gas equal size of span when write calldata for raw request
127-
env.decrease_gas_left(span_size as u64)?;
128-
129-
let memory = env.memory()?;
130-
require_mem_range(memory.size().bytes().0, (ptr + span_size) as usize)?;
131-
132-
let data: Vec<u8> = memory.view()[ptr as usize..(ptr + len) as usize].iter().map(|cell| cell.get()).collect();
133-
vm.env.ask_external_data(eid, did, &data)
134-
})
135-
}),
136-
"get_external_data_status" => Function::new_native_with_env(&store, owasm_env.clone(), |env: &Environment<E>, eid: i64, vid: i64| {
137-
env.with_vm(|vm| {
138-
vm.env.get_external_data_status(eid, vid)
139-
})
140-
}),
141-
"read_external_data" => Function::new_native_with_env(&store, owasm_env.clone(), |env: &Environment<E>, eid: i64, vid: i64, ptr: i64| {
142-
env.with_mut_vm(|vm| -> Result<i64, Error>{
143-
let span_size = vm.env.get_span_size();
144-
// consume gas equal size of span when read data from report
145-
env.decrease_gas_left(span_size as u64)?;
146-
147-
let memory = env.memory()?;
148-
require_mem_range(memory.size().bytes().0, (ptr + span_size) as usize)?;
149-
150-
let data = vm.env.get_external_data(eid, vid)?;
151-
152-
for (idx, byte) in data.iter().enumerate() {
153-
memory.view()[ptr as usize + idx].set(*byte);
154-
}
155-
156-
Ok(data.len() as i64)
157-
})
158-
}),
159-
// "ecvrf_verify" => Function::new_native_with_env(&store, owasm_env.clone(), |env: &Environment<E>, y_ptr: i64, y_len: i64, pi_ptr: i64, pi_len: i64, alpha_ptr: i64, alpha_len: i64| {
160-
// env.with_mut_vm(|vm| -> Result<u32, Error>{
161-
// // consume gas relatively to the function running time (~12ms)
162-
// vm.consume_gas(500000)?;
163-
// env.decrease_gas_left(500000)?;
164-
165-
// let y: Vec<u8> = get_from_mem(env, y_ptr, y_len)?;
166-
// let pi: Vec<u8>= get_from_mem(env, pi_ptr, pi_len)?;
167-
// let alpha: Vec<u8> = get_from_mem(env, alpha_ptr, alpha_len)?;
168-
// Ok(ecvrf::ecvrf_verify(&y, &pi, &alpha) as u32)
169-
// })
170-
// }),
171-
},
172-
};
21+
let store = make_store();
22+
let import_object = create_import_object(&store, owasm_env.clone());
17323

17424
let instance = cache.get_instance(code, &store, &import_object)?;
17525
let instance_ptr = NonNull::from(&instance);
17626
owasm_env.set_wasmer_instance(Some(instance_ptr));
177-
owasm_env.set_gas_left(gas);
27+
owasm_env.set_gas_left(gas_limit);
17828

17929
// get function and exec
18030
let entry = if is_prepare { "prepare" } else { "execute" };
@@ -197,7 +47,7 @@ where
19747
})?;
19848

19949
match get_remaining_points(&instance) {
200-
MeteringPoints::Remaining(count) => Ok(gas.saturating_sub(count)),
50+
MeteringPoints::Remaining(count) => Ok(gas_limit.saturating_sub(count)),
20151
MeteringPoints::Exhausted => Err(Error::OutOfGasError),
20252
}
20353
}

‎packages/vm/src/imports.rs‎

Lines changed: 147 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,147 @@
1+
use wasmer::{imports, Function, ImportObject, Store};
2+
3+
use crate::{
4+
vm::{self, Environment},
5+
Error,
6+
};
7+
8+
// use owasm_crypto::ecvrf;
9+
10+
fn require_mem_range(max_range: usize, require_range: usize) -> Result<(), Error> {
11+
if max_range < require_range {
12+
return Err(Error::MemoryOutOfBoundError);
13+
}
14+
Ok(())
15+
}
16+
17+
pub fn create_import_object<E>(store: &Store, owasm_env: Environment<E>) -> ImportObject
18+
where
19+
E: vm::Env + 'static,
20+
{
21+
imports! {
22+
"env" => {
23+
"gas" => Function::new_native_with_env(&store, owasm_env.clone(), |env: &Environment<E>, _gas: u32| {
24+
env.decrease_gas_left(1)
25+
}),
26+
"get_span_size" => Function::new_native_with_env(&store, owasm_env.clone(), |env: &Environment<E>| {
27+
env.with_vm(|vm| {
28+
vm.env.get_span_size()
29+
})
30+
}),
31+
"read_calldata" => Function::new_native_with_env(&store, owasm_env.clone(), |env: &Environment<E>, ptr: i64| {
32+
env.with_mut_vm(|vm| -> Result<i64, Error>{
33+
let span_size = vm.env.get_span_size();
34+
// consume gas equal size of span when read calldata
35+
env.decrease_gas_left(span_size as u64)?;
36+
37+
let memory = env.memory()?;
38+
require_mem_range(memory.size().bytes().0, (ptr + span_size) as usize)?;
39+
40+
let data = vm.env.get_calldata()?;
41+
42+
for (idx, byte) in data.iter().enumerate() {
43+
memory.view()[ptr as usize + idx].set(*byte);
44+
}
45+
46+
Ok(data.len() as i64)
47+
})
48+
}),
49+
"set_return_data" => Function::new_native_with_env(&store, owasm_env.clone(), |env: &Environment<E>, ptr: i64, len: i64| {
50+
env.with_mut_vm(|vm| {
51+
let span_size = vm.env.get_span_size();
52+
53+
if len > span_size {
54+
return Err(Error::SpanTooSmallError);
55+
}
56+
57+
// consume gas equal size of span when save data to memory
58+
env.decrease_gas_left(span_size as u64)?;
59+
60+
let memory = env.memory()?;
61+
require_mem_range(memory.size().bytes().0, (ptr + span_size) as usize)?;
62+
63+
let data: Vec<u8> = memory.view()[ptr as usize..(ptr + len) as usize].iter().map(|cell| cell.get()).collect();
64+
vm.env.set_return_data(&data)
65+
})
66+
}),
67+
"get_ask_count" => Function::new_native_with_env(&store, owasm_env.clone(), |env: &Environment<E>| {
68+
env.with_vm(|vm| {
69+
vm.env.get_ask_count()
70+
})
71+
}),
72+
"get_min_count" => Function::new_native_with_env(&store, owasm_env.clone(), |env: &Environment<E>| {
73+
env.with_vm(|vm| {
74+
vm.env.get_min_count()
75+
})
76+
}),
77+
"get_prepare_time" => Function::new_native_with_env(&store, owasm_env.clone(), |env: &Environment<E>| {
78+
env.with_vm(|vm| {
79+
vm.env.get_prepare_time()
80+
})
81+
}),
82+
"get_execute_time" => Function::new_native_with_env(&store, owasm_env.clone(), |env: &Environment<E>| {
83+
env.with_vm(|vm| {
84+
vm.env.get_execute_time()
85+
})
86+
}),
87+
"get_ans_count" => Function::new_native_with_env(&store, owasm_env.clone(), |env: &Environment<E>| {
88+
env.with_vm(|vm| {
89+
vm.env.get_ans_count()
90+
})
91+
}),
92+
"ask_external_data" => Function::new_native_with_env(&store, owasm_env.clone(), |env: &Environment<E>, eid: i64, did: i64, ptr: i64, len: i64| {
93+
env.with_mut_vm(|vm| {
94+
let span_size = vm.env.get_span_size();
95+
96+
if len > span_size {
97+
return Err(Error::SpanTooSmallError);
98+
}
99+
100+
// consume gas equal size of span when write calldata for raw request
101+
env.decrease_gas_left(span_size as u64)?;
102+
103+
let memory = env.memory()?;
104+
require_mem_range(memory.size().bytes().0, (ptr + span_size) as usize)?;
105+
106+
let data: Vec<u8> = memory.view()[ptr as usize..(ptr + len) as usize].iter().map(|cell| cell.get()).collect();
107+
vm.env.ask_external_data(eid, did, &data)
108+
})
109+
}),
110+
"get_external_data_status" => Function::new_native_with_env(&store, owasm_env.clone(), |env: &Environment<E>, eid: i64, vid: i64| {
111+
env.with_vm(|vm| {
112+
vm.env.get_external_data_status(eid, vid)
113+
})
114+
}),
115+
"read_external_data" => Function::new_native_with_env(&store, owasm_env.clone(), |env: &Environment<E>, eid: i64, vid: i64, ptr: i64| {
116+
env.with_mut_vm(|vm| -> Result<i64, Error>{
117+
let span_size = vm.env.get_span_size();
118+
// consume gas equal size of span when read data from report
119+
env.decrease_gas_left(span_size as u64)?;
120+
121+
let memory = env.memory()?;
122+
require_mem_range(memory.size().bytes().0, (ptr + span_size) as usize)?;
123+
124+
let data = vm.env.get_external_data(eid, vid)?;
125+
126+
for (idx, byte) in data.iter().enumerate() {
127+
memory.view()[ptr as usize + idx].set(*byte);
128+
}
129+
130+
Ok(data.len() as i64)
131+
})
132+
}),
133+
// "ecvrf_verify" => Function::new_native_with_env(&store, owasm_env.clone(), |env: &Environment<E>, y_ptr: i64, y_len: i64, pi_ptr: i64, pi_len: i64, alpha_ptr: i64, alpha_len: i64| {
134+
// env.with_mut_vm(|vm| -> Result<u32, Error>{
135+
// // consume gas relatively to the function running time (~12ms)
136+
// vm.consume_gas(500000)?;
137+
// env.decrease_gas_left(500000)?;
138+
139+
// let y: Vec<u8> = get_from_mem(env, y_ptr, y_len)?;
140+
// let pi: Vec<u8>= get_from_mem(env, pi_ptr, pi_len)?;
141+
// let alpha: Vec<u8> = get_from_mem(env, alpha_ptr, alpha_len)?;
142+
// Ok(ecvrf::ecvrf_verify(&y, &pi, &alpha) as u32)
143+
// })
144+
// }),
145+
},
146+
}
147+
}

‎packages/vm/src/lib.rs‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -2,6 +2,8 @@ pub mod cache;
22
pub mod calls;
33
pub mod compile;
44
pub mod error;
5+
mod imports;
6+
mod store;
57
pub mod vm;
68

79
pub use calls::run;

‎packages/vm/src/store.rs‎

Lines changed: 17 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,17 @@
1+
use std::sync::Arc;
2+
3+
use wasmer::{Singlepass, Store, Universal, wasmparser::Operator, CompilerConfig};
4+
use wasmer_middlewares::Metering;
5+
6+
fn cost(_operator: &Operator) -> u64 {
7+
// A flat fee for each operation
8+
1
9+
}
10+
11+
pub fn make_store() -> Store {
12+
let mut compiler = Singlepass::new();
13+
let metering = Arc::new(Metering::new(0, cost));
14+
compiler.push_middleware(metering);
15+
let engine = Universal::new(compiler).engine();
16+
Store::new(&engine)
17+
}

0 commit comments

Comments
 (0)