dyndiff; updated-incentive; reduced fees;

vans163 · vans163 · commit 3921808d64e1 · 2025-09-15T15:22:55.000-04:00
diff --git a/ex/lib/api/api_epoch.ex b/ex/lib/api/api_epoch.ex
@@ -25,6 +25,16 @@ defmodule API.Epoch do
       |> Base58.encode()
     end
 
+    def get_diff_bits(epoch \\ nil) do
+      epoch = if epoch do epoch else Consensus.chain_epoch() end
+      API.Contract.get("bic:epoch:diff_bits:#{epoch}", :to_integer) || 24
+    end
+
+    def get_total_sols(epoch \\ nil) do
+      epoch = if epoch do epoch else Consensus.chain_epoch() end
+      API.Contract.get("bic:epoch:total_sols:#{epoch}", :to_integer) || 0
+    end
+
     def get_pop(pk) do
       pk = if byte_size(pk) != 48, do: Base58.decode(pk), else: pk
       Consensus.chain_pop(pk)
diff --git a/ex/lib/api/api_peer.ex b/ex/lib/api/api_peer.ex
@@ -114,7 +114,8 @@ defmodule API.Peer do
       |> anr_for_web()
     end
 
-    def anr_for_web(anrs) when is_list(anrs) do Enum.map(anrs, & anr_for_web(&1)) end
+    def anr_for_web(anrs) when is_list(anrs) do Enum.map(anrs, & anr_for_web(&1)) |> Enum.filter(& &1) end
+    def anr_for_web(nil) do nil end
     def anr_for_web(anr) do
       %{
         pk: Base58.encode(anr.pk),
diff --git a/ex/lib/bic/base.ex b/ex/lib/bic/base.ex
@@ -1,9 +1,14 @@
 defmodule BIC.Base do
     import ConsensusKV
 
-    def exec_cost(txu) do
+    def exec_cost(epoch, txu) do
         bytes = byte_size(txu.tx_encoded) + 32 + 96
-        BIC.Coin.to_cents( 3 + div(bytes, 256) * 3 )
+        #3x lower fee, 1 cent AMA base per tx
+        if epoch >= 295 do
+          BIC.Coin.to_cents( 1 + div(bytes, 256) * 1 )
+        else
+          BIC.Coin.to_cents( 3 + div(bytes, 256) * 3 )
+        end
 
         #for future update
         #BIC.Coin.to_tenthousandth( 18 + div(bytes, 256) * 3 )
@@ -22,18 +27,28 @@ defmodule BIC.Base do
 
         Enum.each(txus, fn(txu)->
             kv_put("bic:base:nonce:#{txu.tx.signer}", txu.tx.nonce, %{to_integer: true})
-            exec_cost = exec_cost(txu)
+            exec_cost = exec_cost(env.entry_epoch, txu)
             kv_increment("bic:coin:balance:#{txu.tx.signer}:AMA", -exec_cost)
-            kv_increment("bic:coin:balance:#{env.entry_signer}:AMA", exec_cost)
+
+            if env.entry_epoch >= 295 do
+              #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)
+            else
+              kv_increment("bic:coin:balance:#{env.entry_signer}:AMA", exec_cost)
+            end
         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)
-              valid = try do BIC.Sol.verify(sol, %{hash: hash, vr_b3: env.entry_vr_b3, segment_vr_hash: segment_vr_hash}) catch _,_ -> false end
+              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)
@@ -53,12 +68,6 @@ defmodule BIC.Base do
         Process.delete(:mutations_reverse)
         seed_random(env.entry_vr, "", "", "")
 
-        if env.entry_epoch >= 282 do
-        else
-          #thank you come again
-          kv_increment("bic:coin:balance:#{env.entry_signer}:AMA", BIC.Coin.to_flat(1))
-        end
-
         if rem(env.entry_height, 1000) == 0 do
             kv_put("bic:epoch:segment_vr_hash", Blake3.hash(env.entry_vr))
         end
@@ -110,9 +119,19 @@ defmodule BIC.Base do
 
                     muts = Process.get(:mutations, []); Process.delete(:mutations)
                     muts_rev = Process.get(:mutations_reverse, []); Process.delete(:mutations_reverse)
+
                     exec_used = (result[:exec_used] || 0) * 100
-                    kv_increment("bic:coin:balance:#{env.entry_signer}:AMA", exec_used)
                     kv_increment("bic:coin:balance:#{env.tx_signer}:AMA", -exec_used)
