Smart contract functions without args

lib/archethic/contracts.ex

@@ -255,27 +255,37 @@ defmodule Archethic.Contracts do
 
   defp get_condition_constants(
          :inherit,
-         %Contract{constants: %Constants{contract: contract_constant}},
+         %Contract{
+           constants: %Constants{contract: contract_constant},
+           public_functions: public_functions,
+           private_functions: private_functions
+         },
          transaction,
          datetime
        ) do
     %{
       "previous" => contract_constant,
       "next" => Constants.from_transaction(transaction),
-      "_time_now" => DateTime.to_unix(datetime)
+      "_time_now" => DateTime.to_unix(datetime),
+      "functions" => Map.merge(public_functions, private_functions)
     }
   end
 
   defp get_condition_constants(
          _,
-         %Contract{constants: %Constants{contract: contract_constant}},
+         %Contract{
+           constants: %Constants{contract: contract_constant},
+           public_functions: public_functions,
+           private_functions: private_functions
+         },
          transaction,
          datetime
        ) do
     %{
       "transaction" => Constants.from_transaction(transaction),
       "contract" => contract_constant,
-      "_time_now" => DateTime.to_unix(datetime)
+      "_time_now" => DateTime.to_unix(datetime),
+      "functions" => Map.merge(public_functions, private_functions)
     }
   end
 end

lib/archethic/contracts/contract.ex

@@ -7,13 +7,16 @@ defmodule Archethic.Contracts.Contract do
   alias Archethic.Contracts.ContractConstants, as: Constants
 
   alias Archethic.Contracts.Interpreter
+  alias Archethic.Contracts.Interpreter.Scope
 
   alias Archethic.SharedSecrets
 
   alias Archethic.TransactionChain.Transaction
   alias Archethic.TransactionChain.TransactionData
 
   defstruct triggers: %{},
+            public_functions: %{},
+            private_functions: %{},
             version: 0,
             conditions: %{},
             constants: %Constants{},
@@ -94,4 +97,29 @@ defmodule Archethic.Contracts.Contract do
       ) do
     Map.update!(contract, :conditions, &Map.put(&1, condition_name, conditions))
   end
+
+  @doc """
+  Add a public or private function to the contract
+  """
+  def add_function(
+        contract = %__MODULE__{},
+        :public,
+        function_name,
+        ast,
+        args
+      ) do
+    function_key = Scope.function_to_function_key(function_name, args)
+    Map.update!(contract, :public_functions, &Map.put(&1, function_key, %{ast: ast, args: args}))
+  end
+
+  def add_function(
+        contract = %__MODULE__{},
+        :private,
+        function_name,
+        ast,
+        args
+      ) do
+    function_key = Scope.function_to_function_key(function_name, args)
+    Map.update!(contract, :private_functions, &Map.put(&1, function_key, %{ast: ast, args: args}))
+  end
 end

lib/archethic/contracts/interpreter.ex

@@ -6,6 +6,9 @@ defmodule Archethic.Contracts.Interpreter do
   alias __MODULE__.Legacy
   alias __MODULE__.ActionInterpreter
   alias __MODULE__.ConditionInterpreter
+  alias __MODULE__.FunctionInterpreter
+  alias __MODULE__.Scope
+
   alias __MODULE__.ConditionValidator
 
   alias Archethic.Contracts.Contract
@@ -117,7 +120,9 @@ defmodule Archethic.Contracts.Interpreter do
         %Contract{
           version: version,
           triggers: triggers,
-          constants: %Constants{contract: contract_constants}
+          constants: %Constants{contract: contract_constants},
+          public_functions: public_functions,
+          private_functions: private_functions
         },
         maybe_trigger_tx,
         opts \\ []
@@ -150,7 +155,8 @@ defmodule Archethic.Contracts.Interpreter do
                 Constants.from_transaction(trigger_tx)
             end,
           "contract" => contract_constants,
-          "_time_now" => timestamp_now
+          "_time_now" => timestamp_now,
+          "functions" => Map.merge(public_functions, private_functions)
         }
 
         result =
@@ -291,7 +297,9 @@ defmodule Archethic.Contracts.Interpreter do
   end
 
   defp parse_contract(1, ast) do
-    case parse_ast_block(ast, %Contract{}) do
+    functions_keys = get_functions(ast)
+
+    case parse_ast_block(ast, %Contract{}, functions_keys) do
       {:ok, contract} ->
         {:ok, %{contract | version: 1}}
 
@@ -304,20 +312,20 @@ defmodule Archethic.Contracts.Interpreter do
     {:error, "@version not supported"}
   end
 
-  defp parse_ast_block([ast | rest], contract) do
-    case parse_ast(ast, contract) do
+  defp parse_ast_block([ast | rest], contract, functions_keys) do
+    case parse_ast(ast, contract, functions_keys) do
       {:ok, contract} ->
-        parse_ast_block(rest, contract)
+        parse_ast_block(rest, contract, functions_keys)
 
       {:error, _, _} = e ->
         e
     end
   end
 
-  defp parse_ast_block([], contract), do: {:ok, contract}
+  defp parse_ast_block([], contract, _), do: {:ok, contract}
 
