add testnet

Author: vans163

ex/config/runtime.exs

@@ -19,6 +19,7 @@ config :ama, :snapshot_height, (System.get_env("SNAPSHOT_HEIGHT") || "34076355")
 
 #Bind Interaces
 config :ama, :offline, (!!System.get_env("OFFLINE") || nil)
+config :ama, :testnet, (!!System.get_env("TESTNET") || nil)
 
 config :ama, :http_ipv4, ((System.get_env("HTTP_IPV4") || "0.0.0.0") |> :unicode.characters_to_list() |> :inet.parse_ipv4_address() |> (case do {:ok, addr}-> addr end))
 config :ama, :http_port, (System.get_env("HTTP_PORT") || "80") |> :erlang.binary_to_integer()
@@ -35,21 +36,33 @@ if !Util.verify_time_sync() do
 end
 
 path = Path.join([work_folder, "sk"])
-if !File.exists?(path) do
-    #IO.puts "No trainer sk (BLS12-381) in #{path} as base58"
+path_seeds = Path.join([work_folder, "seeds"])
+if File.exists?(path) do
+  !File.exists?(path_seeds) && File.copy!(path, path_seeds)
+end
+if !File.exists?(path_seeds) do
     sk = :crypto.strong_rand_bytes(64)
-    #pk = BlsEx.get_public_key!(sk)
-    #IO.puts "generated random sk, your pk is #{Base58.encode(pk)}"
     :ok = File.write!(path, Base58.encode(sk))
 end
-sk = File.read!(path) |> String.trim() |> Base58.decode()
-pk = BlsEx.get_public_key!(sk)
-pop = BlsEx.sign!(sk, pk, BLS12AggSig.dst_pop())
+keys = File.read!(path) |> String.split("\n") |> Enum.filter(& &1 != "") |> Enum.map(& String.trim(&1) |> Base58.decode()) |> Enum.map(fn(seed)->
+  pk = BlsEx.get_public_key!(seed)
+  pop = BlsEx.sign!(seed, pk, BLS12AggSig.dst_pop())
+  %{pk: pk, seed: seed, pop: pop}
+end)
+keys_by_pk = Enum.into(keys, %{}, fn(key)->
+  {key.pk, %{pop: key.pop, seed: key.seed}}
+end)
+config :ama, :keys, keys
+config :ama, :keys_by_pk, keys_by_pk
+
+first_key = hd(keys)
+config :ama, :trainer_pk, first_key.pk
+config :ama, :trainer_sk, first_key.seed
+config :ama, :trainer_pop, first_key.pop
+
+#for local API - ease of use
+config :ama, :seed64, (case System.get_env("SEED64") do nil -> nil; seed64 -> Base58.decode(seed64) end)
 
-config :ama, :trainer_pk_b58, pk |> Base58.encode()
-config :ama, :trainer_pk, pk
-config :ama, :trainer_sk, System.get_env("SEED64") || sk
-config :ama, :trainer_pop, pop
 
 config :ama, :archival_node, System.get_env("ARCHIVALNODE") in ["true", "y", "yes"]
 config :ama, :autoupdate, System.get_env("AUTOUPDATE") in ["true", "y", "yes"]
@@ -69,6 +82,10 @@ config :ama, :anr_next_refresh, 0
 config :ama, :anr_name, anr_name
 config :ama, :anr_desc, anr_desc
 
+#TESTNET = true
+#TESTNET_TICK=true
+#write 10 validators to file
+
 Path.join(work_folder, "ex/")
 |> Path.join("**/*.ex")
 |> Path.wildcard()

ex/lib/consensus/consensus.ex

@@ -602,13 +602,13 @@ defmodule Consensus do
         #{m, m_rev, l, ConsensusKV.hash_mutations(l ++ m ++ m_rev)}
         mutations_hash = ConsensusKV.hash_mutations(l ++ m)
 
-        attestation = Attestation.sign(next_entry.hash, mutations_hash)
+        sk = Application.fetch_env!(:ama, :trainer_sk)
+        attestation = Attestation.sign(sk, next_entry.hash, mutations_hash)
         attestation_packed = Attestation.pack(attestation)
         RocksDB.put(next_entry.hash, attestation_packed, %{rtx: rtx, cf: cf.my_attestation_for_entry})
 
-        pk = Application.fetch_env!(:ama, :trainer_pk)
         trainers = trainers_for_height(Entry.height(next_entry), %{rtx: rtx, cf: cf})
-        is_trainer = pk in trainers
+        validator_seeds = Application.fetch_env!(:ama, :keys) |> Enum.filter(& &1.pk in trainers)
 
         seen_time = :os.system_time(1000)
         RocksDB.put(next_entry.hash, seen_time, %{rtx: rtx, cf: cf.my_seen_time_for_entry, term: true})
