Warning! Contract bytecode has been changed and doesn't match the verified one. Therefore, interaction with this smart contract may be risky.
- Contract name:
- AllowList
- Optimization enabled
- true
- Compiler version
- v0.8.17+commit.8df45f5f
- Optimization runs
- 200
- EVM Version
- default
- Verified at
- 2024-07-26T18:13:59.866407Z
contracts/AllowList.sol
// SPDX-License-Identifier: MIT pragma solidity ^0.8; import "@openzeppelin/contracts/access/Ownable2Step.sol"; import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol"; import "./Tokenomics/IAllowlist.sol"; /** * @title Allowlist contract * @author RBL */ contract AllowList is IAllowList, Ownable2Step{ using EnumerableSet for EnumerableSet.AddressSet; /// @notice The addresses that are allowed EnumerableSet.AddressSet internal _allowedAddresses; /// @notice Emitted when an address is allowed event AddressAllowed(address address_); /// @notice Emitted when an address is disallowed event AddressDisallowed(address address_); /** * @notice Add address to allowed list */ function allow(address address_) external onlyOwner { require(!_allowedAddresses.contains(address_), 'address already allowed'); emit AddressAllowed(address_); _allowedAddresses.add(address_); } /** * @notice Remove address from allowed list */ function disallow(address address_) external onlyOwner { require(_allowedAddresses.contains(address_), 'address already disallowed'); emit AddressDisallowed(address_); _allowedAddresses.remove(address_); } /** * @dev returns length of _allowedAddresses array */ function allowedAddressesLength() external view returns (uint256) { return _allowedAddresses.length(); } /** * @dev returns _allowedAddresses array item's address for "index" */ function allowedAddresses(uint256 index) external view returns (address) { return _allowedAddresses.at(index); } /** * @notice Check if a address is allowed */ function allowed(address address_) external view returns (bool) { return _allowedAddresses.contains(address_); } }
@openzeppelin/contracts/access/Ownable.sol
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol) pragma solidity ^0.8.0; import "../utils/Context.sol"; /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * By default, the owner account will be the one that deploys the contract. This * can later be changed with {transferOwnership}. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ abstract contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ constructor() { _transferOwnership(_msgSender()); } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { _checkOwner(); _; } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if the sender is not the owner. */ function _checkOwner() internal view virtual { require(owner() == _msgSender(), "Ownable: caller is not the owner"); } /** * @dev Leaves the contract without owner. It will not be possible to call * `onlyOwner` functions. Can only be called by the current owner. * * NOTE: Renouncing ownership will leave the contract without an owner, * thereby disabling any functionality that is only available to the owner. */ function renounceOwnership() public virtual onlyOwner { _transferOwnership(address(0)); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Can only be called by the current owner. */ function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); _transferOwnership(newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Internal function without access restriction. */ function _transferOwnership(address newOwner) internal virtual { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } }
@openzeppelin/contracts/access/Ownable2Step.sol
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable2Step.sol) pragma solidity ^0.8.0; import "./Ownable.sol"; /** * @dev Contract module which provides access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * By default, the owner account will be the one that deploys the contract. This * can later be changed with {transferOwnership} and {acceptOwnership}. * * This module is used through inheritance. It will make available all functions * from parent (Ownable). */ abstract contract Ownable2Step is Ownable { address private _pendingOwner; event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner); /** * @dev Returns the address of the pending owner. */ function pendingOwner() public view virtual returns (address) { return _pendingOwner; } /** * @dev Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one. * Can only be called by the current owner. */ function transferOwnership(address newOwner) public virtual override onlyOwner { _pendingOwner = newOwner; emit OwnershipTransferStarted(owner(), newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`) and deletes any pending owner. * Internal function without access restriction. */ function _transferOwnership(address newOwner) internal virtual override { delete _pendingOwner; super._transferOwnership(newOwner); } /** * @dev The new owner accepts the ownership transfer. */ function acceptOwnership() public virtual { address sender = _msgSender(); require(pendingOwner() == sender, "Ownable2Step: caller is not the new owner"); _transferOwnership(sender); } }
@openzeppelin/contracts/utils/Context.sol
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (utils/Context.sol) pragma solidity ^0.8.0; /** * @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 Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } }
@openzeppelin/contracts/utils/structs/EnumerableSet.sol
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (utils/structs/EnumerableSet.sol) // This file was procedurally generated from scripts/generate/templates/EnumerableSet.js. pragma solidity ^0.8.0; /** * @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 of the value in the `values` array, plus 1 because index 0 // means a value is not in the set. mapping(bytes32 => uint256) _indexes; } /** * @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._indexes[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 read and store the value's index to prevent multiple reads from the same storage slot uint256 valueIndex = set._indexes[value]; if (valueIndex != 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 toDeleteIndex = valueIndex - 1; uint256 lastIndex = set._values.length - 1; if (lastIndex != toDeleteIndex) { bytes32 lastValue = set._values[lastIndex]; // Move the last value to the index where the value to delete is set._values[toDeleteIndex] = lastValue; // Update the index for the moved value set._indexes[lastValue] = valueIndex; // Replace lastValue's index to valueIndex } // Delete the slot where the moved value was stored set._values.pop(); // Delete the index for the deleted slot delete set._indexes[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._indexes[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; /// @solidity memory-safe-assembly assembly { 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; /// @solidity memory-safe-assembly assembly { 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; /// @solidity memory-safe-assembly assembly { result := store } return result; } }
contracts/Tokenomics/IAllowlist.sol
interface IAllowList{ function allowed(address address_) external returns (bool); }
Compiler Settings
{"outputSelection":{"*":{"*":["*"],"":["*"]}},"optimizer":{"runs":200,"enabled":true},"libraries":{}}
Contract ABI
[{"type":"event","name":"AddressAllowed","inputs":[{"type":"address","name":"address_","internalType":"address","indexed":false}],"anonymous":false},{"type":"event","name":"AddressDisallowed","inputs":[{"type":"address","name":"address_","internalType":"address","indexed":false}],"anonymous":false},{"type":"event","name":"OwnershipTransferStarted","inputs":[{"type":"address","name":"previousOwner","internalType":"address","indexed":true},{"type":"address","name":"newOwner","internalType":"address","indexed":true}],"anonymous":false},{"type":"event","name":"OwnershipTransferred","inputs":[{"type":"address","name":"previousOwner","internalType":"address","indexed":true},{"type":"address","name":"newOwner","internalType":"address","indexed":true}],"anonymous":false},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"acceptOwnership","inputs":[]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"allow","inputs":[{"type":"address","name":"address_","internalType":"address"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"bool","name":"","internalType":"bool"}],"name":"allowed","inputs":[{"type":"address","name":"address_","internalType":"address"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"address","name":"","internalType":"address"}],"name":"allowedAddresses","inputs":[{"type":"uint256","name":"index","internalType":"uint256"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"allowedAddressesLength","inputs":[]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"disallow","inputs":[{"type":"address","name":"address_","internalType":"address"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"address","name":"","internalType":"address"}],"name":"owner","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"address","name":"","internalType":"address"}],"name":"pendingOwner","inputs":[]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"renounceOwnership","inputs":[]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"transferOwnership","inputs":[{"type":"address","name":"newOwner","internalType":"address"}]}]
Contract Creation Code
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
Deployed ByteCode
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