Messaging with Sepolia (#1493)

- **Move messaging deployment to the main deploy script**
- **Use real values for l1 helpers tools**
- **Update deployments and messaging**

<!-- Reviewable:start -->
- - -
This change is [<img src="https://reviewable.io/review_button.svg"
height="34" align="absmiddle"
alt="Reviewable"/>](https://reviewable.io/reviews/kkrt-labs/kakarot/1493)
<!-- Reviewable:end -->

.env.example

@@ -43,8 +43,9 @@ ACCOUNT_ADDRESS=
 PRIVATE_KEY=
 
 # An EVM private to define a default EOA for EVM related kakarot_scripts
+STARKNET_SEPOLIA_EVM_PRIVATE_KEY=
 # This default value is Anvil first account private key
-EVM_PRIVATE_KEY=0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80
+KATANA_EVM_PRIVATE_KEY=0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80
 
 # Because cairo-land generated files used protobuf<=3.20 and web3.py uses protobuf ~4
 PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION=python

deployments/starknet-mainnet/l1_addresses.json

@@ -0,0 +1,4 @@
+{
+  "StarknetCore": "0xc662c410C0ECf747543f5bA90660f6ABeBD9C8c4",
+  "StarknetVerifier": "0x47312450B3Ac8b5b8e247a6bB6d523e7605bDb60"
+}

deployments/starknet-sepolia/kakarot_deployments.json

@@ -1,10 +1,22 @@
 {
-  "Bridge": {
-    "address": "0x5fbdb2315678afecb367f032d93f642f64180aa3",
-    "starknet_address": "0x31af0ca9f2991fc54f20c54c66d87dd8492066a0a38ab50faa1f4df144f36d9"
+  "WETH9": {
+    "address": "0x37f78d636aab48c5cffc9909390cf62318b8abbf",
+    "starknet_address": "0x19a5d6a1d55619a79fdaa98a696c2b2e379e1b5a402c9bf78ad18833c189c70"
   },
-  "WETH": {
-    "address": "0xe7f1725e7734ce288f8367e1bb143e90bb3f0512",
-    "starknet_address": "0x50ebf948c87f34b5b491ca0f07c9a0a912fe3a11e1f0a73eff9aa5bea86304a"
+  "KakarotETH": {
+    "address": "0x5e950f65e70a06efae17cd3f6d8e4fc6474b5b8d",
+    "starknet_address": "0x734abad1f311ff96517f55d2ae31fa178235c99d51dc97a03f126b719775c62"
+  },
+  "KakarotSTRK": {
+    "address": "0x68b7dbbd2ef15e9e6716d58ea844ee72976b131f",
+    "starknet_address": "0x1dd4844458b812a6a865b6537c03327e58025a1b6b7bd1c2bfb2a7d92234dac"
+  },
+  "L2KakarotMessaging": {
+    "address": "0x3653ff9df27df8bca306fb628e70f1c90fcde27f",
+    "starknet_address": "0x4227ee2b1b5611dbbe1f54410e244f90581ddc8f66caebf9d4e1c9aa8dc8da0"
+  },
+  "Coinbase": {
+    "address": "0xccaa1b04b831ea3e547d4fe4359e0c2f5b34b749",
+    "starknet_address": "0x152c78b2d1229464d461bc323801739bf7a439d049685f59c506b356d0da1bb"
   }
-}
+}

deployments/starknet-sepolia/l1_addresses.json

@@ -0,0 +1,5 @@
+{
+  "StarknetCore": "0xE2Bb56ee936fd6433DC0F6e7e3b8365C906AA057",
+  "StarknetVerifier": "0x07ec0D28e50322Eb0C159B9090ecF3aeA8346DFe",
+  "L1KakarotMessaging": "0xc9c677a629AAe7A149f5F0E7546394f2630e8E9e"
+}

kakarot_scripts/constants.py

@@ -77,10 +77,6 @@ class NetworkType(Enum):
         "check_interval": 0.01,
         "max_wait": 3,
         "relayers": [
-            {
-                "address": 0xB3FF441A68610B30FD5E2ABBF3A1548EB6BA6F3559F2862BF2DC757E5828CA,
-                "private_key": 0x2BBF4F9FD0BBB2E60B0316C1FE0B76CF7A4D0198BD493CED9B8DF2A3A24D68A,
-            },
             {
                 "address": 0xE29882A1FCBA1E7E10CAD46212257FEA5C752A4F9B1B1EC683C503A2CF5C8A,
                 "private_key": 0x14D6672DCB4B77CA36A887E9A11CD9D637D5012468175829E9C6E770C61642,
@@ -298,15 +294,20 @@ class ChainId(IntEnum):
     json.loads((DATA_DIR / "signed_txs.json").read_text())["createx"]
 )
 
-EVM_PRIVATE_KEY = os.getenv("EVM_PRIVATE_KEY")
+prefix = NETWORK["name"].upper().replace("-", "_")
+EVM_PRIVATE_KEY = os.getenv(f"{prefix}_EVM_PRIVATE_KEY")
+if EVM_PRIVATE_KEY is None:
+    logger.warning(
+        f"⚠️  {prefix}_EVM_PRIVATE_KEY not set, defaulting to EVM_PRIVATE_KEY"
+    )
+    EVM_PRIVATE_KEY = os.getenv("EVM_PRIVATE_KEY")
 EVM_ADDRESS = (
     EVM_PRIVATE_KEY
     and keys.PrivateKey(
         bytes.fromhex(EVM_PRIVATE_KEY[2:])
     ).public_key.to_checksum_address()
 )
 
-prefix = NETWORK["name"].upper().replace("-", "_")
 NETWORK["account_address"] = os.environ.get(f"{prefix}_ACCOUNT_ADDRESS")
 if NETWORK["account_address"] is None:
     logger.warning(

kakarot_scripts/deploy_kakarot.py

@@ -1,8 +1,10 @@
 # %% Imports
 import logging
 
+from eth_abi.exceptions import InsufficientDataBytes
 from eth_utils.address import to_checksum_address
 from uvloop import run
+from web3.exceptions import ContractLogicError
 
 from kakarot_scripts.constants import (
     ARACHNID_PROXY_DEPLOYER,
@@ -29,6 +31,12 @@
 )
 from kakarot_scripts.utils.kakarot import dump_deployments as dump_evm_deployments
 from kakarot_scripts.utils.kakarot import get_deployments as get_evm_deployments
+from kakarot_scripts.utils.l1 import (
+    deploy_on_l1,
+    dump_l1_addresses,
+    get_l1_addresses,
+    get_l1_contract,
+)
 from kakarot_scripts.utils.starknet import call, declare
 from kakarot_scripts.utils.starknet import deploy as deploy_starknet
 from kakarot_scripts.utils.starknet import (
@@ -132,16 +140,43 @@ async def main():
 
     dump_deployments(starknet_deployments)
 
-    # Execute calls in lazy mode
-    # After this point, Kakarot needs to be deployed for the remaining calls to be executed
-    await execute_calls()
-    remove_lazy_account(account.address)
-
-    # %% EVM Deployments
+    # %% L1
     starknet_deployments = get_starknet_deployments()
-    evm_deployments = get_evm_deployments()
+    l1_addresses = get_l1_addresses()
+
+    l1_kakarot_messaging = get_l1_contract(
+        "L1L2Messaging",
+        "L1KakarotMessaging",
+        address=l1_addresses.get("L1KakarotMessaging"),
+    )
+    l1_kakarot_messaging_registered_address = None
+    try:
+        l1_kakarot_messaging_registered_address = l1_kakarot_messaging.kakarotAddress()
+    except (ContractLogicError, InsufficientDataBytes):
+        pass
+
+    if l1_kakarot_messaging_registered_address != starknet_deployments["kakarot"]:
+        if NETWORK["type"] == NetworkType.DEV:
+            starknet_core = deploy_on_l1("Starknet", "StarknetMessagingLocal")
+            l1_addresses.update({"StarknetCore": starknet_core.address})
+        else:
+            if "StarknetCore" not in l1_addresses:
+                raise ValueError("StarknetCore missing in L1 addresses")
+
+        l1_kakarot_messaging = deploy_on_l1(
+            "L1L2Messaging",
+            "L1KakarotMessaging",
+            l1_addresses["StarknetCore"],
+            starknet_deployments["kakarot"],
+        )
+        l1_addresses.update({"L1KakarotMessaging": l1_kakarot_messaging.address})
+
+    dump_l1_addresses(l1_addresses)
 
-    # %% Pre-EIP155 deployments, done only once
+    # %% Pre-EIP155 deployments, done only once and don't need an account
+    # Kakarot needs to be deployed for the remaining calls to be executed
+    await execute_calls()
+    remove_lazy_account(account.address)
     await deploy_with_presigned_tx(
         MULTICALL3_DEPLOYER,
         MULTICALL3_SIGNED_TX,
@@ -161,8 +196,9 @@ async def main():
         name="CreateX",
         max_fee=int(0.2e18),
     )
+    register_lazy_account(account.address)
 
-    # %% Tokens deployments
+    # %% EVM Deployments
     if not EVM_ADDRESS:
         logger.info("ℹ️  No EVM address provided, skipping EVM deployments")
         return
@@ -173,19 +209,31 @@ async def main():
         EVM_ADDRESS, amount=100 if NETWORK["type"] is NetworkType.DEV else 0.01
     )
 
-    for contract_app, contract_name, deployed_name, *deployment_args in [
-        ("WETH", "WETH9", "WETH9"),
+    starknet_deployments = get_starknet_deployments()
+    evm_deployments = get_evm_deployments()
+
+    # %% Tokens deployments
+    for (
+        contract_app,
+        contract_name,
+        deployed_name,
+        cairo_precompile,
+        *deployment_args,
+    ) in [
+        ("WETH", "WETH9", "WETH9", False),
         (
             "CairoPrecompiles",
             "DualVmToken",
             "KakarotETH",
+            True,
             starknet_deployments["kakarot"],
             ETH_TOKEN_ADDRESS,
         ),
         (
             "CairoPrecompiles",
             "DualVmToken",
             "KakarotSTRK",
+            True,
             starknet_deployments["kakarot"],
             STRK_TOKEN_ADDRESS,
         ),
@@ -204,13 +252,46 @@ async def main():
             "address": int(token.address, 16),
             "starknet_address": token.starknet_address,
         }
+        if cairo_precompile:
+            await invoke(
+                "kakarot",
+                "set_authorized_cairo_precompile_caller",
+                int(token.address, 16),
+                1,
+            )
+
+    # %% Messaging
+    deployment = evm_deployments.get("L2KakarotMessaging")
+    starknet_address = None
+    if deployment is not None:
+        starknet_address = (
+            await call("kakarot", "get_starknet_address", deployment["address"])
+        ).starknet_address
+
+    if deployment is None or deployment["starknet_address"] != starknet_address:
+        l2_kakarot_messaging = await deploy_evm("L1L2Messaging", "L2KakarotMessaging")
         await invoke(
             "kakarot",
             "set_authorized_cairo_precompile_caller",
-            int(token.address, 16),
+            int(l2_kakarot_messaging.address, 16),
             1,
         )
+        evm_deployments["L2KakarotMessaging"] = {
+            "address": int(l2_kakarot_messaging.address, 16),
+            "starknet_address": l2_kakarot_messaging.starknet_address,
+        }
+
+    l1_messaging_contract_address = (
+        await call("kakarot", "get_l1_messaging_contract_address")
+    ).l1_messaging_contract_address
+    if l1_messaging_contract_address != int(l1_kakarot_messaging.address, 16):
+        await invoke(
+            "kakarot",
+            "set_l1_messaging_contract_address",
+            int(l1_kakarot_messaging.address, 16),
+        )
 
+    # %% Coinbase
     coinbase = (await call("kakarot", "get_coinbase")).coinbase
     if evm_deployments.get("Coinbase", {}).get("address") != coinbase:
         contract = await deploy_evm(
@@ -224,18 +305,20 @@ async def main():
         }
         await invoke("kakarot", "set_coinbase", int(contract.address, 16))
 
+    # %% Tear down
+    await execute_calls()
+    dump_evm_deployments(evm_deployments)
+    balance_after = await get_balance(account.address)
+    logger.info(
+        f"ℹ💰  Deployer balance changed from {balance_pref / 1e18} to {balance_after / 1e18} ETH"
+    )
+
     coinbase = (await call("kakarot", "get_coinbase")).coinbase
     if coinbase == 0:
         logger.error("❌ Coinbase is set to 0, all transaction fees will be lost")
     else:
         logger.info(f"✅ Coinbase set to: 0x{coinbase:040x}")
 
-    dump_evm_deployments(evm_deployments)
-    balance_after = await get_balance(account.address)
-    logger.info(
-        f"ℹ️  Deployer balance changed from {balance_pref / 1e18} to {balance_after / 1e18} ETH"
-    )
-
 
 # %% Run
 def main_sync():

kakarot_scripts/utils/kakarot.py

@@ -1,6 +1,7 @@
 import functools
 import json
 import logging
+import time
 from collections import defaultdict
 from pathlib import Path
 from types import MethodType
@@ -47,7 +48,6 @@
 from kakarot_scripts.utils.starknet import get_contract as _get_starknet_contract
 from kakarot_scripts.utils.starknet import get_deployments as _get_starknet_deployments
 from kakarot_scripts.utils.starknet import invoke as _invoke_starknet
-from kakarot_scripts.utils.starknet import wait_for_transaction
 from kakarot_scripts.utils.uint256 import int_to_uint256
 from tests.utils.constants import TRANSACTION_GAS_LIMIT
 from tests.utils.helpers import pack_calldata, rlp_encode_signed_data
@@ -629,8 +629,13 @@ async def send_starknet_transaction(
         account=relayer,
     )
 
-    await wait_for_transaction(tx_hash=tx_hash)
-    receipt = await RPC_CLIENT.get_transaction_receipt(tx_hash)
+    try:
+        receipt = await RPC_CLIENT.get_transaction_receipt(tx_hash)
+    except Exception:
+        # Sometime the RPC_CLIENT is too fast and the first pool raises with
+        # starknet_py.net.client_errors.ClientError: Client failed with code 29. Message: Transaction hash not found
+        time.sleep(2)
+        receipt = await RPC_CLIENT.get_transaction_receipt(tx_hash)
     transaction_events = [
         event
         for event in receipt.events