@aave-dao/aave-address-book 4.44.22

package/src/governance-v3/IPayloadsControllerCore.sol

@@ -0,0 +1,220 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {PayloadsControllerUtils} from './PayloadsControllerUtils.sol';
+
+interface IPayloadsControllerCore {
+  /// @notice Enum indicating the possible payload states
+  enum PayloadState {
+    None, // state 0 left as empty
+    Created,
+    Queued,
+    Executed,
+    Cancelled,
+    Expired
+  }
+
+  /**
+   * @notice holds configuration of the executor
+   * @param executor address of the executor
+   * @param delay time in seconds between queuing and execution
+   */
+  struct ExecutorConfig {
+    address executor;
+    uint40 delay;
+  }
+
+  /**
+   * @notice Object containing the information necessary to set a new executor
+   * @param accessLevel level of access that the executor will be assigned to
+   * @param executorConfig object containing the configurations for the accessLevel specified
+   */
+  struct UpdateExecutorInput {
+    PayloadsControllerUtils.AccessControl accessLevel;
+    ExecutorConfig executorConfig;
+  }
+
+  /**
+   * @notice Object containing the information necessary to define a payload action
+   * @param target address of the contract that needs to be executed
+   * @param withDelegateCall boolean indicating if execution needs to be delegated
+   * @param accessLevel access level of the executor needed for the execution
+   * @param value value amount that needs to be sent to the executeTransaction method
+   * @param signature method signature that will be executed
+   * @param callData data needed for the execution of the signature
+   */
+  struct ExecutionAction {
+    address target;
+    bool withDelegateCall;
+    PayloadsControllerUtils.AccessControl accessLevel;
+    uint256 value;
+    string signature;
+    bytes callData;
+  }
+
+  /**
+   * @notice Object containing a payload information
+   * @param creator address of the createPayload method caller
+   * @param maximumAccessLevelRequired min level needed to be able to execute all actions
+   * @param state indicates the current state of the payload
+   * @param createdAt time indicating when payload has been created. In seconds // max is: 1.099511628×10¹² (ie 34'865 years)
+   * @param queuedAt time indicating when payload has been queued. In seconds  // max is: 1.099511628×10¹² (ie 34'865 years)
+   * @param executedAt time indicating when a payload has been executed. In seconds  // max is: 1.099511628×10¹² (ie 34'865 years)
+   * @param cancelledAt time indicating when the payload has been cancelled. In seconds
+   * @param expirationTime time indicating when the Payload will expire
+   * @param delay time in seconds that a payload must remain queued before execution
+   * @param gracePeriod time in seconds that a payload has to be executed
+   * @param actions array of actions to be executed
+   */
+  struct Payload {
+    address creator;
+    PayloadsControllerUtils.AccessControl maximumAccessLevelRequired;
+    PayloadState state;
+    uint40 createdAt;
+    uint40 queuedAt;
+    uint40 executedAt;
+    uint40 cancelledAt;
+    uint40 expirationTime;
+    uint40 delay;
+    uint40 gracePeriod;
+    ExecutionAction[] actions;
+  }
+
+  /**
+   * @notice Event emitted when an executor has been set for a determined access level
+   * @param accessLevel level of access that the executor will be set to
+   * @param executor address that will be set for the determined access level
+   * @param delay time in seconds between queuing and execution
+   */
+  event ExecutorSet(
+    PayloadsControllerUtils.AccessControl indexed accessLevel,
+    address indexed executor,
+    uint40 delay
+  );
+
+  /**
+   * @notice Event emitted when a payload has been created
+   * @param payloadId id of the payload created
+   * @param creator address pertaining to the caller of the method createPayload
+   * @param actions array of the actions conforming the payload
+   * @param maximumAccessLevelRequired maximum level of the access control
+   */
+  event PayloadCreated(
+    uint40 indexed payloadId,
+    address indexed creator,
+    ExecutionAction[] actions,
+    PayloadsControllerUtils.AccessControl indexed maximumAccessLevelRequired
+  );
+
+  /**
+   * @notice emitted when a cross chain message gets received
+   * @param originSender address that sent the message on the origin chain
+   * @param originChainId id of the chain where the message originated
+   * @param delivered flag indicating if message has been delivered
+   * @param message bytes containing the necessary information to queue the bridged payload id
+   * @param reason bytes with the revert information
+   */
+  event PayloadExecutionMessageReceived(
+    address indexed originSender,
+    uint256 indexed originChainId,
+    bool indexed delivered,
+    bytes message,
+    bytes reason
+  );
+
+  /**
+   * @notice Event emitted when a payload has been executed
+   * @param payloadId id of the payload being enqueued
+   */
+  event PayloadExecuted(uint40 payloadId);
+
+  /**
+   * @notice Event emitted when a payload has been queued
+   * @param payloadId id of the payload being enqueued
+   */
+  event PayloadQueued(uint40 payloadId);
+
+  /**
+   * @notice Event emitted when cancelling a payload
+   * @param payloadId id of the cancelled payload
+   */
+  event PayloadCancelled(uint40 payloadId);
+
+  /**
+   * @notice get the expiration delay of a payload
+   * @return expiration delay in seconds
+   */
+  function EXPIRATION_DELAY() external view returns (uint40);
+
+  /**
+   * @notice get the maximum time in seconds that a proposal must spend being queued
+   * @return max delay in seconds
+   */
+  function MAX_EXECUTION_DELAY() external view returns (uint40);
+
+  /**
+   * @notice get the minimum time in seconds that a proposal must spend being queued
+   * @return min delay in seconds
+   */
+  function MIN_EXECUTION_DELAY() external view returns (uint40);
+
+  /**
+   * @notice time in seconds where the proposal can be executed (from executionTime) before it expires
+   * @return grace period in seconds
+   */
+  function GRACE_PERIOD() external view returns (uint40);
+
+  /**
+   * @notice get a previously created payload object
+   * @param payloadId id of the payload to retrieve
+   * @return payload information
+   */
+  function getPayloadById(uint40 payloadId) external view returns (Payload memory);
+
+  /**
+   * @notice get the current state of a payload
+   * @param payloadId id of the payload to retrieve the state from
+   * @return payload state
+   */
+  function getPayloadState(uint40 payloadId) external view returns (PayloadState);
+
+  /**
+   * @notice get the total count of payloads created
+   * @return number of payloads
+   */
+  function getPayloadsCount() external view returns (uint40);
+
+  /**
+   * @notice method that will create a Payload object for every action sent
+   * @param actions array of actions which this proposal payload will contain
+   * @return id of the created payload
+   */
+  function createPayload(ExecutionAction[] calldata actions) external returns (uint40);
+
+  /**
+   * @notice method to execute a payload
+   * @param payloadId id of the payload that needs to be executed
+   */
+  function executePayload(uint40 payloadId) external payable;
+
+  /**
+   * @notice method to cancel a payload
+   * @param payloadId id of the payload that needs to be canceled
+   */
+  function cancelPayload(uint40 payloadId) external;
+
+  /**
+   * @notice method to add executors and its configuration
+   * @param executors array of UpdateExecutorInput objects
+   */
+  function updateExecutors(UpdateExecutorInput[] calldata executors) external;
+
+  /**
+   * @notice method to get the executor configuration assigned to the specified level
+   * @param accessControl level of which we want to get the executor configuration from
+   * @return executor configuration
+   */
+  function getExecutorSettingsByAccessControl(
+    PayloadsControllerUtils.AccessControl accessControl
+  ) external view returns (ExecutorConfig memory);
+}

