@aave-dao/aave-address-book 4.44.22

package/src/common/IExecutorWithTimelock.sol

@@ -0,0 +1,195 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.6.0;
+
+interface IExecutorWithTimelock {
+  /**
+   * @dev emitted when a new pending admin is set
+   * @param newPendingAdmin address of the new pending admin
+   **/
+  event NewPendingAdmin(address newPendingAdmin);
+
+  /**
+   * @dev emitted when a new admin is set
+   * @param newAdmin address of the new admin
+   **/
+  event NewAdmin(address newAdmin);
+
+  /**
+   * @dev emitted when a new delay (between queueing and execution) is set
+   * @param delay new delay
+   **/
+  event NewDelay(uint256 delay);
+
+  /**
+   * @dev emitted when a new (trans)action is Queued.
+   * @param actionHash hash of the action
+   * @param target address of the targeted contract
+   * @param value wei value of the transaction
+   * @param signature function signature of the transaction
+   * @param data function arguments of the transaction or callData if signature empty
+   * @param executionTime time at which to execute the transaction
+   * @param withDelegatecall boolean, true = transaction delegatecalls the target, else calls the target
+   **/
+  event QueuedAction(
+    bytes32 actionHash,
+    address indexed target,
+    uint256 value,
+    string signature,
+    bytes data,
+    uint256 executionTime,
+    bool withDelegatecall
+  );
+
+  /**
+   * @dev emitted when an action is Cancelled
+   * @param actionHash hash of the action
+   * @param target address of the targeted contract
+   * @param value wei value of the transaction
+   * @param signature function signature of the transaction
+   * @param data function arguments of the transaction or callData if signature empty
+   * @param executionTime time at which to execute the transaction
+   * @param withDelegatecall boolean, true = transaction delegatecalls the target, else calls the target
+   **/
+  event CancelledAction(
+    bytes32 actionHash,
+    address indexed target,
+    uint256 value,
+    string signature,
+    bytes data,
+    uint256 executionTime,
+    bool withDelegatecall
+  );
+
+  /**
+   * @dev emitted when an action is Cancelled
+   * @param actionHash hash of the action
+   * @param target address of the targeted contract
+   * @param value wei value of the transaction
+   * @param signature function signature of the transaction
+   * @param data function arguments of the transaction or callData if signature empty
+   * @param executionTime time at which to execute the transaction
+   * @param withDelegatecall boolean, true = transaction delegatecalls the target, else calls the target
+   * @param resultData the actual callData used on the target
+   **/
+  event ExecutedAction(
+    bytes32 actionHash,
+    address indexed target,
+    uint256 value,
+    string signature,
+    bytes data,
+    uint256 executionTime,
+    bool withDelegatecall,
+    bytes resultData
+  );
+
+  /**
+   * @dev Getter of the current admin address (should be governance)
+   * @return The address of the current admin
+   **/
+  function getAdmin() external view returns (address);
+
+  /**
+   * @dev Getter of the current pending admin address
+   * @return The address of the pending admin
+   **/
+  function getPendingAdmin() external view returns (address);
+
+  /**
+   * @dev Getter of the delay between queuing and execution
+   * @return The delay in seconds
+   **/
+  function getDelay() external view returns (uint256);
+
+  /**
+   * @dev Returns whether an action (via actionHash) is queued
+   * @param actionHash hash of the action to be checked
+   * keccak256(abi.encode(target, value, signature, data, executionTime, withDelegatecall))
+   * @return true if underlying action of actionHash is queued
+   **/
+  function isActionQueued(bytes32 actionHash) external view returns (bool);
+
+  /**
+   * @dev Checks whether a proposal is over its grace period
+   * @param governance Governance contract
+   * @param proposalId Id of the proposal against which to test
+   * @return true of proposal is over grace period
+   **/
+  function isProposalOverGracePeriod(
+    address governance,
+    uint256 proposalId
+  ) external view returns (bool);
+
+  /**
+   * @dev Getter of grace period constant
+   * @return grace period in seconds
+   **/
+  function GRACE_PERIOD() external view returns (uint256);
+
+  function VOTING_DURATION() external view returns (uint256);
+
+  /**
+   * @dev Getter of minimum delay constant
+   * @return minimum delay in seconds
+   **/
+  function MINIMUM_DELAY() external view returns (uint256);
+
+  /**
+   * @dev Getter of maximum delay constant
+   * @return maximum delay in seconds
+   **/
+  function MAXIMUM_DELAY() external view returns (uint256);
+
+  /**
+   * @dev Function, called by Governance, that queue a transaction, returns action hash
+   * @param target smart contract target
+   * @param value wei value of the transaction
+   * @param signature function signature of the transaction
+   * @param data function arguments of the transaction or callData if signature empty
+   * @param executionTime time at which to execute the transaction
+   * @param withDelegatecall boolean, true = transaction delegatecalls the target, else calls the target
+   **/
+  function queueTransaction(
+    address target,
+    uint256 value,
+    string memory signature,
+    bytes memory data,
+    uint256 executionTime,
+    bool withDelegatecall
+  ) external returns (bytes32);
+
+  /**
+   * @dev Function, called by Governance, that cancels a transaction, returns the callData executed
+   * @param target smart contract target
+   * @param value wei value of the transaction
+   * @param signature function signature of the transaction
+   * @param data function arguments of the transaction or callData if signature empty
+   * @param executionTime time at which to execute the transaction
+   * @param withDelegatecall boolean, true = transaction delegatecalls the target, else calls the target
+   **/
+  function executeTransaction(
+    address target,
+    uint256 value,
+    string memory signature,
+    bytes memory data,
+    uint256 executionTime,
+    bool withDelegatecall
+  ) external payable returns (bytes memory);
+
+  /**
+   * @dev Function, called by Governance, that cancels a transaction, returns action hash
+   * @param target smart contract target
+   * @param value wei value of the transaction
+   * @param signature function signature of the transaction
+   * @param data function arguments of the transaction or callData if signature empty
+   * @param executionTime time at which to execute the transaction
+   * @param withDelegatecall boolean, true = transaction delegatecalls the target, else calls the target
+   **/
+  function cancelTransaction(
+    address target,
+    uint256 value,
+    string memory signature,
+    bytes memory data,
+    uint256 executionTime,
+    bool withDelegatecall
+  ) external returns (bytes32);
+}