+
+                    if env.entry_epoch >= 295 do
+                      #burn 50% to prevent MEV/FreeChainGrowth attack
+                      half_exec_cost = div(exec_used, 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)
+                    else
+                      kv_increment("bic:coin:balance:#{env.entry_signer}:AMA", exec_used)
+                    end
+
                     Process.put(:mutations_gas, Process.get(:mutations, []))
                     Process.put(:mutations_gas_reverse, Process.get(:mutations_reverse, []))
                     Process.put(:mutations, muts)
diff --git a/ex/lib/bic/epoch.ex b/ex/lib/bic/epoch.ex
@@ -7,7 +7,7 @@ defmodule BIC.Epoch do
 
     @a 23_072_960_000
     @c 1110.573766
-    @start_epoch 500
+    @start_epoch 420
 
     def epoch_emission(epoch) when epoch >= @start_epoch do
       floor(0.5 * @a / :math.pow(epoch - @start_epoch + @c, 1.5))
@@ -140,12 +140,15 @@ defmodule BIC.Epoch do
     end
 
     def next(env) do
-        epoch_fin = env.entry_epoch
-        epoch_next = epoch_fin + 1
+      if env.entry_epoch >= 295 or env.entry_epoch < 420 do
+        next_420(env)
+      else
+        epoch_cur = env.entry_epoch
+        epoch_next = epoch_cur + 1
         top_x = 99
 
         # slash sols for malicious trainers
-        removedTrainers = kv_get("bic:epoch:trainers:removed:#{epoch_fin}", %{term: true}) || []
+        removedTrainers = kv_get("bic:epoch:trainers:removed:#{epoch_cur}", %{term: true}) || []
         leaders = kv_get_prefix("bic:epoch:solutions_count:", %{to_integer: true})
         |> Enum.reduce(%{}, fn({pk, count}, acc)->
             if pk in removedTrainers do
@@ -156,14 +159,14 @@ defmodule BIC.Epoch do
         end)
         |> Enum.sort_by(& {elem(&1,1), elem(&1,0)}, :desc)
 
