chore: update node to version 6.13

.dialyzer_ignore.exs

@@ -3,5 +3,5 @@
   # created during runtime that belong to the AE core code.
   ~r/does not exist/,
   # Following warnings are due to bad implementation of riverside.
-  {"lib/phoenix/router.ex", :pattern_match, 405}
+  {"deps/phoenix/lib/phoenix/router.ex", :pattern_match, 405}
 ]

.github/actions/mdw-setup/action.yml

@@ -6,10 +6,10 @@ runs:
   steps:
     - uses: erlef/setup-beam@v1
       with:
-        otp-version: 23.3.4.17
-        elixir-version: 1.13.4
+        otp-version: 26.2.3
+        elixir-version: 1.16.2
         version-type: strict
 
     - name: Get Mdw dependencies
       shell: bash
-      run: mix deps.get
+      run: mix deps.get

.github/actions/node-setup/action.yml

@@ -7,5 +7,5 @@ runs:
     - name: Setup Node
       shell: bash
       run: |
-        curl -L https://github.com/aeternity/aeternity/releases/download/v6.12.0/aeternity-v6.12.0-ubuntu-x86_64.tar.gz -o aeternity.tgz\
+        curl -L https://github.com/aeternity/aeternity/releases/download/v6.13.0/aeternity-v6.13.0-ubuntu-x86_64.tar.gz -o aeternity.tgz\
         && mkdir -p ${NODEROOT}/rel/aeternity && tar xf aeternity.tgz -C ${NODEROOT}/rel/aeternity && cp -rf ${NODEROOT}/rel/aeternity/lib/ ${NODEROOT}

.tool-versions

@@ -1,2 +1,2 @@
-erlang 23.3.4.17
-elixir 1.13.4-otp-23
+erlang 26.2.3
+elixir 1.16.2-otp-26

Dockerfile

@@ -12,9 +12,9 @@
 #   - https://pkgs.org/ - resource for finding needed packages
 #   - Ex: hexpm/elixir:1.13.4-erlang-23.3.4.17-debian-bullseye-20210902-slim
 #
-ARG ELIXIR_VERSION=1.13.4
-ARG OTP_VERSION=23.3.4.18
-ARG DEBIAN_VERSION=bullseye-20220801-slim
+ARG ELIXIR_VERSION=1.16.2
+ARG OTP_VERSION=26.2.3
+ARG DEBIAN_VERSION=bullseye-20240311-slim
 
 ARG BUILDER_IMAGE="hexpm/elixir:${ELIXIR_VERSION}-erlang-${OTP_VERSION}-debian-${DEBIAN_VERSION}"
 ARG RUNNER_IMAGE="debian:${DEBIAN_VERSION}"
@@ -42,7 +42,7 @@ WORKDIR /home/aeternity/node
 ARG DEV_MODE="false"
 ENV DEV_MODE=${DEV_MODE}
 ENV NODEROOT=/home/aeternity/node/local
-ARG NODE_VERSION=6.12.0
+ARG NODE_VERSION=6.13.0
 ARG NODE_URL=https://github.com/aeternity/aeternity/releases/download/v${NODE_VERSION}/aeternity-v${NODE_VERSION}-ubuntu-x86_64.tar.gz
 ENV NODEDIR=/home/aeternity/node/local/rel/aeternity
 RUN mkdir -p ./local/rel/aeternity/data/mnesia

docker-compose-dev.yml

@@ -6,7 +6,7 @@ services:
       dockerfile: ./Dockerfile
       args:
         MIX_ENV: dev
-        RUNNER_IMAGE: "hexpm/elixir:1.13.4-erlang-23.3.4.18-debian-bullseye-20220801"
+        RUNNER_IMAGE: "hexpm/elixir:1.16.2-erlang-26.2.3-debian-bullseye-20240311-slim"
         USER: root
     image: aeternity/ae_mdw_dev${IMAGE_NAME_SUFFIX:-}:latest
     ports:

