[GH-704] Handle Sophia contracts in checks upon creating

Author: cheezus1

apps/aecore/lib/aecore/contract/contract_constants.ex

@@ -13,4 +13,8 @@ defmodule Aecore.Contract.ContractConstants do
   defmacro aevm_solidity_01 do
     quote do: 2
   end
+
+  defmacro sophia_init_function do
+    <<"init">>
+  end
 end

apps/aecore/lib/aecore/contract/sophia/sophia_abi.ex

@@ -0,0 +1,17 @@
+defmodule Aecore.Contract.Sophia.SophiaAbi do
+
+  def get_function_name_from_type_info(function_hash, type_info) do
+    function_info =
+      Enum.find(type_info, nil, fn function_info ->
+        Enum.at(function_info, 0) == function_hash
+      end)
+
+    case function_info do
+      nil ->
+        {:error, :no_such_function}
+      _ ->
+        {:ok, Enum.at(function_info, 1)}
+    end
+  end
+
+end

apps/aecore/lib/aecore/contract/sophia/sophia_data.ex

@@ -0,0 +1,11 @@
+defmodule Aecore.Contract.Sophia.SophiaData do
+
+  @word_size_bits 256
+
+  def get_function_hash_from_call_data(call_data) do
+    <<_::size(@word_size_bits), function_hash_int::size(@word_size_bits), _::binary>> = call_data
+
+    <<function_hash_int::size(@word_size_bits)>>
+  end
+
+end

apps/aecore/lib/aecore/contract/sophia/sophia_wrapped_code.ex

@@ -0,0 +1,39 @@
+defmodule Aecore.Contract.Sophia.SophiaWrappedCode do
+  @moduledoc """
+  Module, defining the wrapped Sophia code structure
+  """
+
+  alias __MODULE__
+
+  @version 1
+
+  @type t :: %SophiaWrappedCode{
+          source_hash: binary(),
+          # [type_hash, name, arg_type, out_type]
+          type_info: map(),
+          byte_code: binary()
+        }
+
+  defstruct [:source_hash, :type_info, :byte_code]
+
+  use Aecore.Util.Serializable
+
+  @spec encode_to_list(SophiaWrappedCode.t()) :: list()
+  def encode_to_list(%SophiaWrappedCode{
+        source_hash: source_hash,
+        type_info: type_info,
+        byte_code: byte_code
+      }) do
+    [@version, source_hash, type_info, byte_code]
+  end
+
+  @spec decode_from_list(binary(), atom()) :: term() | {:error, binary()}
+  def decode_from_list(@version, [source_hash, type_info, byte_code]) do
+    {:ok,
+     %SophiaWrappedCode{
+       source_hash: source_hash,
+       type_info: type_info,
+       byte_code: byte_code
+     }}
+  end
+end

apps/aecore/lib/aecore/contract/tx/contract_create_tx.ex

@@ -10,6 +10,7 @@ defmodule Aecore.Contract.Tx.ContractCreateTx do
   alias Aecore.Account.{Account, AccountStateTree}
   alias Aecore.Chain.{Identifier, Chainstate}
   alias Aecore.Contract.{Contract, Call, CallStateTree, ContractStateTree, Dispatch}
+  alias Aecore.Contract.Sophia.{SophiaWrappedCode, SophiaData, SophiaAbi}
   alias Aecore.Governance.GovernanceConstants
   alias Aecore.Tx.{DataTx, Transaction}
   require Aecore.Contract.ContractConstants, as: Constants
@@ -178,12 +179,25 @@ defmodule Aecore.Contract.Tx.ContractCreateTx do
               Account.apply_transfer!(acc, block_height, (gas_cost + deposit) * -1)
             end)
 
-          updated_store = ContractStateTree.get(updated_state.contracts, contract.id.value).store
-          updated_contract = %{contract | code: call_result.return_value, store: updated_store}
+          updated_contract =
+            case vm_version do
+              Constants.aevm_sophia_01() ->
+                # updated_store = call_result.return_value
+                # TODO: extract Sophia state from return value and save it in contract state
+                contract
+
+              Constants.aevm_solidity_01() ->
+                updated_store =
+                  ContractStateTree.get(updated_state.contracts, contract.id.value).store
+
+                %{contract | code: call_result.return_value, store: updated_store}
+            end
+
+          cleared_call_result = %{call_result | return_value: <<>>}
 
           chain_state_with_call = %{
             updated_state
-            | calls: CallStateTree.insert_call(updated_state.calls, call_result),
+            | calls: CallStateTree.insert_call(updated_state.calls, cleared_call_result),
               accounts: accounts_after_gas_spent,
               contracts:
                 ContractStateTree.enter_contract(updated_state.contracts, updated_contract)
@@ -220,10 +234,13 @@ defmodule Aecore.Contract.Tx.ContractCreateTx do
         _chainstate,
         _block_height,
         %ContractCreateTx{
-          amount: amount,
+          code: code,
+          vm_version: vm_version,
           deposit: deposit,
+          amount: amount,
           gas: gas,
-          gas_price: gas_price
+          gas_price: gas_price,
+          call_data: call_data
         },
         %DataTx{fee: fee, senders: [%Identifier{value: sender}]},
         _context
@@ -233,7 +250,27 @@ defmodule Aecore.Contract.Tx.ContractCreateTx do
     if AccountStateTree.get(accounts, sender).balance - total_deduction < 0 do
       {:error, "#{__MODULE__}: Negative balance"}
     else
-      :ok
+      case vm_version do
+        Constants.aevm_sophia_01() ->
+          case Serialization.rlp_decode_only(code, SophiaWrappedCode) do
+            {:ok, %SophiaWrappedCode{type_info: type_info}} ->
+              function_hash = SophiaData.get_function_hash_from_call_data(call_data)
+
+              case SophiaAbi.get_function_name_from_type_info(function_hash, type_info) do
+                {:ok, Constants.sophia_init_function()} ->
+                  :ok
+
+                {:error, _} ->
+                  {:error, "#{__MODULE__}: Bad init function"}
+              end
+
+            {:error, message} ->
+              {:error, "#{__MODULE__}: #{message}"}
+          end
+
+        Constants.aevm_solidity_01() ->
+          :ok
+      end
     end
   end
 

apps/aeutil/lib/type_to_tag.ex

@@ -41,6 +41,7 @@ defmodule Aeutil.TypeToTag do
   def tag_to_type(58), do: {:ok, Aecore.Channel.ChannelStateOnChain}
   # Channel snapshot transaction - 59
   def tag_to_type(60), do: {:ok, Aecore.Poi.Poi}
+  def tag_to_type(70), do: {:ok, Aecore.Contract.Sophia.SophiaWrappedCode}
   # Non Epoch tags:
   def tag_to_type(100), do: {:ok, Aecore.Chain.Block}
   def tag_to_type(tag), do: {:error, "#{__MODULE__}: Unknown tag: #{inspect(tag)}"}
@@ -83,6 +84,7 @@ defmodule Aeutil.TypeToTag do
   def type_to_tag(Aecore.Channel.ChannelStateOnChain), do: {:ok, 58}
   # Channel snapshot transaction - 59
   def type_to_tag(Aecore.Poi.Poi), do: {:ok, 60}
+  def type_to_tag(Aecore.Contract.Sophia.SophiaWrappedCode), do: {:ok, 70}
   # Non Epoch tags
   def type_to_tag(Aecore.Chain.Block), do: {:ok, 100}
   def type_to_tag(type), do: {:error, "#{__MODULE__}: Non serializable type: #{type}"}