feat: update genvm to 0.0.14 (#904)

* feat: update genvm to 0.0.14

* fix: update integration of balances and messages for genvm

---------

Co-authored-by: Cristiam Da Silva <cristiam86@gmail.com>

Author: kp2pml30

backend/consensus/base.py

@@ -7,7 +7,7 @@
 import asyncio
 from collections import deque
 import traceback
-from typing import Callable, Iterator, List
+from typing import Callable, Iterator, List, Iterable, Literal
 import time
 from abc import ABC, abstractmethod
 import threading
@@ -29,7 +29,13 @@
     Validator,
 )
 from backend.node.base import Node
-from backend.node.types import ExecutionMode, Receipt, Vote, ExecutionResultStatus
+from backend.node.types import (
+    ExecutionMode,
+    Receipt,
+    Vote,
+    ExecutionResultStatus,
+    PendingTransaction,
+)
 from backend.protocol_rpc.message_handler.base import MessageHandler
 from backend.protocol_rpc.message_handler.types import (
     LogEvent,
@@ -107,6 +113,7 @@ def contract_snapshot_factory(
         ret = ContractSnapshot(None, session)
         ret.contract_address = transaction.to_address
         ret.contract_code = transaction.data["contract_code"]
+        ret.balance = transaction.value or 0
         ret.states = {"accepted": {}, "finalized": {}}
         ret.encoded_state = ret.states["accepted"]
         return ret
@@ -1861,6 +1868,8 @@ async def handle(self, context):
                     accepted_state=leader_receipt.contract_state
                 )
 
+            _emit_transactions(context, leader_receipt.pending_transactions, "accepted")
+
         # Set the transaction appeal undetermined status to false and return appeal status
         if context.transaction.appeal_undetermined:
             context.transactions_processor.set_transaction_appeal_undetermined(
@@ -2009,62 +2018,69 @@ async def handle(self, context):
 
         if context.transaction.status != TransactionStatus.UNDETERMINED:
             # Insert pending transactions generated by contract-to-contract calls
-            pending_transactions = (
-                context.transaction.consensus_data.leader_receipt.pending_transactions
+            _emit_transactions(
+                context,
+                context.transaction.consensus_data.leader_receipt.pending_transactions,
+                "finalized",
             )
-            for pending_transaction in pending_transactions:
-                nonce = context.transactions_processor.get_transaction_count(
-                    context.transaction.to_address
+
+
+def _emit_transactions(
+    context: TransactionContext,
+    pending_transactions: Iterable[PendingTransaction],
+    on: Literal["accepted", "finalized"],
+):
+    for pending_transaction in filter(lambda t: t.on == on, pending_transactions):
+        nonce = context.transactions_processor.get_transaction_count(
+            context.transaction.to_address
+        )
+        data: dict
+        transaction_type: TransactionType
+        if pending_transaction.is_deploy():
+            transaction_type = TransactionType.DEPLOY_CONTRACT
+            new_contract_address: str
+            if pending_transaction.salt_nonce == 0:
+                # NOTE: this address is random, which doesn't 100% align with consensus spec
+                new_contract_address = (
+                    context.accounts_manager.create_new_account().address
                 )
-                data: dict
-                transaction_type: TransactionType
-                if pending_transaction.is_deploy():
-                    transaction_type = TransactionType.DEPLOY_CONTRACT
-                    new_contract_address: str
-                    if pending_transaction.salt_nonce == 0:
-                        # NOTE: this address is random, which doesn't 100% align with consensus spec
-                        new_contract_address = (
-                            context.accounts_manager.create_new_account().address
-                        )
-                    else:
-                        from eth_utils.crypto import keccak
-                        from backend.node.types import Address
-                        from backend.node.base import SIMULATOR_CHAIN_ID
-
-                        arr = bytearray()
-                        arr.append(1)
-                        arr.extend(Address(context.transaction.to_address).as_bytes)
-                        arr.extend(
-                            pending_transaction.salt_nonce.to_bytes(
-                                32, "big", signed=False
-                            )
-                        )
-                        arr.extend(SIMULATOR_CHAIN_ID.to_bytes(32, "big", signed=False))
-                        new_contract_address = Address(keccak(arr)[:20]).as_hex
-                        context.accounts_manager.create_new_account_with_address(
-                            new_contract_address
-                        )
-                    pending_transaction.address = new_contract_address
-                    data = {
-                        "contract_address": new_contract_address,
-                        "contract_code": pending_transaction.code,
-                        "calldata": pending_transaction.calldata,
-                    }
-                else:
-                    transaction_type = TransactionType.RUN_CONTRACT
-                    data = {
-                        "calldata": pending_transaction.calldata,
-                    }
-                context.transactions_processor.insert_transaction(
-                    context.transaction.to_address,  # new calls are done by the contract
-                    pending_transaction.address,
-                    data,
-                    value=0,  # we only handle EOA transfers at the moment, so no value gets transferred
-                    type=transaction_type.value,
-                    nonce=nonce,
-                    leader_only=context.transaction.leader_only,  # Cascade
-                    triggered_by_hash=context.transaction.hash,
+            else:
+                from eth_utils.crypto import keccak
+                from backend.node.types import Address
+                from backend.node.base import SIMULATOR_CHAIN_ID
+
+                arr = bytearray()
+                arr.append(1)
+                arr.extend(Address(context.transaction.to_address).as_bytes)
+                arr.extend(
+                    pending_transaction.salt_nonce.to_bytes(32, "big", signed=False)
+                )
+                arr.extend(SIMULATOR_CHAIN_ID.to_bytes(32, "big", signed=False))
+                new_contract_address = Address(keccak(arr)[:20]).as_hex
+                context.accounts_manager.create_new_account_with_address(
+                    new_contract_address
                 )
+            pending_transaction.address = new_contract_address
+            data = {
+                "contract_address": new_contract_address,
+                "contract_code": pending_transaction.code,
+                "calldata": pending_transaction.calldata,
+            }
+        else:
+            transaction_type = TransactionType.RUN_CONTRACT
+            data = {
+                "calldata": pending_transaction.calldata,
+            }
+        context.transactions_processor.insert_transaction(
+            context.transaction.to_address,  # new calls are done by the contract
+            pending_transaction.address,
+            data,
+            value=0,  # we only handle EOA transfers at the moment, so no value gets transferred
+            type=transaction_type.value,
+            nonce=nonce,
+            leader_only=context.transaction.leader_only,  # Cascade
+            triggered_by_hash=context.transaction.hash,
+        )
 
 
 def rotate(nodes: list) -> Iterator[list]:

backend/database_handler/contract_snapshot.py

@@ -15,6 +15,7 @@ class ContractSnapshot:
     contract_address: str
     contract_code: str
     encoded_state: dict[str, str]
+    balance: int
     states: dict[str, dict[str, str]]
     ghost_contract_address: str | None
 
@@ -27,6 +28,8 @@ def __init__(self, contract_address: str | None, session: Session):
             contract_account = self._load_contract_account()
             self.contract_data = contract_account.data
             self.contract_code = self.contract_data["code"]
+            self.balance = contract_account.balance
+
             if ("accepted" in self.contract_data["state"]) and (
                 isinstance(self.contract_data["state"]["accepted"], dict)
             ):
@@ -35,6 +38,7 @@ def __init__(self, contract_address: str | None, session: Session):
                 # Convert old state format
                 self.states = {"accepted": self.contract_data["state"], "finalized": {}}
             self.encoded_state = self.states["accepted"]
+
             self.ghost_contract_address = (
                 self.contract_data["ghost_contract_address"]
                 if "ghost_contract_address" in self.contract_data

backend/node/base.py

@@ -76,6 +76,12 @@ def storage_write(
         data[index : index + len(mem)] = mem
         snap.encoded_state[slot_id] = base64.b64encode(data).decode("utf-8")
 
+    def get_balance(self, addr: Address) -> int:
+        snap = self._get_snapshot(addr)
+        # FIXME(core-team): it is not obvious where `value` is added to `self.balance`
+        # but return must be increased by it
+        return snap.balance
+
 
 class Node:
     def __init__(

backend/node/genvm/base.py

@@ -14,6 +14,7 @@
 import collections.abc
 import functools
 import datetime
+import abc
 
 from backend.node.types import (
     PendingTransaction,
@@ -64,10 +65,12 @@ def encode_result_to_bytes(result: ExecutionReturn | ExecutionError) -> bytes:
 
 # Interface for accessing the blockchain state, it is needed to not tangle current (awfully unoptimized)
 # storage format with the genvm source code
-class StateProxy(typing.Protocol):
+class StateProxy(metaclass=abc.ABCMeta):
+    @abc.abstractmethod
     def storage_read(
         self, account: Address, slot: bytes, index: int, le: int, /
     ) -> bytes: ...
+    @abc.abstractmethod
     def storage_write(
         self,
         account: Address,
@@ -76,7 +79,10 @@ def storage_write(
         got: collections.abc.Buffer,
         /,
     ) -> None: ...
+    @abc.abstractmethod
     def get_code(self, addr: Address) -> bytes: ...
+    @abc.abstractmethod
+    def get_balance(self, addr: Address) -> int: ...
 
 
 # GenVM protocol just in case it is needed for mocks or bringing back the old one
@@ -124,6 +130,9 @@ def get_code(self, addr: Address) -> bytes:
         assert addr == self.my_address
         return self.code
 
+    def get_balance(self, addr: Address) -> int:
+        return 0
+
 
 # Actual genvm wrapper that will start process and handle all communication
 class GenVMHost(IGenVM):
@@ -143,9 +152,9 @@ async def run_contract(
     ) -> ExecutionResult:
         message = {
             "is_init": is_init,
-            "contract_account": contract_address.as_b64,
-            "sender_account": from_address.as_b64,
-            "origin_account": from_address.as_b64,  # FIXME: no origin in simulator #751
+            "contract_address": contract_address.as_b64,
+            "sender_address": from_address.as_b64,
+            "origin_address": from_address.as_b64,  # FIXME: no origin in simulator #751
             "value": None,
             "chain_id": str(
                 chain_id
@@ -154,7 +163,7 @@ async def run_contract(
         if date is not None:
             assert date.tzinfo is not None
             message["datetime"] = date.isoformat()
-        perms = "rc"  # read/call
+        perms = "rcn"  # read/call/spawn nondet
         if not readonly:
             perms += "ws"  # write/send
         return await _run_genvm_host(
@@ -172,16 +181,16 @@ async def get_contract_schema(self, contract_code: bytes) -> ExecutionResult:
         NO_ADDR = str(base64.b64encode(b"\x00" * 20), encoding="ascii")
         message = {
             "is_init": False,
-            "contract_account": NO_ADDR,
-            "sender_account": NO_ADDR,
-            "origin_account": NO_ADDR,
+            "contract_address": NO_ADDR,
+            "sender_address": NO_ADDR,
+            "origin_address": NO_ADDR,
             "value": None,
             "chain_id": "0",
         }
         return await _run_genvm_host(
             functools.partial(
                 _Host,
-                calldata_bytes=calldata.encode({"method": "__get_schema__"}),
+                calldata_bytes=calldata.encode({"method": "#get-schema"}),
                 state_proxy=_StateProxyNone(Address(NO_ADDR), contract_code),
                 leader_results=None,
             ),
@@ -283,11 +292,14 @@ async def consume_result(
 
     async def get_leader_nondet_result(
         self, call_no: int, /
-    ) -> tuple[ResultCode, collections.abc.Buffer] | None:
+    ) -> tuple[ResultCode, collections.abc.Buffer] | ResultCode:
         leader_results = self._leader_results
         if leader_results is None:
-            return None
-        leader_results_mem = memoryview(leader_results[call_no])
+            return ResultCode.NONE
+        res = leader_results.get(call_no, None)
+        if res is None:
+            return ResultCode.NO_LEADERS
+        leader_results_mem = memoryview(res)
         return (ResultCode(leader_results_mem[0]), leader_results_mem[1:])
 
     async def post_nondet_result(
@@ -298,10 +310,19 @@ async def post_nondet_result(
         encoded_result.extend(memoryview(data))
         self._eq_outputs[call_no] = bytes(encoded_result)
 
-    async def post_message(self, account: bytes, calldata: bytes, _data, /) -> None:
+    async def post_message(
+        self, account: bytes, calldata: bytes, data: genvmhost.DefaultTransactionData, /
+    ) -> None:
+        on = data.get("on", "finalized")
+        value = int(data.get("value", "0x0"), 16)
         self._pending_transactions.append(
             PendingTransaction(
-                Address(account).as_hex, calldata, code=None, salt_nonce=0
+                Address(account).as_hex,
+                calldata,
+                code=None,
+                salt_nonce=0,
+                value=value,
+                on=on,
             )
         )
 
@@ -315,12 +336,17 @@ async def deploy_contract(
         data: genvmhost.DeployDefaultTransactionData,
         /,
     ) -> None:
+        on = data.get("on", "finalized")
+        value = int(data.get("value", "0x0"), 16)
+        salt_nonce = int(data.get("salt_nonce", "0x0"), 16)
         self._pending_transactions.append(
             PendingTransaction(
                 address="0x",
                 calldata=calldata,
                 code=code,
-                salt_nonce=data.get("salt_nonce", 0),
+                salt_nonce=salt_nonce,
+                value=value,
+                on=on,
             )
         )
 
@@ -332,6 +358,9 @@ async def eth_call(self, account: bytes, calldata: bytes, /) -> bytes:
         # FIXME(core-team): #748
         assert False
 
+    async def get_balance(self, account: bytes, /) -> int:
+        return self._state_proxy.get_balance(Address(account))
+
 
 async def _run_genvm_host(
     host_supplier: typing.Callable[[socket.socket], _Host],