epoch 490; switch to bintreev2

Author: vans163

ex/lib/consensus/models/entry.ex

@@ -128,6 +128,17 @@ defmodule Entry do
         if !is_list(e.txs), do: throw(%{error: :txs_not_list})
         if length(e.txs) > 100, do: throw(%{error: :TEMPORARY_txs_only_100_per_entry})
 
+        if !!Application.fetch_env!(:ama, :testnet) or eh.height >= RDBProtocol.forkheight() do
+          if !is_binary(eh.root_tx), do: throw(%{error: :root_tx_not_binary})
+          if byte_size(eh.root_tx) != 32, do: throw(%{error: :root_tx_not_256_bits})
+          if eh.root_tx != root_tx2(Enum.map(e.txs, & &1.hash)), do: throw(%{error: :root_tx_invalid})
+
+          if !is_binary(eh.root_validator), do: throw(%{error: :root_validator_not_binary})
+          if byte_size(eh.root_validator) != 32, do: throw(%{error: :root_validator_not_256_bits})
+          validators = DB.Chain.validators_for_height(eh.height)
+          validators_last_change_height = DB.Chain.validators_last_change_height(eh.height)
+          if eh.root_validator != root_validator2(validators, validators_last_change_height), do: throw(%{error: :root_validator_invalid})
+        else
         if !is_binary(eh.root_tx), do: throw(%{error: :root_tx_not_binary})
         if byte_size(eh.root_tx) != 32, do: throw(%{error: :root_tx_not_256_bits})
         if eh.root_tx != root_tx(Enum.map(e.txs, & &1.hash)), do: throw(%{error: :root_tx_invalid})
@@ -137,6 +148,7 @@ defmodule Entry do
         validators = DB.Chain.validators_for_height(eh.height)
         validators_last_change_height = DB.Chain.validators_last_change_height(eh.height)
         if eh.root_validator != root_validator(validators, validators_last_change_height), do: throw(%{error: :root_validator_invalid})