package/src/common/IMigrationHelper.sol

@@ -0,0 +1,113 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {IPool as IV3Pool} from '../AaveV3.sol';
+import {ILendingPool as IV2Pool} from '../AaveV2.sol';
+import {ICreditDelegationToken} from 'aave-v3-origin/contracts/interfaces/ICreditDelegationToken.sol';
+import {IERC20WithPermit} from 'aave-v3-origin/contracts/interfaces/IERC20WithPermit.sol';
+
+interface IMigrationHelper {
+  struct PermitInput {
+    IERC20WithPermit aToken;
+    uint256 value;
+    uint256 deadline;
+    uint8 v;
+    bytes32 r;
+    bytes32 s;
+  }
+
+  struct CreditDelegationInput {
+    ICreditDelegationToken debtToken;
+    uint256 value;
+    uint256 deadline;
+    uint8 v;
+    bytes32 r;
+    bytes32 s;
+  }
+
+  struct RepayInput {
+    address asset;
+    uint256 amount;
+    uint256 rateMode;
+  }
+
+  struct RepaySimpleInput {
+    address asset;
+    uint256 rateMode;
+  }
+
+  struct EmergencyTransferInput {
+    IERC20WithPermit asset;
+    uint256 amount;
+    address to;
+  }
+
+  /**
+   * @notice Method to do migration of any types of positions. Migrating whole amount of specified assets
+   * @param assetsToMigrate - list of assets to migrate
+   * @param positionsToRepay - list of assets to be repayed
+   * @param permits - list of EIP712 permits, can be empty, if approvals provided in advance
+   * @param creditDelegationPermits - list of EIP712 signatures (credit delegations) for v3 variable debt token
+   * @dev check more details about permit at PermitInput and /solidity-utils/contracts/oz-common/interfaces/draft-IERC20Permit.sol
+   **/
+  function migrate(
+    address[] memory assetsToMigrate,
+    RepaySimpleInput[] memory positionsToRepay,
+    PermitInput[] memory permits,
+    CreditDelegationInput[] memory creditDelegationPermits
+  ) external;
+
+  /**
+   * @notice Executes an operation after receiving the flash-borrowed assets
+   * @dev Ensure that the contract can return the debt + premium, e.g., has
+   *      enough funds to repay and has approved the Pool to pull the total amount
+   * @param assets The addresses of the flash-borrowed assets
+   * @param amounts The amounts of the flash-borrowed assets
+   * @param premiums The fee of each flash-borrowed asset
+   * @param initiator The address of the flashloan initiator
+   * @param params The byte-encoded params passed when initiating the flashloan
+   * @return True if the execution of the operation succeeds, false otherwise
+   */
+  function executeOperation(
+    address[] calldata assets,
+    uint256[] calldata amounts,
+    uint256[] calldata premiums,
+    address initiator,
+    bytes calldata params
+  ) external returns (bool);
+
+  /**
+   * @notice Public method to optimize the gas costs, to avoid having getReserveData calls on every execution
+   **/
+  function cacheATokens() external;
+
+  /**
+   * @notice Method to get asset and amount to be supplied to V3
+   * @param asset the v2 pool asset
+   * @param amount origin amount
+   * @return address asset to be supplied to the v3 pool
+   * @return uint256 amount to be supplied to the v3 pool
+   */
+  function getMigrationSupply(
+    address asset,
+    uint256 amount
+  ) external view returns (address, uint256);
+
+  /// @notice The source pool
+  function V2_POOL() external returns (IV2Pool);
+
+  /// @notice The destination pool
+  function V3_POOL() external returns (IV3Pool);
+
+  /**
+   * @notice Public method for rescue funds in case of a wrong transfer
+   * @param emergencyInput - array of parameters to transfer out funds
+   **/
+  function rescueFunds(EmergencyTransferInput[] calldata emergencyInput) external;
+
+  function aTokens(address underlying) external returns (address);
+
+  function vTokens(address underlying) external returns (address);
+
+  function sTokens(address underlying) external returns (address);
+}

