epoch 416 contractstate tree

Author: vans163

ex/lib/api/api_proof.ex

@@ -3,8 +3,8 @@ defmodule API.Proof do
     entry_hash = if byte_size(entry_hash) != 32, do: Base58.decode(entry_hash), else: entry_hash
     proof = Entry.proof_validators(entry_hash)
     %{
-      value: Base58.encode(proof.value),
       key: proof.key,
+      value: Base58.encode(proof.value),
       validators: Enum.map(proof.validators, & Base58.encode(&1)),
       proof: %{
         root: Base58.encode(proof.proof.root),
@@ -17,6 +17,9 @@ defmodule API.Proof do
 
   def proof_contractstate(key) do
     %{db: db, cf: cf} = :persistent_term.get({:rocksdb, Fabric})
-    RDB.bintree_contractstate_root_prove(db, key)
+    proof = RDB.bintree_contractstate_root_prove(db, key)
+    #RDB.bintree_root_verify(proof, "bic:epoch:segment_vr_hash", "7")
+    #RDB.bintree_
+    #
   end
 end

ex/lib/api/db_api.ex

@@ -34,7 +34,7 @@ defmodule DB.API do
       "entry", "entry_meta",
       "attestation",
       "tx", "tx_account_nonce", "tx_receiver_nonce",
-      "contractstate"
+      "contractstate", "contractstate_tree"
     ]
     try do
       {:ok, db_ref, cf_ref_list} = RDB.open_transaction_db(path, cfs)
@@ -44,15 +44,15 @@ defmodule DB.API do
         entry_cf, entry_meta_cf,
         attestation_cf,
         tx_cf, tx_account_nonce_cf, tx_receiver_nonce_cf,
-        contractstate_cf
+        contractstate_cf, contractstate_tree_cf,
       ] = cf_ref_list
       cf = %{
         default: default_cf,
         sysconf: sysconf_cf,
         entry: entry_cf, entry_meta: entry_meta_cf,
         attestation: attestation_cf,
         tx: tx_cf, tx_account_nonce: tx_account_nonce_cf, tx_receiver_nonce: tx_receiver_nonce_cf,
-        contractstate: contractstate_cf
+        contractstate: contractstate_cf, contractstate_tree: contractstate_tree_cf
       }
       :persistent_term.put({:rocksdb, Fabric}, %{db: db_ref, cf_list: cf_ref_list, cf: cf, path: path})
     catch

ex/lib/api/db_chain.ex

@@ -114,6 +114,11 @@ defmodule DB.Chain do
     validator_for_height(height(db_opts) + 1, db_opts)
   end
 
+  def validators_removed(epoch, db_opts \\ %{}) do
+    vstart = validators_for_height(epoch * 100_000, db_opts)
+    vend = validators_for_height(epoch * 100_000 + 99_999, db_opts)
+    vstart -- vend
+  end
 
   #Rewind
   def rewind(target_hash) do
@@ -158,16 +163,20 @@ defmodule DB.Chain do
     Enum.reverse(m_rev)
     |> Enum.each(fn(mut)->
       op = :"#{mut.op}"
+      cf_table = case mut.table do
+        "contractstate" -> cf.contractstate
+        "contractstate_tree" -> cf.contractstate_tree
+      end
       case op do
         :put ->
-          RocksDB.put(mut.key, mut.value, %{rtx: db_opts.rtx, cf: cf.contractstate})
+          RocksDB.put(mut.key, mut.value, %{rtx: db_opts.rtx, cf: cf_table})
         :delete ->
-          RocksDB.delete(mut.key, %{rtx: db_opts.rtx, cf: cf.contractstate})
+          RocksDB.delete(mut.key, %{rtx: db_opts.rtx, cf: cf_table})
         :clear_bit ->
-          old_value = RocksDB.get(mut.key, %{rtx: db_opts.rtx, cf: cf.contractstate})
+          old_value = RocksDB.get(mut.key, %{rtx: db_opts.rtx, cf: cf_table})
           << left::size(mut.value), _old_bit::size(1), right::bitstring >> = old_value
           new_value = << left::size(mut.value), 0::size(1), right::bitstring >>
-          RocksDB.put(mut.key, new_value, %{rtx: db_opts.rtx, cf: cf.contractstate})
+          RocksDB.put(mut.key, new_value, %{rtx: db_opts.rtx, cf: cf_table})
       end
     end)
   end

ex/lib/consensus/consensus_kv.ex

