@hyperlane-xyz/core 5.12.0-ccip.1 → 5.12.0

package/contracts/PackageVersioned.sol

@@ -7,5 +7,5 @@ pragma solidity >=0.6.11;
  **/
 abstract contract PackageVersioned {
     // GENERATED CODE - DO NOT EDIT
-    string public constant PACKAGE_VERSION = "5.11.3";
+    string public constant PACKAGE_VERSION = "5.12.0";
 }

package/contracts/libs/RateLimitMidpointCommonLibrary.sol

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: BSD-3.0
+pragma solidity >=0.8.19 <0.9.0;
+
+/// @notice two rate storage slots per rate limit
+struct RateLimitMidPoint {
+    //// -------------------------------------------- ////
+    //// ------------------ SLOT 0 ------------------ ////
+    //// -------------------------------------------- ////
+    /// @notice the rate per second for this contract
+    uint128 rateLimitPerSecond;
+    /// @notice the cap of the buffer that can be used at once
+    uint112 bufferCap;
+    //// -------------------------------------------- ////
+    //// ------------------ SLOT 1 ------------------ ////
+    //// -------------------------------------------- ////
+    /// @notice the last time the buffer was used by the contract
+    uint32 lastBufferUsedTime;
+    /// @notice the buffer at the timestamp of lastBufferUsedTime
+    uint112 bufferStored;
+    /// @notice the mid point of the buffer
+    uint112 midPoint;
+}

package/contracts/test/ERC20Test.sol

@@ -2,9 +2,12 @@
 pragma solidity >=0.8.0;
 
 import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import "@openzeppelin/contracts/access/Ownable.sol";
+import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
 
 import "../token/interfaces/IXERC20Lockbox.sol";
 import "../token/interfaces/IXERC20.sol";
+import "../token/interfaces/IXERC20VS.sol";
 import "../token/interfaces/IFiatToken.sol";
 
 contract ERC20Test is ERC20 {
@@ -55,13 +58,17 @@ contract FiatTokenTest is ERC20Test, IFiatToken {
     }
 }
 