package/src/common/IOwnable.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.8;
+
+interface IOwnable {
+  event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
+
+  /**
+   * @dev Returns the address of the current owner.
+   */
+  function owner() external view returns (address);
+
+  /**
+   * @dev Leaves the contract without owner. It will not be possible to call
+   * `onlyOwner` functions anymore. Can only be called by the current owner.
+   *
+   * NOTE: Renouncing ownership will leave the contract without an owner,
+   * thereby removing any functionality that is only available to the owner.
+   */
+  function renounceOwnership() external;
+
+  /**
+   * @dev Transfers ownership of the contract to a new account (`newOwner`).
+   * Can only be called by the current owner.
+   */
+  function transferOwnership(address newOwner) external;
+}

package/src/common/IStakeToken.sol

@@ -0,0 +1,194 @@
+pragma solidity ^0.8.10;
+
+interface IStakeToken {
+  event Approval(address indexed owner, address indexed spender, uint256 value);
+  event AssetConfigUpdated(address indexed asset, uint256 emission);
+  event AssetIndexUpdated(address indexed asset, uint256 index);
+  event Cooldown(address indexed user, uint256 amount);
+  event CooldownSecondsChanged(uint256 cooldownSeconds);
+  event DistributionEndChanged(uint256 endTimestamp);
+  event EIP712DomainChanged();
+  event ExchangeRateChanged(uint216 exchangeRate);
+  event FundsReturned(uint256 amount);
+  event Initialized(uint64 version);
+  event MaxSlashablePercentageChanged(uint256 newPercentage);
+  event PendingAdminChanged(address indexed newPendingAdmin, uint256 role);
+  event Redeem(address indexed from, address indexed to, uint256 assets, uint256 shares);
+  event RewardsAccrued(address user, uint256 amount);
+  event RewardsClaimed(address indexed from, address indexed to, uint256 amount);
+  event RoleClaimed(address indexed newAdmin, uint256 role);
+  event Slashed(address indexed destination, uint256 amount);
+  event SlashingExitWindowDurationChanged(uint256 windowSeconds);
+  event SlashingSettled();
+  event Staked(address indexed from, address indexed to, uint256 assets, uint256 shares);
+  event Transfer(address indexed from, address indexed to, uint256 value);
+  event UserIndexUpdated(address indexed user, address indexed asset, uint256 index);
+
+  struct AssetConfigInput {
+    uint128 emissionPerSecond;
+    uint256 totalStaked;
+    address underlyingAsset;
+  }
+
+  function CLAIM_HELPER_ROLE() external view returns (uint256);
+
+  function COOLDOWN_ADMIN_ROLE() external view returns (uint256);
+
+  function DOMAIN_SEPARATOR() external view returns (bytes32);
+
+  function EMISSION_MANAGER() external view returns (address);
+
+  function EXCHANGE_RATE_UNIT() external view returns (uint256);
+
+  function INITIAL_EXCHANGE_RATE() external view returns (uint216);
+
+  function LOWER_BOUND() external view returns (uint256);
+
+  function PRECISION() external view returns (uint8);
+
+  function REWARDS_VAULT() external view returns (address);
+
+  function REWARD_TOKEN() external view returns (address);
+
+  function SLASH_ADMIN_ROLE() external view returns (uint256);
+
+  function STAKED_TOKEN() external view returns (address);
+
+  function UNSTAKE_WINDOW() external view returns (uint256);
+
+  function allowance(address owner, address spender) external view returns (uint256);
+
+  function approve(address spender, uint256 value) external returns (bool);
+
+  function assets(
+    address
+  ) external view returns (uint128 emissionPerSecond, uint128 lastUpdateTimestamp, uint256 index);
+
+  function balanceOf(address account) external view returns (uint256);
+
+  function claimRewards(address to, uint256 amount) external;
+
+  function claimRewardsAndRedeem(address to, uint256 claimAmount, uint256 redeemAmount) external;
+
+  function claimRewardsAndRedeemOnBehalf(
+    address from,
+    address to,
+    uint256 claimAmount,
+    uint256 redeemAmount
+  ) external;
+
+  function claimRewardsOnBehalf(
+    address from,
+    address to,
+    uint256 amount
+  ) external returns (uint256);
+
+  function claimRoleAdmin(uint256 role) external;
+
+  function configureAssets(AssetConfigInput[] memory assetsConfigInput) external;
+
+  function cooldown() external;
+
+  function cooldownOnBehalfOf(address from) external;
+
+  function decimals() external view returns (uint8);
+
+  function distributionEnd() external view returns (uint256);
+
+  function eip712Domain()
+    external
+    view
+    returns (
+      bytes1 fields,
+      string memory name,
+      string memory version,
+      uint256 chainId,
+      address verifyingContract,
+      bytes32 salt,
+      uint256[] memory extensions
+    );
+
+  function getAdmin(uint256 role) external view returns (address);
+
+  function getCooldownSeconds() external view returns (uint256);
+
+  function getExchangeRate() external view returns (uint216);
+
+  function getMaxSlashablePercentage() external view returns (uint256);
+
+  function getPendingAdmin(uint256 role) external view returns (address);
+
+  function getTotalRewardsBalance(address staker) external view returns (uint256);
+
+  function getUserAssetData(address user, address asset) external view returns (uint256);
+
+  function inPostSlashingPeriod() external view returns (bool);
+
+  function initialize(
+    string memory name,
+    string memory symbol,
+    address slashingAdmin,
+    address cooldownPauseAdmin,
+    address claimHelper,
+    uint256 maxSlashablePercentage,
+    uint256 cooldownSeconds
+  ) external;
+
+  function name() external view returns (string memory);
+
+  function nonces(address owner) external view returns (uint256);
+
+  function permit(
+    address owner,
+    address spender,
+    uint256 value,
+    uint256 deadline,
+    uint8 v,
+    bytes32 r,
+    bytes32 s
+  ) external;
+
+  function previewRedeem(uint256 shares) external view returns (uint256);
+
+  function previewStake(uint256 assets) external view returns (uint256);
+
+  function redeem(address to, uint256 amount) external;
+
+  function redeemOnBehalf(address from, address to, uint256 amount) external;
+
+  function returnFunds(uint256 amount) external;
+
+  function setCooldownSeconds(uint256 cooldownSeconds) external;
+
+  function setDistributionEnd(uint256 newDistributionEnd) external;
+
+  function setMaxSlashablePercentage(uint256 percentage) external;
+
+  function setPendingAdmin(uint256 role, address newPendingAdmin) external;
+
+  function settleSlashing() external;
+
+  function slash(address destination, uint256 amount) external returns (uint256);
+
+  function stake(address to, uint256 amount) external;
+
+  function stakeWithPermit(
+    uint256 amount,
+    uint256 deadline,
+    uint8 v,
+    bytes32 r,
+    bytes32 s
+  ) external;
+
+  function stakerRewardsToClaim(address) external view returns (uint256);
+
+  function stakersCooldowns(address) external view returns (uint40 timestamp, uint216 amount);
+
+  function symbol() external view returns (string memory);
+
+  function totalSupply() external view returns (uint256);
+
+  function transfer(address to, uint256 value) external returns (bool);
+
+  function transferFrom(address from, address to, uint256 value) external returns (bool);
+}

