feat(forge): cheatcodes to crosschain sign and attach delegation (#10518)

* feat(forge): cheatcodes to crosschain sign and attach delegation

* Update crates/cheatcodes/spec/src/vm.rs

Co-authored-by: zerosnacks <[email protected]>

* Update crates/cheatcodes/spec/src/vm.rs

Co-authored-by: zerosnacks <[email protected]>

* Update crates/cheatcodes/spec/src/vm.rs

Co-authored-by: zerosnacks <[email protected]>

* Nits

---------

Co-authored-by: zerosnacks <[email protected]>

Author: grandizzy

crates/cheatcodes/assets/cheatcodes.json

@@ -2229,10 +2229,18 @@ interface Vm {
     #[cheatcode(group = Scripting)]
     function signDelegation(address implementation, uint256 privateKey, uint64 nonce) external returns (SignedDelegation memory signedDelegation);
 
+    /// Sign an EIP-7702 authorization for delegation, with optional cross-chain validity.
+    #[cheatcode(group = Scripting)]
+    function signDelegation(address implementation, uint256 privateKey, bool crossChain) external returns (SignedDelegation memory signedDelegation);
+
     /// Designate the next call as an EIP-7702 transaction
     #[cheatcode(group = Scripting)]
     function attachDelegation(SignedDelegation calldata signedDelegation) external;
 
+    /// Designate the next call as an EIP-7702 transaction, with optional cross-chain validity.
+    #[cheatcode(group = Scripting)]
+    function attachDelegation(SignedDelegation calldata signedDelegation, bool crossChain) external;
+
     /// Sign an EIP-7702 authorization and designate the next call as an EIP-7702 transaction
     #[cheatcode(group = Scripting)]
     function signAndAttachDelegation(address implementation, uint256 privateKey) external returns (SignedDelegation memory signedDelegation);
@@ -2241,6 +2249,10 @@ interface Vm {
     #[cheatcode(group = Scripting)]
     function signAndAttachDelegation(address implementation, uint256 privateKey, uint64 nonce) external returns (SignedDelegation memory signedDelegation);
 
+    /// Sign an EIP-7702 authorization and designate the next call as an EIP-7702 transaction, with optional cross-chain validity.
+    #[cheatcode(group = Scripting)]
+    function signAndAttachDelegation(address implementation, uint256 privateKey, bool crossChain) external returns (SignedDelegation memory signedDelegation);
+
     /// Attach an EIP-4844 blob to the next call
     #[cheatcode(group = Scripting)]
     function attachBlob(bytes calldata blob) external;

crates/cheatcodes/spec/src/vm.rs

@@ -33,63 +33,93 @@ impl Cheatcode for broadcast_2Call {
     }
 }
 
-impl Cheatcode for attachDelegationCall {
+impl Cheatcode for attachDelegation_0Call {
     fn apply_stateful(&self, ccx: &mut CheatsCtxt) -> Result {
         let Self { signedDelegation } = self;
-        let SignedDelegation { v, r, s, nonce, implementation } = signedDelegation;
+        attach_delegation(ccx, signedDelegation, false)
+    }
+}
 
-        let auth = Authorization {
-            address: *implementation,
-            nonce: *nonce,
-            chain_id: U256::from(ccx.ecx.env.cfg.chain_id),
-        };
-        let signed_auth = SignedAuthorization::new_unchecked(
-            auth,
-            *v,
-            U256::from_be_bytes(r.0),
-            U256::from_be_bytes(s.0),
-        );
-        write_delegation(ccx, signed_auth.clone())?;
-        ccx.state.active_delegation = Some(signed_auth);
-        Ok(Default::default())
+impl Cheatcode for attachDelegation_1Call {
+    fn apply_stateful(&self, ccx: &mut CheatsCtxt) -> Result {
+        let Self { signedDelegation, crossChain } = self;
+        attach_delegation(ccx, signedDelegation, *crossChain)
     }
 }
 
 impl Cheatcode for signDelegation_0Call {
     fn apply_stateful(&self, ccx: &mut CheatsCtxt) -> Result {
         let Self { implementation, privateKey } = *self;
-        sign_delegation(ccx, privateKey, implementation, None, false)
+        sign_delegation(ccx, privateKey, implementation, None, false, false)
     }
 }
 
 impl Cheatcode for signDelegation_1Call {
     fn apply_stateful(&self, ccx: &mut CheatsCtxt) -> Result {
         let Self { implementation, privateKey, nonce } = *self;
-        sign_delegation(ccx, privateKey, implementation, Some(nonce), false)
+        sign_delegation(ccx, privateKey, implementation, Some(nonce), false, false)
+    }
+}
+
+impl Cheatcode for signDelegation_2Call {
+    fn apply_stateful(&self, ccx: &mut CheatsCtxt) -> Result {
+        let Self { implementation, privateKey, crossChain } = *self;
+        sign_delegation(ccx, privateKey, implementation, None, crossChain, false)
     }
 }
 
 impl Cheatcode for signAndAttachDelegation_0Call {
     fn apply_stateful(&self, ccx: &mut CheatsCtxt) -> Result {
         let Self { implementation, privateKey } = *self;
-        sign_delegation(ccx, privateKey, implementation, None, true)
+        sign_delegation(ccx, privateKey, implementation, None, false, true)
     }
 }
 
 impl Cheatcode for signAndAttachDelegation_1Call {
     fn apply_stateful(&self, ccx: &mut CheatsCtxt) -> Result {
         let Self { implementation, privateKey, nonce } = *self;
-        sign_delegation(ccx, privateKey, implementation, Some(nonce), true)
+        sign_delegation(ccx, privateKey, implementation, Some(nonce), false, true)
     }
 }
 
+impl Cheatcode for signAndAttachDelegation_2Call {
+    fn apply_stateful(&self, ccx: &mut CheatsCtxt) -> Result {
+        let Self { implementation, privateKey, crossChain } = *self;
+        sign_delegation(ccx, privateKey, implementation, None, crossChain, true)
+    }
+}
+
+/// Helper function to attach an EIP-7702 delegation.
+fn attach_delegation(
+    ccx: &mut CheatsCtxt,
+    delegation: &SignedDelegation,
+    cross_chain: bool,
+) -> Result {
+    let SignedDelegation { v, r, s, nonce, implementation } = delegation;
+    // Set chain id to 0 if universal deployment is preferred.
+    // See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-7702.md#protection-from-malleability-cross-chain
+    let chain_id = if cross_chain { U256::from(0) } else { U256::from(ccx.ecx.env.cfg.chain_id) };
+
+    let auth = Authorization { address: *implementation, nonce: *nonce, chain_id };
+    let signed_auth = SignedAuthorization::new_unchecked(
+        auth,
+        *v,
+        U256::from_be_bytes(r.0),
+        U256::from_be_bytes(s.0),
+    );
+    write_delegation(ccx, signed_auth.clone())?;
+    ccx.state.active_delegation = Some(signed_auth);
+    Ok(Default::default())
+}
+
 /// Helper function to sign and attach (if needed) an EIP-7702 delegation.
 /// Uses the provided nonce, otherwise retrieves and increments the nonce of the EOA.
 fn sign_delegation(
     ccx: &mut CheatsCtxt,
     private_key: Uint<256, 4>,
     implementation: Address,
     nonce: Option<u64>,
+    cross_chain: bool,
     attach: bool,
 ) -> Result<Vec<u8>> {
     let signer = PrivateKeySigner::from_bytes(&B256::from(private_key))?;
@@ -101,11 +131,9 @@ fn sign_delegation(
         // If we don't have a nonce then use next auth account nonce.
         authority_acc.data.info.nonce + 1
     };
-    let auth = Authorization {
-        address: implementation,
-        nonce,
-        chain_id: U256::from(ccx.ecx.env.cfg.chain_id),
-    };
+    let chain_id = if cross_chain { U256::from(0) } else { U256::from(ccx.ecx.env.cfg.chain_id) };
+
+    let auth = Authorization { address: implementation, nonce, chain_id };
     let sig = signer.sign_hash_sync(&auth.signature_hash())?;
     // Attach delegation.
     if attach {
@@ -133,6 +161,7 @@ fn write_delegation(ccx: &mut CheatsCtxt, auth: SignedAuthorization) -> Result<(
 
     if auth.address.is_zero() {
         // Set empty code if the delegation address of authority is 0x.
+        // See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-7702.md#behavior.
         ccx.ecx.journaled_state.set_code_with_hash(authority, Bytecode::default(), KECCAK_EMPTY);
     } else {
         let bytecode = Bytecode::new_eip7702(*auth.address());

crates/cheatcodes/src/script.rs

@@ -39,6 +39,22 @@ contract AttachDelegationTest is DSTest {
         assertEq(token.balanceOf(bob), 100);
     }
 
+    function testCallSingleAttachCrossChainDelegation() public {
+        Vm.SignedDelegation memory signedDelegation = vm.signDelegation(address(implementation), alice_pk, true);
+        SimpleDelegateContract.Call[] memory calls = new SimpleDelegateContract.Call[](1);
+        bytes memory data = abi.encodeCall(ERC20.mint, (100, bob));
+        calls[0] = SimpleDelegateContract.Call({to: address(token), data: data, value: 0});
+        // executing as bob to make clear that we don't need to execute the tx as alice
+        vm.broadcast(bob_pk);
+        vm.attachDelegation(signedDelegation, true);
+
+        bytes memory code = address(alice).code;
+        require(code.length > 0, "no code written to alice");
+        SimpleDelegateContract(alice).execute(calls);
+
+        assertEq(token.balanceOf(bob), 100);
+    }
+
     /// forge-config: default.allow_internal_expect_revert = true
     function testCallSingleAttachDelegationWithNonce() public {
         Vm.SignedDelegation memory signedDelegation = vm.signDelegation(address(implementation), alice_pk, 11);
@@ -70,6 +86,26 @@ contract AttachDelegationTest is DSTest {
         assertEq(token.balanceOf(address(this)), 50);
     }
 
+    function testMultiCallAttachCrossChainDelegation() public {
+        Vm.SignedDelegation memory signedDelegation = vm.signDelegation(address(implementation), alice_pk, true);
+        vm.broadcast(bob_pk);
+        vm.attachDelegation(signedDelegation, true);
+
+        SimpleDelegateContract.Call[] memory calls = new SimpleDelegateContract.Call[](2);
+        calls[0] =
+            SimpleDelegateContract.Call({to: address(token), data: abi.encodeCall(ERC20.mint, (50, bob)), value: 0});
+        calls[1] = SimpleDelegateContract.Call({
+            to: address(token),
+            data: abi.encodeCall(ERC20.mint, (50, address(this))),
+            value: 0
+        });
+
+        SimpleDelegateContract(alice).execute(calls);
+
+        assertEq(token.balanceOf(bob), 50);
+        assertEq(token.balanceOf(address(this)), 50);
+    }
+
     function testSwitchAttachDelegation() public {
         Vm.SignedDelegation memory signedDelegation = vm.signDelegation(address(implementation), alice_pk);
 
@@ -138,6 +174,19 @@ contract AttachDelegationTest is DSTest {
         assertEq(token.balanceOf(bob), 100);
     }
 
+    function testCallSingleSignAndAttachCrossChainDelegation() public {
+        SimpleDelegateContract.Call[] memory calls = new SimpleDelegateContract.Call[](1);
+        bytes memory data = abi.encodeCall(ERC20.mint, (100, bob));
+        calls[0] = SimpleDelegateContract.Call({to: address(token), data: data, value: 0});
+        vm.signAndAttachDelegation(address(implementation), alice_pk, true);
+        bytes memory code = address(alice).code;
+        require(code.length > 0, "no code written to alice");
+        vm.broadcast(bob_pk);
+        SimpleDelegateContract(alice).execute(calls);
+
+        assertEq(token.balanceOf(bob), 100);
+    }
+
     /// forge-config: default.allow_internal_expect_revert = true
     function testCallSingleSignAndAttachDelegationWithNonce() public {
         vm._expectCheatcodeRevert("vm.signAndAttachDelegation: invalid nonce");