Note: Our ether balance display is temporarily unavailable. Please check back later.
Source Code
Overview
ETH Balance
Ether balance is temporarily unavailable. Please check back later.
More Info
ContractCreator
Multichain Info
N/A
Latest 1 from a total of 1 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
Value | ||||
---|---|---|---|---|---|---|---|---|---|
0x6114ca61 | 8636711 | 383 days ago | IN | Create: ERC20FixedRewardModuleInfo | 0 ETH | 0.06927158 |
Loading...
Loading
Contract Name:
ERC20FixedRewardModuleInfo
Compiler Version
v0.8.18+commit.87f61d96
Optimization Enabled:
Yes with 10000 runs
Other Settings:
default evmVersion
Contract Source Code (Solidity Standard Json-Input format)
/* ERC20FixedRewardModuleInfo https://github.com/gysr-io/core SPDX-License-Identifier: MIT */ pragma solidity 0.8.18; import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol"; import "../interfaces/IRewardModule.sol"; import "../ERC20FixedRewardModule.sol"; /** * @title ERC20 fixed reward module info library * * @notice this library provides read-only convenience functions to query * additional information about the ERC20FixedRewardModule contract. */ library ERC20FixedRewardModuleInfo { /** * @notice get all token metadata * @param module address of reward module * @return addresses_ * @return names_ * @return symbols_ * @return decimals_ */ function tokens( address module ) external view returns ( address[] memory addresses_, string[] memory names_, string[] memory symbols_, uint8[] memory decimals_ ) { addresses_ = new address[](1); names_ = new string[](1); symbols_ = new string[](1); decimals_ = new uint8[](1); (addresses_[0], names_[0], symbols_[0], decimals_[0]) = token(module); } /** * @notice convenience function to get token metadata in a single call * @param module address of reward module * @return address * @return name * @return symbol * @return decimals */ function token( address module ) public view returns (address, string memory, string memory, uint8) { IRewardModule m = IRewardModule(module); IERC20Metadata tkn = IERC20Metadata(m.tokens()[0]); return (address(tkn), tkn.name(), tkn.symbol(), tkn.decimals()); } /** * @notice generic function to get pending reward balances * @param module address of reward module * @param account bytes32 account of interest for preview * @param shares number of shares that would be used * @return rewards_ estimated reward balances */ function rewards( address module, bytes32 account, uint256 shares, bytes calldata ) public view returns (uint256[] memory rewards_) { rewards_ = new uint256[](1); (rewards_[0], ) = preview(module, account); } /** * @notice preview estimated rewards * @param module address of reward module * @param account bytes32 account of interest for preview * @return estimated reward * @return estimated time vesting coefficient */ function preview( address module, bytes32 account ) public view returns (uint256, uint256) { ERC20FixedRewardModule m = ERC20FixedRewardModule(module); ( uint256 shares, uint256 vested, uint256 earned, uint128 timestamp, uint128 updated ) = m.positions(account); uint256 r = earned; { uint256 end = timestamp + m.period(); uint256 dt = (block.timestamp < end ? block.timestamp : end) - updated; r += ((((shares - vested) * dt) / m.period()) * m.rate()) / 1e18; } if (r == 0) return (0, 0); // convert to tokens { IERC20 tkn = IERC20(m.tokens()[0]); r = (r * tkn.balanceOf(module)) / m.rewards(); } // get vesting coeff uint256 v = 1e18; if (block.timestamp < timestamp + m.period()) v = ((block.timestamp - timestamp) * 1e18) / m.period(); return (r, v); } /** * @notice get effective budget * @param module address of reward module * @return estimated budget in debt shares */ function budget(address module) public view returns (uint256) { ERC20FixedRewardModule m = ERC20FixedRewardModule(module); return m.rewards() - m.debt(); } /** * @notice check potential increase in staking shares for sufficient budget * @param module address of reward module * @param shares number of shares to be staked * @return okay if stake amount is within budget for time period * @return estimated debt shares allocated * @return remaining total debt shares */ function validate( address module, uint256 shares ) public view returns (bool, uint256, uint256) { ERC20FixedRewardModule m = ERC20FixedRewardModule(module); uint256 reward = (shares * m.rate()) / 1e18; uint256 budget_ = budget(module); if (reward > budget_) return (false, reward, 0); return (true, reward, budget_ - reward); } /** * @notice get withdrawable excess budget * @param module address of reward module * @return withdrawable budget in tokens */ function withdrawable(address module) public view returns (uint256) { ERC20FixedRewardModule m = ERC20FixedRewardModule(module); IERC20 tkn = IERC20(m.tokens()[0]); return (budget(module) * tkn.balanceOf(module)) / m.rewards(); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612]. * * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't * need to send a transaction, and thus is not required to hold Ether at all. */ interface IERC20Permit { /** * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens, * given ``owner``'s signed approval. * * IMPORTANT: The same issues {IERC20-approve} has related to transaction * ordering also apply here. * * Emits an {Approval} event. * * Requirements: * * - `spender` cannot be the zero address. * - `deadline` must be a timestamp in the future. * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner` * over the EIP712-formatted function arguments. * - the signature must use ``owner``'s current nonce (see {nonces}). * * For more information on the signature format, see the * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP * section]. */ function permit( address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) external; /** * @dev Returns the current nonce for `owner`. This value must be * included whenever a signature is generated for {permit}. * * Every successful call to {permit} increases ``owner``'s nonce by one. This * prevents a signature from being used multiple times. */ function nonces(address owner) external view returns (uint256); /** * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}. */ // solhint-disable-next-line func-name-mixedcase function DOMAIN_SEPARATOR() external view returns (bytes32); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol) pragma solidity ^0.8.0; import "../IERC20.sol"; /** * @dev Interface for the optional metadata functions from the ERC20 standard. * * _Available since v4.1._ */ interface IERC20Metadata is IERC20 { /** * @dev Returns the name of the token. */ function name() external view returns (string memory); /** * @dev Returns the symbol of the token. */ function symbol() external view returns (string memory); /** * @dev Returns the decimals places of the token. */ function decimals() external view returns (uint8); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC20 standard as defined in the EIP. */ interface IERC20 { /** * @dev Emitted when `value` tokens are moved from one account (`from`) to * another (`to`). * * Note that `value` may be zero. */ event Transfer(address indexed from, address indexed to, uint256 value); /** * @dev Emitted when the allowance of a `spender` for an `owner` is set by * a call to {approve}. `value` is the new allowance. */ event Approval(address indexed owner, address indexed spender, uint256 value); /** * @dev Returns the amount of tokens in existence. */ function totalSupply() external view returns (uint256); /** * @dev Returns the amount of tokens owned by `account`. */ function balanceOf(address account) external view returns (uint256); /** * @dev Moves `amount` tokens from the caller's account to `to`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address to, uint256 amount) external returns (bool); /** * @dev Returns the remaining number of tokens that `spender` will be * allowed to spend on behalf of `owner` through {transferFrom}. This is * zero by default. * * This value changes when {approve} or {transferFrom} are called. */ function allowance(address owner, address spender) external view returns (uint256); /** * @dev Sets `amount` as the allowance of `spender` over the caller's tokens. * * Returns a boolean value indicating whether the operation succeeded. * * IMPORTANT: Beware that changing an allowance with this method brings the risk * that someone may use both the old and the new allowance by unfortunate * transaction ordering. One possible solution to mitigate this race * condition is to first reduce the spender's allowance to 0 and set the * desired value afterwards: * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 * * Emits an {Approval} event. */ function approve(address spender, uint256 amount) external returns (bool); /** * @dev Moves `amount` tokens from `from` to `to` using the * allowance mechanism. `amount` is then deducted from the caller's * allowance. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transferFrom( address from, address to, uint256 amount ) external returns (bool); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.7.0) (token/ERC20/utils/SafeERC20.sol) pragma solidity ^0.8.0; import "../IERC20.sol"; import "../extensions/draft-IERC20Permit.sol"; import "../../../utils/Address.sol"; /** * @title SafeERC20 * @dev Wrappers around ERC20 operations that throw on failure (when the token * contract returns false). Tokens that return no value (and instead revert or * throw on failure) are also supported, non-reverting calls are assumed to be * successful. * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract, * which allows you to call the safe operations as `token.safeTransfer(...)`, etc. */ library SafeERC20 { using Address for address; function safeTransfer( IERC20 token, address to, uint256 value ) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } function safeTransferFrom( IERC20 token, address from, address to, uint256 value ) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); } /** * @dev Deprecated. This function has issues similar to the ones found in * {IERC20-approve}, and its usage is discouraged. * * Whenever possible, use {safeIncreaseAllowance} and * {safeDecreaseAllowance} instead. */ function safeApprove( IERC20 token, address spender, uint256 value ) internal { // safeApprove should only be called when setting an initial allowance, // or when resetting it to zero. To increase and decrease it, use // 'safeIncreaseAllowance' and 'safeDecreaseAllowance' require( (value == 0) || (token.allowance(address(this), spender) == 0), "SafeERC20: approve from non-zero to non-zero allowance" ); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); } function safeIncreaseAllowance( IERC20 token, address spender, uint256 value ) internal { uint256 newAllowance = token.allowance(address(this), spender) + value; _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function safeDecreaseAllowance( IERC20 token, address spender, uint256 value ) internal { unchecked { uint256 oldAllowance = token.allowance(address(this), spender); require(oldAllowance >= value, "SafeERC20: decreased allowance below zero"); uint256 newAllowance = oldAllowance - value; _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } } function safePermit( IERC20Permit token, address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) internal { uint256 nonceBefore = token.nonces(owner); token.permit(owner, spender, value, deadline, v, r, s); uint256 nonceAfter = token.nonces(owner); require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed"); } /** * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement * on the return value: the return value is optional (but if data is returned, it must not be false). * @param token The token targeted by the call. * @param data The call data (encoded using abi.encode or one of its variants). */ function _callOptionalReturn(IERC20 token, bytes memory data) private { // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that // the target address contains contract code and also asserts for success in the low-level call. bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed"); if (returndata.length > 0) { // Return data is optional require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol) pragma solidity ^0.8.1; /** * @dev Collection of functions related to the address type */ library Address { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * ==== * * [IMPORTANT] * ==== * You shouldn't rely on `isContract` to protect against flash loan attacks! * * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract * constructor. * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize/address.code.length, which returns 0 // for contracts in construction, since the code is only stored at the end // of the constructor execution. return account.code.length > 0; } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); (bool success, ) = recipient.call{value: amount}(""); require(success, "Address: unable to send value, recipient may have reverted"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain `call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value ) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value, string memory errorMessage ) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); require(isContract(target), "Address: call to non-contract"); (bool success, bytes memory returndata) = target.call{value: value}(data); return verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall( address target, bytes memory data, string memory errorMessage ) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); (bool success, bytes memory returndata) = target.staticcall(data); return verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { require(isContract(target), "Address: delegate call to non-contract"); (bool success, bytes memory returndata) = target.delegatecall(data); return verifyCallResult(success, returndata, errorMessage); } /** * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the * revert reason using the provided one. * * _Available since v4.3._ */ function verifyCallResult( bool success, bytes memory returndata, string memory errorMessage ) internal pure returns (bytes memory) { if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly /// @solidity memory-safe-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } }
/* ERC20FixedRewardModule https://github.com/gysr-io/core SPDX-License-Identifier: MIT */ pragma solidity 0.8.18; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import "./interfaces/IRewardModule.sol"; import "./interfaces/IConfiguration.sol"; import "./OwnerController.sol"; import "./TokenUtils.sol"; /** * @title ERC20 fixed reward module * * @notice this reward module distributes a fixed amount of a single ERC20 token. * * @dev the fixed reward module provides a guarantee that some amount of tokens * will be earned over a specified time period. This can be used to create * incentive mechanisms such as bond sales, fixed duration payroll, and more. */ contract ERC20FixedRewardModule is IRewardModule, OwnerController { using SafeERC20 for IERC20; using TokenUtils for IERC20; // user position struct Position { uint256 shares; uint256 vested; uint256 earned; uint128 timestamp; uint128 updated; } // configuration fields uint256 public immutable period; uint256 public immutable rate; IERC20 private immutable _token; address private immutable _factory; IConfiguration private immutable _config; // state fields mapping(bytes32 => Position) public positions; uint256 public rewards; uint256 public debt; /** * @param token_ the token that will be rewarded * @param period_ time period (seconds) * @param rate_ constant reward rate (shares / share second) * @param config_ address for configuration contract * @param factory_ address of module factory */ constructor( address token_, uint256 period_, uint256 rate_, address config_, address factory_ ) { require(token_ != address(0)); require(period_ > 0, "xrm1"); require(rate_ > 0, "xrm2"); _token = IERC20(token_); _config = IConfiguration(config_); _factory = factory_; period = period_; rate = rate_; } // -- IRewardModule ------------------------------------------------------- /** * @inheritdoc IRewardModule */ function tokens() external view override returns (address[] memory tokens_) { tokens_ = new address[](1); tokens_[0] = address(_token); } /** * @inheritdoc IRewardModule */ function balances() external view override returns (uint256[] memory balances_) { balances_ = new uint256[](1); if (rewards > 0) { balances_[0] = (_token.balanceOf(address(this)) * (rewards - debt)) / rewards; } } /** * @inheritdoc IRewardModule */ function usage() external pure override returns (uint256) { return 0; } /** * @inheritdoc IRewardModule */ function factory() external view override returns (address) { return _factory; } /** * @inheritdoc IRewardModule * * @dev additional stake will bookmark earnings and rollover remainder to new unvested position */ function stake( bytes32 account, address, uint256 shares, bytes calldata ) external override onlyOwner returns (uint256, uint256) { uint256 reward = (shares * rate) / 1e18; require(reward <= rewards - debt, "xrm3"); Position storage pos = positions[account]; uint256 s = pos.shares; if (s > 0) { uint256 dt = ( block.timestamp < pos.timestamp + period ? block.timestamp : pos.timestamp + period ) - pos.updated; uint256 vested = pos.vested; pos.earned += ((((s - vested) * dt) / period) * rate) / 1e18; pos.vested = vested + ((s - vested) * dt) / period; } pos.shares = s + shares; pos.timestamp = uint128(block.timestamp); pos.updated = uint128(block.timestamp); debt += reward; return (0, 0); } /** * @inheritdoc IRewardModule */ function unstake( bytes32 account, address, address receiver, uint256 shares, bytes calldata ) external override onlyOwner returns (uint256, uint256) { Position storage pos = positions[account]; uint256 s = pos.shares; assert(shares <= s); // note: we assume shares has been validated upstream require(pos.timestamp < block.timestamp); // get all pending rewards uint256 updated = pos.updated; uint256 end = pos.timestamp + period; uint256 dt = (block.timestamp < end ? block.timestamp : end) - updated; uint256 r = pos.earned + ((((s - pos.vested) * dt) / period) * rate) / 1e18; // remove any lost unvested debt if (block.timestamp < end) { uint256 unvested = shares < pos.vested ? 0 : shares - pos.vested; uint256 remaining = end - block.timestamp; debt -= (((unvested * remaining) / period) * rate) / 1e18; } // TODO rework debt decrease math here for precision // update user position if (shares < s) { pos.shares = s - shares; if (shares < pos.vested) { pos.vested -= shares; } else { pos.vested = 0; } pos.updated = uint128(updated + dt); pos.earned = 0; } else { delete positions[account]; } // distribute rewards if (r > 0) { _distribute(receiver, r); } return (0, 0); } /** * @inheritdoc IRewardModule */ function claim( bytes32 account, address, address receiver, uint256, bytes calldata ) external override onlyOwner returns (uint256, uint256) { // get all pending rewards Position storage pos = positions[account]; uint256 updated = pos.updated; uint256 end = pos.timestamp + period; uint256 dt = (block.timestamp < end ? block.timestamp : end) - updated; uint256 r = pos.earned + ((((pos.shares - pos.vested) * dt) / period) * rate) / 1e18; // update user position pos.updated = uint128(updated + dt); pos.earned = 0; // distribute rewards if (r > 0) { _distribute(receiver, r); } return (0, 0); } /** * @inheritdoc IRewardModule */ function update(bytes32, address, bytes calldata) external override {} /** * @inheritdoc IRewardModule */ function clean(bytes calldata) external override {} // -- ERC20FixedRewardModule ---------------------------------------- /** * @notice fund module by depositing reward tokens * @dev this is a public method callable by any account or contract * @param amount number of reward tokens to deposit */ function fund(uint256 amount) external { require(amount > 0, "xrm4"); // get fees (address receiver, uint256 feeRate) = _config.getAddressUint96( keccak256("gysr.core.fixed.fund.fee") ); // do funding transfer, fee processing, and reward shares accounting uint256 minted = _token.receiveWithFee( rewards, msg.sender, amount, receiver, feeRate ); rewards += minted; emit RewardsFunded(address(_token), amount, minted, block.timestamp); } /** * @notice withdraw uncommitted reward tokens from module * @param amount number of reward tokens to withdraw */ function withdraw(uint256 amount) external { requireController(); // validate excess budget require(amount > 0, "xrm5"); require(amount <= _token.balanceOf(address(this)), "xrm6"); uint256 shares = _token.getShares(rewards, amount); require(shares <= rewards - debt, "xrm7"); // withdraw rewards -= shares; _token.safeTransfer(msg.sender, amount); emit RewardsWithdrawn(address(_token), amount, shares, block.timestamp); } // -- ERC20FixedRewardModule internal ------------------------------- /** * @dev internal method to distribute rewards * @param user address of user * @param shares number of shares burned */ function _distribute(address user, uint256 shares) private { // compute reward amount in tokens uint256 amount = _token.getAmount(rewards, shares); // update overall reward shares rewards -= shares; debt -= shares; // do reward _token.safeTransfer(user, amount); emit RewardsDistributed(user, address(_token), amount, shares); } }
/* IConfiguration https://github.com/gysr-io/core SPDX-License-Identifier: MIT */ pragma solidity 0.8.18; /** * @title Configuration interface * * @notice this defines the protocol configuration interface */ interface IConfiguration { // events event ParameterUpdated(bytes32 indexed key, address value); event ParameterUpdated(bytes32 indexed key, uint256 value); event ParameterUpdated(bytes32 indexed key, address value0, uint96 value1); event ParameterOverridden( address indexed caller, bytes32 indexed key, address value ); event ParameterOverridden( address indexed caller, bytes32 indexed key, uint256 value ); event ParameterOverridden( address indexed caller, bytes32 indexed key, address value0, uint96 value1 ); /** * @notice set or update uint256 parameter * @param key keccak256 hash of parameter key * @param value uint256 parameter value */ function setUint256(bytes32 key, uint256 value) external; /** * @notice set or update address parameter * @param key keccak256 hash of parameter key * @param value address parameter value */ function setAddress(bytes32 key, address value) external; /** * @notice set or update packed address + uint96 pair * @param key keccak256 hash of parameter key * @param value0 address parameter value * @param value1 uint96 parameter value */ function setAddressUint96( bytes32 key, address value0, uint96 value1 ) external; /** * @notice get uint256 parameter * @param key keccak256 hash of parameter key * @return uint256 parameter value */ function getUint256(bytes32 key) external view returns (uint256); /** * @notice get address parameter * @param key keccak256 hash of parameter key * @return uint256 parameter value */ function getAddress(bytes32 key) external view returns (address); /** * @notice get packed address + uint96 pair * @param key keccak256 hash of parameter key * @return address parameter value * @return uint96 parameter value */ function getAddressUint96(bytes32 key) external returns (address, uint96); /** * @notice override uint256 parameter for specific caller * @param caller address of caller * @param key keccak256 hash of parameter key * @param value uint256 parameter value */ function overrideUint256( address caller, bytes32 key, uint256 value ) external; /** * @notice override address parameter for specific caller * @param caller address of caller * @param key keccak256 hash of parameter key * @param value address parameter value */ function overrideAddress( address caller, bytes32 key, address value ) external; /** * @notice override address parameter for specific caller * @param caller address of caller * @param key keccak256 hash of parameter key * @param value0 address parameter value * @param value1 uint96 parameter value */ function overrideAddressUint96( address caller, bytes32 key, address value0, uint96 value1 ) external; }
/* IEvents https://github.com/gysr-io/core SPDX-License-Identifier: MIT */ pragma solidity 0.8.18; /** * @title GYSR event system * * @notice common interface to define GYSR event system */ interface IEvents { // staking event Staked( bytes32 indexed account, address indexed user, address indexed token, uint256 amount, uint256 shares ); event Unstaked( bytes32 indexed account, address indexed user, address indexed token, uint256 amount, uint256 shares ); event Claimed( bytes32 indexed account, address indexed user, address indexed token, uint256 amount, uint256 shares ); event Updated(bytes32 indexed account, address indexed user); // rewards event RewardsDistributed( address indexed user, address indexed token, uint256 amount, uint256 shares ); event RewardsFunded( address indexed token, uint256 amount, uint256 shares, uint256 timestamp ); event RewardsExpired( address indexed token, uint256 amount, uint256 shares, uint256 timestamp ); event RewardsWithdrawn( address indexed token, uint256 amount, uint256 shares, uint256 timestamp ); event RewardsUpdated(bytes32 indexed account); // gysr event GysrSpent(address indexed user, uint256 amount); event GysrVested(address indexed user, uint256 amount); event GysrWithdrawn(uint256 amount); }
/* IOwnerController https://github.com/gysr-io/core SPDX-License-Identifier: MIT */ pragma solidity 0.8.18; /** * @title Owner controller interface * * @notice this defines the interface for any contracts that use the * owner controller access pattern */ interface IOwnerController { /** * @dev Returns the address of the current owner. */ function owner() external view returns (address); /** * @dev Returns the address of the current controller. */ function controller() external view returns (address); /** * @dev Transfers ownership of the contract to a new account (`newOwner`). This can * include renouncing ownership by transferring to the zero address. * Can only be called by the current owner. */ function transferOwnership(address newOwner) external; /** * @dev Transfers control of the contract to a new account (`newController`). * Can only be called by the owner. */ function transferControl(address newController) external; }
/* IRewardModule https://github.com/gysr-io/core SPDX-License-Identifier: MIT */ pragma solidity 0.8.18; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "./IEvents.sol"; import "./IOwnerController.sol"; /** * @title Reward module interface * * @notice this contract defines the common interface that any reward module * must implement to be compatible with the modular Pool architecture. */ interface IRewardModule is IOwnerController, IEvents { /** * @return array of reward tokens */ function tokens() external view returns (address[] memory); /** * @return array of reward token balances */ function balances() external view returns (uint256[] memory); /** * @return GYSR usage ratio for reward module */ function usage() external view returns (uint256); /** * @return address of module factory */ function factory() external view returns (address); /** * @notice perform any necessary accounting for new stake * @param account bytes32 id of staking account * @param sender address of sender * @param shares number of new shares minted * @param data addtional data * @return amount of gysr spent * @return amount of gysr vested */ function stake( bytes32 account, address sender, uint256 shares, bytes calldata data ) external returns (uint256, uint256); /** * @notice reward user and perform any necessary accounting for unstake * @param account bytes32 id of staking account * @param sender address of sender * @param receiver address of reward receiver * @param shares number of shares burned * @param data additional data * @return amount of gysr spent * @return amount of gysr vested */ function unstake( bytes32 account, address sender, address receiver, uint256 shares, bytes calldata data ) external returns (uint256, uint256); /** * @notice reward user and perform and necessary accounting for existing stake * @param account bytes32 id of staking account * @param sender address of sender * @param receiver address of reward receiver * @param shares number of shares being claimed against * @param data additional data * @return amount of gysr spent * @return amount of gysr vested */ function claim( bytes32 account, address sender, address receiver, uint256 shares, bytes calldata data ) external returns (uint256, uint256); /** * @notice method called by anyone to update accounting * @dev will only be called ad hoc and should not contain essential logic * @param account bytes32 id of staking account for update * @param sender address of sender * @param data additional data */ function update( bytes32 account, address sender, bytes calldata data ) external; /** * @notice method called by owner to clean up and perform additional accounting * @dev will only be called ad hoc and should not contain any essential logic * @param data additional data */ function clean(bytes calldata data) external; }
/* OwnerController https://github.com/gysr-io/core SPDX-License-Identifier: MIT */ pragma solidity 0.8.18; import "./interfaces/IOwnerController.sol"; /** * @title Owner controller * * @notice this base contract implements an owner-controller access model. * * @dev the contract is an adapted version of the OpenZeppelin Ownable contract. * It allows the owner to designate an additional account as the controller to * perform restricted operations. * * Other changes include supporting role verification with a require method * in addition to the modifier option, and removing some unneeded functionality. * * Original contract here: * https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/access/Ownable.sol */ contract OwnerController is IOwnerController { address private _owner; address private _controller; event OwnershipTransferred( address indexed previousOwner, address indexed newOwner ); event ControlTransferred( address indexed previousController, address indexed newController ); constructor() { _owner = msg.sender; _controller = msg.sender; emit OwnershipTransferred(address(0), _owner); emit ControlTransferred(address(0), _owner); } /** * @dev Returns the address of the current owner. */ function owner() public view override returns (address) { return _owner; } /** * @dev Returns the address of the current controller. */ function controller() public view override returns (address) { return _controller; } /** * @dev Modifier that throws if called by any account other than the owner. */ modifier onlyOwner() { require(_owner == msg.sender, "oc1"); _; } /** * @dev Modifier that throws if called by any account other than the controller. */ modifier onlyController() { require(_controller == msg.sender, "oc2"); _; } /** * @dev Throws if called by any account other than the owner. */ function requireOwner() internal view { require(_owner == msg.sender, "oc1"); } /** * @dev Throws if called by any account other than the controller. */ function requireController() internal view { require(_controller == msg.sender, "oc2"); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). This can * include renouncing ownership by transferring to the zero address. * Can only be called by the current owner. */ function transferOwnership(address newOwner) public virtual override { requireOwner(); require(newOwner != address(0), "oc3"); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } /** * @dev Transfers control of the contract to a new account (`newController`). * Can only be called by the owner. */ function transferControl(address newController) public virtual override { requireOwner(); require(newController != address(0), "oc4"); emit ControlTransferred(_controller, newController); _controller = newController; } }
/* TokenUtils https://github.com/gysr-io/core SPDX-License-Identifier: MIT */ pragma solidity 0.8.18; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; /** * @title Token utilities * * @notice this library implements utility methods for token handling, * dynamic balance accounting, and fee processing */ library TokenUtils { using SafeERC20 for IERC20; uint256 constant INITIAL_SHARES_PER_TOKEN = 1e6; /** * @notice get token shares from amount * @param token erc20 token interface * @param total current total shares * @param amount balance of tokens */ function getShares( IERC20 token, uint256 total, uint256 amount ) internal view returns (uint256) { if (total == 0) return 0; return (total * amount) / token.balanceOf(address(this)); } /** * @notice get token amount from shares * @param token erc20 token interface * @param total current total shares * @param shares balance of shares */ function getAmount( IERC20 token, uint256 total, uint256 shares ) internal view returns (uint256) { if (total == 0) return 0; return (token.balanceOf(address(this)) * shares) / total; } /** * @notice transfer tokens from sender into contract and convert to shares * for internal accounting * @param token erc20 token interface * @param shares current total shares * @param sender token sender * @param amount number of tokens to be sent */ function receiveAmount( IERC20 token, uint256 shares, address sender, uint256 amount ) internal returns (uint256) { // transfer uint256 total = token.balanceOf(address(this)); token.safeTransferFrom(sender, address(this), amount); uint256 actual = token.balanceOf(address(this)) - total; // mint shares at current rate uint256 minted = (total > 0) ? (shares * actual) / total : actual * INITIAL_SHARES_PER_TOKEN; require(minted > 0); return minted; } /** * @notice transfer tokens from sender into contract, process protocol fee, * and convert to shares for internal accounting * @param token erc20 token interface * @param shares current total shares * @param sender token sender * @param amount number of tokens to be sent * @param feeReceiver address to receive fee * @param feeRate portion of amount to take as fee in 18 decimals */ function receiveWithFee( IERC20 token, uint256 shares, address sender, uint256 amount, address feeReceiver, uint256 feeRate ) internal returns (uint256) { // check initial token balance uint256 total = token.balanceOf(address(this)); // process fee uint256 fee; if (feeReceiver != address(0) && feeRate > 0 && feeRate < 1e18) { fee = (amount * feeRate) / 1e18; token.safeTransferFrom(sender, feeReceiver, fee); } // do transfer token.safeTransferFrom(sender, address(this), amount - fee); uint256 actual = token.balanceOf(address(this)) - total; // mint shares at current rate uint256 minted = (total > 0) ? (shares * actual) / total : actual * INITIAL_SHARES_PER_TOKEN; require(minted > 0); return minted; } }
{ "optimizer": { "enabled": true, "runs": 10000 }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "devdoc", "userdoc", "metadata", "abi" ] } }, "libraries": {} }
[{"inputs":[{"internalType":"address","name":"module","type":"address"}],"name":"budget","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"module","type":"address"},{"internalType":"bytes32","name":"account","type":"bytes32"}],"name":"preview","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"module","type":"address"},{"internalType":"bytes32","name":"account","type":"bytes32"},{"internalType":"uint256","name":"shares","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"rewards","outputs":[{"internalType":"uint256[]","name":"rewards_","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"module","type":"address"}],"name":"token","outputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"string","name":"","type":"string"},{"internalType":"string","name":"","type":"string"},{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"module","type":"address"}],"name":"tokens","outputs":[{"internalType":"address[]","name":"addresses_","type":"address[]"},{"internalType":"string[]","name":"names_","type":"string[]"},{"internalType":"string[]","name":"symbols_","type":"string[]"},{"internalType":"uint8[]","name":"decimals_","type":"uint8[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"module","type":"address"},{"internalType":"uint256","name":"shares","type":"uint256"}],"name":"validate","outputs":[{"internalType":"bool","name":"","type":"bool"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"module","type":"address"}],"name":"withdrawable","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
Loading...
Loading
[ Download: CSV Export ]
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.