package/src/common/IStreamable.sol

@@ -0,0 +1,74 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.6.0;
+
+interface IStreamable {
+  struct Stream {
+    uint256 deposit;
+    uint256 ratePerSecond;
+    uint256 remainingBalance;
+    uint256 startTime;
+    uint256 stopTime;
+    address recipient;
+    address sender;
+    address tokenAddress;
+    bool isEntity;
+  }
+
+  event CreateStream(
+    uint256 indexed streamId,
+    address indexed sender,
+    address indexed recipient,
+    uint256 deposit,
+    address tokenAddress,
+    uint256 startTime,
+    uint256 stopTime
+  );
+
+  event WithdrawFromStream(uint256 indexed streamId, address indexed recipient, uint256 amount);
+
+  event CancelStream(
+    uint256 indexed streamId,
+    address indexed sender,
+    address indexed recipient,
+    uint256 senderBalance,
+    uint256 recipientBalance
+  );
+
+  function balanceOf(uint256 streamId, address who) external view returns (uint256 balance);
+
+  function getStream(
+    uint256 streamId
+  )
+    external
+    view
+    returns (
+      address sender,
+      address recipient,
+      uint256 deposit,
+      address token,
+      uint256 startTime,
+      uint256 stopTime,
+      uint256 remainingBalance,
+      uint256 ratePerSecond
+    );
+
+  function createStream(
+    address recipient,
+    uint256 deposit,
+    address tokenAddress,
+    uint256 startTime,
+    uint256 stopTime
+  ) external returns (uint256 streamId);
+
+  function withdrawFromStream(uint256 streamId, uint256 funds) external returns (bool);
+
+  function cancelStream(uint256 streamId) external returns (bool);
+
+  function initialize(address fundsAdmin) external;
+
+  /**
+   * @notice Returns the next available stream id
+   * @return nextStreamId Returns the stream id.
+   */
+  function getNextStreamId() external view returns (uint256);
+}