epoch 413 migration

Author: vans163

ex/lib/api/api_chain.ex

@@ -100,6 +100,24 @@ defmodule API.Chain do
       last_100/50
     end
 
+    def count_wallets() do
+      key = "account:#{:binary.copy(<<0>>, 48)}:balance:AMA"
+      count_wallets_1(key, 0)
+    end
+    def count_wallets_1(key, acc) do
+      %{db: db, cf: cf} = :persistent_term.get({:rocksdb, Fabric})
+      seek = RocksDB.seek_next(key, %{db: db, cf: cf.contractstate})
+      case seek do
+        {<<"account:", pk::384, ":balance:AMA">>, _} ->
+          key = <<"account:", (pk+1)::384, ":balance:AMA">>
+          count_wallets_1(key, acc + 1)
+        {<<"account:", pk::384, _::binary>>, _} ->
+          key = <<"account:", pk::384, ":balance:AMA">>
+          count_wallets_1(key, acc)
+        {_, _} -> acc
+      end
+    end
+
     def format_entry_for_client(nil) do nil end
     def format_entry_for_client(entry) do
         hash = entry.hash

ex/lib/api/api_proof.ex

@@ -0,0 +1,17 @@
+defmodule API.Proof do
+  def proof_validators(entry_hash) 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,
+      validators: Enum.map(proof.validators, & Base58.encode(&1)),
+      proof: %{
+        nodes: Enum.map(proof.proof.nodes, & %{direction: &1.direction, hash: Base58.encode(&1.hash)}),
+        path: Base58.encode(proof.proof.path),
+        path: Base58.encode(proof.proof.root),
+        path: Base58.encode(proof.proof.hash),
+      }
+    }
+  end
+end

ex/lib/api/db_chain.ex

@@ -84,11 +84,11 @@ defmodule DB.Chain do
         height in 3195570..3195575 ->
             RocksDB.get("bic:epoch:validators:height:000000319557", opts)
         true ->
-            case RocksDB.get_prev_or_first("bic:epoch:validators:height:", pad_integer(height), opts) do
+            case RocksDB.get_prev_or_first("bic:epoch:validators:height:", pad_integer(height), db_handle(db_opts, :contractstate, %{})) do
               {nil, nil} ->
                 {_, value} = RocksDB.get_prev_or_first("bic:epoch:trainers:height:", pad_integer(height), opts)
                 value
-              {_, value} -> value
+              {_, value} -> RDB.vecpak_decode(value)
             end
     end
   end

ex/lib/consensus/models/entry.ex

@@ -152,7 +152,6 @@ defmodule Entry do
           %{error: err} = TX.validate(txu, is_special_meeting_block)
           err
         end)
-
         err = Enum.find_value(steam, fn {:ok, result} -> result != :ok && result end)
         if err, do: throw(err)
 

ex/lib/misc/rocksdb.ex

@@ -186,6 +186,16 @@ defmodule RocksDB do
         end
     end
 
+    def seek_next(key, opts) do
+        {:ok, it} = iterator(opts)
+
+        seek_res = RDB.iterator_move(it, {:seek, key})
+        seek_res = case seek_res do
+            {:ok, next_key, value} -> {next_key, value}
+            other -> {nil, nil}
+        end
+    end
+
     def transaction(db) do
       {:ok, rtx} = RDB.transaction(db)
       rtx

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

@@ -1,6 +1,6 @@
 use std::panic::panic_any;
 use crate::{bcat, consensus};
-use crate::consensus::consensus_kv::{kv_get, kv_put, kv_increment};
+use crate::consensus::consensus_kv::{kv_get, kv_put, kv_increment, kv_exists};
 use vecpak::{encode, decode, Term};
 
 pub const DECIMALS: u32 = 9;