-  defp parse_ast(ast = {{:atom, "condition"}, _, _}, contract) do
-    case ConditionInterpreter.parse(ast) do
+  defp parse_ast(ast = {{:atom, "condition"}, _, _}, contract, functions_keys) do
+    case ConditionInterpreter.parse(ast, functions_keys) do
       {:ok, condition_type, condition} ->
         {:ok, Contract.add_condition(contract, condition_type, condition)}
 
@@ -326,8 +334,8 @@ defmodule Archethic.Contracts.Interpreter do
     end
   end
 
-  defp parse_ast(ast = {{:atom, "actions"}, _, _}, contract) do
-    case ActionInterpreter.parse(ast) do
+  defp parse_ast(ast = {{:atom, "actions"}, _, _}, contract, functions_keys) do
+    case ActionInterpreter.parse(ast, functions_keys) do
       {:ok, trigger_type, actions} ->
         {:ok, Contract.add_trigger(contract, trigger_type, actions)}
 
@@ -336,7 +344,31 @@ defmodule Archethic.Contracts.Interpreter do
     end
   end
 
-  defp parse_ast(ast, _), do: {:error, ast, "unexpected term"}
+  defp parse_ast(
+         ast = {{:atom, "export"}, _, [{{:atom, "fun"}, _, _} | _]},
+         contract,
+         functions_keys
+       ) do
+    case FunctionInterpreter.parse(ast, functions_keys) do
+      {:ok, function_name, args, ast} ->
+        {:ok, Contract.add_function(contract, :public, function_name, ast, args)}
+
+      {:error, _, _} = e ->
+        e
+    end
+  end
+
+  defp parse_ast(ast = {{:atom, "fun"}, _, _}, contract, functions_keys) do
+    case FunctionInterpreter.parse(ast, functions_keys) do
+      {:ok, function_name, args, ast} ->
+        {:ok, Contract.add_function(contract, :private, function_name, ast, args)}
+
+      {:error, _, _} = e ->
+        e
+    end
+  end
+
+  defp parse_ast(ast, _, _), do: {:error, ast, "unexpected term"}
 
   defp time_now(:transaction, %Transaction{
          validation_stamp: %ValidationStamp{timestamp: timestamp}
@@ -358,6 +390,21 @@ defmodule Archethic.Contracts.Interpreter do
     Utils.get_current_time_for_interval(interval)
   end
 
+  defp get_functions([{{:atom, "fun"}, _, [{{:atom, function_name}, _, args} | _]} | rest]) do
+    [Scope.function_to_function_key(function_name, args) | get_functions(rest)]
+  end
+
+  defp get_functions([
+         {{:atom, "export"}, _,
+          [{{:atom, "fun"}, _, [{{:atom, function_name}, _, args} | _]} | _]}
+         | rest
+       ]) do
+    [Scope.function_to_function_key(function_name, args) | get_functions(rest)]
+  end
+
+  defp get_functions([_ | rest]), do: get_functions(rest)
+  defp get_functions([]), do: []
+
   # -----------------------------------------
   # contract validation
   # -----------------------------------------

lib/archethic/contracts/interpreter/action_interpreter.ex

@@ -13,13 +13,15 @@ defmodule Archethic.Contracts.Interpreter.ActionInterpreter do
   @doc """
   Parse the given node and return the trigger and the actions block.
   """
-  @spec parse(any()) :: {:ok, atom(), any()} | {:error, any(), String.t()}
-  def parse({{:atom, "actions"}, _, [keyword, [do: block]]}) do
+  @spec parse(any(), list) :: {:ok, atom(), any()} | {:error, any(), String.t()}
+  def parse(_, _ \\ [])
+
+  def parse({{:atom, "actions"}, _, [keyword, [do: block]]}, functions_keys) do
     trigger_type = extract_trigger(keyword)
 
     # We only parse the do..end block with the macro.traverse
     # this help us keep a clean accumulator that is used only for scoping.
-    actions_ast = parse_block(AST.wrap_in_block(block))
+    actions_ast = parse_block(AST.wrap_in_block(block), functions_keys)
 
     {:ok, trigger_type, actions_ast}
   catch
@@ -30,7 +32,7 @@ defmodule Archethic.Contracts.Interpreter.ActionInterpreter do
       {:error, node, reason}
   end
 
-  def parse(node) do
+  def parse(node, _) do
     {:error, node, "unexpected term"}
   end
 
@@ -127,7 +129,7 @@ defmodule Archethic.Contracts.Interpreter.ActionInterpreter do
     throw({:error, node, "Invalid trigger"})
   end
 
-  defp parse_block(ast) do
+  defp parse_block(ast, functions_keys) do
     # here the accumulator is an list of parent scopes & current scope
     # where we can access variables from all of them
     # `acc = [ref1]` means read variable from scope.ref1 or scope
@@ -142,7 +144,7 @@ defmodule Archethic.Contracts.Interpreter.ActionInterpreter do
           prewalk(node, acc)
         end,
         fn node, acc ->
-          postwalk(node, acc)
+          postwalk(node, acc, functions_keys)
         end
       )
 
@@ -187,7 +189,8 @@ defmodule Archethic.Contracts.Interpreter.ActionInterpreter do
   defp postwalk(
          node =
            {{:., _meta, [{:__aliases__, _, [atom: "Contract"]}, {:atom, function_name}]}, _, args},
-         acc
+         acc,
+         _
        ) do
     absolute_module_atom = Archethic.Contracts.Interpreter.Library.Contract
 
@@ -204,7 +207,7 @@ defmodule Archethic.Contracts.Interpreter.ActionInterpreter do
 
     function_atom = String.to_existing_atom(function_name)
 
-    # check the type of the args
+    # check the type of the args, and allow custom function call as args
     unless absolute_module_atom.check_types(function_atom, args) do
       throw({:error, node, "invalid function arguments"})
     end
@@ -226,8 +229,8 @@ defmodule Archethic.Contracts.Interpreter.ActionInterpreter do
   end
 
   # --------------- catch all -------------------
-  defp postwalk(node, acc) do
-    CommonInterpreter.postwalk(node, acc)
+  defp postwalk(node, acc, functions_keys) do
+    CommonInterpreter.postwalk(node, acc, functions_keys)
   end
 
   # keep only the transaction fields we are interested in

lib/archethic/contracts/interpreter/common_interpreter.ex

@@ -253,6 +253,9 @@ defmodule Archethic.Contracts.Interpreter.CommonInterpreter do
     {ast, acc}
   end
 
+  # function call, should be placed after "for" prewalk
+  def prewalk(node = {{:atom, _}, _, args}, acc) when is_list(args), do: {node, acc}
+
   # log (not documented, only useful for developer debugging)
   # will soon be updated to log into the playground console
   def prewalk(_node = {{:atom, "log"}, _, [data]}, acc) do
@@ -272,9 +275,12 @@ defmodule Archethic.Contracts.Interpreter.CommonInterpreter do
   #  |_|
   # ----------------------------------------------------------------------
   # exit block == set parent scope
+  def postwalk(_, _, function_keys \\ [])
+
   def postwalk(
         node = {:__block__, _, _},
-        acc
+        acc,
+        _
       ) do
     {node, List.delete_at(acc, -1)}
   end
@@ -283,7 +289,8 @@ defmodule Archethic.Contracts.Interpreter.CommonInterpreter do
   def postwalk(
         node =
           {{:., meta, [{:__aliases__, _, [atom: module_name]}, {:atom, function_name}]}, _, args},
-        acc
+        acc,
+        _
       )
       when module_name in @modules_whitelisted do
     absolute_module_atom =
@@ -307,6 +314,7 @@ defmodule Archethic.Contracts.Interpreter.CommonInterpreter do
     function_atom = String.to_existing_atom(function_name)
 
     # check the type of the args
+
     unless absolute_module_atom.check_types(function_atom, args) do
       throw({:error, node, "invalid function arguments"})
     end
@@ -322,7 +330,8 @@ defmodule Archethic.Contracts.Interpreter.CommonInterpreter do
   # variable are read from scope
   def postwalk(
         _node = {{:atom, var_name}, _, nil},
-        acc
+        acc,
+        _
       ) do
     new_node =
       quote do
@@ -340,7 +349,8 @@ defmodule Archethic.Contracts.Interpreter.CommonInterpreter do
              {:%{}, _, [{var_name, list}]},
              [do: block]
            ]},