@@ -642,29 +642,17 @@ defmodule Consensus do
 
         :ok = RocksDB.transaction_commit(rtx)
 
-        ap = if is_trainer do
-            #TODO: not ideal in super tight latency constrains but its 1 line and it works
-            send(FabricCoordinatorGen, {:add_attestation, attestation})
-            attestation_packed
-        end
-
-        %{error: :ok, attestation_packed: ap, mutations_hash: mutations_hash, logs: l, muts: m}
+        %{error: :ok, hash: next_entry.hash, validator_seeds: validator_seeds, mutations_hash: mutations_hash, logs: l, muts: m}
     end
 
-    def produce_entry(slot) do
-        %{db: db, cf: cf} = :persistent_term.get({:rocksdb, Fabric})
-
+    def produce_entry(sk, slot) do
         cur_entry = chain_tip_entry()
-        next_entry = Entry.build_next(cur_entry, slot)
+        next_entry = Entry.build_next(sk, cur_entry, slot)
 
-        #TODO: todo add >1 tx
-        #ts_m = :os.system_time(1000)
-        #txs = TXPool.grab_next_valids(next_entry)
+        #TODO: embed aggsig of previous vote
         txs = TXPool.grab_next_valid(100)
-        #IO.inspect {:tx, :os.system_time(1000) - ts_m}
-
         next_entry = Map.put(next_entry, :txs, txs)
-        next_entry = Entry.sign(next_entry)
+        next_entry = Entry.sign(sk, next_entry)
 
         next_entry
     end

ex/lib/consensus/doms/attestation.ex

@@ -6,6 +6,14 @@ defmodule Attestation do
         signer: <>,
         signature: <entry_hash,mutations_hash>,
     }
