truntime.rs - wasm-runtime - A wasm runtime
(HTM) git clone https://git.parazyd.org/wasm-runtime
(DIR) Log
(DIR) Files
(DIR) Refs
(DIR) README
(DIR) LICENSE
---
truntime.rs (6118B)
---
1 use anyhow::{anyhow, Result};
2 use drk_sdk::entrypoint;
3 use std::sync::{Arc, Mutex};
4 use wasmer::{
5 imports, wasmparser::Operator, CompilerConfig, Function, HostEnvInitError, Instance, LazyInit,
6 Memory, Module, Store, Universal, Value, WasmerEnv,
7 };
8 use wasmer_compiler_singlepass::Singlepass;
9 use wasmer_middlewares::{
10 metering::{get_remaining_points, MeteringPoints},
11 Metering,
12 };
13
14 use crate::{memory::MemoryManipulation, util::drk_log};
15
16 /// Function name in our wasm module that allows us to allocate some memory
17 const WASM_MEM_ALLOC: &str = "__drkruntime_mem_alloc";
18 /// Name of the wasm linear memory of our guest module
19 const MEMORY: &str = "memory";
20 /// Hardcoded entrypoint function of a contract
21 pub const ENTRYPOINT: &str = "entrypoint";
22 /// Gas limit for a contract
23 pub const GAS_LIMIT: u64 = 200000;
24
25 #[derive(Clone)]
26 pub struct Env {
27 pub logs: Arc<Mutex<Vec<String>>>,
28 pub memory: LazyInit<Memory>,
29 }
30
31 impl WasmerEnv for Env {
32 fn init_with_instance(
33 &mut self,
34 instance: &Instance,
35 ) -> std::result::Result<(), HostEnvInitError> {
36 let memory: Memory = instance.exports.get_with_generics_weak("memory")?;
37 self.memory.initialize(memory);
38 Ok(())
39 }
40 }
41
42 pub struct Runtime {
43 pub(crate) instance: Instance,
44 pub(crate) env: Env,
45 }
46
47 impl Runtime {
48 /// Create a new wasm runtime instance that contains the given wasm module.
49 pub fn new(wasm_bytes: &[u8]) -> Result<Self> {
50 // This function will be called for each `Operator` encountered during
51 // the wasm module execution. It should return the cost of the operator
52 // that it received as its first argument.
53 let cost_function = |operator: &Operator| -> u64 {
54 match operator {
55 Operator::LocalGet { .. } | Operator::I32Const { .. } => 1,
56 Operator::I32Add { .. } => 2,
57 _ => 0,
58 }
59 };
60
61 // `Metering` needs to be configured with a limit and a cost function.
62 // For each `Operator`, the metering middleware will call the cost
63 // function and subtract the cost from the remaining points.
64 let metering = Arc::new(Metering::new(GAS_LIMIT, cost_function));
65
66 // Define the compiler and middleware, engine, and store
67 let mut compiler = Singlepass::new();
68 compiler.push_middleware(metering);
69 let store = Store::new(&Universal::new(compiler).engine());
70
71 println!("Compiling module...");
72 let module = Module::new(&store, wasm_bytes)?;
73
74 println!("Importing functions...");
75 let env = Env { logs: Arc::new(Mutex::new(vec![])), memory: LazyInit::new() };
76 let import_object = imports! {
77 "env" => {
78 "drk_log_" => Function::new_native_with_env(
79 &store,
80 env.clone(),
81 drk_log,
82 ),
83 }
84 };
85
86 println!("Instantiating module...");
87 let instance = Instance::new(&module, &import_object)?;
88
89 Ok(Self { instance, env })
90 }
91
92 /// Run the hardcoded [ENTRYPOINT] function with the given payload as input.
93 pub fn run(&mut self, payload: &[u8]) -> Result<()> {
94 // Get module linear memory
95 let memory = self.memory()?;
96
97 // Retrieve ptr to pass data
98 let mem_offset = self.guest_mem_alloc(payload.len())?;
99 memory.write(mem_offset, payload)?;
100
101 println!("Getting entrypoint function...");
102 let entrypoint = self.instance.exports.get_function(ENTRYPOINT)?;
103 println!("{:#?}", entrypoint);
104
105 println!("Executing wasm...");
106
107 let ret = match entrypoint.call(&[Value::I32(mem_offset as i32)]) {
108 Ok(v) => {
109 self.print_logs();
110 println!("{}", self.gas_info());
111 v
112 }
113 Err(e) => {
114 self.print_logs();
115 println!("{}", self.gas_info());
116 return Err(e.into())
117 }
118 };
119
120 println!("Executed successfully");
121 println!("Contract returned: {:?}", ret[0]);
122
123 let retval = match ret[0] {
124 Value::I64(v) => v as u64,
125 _ => unreachable!(),
126 };
127
128 match retval {
129 entrypoint::SUCCESS => Ok(()),
130 _ => Err(anyhow!("Contract exited with an error: {0:#x}", retval)),
131 }
132 }
133
134 fn print_logs(&self) {
135 let logs = self.env.logs.lock().unwrap();
136 for msg in logs.iter() {
137 println!("Contract log: {}", msg);
138 }
139 }
140
141 fn gas_info(&self) -> String {
142 let remaining_points = get_remaining_points(&self.instance);
143 match remaining_points {
144 MeteringPoints::Remaining(rem) => {
145 format!("Gas used: {}/{}", GAS_LIMIT - rem, GAS_LIMIT)
146 }
147 MeteringPoints::Exhausted => {
148 format!("Gas fully exhausted: {}/{}", GAS_LIMIT + 1, GAS_LIMIT)
149 }
150 }
151 }
152
153 /// Allocate some memory space on a wasm linear memory to allow direct rw
154 fn guest_mem_alloc(&self, size: usize) -> Result<u32> {
155 let mem_alloc = self.instance.exports.get_function(WASM_MEM_ALLOC)?;
156 let res_target_ptr = mem_alloc.call(&[Value::I32(size as i32)])?.to_vec();
157 Ok(res_target_ptr[0].unwrap_i32() as u32)
158 }
159
160 /// Retrieve linear memory from a wasm module and return its reference
161 fn memory(&self) -> Result<&Memory> {
162 Ok(self.instance.exports.get_memory(MEMORY)?)
163 }
164 }
165
166 #[cfg(test)]
167 mod tests {
168 use super::*;
169 use crate::util::serialize_payload;
170
171 use borsh::BorshSerialize;
172 use pasta_curves::pallas;
173 use smart_contract::Args;
174
175 #[test]
176 fn run_contract() -> Result<()> {
177 let wasm_bytes = std::fs::read("smart_contract.wasm")?;
178 let mut runtime = Runtime::new(&wasm_bytes)?;
179
180 let args = Args { a: pallas::Base::from(777), b: pallas::Base::from(666) };
181 let payload = args.try_to_vec()?;
182
183 let input = serialize_payload(&payload);
184
185 runtime.run(&input)
186 }
187 }