-        acc
+        acc,
+        _
       ) do
     # FIXME: here acc is already the parent acc, it is not the acc of the do block
     # FIXME: this means that our `var_name` will live in the parent scope
@@ -360,8 +370,25 @@ defmodule Archethic.Contracts.Interpreter.CommonInterpreter do
     {new_node, acc}
   end
 
+  def postwalk(node = {{:atom, function_name}, _, args}, acc, function_keys) when is_list(args) do
+    function_key = Scope.function_to_function_key(function_name, args)
+
+    case Enum.member?(function_keys, function_key) do
+      true ->
+        new_node =
+          quote do
+            Scope.execute_function_ast(unquote(function_name), unquote(args))
+          end
+
+        {new_node, acc}
+
+      false ->
+        throw({:error, node, "The function " <> function_key <> " does not exist"})
+    end
+  end
+
   # BigInt mathematics to avoid floating point issues
-  def postwalk(_node = {ast, meta, [lhs, rhs]}, acc) when ast in [:*, :/, :+, :-] do
+  def postwalk(_node = {ast, meta, [lhs, rhs]}, acc, _) when ast in [:*, :/, :+, :-] do
     new_node =
       quote line: Keyword.fetch!(meta, :line) do
         AST.decimal_arithmetic(unquote(ast), unquote(lhs), unquote(rhs))
@@ -371,7 +398,7 @@ defmodule Archethic.Contracts.Interpreter.CommonInterpreter do
   end
 
   # whitelist rest
-  def postwalk(node, acc), do: {node, acc}
+  def postwalk(node, acc, _), do: {node, acc}
 
   # ----------------------------------------------------------------------
   #              _            _