Add fn in SC lib to get genesis address in smart contract

lib/archethic/contracts/interpreter.ex

@@ -587,6 +587,14 @@ defmodule ArchEthic.Contracts.Interpreter do
        when scope != :root,
        do: {node, acc}
 
+  # Whitelist the get_genesis_address/1 function in condition
+  defp prewalk(
+         node = {{:atom, "get_genesis_address"}, _, [_address]},
+         acc = {:ok, %{scope: :condition}}
+       ) do
+    {node, acc}
+  end
+
   # Whitelist the regex_match?/1 function in the condition
   defp prewalk(
          node = {{:atom, "regex_match?"}, _, [_search]},

lib/archethic/contracts/interpreter/library.ex

@@ -2,6 +2,10 @@ defmodule ArchEthic.Contracts.Interpreter.Library do
   @moduledoc false
 
   alias ArchEthic.Crypto
+  alias ArchEthic.P2P
+  alias ArchEthic.P2P.Message.FirstPublicKey
+  alias ArchEthic.P2P.Message.GetFirstPublicKey
+  alias ArchEthic.P2P.Message.NotFound
 
   @doc """
   Match a regex expression
@@ -79,12 +83,12 @@ defmodule ArchEthic.Contracts.Interpreter.Library do
   end
 
   @doc ~S"""
-  Match a json path expression 
+  Match a json path expression
 
   ## Examples
 
        iex> Library.json_path_match?("{\"1622541930\":{\"uco\":{\"eur\":0.176922,\"usd\":0.21642}}}", "$.*.uco.usd")
-       true     
+       true
   """
   @spec json_path_match?(binary(), binary()) :: boolean()
   def json_path_match?(text, path) when is_binary(text) and is_binary(path) do
@@ -149,4 +153,27 @@ defmodule ArchEthic.Contracts.Interpreter.Library do
   def size(binary) when is_binary(binary), do: byte_size(binary)
   def size(list) when is_list(list), do: length(list)
   def size(map) when is_map(map), do: map_size(map)
+
+  @doc """
+  Get the genesis address of the chain
+
+  """
+  @spec get_genesis_address(binary()) ::
+          binary() | {:error, :network_issue} | {:error, :enoaddress}
+  def get_genesis_address(address) do
+    address = Base.decode16!(address)
+
+    with [node | _rest] <- P2P.available_nodes(),
+         public_key_request <- %GetFirstPublicKey{address: address},
+         {:ok, %FirstPublicKey{public_key: key}} <- P2P.send_message(node, public_key_request) do
+      {pub, _priv} = Crypto.derive_keypair(key, 0)
+      Crypto.derive_address(pub)
+    else
+      [] ->
+        {:error, :network_issue}
+
+      {:ok, %NotFound{}} ->
+        {:error, :enoaddress}
+    end
+  end
 end

test/archethic/contracts/interpreter/library_test.exs

@@ -1,7 +1,61 @@
 defmodule ArchEthic.Contracts.Interpreter.LibraryTest do
-  use ExUnit.Case
+  use ArchEthicCase
 
   alias ArchEthic.Contracts.Interpreter.Library
+  alias ArchEthic.Crypto
+  alias ArchEthic.P2P
+  alias ArchEthic.P2P.Node
+  alias ArchEthic.P2P.Message.NotFound
+  alias ArchEthic.P2P.Message.FirstPublicKey
 
   doctest Library
+
+  import Mox
+
+  describe "get_genesis_address/1" do
+    setup do
+      key = <<0::16, :crypto.strong_rand_bytes(32)::binary>>
+
+      P2P.add_and_connect_node(%Node{
+        ip: {127, 0, 0, 1},
+        port: 3000,
+        first_public_key: key,
+        last_public_key: key,
+        available?: true,
+        geo_patch: "AAA",
+        network_patch: "AAA",
+        authorized?: true,
+        authorization_date: DateTime.utc_now()
+      })
+
+      {:ok, [key: key]}
+    end
+
+    test "with empty node list" do
+      MockClient
+      |> expect(:send_message, fn _, _, _ -> [] end)
+
+      address = :crypto.strong_rand_bytes(34) |> Base.encode16()
+      assert {:error, :network_issue} == Library.get_genesis_address(address)
+    end
+
+    test "with NotFound node list" do
+      MockClient
+      |> expect(:send_message, fn _, _, _ -> {:ok, %NotFound{}} end)
+
+      address = :crypto.strong_rand_bytes(34) |> Base.encode16()
+      assert {:error, :enoaddress} == Library.get_genesis_address(address)
+    end
+
+    test "with FirstPublicKey returned", %{key: key} do
+      {pub, _priv} = Crypto.derive_keypair(key, 0)
+      genesis_address = Crypto.derive_address(pub)
+
+      MockClient
+      |> expect(:send_message, fn _, _, _ -> {:ok, %FirstPublicKey{public_key: key}} end)
+
+      address = :crypto.strong_rand_bytes(34) |> Base.encode16()
+      assert genesis_address == Library.get_genesis_address(address)
+    end
+  end
 end