Source Code
Overview
S Balance
0 SMore Info
ContractCreator
Loading...
Loading
Contract Name:
Presale
Compiler Version
v0.8.17+commit.8df45f5f
Optimization Enabled:
Yes with 200 runs
Other Settings:
default evmVersion
Contract Source Code (Solidity Standard Json-Input format)
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./interfaces/IStakingPool.sol";
import "./interfaces/IPresale.sol";
import "./Purchasable.sol";
import "./Fundable.sol";
import "./Vestable.sol";
import "./Whitelistable.sol";
contract Presale is Purchasable, Fundable, Vestable, Whitelistable, IPresale {
mapping(address => uint256) public claimable;
mapping(address => uint256) public totalPurchased;
string public metadataURI;
event EmergencyWithdrawal(address indexed user);
event MetadataURIChanged(string metadataURI);
event Refund(address indexed user, uint256 amount);
bool private isAlreadyInitialized;
// Main Staking Pool
IStakingPool public stakingPool;
constructor(
string memory _metadataURI,
address _funder,
uint256 _salePrice,
ERC20 _paymentToken,
ERC20 _saleToken,
uint256 _softCap,
uint256 _hardCap,
uint256 _startTime,
uint256 _endTime,
uint256 _minTotalPayment,
uint256 _maxTotalPayment,
uint256 _withdrawDelay
)
Purchasable(_paymentToken, _salePrice, _softCap, _hardCap, _minTotalPayment, _maxTotalPayment)
Vestable(_endTime)
Fundable(_paymentToken, _saleToken, _startTime, _endTime, _funder, _msgSender(), _msgSender(), _withdrawDelay)
Whitelistable()
{
if (isAlreadyInitialized) revert AlreadyInitialized();
metadataURI = _metadataURI;
emit PresaleCreated(
address(this),
_metadataURI,
_funder,
_salePrice,
address(_paymentToken),
address(_saleToken),
_softCap,
_hardCap,
_startTime,
_endTime,
_minTotalPayment,
_maxTotalPayment
);
isAlreadyInitialized = true;
}
function setWithdrawDelay(uint24 _withdrawDelay) public override onlyOwner onlyBeforeSale {
setWithdrawTime(endTime + _withdrawDelay);
super.setWithdrawDelay(_withdrawDelay);
}
function setLinearVestingEndTime(uint256 _vestingEndTime) public override onlyOwner onlyBeforeSale {
super.setLinearVestingEndTime(_vestingEndTime);
}
function setCliffPeriod(uint256[] calldata claimTimes, uint8[] calldata pct) public override onlyOwner onlyBeforeSale {
super.setCliffPeriod(claimTimes, pct);
}
function purchase(uint256 paymentAmount) public virtual override onlyDuringSale nonReentrant {
require(whitelistRootHash == 0, "use whitelisted purchase");
_purchase(paymentAmount, maxTotalPayment);
}
function whitelistedPurchase(uint256 paymentAmount, bytes32[] calldata merkleProof) public virtual override onlyDuringSale nonReentrant {
require(checkWhitelist(_msgSender(), merkleProof), "proof invalid");
_purchase(paymentAmount, maxTotalPayment);
}
function withdraw() public virtual override onlyAfterSale nonReentrant {
address user = _msgSender();
require(salePrice > 0, "use withdraw giveaway");
uint256 tokenOwed = getCurrentClaimableToken(user);
_withdraw(tokenOwed);
require(tokenOwed != 0, "no token to be withdrawn");
}
function emergencyWithdraw() public nonReentrant {
address user = _msgSender();
require(!hasCashed, "sale has been cashed already");
require(!hasWithdrawn[user], "cannot use emergency withdrawal after regular withdrawal");
require(paymentReceived[user] > 0, "you did not contribute to this sale");
TransferHelpers.safeTransferERC20(address(paymentToken), user, paymentReceived[user]);
totalPaymentReceived -= paymentReceived[user];
purchaserCount -= 1;
paymentReceived[user] = 0;
totalPurchased[user] = 0;
claimable[user] = 0;
emit EmergencyWithdrawal(user);
}
function withdrawGiveaway(bytes32[] calldata merkleProof) public virtual override onlyAfterSale nonReentrant {
address user = _msgSender();
require(salePrice == 0, "not a giveaway");
require(whitelistRootHash == 0 || checkWhitelist(user, merkleProof), "proof invalid");
uint256 tokenOwed = getCurrentClaimableToken(user);
if (!hasWithdrawn[user]) {
claimable[user] = tokenOwed;
totalPurchased[user] = tokenOwed;
}
_withdraw(tokenOwed);
require(tokenOwed > 0, "withdraw giveaway amount low");
}
function _purchase(uint256 paymentAmount, uint256 remaining) internal override {
totalPaymentReceived += paymentAmount;
super._purchase(paymentAmount, remaining);
uint256 tokenPurchased = (paymentReceived[_msgSender()] * SALE_PRICE_DECIMALS) / salePrice;
totalPurchased[_msgSender()] = tokenPurchased;
claimable[_msgSender()] = tokenPurchased;
}
function _withdraw(uint256 tokenOwed) internal override {
super._withdraw(tokenOwed);
latestClaimTime[_msgSender()] = block.timestamp;
claimable[_msgSender()] -= tokenOwed;
}
function getSaleTokensSold() internal view override returns (uint256 amount) {
return (totalPaymentReceived * SALE_PRICE_DECIMALS) / salePrice;
}
function getCurrentClaimableToken(address user) public view returns (uint256) {
uint256 baseTokens = getUnlockedToken(totalPurchased[user], claimable[user], user);
StakingTiers rank = getUserRank();
// Apply multiplier based on staking rank
if (rank == StakingTiers.RANK1) {
return (baseTokens * 15000) / 10000; // 1.5x
} else if (rank == StakingTiers.RANK2) {
return (baseTokens * 20000) / 10000; // 2x
} else if (rank == StakingTiers.RANK3) {
return (baseTokens * 25000) / 10000; // 2.5x
} else if (rank == StakingTiers.RANK4) {
return (baseTokens * 30000) / 10000; // 3x
} else if (rank == StakingTiers.RANK5) {
return (baseTokens * 35000) / 10000; // 3.5x
}
// Default: no multiplier
return baseTokens;
}
function checkWhitelist(address user, bytes32[] calldata merkleProof) public view virtual returns (bool) {
bytes32 leaf = keccak256(abi.encodePacked(user));
return MerkleProof.verify(merkleProof, whitelistRootHash, leaf);
}
function setMetadataURI(string memory _metadataURI) external onlyOwner {
metadataURI = _metadataURI;
emit MetadataURIChanged(_metadataURI);
}
function setStakingPool(IStakingPool _stakingPool) external onlyOwner {
stakingPool = _stakingPool;
}
function getUserRank() internal view returns (StakingTiers) {
address account = _msgSender();
uint256 amountStaked = stakingPool.amountStaked(account) / 1e18; // Adjust for 18 decimals
if (amountStaked >= 50000) {
return StakingTiers.RANK5;
} else if (amountStaked >= 15000) {
return StakingTiers.RANK4;
} else if (amountStaked >= 10000) {
return StakingTiers.RANK3;
} else if (amountStaked >= 5000) {
return StakingTiers.RANK2;
} else if (amountStaked >= 1000) {
return StakingTiers.RANK1;
} else {
return StakingTiers.NONE;
}
}
function isSoftCapReached() public view returns (bool) {
return totalPaymentReceived >= softCap;
}
function refundIfSoftCapNotReached() public nonReentrant {
require(block.timestamp > endTime, "Sale not ended yet");
require(!isSoftCapReached(), "Soft cap was reached");
require(paymentReceived[_msgSender()] > 0, "No funds to refund");
uint256 amountToRefund = paymentReceived[_msgSender()];
paymentReceived[_msgSender()] = 0;
totalPaymentReceived -= amountToRefund;
purchaserCount -= 1;
TransferHelpers.safeTransferERC20(address(paymentToken), _msgSender(), amountToRefund);
emit Refund(_msgSender(), amountToRefund);
}
receive() external payable {}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (access/AccessControl.sol)
pragma solidity ^0.8.0;
import "./IAccessControl.sol";
import "../utils/Context.sol";
import "../utils/Strings.sol";
import "../utils/introspection/ERC165.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 AccessControl is Context, IAccessControl, ERC165 {
struct RoleData {
mapping(address => bool) members;
bytes32 adminRole;
}
mapping(bytes32 => RoleData) private _roles;
bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
/**
* @dev Modifier that checks that an account has a specific role. Reverts
* with a standardized message including the required role.
*
* The format of the revert reason is given by the following regular expression:
*
* /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
*
* _Available since v4.1._
*/
modifier onlyRole(bytes32 role) {
_checkRole(role);
_;
}
/**
* @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 override returns (bool) {
return _roles[role].members[account];
}
/**
* @dev Revert with a standard message if `_msgSender()` is missing `role`.
* Overriding this function changes the behavior of the {onlyRole} modifier.
*
* Format of the revert message is described in {_checkRole}.
*
* _Available since v4.6._
*/
function _checkRole(bytes32 role) internal view virtual {
_checkRole(role, _msgSender());
}
/**
* @dev Revert with a standard message if `account` is missing `role`.
*
* The format of the revert reason is given by the following regular expression:
*
* /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
*/
function _checkRole(bytes32 role, address account) internal view virtual {
if (!hasRole(role, account)) {
revert(
string(
abi.encodePacked(
"AccessControl: account ",
Strings.toHexString(account),
" is missing role ",
Strings.toHexString(uint256(role), 32)
)
)
);
}
}
/**
* @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 override returns (bytes32) {
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 override 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 override 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 `account`.
*
* May emit a {RoleRevoked} event.
*/
function renounceRole(bytes32 role, address account) public virtual override {
require(account == _msgSender(), "AccessControl: can only renounce roles for self");
_revokeRole(role, account);
}
/**
* @dev Grants `role` to `account`.
*
* If `account` had not been already granted `role`, emits a {RoleGranted}
* event. Note that unlike {grantRole}, this function doesn't perform any
* checks on the calling account.
*
* May emit a {RoleGranted} event.
*
* [WARNING]
* ====
* This function should only be called from the constructor when setting
* up the initial roles for the system.
*
* Using this function in any other way is effectively circumventing the admin
* system imposed by {AccessControl}.
* ====
*
* NOTE: This function is deprecated in favor of {_grantRole}.
*/
function _setupRole(bytes32 role, address account) internal virtual {
_grantRole(role, account);
}
/**
* @dev Sets `adminRole` as ``role``'s admin role.
*
* Emits a {RoleAdminChanged} event.
*/
function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
bytes32 previousAdminRole = getRoleAdmin(role);
_roles[role].adminRole = adminRole;
emit RoleAdminChanged(role, previousAdminRole, adminRole);
}
/**
* @dev Grants `role` to `account`.
*
* Internal function without access restriction.
*
* May emit a {RoleGranted} event.
*/
function _grantRole(bytes32 role, address account) internal virtual {
if (!hasRole(role, account)) {
_roles[role].members[account] = true;
emit RoleGranted(role, account, _msgSender());
}
}
/**
* @dev Revokes `role` from `account`.
*
* Internal function without access restriction.
*
* May emit a {RoleRevoked} event.
*/
function _revokeRole(bytes32 role, address account) internal virtual {
if (hasRole(role, account)) {
_roles[role].members[account] = false;
emit RoleRevoked(role, account, _msgSender());
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol)
pragma solidity ^0.8.0;
/**
* @dev External interface of AccessControl declared to support ERC165 detection.
*/
interface IAccessControl {
/**
* @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.
*
* _Available since v3.1._
*/
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, an admin role
* bearer except when using {AccessControl-_setupRole}.
*/
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 `account`.
*/
function renounceRole(bytes32 role, address account) external;
}// 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);
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)
pragma solidity ^0.8.0;
import "../utils/Context.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 Pausable is Context {
/**
* @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);
bool private _paused;
/**
* @dev Initializes the contract in unpaused state.
*/
constructor() {
_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) {
return _paused;
}
/**
* @dev Throws if the contract is paused.
*/
function _requireNotPaused() internal view virtual {
require(!paused(), "Pausable: paused");
}
/**
* @dev Throws if the contract is not paused.
*/
function _requirePaused() internal view virtual {
require(paused(), "Pausable: not paused");
}
/**
* @dev Triggers stopped state.
*
* Requirements:
*
* - The contract must not be paused.
*/
function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
/**
* @dev Returns to normal state.
*
* Requirements:
*
* - The contract must be paused.
*/
function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (security/ReentrancyGuard.sol)
pragma solidity ^0.8.0;
/**
* @dev Contract module that helps prevent reentrant calls to a function.
*
* Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
* available, which can be applied to functions to make sure there are no nested
* (reentrant) calls to them.
*
* Note that because there is a single `nonReentrant` guard, functions marked as
* `nonReentrant` may not call one another. This can be worked around by making
* those functions `private`, and then adding `external` `nonReentrant` entry
* points to them.
*
* TIP: If you would like to learn more about reentrancy and alternative ways
* to protect against it, check out our blog post
* https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
*/
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
_status = _NOT_ENTERED;
}
/**
* @dev Prevents a contract from calling itself, directly or indirectly.
* Calling a `nonReentrant` function from another `nonReentrant`
* function is not supported. It is possible to prevent this from happening
* by making the `nonReentrant` function external, and making it call a
* `private` function that does the actual work.
*/
modifier nonReentrant() {
_nonReentrantBefore();
_;
_nonReentrantAfter();
}
function _nonReentrantBefore() private {
// On the first call to nonReentrant, _status will be _NOT_ENTERED
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
}
function _nonReentrantAfter() private {
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
/**
* @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
* `nonReentrant` function in the call stack.
*/
function _reentrancyGuardEntered() internal view returns (bool) {
return _status == _ENTERED;
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/ERC20.sol)
pragma solidity ^0.8.0;
import "./IERC20.sol";
import "./extensions/IERC20Metadata.sol";
import "../../utils/Context.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}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* 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 ERC20
* applications.
*
* Additionally, an {Approval} event is emitted on calls to {transferFrom}.
* This allows applications to reconstruct the allowance for all accounts just
* by listening to said events. Other implementations of the EIP may not emit
* these events, as it isn't required by the specification.
*
* Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
* functions have been added to mitigate the well-known issues around setting
* allowances. See {IERC20-approve}.
*/
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values for {name} and {symbol}.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual override returns (string memory) {
return _name;
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
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 override returns (uint8) {
return 18;
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address to, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_transfer(owner, to, amount);
return true;
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
/**
* @dev See {IERC20-approve}.
*
* NOTE: If `amount` 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 amount) public virtual override returns (bool) {
address owner = _msgSender();
_approve(owner, spender, amount);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* 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 `amount`.
* - the caller must have allowance for ``from``'s tokens of at least
* `amount`.
*/
function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, amount);
_transfer(from, to, amount);
return true;
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, allowance(owner, spender) + addedValue);
return true;
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
address owner = _msgSender();
uint256 currentAllowance = allowance(owner, spender);
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(owner, spender, currentAllowance - subtractedValue);
}
return true;
}
/**
* @dev Moves `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.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `from` must have a balance of at least `amount`.
*/
function _transfer(address from, address to, uint256 amount) internal virtual {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(from, to, amount);
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[from] = fromBalance - amount;
// Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by
// decrementing then incrementing.
_balances[to] += amount;
}
emit Transfer(from, to, amount);
_afterTokenTransfer(from, to, amount);
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
*/
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
unchecked {
// Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
_balances[account] += amount;
}
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
// Overflow not possible: amount <= accountBalance <= totalSupply.
_totalSupply -= amount;
}
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
/**
* @dev Sets `amount` 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.
*/
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
/**
* @dev Updates `owner` s allowance for `spender` based on spent `amount`.
*
* Does not update the allowance amount in case of infinite allowance.
* Revert if not enough allowance is available.
*
* Might emit an {Approval} event.
*/
function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
require(currentAllowance >= amount, "ERC20: insufficient allowance");
unchecked {
_approve(owner, spender, currentAllowance - amount);
}
}
}
/**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}
/**
* @dev Hook that is called after any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* has been transferred to `to`.
* - when `from` is zero, `amount` tokens have been minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens have been burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)
pragma solidity ^0.8.0;
import "../IERC20.sol";
/**
* @dev Interface for the optional metadata functions from the ERC20 standard.
*
* _Available since v4.1._
*/
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.4) (token/ERC20/extensions/IERC20Permit.sol)
pragma solidity ^0.8.0;
/**
* @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
* https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
*
* Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
* presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
* need to send a transaction, and thus is not required to hold Ether at all.
*
* ==== Security Considerations
*
* There are two important considerations concerning the use of `permit`. The first is that a valid permit signature
* expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be
* considered as an intention to spend the allowance in any specific way. The second is that because permits have
* built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should
* take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be
* generally recommended is:
*
* ```solidity
* function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {
* try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}
* doThing(..., value);
* }
*
* function doThing(..., uint256 value) public {
* token.safeTransferFrom(msg.sender, address(this), value);
* ...
* }
* ```
*
* Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of
* `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also
* {SafeERC20-safeTransferFrom}).
*
* Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so
* contracts should have entry points that don't rely on permit.
*/
interface IERC20Permit {
/**
* @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
* given ``owner``'s signed approval.
*
* IMPORTANT: The same issues {IERC20-approve} has related to transaction
* ordering also apply here.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `deadline` must be a timestamp in the future.
* - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
* over the EIP712-formatted function arguments.
* - the signature must use ``owner``'s current nonce (see {nonces}).
*
* For more information on the signature format, see the
* https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
* section].
*
* CAUTION: See Security Considerations above.
*/
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
/**
* @dev Returns the current nonce for `owner`. This value must be
* included whenever a signature is generated for {permit}.
*
* Every successful call to {permit} increases ``owner``'s nonce by one. This
* prevents a signature from being used multiple times.
*/
function nonces(address owner) external view returns (uint256);
/**
* @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
*/
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() external view returns (bytes32);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)
pragma solidity ^0.8.0;
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `to`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address to, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `from` to `to` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.3) (token/ERC20/utils/SafeERC20.sol)
pragma solidity ^0.8.0;
import "../IERC20.sol";
import "../extensions/IERC20Permit.sol";
import "../../../utils/Address.sol";
/**
* @title SafeERC20
* @dev Wrappers around ERC20 operations that throw on failure (when the token
* contract returns false). Tokens that return no value (and instead revert or
* throw on failure) are also supported, non-reverting calls are assumed to be
* successful.
* To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
* which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
*/
library SafeERC20 {
using Address for address;
/**
* @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
* non-reverting calls are assumed to be successful.
*/
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
/**
* @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
* calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
*/
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
/**
* @dev Deprecated. This function has issues similar to the ones found in
* {IERC20-approve}, and its usage is discouraged.
*
* Whenever possible, use {safeIncreaseAllowance} and
* {safeDecreaseAllowance} instead.
*/
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require(
(value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
/**
* @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
* non-reverting calls are assumed to be successful.
*/
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 oldAllowance = token.allowance(address(this), spender);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance + value));
}
/**
* @dev Decrease the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
* non-reverting calls are assumed to be successful.
*/
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance - value));
}
}
/**
* @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
* non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval
* to be set to zero before setting it to a non-zero value, such as USDT.
*/
function forceApprove(IERC20 token, address spender, uint256 value) internal {
bytes memory approvalCall = abi.encodeWithSelector(token.approve.selector, spender, value);
if (!_callOptionalReturnBool(token, approvalCall)) {
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0));
_callOptionalReturn(token, approvalCall);
}
}
/**
* @dev Use a ERC-2612 signature to set the `owner` approval toward `spender` on `token`.
* Revert on invalid signature.
*/
function safePermit(
IERC20Permit token,
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) internal {
uint256 nonceBefore = token.nonces(owner);
token.permit(owner, spender, value, deadline, v, r, s);
uint256 nonceAfter = token.nonces(owner);
require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
}
/**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*/
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
// we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
require(returndata.length == 0 || abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
/**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*
* This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.
*/
function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
// We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
// we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false
// and not revert is the subcall reverts.
(bool success, bytes memory returndata) = address(token).call(data);
return
success && (returndata.length == 0 || abi.decode(returndata, (bool))) && Address.isContract(address(token));
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)
pragma solidity ^0.8.1;
/**
* @dev Collection of functions related to the address type
*/
library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
*
* Furthermore, `isContract` will also return true if the target contract within
* the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
* which only has an effect at the end of a transaction.
* ====
*
* [IMPORTANT]
* ====
* You shouldn't rely on `isContract` to protect against flash loan attacks!
*
* Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
* like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
* constructor.
* ====
*/
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://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.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain `call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
/**
* @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
* the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
*
* _Available since v4.8._
*/
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
// only check isContract if the call was successful and the return data is empty
// otherwise we already know that it was a contract
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
/**
* @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
* revert reason or using the provided one.
*
* _Available since v4.3._
*/
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) 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
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.4) (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;
}
function _contextSuffixLength() internal view virtual returns (uint256) {
return 0;
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.2) (utils/cryptography/MerkleProof.sol)
pragma solidity ^0.8.0;
/**
* @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.
*/
library MerkleProof {
/**
* @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.
*/
function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
return processProof(proof, leaf) == root;
}
/**
* @dev Calldata version of {verify}
*
* _Available since v4.7._
*/
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.
*
* _Available since v4.4._
*/
function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
bytes32 computedHash = leaf;
for (uint256 i = 0; i < proof.length; i++) {
computedHash = _hashPair(computedHash, proof[i]);
}
return computedHash;
}
/**
* @dev Calldata version of {processProof}
*
* _Available since v4.7._
*/
function processProofCalldata(bytes32[] calldata proof, bytes32 leaf) internal pure returns (bytes32) {
bytes32 computedHash = leaf;
for (uint256 i = 0; i < proof.length; i++) {
computedHash = _hashPair(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}.
*
* CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.
*
* _Available since v4.7._
*/
function multiProofVerify(
bytes32[] memory proof,
bool[] memory proofFlags,
bytes32 root,
bytes32[] memory leaves
) internal pure returns (bool) {
return processMultiProof(proof, proofFlags, leaves) == root;
}
/**
* @dev Calldata version of {multiProofVerify}
*
* CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.
*
* _Available since v4.7._
*/
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.
*
* 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).
*
* _Available since v4.7._
*/
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 proofLen = proof.length;
uint256 totalHashes = proofFlags.length;
// Check proof validity.
require(leavesLen + proofLen - 1 == totalHashes, "MerkleProof: invalid multiproof");
// 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[](totalHashes);
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 < totalHashes; i++) {
bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
bytes32 b = proofFlags[i]
? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
: proof[proofPos++];
hashes[i] = _hashPair(a, b);
}
if (totalHashes > 0) {
require(proofPos == proofLen, "MerkleProof: invalid multiproof");
unchecked {
return hashes[totalHashes - 1];
}
} else if (leavesLen > 0) {
return leaves[0];
} else {
return proof[0];
}
}
/**
* @dev Calldata version of {processMultiProof}.
*
* CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.
*
* _Available since v4.7._
*/
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 proofLen = proof.length;
uint256 totalHashes = proofFlags.length;
// Check proof validity.
require(leavesLen + proofLen - 1 == totalHashes, "MerkleProof: invalid multiproof");
// 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[](totalHashes);
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 < totalHashes; i++) {
bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
bytes32 b = proofFlags[i]
? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
: proof[proofPos++];
hashes[i] = _hashPair(a, b);
}
if (totalHashes > 0) {
require(proofPos == proofLen, "MerkleProof: invalid multiproof");
unchecked {
return hashes[totalHashes - 1];
}
} else if (leavesLen > 0) {
return leaves[0];
} else {
return proof[0];
}
}
function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) {
return a < b ? _efficientHash(a, b) : _efficientHash(b, a);
}
function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
/// @solidity memory-safe-assembly
assembly {
mstore(0x00, a)
mstore(0x20, b)
value := keccak256(0x00, 0x40)
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)
pragma solidity ^0.8.0;
import "./IERC165.sol";
/**
* @dev Implementation of the {IERC165} interface.
*
* Contracts that want to implement ERC165 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);
* }
* ```
*
* Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
*/
abstract contract ERC165 is IERC165 {
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)
pragma solidity ^0.8.0;
/**
* @dev Interface of the ERC165 standard, as defined in the
* https://eips.ethereum.org/EIPS/eip-165[EIP].
*
* 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[EIP 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);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/math/Math.sol)
pragma solidity ^0.8.0;
/**
* @dev Standard math utilities missing in the Solidity language.
*/
library Math {
enum Rounding {
Down, // Toward negative infinity
Up, // Toward infinity
Zero // Toward zero
}
/**
* @dev Returns the largest of two numbers.
*/
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a > b ? a : b;
}
/**
* @dev Returns the smallest of two numbers.
*/
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return 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 up instead
* of rounding down.
*/
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b - 1) / b can overflow on addition, so we distribute.
return a == 0 ? 0 : (a - 1) / b + 1;
}
/**
* @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
* @dev 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^256 and mod 2^256 - 1, then use
// use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
// variables such that product = prod1 * 2^256 + prod0.
uint256 prod0; // Least significant 256 bits of the product
uint256 prod1; // Most significant 256 bits of the product
assembly {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
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^256. Also prevents denominator == 0.
require(denominator > prod1, "Math: mulDiv 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.
// Does not overflow because the denominator cannot be zero at this stage in the function.
uint256 twos = denominator & (~denominator + 1);
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^256 / 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^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
// that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
// four bits. That is, denominator * inv = 1 mod 2^4.
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^8
inverse *= 2 - denominator * inverse; // inverse mod 2^16
inverse *= 2 - denominator * inverse; // inverse mod 2^32
inverse *= 2 - denominator * inverse; // inverse mod 2^64
inverse *= 2 - denominator * inverse; // inverse mod 2^128
inverse *= 2 - denominator * inverse; // inverse mod 2^256
// 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^256. Since the preconditions guarantee that the outcome is
// less than 2^256, 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;
}
}
/**
* @notice 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) {
uint256 result = mulDiv(x, y, denominator);
if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
result += 1;
}
return result;
}
/**
* @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
*
* Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
*/
function sqrt(uint256 a) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
// For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
//
// We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
// `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
//
// This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
// → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
// → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
//
// Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
uint256 result = 1 << (log2(a) >> 1);
// At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
// since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
// every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
// into the expected uint128 result.
unchecked {
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
return min(result, a / result);
}
}
/**
* @notice 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 + (rounding == Rounding.Up && result * result < a ? 1 : 0);
}
}
/**
* @dev Return the log in base 2, rounded down, of a positive value.
* Returns 0 if given 0.
*/
function log2(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 128;
}
if (value >> 64 > 0) {
value >>= 64;
result += 64;
}
if (value >> 32 > 0) {
value >>= 32;
result += 32;
}
if (value >> 16 > 0) {
value >>= 16;
result += 16;
}
if (value >> 8 > 0) {
value >>= 8;
result += 8;
}
if (value >> 4 > 0) {
value >>= 4;
result += 4;
}
if (value >> 2 > 0) {
value >>= 2;
result += 2;
}
if (value >> 1 > 0) {
result += 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 + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
}
}
/**
* @dev Return the log in base 10, rounded down, of a positive value.
* 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 + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);
}
}
/**
* @dev Return the log in base 256, rounded down, of a positive value.
* 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;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 16;
}
if (value >> 64 > 0) {
value >>= 64;
result += 8;
}
if (value >> 32 > 0) {
value >>= 32;
result += 4;
}
if (value >> 16 > 0) {
value >>= 16;
result += 2;
}
if (value >> 8 > 0) {
result += 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 + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/math/SafeMath.sol)
pragma solidity ^0.8.0;
// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.
/**
* @dev Wrappers over Solidity's arithmetic operations.
*
* NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
* now has built in overflow checking.
*/
library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
/**
* @dev Returns the subtraction of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
/**
* @dev Returns the multiplication of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
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 division by zero flag.
*
* _Available since v3.4._
*/
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
/**
* @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
*
* _Available since v3.4._
*/
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
/**
* @dev Returns the integer division of two unsigned integers, reverting on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator.
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* reverting when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* CAUTION: This function is deprecated because it requires allocating memory for the error
* message unnecessarily. For custom revert reasons use {trySub}.
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
/**
* @dev Returns the integer division of two unsigned integers, reverting with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* reverting with custom message when dividing by zero.
*
* CAUTION: This function is deprecated because it requires allocating memory for the error
* message unnecessarily. For custom revert reasons use {tryMod}.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SignedMath.sol)
pragma solidity ^0.8.0;
/**
* @dev Standard signed math utilities missing in the Solidity language.
*/
library SignedMath {
/**
* @dev Returns the largest of two signed numbers.
*/
function max(int256 a, int256 b) internal pure returns (int256) {
return a > b ? a : b;
}
/**
* @dev Returns the smallest of two signed numbers.
*/
function min(int256 a, int256 b) internal pure returns (int256) {
return a < b ? a : b;
}
/**
* @dev Returns the average of two signed numbers without overflow.
* The result is rounded towards zero.
*/
function average(int256 a, int256 b) internal pure returns (int256) {
// Formula from the book "Hacker's Delight"
int256 x = (a & b) + ((a ^ b) >> 1);
return x + (int256(uint256(x) >> 255) & (a ^ b));
}
/**
* @dev Returns the absolute unsigned value of a signed value.
*/
function abs(int256 n) internal pure returns (uint256) {
unchecked {
// must be unchecked in order to support `n = type(int256).min`
return uint256(n >= 0 ? n : -n);
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/Strings.sol)
pragma solidity ^0.8.0;
import "./math/Math.sol";
import "./math/SignedMath.sol";
/**
* @dev String operations.
*/
library Strings {
bytes16 private constant _SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
/**
* @dev Converts a `uint256` to its ASCII `string` decimal representation.
*/
function toString(uint256 value) internal pure returns (string memory) {
unchecked {
uint256 length = Math.log10(value) + 1;
string memory buffer = new string(length);
uint256 ptr;
/// @solidity memory-safe-assembly
assembly {
ptr := add(buffer, add(32, length))
}
while (true) {
ptr--;
/// @solidity memory-safe-assembly
assembly {
mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
}
value /= 10;
if (value == 0) break;
}
return buffer;
}
}
/**
* @dev Converts a `int256` to its ASCII `string` decimal representation.
*/
function toString(int256 value) internal pure returns (string memory) {
return string(abi.encodePacked(value < 0 ? "-" : "", toString(SignedMath.abs(value))));
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
*/
function toHexString(uint256 value) internal pure returns (string memory) {
unchecked {
return toHexString(value, Math.log256(value) + 1);
}
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
*/
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
/**
* @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
*/
function toHexString(address addr) internal pure returns (string memory) {
return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
}
/**
* @dev Returns true if the two strings are equal.
*/
function equal(string memory a, string memory b) internal pure returns (bool) {
return keccak256(bytes(a)) == keccak256(bytes(b));
}
}pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "./helpers/TransferHelper.sol";
import "./Taxable.sol";
abstract contract Fundable is Ownable, AccessControl, Taxable, ReentrancyGuard {
using SafeERC20 for ERC20;
uint64 constant SALE_PRICE_DECIMALS = 10 ** 18;
uint64 private constant ONE_HOUR = 3600;
uint64 private constant ONE_YEAR = 31556926;
uint64 private constant FIVE_YEARS = 157784630;
uint64 private constant TEN_YEARS = 315360000;
bytes32 public FUNDER_ROLE = keccak256(abi.encodePacked("FUNDER_ROLE"));
bytes32 public CASHER_ROLE = keccak256(abi.encodePacked("CASHER_ROLE"));
uint256 public startTime;
uint256 public endTime;
ERC20 private immutable paymentToken;
ERC20 private immutable saleToken;
mapping(address => bool) public hasWithdrawn;
uint256 public saleAmount;
bool public hasCashed;
uint256 public totalPaymentReceived;
uint32 public withdrawerCount;
uint256 withdrawDelay;
constructor(
ERC20 _paymentToken,
ERC20 _saleToken,
uint256 _startTime,
uint256 _endTime,
address _funder,
address _taxCollector,
address _taxSetter,
uint256 _withdrawDelay
) Taxable(_taxCollector, _taxSetter) {
require(_saleToken != _paymentToken, "saleToken = paymentToken");
require(address(_saleToken) != address(0), "0x0 saleToken");
require(block.timestamp < _startTime, "start timestamp too early");
require(_startTime - ONE_YEAR < block.timestamp, "start time has to be within 1 year");
require(_startTime < _endTime - ONE_HOUR, "end timestamp before start should be least 1 hour");
require(_endTime - TEN_YEARS < _startTime, "end time has to be within 10 years");
require(_funder != address(0), "0x0 funder");
_grantRole(FUNDER_ROLE, _funder);
paymentToken = _paymentToken; // can be 0 (for giveaway)
saleToken = _saleToken;
startTime = _startTime;
endTime = _endTime;
withdrawDelay = _withdrawDelay;
}
modifier onlyFunder() {
require(hasRole(FUNDER_ROLE, _msgSender()), "caller not funder");
_;
}
modifier onlyCasherOrOwner() {
require(hasRole(CASHER_ROLE, _msgSender()) || _msgSender() == owner(), "caller not casher or owner");
_;
}
modifier onlyBeforeSale() {
require(block.timestamp < startTime, "sale already started");
_;
}
modifier onlyAfterSale() {
require(block.timestamp > endTime + withdrawDelay, "can't withdraw before claim is started");
_;
}
modifier onlyDuringSale() {
require(startTime <= block.timestamp, "sale has not begun");
require(block.timestamp < endTime, "sale over");
_;
}
event SetCasher(address indexed casher);
event RemoveCasher(address indexed casher);
event Fund(address indexed sender, uint256 amount);
event SetWithdrawDelay(uint24 indexed withdrawDelay);
event Cash(address indexed sender, uint256 paymentTokenBalance, uint256 saleTokenBalance);
event EmergencyTokenRetrieve(address indexed sender, uint256 amount);
event Withdraw(address indexed sender, uint256 amount);
event UpdateStartTime(uint256 startTime);
event UpdateEndTime(uint256 endTime);
function setCasher(address _casher) public onlyOwner {
require(!hasRole(CASHER_ROLE, _casher), "already casher");
_grantRole(CASHER_ROLE, _casher);
emit SetCasher(_casher);
}
function removeCasher(address _casher) public onlyOwner {
require(hasRole(CASHER_ROLE, _casher), "not casher");
_revokeRole(CASHER_ROLE, _casher);
emit RemoveCasher(_casher);
}
function setWithdrawDelay(uint24 _withdrawDelay) public virtual onlyOwner onlyBeforeSale {
require(_withdrawDelay < FIVE_YEARS, "withdrawDelay has to be within 5 years");
withdrawDelay = _withdrawDelay;
emit SetWithdrawDelay(_withdrawDelay);
}
function getSaleTokensSold() internal virtual returns (uint256 amount);
function fund(uint256 amount) public onlyFunder onlyBeforeSale {
TransferHelpers.safeTransferFromERC20(address(saleToken), _msgSender(), address(this), amount);
saleAmount += amount;
emit Fund(_msgSender(), amount);
}
function cash() external onlyCasherOrOwner {
require(endTime + withdrawDelay < block.timestamp, "cannot withdraw yet");
require(!hasCashed, "already cashed");
hasCashed = true;
uint256 paymentTokenBal = paymentToken.balanceOf(address(this));
uint256 collectorsDue = (taxPercentage * paymentTokenBal) / 100;
TransferHelpers.safeTransferERC20(address(paymentToken), _msgSender(), paymentTokenBal - collectorsDue);
if (collectorsDue > 0) TransferHelpers.safeTransferERC20(address(paymentToken), taxCollector, collectorsDue);
uint256 saleTokenBal = saleToken.balanceOf(address(this));
uint256 totalTokensSold = getSaleTokensSold();
uint256 principal = saleAmount < saleTokenBal ? saleTokenBal : saleAmount;
uint256 amountUnsold = principal - totalTokensSold;
TransferHelpers.safeTransferERC20(address(saleToken), _msgSender(), amountUnsold);
emit Cash(_msgSender(), paymentTokenBal, amountUnsold);
}
function emergencyTokenRetrieve(address token) public onlyOwner onlyAfterSale {
require(token != address(saleToken));
uint256 tokenBalance = ERC20(token).balanceOf(address(this));
TransferHelpers.safeTransferERC20(token, _msgSender(), tokenBalance);
emit EmergencyTokenRetrieve(_msgSender(), tokenBalance);
}
function withdraw() public virtual nonReentrant {}
function _withdraw(uint256 saleTokenOwed) internal virtual {
require(saleTokenOwed > 0, "no token to be withdrawn");
if (!hasWithdrawn[_msgSender()]) {
withdrawerCount += 1;
hasWithdrawn[_msgSender()] = true;
}
TransferHelpers.safeTransferERC20(address(saleToken), _msgSender(), saleTokenOwed);
emit Withdraw(_msgSender(), saleTokenOwed);
}
function setStartTime(uint256 _startTime) public onlyOwner {
startTime = _startTime;
emit UpdateStartTime(_startTime);
}
function setEndTime(uint256 _endTime) public onlyOwner {
require(_endTime > endTime, "can only extend presale");
endTime = _endTime;
emit UpdateEndTime(_endTime);
}
}pragma solidity ^0.8.0;
import "@openzeppelin/contracts/utils/Address.sol";
library TransferHelpers {
using Address for address;
function safeTransferERC20(address token, address to, uint256 amount) internal {
bytes4 encodedFunc = bytes4(keccak256(bytes("transfer(address,uint256)")));
token.functionCall(abi.encodeWithSelector(encodedFunc, to, amount));
}
function safeTransferFromERC20(address token, address from, address to, uint256 amount) internal {
bytes4 encodedFunc = bytes4(keccak256(bytes("transferFrom(address,address,uint256)")));
token.functionCall(abi.encodeWithSelector(encodedFunc, from, to, amount));
}
function safeTransferEther(address to, uint256 amount) internal returns (bool success) {
(success, ) = to.call{value: amount}(new bytes(0));
}
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface IPresale {
error AlreadyInitialized();
event PresaleCreated(
address indexed presaleId,
string metadataURI,
address funder,
uint256 salePrice,
address indexed paymentToken,
address indexed saleToken,
uint256 softCap,
uint256 hardCap,
uint256 startTime,
uint256 endTime,
uint256 minTotalPayment,
uint256 maxTotalPayment
);
}pragma solidity ^0.8.0;
interface IStakingPool {
event Stake(address indexed account, uint256 amount, uint256 timestamp);
event Unstake(address indexed account, uint256 amount);
event Withdrawal(address indexed account, uint amount0, uint256 amount1);
event StakeFeePercentageChange(uint16 stakeFeePercentageChange);
event WithdrawalFeePercentageChange(uint16 withdrawalFeePercentageChange);
event APYRateChange(uint24 apyRate);
error ZeroAddressForFeesSet();
error Blocked();
error OnlyModeratorOrOwner();
error RewardIsZero();
error NoStake();
error AlreadyModerator();
error NotModerator();
error AlreadyInitialized();
event RewardsAdded(uint256 reward);
event RewardDrained(uint256 amount);
function blockedAddresses(address) external view returns (bool);
function stakeFeePercentage() external view returns (uint16);
function token0() external view returns (address);
function token1() external view returns (address);
function apyRate() external view returns (uint24);
function withdrawalIntervals() external view returns (uint256);
function feeReceiver() external view returns (address);
function amountStaked(address) external view returns (uint256);
function lastStakeTime(address) external view returns (uint256);
function nextWithdrawalTime(address) external view returns (uint256);
function blocked(address _account) external view returns (bool);
event Initialized(
address newOwner,
address token0,
address token1,
uint24 apyRate,
uint16 stakeFeePercentage,
uint16 withdrawalFeePercentage,
address feeReceiver,
uint256 intervals
);
function initialize(
address _newOwner,
address _token0,
address _token1,
uint24 _apyRate,
uint16 _stakeFeePercentage,
uint16 _withdrawalFeePercentage,
address _feeReceiver,
uint256 _intervals
) external;
}pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "./helpers/TransferHelper.sol";
abstract contract Purchasable is Ownable, ReentrancyGuard {
using Address for address;
using SafeERC20 for ERC20;
enum StakingTiers {
NONE,
RANK1,
RANK2,
RANK3,
RANK4,
RANK5
}
// payment token
ERC20 public immutable paymentToken;
// price of the sale token
uint256 public salePrice;
// max for payment token amount
uint256 public maxTotalPayment;
// optional min for payment token amount
uint256 public minTotalPayment;
// Soft Cap
uint256 public softCap;
// Hard Cap
uint256 public hardCap;
mapping(address => uint256) public paymentReceived;
uint32 public purchaserCount;
event Purchase(address indexed sender, uint256 paymentAmount);
event SetMinTotalPayment(uint256 indexed minTotalPayment);
event SetMaxTotalPayment(uint256 indexed maxTotalPayment);
event SetSalePrice(uint256 indexed salePrice);
event SetSoftCap(uint256 indexed softCap);
event SetHardCap(uint256 indexed hardCap);
event SetRefundPeriod(uint256 indexed refundPeriod);
constructor(ERC20 _paymentToken, uint256 _salePrice, uint256 _softCap, uint256 _hardCap, uint256 _minTotalPayment, uint256 _maxTotalPayment) {
require(
_salePrice == 0 || (_salePrice != 0 && address(_paymentToken).isContract()),
"Invalid payment token for non-zero sale price"
);
require(_minTotalPayment <= _maxTotalPayment, "minTotalPayment must be <= maxTotalPayment");
require(_softCap <= _hardCap, "softCap must be <= hardCap");
require(_maxTotalPayment > 0, "maxTotalPayment must be positive");
salePrice = _salePrice;
paymentToken = _paymentToken;
minTotalPayment = _minTotalPayment;
maxTotalPayment = _maxTotalPayment;
softCap = _softCap;
hardCap = _hardCap;
}
function setMinTotalPayment(uint256 _minTotalPayment) public onlyOwner {
minTotalPayment = _minTotalPayment;
emit SetMinTotalPayment(_minTotalPayment);
}
function setMaxTotalPayment(uint256 _maxTotalPayment) public onlyOwner {
maxTotalPayment = _maxTotalPayment;
emit SetMaxTotalPayment(_maxTotalPayment);
}
function setSalePrice(uint256 _salePrice) public onlyOwner {
require(_salePrice > 0, "Price must be positive");
salePrice = _salePrice;
emit SetSalePrice(_salePrice);
}
function setSoftCap(uint256 _softCap) public onlyOwner {
softCap = _softCap;
emit SetSoftCap(_softCap);
}
function setHardCap(uint256 _hardCap) public onlyOwner {
hardCap = _hardCap;
emit SetHardCap(_hardCap);
}
function purchase(uint256 paymentAmount) public virtual nonReentrant {}
function _purchase(uint256 paymentAmount, uint256 remaining) internal virtual {
require(paymentAmount >= minTotalPayment, "amount below min");
require(paymentAmount <= remaining, "exceeds max payment");
TransferHelpers.safeTransferFromERC20(address(paymentToken), _msgSender(), address(this), paymentAmount);
if (paymentReceived[_msgSender()] == 0) purchaserCount += 1;
paymentReceived[_msgSender()] += paymentAmount;
emit Purchase(_msgSender(), paymentAmount);
}
}pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/utils/Context.sol";
abstract contract Taxable is Context, AccessControl {
address public taxCollector;
uint16 public taxPercentage = 1000; // Default : 10% (Basis Points)
bytes32 public taxSetterRole = keccak256(abi.encodePacked("TAX_SETTER_ROLE"));
constructor(
address _taxCollector,
address _taxSetter
) {
taxCollector = _taxCollector;
_grantRole(taxSetterRole, _taxSetter);
}
modifier onlyTaxSetter() {
require(hasRole(taxSetterRole, _msgSender()), "must be tax setter");
_;
}
function setTaxPercentage(uint8 _taxPercentage) external onlyTaxSetter {
taxPercentage = _taxPercentage;
}
function setTaxCollector(address _taxCollector) external onlyTaxSetter {
taxCollector = _taxCollector;
}
}pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./helpers/TransferHelper.sol";
// Inspiration: https://github.com/ImpossibleFinance/launchpad-contracts/blob/main/contracts/IFVestable.sol
abstract contract Vestable is Ownable {
uint256 public withdrawTime;
mapping(address => uint256) public latestClaimTime;
using SafeMath for uint256;
// for linear vesting
uint256 public linearVestingEndTime;
event SetLinearVestingEndTime(uint256 indexed linearVestingEndTime);
// for cliff vesting
struct CliffVesting {
uint256 claimTime;
uint8 percentage;
}
CliffVesting[] public cliffPeriod;
event SetCliffVestingPeriod(CliffVesting[] indexed cliffPeriod);
constructor(uint256 _withdrawTime) {
withdrawTime = _withdrawTime;
}
function setWithdrawTime(uint256 _withdrawTime) internal {
withdrawTime = _withdrawTime;
}
function getCliffPeriod() external view returns (CliffVesting[] memory) {
return cliffPeriod;
}
function setLinearVestingEndTime(uint256 _linearVestingEndTime) public virtual onlyOwner {
require(_linearVestingEndTime > withdrawTime, "vesting end time has to be after withdrawal start time");
linearVestingEndTime = _linearVestingEndTime;
delete cliffPeriod;
emit SetLinearVestingEndTime(_linearVestingEndTime);
}
function setCliffPeriod(uint256[] calldata claimTimes, uint8[] calldata pct) public virtual onlyOwner {
require(claimTimes.length == pct.length, "dates and pct doesn't match");
require(claimTimes.length > 0, "input is empty");
require(claimTimes.length <= 100, "input length cannot exceed 100");
delete cliffPeriod;
uint256 maxDate;
uint8 totalPct;
require(claimTimes[0] > withdrawTime, "first claim time is before end time + withdraw delay");
for (uint256 i = 0; i < claimTimes.length; i++) {
require(maxDate < claimTimes[i], "dates not in ascending order");
maxDate = claimTimes[i];
totalPct += pct[i];
cliffPeriod.push(CliffVesting(claimTimes[i], pct[i]));
}
require(totalPct == 100, "total input percentage doesn't equal to 100");
linearVestingEndTime = 0;
emit SetCliffVestingPeriod(cliffPeriod);
}
function getUnlockedToken(
uint256 totalPurchased,
uint256 claimable,
address user
) public view virtual returns (uint256) {
// linear vesting
if (linearVestingEndTime > block.timestamp) {
// current claimable = total purchased * (now - last claimed time) / (total vesting time)
return (totalPurchased * (block.timestamp - Math.max(latestClaimTime[user], withdrawTime))) / (linearVestingEndTime - withdrawTime);
}
// cliff vesting
uint256 cliffPeriodLength = cliffPeriod.length;
if (cliffPeriodLength != 0 && cliffPeriod[cliffPeriodLength - 1].claimTime > block.timestamp) {
uint8 claimablePct;
for (uint8 i; i < cliffPeriodLength; i++) {
// if the cliff timestamp has been passed, add the claimable percentage
if (cliffPeriod[i].claimTime > block.timestamp) {
break;
}
if (latestClaimTime[user] < cliffPeriod[i].claimTime) {
claimablePct += cliffPeriod[i].percentage;
}
}
if (claimablePct == 0) {
return 0;
}
return (totalPurchased * claimablePct) / 100;
}
return claimable;
}
}pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
abstract contract Whitelistable is Ownable, AccessControl, ReentrancyGuard {
bytes32 public whitelistRootHash;
bytes32 public WHITELIST_SETTER_ROLE = keccak256(abi.encodePacked("WHITELIST_SETTER_ROLE"));
event SetWhitelistSetter(address indexed whitelistSetter);
event RemoveWhitelistSetter(address indexed whitelistSetter);
event SetWhitelist(bytes32 indexed whitelistRootHash);
modifier onlyWhitelistSetterOrOwner() {
require(hasRole(WHITELIST_SETTER_ROLE, _msgSender()) || _msgSender() == owner(), "caller not whitelist setter or owner");
_;
}
function setWhitelistSetter(address _whitelistSetter) public onlyOwner {
require(!hasRole(WHITELIST_SETTER_ROLE, _whitelistSetter), "already whitelist setter");
_grantRole(WHITELIST_SETTER_ROLE, _whitelistSetter);
emit SetWhitelistSetter(_whitelistSetter);
}
function removeWhitelistSetter(address _whitelistSetter) public onlyOwner {
require(hasRole(WHITELIST_SETTER_ROLE, _whitelistSetter), "not whitelist setter");
_revokeRole(WHITELIST_SETTER_ROLE, _whitelistSetter);
emit RemoveWhitelistSetter(_whitelistSetter);
}
function setWhitelist(bytes32 _whitelistRootHash) public onlyWhitelistSetterOrOwner {
whitelistRootHash = _whitelistRootHash;
emit SetWhitelist(_whitelistRootHash);
}
function whitelistedPurchase(uint256 paymentAmount, bytes32[] calldata merkleProof) public virtual {}
function withdrawGiveaway(bytes32[] calldata merkleProof) public virtual nonReentrant {}
}{
"viaIR": true,
"optimizer": {
"enabled": true,
"runs": 200
},
"outputSelection": {
"*": {
"*": [
"evm.bytecode",
"evm.deployedBytecode",
"devdoc",
"userdoc",
"metadata",
"abi"
]
}
},
"libraries": {}
}Contract ABI
API[{"inputs":[{"internalType":"string","name":"_metadataURI","type":"string"},{"internalType":"address","name":"_funder","type":"address"},{"internalType":"uint256","name":"_salePrice","type":"uint256"},{"internalType":"contract ERC20","name":"_paymentToken","type":"address"},{"internalType":"contract ERC20","name":"_saleToken","type":"address"},{"internalType":"uint256","name":"_softCap","type":"uint256"},{"internalType":"uint256","name":"_hardCap","type":"uint256"},{"internalType":"uint256","name":"_startTime","type":"uint256"},{"internalType":"uint256","name":"_endTime","type":"uint256"},{"internalType":"uint256","name":"_minTotalPayment","type":"uint256"},{"internalType":"uint256","name":"_maxTotalPayment","type":"uint256"},{"internalType":"uint256","name":"_withdrawDelay","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AlreadyInitialized","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"uint256","name":"paymentTokenBalance","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"saleTokenBalance","type":"uint256"}],"name":"Cash","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"EmergencyTokenRetrieve","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"}],"name":"EmergencyWithdrawal","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Fund","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"metadataURI","type":"string"}],"name":"MetadataURIChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"presaleId","type":"address"},{"indexed":false,"internalType":"string","name":"metadataURI","type":"string"},{"indexed":false,"internalType":"address","name":"funder","type":"address"},{"indexed":false,"internalType":"uint256","name":"salePrice","type":"uint256"},{"indexed":true,"internalType":"address","name":"paymentToken","type":"address"},{"indexed":true,"internalType":"address","name":"saleToken","type":"address"},{"indexed":false,"internalType":"uint256","name":"softCap","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"hardCap","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"startTime","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"endTime","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"minTotalPayment","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"maxTotalPayment","type":"uint256"}],"name":"PresaleCreated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"uint256","name":"paymentAmount","type":"uint256"}],"name":"Purchase","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Refund","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"casher","type":"address"}],"name":"RemoveCasher","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"whitelistSetter","type":"address"}],"name":"RemoveWhitelistSetter","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":true,"internalType":"address","name":"casher","type":"address"}],"name":"SetCasher","type":"event"},{"anonymous":false,"inputs":[{"components":[{"internalType":"uint256","name":"claimTime","type":"uint256"},{"internalType":"uint8","name":"percentage","type":"uint8"}],"indexed":true,"internalType":"struct Vestable.CliffVesting[]","name":"cliffPeriod","type":"tuple[]"}],"name":"SetCliffVestingPeriod","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"hardCap","type":"uint256"}],"name":"SetHardCap","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"linearVestingEndTime","type":"uint256"}],"name":"SetLinearVestingEndTime","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"maxTotalPayment","type":"uint256"}],"name":"SetMaxTotalPayment","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"minTotalPayment","type":"uint256"}],"name":"SetMinTotalPayment","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"refundPeriod","type":"uint256"}],"name":"SetRefundPeriod","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"salePrice","type":"uint256"}],"name":"SetSalePrice","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"softCap","type":"uint256"}],"name":"SetSoftCap","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"whitelistRootHash","type":"bytes32"}],"name":"SetWhitelist","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"whitelistSetter","type":"address"}],"name":"SetWhitelistSetter","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint24","name":"withdrawDelay","type":"uint24"}],"name":"SetWithdrawDelay","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"endTime","type":"uint256"}],"name":"UpdateEndTime","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"startTime","type":"uint256"}],"name":"UpdateStartTime","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[],"name":"CASHER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"FUNDER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"WHITELIST_SETTER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"cash","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"bytes32[]","name":"merkleProof","type":"bytes32[]"}],"name":"checkWhitelist","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"claimable","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"cliffPeriod","outputs":[{"internalType":"uint256","name":"claimTime","type":"uint256"},{"internalType":"uint8","name":"percentage","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"emergencyTokenRetrieve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"emergencyWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"endTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"fund","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getCliffPeriod","outputs":[{"components":[{"internalType":"uint256","name":"claimTime","type":"uint256"},{"internalType":"uint8","name":"percentage","type":"uint8"}],"internalType":"struct Vestable.CliffVesting[]","name":"","type":"tuple[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"getCurrentClaimableToken","outputs":[{"internalType":"uint256","name":"","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":"uint256","name":"totalPurchased","type":"uint256"},{"internalType":"uint256","name":"claimable","type":"uint256"},{"internalType":"address","name":"user","type":"address"}],"name":"getUnlockedToken","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":[],"name":"hardCap","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"hasCashed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","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":[{"internalType":"address","name":"","type":"address"}],"name":"hasWithdrawn","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isSoftCapReached","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"latestClaimTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"linearVestingEndTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxTotalPayment","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"metadataURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"minTotalPayment","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"paymentReceived","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"paymentToken","outputs":[{"internalType":"contract ERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"paymentAmount","type":"uint256"}],"name":"purchase","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"purchaserCount","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"refundIfSoftCapNotReached","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_casher","type":"address"}],"name":"removeCasher","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_whitelistSetter","type":"address"}],"name":"removeWhitelistSetter","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"renounceRole","outputs":[],"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":[],"name":"saleAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"salePrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_casher","type":"address"}],"name":"setCasher","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"claimTimes","type":"uint256[]"},{"internalType":"uint8[]","name":"pct","type":"uint8[]"}],"name":"setCliffPeriod","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_endTime","type":"uint256"}],"name":"setEndTime","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_hardCap","type":"uint256"}],"name":"setHardCap","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_vestingEndTime","type":"uint256"}],"name":"setLinearVestingEndTime","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_maxTotalPayment","type":"uint256"}],"name":"setMaxTotalPayment","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_metadataURI","type":"string"}],"name":"setMetadataURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_minTotalPayment","type":"uint256"}],"name":"setMinTotalPayment","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_salePrice","type":"uint256"}],"name":"setSalePrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_softCap","type":"uint256"}],"name":"setSoftCap","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IStakingPool","name":"_stakingPool","type":"address"}],"name":"setStakingPool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_startTime","type":"uint256"}],"name":"setStartTime","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_taxCollector","type":"address"}],"name":"setTaxCollector","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint8","name":"_taxPercentage","type":"uint8"}],"name":"setTaxPercentage","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_whitelistRootHash","type":"bytes32"}],"name":"setWhitelist","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_whitelistSetter","type":"address"}],"name":"setWhitelistSetter","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint24","name":"_withdrawDelay","type":"uint24"}],"name":"setWithdrawDelay","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"softCap","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"stakingPool","outputs":[{"internalType":"contract IStakingPool","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"startTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"taxCollector","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"taxPercentage","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"taxSetterRole","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalPaymentReceived","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"totalPurchased","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"whitelistRootHash","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"paymentAmount","type":"uint256"},{"internalType":"bytes32[]","name":"merkleProof","type":"bytes32[]"}],"name":"whitelistedPurchase","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32[]","name":"merkleProof","type":"bytes32[]"}],"name":"withdrawGiveaway","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdrawerCount","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]Contract Creation Code
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
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
0000000000000000000000000000000000000000000000000000000000000180000000000000000000000000426dcf053185c099cbe05dcb23775544bbee16d6000000000000000000000000000000000000000000000000000000000000012c000000000000000000000000af93888cbd250300470a1618206e036e11470149000000000000000000000000deb561f9216576b41d6e67414c81ff0fdbba5b4600000000000000000000000000000000000000000000152d02c7e14af68000000000000000000000000000000000000000000000000054b40b1f852bda0000000000000000000000000000000000000000000000000000000000000067cca8790000000000000000000000000000000000000000000000000000000067d5e2f900000000000000000000000000000000000000000000003635c9adc5dea0000000000000000000000000000000000000000000000000010f0cf064dd592000000000000000000000000000000000000000000000000000000000000000015180000000000000000000000000000000000000000000000000000000000000001468747470733a2f2f73756e616d692e7472616465000000000000000000000000
-----Decoded View---------------
Arg [0] : _metadataURI (string): https://sunami.trade
Arg [1] : _funder (address): 0x426DcF053185c099cbE05dcb23775544bbEe16d6
Arg [2] : _salePrice (uint256): 300
Arg [3] : _paymentToken (address): 0xAF93888cbD250300470A1618206e036E11470149
Arg [4] : _saleToken (address): 0xdEB561F9216576B41D6E67414c81Ff0fdbba5b46
Arg [5] : _softCap (uint256): 100000000000000000000000
Arg [6] : _hardCap (uint256): 400000000000000000000000
Arg [7] : _startTime (uint256): 1741465721
Arg [8] : _endTime (uint256): 1742070521
Arg [9] : _minTotalPayment (uint256): 1000000000000000000000
Arg [10] : _maxTotalPayment (uint256): 5000000000000000000000
Arg [11] : _withdrawDelay (uint256): 86400
-----Encoded View---------------
14 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000180
Arg [1] : 000000000000000000000000426dcf053185c099cbe05dcb23775544bbee16d6
Arg [2] : 000000000000000000000000000000000000000000000000000000000000012c
Arg [3] : 000000000000000000000000af93888cbd250300470a1618206e036e11470149
Arg [4] : 000000000000000000000000deb561f9216576b41d6e67414c81ff0fdbba5b46
Arg [5] : 00000000000000000000000000000000000000000000152d02c7e14af6800000
Arg [6] : 0000000000000000000000000000000000000000000054b40b1f852bda000000
Arg [7] : 0000000000000000000000000000000000000000000000000000000067cca879
Arg [8] : 0000000000000000000000000000000000000000000000000000000067d5e2f9
Arg [9] : 00000000000000000000000000000000000000000000003635c9adc5dea00000
Arg [10] : 00000000000000000000000000000000000000000000010f0cf064dd59200000
Arg [11] : 0000000000000000000000000000000000000000000000000000000000015180
Arg [12] : 0000000000000000000000000000000000000000000000000000000000000014
Arg [13] : 68747470733a2f2f73756e616d692e7472616465000000000000000000000000
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 35 Chains
| Chain | Token | Portfolio % | Price | Amount | Value |
|---|
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.