package/src/governance-v3/IVotingMachineWithProofs.sol

@@ -0,0 +1,380 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {IDataWarehouse} from './IDataWarehouse.sol';
+import {IVotingStrategy} from './IVotingStrategy.sol';
+
+interface IVotingMachineWithProofs {
+  /**
+   * @notice Object containing the signature parameters to be able to vote as a representative
+   * @param v v part of the voter signature
+   * @param r r part of the voter signature
+   * @param s s part of the voter signature
+   */
+  struct SignatureParams {
+    uint8 v;
+    bytes32 r;
+    bytes32 s;
+  }
+
+  /**
+   * @notice Object to use over submitVoteBySignature and in case of bridging for protect against wrong roots inclusion
+   * @param underlyingAsset address of the token on L1, used for voting
+   * @param slot base storage position where the balance on underlyingAsset contract resides on L1. (Normally position 0)
+   */
+  struct VotingAssetWithSlot {
+    address underlyingAsset;
+    uint128 slot;
+  }
+
+  /**
+   * @notice object containing the information of a bridged vote
+   * @param support indicates if vote is in favor or against the proposal
+   * @param votingAssetsWithSlots list of token addresses with storage slots, that the voter will use for voting
+   */
+  struct BridgedVote {
+    bool support;
+    VotingAssetWithSlot[] votingAssetsWithSlot;
+  }
+
+  /**
+   * @notice enum delimiting the possible states a proposal can have on the voting machine
+   * @dev ProposalState enum defines the state machine of a proposal being voted, so the order on which the state is
+          defined is important. Check logic correctness if new states are added / removed
+   */
+  enum ProposalState {
+    NotCreated,
+    Active,
+    Finished,
+    SentToGovernance
+  }
+
+  /**
+   * @notice Object with vote information
+   * @param support boolean indicating if the vote is in favor or against a proposal
+   * @param votingPower the power used for voting
+   */
+  struct Vote {
+    bool support;
+    uint248 votingPower;
+  }
+
+  /**
+   * @notice Object containing a proposal information
+   * @param id numeric identification of the proposal
+   * @param sentToGovernance boolean indication if the proposal results have been sent back to L1 governance
+   * @param startTime timestamp of the start of voting on the proposal
+   * @param endTime timestamp when the voting on the proposal finishes (startTime + votingDuration)
+   * @param votingClosedAndSentTimestamp timestamp indicating when the vote has been closed and sent to governance chain
+   * @param forVotes votes cast in favor of the proposal
+   * @param againstVotes votes cast against the proposal
+   * @param creationBlockNumber blockNumber from when the proposal has been created in votingMachine
+   * @param votingClosedAndSentBlockNumber block from when the vote has been closed and sent to governance chain
+   * @param votes mapping indication for every voter of the proposal the information of that vote
+   */
+  struct Proposal {
+    uint256 id;
+    bool sentToGovernance;
+    uint40 startTime;
+    uint40 endTime;
+    uint40 votingClosedAndSentTimestamp;
+    uint128 forVotes;
+    uint128 againstVotes;
+    uint256 creationBlockNumber;
+    uint256 votingClosedAndSentBlockNumber;
+    mapping(address => Vote) votes;
+  }
+
+  /**
+   * @notice Object containing a proposal information
+   * @param id numeric identification of the proposal
+   * @param sentToGovernance boolean indication if the proposal results have been sent back to L1 governance
+   * @param startTime timestamp of the start of voting on the proposal
+   * @param endTime timestamp when the voting on the proposal finishes (startTime + votingDuration)
+   * @param votingClosedAndSentTimestamp timestamp indicating when the vote has been closed and sent to governance chain
+   * @param forVotes votes cast in favor of the proposal
+   * @param againstVotes votes cast against the proposal
+   * @param creationBlockNumber blockNumber from when the proposal has been created in votingMachine
+   * @param votingClosedAndSentBlockNumber block from when the vote has been closed and sent back to governance chain
+   */
+  struct ProposalWithoutVotes {
+    uint256 id;
+    bool sentToGovernance;
+    uint40 startTime;
+    uint40 endTime;
+    uint40 votingClosedAndSentTimestamp;
+    uint128 forVotes;
+    uint128 againstVotes;
+    uint256 creationBlockNumber;
+    uint256 votingClosedAndSentBlockNumber;
+  }
+
+  /**
+   * @notice vote configuration passed from l1
+   * @param votingDuration duration in seconds of the vote for a proposal
+   * @param l1BlockHash hash of the block on L1 from the block when the proposal was activated for voting (sent to voting machine)
+            this block hash is used to delimit from when the voting power is accounted for voting
+   */
+  struct ProposalVoteConfiguration {
+    uint24 votingDuration;
+    bytes32 l1ProposalBlockHash;
+  }
+
+  /**
+   * @notice Object with the necessary information to process a vote
+   * @param underlyingAsset address of the token on L1, used for voting
+   * @param slot base storage position where the balance on underlyingAsset contract resides on L1. (Normally position 0)
+   * @param proof bytes of the generated proof on L1 with the slot information of underlying asset.
+   */
+  struct VotingBalanceProof {
+    address underlyingAsset;
+    uint128 slot;
+    bytes proof;
+  }
+
+  /**
+   * @notice emitted when a proposal is created
+   * @param proposalId numeric id of the created proposal
+   * @param l1BlockHash block hash from the block on l1 from when the proposal was activated for voting
+   * @param startTime timestamp when the proposal was created and ready for voting
+   * @param endTime timestamp of when the voting period ends. (startTime + votingDuration)
+   */
+  event ProposalVoteStarted(
+    uint256 indexed proposalId,
+    bytes32 indexed l1BlockHash,
+    uint256 startTime,
+    uint256 endTime
+  );
+
+  /**
+   * @notice emitted when the results of a vote on a proposal are sent to L1
+   * @param proposalId numeric id of the proposal which results are sent to L1
+   * @param forVotes votes cast in favor of proposal
+   * @param againstVotes votes cast against the proposal
+   */
+  event ProposalResultsSent(uint256 indexed proposalId, uint256 forVotes, uint256 againstVotes);
+
+  /**
+   * @notice emitted when a vote is registered
+   * @param proposalId Id of the proposal
+   * @param voter address of the voter
+   * @param support boolean, true = vote for, false = vote against
+   * @param votingPower Power of the voter/vote
+   */
+  event VoteEmitted(
+    uint256 indexed proposalId,
+    address indexed voter,
+    bool indexed support,
+    uint256 votingPower
+  );
+
+  /**
+   * @notice emitted when a voting configuration of a proposal gets received. Meaning that has been bridged successfully
+   * @param proposalId id of the proposal bridged to start the vote on
+   * @param blockHash hash of the block on L1 when the proposal was activated for voting
+   * @param votingDuration duration in seconds of the vote
+   * @param voteCreated boolean indicating if the vote has been created or not.
+   * @dev the vote will only be created automatically if when the configuration is bridged, all necessary roots
+          have been registered already.
+   */
+  event ProposalVoteConfigurationBridged(
+    uint256 indexed proposalId,
+    bytes32 indexed blockHash,
+    uint24 votingDuration,
+    bool indexed voteCreated
+  );
+
+  /**
+   * @notice method to get the representatives mapping slot in Governance contract
+   * @return representatives slot
+   */
+  function REPRESENTATIVES_SLOT() external view returns (uint256);
+
+  /**
+   * @notice method to get the Governance contract address
+   * @return Governance address
+   */
+  function GOVERNANCE() external view returns (address);
+
+  /**
+   * @notice method to get the voting asset with slot signature
+   * @return signature of the voting asset with slot method
+   */
+  function VOTING_ASSET_WITH_SLOT_RAW() external view returns (string memory);
+
+  /**
+   * @notice method to get the DataWarehouse contract
+   * @return DataWarehouse contract
+   */
+  function DATA_WAREHOUSE() external view returns (IDataWarehouse);
+
+  /**
+   * @notice method to get the VotingStrategy contract
+   * @return VotingStrategy contract
+   */
+  function VOTING_STRATEGY() external view returns (IVotingStrategy);
+
+  /**
+   * @notice Get the v4 compatible domain separator
+   * @dev Return cached value if chainId matches cache, otherwise recomputes separator
+   * @return The domain separator of the token at current chain
+   */
+  function DOMAIN_SEPARATOR() external view returns (bytes32);
+
+  /**
+   * @notice method to get the vote submitted type hash for permits digest
+   * @return hash of vote submitted string
+   */
+  function VOTE_SUBMITTED_TYPEHASH() external view returns (bytes32);
+
+  /**
+   * @notice method to get the vote submitted by representative type hash for permits digest
+   * @return hash of vote submitted by representative string
+   */
+  function VOTE_SUBMITTED_BY_REPRESENTATIVE_TYPEHASH() external view returns (bytes32);
+
+  /**
+   * @notice method to get the voting asset with slot type hash for permits digest
+   * @return hash of vote submitted string
+   */
+  function VOTING_ASSET_WITH_SLOT_TYPEHASH() external view returns (bytes32);
+
+  /**
+   * @notice method to get the contract name for permits digest
+   * @return contract name string
+   */
+  function NAME() external view returns (string memory);
+
+  /**
+   * @notice method to get a proposal information specified by its id
+   * @param proposalId id of the proposal to retrieve
+   * @return the proposal information without the users vote
+   */
+  function getProposalById(uint256 proposalId) external view returns (ProposalWithoutVotes memory);
+
+  /**
+   * @notice method to get the state of a proposal specified by its id
+   * @param proposalId id of the proposal to retrieve the state of
+   * @return the state of the proposal
+   */
+  function getProposalState(uint256 proposalId) external view returns (ProposalState);
+
+  /**
+   * @notice method to get the voting configuration of a proposal specified by its id
+   * @param proposalId id of the proposal to retrieve the voting configuration from
+   * @return the proposal vote configuration object
+   */
+  function getProposalVoteConfiguration(
+    uint256 proposalId
+  ) external view returns (ProposalVoteConfiguration memory);
+
+  /**
+  * @notice method to get a paginated list of proposalIds. The proposals are taken from a list of proposals that have
+            received vote configuration from governance chain
+  * @param skip number of proposal ids to skip. from latest in the list of proposal ids with voting configuration
+  * @param size length of proposal ids to ask for.
+  * @return list of proposal ids
+  * @dev This is mainly used to get a list of proposals that require automation in some step of the proposal live cycle.
+  */
+  function getProposalsVoteConfigurationIds(
+    uint256 skip,
+    uint256 size
+  ) external view returns (uint256[] memory);
+
+  /**
+   * @notice method to get the vote set by a user on a proposal specified by its id
+   * @param user address of the user that voted
+   * @param proposalId id of the proposal to retrieve the vote from
+   * @return the vote (support and voting power) emitted
+   */
+  function getUserProposalVote(
+    address user,
+    uint256 proposalId
+  ) external view returns (Vote memory);
+
+  /**
+    * @notice method to start a vote on a proposal specified by its id.
+    * @param proposalId id of the proposal to start the vote on.
+    * @return the id of the proposal that had the vote started on.
+    * @dev this method can be called by anyone, requiring that the appropriate conditions are met.
+           basically that the proper roots have been registered.
+           It can also be called internally when the bridged message is received and the the required roots
+           have been registered
+    */
+  function startProposalVote(uint256 proposalId) external returns (uint256);
+
+  /**
+    * @notice method to cast a vote on a proposal specified by its id
+    * @param proposalId id of the proposal on which the vote will be cast
+    * @param support boolean indicating if the vote is in favor or against the proposal
+    * @param votingBalanceProofs list of objects containing the information necessary to vote using the tokens
+             allowed on the voting strategy.
+    * @dev A vote does not need to use all the tokens allowed, can be a subset
+    */
+  function submitVote(
+    uint256 proposalId,
+    bool support,
+    VotingBalanceProof[] calldata votingBalanceProofs
+  ) external;
+
+  /**
+   * @notice Function to register the vote of user that has voted offchain via signature
+   * @param proposalId id of the proposal
+   * @param voter the voter address
+   * @param support boolean, true = vote for, false = vote against
+   * @param votingBalanceProofs list of voting assets proofs
+   * @param v v part of the voter signature
+   * @param r r part of the voter signature
+   * @param s s part of the voter signature
+   */
+  function submitVoteBySignature(
+    uint256 proposalId,
+    address voter,
+    bool support,
+    VotingBalanceProof[] calldata votingBalanceProofs,
+    uint8 v,
+    bytes32 r,
+    bytes32 s
+  ) external;
+
+  /**
+   * @notice method to close a vote on a proposal specified by its id and send the results back to governance
+   * @param proposalId id of the proposal to close the vote on and send the voting result to governance
+   * @dev This method will trigger the bridging flow
+   */
+  function closeAndSendVote(uint256 proposalId) external;
+
+  /**
+   * @notice Function to register the vote of user as its representative
+   * @param proposalId id of the proposal
+   * @param support boolean, true = vote for, false = vote against
+   * @param voter the voter address
+   * @param proofOfRepresentation proof that can validate that msg.sender is the voter representative
+   * @param votingBalanceProofs list of voting assets proofs
+   */
+  function submitVoteAsRepresentative(
+    uint256 proposalId,
+    bool support,
+    address voter,
+    bytes memory proofOfRepresentation,
+    VotingBalanceProof[] calldata votingBalanceProofs
+  ) external;
+
+  /**
+   * @notice Function to register the vote of user as its representative with a signed message
+   * @param proposalId id of the proposal
+   * @param voter the voter address
+   * @param proofOfRepresentation proof that can validate that msg.sender is the voter representative
+   * @param votingBalanceProofs list of voting assets proofs
+   * @param signatureParams object containing the necessary signature parameters
+   */
+  function submitVoteAsRepresentativeBySignature(
+    uint256 proposalId,
+    address voter,
+    address representative,
+    bool support,
+    bytes memory proofOfRepresentation,
+    VotingBalanceProof[] calldata votingBalanceProofs,
+    SignatureParams memory signatureParams
+  ) external;
+}