docker-compose-test.yml

@@ -6,7 +6,7 @@ services:
       dockerfile: ./Dockerfile
       args:
         MIX_ENV: test
-        RUNNER_IMAGE: "hexpm/elixir:1.13.4-erlang-23.3.4.18-debian-bullseye-20220801"
+        RUNNER_IMAGE: "hexpm/elixir:1.16.2-erlang-26.2.3-debian-bullseye-20240311-slim"
         USER: root
     image: ae_mdw_test:latest
     command: ./scripts/test.sh

lib/ae_mdw/aex9.ex

@@ -5,7 +5,6 @@ defmodule AeMdw.Aex9 do
 
   alias :aeser_api_encoder, as: Enc
   alias AeMdw.Collection
-  alias AeMdw.Db.AsyncStore
   alias AeMdw.Db.Model
   alias AeMdw.Db.State
   alias AeMdw.Db.Util, as: DbUtil
@@ -40,13 +39,14 @@ defmodule AeMdw.Aex9 do
 
   @type amounts :: map()
 
-  @spec fetch_balances(State.t(), pubkey(), boolean()) :: {:ok, amounts()} | {:error, Error.t()}
-  def fetch_balances(state, contract_pk, top?) do
+  @spec fetch_balances(State.t(), State.t(), pubkey(), boolean()) ::
+          {:ok, amounts()} | {:error, Error.t()}
+  def fetch_balances(state, async_state, contract_pk, top?) do
     if top? do
       {amounts, _height} = Db.aex9_balances!(contract_pk, true)
       amounts
     else
-      state = get_store_state(state, contract_pk)
+      state = get_store_state(state, async_state, contract_pk)
 
       state
       |> Collection.stream(Model.Aex9EventBalance, {contract_pk, <<>>})
@@ -178,10 +178,10 @@ defmodule AeMdw.Aex9 do
     end
   end
 
-  @spec fetch_amount(State.t(), pubkey(), pubkey()) ::
+  @spec fetch_amount(State.t(), State.t(), pubkey(), pubkey()) ::
           {:ok, {number(), txi()}} | {:error, Error.t()}
-  def fetch_amount(state, contract_pk, account_pk) do
-    state = get_store_state(state, contract_pk, account_pk)
+  def fetch_amount(state, async_state, contract_pk, account_pk) do
+    state = get_store_state(state, async_state, contract_pk, account_pk)
 
     case State.get(state, Model.Aex9EventBalance, {contract_pk, account_pk}) do
       {:ok, Model.aex9_event_balance(amount: amount, txi: call_txi)} ->
@@ -195,10 +195,10 @@ defmodule AeMdw.Aex9 do
     end
   end
 
-  @spec fetch_amount_and_keyblock(State.t(), pubkey(), pubkey()) ::
+  @spec fetch_amount_and_keyblock(State.t(), State.t(), pubkey(), pubkey()) ::
           {:ok, {number(), Db.height_hash()}} | {:error, Error.t()}
-  def fetch_amount_and_keyblock(state, contract_pk, account_pk) do
-    with {:ok, {amount, call_txi}} <- fetch_amount(state, contract_pk, account_pk) do
+  def fetch_amount_and_keyblock(state, async_state, contract_pk, account_pk) do
+    with {:ok, {amount, call_txi}} <- fetch_amount(state, async_state, contract_pk, account_pk) do
       kbi = DbUtil.txi_to_gen(state, call_txi)
       Model.block(hash: kb_hash) = State.fetch!(state, Model.Block, {kbi, -1})
 
@@ -286,9 +286,7 @@ defmodule AeMdw.Aex9 do
   #
   # Private functions
   #
-  defp get_store_state(state, contract_pk, account_pk \\ <<>>) do
-    async_state = State.new(AsyncStore.instance())
-
+  defp get_store_state(state, async_state, contract_pk, account_pk \\ <<>>) do
     case State.next(async_state, Model.Aex9EventBalance, {contract_pk, account_pk}) do
       {:ok, {^contract_pk, _account_pk}} -> async_state
       _other -> state

