Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT
pragma solidity >=0.4.22 <0.9.0;
pragma experimental ABIEncoderV2;

import "@openzeppelin/contracts/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";

contract ERC20Initialize is ERC20, Initializable{

    function initialize( string memory name_, string memory symbol_, uint8 decimals_ ) public initializer {
        _name = name_;
        _symbol = symbol_;
        _decimals = decimals_;
    }
    
}

contract OwnableStorage {

    address public _admin;
    address public _governance;

    constructor() payable {
        _admin = msg.sender;
        _governance = msg.sender;
    }

    function setAdmin( address account ) public {
        require( isAdmin( msg.sender ), "Not a admin" );
        _admin = account;
    }

    function setGovernance( address account ) public {
        require( isAdmin( msg.sender ) || isGovernance( msg.sender ), "Not a admin or governance" );
        _admin = account;
    }

    function isAdmin( address account ) public view returns( bool ) {
        return account == _admin;
    }

    function isGovernance( address account ) public view returns( bool ) {
        return account == _admin;
    }

}

contract Ownable{

    OwnableStorage _storage;

    function initialize( address storage_ ) public {
        _storage = OwnableStorage(storage_);
    }

    modifier OnlyAdmin(){
        require( _storage.isAdmin(msg.sender), "Not a admin" );
        _;
    }

    modifier OnlyGovernance(){
        require( _storage.isGovernance( msg.sender ), "Not a Governance" );
        _;
    }

    modifier OnlyAdminOrGovernance(){
        require( _storage.isAdmin(msg.sender) || _storage.isGovernance( msg.sender ), "Not a Admin or Governance" );
        _;
    }

    function updateAdmin( address admin_ ) public OnlyAdmin {
        _storage.setAdmin(admin_);
    }

    function updateGovenance( address gov_ ) public OnlyAdminOrGovernance {
        _storage.setGovernance(gov_);
    }

}

contract InitializableProxy is Proxy, Initializable{

    function initialize( address implAddress, bytes memory initData ) public virtual initializer{
        assert(_IMPLEMENTATION_SLOT == bytes32(uint256(keccak256("eip1967.proxy.implementation")) - 1));
        _setImplementation(implAddress);
        if(initData.length > 0) {
            Address.functionDelegateCall(implAddress, initData);
        }  
    }

    event Upgraded(address indexed implementation);

    bytes32 private constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;

    function _implementation() internal view virtual override returns (address impl) {
        bytes32 slot = _IMPLEMENTATION_SLOT;
        // solhint-disable-next-line no-inline-assembly
        assembly {
            impl := sload(slot)
        }
    }

    function _upgradeTo(address newImplementation) internal virtual {
        _setImplementation(newImplementation);
        emit Upgraded(newImplementation);
    }

    function _setImplementation(address newImplementation) private {
        require(Address.isContract(newImplementation), "ERC1967Proxy: new implementation is not a contract");

        bytes32 slot = _IMPLEMENTATION_SLOT;

        // solhint-disable-next-line no-inline-assembly
        assembly {
            sstore(slot, newImplementation)
        }
    }

}

contract PunkRewardPoolProxy is InitializableProxy{

    function initialize( address implAddress, bytes memory initData ) public override initializer{
        require(msg.sender == address(0xd82348b97d8BADd471097AD60e37B1d34fAD4BE2), "Only 0xd82348b97d8BADd471097AD60e37B1d34fAD4BE2");
        super.initialize( implAddress, initData );
    }
    
    function upgrade( address addr ) public {
        require(msg.sender == address(0xd82348b97d8BADd471097AD60e37B1d34fAD4BE2), "Only 0xd82348b97d8BADd471097AD60e37B1d34fAD4BE2");
        _upgradeTo( addr );
    }

}

