full migration plus purge EETF

Author: vans163

ex/build_clean.sh

@@ -0,0 +1,16 @@
+#!/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 \
+    && cd /tmp/node/ex \
+    && export MIX_ENV=prod \
+    && export CC='clang-19' CXX='clang++-19' CFLAGS='-march=haswell' CXXFLAGS='-march=haswell' \
+    && export RUSTFLAGS='-C target-cpu=haswell -C opt-level=3' \
+    && export LLVM_CONFIG_PATH=/usr/bin/llvm-config-19 LIBCLANG_PATH=/usr/lib/llvm-19/lib \
+    && mix deps.get \
+    && mix release \
+    && cp _build/prod/rel/bakeware/ama /root/node/ex/amadeusd"
+sha256sum amadeusd

ex/lib/api/api_chain.ex

@@ -100,24 +100,6 @@ 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_contract.ex

@@ -29,15 +29,27 @@ defmodule API.Contract do
     end
 
     def richlist() do
-      %{db: db, cf: cf} = :persistent_term.get({:rocksdb, Fabric})
-      opts = %{db: db, cf: cf.contractstate, to_integer: true}
-      RocksDB.get_prefix("bic:coin:balance:", opts)
-      |> Enum.map(fn({pk_symbol, coins})->
-          <<pk::48-binary,":",symbol::binary>> = pk_symbol
-          %{pk: Base58.encode(pk), symbol: symbol, flat: coins, float: trunc(BIC.Coin.from_flat(coins))}
-      end)
+      key = "account:#{:binary.copy(<<0>>, 48)}:balance:AMA"
+      {acc, count} = richlist_1(key, {[], 0})
+      acc = acc
       |> Enum.filter(& &1.symbol == "AMA")
       |> Enum.sort_by(& &1.flat, :desc)
+      {acc, count}
+    end
+    def richlist_1(key, {acc, count}) 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">>, value} ->
+          key = <<"account:", (pk+1)::384, ":balance:AMA">>
+          flat = :erlang.binary_to_integer(value)
+          entry = %{pk: Base58.encode(<<pk::384>>), symbol: "AMA", flat: flat, float: trunc(BIC.Coin.from_flat(flat))}
+          richlist_1(key, {acc ++ [entry], count + 1})
+        {<<"account:", pk::384, _::binary>>, _} ->
+          key = <<"account:", pk::384, ":balance:AMA">>
+          richlist_1(key, {acc, count})
+        {_, _} -> {acc, count}
+      end
     end
 
     def total_burned() do

ex/lib/api/api_epoch.ex

@@ -13,7 +13,7 @@ defmodule API.Epoch do
 
     def get_emission_address(pk) do
       pk = if byte_size(pk) != 48, do: Base58.decode(pk), else: pk
-      API.Contract.get("bic:epoch:emission_address:#{pk}")
+      API.Contract.get("account:#{pk}:attribute:emission_address")
       |> case do
         nil -> nil
         addr -> Base58.encode(addr)

ex/lib/api/api_wallet.ex

@@ -16,7 +16,7 @@ defmodule API.Wallet do
 
         %{db: db, cf: cf} = :persistent_term.get({:rocksdb, Fabric})
         opts = %{db: db, cf: cf.contractstate, to_integer: true}
-        RocksDB.get_prefix("bic:coin:balance:#{pk}:", opts)
+        RocksDB.get_prefix("account:#{pk}:balance:", opts)
         |> Enum.map(fn({symbol, coins})->
             %{symbol: symbol, flat: coins, float: BIC.Coin.from_flat(coins)}
         end)

ex/lib/api/db_chain.ex

@@ -36,23 +36,15 @@ defmodule DB.Chain do
   end
 
   def pop(pk, db_opts \\ %{}) do
-    RocksDB.get("bic:epoch:pop:#{pk}", db_handle(db_opts, :contractstate, %{}))
+    RocksDB.get("account:#{pk}:attribute:pop", db_handle(db_opts, :contractstate, %{}))
   end
 
   def nonce(pk, db_opts \\ %{}) do
