@usdu-core/usdu-core 0.0.1

package/contracts/morpho/helpers/PendingLib.sol

@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity ^0.8.0;
+
+struct MarketConfig {
+	/// @notice The maximum amount of assets that can be allocated to the market.
+	uint184 cap;
+	/// @notice Whether the market is in the withdraw queue.
+	bool enabled;
+	/// @notice The timestamp at which the market can be instantly removed from the withdraw queue.
+	uint64 removableAt;
+}
+
+struct PendingUint192 {
+	/// @notice The pending value to set.
+	uint192 value;
+	/// @notice The timestamp at which the pending value becomes valid.
+	uint64 validAt;
+}
+
+struct PendingAddress {
+	/// @notice The pending value to set.
+	address value;
+	/// @notice The timestamp at which the pending value becomes valid.
+	uint64 validAt;
+}
+
+/// @title PendingLib
+/// @author Morpho Labs
+/// @custom:contact security@morpho.org
+/// @notice Library to manage pending values and their validity timestamp.
+library PendingLib {
+	/// @dev Updates `pending`'s value to `newValue` and its corresponding `validAt` timestamp.
+	/// @dev Assumes `timelock` <= `MAX_TIMELOCK`.
+	function update(PendingUint192 storage pending, uint184 newValue, uint256 timelock) internal {
+		pending.value = newValue;
+		// Safe "unchecked" cast because timelock <= MAX_TIMELOCK.
+		pending.validAt = uint64(block.timestamp + timelock);
+	}
+
+	/// @dev Updates `pending`'s value to `newValue` and its corresponding `validAt` timestamp.
+	/// @dev Assumes `timelock` <= `MAX_TIMELOCK`.
+	function update(PendingAddress storage pending, address newValue, uint256 timelock) internal {
+		pending.value = newValue;
+		// Safe "unchecked" cast because timelock <= MAX_TIMELOCK.
+		pending.validAt = uint64(block.timestamp + timelock);
+	}
+}

package/contracts/morpho/helpers/SharesMathLib.sol

@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity ^0.8.0;
+
+import {MathLib} from './MathLib.sol';
+
+/// @title SharesMathLib
+/// @author Morpho Labs
+/// @custom:contact security@morpho.org
+/// @notice Shares management library.
+/// @dev This implementation mitigates share price manipulations, using OpenZeppelin's method of virtual shares:
+/// https://docs.openzeppelin.com/contracts/4.x/erc4626#inflation-attack.
+library SharesMathLib {
+	using MathLib for uint256;
+
+	/// @dev The number of virtual shares has been chosen low enough to prevent overflows, and high enough to ensure
+	/// high precision computations.
+	/// @dev Virtual shares can never be redeemed for the assets they are entitled to, but it is assumed the share price
+	/// stays low enough not to inflate these assets to a significant value.
+	/// @dev Warning: The assets to which virtual borrow shares are entitled behave like unrealizable bad debt.
+	uint256 internal constant VIRTUAL_SHARES = 1e6;
+
+	/// @dev A number of virtual assets of 1 enforces a conversion rate between shares and assets when a market is
+	/// empty.
+	uint256 internal constant VIRTUAL_ASSETS = 1;
+
+	/// @dev Calculates the value of `assets` quoted in shares, rounding down.
+	function toSharesDown(uint256 assets, uint256 totalAssets, uint256 totalShares) internal pure returns (uint256) {
+		return assets.mulDivDown(totalShares + VIRTUAL_SHARES, totalAssets + VIRTUAL_ASSETS);
+	}
+
+	/// @dev Calculates the value of `shares` quoted in assets, rounding down.
+	function toAssetsDown(uint256 shares, uint256 totalAssets, uint256 totalShares) internal pure returns (uint256) {
+		return shares.mulDivDown(totalAssets + VIRTUAL_ASSETS, totalShares + VIRTUAL_SHARES);
+	}
+
+	/// @dev Calculates the value of `assets` quoted in shares, rounding up.
+	function toSharesUp(uint256 assets, uint256 totalAssets, uint256 totalShares) internal pure returns (uint256) {
+		return assets.mulDivUp(totalShares + VIRTUAL_SHARES, totalAssets + VIRTUAL_ASSETS);
+	}
+
+	/// @dev Calculates the value of `shares` quoted in assets, rounding up.
+	function toAssetsUp(uint256 shares, uint256 totalAssets, uint256 totalShares) internal pure returns (uint256) {
+		return shares.mulDivUp(totalAssets + VIRTUAL_ASSETS, totalShares + VIRTUAL_SHARES);
+	}
+}