@@ -207,9 +207,15 @@ defmodule ConsensusKV do
       end
     end
 
-    def hash_mutations(m) do
+    def hash_mutations(height, m) do
+        if height >= 416_00000 do
+          RDB.vecpak_encode(m)
+          |> Blake3.hash()
+        else
+        m = Enum.map(m, & Map.drop(&1, [:table]))
         RDB.vecpak_encode(m)
         |> Blake3.hash()
+        end
     end
 
     def merge_nested(left, right) do

ex/lib/consensus/fabric_gen.ex

@@ -314,22 +314,26 @@ defmodule FabricGen do
       txus = Enum.map(entry.txs, & Map.put(&1, :tx_cost, TX.exec_cost(0, &1)))
       {rtx, m, m_rev, l} = RDB.apply_entry(db, next_entry_trimmed_map,
         Application.fetch_env!(:ama, :trainer_pk), Application.fetch_env!(:ama, :trainer_sk), txus,
-        Application.fetch_env!(:ama, :testnet), Map.keys(Application.fetch_env!(:ama, :keys_by_pk))
+        !!Application.fetch_env!(:ama, :testnet), Map.keys(Application.fetch_env!(:ama, :keys_by_pk))
       )
       rebuild_m_fn = fn(m)->
         Enum.map(m, fn(inner)->
           op = :"#{IO.iodata_to_binary(inner[~c"op"])}"
           case op do
-            :set_bit -> %{op: op, key: IO.iodata_to_binary(inner[~c"key"]), value: :erlang.binary_to_integer("#{inner[~c"value"]}"), bloomsize: :erlang.binary_to_integer("#{inner[~c"bloomsize"]}")}
-            :clear_bit -> %{op: op, key: IO.iodata_to_binary(inner[~c"key"]), value: :erlang.binary_to_integer("#{inner[~c"value"]}")}
-            :delete -> %{op: op, key: IO.iodata_to_binary(inner[~c"key"])}
-            :put -> %{op: op, key: IO.iodata_to_binary(inner[~c"key"]), value: IO.iodata_to_binary(inner[~c"value"])}
+            :set_bit -> %{op: op, table: IO.iodata_to_binary(inner[~c"table"]), key: IO.iodata_to_binary(inner[~c"key"]), value: :erlang.binary_to_integer("#{inner[~c"value"]}"), bloomsize: :erlang.binary_to_integer("#{inner[~c"bloomsize"]}")}
+            :clear_bit -> %{op: op, table: IO.iodata_to_binary(inner[~c"table"]), key: IO.iodata_to_binary(inner[~c"key"]), value: :erlang.binary_to_integer("#{inner[~c"value"]}")}
+            :delete -> %{op: op, table: IO.iodata_to_binary(inner[~c"table"]), key: IO.iodata_to_binary(inner[~c"key"])}
+            :put -> %{op: op, table: IO.iodata_to_binary(inner[~c"table"]), key: IO.iodata_to_binary(inner[~c"key"]), value: IO.iodata_to_binary(inner[~c"value"])}
           end
         end)
       end
       rebuild_l_fn = fn(m)->
         Enum.map(m, fn(inner)->
+          if entry.header.height >= 416_00000 do
+            %{error: IO.iodata_to_binary(inner["error"]), gas_used: IO.iodata_to_binary(inner["gas_used"])}
+          else
           %{error: :"#{IO.iodata_to_binary(inner["error"])}"}
+          end
         end)
       end
       m = rebuild_m_fn.(m)
@@ -345,7 +349,7 @@ defmodule FabricGen do
       #m = m ++ m_exit
       #m_rev = m_rev ++ m_exit_rev
 
-      mutations_hash = ConsensusKV.hash_mutations(l ++ m)
+      mutations_hash = ConsensusKV.hash_mutations(next_entry.header.height, l ++ m)
 
       RocksDB.put("temporal_tip", next_entry.hash, %{rtx: rtx, cf: cf.sysconf})
 

ex/lib/consensus/models/consensus.ex

@@ -19,6 +19,11 @@ defmodule Consensus do
           mask_set_size: 99
         }
       }
