contracts: tests: update tests to handle restricted calls

contracts/tests/conftest.py

@@ -1,6 +1,27 @@
+from dataclasses import dataclass
+
+import brownie
 import pytest
+from brownie import (
+    FillManager,
+    OptimismProofSubmitter,
+    RequestManager,
+    ResolutionRegistry,
+    Resolver,
+    TestCrossDomainMessenger,
+    accounts,
+)
 
-from brownie import accounts
+
+@dataclass(frozen=True)
+class Contracts:
+    resolver: Resolver
+    fill_manager: FillManager
+    request_manager: RequestManager
+    messenger1: TestCrossDomainMessenger
+    messenger2: TestCrossDomainMessenger
+    proof_submitter: OptimismProofSubmitter
+    resolution_registry: ResolutionRegistry
 
 
 @pytest.fixture
@@ -13,24 +34,6 @@ def token(deployer, MintableToken):
     return deployer.deploy(MintableToken, int(1e18))
 
 
-@pytest.fixture
-def test_cross_domain_messenger(deployer, TestCrossDomainMessenger):
-    contract = deployer.deploy(TestCrossDomainMessenger)
-    contract.setForwardState(True)
-
-    return contract
-
-
-@pytest.fixture
-def resolver(deployer, Resolver, test_cross_domain_messenger):
-    return deployer.deploy(Resolver, test_cross_domain_messenger.address)
-
-
-@pytest.fixture
-def resolution_registry(deployer, ResolutionRegistry):
-    return deployer.deploy(ResolutionRegistry)
-
-
 @pytest.fixture
 def claim_stake():
     return 100
@@ -52,16 +55,23 @@ def challenge_period_extension():
 
 
 @pytest.fixture
-def request_manager(
-    deployer,
-    RequestManager,
-    claim_stake,
-    claim_period,
-    challenge_period,
-    challenge_period_extension,
-    resolution_registry,
-):
-    return deployer.deploy(
+def contracts(deployer, claim_stake, claim_period, challenge_period, challenge_period_extension):
+    # L2b contracts
+    messenger1 = deployer.deploy(TestCrossDomainMessenger)
+    messenger1.setForwardState(True)
+
+    # L1 contracts
+    messenger2 = deployer.deploy(TestCrossDomainMessenger)
+    messenger2.setForwardState(True)
+    resolver = deployer.deploy(Resolver, messenger2.address)
+
+    # L2b contracts, again
+    proof_submitter = deployer.deploy(OptimismProofSubmitter, messenger1.address)
+    fill_manager = deployer.deploy(FillManager, resolver, proof_submitter.address)
+
+    # L2a contracts
+    resolution_registry = deployer.deploy(ResolutionRegistry)
+    request_manager = deployer.deploy(
         RequestManager,
         claim_stake,
         claim_period,
@@ -70,12 +80,54 @@ def request_manager(
         resolution_registry.address,
     )
 
+    # Explicitly allow calls between contracts. The chain of trust:
+    #
+    # fill_manager -> proof_submitter -> messenger1 -> L1 resolver ->
+    # messenger2 -> resolution registry
+    l1_chain_id = l2_chain_id = brownie.chain.id
+
+    proof_submitter.addCaller(l2_chain_id, fill_manager.address)
+    messenger1.addCaller(l2_chain_id, proof_submitter.address)
+    resolver.addCaller(l2_chain_id, messenger1.address)
+    messenger2.addCaller(l1_chain_id, resolver.address)
+    resolution_registry.addCaller(l1_chain_id, messenger2.address)
+
+    return Contracts(
+        messenger1=messenger1,
+        messenger2=messenger2,
+        resolver=resolver,
+        proof_submitter=proof_submitter,
+        fill_manager=fill_manager,
+        request_manager=request_manager,
+        resolution_registry=resolution_registry,
+    )
+
+
+@pytest.fixture
+def request_manager(contracts):
+    return contracts.request_manager
+
+
+@pytest.fixture
+def test_cross_domain_messenger(contracts):
+    return contracts.messenger
+
+
+@pytest.fixture
+def resolver(contracts):
+    return contracts.resolver
+
+
+@pytest.fixture
+def resolution_registry(contracts):
+    return contracts.resolution_registry
+
 
 @pytest.fixture
-def optimism_proof_submitter(deployer, OptimismProofSubmitter, test_cross_domain_messenger):
-    return deployer.deploy(OptimismProofSubmitter, test_cross_domain_messenger.address)
+def optimism_proof_submitter(contracts):
+    return contracts.proof_submitter
 
 
 @pytest.fixture
-def fill_manager(deployer, FillManager, resolver, optimism_proof_submitter):
-    return deployer.deploy(FillManager, resolver, optimism_proof_submitter.address)
+def fill_manager(contracts):
+    return contracts.fill_manager

contracts/tests/test_request_manager.py

@@ -524,10 +524,10 @@ def test_second_claim_after_withdraw(request_manager, token, claim_stake, claim_
 
 
 def test_withdraw_without_challenge_with_resolution(
-    request_manager, resolution_registry, token, claim_stake
+    request_manager, resolution_registry, token, claim_stake, contracts
 ):
     """Test withdraw when a claim was not challenged, but L1 resolved"""
-    deployer, requester, claimer = accounts[:3]
+    requester, claimer = accounts[1:3]
     transfer_amount = 23
 
     claimer_eth_balance = web3.eth.get_balance(claimer.address)
@@ -546,7 +546,7 @@ def test_withdraw_without_challenge_with_resolution(
     assert web3.eth.get_balance(claimer.address) == claimer_eth_balance - claim_stake
 
     # Register a L1 resolution
-    resolution_registry.resolveRequest(request_id, claimer.address, {"from": deployer})
+    resolution_registry.resolveRequest(request_id, claimer.address, {"from": contracts.messenger2})
     # The claim pariod is not over, but the resolution must allow withdrawal now
     withdraw_tx = request_manager.withdraw(claim_id, {"from": claimer})
     assert "ClaimWithdrawn" in withdraw_tx.events