ETH Price: $3,632.32 (-0.26%)

Transaction Decoder

Block:
13553576 at Nov-05-2021 01:08:57 AM +UTC
Transaction Fee:
0.12116734810874468 ETH $440.12
Gas Used:
1,007,108 Gas / 120.31216921 Gwei

Emitted Events:

Account State Difference:

  Address   Before After State Difference Code
0xB17AcC8f...0DAe72c26
1.592986022686788424 Eth
Nonce: 12
1.471818674578043744 Eth
Nonce: 13
0.12116734810874468
0xE9cB6838...8e9853C02
0 Eth
Nonce: 0
0 Eth
Nonce: 1
From: 0 To: 1978800940230666353326175362672317752236742080583462816069831280564438432128341248647919750511110922544945807614117545761477385847363239265385655973644157878887086419637192608197885632532773679713524017964870422280006219611163558326352638542005376079280155310398896652241518587012062587393107168675643332415412696661671677541614570434749971212862182604548601384445906664612289264345796175510233591625883338079832029551176111898874074410913143644433902627785400740516232450430649030123482768484834777185613633949002575117849433267963559183753780047106529988430742397568362943488721869337480442157113627721337132780781651621989443968975865399479384786681896793036045072594830475471705685169523539890896242652686751858071550414936461678460449978266145343410535256270330389769015665266831619957673450895024460400025403849343107470519238369092516423170996420789059692106166702273483904568485532526903398994514393185844066878198732302535791016345851000656572993289332585530237371881594715952042475031033461441447500208358890681654597022161591205296313530321451203939315214016576344502420617676684661808531288737884014683516998807633040092743573353993190458490932633385274297528103843432256683658606174178075371738660661156480352831398041085439687126848851524229057084642388547258436817590364406043500666200928881052464957736778812912861021094541388932014088174412436597769805283218464680543334086274488725758948563269585331156703926836373033024133667929013284451404149537937852537891721747828968486810371669424076849352692785872649161198256003464819772481419822954644284813107420795119017492372243318051820069842491611201822590229830708255661437505359183418855143508469840948265951991802556278738207362611115372722739467451295059680182544375139616521301263378510886583900158516440449954137004296770915505982709393029938674179317296569242229144811953440136731995247486313164588149472147265561622432945202319815588059477669501195311310185865676211902089268297484516137994721473903412287647512804888363811630988357972394784775334244971332302161660976107786590020634236074589835330545859273196362344035913280574404824155483413314774438400619823339992524357188184027878925050942154405509028239583960304478574891683870700519643012712452796765425827318912325894928821343195683522683617918036435000315478564290033748727458883622504365943465291459138527905973985171106825157298212582425521426360000825054569333876115993036213717728588724753130496027101062948531000164793853196266345772826295787695794605288004217471558140516901728842004224571376305729334357121279808245143529519621512961727935921807321151474100608399940630816809224790559811858769961292404122660151923988615600278495342891702131490628807628078845806371199148549889438133160698608666307658050828180238183211844031052877678112614926556110236157012021988343216190269940900780672423770088044084220999905111790127098703221416739621205044900991524632202797592845773583314070134547934244007440260982766195268219810026664604270266128287585163735925084409962142811871159524477329517209622366523159377089308046314451050318403675565038001940457924010812337501050661406323482704597943992285262957227678235918440573640496556783198067490438886856751993870817628705269403664406583187156649510652705383997397196922302039884962217151929461459367838624520337024192369475632666485947458250509034800952446177099681868818593260681577421447438090274278595950742206288813066586754887920452712295903665768134857013822048236739962387798519694159846323642947527628201036282810805066585261772925439025266939643940676281074974666473875229906758124853548661634328465012716042279065404600455738236279802635488117372073395082996857591162263328136836460485190356534236319572407995867452200178154151956832297174939816215221376718779611264065419823232708316687693880680229711390058033402929082681745492101606375975613708169522342882364884770654643962181964593958276027323105418937356728242900591452100383845341448690043436551314070682640787572916861265267742110172612574016591663074761059436523375197942681562985421581430280897961404509292235638173967731661580632412872139199983405080467402601904000974174159832363492601447636319595489106795385593096678496599562785856281794394412064630495127563985653505143019273488129322892964592750235034002154631128643107987511086177717501121925434416006707610727457277472707544917156164632845652107948357049214442591336269546016218884497352254403830930399549092376377388761227709551367265216670570578466487526376537443412591674495446119463759007151587257317644971111676051458503486640303526408397922404958531945778519748593969565595906746540708565458009130523615294988861411775399460159592532917202993809207468422626025818061683859506067034023043876566181185248759423092575482510106670826149255988304700796754117932180842494390438707387002204833662956206904457074727817648714030916886626687303197227447353964623540327134524303341109456682048871712795384075836440866453764480315108629622503005292275404582906838887015729529498298113718154010842452614356647227964748437582013150056764917750699932992889195444944577221251876084989305485379377412772023552013845294669833488073575405807003146442215221301299126292182300446402070162319095499700991037478791532533243634657246553135256888475908245218092501213599328864046846458037710200134265540807404120212483485088717409132496271172740823673330108414434503189420950314516583263045180610606716576646161546237519032619865867672445330445394188918944473265663804841545588396225832375007930567526430589930470669977513052541448301242197482126014541100022577682014828251994553554909488330243713910025735338775222950514812136283864568095544671636821027092711469203783417484897251541513383780613442604853094105669478606173644424565016237897310044210415437500459187263401334561786036676512698777256046362574508069642024621239171442380864222943337504078974115972280324920282738271801959903821427334336898075341863131114248642974623199532340714112140926850521590934492282706298196877872594922904434785763329851109953641676278634344903352289067120596101786861819114382550699125650557921941449794274979344400765861316411456294778891469161974819061144377636227691408493498672412220788321356864768417952771471487326147846366326237664995195652678243468064517608870150373888100225881870866071388205311467609748848939253733590554141738365219154013752918655861820824198739969899338483958200461114088417683709953953545915528935211778414603713013097031338876491118560505750467848269586145276934054735159576111766659064169979065054695534695769359725788960915949769006324454736971026956214234189278042219028777261675287083080340719827573180025012427785916384462254062035401577035172985088145812010987602027429162653638870973026446728574192910381009091450313217860738326517930514136810574843894199948636688377753429757159100181173415695638273634488375324076807685389777947602527520886220966177158470975076496714604889508944838760192772340549513299637025011207782803850323334602408902932190107142632058259410052540343937291948771713633649364430757361099304723218581276789168880960039682617408523228595097948681555176082265299762669061972717292988004013387008928834003777498911345122778053882316121192129158421395914201078986814952147608613613087444984527694437797407673723852640716999206839912178990197372271491620690282702751043324195767566201371207691779949980441205599951183075116267619218137236984316563371959036940981110881759854699856783757390197723877575399870133420380201573322839892767563131685828728712561689928776160026929111930792067886349179004747315838629620037009981545407288626701455811971455697083944532247349916717044581257592707719072704988467333693995720145150164148529951192071158365972733782105490221699555291718206479645036313622961905500930243047863039420101175739548881627950254124014017589534490983058519095446105214510634922828132737305107372808831060867417955747830629806575173401378283804269852178296001857363752715176601142950810971835019364970263111244282123292573198021969260703024369571337845449554147304917838804974435350248525766987905553906053984397283680001377128476335353290575281564727913806757880700702598441387271209293134554720192395477045528789904355822345217204684590851891786292244107019862800517972983252579668395429766791059664574324615554994083324780191855401753440529749517412875841463161546765060797533153250636193711925652396315646855153702100102649782547323486345778663840909101373445048041382420699742692457596686343689773831497442367528166485580964625533184780646958867167025507998218308427405489386091786444532040537132168538847508106927061209677800891378454849221145506886939257320091059076542243348581924784981726504388967896349338707868513126168418372898402850659906062043401670087788535043650766548555453827788023725459759801782073270379419682310878080176536233475321616275804324976005549109115877966573200865899266254817050815982147729563057804108174814571499614399598090429169500315272370918418818577528705987589409616736631696698505158068553963175007313852187506820707515718017634403367189522923706685649347067309159486952136192735556088463152657323256928723040922725150789289332372329051716171467187118226050665021491
(Ethermine)
3,284.488013484504379437 Eth3,284.489524146504379437 Eth0.001510662