contract VestingPunk is Initializable{
    using SafeMath for uint;

    address _punkToken;
    address _holder;
    
    uint _lockPeriod = 2 * 365 * 24 * 60 * 60;
    uint _startTimestamp = 1622473200;
    uint _released = 0;
    
    function initialize( address punkToken_, address holder_ ) public initializer {
        _punkToken = punkToken_;
        _holder = holder_;
    }

    function release() public {
        require( _startTimestamp <= _currentTimestamp(), "not yet Jun 01, 2021" );
        uint ableAmount = releasable();
        if( ableAmount > _currentBalance() ){
            ableAmount = _currentBalance();
        }
        IERC20( _punkToken ).transfer( _holder, ableAmount );
        _released += ableAmount;
    }

    function released() public view returns ( uint ){
        return _released;
    }

    function releasable() public view returns( uint ){
        if( _startTimestamp > _currentTimestamp() ) return 0;
        if( _currentBalance() == 0 ) return 0;
        return ( ( _currentBalance().add( _released ) ).mul( _currentTimestamp() - _startTimestamp ).div( _lockPeriod ) ).sub( _released );
    }

    function _currentBalance() private view returns( uint ){
        return IERC20( _punkToken ).balanceOf( address( this ) );
    }

    function _currentTimestamp() private view returns( uint ){
        return block.timestamp;
    }

}

contract PunkToken is ERC20Initialize, Ownable{
    using Address for address;

    function initializePunk(
            address ownableStorage,
            address airdropControlAddress,
            address earlyContributorControlAddress,
            address devFundsVestingContract, 
            address rewardPoolForSaverContract,
            address rewardPoolForFutureProduct1Contract,
            address rewardPoolForFutureProduct2Contract
            ) public {

        require(Address.isContract(devFundsVestingContract), "devFundsVestingContract is not Contract address");
        require(Address.isContract(rewardPoolForSaverContract), "rewardPoolForSaverContract is not Contract address");
        require(Address.isContract(rewardPoolForFutureProduct1Contract), "rewardPoolForFutureProduct1Contract is not Contract address");
        require(Address.isContract(rewardPoolForFutureProduct2Contract), "rewardPoolForFutureProduct2Contract is not Contract address");

        Ownable.initialize( ownableStorage );

        ERC20Initialize.initialize(
            "Punk Token",
            "PUNK",
            18);
        
        _mint( airdropControlAddress, 2100000e18 );

        _mint( earlyContributorControlAddress, 2100000e18 );
        _mint( devFundsVestingContract, 2100000e18 );
        
        _mint( rewardPoolForSaverContract, 10500000e18 );
        _mint( rewardPoolForFutureProduct1Contract, 2100000e18 );
        _mint( rewardPoolForFutureProduct2Contract, 2100000e18 );

    }

    function setDecimals( uint8 decimals_ ) public OnlyAdmin {
        require(decimals_ != decimals(), "Equals Decimals");
        _decimals = decimals_;
    }
}

