refactor: remove OpsTimelockBuilder

src/release-template/2-multisig.s.sol

@@ -1,18 +1,47 @@
 // SPDX-License-Identifier: BUSL-1.1
 pragma solidity ^0.8.12;
 
-import {MultisigCall, MultisigCallUtils, OpsTimelockBuilder} from "../templates/OpsTimelockBuilder.sol";
+import {MultisigCall, MultisigCallUtils, MultisigBuilder} from "../templates/MultisigBuilder.sol";
+import {ITimelock} from "../interfaces/ITimelock.sol";
 
-contract Queue is OpsTimelockBuilder {
+contract Queue is MultisigBuilder {
     using MultisigCallUtils for MultisigCall[];
 
-    MultisigCall[] internal _executorCalls;
+    MultisigCall[] private _executorCalls;
+    MultisigCall[] private _opsCalls;
+
+    function _queue() internal returns (MultisigCall[] memory) {
 
-    function queue() public override returns (MultisigCall[] memory) {
         //////////////////////////
         // construct executor data here
         //////////////////////////
 
         return _executorCalls;
     }
+
+    /**
+     * @dev Can be overridden so that executing script can inherit this contract.
+     */
+    function _execute() internal virtual override returns (MultisigCall[] memory) {
+        // get the queue data
+        MultisigCall[] memory calls = _queue();
+
+        address multiSendCallOnly = zeusAddress("MultiSendCallOnly");
+        address timelock = zeusAddress("Timelock");
+
+        // encode calls for executor
+        bytes memory executorCalldata = calls.makeExecutorCalldata(multiSendCallOnly, timelock);
+
+        address executorMultisig = zeusAddress("ExecutorMultisig");
+
+        // encode executor data for timelock
+        bytes memory timelockCalldata = abi.encodeWithSelector(
+            ITimelock.queueTransaction.selector, executorMultisig, 0, "", executorCalldata, type(uint256).max
+        );
+
+        _opsCalls.append(timelock, timelockCalldata);
+
+        // encode timelock data for ops multisig
+        return _opsCalls;
+    }
 }

src/release-template/3-multisig.s.sol

@@ -6,22 +6,23 @@ import {SafeTx, SafeTxUtils} from "../utils/SafeTxUtils.sol";
 import {ITimelock} from "../interfaces/ITimelock.sol";
 import {Queue} from "./2-multisig.s.sol";
 
-contract Execute is MultisigBuilder {
+contract Execute is Queue {
     using MultisigCallUtils for MultisigCall[];
     using SafeTxUtils for SafeTx;
 
-    MultisigCall[] internal _opsCalls;
+    MultisigCall[] private _opsCalls;
 
+    /**
+     * @dev Overrides the previous _execute function to execute the queued transactions.
+     */
     function _execute() internal override returns (MultisigCall[] memory) {
-        Queue queue = new Queue();
 
-        MultisigCall[] memory _executorCalls = queue.queue();
+        MultisigCall[] memory _executorCalls = _queue();
 
-        address multiSendCallOnly = vm.envAddress("ZEUS_DEPLOYED_MultiSendCallOnly");
+        address multiSendCallOnly = zeusAddress("MultiSendCallOnly");
+        address timelock = zeusAddress("Timelock");
 
-        address timelock = vm.envAddress("ZEUS_DEPLOYED_Timelock");
-
-        bytes memory executorCalldata = queue.makeExecutorCalldata(_executorCalls, multiSendCallOnly, timelock);
+        bytes memory executorCalldata = _executorCalls.makeExecutorCalldata(multiSendCallOnly, timelock);
 
         // execute queued transaction
         _opsCalls.append({

src/utils/MultisigCallUtils.sol

@@ -40,4 +40,17 @@ library MultisigCallUtils {
 
         return abi.encodeWithSelector(IMultiSend.multiSend.selector, ret);
     }
+
+    function makeExecutorCalldata(MultisigCall[] memory calls, address multiSendCallOnly, address timelock)
+        internal
+        pure
+        returns (bytes memory)
+    {
+        return abi.encodeWithSelector(
+            IMultiSend.multiSend.selector,
+            encodeMultisendTxs(calls),
+            multiSendCallOnly,
+            timelock
+        );
+    }
 }