Overview
ETH Balance
0 ETH
ETH Value
$0.00More Info
Private Name Tags
ContractCreator
Multichain Info
No addresses found
| Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
|---|---|---|---|---|---|---|---|---|---|
Latest 1 internal transaction
| Parent Transaction Hash | Block | From | To | |||
|---|---|---|---|---|---|---|
| 5206960 | 4 days ago | Contract Creation | 0 ETH |
Loading...
Loading
This contract may be a proxy contract. Click on More Options and select Is this a proxy? to confirm and enable the "Read as Proxy" & "Write as Proxy" tabs.
Contract Source Code Verified (Exact Match)
Contract Name:
Token
Compiler Version
v0.8.26-1.0.1
ZkSolc Version
v1.5.11
Contract Source Code (Solidity)
/**
*Submitted for verification at abscan.org on 2025-03-27
*/
// SPDX-License-Identifier: UNLICENSED
pragma solidity =0.8.26 ^0.8.0 ^0.8.20 ^0.8.21 ^0.8.24;
// lib/openzeppelin-contracts/contracts/utils/structs/EnumerableSet.sol
// OpenZeppelin Contracts (last updated v5.0.0) (utils/structs/EnumerableSet.sol)
// This file was procedurally generated from scripts/generate/templates/EnumerableSet.js.
/**
* @dev Library for managing
* https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
* types.
*
* Sets have the following properties:
*
* - Elements are added, removed, and checked for existence in constant time
* (O(1)).
* - Elements are enumerated in O(n). No guarantees are made on the ordering.
*
* ```solidity
* contract Example {
* // Add the library methods
* using EnumerableSet for EnumerableSet.AddressSet;
*
* // Declare a set state variable
* EnumerableSet.AddressSet private mySet;
* }
* ```
*
* As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
* and `uint256` (`UintSet`) are supported.
*
* [WARNING]
* ====
* Trying to delete such a structure from storage will likely result in data corruption, rendering the structure
* unusable.
* See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.
*
* In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an
* array of EnumerableSet.
* ====
*/
library EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position is the index of the value in the `values` array plus 1.
// Position 0 is used to mean a value is not in the set.
mapping(bytes32 value => uint256) _positions;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
// The value is stored at length-1, but we add 1 to all indexes
// and use 0 as a sentinel value
set._positions[value] = set._values.length;
return true;
} else {
return false;
}
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function _remove(Set storage set, bytes32 value) private returns (bool) {
// We cache the value's position to prevent multiple reads from the same storage slot
uint256 position = set._positions[value];
if (position != 0) {
// Equivalent to contains(set, value)
// To delete an element from the _values array in O(1), we swap the element to delete with the last one in
// the array, and then remove the last element (sometimes called as 'swap and pop').
// This modifies the order of the array, as noted in {at}.
uint256 valueIndex = position - 1;
uint256 lastIndex = set._values.length - 1;
if (valueIndex != lastIndex) {
bytes32 lastValue = set._values[lastIndex];
// Move the lastValue to the index where the value to delete is
set._values[valueIndex] = lastValue;
// Update the tracked position of the lastValue (that was just moved)
set._positions[lastValue] = position;
}
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the tracked position for the deleted slot
delete set._positions[value];
return true;
} else {
return false;
}
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._positions[value] != 0;
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function _at(Set storage set, uint256 index) private view returns (bytes32) {
return set._values[index];
}
/**
* @dev Return the entire set in an array
*
* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
* this function has an unbounded cost, and using it as part of a state-changing function may render the function
* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
*/
function _values(Set storage set) private view returns (bytes32[] memory) {
return set._values;
}
// Bytes32Set
struct Bytes32Set {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _add(set._inner, value);
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _remove(set._inner, value);
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
return _contains(set._inner, value);
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(Bytes32Set storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
return _at(set._inner, index);
}
/**
* @dev Return the entire set in an array
*
* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
* this function has an unbounded cost, and using it as part of a state-changing function may render the function
* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
*/
function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
bytes32[] memory store = _values(set._inner);
bytes32[] memory result;
assembly ("memory-safe") {
result := store
}
return result;
}
// AddressSet
struct AddressSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(uint160(value))));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(uint160(value))));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(uint160(value))));
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint160(uint256(_at(set._inner, index))));
}
/**
* @dev Return the entire set in an array
*
* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
* this function has an unbounded cost, and using it as part of a state-changing function may render the function
* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
*/
function values(AddressSet storage set) internal view returns (address[] memory) {
bytes32[] memory store = _values(set._inner);
address[] memory result;
assembly ("memory-safe") {
result := store
}
return result;
}
// UintSet
struct UintSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
/**
* @dev Return the entire set in an array
*
* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
* this function has an unbounded cost, and using it as part of a state-changing function may render the function
* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
*/
function values(UintSet storage set) internal view returns (uint256[] memory) {
bytes32[] memory store = _values(set._inner);
uint256[] memory result;
assembly ("memory-safe") {
result := store
}
return result;
}
}
// lib/openzeppelin-contracts/contracts/utils/Errors.sol
/**
* @dev Collection of common custom errors used in multiple contracts
*
* IMPORTANT: Backwards compatibility is not guaranteed in future versions of the library.
* It is recommended to avoid relying on the error API for critical functionality.
*/
library Errors {
/**
* @dev The ETH balance of the account is not enough to perform the operation.
*/
error InsufficientBalance(uint256 balance, uint256 needed);
/**
* @dev A call to an address target failed. The target may have reverted.
*/
error FailedCall();
/**
* @dev The deployment failed.
*/
error FailedDeployment();
/**
* @dev A necessary precompile is missing.
*/
error MissingPrecompile(address);
}
// lib/openzeppelin-contracts/contracts/utils/cryptography/Hashes.sol
/**
* @dev Library of standard hash functions.
*/
library Hashes {
/**
* @dev Commutative Keccak256 hash of a sorted pair of bytes32. Frequently used when working with merkle proofs.
*
* NOTE: Equivalent to the `standardNodeHash` in our https://github.com/OpenZeppelin/merkle-tree[JavaScript library].
*/
function commutativeKeccak256(bytes32 a, bytes32 b) internal pure returns (bytes32) {
return a < b ? _efficientKeccak256(a, b) : _efficientKeccak256(b, a);
}
/**
* @dev Implementation of keccak256(abi.encode(a, b)) that doesn't allocate or expand memory.
*/
function _efficientKeccak256(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
assembly ("memory-safe") {
mstore(0x00, a)
mstore(0x20, b)
value := keccak256(0x00, 0x40)
}
}
}
// lib/openzeppelin-contracts/contracts/access/IAccessControl.sol
// OpenZeppelin Contracts (last updated v5.0.0) (access/IAccessControl.sol)
/**
* @dev External interface of AccessControl declared to support ERC-165 detection.
*/
interface IAccessControl {
/**
* @dev The `account` is missing a role.
*/
error AccessControlUnauthorizedAccount(address account, bytes32 neededRole);
/**
* @dev The caller of a function is not the expected one.
*
* NOTE: Don't confuse with {AccessControlUnauthorizedAccount}.
*/
error AccessControlBadConfirmation();
/**
* @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
*
* `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
* {RoleAdminChanged} not being emitted signaling this.
*/
event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);
/**
* @dev Emitted when `account` is granted `role`.
*
* `sender` is the account that originated the contract call. This account bears the admin role (for the granted role).
* Expected in cases where the role was granted using the internal {AccessControl-_grantRole}.
*/
event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
/**
* @dev Emitted when `account` is revoked `role`.
*
* `sender` is the account that originated the contract call:
* - if using `revokeRole`, it is the admin role bearer
* - if using `renounceRole`, it is the role bearer (i.e. `account`)
*/
event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
/**
* @dev Returns `true` if `account` has been granted `role`.
*/
function hasRole(bytes32 role, address account) external view returns (bool);
/**
* @dev Returns the admin role that controls `role`. See {grantRole} and
* {revokeRole}.
*
* To change a role's admin, use {AccessControl-_setRoleAdmin}.
*/
function getRoleAdmin(bytes32 role) external view returns (bytes32);
/**
* @dev Grants `role` to `account`.
*
* If `account` had not been already granted `role`, emits a {RoleGranted}
* event.
*
* Requirements:
*
* - the caller must have ``role``'s admin role.
*/
function grantRole(bytes32 role, address account) external;
/**
* @dev Revokes `role` from `account`.
*
* If `account` had been granted `role`, emits a {RoleRevoked} event.
*
* Requirements:
*
* - the caller must have ``role``'s admin role.
*/
function revokeRole(bytes32 role, address account) external;
/**
* @dev Revokes `role` from the calling account.
*
* Roles are often managed via {grantRole} and {revokeRole}: this function's
* purpose is to provide a mechanism for accounts to lose their privileges
* if they are compromised (such as when a trusted device is misplaced).
*
* If the calling account had been granted `role`, emits a {RoleRevoked}
* event.
*
* Requirements:
*
* - the caller must be `callerConfirmation`.
*/
function renounceRole(bytes32 role, address callerConfirmation) external;
}
// lib/openzeppelin-contracts/contracts/proxy/beacon/IBeacon.sol
// OpenZeppelin Contracts (last updated v5.0.0) (proxy/beacon/IBeacon.sol)
/**
* @dev This is the interface that {BeaconProxy} expects of its beacon.
*/
interface IBeacon {
/**
* @dev Must return an address that can be used as a delegate call target.
*
* {UpgradeableBeacon} will check that this address is a contract.
*/
function implementation() external view returns (address);
}
// lib/openzeppelin-contracts/contracts/utils/introspection/IERC165.sol
// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/IERC165.sol)
/**
* @dev Interface of the ERC-165 standard, as defined in the
* https://eips.ethereum.org/EIPS/eip-165[ERC].
*
* Implementers can declare support of contract interfaces, which can then be
* queried by others ({ERC165Checker}).
*
* For an implementation, see {ERC165}.
*/
interface IERC165 {
/**
* @dev Returns true if this contract implements the interface defined by
* `interfaceId`. See the corresponding
* https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]
* to learn more about how these ids are created.
*
* This function call must use less than 30 000 gas.
*/
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
// lib/openzeppelin-contracts/contracts/interfaces/IERC1967.sol
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC1967.sol)
/**
* @dev ERC-1967: Proxy Storage Slots. This interface contains the events defined in the ERC.
*/
interface IERC1967 {
/**
* @dev Emitted when the implementation is upgraded.
*/
event Upgraded(address indexed implementation);
/**
* @dev Emitted when the admin account has changed.
*/
event AdminChanged(address previousAdmin, address newAdmin);
/**
* @dev Emitted when the beacon is changed.
*/
event BeaconUpgraded(address indexed beacon);
}
// lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)
/**
* @dev Interface of the ERC-20 standard as defined in the ERC.
*/
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 value of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the value of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves a `value` amount of 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 value) 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 a `value` amount of tokens 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 value) external returns (bool);
/**
* @dev Moves a `value` amount of tokens from `from` to `to` using the
* allowance mechanism. `value` 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 value) external returns (bool);
}
// lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/Initializable.sol
// OpenZeppelin Contracts (last updated v5.0.0) (proxy/utils/Initializable.sol)
/**
* @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
* behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an
* external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
* function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
*
* The initialization functions use a version number. Once a version number is used, it is consumed and cannot be
* reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in
* case an upgrade adds a module that needs to be initialized.
*
* For example:
*
* [.hljs-theme-light.nopadding]
* ```solidity
* contract MyToken is ERC20Upgradeable {
* function initialize() initializer public {
* __ERC20_init("MyToken", "MTK");
* }
* }
*
* contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {
* function initializeV2() reinitializer(2) public {
* __ERC20Permit_init("MyToken");
* }
* }
* ```
*
* TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
* possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
*
* CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
* that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
*
* [CAUTION]
* ====
* Avoid leaving a contract uninitialized.
*
* An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
* contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke
* the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:
*
* [.hljs-theme-light.nopadding]
* ```
* /// @custom:oz-upgrades-unsafe-allow constructor
* constructor() {
* _disableInitializers();
* }
* ```
* ====
*/
abstract contract Initializable {
/**
* @dev Storage of the initializable contract.
*
* It's implemented on a custom ERC-7201 namespace to reduce the risk of storage collisions
* when using with upgradeable contracts.
*
* @custom:storage-location erc7201:openzeppelin.storage.Initializable
*/
struct InitializableStorage {
/**
* @dev Indicates that the contract has been initialized.
*/
uint64 _initialized;
/**
* @dev Indicates that the contract is in the process of being initialized.
*/
bool _initializing;
}
// keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.Initializable")) - 1)) & ~bytes32(uint256(0xff))
bytes32 private constant INITIALIZABLE_STORAGE = 0xf0c57e16840df040f15088dc2f81fe391c3923bec73e23a9662efc9c229c6a00;
/**
* @dev The contract is already initialized.
*/
error InvalidInitialization();
/**
* @dev The contract is not initializing.
*/
error NotInitializing();
/**
* @dev Triggered when the contract has been initialized or reinitialized.
*/
event Initialized(uint64 version);
/**
* @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,
* `onlyInitializing` functions can be used to initialize parent contracts.
*
* Similar to `reinitializer(1)`, except that in the context of a constructor an `initializer` may be invoked any
* number of times. This behavior in the constructor can be useful during testing and is not expected to be used in
* production.
*
* Emits an {Initialized} event.
*/
modifier initializer() {
// solhint-disable-next-line var-name-mixedcase
InitializableStorage storage $ = _getInitializableStorage();
// Cache values to avoid duplicated sloads
bool isTopLevelCall = !$._initializing;
uint64 initialized = $._initialized;
// Allowed calls:
// - initialSetup: the contract is not in the initializing state and no previous version was
// initialized
// - construction: the contract is initialized at version 1 (no reininitialization) and the
// current contract is just being deployed
bool initialSetup = initialized == 0 && isTopLevelCall;
bool construction = initialized == 1 && address(this).code.length == 0;
if (!initialSetup && !construction) {
revert InvalidInitialization();
}
$._initialized = 1;
if (isTopLevelCall) {
$._initializing = true;
}
_;
if (isTopLevelCall) {
$._initializing = false;
emit Initialized(1);
}
}
/**
* @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the
* contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be
* used to initialize parent contracts.
*
* A reinitializer may be used after the original initialization step. This is essential to configure modules that
* are added through upgrades and that require initialization.
*
* When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`
* cannot be nested. If one is invoked in the context of another, execution will revert.
*
* Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in
* a contract, executing them in the right order is up to the developer or operator.
*
* WARNING: Setting the version to 2**64 - 1 will prevent any future reinitialization.
*
* Emits an {Initialized} event.
*/
modifier reinitializer(uint64 version) {
// solhint-disable-next-line var-name-mixedcase
InitializableStorage storage $ = _getInitializableStorage();
if ($._initializing || $._initialized >= version) {
revert InvalidInitialization();
}
$._initialized = version;
$._initializing = true;
_;
$._initializing = false;
emit Initialized(version);
}
/**
* @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
* {initializer} and {reinitializer} modifiers, directly or indirectly.
*/
modifier onlyInitializing() {
_checkInitializing();
_;
}
/**
* @dev Reverts if the contract is not in an initializing state. See {onlyInitializing}.
*/
function _checkInitializing() internal view virtual {
if (!_isInitializing()) {
revert NotInitializing();
}
}
/**
* @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.
* Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized
* to any version. It is recommended to use this to lock implementation contracts that are designed to be called
* through proxies.
*
* Emits an {Initialized} event the first time it is successfully executed.
*/
function _disableInitializers() internal virtual {
// solhint-disable-next-line var-name-mixedcase
InitializableStorage storage $ = _getInitializableStorage();
if ($._initializing) {
revert InvalidInitialization();
}
if ($._initialized != type(uint64).max) {
$._initialized = type(uint64).max;
emit Initialized(type(uint64).max);
}
}
/**
* @dev Returns the highest version that has been initialized. See {reinitializer}.
*/
function _getInitializedVersion() internal view returns (uint64) {
return _getInitializableStorage()._initialized;
}
/**
* @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.
*/
function _isInitializing() internal view returns (bool) {
return _getInitializableStorage()._initializing;
}
/**
* @dev Returns a pointer to the storage namespace.
*/
// solhint-disable-next-line var-name-mixedcase
function _getInitializableStorage() private pure returns (InitializableStorage storage $) {
assembly {
$.slot := INITIALIZABLE_STORAGE
}
}
}
// lib/openzeppelin-contracts/contracts/utils/Panic.sol
/**
* @dev Helper library for emitting standardized panic codes.
*
* ```solidity
* contract Example {
* using Panic for uint256;
*
* // Use any of the declared internal constants
* function foo() { Panic.GENERIC.panic(); }
*
* // Alternatively
* function foo() { Panic.panic(Panic.GENERIC); }
* }
* ```
*
* Follows the list from https://github.com/ethereum/solidity/blob/v0.8.24/libsolutil/ErrorCodes.h[libsolutil].
*/
// slither-disable-next-line unused-state
library Panic {
/// @dev generic / unspecified error
uint256 internal constant GENERIC = 0x00;
/// @dev used by the assert() builtin
uint256 internal constant ASSERT = 0x01;
/// @dev arithmetic underflow or overflow
uint256 internal constant UNDER_OVERFLOW = 0x11;
/// @dev division or modulo by zero
uint256 internal constant DIVISION_BY_ZERO = 0x12;
/// @dev enum conversion error
uint256 internal constant ENUM_CONVERSION_ERROR = 0x21;
/// @dev invalid encoding in storage
uint256 internal constant STORAGE_ENCODING_ERROR = 0x22;
/// @dev empty array pop
uint256 internal constant EMPTY_ARRAY_POP = 0x31;
/// @dev array out of bounds access
uint256 internal constant ARRAY_OUT_OF_BOUNDS = 0x32;
/// @dev resource error (too large allocation or too large array)
uint256 internal constant RESOURCE_ERROR = 0x41;
/// @dev calling invalid internal function
uint256 internal constant INVALID_INTERNAL_FUNCTION = 0x51;
/// @dev Reverts with a panic code. Recommended to use with
/// the internal constants with predefined codes.
function panic(uint256 code) internal pure {
assembly ("memory-safe") {
mstore(0x00, 0x4e487b71)
mstore(0x20, code)
revert(0x1c, 0x24)
}
}
}
// lib/openzeppelin-contracts/contracts/utils/math/SafeCast.sol
// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/SafeCast.sol)
// This file was procedurally generated from scripts/generate/templates/SafeCast.js.
/**
* @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow
* checks.
*
* Downcasting from uint256/int256 in Solidity does not revert on overflow. This can
* easily result in undesired exploitation or bugs, since developers usually
* assume that overflows raise errors. `SafeCast` restores this intuition by
* reverting the transaction when such an operation overflows.
*
* Using this library instead of the unchecked operations eliminates an entire
* class of bugs, so it's recommended to use it always.
*/
library SafeCast {
/**
* @dev Value doesn't fit in an uint of `bits` size.
*/
error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);
/**
* @dev An int value doesn't fit in an uint of `bits` size.
*/
error SafeCastOverflowedIntToUint(int256 value);
/**
* @dev Value doesn't fit in an int of `bits` size.
*/
error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);
/**
* @dev An uint value doesn't fit in an int of `bits` size.
*/
error SafeCastOverflowedUintToInt(uint256 value);
/**
* @dev Returns the downcasted uint248 from uint256, reverting on
* overflow (when the input is greater than largest uint248).
*
* Counterpart to Solidity's `uint248` operator.
*
* Requirements:
*
* - input must fit into 248 bits
*/
function toUint248(uint256 value) internal pure returns (uint248) {
if (value > type(uint248).max) {
revert SafeCastOverflowedUintDowncast(248, value);
}
return uint248(value);
}
/**
* @dev Returns the downcasted uint240 from uint256, reverting on
* overflow (when the input is greater than largest uint240).
*
* Counterpart to Solidity's `uint240` operator.
*
* Requirements:
*
* - input must fit into 240 bits
*/
function toUint240(uint256 value) internal pure returns (uint240) {
if (value > type(uint240).max) {
revert SafeCastOverflowedUintDowncast(240, value);
}
return uint240(value);
}
/**
* @dev Returns the downcasted uint232 from uint256, reverting on
* overflow (when the input is greater than largest uint232).
*
* Counterpart to Solidity's `uint232` operator.
*
* Requirements:
*
* - input must fit into 232 bits
*/
function toUint232(uint256 value) internal pure returns (uint232) {
if (value > type(uint232).max) {
revert SafeCastOverflowedUintDowncast(232, value);
}
return uint232(value);
}
/**
* @dev Returns the downcasted uint224 from uint256, reverting on
* overflow (when the input is greater than largest uint224).
*
* Counterpart to Solidity's `uint224` operator.
*
* Requirements:
*
* - input must fit into 224 bits
*/
function toUint224(uint256 value) internal pure returns (uint224) {
if (value > type(uint224).max) {
revert SafeCastOverflowedUintDowncast(224, value);
}
return uint224(value);
}
/**
* @dev Returns the downcasted uint216 from uint256, reverting on
* overflow (when the input is greater than largest uint216).
*
* Counterpart to Solidity's `uint216` operator.
*
* Requirements:
*
* - input must fit into 216 bits
*/
function toUint216(uint256 value) internal pure returns (uint216) {
if (value > type(uint216).max) {
revert SafeCastOverflowedUintDowncast(216, value);
}
return uint216(value);
}
/**
* @dev Returns the downcasted uint208 from uint256, reverting on
* overflow (when the input is greater than largest uint208).
*
* Counterpart to Solidity's `uint208` operator.
*
* Requirements:
*
* - input must fit into 208 bits
*/
function toUint208(uint256 value) internal pure returns (uint208) {
if (value > type(uint208).max) {
revert SafeCastOverflowedUintDowncast(208, value);
}
return uint208(value);
}
/**
* @dev Returns the downcasted uint200 from uint256, reverting on
* overflow (when the input is greater than largest uint200).
*
* Counterpart to Solidity's `uint200` operator.
*
* Requirements:
*
* - input must fit into 200 bits
*/
function toUint200(uint256 value) internal pure returns (uint200) {
if (value > type(uint200).max) {
revert SafeCastOverflowedUintDowncast(200, value);
}
return uint200(value);
}
/**
* @dev Returns the downcasted uint192 from uint256, reverting on
* overflow (when the input is greater than largest uint192).
*
* Counterpart to Solidity's `uint192` operator.
*
* Requirements:
*
* - input must fit into 192 bits
*/
function toUint192(uint256 value) internal pure returns (uint192) {
if (value > type(uint192).max) {
revert SafeCastOverflowedUintDowncast(192, value);
}
return uint192(value);
}
/**
* @dev Returns the downcasted uint184 from uint256, reverting on
* overflow (when the input is greater than largest uint184).
*
* Counterpart to Solidity's `uint184` operator.
*
* Requirements:
*
* - input must fit into 184 bits
*/
function toUint184(uint256 value) internal pure returns (uint184) {
if (value > type(uint184).max) {
revert SafeCastOverflowedUintDowncast(184, value);
}
return uint184(value);
}
/**
* @dev Returns the downcasted uint176 from uint256, reverting on
* overflow (when the input is greater than largest uint176).
*
* Counterpart to Solidity's `uint176` operator.
*
* Requirements:
*
* - input must fit into 176 bits
*/
function toUint176(uint256 value) internal pure returns (uint176) {
if (value > type(uint176).max) {
revert SafeCastOverflowedUintDowncast(176, value);
}
return uint176(value);
}
/**
* @dev Returns the downcasted uint168 from uint256, reverting on
* overflow (when the input is greater than largest uint168).
*
* Counterpart to Solidity's `uint168` operator.
*
* Requirements:
*
* - input must fit into 168 bits
*/
function toUint168(uint256 value) internal pure returns (uint168) {
if (value > type(uint168).max) {
revert SafeCastOverflowedUintDowncast(168, value);
}
return uint168(value);
}
/**
* @dev Returns the downcasted uint160 from uint256, reverting on
* overflow (when the input is greater than largest uint160).
*
* Counterpart to Solidity's `uint160` operator.
*
* Requirements:
*
* - input must fit into 160 bits
*/
function toUint160(uint256 value) internal pure returns (uint160) {
if (value > type(uint160).max) {
revert SafeCastOverflowedUintDowncast(160, value);
}
return uint160(value);
}
/**
* @dev Returns the downcasted uint152 from uint256, reverting on
* overflow (when the input is greater than largest uint152).
*
* Counterpart to Solidity's `uint152` operator.
*
* Requirements:
*
* - input must fit into 152 bits
*/
function toUint152(uint256 value) internal pure returns (uint152) {
if (value > type(uint152).max) {
revert SafeCastOverflowedUintDowncast(152, value);
}
return uint152(value);
}
/**
* @dev Returns the downcasted uint144 from uint256, reverting on
* overflow (when the input is greater than largest uint144).
*
* Counterpart to Solidity's `uint144` operator.
*
* Requirements:
*
* - input must fit into 144 bits
*/
function toUint144(uint256 value) internal pure returns (uint144) {
if (value > type(uint144).max) {
revert SafeCastOverflowedUintDowncast(144, value);
}
return uint144(value);
}
/**
* @dev Returns the downcasted uint136 from uint256, reverting on
* overflow (when the input is greater than largest uint136).
*
* Counterpart to Solidity's `uint136` operator.
*
* Requirements:
*
* - input must fit into 136 bits
*/
function toUint136(uint256 value) internal pure returns (uint136) {
if (value > type(uint136).max) {
revert SafeCastOverflowedUintDowncast(136, value);
}
return uint136(value);
}
/**
* @dev Returns the downcasted uint128 from uint256, reverting on
* overflow (when the input is greater than largest uint128).
*
* Counterpart to Solidity's `uint128` operator.
*
* Requirements:
*
* - input must fit into 128 bits
*/
function toUint128(uint256 value) internal pure returns (uint128) {
if (value > type(uint128).max) {
revert SafeCastOverflowedUintDowncast(128, value);
}
return uint128(value);
}
/**
* @dev Returns the downcasted uint120 from uint256, reverting on
* overflow (when the input is greater than largest uint120).
*
* Counterpart to Solidity's `uint120` operator.
*
* Requirements:
*
* - input must fit into 120 bits
*/
function toUint120(uint256 value) internal pure returns (uint120) {
if (value > type(uint120).max) {
revert SafeCastOverflowedUintDowncast(120, value);
}
return uint120(value);
}
/**
* @dev Returns the downcasted uint112 from uint256, reverting on
* overflow (when the input is greater than largest uint112).
*
* Counterpart to Solidity's `uint112` operator.
*
* Requirements:
*
* - input must fit into 112 bits
*/
function toUint112(uint256 value) internal pure returns (uint112) {
if (value > type(uint112).max) {
revert SafeCastOverflowedUintDowncast(112, value);
}
return uint112(value);
}
/**
* @dev Returns the downcasted uint104 from uint256, reverting on
* overflow (when the input is greater than largest uint104).
*
* Counterpart to Solidity's `uint104` operator.
*
* Requirements:
*
* - input must fit into 104 bits
*/
function toUint104(uint256 value) internal pure returns (uint104) {
if (value > type(uint104).max) {
revert SafeCastOverflowedUintDowncast(104, value);
}
return uint104(value);
}
/**
* @dev Returns the downcasted uint96 from uint256, reverting on
* overflow (when the input is greater than largest uint96).
*
* Counterpart to Solidity's `uint96` operator.
*
* Requirements:
*
* - input must fit into 96 bits
*/
function toUint96(uint256 value) internal pure returns (uint96) {
if (value > type(uint96).max) {
revert SafeCastOverflowedUintDowncast(96, value);
}
return uint96(value);
}
/**
* @dev Returns the downcasted uint88 from uint256, reverting on
* overflow (when the input is greater than largest uint88).
*
* Counterpart to Solidity's `uint88` operator.
*
* Requirements:
*
* - input must fit into 88 bits
*/
function toUint88(uint256 value) internal pure returns (uint88) {
if (value > type(uint88).max) {
revert SafeCastOverflowedUintDowncast(88, value);
}
return uint88(value);
}
/**
* @dev Returns the downcasted uint80 from uint256, reverting on
* overflow (when the input is greater than largest uint80).
*
* Counterpart to Solidity's `uint80` operator.
*
* Requirements:
*
* - input must fit into 80 bits
*/
function toUint80(uint256 value) internal pure returns (uint80) {
if (value > type(uint80).max) {
revert SafeCastOverflowedUintDowncast(80, value);
}
return uint80(value);
}
/**
* @dev Returns the downcasted uint72 from uint256, reverting on
* overflow (when the input is greater than largest uint72).
*
* Counterpart to Solidity's `uint72` operator.
*
* Requirements:
*
* - input must fit into 72 bits
*/
function toUint72(uint256 value) internal pure returns (uint72) {
if (value > type(uint72).max) {
revert SafeCastOverflowedUintDowncast(72, value);
}
return uint72(value);
}
/**
* @dev Returns the downcasted uint64 from uint256, reverting on
* overflow (when the input is greater than largest uint64).
*
* Counterpart to Solidity's `uint64` operator.
*
* Requirements:
*
* - input must fit into 64 bits
*/
function toUint64(uint256 value) internal pure returns (uint64) {
if (value > type(uint64).max) {
revert SafeCastOverflowedUintDowncast(64, value);
}
return uint64(value);
}
/**
* @dev Returns the downcasted uint56 from uint256, reverting on
* overflow (when the input is greater than largest uint56).
*
* Counterpart to Solidity's `uint56` operator.
*
* Requirements:
*
* - input must fit into 56 bits
*/
function toUint56(uint256 value) internal pure returns (uint56) {
if (value > type(uint56).max) {
revert SafeCastOverflowedUintDowncast(56, value);
}
return uint56(value);
}
/**
* @dev Returns the downcasted uint48 from uint256, reverting on
* overflow (when the input is greater than largest uint48).
*
* Counterpart to Solidity's `uint48` operator.
*
* Requirements:
*
* - input must fit into 48 bits
*/
function toUint48(uint256 value) internal pure returns (uint48) {
if (value > type(uint48).max) {
revert SafeCastOverflowedUintDowncast(48, value);
}
return uint48(value);
}
/**
* @dev Returns the downcasted uint40 from uint256, reverting on
* overflow (when the input is greater than largest uint40).
*
* Counterpart to Solidity's `uint40` operator.
*
* Requirements:
*
* - input must fit into 40 bits
*/
function toUint40(uint256 value) internal pure returns (uint40) {
if (value > type(uint40).max) {
revert SafeCastOverflowedUintDowncast(40, value);
}
return uint40(value);
}
/**
* @dev Returns the downcasted uint32 from uint256, reverting on
* overflow (when the input is greater than largest uint32).
*
* Counterpart to Solidity's `uint32` operator.
*
* Requirements:
*
* - input must fit into 32 bits
*/
function toUint32(uint256 value) internal pure returns (uint32) {
if (value > type(uint32).max) {
revert SafeCastOverflowedUintDowncast(32, value);
}
return uint32(value);
}
/**
* @dev Returns the downcasted uint24 from uint256, reverting on
* overflow (when the input is greater than largest uint24).
*
* Counterpart to Solidity's `uint24` operator.
*
* Requirements:
*
* - input must fit into 24 bits
*/
function toUint24(uint256 value) internal pure returns (uint24) {
if (value > type(uint24).max) {
revert SafeCastOverflowedUintDowncast(24, value);
}
return uint24(value);
}
/**
* @dev Returns the downcasted uint16 from uint256, reverting on
* overflow (when the input is greater than largest uint16).
*
* Counterpart to Solidity's `uint16` operator.
*
* Requirements:
*
* - input must fit into 16 bits
*/
function toUint16(uint256 value) internal pure returns (uint16) {
if (value > type(uint16).max) {
revert SafeCastOverflowedUintDowncast(16, value);
}
return uint16(value);
}
/**
* @dev Returns the downcasted uint8 from uint256, reverting on
* overflow (when the input is greater than largest uint8).
*
* Counterpart to Solidity's `uint8` operator.
*
* Requirements:
*
* - input must fit into 8 bits
*/
function toUint8(uint256 value) internal pure returns (uint8) {
if (value > type(uint8).max) {
revert SafeCastOverflowedUintDowncast(8, value);
}
return uint8(value);
}
/**
* @dev Converts a signed int256 into an unsigned uint256.
*
* Requirements:
*
* - input must be greater than or equal to 0.
*/
function toUint256(int256 value) internal pure returns (uint256) {
if (value < 0) {
revert SafeCastOverflowedIntToUint(value);
}
return uint256(value);
}
/**
* @dev Returns the downcasted int248 from int256, reverting on
* overflow (when the input is less than smallest int248 or
* greater than largest int248).
*
* Counterpart to Solidity's `int248` operator.
*
* Requirements:
*
* - input must fit into 248 bits
*/
function toInt248(int256 value) internal pure returns (int248 downcasted) {
downcasted = int248(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(248, value);
}
}
/**
* @dev Returns the downcasted int240 from int256, reverting on
* overflow (when the input is less than smallest int240 or
* greater than largest int240).
*
* Counterpart to Solidity's `int240` operator.
*
* Requirements:
*
* - input must fit into 240 bits
*/
function toInt240(int256 value) internal pure returns (int240 downcasted) {
downcasted = int240(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(240, value);
}
}
/**
* @dev Returns the downcasted int232 from int256, reverting on
* overflow (when the input is less than smallest int232 or
* greater than largest int232).
*
* Counterpart to Solidity's `int232` operator.
*
* Requirements:
*
* - input must fit into 232 bits
*/
function toInt232(int256 value) internal pure returns (int232 downcasted) {
downcasted = int232(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(232, value);
}
}
/**
* @dev Returns the downcasted int224 from int256, reverting on
* overflow (when the input is less than smallest int224 or
* greater than largest int224).
*
* Counterpart to Solidity's `int224` operator.
*
* Requirements:
*
* - input must fit into 224 bits
*/
function toInt224(int256 value) internal pure returns (int224 downcasted) {
downcasted = int224(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(224, value);
}
}
/**
* @dev Returns the downcasted int216 from int256, reverting on
* overflow (when the input is less than smallest int216 or
* greater than largest int216).
*
* Counterpart to Solidity's `int216` operator.
*
* Requirements:
*
* - input must fit into 216 bits
*/
function toInt216(int256 value) internal pure returns (int216 downcasted) {
downcasted = int216(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(216, value);
}
}
/**
* @dev Returns the downcasted int208 from int256, reverting on
* overflow (when the input is less than smallest int208 or
* greater than largest int208).
*
* Counterpart to Solidity's `int208` operator.
*
* Requirements:
*
* - input must fit into 208 bits
*/
function toInt208(int256 value) internal pure returns (int208 downcasted) {
downcasted = int208(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(208, value);
}
}
/**
* @dev Returns the downcasted int200 from int256, reverting on
* overflow (when the input is less than smallest int200 or
* greater than largest int200).
*
* Counterpart to Solidity's `int200` operator.
*
* Requirements:
*
* - input must fit into 200 bits
*/
function toInt200(int256 value) internal pure returns (int200 downcasted) {
downcasted = int200(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(200, value);
}
}
/**
* @dev Returns the downcasted int192 from int256, reverting on
* overflow (when the input is less than smallest int192 or
* greater than largest int192).
*
* Counterpart to Solidity's `int192` operator.
*
* Requirements:
*
* - input must fit into 192 bits
*/
function toInt192(int256 value) internal pure returns (int192 downcasted) {
downcasted = int192(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(192, value);
}
}
/**
* @dev Returns the downcasted int184 from int256, reverting on
* overflow (when the input is less than smallest int184 or
* greater than largest int184).
*
* Counterpart to Solidity's `int184` operator.
*
* Requirements:
*
* - input must fit into 184 bits
*/
function toInt184(int256 value) internal pure returns (int184 downcasted) {
downcasted = int184(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(184, value);
}
}
/**
* @dev Returns the downcasted int176 from int256, reverting on
* overflow (when the input is less than smallest int176 or
* greater than largest int176).
*
* Counterpart to Solidity's `int176` operator.
*
* Requirements:
*
* - input must fit into 176 bits
*/
function toInt176(int256 value) internal pure returns (int176 downcasted) {
downcasted = int176(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(176, value);
}
}
/**
* @dev Returns the downcasted int168 from int256, reverting on
* overflow (when the input is less than smallest int168 or
* greater than largest int168).
*
* Counterpart to Solidity's `int168` operator.
*
* Requirements:
*
* - input must fit into 168 bits
*/
function toInt168(int256 value) internal pure returns (int168 downcasted) {
downcasted = int168(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(168, value);
}
}
/**
* @dev Returns the downcasted int160 from int256, reverting on
* overflow (when the input is less than smallest int160 or
* greater than largest int160).
*
* Counterpart to Solidity's `int160` operator.
*
* Requirements:
*
* - input must fit into 160 bits
*/
function toInt160(int256 value) internal pure returns (int160 downcasted) {
downcasted = int160(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(160, value);
}
}
/**
* @dev Returns the downcasted int152 from int256, reverting on
* overflow (when the input is less than smallest int152 or
* greater than largest int152).
*
* Counterpart to Solidity's `int152` operator.
*
* Requirements:
*
* - input must fit into 152 bits
*/
function toInt152(int256 value) internal pure returns (int152 downcasted) {
downcasted = int152(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(152, value);
}
}
/**
* @dev Returns the downcasted int144 from int256, reverting on
* overflow (when the input is less than smallest int144 or
* greater than largest int144).
*
* Counterpart to Solidity's `int144` operator.
*
* Requirements:
*
* - input must fit into 144 bits
*/
function toInt144(int256 value) internal pure returns (int144 downcasted) {
downcasted = int144(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(144, value);
}
}
/**
* @dev Returns the downcasted int136 from int256, reverting on
* overflow (when the input is less than smallest int136 or
* greater than largest int136).
*
* Counterpart to Solidity's `int136` operator.
*
* Requirements:
*
* - input must fit into 136 bits
*/
function toInt136(int256 value) internal pure returns (int136 downcasted) {
downcasted = int136(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(136, value);
}
}
/**
* @dev Returns the downcasted int128 from int256, reverting on
* overflow (when the input is less than smallest int128 or
* greater than largest int128).
*
* Counterpart to Solidity's `int128` operator.
*
* Requirements:
*
* - input must fit into 128 bits
*/
function toInt128(int256 value) internal pure returns (int128 downcasted) {
downcasted = int128(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(128, value);
}
}
/**
* @dev Returns the downcasted int120 from int256, reverting on
* overflow (when the input is less than smallest int120 or
* greater than largest int120).
*
* Counterpart to Solidity's `int120` operator.
*
* Requirements:
*
* - input must fit into 120 bits
*/
function toInt120(int256 value) internal pure returns (int120 downcasted) {
downcasted = int120(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(120, value);
}
}
/**
* @dev Returns the downcasted int112 from int256, reverting on
* overflow (when the input is less than smallest int112 or
* greater than largest int112).
*
* Counterpart to Solidity's `int112` operator.
*
* Requirements:
*
* - input must fit into 112 bits
*/
function toInt112(int256 value) internal pure returns (int112 downcasted) {
downcasted = int112(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(112, value);
}
}
/**
* @dev Returns the downcasted int104 from int256, reverting on
* overflow (when the input is less than smallest int104 or
* greater than largest int104).
*
* Counterpart to Solidity's `int104` operator.
*
* Requirements:
*
* - input must fit into 104 bits
*/
function toInt104(int256 value) internal pure returns (int104 downcasted) {
downcasted = int104(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(104, value);
}
}
/**
* @dev Returns the downcasted int96 from int256, reverting on
* overflow (when the input is less than smallest int96 or
* greater than largest int96).
*
* Counterpart to Solidity's `int96` operator.
*
* Requirements:
*
* - input must fit into 96 bits
*/
function toInt96(int256 value) internal pure returns (int96 downcasted) {
downcasted = int96(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(96, value);
}
}
/**
* @dev Returns the downcasted int88 from int256, reverting on
* overflow (when the input is less than smallest int88 or
* greater than largest int88).
*
* Counterpart to Solidity's `int88` operator.
*
* Requirements:
*
* - input must fit into 88 bits
*/
function toInt88(int256 value) internal pure returns (int88 downcasted) {
downcasted = int88(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(88, value);
}
}
/**
* @dev Returns the downcasted int80 from int256, reverting on
* overflow (when the input is less than smallest int80 or
* greater than largest int80).
*
* Counterpart to Solidity's `int80` operator.
*
* Requirements:
*
* - input must fit into 80 bits
*/
function toInt80(int256 value) internal pure returns (int80 downcasted) {
downcasted = int80(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(80, value);
}
}
/**
* @dev Returns the downcasted int72 from int256, reverting on
* overflow (when the input is less than smallest int72 or
* greater than largest int72).
*
* Counterpart to Solidity's `int72` operator.
*
* Requirements:
*
* - input must fit into 72 bits
*/
function toInt72(int256 value) internal pure returns (int72 downcasted) {
downcasted = int72(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(72, value);
}
}
/**
* @dev Returns the downcasted int64 from int256, reverting on
* overflow (when the input is less than smallest int64 or
* greater than largest int64).
*
* Counterpart to Solidity's `int64` operator.
*
* Requirements:
*
* - input must fit into 64 bits
*/
function toInt64(int256 value) internal pure returns (int64 downcasted) {
downcasted = int64(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(64, value);
}
}
/**
* @dev Returns the downcasted int56 from int256, reverting on
* overflow (when the input is less than smallest int56 or
* greater than largest int56).
*
* Counterpart to Solidity's `int56` operator.
*
* Requirements:
*
* - input must fit into 56 bits
*/
function toInt56(int256 value) internal pure returns (int56 downcasted) {
downcasted = int56(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(56, value);
}
}
/**
* @dev Returns the downcasted int48 from int256, reverting on
* overflow (when the input is less than smallest int48 or
* greater than largest int48).
*
* Counterpart to Solidity's `int48` operator.
*
* Requirements:
*
* - input must fit into 48 bits
*/
function toInt48(int256 value) internal pure returns (int48 downcasted) {
downcasted = int48(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(48, value);
}
}
/**
* @dev Returns the downcasted int40 from int256, reverting on
* overflow (when the input is less than smallest int40 or
* greater than largest int40).
*
* Counterpart to Solidity's `int40` operator.
*
* Requirements:
*
* - input must fit into 40 bits
*/
function toInt40(int256 value) internal pure returns (int40 downcasted) {
downcasted = int40(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(40, value);
}
}
/**
* @dev Returns the downcasted int32 from int256, reverting on
* overflow (when the input is less than smallest int32 or
* greater than largest int32).
*
* Counterpart to Solidity's `int32` operator.
*
* Requirements:
*
* - input must fit into 32 bits
*/
function toInt32(int256 value) internal pure returns (int32 downcasted) {
downcasted = int32(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(32, value);
}
}
/**
* @dev Returns the downcasted int24 from int256, reverting on
* overflow (when the input is less than smallest int24 or
* greater than largest int24).
*
* Counterpart to Solidity's `int24` operator.
*
* Requirements:
*
* - input must fit into 24 bits
*/
function toInt24(int256 value) internal pure returns (int24 downcasted) {
downcasted = int24(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(24, value);
}
}
/**
* @dev Returns the downcasted int16 from int256, reverting on
* overflow (when the input is less than smallest int16 or
* greater than largest int16).
*
* Counterpart to Solidity's `int16` operator.
*
* Requirements:
*
* - input must fit into 16 bits
*/
function toInt16(int256 value) internal pure returns (int16 downcasted) {
downcasted = int16(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(16, value);
}
}
/**
* @dev Returns the downcasted int8 from int256, reverting on
* overflow (when the input is less than smallest int8 or
* greater than largest int8).
*
* Counterpart to Solidity's `int8` operator.
*
* Requirements:
*
* - input must fit into 8 bits
*/
function toInt8(int256 value) internal pure returns (int8 downcasted) {
downcasted = int8(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(8, value);
}
}
/**
* @dev Converts an unsigned uint256 into a signed int256.
*
* Requirements:
*
* - input must be less than or equal to maxInt256.
*/
function toInt256(uint256 value) internal pure returns (int256) {
// Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive
if (value > uint256(type(int256).max)) {
revert SafeCastOverflowedUintToInt(value);
}
return int256(value);
}
/**
* @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.
*/
function toUint(bool b) internal pure returns (uint256 u) {
assembly ("memory-safe") {
u := iszero(iszero(b))
}
}
}
// lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol
// OpenZeppelin Contracts (last updated v5.0.0) (utils/StorageSlot.sol)
// This file was procedurally generated from scripts/generate/templates/StorageSlot.js.
/**
* @dev Library for reading and writing primitive types to specific storage slots.
*
* Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.
* This library helps with reading and writing to such slots without the need for inline assembly.
*
* The functions in this library return Slot structs that contain a `value` member that can be used to read or write.
*
* Example usage to set ERC-1967 implementation slot:
* ```solidity
* contract ERC1967 {
* // Define the slot. Alternatively, use the SlotDerivation library to derive the slot.
* bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
*
* function _getImplementation() internal view returns (address) {
* return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
* }
*
* function _setImplementation(address newImplementation) internal {
* require(newImplementation.code.length > 0);
* StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
* }
* }
* ```
*
* Since version 5.1, this library also support writing and reading value types to and from transient storage.
*
* * Example using transient storage:
* ```solidity
* contract Lock {
* // Define the slot. Alternatively, use the SlotDerivation library to derive the slot.
* bytes32 internal constant _LOCK_SLOT = 0xf4678858b2b588224636b8522b729e7722d32fc491da849ed75b3fdf3c84f542;
*
* modifier locked() {
* require(!_LOCK_SLOT.asBoolean().tload());
*
* _LOCK_SLOT.asBoolean().tstore(true);
* _;
* _LOCK_SLOT.asBoolean().tstore(false);
* }
* }
* ```
*
* TIP: Consider using this library along with {SlotDerivation}.
*/
library StorageSlot {
struct AddressSlot {
address value;
}
struct BooleanSlot {
bool value;
}
struct Bytes32Slot {
bytes32 value;
}
struct Uint256Slot {
uint256 value;
}
struct Int256Slot {
int256 value;
}
struct StringSlot {
string value;
}
struct BytesSlot {
bytes value;
}
/**
* @dev Returns an `AddressSlot` with member `value` located at `slot`.
*/
function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
assembly ("memory-safe") {
r.slot := slot
}
}
/**
* @dev Returns a `BooleanSlot` with member `value` located at `slot`.
*/
function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
assembly ("memory-safe") {
r.slot := slot
}
}
/**
* @dev Returns a `Bytes32Slot` with member `value` located at `slot`.
*/
function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
assembly ("memory-safe") {
r.slot := slot
}
}
/**
* @dev Returns a `Uint256Slot` with member `value` located at `slot`.
*/
function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
assembly ("memory-safe") {
r.slot := slot
}
}
/**
* @dev Returns a `Int256Slot` with member `value` located at `slot`.
*/
function getInt256Slot(bytes32 slot) internal pure returns (Int256Slot storage r) {
assembly ("memory-safe") {
r.slot := slot
}
}
/**
* @dev Returns a `StringSlot` with member `value` located at `slot`.
*/
function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {
assembly ("memory-safe") {
r.slot := slot
}
}
/**
* @dev Returns an `StringSlot` representation of the string storage pointer `store`.
*/
function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {
assembly ("memory-safe") {
r.slot := store.slot
}
}
/**
* @dev Returns a `BytesSlot` with member `value` located at `slot`.
*/
function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {
assembly ("memory-safe") {
r.slot := slot
}
}
/**
* @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`.
*/
function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {
assembly ("memory-safe") {
r.slot := store.slot
}
}
/**
* @dev UDVT that represent a slot holding a address.
*/
type AddressSlotType is bytes32;
/**
* @dev Cast an arbitrary slot to a AddressSlotType.
*/
function asAddress(bytes32 slot) internal pure returns (AddressSlotType) {
return AddressSlotType.wrap(slot);
}
/**
* @dev UDVT that represent a slot holding a bool.
*/
type BooleanSlotType is bytes32;
/**
* @dev Cast an arbitrary slot to a BooleanSlotType.
*/
function asBoolean(bytes32 slot) internal pure returns (BooleanSlotType) {
return BooleanSlotType.wrap(slot);
}
/**
* @dev UDVT that represent a slot holding a bytes32.
*/
type Bytes32SlotType is bytes32;
/**
* @dev Cast an arbitrary slot to a Bytes32SlotType.
*/
function asBytes32(bytes32 slot) internal pure returns (Bytes32SlotType) {
return Bytes32SlotType.wrap(slot);
}
/**
* @dev UDVT that represent a slot holding a uint256.
*/
type Uint256SlotType is bytes32;
/**
* @dev Cast an arbitrary slot to a Uint256SlotType.
*/
function asUint256(bytes32 slot) internal pure returns (Uint256SlotType) {
return Uint256SlotType.wrap(slot);
}
/**
* @dev UDVT that represent a slot holding a int256.
*/
type Int256SlotType is bytes32;
/**
* @dev Cast an arbitrary slot to a Int256SlotType.
*/
function asInt256(bytes32 slot) internal pure returns (Int256SlotType) {
return Int256SlotType.wrap(slot);
}
/**
* @dev Load the value held at location `slot` in transient storage.
*/
function tload(AddressSlotType slot) internal view returns (address value) {
assembly ("memory-safe") {
value := tload(slot)
}
}
/**
* @dev Store `value` at location `slot` in transient storage.
*/
function tstore(AddressSlotType slot, address value) internal {
assembly ("memory-safe") {
tstore(slot, value)
}
}
/**
* @dev Load the value held at location `slot` in transient storage.
*/
function tload(BooleanSlotType slot) internal view returns (bool value) {
assembly ("memory-safe") {
value := tload(slot)
}
}
/**
* @dev Store `value` at location `slot` in transient storage.
*/
function tstore(BooleanSlotType slot, bool value) internal {
assembly ("memory-safe") {
tstore(slot, value)
}
}
/**
* @dev Load the value held at location `slot` in transient storage.
*/
function tload(Bytes32SlotType slot) internal view returns (bytes32 value) {
assembly ("memory-safe") {
value := tload(slot)
}
}
/**
* @dev Store `value` at location `slot` in transient storage.
*/
function tstore(Bytes32SlotType slot, bytes32 value) internal {
assembly ("memory-safe") {
tstore(slot, value)
}
}
/**
* @dev Load the value held at location `slot` in transient storage.
*/
function tload(Uint256SlotType slot) internal view returns (uint256 value) {
assembly ("memory-safe") {
value := tload(slot)
}
}
/**
* @dev Store `value` at location `slot` in transient storage.
*/
function tstore(Uint256SlotType slot, uint256 value) internal {
assembly ("memory-safe") {
tstore(slot, value)
}
}
/**
* @dev Load the value held at location `slot` in transient storage.
*/
function tload(Int256SlotType slot) internal view returns (int256 value) {
assembly ("memory-safe") {
value := tload(slot)
}
}
/**
* @dev Store `value` at location `slot` in transient storage.
*/
function tstore(Int256SlotType slot, int256 value) internal {
assembly ("memory-safe") {
tstore(slot, value)
}
}
}
// src/Types.sol
/// @dev Types.sol defines the Token struct data types used in the TokenStorage layout
/// @dev represents data related to $MINT token accruals (linked to a specific account)
struct AccrualData {
/// @dev last ratio an account had when one of their actions led to a change in the
/// distributionSupply
uint256 offset;
/// @dev amount of tokens accrued as a result of distribution to token holders
uint256 accruedTokens;
}
/// @dev struct representing the basis point values used to initialize the Token
/// and get around stack too deep
struct InitializationBasisPointValues {
/// @dev fraction of attempt value going to distribution fund in basis points
uint256 distributionFractionBP;
/// @dev fraction of attempt value going to trades fund in basis points
uint256 tradesFractionBP;
/// @dev fraction of attempt value going to token backing fund in basis points
uint256 tokenBackingFractionBP;
/// @dev fraction of mint attempt value as fees for protocol in basis points
uint256 protocolFeeBP;
/// @dev fraction of mint attempt value going to repayment fund in basis points
uint256 repaymentFractionBP;
/// @dev fraction of mint attempt value going to mummy pocket money fund in basis points
uint256 mummyPocketMoneyFractionBP;
}
/// @dev struct representing the addresses used to initialize the Token
struct InitializationAddresses {
/// @dev address of the admin
address admin;
/// @dev address of the manager
address manager;
/// @dev address of the fund manager
address fundManager;
/// @dev address of the address manager
address addressManager;
/// @dev address of the pauser
address pauser;
/// @dev address of the upgrader
address upgrader;
/// @dev address of the service
address service;
/// @dev address of the minter
address minter;
/// @dev address of the treasury
address treasury;
/// @dev address of the trades wallet
address tradesWallet;
}
/// @dev struct representing an account and amount to be refunded
struct Refund {
/// @dev account that is being refunded
address account;
/// @dev amount being refunded
uint256 amount;
}
/// @dev enum representing the different funds in the Token
enum Fund {
/// @dev fees fund
FEES,
/// @dev earnings fund
EARNINGS,
/// @dev trades fund
TRADES,
/// @dev token backing fund
TOKEN_BACKING,
/// @dev repayment fund
REPAYMENT
}
// lib/openzeppelin-contracts/contracts/interfaces/draft-IERC1822.sol
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/draft-IERC1822.sol)
/**
* @dev ERC-1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified
* proxy whose upgrades are fully controlled by the current implementation.
*/
interface IERC1822Proxiable {
/**
* @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation
* address.
*
* IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks
* bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this
* function revert if invoked through a proxy.
*/
function proxiableUUID() external view returns (bytes32);
}
// lib/openzeppelin-contracts/contracts/interfaces/draft-IERC6093.sol
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/draft-IERC6093.sol)
/**
* @dev Standard ERC-20 Errors
* Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-20 tokens.
*/
interface IERC20Errors {
/**
* @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
* @param sender Address whose tokens are being transferred.
* @param balance Current balance for the interacting account.
* @param needed Minimum amount required to perform a transfer.
*/
error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);
/**
* @dev Indicates a failure with the token `sender`. Used in transfers.
* @param sender Address whose tokens are being transferred.
*/
error ERC20InvalidSender(address sender);
/**
* @dev Indicates a failure with the token `receiver`. Used in transfers.
* @param receiver Address to which tokens are being transferred.
*/
error ERC20InvalidReceiver(address receiver);
/**
* @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.
* @param spender Address that may be allowed to operate on tokens without being their owner.
* @param allowance Amount of tokens a `spender` is allowed to operate with.
* @param needed Minimum amount required to perform a transfer.
*/
error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);
/**
* @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
* @param approver Address initiating an approval operation.
*/
error ERC20InvalidApprover(address approver);
/**
* @dev Indicates a failure with the `spender` to be approved. Used in approvals.
* @param spender Address that may be allowed to operate on tokens without being their owner.
*/
error ERC20InvalidSpender(address spender);
}
/**
* @dev Standard ERC-721 Errors
* Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-721 tokens.
*/
interface IERC721Errors {
/**
* @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in ERC-20.
* Used in balance queries.
* @param owner Address of the current owner of a token.
*/
error ERC721InvalidOwner(address owner);
/**
* @dev Indicates a `tokenId` whose `owner` is the zero address.
* @param tokenId Identifier number of a token.
*/
error ERC721NonexistentToken(uint256 tokenId);
/**
* @dev Indicates an error related to the ownership over a particular token. Used in transfers.
* @param sender Address whose tokens are being transferred.
* @param tokenId Identifier number of a token.
* @param owner Address of the current owner of a token.
*/
error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);
/**
* @dev Indicates a failure with the token `sender`. Used in transfers.
* @param sender Address whose tokens are being transferred.
*/
error ERC721InvalidSender(address sender);
/**
* @dev Indicates a failure with the token `receiver`. Used in transfers.
* @param receiver Address to which tokens are being transferred.
*/
error ERC721InvalidReceiver(address receiver);
/**
* @dev Indicates a failure with the `operator`’s approval. Used in transfers.
* @param operator Address that may be allowed to operate on tokens without being their owner.
* @param tokenId Identifier number of a token.
*/
error ERC721InsufficientApproval(address operator, uint256 tokenId);
/**
* @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
* @param approver Address initiating an approval operation.
*/
error ERC721InvalidApprover(address approver);
/**
* @dev Indicates a failure with the `operator` to be approved. Used in approvals.
* @param operator Address that may be allowed to operate on tokens without being their owner.
*/
error ERC721InvalidOperator(address operator);
}
/**
* @dev Standard ERC-1155 Errors
* Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-1155 tokens.
*/
interface IERC1155Errors {
/**
* @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
* @param sender Address whose tokens are being transferred.
* @param balance Current balance for the interacting account.
* @param needed Minimum amount required to perform a transfer.
* @param tokenId Identifier number of a token.
*/
error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);
/**
* @dev Indicates a failure with the token `sender`. Used in transfers.
* @param sender Address whose tokens are being transferred.
*/
error ERC1155InvalidSender(address sender);
/**
* @dev Indicates a failure with the token `receiver`. Used in transfers.
* @param receiver Address to which tokens are being transferred.
*/
error ERC1155InvalidReceiver(address receiver);
/**
* @dev Indicates a failure with the `operator`’s approval. Used in transfers.
* @param operator Address that may be allowed to operate on tokens without being their owner.
* @param owner Address of the current owner of a token.
*/
error ERC1155MissingApprovalForAll(address operator, address owner);
/**
* @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
* @param approver Address initiating an approval operation.
*/
error ERC1155InvalidApprover(address approver);
/**
* @dev Indicates a failure with the `operator` to be approved. Used in approvals.
* @param operator Address that may be allowed to operate on tokens without being their owner.
*/
error ERC1155InvalidOperator(address operator);
/**
* @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.
* Used in batch transfers.
* @param idsLength Length of the array of token identifiers
* @param valuesLength Length of the array of token amounts
*/
error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);
}
// lib/openzeppelin-contracts/contracts/utils/Address.sol
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Address.sol)
/**
* @dev Collection of functions related to the address type
*/
library Address {
/**
* @dev There's no code at `target` (it is not a contract).
*/
error AddressEmptyCode(address target);
/**
* @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://consensys.net/diligence/blog/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.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
if (address(this).balance < amount) {
revert Errors.InsufficientBalance(address(this).balance, amount);
}
(bool success, ) = recipient.call{value: amount}("");
if (!success) {
revert Errors.FailedCall();
}
}
/**
* @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 or custom error, it is bubbled
* up by this function (like regular Solidity function calls). However, if
* the call reverted with no returned reason, this function reverts with a
* {Errors.FailedCall} error.
*
* 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.
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0);
}
/**
* @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`.
*/
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
if (address(this).balance < value) {
revert Errors.InsufficientBalance(address(this).balance, value);
}
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata);
}
/**
* @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target
* was not a contract or bubbling up the revert reason (falling back to {Errors.FailedCall}) in case
* of an unsuccessful call.
*/
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata
) internal view returns (bytes memory) {
if (!success) {
_revert(returndata);
} else {
// only check if target is a contract if the call was successful and the return data is empty
// otherwise we already know that it was a contract
if (returndata.length == 0 && target.code.length == 0) {
revert AddressEmptyCode(target);
}
return returndata;
}
}
/**
* @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the
* revert reason or with a default {Errors.FailedCall} error.
*/
function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {
if (!success) {
_revert(returndata);
} else {
return returndata;
}
}
/**
* @dev Reverts with returndata if present. Otherwise reverts with {Errors.FailedCall}.
*/
function _revert(bytes memory returndata) private pure {
// 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
assembly ("memory-safe") {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert Errors.FailedCall();
}
}
}
// lib/openzeppelin-contracts-upgradeable/contracts/utils/ContextUpgradeable.sol
// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract ContextUpgradeable is Initializable {
function __Context_init() internal onlyInitializing {
}
function __Context_init_unchained() internal onlyInitializing {
}
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
function _contextSuffixLength() internal view virtual returns (uint256) {
return 0;
}
}
// lib/openzeppelin-contracts/contracts/token/ERC20/extensions/IERC20Metadata.sol
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Metadata.sol)
/**
* @dev Interface for the optional metadata functions from the ERC-20 standard.
*/
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);
}
// src/IToken.sol
/// @title IToken
/// @dev interface for Token contract containing all events, errors, and external/public functions
interface IToken {
/// @notice thrown when the length of two arrays do not match
error ArrayLengthMismatch();
/// @notice thrown when attempting to set a value larger than basis
error BasisExceeded();
/// @notice thrown when attempting to set a new value which would mean that the sum of all
/// fractions to be taken from the attempt amount exceeds basis
error FractionSumExceedsBasis();
/// @notice thrown when attempting to reallocate funds to the 'from' fund
error FundSelfTransfer();
/// @notice thrown when attempting to withdarw an amount larger than current earnings
error InsufficientEarnings();
/// @notice thrown when attempting to refund an amount larger than current repayment fund
error InsufficientRepaymentFund();
/// @notice thrown when attempting a mint attempt with Token but there is insufficient token backing
/// to cover the attempt
error InsufficientTokenBacking();
/// @notice thrown when a non-existent fund is being accessed
error InvalidFund();
/// @notice thrown when attempting on a gameId not contained in gameIds enumerable set
error InvalidGameId();
/// @notice thrown when the proof for a social claim is not matching the _msgSender() claiming and amount to claim
error InvalidProof();
/// @notice thrown when attempting to withdraw token backing liquidity but the amount is greater than the current
/// token backing fund amount
error TokenBackingFundTooLow();
/// @notice thrown when attempting to set a mummy pocket money fraction BP which is greater than the trades fraction BP
error TradesFractionExceeded();
/// @notice thrown when attempting to withdraw trades wallet funds but the amount is greater than the current
/// trades fund amount
error TradesFundTooLow();
/// @notice thrown when attempting to transfer tokens and the from address is neither
/// the zero-address, nor the contract address, or the to address is not the zero address
error NonTransferable();
/// @notice thrown when attempting to set a value to the zero address
error ZeroAddress();
/// @notice thrown when attempting on a game with zero amount ie zending 0 tokens or native currency (ETH)
error ZeroAmountAttempt();
/// @notice emitted when an attempt is made on a game
/// @param gameId of game being attempted
/// @param account address of account attempting game
/// @param amount msg.value received on attempt call
/// @param attemptId UUID of attempt
event AttemptMade(
uint256 gameId,
address account,
uint256 amount,
string attemptId
);
/// @notice emitted when an attempt is made on a game, with `Token` used as payment
/// @param gameId of game being attempted
/// @param account address of account attempting game
/// @param amount amount of `Token` received
/// @param amountValue amount of ETH corresponding to `Token` amount received
/// @param attemptId UUID of attempt
event AttemptWithTokenMade(
uint256 gameId,
address account,
uint256 amount,
uint256 amountValue,
string attemptId
);
/// @notice emitted when an airdrop is minted
/// @param amount `Token` amount to mint for airdrop
event AirdropMinted(uint256 amount);
/// @notice emitted when a batch refund is processed
/// @param refunds array of Refund structs
event BatchRefundProcessed(Refund[] refunds);
/// @notice emitted when a new distributionFractionBP value is set
/// @param distributionFractionBP the new distributionFractionBP value
event DistributionFractionSet(uint256 distributionFractionBP);
/// @notice emitted when earnings are withdrawn
/// @param amount earnings withdrawn
event EarningsWithdrawn(uint256 amount);
/// @notice emitted when fees are withdraw and sent to reasury
event FeesWithdrawn(uint256 fees);
/// @notice emitted when funds are reallocated from one fund to another
/// @param from Fund debited
/// @param to Fund credited
/// @param amount Amount reallocated
event FundsReallocated(Fund from, Fund to, uint256 amount);
/// @notice emitted when a new gameId is added to gameIds
/// @param gameId id of new game
event GameIdAdded(uint256 gameId);
/// @notice emitted when a new value of repaymentFractionBP is set
/// @param repaymentFractionBP new repaymentFractionBP value
event RepaymentFractionSet(uint256 repaymentFractionBP);
/// @notice emitted when token backing liquidity is withdrawn
/// @param amount token backing liquidity withdrawn
event TokenBackingLiquidityWithdrawn(uint256 amount);
/// @notice emitted when a new value of tradesFractionBP is set
/// @param tradesFractionBP new tradesFractionBP value
event TradesFractionSet(uint256 tradesFractionBP);
/// @notice emitted when a new value of tradesWallet is set
/// @param wallet new tradesWallet value
event TradesWalletSet(address wallet);
/// @notice emitted when trades funds are sent to trades wallet
/// @param amount funded
event TradesWalletFunded(uint256 amount);
/// @notice emitted when an account is added to minters
/// @param account address of account
event MinterAdded(address account);
/// @notice emitted when an account is removed from minters
/// @param account address of account
event MinterRemoved(address account);
/// @notice emitted when a new value of mummyPocketMoneyFloor is set
/// @param mummyPocketMoneyFloor new mummyPocketMoneyFloor value
event MummyPocketMoneyFloorSet(uint256 mummyPocketMoneyFloor);
/// @notice emitted when a new value of mummyPocketMoneyFractionBP is set
/// @param mummyPocketMoneyFractionBP new mummyPocketMoneyFractionBP value
event MummyPocketMoneyFractionSet(uint256 mummyPocketMoneyFractionBP);
/// @notice emitted when mummy pocket money is reset
/// @param attemptId UUID of attempt
/// @param mummyPocketMoney value of mummy pocket money in ETH
event MummyPocketMoneyReset(string attemptId, uint256 mummyPocketMoney);
/// @notice emitted when a new period for earnings has started
/// @param currentEarnings value of period earnings at end of last period
event NewPeriodStarted(uint256 currentEarnings);
/// @notice emitted when a new value of protocolFeeBP is set
/// @param protocolFeeBP new protocolFeeBP value
event ProtocolFeeSet(uint256 protocolFeeBP);
/// @notice emitted when repayment liquidity is injected
/// @param amount injected
event RepaymentLiquidityInjected(uint256 amount);
/// @notice emitted when an account claims social earnings
/// @param account address of account which claimed
/// @param amount amount claimed as social earnings
event SocialEarningsClaimed(address account, uint256 amount);
/// @notice emitted when a new socialRoot value is set
/// @param root new socialRoot value
event SocialRootSet(bytes32 root);
/// @notice emitted when a new value of tokenBackingFractionBP is set
/// @param fractionBP new tokenBackingFractionBP value
event TokenBackingFractionSet(uint256 fractionBP);
/// @notice emitted when token backing funds are injected
/// @param amount injected
event TokenBackingLiquidityInjected(uint256 amount);
/// @notice emitted when trades funds are injected
/// @param amount injected
event TradesLiquidityInjected(uint256 amount);
/// @notice emitted when a new value of treasury is set
/// @param treasury new treasury value
event TreasurySet(address treasury);
/// @notice initializing function of Token contract
/// @param name name of Token
/// @param symbol symbol of Token
/// @param addresses InitializationAddresses struct containing addresses of admin, manager,
/// fundManager, addressManager, upgrader, service, pauser, minter, treasury, tradesWallet
/// @param basisPointValues InitializationBasisPointValues struct containing distributionFractionBP, tradesFractionBP,
/// tokenBackingFractionBP, and protocolFeeBP
function __Token_init(
string memory name,
string memory symbol,
InitializationAddresses calldata addresses,
InitializationBasisPointValues calldata basisPointValues
) external;
/// @notice adds a new game id to gameIds
/// @param id new game id
function addGameId(uint256 id) external;
/// @notice makes an attempt on a game matching gameId on behalf of _msgSender()
/// @param gameId id of game being attempted
/// @param attemptId UUID of attempt
function attempt(
uint256 gameId,
string calldata attemptId
) external payable;
/// @notice makes an attempt on a game matching gameId on behalf of _msgSender()
/// using `Token` as payment
/// @param gameId id of game being attempted
/// @param size amount of `Token` used as payment
/// @param attemptId UUID of attempt
function attemptWithToken(
uint256 gameId,
uint256 size,
string calldata attemptId
) external;
/// @notice processes a batch refund for a list of accounts and amounts, sending
/// the amount of ETH corresponding to each account's refund amount
/// @param refunds array of Refund structs
function batchRefund(Refund[] calldata refunds) external;
/// @notice claims all claimable tokens for the _msgSender()
function claim() external;
/// @notice sends an amount of ETH as social earnings to _msgSender() from the `earnings`
/// @param proof merkle proof data to verify against
/// @param amount total amount earned thus far by _msgSender()
function claimSocialEarnings(
bytes32[] calldata proof,
uint256 amount
) external;
/// @notice Disperses tokens to a list of recipients
/// @param recipients assumed ordered array of recipient addresses
/// @param amounts assumed ordered array of token amounts to disperse
function disperseTokens(
address[] calldata recipients,
uint256[] calldata amounts
) external;
/// @notice returns AccrualData struct pertaining to account, which contains Token accrual
/// information
/// @param account address of account
/// @return data AccrualData of account
function getAccrualData(
address account
) external view returns (AccrualData memory data);
/// @notice returns value of airdropSupply
/// @return supply value of airdropSupply
function getAirdropSupply() external view returns (uint256 supply);
/// @notice returns all claimable tokens of a given account
/// @param account address of account
/// @return amount amount of claimable tokens
function getClaimableTokens(
address account
) external view returns (uint256 amount);
/// @notice returns the distributionFractionBP value
/// @return fractionBP value of distributionFractionBP
function getDistributionFractionBP()
external
view
returns (uint256 fractionBP);
/// @notice returns the distribution supply value
/// @return supply distribution supply value
function getDistributionSupply() external view returns (uint256 supply);
/// @notice returns earnings from attempts
/// @return earnings current earnings
function getEarnings() external view returns (uint256 earnings);
/// @notice returns fees earned from attempts
/// @return fees current fees accrued from mint attempts
function getFees() external view returns (uint256 fees);
/// @notice returns game ids of games which can be played
/// @return ids array of game ids which can be played
function getGameIds() external view returns (uint256[] memory ids);
/// @notice returns the global ratio value
/// @return ratio global ratio value
function getGlobalRatio() external view returns (uint256 ratio);
/// @notice returns the mummy pocket money value in ETH
/// @return mummyPocketMoney value of mummy pocket money in ETH
function getMummyPocketMoney()
external
view
returns (uint256 mummyPocketMoney);
/// @notice returns the mummy pocket money floor value in ETH
/// @return mummyPocketMoneyFloor value of mummy pocket money floor
function getMummyPocketMoneyFloor()
external
view
returns (uint256 mummyPocketMoneyFloor);
/// @notice returns the mummy pocket money fraction in basis points
/// @return mummyPocketMoneyFractionBP value of mummy pocket money fraction in basis points
function getMummyPocketMoneyFractionBP()
external
view
returns (uint256 mummyPocketMoneyFractionBP);
/// @notice returns the period earnings value
/// @return earnings current value of period earnings
function getPeriodEarnings() external view returns (uint256 earnings);
/// @notice returns value of protocol fee in basis points
/// @return protocolFeeBP value of protocol fee in basis points
function getProtocolFeeBP() external view returns (uint256 protocolFeeBP);
/// @notice returns value of repayment fraction in basis points
/// @return fractionBP value of repayment fraction in basis points
function getRepaymentFractionBP()
external
view
returns (uint256 fractionBP);
/// @notice returns ETH currently in repayment fund
/// @return fund ETH in repayment fund
function getRepaymentFund() external view returns (uint256 fund);
/// @notice returns the social earnings deduction of an account
/// @param account address of account to get deductions for
/// @return deduction social earnings deduction of account
function getSocialEarningsDeduction(
address account
) external view returns (uint256 deduction);
/// @notice retruns value of socialRoot
/// @return root value of socialRoot
function getSocialRoot() external view returns (bytes32 root);
/// @notice returns value of tokenBackingFractionBP
/// @return fractionBP value of tokenBackingFractionBP
function getTokenBackingFractionBP()
external
view
returns (uint256 fractionBP);
/// @notice returns value of tokenBackingFund
/// @return fund value of tokenBackingFund
function getTokenBackingFund() external view returns (uint256 fund);
/// @notice returns the trades fraction in basis points
/// @return fractionBP value of trades fraction in basis points
function getTradesFractionBP() external view returns (uint256 fractionBP);
/// @notice returns the trades fund value
/// @return fund value of trades fund
function getTradesFund() external view returns (uint256 fund);
/// @notice returns the trades wallet address
/// @return wallet address of trades wallet
function getTradesWallet() external view returns (address wallet);
/// @notice returns address of treasury
/// @return treasury address of treasury
function getTreasury() external view returns (address treasury);
/// @notice injects liquidity into the repayment fund
function injectRepaymentLiquidity() external payable;
/// @notice injects liquidity into the token backing fund
function injectTokenBackingLiquidity() external payable;
/// @notice injects liquidity into the trades fund
function injectTradesLiquidity() external payable;
/// @notice mint an amount of tokens to an account
/// @param account address of account receive the tokens
/// @param amount amount of tokens to mint
function mint(address account, uint256 amount) external;
/// @notice mints an amount of tokens intended for airdrop
/// @param amount airdrop token amount
function mintAirdrop(uint256 amount) external payable;
/// @notice pauses minting
function pause() external;
/// @notice reallocates funds from one fund to another
/// @param from Fund to debit
/// @param to Fund to credit
/// @param amount Amount to reallocate
function reallocateFunds(Fund from, Fund to, uint256 amount) external;
/// @notice resets mummy pocket money to the floor value
/// @param attemptId UUID of attempt
/// @return mummyPocketMoney value of mummy pocket money in ETH
function resetMummyPocketMoney(
string calldata attemptId
) external returns (uint256 mummyPocketMoney);
/// @notice sets a new value for distributionFractionBP
/// @param distributionFractionBP new distributionFractionBP value
function setDistributionFractionBP(uint256 distributionFractionBP) external;
/// @notice sets a new value for mummyPocketMoneyFloor
/// @param mummyPocketMoneyFloor new mummyPocketMoneyFloor value
function setMummyPocketMoneyFloor(uint256 mummyPocketMoneyFloor) external;
/// @notice sets a new value for mummyPocketMoneyFractionBP
/// @param mummyPocketMoneyFractionBP new mummyPocketMoneyFractionBP value
function setMummyPocketMoneyFractionBP(
uint256 mummyPocketMoneyFractionBP
) external;
/// @notice sets a new value for repaymentFractionBP
/// @param repaymentFractionBP new repaymentFractionBP value
function setRepaymentFractionBP(uint256 repaymentFractionBP) external;
/// @notice sets a new value for tradesFractionBP
/// @param tradesFractionBP new tradesFractionBP value
function setTradesFractionBP(uint256 tradesFractionBP) external;
/// @notice sets a new value for tradesWallet
/// @param tradesWallet new tradesWallet value
function setTradesWallet(address tradesWallet) external;
/// @notice sets a new value for protocolFeeBP
/// @param protocolFeeBP new protocolFeeBP value
function setProtocolFeeBP(uint256 protocolFeeBP) external;
/// @notice begins a new period for earnings
/// @return currentEarnings returns current value of earnings for given period
function startNewPeriod() external returns (uint256 currentEarnings);
/// @notice sets a new value for the socialRoot
/// @param root new socialRoot value
function setSocialRoot(bytes32 root) external;
/// @notice sets a new value for tokenBackingFractionBP
/// @param tokenBackingFractionBP new tokenBackingFractionBP value
function setTokenBackingFractionBP(uint256 tokenBackingFractionBP) external;
/// @notice sets a new value for treasury
/// @param treasury new treasury value
function setTreasury(address treasury) external;
/// @notice unpauses minting
function unpause() external;
/// @notice withdraws an amount of ETH from earnings and sends to treasury
/// @param amount withdrawal amount
function withdrawEarnings(uint256 amount) external;
/// @notice withdraws fees and sends to treasury
function withdrawFees() external;
/// @notice withdraws an amount of token backing liquidity and sends to treasury
/// @param amount withdrawal amount
function withdrawTokenBackingLiquidity(uint256 amount) external;
/// @notice withdraws an amount of trades funds and sends to trades wallet
/// @param amount withdrawal amount
function withdrawTradesWalletFunds(uint256 amount) external;
}
// lib/openzeppelin-contracts/contracts/utils/cryptography/MerkleProof.sol
// OpenZeppelin Contracts (last updated v5.0.0) (utils/cryptography/MerkleProof.sol)
// This file was procedurally generated from scripts/generate/templates/MerkleProof.js.
/**
* @dev These functions deal with verification of Merkle Tree proofs.
*
* The tree and the proofs can be generated using our
* https://github.com/OpenZeppelin/merkle-tree[JavaScript library].
* You will find a quickstart guide in the readme.
*
* WARNING: You should avoid using leaf values that are 64 bytes long prior to
* hashing, or use a hash function other than keccak256 for hashing leaves.
* This is because the concatenation of a sorted pair of internal nodes in
* the Merkle tree could be reinterpreted as a leaf value.
* OpenZeppelin's JavaScript library generates Merkle trees that are safe
* against this attack out of the box.
*
* IMPORTANT: Consider memory side-effects when using custom hashing functions
* that access memory in an unsafe way.
*
* NOTE: This library supports proof verification for merkle trees built using
* custom _commutative_ hashing functions (i.e. `H(a, b) == H(b, a)`). Proving
* leaf inclusion in trees built using non-commutative hashing functions requires
* additional logic that is not supported by this library.
*/
library MerkleProof {
/**
*@dev The multiproof provided is not valid.
*/
error MerkleProofInvalidMultiproof();
/**
* @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
* defined by `root`. For this, a `proof` must be provided, containing
* sibling hashes on the branch from the leaf to the root of the tree. Each
* pair of leaves and each pair of pre-images are assumed to be sorted.
*
* This version handles proofs in memory with the default hashing function.
*/
function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
return processProof(proof, leaf) == root;
}
/**
* @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
* from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
* hash matches the root of the tree. When processing the proof, the pairs
* of leafs & pre-images are assumed to be sorted.
*
* This version handles proofs in memory with the default hashing function.
*/
function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
bytes32 computedHash = leaf;
for (uint256 i = 0; i < proof.length; i++) {
computedHash = Hashes.commutativeKeccak256(computedHash, proof[i]);
}
return computedHash;
}
/**
* @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
* defined by `root`. For this, a `proof` must be provided, containing
* sibling hashes on the branch from the leaf to the root of the tree. Each
* pair of leaves and each pair of pre-images are assumed to be sorted.
*
* This version handles proofs in memory with a custom hashing function.
*/
function verify(
bytes32[] memory proof,
bytes32 root,
bytes32 leaf,
function(bytes32, bytes32) view returns (bytes32) hasher
) internal view returns (bool) {
return processProof(proof, leaf, hasher) == root;
}
/**
* @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
* from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
* hash matches the root of the tree. When processing the proof, the pairs
* of leafs & pre-images are assumed to be sorted.
*
* This version handles proofs in memory with a custom hashing function.
*/
function processProof(
bytes32[] memory proof,
bytes32 leaf,
function(bytes32, bytes32) view returns (bytes32) hasher
) internal view returns (bytes32) {
bytes32 computedHash = leaf;
for (uint256 i = 0; i < proof.length; i++) {
computedHash = hasher(computedHash, proof[i]);
}
return computedHash;
}
/**
* @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
* defined by `root`. For this, a `proof` must be provided, containing
* sibling hashes on the branch from the leaf to the root of the tree. Each
* pair of leaves and each pair of pre-images are assumed to be sorted.
*
* This version handles proofs in calldata with the default hashing function.
*/
function verifyCalldata(bytes32[] calldata proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
return processProofCalldata(proof, leaf) == root;
}
/**
* @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
* from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
* hash matches the root of the tree. When processing the proof, the pairs
* of leafs & pre-images are assumed to be sorted.
*
* This version handles proofs in calldata with the default hashing function.
*/
function processProofCalldata(bytes32[] calldata proof, bytes32 leaf) internal pure returns (bytes32) {
bytes32 computedHash = leaf;
for (uint256 i = 0; i < proof.length; i++) {
computedHash = Hashes.commutativeKeccak256(computedHash, proof[i]);
}
return computedHash;
}
/**
* @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
* defined by `root`. For this, a `proof` must be provided, containing
* sibling hashes on the branch from the leaf to the root of the tree. Each
* pair of leaves and each pair of pre-images are assumed to be sorted.
*
* This version handles proofs in calldata with a custom hashing function.
*/
function verifyCalldata(
bytes32[] calldata proof,
bytes32 root,
bytes32 leaf,
function(bytes32, bytes32) view returns (bytes32) hasher
) internal view returns (bool) {
return processProofCalldata(proof, leaf, hasher) == root;
}
/**
* @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
* from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
* hash matches the root of the tree. When processing the proof, the pairs
* of leafs & pre-images are assumed to be sorted.
*
* This version handles proofs in calldata with a custom hashing function.
*/
function processProofCalldata(
bytes32[] calldata proof,
bytes32 leaf,
function(bytes32, bytes32) view returns (bytes32) hasher
) internal view returns (bytes32) {
bytes32 computedHash = leaf;
for (uint256 i = 0; i < proof.length; i++) {
computedHash = hasher(computedHash, proof[i]);
}
return computedHash;
}
/**
* @dev Returns true if the `leaves` can be simultaneously proven to be a part of a Merkle tree defined by
* `root`, according to `proof` and `proofFlags` as described in {processMultiProof}.
*
* This version handles multiproofs in memory with the default hashing function.
*
* CAUTION: Not all Merkle trees admit multiproofs. See {processMultiProof} for details.
*
* NOTE: Consider the case where `root == proof[0] && leaves.length == 0` as it will return `true`.
* The `leaves` must be validated independently. See {processMultiProof}.
*/
function multiProofVerify(
bytes32[] memory proof,
bool[] memory proofFlags,
bytes32 root,
bytes32[] memory leaves
) internal pure returns (bool) {
return processMultiProof(proof, proofFlags, leaves) == root;
}
/**
* @dev Returns the root of a tree reconstructed from `leaves` and sibling nodes in `proof`. The reconstruction
* proceeds by incrementally reconstructing all inner nodes by combining a leaf/inner node with either another
* leaf/inner node or a proof sibling node, depending on whether each `proofFlags` item is true or false
* respectively.
*
* This version handles multiproofs in memory with the default hashing function.
*
* CAUTION: Not all Merkle trees admit multiproofs. To use multiproofs, it is sufficient to ensure that: 1) the tree
* is complete (but not necessarily perfect), 2) the leaves to be proven are in the opposite order they are in the
* tree (i.e., as seen from right to left starting at the deepest layer and continuing at the next layer).
*
* NOTE: The _empty set_ (i.e. the case where `proof.length == 1 && leaves.length == 0`) is considered a no-op,
* and therefore a valid multiproof (i.e. it returns `proof[0]`). Consider disallowing this case if you're not
* validating the leaves elsewhere.
*/
function processMultiProof(
bytes32[] memory proof,
bool[] memory proofFlags,
bytes32[] memory leaves
) internal pure returns (bytes32 merkleRoot) {
// This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by
// consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
// `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
// the Merkle tree.
uint256 leavesLen = leaves.length;
uint256 proofFlagsLen = proofFlags.length;
// Check proof validity.
if (leavesLen + proof.length != proofFlagsLen + 1) {
revert MerkleProofInvalidMultiproof();
}
// The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
// `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
bytes32[] memory hashes = new bytes32[](proofFlagsLen);
uint256 leafPos = 0;
uint256 hashPos = 0;
uint256 proofPos = 0;
// At each step, we compute the next hash using two values:
// - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
// get the next hash.
// - depending on the flag, either another value from the "main queue" (merging branches) or an element from the
// `proof` array.
for (uint256 i = 0; i < proofFlagsLen; i++) {
bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
bytes32 b = proofFlags[i]
? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
: proof[proofPos++];
hashes[i] = Hashes.commutativeKeccak256(a, b);
}
if (proofFlagsLen > 0) {
if (proofPos != proof.length) {
revert MerkleProofInvalidMultiproof();
}
unchecked {
return hashes[proofFlagsLen - 1];
}
} else if (leavesLen > 0) {
return leaves[0];
} else {
return proof[0];
}
}
/**
* @dev Returns true if the `leaves` can be simultaneously proven to be a part of a Merkle tree defined by
* `root`, according to `proof` and `proofFlags` as described in {processMultiProof}.
*
* This version handles multiproofs in memory with a custom hashing function.
*
* CAUTION: Not all Merkle trees admit multiproofs. See {processMultiProof} for details.
*
* NOTE: Consider the case where `root == proof[0] && leaves.length == 0` as it will return `true`.
* The `leaves` must be validated independently. See {processMultiProof}.
*/
function multiProofVerify(
bytes32[] memory proof,
bool[] memory proofFlags,
bytes32 root,
bytes32[] memory leaves,
function(bytes32, bytes32) view returns (bytes32) hasher
) internal view returns (bool) {
return processMultiProof(proof, proofFlags, leaves, hasher) == root;
}
/**
* @dev Returns the root of a tree reconstructed from `leaves` and sibling nodes in `proof`. The reconstruction
* proceeds by incrementally reconstructing all inner nodes by combining a leaf/inner node with either another
* leaf/inner node or a proof sibling node, depending on whether each `proofFlags` item is true or false
* respectively.
*
* This version handles multiproofs in memory with a custom hashing function.
*
* CAUTION: Not all Merkle trees admit multiproofs. To use multiproofs, it is sufficient to ensure that: 1) the tree
* is complete (but not necessarily perfect), 2) the leaves to be proven are in the opposite order they are in the
* tree (i.e., as seen from right to left starting at the deepest layer and continuing at the next layer).
*
* NOTE: The _empty set_ (i.e. the case where `proof.length == 1 && leaves.length == 0`) is considered a no-op,
* and therefore a valid multiproof (i.e. it returns `proof[0]`). Consider disallowing this case if you're not
* validating the leaves elsewhere.
*/
function processMultiProof(
bytes32[] memory proof,
bool[] memory proofFlags,
bytes32[] memory leaves,
function(bytes32, bytes32) view returns (bytes32) hasher
) internal view returns (bytes32 merkleRoot) {
// This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by
// consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
// `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
// the Merkle tree.
uint256 leavesLen = leaves.length;
uint256 proofFlagsLen = proofFlags.length;
// Check proof validity.
if (leavesLen + proof.length != proofFlagsLen + 1) {
revert MerkleProofInvalidMultiproof();
}
// The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
// `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
bytes32[] memory hashes = new bytes32[](proofFlagsLen);
uint256 leafPos = 0;
uint256 hashPos = 0;
uint256 proofPos = 0;
// At each step, we compute the next hash using two values:
// - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
// get the next hash.
// - depending on the flag, either another value from the "main queue" (merging branches) or an element from the
// `proof` array.
for (uint256 i = 0; i < proofFlagsLen; i++) {
bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
bytes32 b = proofFlags[i]
? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
: proof[proofPos++];
hashes[i] = hasher(a, b);
}
if (proofFlagsLen > 0) {
if (proofPos != proof.length) {
revert MerkleProofInvalidMultiproof();
}
unchecked {
return hashes[proofFlagsLen - 1];
}
} else if (leavesLen > 0) {
return leaves[0];
} else {
return proof[0];
}
}
/**
* @dev Returns true if the `leaves` can be simultaneously proven to be a part of a Merkle tree defined by
* `root`, according to `proof` and `proofFlags` as described in {processMultiProof}.
*
* This version handles multiproofs in calldata with the default hashing function.
*
* CAUTION: Not all Merkle trees admit multiproofs. See {processMultiProof} for details.
*
* NOTE: Consider the case where `root == proof[0] && leaves.length == 0` as it will return `true`.
* The `leaves` must be validated independently. See {processMultiProofCalldata}.
*/
function multiProofVerifyCalldata(
bytes32[] calldata proof,
bool[] calldata proofFlags,
bytes32 root,
bytes32[] memory leaves
) internal pure returns (bool) {
return processMultiProofCalldata(proof, proofFlags, leaves) == root;
}
/**
* @dev Returns the root of a tree reconstructed from `leaves` and sibling nodes in `proof`. The reconstruction
* proceeds by incrementally reconstructing all inner nodes by combining a leaf/inner node with either another
* leaf/inner node or a proof sibling node, depending on whether each `proofFlags` item is true or false
* respectively.
*
* This version handles multiproofs in calldata with the default hashing function.
*
* CAUTION: Not all Merkle trees admit multiproofs. To use multiproofs, it is sufficient to ensure that: 1) the tree
* is complete (but not necessarily perfect), 2) the leaves to be proven are in the opposite order they are in the
* tree (i.e., as seen from right to left starting at the deepest layer and continuing at the next layer).
*
* NOTE: The _empty set_ (i.e. the case where `proof.length == 1 && leaves.length == 0`) is considered a no-op,
* and therefore a valid multiproof (i.e. it returns `proof[0]`). Consider disallowing this case if you're not
* validating the leaves elsewhere.
*/
function processMultiProofCalldata(
bytes32[] calldata proof,
bool[] calldata proofFlags,
bytes32[] memory leaves
) internal pure returns (bytes32 merkleRoot) {
// This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by
// consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
// `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
// the Merkle tree.
uint256 leavesLen = leaves.length;
uint256 proofFlagsLen = proofFlags.length;
// Check proof validity.
if (leavesLen + proof.length != proofFlagsLen + 1) {
revert MerkleProofInvalidMultiproof();
}
// The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
// `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
bytes32[] memory hashes = new bytes32[](proofFlagsLen);
uint256 leafPos = 0;
uint256 hashPos = 0;
uint256 proofPos = 0;
// At each step, we compute the next hash using two values:
// - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
// get the next hash.
// - depending on the flag, either another value from the "main queue" (merging branches) or an element from the
// `proof` array.
for (uint256 i = 0; i < proofFlagsLen; i++) {
bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
bytes32 b = proofFlags[i]
? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
: proof[proofPos++];
hashes[i] = Hashes.commutativeKeccak256(a, b);
}
if (proofFlagsLen > 0) {
if (proofPos != proof.length) {
revert MerkleProofInvalidMultiproof();
}
unchecked {
return hashes[proofFlagsLen - 1];
}
} else if (leavesLen > 0) {
return leaves[0];
} else {
return proof[0];
}
}
/**
* @dev Returns true if the `leaves` can be simultaneously proven to be a part of a Merkle tree defined by
* `root`, according to `proof` and `proofFlags` as described in {processMultiProof}.
*
* This version handles multiproofs in calldata with a custom hashing function.
*
* CAUTION: Not all Merkle trees admit multiproofs. See {processMultiProof} for details.
*
* NOTE: Consider the case where `root == proof[0] && leaves.length == 0` as it will return `true`.
* The `leaves` must be validated independently. See {processMultiProofCalldata}.
*/
function multiProofVerifyCalldata(
bytes32[] calldata proof,
bool[] calldata proofFlags,
bytes32 root,
bytes32[] memory leaves,
function(bytes32, bytes32) view returns (bytes32) hasher
) internal view returns (bool) {
return processMultiProofCalldata(proof, proofFlags, leaves, hasher) == root;
}
/**
* @dev Returns the root of a tree reconstructed from `leaves` and sibling nodes in `proof`. The reconstruction
* proceeds by incrementally reconstructing all inner nodes by combining a leaf/inner node with either another
* leaf/inner node or a proof sibling node, depending on whether each `proofFlags` item is true or false
* respectively.
*
* This version handles multiproofs in calldata with a custom hashing function.
*
* CAUTION: Not all Merkle trees admit multiproofs. To use multiproofs, it is sufficient to ensure that: 1) the tree
* is complete (but not necessarily perfect), 2) the leaves to be proven are in the opposite order they are in the
* tree (i.e., as seen from right to left starting at the deepest layer and continuing at the next layer).
*
* NOTE: The _empty set_ (i.e. the case where `proof.length == 1 && leaves.length == 0`) is considered a no-op,
* and therefore a valid multiproof (i.e. it returns `proof[0]`). Consider disallowing this case if you're not
* validating the leaves elsewhere.
*/
function processMultiProofCalldata(
bytes32[] calldata proof,
bool[] calldata proofFlags,
bytes32[] memory leaves,
function(bytes32, bytes32) view returns (bytes32) hasher
) internal view returns (bytes32 merkleRoot) {
// This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by
// consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
// `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
// the Merkle tree.
uint256 leavesLen = leaves.length;
uint256 proofFlagsLen = proofFlags.length;
// Check proof validity.
if (leavesLen + proof.length != proofFlagsLen + 1) {
revert MerkleProofInvalidMultiproof();
}
// The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
// `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
bytes32[] memory hashes = new bytes32[](proofFlagsLen);
uint256 leafPos = 0;
uint256 hashPos = 0;
uint256 proofPos = 0;
// At each step, we compute the next hash using two values:
// - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
// get the next hash.
// - depending on the flag, either another value from the "main queue" (merging branches) or an element from the
// `proof` array.
for (uint256 i = 0; i < proofFlagsLen; i++) {
bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
bytes32 b = proofFlags[i]
? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
: proof[proofPos++];
hashes[i] = hasher(a, b);
}
if (proofFlagsLen > 0) {
if (proofPos != proof.length) {
revert MerkleProofInvalidMultiproof();
}
unchecked {
return hashes[proofFlagsLen - 1];
}
} else if (leavesLen > 0) {
return leaves[0];
} else {
return proof[0];
}
}
}
// lib/openzeppelin-contracts-upgradeable/contracts/utils/introspection/ERC165Upgradeable.sol
// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/ERC165.sol)
/**
* @dev Implementation of the {IERC165} interface.
*
* Contracts that want to implement ERC-165 should inherit from this contract and override {supportsInterface} to check
* for the additional interface id that will be supported. For example:
*
* ```solidity
* function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
* return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
* }
* ```
*/
abstract contract ERC165Upgradeable is Initializable, IERC165 {
function __ERC165_init() internal onlyInitializing {
}
function __ERC165_init_unchained() internal onlyInitializing {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
// lib/openzeppelin-contracts/contracts/utils/math/Math.sol
// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/Math.sol)
/**
* @dev Standard math utilities missing in the Solidity language.
*/
library Math {
enum Rounding {
Floor, // Toward negative infinity
Ceil, // Toward positive infinity
Trunc, // Toward zero
Expand // Away from zero
}
/**
* @dev Returns the addition of two unsigned integers, with an success flag (no overflow).
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
/**
* @dev Returns the subtraction of two unsigned integers, with an success flag (no overflow).
*/
function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
/**
* @dev Returns the multiplication of two unsigned integers, with an success flag (no overflow).
*/
function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
unchecked {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
/**
* @dev Returns the division of two unsigned integers, with a success flag (no division by zero).
*/
function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
/**
* @dev Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero).
*/
function tryMod(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
/**
* @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.
*
* IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.
* However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute
* one branch when needed, making this function more expensive.
*/
function ternary(bool condition, uint256 a, uint256 b) internal pure returns (uint256) {
unchecked {
// branchless ternary works because:
// b ^ (a ^ b) == a
// b ^ 0 == b
return b ^ ((a ^ b) * SafeCast.toUint(condition));
}
}
/**
* @dev Returns the largest of two numbers.
*/
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return ternary(a > b, a, b);
}
/**
* @dev Returns the smallest of two numbers.
*/
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return ternary(a < b, a, b);
}
/**
* @dev Returns the average of two numbers. The result is rounded towards
* zero.
*/
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow.
return (a & b) + (a ^ b) / 2;
}
/**
* @dev Returns the ceiling of the division of two numbers.
*
* This differs from standard division with `/` in that it rounds towards infinity instead
* of rounding towards zero.
*/
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
if (b == 0) {
// Guarantee the same behavior as in a regular Solidity division.
Panic.panic(Panic.DIVISION_BY_ZERO);
}
// The following calculation ensures accurate ceiling division without overflow.
// Since a is non-zero, (a - 1) / b will not overflow.
// The largest possible result occurs when (a - 1) / b is type(uint256).max,
// but the largest value we can obtain is type(uint256).max - 1, which happens
// when a = type(uint256).max and b = 1.
unchecked {
return SafeCast.toUint(a > 0) * ((a - 1) / b + 1);
}
}
/**
* @dev Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or
* denominator == 0.
*
* Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by
* Uniswap Labs also under MIT license.
*/
function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
unchecked {
// 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2²⁵⁶ and mod 2²⁵⁶ - 1, then use
// the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
// variables such that product = prod1 * 2²⁵⁶ + prod0.
uint256 prod0 = x * y; // Least significant 256 bits of the product
uint256 prod1; // Most significant 256 bits of the product
assembly {
let mm := mulmod(x, y, not(0))
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
// Handle non-overflow cases, 256 by 256 division.
if (prod1 == 0) {
// Solidity will revert if denominator == 0, unlike the div opcode on its own.
// The surrounding unchecked block does not change this fact.
// See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
return prod0 / denominator;
}
// Make sure the result is less than 2²⁵⁶. Also prevents denominator == 0.
if (denominator <= prod1) {
Panic.panic(ternary(denominator == 0, Panic.DIVISION_BY_ZERO, Panic.UNDER_OVERFLOW));
}
///////////////////////////////////////////////
// 512 by 256 division.
///////////////////////////////////////////////
// Make division exact by subtracting the remainder from [prod1 prod0].
uint256 remainder;
assembly {
// Compute remainder using mulmod.
remainder := mulmod(x, y, denominator)
// Subtract 256 bit number from 512 bit number.
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
// Factor powers of two out of denominator and compute largest power of two divisor of denominator.
// Always >= 1. See https://cs.stackexchange.com/q/138556/92363.
uint256 twos = denominator & (0 - denominator);
assembly {
// Divide denominator by twos.
denominator := div(denominator, twos)
// Divide [prod1 prod0] by twos.
prod0 := div(prod0, twos)
// Flip twos such that it is 2²⁵⁶ / twos. If twos is zero, then it becomes one.
twos := add(div(sub(0, twos), twos), 1)
}
// Shift in bits from prod1 into prod0.
prod0 |= prod1 * twos;
// Invert denominator mod 2²⁵⁶. Now that denominator is an odd number, it has an inverse modulo 2²⁵⁶ such
// that denominator * inv ≡ 1 mod 2²⁵⁶. Compute the inverse by starting with a seed that is correct for
// four bits. That is, denominator * inv ≡ 1 mod 2⁴.
uint256 inverse = (3 * denominator) ^ 2;
// Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also
// works in modular arithmetic, doubling the correct bits in each step.
inverse *= 2 - denominator * inverse; // inverse mod 2⁸
inverse *= 2 - denominator * inverse; // inverse mod 2¹⁶
inverse *= 2 - denominator * inverse; // inverse mod 2³²
inverse *= 2 - denominator * inverse; // inverse mod 2⁶⁴
inverse *= 2 - denominator * inverse; // inverse mod 2¹²⁸
inverse *= 2 - denominator * inverse; // inverse mod 2²⁵⁶
// Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
// This will give us the correct result modulo 2²⁵⁶. Since the preconditions guarantee that the outcome is
// less than 2²⁵⁶, this is the final result. We don't need to compute the high bits of the result and prod1
// is no longer required.
result = prod0 * inverse;
return result;
}
}
/**
* @dev Calculates x * y / denominator with full precision, following the selected rounding direction.
*/
function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0);
}
/**
* @dev Calculate the modular multiplicative inverse of a number in Z/nZ.
*
* If n is a prime, then Z/nZ is a field. In that case all elements are inversible, except 0.
* If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible.
*
* If the input value is not inversible, 0 is returned.
*
* NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Fermat's little theorem and get the
* inverse using `Math.modExp(a, n - 2, n)`. See {invModPrime}.
*/
function invMod(uint256 a, uint256 n) internal pure returns (uint256) {
unchecked {
if (n == 0) return 0;
// The inverse modulo is calculated using the Extended Euclidean Algorithm (iterative version)
// Used to compute integers x and y such that: ax + ny = gcd(a, n).
// When the gcd is 1, then the inverse of a modulo n exists and it's x.
// ax + ny = 1
// ax = 1 + (-y)n
// ax ≡ 1 (mod n) # x is the inverse of a modulo n
// If the remainder is 0 the gcd is n right away.
uint256 remainder = a % n;
uint256 gcd = n;
// Therefore the initial coefficients are:
// ax + ny = gcd(a, n) = n
// 0a + 1n = n
int256 x = 0;
int256 y = 1;
while (remainder != 0) {
uint256 quotient = gcd / remainder;
(gcd, remainder) = (
// The old remainder is the next gcd to try.
remainder,
// Compute the next remainder.
// Can't overflow given that (a % gcd) * (gcd // (a % gcd)) <= gcd
// where gcd is at most n (capped to type(uint256).max)
gcd - remainder * quotient
);
(x, y) = (
// Increment the coefficient of a.
y,
// Decrement the coefficient of n.
// Can overflow, but the result is casted to uint256 so that the
// next value of y is "wrapped around" to a value between 0 and n - 1.
x - y * int256(quotient)
);
}
if (gcd != 1) return 0; // No inverse exists.
return ternary(x < 0, n - uint256(-x), uint256(x)); // Wrap the result if it's negative.
}
}
/**
* @dev Variant of {invMod}. More efficient, but only works if `p` is known to be a prime greater than `2`.
*
* From https://en.wikipedia.org/wiki/Fermat%27s_little_theorem[Fermat's little theorem], we know that if p is
* prime, then `a**(p-1) ≡ 1 mod p`. As a consequence, we have `a * a**(p-2) ≡ 1 mod p`, which means that
* `a**(p-2)` is the modular multiplicative inverse of a in Fp.
*
* NOTE: this function does NOT check that `p` is a prime greater than `2`.
*/
function invModPrime(uint256 a, uint256 p) internal view returns (uint256) {
unchecked {
return Math.modExp(a, p - 2, p);
}
}
/**
* @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m)
*
* Requirements:
* - modulus can't be zero
* - underlying staticcall to precompile must succeed
*
* IMPORTANT: The result is only valid if the underlying call succeeds. When using this function, make
* sure the chain you're using it on supports the precompiled contract for modular exponentiation
* at address 0x05 as specified in https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise,
* the underlying function will succeed given the lack of a revert, but the result may be incorrectly
* interpreted as 0.
*/
function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) {
(bool success, uint256 result) = tryModExp(b, e, m);
if (!success) {
Panic.panic(Panic.DIVISION_BY_ZERO);
}
return result;
}
/**
* @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m).
* It includes a success flag indicating if the operation succeeded. Operation will be marked as failed if trying
* to operate modulo 0 or if the underlying precompile reverted.
*
* IMPORTANT: The result is only valid if the success flag is true. When using this function, make sure the chain
* you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in
* https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, the underlying function will succeed given the lack
* of a revert, but the result may be incorrectly interpreted as 0.
*/
function tryModExp(uint256 b, uint256 e, uint256 m) internal view returns (bool success, uint256 result) {
if (m == 0) return (false, 0);
assembly ("memory-safe") {
let ptr := mload(0x40)
// | Offset | Content | Content (Hex) |
// |-----------|------------|--------------------------------------------------------------------|
// | 0x00:0x1f | size of b | 0x0000000000000000000000000000000000000000000000000000000000000020 |
// | 0x20:0x3f | size of e | 0x0000000000000000000000000000000000000000000000000000000000000020 |
// | 0x40:0x5f | size of m | 0x0000000000000000000000000000000000000000000000000000000000000020 |
// | 0x60:0x7f | value of b | 0x<.............................................................b> |
// | 0x80:0x9f | value of e | 0x<.............................................................e> |
// | 0xa0:0xbf | value of m | 0x<.............................................................m> |
mstore(ptr, 0x20)
mstore(add(ptr, 0x20), 0x20)
mstore(add(ptr, 0x40), 0x20)
mstore(add(ptr, 0x60), b)
mstore(add(ptr, 0x80), e)
mstore(add(ptr, 0xa0), m)
// Given the result < m, it's guaranteed to fit in 32 bytes,
// so we can use the memory scratch space located at offset 0.
success := staticcall(gas(), 0x05, ptr, 0xc0, 0x00, 0x20)
result := mload(0x00)
}
}
/**
* @dev Variant of {modExp} that supports inputs of arbitrary length.
*/
function modExp(bytes memory b, bytes memory e, bytes memory m) internal view returns (bytes memory) {
(bool success, bytes memory result) = tryModExp(b, e, m);
if (!success) {
Panic.panic(Panic.DIVISION_BY_ZERO);
}
return result;
}
/**
* @dev Variant of {tryModExp} that supports inputs of arbitrary length.
*/
function tryModExp(
bytes memory b,
bytes memory e,
bytes memory m
) internal view returns (bool success, bytes memory result) {
if (_zeroBytes(m)) return (false, new bytes(0));
uint256 mLen = m.length;
// Encode call args in result and move the free memory pointer
result = abi.encodePacked(b.length, e.length, mLen, b, e, m);
assembly ("memory-safe") {
let dataPtr := add(result, 0x20)
// Write result on top of args to avoid allocating extra memory.
success := staticcall(gas(), 0x05, dataPtr, mload(result), dataPtr, mLen)
// Overwrite the length.
// result.length > returndatasize() is guaranteed because returndatasize() == m.length
mstore(result, mLen)
// Set the memory pointer after the returned data.
mstore(0x40, add(dataPtr, mLen))
}
}
/**
* @dev Returns whether the provided byte array is zero.
*/
function _zeroBytes(bytes memory byteArray) private pure returns (bool) {
for (uint256 i = 0; i < byteArray.length; ++i) {
if (byteArray[i] != 0) {
return false;
}
}
return true;
}
/**
* @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded
* towards zero.
*
* This method is based on Newton's method for computing square roots; the algorithm is restricted to only
* using integer operations.
*/
function sqrt(uint256 a) internal pure returns (uint256) {
unchecked {
// Take care of easy edge cases when a == 0 or a == 1
if (a <= 1) {
return a;
}
// In this function, we use Newton's method to get a root of `f(x) := x² - a`. It involves building a
// sequence x_n that converges toward sqrt(a). For each iteration x_n, we also define the error between
// the current value as `ε_n = | x_n - sqrt(a) |`.
//
// For our first estimation, we consider `e` the smallest power of 2 which is bigger than the square root
// of the target. (i.e. `2**(e-1) ≤ sqrt(a) < 2**e`). We know that `e ≤ 128` because `(2¹²⁸)² = 2²⁵⁶` is
// bigger than any uint256.
//
// By noticing that
// `2**(e-1) ≤ sqrt(a) < 2**e → (2**(e-1))² ≤ a < (2**e)² → 2**(2*e-2) ≤ a < 2**(2*e)`
// we can deduce that `e - 1` is `log2(a) / 2`. We can thus compute `x_n = 2**(e-1)` using a method similar
// to the msb function.
uint256 aa = a;
uint256 xn = 1;
if (aa >= (1 << 128)) {
aa >>= 128;
xn <<= 64;
}
if (aa >= (1 << 64)) {
aa >>= 64;
xn <<= 32;
}
if (aa >= (1 << 32)) {
aa >>= 32;
xn <<= 16;
}
if (aa >= (1 << 16)) {
aa >>= 16;
xn <<= 8;
}
if (aa >= (1 << 8)) {
aa >>= 8;
xn <<= 4;
}
if (aa >= (1 << 4)) {
aa >>= 4;
xn <<= 2;
}
if (aa >= (1 << 2)) {
xn <<= 1;
}
// We now have x_n such that `x_n = 2**(e-1) ≤ sqrt(a) < 2**e = 2 * x_n`. This implies ε_n ≤ 2**(e-1).
//
// We can refine our estimation by noticing that the middle of that interval minimizes the error.
// If we move x_n to equal 2**(e-1) + 2**(e-2), then we reduce the error to ε_n ≤ 2**(e-2).
// This is going to be our x_0 (and ε_0)
xn = (3 * xn) >> 1; // ε_0 := | x_0 - sqrt(a) | ≤ 2**(e-2)
// From here, Newton's method give us:
// x_{n+1} = (x_n + a / x_n) / 2
//
// One should note that:
// x_{n+1}² - a = ((x_n + a / x_n) / 2)² - a
// = ((x_n² + a) / (2 * x_n))² - a
// = (x_n⁴ + 2 * a * x_n² + a²) / (4 * x_n²) - a
// = (x_n⁴ + 2 * a * x_n² + a² - 4 * a * x_n²) / (4 * x_n²)
// = (x_n⁴ - 2 * a * x_n² + a²) / (4 * x_n²)
// = (x_n² - a)² / (2 * x_n)²
// = ((x_n² - a) / (2 * x_n))²
// ≥ 0
// Which proves that for all n ≥ 1, sqrt(a) ≤ x_n
//
// This gives us the proof of quadratic convergence of the sequence:
// ε_{n+1} = | x_{n+1} - sqrt(a) |
// = | (x_n + a / x_n) / 2 - sqrt(a) |
// = | (x_n² + a - 2*x_n*sqrt(a)) / (2 * x_n) |
// = | (x_n - sqrt(a))² / (2 * x_n) |
// = | ε_n² / (2 * x_n) |
// = ε_n² / | (2 * x_n) |
//
// For the first iteration, we have a special case where x_0 is known:
// ε_1 = ε_0² / | (2 * x_0) |
// ≤ (2**(e-2))² / (2 * (2**(e-1) + 2**(e-2)))
// ≤ 2**(2*e-4) / (3 * 2**(e-1))
// ≤ 2**(e-3) / 3
// ≤ 2**(e-3-log2(3))
// ≤ 2**(e-4.5)
//
// For the following iterations, we use the fact that, 2**(e-1) ≤ sqrt(a) ≤ x_n:
// ε_{n+1} = ε_n² / | (2 * x_n) |
// ≤ (2**(e-k))² / (2 * 2**(e-1))
// ≤ 2**(2*e-2*k) / 2**e
// ≤ 2**(e-2*k)
xn = (xn + a / xn) >> 1; // ε_1 := | x_1 - sqrt(a) | ≤ 2**(e-4.5) -- special case, see above
xn = (xn + a / xn) >> 1; // ε_2 := | x_2 - sqrt(a) | ≤ 2**(e-9) -- general case with k = 4.5
xn = (xn + a / xn) >> 1; // ε_3 := | x_3 - sqrt(a) | ≤ 2**(e-18) -- general case with k = 9
xn = (xn + a / xn) >> 1; // ε_4 := | x_4 - sqrt(a) | ≤ 2**(e-36) -- general case with k = 18
xn = (xn + a / xn) >> 1; // ε_5 := | x_5 - sqrt(a) | ≤ 2**(e-72) -- general case with k = 36
xn = (xn + a / xn) >> 1; // ε_6 := | x_6 - sqrt(a) | ≤ 2**(e-144) -- general case with k = 72
// Because e ≤ 128 (as discussed during the first estimation phase), we know have reached a precision
// ε_6 ≤ 2**(e-144) < 1. Given we're operating on integers, then we can ensure that xn is now either
// sqrt(a) or sqrt(a) + 1.
return xn - SafeCast.toUint(xn > a / xn);
}
}
/**
* @dev Calculates sqrt(a), following the selected rounding direction.
*/
function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = sqrt(a);
return result + SafeCast.toUint(unsignedRoundsUp(rounding) && result * result < a);
}
}
/**
* @dev Return the log in base 2 of a positive value rounded towards zero.
* Returns 0 if given 0.
*/
function log2(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
uint256 exp;
unchecked {
exp = 128 * SafeCast.toUint(value > (1 << 128) - 1);
value >>= exp;
result += exp;
exp = 64 * SafeCast.toUint(value > (1 << 64) - 1);
value >>= exp;
result += exp;
exp = 32 * SafeCast.toUint(value > (1 << 32) - 1);
value >>= exp;
result += exp;
exp = 16 * SafeCast.toUint(value > (1 << 16) - 1);
value >>= exp;
result += exp;
exp = 8 * SafeCast.toUint(value > (1 << 8) - 1);
value >>= exp;
result += exp;
exp = 4 * SafeCast.toUint(value > (1 << 4) - 1);
value >>= exp;
result += exp;
exp = 2 * SafeCast.toUint(value > (1 << 2) - 1);
value >>= exp;
result += exp;
result += SafeCast.toUint(value > 1);
}
return result;
}
/**
* @dev Return the log in base 2, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log2(value);
return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << result < value);
}
}
/**
* @dev Return the log in base 10 of a positive value rounded towards zero.
* Returns 0 if given 0.
*/
function log10(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >= 10 ** 64) {
value /= 10 ** 64;
result += 64;
}
if (value >= 10 ** 32) {
value /= 10 ** 32;
result += 32;
}
if (value >= 10 ** 16) {
value /= 10 ** 16;
result += 16;
}
if (value >= 10 ** 8) {
value /= 10 ** 8;
result += 8;
}
if (value >= 10 ** 4) {
value /= 10 ** 4;
result += 4;
}
if (value >= 10 ** 2) {
value /= 10 ** 2;
result += 2;
}
if (value >= 10 ** 1) {
result += 1;
}
}
return result;
}
/**
* @dev Return the log in base 10, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log10(value);
return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 10 ** result < value);
}
}
/**
* @dev Return the log in base 256 of a positive value rounded towards zero.
* Returns 0 if given 0.
*
* Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
*/
function log256(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
uint256 isGt;
unchecked {
isGt = SafeCast.toUint(value > (1 << 128) - 1);
value >>= isGt * 128;
result += isGt * 16;
isGt = SafeCast.toUint(value > (1 << 64) - 1);
value >>= isGt * 64;
result += isGt * 8;
isGt = SafeCast.toUint(value > (1 << 32) - 1);
value >>= isGt * 32;
result += isGt * 4;
isGt = SafeCast.toUint(value > (1 << 16) - 1);
value >>= isGt * 16;
result += isGt * 2;
result += SafeCast.toUint(value > (1 << 8) - 1);
}
return result;
}
/**
* @dev Return the log in base 256, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log256(value);
return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << (result << 3) < value);
}
}
/**
* @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.
*/
function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {
return uint8(rounding) % 2 == 1;
}
}
// lib/openzeppelin-contracts-upgradeable/contracts/utils/PausableUpgradeable.sol
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Pausable.sol)
/**
* @dev Contract module which allows children to implement an emergency stop
* mechanism that can be triggered by an authorized account.
*
* This module is used through inheritance. It will make available the
* modifiers `whenNotPaused` and `whenPaused`, which can be applied to
* the functions of your contract. Note that they will not be pausable by
* simply including this module, only once the modifiers are put in place.
*/
abstract contract PausableUpgradeable is Initializable, ContextUpgradeable {
/// @custom:storage-location erc7201:openzeppelin.storage.Pausable
struct PausableStorage {
bool _paused;
}
// keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.Pausable")) - 1)) & ~bytes32(uint256(0xff))
bytes32 private constant PausableStorageLocation = 0xcd5ed15c6e187e77e9aee88184c21f4f2182ab5827cb3b7e07fbedcd63f03300;
function _getPausableStorage() private pure returns (PausableStorage storage $) {
assembly {
$.slot := PausableStorageLocation
}
}
/**
* @dev Emitted when the pause is triggered by `account`.
*/
event Paused(address account);
/**
* @dev Emitted when the pause is lifted by `account`.
*/
event Unpaused(address account);
/**
* @dev The operation failed because the contract is paused.
*/
error EnforcedPause();
/**
* @dev The operation failed because the contract is not paused.
*/
error ExpectedPause();
/**
* @dev Initializes the contract in unpaused state.
*/
function __Pausable_init() internal onlyInitializing {
__Pausable_init_unchained();
}
function __Pausable_init_unchained() internal onlyInitializing {
PausableStorage storage $ = _getPausableStorage();
$._paused = false;
}
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*
* Requirements:
*
* - The contract must not be paused.
*/
modifier whenNotPaused() {
_requireNotPaused();
_;
}
/**
* @dev Modifier to make a function callable only when the contract is paused.
*
* Requirements:
*
* - The contract must be paused.
*/
modifier whenPaused() {
_requirePaused();
_;
}
/**
* @dev Returns true if the contract is paused, and false otherwise.
*/
function paused() public view virtual returns (bool) {
PausableStorage storage $ = _getPausableStorage();
return $._paused;
}
/**
* @dev Throws if the contract is paused.
*/
function _requireNotPaused() internal view virtual {
if (paused()) {
revert EnforcedPause();
}
}
/**
* @dev Throws if the contract is not paused.
*/
function _requirePaused() internal view virtual {
if (!paused()) {
revert ExpectedPause();
}
}
/**
* @dev Triggers stopped state.
*
* Requirements:
*
* - The contract must not be paused.
*/
function _pause() internal virtual whenNotPaused {
PausableStorage storage $ = _getPausableStorage();
$._paused = true;
emit Paused(_msgSender());
}
/**
* @dev Returns to normal state.
*
* Requirements:
*
* - The contract must be paused.
*/
function _unpause() internal virtual whenPaused {
PausableStorage storage $ = _getPausableStorage();
$._paused = false;
emit Unpaused(_msgSender());
}
}
// src/TokenStorage.sol
/// @title TokenStorage
/// @dev defines storage layout for the Token facet
library TokenStorage {
struct Layout {
/// @dev ratio of distributionSupply to totalSupply
uint256 globalRatio;
/// @dev number of tokens held for distribution to token holders
uint256 distributionSupply;
/// @dev number of tokens held for airdrop dispersion
uint256 airdropSupply;
/// @dev fraction of tokens to be reserved for distribution to token holders in basis points
uint256 distributionFractionBP;
/// @dev fraction of attempt value going to trades fund in basis points
uint256 tradesFractionBP;
/// @dev fraction of attempt value going to token backing fund in basis points
uint256 tokenBackingFractionBP;
/// @dev fraction of mint attempt value as fees for protocol in basis points
uint256 protocolFeeBP;
/// @dev earnigns in current period
uint256 periodEarnings;
/// @dev currently held ETH earnings from mint attempts
uint256 earnings;
/// @dev currently held ETH accumulated from fees on mint attempts
uint256 fees;
/// @dev currently held ETH in trades fund
uint256 tradesFund;
/// @dev currently held ETH in token backing fund
uint256 tokenBackingFund;
/// @dev root of merkleTree responsible for accounting for earnings due to social activity
bytes32 socialRoot;
/// @dev address to send fees to
address treasury;
/// @dev address to send trade funds to
address tradesWallet;
/// @dev information related to Token accruals for an account
mapping(address account => AccrualData data) accrualData;
/// @dev deduction on social earnings for an account
mapping(address account => uint256 deduction) socialEarningsDeduction;
/// @dev set of game ids currently active
EnumerableSet.UintSet gameIds;
/// @dev fraction of mint attempt value going to repayment fund in basis points
uint256 repaymentFractionBP;
/// @dev currently held ETH in repayment fund
uint256 repaymentFund;
/// @dev fraction of attempt value going to mummy pocket money in basis points
uint256 mummyPocketMoneyFractionBP;
/// @dev current mummy pocket money in ETH
uint256 mummyPocketMoney;
/// @dev floor for mummy pocket money in ETH
uint256 mummyPocketMoneyFloor;
}
bytes32 internal constant STORAGE_SLOT =
keccak256("insrt.contracts.v3.storage.MintToken");
function layout() internal pure returns (Layout storage l) {
bytes32 slot = STORAGE_SLOT;
assembly {
l.slot := slot
}
}
}
// lib/openzeppelin-contracts-upgradeable/contracts/access/AccessControlUpgradeable.sol
// OpenZeppelin Contracts (last updated v5.0.0) (access/AccessControl.sol)
/**
* @dev Contract module that allows children to implement role-based access
* control mechanisms. This is a lightweight version that doesn't allow enumerating role
* members except through off-chain means by accessing the contract event logs. Some
* applications may benefit from on-chain enumerability, for those cases see
* {AccessControlEnumerable}.
*
* Roles are referred to by their `bytes32` identifier. These should be exposed
* in the external API and be unique. The best way to achieve this is by
* using `public constant` hash digests:
*
* ```solidity
* bytes32 public constant MY_ROLE = keccak256("MY_ROLE");
* ```
*
* Roles can be used to represent a set of permissions. To restrict access to a
* function call, use {hasRole}:
*
* ```solidity
* function foo() public {
* require(hasRole(MY_ROLE, msg.sender));
* ...
* }
* ```
*
* Roles can be granted and revoked dynamically via the {grantRole} and
* {revokeRole} functions. Each role has an associated admin role, and only
* accounts that have a role's admin role can call {grantRole} and {revokeRole}.
*
* By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means
* that only accounts with this role will be able to grant or revoke other
* roles. More complex role relationships can be created by using
* {_setRoleAdmin}.
*
* WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to
* grant and revoke this role. Extra precautions should be taken to secure
* accounts that have been granted it. We recommend using {AccessControlDefaultAdminRules}
* to enforce additional security measures for this role.
*/
abstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControl, ERC165Upgradeable {
struct RoleData {
mapping(address account => bool) hasRole;
bytes32 adminRole;
}
bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
/// @custom:storage-location erc7201:openzeppelin.storage.AccessControl
struct AccessControlStorage {
mapping(bytes32 role => RoleData) _roles;
}
// keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.AccessControl")) - 1)) & ~bytes32(uint256(0xff))
bytes32 private constant AccessControlStorageLocation = 0x02dd7bc7dec4dceedda775e58dd541e08a116c6c53815c0bd028192f7b626800;
function _getAccessControlStorage() private pure returns (AccessControlStorage storage $) {
assembly {
$.slot := AccessControlStorageLocation
}
}
/**
* @dev Modifier that checks that an account has a specific role. Reverts
* with an {AccessControlUnauthorizedAccount} error including the required role.
*/
modifier onlyRole(bytes32 role) {
_checkRole(role);
_;
}
function __AccessControl_init() internal onlyInitializing {
}
function __AccessControl_init_unchained() internal onlyInitializing {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId);
}
/**
* @dev Returns `true` if `account` has been granted `role`.
*/
function hasRole(bytes32 role, address account) public view virtual returns (bool) {
AccessControlStorage storage $ = _getAccessControlStorage();
return $._roles[role].hasRole[account];
}
/**
* @dev Reverts with an {AccessControlUnauthorizedAccount} error if `_msgSender()`
* is missing `role`. Overriding this function changes the behavior of the {onlyRole} modifier.
*/
function _checkRole(bytes32 role) internal view virtual {
_checkRole(role, _msgSender());
}
/**
* @dev Reverts with an {AccessControlUnauthorizedAccount} error if `account`
* is missing `role`.
*/
function _checkRole(bytes32 role, address account) internal view virtual {
if (!hasRole(role, account)) {
revert AccessControlUnauthorizedAccount(account, role);
}
}
/**
* @dev Returns the admin role that controls `role`. See {grantRole} and
* {revokeRole}.
*
* To change a role's admin, use {_setRoleAdmin}.
*/
function getRoleAdmin(bytes32 role) public view virtual returns (bytes32) {
AccessControlStorage storage $ = _getAccessControlStorage();
return $._roles[role].adminRole;
}
/**
* @dev Grants `role` to `account`.
*
* If `account` had not been already granted `role`, emits a {RoleGranted}
* event.
*
* Requirements:
*
* - the caller must have ``role``'s admin role.
*
* May emit a {RoleGranted} event.
*/
function grantRole(bytes32 role, address account) public virtual onlyRole(getRoleAdmin(role)) {
_grantRole(role, account);
}
/**
* @dev Revokes `role` from `account`.
*
* If `account` had been granted `role`, emits a {RoleRevoked} event.
*
* Requirements:
*
* - the caller must have ``role``'s admin role.
*
* May emit a {RoleRevoked} event.
*/
function revokeRole(bytes32 role, address account) public virtual onlyRole(getRoleAdmin(role)) {
_revokeRole(role, account);
}
/**
* @dev Revokes `role` from the calling account.
*
* Roles are often managed via {grantRole} and {revokeRole}: this function's
* purpose is to provide a mechanism for accounts to lose their privileges
* if they are compromised (such as when a trusted device is misplaced).
*
* If the calling account had been revoked `role`, emits a {RoleRevoked}
* event.
*
* Requirements:
*
* - the caller must be `callerConfirmation`.
*
* May emit a {RoleRevoked} event.
*/
function renounceRole(bytes32 role, address callerConfirmation) public virtual {
if (callerConfirmation != _msgSender()) {
revert AccessControlBadConfirmation();
}
_revokeRole(role, callerConfirmation);
}
/**
* @dev Sets `adminRole` as ``role``'s admin role.
*
* Emits a {RoleAdminChanged} event.
*/
function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
AccessControlStorage storage $ = _getAccessControlStorage();
bytes32 previousAdminRole = getRoleAdmin(role);
$._roles[role].adminRole = adminRole;
emit RoleAdminChanged(role, previousAdminRole, adminRole);
}
/**
* @dev Attempts to grant `role` to `account` and returns a boolean indicating if `role` was granted.
*
* Internal function without access restriction.
*
* May emit a {RoleGranted} event.
*/
function _grantRole(bytes32 role, address account) internal virtual returns (bool) {
AccessControlStorage storage $ = _getAccessControlStorage();
if (!hasRole(role, account)) {
$._roles[role].hasRole[account] = true;
emit RoleGranted(role, account, _msgSender());
return true;
} else {
return false;
}
}
/**
* @dev Attempts to revoke `role` to `account` and returns a boolean indicating if `role` was revoked.
*
* Internal function without access restriction.
*
* May emit a {RoleRevoked} event.
*/
function _revokeRole(bytes32 role, address account) internal virtual returns (bool) {
AccessControlStorage storage $ = _getAccessControlStorage();
if (hasRole(role, account)) {
$._roles[role].hasRole[account] = false;
emit RoleRevoked(role, account, _msgSender());
return true;
} else {
return false;
}
}
}
// lib/openzeppelin-contracts/contracts/proxy/ERC1967/ERC1967Utils.sol
// OpenZeppelin Contracts (last updated v5.0.0) (proxy/ERC1967/ERC1967Utils.sol)
/**
* @dev This library provides getters and event emitting update functions for
* https://eips.ethereum.org/EIPS/eip-1967[ERC-1967] slots.
*/
library ERC1967Utils {
/**
* @dev Storage slot with the address of the current implementation.
* This is the keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1.
*/
// solhint-disable-next-line private-vars-leading-underscore
bytes32 internal constant IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
/**
* @dev The `implementation` of the proxy is invalid.
*/
error ERC1967InvalidImplementation(address implementation);
/**
* @dev The `admin` of the proxy is invalid.
*/
error ERC1967InvalidAdmin(address admin);
/**
* @dev The `beacon` of the proxy is invalid.
*/
error ERC1967InvalidBeacon(address beacon);
/**
* @dev An upgrade function sees `msg.value > 0` that may be lost.
*/
error ERC1967NonPayable();
/**
* @dev Returns the current implementation address.
*/
function getImplementation() internal view returns (address) {
return StorageSlot.getAddressSlot(IMPLEMENTATION_SLOT).value;
}
/**
* @dev Stores a new address in the ERC-1967 implementation slot.
*/
function _setImplementation(address newImplementation) private {
if (newImplementation.code.length == 0) {
revert ERC1967InvalidImplementation(newImplementation);
}
StorageSlot.getAddressSlot(IMPLEMENTATION_SLOT).value = newImplementation;
}
/**
* @dev Performs implementation upgrade with additional setup call if data is nonempty.
* This function is payable only if the setup call is performed, otherwise `msg.value` is rejected
* to avoid stuck value in the contract.
*
* Emits an {IERC1967-Upgraded} event.
*/
function upgradeToAndCall(address newImplementation, bytes memory data) internal {
_setImplementation(newImplementation);
emit IERC1967.Upgraded(newImplementation);
if (data.length > 0) {
Address.functionDelegateCall(newImplementation, data);
} else {
_checkNonPayable();
}
}
/**
* @dev Storage slot with the admin of the contract.
* This is the keccak-256 hash of "eip1967.proxy.admin" subtracted by 1.
*/
// solhint-disable-next-line private-vars-leading-underscore
bytes32 internal constant ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
/**
* @dev Returns the current admin.
*
* TIP: To get this value clients can read directly from the storage slot shown below (specified by ERC-1967) using
* the https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call.
* `0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103`
*/
function getAdmin() internal view returns (address) {
return StorageSlot.getAddressSlot(ADMIN_SLOT).value;
}
/**
* @dev Stores a new address in the ERC-1967 admin slot.
*/
function _setAdmin(address newAdmin) private {
if (newAdmin == address(0)) {
revert ERC1967InvalidAdmin(address(0));
}
StorageSlot.getAddressSlot(ADMIN_SLOT).value = newAdmin;
}
/**
* @dev Changes the admin of the proxy.
*
* Emits an {IERC1967-AdminChanged} event.
*/
function changeAdmin(address newAdmin) internal {
emit IERC1967.AdminChanged(getAdmin(), newAdmin);
_setAdmin(newAdmin);
}
/**
* @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.
* This is the keccak-256 hash of "eip1967.proxy.beacon" subtracted by 1.
*/
// solhint-disable-next-line private-vars-leading-underscore
bytes32 internal constant BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;
/**
* @dev Returns the current beacon.
*/
function getBeacon() internal view returns (address) {
return StorageSlot.getAddressSlot(BEACON_SLOT).value;
}
/**
* @dev Stores a new beacon in the ERC-1967 beacon slot.
*/
function _setBeacon(address newBeacon) private {
if (newBeacon.code.length == 0) {
revert ERC1967InvalidBeacon(newBeacon);
}
StorageSlot.getAddressSlot(BEACON_SLOT).value = newBeacon;
address beaconImplementation = IBeacon(newBeacon).implementation();
if (beaconImplementation.code.length == 0) {
revert ERC1967InvalidImplementation(beaconImplementation);
}
}
/**
* @dev Change the beacon and trigger a setup call if data is nonempty.
* This function is payable only if the setup call is performed, otherwise `msg.value` is rejected
* to avoid stuck value in the contract.
*
* Emits an {IERC1967-BeaconUpgraded} event.
*
* CAUTION: Invoking this function has no effect on an instance of {BeaconProxy} since v5, since
* it uses an immutable beacon without looking at the value of the ERC-1967 beacon slot for
* efficiency.
*/
function upgradeBeaconToAndCall(address newBeacon, bytes memory data) internal {
_setBeacon(newBeacon);
emit IERC1967.BeaconUpgraded(newBeacon);
if (data.length > 0) {
Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);
} else {
_checkNonPayable();
}
}
/**
* @dev Reverts if `msg.value` is not zero. It can be used to avoid `msg.value` stuck in the contract
* if an upgrade doesn't perform an initialization call.
*/
function _checkNonPayable() private {
if (msg.value > 0) {
revert ERC1967NonPayable();
}
}
}
// lib/openzeppelin-contracts-upgradeable/contracts/token/ERC20/ERC20Upgradeable.sol
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/ERC20.sol)
/**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
*
* TIP: For a detailed writeup see our guide
* https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
* to implement supply mechanisms].
*
* The default value of {decimals} is 18. To change this, you should override
* this function so it returns a different value.
*
* We have followed general OpenZeppelin Contracts guidelines: functions revert
* instead returning `false` on failure. This behavior is nonetheless
* conventional and does not conflict with the expectations of ERC-20
* applications.
*/
abstract contract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20, IERC20Metadata, IERC20Errors {
/// @custom:storage-location erc7201:openzeppelin.storage.ERC20
struct ERC20Storage {
mapping(address account => uint256) _balances;
mapping(address account => mapping(address spender => uint256)) _allowances;
uint256 _totalSupply;
string _name;
string _symbol;
}
// keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.ERC20")) - 1)) & ~bytes32(uint256(0xff))
bytes32 private constant ERC20StorageLocation = 0x52c63247e1f47db19d5ce0460030c497f067ca4cebf71ba98eeadabe20bace00;
function _getERC20Storage() private pure returns (ERC20Storage storage $) {
assembly {
$.slot := ERC20StorageLocation
}
}
/**
* @dev Sets the values for {name} and {symbol}.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
function __ERC20_init(string memory name_, string memory symbol_) internal onlyInitializing {
__ERC20_init_unchained(name_, symbol_);
}
function __ERC20_init_unchained(string memory name_, string memory symbol_) internal onlyInitializing {
ERC20Storage storage $ = _getERC20Storage();
$._name = name_;
$._symbol = symbol_;
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual returns (string memory) {
ERC20Storage storage $ = _getERC20Storage();
return $._name;
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual returns (string memory) {
ERC20Storage storage $ = _getERC20Storage();
return $._symbol;
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5.05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the default value returned by this function, unless
* it's overridden.
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual returns (uint8) {
return 18;
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual returns (uint256) {
ERC20Storage storage $ = _getERC20Storage();
return $._totalSupply;
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual returns (uint256) {
ERC20Storage storage $ = _getERC20Storage();
return $._balances[account];
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - the caller must have a balance of at least `value`.
*/
function transfer(address to, uint256 value) public virtual returns (bool) {
address owner = _msgSender();
_transfer(owner, to, value);
return true;
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual returns (uint256) {
ERC20Storage storage $ = _getERC20Storage();
return $._allowances[owner][spender];
}
/**
* @dev See {IERC20-approve}.
*
* NOTE: If `value` is the maximum `uint256`, the allowance is not updated on
* `transferFrom`. This is semantically equivalent to an infinite approval.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 value) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, value);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Skips emitting an {Approval} event indicating an allowance update. This is not
* required by the ERC. See {xref-ERC20-_approve-address-address-uint256-bool-}[_approve].
*
* NOTE: Does not update the allowance if the current allowance
* is the maximum `uint256`.
*
* Requirements:
*
* - `from` and `to` cannot be the zero address.
* - `from` must have a balance of at least `value`.
* - the caller must have allowance for ``from``'s tokens of at least
* `value`.
*/
function transferFrom(address from, address to, uint256 value) public virtual returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, value);
_transfer(from, to, value);
return true;
}
/**
* @dev Moves a `value` amount of tokens from `from` to `to`.
*
* This internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* NOTE: This function is not virtual, {_update} should be overridden instead.
*/
function _transfer(address from, address to, uint256 value) internal {
if (from == address(0)) {
revert ERC20InvalidSender(address(0));
}
if (to == address(0)) {
revert ERC20InvalidReceiver(address(0));
}
_update(from, to, value);
}
/**
* @dev Transfers a `value` amount of tokens from `from` to `to`, or alternatively mints (or burns) if `from`
* (or `to`) is the zero address. All customizations to transfers, mints, and burns should be done by overriding
* this function.
*
* Emits a {Transfer} event.
*/
function _update(address from, address to, uint256 value) internal virtual {
ERC20Storage storage $ = _getERC20Storage();
if (from == address(0)) {
// Overflow check required: The rest of the code assumes that totalSupply never overflows
$._totalSupply += value;
} else {
uint256 fromBalance = $._balances[from];
if (fromBalance < value) {
revert ERC20InsufficientBalance(from, fromBalance, value);
}
unchecked {
// Overflow not possible: value <= fromBalance <= totalSupply.
$._balances[from] = fromBalance - value;
}
}
if (to == address(0)) {
unchecked {
// Overflow not possible: value <= totalSupply or value <= fromBalance <= totalSupply.
$._totalSupply -= value;
}
} else {
unchecked {
// Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256.
$._balances[to] += value;
}
}
emit Transfer(from, to, value);
}
/**
* @dev Creates a `value` amount of tokens and assigns them to `account`, by transferring it from address(0).
* Relies on the `_update` mechanism
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* NOTE: This function is not virtual, {_update} should be overridden instead.
*/
function _mint(address account, uint256 value) internal {
if (account == address(0)) {
revert ERC20InvalidReceiver(address(0));
}
_update(address(0), account, value);
}
/**
* @dev Destroys a `value` amount of tokens from `account`, lowering the total supply.
* Relies on the `_update` mechanism.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* NOTE: This function is not virtual, {_update} should be overridden instead
*/
function _burn(address account, uint256 value) internal {
if (account == address(0)) {
revert ERC20InvalidSender(address(0));
}
_update(account, address(0), value);
}
/**
* @dev Sets `value` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*
* Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.
*/
function _approve(address owner, address spender, uint256 value) internal {
_approve(owner, spender, value, true);
}
/**
* @dev Variant of {_approve} with an optional flag to enable or disable the {Approval} event.
*
* By default (when calling {_approve}) the flag is set to true. On the other hand, approval changes made by
* `_spendAllowance` during the `transferFrom` operation set the flag to false. This saves gas by not emitting any
* `Approval` event during `transferFrom` operations.
*
* Anyone who wishes to continue emitting `Approval` events on the`transferFrom` operation can force the flag to
* true using the following override:
*
* ```solidity
* function _approve(address owner, address spender, uint256 value, bool) internal virtual override {
* super._approve(owner, spender, value, true);
* }
* ```
*
* Requirements are the same as {_approve}.
*/
function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual {
ERC20Storage storage $ = _getERC20Storage();
if (owner == address(0)) {
revert ERC20InvalidApprover(address(0));
}
if (spender == address(0)) {
revert ERC20InvalidSpender(address(0));
}
$._allowances[owner][spender] = value;
if (emitEvent) {
emit Approval(owner, spender, value);
}
}
/**
* @dev Updates `owner` s allowance for `spender` based on spent `value`.
*
* Does not update the allowance value in case of infinite allowance.
* Revert if not enough allowance is available.
*
* Does not emit an {Approval} event.
*/
function _spendAllowance(address owner, address spender, uint256 value) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
if (currentAllowance < value) {
revert ERC20InsufficientAllowance(spender, currentAllowance, value);
}
unchecked {
_approve(owner, spender, currentAllowance - value, false);
}
}
}
}
// lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/UUPSUpgradeable.sol
// OpenZeppelin Contracts (last updated v5.0.0) (proxy/utils/UUPSUpgradeable.sol)
/**
* @dev An upgradeability mechanism designed for UUPS proxies. The functions included here can perform an upgrade of an
* {ERC1967Proxy}, when this contract is set as the implementation behind such a proxy.
*
* A security mechanism ensures that an upgrade does not turn off upgradeability accidentally, although this risk is
* reinstated if the upgrade retains upgradeability but removes the security mechanism, e.g. by replacing
* `UUPSUpgradeable` with a custom implementation of upgrades.
*
* The {_authorizeUpgrade} function must be overridden to include access restriction to the upgrade mechanism.
*/
abstract contract UUPSUpgradeable is Initializable, IERC1822Proxiable {
/// @custom:oz-upgrades-unsafe-allow state-variable-immutable
address private immutable __self = address(this);
/**
* @dev The version of the upgrade interface of the contract. If this getter is missing, both `upgradeTo(address)`
* and `upgradeToAndCall(address,bytes)` are present, and `upgradeTo` must be used if no function should be called,
* while `upgradeToAndCall` will invoke the `receive` function if the second argument is the empty byte string.
* If the getter returns `"5.0.0"`, only `upgradeToAndCall(address,bytes)` is present, and the second argument must
* be the empty byte string if no function should be called, making it impossible to invoke the `receive` function
* during an upgrade.
*/
string public constant UPGRADE_INTERFACE_VERSION = "5.0.0";
/**
* @dev The call is from an unauthorized context.
*/
error UUPSUnauthorizedCallContext();
/**
* @dev The storage `slot` is unsupported as a UUID.
*/
error UUPSUnsupportedProxiableUUID(bytes32 slot);
/**
* @dev Check that the execution is being performed through a delegatecall call and that the execution context is
* a proxy contract with an implementation (as defined in ERC-1967) pointing to self. This should only be the case
* for UUPS and transparent proxies that are using the current contract as their implementation. Execution of a
* function through ERC-1167 minimal proxies (clones) would not normally pass this test, but is not guaranteed to
* fail.
*/
modifier onlyProxy() {
_checkProxy();
_;
}
/**
* @dev Check that the execution is not being performed through a delegate call. This allows a function to be
* callable on the implementing contract but not through proxies.
*/
modifier notDelegated() {
_checkNotDelegated();
_;
}
function __UUPSUpgradeable_init() internal onlyInitializing {
}
function __UUPSUpgradeable_init_unchained() internal onlyInitializing {
}
/**
* @dev Implementation of the ERC-1822 {proxiableUUID} function. This returns the storage slot used by the
* implementation. It is used to validate the implementation's compatibility when performing an upgrade.
*
* IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks
* bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this
* function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier.
*/
function proxiableUUID() external view virtual notDelegated returns (bytes32) {
return ERC1967Utils.IMPLEMENTATION_SLOT;
}
/**
* @dev Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call
* encoded in `data`.
*
* Calls {_authorizeUpgrade}.
*
* Emits an {Upgraded} event.
*
* @custom:oz-upgrades-unsafe-allow-reachable delegatecall
*/
function upgradeToAndCall(address newImplementation, bytes memory data) public payable virtual onlyProxy {
_authorizeUpgrade(newImplementation);
_upgradeToAndCallUUPS(newImplementation, data);
}
/**
* @dev Reverts if the execution is not performed via delegatecall or the execution
* context is not of a proxy with an ERC-1967 compliant implementation pointing to self.
* See {_onlyProxy}.
*/
function _checkProxy() internal view virtual {
if (
address(this) == __self || // Must be called through delegatecall
ERC1967Utils.getImplementation() != __self // Must be called through an active proxy
) {
revert UUPSUnauthorizedCallContext();
}
}
/**
* @dev Reverts if the execution is performed via delegatecall.
* See {notDelegated}.
*/
function _checkNotDelegated() internal view virtual {
if (address(this) != __self) {
// Must not be called through delegatecall
revert UUPSUnauthorizedCallContext();
}
}
/**
* @dev Function that should revert when `msg.sender` is not authorized to upgrade the contract. Called by
* {upgradeToAndCall}.
*
* Normally, this function will use an xref:access.adoc[access control] modifier such as {Ownable-onlyOwner}.
*
* ```solidity
* function _authorizeUpgrade(address) internal onlyOwner {}
* ```
*/
function _authorizeUpgrade(address newImplementation) internal virtual;
/**
* @dev Performs an implementation upgrade with a security check for UUPS proxies, and additional setup call.
*
* As a security check, {proxiableUUID} is invoked in the new implementation, and the return value
* is expected to be the implementation slot in ERC-1967.
*
* Emits an {IERC1967-Upgraded} event.
*/
function _upgradeToAndCallUUPS(address newImplementation, bytes memory data) private {
try IERC1822Proxiable(newImplementation).proxiableUUID() returns (bytes32 slot) {
if (slot != ERC1967Utils.IMPLEMENTATION_SLOT) {
revert UUPSUnsupportedProxiableUUID(slot);
}
ERC1967Utils.upgradeToAndCall(newImplementation, data);
} catch {
// The implementation is not UUPS
revert ERC1967Utils.ERC1967InvalidImplementation(newImplementation);
}
}
}
// src/Token.sol
/// @title Token
/// @dev contains all logic for the Token contract
contract Token is
IToken,
UUPSUpgradeable,
AccessControlUpgradeable,
ERC20Upgradeable,
PausableUpgradeable
{
using Address for address payable;
using EnumerableSet for EnumerableSet.AddressSet;
using EnumerableSet for EnumerableSet.UintSet;
using Math for uint256;
/// @dev role which can manage core parameters of the protocol (add game ids, set fractions etc)
bytes32 public constant MANAGER_ROLE = keccak256("MANAGER_ROLE");
/// @dev role which can withdraw/reallocate funds of the protocol (fees, earnings, trades, token backing, repayment)
bytes32 public constant FUND_MANAGER_ROLE = keccak256("FUND_MANAGER_ROLE");
/// @dev role which can set addresses of the protocol (treasury, trades wallet, refund operator)
bytes32 public constant ADDRESS_MANAGER_ROLE =
keccak256("ADDRESS_MANAGER_ROLE");
/// @dev role which can upgrade the contract
bytes32 public constant UPGRADER_ROLE = keccak256("UPGRADER_ROLE");
/// @dev role which can mint / burn tokens only
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
/// @dev role which can start new periods, payout ETH and set social root
bytes32 public constant SERVICE_ROLE = keccak256("SERVICE_ROLE");
/// @dev role which can pause the contracts
bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
// used for floating point calculations
uint256 public constant SCALE = 10 ** 36;
// used for fee calculations - not sufficient for floating point calculations
uint32 public constant BASIS = 1000000000;
/// @dev conversion ratio: 1 ETH = 1,000,000 $TOKEN
uint256 public constant TOKEN_TO_ETH_RATIO = 1e6;
constructor() {
_disableInitializers();
}
/// @inheritdoc IToken
function __Token_init(
string memory name,
string memory symbol,
InitializationAddresses calldata addresses,
InitializationBasisPointValues calldata basisPointValues
) external initializer {
__Pausable_init();
__AccessControl_init();
__UUPSUpgradeable_init();
__ERC20_init(name, symbol);
// set addresses
_grantRole(DEFAULT_ADMIN_ROLE, addresses.admin);
_grantRole(MANAGER_ROLE, addresses.manager);
_grantRole(FUND_MANAGER_ROLE, addresses.fundManager);
_grantRole(ADDRESS_MANAGER_ROLE, addresses.addressManager);
_grantRole(UPGRADER_ROLE, addresses.upgrader);
_grantRole(MINTER_ROLE, addresses.minter);
_grantRole(SERVICE_ROLE, addresses.service);
_grantRole(PAUSER_ROLE, addresses.pauser);
_setTreasury(addresses.treasury);
_setTradesWallet(addresses.tradesWallet);
// set BP values
_setDistributionFractionBP(basisPointValues.distributionFractionBP);
_setTradesFractionBP(basisPointValues.tradesFractionBP);
_setTokenBackingFractionBP(basisPointValues.tokenBackingFractionBP);
_setProtocolFeeBP(basisPointValues.protocolFeeBP);
_setRepaymentFractionBP(basisPointValues.repaymentFractionBP);
_setMummyPocketMoneyFractionBP(
basisPointValues.mummyPocketMoneyFractionBP
);
}
/// @inheritdoc IToken
function attempt(
uint256 gameId,
string calldata attemptId
) external payable whenNotPaused {
TokenStorage.Layout storage $ = TokenStorage.layout();
if (!$.gameIds.contains(gameId)) {
revert InvalidGameId();
}
if (msg.value == 0) {
revert ZeroAmountAttempt();
}
// allocate attempt value
uint256 fees = msg.value.mulDiv($.protocolFeeBP, BASIS);
uint256 tradesFundAllocation = msg.value.mulDiv(
$.tradesFractionBP,
BASIS
);
uint256 tokenBackingAllocation = msg.value.mulDiv(
$.tokenBackingFractionBP,
BASIS
);
uint256 repaymentFundAllocation = msg.value.mulDiv(
$.repaymentFractionBP,
BASIS
);
uint256 earnings = msg.value -
fees -
tradesFundAllocation -
tokenBackingAllocation -
repaymentFundAllocation;
uint256 mummyPocketMoneyAllocation = msg.value.mulDiv(
$.mummyPocketMoneyFractionBP,
BASIS
);
$.tradesFund += tradesFundAllocation;
$.tokenBackingFund += tokenBackingAllocation;
$.repaymentFund += repaymentFundAllocation;
$.fees += fees;
$.earnings += earnings;
$.periodEarnings += earnings;
$.mummyPocketMoney += mummyPocketMoneyAllocation;
emit AttemptMade(gameId, _msgSender(), msg.value, attemptId);
}
/// @inheritdoc IToken
function attemptWithToken(
uint256 gameId,
uint256 amount,
string calldata attemptId
) external whenNotPaused {
TokenStorage.Layout storage $ = TokenStorage.layout();
if (!$.gameIds.contains(gameId)) {
revert InvalidGameId();
}
// if amount is less than TOKEN_TO_ETH_RATIO less than 1
// wei is being sent in terms of value
if (amount < TOKEN_TO_ETH_RATIO) {
revert ZeroAmountAttempt();
}
uint256 amountValue = amount / TOKEN_TO_ETH_RATIO;
// allocate attempt value
uint256 fees = amountValue.mulDiv($.protocolFeeBP, BASIS);
uint256 tradesFundAllocation = amountValue.mulDiv(
$.tradesFractionBP,
BASIS
);
uint256 tokenBackingAllocation = amountValue.mulDiv(
$.tokenBackingFractionBP,
BASIS
);
uint256 repaymentFundAllocation = amountValue.mulDiv(
$.repaymentFractionBP,
BASIS
);
uint256 earnings = amountValue -
fees -
tradesFundAllocation -
tokenBackingAllocation -
repaymentFundAllocation;
uint256 mummyPocketMoneyAllocation = amountValue.mulDiv(
$.mummyPocketMoneyFractionBP,
BASIS
);
if ($.tokenBackingFund < amountValue - tokenBackingAllocation) {
revert InsufficientTokenBacking();
}
_accrueTokens($, _msgSender());
_burn(_msgSender(), amount);
$.fees += fees;
$.tradesFund += tradesFundAllocation;
// consolation decreases since that is where the value for this attempt
// comes from
$.tokenBackingFund -= amountValue - tokenBackingAllocation;
$.repaymentFund += repaymentFundAllocation;
$.earnings += earnings;
$.periodEarnings += earnings;
$.mummyPocketMoney += mummyPocketMoneyAllocation;
emit AttemptWithTokenMade(
gameId,
_msgSender(),
amount,
amountValue,
attemptId
);
}
/// @inheritdoc IToken
function addGameId(uint256 id) external onlyRole(MANAGER_ROLE) {
TokenStorage.layout().gameIds.add(id);
emit GameIdAdded(id);
}
/// @inheritdoc IToken
function batchRefund(
Refund[] calldata refunds
) external onlyRole(SERVICE_ROLE) {
TokenStorage.Layout storage $ = TokenStorage.layout();
uint256 refundCount = refunds.length;
uint256 totalAmount;
for (uint256 i = 0; i < refundCount; ++i) {
totalAmount += refunds[i].amount;
}
if (totalAmount > $.repaymentFund) {
revert InsufficientRepaymentFund();
}
$.repaymentFund -= totalAmount;
unchecked {
for (uint256 i = 0; i < refundCount; ++i) {
if (refunds[i].account == address(0)) {
revert ZeroAddress();
}
if (refunds[i].amount == 0) continue;
payable(refunds[i].account).sendValue(refunds[i].amount);
}
}
emit BatchRefundProcessed(refunds);
}
/// @inheritdoc IToken
function claim() external {
TokenStorage.Layout storage $ = TokenStorage.layout();
// accrue tokens prior to claim
AccrualData storage accountData = _accrueTokens($, _msgSender());
uint256 accruedTokens = accountData.accruedTokens;
// decrease distribution supply by claimed tokens
$.distributionSupply -= accruedTokens;
// set accruedTokens of account to 0
accountData.accruedTokens = 0;
_transfer(address(this), _msgSender(), accruedTokens);
}
/// @inheritdoc IToken
function claimSocialEarnings(
bytes32[] calldata proof,
uint256 amount
) external {
TokenStorage.Layout storage $ = TokenStorage.layout();
bytes32 leaf = keccak256(
abi.encodePacked(keccak256(abi.encodePacked(_msgSender(), amount)))
);
if (!MerkleProof.verify(proof, $.socialRoot, leaf)) {
revert InvalidProof();
}
uint256 amountEarned = amount - $.socialEarningsDeduction[_msgSender()];
if (amountEarned > $.earnings) {
revert InsufficientEarnings();
}
$.earnings -= amountEarned;
$.tokenBackingFund += amountEarned;
$.socialEarningsDeduction[_msgSender()] += amountEarned;
_accrueTokens($, _msgSender());
_mint(_msgSender(), amountEarned * TOKEN_TO_ETH_RATIO);
emit SocialEarningsClaimed(_msgSender(), amountEarned);
}
/// @inheritdoc IToken
function disperseTokens(
address[] calldata recipients,
uint256[] calldata amounts
) external onlyRole(MANAGER_ROLE) {
TokenStorage.Layout storage $ = TokenStorage.layout();
uint256 totalAmount;
for (uint256 i = 0; i < recipients.length; ++i) {
// accrue tokens prior to disperse
_accrueTokens($, recipients[i]);
_transfer(address(this), recipients[i], amounts[i]);
totalAmount += amounts[i];
}
$.airdropSupply -= totalAmount;
}
/// @inheritdoc IToken
function injectRepaymentLiquidity()
external
payable
onlyRole(MANAGER_ROLE)
{
TokenStorage.Layout storage $ = TokenStorage.layout();
$.repaymentFund += msg.value;
emit RepaymentLiquidityInjected(msg.value);
}
/// @inheritdoc IToken
function injectTradesLiquidity() external payable onlyRole(MANAGER_ROLE) {
TokenStorage.Layout storage $ = TokenStorage.layout();
$.tradesFund += msg.value;
emit TradesLiquidityInjected(msg.value);
}
/// @inheritdoc IToken
function injectTokenBackingLiquidity()
external
payable
onlyRole(MANAGER_ROLE)
{
TokenStorage.Layout storage $ = TokenStorage.layout();
$.tokenBackingFund += msg.value;
emit TokenBackingLiquidityInjected(msg.value);
}
/// @inheritdoc IToken
function mint(
address account,
uint256 amount
) external onlyRole(MINTER_ROLE) whenNotPaused {
if (TokenStorage.layout().distributionFractionBP == 0) {
_mint(account, amount);
} else {
_mintWithDistribution(account, amount);
}
}
/// @inheritdoc IToken
function mintAirdrop(
uint256 amount
) external payable onlyRole(MANAGER_ROLE) whenNotPaused {
TokenStorage.Layout storage $ = TokenStorage.layout();
// permit this to be zero; can provide enough ETH to cover the airdrop if desired
$.tokenBackingFund += msg.value;
uint256 availablility = $.tokenBackingFund *
TOKEN_TO_ETH_RATIO -
totalSupply();
if (amount > availablility) {
revert InsufficientTokenBacking();
}
_mint(address(this), amount);
// increase supply by the amount minted for airdrop
$.airdropSupply += amount;
emit AirdropMinted(amount);
}
/// @inheritdoc IToken
function pause() external override onlyRole(PAUSER_ROLE) whenNotPaused {
_pause();
}
/// @inheritdoc IToken
function reallocateFunds(
Fund from,
Fund to,
uint256 amount
) external onlyRole(FUND_MANAGER_ROLE) {
if (from == to) {
revert FundSelfTransfer();
}
_debitFund(from, amount);
_creditFund(to, amount);
emit FundsReallocated(from, to, amount);
}
/// @inheritdoc IToken
function resetMummyPocketMoney(
string calldata attemptId
) external onlyRole(SERVICE_ROLE) returns (uint256 mummyPocketMoney) {
TokenStorage.Layout storage $ = TokenStorage.layout();
mummyPocketMoney = $.mummyPocketMoney;
$.mummyPocketMoney = $.mummyPocketMoneyFloor;
emit MummyPocketMoneyReset(attemptId, mummyPocketMoney);
}
/// @inheritdoc IToken
function setDistributionFractionBP(
uint256 distributionFractionBP
) external onlyRole(MANAGER_ROLE) {
_setDistributionFractionBP(distributionFractionBP);
}
/// @inheritdoc IToken
function setMummyPocketMoneyFloor(
uint256 mummyPocketMoneyFloor
) external onlyRole(MANAGER_ROLE) {
TokenStorage.layout().mummyPocketMoneyFloor = mummyPocketMoneyFloor;
emit MummyPocketMoneyFloorSet(mummyPocketMoneyFloor);
}
/// @inheritdoc IToken
function setMummyPocketMoneyFractionBP(
uint256 mummyPocketMoneyFractionBP
) external onlyRole(MANAGER_ROLE) {
_setMummyPocketMoneyFractionBP(mummyPocketMoneyFractionBP);
}
/// @inheritdoc IToken
function setTradesFractionBP(
uint256 tradesFractionBP
) external onlyRole(MANAGER_ROLE) {
_setTradesFractionBP(tradesFractionBP);
}
/// @inheritdoc IToken
function setTradesWallet(
address tradesWallet
) external onlyRole(ADDRESS_MANAGER_ROLE) {
_setTradesWallet(tradesWallet);
}
/// @inheritdoc IToken
function setProtocolFeeBP(
uint256 protocolFeeBP
) external onlyRole(MANAGER_ROLE) {
_setProtocolFeeBP(protocolFeeBP);
}
/// @inheritdoc IToken
function setRepaymentFractionBP(
uint256 repaymentFractionBP
) external onlyRole(MANAGER_ROLE) {
_setRepaymentFractionBP(repaymentFractionBP);
}
/// @inheritdoc IToken
function setSocialRoot(bytes32 root) external onlyRole(SERVICE_ROLE) {
TokenStorage.layout().socialRoot = root;
emit SocialRootSet(root);
}
/// @inheritdoc IToken
function setTokenBackingFractionBP(
uint256 tokenBackingFractionBP
) external onlyRole(MANAGER_ROLE) {
_setTokenBackingFractionBP(tokenBackingFractionBP);
}
/// @inheritdoc IToken
function setTreasury(
address treasury
) external onlyRole(ADDRESS_MANAGER_ROLE) {
_setTreasury(treasury);
}
/// @inheritdoc IToken
function startNewPeriod()
external
onlyRole(SERVICE_ROLE)
returns (uint256 currentEarnings)
{
TokenStorage.Layout storage $ = TokenStorage.layout();
currentEarnings = $.periodEarnings;
delete $.periodEarnings;
emit NewPeriodStarted(currentEarnings);
}
/// @inheritdoc IToken
function unpause() external override onlyRole(PAUSER_ROLE) whenPaused {
_unpause();
}
/// @inheritdoc IToken
function withdrawEarnings(
uint256 amount
) external onlyRole(FUND_MANAGER_ROLE) {
TokenStorage.Layout storage $ = TokenStorage.layout();
if ($.earnings < amount) {
revert InsufficientEarnings();
}
$.earnings -= amount;
payable($.treasury).sendValue(amount);
emit EarningsWithdrawn(amount);
}
/// @inheritdoc IToken
function withdrawFees() external onlyRole(FUND_MANAGER_ROLE) {
TokenStorage.Layout storage $ = TokenStorage.layout();
uint256 fees = $.fees;
delete $.fees;
payable($.treasury).sendValue(fees);
emit FeesWithdrawn(fees);
}
/// @inheritdoc IToken
function withdrawTradesWalletFunds(
uint256 amount
) external onlyRole(FUND_MANAGER_ROLE) {
TokenStorage.Layout storage $ = TokenStorage.layout();
if (amount > $.tradesFund) {
revert TradesFundTooLow();
}
$.tradesFund -= amount;
payable($.tradesWallet).sendValue(amount);
emit TradesWalletFunded(amount);
}
/// @inheritdoc IToken
function withdrawTokenBackingLiquidity(
uint256 amount
) external onlyRole(FUND_MANAGER_ROLE) {
TokenStorage.Layout storage $ = TokenStorage.layout();
if (amount > $.tokenBackingFund) {
revert TokenBackingFundTooLow();
}
$.tokenBackingFund -= amount;
payable($.treasury).sendValue(amount);
emit TokenBackingLiquidityWithdrawn(amount);
}
/// @inheritdoc IToken
function getAccrualData(
address account
) external view returns (AccrualData memory data) {
data = TokenStorage.layout().accrualData[account];
}
/// @inheritdoc IToken
function getAirdropSupply() external view returns (uint256 supply) {
supply = TokenStorage.layout().airdropSupply;
}
/// @inheritdoc IToken
function getClaimableTokens(
address account
) external view returns (uint256 amount) {
TokenStorage.Layout storage $ = TokenStorage.layout();
AccrualData storage accountData = $.accrualData[account];
amount =
balanceOf(account).mulDiv(
$.globalRatio - accountData.offset,
SCALE
) +
accountData.accruedTokens;
}
/// @inheritdoc IToken
function getDistributionFractionBP()
external
view
returns (uint256 fractionBP)
{
fractionBP = TokenStorage.layout().distributionFractionBP;
}
/// @inheritdoc IToken
function getDistributionSupply() external view returns (uint256 supply) {
supply = TokenStorage.layout().distributionSupply;
}
/// @inheritdoc IToken
function getEarnings() external view returns (uint256 earnings) {
earnings = TokenStorage.layout().earnings;
}
/// @inheritdoc IToken
function getFees() external view returns (uint256 fees) {
fees = TokenStorage.layout().fees;
}
/// @inheritdoc IToken
function getGameIds() external view returns (uint256[] memory ids) {
ids = TokenStorage.layout().gameIds.values();
}
/// @inheritdoc IToken
function getMummyPocketMoney()
external
view
returns (uint256 mummyPocketMoney)
{
mummyPocketMoney = TokenStorage.layout().mummyPocketMoney;
}
/// @inheritdoc IToken
function getMummyPocketMoneyFloor()
external
view
returns (uint256 mummyPocketMoneyFloor)
{
mummyPocketMoneyFloor = TokenStorage.layout().mummyPocketMoneyFloor;
}
/// @inheritdoc IToken
function getMummyPocketMoneyFractionBP()
external
view
returns (uint256 mummyPocketMoneyFractionBP)
{
mummyPocketMoneyFractionBP = TokenStorage
.layout()
.mummyPocketMoneyFractionBP;
}
/// @notice returns the global ratio value
/// @return ratio global ratio value
function getGlobalRatio() external view returns (uint256 ratio) {
ratio = TokenStorage.layout().globalRatio;
}
/// @inheritdoc IToken
function getPeriodEarnings() external view returns (uint256 earnings) {
earnings = TokenStorage.layout().periodEarnings;
}
/// @inheritdoc IToken
function getProtocolFeeBP() external view returns (uint256 protocolFeeBP) {
protocolFeeBP = TokenStorage.layout().protocolFeeBP;
}
/// @inheritdoc IToken
function getRepaymentFractionBP()
external
view
returns (uint256 fractionBP)
{
fractionBP = TokenStorage.layout().repaymentFractionBP;
}
/// @inheritdoc IToken
function getRepaymentFund() external view returns (uint256 fund) {
fund = TokenStorage.layout().repaymentFund;
}
/// @inheritdoc IToken
function getSocialEarningsDeduction(
address account
) external view returns (uint256 deduction) {
deduction = TokenStorage.layout().socialEarningsDeduction[account];
}
/// @inheritdoc IToken
function getSocialRoot() external view returns (bytes32 root) {
root = TokenStorage.layout().socialRoot;
}
/// @inheritdoc IToken
function getTokenBackingFractionBP()
external
view
returns (uint256 fractionBP)
{
fractionBP = TokenStorage.layout().tokenBackingFractionBP;
}
/// @inheritdoc IToken
function getTokenBackingFund() external view returns (uint256 fund) {
fund = TokenStorage.layout().tokenBackingFund;
}
/// @inheritdoc IToken
function getTradesFractionBP() external view returns (uint256 fractionBP) {
fractionBP = TokenStorage.layout().tradesFractionBP;
}
/// @inheritdoc IToken
function getTradesFund() external view returns (uint256 fund) {
fund = TokenStorage.layout().tradesFund;
}
/// @inheritdoc IToken
function getTradesWallet() external view returns (address wallet) {
wallet = TokenStorage.layout().tradesWallet;
}
/// @inheritdoc IToken
function getTreasury() external view returns (address treasury) {
treasury = TokenStorage.layout().treasury;
}
/// @notice accrues the tokens available for claiming for an account
/// @param $ TokenStorage Layout struct
/// @param account address of account
/// @return accountData accrualData of given account
function _accrueTokens(
TokenStorage.Layout storage $,
address account
) internal returns (AccrualData storage accountData) {
accountData = $.accrualData[account];
// calculate claimable tokens
uint256 accruedTokens = balanceOf(account).mulDiv(
$.globalRatio - accountData.offset,
SCALE
);
// update account's last ratio
accountData.offset = $.globalRatio;
// update claimable tokens
accountData.accruedTokens += accruedTokens;
}
/// @inheritdoc UUPSUpgradeable
function _authorizeUpgrade(
address
) internal override onlyRole(UPGRADER_ROLE) {}
/// @notice sets a new value for distributionFractionBP
/// @param distributionFractionBP new distributionFractionBP value
function _setDistributionFractionBP(
uint256 distributionFractionBP
) internal {
_enforceBasis(distributionFractionBP, BASIS);
TokenStorage.layout().distributionFractionBP = distributionFractionBP;
emit DistributionFractionSet(distributionFractionBP);
}
/// @notice sets a new value for mummyPocketMoneyFractionBP
/// @param mummyPocketMoneyFractionBP new mummyPocketMoneyFractionBP value
function _setMummyPocketMoneyFractionBP(
uint256 mummyPocketMoneyFractionBP
) internal {
_enforceBasis(mummyPocketMoneyFractionBP, BASIS);
TokenStorage.Layout storage $ = TokenStorage.layout();
if ($.tradesFractionBP < mummyPocketMoneyFractionBP) {
revert TradesFractionExceeded();
}
$.mummyPocketMoneyFractionBP = mummyPocketMoneyFractionBP;
emit MummyPocketMoneyFractionSet(mummyPocketMoneyFractionBP);
}
/// @notice sets a new value for repaymentFractionBP
/// @param repaymentFractionBP new repaymentFractionBP value
function _setRepaymentFractionBP(uint256 repaymentFractionBP) internal {
_enforceBasis(repaymentFractionBP, BASIS);
TokenStorage.Layout storage $ = TokenStorage.layout();
if (
$.protocolFeeBP +
$.tradesFractionBP +
$.tokenBackingFractionBP +
repaymentFractionBP >
BASIS
) {
revert FractionSumExceedsBasis();
}
$.repaymentFractionBP = repaymentFractionBP;
emit RepaymentFractionSet(repaymentFractionBP);
}
/// @notice sets a new value for tradesFractionBP
/// @param tradesFractionBP new tradesFractionBP value
function _setTradesFractionBP(uint256 tradesFractionBP) internal {
_enforceBasis(tradesFractionBP, BASIS);
TokenStorage.Layout storage $ = TokenStorage.layout();
if (
$.tokenBackingFractionBP +
tradesFractionBP +
$.protocolFeeBP +
$.repaymentFractionBP >
BASIS
) {
revert FractionSumExceedsBasis();
}
$.tradesFractionBP = tradesFractionBP;
emit TradesFractionSet(tradesFractionBP);
}
/// @notice sets a new value for tradesWallet
/// @param tradesWallet new tradesWallet value
function _setTradesWallet(address tradesWallet) internal {
_enforceNonZeroAddress(tradesWallet);
TokenStorage.layout().tradesWallet = tradesWallet;
emit TradesWalletSet(tradesWallet);
}
/// @notice sets a new value for protocolFeeBP
/// @param feeBP new protocolFeeBP value
function _setProtocolFeeBP(uint256 feeBP) internal {
_enforceBasis(feeBP, BASIS);
TokenStorage.Layout storage $ = TokenStorage.layout();
if (
$.tokenBackingFractionBP +
$.tradesFractionBP +
feeBP +
$.repaymentFractionBP >
BASIS
) {
revert FractionSumExceedsBasis();
}
$.protocolFeeBP = feeBP;
emit ProtocolFeeSet(feeBP);
}
/// @notice sets a new value for tokenBackingFractionBP
/// @param tokenBackingFractionBP new tokenBackingFractionBP value
function _setTokenBackingFractionBP(
uint256 tokenBackingFractionBP
) internal {
_enforceBasis(tokenBackingFractionBP, BASIS);
TokenStorage.Layout storage $ = TokenStorage.layout();
if (
$.tradesFractionBP +
$.protocolFeeBP +
$.repaymentFractionBP +
tokenBackingFractionBP >
BASIS
) {
revert FractionSumExceedsBasis();
}
$.tokenBackingFractionBP = tokenBackingFractionBP;
emit TokenBackingFractionSet(tokenBackingFractionBP);
}
/// @notice sets a new value for treasury
/// @param treasury new treasury value
function _setTreasury(address treasury) internal {
_enforceNonZeroAddress(treasury);
TokenStorage.layout().treasury = treasury;
emit TreasurySet(treasury);
}
/// @notice enforces that an address is not the zero address
/// @param addressToCheck address to check
function _enforceNonZeroAddress(address addressToCheck) internal pure {
if (addressToCheck == address(0)) {
revert ZeroAddress();
}
}
/// @notice credits a given fund with an amount
/// @param fund Fund to credit
/// @param amount Amount to credit
function _creditFund(Fund fund, uint256 amount) internal {
TokenStorage.Layout storage $ = TokenStorage.layout();
// enum conversion error thrown if fund is invalid
if (fund == Fund.FEES) $.fees += amount;
else if (fund == Fund.EARNINGS) $.earnings += amount;
else if (fund == Fund.TRADES) $.tradesFund += amount;
else if (fund == Fund.TOKEN_BACKING) $.tokenBackingFund += amount;
else if (fund == Fund.REPAYMENT) $.repaymentFund += amount;
}
/// @notice debits a given fund with an amount
/// @param fund Fund to debit
/// @param amount Amount to debit
function _debitFund(Fund fund, uint256 amount) internal {
TokenStorage.Layout storage $ = TokenStorage.layout();
// enum conversion error thrown if fund is invalid
if (fund == Fund.FEES) $.fees -= amount;
else if (fund == Fund.EARNINGS) $.earnings -= amount;
else if (fund == Fund.TRADES) $.tradesFund -= amount;
else if (fund == Fund.TOKEN_BACKING) $.tokenBackingFund -= amount;
else if (fund == Fund.REPAYMENT) $.repaymentFund -= amount;
}
/// @notice mints tokens when distributionFractionBP is non-zero
/// @param account address of account to mint to
/// @param amount amount to mint
function _mintWithDistribution(address account, uint256 amount) internal {
TokenStorage.Layout storage $ = TokenStorage.layout();
// calculate amount for distribution
uint256 distributionAmount = amount.mulDiv(
$.distributionFractionBP,
BASIS
);
// decrease amount to mint to account
amount -= distributionAmount;
uint256 accountBalance = balanceOf(account);
uint256 supplyDelta = totalSupply() -
accountBalance -
$.distributionSupply -
$.airdropSupply;
AccrualData storage accountData = $.accrualData[account];
// Always calculate and accrue previous token accruals
uint256 previousAccruals = accountBalance.mulDiv(
$.globalRatio - accountData.offset,
SCALE
);
// Calculate the distribution ratio
uint256 distributionRatio = distributionAmount.mulDiv(
SCALE,
supplyDelta > 0 ? supplyDelta : amount
);
// Update globalRatio
$.globalRatio += distributionRatio;
// If supplyDelta is zero, adjust the account offset differently
if (supplyDelta == 0) {
// Handle the case where there are no tokens in circulation
// If this is the first minter, account offset should be one step behind globalRatio
if ($.globalRatio % distributionRatio == 0) {
accountData.offset = $.globalRatio - distributionRatio;
} else {
// Sole holder due to all other minters burning tokens
accountData.accruedTokens +=
distributionAmount +
previousAccruals;
accountData.offset = $.globalRatio;
}
} else {
// Normal case where there are other tokens in circulation
accountData.offset = $.globalRatio;
accountData.accruedTokens += previousAccruals;
}
$.distributionSupply += distributionAmount;
// mint tokens to contract and account
_mint(address(this), distributionAmount);
_mint(account, amount);
}
/// @inheritdoc ERC20Upgradeable
/// @dev overrides _update hook to enforce non-transferability
function _update(
address from,
address to,
uint256 value
) internal virtual override {
if (from != address(0) && from != address(this)) {
if (to != address(0)) {
revert NonTransferable();
}
}
super._update(from, to, value);
}
/// @notice enforces that a value does not exceed the basis
/// @param value value to check
/// @param basis basis to check against
function _enforceBasis(uint256 value, uint256 basis) internal pure {
if (value > basis) {
revert BasisExceeded();
}
}
}Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
Contract ABI
API[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AccessControlBadConfirmation","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"bytes32","name":"neededRole","type":"bytes32"}],"name":"AccessControlUnauthorizedAccount","type":"error"},{"inputs":[{"internalType":"address","name":"target","type":"address"}],"name":"AddressEmptyCode","type":"error"},{"inputs":[],"name":"ArrayLengthMismatch","type":"error"},{"inputs":[],"name":"BasisExceeded","type":"error"},{"inputs":[{"internalType":"address","name":"implementation","type":"address"}],"name":"ERC1967InvalidImplementation","type":"error"},{"inputs":[],"name":"ERC1967NonPayable","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"allowance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientAllowance","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientBalance","type":"error"},{"inputs":[{"internalType":"address","name":"approver","type":"address"}],"name":"ERC20InvalidApprover","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"ERC20InvalidReceiver","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"ERC20InvalidSender","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"}],"name":"ERC20InvalidSpender","type":"error"},{"inputs":[],"name":"EnforcedPause","type":"error"},{"inputs":[],"name":"ExpectedPause","type":"error"},{"inputs":[],"name":"FailedCall","type":"error"},{"inputs":[],"name":"FractionSumExceedsBasis","type":"error"},{"inputs":[],"name":"FundSelfTransfer","type":"error"},{"inputs":[{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"InsufficientBalance","type":"error"},{"inputs":[],"name":"InsufficientEarnings","type":"error"},{"inputs":[],"name":"InsufficientRepaymentFund","type":"error"},{"inputs":[],"name":"InsufficientTokenBacking","type":"error"},{"inputs":[],"name":"InvalidFund","type":"error"},{"inputs":[],"name":"InvalidGameId","type":"error"},{"inputs":[],"name":"InvalidInitialization","type":"error"},{"inputs":[],"name":"InvalidProof","type":"error"},{"inputs":[],"name":"NonTransferable","type":"error"},{"inputs":[],"name":"NotInitializing","type":"error"},{"inputs":[],"name":"TokenBackingFundTooLow","type":"error"},{"inputs":[],"name":"TradesFractionExceeded","type":"error"},{"inputs":[],"name":"TradesFundTooLow","type":"error"},{"inputs":[],"name":"UUPSUnauthorizedCallContext","type":"error"},{"inputs":[{"internalType":"bytes32","name":"slot","type":"bytes32"}],"name":"UUPSUnsupportedProxiableUUID","type":"error"},{"inputs":[],"name":"ZeroAddress","type":"error"},{"inputs":[],"name":"ZeroAmountAttempt","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"AirdropMinted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"gameId","type":"uint256"},{"indexed":false,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"string","name":"attemptId","type":"string"}],"name":"AttemptMade","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"gameId","type":"uint256"},{"indexed":false,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amountValue","type":"uint256"},{"indexed":false,"internalType":"string","name":"attemptId","type":"string"}],"name":"AttemptWithTokenMade","type":"event"},{"anonymous":false,"inputs":[{"components":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"indexed":false,"internalType":"struct Refund[]","name":"refunds","type":"tuple[]"}],"name":"BatchRefundProcessed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"distributionFractionBP","type":"uint256"}],"name":"DistributionFractionSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"EarningsWithdrawn","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"fees","type":"uint256"}],"name":"FeesWithdrawn","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"enum Fund","name":"from","type":"uint8"},{"indexed":false,"internalType":"enum Fund","name":"to","type":"uint8"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"FundsReallocated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"gameId","type":"uint256"}],"name":"GameIdAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint64","name":"version","type":"uint64"}],"name":"Initialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"MinterAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"MinterRemoved","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"mummyPocketMoneyFloor","type":"uint256"}],"name":"MummyPocketMoneyFloorSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"mummyPocketMoneyFractionBP","type":"uint256"}],"name":"MummyPocketMoneyFractionSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"attemptId","type":"string"},{"indexed":false,"internalType":"uint256","name":"mummyPocketMoney","type":"uint256"}],"name":"MummyPocketMoneyReset","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"currentEarnings","type":"uint256"}],"name":"NewPeriodStarted","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"protocolFeeBP","type":"uint256"}],"name":"ProtocolFeeSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"repaymentFractionBP","type":"uint256"}],"name":"RepaymentFractionSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"RepaymentLiquidityInjected","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"previousAdminRole","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"newAdminRole","type":"bytes32"}],"name":"RoleAdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleGranted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"SocialEarningsClaimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes32","name":"root","type":"bytes32"}],"name":"SocialRootSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"fractionBP","type":"uint256"}],"name":"TokenBackingFractionSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"TokenBackingLiquidityInjected","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"TokenBackingLiquidityWithdrawn","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"tradesFractionBP","type":"uint256"}],"name":"TradesFractionSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"TradesLiquidityInjected","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"TradesWalletFunded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"wallet","type":"address"}],"name":"TradesWalletSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"treasury","type":"address"}],"name":"TreasurySet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"implementation","type":"address"}],"name":"Upgraded","type":"event"},{"inputs":[],"name":"ADDRESS_MANAGER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"BASIS","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"FUND_MANAGER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MANAGER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MINTER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PAUSER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"SCALE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"SERVICE_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TOKEN_TO_ETH_RATIO","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"UPGRADER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"UPGRADE_INTERFACE_VERSION","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"symbol","type":"string"},{"components":[{"internalType":"address","name":"admin","type":"address"},{"internalType":"address","name":"manager","type":"address"},{"internalType":"address","name":"fundManager","type":"address"},{"internalType":"address","name":"addressManager","type":"address"},{"internalType":"address","name":"pauser","type":"address"},{"internalType":"address","name":"upgrader","type":"address"},{"internalType":"address","name":"service","type":"address"},{"internalType":"address","name":"minter","type":"address"},{"internalType":"address","name":"treasury","type":"address"},{"internalType":"address","name":"tradesWallet","type":"address"}],"internalType":"struct InitializationAddresses","name":"addresses","type":"tuple"},{"components":[{"internalType":"uint256","name":"distributionFractionBP","type":"uint256"},{"internalType":"uint256","name":"tradesFractionBP","type":"uint256"},{"internalType":"uint256","name":"tokenBackingFractionBP","type":"uint256"},{"internalType":"uint256","name":"protocolFeeBP","type":"uint256"},{"internalType":"uint256","name":"repaymentFractionBP","type":"uint256"},{"internalType":"uint256","name":"mummyPocketMoneyFractionBP","type":"uint256"}],"internalType":"struct InitializationBasisPointValues","name":"basisPointValues","type":"tuple"}],"name":"__Token_init","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"addGameId","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"gameId","type":"uint256"},{"internalType":"string","name":"attemptId","type":"string"}],"name":"attempt","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"gameId","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"string","name":"attemptId","type":"string"}],"name":"attemptWithToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"internalType":"struct Refund[]","name":"refunds","type":"tuple[]"}],"name":"batchRefund","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32[]","name":"proof","type":"bytes32[]"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"claimSocialEarnings","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"recipients","type":"address[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"name":"disperseTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"getAccrualData","outputs":[{"components":[{"internalType":"uint256","name":"offset","type":"uint256"},{"internalType":"uint256","name":"accruedTokens","type":"uint256"}],"internalType":"struct AccrualData","name":"data","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getAirdropSupply","outputs":[{"internalType":"uint256","name":"supply","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"getClaimableTokens","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getDistributionFractionBP","outputs":[{"internalType":"uint256","name":"fractionBP","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getDistributionSupply","outputs":[{"internalType":"uint256","name":"supply","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getEarnings","outputs":[{"internalType":"uint256","name":"earnings","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getFees","outputs":[{"internalType":"uint256","name":"fees","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getGameIds","outputs":[{"internalType":"uint256[]","name":"ids","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getGlobalRatio","outputs":[{"internalType":"uint256","name":"ratio","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getMummyPocketMoney","outputs":[{"internalType":"uint256","name":"mummyPocketMoney","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getMummyPocketMoneyFloor","outputs":[{"internalType":"uint256","name":"mummyPocketMoneyFloor","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getMummyPocketMoneyFractionBP","outputs":[{"internalType":"uint256","name":"mummyPocketMoneyFractionBP","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getPeriodEarnings","outputs":[{"internalType":"uint256","name":"earnings","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getProtocolFeeBP","outputs":[{"internalType":"uint256","name":"protocolFeeBP","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getRepaymentFractionBP","outputs":[{"internalType":"uint256","name":"fractionBP","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getRepaymentFund","outputs":[{"internalType":"uint256","name":"fund","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleAdmin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"getSocialEarningsDeduction","outputs":[{"internalType":"uint256","name":"deduction","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getSocialRoot","outputs":[{"internalType":"bytes32","name":"root","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTokenBackingFractionBP","outputs":[{"internalType":"uint256","name":"fractionBP","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTokenBackingFund","outputs":[{"internalType":"uint256","name":"fund","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTradesFractionBP","outputs":[{"internalType":"uint256","name":"fractionBP","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTradesFund","outputs":[{"internalType":"uint256","name":"fund","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTradesWallet","outputs":[{"internalType":"address","name":"wallet","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTreasury","outputs":[{"internalType":"address","name":"treasury","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"grantRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"hasRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"injectRepaymentLiquidity","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"injectTokenBackingLiquidity","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"injectTradesLiquidity","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"mintAirdrop","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"proxiableUUID","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"enum Fund","name":"from","type":"uint8"},{"internalType":"enum Fund","name":"to","type":"uint8"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"reallocateFunds","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"callerConfirmation","type":"address"}],"name":"renounceRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"attemptId","type":"string"}],"name":"resetMummyPocketMoney","outputs":[{"internalType":"uint256","name":"mummyPocketMoney","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"revokeRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"distributionFractionBP","type":"uint256"}],"name":"setDistributionFractionBP","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"mummyPocketMoneyFloor","type":"uint256"}],"name":"setMummyPocketMoneyFloor","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"mummyPocketMoneyFractionBP","type":"uint256"}],"name":"setMummyPocketMoneyFractionBP","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"protocolFeeBP","type":"uint256"}],"name":"setProtocolFeeBP","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"repaymentFractionBP","type":"uint256"}],"name":"setRepaymentFractionBP","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"root","type":"bytes32"}],"name":"setSocialRoot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenBackingFractionBP","type":"uint256"}],"name":"setTokenBackingFractionBP","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tradesFractionBP","type":"uint256"}],"name":"setTradesFractionBP","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"tradesWallet","type":"address"}],"name":"setTradesWallet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"treasury","type":"address"}],"name":"setTreasury","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startNewPeriod","outputs":[{"internalType":"uint256","name":"currentEarnings","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newImplementation","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"upgradeToAndCall","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdrawEarnings","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdrawTokenBackingLiquidity","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdrawTradesWalletFunds","outputs":[],"stateMutability":"nonpayable","type":"function"}]Contract Creation Code
9c4d535b0000000000000000000000000000000000000000000000000000000000000000010008517b51d91ac42785c77123ceaa29ec1ceb7e517c427231bbff9756004d00000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000000
Deployed Bytecode
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
Loading...
Loading
Loading...
Loading
Loading...
Loading
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.