// Not Ready
contract PunkRewardPool is Ownable, Initializable{
    using SafeMath for uint;
    using SafeERC20 for IERC20;

    IERC20 _punkToken;

    uint startBlock;
    uint blockYear = 4 * 60 * 24 * 365;
    
    uint initialEvent = 4 * 60 * 24 * 7 * 4;
    uint eventWeight = 2;
    uint normalWeight = 3;

    uint _weightSum;
    uint released;

    address [] _products;
    mapping ( address => bool ) _checkProducts;
    mapping ( address => uint ) _totalSupply;
    mapping ( address => uint ) _weight;
    
    mapping ( address => mapping( address=>uint ) ) _balances;
    mapping ( address => mapping( address=>uint ) ) _updateTimes;
    mapping ( address => mapping( address=>uint ) ) _perBlock;

    mapping ( address => mapping( address=>uint ) ) _released_per_products;


    modifier checkProduct( address productAddr ){
        require(_checkProducts[productAddr]);
        _;
    }

    function initializeRewardPool( address punkToken_ ) public initializer{
        _punkToken = IERC20(punkToken_);
        blockYear = 4 * 60 * 24 * 365;
        initialEvent = 4 * 60 * 24 * 7 * 4;
        eventWeight = 2;
        normalWeight = 3;
        _weightSum = 0;
        released = 0;
    }
    
    function enterRewardPool( address productAddr, uint amounts ) public checkProduct( productAddr ){
        IERC20( productAddr ).safeTransferFrom( msg.sender, address(this), amounts );
        _totalSupply[productAddr] = _totalSupply[productAddr].add( amounts );
        _balances[productAddr][msg.sender] = _balances[productAddr][msg.sender].add( amounts );
    }

    function exitRewardPool( address productAddr, uint amounts ) public checkProduct( productAddr ){
        IERC20( productAddr ).safeTransfer( msg.sender, amounts );
        _totalSupply[productAddr] = _totalSupply[productAddr].sub( amounts );
        _balances[productAddr][msg.sender] = _balances[productAddr][msg.sender].sub( amounts );
    }

    function addProduct( address productAddr ) public {
        require(!_checkProducts[productAddr], "Already adding product");
        require(IERC20(productAddr).totalSupply() > 0, "is Empty token");

        if( _products.length == 0 ) startBlock = block.number;
        
        _products.push( productAddr );
        _checkProducts[productAddr] = true;
    }

    function getStartBlock(  ) public view returns ( uint ){
        return startBlock;
    }

    function products() public view returns( address [] memory  ){
        return _products;
    }

    function updateWeights( address [] calldata productAddrs, uint [] calldata weights ) public {
        require( productAddrs.length == weights.length );
        require( productAddrs.length == _products.length );

        _weightSum = 0;
        for( uint i = 0 ; i < productAddrs.length ; i++ ){
            _weight[productAddrs[i]] = weights[i];
            _weightSum += weights[i];
        }
    }

    function getRewardFromBlock( ) public view returns( uint ){
        if( block.number.sub(startBlock) < initialEvent ){
            // Events
            uint totalDistribution =_punkToken.balanceOf(address(this)).add( released ).mul( eventWeight ).div( eventWeight.add( normalWeight ) );
            
            return totalDistribution;
            
        }else{

            uint totalDistribution =_punkToken.balanceOf(address(this)).add( released ).mul( normalWeight ).div( eventWeight.add( normalWeight ) );
            uint period = block.number.sub( startBlock.add( initialEvent ) ).div( blockYear.mul(4) ).add( 1 );

            return totalDistribution.div( period.mul( 2 ) );
        }

        // return block.number.sub( fromBlock ).mul(origin).div( getPeriod().mul( 2 ) ).div( 4 ).div( blockYear );
    }
    
    function getPeriod( ) public view returns ( uint ){
        return block.number.sub( startBlock ).div( blockYear.mul(4) ).add( 1 );
    }

    function getRewardFromBlockEvent( uint fromBlock ) public view returns( uint ){
        uint period = block.number.sub(startBlock).div( blockYear.mul(4) ).add( 1 ).mul( 2 );
        uint origin = _punkToken.balanceOf(address(this)).add( released );
        return block.number.sub( fromBlock ).mul(origin).div( period ).div( 4 ).div( blockYear );
    }

    function transfer( address to, uint amount ) public returns(bool){
        _punkToken.safeTransfer(to, amount);
        return true;
    }

    function balanceOf( address addr ) public view returns( uint ) {
        return _punkToken.balanceOf(addr);
    }

    function totalSupply( address addr, address addr2 ) public view returns( uint ){
        return _perBlock[addr][addr2];
    }

}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "../Proxy.sol";
import "../../utils/Address.sol";

/**
 * @dev This contract implements an upgradeable proxy. It is upgradeable because calls are delegated to an
 * implementation address that can be changed. This address is stored in storage in the location specified by
 * https://eips.ethereum.org/EIPS/eip-1967[EIP1967], so that it doesn't conflict with the storage layout of the
 * implementation behind the proxy.
 *
 * Upgradeability is only provided internally through {_upgradeTo}. For an externally upgradeable proxy see
 * {TransparentUpgradeableProxy}.
 */
