Add return data for process (#188)

* add cuda

* bugfix

* replace unwrap with proper error handle in state_storage

* ADD: system contract test.

* ADD: test data for sys-contract debug.

* Add error handle in zk-vm

* MOD: sys contract.

* MOD: init tape.

* MOD: sys contract.

* Deal error handle in executor

* FIX: tape init.

* MOD: debug sys contracts.

* update ntt logic

* MOD: sys contracts.

* remove Drop for OlaStark

* add remark to fri_proof_of_work

* FIX: bytes poseidon.

* ADD: finish_batch.

* error handle progressing

* error handle: use for loop instead of iterator fold

* error handle: mutex lock

* update execute tx and return result

* MOD: StorageQuery add block_timestamp.

* error handling progressing

* error handling progressing

* MOD: StorageQuery add pre_value and init_write type.

* bugfix

* error handling for executor module

* error handle: remove panic in executor module

* error handle progressing

* FIX: callee exe code when init tape.

* error handle

* FIX: addr params.

* Error handle for UpdatesBatch

* FIX: missing StorageQueries.

* error handle progressing

* fmt code

* fix typos

* fix some warnings

* fix bug

* Update system contract json

* Refactor code

* Refactor code

* Save data in tape when tstore, remove it when sccall

* FIX: storage cache.

* refactor code

* remove useless commemnt

---------

Co-authored-by: peinlcy <peinlcy@gmail.com>
Co-authored-by: web3Softcloud <renzhexin@web3.com>
Co-authored-by: Softcloud <Softcloud1988@gmail.com>

core/src/state/mod.rs

@@ -1,5 +1,6 @@
 use crate::crypto::hash::Hasher;
 use crate::merkle_tree::log::StorageQuery;
+use crate::merkle_tree::log::StorageQuery;
 use crate::state::contracts::Contracts;
 use std::collections::BTreeMap;
 

executor/src/lib.rs

@@ -8,6 +8,7 @@ use core::vm::memory::{MemoryTree, HP_START_ADDR, PSP_START_ADDR};
 
 use core::merkle_tree::log::{StorageLog, StorageQuery};
 use core::merkle_tree::log::{StorageLogKind, WitnessStorageLog};
+use core::merkle_tree::tree::AccountTree;
 
 use core::program::instruction::IMM_INSTRUCTION_LEN;
 use core::program::instruction::{ImmediateOrRegName, Opcode};
@@ -249,6 +250,7 @@ pub struct Process {
 impl Process {
     pub fn new() -> Self {
         Self {
+            block_timestamp: 0,
             block_timestamp: 0,
             env_idx: Default::default(),
             call_sc_cnt: Default::default(),
@@ -1905,8 +1907,10 @@ impl Process {
 
         if op1_value.0 == GoldilocksField::ONE {
             append_caller_callee_addr(self, self.addr_storage, callee_address, self.addr_storage);
+            append_caller_callee_addr(self, self.addr_storage, callee_address, self.addr_storage);
         } else if op1_value.0 == GoldilocksField::ZERO {
             append_caller_callee_addr(self, self.addr_storage, callee_address, callee_address);
+            append_caller_callee_addr(self, self.addr_storage, callee_address, callee_address);
         } else {
             return Err(ProcessorError::ParseOpcodeError);
         }

executor/src/load_tx.rs

@@ -86,9 +86,28 @@ load_ctx_to_tape!(load_tx_context, TxCtxInfo);
 //     process.tp += GoldilocksField::from_canonical_u64(ctx_addr_len as u64);
 // }
 
+// pub fn init_tape(
+//     process: &mut Process,
+//     mut calldata: Vec<GoldilocksField>,
+//     caller_exe_addr: Address,
+//     callee_addr: Address,
+//     callee_exe_addr: Address,
+//     ctx_info: &TxCtxInfo,
+// ) {
+//     let tp_start = load_tx_context(process, ctx_info);
+//     process.tp = GoldilocksField::from_canonical_u64(tp_start as u64);
+//     load_tx_calldata(process, &calldata);
+//     let ctx_addr_len = load_ctx_addr_info(
+//         process,
+//         &init_ctx_addr_info(caller_exe_addr, callee_addr, callee_exe_addr),
+//     );
+//     process.tp += GoldilocksField::from_canonical_u64(ctx_addr_len as u64);
+// }
+
 pub fn init_tape(
     process: &mut Process,
     calldata: Vec<GoldilocksField>,
+    calldata: Vec<GoldilocksField>,
     caller_exe_addr: Address,
     callee_addr: Address,
     callee_exe_addr: Address,

zk-vm/src/lib.rs

@@ -336,6 +336,7 @@ impl OlaVM {
             caller_addr,
             code_exe_addr,
             code_exe_addr,
+            code_exe_addr,
             &self.ctx_info,
         );
         let mut program = Program::default();
@@ -464,6 +465,7 @@ impl OlaVM {
                         }
                         self.ola_state.txs_trace.insert(env_id, trace);
                         self.ola_state.storage_queries.append(&mut storage_queries);
+                        self.ola_state.storage_queries.append(&mut storage_queries);
                         env_idx -= 1;
                         process.tp = tp;
                         process.tape = tape_tree;
@@ -498,4 +500,13 @@ impl OlaVM {
             false,
         )
     }
+
+    pub fn finish_batch(&mut self, block_number: u32) -> Result<(), StateError> {
+        let entry_point_addr = [0, 0, 0, 32769].map(|l| GoldilocksField::from_canonical_u64(l));
+        let calldata = [block_number as u64, 1, 2190639505]
+            .iter()
+            .map(|l| GoldilocksField::from_canonical_u64(*l))
+            .collect();
+        self.execute_tx(entry_point_addr, entry_point_addr, calldata, false)
+    }
 }