Fix compilation issue with solidity versions >= 0.8.12 (safe-global#772)

Fixes: safe-global#735 and safe-global#773

### Changes in PR
- Add a hook function `_onAfterExecTransactionFromModule` that gets
called after execution from module.
- SafeL2 overrides this function to emit event `SafeModuleTransaction`.
- Add test that checks if `execTransactionFromModuleReturnData` in
SafeL2 emits `SafeModuleTransaction` event.

#### Codesize increase by `33` bytes with compiler version 0.7.6 

#### This PR:

```
Safe 21814 bytes (limit is 24576)
SafeL2 22632 bytes (limit is 24576)
```

#### Main branch
```
Safe 21781 bytes (limit is 24576)
SafeL2 22623 bytes (limit is 24576)
```


### Impact on gas usage with `Safe` contract

Changes in this PR add additional overhead of `49` gas

####  This PR:

```
·------------------------------------------------------------|----------------------------|-------------|------------------------------·
|                    Solc version: 0.7.6                     ·  Optimizer enabled: false  ·  Runs: 200  ·  Block limit: 100000000 gas  │
·····························································|····························|·············|·······························
|  Methods                                                                                                                             │
·····················|·······································|·············|··············|·············|···············|···············
|  Contract          ·  Method                               ·  Min        ·  Max         ·  Avg        ·  # calls      ·  usd (avg)   │
·····················|·······································|·············|··············|·············|···············|···············
|  Safe              ·  execTransactionFromModule            ·      51630  ·      184223  ·     127865  ·           11  ·           -  │
·····················|·······································|·············|··············|·············|···············|···············
|  Safe              ·  execTransactionFromModuleReturnData  ·      52273  ·      183979  ·     107919  ·            5  ·           -  │
```

#### Main branch

```
·------------------------------------------------------------|----------------------------|-------------|------------------------------·
|                    Solc version: 0.7.6                     ·  Optimizer enabled: false  ·  Runs: 200  ·  Block limit: 100000000 gas  │
·····························································|····························|·············|·······························
|  Methods                                                                                                                             │
·····················|·······································|·············|··············|·············|···············|···············
|  Safe              ·  execTransactionFromModule            ·      51581  ·      184186  ·     127818  ·           11  ·           -  │
·····················|·······································|·············|··············|·············|···············|···············
|  Safe              ·  execTransactionFromModuleReturnData  ·      52224  ·      183930  ·     107870  ·            5  ·           -  │
```

Why this approach?
- Clean code
- Introduces a hook that allows contracts inheriting Safe to do
additional post processing.


**Alternatives considered**
A.
- Move the function `execTransactionFromModule(...)` from
`ModuleManager` to `Safe` contract.
safe-global@3521a4b
- But this is not an ideal approach as `ModuleManager` does not
implement `execTransactionFromModule`.
- Pro: Minimal code changes, no impact on codesize

B.
- Create `_onExecTransactionFromModule` method that gets called by
`execTransactionFromModule`
- ~~Con: This approach still has repeating code~~
- Approach is similar to `A` with new function. Here,
`_onExecTransactionFromModule` still calls its parent.
- Pro: Increase in codesize by only `24` bytes

Side note:

Why event `SafeModuleTransaction` is not emitted by
`execTransactionFromModuleReturnData` in `SafeL2`? Why `SafeL2` does not
override `execTransactionFromModuleReturnData`.
-> `execTransactionFromModuleReturnData` in `SafeL2` should also emit
event. Might have been missed in the past. ~~Would be covered in a
separate PR.~~. This PR fixes the issue.

---------

Co-authored-by: Nicholas Rodrigues Lordello <[email protected]>

Author: akshay-ap

contracts/SafeL2.sol

@@ -6,7 +6,9 @@ import {Safe, Enum} from "./Safe.sol";
 // Imports are required for NatSpec validation of the compiler, and falsely detected as unused by
 // the linter, so disable the `no-unused-imports` rule for the next line.
 // solhint-disable-next-line no-unused-import
-import {ISafe, IModuleManager} from "./interfaces/ISafe.sol";
+import {ISafe} from "./interfaces/ISafe.sol";
+// solhint-disable-next-line no-unused-import
+import {ModuleManager} from "./base/ModuleManager.sol";
 
 /**
  * @title SafeL2 - An implementation of the Safe contract that emits additional events on transaction executions.
@@ -69,15 +71,15 @@ contract SafeL2 is Safe {
     }
 
     /**
-     * @inheritdoc IModuleManager
+     * @inheritdoc ModuleManager
      */
-    function execTransactionFromModule(
+    function onAfterExecTransactionFromModule(
         address to,
         uint256 value,
         bytes memory data,
-        Enum.Operation operation
-    ) public override returns (bool success) {
+        Enum.Operation operation,
+        bool /*success*/
+    ) internal override {
         emit SafeModuleTransaction(msg.sender, to, value, data, operation);
-        success = super.execTransactionFromModule(to, value, data, operation);
     }
 }

contracts/base/ModuleManager.sol

@@ -152,11 +152,11 @@ abstract contract ModuleManager is SelfAuthorized, Executor, IModuleManager {
         uint256 value,
         bytes memory data,
         Enum.Operation operation
-    ) public virtual override returns (bool success) {
+    ) public override returns (bool success) {
         (address guard, bytes32 guardHash) = preModuleExecution(to, value, data, operation);
-
         success = execute(to, value, data, operation, type(uint256).max);
         postModuleExecution(guard, guardHash, success);
+        onAfterExecTransactionFromModule(to, value, data, operation, success);
     }
 
     /**
@@ -185,6 +185,7 @@ abstract contract ModuleManager is SelfAuthorized, Executor, IModuleManager {
         }
         /* solhint-enable no-inline-assembly */
         postModuleExecution(guard, guardHash, success);
+        onAfterExecTransactionFromModule(to, value, data, operation, success);
     }
 
     /**
@@ -275,4 +276,20 @@ abstract contract ModuleManager is SelfAuthorized, Executor, IModuleManager {
             moduleGuard := sload(slot)
         }
     }
+
+    /**
+     * @notice A hook that gets called after execution of {execTransactionFromModule*} methods.
+     * @param to Destination address of module transaction.
+     * @param value Ether value of module transaction.
+     * @param data Data payload of module transaction.
+     * @param operation Operation type of module transaction.
+     * @param success Boolean flag indicating if the call succeeded.
+     */
+    function onAfterExecTransactionFromModule(
+        address to,
+        uint256 value,
+        bytes memory data,
+        Enum.Operation operation,
+        bool success
+    ) internal virtual {}
 }

test/l2/Safe.Execution.spec.ts

@@ -89,5 +89,22 @@ describe("SafeL2", () => {
                 .to.emit(safe, "ExecutionFromModuleSuccess")
                 .withArgs(user2.address);
         });
+
+        it("should emit SafeModuleTransaction event in execTransactionFromModuleReturnData", async () => {
+            const {
+                safe,
+                mock,
+                signers: [user1, user2],
+            } = await setupTests();
+            const mockAddress = await mock.getAddress();
+            const user2Safe = safe.connect(user2);
+            await executeContractCallWithSigners(safe, safe, "enableModule", [user2.address], [user1]);
+
+            await expect(user2Safe.execTransactionFromModuleReturnData(mockAddress, 0, "0xbaddad", 0))
+                .to.emit(safe, "SafeModuleTransaction")
+                .withArgs(user2.address, mockAddress, 0, "0xbaddad", 0)
+                .to.emit(safe, "ExecutionFromModuleSuccess")
+                .withArgs(user2.address);
+        });
     });
 });