contract ERC1967Proxy is Proxy {
    /**
     * @dev Initializes the upgradeable proxy with an initial implementation specified by `_logic`.
     *
     * If `_data` is nonempty, it's used as data in a delegate call to `_logic`. This will typically be an encoded
     * function call, and allows initializating the storage of the proxy like a Solidity constructor.
     */
    constructor(address _logic, bytes memory _data) payable {
        assert(_IMPLEMENTATION_SLOT == bytes32(uint256(keccak256("eip1967.proxy.implementation")) - 1));
        _setImplementation(_logic);
        if(_data.length > 0) {
            Address.functionDelegateCall(_logic, _data);
        }
    }

    /**
     * @dev Emitted when the implementation is upgraded.
     */
    event Upgraded(address indexed implementation);

    /**
     * @dev Storage slot with the address of the current implementation.
     * This is the keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1, and is
     * validated in the constructor.
     */
    bytes32 private constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;

    /**
     * @dev Returns the current implementation address.
     */
    function _implementation() internal view virtual override returns (address impl) {
        bytes32 slot = _IMPLEMENTATION_SLOT;
        // solhint-disable-next-line no-inline-assembly
        assembly {
            impl := sload(slot)
        }
    }

    /**
     * @dev Upgrades the proxy to a new implementation.
     *
     * Emits an {Upgraded} event.
     */
    function _upgradeTo(address newImplementation) internal virtual {
        _setImplementation(newImplementation);
        emit Upgraded(newImplementation);
    }

    /**
     * @dev Stores a new address in the EIP1967 implementation slot.
     */
    function _setImplementation(address newImplementation) private {
        require(Address.isContract(newImplementation), "ERC1967Proxy: new implementation is not a contract");

        bytes32 slot = _IMPLEMENTATION_SLOT;

        // solhint-disable-next-line no-inline-assembly
        assembly {
            sstore(slot, newImplementation)
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM
 * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to
 * be specified by overriding the virtual {_implementation} function.
 *
 * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a
 * different contract through the {_delegate} function.
 *
 * The success and return data of the delegated call will be returned back to the caller of the proxy.
 */
abstract contract Proxy {
    /**
     * @dev Delegates the current call to `implementation`.
     *
     * This function does not return to its internall call site, it will return directly to the external caller.
     */
    function _delegate(address implementation) internal virtual {
        // solhint-disable-next-line no-inline-assembly
        assembly {
            // Copy msg.data. We take full control of memory in this inline assembly
            // block because it will not return to Solidity code. We overwrite the
            // Solidity scratch pad at memory position 0.
            calldatacopy(0, 0, calldatasize())

            // Call the implementation.
            // out and outsize are 0 because we don't know the size yet.
            let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)

            // Copy the returned data.
            returndatacopy(0, 0, returndatasize())

            switch result
            // delegatecall returns 0 on error.
            case 0 { revert(0, returndatasize()) }
            default { return(0, returndatasize()) }
        }
    }

    /**
     * @dev This is a virtual function that should be overriden so it returns the address to which the fallback function
     * and {_fallback} should delegate.
     */
    function _implementation() internal view virtual returns (address);

    /**
     * @dev Delegates the current call to the address returned by `_implementation()`.
     *
     * This function does not return to its internall call site, it will return directly to the external caller.
     */
    function _fallback() internal virtual {
        _beforeFallback();
        _delegate(_implementation());
    }

    /**
     * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other
     * function in the contract matches the call data.
     */
    fallback () external payable virtual {
        _fallback();
    }

    /**
     * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data
     * is empty.
     */
    receive () external payable virtual {
        _fallback();
    }

    /**
     * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`
     * call, or as part of the Solidity `fallback` or `receive` functions.
     *
     * If overriden should call `super._beforeFallback()`.
     */
    function _beforeFallback() internal virtual {
    }
}

// SPDX-License-Identifier: MIT

// solhint-disable-next-line compiler-version
pragma solidity ^0.8.0;

import "../../utils/Address.sol";

/**
 * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
 * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an
 * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
 * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
 *
 * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
 * possible by providing the encoded function call as the `_data` argument to {UpgradeableProxy-constructor}.
 *
 * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
 * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
 */
abstract contract Initializable {

    /**
     * @dev Indicates that the contract has been initialized.
     */
    bool private _initialized;

    /**
     * @dev Indicates that the contract is in the process of being initialized.
     */
    bool private _initializing;

    /**
     * @dev Modifier to protect an initializer function from being invoked twice.
     */
    modifier initializer() {
        require(_initializing || !_initialized, "Initializable: contract is already initialized");

        bool isTopLevelCall = !_initializing;
        if (isTopLevelCall) {
            _initializing = true;
            _initialized = true;
        }

        _;

        if (isTopLevelCall) {
            _initializing = false;
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IERC20.sol";
import "../../utils/Context.sol";

/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin guidelines: functions revert instead
 * of returning `false` on failure. This behavior is nonetheless conventional
 * and does not conflict with the expectations of ERC20 applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20 is Context, IERC20 {
    mapping (address => uint256) private _balances;

    mapping (address => mapping (address => uint256)) private _allowances;

    uint256 private _totalSupply;

    string internal _name;
    string internal _symbol;
    uint8 internal _decimals;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * The defaut value of {decimals} is 18. To select a different value for
     * {decimals} you should overload it.
     *
     * All three of these values are immutable: they can only be set once during
     * construction.
     */
    constructor () {
        // _name = name_;
        // _symbol = symbol_;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5,05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the value {ERC20} uses, unless this function is
     * overloaded;
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view virtual override returns (uint8) {
        return _decimals;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual override returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `recipient` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view virtual override returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        _approve(_msgSender(), spender, amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * Requirements:
     *
     * - `sender` and `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     * - the caller must have allowance for ``sender``'s tokens of at least
     * `amount`.
     */
    function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(sender, recipient, amount);

        uint256 currentAllowance = _allowances[sender][_msgSender()];
        require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
        _approve(sender, _msgSender(), currentAllowance - amount);

        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        uint256 currentAllowance = _allowances[_msgSender()][spender];
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        _approve(_msgSender(), spender, currentAllowance - subtractedValue);

        return true;
    }

    /**
     * @dev Moves tokens `amount` from `sender` to `recipient`.
     *
     * This is internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `sender` cannot be the zero address.
     * - `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     */
    function _transfer(address sender, address recipient, uint256 amount) internal virtual {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(sender, recipient, amount);

        uint256 senderBalance = _balances[sender];
        require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
        _balances[sender] = senderBalance - amount;
        _balances[recipient] += amount;

        emit Transfer(sender, recipient, amount);
    }

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

        _totalSupply += amount;
        _balances[account] += amount;
        emit Transfer(address(0), account, amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        _balances[account] = accountBalance - amount;
        _totalSupply -= amount;

        emit Transfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(address owner, address spender, uint256 amount) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    /**
     * @dev Hook that is called before any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * will be to transferred to `to`.
     * - when `from` is zero, `amount` tokens will be minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {

    function decimals() external view returns (uint8);
    function name() external view returns (string memory);
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

    /**
     * @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);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "../IERC20.sol";
import "../../../utils/Address.sol";

/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using Address for address;

    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(IERC20 token, address spender, uint256 value) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        // solhint-disable-next-line max-line-length
        require((value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender) + value;
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        unchecked {
            uint256 oldAllowance = token.allowance(address(this), spender);
            require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
            uint256 newAllowance = oldAllowance - value;
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
        }
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
        if (returndata.length > 0) { // Return data is optional
            // solhint-disable-next-line max-line-length
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        // solhint-disable-next-line no-inline-assembly
        assembly { size := extcodesize(account) }
        return size > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (bool success, ) = recipient.call{ value: amount }("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain`call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
      return functionCall(target, data, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        require(isContract(target), "Address: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{ value: value }(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.staticcall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
        require(isContract(target), "Address: delegate call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

// SPDX-License-Identifier: MIT

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) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler
 * now has built in overflow checking.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the substraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        return a + b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return a - b;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        return a * b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        unchecked {
            require(b <= a, errorMessage);
            return a - b;
        }
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a / b;
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}

{
  "remappings": [],
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "evmVersion": "byzantium",
  "libraries": {},
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":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"},{"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":"amount","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":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"name_","type":"string"},{"internalType":"string","name":"symbol_","type":"string"},{"internalType":"uint8","name":"decimals_","type":"uint8"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"storage_","type":"address"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"ownableStorage","type":"address"},{"internalType":"address","name":"airdropControlAddress","type":"address"},{"internalType":"address","name":"earlyContributorControlAddress","type":"address"},{"internalType":"address","name":"devFundsVestingContract","type":"address"},{"internalType":"address","name":"rewardPoolForSaverContract","type":"address"},{"internalType":"address","name":"rewardPoolForFutureProduct1Contract","type":"address"},{"internalType":"address","name":"rewardPoolForFutureProduct2Contract","type":"address"}],"name":"initializePunk","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint8","name":"decimals_","type":"uint8"}],"name":"setDecimals","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"admin_","type":"address"}],"name":"updateAdmin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"gov_","type":"address"}],"name":"updateGovenance","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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