feat: l1 execution

.gitmodules

@@ -18,3 +18,6 @@
 	url = https://github.com/safe-global/safe-contracts
 [submodule "lib/safe-contracts"]
 	branch = v1.4.0
+[submodule "ethereum/lib/openzeppelin-contracts"]
+	path = ethereum/lib/openzeppelin-contracts
+	url = https://github.com/OpenZeppelin/openzeppelin-contracts

ethereum/remappings.txt

@@ -1,2 +1,5 @@
-@gnosis.pm/safe-contracts=lib/safe-contracts
+@gnosis.pm/safe-contracts=lib/safe-contracts/
+@openzeppelin/contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts
+@gnosis.pm/zodiac/=lib/zodiac/
+@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts
 @openzeppelin/contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts

ethereum/src/deps.sol

@@ -0,0 +1,9 @@
+/// SPDX-License-Identifier: MIT
+
+// pragma solidity ^0.8.19;
+
+// import "@gnosis.pm/safe-contracts/contracts/SafeL2.sol";
+// import "@gnosis.pm/safe-contracts/contracts/proxies/SafeProxyFactory.sol";
+// import "@gnosis.pm/zodiac/contracts/factory/ModuleProxyFactory.sol";
+// import "@gnosis.pm/zodiac/contracts/guard/Guardable.sol";
+// import "@gnosis.pm/zodiac/contracts/core/Module.sol";

ethereum/src/execution-strategies/L1AvatarExecutionStrategy.sol

@@ -2,22 +2,19 @@
 
 pragma solidity ^0.8.19;
 
-import "zodiac/interfaces/IAvatar.sol";
+import "@gnosis.pm/zodiac/contracts/interfaces/IAvatar.sol";
 import "../interfaces/IStarknetCore.sol";
 import {SimpleQuorumExecutionStrategy} from "./SimpleQuorumExecutionStrategy.sol";
 import "../types.sol";
-/**
- * @title Snapshot X L1 execution Zodiac module
- * @author Snapshot Labs
- * @notice Trustless L1 execution of Snapshot X decisions via an Avatar contract such as a Gnosis Safe
- * @dev Work in progress
- */
 