lib/ae_mdw/db/async_store.ex

@@ -21,15 +21,15 @@ defmodule AeMdw.Db.AsyncStore do
   @typep table() :: Database.table()
   @opaque t() :: %__MODULE__{tid: :single_async_store}
 
-  @spec init() :: :ok
-  def init do
-    EtsCache.new(@table_id, @ttl_minutes, :ordered_set)
+  @spec init(atom()) :: :ok
+  def init(t_id \\ @table_id) do
+    EtsCache.new(t_id, @ttl_minutes, :ordered_set)
     :ok
   end
 
-  @spec instance() :: t()
-  def instance do
-    %__MODULE__{tid: @table_id}
+  @spec instance(atom()) :: t()
+  def instance(t_id \\ @table_id) do
+    %__MODULE__{tid: t_id}
   end
 
   @spec mutations(t()) :: [Mutation.t()]

lib/ae_mdw/db/int_transfer.ex

@@ -40,7 +40,12 @@ defmodule AeMdw.Db.IntTransfer do
   def block_rewards_mutations(key_block) do
     height = :aec_blocks.height(key_block)
     delay = :aec_governance.beneficiary_reward_delay()
-    dev_benefs = Enum.map(:aec_dev_reward.beneficiaries(), &elem(&1, 0))
+
+    dev_benefs =
+      for {protocol, _height} <- :aec_hard_forks.protocols(),
+          {pk, _share} <- :aec_dev_reward.beneficiaries(protocol) do
+        pk
+      end
 
     {devs_rewards, miners_rewards} =
       key_block

lib/ae_mdw/db/origin.ex

@@ -16,7 +16,6 @@ defmodule AeMdw.Db.Origin do
   import AeMdw.Util
 
   @contract_creation_types ~w(contract_create_tx contract_call_tx ga_attach_tx)a
-  @iris_protocol 5
 
   @typep contract_locator() :: {:contract, Txs.txi()} | {:contract_call, Txs.txi()}
   @typep creation_txi_locator() :: {:contract, Db.pubkey()}
@@ -142,24 +141,14 @@ defmodule AeMdw.Db.Origin do
     end
   end
 
-  defp hc_contracts do
-    if isis_hardfork?() do
-      {:ok, hc_contracts_json} =
-        :aec_fork_block_settings.hc_seed_contracts(
-          @iris_protocol,
-          :aec_governance.get_network_id()
-        )
-
-      hc_contracts_json
-      |> Enum.find_value([], fn {item, list} -> if item == "contracts", do: list end)
-      |> Enum.map(&(Map.get(&1, "pubkey") || Map.fetch!(&1, "contract_pubkey")))
-      |> Enum.map(&Validate.id!/1)
-    else
-      []
-    end
-  end
-
-  defp isis_hardfork? do
-    match?({:ok, _hardfork_map}, :aeu_env.find_config(["chain", "hard_forks"], [:user_config]))
+  @spec hc_contracts() :: [Db.pubkey()]
+  def hc_contracts do
+    :aec_hard_forks.protocols()
+    |> Enum.flat_map(fn {protocol, _height} ->
+      protocol |> :aec_fork_block_settings.contracts() |> Map.get("contracts", [])
+    end)
+    |> Enum.map(fn contract ->
+      (Map.get(contract, "pubkey") || Map.fetch!(contract, "contract_pubkey")) |> Validate.id!()
+    end)
   end
 end

lib/ae_mdw/db/rocksdb.ex