package/contracts/morpho/helpers/VaultLib.sol

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity ^0.8.0;
+
+import {IERC4626} from './IERC4626.sol';
+
+/// @title VaultLib
+/// @author Morpho Labs
+/// @custom:contact security@morpho.org
+/// @notice Library exposing functions to price shares of an ERC4626 vault.
+library VaultLib {
+	/// @dev Converts `shares` into the corresponding assets on the `vault`.
+	/// @dev When `vault` is the address zero, returns 1.
+	function getAssets(IERC4626 vault, uint256 shares) internal view returns (uint256) {
+		if (address(vault) == address(0)) return 1;
+
+		return vault.convertToAssets(shares);
+	}
+}

package/contracts/reward/RewardDistributionV1.sol

@@ -0,0 +1,110 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity ^0.8.20;
+
+import {Math} from '@openzeppelin/contracts/utils/math/Math.sol';
+
+import {IStablecoinModifier, Stablecoin} from '../stablecoin/IStablecoinModifier.sol';
+import {ErrorsLib} from '../stablecoin/libraries/ErrorsLib.sol';
+
+abstract contract RewardDistributionV1 is IStablecoinModifier {
+	using Math for uint256;
+
+	address[5] public receivers;
+	uint32[5] public weights;
+	uint256 public totalWeights;
+
+	address[5] public pendingReceivers;
+	uint32[5] public pendingWeights;
+	uint256 public pendingValidAt;
+
+	// ---------------------------------------------------------------------------------------
+
+	event SubmitDistribution(address indexed caller, address[5] receivers, uint32[5] weights, uint256 timelock);
+	event RevokeDistribution(address indexed caller);
+	event SetDistribution(address indexed caller);
+	event Distribution(address indexed receiver, uint256 amount, uint256 ratio);
+
+	// ---------------------------------------------------------------------------------------
+
+	constructor(Stablecoin _stable, address[5] memory _receivers, uint32[5] memory _weights) IStablecoinModifier(_stable) {
+		_setDistribution(_receivers, _weights);
+	}
+
+	// ---------------------------------------------------------------------------------------
+
+	function setDistribution(address[5] calldata _receivers, uint32[5] calldata _weights) external onlyCurator {
+		if (pendingValidAt != 0) revert ErrorsLib.AlreadyPending();
+
+		if (receivers[0] == address(0)) {
+			_setDistribution(_receivers, _weights);
+		} else {
+			pendingReceivers = _receivers;
+			pendingWeights = _weights;
+			pendingValidAt = block.timestamp + stable.timelock();
+			emit SubmitDistribution(_msgSender(), _receivers, _weights, pendingValidAt);
+		}
+	}
+
+	function revokePendingDistribution() external onlyCuratorOrGuardian {
+		if (pendingValidAt == 0) revert ErrorsLib.NoPendingValue();
+		emit RevokeDistribution(_msgSender());
+		_cleanUpPending();
+	}
+
+	function applyDistribution() external afterTimelock(pendingValidAt) {
+		_setDistribution(pendingReceivers, pendingWeights);
+	}
+
+	function _setDistribution(address[5] memory _receivers, uint32[5] memory _weights) internal {
+		// reset totalWeights
+		totalWeights = 0;
+
+		// update total weight
+		for (uint32 i = 0; i < 5; i++) {
+			if (_receivers[i] == address(0)) continue;
+			totalWeights += _weights[i];
+		}
+
+		// update distribution
+		receivers = _receivers;
+		weights = _weights;
+
+		// emit event
+		emit SetDistribution(_msgSender());
+
+		_cleanUpPending();
+	}
+
+	function _cleanUpPending() internal {
+		delete pendingReceivers;
+		delete pendingWeights;
+		delete pendingValidAt;
+	}
+
+	// ---------------------------------------------------------------------------------------
+
+	function _distribute() internal {
+		// distribute all stables
+		uint256 amount = stable.balanceOf(address(this));
+
+		// distribution is not available
+		if (totalWeights == 0 || amount == 0) return;
+
+		for (uint256 i = 0; i < 5; i++) {
+			address receiver = receivers[i];
+			uint256 weight = weights[i];
+
+			// end distribution
+			if (receiver == address(0)) return;
+
+			// distribute weighted split
+			uint256 split = (weight * amount) / totalWeights;
+
+			// distribute revenue split
+			stable.transfer(receiver, split);
+
+			// last weighted ratio might be inconsistant, due to remaining assets distribution
+			emit Distribution(receiver, split, (weight * 1 ether) / totalWeights);
+		}
+	}
+}

