Adapt to cairo-lang 0.9.0

pyproject.toml

@@ -14,11 +14,12 @@ keywords = ["starknet", "cairo", "testnet", "local", "server"]
 python = ">=3.7.2,<3.10"
 Flask = {extras = ["async"], version = "~2.0.3"}
 flask-cors = "~3.0.10"
-cairo-lang = "0.8.2.1"
+cairo-lang = "0.9.0"
 dill = "~0.3.4"
 meinheld = "~1.0.2"
 Werkzeug = "~2.0.3"
 crypto-cpp-py = "^1.0.4"
+cloudpickle = "^2.1.0"
 
 [tool.poetry.dev-dependencies]
 pylint = "~2.12.2"

starknet_devnet/account.py

@@ -6,8 +6,8 @@
 from starkware.solidity.utils import load_nearby_contract
 from starkware.starknet.business_logic.state.objects import ContractState, ContractCarriedState
 from starkware.starknet.public.abi import get_selector_from_name
-from starkware.starknet.services.api.contract_definition import ContractDefinition
-from starkware.starknet.services.api.gateway.contract_address import calculate_contract_address_from_hash
+from starkware.starknet.services.api.contract_class import ContractClass
+from starkware.starknet.core.os.contract_address.contract_address import calculate_contract_address_from_hash
 from starkware.starknet.storage.starknet_storage import StorageLeaf
 from starkware.starknet.testing.starknet import Starknet
 from starkware.starknet.testing.contract import StarknetContract
@@ -18,11 +18,11 @@
 class Account:
     """Account contract wrapper."""
 
-    DEFINITION: ContractDefinition = None # loaded lazily
+    CONTRACT_CLASS: ContractClass = None # loaded lazily
     CONTRACT_PATH = "accounts_artifacts/OpenZeppelin/0.1.0/Account.cairo/Account"
 
     # Precalculated to save time
-    # HASH = compute_contract_hash(contract_definition=Account.get_definition()))
+    # HASH = compute_class_hash(contract_class=Account.get_contract_class()))
     HASH = 361479646297615797917493841430922492724680358320444679508058603177506550951
     HASH_BYTES = to_bytes(HASH)
 
@@ -34,26 +34,26 @@ def __init__(self, private_key: int, public_key: int, initial_balance: int):
         self.public_key = public_key
         self.address = calculate_contract_address_from_hash(
             salt=Account.SALT,
-            contract_hash=Account.HASH,
+            class_hash=Account.HASH,
             constructor_calldata=[public_key],
-            caller_address=0
+            deployer_address=0
         )
         self.initial_balance = initial_balance
 
     @classmethod
-    def get_definition(cls):
-        """Returns contract definition via lazy loading."""
-        if not cls.DEFINITION:
-            cls.DEFINITION = ContractDefinition.load(load_nearby_contract(cls.CONTRACT_PATH))
-        return cls.DEFINITION
+    def get_contract_class(cls):
+        """Returns contract class via lazy loading."""
+        if not cls.CONTRACT_CLASS:
+            cls.CONTRACT_CLASS = ContractClass.load(load_nearby_contract(cls.CONTRACT_PATH))
+        return cls.CONTRACT_CLASS
 
     async def deploy(self, starknet: Starknet) -> StarknetContract:
         """Deploy this account."""
         account_carried_state = starknet.state.state.contract_states[self.address]
         account_state = account_carried_state.state
         assert not account_state.initialized
 