Execution Trace

StripToken.60806040( )
// Sources flattened with hardhat v2.5.0 https://hardhat.org

// File @openzeppelin/contracts/token/ERC20/[email protected]

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @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);
}


// File @openzeppelin/contracts/token/ERC20/extensions/[email protected]


pragma solidity ^0.8.0;

/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 *
 * _Available since v4.1._
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the symbol of the token.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}


// File @openzeppelin/contracts/utils/[email protected]


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/token/ERC20/[email protected]


pragma solidity ^0.8.0;



/**
 * @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, IERC20Metadata {
    mapping(address => uint256) private _balances;

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

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

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

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

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

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

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

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

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `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");
        unchecked {
            _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");
        unchecked {
            _approve(_msgSender(), spender, currentAllowance - subtractedValue);
        }

        return true;
    }

    /**
     * @dev Moves `amount` of tokens from `sender` to `recipient`.
     *
     * This internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `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");
        unchecked {
            _balances[sender] = senderBalance - amount;
        }
        _balances[recipient] += amount;

        emit Transfer(sender, recipient, amount);

        _afterTokenTransfer(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:
     *
     * - `account` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

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

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

        _afterTokenTransfer(address(0), account, amount);
    }

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

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

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

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

        _afterTokenTransfer(account, address(0), amount);
    }

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

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

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

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


// File @openzeppelin/contracts/access/[email protected]


pragma solidity ^0.8.0;

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _setOwner(_msgSender());
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _setOwner(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _setOwner(newOwner);
    }

    function _setOwner(address newOwner) private {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}


// File @openzeppelin/contracts/utils/math/[email protected]


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. 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;
        }
    }
}


// File contracts/StripToken.sol


/******************************************************************************
           ██                                                                
   ▒▓▓▒    ██     ▒▒                                                         
  ██████   ██ ▒▓█▓   ████  ██████ █████   █  ████     ███   ████   █  █    ██  
  ██████▒  ▓███▒    █▒▒▒█▒  ▒██▒▒ ██▒▒▒█  █▒ █▒▒██   █▒ ▒█  █▒▒██  █▒ ██▒  ██▒ 
   ▓██▓▒▒▓███▒      ██       ██▒  ██▒  █     █▒  █  ██▒    ██▒  █▒    ███▒ ██▒ 
      ▒██████       ▒████▒   ██▒  █████▒  █▒ ████▒  ██▒    ██▒  █▒ █▒ ██▒█▒██▒ 
    ▓█████ ▓█         ▒▒██▒  ██▒  ██▒▒██  █▒ ██▒    ██▒    ██▒  █▒ █▒ ██▒▒███▒ 
   ███████ ██      ▒█   ██▒  ██▒  ██▒  █▒ █▒ ██▒    ▒██  █ ██▒ ██▒ █▒ ██▒ ▒██▒ 
   ████████▓▓       █████▒   ██▒  ██▒  ██▒█▒ ██▒     ▒███▒  ████▒  █▒ ██▒  ▒█▒ 
    ▒███████████▓▒▒                                                          
       ▒▓█████████████▒    ===================================================
           ▓▓███████████▓       
           ██  ▒█████████▒      
           ██    ████████       Token..: STRIPCOIN
           ██  ▒███████▒        Version: 1.0
           ██▒██████▒           License: MIT
           ██████▒              
         ▒████▒                 
       ▓█████                   
    ▒▓█▓▒  ▓█                   
  ▒█▓▒     ██                   
▒▓▒        ██      
*******************************************************************************/             

