Add L1 to L2 message mock endpoint

page/docs/guide/postman.md

@@ -50,6 +50,58 @@ constructor(MockStarknetMessaging mockStarknetMessaging_) public {
 }
 ```
 
+### Postman - l1 to l2 mock endpoint
+
+Sending mock transactions from L1 to L2 without the need for running L1. Deployed L2 contract address `l2_contract_address` and `entry_point_selector` must be valid otherwise new block will not be created.
+
+Normally `nonce` is calculated by l1 StarknetContract but in this case, we need to provide it manually.
+
+```
+POST /postman/send_message_to_l2
+```
+
+Request:
+```
+{
+    "l2_contract_address":"0x00285ddb7e5c777b310d806b9b2a0f7c7ba0a41f12b420219209d97a3b7f25b2",
+    "entry_point_selector":"0xC73F681176FC7B3F9693986FD7B14581E8D540519E27400E88B8713932BE01",
+    "l1_contract_address":"0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512",
+    "payload":[
+      "0x1",
+      "0x2"
+    ],
+    "nonce":"0x0"
+}
+```
+
+Response: 
+```
+{'transaction_hash': 1283711137402474683298514877824575801113282594306182191973277342794215646143}
+```
+
+### Postman - l2 to l1 mock endpoint
+
+Sending mock transactions from L2 to L1.
+Deployed L2 contract address `l2_contract_address` and `l1_contract_address` must be valid.
+
+```
+POST /postman/consume_message_from_l2
+```
+
+Request:
+```
+{
+    "l2_contract_address": "0x00285ddb7e5c777b310d806b9b2a0f7c7ba0a41f12b420219209d97a3b7f25b2",
+    "l1_contract_address": "0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512",
+    "payload": ["0x0", "0x1", "0x3e8"],
+}
+```
+
+Response: 
+```
+{'message_hash': '0xae14f241131b524ac8d043d9cb4934253ac5c5589afef19f0d761816a9c7e26d'}
+```
+
 ## Dumping
 
 To preserve your Devnet instance for future use, there are several options:

starknet_devnet/blueprints/base.py

@@ -6,7 +6,11 @@
 
 from starknet_devnet.fee_token import FeeToken
 from starknet_devnet.state import state
-from starknet_devnet.util import StarknetDevnetException, check_valid_dump_path
+from starknet_devnet.util import (
+    StarknetDevnetException,
+    check_valid_dump_path,
+    custom_int,
+)
 
 base = Blueprint("base", __name__)
 
@@ -44,20 +48,20 @@ def extract_positive(request_json, prop_name: str):
     return value
 
 
-def extract_hex_string(request_json, prop_name: str) -> int:
-    """Parse value from hex string to int"""
+def hex_converter(request_json, prop_name: str, convert=custom_int) -> int:
+    """Parse value from hex string to int, or values from hex strings to ints"""
     value = request_json.get(prop_name)
     if value is None:
         raise StarknetDevnetException(
             code=StarkErrorCode.MALFORMED_REQUEST,
             status_code=400,
-            message=f"{prop_name} value must be provided.",
+            message=f"{prop_name} value or values must be provided.",
         )
 
     try:
-        return int(value, 16)
+        return convert(value)
     except (ValueError, TypeError) as error:
-        message = f"{prop_name} value must be a hex string."
+        message = f"{prop_name} value or values must be a hex string."
         raise StarknetDevnetException(
             code=StarkErrorCode.MALFORMED_REQUEST,
             status_code=400,
@@ -172,7 +176,7 @@ async def mint():
     """Mint token and transfer to the provided address"""
     request_json = request.json or {}
 
-    address = extract_hex_string(request_json, "address")
+    address = hex_converter(request_json, "address")
     amount = extract_positive(request_json, "amount")
     is_lite = request_json.get("lite", False)
 

starknet_devnet/blueprints/postman.py

@@ -5,10 +5,12 @@
 import json
 
 from flask import Blueprint, jsonify, request
+from starkware.starknet.business_logic.transaction.objects import InternalL1Handler
 from starkware.starkware_utils.error_handling import StarkErrorCode
 
+from starknet_devnet.blueprints.base import hex_converter
 from starknet_devnet.state import state
-from starknet_devnet.util import StarknetDevnetException
+from starknet_devnet.util import StarknetDevnetException, to_int_array
 
 postman = Blueprint("postman", __name__, url_prefix="/postman")
 
@@ -55,3 +57,47 @@ async def flush():
 
     result_dict = await state.starknet_wrapper.postman_flush()
     return jsonify(result_dict)
+
+
+@postman.route("/send_message_to_l2", methods=["POST"])
+async def send_message_to_l2():
+    """L1 to L2 message mock endpoint"""
+    request_json = request.json or {}
+
+    # Generate transactions
+    transaction = InternalL1Handler.create(
+        contract_address=hex_converter(request_json, "l2_contract_address"),
+        entry_point_selector=hex_converter(request_json, "entry_point_selector"),
+        calldata=[
+            hex_converter(request_json, "l1_contract_address"),
+            *hex_converter(request_json, "payload", to_int_array),
+        ],
+        nonce=hex_converter(request_json, "nonce"),
+        chain_id=state.starknet_wrapper.get_state().general_config.chain_id.value,
+    )
+
+    result = await state.starknet_wrapper.mock_message_to_l2(transaction)
+    return jsonify({"transaction_hash": result})
+
+
+@postman.route("/consume_message_from_l2", methods=["POST"])
+async def consume_message_from_l2():
+    """L2 to L1 message mock endpoint"""
+    request_json = request.json or {}
+
+    from_address = hex_converter(request_json, "l2_contract_address")
+    to_address = hex_converter(request_json, "l1_contract_address")
+    payload = hex_converter(request_json, "payload", to_int_array)
+    result = ""
+
+    try:
+        result = await state.starknet_wrapper.consume_message_from_l2(
+            from_address, to_address, payload
+        )
+        return jsonify({"message_hash": result})
+    except AssertionError as err:
+        raise StarknetDevnetException(
+            code=StarkErrorCode.MALFORMED_REQUEST,
+            message=f"Message of hash {result} is fully consumed or does not exist.",
+            status_code=500,
+        ) from err

starknet_devnet/starknet_wrapper.py

@@ -45,6 +45,7 @@
     DeployAccount,
     InvokeFunction,
 )
+from starkware.starknet.services.api.messages import StarknetMessageToL1
 from starkware.starknet.testing.objects import FunctionInvocation
 from starkware.starknet.testing.starknet import Starknet
 from starkware.starknet.third_party.open_zeppelin.starknet_contracts import (
@@ -547,6 +548,38 @@ async def load_messaging_contract_in_l1(
             self.starknet, network_url, contract_address, network_id
         )
 
+    async def consume_message_from_l2(
+        self, from_address: int, to_address: int, payload: List[int]
+    ) -> str:
+        """
+        Mocks the L1 contract function consumeMessageFromL2.
+        """
+        state = self.get_state()
+
+        starknet_message = StarknetMessageToL1(
+            from_address=from_address,
+            to_address=to_address,
+            payload=payload,
+        )
+        message_hash = starknet_message.get_hash()
+        state.consume_message_hash(message_hash=message_hash)
+        return message_hash
+
+    async def mock_message_to_l2(self, transaction: InternalL1Handler) -> dict:
+        """Handles L1 to L2 message mock endpoint"""
+
+        state = self.get_state()
+
+        # Execute transactions inside StarknetWrapper
+        async with self.__get_transaction_handler() as tx_handler:
+            tx_handler.internal_tx = transaction
+            tx_handler.execution_info = await state.execute_tx(tx_handler.internal_tx)
+            tx_handler.internal_calls = (
+                tx_handler.execution_info.call_info.internal_calls
+            )
+
+        return transaction.hash_value
+
     async def postman_flush(self) -> dict:
         """Handles all pending L1 <> L2 messages and sends them to the other layer."""
 

starknet_devnet/util.py

@@ -34,6 +34,11 @@ def fixed_length_hex(arg: int) -> str:
     return f"0x{arg:064x}"
 
 
+def to_int_array(values: List[str]) -> List[int]:
+    """Convert to List of ints"""
+    return [int(numeric, 16) for numeric in values]
+
+
 @dataclass
 class Uint256:
     """Abstraction of Uint256 type"""

test/test_fee_token.py

@@ -99,15 +99,15 @@ def test_wrong_mint_address_format():
     resp = mint_client({"amount": 10, "address": "invalid_address"})
 
     assert resp.status_code == 400
-    assert resp.json["message"] == "address value must be a hex string."
+    assert resp.json["message"] == "address value or values must be a hex string."
 
 
 def test_missing_mint_address():
     """Assert failure if mint address missing"""
     resp = mint_client({"amount": 10})
 
     assert resp.status_code == 400
-    assert resp.json["message"] == "address value must be provided."
+    assert resp.json["message"] == "address value or values must be provided."
 
 
 @pytest.mark.fee_token