rename

packages/contract_bootloader/dryrun_syscall_handler.py

@@ -17,10 +17,10 @@
     MemorizerFunctionId as HeaderMemorizerFunctionId,
     MemorizerKey as HeaderMemorizerKey,
 )
-from contract_bootloader.dryrun_syscall_handler.header_memorizer_handler import (
+from contract_bootloader.dryrun_syscall_handler_memorizer.header_memorizer_handler import (
     DryRunHeaderMemorizerHandler,
 )
-from contract_bootloader.dryrun_syscall_handler.account_memorizer_handler import (
+from contract_bootloader.dryrun_syscall_handler_memorizer.account_memorizer_handler import (
     DryRunAccountMemorizerHandler,
 )
 

packages/contract_bootloader/syscall_handler.py

@@ -17,10 +17,10 @@
     MemorizerFunctionId as AccountMemorizerFunctionId,
     MemorizerKey as AccountMemorizerKey,
 )
-from contract_bootloader.syscall_handler.account_memorizer_handler import (
+from contract_bootloader.syscall_handler_memorizer.account_memorizer_handler import (
     AccountMemorizerHandler,
 )
-from contract_bootloader.syscall_handler.header_memorizer_handler import (
+from contract_bootloader.syscall_handler_memorizer.header_memorizer_handler import (
     HeaderMemorizerHandler,
 )
 

packages/contract_bootloader/syscall_handler_memorizer/account_memorizer_handler.py

@@ -0,0 +1,97 @@
+from rlp import decode
+from typing import Tuple
+from contract_bootloader.memorizer.memorizer import Memorizer
+from contract_bootloader.memorizer.account_memorizer import (
+    AbstractAccountMemorizerBase,
+    MemorizerKey,
+)
+from starkware.cairo.lang.vm.memory_segments import MemorySegmentManager
+from tools.py.account import Account
+from tools.py.rlp import get_rlp_len
+from tools.py.utils import little_8_bytes_chunks_to_bytes
+
+
+class AccountMemorizerHandler(AbstractAccountMemorizerBase):
+    def __init__(self, segments: MemorySegmentManager, memorizer: Memorizer):
+        super().__init__(memorizer=memorizer)
+        self.segments = segments
+
+    def get_nonce(self, key: MemorizerKey) -> Tuple[int, int]:
+        memorizer_value_ptr = self.memorizer.read(key=key.derive())
+
+        rlp_len = get_rlp_len(
+            rlp=self.segments.memory[memorizer_value_ptr], item_start_offset=0
+        )
+        rlp = self._get_felt_range(
+            start_addr=memorizer_value_ptr,
+            end_addr=memorizer_value_ptr + (rlp_len + 7) // 8,
+        )
+
+        value = decode(little_8_bytes_chunks_to_bytes(rlp, rlp_len), Account).as_dict()[
+            "nonce"
+        ]
+
+        return (
+            value % 0x100000000000000000000000000000000,
+            value // 0x100000000000000000000000000000000,
+        )
+
+    def get_balance(self, key: MemorizerKey) -> Tuple[int, int]:
+        memorizer_value_ptr = self.memorizer.read(key=key.derive())
+
+        rlp_len = get_rlp_len(
+            rlp=self.segments.memory[memorizer_value_ptr], item_start_offset=0
+        )
+        rlp = self._get_felt_range(
+            start_addr=memorizer_value_ptr,
+            end_addr=memorizer_value_ptr + (rlp_len + 7) // 8,
+        )
+
+        value = decode(little_8_bytes_chunks_to_bytes(rlp, rlp_len), Account).as_dict()[
+            "balance"
+        ]
+
+        return (
+            value % 0x100000000000000000000000000000000,
+            value // 0x100000000000000000000000000000000,
+        )
+
+    def get_state_root(self, key: MemorizerKey) -> Tuple[int, int]:
+        memorizer_value_ptr = self.memorizer.read(key=key.derive())
+
+        rlp_len = get_rlp_len(
+            rlp=self.segments.memory[memorizer_value_ptr], item_start_offset=0
+        )
+        rlp = self._get_felt_range(
+            start_addr=memorizer_value_ptr,
+            end_addr=memorizer_value_ptr + (rlp_len + 7) // 8,
+        )
+
+        value = decode(little_8_bytes_chunks_to_bytes(rlp, rlp_len), Account).as_dict()[
+            "storageRoot"
+        ]
+
+        return (
+            value % 0x100000000000000000000000000000000,
+            value // 0x100000000000000000000000000000000,
+        )
+
+    def get_code_hash(self, key: MemorizerKey) -> Tuple[int, int]:
+        memorizer_value_ptr = self.memorizer.read(key=key.derive())
+
+        rlp_len = get_rlp_len(
+            rlp=self.segments.memory[memorizer_value_ptr], item_start_offset=0
+        )
+        rlp = self._get_felt_range(
+            start_addr=memorizer_value_ptr,
+            end_addr=memorizer_value_ptr + (rlp_len + 7) // 8,
+        )
+
+        value = decode(little_8_bytes_chunks_to_bytes(rlp, rlp_len), Account).as_dict()[
+            "codeHash"
+        ]
+
+        return (
+            value % 0x100000000000000000000000000000000,
+            value // 0x100000000000000000000000000000000,
+        )