+/// @title L1 Avatar Execution Strategy
+/// @notice Used to execute SX Starknet proposal transactions from an Avatar contract on Ethereum.
+/// @dev An Avatar contract is any contract that implements the IAvatar interface, eg a Gnosis Safe.
 contract L1AvatarExecutionStrategy is SimpleQuorumExecutionStrategy {
     /// @dev Address of the avatar that this module will pass transactions to.
     address public target;
 
-    /// The StarkNet Core contract
+    /// The Starknet Core contract.
     address public starknetCore;
 
     /// Address of the StarkNet contract that will send execution details to this contract in a L2 -> L1 message
@@ -29,66 +26,65 @@ contract L1AvatarExecutionStrategy is SimpleQuorumExecutionStrategy {
     /// @dev Emitted each time the Execution Relayer is set.
     event ExecutionRelayerSet(uint256 indexed newExecutionRelayer);
 
-    /**
-     * @dev Emitted when a new module proxy instance has been deployed
-     * @param _owner Address of the owner of this contract
-     * @param _target Address that this contract will pass transactions to
-     * @param _starknetCore Address of the StarkNet Core contract
-     * @param _executionRelayer Address of the StarkNet contract that will send execution details to this contract in a L2 -> L1 message
-     */
-    event SXAvatarExecutorSetUp(
+    /// @notice Emitted when a new Avatar Execution Strategy is initialized.
+    /// @param _owner Address of the owner of the strategy.
+    /// @param _target Address of the avatar that this module will pass transactions to.
+    /// @param _starknetCore Address of the StarkNet Core contract.
+    /// @param _executionRelayer Address of the StarkNet contract that will send execution details to this contract in a L2 -> L1 message
+    /// @param _starknetSpaces Array of whitelisted space contracts.
+    /// @param _quorum The quorum required to execute a proposal.
+    event L1AvatarExecutionStrategySetUp(
         address indexed _owner,
         address _target,
         address _starknetCore,
         uint256 _executionRelayer,
-        uint256[] _starknetSpaces
+        uint256[] _starknetSpaces,
+        uint256 _quorum
     );
 
-    /**
-     * @dev Constructs the master contract
-     * @param _owner Address of the owner of this contract
-     * @param _target Address that this contract will pass transactions to
-     * @param _starknetCore Address of the StarkNet Core contract
-     * @param _executionRelayer Address of the StarkNet contract that will send execution details to this contract in a L2 -> L1 message
-     * @param _starknetSpaces of spaces deployed on StarkNet that are allowed to execute proposals via this contract
-     */
+    /// @notice Constructor
+    /// @param _owner Address of the owner of this contract.
+    /// @param _target Address of the avatar that this module will pass transactions to.
+    /// @param _starknetCore Address of the StarkNet Core contract.
+    /// @param _executionRelayer Address of the StarkNet contract that will send execution details to this contract in a L2 -> L1 message
+    /// @param _starknetSpaces Array of whitelisted space contracts.
+    /// @param _quorum The quorum required to execute a proposal.
     constructor(
         address _owner,
         address _target,
         address _starknetCore,
         uint256 _executionRelayer,
-        uint256[] memory _starknetSpaces
+        uint256[] memory _starknetSpaces,
+        uint256 _quorum
     ) {
-        bytes memory initParams = abi.encode(_owner, _target, _starknetCore, _executionRelayer, _starknetSpaces);
+        bytes memory initParams =
+            abi.encode(_owner, _target, _starknetCore, _executionRelayer, _starknetSpaces, _quorum);
         setUp(initParams);
     }
 
-    /**
-     * @dev Proxy constructor
-     * @param initParams Initialization parameters
-     */
+    /// @notice Initialization function, should be called immediately after deploying a new proxy to this contract.
+    /// @param initParams ABI encoded parameters, in the same order as the constructor.
     function setUp(bytes memory initParams) public initializer {
         (
             address _owner,
             address _target,
             address _starknetCore,
             uint256 _executionRelayer,
-            uint256[] memory _starknetSpaces
-        ) = abi.decode(initParams, (address, address, address, uint256, uint256[]));
+            uint256[] memory _starknetSpaces,
+            uint256 _quorum
+        ) = abi.decode(initParams, (address, address, address, uint256, uint256[], uint256));
         __Ownable_init();
         transferOwnership(_owner);
         __SpaceManager_init(_starknetSpaces);
+        __SimpleQuorumExecutionStrategy_init(_quorum);
         target = _target;
         starknetCore = _starknetCore;
         executionRelayer = _executionRelayer;
-
-        emit SXAvatarExecutorSetUp(_owner, _target, _starknetCore, _executionRelayer, _starknetSpaces);
+        emit L1AvatarExecutionStrategySetUp(_owner, _target, _starknetCore, _executionRelayer, _starknetSpaces, _quorum);
     }
 
-    /**
-     * @dev Changes the StarkNet execution relayer contract
-     * @param _executionRelayer Address of the new execution relayer contract
-     */
+    /// @notice Sets the Starknet execution relayer contract
+    /// @param _executionRelayer Address of the new execution relayer contract
     function setExecutionRelayer(uint256 _executionRelayer) external onlyOwner {
         executionRelayer = _executionRelayer;
         emit ExecutionRelayerSet(_executionRelayer);
@@ -107,16 +103,16 @@ contract L1AvatarExecutionStrategy is SimpleQuorumExecutionStrategy {
     /// @param votesFor The number of votes for the proposal.
     /// @param votesAgainst The number of votes against the proposal.
     /// @param votesAbstain The number of votes abstaining from the proposal.
-    /// @param executionHash The hash of the execution payload.
-    /// @param payload The encoded execution payload.
+    /// @param executionHash The hash of the proposal transactions.
+    /// @param transactions The proposal transactions to be executed.
     function execute(
         uint256 space,
         Proposal memory proposal,
         uint256 votesFor,
         uint256 votesAgainst,
         uint256 votesAbstain,
-        bytes32 executionHash,
-        bytes memory payload
+        uint256 executionHash,
+        MetaTransaction[] memory transactions
     ) external onlySpace(space) {
         // Call to the Starknet core contract will fail if finalized proposal message was not received on L1.
         _receiveProposal(space, proposal, votesFor, votesAgainst, votesAbstain, executionHash);
@@ -126,9 +122,9 @@ contract L1AvatarExecutionStrategy is SimpleQuorumExecutionStrategy {
             revert InvalidProposalStatus(proposalStatus);
         }
 
-        if (executionHash != keccak256(payload)) revert InvalidPayload();
+        if (bytes32(executionHash) != keccak256(abi.encode(transactions))) revert InvalidPayload();
 
-        _execute(payload);
+        _execute(transactions);
     }
 
     /// @dev Reverts if the expected message was not received from L2.
@@ -138,36 +134,40 @@ contract L1AvatarExecutionStrategy is SimpleQuorumExecutionStrategy {
         uint256 votesFor,
         uint256 votesAgainst,
         uint256 votesAbstain,
-        bytes32 executionHash
+        uint256 executionHash
     ) internal {
-        uint256[] memory payload = new uint256[](15);
+        // The Cairo serialization of the payload sent from L2
+        uint256[] memory payload = new uint256[](19);
         payload[0] = space;
-        // The serialized Proposal struct
-        // TODO: this is probably an incorrect serialization
-        payload[1] = uint256(proposal.snapshotTimestamp);
-        payload[2] = uint256(proposal.startTimestamp);
-        payload[3] = uint256(proposal.minEndTimestamp);
-        payload[4] = uint256(proposal.maxEndTimestamp);
+        payload[1] = uint256(proposal.startTimestamp);
+        payload[2] = uint256(proposal.minEndTimestamp);
+        payload[3] = uint256(proposal.maxEndTimestamp);
+        payload[4] = uint256(proposal.finalizationStatus);
         payload[5] = proposal.executionPayloadHash;
-        payload[6] = uint256(uint160(proposal.executionStrategy));
-        payload[7] = uint256(uint160(proposal.author));
-        payload[8] = uint256(proposal.finalizationStatus);
-        payload[9] = proposal.activeVotingStrategies;
+        payload[6] = proposal.executionStrategy;
+        payload[7] = proposal.authorAddressType;
+        payload[8] = proposal.author;
+        payload[9] = proposal.activeVotingStrategies & (2 ** 128 - 1);
+        payload[10] = proposal.activeVotingStrategies >> 128;
+
+        payload[11] = votesFor & (2 ** 128 - 1);
+        payload[12] = votesFor >> 128;
+
+        payload[13] = votesAgainst & (2 ** 128 - 1);
+        payload[14] = votesAgainst >> 128;
 
-        payload[10] = votesFor;
-        payload[11] = votesAgainst;
-        payload[12] = votesAbstain;
+        payload[15] = votesAbstain & (2 ** 128 - 1);
+        payload[16] = votesAbstain >> 128;
 
-        payload[13] = uint256(executionHash >> 128); // High 128 bits of executionHash
-        payload[14] = uint256(executionHash) & (2 ** 128 - 1); // Low 128 bits of executionHash
+        payload[17] = executionHash & (2 ** 128 - 1);
+        payload[18] = executionHash >> 128;
 
         // If proposal execution message did not exist/not received yet, then this will revert.
         IStarknetCore(starknetCore).consumeMessageFromL2(executionRelayer, payload);
     }
 
     /// @dev Decodes and executes the payload via the avatar.
-    function _execute(bytes memory payload) internal {
-        MetaTransaction[] memory transactions = abi.decode(payload, (MetaTransaction[]));
+    function _execute(MetaTransaction[] memory transactions) internal {
         for (uint256 i = 0; i < transactions.length; i++) {
             bool success = IAvatar(target).execTransactionFromModule(
                 transactions[i].to, transactions[i].value, transactions[i].data, transactions[i].operation
@@ -179,6 +179,6 @@ contract L1AvatarExecutionStrategy is SimpleQuorumExecutionStrategy {
 
     /// @notice Returns the type of execution strategy.
     function getStrategyType() external pure override returns (string memory) {
-        return "SimpleQuorumL1AvatarExecutionStrategy";
+        return "SimpleQuorumL1Avatar";
     }
 }

ethereum/src/execution-strategies/SimpleQuorumExecutionStrategy.sol

@@ -1,13 +1,15 @@
 // SPDX-License-Identifier: MIT
 
-pragma solidity ^0.8.18;
+pragma solidity ^0.8.19;
 
 import {IExecutionStrategy} from "../interfaces/IExecutionStrategy.sol";
 import {FinalizationStatus, Proposal, ProposalStatus} from "../types.sol";
 import {StarknetSpaceManager} from "./StarknetSpaceManager.sol";
 
 /// @title Simple Quorum Base Execution Strategy
 abstract contract SimpleQuorumExecutionStrategy is IExecutionStrategy, StarknetSpaceManager {
+    event QuorumUpdated(uint256 newQuorum);
+
     /// @notice The quorum required to execute a proposal using this strategy.
     uint256 public quorum;
 

ethereum/src/execution-strategies/StarknetSpaceManager.sol

@@ -3,56 +3,57 @@
 pragma solidity ^0.8.19;
 
 import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+import {TRUE, FALSE} from "../types.sol";
 
-/// @title Space Manager - A contract that manages SX spaces on Starknet that are able to execute transactions via this contract
-/// @author Snapshot Labs
+/// @title Space Manager
+/// @notice Manages a whitelist of Spaces that are authorized to execute transactions via this contract.
 contract StarknetSpaceManager is OwnableUpgradeable {
+    /// @notice Thrown if a space is not in the whitelist.
     error InvalidSpace();
 
     /// @dev Mapping of spaces that are enabled.
     /// A uint256 is used as Starknet addresses cannot be cast to a solidity address type.
-    mapping(uint256 => bool) internal spaces;
+    mapping(uint256 spaces => uint256 isEnabled) internal spaces;
 
     /// @notice Emitted when a space is enabled.
     event SpaceEnabled(uint256 space);
 
     /// @notice Emitted when a space is disabled.
     event SpaceDisabled(uint256 space);
 
-    /// @notice Initialize the contract with a list of spaces. Called only once.
+    /// @notice Initialize the contract with a list of Starknet spaces. Called only once.
     /// @param _spaces List of spaces.
     function __SpaceManager_init(uint256[] memory _spaces) internal onlyInitializing {
         for (uint256 i = 0; i < _spaces.length; i++) {
-            if (_spaces[i] == 0 || isSpaceEnabled(_spaces[i])) revert InvalidSpace();
-            spaces[_spaces[i]] = true;
+            spaces[_spaces[i]] = TRUE;
         }
     }
 
     /// @notice Enable a space.
     /// @param space Address of the space.
     function enableSpace(uint256 space) public onlyOwner {
-        if (space == 0 || isSpaceEnabled(space)) revert InvalidSpace();
-        spaces[space] = true;
+        if (space == 0 || (spaces[space] != FALSE)) revert InvalidSpace();
+        spaces[space] = TRUE;
         emit SpaceEnabled(space);
     }
 
     /// @notice Disable a space.
     /// @param space Address of the space.
-    function disableSpace(uint256 space) public onlyOwner {
-        if (!spaces[space]) revert InvalidSpace();
-        spaces[space] = false;
+    function disableSpace(uint256 space) external onlyOwner {
+        if (spaces[space] == FALSE) revert InvalidSpace();
+        spaces[space] = FALSE;
         emit SpaceDisabled(space);
     }
 
     /// @notice Check if a space is enabled.
     /// @param space Address of the space.
-    /// @return bool whether the space is enabled.
-    function isSpaceEnabled(uint256 space) public view returns (bool) {
+    /// @return uint256 whether the space is enabled.
+    function isSpaceEnabled(uint256 space) external view returns (uint256) {
         return spaces[space];
     }
 
-    modifier onlySpace(uint256 callerAddress) {
-        if (!isSpaceEnabled(callerAddress)) revert InvalidSpace();
+    modifier onlySpace(uint256 space) {
+        if (spaces[space] == FALSE) revert InvalidSpace();
         _;
     }
 }

ethereum/src/mocks/Avatar.sol

@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.18;
+
+import {IAvatar} from "@gnosis.pm/zodiac/contracts/interfaces/IAvatar.sol";
+
+contract Avatar {
+    error NotAuthorized();
+
+    mapping(address module => bool isEnabled) internal modules;
+
+    // solhint-disable-next-line no-empty-blocks
+    receive() external payable {}
+
+    function enableModule(address _module) external {
+        modules[_module] = true;
+    }
+
+    function disableModule(address _module) external {
+        modules[_module] = false;
+    }
+
+    function isModuleEnabled(address _module) external view returns (bool) {
+        return modules[_module];
+    }
+
+    function execTransactionFromModule(address payable to, uint256 value, bytes calldata data, uint8 operation)
+        external
+        returns (bool success)
+    {
+        if (!modules[msg.sender]) revert NotAuthorized();
+        // solhint-disable-next-line avoid-low-level-calls
+        if (operation == 1) (success,) = to.delegatecall(data);
+        else (success,) = to.call{value: value}(data);
+    }
+
+    function getModulesPaginated(
+        address,
+        uint256 // pageSize
+    ) external pure returns (address[] memory array, address next) {
+        // Unimplemented
+        return (new address[](0), address(0));
+    }
+}