fix testnet bugs; add bintree sample;

Author: vans163

ex/build_clean.sh

@@ -1,7 +1,5 @@
 #!/bin/bash
 
-#&& export ERL_COMPILER_OPTIONS=bin_opt_info \
-
 podman run -it --rm -v ../.:/root/node --entrypoint bash erlang_builder -c "echo 'building amadeus..' \
     && cd /tmp \
     && git clone https://github.com/amadeusprotocol/node \

ex/lib/api/api_proof.ex

@@ -7,11 +7,16 @@ defmodule API.Proof do
       key: proof.key,
       validators: Enum.map(proof.validators, & Base58.encode(&1)),
       proof: %{
-        nodes: Enum.map(proof.proof.nodes, & %{direction: &1.direction, hash: Base58.encode(&1.hash)}),
+        root: Base58.encode(proof.proof.root),
         path: Base58.encode(proof.proof.path),
-        path: Base58.encode(proof.proof.root),
-        path: Base58.encode(proof.proof.hash),
+        hash: Base58.encode(proof.proof.hash),
+        nodes: Enum.map(proof.proof.nodes, & %{direction: &1.direction, hash: Base58.encode(&1.hash)}),
       }
     }
   end
+
+  def proof_contractstate(key) do
+    %{db: db, cf: cf} = :persistent_term.get({:rocksdb, Fabric})
+    RDB.bintree_contractstate_root_prove(db, key)
+  end
 end

ex/lib/api/api_tx.ex

@@ -185,7 +185,7 @@ defmodule API.TX do
                 true -> Base58.encode(arg)
             end
         end)
-        Map.put(action, :args, args)
+        action = Map.put(action, :args, args)
 
         tx = put_in(tx, [:tx, :action], action)
 

ex/lib/bic/base.ex

@@ -1,59 +1,13 @@
 defmodule BIC.Base do
     import ConsensusKV
 
-    def exec_cost(epoch, txu) do
-        bytes = byte_size(txu.tx_encoded) + 32 + 96
-        BIC.Coin.to_cents( 1 + div(bytes, 1024) * 1 )
-
-        #for future update
-        #BIC.Coin.to_tenthousandth( 18 + div(bytes, 256) * 3 )
-    end
-
     def seed_random(vr, txhash, action_index, call_cnt) do
         seed_bin = <<seed::256-little>> = Blake3.hash(
             <<vr::binary, txhash::binary, action_index::binary, call_cnt::binary>>)
         :rand.seed(:exsss, seed)
         seed_bin
     end
 
-    def call_txs_pre_parallel(env, txus) do
-        Process.delete(:mutations)
-        Process.delete(:mutations_reverse)
-
-        Enum.each(txus, fn(txu)->
-            kv_put("bic:base:nonce:#{txu.tx.signer}", txu.tx.nonce, %{to_integer: true})
-            exec_cost = exec_cost(env.entry_epoch, txu)
-            kv_increment("bic:coin:balance:#{txu.tx.signer}:AMA", -exec_cost)
-
-            #burn 50% to prevent MEV/FreeChainGrowth attack
-            half_exec_cost = div(exec_cost, 2)
-            kv_increment("bic:coin:balance:#{env.entry_signer}:AMA", half_exec_cost)
-            kv_increment("bic:coin:balance:#{BIC.Coin.burn_address()}:AMA", half_exec_cost)
-        end)
-
-        #parallel verify sols
-        segment_vr_hash = kv_get("bic:epoch:segment_vr_hash")
-        diff_bits = kv_get("bic:epoch:diff_bits", %{to_integer: true}) || 24
-        steam = Task.async_stream(txus, fn txu ->
-            sol = Enum.find_value(txu.tx.actions, fn(a)-> a.function == "submit_sol" and length(a.args) != [] and hd(a.args) end)
-            if sol do
-              hash = Blake3.hash(sol)
-              opts = %{hash: hash, vr_b3: env.entry_vr_b3, segment_vr_hash: segment_vr_hash, diff_bits: diff_bits}
-              valid = try do BIC.Sol.verify(sol, opts) catch _,_ -> false end
-              %{hash: hash, valid: valid}
-            end
-        end)
-
-        sol_verified_cache = for {error, spec} <- steam,
-          error == :ok and spec != nil,
-          into: %{},
-          do: {spec.hash, spec.valid}
-
-        Process.put(SolVerifiedCache, sol_verified_cache)
-
-        {Process.get(:mutations, []), Process.get(:mutations_reverse, [])}
-    end
-
     def call_exit(env) do
         Process.delete(:mutations)
         Process.delete(:mutations_reverse)