@@ -125,9 +125,9 @@ defmodule AeMdw.Db.RocksDb do
   """
   @spec dirty_iterator(transaction(), table(), Keyword.t()) :: {:ok, iterator()} | {:error, any()}
   def dirty_iterator(transaction, table, read_options \\ []) do
-    {db_ref, cf_ref} = cf_refs(table)
+    {_db_ref, cf_ref} = cf_refs(table)
 
-    :rocksdb.transaction_iterator(db_ref, transaction, cf_ref, read_options)
+    :rocksdb.transaction_iterator(transaction, cf_ref, read_options)
   end
 
   @doc """

lib/ae_mdw/db/status.ex

@@ -38,7 +38,7 @@ defmodule AeMdw.Db.Status do
 
   defp node_status do
     {node_syncing?, node_progress} =
-      with {node_syncing?, node_progress, _height} <- :aec_sync.sync_progress() do
+      with {node_syncing?, node_progress, _height, _chain_id} <- :aec_sync.sync_progress() do
         {node_syncing?, node_progress}
       end
 

lib/ae_mdw/log.ex

@@ -12,7 +12,7 @@ defmodule AeMdw.Log do
 
   @spec warn(String.t()) :: :ok
   def warn(msg),
-    do: Logger.warn(msg)
+    do: Logger.warning(msg)
 
   @spec error(String.t() | exception()) :: :ok
   def error(msg) when is_binary(msg),

lib/ae_mdw/sync/async_store_server.ex

@@ -15,15 +15,22 @@ defmodule AeMdw.Sync.AsyncStoreServer do
   alias AeMdw.Db.State
   alias AeMdw.Sync.AsyncTasks.WealthRank
 
+  @typep internal_state() :: %{async_store: AsyncStore.t(), last_db_kbi: AeMdw.Blocks.height()}
+
   @spec start_link([]) :: GenServer.on_start()
   def start_link([]) do
-    GenServer.start_link(__MODULE__, :ok, name: __MODULE__)
+    GenServer.start_link(__MODULE__, %{async_store: AsyncStore.instance()}, name: __MODULE__)
+  end
+
+  @spec start_link(%{async_store: AsyncStore.t()}) :: GenServer.on_start()
+  def start_link(%{async_store: async_store}) do
+    GenServer.start_link(__MODULE__, %{async_store: async_store}, name: __MODULE__)
   end
 
-  @spec init(:ok) :: {:ok, %{last_db_kbi: AeMdw.Blocks.height()}}
+  @spec init(%{async_store: AsyncStore.t()}) :: {:ok, internal_state()}
   @impl GenServer
-  def init(:ok) do
-    {:ok, %{last_db_kbi: 0}}
+  def init(%{async_store: async_store}) do
+    {:ok, %{last_db_kbi: 0, async_store: async_store}}
   end
 
   @spec write_mutations([Mutation.t()], fun()) :: :ok
@@ -37,8 +44,11 @@ defmodule AeMdw.Sync.AsyncStoreServer do
   end
 
   @impl GenServer
-  def handle_cast({:write_mutations, mutations, done_fn}, state) do
-    async_state = State.new(AsyncStore.instance())
+  def handle_cast(
+        {:write_mutations, mutations, done_fn},
+        %{async_store: async_store} = state
+      ) do
+    async_state = State.new(async_store)
 
     mutations
     |> Enum.reject(&is_nil/1)
@@ -50,17 +60,21 @@ defmodule AeMdw.Sync.AsyncStoreServer do
   end
 
   @impl GenServer
-  def handle_call({:write_store, db_state1}, _from, state) do
-    {top_keys, store} = WealthRank.prune_balance_ranking(AsyncStore.instance())
+  def handle_call(
+        {:write_store, db_state1},
+        _from,
+        %{async_store: async_store} = state
+      ) do
+    {top_keys, store} = WealthRank.prune_balance_ranking(async_store)
 
     db_state2 =
       store
       |> AsyncStore.mutations()
       |> Enum.reduce(db_state1, &Mutation.execute/2)
 
-    AsyncStore.clear(AsyncStore.instance())
+    AsyncStore.clear(async_store)
 