-contract XERC20Test is ERC20Test, IXERC20 {
+contract XERC20Test is ERC20Test, Ownable, IXERC20 {
     constructor(
         string memory name,
         string memory symbol,
         uint256 totalSupply,
         uint8 __decimals
-    ) ERC20Test(name, symbol, totalSupply, __decimals) {}
+    ) ERC20Test(name, symbol, totalSupply, __decimals) Ownable() {}
+
+    function initialize() external {
+        _transferOwnership(msg.sender);
+    }
 
     function mint(address account, uint256 amount) public override {
         _mint(account, amount);
@@ -75,8 +82,8 @@ contract XERC20Test is ERC20Test, IXERC20 {
         assert(false);
     }
 
-    function owner() external pure returns (address) {
-        return address(0x0);
+    function owner() public view override(Ownable, IXERC20) returns (address) {
+        return Ownable.owner();
     }
 
     function burningCurrentLimitOf(
@@ -104,6 +111,151 @@ contract XERC20Test is ERC20Test, IXERC20 {
     }
 }
 
+contract XERC20VSTest is ERC20Test, Ownable, IXERC20VS {
+    event ConfigurationChanged(
+        address indexed bridge,
+        uint112 bufferCap,
+        uint128 rateLimitPerSecond
+    );
+
+    mapping(address bridge => RateLimitMidPoint bridgeRateLimit)
+        internal _rateLimits;
+
+    constructor(
+        string memory name,
+        string memory symbol,
+        uint256 totalSupply,
+        uint8 __decimals
+    ) ERC20Test(name, symbol, totalSupply, __decimals) Ownable() {
+        _transferOwnership(msg.sender);
+    }
+
+    function initialize() external {
+        _transferOwnership(msg.sender);
+    }
+
+    function owner() public view override(Ownable) returns (address) {
+        return Ownable.owner();
+    }
+
+    function lockbox() external view override returns (address) {
+        return address(0);
+    }
+
+    function rateLimits(
+        address _bridge
+    ) external view override returns (RateLimitMidPoint memory _rateLimit) {
+        return _rateLimits[_bridge];
+    }
+
+    function mintingMaxLimitOf(
+        address _bridge
+    ) external view returns (uint256) {
+        return _rateLimits[_bridge].bufferCap;
+    }
+
+    function burningMaxLimitOf(
+        address _bridge
+    ) external view returns (uint256) {
+        return _rateLimits[_bridge].bufferCap;
+    }
+
+    function burningCurrentLimitOf(
+        address _bridge
+    ) external view returns (uint256) {
+        return _rateLimits[_bridge].bufferCap - _buffer(_rateLimits[_bridge]);
+    }
+
+    function mintingCurrentLimitOf(
+        address _bridge
+    ) external view returns (uint256) {
+        return _buffer(_rateLimits[_bridge]);
+    }
+
+    function mint(address account, uint256 amount) public override {
+        _mint(account, amount);
+    }
+
+    function burn(address account, uint256 amount) public override {
+        _burn(account, amount);
+    }
+
+    function setBufferCap(
+        address _bridge,
+        uint256 _newBufferCap
+    ) external override {}
+
+    function setRateLimitPerSecond(
+        address _bridge,
+        uint128 _newRateLimitPerSecond
+    ) external override {}
+
+    function addBridge(
+        RateLimitMidPointInfo memory rateLimit
+    ) external onlyOwner {
+        _rateLimits[rateLimit.bridge] = RateLimitMidPoint({
+            bufferCap: rateLimit.bufferCap,
+            lastBufferUsedTime: uint32(block.timestamp),
+            bufferStored: uint112(rateLimit.bufferCap / 2),
+            midPoint: uint112(rateLimit.bufferCap / 2),
+            rateLimitPerSecond: rateLimit.rateLimitPerSecond
+        });
+
+        emit ConfigurationChanged(
+            rateLimit.bridge,
+            rateLimit.bufferCap,
+            rateLimit.rateLimitPerSecond
+        );
+    }
+
+    function removeBridge(address _bridge) external override {
+        delete _rateLimits[_bridge];
+    }
+
+    function _buffer(
+        RateLimitMidPoint storage limit
+    ) internal view returns (uint256) {
+        uint256 elapsed;
+        unchecked {
+            elapsed = uint32(block.timestamp) - limit.lastBufferUsedTime;
+        }
+
+        uint256 accrued = uint256(limit.rateLimitPerSecond) * elapsed;
+        if (limit.bufferStored < limit.midPoint) {
+            return
+                Math.min(
+                    uint256(limit.bufferStored) + accrued,
+                    uint256(limit.midPoint)
+                );
+        } else if (limit.bufferStored > limit.midPoint) {
+            /// past midpoint so subtract accrued off bufferStored back down to midpoint
+
+            /// second part of if statement will not be evaluated if first part is true
+            if (
+                accrued > limit.bufferStored ||
+                limit.bufferStored - accrued < limit.midPoint
+            ) {
+                /// if accrued is more than buffer stored, subtracting will underflow,
+                /// and we are at the midpoint, so return that
+                return limit.midPoint;
+            } else {
+                return limit.bufferStored - accrued;
+            }
+        } else {
+            /// no change
+            return limit.bufferStored;
+        }
+    }
+
+    function rateLimitPerSecond(address from) public view returns (uint256) {
+        return _rateLimits[from].rateLimitPerSecond;
+    }
+
+    function bufferCap(address from) public view returns (uint256) {
+        return _rateLimits[from].bufferCap;
+    }
+}
+
 contract XERC20LockboxTest is IXERC20Lockbox {
     IXERC20 public immutable XERC20;
     IERC20 public immutable ERC20;

package/contracts/token/interfaces/IXERC20VS.sol

@@ -0,0 +1,96 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {RateLimitMidPoint} from "../../libs/RateLimitMidpointCommonLibrary.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+interface IXERC20VS is IERC20 {
+    /// @notice Emits when a limit is set
+    /// @param _bridge The address of the bridge we are setting the limit to
+    /// @param _bufferCap The updated buffer cap for the bridge
+    event BridgeLimitsSet(address indexed _bridge, uint256 _bufferCap);
+
+    struct RateLimitMidPointInfo {
+        /// @notice the buffer cap for this bridge
+        uint112 bufferCap;
+        /// @notice the rate limit per second for this bridge
+        uint128 rateLimitPerSecond;
+        /// @notice the bridge address
+        address bridge;
+    }
+
+    /// @notice The address of the lockbox contract
+    function lockbox() external view returns (address);
+
+    /// @notice Maps bridge address to bridge rate limits
+    /// @param _bridge The bridge we are viewing the limits of
+    /// @return _rateLimit The limits of the bridge
+    function rateLimits(
+        address _bridge
+    ) external view returns (RateLimitMidPoint memory _rateLimit);
+
+    /// @notice Returns the max limit of a bridge
+    /// @param _bridge The bridge we are viewing the limits of
+    /// @return _limit The limit the bridge has
+    function mintingMaxLimitOf(
+        address _bridge
+    ) external view returns (uint256 _limit);
+
+    /// @notice Returns the max limit of a bridge
+    /// @param _bridge the bridge we are viewing the limits of
+    /// @return _limit The limit the bridge has
+    function burningMaxLimitOf(
+        address _bridge
+    ) external view returns (uint256 _limit);
+
+    /// @notice Returns the current limit of a bridge
+    /// @param _bridge The bridge we are viewing the limits of
+    /// @return _limit The limit the bridge has
+    function mintingCurrentLimitOf(
+        address _bridge
+    ) external view returns (uint256 _limit);
+
+    /// @notice Returns the current limit of a bridge
+    /// @param _bridge the bridge we are viewing the limits of
+    /// @return _limit The limit the bridge has
+    function burningCurrentLimitOf(
+        address _bridge
+    ) external view returns (uint256 _limit);
+
+    /// @notice Mints tokens for a user
+    /// @dev Can only be called by a bridge
+    /// @param _user The address of the user who needs tokens minted
+    /// @param _amount The amount of tokens being minted
+    function mint(address _user, uint256 _amount) external;
+
+    /// @notice Burns tokens for a user
+    /// @dev Can only be called by a bridge
+    /// @param _user The address of the user who needs tokens burned
+    /// @param _amount The amount of tokens being burned
+    function burn(address _user, uint256 _amount) external;
+
+    /// @notice Conform to the xERC20 setLimits interface
+    /// @dev Can only be called if the bridge already has a buffer cap
+    /// @param _bridge The bridge we are setting the limits of
+    /// @param _newBufferCap The new buffer cap, uint112 max for unlimited
+    function setBufferCap(address _bridge, uint256 _newBufferCap) external;
+
+    /// @notice Sets rate limit per second for a bridge
+    /// @dev Can only be called if the bridge already has a buffer cap
+    /// @param _bridge The bridge we are setting the limits of
+    /// @param _newRateLimitPerSecond The new rate limit per second
+    function setRateLimitPerSecond(
+        address _bridge,
+        uint128 _newRateLimitPerSecond
+    ) external;
+
+    /// @notice Adds a new bridge to the currently active bridges
+    /// @param _newBridge The bridge to add
+    function addBridge(RateLimitMidPointInfo memory _newBridge) external;
+
+    /// @notice Removes a bridge from the currently active bridges
+    /// deleting its buffer stored, buffer cap, mid point and last
+    /// buffer used time
+    /// @param _bridge The bridge to remove
+    function removeBridge(address _bridge) external;
+}