+
+      entry_hash
+      root_blocks
+      root_contractstate
+      root_receipts
     """
 
     def validate_vs_chain(c) do

ex/lib/consensus/models/tx.ex

@@ -80,6 +80,7 @@ defmodule TX do
       if !is_binary(action[:contract]), do: throw %{error: :contract_must_be_binary}
       if !is_binary(action[:function]), do: throw %{error: :function_must_be_binary}
       if !is_list(action[:args]), do: throw %{error: :args_must_be_list}
+      if length(action.args) > 16, do: throw %{error: :args_length_cannot_exceed_16}
       Enum.each(action.args, fn(arg)->
         if !is_binary(arg), do: throw(%{error: :arg_must_be_binary})
       end)

ex/lib/misc/rocksdb.ex

@@ -214,6 +214,9 @@ defmodule RocksDB do
       d = RocksDB.dump(cf.contractstate)
       dd = inspect d, limit: 1111111111111111111, pretty: true
       File.write! "/tmp/amastate", dd
+      d = RocksDB.dump(cf.contractstate_tree)
+      dd = inspect d, limit: 1111111111111111111, pretty: true
+      File.write! "/tmp/amastate_tree", dd
     end
 
     def dump(cf) do

ex/lib/native/rdb.ex

@@ -52,6 +52,6 @@ defmodule RDB do
 
   def bintree_root(_propslist), do: :erlang.nif_error(:nif_not_loaded)
   def bintree_root_prove(_propslist, _key), do: :erlang.nif_error(:nif_not_loaded)
-  def bintree_root_verify(_proof, _key, _value), do: :erlang.nif_error(:nif_not_loaded)
+  def bintree_root_verify(_proof, _ns, _key, _value), do: :erlang.nif_error(:nif_not_loaded)
   def bintree_contractstate_root_prove(_db, _key), do: :erlang.nif_error(:nif_not_loaded)
 end

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

@@ -11,6 +11,26 @@ const ZERO_HASH: Hash = [0u8; 32];
 // STRUCTS
 // ============================================================================
 
+/// The Universal Proof Struct.
+///
+/// - If `path` == sha256(key) and `hash` == sha256(key, value): It's an Inclusion Proof.
+/// - If `path` == sha256(key) and `hash` != sha256(key, value): It's a Mismatch Proof.
+/// - If `path` != sha256(key): It's a Non-Existence Proof (pointing to the closest ancestor).
+#[derive(Debug, Clone)]
+pub struct Proof {
+    pub root: Hash,
+    pub nodes: Vec<ProofNode>,
+    pub path: Path, // The path of the leaf node actually found in the tree
+    pub hash: Hash, // The hash of the leaf node actually found in the tree
+}
+
+/// A simplified proof node without length.
+#[derive(Debug, Clone)]
+pub struct ProofNode {
+    pub hash: Hash,
+    pub direction: u8
+}
+
 #[derive(Debug, Clone, PartialEq, Eq, Copy)]
 pub struct NodeKey {
     pub path: Path,
@@ -39,26 +59,6 @@ pub enum Op {
     Delete(Vec<u8>),
 }
 
-/// A simplified proof node without length.
-#[derive(Debug, Clone)]
-pub struct ProofNode {
-    pub hash: Hash,
-    pub direction: u8
-}
-
-/// The Universal Proof Struct.
-///
-/// - If `path` == sha256(key) and `hash` == sha256(key, value): It's an Inclusion Proof.
-/// - If `path` == sha256(key) and `hash` != sha256(key, value): It's a Mismatch Proof.
-/// - If `path` != sha256(key): It's a Non-Existence Proof (pointing to the closest ancestor).
-#[derive(Debug, Clone)]
-pub struct Proof {
-    pub root: Hash,
-    pub nodes: Vec<ProofNode>,
-    pub path: Path, // The path of the leaf node actually found in the tree
-    pub hash: Hash, // The hash of the leaf node actually found in the tree
-}
-
 #[derive(Debug, PartialEq)]
 pub enum VerifyStatus {
     Included,       // Key exists and Value matches
@@ -387,8 +387,8 @@ impl Hubt {
     // ========================================================================
 
     /// Verifies the proof and determines the relationship between the Key, Value, and the Tree.
-    pub fn verify(proof: &Proof, k: Vec<u8>, v: Vec<u8>) -> VerifyStatus {
-        let target_path = sha256(&k);
+    pub fn verify(proof: &Proof, ns: Option<&[u8]>, k: Vec<u8>, v: Vec<u8>) -> VerifyStatus {
+        let target_path = compute_namespace_path(ns, &k);
         let claimed_leaf_hash = concat_and_hash(&k, &v);
 
         // 1. Basic Integrity Check: Does the proof path/hash actually hash up to the Root?