Refactor MultisigProposal and Proposal contracts for improved operation handling and code clarity

- Removed the constant MULTISIG_BYTECODE_HASH from MultisigProposal.
- Simplified the getOperations function for better readability.
- Enhanced getCalldata to ensure consistent validation of targets, values, arguments, and operations.
- Updated internal functions for clarity and conciseness, including _validateAction and _processStateChanges.
- Improved logging for proposal actions and calldata.

Author: anajuliabit

src/proposals/MultisigProposal.sol

@@ -9,10 +9,6 @@ import {Constants} from "@utils/Constants.sol";
 abstract contract MultisigProposal is Proposal {
     using Address for address;
 
-    bytes32 public constant MULTISIG_BYTECODE_HASH = bytes32(
-        0xb89c1b3bdf2cf8827818646bce9a8f6e372885f8c55e5c07acbd307cb133b000
-    );
-
     struct Call3Value {
         address target;
         bool allowFailure;
@@ -47,7 +43,8 @@ abstract contract MultisigProposal is Proposal {
 
         require(
             targets.length == values.length && values.length == arguments.length
-                && arguments.length == operations.length,
+                && arguments.length == operations.length
+                && operations.length == actions.length,
             "Array lengths mismatch"
         );
 
@@ -80,16 +77,34 @@ abstract contract MultisigProposal is Proposal {
     function _simulateActions(address multisig) internal {
         vm.startPrank(multisig);
 
-        /// this is a hack because multisig execTransaction requires owners signatures
-        /// so we cannot simulate it exactly as it will be executed on mainnet
-        vm.etch(multisig, Constants.MULTISEND_BYTECODE);
-
         bytes memory data = getCalldata();
 
-        multisig.functionCall(data);
+        // this is a hack because multisig execTransaction requires owners signatures
+        // so the SAFE_CREATION_BYTECODE override the checkNSignatures function
+        bytes memory bytecode = Constants.SAFE_CREATION_BYTECODE;
+        address addr;
+        /// @solidity memory-safe-assembly
+        assembly {
+            addr := create(0, add(bytecode, 0x20), mload(bytecode))
+        }
+
+        vm.etch(multisig, address(addr).code);
+
+        bytes memory safeCalldata = abi.encodeWithSignature(
+            "execTransaction(address,uint256,bytes,uint8,uint256,uint256,uint256,address,address,bytes)",
+            Constants.SAFE_MULTISEND_COTNRACT,
+            0,
+            data,
+            1,
+            0,
+            0,
+            0,
+            address(0),
+            address(0),
+            ""
+        );
 
-        /// revert contract code to original safe bytecode
-        vm.etch(multisig, Constants.SAFE_BYTECODE);
+        multisig.functionCall(safeCalldata);
 
         vm.stopPrank();
     }

src/proposals/Proposal.sol

@@ -4,9 +4,9 @@ import {Test} from "@forge-std/Test.sol";
 import {VmSafe} from "@forge-std/Vm.sol";
 import {console} from "@forge-std/console.sol";
 
+import {Addresses} from "@addresses/Addresses.sol";
 import {Script} from "@forge-std/Script.sol";
 import {IProposal} from "@proposals/IProposal.sol";
-import {Addresses} from "@addresses/Addresses.sol";
 
 abstract contract Proposal is Test, Script, IProposal {
     struct Action {
@@ -363,10 +363,10 @@ abstract contract Proposal is Test, Script, IProposal {
             /// static calls are ignored,
             /// calls to and from Addresses and the vm contract are ignored
             if (
+                /// ignore calls to vm in the build function
                 accountAccesses[i].account != address(addresses)
                     && accountAccesses[i].account != address(vm)
-                /// ignore calls to vm in the build function
-                && accountAccesses[i].accessor != address(addresses)
+                    && accountAccesses[i].accessor != address(addresses)
                     && accountAccesses[i].kind == VmSafe.AccountAccessKind.Call
                     && accountAccesses[i].accessor == caller
             ) {