package/contracts/reward/RewardRouterV0.sol

@@ -0,0 +1,63 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity ^0.8.20;
+
+import {Math} from '@openzeppelin/contracts/utils/math/Math.sol';
+
+import {IERC20} from '@openzeppelin/contracts/token/ERC20/IERC20.sol';
+import {SafeERC20} from '@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol';
+
+import {IStablecoin} from '../stablecoin/IStablecoin.sol';
+
+/// @title RewardRouterV0 - Non-custodial Router
+/// @author @samclassix <samclassix@proton.me>, @wrytlabs <wrytlabs@proton.me>
+/// @notice This contract acts purely as a non-custodial router, helping connect on-chain deposits with the off-chain reward program.
+contract RewardRouterV0 {
+	using Math for uint256;
+	using SafeERC20 for IERC20;
+
+	// stable
+	IStablecoin public immutable stable;
+
+	// UniversalRewardsDistributor
+	address public immutable urd;
+
+	// signer -> token -> approved
+	mapping(address => mapping(address => uint256)) public approved;
+
+	// events
+	event SetApprove(address indexed signer, address indexed token, uint256 amount);
+	event Rewards(address indexed signer, address indexed token, uint256 amount);
+
+	// errors
+
+	error AllowanceTooLow();
+
+	// ---------------------------------------------------------------------------------------
+
+	constructor(IStablecoin _stable, address _urd) {
+		stable = _stable;
+		urd = _urd;
+	}
+
+	// ---------------------------------------------------------------------------------------
+
+	function setApprove(address signer, address token, uint256 amount) external {
+		stable.verifyCurator(msg.sender);
+		approved[signer][token] = amount;
+		emit SetApprove(signer, token, amount);
+	}
+
+	// ---------------------------------------------------------------------------------------
+
+	/// @dev This is a work around, since a signature is needed for the program.
+	// The contract immediately forwards the tokens to urd, avoiding custody.
+	/// @param token The token contract address
+	/// @param amount The amount to deposit
+	function deposit(address signer, address token, uint256 amount) external {
+		if (approved[signer][token] < amount) revert AllowanceTooLow();
+		approved[signer][token] -= amount;
+		IERC20(token).transfer(signer, amount);
+		IERC20(token).transferFrom(signer, urd, amount);
+		emit Rewards(signer, token, amount);
+	}
+}

package/contracts/reward/Rewards.example.json

@@ -0,0 +1,72 @@
+{
+	"domain": {
+		"name": "Morpho Rewards Hub",
+		"version": "1",
+		"chainId": 1
+	},
+	"types": {
+		"BaseProgramPayload": [
+			{
+				"name": "programType",
+				"type": "string"
+			},
+			{
+				"name": "fundsSender",
+				"type": "address"
+			},
+			{
+				"name": "start",
+				"type": "string"
+			},
+			{
+				"name": "end",
+				"type": "string"
+			},
+			{
+				"name": "targetChainId",
+				"type": "uint256"
+			},
+			{
+				"name": "distributorAddress",
+				"type": "address"
+			},
+			{
+				"name": "distributorChainId",
+				"type": "uint256"
+			},
+			{
+				"name": "assetAddress",
+				"type": "address"
+			}
+		],
+		"VaultProgramPayload": [
+			{
+				"name": "base",
+				"type": "BaseProgramPayload"
+			},
+			{
+				"name": "vault",
+				"type": "address"
+			},
+			{
+				"name": "amount",
+				"type": "string"
+			}
+		]
+	},
+	"primaryType": "VaultProgramPayload",
+	"message": {
+		"base": {
+			"programType": "vault-reward",
+			"fundsSender": "0x0170F42f224b99CcbbeE673093589c5f9691dd06",
+			"start": "1749945600",
+			"end": "1751241600",
+			"targetChainId": 1,
+			"distributorAddress": "0x330eefa8a787552dc5cad3c3ca644844b1e61ddb",
+			"distributorChainId": 1,
+			"assetAddress": "0xB58E61C3098d85632Df34EecfB899A1Ed80921cB"
+		},
+		"vault": "0xFa7ED49Eb24A6117D8a3168EEE69D26b45C40C63",
+		"amount": "10000000000000000"
+	}
+}

