@hyperlane-xyz/core 5.12.0-ccip.2 → 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.12.0-ccip.1";
+    string public constant PACKAGE_VERSION = "5.12.0";
 }

package/contracts/test/ERC20Test.sol

@@ -3,9 +3,11 @@ 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 {
@@ -109,6 +111,151 @@ contract XERC20Test is ERC20Test, Ownable, 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;