-        starknet.state.state.contract_definitions[Account.HASH_BYTES] = Account.get_definition()
+        starknet.state.state.contract_definitions[Account.HASH_BYTES] = Account.get_contract_class()
 
         newly_deployed_account_state = await ContractState.create(
             contract_hash=Account.HASH_BYTES,
@@ -78,7 +78,7 @@ async def deploy(self, starknet: Starknet) -> StarknetContract:
 
         return StarknetContract(
             state=starknet.state,
-            abi=Account.get_definition().abi,
+            abi=Account.get_contract_class().abi,
             contract_address=self.address,
             deploy_execution_info=None
         )

starknet_devnet/blocks.py

@@ -5,7 +5,7 @@
 from typing import Dict
 
 from starkware.starknet.testing.state import StarknetState
-from starkware.starknet.services.api.feeder_gateway.block_hash import calculate_block_hash
+from starkware.starknet.core.os.block_hash.block_hash import calculate_block_hash
 from starkware.starknet.services.api.feeder_gateway.response_objects import StarknetBlock, BlockStatus
 from starkware.starknet.services.api.feeder_gateway.response_objects import BlockStateUpdate
 

starknet_devnet/blueprints/feeder_gateway.py

@@ -85,7 +85,7 @@ def get_code():
 @feeder_gateway.route("/get_full_contract", methods=["GET"])
 def get_full_contract():
     """
-    Returns the contract definition of the contract whose contractAddress is provided.
+    Returns the contract class of the contract whose contractAddress is provided.
     """
     _check_block_hash(request.args)
 

starknet_devnet/contract_wrapper.py

@@ -5,62 +5,22 @@
 from dataclasses import dataclass
 from typing import List
 
-from starkware.starknet.services.api.contract_definition import ContractDefinition
+from starkware.starknet.services.api.contract_class import ContractClass
 from starkware.starknet.testing.contract import StarknetContract
 from starkware.starknet.utils.api_utils import cast_to_felts
-from starkware.starknet.business_logic.internal_transaction import InternalInvokeFunction
-from starkware.starknet.business_logic.execution.execute_entry_point import ExecuteEntryPoint
-from starkware.starknet.business_logic.execution.objects import (
-    TransactionExecutionContext,
-    TransactionExecutionInfo,
-)
-from starkware.starknet.testing.state import StarknetState
-
-async def call_internal_tx(starknet_state: StarknetState, internal_tx: InternalInvokeFunction):
-    """
-    Executes an internal transaction.
-    """
-    with starknet_state.state.copy_and_apply() as state_copy:
-        tx_execution_context = TransactionExecutionContext.create(
-            account_contract_address=internal_tx.contract_address,
-            transaction_hash=internal_tx.hash_value,
-            signature=internal_tx.signature,
-            max_fee=internal_tx.max_fee,
-            n_steps=starknet_state.general_config.invoke_tx_max_n_steps,
-            version=internal_tx.version,
-        )
-        call = ExecuteEntryPoint(
-            contract_address=internal_tx.contract_address,
-            code_address=internal_tx.code_address,
-            entry_point_selector=internal_tx.entry_point_selector,
-            entry_point_type=internal_tx.entry_point_type,
-            calldata=internal_tx.calldata,
-            caller_address=internal_tx.caller_address,
-        )
-        call_info = await call.execute(
-            state=state_copy,
-            general_config=starknet_state.general_config,
-            tx_execution_context=tx_execution_context
-        )
-        fee_transfer_info = None
-        actual_fee = 0
-
-    return TransactionExecutionInfo(
-        call_info=call_info, fee_transfer_info=fee_transfer_info, actual_fee=actual_fee
-    )
 
 @dataclass
 class ContractWrapper:
     """
     Wraps a StarknetContract, storing its types and code for later use.
     """
-    def __init__(self, contract: StarknetContract, contract_definition: ContractDefinition):
+    def __init__(self, contract: StarknetContract, contract_class: ContractClass):
         self.contract: StarknetContract = contract
-        self.contract_definition = contract_definition.remove_debug_info().dump()
+        self.contract_class = contract_class.remove_debug_info().dump()
 
         self.code: dict = {
-            "abi": contract_definition.abi,
-            "bytecode": self.contract_definition["program"]["data"]
+            "abi": contract_class.abi,
+            "bytecode": self.contract_class["program"]["data"]
         }
 
     # pylint: disable=too-many-arguments

starknet_devnet/contracts.py

@@ -55,4 +55,4 @@ def get_full_contract(self, address: int) -> ContractWrapper:
         Get the contract wrapper by address.
         """
         contract = self.get_by_address(address)
-        return contract.contract_definition
+        return contract.contract_class

starknet_devnet/dump.py

@@ -2,7 +2,7 @@
 
 import multiprocessing
 
-import dill as pickle
+import cloudpickle as pickle
 
 from .util import DumpOn
 

starknet_devnet/fee_token.py

@@ -3,7 +3,7 @@
 """
 
 from starkware.solidity.utils import load_nearby_contract
-from starkware.starknet.services.api.contract_definition import ContractDefinition
+from starkware.starknet.services.api.contract_class import ContractClass
 from starkware.starknet.business_logic.state.objects import ContractState, ContractCarriedState
 from starkware.starknet.testing.contract import StarknetContract
 from starkware.starknet.testing.starknet import Starknet
@@ -14,10 +14,10 @@
 class FeeToken:
     """Wrapper of token for charging fees."""
 
-    DEFINITION: ContractDefinition = None # loaded lazily
+    CONTRACT_CLASS: ContractClass = None # loaded lazily
 
     # Precalcuated to save time
-    # HASH = to_bytes(compute_contract_hash(contract_definition=FeeToken.get_definition()))
+    # HASH = to_bytes(compute_class_hash(contract_class=FeeToken.get_contract_class()))
     HASH = 375899817338126263298463755162657787890597705735749339531748983767835688120
     HASH_BYTES = to_bytes(HASH)
 
@@ -26,7 +26,7 @@ class FeeToken:
     CONSTRUCTOR_CALLDATA = []
 
     # Precalculated to save time
-    # ADDRESS = calculate_contract_address_from_hash(salt=SALT, contract_hash=HASH,
+    # ADDRESS = calculate_contract_address_from_hash(salt=SALT, class_hash=HASH,
     #     constructor_calldata=CONSTRUCTOR_CALLDATA,
     #     caller_address=0
     # )
@@ -35,11 +35,11 @@ class FeeToken:
     contract: StarknetContract = None
 
     @classmethod
-    def get_definition(cls):
-        """Returns contract definition via lazy loading."""
-        if not cls.DEFINITION:
-            cls.DEFINITION = ContractDefinition.load(load_nearby_contract("ERC20"))
-        return cls.DEFINITION
+    def get_contract_class(cls):
+        """Returns contract class via lazy loading."""
+        if not cls.CONTRACT_CLASS:
+            cls.CONTRACT_CLASS = ContractClass.load(load_nearby_contract("ERC20"))
+        return cls.CONTRACT_CLASS
 
     @classmethod
     async def deploy(cls, starknet: Starknet):
@@ -49,7 +49,7 @@ async def deploy(cls, starknet: Starknet):
         fee_token_state = fee_token_carried_state.state
         assert not fee_token_state.initialized
 
-        starknet.state.state.contract_definitions[cls.HASH_BYTES] = cls.get_definition()
+        starknet.state.state.contract_definitions[cls.HASH_BYTES] = cls.get_contract_class()
         newly_deployed_fee_token_state = await ContractState.create(
             contract_hash=cls.HASH_BYTES,
             storage_commitment_tree=fee_token_state.storage_commitment_tree
@@ -66,7 +66,7 @@ async def deploy(cls, starknet: Starknet):
 
         cls.contract = StarknetContract(
             state=starknet.state,
-            abi=cls.get_definition().abi,
+            abi=cls.get_contract_class().abi,
             contract_address=cls.ADDRESS,
             deploy_execution_info=None
         )

starknet_devnet/origin.py

@@ -46,7 +46,7 @@ def get_code(self, contract_address: int) -> dict:
         raise NotImplementedError
 
     def get_full_contract(self, contract_address: int) -> dict:
-        """Returns the contract definition"""
+        """Returns the contract class"""
         raise NotImplementedError
 
     def get_storage_at(self, contract_address: int, key: int) -> str:

starknet_devnet/server.py

@@ -3,11 +3,11 @@
 """
 
 import sys
-import meinheld
-import dill as pickle
+from pickle import UnpicklingError
 
 from flask import Flask
 from flask_cors import CORS
+import meinheld
 
 from starkware.starkware_utils.error_handling import StarkException
 from .blueprints.base import base
@@ -50,7 +50,7 @@ def load_dumped(args):
     if args.load_path:
         try:
             state.load(args.load_path)
-        except (FileNotFoundError, pickle.UnpicklingError):
+        except (FileNotFoundError, UnpicklingError):
             sys.exit(f"Error: Cannot load from {args.load_path}. Make sure the file exists and contains a Devnet dump.")
 
 def enable_lite_mode(args):