+        end
 
         is_special_meeting_block = !!e[:mask]
         steam = Task.async_stream(e.txs, fn txu ->
@@ -218,6 +230,22 @@ defmodule Entry do
         validators = DB.Chain.validators_for_height(next_height)
         validators_last_change_height = DB.Chain.validators_last_change_height(next_height)
 
+        if !!Application.fetch_env!(:ama, :testnet) or next_height >= RDBProtocol.forkheight() do
+          %{
+              header: %{
+                  slot: cur_entry.header.slot + 1,
+                  height: next_height,
+                  prev_slot: cur_entry.header.slot,
+                  prev_hash: cur_entry.hash,
+                  dr: dr,
+                  vr: vr,
+                  signer: pk,
+                  root_tx: root_tx2(Enum.map(txus, & &1.hash)),
+                  root_validator: root_validator2(validators, validators_last_change_height)
+              },
+              txs: txus
+          }
+        else
         %{
             header: %{
                 slot: cur_entry.header.slot + 1,
@@ -232,6 +260,7 @@ defmodule Entry do
             },
             txs: txus
         }
+        end
     end
 
     def sign(seed, entry) do
@@ -263,6 +292,16 @@ defmodule Entry do
       by_index_hash ++ [{"count", "#{length(hashes)}"}]
     end
 
+    def root_tx2(hashes) do
+      RDB.bintree_root2(root_tx_build2(hashes))
+    end
+    def root_tx_build2(hashes) do
+      by_index_hash = Enum.flat_map(Enum.with_index(hashes), fn{hash, index}->
+        [{nil, hash, "#{index}"}]
+      end)
+      by_index_hash ++ [{nil, "count", "#{length(hashes)}"}]
+    end
+
     def root_validator(validator_pks, last_change_height) do
       RDB.bintree_root(root_validator_build(validator_pks, last_change_height))
     end
@@ -274,6 +313,17 @@ defmodule Entry do
       kvs ++ [{"hash", :crypto.hash(:sha256, Enum.join(validator_pks))}, {"last_change_height", "#{last_change_height}"}]
     end
 
+    def root_validator2(validator_pks, last_change_height) do
+      RDB.bintree_root2(root_validator_build2(validator_pks, last_change_height))
+    end
+    def root_validator_build2(validator_pks, last_change_height) do
+      by_index_hash = Enum.flat_map(Enum.with_index(validator_pks), fn{hash, index}->
+        [{nil, hash, "#{index}"}]
+      end)
+      kvs = by_index_hash ++ [{nil, "count", "#{length(validator_pks)}"}]
+      kvs ++ [{nil, "hash", :crypto.hash(:sha256, Enum.join(validator_pks))}, {nil, "last_change_height", "#{last_change_height}"}]
+    end
+
     def root_block() do
       #TODO for future
       #proof of inclusion for previous blocks
@@ -282,8 +332,11 @@ defmodule Entry do
     def proof_tx_included(entry_hash, tx_hash) do
       entry = DB.Entry.by_hash(entry_hash)
       tx_hashes = Enum.map(entry.txs, & &1.hash)
-      kvs = root_tx_build(tx_hashes)
-      RDB.bintree_root_prove(kvs, tx_hash)
+      kvs = root_tx_build2(tx_hashes)
+      RDB.bintree_root_prove2(kvs, nil, tx_hash)
+
+      #p = Entry.proof_tx_included Base58.decode("BzF3P2a5gMpQ2FwAuiftHC85BnDfxcmYXPfW95BmNnXU"), Base58.decode("3ySbVoruCQsGb9K1XkRbQdm5WSuxnEoVCugAUj6qouS6")
+      #RDB.bintree_root_verify2(p, nil, Base58.decode("3ySbVoruCQsGb9K1XkRbQdm5WSuxnEoVCugAUj6qouS6"), "0")
     end
 
     def proof_validators(entry_hash) do

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

@@ -1,8 +1,17 @@
 use crate::consensus::bic::coin;
 use crate::consensus::consensus_kv;
 
-pub const FORKHEIGHT: u64 = 435_00000;
-//pub const FORKHEIGHT: u64 = 0;
+pub const FORKHEIGHT: u64 = 490_00000;
+//pub const FORKHEIGHT_TESTNET: u64 = 75_00000;
+pub const FORKHEIGHT_TESTNET: u64 = 100;
+
+pub fn forkheight(env: &crate::consensus::consensus_apply::ApplyEnv) -> u64 {
+    if env.testnet {
+        FORKHEIGHT_TESTNET
+    } else {
+        FORKHEIGHT
+    }
+}
 
 pub const AMA_1_DOLLAR: i128 = 1_000_000_000;
 pub const AMA_10_CENT: i128 =    100_000_000;
@@ -25,15 +34,15 @@ pub const COST_PER_DB_WRITE_BYTE: i128 = 250 * 10;
 pub const COST_PER_DB_WRITE_BYTE2: i128 = 250;
 
 pub fn cost_db_read_byte(env: &crate::consensus::consensus_apply::ApplyEnv) -> i128 {
-    if env.testnet {
+    if env.caller_env.entry_height >= forkheight(env) {
         COST_PER_DB_READ_BYTE2
     } else {
         COST_PER_DB_READ_BYTE
     }
 }
 
 pub fn cost_db_write_byte(env: &crate::consensus::consensus_apply::ApplyEnv) -> i128 {
-    if env.testnet {
+    if env.caller_env.entry_height >= forkheight(env) {
         COST_PER_DB_WRITE_BYTE2
     } else {
         COST_PER_DB_WRITE_BYTE
@@ -61,15 +70,6 @@ pub const WASM_MAX_GLOBALS: u32 = 100;
 pub const WASM_MAX_EXPORTS: u32 = 50;
 pub const WASM_MAX_IMPORTS: u32 = 50;
 
-#[derive(Clone, Debug)]
-pub struct ExecutionReceipt {
-    pub txid: Vec<u8>,
-    pub success: bool,
-    pub result: Vec<u8>,
-    pub exec_used: Vec<u8>,
-    pub logs: Vec<Vec<u8>>,
-}
-
 pub fn pay_cost(env: &mut crate::consensus::consensus_apply::ApplyEnv, cost: i128) {
     consensus_kv::kv_increment(env, &crate::bcat(&[b"account:", &env.caller_env.account_origin, b":balance:AMA"]), -cost);
     // Increment validator / burn