-    if RocksDB.exists("account:#{pk}:attribute:nonce", db_handle(db_opts, :contractstate, %{to_integer: true})) do
-      RocksDB.get("account:#{pk}:attribute:nonce", db_handle(db_opts, :contractstate, %{to_integer: true}))
-    else
-      RocksDB.get("bic:base:nonce:#{pk}", db_handle(db_opts, :contractstate, %{to_integer: true}))
-    end
+    RocksDB.get("account:#{pk}:attribute:nonce", db_handle(db_opts, :contractstate, %{to_integer: true}))
   end
 
   def balance(pk, symbol \\ "AMA", db_opts \\ %{}) do
-    if RocksDB.exists("account:#{pk}:balance:#{symbol}", db_handle(db_opts, :contractstate, %{to_integer: true})) do
-      RocksDB.get("account:#{pk}:balance:#{symbol}", db_handle(db_opts, :contractstate, %{to_integer: true})) || 0
-    else
-      RocksDB.get("bic:coin:balance:#{pk}:#{symbol}", db_handle(db_opts, :contractstate, %{to_integer: true})) || 0
-    end
+    RocksDB.get("account:#{pk}:balance:#{symbol}", db_handle(db_opts, :contractstate, %{to_integer: true})) || 0
   end
 
   def tx(tx_hash, db_opts \\ %{}) do
@@ -79,23 +71,20 @@ defmodule DB.Chain do
   end
 
   def validators_for_height(height, db_opts \\ %{}) do
-    opts = db_handle(db_opts, :contractstate, %{term: true})
+    opts = db_handle(db_opts, :contractstate, %{})
     cond 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), db_handle(db_opts, :contractstate, %{})) do
-              {nil, nil} ->
-                {_, value} = RocksDB.get_prev_or_first("bic:epoch:trainers:height:", pad_integer(height), opts)
-                value
-              {_, value} -> RDB.vecpak_decode(value)
-            end
+      height in 3195570..3195575 ->
+        RocksDB.get("bic:epoch:validators:height:000000319557", opts)
+        |> RDB.vecpak_decode()
+      true ->
+        {_, value} = RocksDB.get_prev_or_first("bic:epoch:validators:height:", pad_integer(height), opts)
+        RDB.vecpak_decode(value)
     end
   end
 
   def validators_last_change_height(height, db_opts \\ %{}) do
-    opts = db_handle(db_opts, :contractstate, %{term: true})
-    {key, _value} = RocksDB.get_prev_or_first("bic:epoch:trainers:height:", pad_integer(height), opts)
+    opts = db_handle(db_opts, :contractstate, %{})
+    {key, _value} = RocksDB.get_prev_or_first("bic:epoch:validators:height:", pad_integer(height), opts)
     :erlang.binary_to_integer(key)
   end
 

ex/lib/bic/base.ex

@@ -65,8 +65,8 @@ defmodule BIC.Base do
 
         cond do
             env.entry_height == 0 ->
-                kv_put("bic:epoch:trainers:0", [env.entry_signer], %{term: true})
-                kv_put("bic:epoch:pop:#{env.entry_signer}", EntryGenesis.pop())
+                kv_put("bic:epoch:validators:height:000000000000", [env.entry_signer], %{term: true})
+                kv_put("account:#{env.entry_signer}:attribute:pop", EntryGenesis.pop())
             rem(env.entry_height, 100_000) == 99_999 ->
                 BIC.Epoch.next(env)
             true -> :ok

ex/lib/consensus/models/entry_genesis.ex

@@ -187,16 +187,14 @@ defmodule EntryGenesis do
         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:0",