-    _store = WealthRank.restore_ranking(AsyncStore.instance(), top_keys)
+    _store = WealthRank.restore_ranking(async_store, top_keys)
 
     {:reply, db_state2, state}
   end

lib/ae_mdw/sync/async_tasks/store_account_balance.ex

@@ -4,6 +4,7 @@ defmodule AeMdw.Sync.AsyncTasks.StoreAccountBalance do
   """
   @behaviour AeMdw.Sync.AsyncTasks.Work
 
+  alias AeMdw.Db.AsyncStore
   alias AeMdw.Db.Model
   alias AeMdw.Sync.AsyncTasks.WealthRank
   alias AeMdw.Log
@@ -21,7 +22,8 @@ defmodule AeMdw.Sync.AsyncTasks.StoreAccountBalance do
         with {:value, trees} <- :aec_db.find_block_state_partial(block_hash, true, [:accounts]),
              accounts_tree <- :aec_trees.accounts(trees),
              balances <- get_balances(accounts_tree, account_set) do
-          WealthRank.update_balances(balances)
+          async_store = AsyncStore.instance()
+          WealthRank.update_balances(async_store, balances)
         end
       end)
 

lib/ae_mdw/sync/async_tasks/wealth_rank.ex

@@ -58,13 +58,13 @@ defmodule AeMdw.Sync.AsyncTasks.WealthRank do
     end
   end
 
-  @spec update_balances(balances()) :: :ok
-  def update_balances(balances) do
+  @spec update_balances(AsyncStore.t(), balances()) :: :ok
+  def update_balances(async_store, balances) do
     async_store =
-      if AsyncStore.next(AsyncStore.instance(), Model.BalanceAccount, nil) == :none do
-        init_wealth_store()
+      if AsyncStore.next(async_store, Model.BalanceAccount, nil) == :none do
+        init_wealth_store(async_store)
       else
-        AsyncStore.instance()
+        async_store
       end
 
     _store =
@@ -79,9 +79,7 @@ defmodule AeMdw.Sync.AsyncTasks.WealthRank do
     :ok
   end
 
-  defp init_wealth_store do
-    async_store = AsyncStore.instance()
-
+  defp init_wealth_store(async_store) do
     State.new()
     |> Collection.stream(Model.BalanceAccount, :backward, nil, {nil, nil})
     |> Enum.reduce(async_store, fn {amount, pubkey}, store ->

lib/ae_mdw/sync/mem_store_creator.ex

@@ -18,7 +18,12 @@ defmodule AeMdw.Sync.MemStoreCreator do
 
   @spec create() :: MemStore.t()
   def create do
-    GenServer.call(__MODULE__, :create)
+    GenServer.call(__MODULE__, {:create, DbStore.new()})
+  end
+
+  @spec create(fallback_store :: AeMdw.Db.Store.t()) :: MemStore.t()
+  def create(fallback_store) do
+    GenServer.call(__MODULE__, {:create, fallback_store})
   end
 
   @spec commit(MemStore.t()) :: :ok
@@ -27,8 +32,8 @@ defmodule AeMdw.Sync.MemStoreCreator do
   end
 
   @impl true
-  def handle_call(:create, _from, %{stores: stores} = state) do
-    sync_store = MemStore.new(DbStore.new())
+  def handle_call({:create, fallback_store}, _from, %{stores: stores} = state) do
+    sync_store = MemStore.new(fallback_store)
     created_at = System.monotonic_time(:second)
     stores = [%{store: sync_store, created_at: created_at} | stores]
 

lib/ae_mdw/sync/syncing_queue.ex

@@ -9,7 +9,7 @@ defmodule AeMdw.Sync.SyncingQueue do
 
   use GenServer
 
-  @type task_fn :: (() -> :ok)
+  @type task_fn :: (-> :ok)
 
   @spec start_link(term()) :: {:ok, pid()}
   def start_link(_opts) do