package/contracts/stablecoin/IStablecoin.sol

@@ -0,0 +1,211 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity ^0.8.20;
+
+import {IERC20} from '@openzeppelin/contracts/token/ERC20/IERC20.sol';
+
+interface IStablecoin is IERC20 {
+	// ---------------------------------------------------------------------------------------
+
+	/// @notice Checks if the given account has the curator role.
+	/// @param account The address to check.
+	/// @return True if the account is a curator, false otherwise.
+	function checkCurator(address account) external view returns (bool);
+
+	/// @notice Checks if the given account has the guardian role.
+	/// @param account The address to check.
+	/// @return True if the account is a guardian, false otherwise.
+	function checkGuardian(address account) external view returns (bool);
+
+	/// @notice Checks if the given account is either a curator or a guardian.
+	/// @param account The address to check.
+	/// @return True if the account is a curator or a guardian, false otherwise.
+	function checkCuratorOrGuardian(address account) external view returns (bool);
+
+	/// @notice Checks if the given account has any module role (active or expired).
+	/// @param account The address to check.
+	/// @return True if the account is a module, false otherwise.
+	function checkModule(address account) external view returns (bool);
+
+	/// @notice Checks if the given account is a valid (non-expired) module.
+	/// @param account The address to check.
+	/// @return True if the account is a valid module, false otherwise.
+	function checkValidModule(address account) external view returns (bool);
+
+	// ---------------------------------------------------------------------------------------
+
+	/// @notice Verifies that the given account is a curator.
+	/// @dev Reverts if the account is not a curator.
+	/// @param account The address to verify.
+	function verifyCurator(address account) external view;
+
+	/// @notice Verifies that the given account is a guardian.
+	/// @dev Reverts if the account is not a guardian.
+	/// @param account The address to verify.
+	function verifyGuardian(address account) external view;
+
+	/// @notice Verifies that the given account is either a curator or a guardian.
+	/// @dev Reverts if the account is neither a curator nor a guardian.
+	/// @param account The address to verify.
+	function verifyCuratorOrGuardian(address account) external view;
+
+	/// @notice Verifies that the given account has a module role (active or expired).
+	/// @dev Reverts if the account is not a module.
+	/// @param account The address to verify.
+	function verifyModule(address account) external view;
+
+	/// @notice Verifies that the given account is a valid (non-expired) module.
+	/// @dev Reverts if the account is not a valid module.
+	/// @param account The address to verify.
+	function verifyValidModule(address account) external view;
+
+	// ---------------------------------------------------------------------------------------
+
+	/// @notice Mints `value` tokens to address `to`.
+	/// @dev Callable only by addresses with the `validModule` role.
+	/// @param to The address receiving the minted tokens.
+	/// @param value The amount of tokens to mint.
+	/// @custom:role validModule
+	function mintModule(address to, uint256 value) external;
+
+	/// @notice Burns `amount` tokens from address `from`.
+	/// @dev Callable only by addresses with the `onlyModule` role.
+	/// @param from The address whose tokens will be burned.
+	/// @param amount The amount of tokens to burn.
+	/// @custom:role onlyModule
+	function burnModule(address from, uint256 amount) external;
+
+	/// @notice Burns `amount` tokens from the caller's balance.
+	/// @dev Publicly accessible by any user with sufficient balance.
+	/// @param amount The amount of tokens to burn.
+	/// @custom:role public
+	function burn(uint256 amount) external;
+
+	// ---------------------------------------------------------------------------------------
+
+	/// @notice Sets a new curator for the contract.
+	/// @dev Callable only by the current curator.
+	/// @param newCurator The address to assign as the new curator.
+	/// @custom:role onlyCurator
+	function setCurator(address newCurator) external;
+
+	/// @notice Publicly initiates a curator change by paying a fee.
+	/// @dev Caller must pay `fee`, which must be at least `ConstantsLib.PUBLIC_FEE * 10`.
+	/// @dev Applies a timelock that is twice as long
+	/// @param newCurator The address to be proposed as the new curator.
+	/// @param fee The fee amount submitted with the transaction.
+	/// @custom:rule claimPublicFee(fee, ConstantsLib.PUBLIC_FEE * 10)
+	function setCuratorPublic(address newCurator, uint256 fee) external;
+
+	/// @notice Cancels a pending curator proposal.
+	/// @dev Callable by either the current curator or a guardian.
+	/// @custom:role onlyCuratorOrGuardian
+	function revokePendingCurator() external;
+
+	/// @notice Accepts the curator role after the timelock period.
+	/// @dev Only new curator can accept the new role.
+	/// @dev Callable only after `pendingCurator.validAt` timestamp has passed.
+	/// @custom:rule afterTimelock(pendingCurator.validAt)
+	function acceptCurator() external;
+
+	// ---------------------------------------------------------------------------------------
+
+	/// @notice Sets a new guardian for the contract.
+	/// @dev Callable only by the current curator.
+	/// @param newGuardian The address to assign as the new guardian.
+	/// @custom:role onlyCurator
+	function setGuardian(address newGuardian) external;
+
+	/// @notice Cancels a pending guardian proposal.
+	/// @dev Callable by either the current curator or the current guardian.
+	/// @custom:role onlyCuratorOrGuardian
+	function revokePendingGuardian() external;
+
+	/// @notice Accepts the guardian role after the timelock period.
+	/// @dev Callable only after `pendingGuardian.validAt` timestamp has passed.
+	/// @custom:rule afterTimelock(pendingGuardian.validAt)
+	function acceptGuardian() external;
+
+	// ---------------------------------------------------------------------------------------
+
+	/// @notice Proposes a new timelock duration for sensitive actions.
+	/// @dev Callable only by the current curator.
+	/// @param newTimelock The new timelock duration (typically in seconds).
+	/// @custom:role onlyCurator
+	function setTimelock(uint256 newTimelock) external;
+
+	/// @notice Cancels a pending timelock change.
+	/// @dev Callable by either the curator or the guardian.
+	/// @custom:role onlyCuratorOrGuardian
+	function revokePendingTimelock() external;
+
+	/// @notice Finalizes the timelock change after the delay period.
+	/// @dev Callable only after `pendingTimelock.validAt` has passed.
+	/// @custom:rule afterTimelock(pendingTimelock.validAt)
+	function acceptTimelock() external;
+
+	// ---------------------------------------------------------------------------------------
+
+	/// @notice Proposes a new module with an expiration time and message.
+	/// @dev Callable only by the curator.
+	/// @param module The address of the module to config.
+	/// @param expiredAt The timestamp when the module should expire.
+	/// @param message A message describing the module purpose or context.
+	/// @custom:role onlyCurator
+	function setModule(address module, uint256 expiredAt, string calldata message) external;
+
+	/// @notice Publicly proposes a new module by paying a fee.
+	/// @dev Requires a fee at least equal to `ConstantsLib.PUBLIC_FEE`.
+	/// @dev Applies a timelock that is twice as long
+	/// @param module The address of the module to config.
+	/// @param expiredAt The timestamp when the module should expire.
+	/// @param message A message describing the module purpose or context.
+	/// @param fee The fee amount submitted with the transaction.
+	/// @custom:rule claimPublicFee(fee, ConstantsLib.PUBLIC_FEE)
+	function setModulePublic(address module, uint256 expiredAt, string calldata message, uint256 fee) external;
+
+	/// @notice Cancels a pending module proposal.
+	/// @dev Callable by either the curator or the guardian.
+	/// @param module The address of the module to revoke.
+	/// @param message A message explaining the revocation.
+	/// @custom:role onlyCuratorOrGuardian
+	function revokePendingModule(address module, string calldata message) external;
+
+	/// @notice Finalizes the addition of a module after the timelock period.
+	/// @dev Callable only after `pendingModules[module].validAt` has passed.
+	/// @param module The address of the module to accept.
+	/// @custom:rule afterTimelock(pendingModules[module].validAt)
+	function acceptModule(address module) external;
+
+	// ---------------------------------------------------------------------------------------
+
+	/// @notice Freezes the specified account, typically to restrict actions like transfers or module usage.
+	/// @dev Callable only by the curator.
+	/// @param account The address to be frozen.
+	/// @param message A message explaining the reason for freezing the account.
+	/// @custom:role onlyCurator
+	function setFreeze(address account, string calldata message) external;
+
+	// ---------------------------------------------------------------------------------------
+
+	/// @notice Initiates the unfreezing of a frozen account.
+	/// @dev Callable by either the curator or the guardian.
+	/// @param account The address to be unfrozen.
+	/// @param message A message explaining the reason for unfreezing.
+	/// @custom:role onlyCuratorOrGuardian
+	function setUnfreeze(address account, string calldata message) external;
+
+	/// @notice Cancels a pending unfreeze request.
+	/// @dev Callable by either the curator or the guardian.
+	/// @param account The address whose unfreeze request is being revoked.
+	/// @param message A message explaining the revocation.
+	/// @custom:role onlyCuratorOrGuardian
+	function revokePendingUnfreeze(address account, string calldata message) external;
+
+	/// @notice Finalizes the unfreezing of an account after the timelock period.
+	/// @dev Callable only after `pendingUnfreeze[account].validAt` has passed.
+	/// @param account The address to unfreeze.
+	/// @custom:rule afterTimelock(pendingUnfreeze[account].validAt)
+	function acceptUnfreeze(address account) external;
+
+	// ---------------------------------------------------------------------------------------
+}