pragma solidity ^0.8.0;




/**
 * @title StripToken Contract
 * @author 
 * @dev
 */

contract StripToken is ERC20, Ownable {
    using SafeMath for uint256;

    // modify token name
    string public constant NAME = 'StripCoin';
    // modify token symbol
    string public constant SYMBOL = 'STRIP';
    // modify token decimals
    uint8 public constant DECIMALS = 18;
    // modify initial token supply
    uint256 public constant TOTAL_SUPPLY = 500e9 * (10**uint256(DECIMALS)); // 500,000,000,000 tokens
    // multisig contract address
    address public multiSigAdmin;

    event MultiSigAdminUpdated(address _multiSigAdmin);

    /**
     * @dev Constructor that gives msg.sender all of existing tokens.
     */
    constructor() Ownable() ERC20(NAME, SYMBOL) {
        _mint(msg.sender, TOTAL_SUPPLY);
    }

    /**
     * @dev Override decimals() function to customize decimals
     */
    function decimals() public view virtual override returns (uint8) {
        return DECIMALS;
    }

    function setMultiSigAdminAddress(address _multiSigAdmin) external onlyOwner {
        require (_multiSigAdmin != address(0x00), "Invalid MultiSig admin address");
        multiSigAdmin = _multiSigAdmin;
        emit MultiSigAdminUpdated(multiSigAdmin);
    }
    
    /**
     * @dev Recovers the ERC20 token balance mistakenly sent to the contract. Only multisig contract can call this function
     * @param tokenAddress The token contract address
     * @param tokenAmount Number of tokens to be sent
     */
    function recoverERC20(address tokenAddress, uint256 tokenAmount) external onlyMultiSigAdmin {
        IERC20(tokenAddress).transfer(owner(), tokenAmount);
    }

    // modifier for multiSig only
    modifier onlyMultiSigAdmin() {
        require(msg.sender == multiSigAdmin, "Should be multiSig contract");
        _;
    }
}