loading storage file and read code from the file

Author: b00f

tanour/src/contract.rs

@@ -48,7 +48,7 @@ impl Contract {
         let file_path = Path::new(&params.storage_path)
             .join(format!("{}.storage", crate::address_to_hex(address)));
         let storage_file = StorageFile::create(
-            file_path.to_str().unwrap(),
+            file_path.to_str().unwrap(), // TODO: no unwrap
             storage_size_in_mb,
             owner,
             current_block_no,
@@ -71,23 +71,30 @@ impl Contract {
         })
     }
 
-    // pub fn load(
-    //     provider: P,
-    //     address: &Address,
-    //     params: Params,
-    // ) -> Result<Self> {
-
-    //     let state = Arc::new(Mutex::new(State::new(provider, PAGE_SIZE)));
-    //     let executor =
-    //         wasmer::WasmerExecutor::new(code, memory_limit_page, metering_limit, state.clone())?;
-
-    //     Ok(Contract {
-    //         executor: Box::new(executor),
-    //         _state: state,
-    //         buffer: Vec::new(),
-    //         address: address.clone(),
-    //     })
-    // }
+    pub fn load(
+        blockchain_api: Box<dyn BlockchainAPI>,
+        address: &Address,
+        params: Params,
+    ) -> Result<Self> {
+        let file_path = Path::new(&params.storage_path)
+            .join(format!("{}.storage", crate::address_to_hex(address)));
+        let mut storage_file = StorageFile::load(file_path.to_str().unwrap())?;
+        let code = storage_file.read_code()?;
+        let state = Arc::new(Mutex::new(Provider::new(blockchain_api, storage_file)));
+        let executor = wasmer::WasmerExecutor::new(
+            &code,
+            params.memory_limit_page,
+            params.metering_limit,
+            state.clone(),
+        )?;
+
+        Ok(Contract {
+            executor: Box::new(executor),
+            _state: state,
+            buffer: Vec::new(),
+            _address: *address,
+        })
+    }
 
     fn call_exported_fn<'a, E: Encode<()>, D: Decode<'a, ()>>(
         &'a mut self,

tanour/src/storage_file.rs

@@ -1,8 +1,4 @@
-use crate::{
-    error::{Result},
-    page::Page,
-    Address,
-};
+use crate::{error::Result, page::Page, Address};
 use std::{
     collections::{hash_map::Entry, HashMap},
     io::Write,
@@ -22,8 +18,9 @@ struct Header {
     created_at: u32,
     valid_until: u32,
     code_offset: u32,
+    code_length: u32,
     data_offset: u32,
-    reserved: [u8; 88],
+    reserved: [u8; 84],
 }
 
 const PAGE_SIZE: u32 = 1024 * 1024; // 1 MB
@@ -53,8 +50,8 @@ impl StorageFile {
         file.write_all(&zeros)?;
 
         let code_offset = std::mem::size_of::<Header>() as u32;
-        let code_len = code.len() as u32;
-        let data_offset = code_offset + code_len + (128 - (code_len % 128));
+        let code_length = code.len() as u32;
+        let data_offset = code_offset + code_length + (128 - (code_length % 128));
 
         let header = Header {
             bom: 0x7374,
@@ -63,8 +60,9 @@ impl StorageFile {
             created_at,
             valid_until,
             code_offset,
+            code_length,
             data_offset,
-            reserved: [0; 88],
+            reserved: [0; 84],
         };
 
         file.rewind()?;
@@ -102,6 +100,14 @@ impl StorageFile {
         })
     }
 
+    pub fn read_code(&mut self) -> Result<Vec<u8>> {
+        let mut code = vec![0u8; self.header.code_length as usize];
+        self.file
+            .seek(SeekFrom::Start(self.header.code_offset as u64))?;
+        self.file.read_exact(&mut code)?;
+        Ok(code)
+    }
+
     pub fn read_storage(&mut self, offset: u32, length: u32) -> Result<Vec<u8>> {
         log::debug!("read_storage, offset: {offset}, length: {length}");
         let first_page = offset / PAGE_SIZE;