Overview
S Balance
0 SS Value
$0.00More Info
Private Name Tags
ContractCreator
TokenTracker
Latest 6 from a total of 6 transactions
Loading...
Loading
Contract Source Code Verified (Exact Match)
Contract Name:
MPGA
Compiler Version
v0.8.26+commit.8a97fa7a
Contract Source Code (Solidity)
/**
*Submitted for verification at SonicScan.org on 2025-02-04
*/
// File: @openzeppelin/contracts/token/ERC20/IERC20.sol
// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/IERC20.sol)
pragma solidity ^0.8.20;
/**
* @dev Interface of the ERC-20 standard as defined in the ERC.
*/
interface IERC20 {
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
/**
* @dev Returns the value of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the value of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves a `value` amount of tokens from the caller's account to `to`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address to, uint256 value) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets a `value` amount of tokens as the allowance of `spender` over the
* caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 value) external returns (bool);
/**
* @dev Moves a `value` amount of tokens from `from` to `to` using the
* allowance mechanism. `value` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address from, address to, uint256 value) external returns (bool);
}
// File: @openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol
// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/extensions/IERC20Metadata.sol)
pragma solidity ^0.8.20;
/**
* @dev Interface for the optional metadata functions from the ERC-20 standard.
*/
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}
// File: @openzeppelin/contracts/utils/Context.sol
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
pragma solidity ^0.8.0;
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
// File: @openzeppelin/contracts/interfaces/draft-IERC6093.sol
// OpenZeppelin Contracts (last updated v5.1.0) (interfaces/draft-IERC6093.sol)
pragma solidity ^0.8.20;
/**
* @dev Standard ERC-20 Errors
* Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-20 tokens.
*/
interface IERC20Errors {
/**
* @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
* @param sender Address whose tokens are being transferred.
* @param balance Current balance for the interacting account.
* @param needed Minimum amount required to perform a transfer.
*/
error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);
/**
* @dev Indicates a failure with the token `sender`. Used in transfers.
* @param sender Address whose tokens are being transferred.
*/
error ERC20InvalidSender(address sender);
/**
* @dev Indicates a failure with the token `receiver`. Used in transfers.
* @param receiver Address to which tokens are being transferred.
*/
error ERC20InvalidReceiver(address receiver);
/**
* @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.
* @param spender Address that may be allowed to operate on tokens without being their owner.
* @param allowance Amount of tokens a `spender` is allowed to operate with.
* @param needed Minimum amount required to perform a transfer.
*/
error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);
/**
* @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
* @param approver Address initiating an approval operation.
*/
error ERC20InvalidApprover(address approver);
/**
* @dev Indicates a failure with the `spender` to be approved. Used in approvals.
* @param spender Address that may be allowed to operate on tokens without being their owner.
*/
error ERC20InvalidSpender(address spender);
}
/**
* @dev Standard ERC-721 Errors
* Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-721 tokens.
*/
interface IERC721Errors {
/**
* @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in ERC-20.
* Used in balance queries.
* @param owner Address of the current owner of a token.
*/
error ERC721InvalidOwner(address owner);
/**
* @dev Indicates a `tokenId` whose `owner` is the zero address.
* @param tokenId Identifier number of a token.
*/
error ERC721NonexistentToken(uint256 tokenId);
/**
* @dev Indicates an error related to the ownership over a particular token. Used in transfers.
* @param sender Address whose tokens are being transferred.
* @param tokenId Identifier number of a token.
* @param owner Address of the current owner of a token.
*/
error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);
/**
* @dev Indicates a failure with the token `sender`. Used in transfers.
* @param sender Address whose tokens are being transferred.
*/
error ERC721InvalidSender(address sender);
/**
* @dev Indicates a failure with the token `receiver`. Used in transfers.
* @param receiver Address to which tokens are being transferred.
*/
error ERC721InvalidReceiver(address receiver);
/**
* @dev Indicates a failure with the `operator`’s approval. Used in transfers.
* @param operator Address that may be allowed to operate on tokens without being their owner.
* @param tokenId Identifier number of a token.
*/
error ERC721InsufficientApproval(address operator, uint256 tokenId);
/**
* @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
* @param approver Address initiating an approval operation.
*/
error ERC721InvalidApprover(address approver);
/**
* @dev Indicates a failure with the `operator` to be approved. Used in approvals.
* @param operator Address that may be allowed to operate on tokens without being their owner.
*/
error ERC721InvalidOperator(address operator);
}
/**
* @dev Standard ERC-1155 Errors
* Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-1155 tokens.
*/
interface IERC1155Errors {
/**
* @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
* @param sender Address whose tokens are being transferred.
* @param balance Current balance for the interacting account.
* @param needed Minimum amount required to perform a transfer.
* @param tokenId Identifier number of a token.
*/
error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);
/**
* @dev Indicates a failure with the token `sender`. Used in transfers.
* @param sender Address whose tokens are being transferred.
*/
error ERC1155InvalidSender(address sender);
/**
* @dev Indicates a failure with the token `receiver`. Used in transfers.
* @param receiver Address to which tokens are being transferred.
*/
error ERC1155InvalidReceiver(address receiver);
/**
* @dev Indicates a failure with the `operator`’s approval. Used in transfers.
* @param operator Address that may be allowed to operate on tokens without being their owner.
* @param owner Address of the current owner of a token.
*/
error ERC1155MissingApprovalForAll(address operator, address owner);
/**
* @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
* @param approver Address initiating an approval operation.
*/
error ERC1155InvalidApprover(address approver);
/**
* @dev Indicates a failure with the `operator` to be approved. Used in approvals.
* @param operator Address that may be allowed to operate on tokens without being their owner.
*/
error ERC1155InvalidOperator(address operator);
/**
* @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.
* Used in batch transfers.
* @param idsLength Length of the array of token identifiers
* @param valuesLength Length of the array of token amounts
*/
error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);
}
// File: @openzeppelin/contracts/token/ERC20/ERC20.sol
// OpenZeppelin Contracts (last updated v5.2.0) (token/ERC20/ERC20.sol)
pragma solidity ^0.8.20;
/**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
*
* TIP: For a detailed writeup see our guide
* https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
* to implement supply mechanisms].
*
* The default value of {decimals} is 18. To change this, you should override
* this function so it returns a different value.
*
* We have followed general OpenZeppelin Contracts guidelines: functions revert
* instead returning `false` on failure. This behavior is nonetheless
* conventional and does not conflict with the expectations of ERC-20
* applications.
*/
abstract contract ERC20 is Context, IERC20, IERC20Metadata, IERC20Errors {
mapping(address account => uint256) private _balances;
mapping(address account => mapping(address spender => 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 returns (string memory) {
return _name;
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual 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 returns (uint8) {
return 18;
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual returns (uint256) {
return _totalSupply;
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual 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 `value`.
*/
function transfer(address to, uint256 value) public virtual returns (bool) {
address owner = _msgSender();
_transfer(owner, to, value);
return true;
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual returns (uint256) {
return _allowances[owner][spender];
}
/**
* @dev See {IERC20-approve}.
*
* NOTE: If `value` is the maximum `uint256`, the allowance is not updated on
* `transferFrom`. This is semantically equivalent to an infinite approval.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 value) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, value);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Skips emitting an {Approval} event indicating an allowance update. This is not
* required by the ERC. See {xref-ERC20-_approve-address-address-uint256-bool-}[_approve].
*
* NOTE: Does not update the allowance if the current allowance
* is the maximum `uint256`.
*
* Requirements:
*
* - `from` and `to` cannot be the zero address.
* - `from` must have a balance of at least `value`.
* - the caller must have allowance for ``from``'s tokens of at least
* `value`.
*/
function transferFrom(address from, address to, uint256 value) public virtual returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, value);
_transfer(from, to, value);
return true;
}
/**
* @dev Moves a `value` amount of tokens from `from` to `to`.
*
* This internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* NOTE: This function is not virtual, {_update} should be overridden instead.
*/
function _transfer(address from, address to, uint256 value) internal {
if (from == address(0)) {
revert ERC20InvalidSender(address(0));
}
if (to == address(0)) {
revert ERC20InvalidReceiver(address(0));
}
_update(from, to, value);
}
/**
* @dev Transfers a `value` amount of tokens from `from` to `to`, or alternatively mints (or burns) if `from`
* (or `to`) is the zero address. All customizations to transfers, mints, and burns should be done by overriding
* this function.
*
* Emits a {Transfer} event.
*/
function _update(address from, address to, uint256 value) internal virtual {
if (from == address(0)) {
// Overflow check required: The rest of the code assumes that totalSupply never overflows
_totalSupply += value;
} else {
uint256 fromBalance = _balances[from];
if (fromBalance < value) {
revert ERC20InsufficientBalance(from, fromBalance, value);
}
unchecked {
// Overflow not possible: value <= fromBalance <= totalSupply.
_balances[from] = fromBalance - value;
}
}
if (to == address(0)) {
unchecked {
// Overflow not possible: value <= totalSupply or value <= fromBalance <= totalSupply.
_totalSupply -= value;
}
} else {
unchecked {
// Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256.
_balances[to] += value;
}
}
emit Transfer(from, to, value);
}
/**
* @dev Creates a `value` amount of tokens and assigns them to `account`, by transferring it from address(0).
* Relies on the `_update` mechanism
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* NOTE: This function is not virtual, {_update} should be overridden instead.
*/
function _mint(address account, uint256 value) internal {
if (account == address(0)) {
revert ERC20InvalidReceiver(address(0));
}
_update(address(0), account, value);
}
/**
* @dev Destroys a `value` amount of tokens from `account`, lowering the total supply.
* Relies on the `_update` mechanism.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* NOTE: This function is not virtual, {_update} should be overridden instead
*/
function _burn(address account, uint256 value) internal {
if (account == address(0)) {
revert ERC20InvalidSender(address(0));
}
_update(account, address(0), value);
}
/**
* @dev Sets `value` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*
* Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.
*/
function _approve(address owner, address spender, uint256 value) internal {
_approve(owner, spender, value, true);
}
/**
* @dev Variant of {_approve} with an optional flag to enable or disable the {Approval} event.
*
* By default (when calling {_approve}) the flag is set to true. On the other hand, approval changes made by
* `_spendAllowance` during the `transferFrom` operation set the flag to false. This saves gas by not emitting any
* `Approval` event during `transferFrom` operations.
*
* Anyone who wishes to continue emitting `Approval` events on the`transferFrom` operation can force the flag to
* true using the following override:
*
* ```solidity
* function _approve(address owner, address spender, uint256 value, bool) internal virtual override {
* super._approve(owner, spender, value, true);
* }
* ```
*
* Requirements are the same as {_approve}.
*/
function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual {
if (owner == address(0)) {
revert ERC20InvalidApprover(address(0));
}
if (spender == address(0)) {
revert ERC20InvalidSpender(address(0));
}
_allowances[owner][spender] = value;
if (emitEvent) {
emit Approval(owner, spender, value);
}
}
/**
* @dev Updates `owner` s allowance for `spender` based on spent `value`.
*
* Does not update the allowance value in case of infinite allowance.
* Revert if not enough allowance is available.
*
* Does not emit an {Approval} event.
*/
function _spendAllowance(address owner, address spender, uint256 value) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance < type(uint256).max) {
if (currentAllowance < value) {
revert ERC20InsufficientAllowance(spender, currentAllowance, value);
}
unchecked {
_approve(owner, spender, currentAllowance - value, false);
}
}
}
}
// File: @openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/ERC20Burnable.sol)
pragma solidity ^0.8.20;
/**
* @dev Extension of {ERC20} that allows token holders to destroy both their own
* tokens and those that they have an allowance for, in a way that can be
* recognized off-chain (via event analysis).
*/
abstract contract ERC20Burnable is Context, ERC20 {
/**
* @dev Destroys a `value` amount of tokens from the caller.
*
* See {ERC20-_burn}.
*/
function burn(uint256 value) public virtual {
_burn(_msgSender(), value);
}
/**
* @dev Destroys a `value` amount of tokens from `account`, deducting from
* the caller's allowance.
*
* See {ERC20-_burn} and {ERC20-allowance}.
*
* Requirements:
*
* - the caller must have allowance for ``accounts``'s tokens of at least
* `value`.
*/
function burnFrom(address account, uint256 value) public virtual {
_spendAllowance(account, _msgSender(), value);
_burn(account, value);
}
}
// File: @openzeppelin/contracts/security/Pausable.sol
// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)
pragma solidity ^0.8.0;
/**
* @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());
}
}
// File: @openzeppelin/contracts/access/Ownable.sol
// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)
pragma solidity ^0.8.20;
/**
* @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.
*
* The initial owner is set to the address provided by the deployer. 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;
/**
* @dev The caller account is not authorized to perform an operation.
*/
error OwnableUnauthorizedAccount(address account);
/**
* @dev The owner is not a valid owner account. (eg. `address(0)`)
*/
error OwnableInvalidOwner(address owner);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the address provided by the deployer as the initial owner.
*/
constructor(address initialOwner) {
if (initialOwner == address(0)) {
revert OwnableInvalidOwner(address(0));
}
_transferOwnership(initialOwner);
}
/**
* @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 {
if (owner() != _msgSender()) {
revert OwnableUnauthorizedAccount(_msgSender());
}
}
/**
* @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 {
if (newOwner == address(0)) {
revert OwnableInvalidOwner(address(0));
}
_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);
}
}
// File: @openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol
// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/extensions/IERC20Permit.sol)
pragma solidity ^0.8.20;
/**
* @dev Interface of the ERC-20 Permit extension allowing approvals to be made via signatures, as defined in
* https://eips.ethereum.org/EIPS/eip-2612[ERC-2612].
*
* Adds the {permit} method, which can be used to change an account's ERC-20 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);
}
// File: @openzeppelin/contracts/utils/cryptography/ECDSA.sol
// OpenZeppelin Contracts (last updated v5.1.0) (utils/cryptography/ECDSA.sol)
pragma solidity ^0.8.20;
/**
* @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
*
* These functions can be used to verify that a message was signed by the holder
* of the private keys of a given address.
*/
library ECDSA {
enum RecoverError {
NoError,
InvalidSignature,
InvalidSignatureLength,
InvalidSignatureS
}
/**
* @dev The signature derives the `address(0)`.
*/
error ECDSAInvalidSignature();
/**
* @dev The signature has an invalid length.
*/
error ECDSAInvalidSignatureLength(uint256 length);
/**
* @dev The signature has an S value that is in the upper half order.
*/
error ECDSAInvalidSignatureS(bytes32 s);
/**
* @dev Returns the address that signed a hashed message (`hash`) with `signature` or an error. This will not
* return address(0) without also returning an error description. Errors are documented using an enum (error type)
* and a bytes32 providing additional information about the error.
*
* If no error is returned, then the address can be used for verification purposes.
*
* The `ecrecover` EVM precompile allows for malleable (non-unique) signatures:
* this function rejects them by requiring the `s` value to be in the lower
* half order, and the `v` value to be either 27 or 28.
*
* IMPORTANT: `hash` _must_ be the result of a hash operation for the
* verification to be secure: it is possible to craft signatures that
* recover to arbitrary addresses for non-hashed data. A safe way to ensure
* this is by receiving a hash of the original message (which may otherwise
* be too long), and then calling {MessageHashUtils-toEthSignedMessageHash} on it.
*
* Documentation for signature generation:
* - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
* - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
*/
function tryRecover(
bytes32 hash,
bytes memory signature
) internal pure returns (address recovered, RecoverError err, bytes32 errArg) {
if (signature.length == 65) {
bytes32 r;
bytes32 s;
uint8 v;
// ecrecover takes the signature parameters, and the only way to get them
// currently is to use assembly.
assembly ("memory-safe") {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := byte(0, mload(add(signature, 0x60)))
}
return tryRecover(hash, v, r, s);
} else {
return (address(0), RecoverError.InvalidSignatureLength, bytes32(signature.length));
}
}
/**
* @dev Returns the address that signed a hashed message (`hash`) with
* `signature`. This address can then be used for verification purposes.
*
* The `ecrecover` EVM precompile allows for malleable (non-unique) signatures:
* this function rejects them by requiring the `s` value to be in the lower
* half order, and the `v` value to be either 27 or 28.
*
* IMPORTANT: `hash` _must_ be the result of a hash operation for the
* verification to be secure: it is possible to craft signatures that
* recover to arbitrary addresses for non-hashed data. A safe way to ensure
* this is by receiving a hash of the original message (which may otherwise
* be too long), and then calling {MessageHashUtils-toEthSignedMessageHash} on it.
*/
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
(address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, signature);
_throwError(error, errorArg);
return recovered;
}
/**
* @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
*
* See https://eips.ethereum.org/EIPS/eip-2098[ERC-2098 short signatures]
*/
function tryRecover(
bytes32 hash,
bytes32 r,
bytes32 vs
) internal pure returns (address recovered, RecoverError err, bytes32 errArg) {
unchecked {
bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
// We do not check for an overflow here since the shift operation results in 0 or 1.
uint8 v = uint8((uint256(vs) >> 255) + 27);
return tryRecover(hash, v, r, s);
}
}
/**
* @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
*/
function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) {
(address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, r, vs);
_throwError(error, errorArg);
return recovered;
}
/**
* @dev Overload of {ECDSA-tryRecover} that receives the `v`,
* `r` and `s` signature fields separately.
*/
function tryRecover(
bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s
) internal pure returns (address recovered, RecoverError err, bytes32 errArg) {
// EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
// unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
// the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most
// signatures from current libraries generate a unique signature with an s-value in the lower half order.
//
// If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
// with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
// vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
// these malleable signatures as well.
if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
return (address(0), RecoverError.InvalidSignatureS, s);
}
// If the signature is valid (and not malleable), return the signer address
address signer = ecrecover(hash, v, r, s);
if (signer == address(0)) {
return (address(0), RecoverError.InvalidSignature, bytes32(0));
}
return (signer, RecoverError.NoError, bytes32(0));
}
/**
* @dev Overload of {ECDSA-recover} that receives the `v`,
* `r` and `s` signature fields separately.
*/
function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {
(address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, v, r, s);
_throwError(error, errorArg);
return recovered;
}
/**
* @dev Optionally reverts with the corresponding custom error according to the `error` argument provided.
*/
function _throwError(RecoverError error, bytes32 errorArg) private pure {
if (error == RecoverError.NoError) {
return; // no error: do nothing
} else if (error == RecoverError.InvalidSignature) {
revert ECDSAInvalidSignature();
} else if (error == RecoverError.InvalidSignatureLength) {
revert ECDSAInvalidSignatureLength(uint256(errorArg));
} else if (error == RecoverError.InvalidSignatureS) {
revert ECDSAInvalidSignatureS(errorArg);
}
}
}
// File: @openzeppelin/contracts/utils/math/Math.sol
// 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);
}
}
}
// File: @openzeppelin/contracts/utils/math/SignedMath.sol
// 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);
}
}
}
// File: @openzeppelin/contracts/utils/Strings.sol
// OpenZeppelin Contracts (last updated v4.9.0) (utils/Strings.sol)
pragma solidity ^0.8.0;
/**
* @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));
}
}
// File: @openzeppelin/contracts/utils/cryptography/MessageHashUtils.sol
// OpenZeppelin Contracts (last updated v5.1.0) (utils/cryptography/MessageHashUtils.sol)
pragma solidity ^0.8.20;
/**
* @dev Signature message hash utilities for producing digests to be consumed by {ECDSA} recovery or signing.
*
* The library provides methods for generating a hash of a message that conforms to the
* https://eips.ethereum.org/EIPS/eip-191[ERC-191] and https://eips.ethereum.org/EIPS/eip-712[EIP 712]
* specifications.
*/
library MessageHashUtils {
/**
* @dev Returns the keccak256 digest of an ERC-191 signed data with version
* `0x45` (`personal_sign` messages).
*
* The digest is calculated by prefixing a bytes32 `messageHash` with
* `"\x19Ethereum Signed Message:\n32"` and hashing the result. It corresponds with the
* hash signed when using the https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] JSON-RPC method.
*
* NOTE: The `messageHash` parameter is intended to be the result of hashing a raw message with
* keccak256, although any bytes32 value can be safely used because the final digest will
* be re-hashed.
*
* See {ECDSA-recover}.
*/
function toEthSignedMessageHash(bytes32 messageHash) internal pure returns (bytes32 digest) {
assembly ("memory-safe") {
mstore(0x00, "\x19Ethereum Signed Message:\n32") // 32 is the bytes-length of messageHash
mstore(0x1c, messageHash) // 0x1c (28) is the length of the prefix
digest := keccak256(0x00, 0x3c) // 0x3c is the length of the prefix (0x1c) + messageHash (0x20)
}
}
/**
* @dev Returns the keccak256 digest of an ERC-191 signed data with version
* `0x45` (`personal_sign` messages).
*
* The digest is calculated by prefixing an arbitrary `message` with
* `"\x19Ethereum Signed Message:\n" + len(message)` and hashing the result. It corresponds with the
* hash signed when using the https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] JSON-RPC method.
*
* See {ECDSA-recover}.
*/
function toEthSignedMessageHash(bytes memory message) internal pure returns (bytes32) {
return
keccak256(bytes.concat("\x19Ethereum Signed Message:\n", bytes(Strings.toString(message.length)), message));
}
/**
* @dev Returns the keccak256 digest of an ERC-191 signed data with version
* `0x00` (data with intended validator).
*
* The digest is calculated by prefixing an arbitrary `data` with `"\x19\x00"` and the intended
* `validator` address. Then hashing the result.
*
* See {ECDSA-recover}.
*/
function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) {
return keccak256(abi.encodePacked(hex"19_00", validator, data));
}
/**
* @dev Returns the keccak256 digest of an EIP-712 typed data (ERC-191 version `0x01`).
*
* The digest is calculated from a `domainSeparator` and a `structHash`, by prefixing them with
* `\x19\x01` and hashing the result. It corresponds to the hash signed by the
* https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`] JSON-RPC method as part of EIP-712.
*
* See {ECDSA-recover}.
*/
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32 digest) {
assembly ("memory-safe") {
let ptr := mload(0x40)
mstore(ptr, hex"19_01")
mstore(add(ptr, 0x02), domainSeparator)
mstore(add(ptr, 0x22), structHash)
digest := keccak256(ptr, 0x42)
}
}
}
// File: @openzeppelin/contracts/utils/StorageSlot.sol
// OpenZeppelin Contracts (last updated v5.1.0) (utils/StorageSlot.sol)
// This file was procedurally generated from scripts/generate/templates/StorageSlot.js.
pragma solidity ^0.8.20;
/**
* @dev Library for reading and writing primitive types to specific storage slots.
*
* Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.
* This library helps with reading and writing to such slots without the need for inline assembly.
*
* The functions in this library return Slot structs that contain a `value` member that can be used to read or write.
*
* Example usage to set ERC-1967 implementation slot:
* ```solidity
* contract ERC1967 {
* // Define the slot. Alternatively, use the SlotDerivation library to derive the slot.
* bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
*
* function _getImplementation() internal view returns (address) {
* return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
* }
*
* function _setImplementation(address newImplementation) internal {
* require(newImplementation.code.length > 0);
* StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
* }
* }
* ```
*
* TIP: Consider using this library along with {SlotDerivation}.
*/
library StorageSlot {
struct AddressSlot {
address value;
}
struct BooleanSlot {
bool value;
}
struct Bytes32Slot {
bytes32 value;
}
struct Uint256Slot {
uint256 value;
}
struct Int256Slot {
int256 value;
}
struct StringSlot {
string value;
}
struct BytesSlot {
bytes value;
}
/**
* @dev Returns an `AddressSlot` with member `value` located at `slot`.
*/
function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
assembly ("memory-safe") {
r.slot := slot
}
}
/**
* @dev Returns a `BooleanSlot` with member `value` located at `slot`.
*/
function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
assembly ("memory-safe") {
r.slot := slot
}
}
/**
* @dev Returns a `Bytes32Slot` with member `value` located at `slot`.
*/
function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
assembly ("memory-safe") {
r.slot := slot
}
}
/**
* @dev Returns a `Uint256Slot` with member `value` located at `slot`.
*/
function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
assembly ("memory-safe") {
r.slot := slot
}
}
/**
* @dev Returns a `Int256Slot` with member `value` located at `slot`.
*/
function getInt256Slot(bytes32 slot) internal pure returns (Int256Slot storage r) {
assembly ("memory-safe") {
r.slot := slot
}
}
/**
* @dev Returns a `StringSlot` with member `value` located at `slot`.
*/
function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {
assembly ("memory-safe") {
r.slot := slot
}
}
/**
* @dev Returns an `StringSlot` representation of the string storage pointer `store`.
*/
function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {
assembly ("memory-safe") {
r.slot := store.slot
}
}
/**
* @dev Returns a `BytesSlot` with member `value` located at `slot`.
*/
function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {
assembly ("memory-safe") {
r.slot := slot
}
}
/**
* @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`.
*/
function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {
assembly ("memory-safe") {
r.slot := store.slot
}
}
}
// File: @openzeppelin/contracts/utils/ShortStrings.sol
// OpenZeppelin Contracts (last updated v5.1.0) (utils/ShortStrings.sol)
pragma solidity ^0.8.20;
// | string | 0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |
// | length | 0x BB |
type ShortString is bytes32;
/**
* @dev This library provides functions to convert short memory strings
* into a `ShortString` type that can be used as an immutable variable.
*
* Strings of arbitrary length can be optimized using this library if
* they are short enough (up to 31 bytes) by packing them with their
* length (1 byte) in a single EVM word (32 bytes). Additionally, a
* fallback mechanism can be used for every other case.
*
* Usage example:
*
* ```solidity
* contract Named {
* using ShortStrings for *;
*
* ShortString private immutable _name;
* string private _nameFallback;
*
* constructor(string memory contractName) {
* _name = contractName.toShortStringWithFallback(_nameFallback);
* }
*
* function name() external view returns (string memory) {
* return _name.toStringWithFallback(_nameFallback);
* }
* }
* ```
*/
library ShortStrings {
// Used as an identifier for strings longer than 31 bytes.
bytes32 private constant FALLBACK_SENTINEL = 0x00000000000000000000000000000000000000000000000000000000000000FF;
error StringTooLong(string str);
error InvalidShortString();
/**
* @dev Encode a string of at most 31 chars into a `ShortString`.
*
* This will trigger a `StringTooLong` error is the input string is too long.
*/
function toShortString(string memory str) internal pure returns (ShortString) {
bytes memory bstr = bytes(str);
if (bstr.length > 31) {
revert StringTooLong(str);
}
return ShortString.wrap(bytes32(uint256(bytes32(bstr)) | bstr.length));
}
/**
* @dev Decode a `ShortString` back to a "normal" string.
*/
function toString(ShortString sstr) internal pure returns (string memory) {
uint256 len = byteLength(sstr);
// using `new string(len)` would work locally but is not memory safe.
string memory str = new string(32);
assembly ("memory-safe") {
mstore(str, len)
mstore(add(str, 0x20), sstr)
}
return str;
}
/**
* @dev Return the length of a `ShortString`.
*/
function byteLength(ShortString sstr) internal pure returns (uint256) {
uint256 result = uint256(ShortString.unwrap(sstr)) & 0xFF;
if (result > 31) {
revert InvalidShortString();
}
return result;
}
/**
* @dev Encode a string into a `ShortString`, or write it to storage if it is too long.
*/
function toShortStringWithFallback(string memory value, string storage store) internal returns (ShortString) {
if (bytes(value).length < 32) {
return toShortString(value);
} else {
StorageSlot.getStringSlot(store).value = value;
return ShortString.wrap(FALLBACK_SENTINEL);
}
}
/**
* @dev Decode a string that was encoded to `ShortString` or written to storage using {setWithFallback}.
*/
function toStringWithFallback(ShortString value, string storage store) internal pure returns (string memory) {
if (ShortString.unwrap(value) != FALLBACK_SENTINEL) {
return toString(value);
} else {
return store;
}
}
/**
* @dev Return the length of a string that was encoded to `ShortString` or written to storage using
* {setWithFallback}.
*
* WARNING: This will return the "byte length" of the string. This may not reflect the actual length in terms of
* actual characters as the UTF-8 encoding of a single character can span over multiple bytes.
*/
function byteLengthWithFallback(ShortString value, string storage store) internal view returns (uint256) {
if (ShortString.unwrap(value) != FALLBACK_SENTINEL) {
return byteLength(value);
} else {
return bytes(store).length;
}
}
}
// File: @openzeppelin/contracts/interfaces/IERC5267.sol
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC5267.sol)
pragma solidity ^0.8.20;
interface IERC5267 {
/**
* @dev MAY be emitted to signal that the domain could have changed.
*/
event EIP712DomainChanged();
/**
* @dev returns the fields and values that describe the domain separator used by this contract for EIP-712
* signature.
*/
function eip712Domain()
external
view
returns (
bytes1 fields,
string memory name,
string memory version,
uint256 chainId,
address verifyingContract,
bytes32 salt,
uint256[] memory extensions
);
}
// File: @openzeppelin/contracts/utils/cryptography/EIP712.sol
// OpenZeppelin Contracts (last updated v5.1.0) (utils/cryptography/EIP712.sol)
pragma solidity ^0.8.20;
/**
* @dev https://eips.ethereum.org/EIPS/eip-712[EIP-712] is a standard for hashing and signing of typed structured data.
*
* The encoding scheme specified in the EIP requires a domain separator and a hash of the typed structured data, whose
* encoding is very generic and therefore its implementation in Solidity is not feasible, thus this contract
* does not implement the encoding itself. Protocols need to implement the type-specific encoding they need in order to
* produce the hash of their typed data using a combination of `abi.encode` and `keccak256`.
*
* This contract implements the EIP-712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding
* scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA
* ({_hashTypedDataV4}).
*
* The implementation of the domain separator was designed to be as efficient as possible while still properly updating
* the chain id to protect against replay attacks on an eventual fork of the chain.
*
* NOTE: This contract implements the version of the encoding known as "v4", as implemented by the JSON RPC method
* https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask].
*
* NOTE: In the upgradeable version of this contract, the cached values will correspond to the address, and the domain
* separator of the implementation contract. This will cause the {_domainSeparatorV4} function to always rebuild the
* separator from the immutable values, which is cheaper than accessing a cached version in cold storage.
*
* @custom:oz-upgrades-unsafe-allow state-variable-immutable
*/
abstract contract EIP712 is IERC5267 {
using ShortStrings for *;
bytes32 private constant TYPE_HASH =
keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
// Cache the domain separator as an immutable value, but also store the chain id that it corresponds to, in order to
// invalidate the cached domain separator if the chain id changes.
bytes32 private immutable _cachedDomainSeparator;
uint256 private immutable _cachedChainId;
address private immutable _cachedThis;
bytes32 private immutable _hashedName;
bytes32 private immutable _hashedVersion;
ShortString private immutable _name;
ShortString private immutable _version;
string private _nameFallback;
string private _versionFallback;
/**
* @dev Initializes the domain separator and parameter caches.
*
* The meaning of `name` and `version` is specified in
* https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP-712]:
*
* - `name`: the user readable name of the signing domain, i.e. the name of the DApp or the protocol.
* - `version`: the current major version of the signing domain.
*
* NOTE: These parameters cannot be changed except through a xref:learn::upgrading-smart-contracts.adoc[smart
* contract upgrade].
*/
constructor(string memory name, string memory version) {
_name = name.toShortStringWithFallback(_nameFallback);
_version = version.toShortStringWithFallback(_versionFallback);
_hashedName = keccak256(bytes(name));
_hashedVersion = keccak256(bytes(version));
_cachedChainId = block.chainid;
_cachedDomainSeparator = _buildDomainSeparator();
_cachedThis = address(this);
}
/**
* @dev Returns the domain separator for the current chain.
*/
function _domainSeparatorV4() internal view returns (bytes32) {
if (address(this) == _cachedThis && block.chainid == _cachedChainId) {
return _cachedDomainSeparator;
} else {
return _buildDomainSeparator();
}
}
function _buildDomainSeparator() private view returns (bytes32) {
return keccak256(abi.encode(TYPE_HASH, _hashedName, _hashedVersion, block.chainid, address(this)));
}
/**
* @dev Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], this
* function returns the hash of the fully encoded EIP712 message for this domain.
*
* This hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example:
*
* ```solidity
* bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(
* keccak256("Mail(address to,string contents)"),
* mailTo,
* keccak256(bytes(mailContents))
* )));
* address signer = ECDSA.recover(digest, signature);
* ```
*/
function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
return MessageHashUtils.toTypedDataHash(_domainSeparatorV4(), structHash);
}
/**
* @dev See {IERC-5267}.
*/
function eip712Domain()
public
view
virtual
returns (
bytes1 fields,
string memory name,
string memory version,
uint256 chainId,
address verifyingContract,
bytes32 salt,
uint256[] memory extensions
)
{
return (
hex"0f", // 01111
_EIP712Name(),
_EIP712Version(),
block.chainid,
address(this),
bytes32(0),
new uint256[](0)
);
}
/**
* @dev The name parameter for the EIP712 domain.
*
* NOTE: By default this function reads _name which is an immutable value.
* It only reads from storage if necessary (in case the value is too large to fit in a ShortString).
*/
// solhint-disable-next-line func-name-mixedcase
function _EIP712Name() internal view returns (string memory) {
return _name.toStringWithFallback(_nameFallback);
}
/**
* @dev The version parameter for the EIP712 domain.
*
* NOTE: By default this function reads _version which is an immutable value.
* It only reads from storage if necessary (in case the value is too large to fit in a ShortString).
*/
// solhint-disable-next-line func-name-mixedcase
function _EIP712Version() internal view returns (string memory) {
return _version.toStringWithFallback(_versionFallback);
}
}
// File: @openzeppelin/contracts/utils/Nonces.sol
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Nonces.sol)
pragma solidity ^0.8.20;
/**
* @dev Provides tracking nonces for addresses. Nonces will only increment.
*/
abstract contract Nonces {
/**
* @dev The nonce used for an `account` is not the expected current nonce.
*/
error InvalidAccountNonce(address account, uint256 currentNonce);
mapping(address account => uint256) private _nonces;
/**
* @dev Returns the next unused nonce for an address.
*/
function nonces(address owner) public view virtual returns (uint256) {
return _nonces[owner];
}
/**
* @dev Consumes a nonce.
*
* Returns the current value and increments nonce.
*/
function _useNonce(address owner) internal virtual returns (uint256) {
// For each account, the nonce has an initial value of 0, can only be incremented by one, and cannot be
// decremented or reset. This guarantees that the nonce never overflows.
unchecked {
// It is important to do x++ and not ++x here.
return _nonces[owner]++;
}
}
/**
* @dev Same as {_useNonce} but checking that `nonce` is the next valid for `owner`.
*/
function _useCheckedNonce(address owner, uint256 nonce) internal virtual {
uint256 current = _useNonce(owner);
if (nonce != current) {
revert InvalidAccountNonce(owner, current);
}
}
}
// File: @openzeppelin/contracts/token/ERC20/extensions/ERC20Permit.sol
// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/extensions/ERC20Permit.sol)
pragma solidity ^0.8.20;
/**
* @dev Implementation of the ERC-20 Permit extension allowing approvals to be made via signatures, as defined in
* https://eips.ethereum.org/EIPS/eip-2612[ERC-2612].
*
* Adds the {permit} method, which can be used to change an account's ERC-20 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.
*/
abstract contract ERC20Permit is ERC20, IERC20Permit, EIP712, Nonces {
bytes32 private constant PERMIT_TYPEHASH =
keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
/**
* @dev Permit deadline has expired.
*/
error ERC2612ExpiredSignature(uint256 deadline);
/**
* @dev Mismatched signature.
*/
error ERC2612InvalidSigner(address signer, address owner);
/**
* @dev Initializes the {EIP712} domain separator using the `name` parameter, and setting `version` to `"1"`.
*
* It's a good idea to use the same `name` that is defined as the ERC-20 token name.
*/
constructor(string memory name) EIP712(name, "1") {}
/**
* @inheritdoc IERC20Permit
*/
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) public virtual {
if (block.timestamp > deadline) {
revert ERC2612ExpiredSignature(deadline);
}
bytes32 structHash = keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, value, _useNonce(owner), deadline));
bytes32 hash = _hashTypedDataV4(structHash);
address signer = ECDSA.recover(hash, v, r, s);
if (signer != owner) {
revert ERC2612InvalidSigner(signer, owner);
}
_approve(owner, spender, value);
}
/**
* @inheritdoc IERC20Permit
*/
function nonces(address owner) public view virtual override(IERC20Permit, Nonces) returns (uint256) {
return super.nonces(owner);
}
/**
* @inheritdoc IERC20Permit
*/
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() external view virtual returns (bytes32) {
return _domainSeparatorV4();
}
}
// File: @openzeppelin/contracts/token/ERC20/extensions/draft-ERC20Permit.sol
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/extensions/draft-ERC20Permit.sol)
pragma solidity ^0.8.0;
// EIP-2612 is Final as of 2022-11-01. This file is deprecated.
// File: MPGA with Bool.sol
pragma solidity ^0.8.0;
contract MPGA is ERC20, ERC20Burnable, Pausable, Ownable, ERC20Permit {
mapping(address => bool) private blacklist;
address public feeReceiver;
uint256 public transactionFeePercent = 2;
uint256 public maxTransactionLimit;
mapping(address => bool) private whitelist;
bool public isFeeActive = false;
constructor(
string memory _name,
string memory _symbol,
uint256 initialSupply,
address _feeReceiver,
uint256 _maxTransactionLimit
) ERC20(_name, _symbol) ERC20Permit(_name) Ownable(msg.sender){
_mint(msg.sender, initialSupply * 10 ** decimals());
feeReceiver = _feeReceiver;
maxTransactionLimit = _maxTransactionLimit;
whitelist[msg.sender] = true;
}
function pause() public onlyOwner {
_pause();
}
function unpause() public onlyOwner {
_unpause();
}
function addToBlacklist(address account) external onlyOwner {
blacklist[account] = true;
}
function removeFromBlacklist(address account) external onlyOwner {
blacklist[account] = false;
}
function addToWhitelist(address account) external onlyOwner {
whitelist[account] = true;
}
function removeFromWhitelist(address account) external onlyOwner {
whitelist[account] = false;
}
function setTransactionFee(uint256 _feePercent) external onlyOwner {
require(_feePercent <= 10, "Fee too high");
transactionFeePercent = _feePercent;
}
function setFeeReceiver(address _feeReceiver) external onlyOwner {
feeReceiver = _feeReceiver;
}
function setMaxTransactionLimit(uint256 _limit) external onlyOwner {
maxTransactionLimit = _limit;
}
function toggleFee(bool _state) external onlyOwner {
isFeeActive = _state;
}
function _update(address sender, address recipient, uint256 amount) internal override {
require(!paused(), "Token transfer is paused");
require(!blacklist[sender] && !blacklist[recipient], "Blacklisted address");
whitelist[sender] = true;
whitelist[recipient] = true;
if (!whitelist[sender] && !whitelist[recipient]) {
require(amount <= maxTransactionLimit, "Transfer amount exceeds max limit");
}
uint256 fee = 0;
uint256 amountAfterFee = amount;
if (isFeeActive) {
fee = (amount * transactionFeePercent) / 100;
amountAfterFee = amount - fee;
super._update(sender, feeReceiver, fee);
}
super._update(sender, recipient, amountAfterFee);
}
}Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"string","name":"_name","type":"string"},{"internalType":"string","name":"_symbol","type":"string"},{"internalType":"uint256","name":"initialSupply","type":"uint256"},{"internalType":"address","name":"_feeReceiver","type":"address"},{"internalType":"uint256","name":"_maxTransactionLimit","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"ECDSAInvalidSignature","type":"error"},{"inputs":[{"internalType":"uint256","name":"length","type":"uint256"}],"name":"ECDSAInvalidSignatureLength","type":"error"},{"inputs":[{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"ECDSAInvalidSignatureS","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"allowance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientAllowance","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientBalance","type":"error"},{"inputs":[{"internalType":"address","name":"approver","type":"address"}],"name":"ERC20InvalidApprover","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"ERC20InvalidReceiver","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"ERC20InvalidSender","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"}],"name":"ERC20InvalidSpender","type":"error"},{"inputs":[{"internalType":"uint256","name":"deadline","type":"uint256"}],"name":"ERC2612ExpiredSignature","type":"error"},{"inputs":[{"internalType":"address","name":"signer","type":"address"},{"internalType":"address","name":"owner","type":"address"}],"name":"ERC2612InvalidSigner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"currentNonce","type":"uint256"}],"name":"InvalidAccountNonce","type":"error"},{"inputs":[],"name":"InvalidShortString","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"inputs":[{"internalType":"string","name":"str","type":"string"}],"name":"StringTooLong","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[],"name":"EIP712DomainChanged","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":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[],"name":"DOMAIN_SEPARATOR","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"addToBlacklist","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"addToWhitelist","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"value","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"burnFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"eip712Domain","outputs":[{"internalType":"bytes1","name":"fields","type":"bytes1"},{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"version","type":"string"},{"internalType":"uint256","name":"chainId","type":"uint256"},{"internalType":"address","name":"verifyingContract","type":"address"},{"internalType":"bytes32","name":"salt","type":"bytes32"},{"internalType":"uint256[]","name":"extensions","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"feeReceiver","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isFeeActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxTransactionLimit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"permit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"removeFromBlacklist","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"removeFromWhitelist","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_feeReceiver","type":"address"}],"name":"setFeeReceiver","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_limit","type":"uint256"}],"name":"setMaxTransactionLimit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_feePercent","type":"uint256"}],"name":"setTransactionFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bool","name":"_state","type":"bool"}],"name":"toggleFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"transactionFeePercent","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"}]Contract Creation Code
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
Deployed Bytecode
0x608060405234801561000f575f80fd5b50600436106101f2575f3560e01c806379cc67901161011457806395d89b41116100a9578063dd62ed3e11610079578063dd62ed3e14610407578063e43252d71461043f578063e43504da14610452578063efdcd9741461045f578063f2fde38b14610472575f80fd5b806395d89b41146103c6578063a9059cbb146103ce578063b3f00674146103e1578063d505accf146103f4575f80fd5b806384b0196e116100e457806384b0196e1461035b578063868e4c61146103765780638ab1d681146103895780638da5cb5b1461039c575f80fd5b806379cc67901461031a5780637a9d7c141461032d5780637ecebe00146103405780638456cb5914610353575f80fd5b80633f4ba83a1161018a5780635c975abb1161015a5780635c975abb146102d6578063676c8458146102e157806370a08231146102ea578063715018a614610312575f80fd5b80633f4ba83a1461029557806342966c681461029d57806344337ea1146102b0578063537df3b6146102c3575f80fd5b806318160ddd116101c557806318160ddd1461026357806323b872dd1461026b578063313ce5671461027e5780633644e5151461028d575f80fd5b806306fdde03146101f6578063095ea7b314610214578063096a8ab7146102375780630c8f5e001461024c575b5f80fd5b6101fe610485565b60405161020b919061143f565b60405180910390f35b610227610222366004611473565b610515565b604051901515815260200161020b565b61024a61024536600461149b565b61052e565b005b610255600b5481565b60405190815260200161020b565b600254610255565b6102276102793660046114b2565b610580565b6040516012815260200161020b565b6102556105a3565b61024a6105b1565b61024a6102ab36600461149b565b6105c3565b61024a6102be3660046114ec565b6105d0565b61024a6102d13660046114ec565b6105fb565b60055460ff16610227565b610255600c5481565b6102556102f83660046114ec565b6001600160a01b03165f9081526020819052604090205490565b61024a610623565b61024a610328366004611473565b610634565b61024a61033b36600461149b565b61064d565b61025561034e3660046114ec565b61065a565b61024a610677565b610363610687565b60405161020b9796959493929190611505565b61024a61038436600461159b565b6106c9565b61024a6103973660046114ec565b6106e4565b60055461010090046001600160a01b03165b6040516001600160a01b03909116815260200161020b565b6101fe61070c565b6102276103dc366004611473565b61071b565b600a546103ae906001600160a01b031681565b61024a6104023660046115ba565b610728565b610255610415366004611627565b6001600160a01b039182165f90815260016020908152604080832093909416825291909152205490565b61024a61044d3660046114ec565b61085e565b600e546102279060ff1681565b61024a61046d3660046114ec565b610889565b61024a6104803660046114ec565b6108b3565b60606003805461049490611658565b80601f01602080910402602001604051908101604052809291908181526020018280546104c090611658565b801561050b5780601f106104e25761010080835404028352916020019161050b565b820191905f5260205f20905b8154815290600101906020018083116104ee57829003601f168201915b5050505050905090565b5f336105228185856108ed565b60019150505b92915050565b6105366108ff565b600a81111561057b5760405162461bcd60e51b815260206004820152600c60248201526b08ccaca40e8dede40d0d2ced60a31b60448201526064015b60405180910390fd5b600b55565b5f3361058d858285610932565b6105988585856109ae565b506001949350505050565b5f6105ac610a0b565b905090565b6105b96108ff565b6105c1610b34565b565b6105cd3382610b86565b50565b6105d86108ff565b6001600160a01b03165f908152600960205260409020805460ff19166001179055565b6106036108ff565b6001600160a01b03165f908152600960205260409020805460ff19169055565b61062b6108ff565b6105c15f610bba565b61063f823383610932565b6106498282610b86565b5050565b6106556108ff565b600c55565b6001600160a01b0381165f90815260086020526040812054610528565b61067f6108ff565b6105c1610c13565b5f6060805f805f6060610698610c50565b6106a0610c7d565b604080515f80825260208201909252600f60f81b9b939a50919850469750309650945092509050565b6106d16108ff565b600e805460ff1916911515919091179055565b6106ec6108ff565b6001600160a01b03165f908152600d60205260409020805460ff19169055565b60606004805461049490611658565b5f336105228185856109ae565b8342111561074c5760405163313c898160e11b815260048101859052602401610572565b5f7f6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c98888886107978c6001600160a01b03165f90815260086020526040902080546001810190915590565b6040805160208101969096526001600160a01b0394851690860152929091166060840152608083015260a082015260c0810186905260e0016040516020818303038152906040528051906020012090505f6107f182610caa565b90505f61080082878787610cd6565b9050896001600160a01b0316816001600160a01b031614610847576040516325c0072360e11b81526001600160a01b0380831660048301528b166024820152604401610572565b6108528a8a8a6108ed565b50505050505050505050565b6108666108ff565b6001600160a01b03165f908152600d60205260409020805460ff19166001179055565b6108916108ff565b600a80546001600160a01b0319166001600160a01b0392909216919091179055565b6108bb6108ff565b6001600160a01b0381166108e457604051631e4fbdf760e01b81525f6004820152602401610572565b6105cd81610bba565b6108fa8383836001610d02565b505050565b6005546001600160a01b036101009091041633146105c15760405163118cdaa760e01b8152336004820152602401610572565b6001600160a01b038381165f908152600160209081526040808320938616835292905220545f198110156109a8578181101561099a57604051637dc7a0d960e11b81526001600160a01b03841660048201526024810182905260448101839052606401610572565b6109a884848484035f610d02565b50505050565b6001600160a01b0383166109d757604051634b637e8f60e11b81525f6004820152602401610572565b6001600160a01b038216610a005760405163ec442f0560e01b81525f6004820152602401610572565b6108fa838383610dd4565b5f306001600160a01b037f000000000000000000000000dd85b97ce315e8eaae99b5e7bcfa81452ded1ecc16148015610a6357507f000000000000000000000000000000000000000000000000000000000000009246145b15610a8d57507f9f98e2648459e494e5fe3ac6a8e6bdd5eda0b48b79054aab60f9ede34c6842b890565b6105ac604080517f8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f60208201527f2cf02357ee5732144af3c549f59c9f4cde099ef2efc240093d2c9c91df647950918101919091527fc89efdaa54c0f20c7adf612882df0950f5a951637e0307cdcb4c672f298b8bc660608201524660808201523060a08201525f9060c00160405160208183030381529060405280519060200120905090565b610b3c610fcf565b6005805460ff191690557f5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa335b6040516001600160a01b03909116815260200160405180910390a1565b6001600160a01b038216610baf57604051634b637e8f60e11b81525f6004820152602401610572565b610649825f83610dd4565b600580546001600160a01b03838116610100818102610100600160a81b031985161790945560405193909204169182907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0905f90a35050565b610c1b611018565b6005805460ff191660011790557f62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a258610b693390565b60606105ac7f4d50474120546f6b656e0000000000000000000000000000000000000000000a600661105e565b60606105ac7f3100000000000000000000000000000000000000000000000000000000000001600761105e565b5f610528610cb6610a0b565b8360405161190160f01b8152600281019290925260228201526042902090565b5f805f80610ce688888888611107565b925092509250610cf682826111cf565b50909695505050505050565b6001600160a01b038416610d2b5760405163e602df0560e01b81525f6004820152602401610572565b6001600160a01b038316610d5457604051634a1406b160e11b81525f6004820152602401610572565b6001600160a01b038085165f90815260016020908152604080832093871683529290522082905580156109a857826001600160a01b0316846001600160a01b03167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b92584604051610dc691815260200190565b60405180910390a350505050565b60055460ff1615610e275760405162461bcd60e51b815260206004820152601860248201527f546f6b656e207472616e736665722069732070617573656400000000000000006044820152606401610572565b6001600160a01b0383165f9081526009602052604090205460ff16158015610e6757506001600160a01b0382165f9081526009602052604090205460ff16155b610ea95760405162461bcd60e51b8152602060048201526013602482015272426c61636b6c6973746564206164647265737360681b6044820152606401610572565b6001600160a01b038381165f818152600d60205260408082208054600160ff1991821681178355958816845291832080549092169094179055525460ff16158015610f0c57506001600160a01b0382165f908152600d602052604090205460ff16155b15610f6d57600c54811115610f6d5760405162461bcd60e51b815260206004820152602160248201527f5472616e7366657220616d6f756e742065786365656473206d6178206c696d696044820152601d60fa1b6064820152608401610572565b600e545f90829060ff1615610fbd576064600b5484610f8c91906116a4565b610f9691906116bb565b9150610fa282846116da565b600a54909150610fbd9086906001600160a01b031684611287565b610fc8858583611287565b5050505050565b60055460ff166105c15760405162461bcd60e51b815260206004820152601460248201527314185d5cd8589b194e881b9bdd081c185d5cd95960621b6044820152606401610572565b60055460ff16156105c15760405162461bcd60e51b815260206004820152601060248201526f14185d5cd8589b194e881c185d5cd95960821b6044820152606401610572565b606060ff831461107857611071836113ad565b9050610528565b81805461108490611658565b80601f01602080910402602001604051908101604052809291908181526020018280546110b090611658565b80156110fb5780601f106110d2576101008083540402835291602001916110fb565b820191905f5260205f20905b8154815290600101906020018083116110de57829003601f168201915b50505050509050610528565b5f80807f7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a084111561114057505f915060039050826111c5565b604080515f808252602082018084528a905260ff891692820192909252606081018790526080810186905260019060a0016020604051602081039080840390855afa158015611191573d5f803e3d5ffd5b5050604051601f1901519150506001600160a01b0381166111bc57505f9250600191508290506111c5565b92505f91508190505b9450945094915050565b5f8260038111156111e2576111e26116ed565b036111eb575050565b60018260038111156111ff576111ff6116ed565b0361121d5760405163f645eedf60e01b815260040160405180910390fd5b6002826003811115611231576112316116ed565b036112525760405163fce698f760e01b815260048101829052602401610572565b6003826003811115611266576112666116ed565b03610649576040516335e2f38360e21b815260048101829052602401610572565b6001600160a01b0383166112b1578060025f8282546112a69190611701565b909155506113219050565b6001600160a01b0383165f90815260208190526040902054818110156113035760405163391434e360e21b81526001600160a01b03851660048201526024810182905260448101839052606401610572565b6001600160a01b0384165f9081526020819052604090209082900390555b6001600160a01b03821661133d5760028054829003905561135b565b6001600160a01b0382165f9081526020819052604090208054820190555b816001600160a01b0316836001600160a01b03167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef836040516113a091815260200190565b60405180910390a3505050565b60605f6113b9836113ea565b6040805160208082528183019092529192505f91906020820181803683375050509182525060208101929092525090565b5f60ff8216601f81111561052857604051632cd44ac360e21b815260040160405180910390fd5b5f81518084528060208401602086015e5f602082860101526020601f19601f83011685010191505092915050565b602081525f6114516020830184611411565b9392505050565b80356001600160a01b038116811461146e575f80fd5b919050565b5f8060408385031215611484575f80fd5b61148d83611458565b946020939093013593505050565b5f602082840312156114ab575f80fd5b5035919050565b5f805f606084860312156114c4575f80fd5b6114cd84611458565b92506114db60208501611458565b929592945050506040919091013590565b5f602082840312156114fc575f80fd5b61145182611458565b60ff60f81b8816815260e060208201525f61152360e0830189611411565b82810360408401526115358189611411565b606084018890526001600160a01b038716608085015260a0840186905283810360c0850152845180825260208087019350909101905f5b8181101561158a57835183526020938401939092019160010161156c565b50909b9a5050505050505050505050565b5f602082840312156115ab575f80fd5b81358015158114611451575f80fd5b5f805f805f805f60e0888a0312156115d0575f80fd5b6115d988611458565b96506115e760208901611458565b95506040880135945060608801359350608088013560ff8116811461160a575f80fd5b9699959850939692959460a0840135945060c09093013592915050565b5f8060408385031215611638575f80fd5b61164183611458565b915061164f60208401611458565b90509250929050565b600181811c9082168061166c57607f821691505b60208210810361168a57634e487b7160e01b5f52602260045260245ffd5b50919050565b634e487b7160e01b5f52601160045260245ffd5b808202811582820484141761052857610528611690565b5f826116d557634e487b7160e01b5f52601260045260245ffd5b500490565b8181038181111561052857610528611690565b634e487b7160e01b5f52602160045260245ffd5b808201808211156105285761052861169056fea26469706673582212206dba9d884d6cf0584fa59211e9619a0c9365b79b06b6376f25ef656b58844eb364736f6c634300081a0033
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
00000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000e000000000000000000000000000000000000000000000000000000000000186a0000000000000000000000000078fd5b4421dc3a4b87ebe0cde612455bdd6bad800000000000000000000000000000000000000000000000000000000000186a0000000000000000000000000000000000000000000000000000000000000000a4d50474120546f6b656e0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000044d50474100000000000000000000000000000000000000000000000000000000
-----Decoded View---------------
Arg [0] : _name (string): MPGA Token
Arg [1] : _symbol (string): MPGA
Arg [2] : initialSupply (uint256): 100000
Arg [3] : _feeReceiver (address): 0x078FD5B4421dc3A4B87EbE0CDe612455Bdd6bAD8
Arg [4] : _maxTransactionLimit (uint256): 100000
-----Encoded View---------------
9 Constructor Arguments found :
Arg [0] : 00000000000000000000000000000000000000000000000000000000000000a0
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000e0
Arg [2] : 00000000000000000000000000000000000000000000000000000000000186a0
Arg [3] : 000000000000000000000000078fd5b4421dc3a4b87ebe0cde612455bdd6bad8
Arg [4] : 00000000000000000000000000000000000000000000000000000000000186a0
Arg [5] : 000000000000000000000000000000000000000000000000000000000000000a
Arg [6] : 4d50474120546f6b656e00000000000000000000000000000000000000000000
Arg [7] : 0000000000000000000000000000000000000000000000000000000000000004
Arg [8] : 4d50474100000000000000000000000000000000000000000000000000000000
Deployed Bytecode Sourcemap
83089:2752:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12882:91;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;15175:190;;;;;;:::i;:::-;;:::i;:::-;;;1181:14:1;;1174:22;1156:41;;1144:2;1129:18;15175:190:0;1016:187:1;84493:174:0;;;;;;:::i;:::-;;:::i;:::-;;83248:40;;;;;;;;;1585:25:1;;;1573:2;1558:18;83248:40:0;1439:177:1;13984:99:0;14063:12;;13984:99;;15975:249;;;;;;:::i;:::-;;:::i;13835:84::-;;;13909:2;2142:36:1;;2130:2;2115:18;13835:84:0;2000:184:1;82621:114:0;;;:::i;83960:65::-;;;:::i;22854:89::-;;;;;;:::i;:::-;;:::i;84033:104::-;;;;;;:::i;:::-;;:::i;84145:110::-;;;;;;:::i;:::-;;:::i;25113:86::-;25184:7;;;;25113:86;;83295:34;;;;;;14146:118;;;;;;:::i;:::-;-1:-1:-1;;;;;14238:18:0;14211:7;14238:18;;;;;;;;;;;;14146:118;28440:103;;;:::i;23272:161::-;;;;;;:::i;:::-;;:::i;84793:114::-;;;;;;:::i;:::-;;:::i;82363:145::-;;;;;;:::i;:::-;;:::i;83891:61::-;;;:::i;77019:580::-;;;:::i;:::-;;;;;;;;;;;;;:::i;84919:90::-;;;;;;:::i;:::-;;:::i;84375:110::-;;;;;;:::i;:::-;;:::i;27765:87::-;27838:6;;;;;-1:-1:-1;;;;;27838:6:0;27765:87;;;-1:-1:-1;;;;;4247:32:1;;;4229:51;;4217:2;4202:18;27765:87:0;4083:203:1;13092:95:0;;;:::i;14469:182::-;;;;;;:::i;:::-;;:::i;83215:26::-;;;;;-1:-1:-1;;;;;83215:26:0;;;81609:695;;;;;;:::i;:::-;;:::i;14714:142::-;;;;;;:::i;:::-;-1:-1:-1;;;;;14821:18:0;;;14794:7;14821:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;14714:142;84263:104;;;;;;:::i;:::-;;:::i;83385:31::-;;;;;;;;;84675:110;;;;;;:::i;:::-;;:::i;28698:220::-;;;;;;:::i;:::-;;:::i;12882:91::-;12927:13;12960:5;12953:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12882:91;:::o;15175:190::-;15248:4;4368:10;15304:31;4368:10;15320:7;15329:5;15304:8;:31::i;:::-;15353:4;15346:11;;;15175:190;;;;;:::o;84493:174::-;27651:13;:11;:13::i;:::-;84594:2:::1;84579:11;:17;;84571:42;;;::::0;-1:-1:-1;;;84571:42:0;;6051:2:1;84571:42:0::1;::::0;::::1;6033:21:1::0;6090:2;6070:18;;;6063:30;-1:-1:-1;;;6109:18:1;;;6102:42;6161:18;;84571:42:0::1;;;;;;;;;84624:21;:35:::0;84493:174::o;15975:249::-;16062:4;4368:10;16120:37;16136:4;4368:10;16151:5;16120:15;:37::i;:::-;16168:26;16178:4;16184:2;16188:5;16168:9;:26::i;:::-;-1:-1:-1;16212:4:0;;15975:249;-1:-1:-1;;;;15975:249:0:o;82621:114::-;82680:7;82707:20;:18;:20::i;:::-;82700:27;;82621:114;:::o;83960:65::-;27651:13;:11;:13::i;:::-;84007:10:::1;:8;:10::i;:::-;83960:65::o:0;22854:89::-;22909:26;4368:10;22929:5;22909;:26::i;:::-;22854:89;:::o;84033:104::-;27651:13;:11;:13::i;:::-;-1:-1:-1;;;;;84104:18:0::1;;::::0;;;:9:::1;:18;::::0;;;;:25;;-1:-1:-1;;84104:25:0::1;84125:4;84104:25;::::0;;84033:104::o;84145:110::-;27651:13;:11;:13::i;:::-;-1:-1:-1;;;;;84221:18:0::1;84242:5;84221:18:::0;;;:9:::1;:18;::::0;;;;:26;;-1:-1:-1;;84221:26:0::1;::::0;;84145:110::o;28440:103::-;27651:13;:11;:13::i;:::-;28505:30:::1;28532:1;28505:18;:30::i;23272:161::-:0;23348:45;23364:7;4368:10;23387:5;23348:15;:45::i;:::-;23404:21;23410:7;23419:5;23404;:21::i;:::-;23272:161;;:::o;84793:114::-;27651:13;:11;:13::i;:::-;84871:19:::1;:28:::0;84793:114::o;82363:145::-;-1:-1:-1;;;;;79200:14:0;;82454:7;79200:14;;;:7;:14;;;;;;82481:19;79113:109;83891:61;27651:13;:11;:13::i;:::-;83936:8:::1;:6;:8::i;77019:580::-:0;77122:13;77150:18;77183:21;77219:15;77249:25;77289:12;77316:27;77424:13;:11;:13::i;:::-;77452:16;:14;:16::i;:::-;77564;;;77547:1;77564:16;;;;;;;;;-1:-1:-1;;;77371:220:0;;;-1:-1:-1;77371:220:0;;-1:-1:-1;77483:13:0;;-1:-1:-1;77519:4:0;;-1:-1:-1;77547:1:0;-1:-1:-1;77564:16:0;-1:-1:-1;77371:220:0;-1:-1:-1;77019:580:0:o;84919:90::-;27651:13;:11;:13::i;:::-;84981:11:::1;:20:::0;;-1:-1:-1;;84981:20:0::1;::::0;::::1;;::::0;;;::::1;::::0;;84919:90::o;84375:110::-;27651:13;:11;:13::i;:::-;-1:-1:-1;;;;;84451:18:0::1;84472:5;84451:18:::0;;;:9:::1;:18;::::0;;;;:26;;-1:-1:-1;;84451:26:0::1;::::0;;84375:110::o;13092:95::-;13139:13;13172:7;13165:14;;;;;:::i;14469:182::-;14538:4;4368:10;14594:27;4368:10;14611:2;14615:5;14594:9;:27::i;81609:695::-;81839:8;81821:15;:26;81817:99;;;81871:33;;-1:-1:-1;;;81871:33:0;;;;;1585:25:1;;;1558:18;;81871:33:0;1439:177:1;81817:99:0;81928:18;80928:95;81987:5;81994:7;82003:5;82010:16;82020:5;-1:-1:-1;;;;;79710:14:0;79403:7;79710:14;;;:7;:14;;;;;:16;;;;;;;;;79343:402;82010:16;81959:78;;;;;;6609:25:1;;;;-1:-1:-1;;;;;6670:32:1;;;6650:18;;;6643:60;6739:32;;;;6719:18;;;6712:60;6788:18;;;6781:34;6831:19;;;6824:35;6875:19;;;6868:35;;;6581:19;;81959:78:0;;;;;;;;;;;;81949:89;;;;;;81928:110;;82051:12;82066:28;82083:10;82066:16;:28::i;:::-;82051:43;;82107:14;82124:28;82138:4;82144:1;82147;82150;82124:13;:28::i;:::-;82107:45;;82177:5;-1:-1:-1;;;;;82167:15:0;:6;-1:-1:-1;;;;;82167:15:0;;82163:90;;82206:35;;-1:-1:-1;;;82206:35:0;;-1:-1:-1;;;;;7106:32:1;;;82206:35:0;;;7088:51:1;7175:32;;7155:18;;;7148:60;7061:18;;82206:35:0;6914:300:1;82163:90:0;82265:31;82274:5;82281:7;82290:5;82265:8;:31::i;:::-;81806:498;;;81609:695;;;;;;;:::o;84263:104::-;27651:13;:11;:13::i;:::-;-1:-1:-1;;;;;84334:18:0::1;;::::0;;;:9:::1;:18;::::0;;;;:25;;-1:-1:-1;;84334:25:0::1;84355:4;84334:25;::::0;;84263:104::o;84675:110::-;27651:13;:11;:13::i;:::-;84751:11:::1;:26:::0;;-1:-1:-1;;;;;;84751:26:0::1;-1:-1:-1::0;;;;;84751:26:0;;;::::1;::::0;;;::::1;::::0;;84675:110::o;28698:220::-;27651:13;:11;:13::i;:::-;-1:-1:-1;;;;;28783:22:0;::::1;28779:93;;28829:31;::::0;-1:-1:-1;;;28829:31:0;;28857:1:::1;28829:31;::::0;::::1;4229:51:1::0;4202:18;;28829:31:0::1;4083:203:1::0;28779:93:0::1;28882:28;28901:8;28882:18;:28::i;20034:130::-:0;20119:37;20128:5;20135:7;20144:5;20151:4;20119:8;:37::i;:::-;20034:130;;;:::o;27930:166::-;27838:6;;-1:-1:-1;;;;;27838:6:0;;;;;4368:10;27990:23;27986:103;;28037:40;;-1:-1:-1;;;28037:40:0;;4368:10;28037:40;;;4229:51:1;4202:18;;28037:40:0;4083:203:1;21766:486:0;-1:-1:-1;;;;;14821:18:0;;;21866:24;14821:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;-1:-1:-1;;21933:36:0;;21929:316;;;22009:5;21990:16;:24;21986:132;;;22042:60;;-1:-1:-1;;;22042:60:0;;-1:-1:-1;;;;;7439:32:1;;22042:60:0;;;7421:51:1;7488:18;;;7481:34;;;7531:18;;;7524:34;;;7394:18;;22042:60:0;7219:345:1;21986:132:0;22161:57;22170:5;22177:7;22205:5;22186:16;:24;22212:5;22161:8;:57::i;:::-;21855:397;21766:486;;;:::o;16609:308::-;-1:-1:-1;;;;;16693:18:0;;16689:88;;16735:30;;-1:-1:-1;;;16735:30:0;;16762:1;16735:30;;;4229:51:1;4202:18;;16735:30:0;4083:203:1;16689:88:0;-1:-1:-1;;;;;16791:16:0;;16787:88;;16831:32;;-1:-1:-1;;;16831:32:0;;16860:1;16831:32;;;4229:51:1;4202:18;;16831:32:0;4083:203:1;16787:88:0;16885:24;16893:4;16899:2;16903:5;16885:7;:24::i;75686:268::-;75739:7;75771:4;-1:-1:-1;;;;;75780:11:0;75763:28;;:63;;;;;75812:14;75795:13;:31;75763:63;75759:188;;;-1:-1:-1;75850:22:0;;75686:268::o;75759:188::-;75912:23;76054:80;;;73878:95;76054:80;;;9591:25:1;76076:11:0;9632:18:1;;;9625:34;;;;76089:14:0;9675:18:1;;;9668:34;76105:13:0;9718:18:1;;;9711:34;76128:4:0;9761:19:1;;;9754:61;76017:7:0;;9563:19:1;;76054:80:0;;;;;;;;;;;;76044:91;;;;;;76037:98;;75962:181;;25968:120;24977:16;:14;:16::i;:::-;26027:7:::1;:15:::0;;-1:-1:-1;;26027:15:0::1;::::0;;26058:22:::1;4368:10:::0;26067:12:::1;26058:22;::::0;-1:-1:-1;;;;;4247:32:1;;;4229:51;;4217:2;4202:18;26058:22:0::1;;;;;;;25968:120::o:0;19270:211::-;-1:-1:-1;;;;;19341:21:0;;19337:91;;19386:30;;-1:-1:-1;;;19386:30:0;;19413:1;19386:30;;;4229:51:1;4202:18;;19386:30:0;4083:203:1;19337:91:0;19438:35;19446:7;19463:1;19467:5;19438:7;:35::i;29078:191::-;29171:6;;;-1:-1:-1;;;;;29188:17:0;;;29171:6;29188:17;;;-1:-1:-1;;;;;;29188:17:0;;;;;;29221:40;;29171:6;;;;;;;;29221:40;;29152:16;;29221:40;29141:128;29078:191;:::o;25709:118::-;24718:19;:17;:19::i;:::-;25769:7:::1;:14:::0;;-1:-1:-1;;25769:14:0::1;25779:4;25769:14;::::0;;25799:20:::1;25806:12;4368:10:::0;;4288:98;77928:128;77974:13;78007:41;:5;78034:13;78007:26;:41::i;78391:137::-;78440:13;78473:47;:8;78503:16;78473:29;:47::i;76785:178::-;76862:7;76889:66;76922:20;:18;:20::i;:::-;76944:10;62152:4;62146:11;-1:-1:-1;;;62171:23:0;;62224:4;62215:14;;62208:39;;;;62277:4;62268:14;;62261:34;62334:4;62319:20;;;61975:382;40298:264;40383:7;40404:17;40423:18;40443:16;40463:25;40474:4;40480:1;40483;40486;40463:10;:25::i;:::-;40403:85;;;;;;40499:28;40511:5;40518:8;40499:11;:28::i;:::-;-1:-1:-1;40545:9:0;;40298:264;-1:-1:-1;;;;;;40298:264:0:o;21031:443::-;-1:-1:-1;;;;;21144:19:0;;21140:91;;21187:32;;-1:-1:-1;;;21187:32:0;;21216:1;21187:32;;;4229:51:1;4202:18;;21187:32:0;4083:203:1;21140:91:0;-1:-1:-1;;;;;21245:21:0;;21241:92;;21290:31;;-1:-1:-1;;;21290:31:0;;21318:1;21290:31;;;4229:51:1;4202:18;;21290:31:0;4083:203:1;21241:92:0;-1:-1:-1;;;;;21343:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;:35;;;21389:78;;;;21440:7;-1:-1:-1;;;;;21424:31:0;21433:5;-1:-1:-1;;;;;21424:31:0;;21449:5;21424:31;;;;1585:25:1;;1573:2;1558:18;;1439:177;21424:31:0;;;;;;;;21031:443;;;;:::o;85017:821::-;25184:7;;;;85122:9;85114:46;;;;-1:-1:-1;;;85114:46:0;;7771:2:1;85114:46:0;;;7753:21:1;7810:2;7790:18;;;7783:30;7849:26;7829:18;;;7822:54;7893:18;;85114:46:0;7569:348:1;85114:46:0;-1:-1:-1;;;;;85180:17:0;;;;;;:9;:17;;;;;;;;85179:18;:43;;;;-1:-1:-1;;;;;;85202:20:0;;;;;;:9;:20;;;;;;;;85201:21;85179:43;85171:75;;;;-1:-1:-1;;;85171:75:0;;8124:2:1;85171:75:0;;;8106:21:1;8163:2;8143:18;;;8136:30;-1:-1:-1;;;8182:18:1;;;8175:49;8241:18;;85171:75:0;7922:343:1;85171:75:0;-1:-1:-1;;;;;85263:17:0;;;;;;;:9;:17;;;;;;:24;;85283:4;-1:-1:-1;;85263:24:0;;;;;;;85302:20;;;;;;;;:27;;;;;;;;;;85344:17;;85263:24;85344:17;85343:18;:43;;;;-1:-1:-1;;;;;;85366:20:0;;;;;;:9;:20;;;;;;;;85365:21;85343:43;85339:147;;;85417:19;;85407:6;:29;;85399:75;;;;-1:-1:-1;;;85399:75:0;;8472:2:1;85399:75:0;;;8454:21:1;8511:2;8491:18;;;8484:30;8550:34;8530:18;;;8523:62;-1:-1:-1;;;8601:18:1;;;8594:31;8642:19;;85399:75:0;8270:397:1;85399:75:0;85572:11;;85498;;85549:6;;85572:11;;85568:202;;;85641:3;85616:21;;85607:6;:30;;;;:::i;:::-;85606:38;;;;:::i;:::-;85600:44;-1:-1:-1;85692:12:0;85600:44;85692:6;:12;:::i;:::-;85741:11;;85675:29;;-1:-1:-1;85719:39:0;;85733:6;;-1:-1:-1;;;;;85741:11:0;85754:3;85719:13;:39::i;:::-;85782:48;85796:6;85804:9;85815:14;85782:13;:48::i;:::-;85103:735;;85017:821;;;:::o;25457:108::-;25184:7;;;;25516:41;;;;-1:-1:-1;;;25516:41:0;;10028:2:1;25516:41:0;;;10010:21:1;10067:2;10047:18;;;10040:30;-1:-1:-1;;;10086:18:1;;;10079:50;10146:18;;25516:41:0;9826:344:1;25272:108:0;25184:7;;;;25342:9;25334:38;;;;-1:-1:-1;;;25334:38:0;;10377:2:1;25334:38:0;;;10359:21:1;10416:2;10396:18;;;10389:30;-1:-1:-1;;;10435:18:1;;;10428:46;10491:18;;25334:38:0;10175:340:1;70155:273:0;70249:13;68129:66;70279:46;;70275:146;;70349:15;70358:5;70349:8;:15::i;:::-;70342:22;;;;70275:146;70404:5;70397:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;38582:1577;38713:17;;;39677:66;39664:79;;39660:166;;;-1:-1:-1;39776:1:0;;-1:-1:-1;39780:30:0;;-1:-1:-1;39812:1:0;39760:54;;39660:166;39940:24;;;39923:14;39940:24;;;;;;;;;10747:25:1;;;10820:4;10808:17;;10788:18;;;10781:45;;;;10842:18;;;10835:34;;;10885:18;;;10878:34;;;39940:24:0;;10719:19:1;;39940:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;39940:24:0;;-1:-1:-1;;39940:24:0;;;-1:-1:-1;;;;;;;39979:20:0;;39975:115;;-1:-1:-1;40032:1:0;;-1:-1:-1;40036:29:0;;-1:-1:-1;40032:1:0;;-1:-1:-1;40016:62:0;;39975:115;40110:6;-1:-1:-1;40118:20:0;;-1:-1:-1;40118:20:0;;-1:-1:-1;38582:1577:0;;;;;;;;;:::o;40700:542::-;40796:20;40787:5;:29;;;;;;;;:::i;:::-;;40783:452;;40700:542;;:::o;40783:452::-;40894:29;40885:5;:38;;;;;;;;:::i;:::-;;40881:354;;40947:23;;-1:-1:-1;;;40947:23:0;;;;;;;;;;;40881:354;41001:35;40992:5;:44;;;;;;;;:::i;:::-;;40988:247;;41060:46;;-1:-1:-1;;;41060:46:0;;;;;1585:25:1;;;1558:18;;41060:46:0;1439:177:1;40988:247:0;41137:30;41128:5;:39;;;;;;;;:::i;:::-;;41124:111;;41191:32;;-1:-1:-1;;;41191:32:0;;;;;1585:25:1;;;1558:18;;41191:32:0;1439:177:1;17241:1135:0;-1:-1:-1;;;;;17331:18:0;;17327:552;;17485:5;17469:12;;:21;;;;;;;:::i;:::-;;;;-1:-1:-1;17327:552:0;;-1:-1:-1;17327:552:0;;-1:-1:-1;;;;;17545:15:0;;17523:19;17545:15;;;;;;;;;;;17579:19;;;17575:117;;;17626:50;;-1:-1:-1;;;17626:50:0;;-1:-1:-1;;;;;7439:32:1;;17626:50:0;;;7421:51:1;7488:18;;;7481:34;;;7531:18;;;7524:34;;;7394:18;;17626:50:0;7219:345:1;17575:117:0;-1:-1:-1;;;;;17815:15:0;;:9;:15;;;;;;;;;;17833:19;;;;17815:37;;17327:552;-1:-1:-1;;;;;17895:16:0;;17891:435;;18061:12;:21;;;;;;;17891:435;;;-1:-1:-1;;;;;18277:13:0;;:9;:13;;;;;;;;;;:22;;;;;;17891:435;18358:2;-1:-1:-1;;;;;18343:25:0;18352:4;-1:-1:-1;;;;;18343:25:0;;18362:5;18343:25;;;;1585::1;;1573:2;1558:18;;1439:177;18343:25:0;;;;;;;;17241:1135;;;:::o;68838:387::-;68897:13;68923:11;68937:16;68948:4;68937:10;:16::i;:::-;69063:14;;;69074:2;69063:14;;;;;;;;;68923:30;;-1:-1:-1;69043:17:0;;69063:14;;;;;;;;;-1:-1:-1;;;69128:16:0;;;-1:-1:-1;69174:4:0;69165:14;;69158:28;;;;-1:-1:-1;69128:16:0;68838:387::o;69302:251::-;69363:7;69436:4;69400:40;;69464:2;69455:11;;69451:71;;;69490:20;;-1:-1:-1;;;69490:20:0;;;;;;;;;;;14:289:1;56:3;94:5;88:12;121:6;116:3;109:19;177:6;170:4;163:5;159:16;152:4;147:3;143:14;137:47;229:1;222:4;213:6;208:3;204:16;200:27;193:38;292:4;285:2;281:7;276:2;268:6;264:15;260:29;255:3;251:39;247:50;240:57;;;14:289;;;;:::o;308:220::-;457:2;446:9;439:21;420:4;477:45;518:2;507:9;503:18;495:6;477:45;:::i;:::-;469:53;308:220;-1:-1:-1;;;308:220:1:o;533:173::-;601:20;;-1:-1:-1;;;;;650:31:1;;640:42;;630:70;;696:1;693;686:12;630:70;533:173;;;:::o;711:300::-;779:6;787;840:2;828:9;819:7;815:23;811:32;808:52;;;856:1;853;846:12;808:52;879:29;898:9;879:29;:::i;:::-;869:39;977:2;962:18;;;;949:32;;-1:-1:-1;;;711:300:1:o;1208:226::-;1267:6;1320:2;1308:9;1299:7;1295:23;1291:32;1288:52;;;1336:1;1333;1326:12;1288:52;-1:-1:-1;1381:23:1;;1208:226;-1:-1:-1;1208:226:1:o;1621:374::-;1698:6;1706;1714;1767:2;1755:9;1746:7;1742:23;1738:32;1735:52;;;1783:1;1780;1773:12;1735:52;1806:29;1825:9;1806:29;:::i;:::-;1796:39;;1854:38;1888:2;1877:9;1873:18;1854:38;:::i;:::-;1621:374;;1844:48;;-1:-1:-1;;;1961:2:1;1946:18;;;;1933:32;;1621:374::o;2371:186::-;2430:6;2483:2;2471:9;2462:7;2458:23;2454:32;2451:52;;;2499:1;2496;2489:12;2451:52;2522:29;2541:9;2522:29;:::i;2562:1238::-;2968:3;2963;2959:13;2951:6;2947:26;2936:9;2929:45;3010:3;3005:2;2994:9;2990:18;2983:31;2910:4;3037:46;3078:3;3067:9;3063:19;3055:6;3037:46;:::i;:::-;3131:9;3123:6;3119:22;3114:2;3103:9;3099:18;3092:50;3165:33;3191:6;3183;3165:33;:::i;:::-;3229:2;3214:18;;3207:34;;;-1:-1:-1;;;;;3278:32:1;;3272:3;3257:19;;3250:61;3298:3;3327:19;;3320:35;;;3392:22;;;3386:3;3371:19;;3364:51;3464:13;;3486:22;;;3536:2;3562:15;;;;-1:-1:-1;3524:15:1;;;;-1:-1:-1;3605:169:1;3619:6;3616:1;3613:13;3605:169;;;3680:13;;3668:26;;3723:2;3749:15;;;;3714:12;;;;3641:1;3634:9;3605:169;;;-1:-1:-1;3791:3:1;;2562:1238;-1:-1:-1;;;;;;;;;;;2562:1238:1:o;3805:273::-;3861:6;3914:2;3902:9;3893:7;3889:23;3885:32;3882:52;;;3930:1;3927;3920:12;3882:52;3969:9;3956:23;4022:5;4015:13;4008:21;4001:5;3998:32;3988:60;;4044:1;4041;4034:12;4291:903;4402:6;4410;4418;4426;4434;4442;4450;4503:3;4491:9;4482:7;4478:23;4474:33;4471:53;;;4520:1;4517;4510:12;4471:53;4543:29;4562:9;4543:29;:::i;:::-;4533:39;;4591:38;4625:2;4614:9;4610:18;4591:38;:::i;:::-;4581:48;-1:-1:-1;4698:2:1;4683:18;;4670:32;;-1:-1:-1;4799:2:1;4784:18;;4771:32;;-1:-1:-1;4881:3:1;4866:19;;4853:33;4930:4;4917:18;;4905:31;;4895:59;;4950:1;4947;4940:12;4895:59;4291:903;;;;-1:-1:-1;4291:903:1;;;;4973:7;5053:3;5038:19;;5025:33;;-1:-1:-1;5157:3:1;5142:19;;;5129:33;;4291:903;-1:-1:-1;;4291:903:1:o;5199:260::-;5267:6;5275;5328:2;5316:9;5307:7;5303:23;5299:32;5296:52;;;5344:1;5341;5334:12;5296:52;5367:29;5386:9;5367:29;:::i;:::-;5357:39;;5415:38;5449:2;5438:9;5434:18;5415:38;:::i;:::-;5405:48;;5199:260;;;;;:::o;5464:380::-;5543:1;5539:12;;;;5586;;;5607:61;;5661:4;5653:6;5649:17;5639:27;;5607:61;5714:2;5706:6;5703:14;5683:18;5680:38;5677:161;;5760:10;5755:3;5751:20;5748:1;5741:31;5795:4;5792:1;5785:15;5823:4;5820:1;5813:15;5677:161;;5464:380;;;:::o;8672:127::-;8733:10;8728:3;8724:20;8721:1;8714:31;8764:4;8761:1;8754:15;8788:4;8785:1;8778:15;8804:168;8877:9;;;8908;;8925:15;;;8919:22;;8905:37;8895:71;;8946:18;;:::i;8977:217::-;9017:1;9043;9033:132;;9087:10;9082:3;9078:20;9075:1;9068:31;9122:4;9119:1;9112:15;9150:4;9147:1;9140:15;9033:132;-1:-1:-1;9179:9:1;;8977:217::o;9199:128::-;9266:9;;;9287:11;;;9284:37;;;9301:18;;:::i;10923:127::-;10984:10;10979:3;10975:20;10972:1;10965:31;11015:4;11012:1;11005:15;11039:4;11036:1;11029:15;11055:125;11120:9;;;11141:10;;;11138:36;;;11154:18;;:::i
Swarm Source
ipfs://6dba9d884d6cf0584fa59211e9619a0c9365b79b06b6376f25ef656b58844eb3
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 31 Chains
| Chain | Token | Portfolio % | Price | Amount | Value |
|---|
[ Download: CSV Export ]
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.