clean up apply_entry

Author: vans163

ex/lib/consensus/coordination/fabric_event_gen.ex

@@ -44,9 +44,9 @@ defmodule FabricEventGen do
     {:noreply, state}
   end
 
-  def handle_info({:entry, entry, muts_hash, muts, logs}, state) do
+  def handle_info({:entry, entry, muts_hash, muts, receipts}, state) do
     height = Entry.height(entry)
-    if logs != [] do
+    if receipts != [] do
       #IO.inspect {height, logs, muts}
     end
 

ex/lib/consensus/fabric_gen.ex

@@ -182,12 +182,12 @@ defmodule FabricGen do
       entry ->
         start_ts = :os.system_time(1000)
         task = Task.async(fn -> FabricGen.apply_entry(entry) end)
-        %{error: :ok, mutations_hash: m_hash, logs: l, muts: m
+        %{error: :ok, mutations_hash: m_hash, receipts: r, muts: m
         } = case Task.await(task, :infinity) do
           result = %{error: :ok} -> result
         end
 
-        FabricEventGen.event_applied(entry, m_hash, m, l)
+        FabricEventGen.event_applied(entry, m_hash, m, r)
         TXPool.delete_packed(entry.txs)
 
         proc_entries()
@@ -294,22 +294,8 @@ defmodule FabricGen do
       %{db: db, cf: cf} = :persistent_term.get({:rocksdb, Fabric})
 
       entry = next_entry
-      next_entry_trimmed_map = %{
-          entry_signer: entry.header.signer,
-          entry_prev_hash: entry.header.prev_hash,
-          entry_vr: entry.header.vr,
-          entry_vr_b3: Blake3.hash(entry.header.vr),
-          entry_dr: entry.header.dr,
-          entry_slot: entry.header.slot,
-          entry_prev_slot: entry.header.prev_slot,
-          entry_height: entry.header.height,
-          entry_epoch: div(entry.header.height, 100_000),
-      }
-
-      txus = Enum.map(entry.txs, & Map.merge(&1, %{tx_size: byte_size(RDB.vecpak_encode(&1)), tx_historical_cost: TX.historical_cost(entry.header.height, &1) }))
-      #IO.inspect txus, limit: 1111111111
-      {rtx, m, m_rev, l, receipts, root_receipts, root_contractstate} = RDB.apply_entry(db, next_entry_trimmed_map,
-        Application.fetch_env!(:ama, :trainer_pk), Application.fetch_env!(:ama, :trainer_sk), txus,
+      {rtx, m, m_rev, receipts, root_receipts, root_contractstate} = RDB.apply_entry(db, RDB.vecpak_encode(entry),
+        Application.fetch_env!(:ama, :trainer_pk), Application.fetch_env!(:ama, :trainer_sk),
         !!Application.fetch_env!(:ama, :testnet), Map.keys(Application.fetch_env!(:ama, :keys_by_pk))
       )
       rebuild_m_fn = fn(m)->
@@ -323,14 +309,8 @@ defmodule FabricGen do
           end
         end)
       end
-      rebuild_l_fn = fn(m)->
-        Enum.map(m, fn(inner)->
-          %{error: IO.iodata_to_binary(inner["error"]), exec_used: IO.iodata_to_binary(inner["exec_used"])}
-        end)
-      end
       m = rebuild_m_fn.(m)
       m_rev = rebuild_m_fn.(m_rev)
-      l = rebuild_l_fn.(l)
 
       #receipts != [] && IO.inspect receipts
       #IO.inspect {entry.header.height, :erlang.crc32(root_receipts), :erlang.crc32(root_contractstate)}
@@ -384,6 +364,6 @@ defmodule FabricGen do
 
       :ok = RocksDB.transaction_commit(rtx)
 
-      %{error: :ok, mutations_hash: mutations_hash, logs: l, muts: m}
+      %{error: :ok, mutations_hash: mutations_hash, muts: m, receipts: receipts}
   end
 end

ex/lib/consensus/models/tx.ex

@@ -73,8 +73,7 @@ defmodule TX do
       if !BlsEx.verify?(txu.tx.signer, txu.signature, txu.hash, BLS12AggSig.dst_tx()), do: throw(%{error: :invalid_signature})
 
       if !is_integer(txu.tx.nonce), do: throw(%{error: :nonce_not_integer})
-      if txu.tx.nonce > 99_999_999_999_999_999_999, do: throw(%{error: :nonce_too_high})
-
+      if txu.tx.nonce > 18_446_744_073_709_551_615, do: throw(%{error: :nonce_too_high})
       if !is_map(action), do: throw(%{error: :action_must_be_map})
       if action[:op] != "call", do: throw %{error: :op_must_be_call}
       if !is_binary(action[:contract]), do: throw %{error: :contract_must_be_binary}

ex/lib/native/rdb.ex

@@ -43,7 +43,7 @@ defmodule RDB do
   def transaction_iterator_cf(_tx, _cf), do: :erlang.nif_error(:nif_not_loaded)
   def transaction_iterator_move(_it, _action), do: :erlang.nif_error(:nif_not_loaded)
 
-  def apply_entry(_db, _next_entry_trimmed_map, _pk, _sk, _txus, _testnet, _testnet_peddlebike), do: :erlang.nif_error(:nif_not_loaded)
+  def apply_entry(_db, _entry, _pk, _sk, _testnet, _testnet_peddlebike), do: :erlang.nif_error(:nif_not_loaded)
 
   def vecpak_encode(_map), do: :erlang.nif_error(:nif_not_loaded)
   def vecpak_decode(_bin), do: :erlang.nif_error(:nif_not_loaded)

ex/native/rdb/src/atoms.rs

@@ -33,6 +33,7 @@ rustler::atoms! {
     entry_prev_slot,
     entry_height,
     entry_epoch,
+    entry_full,
 
     tx,
     tx_encoded,
@@ -54,7 +55,6 @@ rustler::atoms! {
 
     tx_cost,
     tx_historical_cost,
-    tx_size,
 
     direction,
     root,

ex/native/rdb/src/consensus/bic/protocol.rs

@@ -57,3 +57,10 @@ pub fn pay_cost(env: &mut crate::consensus::consensus_apply::ApplyEnv, cost: i12
     consensus_kv::kv_increment(env, &crate::bcat(&[b"account:", &env.caller_env.entry_signer, b":balance:AMA"]), cost/2);
     consensus_kv::kv_increment(env, &crate::bcat(&[b"account:", &coin::BURN_ADDRESS, b":balance:AMA"]), cost/2);
 }
+
+pub fn tx_historical_cost(txu: &crate::model::tx::TXU) -> i128 {
+    std::cmp::max(
+            AMA_1_CENT,
+            COST_PER_BYTE_HISTORICAL * crate::model::tx::to_bytes_tx(&txu.tx).unwrap().len() as i128,
+        )
+}

ex/native/rdb/src/consensus/bic/wasm.rs

@@ -636,12 +636,6 @@ pub fn setup_wasm_instance(env: &mut ApplyEnv, module: &Module, store: &mut Stor
 
 
 /*
-            "import_attach" => Function::new_typed_with_env(&mut store, &host_env, import_attach_implementation),
-
-            "import_call_1" => Function::new_typed_with_env(&mut store, &host_env, import_call_1_implementation),
-            "import_call_2" => Function::new_typed_with_env(&mut store, &host_env, import_call_2_implementation),
-            "import_call_3" => Function::new_typed_with_env(&mut store, &host_env, import_call_3_implementation),
-            "import_call_4" => Function::new_typed_with_env(&mut store, &host_env, import_call_4_implementation),
 
             //storage
             "import_kv_clear" => Function::new_typed_with_env(&mut store, &host_env, import_storage_kv_clear_implementation),
@@ -745,7 +739,7 @@ pub fn call_contract(env: &mut ApplyEnv, wasm_bytes: &[u8], function_name: Strin
     let start = Instant::now();
     let call_result = entry_to_call.call(&mut store, &wasm_args);
     let duration = start.elapsed();
-    println!("call result {} {:?}", duration.as_millis(), call_result);
+    //println!("call result {} {:?}", duration.as_millis(), call_result);
 
     let remaining = match get_remaining_points(&mut store, &instance) {
         MeteringPoints::Remaining(v) => v,

ex/native/rdb/src/consensus/consensus_apply.rs

@@ -104,12 +104,11 @@ impl<'db> ApplyEnv<'db> {
         Transaction<'db, TransactionDB<MultiThreaded>>,
         Vec<consensus_muts::Mutation>,
         Vec<consensus_muts::Mutation>,
-        Vec<HashMap<String, String>>,
         Vec<protocol::ExecutionReceipt>,
         [u8; 32],
         [u8; 32],
     ) {
-        (self.txn, self.muts_final, self.muts_final_rev, self.result_log, self.receipts, root_receipts, root_contractstate)
+        (self.txn, self.muts_final, self.muts_final_rev, self.receipts, root_receipts, root_contractstate)
     }
 }
 
@@ -155,28 +154,37 @@ pub fn set_apply_env_tx<'db>(env: &mut ApplyEnv<'db>, tx_hash: &[u8; 32], tx_sig
     env.caller_env.account_origin = tx_signer.to_vec();
 }
 
-pub fn apply_entry<'db, 'a>(db: &'db TransactionDB<MultiThreaded>, pk: &[u8], sk: &[u8],
-    entry_signer: &[u8; 48], entry_prev_hash: &[u8; 32],
-    entry_slot: u64, entry_prev_slot: u64, entry_height: u64, entry_epoch: u64,
-    entry_vr: &[u8; 96], entry_vr_b3: &[u8; 32], entry_dr: &[u8; 32],
-    txus: Vec<rustler::Term<'a>>, txn: Transaction<'db, TransactionDB<MultiThreaded>>,
+pub fn apply_entry<'db, 'a>(db: &'db TransactionDB<MultiThreaded>, txn: Transaction<'db, TransactionDB<MultiThreaded>>,
+    entry: crate::model::entry::Entry, pk: &[u8], sk: &[u8],
     testnet: bool, testnet_peddlebikes: Vec<Vec<u8>>,
-) -> (Transaction<'db, TransactionDB<MultiThreaded>>, Vec<consensus_muts::Mutation>, Vec<consensus_muts::Mutation>, Vec<HashMap<String, String>>, Vec<protocol::ExecutionReceipt>, [u8; 32], [u8; 32]) {
+) -> (Transaction<'db, TransactionDB<MultiThreaded>>, Vec<consensus_muts::Mutation>, Vec<consensus_muts::Mutation>, Vec<protocol::ExecutionReceipt>, [u8; 32], [u8; 32]) {
     let cf_h = db.cf_handle("contractstate").unwrap();
     let cf2_h = db.cf_handle("contractstate").unwrap();
     let cf_tree_h = db.cf_handle("contractstate_tree").unwrap();
+
+    let entry_signer = entry.header.signer.as_slice().try_into().unwrap_or_else(|_| panic!("entry_signer_len_wrong"));
+    let entry_prev_hash = entry.header.prev_hash.as_slice().try_into().unwrap_or_else(|_| panic!("entry_prev_hash_len_wrong"));
+    let entry_vr = entry.header.vr.as_slice().try_into().unwrap_or_else(|_| panic!("entry_vr_len_wrong"));
+    let entry_vr_b3_binding = blake3::hash(&entry.header.vr);
+    let entry_vr_b3 = entry_vr_b3_binding.as_bytes().try_into().unwrap_or_else(|_| panic!("entry_vr_len_wrong"));
+    let entry_dr = entry.header.dr.as_slice().try_into().unwrap_or_else(|_| panic!("entry_dr_len_wrong"));
+
+
+    let entry_epoch = entry.header.height / 100_000;
     let mut applyenv = make_apply_env(db, txn, cf_h, b"contractstate".to_vec(), cf2_h, cf_tree_h,
-        entry_signer, entry_prev_hash, entry_slot, entry_prev_slot, entry_height, entry_epoch, entry_vr, entry_vr_b3, entry_dr,
+        entry_signer, entry_prev_hash, entry.header.slot, entry.header.prev_slot, entry.header.height,
+        entry_epoch, entry_vr, entry_vr_b3, entry_dr,
         testnet, testnet_peddlebikes);
 
-    call_txs_pre_upfront_cost(&mut applyenv, &txus);
+    call_txs_pre_upfront_cost(&mut applyenv, &entry.txs);
 
-    for (i, txu) in txus.clone().into_iter().enumerate() {
-        let tx_hash = crate::fixed::<32>(txu.map_get(crate::atoms::hash()).unwrap()).unwrap();
-        let tx = txu.map_get(crate::atoms::tx()).unwrap();
-        let tx_signer = crate::fixed::<48>(tx.map_get(crate::atoms::signer()).unwrap()).unwrap();
-        let tx_nonce = tx.map_get(crate::atoms::nonce()).unwrap().decode::<u64>().unwrap();
-        let action = tx.map_get(crate::atoms::action()).unwrap().decode::<rustler::Term<'a>>().unwrap();
+    for (i, txu) in entry.txs.clone().into_iter().enumerate() {
+        let tx_historical_cost = crate::consensus::bic::protocol::tx_historical_cost(&txu);
+
+        let tx_hash = txu.hash.as_slice().try_into().unwrap_or_else(|_| panic!("tx_hash_len_wrong"));
+        let tx_signer = txu.tx.signer.as_slice().try_into().unwrap_or_else(|_| panic!("tx_signer_len_wrong"));
+        let tx_nonce = txu.tx.nonce;
+        let action = txu.tx.action;
 
         applyenv.caller_env.tx_index = i as u64;
         applyenv.caller_env.tx_hash = tx_hash;
@@ -186,24 +194,11 @@ pub fn apply_entry<'db, 'a>(db: &'db TransactionDB<MultiThreaded>, pk: &[u8], sk
         applyenv.caller_env.account_caller = tx_signer.to_vec();
 
         //let op = action.map_get(crate::atoms::op()).unwrap().decode::<rustler::Binary>().unwrap().as_slice();
-        let contract = action.map_get(crate::atoms::contract()).unwrap().decode::<rustler::Binary>().unwrap().to_vec();
-        let function = action.map_get(crate::atoms::function()).unwrap().decode::<rustler::Binary>().unwrap().to_vec();
-
-        let args = action.map_get(crate::atoms::args()).unwrap().decode::<Vec<rustler::Binary>>().unwrap().into_iter().map(|b| b.as_slice().to_vec()).collect();
-        let attached_symbol = match action.map_get(crate::atoms::attached_symbol()).ok() {
-            None => None,
-            Some(t) => match t.decode::<Option<rustler::Binary>>().ok().flatten() {
-                None => None,
-                Some(bin) => Some(bin.as_slice().to_vec()),
-            },
-        };
-        let attached_amount = match action.map_get(crate::atoms::attached_amount()).ok() {
-            None => None,
-            Some(t) => match t.decode::<Option<rustler::Binary>>().ok().flatten() {
-                None => None,
-                Some(bin) => Some(bin.as_slice().to_vec()),
-            },
-        };
+        let contract = action.contract;
+        let function = action.function;
+        let args = action.args;
+        let attached_symbol = action.attached_symbol.clone();
+        let attached_amount = action.attached_amount.clone();
 
         applyenv.caller_env.account_current = contract.to_vec();
         applyenv.muts = Vec::new();
@@ -234,7 +229,6 @@ pub fn apply_entry<'db, 'a>(db: &'db TransactionDB<MultiThreaded>, pk: &[u8], sk
 
         applyenv.exec_track = false;
 
-        let tx_historical_cost = txu.map_get(crate::atoms::tx_historical_cost()).unwrap().decode::<i128>().unwrap();
         let exec_cost_total = ((tx_historical_cost + (applyenv.exec_max - applyenv.exec_left) + (applyenv.storage_max - applyenv.storage_left)) as u64).to_string();
 
         match res {
@@ -318,7 +312,7 @@ pub fn apply_entry<'db, 'a>(db: &'db TransactionDB<MultiThreaded>, pk: &[u8], sk
 
     call_exit(&mut applyenv);
 
-    let root_receipts = root_receipts(txus.clone(), applyenv.result_log.clone());
+    let root_receipts = root_receipts(entry.txs.clone(), applyenv.result_log.clone());
     let root_contractstate = update_and_root_contractstate(&mut applyenv);
 
     //println!("r{:?} {}", applyenv.caller_env.entry_height, root_receipts(txus.clone(), applyenv.result_log.clone()).iter().map(|b| format!("{:02x}", b)).collect::<String>() );
@@ -376,15 +370,15 @@ fn update_and_root_contractstate(applyenv: &mut ApplyEnv) -> [u8; 32] {
     root_contractstate
 }
 
-fn root_receipts(txus: Vec<rustler::Term>, result_log: Vec<HashMap<String, String>>) -> [u8; 32] {
+fn root_receipts(txus: Vec<crate::model::tx::TXU>, result_log: Vec<HashMap<String, String>>) -> [u8; 32] {
     use sha2::{Sha256, Digest};
     let mut hubt = bintree::Hubt::new();
     let mut kvs = Vec::new();
 
     let count = txus.len();
 
     for (txu, log) in txus.into_iter().zip(result_log.into_iter()) {
-        let tx_hash = crate::fixed::<32>(txu.map_get(crate::atoms::hash()).unwrap()).unwrap();
+        let tx_hash = txu.hash;
 
         let error = log.get("error")
             .expect("no_error_key_in_receipt")
@@ -476,27 +470,22 @@ fn refund_exec_storage_deposit(applyenv: &mut ApplyEnv) {
     applyenv.muts_final_rev.append(&mut applyenv.muts_rev);
 }
 
-fn call_txs_pre_upfront_cost<'a>(env: &mut ApplyEnv, txus: &[rustler::Term<'a>]) {
+fn call_txs_pre_upfront_cost<'a>(env: &mut ApplyEnv, txus: &[crate::model::tx::TXU]) {
     env.muts = Vec::new();
     env.muts_rev = Vec::new();
     for txu in txus {
-        let tx_hash = crate::fixed::<32>(txu.map_get(crate::atoms::hash()).unwrap()).unwrap();
-        let tx = txu.map_get(crate::atoms::tx()).unwrap();
-        let tx_signer = crate::fixed::<48>(tx.map_get(crate::atoms::signer()).unwrap()).unwrap();
-        let tx_nonce = tx.map_get(crate::atoms::nonce()).unwrap().decode::<u64>().unwrap();
+        let tx_hash = txu.hash.as_slice().try_into().unwrap_or_else(|_| panic!("tx_hash_len_wrong"));
+        let tx_signer = txu.tx.signer.as_slice().try_into().unwrap_or_else(|_| panic!("tx_signer_len_wrong"));
+        let tx_nonce = txu.tx.nonce;
 
         set_apply_env_tx(env, &tx_hash, &tx_signer, tx_nonce);
 
         // Update nonce
         consensus_kv::kv_put(env, &crate::bcat(&[b"account:", &tx_signer, b":attribute:nonce"]), &tx_nonce.to_string().into_bytes());
 
         // Deduct tx historical cost
-        let tx_historical_cost = txu.map_get(crate::atoms::tx_historical_cost()).unwrap().decode::<i128>().unwrap();
+        let tx_historical_cost = crate::consensus::bic::protocol::tx_historical_cost(txu);
         protocol::pay_cost(env, tx_historical_cost);
-        // Deduct fixed call costs
-        let action = tx.map_get(crate::atoms::action()).unwrap().decode::<rustler::Term<'a>>().unwrap();
-        let contract = action.map_get(crate::atoms::contract()).unwrap().decode::<rustler::Binary>().unwrap().to_vec();
-        let function = action.map_get(crate::atoms::function()).unwrap().decode::<rustler::Binary>().unwrap().to_vec();
 
         //lock 0.1 AMA during execution
         consensus_kv::kv_increment(env, &crate::bcat(&[b"account:", &env.caller_env.account_origin, b":balance:AMA"]), -protocol::AMA_10_CENT);
@@ -634,7 +623,6 @@ fn migrate_db(env: &mut ApplyEnv) {
     }
 }
 
-
 pub fn valid_bic_action(contract: Vec<u8>, function: Vec<u8>) -> bool {
     let c = contract.as_slice();
     let f = function.as_slice();

ex/native/rdb/src/lib.rs

@@ -675,26 +675,17 @@ pub fn fixed<const N: usize>(t: Term<'_>) -> Result<[u8; N], Error> {
 }
 
 #[rustler::nif(schedule = "DirtyCpu")]
-fn apply_entry<'a>(env: Env<'a>, db: ResourceArc<DbResource>, next_entry_trimmed_map: Term<'a>, pk: Binary, sk: Binary, txus: Vec<Term<'a>>,
-    testnet: bool, testnet_peddlebikes: Vec<Binary>) -> Result<Term<'a>, Error> {
-    let entry_signer = fixed::<48>(next_entry_trimmed_map.map_get(atoms::entry_signer())?)?;
-    let entry_prev_hash = fixed::<32>(next_entry_trimmed_map.map_get(atoms::entry_prev_hash())?)?;
-    let entry_vr = fixed::<96>(next_entry_trimmed_map.map_get(atoms::entry_vr())?)?;
-    let entry_vr_b3 = fixed::<32>(next_entry_trimmed_map.map_get(atoms::entry_vr_b3())?)?;
-    let entry_dr = fixed::<32>(next_entry_trimmed_map.map_get(atoms::entry_dr())?)?;
-
-    let entry_slot = next_entry_trimmed_map.map_get(atoms::entry_slot())?.decode::<u64>()?;
-    let entry_prev_slot = next_entry_trimmed_map.map_get(atoms::entry_prev_slot())?.decode::<u64>()?;
-    let entry_height = next_entry_trimmed_map.map_get(atoms::entry_height())?.decode::<u64>()?;
-    let entry_epoch = next_entry_trimmed_map.map_get(atoms::entry_epoch())?.decode::<u64>()?;
+fn apply_entry<'a>(env: Env<'a>, db: ResourceArc<DbResource>, entry_vecpak: Binary, pk: Binary, sk: Binary,
+    testnet: bool, testnet_peddlebikes: Vec<Binary>) -> Result<Term<'a>, Error>
+{
+    let entry = crate::model::entry::from_bytes(entry_vecpak.as_slice()).map_err(|_| Error::BadArg)?;
 
     let txn_opts = TransactionOptions::default();
     let write_opts = WriteOptions::default();
     let txn = db.db.transaction_opt(&write_opts, &txn_opts);
 
-    let (txn, muts, muts_rev, result_log, receipts, root_receipts, root_contractstate) =
-        consensus::consensus_apply::apply_entry(&db.db, pk.as_slice(), sk.as_slice(), &entry_signer, &entry_prev_hash,
-            entry_slot, entry_prev_slot, entry_height, entry_epoch, &entry_vr, &entry_vr_b3, &entry_dr, txus, txn,
+    let (txn, muts, muts_rev, receipts, root_receipts, root_contractstate) =
+        consensus::consensus_apply::apply_entry(&db.db, txn, entry, pk.as_slice(), sk.as_slice(),
             testnet, testnet_peddlebikes.iter().map(|bin| bin.as_slice().to_vec()).collect()
         );
 
@@ -723,7 +714,7 @@ fn apply_entry<'a>(env: Env<'a>, db: ResourceArc<DbResource>, next_entry_trimmed
         receipts_list.push(map);
     }
 
-    Ok((term_txn, consensus_muts::mutations_to_map(muts), consensus_muts::mutations_to_map(muts_rev), result_log, receipts_list,
+    Ok((term_txn, consensus_muts::mutations_to_map(muts), consensus_muts::mutations_to_map(muts_rev), receipts_list,
         Binary::from_owned(ob1, env).encode(env), Binary::from_owned(ob2, env).encode(env)).encode(env))
 }
 
@@ -957,7 +948,6 @@ fn contract_view<'a>(env: Env<'a>, db: ResourceArc<DbResource>, cur_entry_trimme
 fn protocol_constants<'a>(env: Env<'a>) -> Term<'a> {
     let mut map = Term::map_new(env);
 
-
     map = map.map_put(atoms::forkheight(), protocol::FORKHEIGHT).ok().unwrap();
 
     map = map.map_put(atoms::ama_1_dollar(), protocol::AMA_1_DOLLAR).ok().unwrap();