package/src/governance-v3/IVotingPortal.sol

@@ -0,0 +1,99 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {IBaseReceiverPortal} from './IBaseReceiverPortal.sol';
+import {IVotingMachineWithProofs} from './IVotingMachineWithProofs.sol';
+
+/**
+ * @title IVotingPortal
+ * @author BGD Labs
+ * @notice interface containing the objects, events and methods definitions of the VotingPortal contract
+ */
+interface IVotingPortal is IBaseReceiverPortal {
+  /**
+   * @notice enum containing the different type of messages that can be bridged
+   * @param Null empty state
+   * @param Proposal indicates that the message is to bridge a proposal configuration
+   */
+  enum MessageType {
+    Null,
+    Proposal
+  }
+
+  /**
+   * @notice emitted when "Start voting" gas limit gets updated
+   * @param gasLimit the new gas limit
+   */
+  event StartVotingGasLimitUpdated(uint128 gasLimit);
+
+  /**
+   * @notice emitted when a vote message is received
+   * @param originSender address that sent the message on the origin chain
+   * @param originChainId id of the chain where the message originated
+   * @param delivered flag indicating if message has been delivered
+   * @param message bytes containing the necessary information to queue the bridged proposal id
+   * @param reason bytes with the revert information
+   */
+  event VoteMessageReceived(
+    address indexed originSender,
+    uint256 indexed originChainId,
+    bool indexed delivered,
+    bytes message,
+    bytes reason
+  );
+
+  /**
+   * @notice get the chain id where the voting machine which is deployed
+   * @return network id
+   */
+  function VOTING_MACHINE_CHAIN_ID() external view returns (uint256);
+
+  /**
+   * @notice gets the address of the voting machine on the destination network
+   * @return voting machine address
+   */
+  function VOTING_MACHINE() external view returns (address);
+
+  /**
+   * @notice gets the address of the connected governance
+   * @return governance address
+   */
+  function GOVERNANCE() external view returns (address);
+
+  /**
+   * @notice gets the address of the CrossChainController deployed on current network
+   * @return CrossChainController address
+   */
+  function CROSS_CHAIN_CONTROLLER() external view returns (address);
+
+  /**
+   * @notice method to set the gas limit for "Start voting" bridging tx
+   * @param gasLimit the new gas limit
+   */
+  function setStartVotingGasLimit(uint128 gasLimit) external;
+
+  /**
+   * @notice method to get the gas limit for "Start voting" bridging tx
+   * @return the gas limit
+   */
+  function getStartVotingGasLimit() external view returns (uint128);
+
+  /**
+   * @notice method to bridge the vote configuration to voting chain, so a vote can be started.
+   * @param proposalId id of the proposal bridged to start the vote on
+   * @param blockHash hash of the block on L1 when the proposal was activated for voting
+   * @param votingDuration duration in seconds of the vote
+   */
+  function forwardStartVotingMessage(
+    uint256 proposalId,
+    bytes32 blockHash,
+    uint24 votingDuration
+  ) external;
+
+  /**
+   * @notice method to decode a message from from voting machine chain
+   * @param message encoded message with message type
+   * @return proposalId, forVotes, againstVotes from the decoded message
+   */
+  function decodeMessage(bytes memory message) external pure returns (uint256, uint128, uint128);
+}