-          :erlang.term_to_binary(validator_pks), %{rtx: rtx, cf: cf.contractstate})
-        RocksDB.put("bic:epoch:trainers:height:#{String.pad_leading("0", 12, "0")}",
-          :erlang.term_to_binary(validator_pks), %{rtx: rtx, cf: cf.contractstate})
+        RocksDB.put("bic:epoch:validators:height:#{String.pad_leading("0", 12, "0")}",
+          RDB.vecpak_encode(validator_pks), %{rtx: rtx, cf: cf.contractstate})
         RocksDB.put("bic:epoch:diff_bits", "8", %{rtx: rtx, cf: cf.contractstate})
         RocksDB.put("bic:epoch:segment_vr_hash", Blake3.hash(vr), %{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})
+          RocksDB.put("account:#{key.pk}:balance:AMA", "1001000000000", %{rtx: rtx, cf: cf.contractstate})
+          RocksDB.put("account:#{key.pk}:attribute:pop", key.pop, %{rtx: rtx, cf: cf.contractstate})
         end)
         rtx = RocksDB.transaction_commit(rtx)
       end

ex/lib/consensus/models/tx.ex

@@ -56,23 +56,21 @@ defmodule TX do
      end
    end
 
-   def validate(txu, is_special_meeting_block \\ false) do
+   def validate(txu_orig, is_special_meeting_block \\ false) do
     try do
-      true = !txu[:tx_encoded]
-
-      txu = Map.take(txu, @fields)
-      tx_encoded = RDB.vecpak_encode(txu.tx)
-
+      txu = Map.take(txu_orig, @fields)
+      true = txu == txu_orig
       tx = Map.take(txu.tx, @fields_tx)
+      true = txu.tx == tx
+      txu = put_in(txu, [:tx], tx)
       action = Map.take(txu.tx.action, @fields_action)
+      true = txu.tx.action == action
+      txu = put_in(txu, [:tx, :action], action)
 
+      tx_encoded = RDB.vecpak_encode(txu.tx)
       if byte_size(tx_encoded) >= Application.fetch_env!(:ama, :tx_size), do: throw(%{error: :too_large})
-
-      hash = Map.fetch!(txu, :hash)
-      signature = Map.fetch!(txu, :signature)
-
-      if hash != :crypto.hash(:sha256, tx_encoded), do: throw(%{error: :invalid_hash})
-      if !BlsEx.verify?(txu.tx.signer, signature, hash, BLS12AggSig.dst_tx()), do: throw(%{error: :invalid_signature})
+      if txu.hash != :crypto.hash(:sha256, tx_encoded), do: throw(%{error: :invalid_hash})
+      if !BlsEx.verify?(txu.tx.signer, txu.signature, txu.hash, BLS12AggSig.dst_tx()), do: throw(%{error: :invalid_signature})
 
       if !is_integer(txu.tx.nonce), do: throw(%{error: :nonce_not_integer})
       if txu.tx.nonce > 99_999_999_999_999_999_999, do: throw(%{error: :nonce_too_high})
@@ -105,7 +103,6 @@ defmodule TX do
       #if !!txp.tx[:delay] and txp.tx.delay <= 0, do: throw %{error: :delay_too_low}
       #if !!txp.tx[:delay] and txp.tx.delay > 100_000, do: throw %{error: :delay_too_hi}
 
-      txu = %{tx: %{nonce: txu.tx.nonce, signer: txu.tx.signer, action: action}, hash: hash, signature: signature}
       throw %{error: :ok, txu: txu}
     catch
         :throw,r -> r

ex/lib/ex.ex

@@ -57,8 +57,8 @@ defmodule Ama do
   def offline_node() do
     %{db: db, cf: cf} = :persistent_term.get({:rocksdb, Fabric})
     if !DB.Entry.by_hash(EntryGenesis.get().hash) do
-      RocksDB.put("bic:epoch:trainers:height:#{String.pad_leading("0", 12, "0")}",
-        :erlang.term_to_binary([EntryGenesis.signer()]), %{db: db, cf: cf.contractstate})
+      RocksDB.put("bic:epoch:validators:height:#{String.pad_leading("0", 12, "0")}",
+        RDB.vecpak_encode([EntryGenesis.signer()]), %{db: db, cf: cf.contractstate})
 
       entry = EntryGenesis.get()
       DB.Entry.insert(entry)