ex/lib/consensus/fabric_gen.ex

@@ -312,7 +312,10 @@ 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)
+      {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))
+      )
       rebuild_m_fn = fn(m)->
         Enum.map(m, fn(inner)->
           op = :"#{IO.iodata_to_binary(inner[~c"op"])}"
@@ -333,6 +336,8 @@ defmodule FabricGen do
       m_rev = rebuild_m_fn.(m_rev)
       l = rebuild_l_fn.(l)
 
+      #IO.inspect Enum.map(m, & Map.put(&1, :key, RocksDB.ascii_dump(&1.key))), limit: 11111111111
+
       #call the exit
       Process.put({RocksDB, :ctx}, %{rtx: rtx, cf: cf})
       #mapenv = make_mapenv(next_entry)

ex/lib/misc/rocksdb.ex

@@ -209,6 +209,13 @@ defmodule RocksDB do
       :ok = RDB.transaction_rollback(rtx)
     end
 
+    def dumpstate() do
+      %{db: db, cf: cf} = :persistent_term.get({:rocksdb, Fabric})
+      d = RocksDB.dump(cf.contractstate)
+      dd = inspect d, limit: 1111111111111111111, pretty: true
+      File.write! "/tmp/amastate", dd
+    end
+
     def dump(cf) do
         {:ok, it} = RDB.iterator_cf(cf)
         res = RDB.iterator_move(it, :first)

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), 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 vecpak_encode(_map), do: :erlang.nif_error(:nif_not_loaded)
   def vecpak_decode(_bin), do: :erlang.nif_error(:nif_not_loaded)
@@ -53,4 +53,5 @@ 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_contractstate_root_prove(_db, _key), do: :erlang.nif_error(:nif_not_loaded)
 end

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

@@ -284,7 +284,10 @@ pub fn call_slash_trainer(env: &mut crate::consensus::consensus_apply::ApplyEnv,
 pub fn next(env: &mut ApplyEnv) {
     let epoch_cur = env.caller_env.entry_epoch;
     let epoch_next = env.caller_env.entry_epoch + 1;
-    let peddlebike67_map: HashSet<Vec<u8>> = PEDDLEBIKE67.iter().map(|pk| pk.to_vec()).collect();
+    let mut peddlebike67_map: HashSet<Vec<u8>> = PEDDLEBIKE67.iter().map(|pk| pk.to_vec()).collect();
+    if env.testnet {
+        peddlebike67_map = env.testnet_peddlebikes.iter().map(|pk| pk.to_vec()).collect();
+    }
 
     // slash sols for malicious trainers
     //let trainers = kv_get_trainers(env, &bcat(&[b"bic:epoch:trainers:", epoch_cur.to_string().as_bytes()]));

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

@@ -67,6 +67,24 @@ pub enum VerifyStatus {
     Invalid,        // The proof itself is mathematically invalid (bad root/chain)
 }
 
+#[inline]
+pub fn compute_namespace_path(namespace: Option<&[u8]>, key: &[u8]) -> Path {
+    match namespace {
+        Some(ns) => {
+            let ns_hash = sha256(ns);
+            let key_hash = sha256(key);
+
+            let mut path = [0u8; 32];
+            path[0..8].copy_from_slice(&ns_hash[0..8]);
+            path[8..32].copy_from_slice(&key_hash[0..24]);
+            path
+        },
+        None => {
+            sha256(key)
+        }
+    }
+}
+
 // ============================================================================
 // BIT HELPERS (Optimized & Inlined)
 // ============================================================================