package/contracts/stablecoin/IStablecoinMetadata.sol

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity ^0.8.20;
+
+import {IStablecoin} from './IStablecoin.sol';
+import {PendingLib, PendingUint192, PendingAddress} from './libraries/PendingLib.sol';
+
+interface IStablecoinMetadata is IStablecoin {
+	function curator() external view returns (address);
+
+	function pendingCurator() external view returns (PendingAddress memory);
+
+	function guardian() external view returns (address);
+
+	function pendingGuardian() external view returns (PendingAddress memory);
+
+	function timelock() external view returns (uint256);
+
+	function pendingTimelock() external view returns (PendingUint192 memory);
+
+	function modules(address module) external view returns (uint256);
+
+	function pendingModules(address module) external view returns (PendingUint192 memory);
+
+	function unfreeze(address account) external view returns (uint256);
+
+	function pendingUnfreeze(address account) external view returns (PendingUint192 memory);
+}

package/contracts/stablecoin/IStablecoinModifier.sol

@@ -0,0 +1,52 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity ^0.8.20;
+
+import {Context} from '@openzeppelin/contracts/utils/Context.sol';
+
+import {Stablecoin} from './Stablecoin.sol';
+import {ErrorsLib} from './libraries/ErrorsLib.sol';
+
+abstract contract IStablecoinModifier is Context {
+	Stablecoin public immutable stable;
+
+	modifier onlyCurator() {
+		stable.verifyCurator(_msgSender());
+		_;
+	}
+
+	modifier onlyGuardian() {
+		stable.verifyGuardian(_msgSender());
+		_;
+	}
+
+	modifier onlyCuratorOrGuardian() {
+		stable.verifyCuratorOrGuardian(_msgSender());
+		_;
+	}
+
+	modifier onlyModule() {
+		stable.verifyModule(_msgSender());
+		_;
+	}
+
+	modifier validModule() {
+		stable.verifyValidModule(_msgSender());
+		_;
+	}
+
+	modifier afterTimelock(uint256 validAt) {
+		if (validAt == 0) revert ErrorsLib.NoPendingValue();
+		if (block.timestamp < validAt) revert ErrorsLib.TimelockNotElapsed();
+		_;
+	}
+
+	modifier claimPublicFee(uint256 fee, uint256 min) {
+		if (fee < min) revert ErrorsLib.ProposalFeeToLow(min);
+		stable.transferFrom(_msgSender(), stable.curator(), fee);
+		_;
+	}
+
+	constructor(Stablecoin _stable) {
+		stable = _stable;
+	}
+}