@@ -110,24 +110,24 @@ pub fn call_transfer(env: &mut crate::consensus::consensus_apply::ApplyEnv, args
     if paused(env, symbol) { panic_any("paused") }
     if soulbound(env, symbol) { panic_any("soulbound") }
 
-    kv_increment(env, &bcat(&[b"bic:coin:balance:", env.caller_env.account_caller.as_slice(), b":", symbol]), -amount);
-    kv_increment(env, &bcat(&[b"bic:coin:balance:", receiver, b":", symbol]), amount);
+     if kv_exists(env, &bcat(&[b"account:", &BURN_ADDRESS, b":balance:AMA"])) {
+        kv_increment(env, &bcat(&[b"account:", &env.caller_env.account_caller, b":balance:", symbol]), -amount);
+        kv_increment(env, &bcat(&[b"account:", receiver, b":balance:", symbol]), amount);
 
-    //Account burnt coins
-    if symbol != b"AMA" && receiver == &BURN_ADDRESS {
-        kv_increment(env, &bcat(&[b"bic:coin:totalSupply:", symbol]), -amount);
-    }
-}
-
-/*
-kv_increment(env, &bcat(&[b"account:", &env.caller_env.account_caller, b":balance:", &symbol]), -amount);
-kv_increment(env, &bcat(&[b"account:", receiver, b":balance:", symbol]), amount);
+        //Account burnt coins
+        if symbol != b"AMA" && receiver == &BURN_ADDRESS {
+            kv_increment(env, &bcat(&[b"coin:", symbol, b":totalSupply"]), -amount);
+        }
+    } else {
+        kv_increment(env, &bcat(&[b"bic:coin:balance:", env.caller_env.account_caller.as_slice(), b":", symbol]), -amount);
+        kv_increment(env, &bcat(&[b"bic:coin:balance:", receiver, b":", symbol]), amount);
 
-//Account burnt coins
-if symbol != b"AMA" && receiver == &BURN_ADDRESS {
-    kv_increment(env, &bcat(&[b"coin:", symbol, b":totalSupply"]), -amount);
+        //Account burnt coins
+        if symbol != b"AMA" && receiver == &BURN_ADDRESS {
+            kv_increment(env, &bcat(&[b"bic:coin:totalSupply:", symbol]), -amount);
+        }
+    }
 }
- */
 
 pub fn call_create_and_mint(env: &mut crate::consensus::consensus_apply::ApplyEnv, args: Vec<Vec<u8>>) {
     if args.len() < 2 { panic_any("invalid_args") }

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

@@ -176,7 +176,12 @@ pub fn call_set_emission_address(env: &mut crate::consensus::consensus_apply::Ap
     if args.len() != 1 { panic_any("invalid_args") }
     let address = args[0].as_slice();
     if address.len() != 48 { panic_any("invalid_address_pk") }
-    kv_put(env, &bcat(&[b"bic:epoch:emission_address:", env.caller_env.account_caller.as_slice()]), address);
+
+    if kv_exists(env, &crate::bcat(&[b"account:", &crate::consensus::bic::coin::BURN_ADDRESS, b":balance:AMA"])) {
+        kv_put(env, &bcat(&[b"account:", &env.caller_env.account_caller, b":attribute:emission_address"]), address);
+    } else {
+        kv_put(env, &bcat(&[b"bic:epoch:emission_address:", env.caller_env.account_caller.as_slice()]), address);
+    }
 }
 
 pub fn call_submit_sol(env: &mut crate::consensus::consensus_apply::ApplyEnv, args: Vec<Vec<u8>>) {
@@ -203,10 +208,19 @@ pub fn call_submit_sol(env: &mut crate::consensus::consensus_apply::ApplyEnv, ar
         panic_any("invalid_sol");
     }
 
-    if !kv_exists(env, &bcat(&[b"bic:epoch:pop:", usol.pk.as_slice()])) {
-        match consensus::bls12_381::verify(&usol.pk, &usol.pop, &usol.pk, consensus::aggsig::DST_POP) {
-            Ok(()) => kv_put(env, &bcat(&[b"bic:epoch:pop:", usol.pk.as_slice()]), &usol.pop),
-            Err(_) => panic_any("invalid_pop")
+    if kv_exists(env, &crate::bcat(&[b"account:", &crate::consensus::bic::coin::BURN_ADDRESS, b":balance:AMA"])) {
+        if !kv_exists(env, &bcat(&[b"account:", &usol.pk, b":attribute:pop"])) {
+            match consensus::bls12_381::verify(&usol.pk, &usol.pop, &usol.pk, consensus::aggsig::DST_POP) {
+                Ok(()) => kv_put(env, &bcat(&[b"account:", &usol.pk, b":attribute:pop"]), &usol.pop),
+                Err(_) => panic_any("invalid_pop")
+            }
+        }
+    } else {
+        if !kv_exists(env, &bcat(&[b"bic:epoch:pop:", usol.pk.as_slice()])) {
+            match consensus::bls12_381::verify(&usol.pk, &usol.pop, &usol.pk, consensus::aggsig::DST_POP) {
+                Ok(()) => kv_put(env, &bcat(&[b"bic:epoch:pop:", usol.pk.as_slice()]), &usol.pop),
+                Err(_) => panic_any("invalid_pop")
+            }
         }
     }
     kv_increment(env, &bcat(&[b"bic:epoch:solutions_count:", usol.pk.as_slice()]), 1);
@@ -304,21 +318,20 @@ pub fn call_slash_trainer(env: &mut crate::consensus::consensus_apply::ApplyEnv,
     };
     if !signature_valid { panic_any("invalid_signature") }
 
-    let mut trainers_removed = kv_get_trainers(env, &bcat(&[b"bic:epoch:trainers:removed:", epoch.to_string().as_bytes()]));
-    trainers_removed.push(malicious_pk.to_vec());
-    let term_trainers_removed = consensus::bic::eetf_list_of_binaries(trainers_removed).unwrap();
-    kv_put(env, &bcat(&[b"bic:epoch:trainers:removed:", epoch.to_string().as_bytes()]), term_trainers_removed.as_slice());
-
-    trainers.retain(|pk| pk.as_slice() != malicious_pk);
-    let term_trainers = consensus::bic::eetf_list_of_binaries(trainers).unwrap();
-    kv_put(env, &bcat(&[b"bic:epoch:trainers:", epoch.to_string().as_bytes()]), term_trainers.as_slice());
-
-    kv_put(env, &bcat(&[b"bic:epoch:trainers:height:", &height_next]), term_trainers.as_slice());
-/*
     trainers.retain(|pk| pk.as_slice() != malicious_pk);
-    let term_trainers = consensus::bic::list_of_binaries_to_vecpak(trainers);
-    kv_put(env, &bcat(&[b"bic:epoch:trainers:height:", &height_next]), term_trainers.as_slice());
-*/
+    if env.caller_env.entry_height >= 413_00000 {
+        let term_trainers = consensus::bic::list_of_binaries_to_vecpak(trainers);
+        kv_put(env, &bcat(&[b"bic:epoch:validators:height:", &height_next]), term_trainers.as_slice());
+    } else {
+        let mut trainers_removed = kv_get_trainers(env, &bcat(&[b"bic:epoch:trainers:removed:", epoch.to_string().as_bytes()]));
+        trainers_removed.push(malicious_pk.to_vec());
+        let term_trainers_removed = consensus::bic::eetf_list_of_binaries(trainers_removed).unwrap();
+        kv_put(env, &bcat(&[b"bic:epoch:trainers:removed:", epoch.to_string().as_bytes()]), term_trainers_removed.as_slice());
+
+        let term_trainers = consensus::bic::eetf_list_of_binaries(trainers).unwrap();
+        kv_put(env, &bcat(&[b"bic:epoch:trainers:", epoch.to_string().as_bytes()]), term_trainers.as_slice());
+        kv_put(env, &bcat(&[b"bic:epoch:trainers:height:", &height_next]), term_trainers.as_slice());
+    }
 }
 
 pub fn next(env: &mut ApplyEnv) {

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

@@ -35,7 +35,7 @@ pub fn call_unlock(env: &mut crate::consensus::consensus_apply::ApplyEnv, args:
     if env.caller_env.entry_epoch < unlock_epoch {
         panic_any("vault_is_locked")
     } else {
-        kv_increment(env, &bcat(&[b"bic:coin:balance:", &env.caller_env.account_caller, &symbol]), amount as i128);
+        kv_increment(env, &bcat(&[b"account:", &env.caller_env.account_caller, b":balance:", symbol]), amount as i128);
         kv_delete(env, vault_key);
     }
 }

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

@@ -35,7 +35,7 @@ pub fn call_lock(env: &mut crate::consensus::consensus_apply::ApplyEnv, args: Ve
 
     if amount <= to_flat(1) { panic_any("invalid_amount") }
     if amount > balance(env, env.caller_env.account_caller.as_slice(), b"AMA") { panic_any("insufficient_funds") }
-    kv_increment(env, &bcat(&[b"bic:coin:balance:", &env.caller_env.account_caller, b":AMA"]), -amount);
+    kv_increment(env, &bcat(&[b"account:", &env.caller_env.account_caller, b":balance:AMA"]), -amount);
 
     let vault_index = kv_increment(env, &bcat(&[b"bic:lockup_prime:unique_index"]), 1);
     let vault_value = bcat(&[
@@ -69,13 +69,13 @@ pub fn call_unlock(env: &mut crate::consensus::consensus_apply::ApplyEnv, args:
         let penalty = unlock_amount / 4;
         let disbursement = unlock_amount - penalty;
 
-        kv_increment(env, &bcat(&[b"bic:coin:balance:", TREASURY_DONATION_ADDRESS, b":AMA"]), penalty as i128);
+        kv_increment(env, &bcat(&[b"account:", TREASURY_DONATION_ADDRESS, b":balance:AMA"]), penalty as i128);
         //Lockup for 5 epochs
         create_lock(env, env.caller_env.account_caller.to_vec().as_slice(), b"AMA", disbursement as i128, env.caller_env.entry_epoch.saturating_add(5));
     } else {
         let prime_points = unlock_amount * multiplier;
         mint(env, b"PRIME", prime_points as i128, env.caller_env.account_caller.to_vec().as_slice());
-        kv_increment(env, &bcat(&[b"bic:coin:balance:", &env.caller_env.account_caller, b":AMA"]), unlock_amount as i128);
+        kv_increment(env, &bcat(&[b"account:", &env.caller_env.account_caller, b":balance:AMA"]), unlock_amount as i128);
     }
 
     kv_delete(env, vault_key);

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

@@ -10,9 +10,17 @@ pub fn tx_cost_per_byte(_epoch: u64, tx_encoded_len: usize) -> i128 {
 }
 
 pub fn pay_cost(env: &mut crate::consensus::consensus_apply::ApplyEnv, cost: i128) {
+    if consensus_kv::kv_exists(env, &crate::bcat(&[b"account:", &coin::BURN_ADDRESS, b":balance:AMA"])) {
+        consensus_kv::kv_increment(env, &crate::bcat(&[b"account:", &env.caller_env.account_origin, b":balance:AMA"]), -cost);
+        // Increment validator / burn
+        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);
+    } else {
+
     // Deduct tx cost
     consensus_kv::kv_increment(env, &crate::bcat(&[b"bic:coin:balance:", env.caller_env.account_origin.as_slice(), b":AMA"]), -cost);
     // Increment validator / burn
     consensus_kv::kv_increment(env, &crate::bcat(&[b"bic:coin:balance:", env.caller_env.entry_signer.as_slice(), b":AMA"]), cost/2);
     consensus_kv::kv_increment(env, &crate::bcat(&[b"bic:coin:balance:", &coin::BURN_ADDRESS, b":AMA"]), cost/2);
+    }
 }