+
+    ssz
+    <<
+      signature::96,
+      signer::48,
+      entry_hash::32,
+      mutations_hash::32
+    >>
     """
     def unpack(attestation_packed) when is_binary(attestation_packed) do
         a = :erlang.binary_to_term(attestation_packed, [:safe])
@@ -24,9 +32,8 @@ defmodule Attestation do
         |> :erlang.term_to_binary([:deterministic])
     end
 
-    def sign(entry_hash, mutations_hash) do
-        pk = Application.fetch_env!(:ama, :trainer_pk)
-        sk = Application.fetch_env!(:ama, :trainer_sk)
+    def sign(sk, entry_hash, mutations_hash) do
+        pk = BlsEx.get_public_key!(sk)
         signature = BlsEx.sign!(sk, <<entry_hash::binary, mutations_hash::binary>>, BLS12AggSig.dst_att())
         %{
             entry_hash: entry_hash,

ex/lib/consensus/doms/entry.ex

@@ -36,9 +36,7 @@ defmodule Entry do
         |> :erlang.term_to_binary([:deterministic])
     end
 
-    def sign(entry_unpacked) do
-        sk = Application.fetch_env!(:ama, :trainer_sk)
-
+    def sign(sk, entry_unpacked) do
         txs_hash = Blake3.hash(Enum.join(entry_unpacked.txs))
         entry_unpacked = put_in(entry_unpacked, [:header_unpacked, :txs_hash], txs_hash)
         h = :erlang.term_to_binary(entry_unpacked.header_unpacked, [:deterministic])
@@ -175,9 +173,8 @@ defmodule Entry do
         end
     end
 
-    def build_next(cur_entry, slot) do
-        pk = Application.fetch_env!(:ama, :trainer_pk)
-        sk = Application.fetch_env!(:ama, :trainer_sk)
+    def build_next(sk, cur_entry, slot) do
+        pk = BlsEx.get_public_key!(sk)
 
         dr = Blake3.hash(cur_entry.header_unpacked.dr)
         vr = BlsEx.sign!(sk, cur_entry.header_unpacked.vr, BLS12AggSig.dst_vrf())

ex/lib/consensus/doms/entry_genesis.ex

@@ -122,20 +122,84 @@ defmodule EntryGenesis do
           },
           txs: [],
         }
-        entry_signed = Entry.sign(entry)
+        entry_signed = Entry.sign(sk, entry)
 
         %{db: db, cf: cf} = :persistent_term.get({:rocksdb, Fabric})
         rtx = RocksDB.transaction(db)
         Process.put({RocksDB, :ctx}, %{rtx: rtx, cf: cf})
         {mutations, _} = BIC.Base.call_exit(%{entry: entry})
 
         mutations_hash = ConsensusKV.hash_mutations(mutations)
-        attestation = Attestation.sign(entry_signed.hash, mutations_hash)
+        attestation = Attestation.sign(sk, entry_signed.hash, mutations_hash)
 
         pop = BlsEx.sign!(sk, pk, BLS12AggSig.dst_pop())
         entry_signed = Entry.pack(entry_signed) |> Entry.unpack()
 
         IO.inspect {entry_signed, attestation, pop}, limit: :infinity
         :ok
     end
+
+    def generate_testnet() do
+      %{db: db, cf: cf} = :persistent_term.get({:rocksdb, Fabric})
+      if !RocksDB.get("temporal_height", %{db: db, cf: cf.sysconf}) do
+        IO.puts "making testnet.."
+
+        pk = Application.fetch_env!(:ama, :trainer_pk)
+        sk = Application.fetch_env!(:ama, :trainer_sk)
+
+        if length(Application.fetch_env!(:ama, :keys)) < 10 do
+          new_keys = Enum.map(0..9, fn(_)-> :crypto.strong_rand_bytes(64) |> Base58.encode() end)
+          |> Enum.join("\n")
+          workdir = Application.fetch_env!(:ama, :work_folder)
+          File.write!(Path.join([workdir, "seeds"]), new_keys)
+          IO.puts "seeded testnet please restart node"
+          :erlang.halt()
+        end
+
+        entropy_seed = :crypto.strong_rand_bytes(512)
+        dr = Blake3.hash(entropy_seed)
+        vr = BlsEx.sign!(sk, dr<>dr<>dr, BLS12AggSig.dst_vrf())
+
+        entry = %{
+          header_unpacked: %{
+            slot: 0,
+            height: 0,
+            prev_slot: -1,
+            prev_hash: <<>>,
+            dr: dr,
+            vr: vr,
+            signer: pk,
+          },
+          txs: [],
+        }
+        entry_signed = Entry.sign(sk, entry)
+
+
+        rtx = RocksDB.transaction(db)
+        Process.put({RocksDB, :ctx}, %{rtx: rtx, cf: cf})
+
+        mutations_hash = ConsensusKV.hash_mutations([])
+        attestation = Attestation.sign(sk, entry_signed.hash, mutations_hash)
+
+        pop = BlsEx.sign!(sk, pk, BLS12AggSig.dst_pop())
+        entry_signed = Entry.pack(entry_signed) |> Entry.unpack()
+
+        RocksDB.put(entry_signed.hash, Entry.pack(entry_signed), %{rtx: rtx, cf: cf.entry})
+        RocksDB.put(entry_signed.hash, :os.system_time(1000), %{rtx: rtx, cf: cf.my_seen_time_for_entry, term: true})
+        RocksDB.put("temporal_tip", entry_signed.hash, %{rtx: rtx, cf: cf.sysconf})
+        RocksDB.put("temporal_height", 0, %{rtx: rtx, cf: cf.sysconf, term: true})
+        RocksDB.put("rooted_tip", entry_signed.hash, %{rtx: rtx, cf: cf.sysconf})
+
+        validator_pks = Application.fetch_env!(:ama, :keys) |> Enum.map(& &1.pk)
+        RocksDB.put("bic:epoch:trainers:height:#{String.pad_leading("0", 12, "0")}",
+          :erlang.term_to_binary(validator_pks), %{rtx: rtx, cf: cf.contractstate})
+        Enum.each(Application.fetch_env!(:ama, :keys), fn(key)->
+          RocksDB.put("bic:coin:balance:#{key.pk}:AMA", "1001000000000", %{rtx: rtx, cf: cf.contractstate})
+          RocksDB.put("bic:epoch:pop:#{key.pk}", key.pop, %{rtx: rtx, cf: cf.contractstate})
+        end)
+        rtx = RocksDB.transaction_commit(rtx)
+
+        #Fabric.aggregate_attestation(attestation |> Attestation.pack())
+      end
+    end
 end

ex/lib/consensus/fabric_gen.ex

@@ -50,6 +50,8 @@ defmodule FabricGen do
 
   def tick_slot(state) do
     #IO.inspect "tick_slot"
+    Application.fetch_env!(:ama, :testnet) && Process.sleep(500)
+
     if proc_if_my_slot() do
       proc_entries()
       #proc_compact()
@@ -200,23 +202,27 @@ defmodule FabricGen do
         #IO.inspect {:took, entry.header_unpacked.height, :os.system_time(1000) - ts_s}
 
         task = Task.async(fn -> Consensus.apply_entry(entry) end)
-        %{error: :ok, attestation_packed: attestation_packed,
+        %{error: :ok, hash: hash, validator_seeds: vseeds,
           mutations_hash: m_hash, logs: l, muts: m
         } = case Task.await(task, :infinity) do
           result = %{error: :ok} -> result
         end
 
         FabricEventGen.event_applied(entry, m_hash, m, l)
 
-        if !!attestation_packed and FabricSyncAttestGen.isQuorumSyncedOffByX(6) do
-          msg = NodeProto.event_attestation(attestation_packed)
-          NodeGen.broadcast(msg)
+        Enum.each(vseeds, fn(seed)->
+          attestation = Attestation.sign(seed.seed, hash, m_hash)
+          send(FabricCoordinatorGen, {:add_attestation, attestation})
+          if FabricSyncAttestGen.isQuorumSyncedOffByX(6) do
+            msg = NodeProto.event_attestation(Attestation.pack(attestation))
+            NodeGen.broadcast(msg)
 
-          #Ensure RPC nodes are as up-to-date as possible
-          #TODO: fix this in a better way later
-          peers = Application.fetch_env!(:ama, :seedanrs_as_peers)
-          send(NodeGen.get_socket_gen(), {:send_to, peers, msg})
-        end
+            #Ensure RPC nodes are as up-to-date as possible
+            #TODO: fix this in a better way later
+            peers = Application.fetch_env!(:ama, :seedanrs_as_peers)
+            send(NodeGen.get_socket_gen(), {:send_to, peers, msg})
+          end
+        end)
 
         TXPool.delete_packed(entry.txs)
 
@@ -225,7 +231,6 @@ defmodule FabricGen do
   end
 
   def proc_if_my_slot() do
-    pk = Application.fetch_env!(:ama, :trainer_pk)
     entry = Consensus.chain_tip_entry()
     next_slot = entry.header_unpacked.slot + 1
     next_height = entry.header_unpacked.height + 1
@@ -239,13 +244,15 @@ defmodule FabricGen do
     |> Enum.filter(& &1.header_unpacked.prev_hash == rooted_tip)
     emptyHeight = emptyHeight == []
 
+    am_i_next = Enum.find(Application.fetch_env!(:ama, :keys), & &1.pk == slot_trainer)
+
     cond do
       !FabricSyncAttestGen.isQuorumSynced() -> nil
 
       lastSlot == next_slot -> nil
       !emptyHeight -> nil
 
-      pk == slot_trainer ->
+      am_i_next ->
         :persistent_term.put(:last_made_entry_slot, next_slot)
 
         if :persistent_term.get(:snapshot_before_my_slot, nil) do
@@ -254,17 +261,17 @@ defmodule FabricGen do
           FabricSnapshot.snapshot_tmp()
         end
 
-        IO.puts "🔧 im in slot #{next_slot}, working.. *Click Clak*"
+        !Application.fetch_env!(:ama, :testnet) && IO.puts("🔧 im in slot #{next_slot}, working.. *Click Clak*")
 
-        proc_if_my_slot_1(next_slot)
+        proc_if_my_slot_1(am_i_next.seed, next_slot)
 
       true ->
         nil
     end
   end
 
-  def proc_if_my_slot_1(next_slot) do
-    next_entry = Consensus.produce_entry(next_slot)
+  def proc_if_my_slot_1(seed, next_slot) do
+    next_entry = Consensus.produce_entry(seed, next_slot)
     Fabric.insert_entry(next_entry, :os.system_time(1000))
 
     msg = NodeProto.event_entry(Entry.pack(next_entry))

ex/lib/consensus/fabric_sync_attest_gen.ex

@@ -54,6 +54,7 @@ defmodule FabricSyncAttestGen do
 
   def isQuorumSynced() do
     cond do
+      Application.fetch_env!(:ama, :testnet) -> true
       !hasQuorum() -> false
       isSynced() != :full -> false
       Fabric.rooted_tip_height() < Consensus.chain_height() -> false

ex/lib/consensus/special_meeting/special_meeting_gen.ex

@@ -160,17 +160,18 @@ defmodule SpecialMeetingGen do
 
   def build_slash_entry(st) do
     my_pk = Application.fetch_env!(:ama, :trainer_pk)
+    sk = Application.fetch_env!(:ama, :trainer_sk)
     packed_tx = build_slash_tx(st)
 
     true = FabricSyncAttestGen.isQuorumSynced()
     cur_entry = Fabric.rooted_tip_entry()
     cur_height = cur_entry.header_unpacked.height
     cur_slot = cur_entry.header_unpacked.slot
 
-    next_entry = Entry.build_next(cur_entry, cur_slot + 1)
+    next_entry = Entry.build_next(sk, cur_entry, cur_slot + 1)
     txs = [packed_tx]
     next_entry = Map.put(next_entry, :txs, txs)
-    next_entry = Entry.sign(next_entry)
+    next_entry = Entry.sign(sk, next_entry)
 
     trainers = Consensus.trainers_for_height(next_entry.header_unpacked.height + 1)
     mask = <<0::size(length(trainers))>>