-        trainers = kv_get("bic:epoch:trainers:#{epoch_fin}", %{term: true})
+        trainers = kv_get("bic:epoch:trainers:#{epoch_cur}", %{term: true})
         trainers_to_recv_emissions = leaders
         |> Enum.filter(& elem(&1,0) in trainers)
         |> Enum.take(top_x)
 
         total_sols = Enum.reduce(trainers_to_recv_emissions, 0, & &2 + elem(&1,1))
         Enum.each(trainers_to_recv_emissions, fn({trainer, trainer_sols})->
-            coins = div(trainer_sols * epoch_emission(epoch_fin), total_sols)
+            coins = div(trainer_sols * epoch_emission(epoch_cur), total_sols)
 
             emission_address = kv_get("bic:epoch:emission_address:#{trainer}")
             if emission_address do
@@ -189,6 +192,91 @@ defmodule BIC.Epoch do
 
         height = String.pad_leading("#{env.entry_height+1}", 12, "0")
         kv_put("bic:epoch:trainers:height:#{height}", new_validators, %{term: true})
+      end
+    end
+
+    def next_420(env) do
+        epoch_cur = env.entry_epoch
+        epoch_next = epoch_cur + 1
+        top_x = 99
+
+        # slash sols for malicious trainers
+        removedTrainers = kv_get("bic:epoch:trainers:removed:#{epoch_cur}", %{term: true}) || []
+        leaders = kv_get_prefix("bic:epoch:solutions_count:", %{to_integer: true})
+        |> Enum.reduce(%{}, fn({pk, count}, acc)->
+            if pk in removedTrainers do
+                acc
+            else
+                Map.put(acc, pk, count)
+            end
+        end)
+        |> Enum.sort_by(& {elem(&1,1), elem(&1,0)}, :desc)
+
+        trainers = kv_get("bic:epoch:trainers:#{epoch_cur}", %{term: true})
+        trainers_to_recv_emissions = leaders
+        |> Enum.filter(& elem(&1,0) in trainers and elem(&1,0) not in @peddlebike67)
+        |> Enum.take(top_x)
+
+        epoch_total_emission = epoch_emission(epoch_cur)
+        epoch_early_adopter_emission = div(epoch_total_emission, 7)
+        epoch_communityfund_emission = epoch_total_emission - epoch_early_adopter_emission
+        #Community fund for grants such as building open source code and building onchain/ecosystem
+        #alot of interest from early adopters to receive grants for building
+
+        n_count = length(@peddlebike67)
+        q = div(epoch_communityfund_emission, n_count)
+        r = rem(epoch_communityfund_emission, n_count)
+        n_summed = List.duplicate(q + 1, r) ++ List.duplicate(q, n_count - r)
+
+        Enum.zip(@peddlebike67, n_summed)
+        |> Enum.each(fn({trainer, coins})->
+          emission_address = kv_get("bic:epoch:emission_address:#{trainer}")
+          if emission_address do
+              kv_increment("bic:coin:balance:#{emission_address}:AMA", coins)
+          else
+              kv_increment("bic:coin:balance:#{trainer}:AMA", coins)
+          end
+        end)
+
+        total_sols = Enum.reduce(trainers_to_recv_emissions, 0, & &2 + elem(&1,1))
+        if total_sols > 0 do
+          Enum.each(trainers_to_recv_emissions, fn({trainer, trainer_sols})->
+              coins = div(trainer_sols * epoch_early_adopter_emission, total_sols)
+
+              emission_address = kv_get("bic:epoch:emission_address:#{trainer}")
+              if emission_address do
+                  kv_increment("bic:coin:balance:#{emission_address}:AMA", coins)
+              else
+                  kv_increment("bic:coin:balance:#{trainer}:AMA", coins)
+              end
+          end)
+        end
+
+        leaders = Enum.map(leaders, fn{pk, _}-> pk end)
+
+        #REMOVE THIS LATER, first we must start with a peddle bike as a
+        #UAV proved to have a lack of skilled pilots
+        leaders = leaders -- @peddlebike67
+        new_validators = (@peddlebike67 ++ leaders)
+        |> Enum.take(top_x)
+        |> Enum.shuffle()
+
+        kv_put("bic:epoch:trainers:#{epoch_next}", new_validators, %{term: true})
+
+        height = String.pad_leading("#{env.entry_height+1}", 12, "0")
+        kv_put("bic:epoch:trainers:height:#{height}", new_validators, %{term: true})
+
+        #new difficulty handling
+        old_diff_bits = kv_get("bic:epoch:diff_bits", %{to_integer: true}) || 24
+        next_diff_bits = SolDifficulty.next(old_diff_bits, total_sols)
+        kv_put("bic:epoch:diff_bits", next_diff_bits, %{to_integer: true})
+
+        #log for analysis / potential backseek in future upgrade
+        kv_put("bic:epoch:diff_bits:#{epoch_next}", next_diff_bits, %{to_integer: true})
+        kv_put("bic:epoch:total_sols:#{epoch_cur}", total_sols, %{to_integer: true})
+
+        kv_clear("bic:epoch:solbloom:")
+        kv_clear("bic:epoch:solutions_count:")
     end
 
     def slash_trainer_verify(cur_epoch, malicious_pk, trainers, mask, signature) do
diff --git a/ex/lib/bic/sol.ex b/ex/lib/bic/sol.ex
@@ -38,8 +38,20 @@ defmodule BIC.Sol do
         a == 0
     end
 
+    def verify_hash_diff(_epoch, hash, diff_bits) do
+      <<a::size(diff_bits), _::bitstring>> = hash
+      a == 0
+    end
+
     def verify(sol = <<epoch::32-little, _::binary>>, opts \\ %{}) do
       cond do
+        epoch >= 295 ->
+          usol = unpack(sol)
+          if opts.segment_vr_hash != usol.segment_vr_hash, do: throw %{error: :segment_vr_hash}
+          if byte_size(sol) != @sol_size, do: throw(%{error: :invalid_sol_seed_size})
+          hash = Map.get_lazy(opts, :hash, fn()-> Blake3.hash(sol) end)
+          vr_b3 = Map.get_lazy(opts, :vr_b3, fn()-> :crypto.strong_rand_bytes(32) end)
+          verify_hash_diff(epoch, hash, opts.diff_bits) and Blake3.freivalds_e260(sol, vr_b3)
         epoch >= 282 ->
           usol = unpack(sol)
           if opts.segment_vr_hash != usol.segment_vr_hash, do: throw %{error: :segment_vr_hash}
diff --git a/ex/lib/bic/sol_difficulty.ex b/ex/lib/bic/sol_difficulty.ex
@@ -0,0 +1,56 @@
+defmodule SolDifficulty do
+  @target_sols_epoch 380_000
+
+  @tol_num 1
+  @tol_den 10
+
+  @max_step_down 3
+  @max_step_up   2
+  @up_slowdown   2
+
+  @diff_min_bits 20
+  @diff_max_bits 64
+
+  defp clamp_bits(b), do: b |> max(@diff_min_bits) |> min(@diff_max_bits)
+
+  defp ceil_div(a, b), do: div(a + b - 1, b)
+
+  defp ilog2_floor(n) when n >= 1, do: do_ilog2(n, 0)
+  defp do_ilog2(1, acc), do: acc
+  defp do_ilog2(n, acc), do: do_ilog2(div(n, 2), acc + 1)
+
+  defp ceil_log2_ratio(a, b) when a <= b, do: 0
+  defp ceil_log2_ratio(a, b) do
+    d0 = ilog2_floor(a) - ilog2_floor(b)
+    if :erlang.bsl(b, d0) >= a, do: d0, else: d0 + 1
+  end
+
+  def next(prev_bits, sols) do
+    target = @target_sols_epoch
+
+    lo = max(1, div(target * (@tol_den - @tol_num) + div(@tol_den, 2), @tol_den))
+    hi =        div(target * (@tol_den + @tol_num) + div(@tol_den, 2), @tol_den)
+
+    cond do
+      sols == 0 ->
+        clamp_bits(prev_bits - min(@max_step_down, 3))
+
+      sols > hi ->
+        raw = ceil_log2_ratio(sols, target)
+        delta = raw
+        |> ceil_div(@up_slowdown)
+        |> min(@max_step_up)
+        |> max(1)
+        clamp_bits(prev_bits + delta)
+
+      sols < lo ->
+        delta = ceil_log2_ratio(target, max(sols, 1))
+        |> min(@max_step_down)
+        |> max(1)
+        clamp_bits(prev_bits - delta)
+
+      true ->
+        prev_bits
+    end
+  end
+end
diff --git a/ex/lib/consensus/consensus.ex b/ex/lib/consensus/consensus.ex
@@ -125,6 +125,16 @@ defmodule Consensus do
       RocksDB.get("bic:epoch:segment_vr_hash", %{db: db, cf: cf.contractstate})
     end
 
+    def chain_diff_bits() do
+      %{db: db, cf: cf} = :persistent_term.get({:rocksdb, Fabric})
+      RocksDB.get("bic:epoch:diff_bits", %{db: db, cf: cf.contractstate, to_integer: true}) || 24
+    end
+
+    def chain_total_sols() do
+      %{db: db, cf: cf} = :persistent_term.get({:rocksdb, Fabric})
+      RocksDB.get("bic:epoch:total_sols", %{db: db, cf: cf.contractstate, to_integer: true}) || 0
+    end
+
     def chain_pop(pk) do
       %{db: db, cf: cf} = :persistent_term.get({:rocksdb, Fabric})
       RocksDB.get("bic:epoch:pop:#{pk}", %{db: db, cf: cf.contractstate})
diff --git a/ex/lib/consensus/doms/entry.ex b/ex/lib/consensus/doms/entry.ex
@@ -157,8 +157,9 @@ defmodule Entry do
         txus = Enum.map(next_entry.txs, & TX.unpack(&1))
         chain_epoch = Consensus.chain_epoch()
         segment_vr_hash = Consensus.chain_segment_vr_hash()
+        diff_bits = Consensus.chain_diff_bits()
         Enum.reduce(txus, %{}, fn(txu, batch_state)->
-            case TXPool.validate_tx(txu, %{epoch: chain_epoch, segment_vr_hash: segment_vr_hash, batch_state: batch_state}) do
+            case TXPool.validate_tx(txu, %{epoch: chain_epoch, segment_vr_hash: segment_vr_hash, diff_bits: diff_bits, batch_state: batch_state}) do
                %{error: :ok, batch_state: batch_state} -> batch_state
                %{error: error} when error in [:invalid_tx_nonce, :not_enough_tx_exec_balance] -> throw %{error: error}
                _ -> batch_state
diff --git a/ex/lib/consensus/doms/tx.ex b/ex/lib/consensus/doms/tx.ex
@@ -128,13 +128,14 @@ defmodule TX do
    def chain_valid(txu) do
       #TODO: once more than 1 tx allowed per entry fix this
       chainNonce = Consensus.chain_nonce(txu.tx.signer)
+      chainEpoch = Consensus.chain_epoch()
       nonceValid = !chainNonce or txu.tx.nonce > chainNonce
-      hasBalance = BIC.Base.exec_cost(txu) <= Consensus.chain_balance(txu.tx.signer)
+      hasBalance = BIC.Base.exec_cost(chainEpoch, txu) <= Consensus.chain_balance(txu.tx.signer)
 
       hasSol = Enum.find_value(txu.tx.actions, fn(a)-> a.function == "submit_sol" and hd(a.args) end)
       epochSolValid = if !hasSol do true else
          <<sol_epoch::32-little, _::binary>> = hasSol
-         Consensus.chain_epoch() == sol_epoch
+         chainEpoch == sol_epoch
       end
 
       cond do
diff --git a/ex/lib/consensus/fabric_cleaner.ex b/ex/lib/consensus/fabric_cleaner.ex
diff --git a/ex/lib/node/txpool.ex b/ex/lib/node/txpool.ex
diff --git a/ex/lib/node/upow.ex b/ex/lib/node/upow.ex
