Contract 0x87E3d326A72946624d3B95d96cBC132D78E4acee

 
Txn Hash Method
Block
From
To
Value [Txn Fee]
0xc111c6fe43592ce15246bc440ce988fa9de9af638cca67e16ddc69adcd83a931Approve485200572022-10-06 2:44:054 hrs 7 mins ago0x7cbe48679402d0e89eb7a89120f691c03f1baf9e IN  0x87e3d326a72946624d3b95d96cbc132d78e4acee0 FTM0.0001166925
0xae75bef64ea688f744ba1d5dffde7a2ee785f33fd60a6a785e4b82af2c7e4b9fApprove485200042022-10-06 2:43:124 hrs 8 mins ago0xb8b5123022a8645f55a210b098e97379ad8a609f IN  0x87e3d326a72946624d3b95d96cbc132d78e4acee0 FTM0.0001167225
0xfb7b7ff4765300c0e07365168c7e0318dfbbad90f0dac1a01fe04276c3a94a49Approve484663012022-10-05 10:21:5220 hrs 30 mins ago0xc21f167bc57e1b82931f3398bfd1ec656310ed89 IN  0x87e3d326a72946624d3b95d96cbc132d78e4acee0 FTM0.0001167525
0xd1c3584c9e7ddb637ba9bcd1a6cfb9252268badaacfb88fa83100877de75c551Approve483947402022-10-04 12:03:101 day 18 hrs ago0x1deec8dd56ba410ecf77198764aede4d8f5d0937 IN  0x87e3d326a72946624d3b95d96cbc132d78e4acee0 FTM0.0001167225
0x8c0217f37a44808d14c6493e3dc2b8af1f196a413978d807a67be00d23b76cbdApprove483676302022-10-04 3:44:282 days 3 hrs ago0x5864f49955e04c02a7b959a783aa740ad4151cad IN  0x87e3d326a72946624d3b95d96cbc132d78e4acee0 FTM0.00513579
0xae5b7ced3d887ab4d16d19a79edc3e82939db0a2df980c948272cb7cdfc6ba0eApprove483189032022-10-03 12:23:412 days 18 hrs ago0x7df6d31be5962bf3a03ba3ef1ae426ab1dd18e16 IN  0x87e3d326a72946624d3b95d96cbc132d78e4acee0 FTM0.026448777026
0xaf07003397a91480cbc23a89378133f9d87b38c22552f6dae9b2d7581549ab0aApprove483011092022-10-03 6:59:302 days 23 hrs ago0xe61622c40d2fc8efb367f5e192e3c2f83b8d2e3f IN  0x87e3d326a72946624d3b95d96cbc132d78e4acee0 FTM0.0001167525
0x009ad236a24ade1e805813751e94a48d32717fc10e97a84632e71e20b841f6ccApprove482528752022-10-02 15:36:433 days 15 hrs ago0x52609f5054a1cd8e44777944e0ea9843b65ae58b IN  0x87e3d326a72946624d3b95d96cbc132d78e4acee0 FTM0.000119835099
0xb01488e45c84102695943b60097f98702c05e875f333a88cd642ad18936ddae7Approve482525972022-10-02 15:31:483 days 15 hrs ago0xf65e07e68568cd06beec5534460d3f45e4c039c1 IN  0x87e3d326a72946624d3b95d96cbc132d78e4acee0 FTM0.000093378
0xc21451099b19aef0c7526789930ec1318e921e93a31fe696b272362cc154d163Approve482451332022-10-02 13:18:263 days 17 hrs ago0x7cbe48679402d0e89eb7a89120f691c03f1baf9e IN  0x87e3d326a72946624d3b95d96cbc132d78e4acee0 FTM0.000116979594
0x20a4d97f185c8d6c6c15d88d2cdd2d1d744e5a6010ca631d9c47b530b36fc9cbApprove482449472022-10-02 13:15:193 days 17 hrs ago0xb8b5123022a8645f55a210b098e97379ad8a609f IN  0x87e3d326a72946624d3b95d96cbc132d78e4acee0 FTM0.000117009667
0xda08f67baa1815a7463768b65beca2fafe4ffa144d958dc36a9fbc0a63e4b1ceTransfer482302862022-10-02 8:28:203 days 22 hrs ago0x2c51d8b98363e69e6100019ab1c9cc1a52b7cb17 IN  0x87e3d326a72946624d3b95d96cbc132d78e4acee0 FTM0.0017257756
0x44e14ee191ea3e80774a48d72eb909300c244c7bb6b818d31a322240b157841bApprove481426242022-10-01 5:24:235 days 1 hr ago0x38d1f7e7426788ad049683f2523582f4ba807bf1 IN  0x87e3d326a72946624d3b95d96cbc132d78e4acee0 FTM0.0001167525
0x65907e2e38308bd9d84c83bef4bebba79bfa8dbae4159a98478cd1d41c27e90bApprove481424232022-10-01 5:20:495 days 1 hr ago0x4505a79242845605add9eb546220008de42c5f8d IN  0x87e3d326a72946624d3b95d96cbc132d78e4acee0 FTM0.0001167225
0x9eebc578c3b270d66000d8d69ff0873e516568c7e749d4439e009e52969607e8Approve481422212022-10-01 5:17:025 days 1 hr ago0x944c94ba454764fc3217d4131bce737f01f6a3b9 IN  0x87e3d326a72946624d3b95d96cbc132d78e4acee0 FTM0.0001167225
0x44cda267f61b46e8742eeb72c470ccef54cde41b04081d89fb57e10fbe42254bApprove480665392022-09-30 5:24:426 days 1 hr ago0x1707d27f6818cf4e51b83413f49e2cbf49f6cb71 IN  0x87e3d326a72946624d3b95d96cbc132d78e4acee0 FTM0.0001166925
0x4312cb273e67b61168f84c05d51d52db9ede6c4619939adb2b588dd1d76778faApprove480225152022-09-29 15:55:316 days 14 hrs ago0xd1125c7c8d0c45283ef77764f458079c425f604c IN  0x87e3d326a72946624d3b95d96cbc132d78e4acee0 FTM0.000131853429
0x473ec4940d36f8570651ce99b509122c47192be61246b6b33cc64f5a99bed5a9Approve480223932022-09-29 15:53:126 days 14 hrs ago0x574fea1046ca7baf770e48871a75de9b8bee84d3 IN  0x87e3d326a72946624d3b95d96cbc132d78e4acee0 FTM0.001689350326
0x08f14ff87471a1418ffce4e760ef5b8d22067df1c608bc815e4f2691d116496fApprove480205762022-09-29 15:12:286 days 15 hrs ago0x7cbe48679402d0e89eb7a89120f691c03f1baf9e IN  0x87e3d326a72946624d3b95d96cbc132d78e4acee0 FTM0.000122240976
0x589cc61be53d408fb4e9a4a193b5a5c5aeefc62d399e1ef73caa0f23314edf08Approve480204822022-09-29 15:10:366 days 15 hrs ago0xb8b5123022a8645f55a210b098e97379ad8a609f IN  0x87e3d326a72946624d3b95d96cbc132d78e4acee0 FTM0.000123585326
0x7fb41c66b4720f98396ce3d083aaea8c79e9190b97ed8691de0de10bb781904bApprove479075602022-09-28 2:29:348 days 4 hrs ago0x91c503cf9b576096f19c1e26bba5b654637ceae8 IN  0x87e3d326a72946624d3b95d96cbc132d78e4acee0 FTM0.000129302977
0x7345bb01d9fc23fe40bc7c9c8af050472124cb2e8ef37d0fecde2cc4c5d68249Approve478619932022-09-27 11:35:098 days 19 hrs ago0x1deec8dd56ba410ecf77198764aede4d8f5d0937 IN  0x87e3d326a72946624d3b95d96cbc132d78e4acee0 FTM0.0001167225
0x1d5bd651adebe7a0d02f400cdd6cd7bd3a574863ebb01782ecfbb9c143b47441Approve478514462022-09-27 8:21:298 days 22 hrs ago0x3c1f25c92fbeb553e74be9c1171f8134e3aa2f69 IN  0x87e3d326a72946624d3b95d96cbc132d78e4acee0 FTM0.0001167525
0x4ed039583cc5cb1ef36b1ff454bce5fe7993220aca205295e04686ae31e707bdTransfer478435482022-09-27 5:49:259 days 1 hr ago0xf78a055c90251afbb83b9073e25b513d628379ef IN  0x87e3d326a72946624d3b95d96cbc132d78e4acee0 FTM0.000085915
0xff569076ebde17c8c7725740b49a4a26432289c8570dcaeaaa0850744ca72210Approve478243092022-09-26 23:36:079 days 7 hrs ago0x7cbe48679402d0e89eb7a89120f691c03f1baf9e IN  0x87e3d326a72946624d3b95d96cbc132d78e4acee0 FTM0.0001166925
[ Download CSV Export 
Latest 1 internal transaction
Parent Txn Hash Block From To Value
0xc638bf26f4d1d2de030abee8e5c71f072c2070d5246e7ebe4568d74f6607dab8406900872022-06-17 3:49:11111 days 3 hrs ago 0xe9d4c6982cc08f16ec8875873820b1389b3f3bad  Contract Creation0 FTM
[ Download CSV Export 
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
DRUGERC20Token

Compiler Version
v0.7.5+commit.eb77ed08

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, None license

Contract Source Code (Solidity)

/**
 *Submitted for verification at FtmScan.com on 2022-06-17
*/

/**
 *Submitted for verification at Etherscan.io on 2021-03-21
 */

// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;

/**
 * @dev Intended to update the TWAP for a token based on accepting an update call from that token.
 *  expectation is to have this happen in the _beforeTokenTransfer function of ERC20.
 *  Provides a method for a token to register its price sourve adaptor.
 *  Provides a function for a token to register its TWAP updater. Defaults to token itself.
 *  Provides a function a tokent to set its TWAP epoch.
 *  Implements automatic closeing and opening up a TWAP epoch when epoch ends.
 *  Provides a function to report the TWAP from the last epoch when passed a token address.
 */
interface ITWAPOracle {
    function uniV2CompPairAddressForLastEpochUpdateBlockTimstamp(address)
        external
        returns (uint32);

    function priceTokenAddressForPricingTokenAddressForLastEpochUpdateBlockTimstamp(
        address tokenToPrice_,
        address tokenForPriceComparison_,
        uint256 epochPeriod_
    ) external returns (uint32);

    function pricedTokenForPricingTokenForEpochPeriodForPrice(
        address,
        address,
        uint256
    ) external returns (uint256);

    function pricedTokenForPricingTokenForEpochPeriodForLastEpochPrice(
        address,
        address,
        uint256
    ) external returns (uint256);

    function updateTWAP(
        address uniV2CompatPairAddressToUpdate_,
        uint256 eopchPeriodToUpdate_
    ) external returns (bool);
}

library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.
    struct Set {
        // Storage of set values
        bytes32[] _values;
        // Position of the value in the `values` array, plus 1 because index 0
        // means a value is not in the set.
        mapping(bytes32 => uint256) _indexes;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._indexes[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We read and store the value's index to prevent multiple reads from the same storage slot
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) {
            // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = valueIndex - 1;
            uint256 lastIndex = set._values.length - 1;

            // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs
            // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.

            bytes32 lastvalue = set._values[lastIndex];

            // Move the last value to the index where the value to delete is
            set._values[toDeleteIndex] = lastvalue;
            // Update the index for the moved value
            set._indexes[lastvalue] = toDeleteIndex + 1;
            // All indexes are 1-based

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the index for the deleted slot
            delete set._indexes[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value)
        private
        view
        returns (bool)
    {
        return set._indexes[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function _at(Set storage set, uint256 index)
        private
        view
        returns (bytes32)
    {
        require(
            set._values.length > index,
            "EnumerableSet: index out of bounds"
        );
        return set._values[index];
    }

    function _getValues(Set storage set_)
        private
        view
        returns (bytes32[] storage)
    {
        return set_._values;
    }

    // TODO needs insert function that maintains order.
    // TODO needs NatSpec documentation comment.
    /**
     * Inserts new value by moving existing value at provided index to end of array and setting provided value at provided index
     */
    function _insert(
        Set storage set_,
        uint256 index_,
        bytes32 valueToInsert_
    ) private returns (bool) {
        require(set_._values.length > index_);
        require(
            !_contains(set_, valueToInsert_),
            "Remove value you wish to insert if you wish to reorder array."
        );
        bytes32 existingValue_ = _at(set_, index_);
        set_._values[index_] = valueToInsert_;
        return _add(set_, existingValue_);
    }

    struct Bytes4Set {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(Bytes4Set storage set, bytes4 value) internal returns (bool) {
        return _add(set._inner, value);
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(Bytes4Set storage set, bytes4 value)
        internal
        returns (bool)
    {
        return _remove(set._inner, value);
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(Bytes4Set storage set, bytes4 value)
        internal
        view
        returns (bool)
    {
        return _contains(set._inner, value);
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function length(Bytes4Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(Bytes4Set storage set, uint256 index)
        internal
        view
        returns (bytes4)
    {
        return bytes4(_at(set._inner, index));
    }

    function getValues(Bytes4Set storage set_)
        internal
        view
        returns (bytes4[] memory)
    {
        bytes4[] memory bytes4Array_;
        for (
            uint256 iteration_ = 0;
            _length(set_._inner) > iteration_;
            iteration_++
        ) {
            bytes4Array_[iteration_] = bytes4(_at(set_._inner, iteration_));
        }
        return bytes4Array_;
    }

    function insert(
        Bytes4Set storage set_,
        uint256 index_,
        bytes4 valueToInsert_
    ) internal returns (bool) {
        return _insert(set_._inner, index_, valueToInsert_);
    }

    struct Bytes32Set {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(Bytes32Set storage set, bytes32 value)
        internal
        returns (bool)
    {
        return _add(set._inner, value);
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(Bytes32Set storage set, bytes32 value)
        internal
        returns (bool)
    {
        return _remove(set._inner, value);
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(Bytes32Set storage set, bytes32 value)
        internal
        view
        returns (bool)
    {
        return _contains(set._inner, value);
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(Bytes32Set storage set, uint256 index)
        internal
        view
        returns (bytes32)
    {
        return _at(set._inner, index);
    }

    function getValues(Bytes32Set storage set_)
        internal
        view
        returns (bytes4[] memory)
    {
        bytes4[] memory bytes4Array_;

        for (
            uint256 iteration_ = 0;
            _length(set_._inner) >= iteration_;
            iteration_++
        ) {
            bytes4Array_[iteration_] = bytes4(at(set_, iteration_));
        }

        return bytes4Array_;
    }

    function insert(
        Bytes32Set storage set_,
        uint256 index_,
        bytes32 valueToInsert_
    ) internal returns (bool) {
        return _insert(set_._inner, index_, valueToInsert_);
    }

    // AddressSet
    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value)
        internal
        returns (bool)
    {
        return _add(set._inner, bytes32(uint256(value)));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value)
        internal
        returns (bool)
    {
        return _remove(set._inner, bytes32(uint256(value)));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value)
        internal
        view
        returns (bool)
    {
        return _contains(set._inner, bytes32(uint256(value)));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(AddressSet storage set, uint256 index)
        internal
        view
        returns (address)
    {
        return address(uint256(_at(set._inner, index)));
    }

    /**
     * TODO Might require explicit conversion of bytes32[] to address[].
     *  Might require iteration.
     */
    function getValues(AddressSet storage set_)
        internal
        view
        returns (address[] memory)
    {
        address[] memory addressArray;

        for (
            uint256 iteration_ = 0;
            _length(set_._inner) >= iteration_;
            iteration_++
        ) {
            addressArray[iteration_] = at(set_, iteration_);
        }

        return addressArray;
    }

    function insert(
        AddressSet storage set_,
        uint256 index_,
        address valueToInsert_
    ) internal returns (bool) {
        return _insert(set_._inner, index_, bytes32(uint256(valueToInsert_)));
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value)
        internal
        returns (bool)
    {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value)
        internal
        view
        returns (bool)
    {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(UintSet storage set, uint256 index)
        internal
        view
        returns (uint256)
    {
        return uint256(_at(set._inner, index));
    }

    struct UInt256Set {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UInt256Set storage set, uint256 value)
        internal
        returns (bool)
    {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UInt256Set storage set, uint256 value)
        internal
        returns (bool)
    {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UInt256Set storage set, uint256 value)
        internal
        view
        returns (bool)
    {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function length(UInt256Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(UInt256Set storage set, uint256 index)
        internal
        view
        returns (uint256)
    {
        return uint256(_at(set._inner, index));
    }
}

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

library SafeMath {
    /**
     * @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) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    /**
     * @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 sub(a, b, "SafeMath: subtraction overflow");
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

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

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts 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) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts 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) {
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts 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 mod(a, b, "SafeMath: modulo by zero");
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts with custom message 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,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }

    // babylonian method (https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method)
    function sqrrt(uint256 a) internal pure returns (uint256 c) {
        if (a > 3) {
            c = a;
            uint256 b = add(div(a, 2), 1);
            while (b < c) {
                c = b;
                b = div(add(div(a, b), b), 2);
            }
        } else if (a != 0) {
            c = 1;
        }
    }

    /*
     * Expects percentage to be trailed by 00,
     */
    function percentageAmount(uint256 total_, uint8 percentage_)
        internal
        pure
        returns (uint256 percentAmount_)
    {
        return div(mul(total_, percentage_), 1000);
    }

    /*
     * Expects percentage to be trailed by 00,
     */
    function substractPercentage(uint256 total_, uint8 percentageToSub_)
        internal
        pure
        returns (uint256 result_)
    {
        return sub(total_, div(mul(total_, percentageToSub_), 1000));
    }

    function percentageOfTotal(uint256 part_, uint256 total_)
        internal
        pure
        returns (uint256 percent_)
    {
        return div(mul(part_, 100), total_);
    }

    /**
     * Taken from Hypersonic https://github.com/M2629/HyperSonic/blob/main/Math.sol
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow, so we distribute
        return (a / 2) + (b / 2) + (((a % 2) + (b % 2)) / 2);
    }

    function quadraticPricing(uint256 payment_, uint256 multiplier_)
        internal
        pure
        returns (uint256)
    {
        return sqrrt(mul(multiplier_, payment_));
    }

    function bondingCurve(uint256 supply_, uint256 multiplier_)
        internal
        pure
        returns (uint256)
    {
        return mul(multiplier_, supply_);
    }
}

abstract contract ERC20 is IERC20 {
    using SafeMath for uint256;

    // TODO comment actual hash value.
    bytes32 private constant ERC20TOKEN_ERC1820_INTERFACE_ID =
        keccak256("ERC20Token");

    // Present in ERC777
    mapping(address => uint256) internal _balances;

    // Present in ERC777
    mapping(address => mapping(address => uint256)) internal _allowances;

    // Present in ERC777
    uint256 internal _totalSupply;

    // Present in ERC777
    string internal _name;

    // Present in ERC777
    string internal _symbol;

    // Present in ERC777
    uint8 internal _decimals;

    /**
     * @dev Sets the values for {name} and {symbol}, initializes {decimals} with
     * a default value of 18.
     *
     * To select a different value for {decimals}, use {_setupDecimals}.
     *
     * All three of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(
        string memory name_,
        string memory symbol_,
        uint8 decimals_
    ) {
        _name = name_;
        _symbol = symbol_;
        _decimals = decimals_;
    }

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

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    // Present in ERC777
    function symbol() public view 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 {_setupDecimals} is
     * called.
     *
     * 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}.
     */
    // Present in ERC777
    function decimals() public view returns (uint8) {
        return _decimals;
    }

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

    /**
     * @dev See {IERC20-balanceOf}.
     */
    // Present in ERC777
    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`.
     */
    // Overrideen in ERC777
    // Confirm that this behavior changes
    function transfer(address recipient, uint256 amount)
        public
        virtual
        override
        returns (bool)
    {
        _transfer(msg.sender, recipient, amount);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    // Present in ERC777
    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.
     */
    // Present in ERC777
    function approve(address spender, uint256 amount)
        public
        virtual
        override
        returns (bool)
    {
        _approve(msg.sender, 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`.
     */
    // Present in ERC777
    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) public virtual override returns (bool) {
        _transfer(sender, recipient, amount);
        _approve(
            sender,
            msg.sender,
            _allowances[sender][msg.sender].sub(
                amount,
                "ERC20: transfer amount exceeds allowance"
            )
        );
        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(
            msg.sender,
            spender,
            _allowances[msg.sender][spender].add(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)
    {
        _approve(
            msg.sender,
            spender,
            _allowances[msg.sender][spender].sub(
                subtractedValue,
                "ERC20: decreased allowance below zero"
            )
        );
        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);

        _balances[sender] = _balances[sender].sub(
            amount,
            "ERC20: transfer amount exceeds balance"
        );
        _balances[recipient] = _balances[recipient].add(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.
     */
    // Present in ERC777
    function _mint(address account_, uint256 amount_) internal virtual {
        require(account_ != address(0), "ERC20: mint to the zero address");
        _beforeTokenTransfer(address(this), account_, amount_);
        _totalSupply = _totalSupply.add(amount_);
        _balances[account_] = _balances[account_].add(amount_);
        emit Transfer(address(this), 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.
     */
    // Present in ERC777
    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

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

        _balances[account] = _balances[account].sub(
            amount,
            "ERC20: burn amount exceeds balance"
        );
        _totalSupply = _totalSupply.sub(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.
     */
    // Present in ERC777
    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 Sets {decimals} to a value other than the default one of 18.
     *
     * WARNING: This function should only be called from the constructor. Most
     * applications that interact with token contracts will not expect
     * {decimals} to ever change, and may work incorrectly if it does.
     */
    // Considering deprication to reduce size of bytecode as changing _decimals to internal acheived the same functionality.
    // function _setupDecimals(uint8 decimals_) internal {
    //     _decimals = decimals_;
    // }

    /**
     * @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].
     */
    // Present in ERC777
    function _beforeTokenTransfer(
        address from_,
        address to_,
        uint256 amount_
    ) internal virtual {}
}

library Counters {
    using SafeMath for uint256;

    struct Counter {
        // This variable should never be directly accessed by users of the library: interactions must be restricted to
        // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
        // this feature: see https://github.com/ethereum/solidity/issues/4637
        uint256 _value; // default: 0
    }

    function current(Counter storage counter) internal view returns (uint256) {
        return counter._value;
    }

    function increment(Counter storage counter) internal {
        // The {SafeMath} overflow check can be skipped here, see the comment at the top
        counter._value += 1;
    }

    function decrement(Counter storage counter) internal {
        counter._value = counter._value.sub(1);
    }
}

interface IERC2612Permit {
    /**
     * @dev Sets `amount` as the allowance of `spender` over `owner`'s tokens,
     * given `owner`'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     */
    function permit(
        address owner,
        address spender,
        uint256 amount,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current ERC2612 nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);
}

abstract contract ERC20Permit is ERC20, IERC2612Permit {
    using Counters for Counters.Counter;

    mapping(address => Counters.Counter) private _nonces;

    // keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
    bytes32 public constant PERMIT_TYPEHASH =
        0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;

    bytes32 public DOMAIN_SEPARATOR;

    constructor() {
        uint256 chainID;
        assembly {
            chainID := chainid()
        }

        DOMAIN_SEPARATOR = keccak256(
            abi.encode(
                keccak256(
                    "EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"
                ),
                keccak256(bytes(name())),
                keccak256(bytes("1")), // Version
                chainID,
                address(this)
            )
        );
    }

    /**
     * @dev See {IERC2612Permit-permit}.
     *
     */
    function permit(
        address owner,
        address spender,
        uint256 amount,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) public virtual override {
        require(block.timestamp <= deadline, "Permit: expired deadline");

        bytes32 hashStruct = keccak256(
            abi.encode(
                PERMIT_TYPEHASH,
                owner,
                spender,
                amount,
                _nonces[owner].current(),
                deadline
            )
        );

        bytes32 _hash = keccak256(
            abi.encodePacked(uint16(0x1901), DOMAIN_SEPARATOR, hashStruct)
        );

        address signer = ecrecover(_hash, v, r, s);
        require(
            signer != address(0) && signer == owner,
            "ZeroSwapPermit: Invalid signature"
        );

        _nonces[owner].increment();
        _approve(owner, spender, amount);
    }

    /**
     * @dev See {IERC2612Permit-nonces}.
     */
    function nonces(address owner) public view override returns (uint256) {
        return _nonces[owner].current();
    }
}

interface IOwnable {
    function owner() external view returns (address);

    function renounceOwnership() external;

    function transferOwnership(address newOwner_) external;
}

contract Ownable is IOwnable {
    address internal _owner;

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _owner = msg.sender;
        emit OwnershipTransferred(address(0), _owner);
    }

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

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(_owner == msg.sender, "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 override onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = 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
        override
        onlyOwner
    {
        require(
            newOwner_ != address(0),
            "Ownable: new owner is the zero address"
        );
        emit OwnershipTransferred(_owner, newOwner_);
        _owner = newOwner_;
    }
}

contract VaultOwned is Ownable {
    address internal _vault;

    function setVault(address vault_) external onlyOwner returns (bool) {
        _vault = vault_;

        return true;
    }

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

    /**
     * @dev Throws if called by any account other than the vault.
     */
    modifier onlyVault() {
        require(_vault == msg.sender, "VaultOwned: caller is not the Vault");
        _;
    }
}

contract TWAPOracleUpdater is ERC20Permit, VaultOwned {
    using EnumerableSet for EnumerableSet.AddressSet;

    event TWAPOracleChanged(
        address indexed previousTWAPOracle,
        address indexed newTWAPOracle
    );
    event TWAPEpochChanged(
        uint256 previousTWAPEpochPeriod,
        uint256 newTWAPEpochPeriod
    );
    event TWAPSourceAdded(address indexed newTWAPSource);
    event TWAPSourceRemoved(address indexed removedTWAPSource);

    EnumerableSet.AddressSet private _dexPoolsTWAPSources;

    ITWAPOracle public twapOracle;

    uint256 public twapEpochPeriod;

    constructor(
        string memory name_,
        string memory symbol_,
        uint8 decimals_
    ) ERC20(name_, symbol_, decimals_) {}

    function changeTWAPOracle(address newTWAPOracle_) external onlyOwner {
        emit TWAPOracleChanged(address(twapOracle), newTWAPOracle_);
        twapOracle = ITWAPOracle(newTWAPOracle_);
    }

    function changeTWAPEpochPeriod(uint256 newTWAPEpochPeriod_)
        external
        onlyOwner
    {
        require(
            newTWAPEpochPeriod_ > 0,
            "TWAPOracleUpdater: TWAP Epoch period must be greater than 0."
        );
        emit TWAPEpochChanged(twapEpochPeriod, newTWAPEpochPeriod_);
        twapEpochPeriod = newTWAPEpochPeriod_;
    }

    function addTWAPSource(address newTWAPSourceDexPool_) external onlyOwner {
        require(
            _dexPoolsTWAPSources.add(newTWAPSourceDexPool_),
            "OlympusERC20TOken: TWAP Source already stored."
        );
        emit TWAPSourceAdded(newTWAPSourceDexPool_);
    }

    function removeTWAPSource(address twapSourceToRemove_) external onlyOwner {
        require(
            _dexPoolsTWAPSources.remove(twapSourceToRemove_),
            "OlympusERC20TOken: TWAP source not present."
        );
        emit TWAPSourceRemoved(twapSourceToRemove_);
    }

    function _uodateTWAPOracle(
        address dexPoolToUpdateFrom_,
        uint256 twapEpochPeriodToUpdate_
    ) internal {
        if (_dexPoolsTWAPSources.contains(dexPoolToUpdateFrom_)) {
            twapOracle.updateTWAP(
                dexPoolToUpdateFrom_,
                twapEpochPeriodToUpdate_
            );
        }
    }

    function _beforeTokenTransfer(
        address from_,
        address to_,
        uint256 amount_
    ) internal virtual override {
        if (_dexPoolsTWAPSources.contains(from_)) {
            _uodateTWAPOracle(from_, twapEpochPeriod);
        } else {
            if (_dexPoolsTWAPSources.contains(to_)) {
                _uodateTWAPOracle(to_, twapEpochPeriod);
            }
        }
    }
}

contract Divine is TWAPOracleUpdater {
    constructor(
        string memory name_,
        string memory symbol_,
        uint8 decimals_
    ) TWAPOracleUpdater(name_, symbol_, decimals_) {}
}

contract DRUGERC20Token is Divine {
    using SafeMath for uint256;

    constructor() Divine("DRUG", "DRUG", 18) {
        _mint(msg.sender, 10000000 * 1e18);
    }

    function burn(uint256 amount) public virtual {
        _burn(msg.sender, amount);
    }

    function burnFrom(address account_, uint256 amount_) public virtual {
        _burnFrom(account_, amount_);
    }

    function _burnFrom(address account_, uint256 amount_) public virtual {
        uint256 decreasedAllowance_ = allowance(account_, msg.sender).sub(
            amount_,
            "ERC20: burn amount exceeds allowance"
        );

        _approve(account_, msg.sender, decreasedAllowance_);
        _burn(account_, amount_);
    }

    function withdraw(IERC20 _token) external onlyOwner {
        IERC20(_token).transfer(
            msg.sender,
            IERC20(_token).balanceOf(address(this))
        );
    }
}

Contract Security Audit

Contract ABI

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"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":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"previousTWAPEpochPeriod","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newTWAPEpochPeriod","type":"uint256"}],"name":"TWAPEpochChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousTWAPOracle","type":"address"},{"indexed":true,"internalType":"address","name":"newTWAPOracle","type":"address"}],"name":"TWAPOracleChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"newTWAPSource","type":"address"}],"name":"TWAPSourceAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"removedTWAPSource","type":"address"}],"name":"TWAPSourceRemoved","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":[],"name":"DOMAIN_SEPARATOR","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PERMIT_TYPEHASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account_","type":"address"},{"internalType":"uint256","name":"amount_","type":"uint256"}],"name":"_burnFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newTWAPSourceDexPool_","type":"address"}],"name":"addTWAPSource","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"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":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account_","type":"address"},{"internalType":"uint256","name":"amount_","type":"uint256"}],"name":"burnFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newTWAPEpochPeriod_","type":"uint256"}],"name":"changeTWAPEpochPeriod","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newTWAPOracle_","type":"address"}],"name":"changeTWAPOracle","outputs":[],"stateMutability":"nonpayable","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":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"permit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"twapSourceToRemove_","type":"address"}],"name":"removeTWAPSource","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"vault_","type":"address"}],"name":"setVault","outputs":[{"internalType":"bool","name":"","type":"bool"}],"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":"newOwner_","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"twapEpochPeriod","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"twapOracle","outputs":[{"internalType":"contract ITWAPOracle","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"vault","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"_token","type":"address"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

Deployed ByteCode Sourcemap

48105:931:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;28080:83;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30561:208;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;30561:208:0;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;29233:100;;;:::i;:::-;;;;;;;;;;;;;;;;31277:450;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;31277:450:0;;;;;;;;;;;;;;;;;:::i;40732:117::-;;;:::i;29059:83::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;;45952:198;;;;;;;;;;;;;;;;-1:-1:-1;45952:198:0;-1:-1:-1;;;;;45952:198:0;;:::i;:::-;;40858:31;;;:::i;32136:296::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;32136:296:0;;;;;;;;:::i;48283:89::-;;;;;;;;;;;;;;;;-1:-1:-1;48283:89:0;;:::i;46158:372::-;;;;;;;;;;;;;;;;-1:-1:-1;46158:372:0;;:::i;48849:184::-;;;;;;;;;;;;;;;;-1:-1:-1;48849:184:0;-1:-1:-1;;;;;48849:184:0;;:::i;44676:126::-;;;;;;;;;;;;;;;;-1:-1:-1;44676:126:0;-1:-1:-1;;;;;44676:126:0;;:::i;29422:177::-;;;;;;;;;;;;;;;;-1:-1:-1;29422:177:0;-1:-1:-1;;;;;29422:177:0;;:::i;43952:157::-;;;:::i;48380:115::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;48380:115:0;;;;;;;;:::i;42512:120::-;;;;;;;;;;;;;;;;-1:-1:-1;42512:120:0;-1:-1:-1;;;;;42512:120:0;;:::i;43303:88::-;;;:::i;:::-;;;;-1:-1:-1;;;;;43303:88:0;;;;;;;;;;;;;;45725:29;;;:::i;28308:87::-;;;:::i;48503:338::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;48503:338:0;;;;;;;;:::i;32935:396::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;32935:396:0;;;;;;;;:::i;29884:214::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;29884:214:0;;;;;;;;:::i;46538:289::-;;;;;;;;;;;;;;;;-1:-1:-1;46538:289:0;-1:-1:-1;;;;;46538:289:0;;:::i;45763:30::-;;;:::i;41485:959::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;41485:959:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;30187:201::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;30187:201:0;;;;;;;;;;:::i;46835:288::-;;;;;;;;;;;;;;;;-1:-1:-1;46835:288:0;-1:-1:-1;;;;;46835:288:0;;:::i;44264:335::-;;;;;;;;;;;;;;;;-1:-1:-1;44264:335:0;-1:-1:-1;;;;;44264:335:0;;:::i;44883:79::-;;;:::i;28080:83::-;28150:5;28143:12;;;;;;;;-1:-1:-1;;28143:12:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;28117:13;;28143:12;;28150:5;;28143:12;;28150:5;28143:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;28080:83;:::o;30561:208::-;30680:4;30702:37;30711:10;30723:7;30732:6;30702:8;:37::i;:::-;-1:-1:-1;30757:4:0;30561:208;;;;;:::o;29233:100::-;29313:12;;29233:100;:::o;31277:450::-;31417:4;31434:36;31444:6;31452:9;31463:6;31434:9;:36::i;:::-;31481:216;31504:6;31525:10;31550:136;31604:6;31550:136;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;31550:19:0;;;;;;:11;:19;;;;;;;;31570:10;31550:31;;;;;;;;;:136;:35;:136::i;:::-;31481:8;:216::i;:::-;-1:-1:-1;31715:4:0;31277:450;;;;;:::o;40732:117::-;40783:66;40732:117;:::o;29059:83::-;29125:9;;;;29059:83;:::o;45952:198::-;43524:6;;-1:-1:-1;;;;;43524:6:0;43534:10;43524:20;43516:65;;;;;-1:-1:-1;;;43516:65:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;43516:65:0;;;;;;;;;;;;;;;46063:10:::1;::::0;46037:54:::1;::::0;-1:-1:-1;;;;;46037:54:0;;::::1;::::0;46063:10:::1;::::0;46037:54:::1;::::0;46063:10:::1;::::0;46037:54:::1;46102:10;:40:::0;;-1:-1:-1;;;;;;46102:40:0::1;-1:-1:-1::0;;;;;46102:40:0;;;::::1;::::0;;;::::1;::::0;;45952:198::o;40858:31::-;;;;:::o;32136:296::-;32296:10;32251:4;32343:23;;;:11;:23;;;;;;;;-1:-1:-1;;;;;32343:32:0;;;;;;;;;;32251:4;;32273:129;;32321:7;;32343:48;;32380:10;32343:36;:48::i;48283:89::-;48339:25;48345:10;48357:6;48339:5;:25::i;:::-;48283:89;:::o;46158:372::-;43524:6;;-1:-1:-1;;;;;43524:6:0;43534:10;43524:20;43516:65;;;;;-1:-1:-1;;;43516:65:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;43516:65:0;;;;;;;;;;;;;;;46315:1:::1;46293:19;:23;46271:133;;;;-1:-1:-1::0;;;46271:133:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46437:15;::::0;46420:54:::1;::::0;;;;;::::1;::::0;::::1;::::0;;;;;::::1;::::0;;;;;;;;::::1;46485:15;:37:::0;46158:372::o;48849:184::-;43524:6;;-1:-1:-1;;;;;43524:6:0;43534:10;43524:20;43516:65;;;;;-1:-1:-1;;;43516:65:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;43516:65:0;;;;;;;;;;;;;;;48919:6:::1;-1:-1:-1::0;;;;;48912:23:0::1;;48950:10;48982:6;-1:-1:-1::0;;;;;48975:24:0::1;;49008:4;48975:39;;;;;;;;;;;;;-1:-1:-1::0;;;;;48975:39:0::1;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;48975:39:0;48912:113:::1;::::0;;-1:-1:-1;;;;;;48912:113:0::1;::::0;;;;;;-1:-1:-1;;;;;48912:113:0;;::::1;;::::0;::::1;::::0;;;;;;;;;;;;;;48975:39:::1;::::0;48912:113;;;;;;;-1:-1:-1;48912:113:0;;::::1;;::::0;::::1;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;;;48849:184:0:o;44676:126::-;43524:6;;44738:4;;-1:-1:-1;;;;;43524:6:0;43534:10;43524:20;43516:65;;;;;-1:-1:-1;;;43516:65:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;43516:65:0;;;;;;;;;;;;;;;-1:-1:-1;44755:6:0::1;:15:::0;;-1:-1:-1;;;;;44755:15:0;::::1;-1:-1:-1::0;;;;;;44755:15:0;;::::1;;::::0;;;44676:126;;;:::o;29422:177::-;-1:-1:-1;;;;;29573:18:0;29541:7;29573:18;;;;;;;;;;;;29422:177::o;43952:157::-;43524:6;;-1:-1:-1;;;;;43524:6:0;43534:10;43524:20;43516:65;;;;;-1:-1:-1;;;43516:65:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;43516:65:0;;;;;;;;;;;;;;;44052:6:::1;::::0;44031:40:::1;::::0;44068:1:::1;::::0;-1:-1:-1;;;;;44052:6:0::1;::::0;44031:40:::1;::::0;44068:1;;44031:40:::1;44082:6;:19:::0;;-1:-1:-1;;;;;;44082:19:0::1;::::0;;43952:157::o;48380:115::-;48459:28;48469:8;48479:7;48459:9;:28::i;:::-;48380:115;;:::o;42512:120::-;-1:-1:-1;;;;;42600:14:0;;42573:7;42600:14;;;:7;:14;;;;;:24;;:22;:24::i;43303:88::-;43377:6;;-1:-1:-1;;;;;43377:6:0;43303:88;:::o;45725:29::-;;;-1:-1:-1;;;;;45725:29:0;;:::o;28308:87::-;28380:7;28373:14;;;;;;;;-1:-1:-1;;28373:14:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;28347:13;;28373:14;;28380:7;;28373:14;;28380:7;28373:14;;;;;;;;;;;;;;;;;;;;;;;;48503:338;48583:27;48613:121;48663:7;48613:121;;;;;;;;;;;;;;;;;:31;48623:8;48633:10;48613:9;:31::i;:::-;:35;:121;:35;:121::i;:::-;48583:151;;48747:51;48756:8;48766:10;48778:19;48747:8;:51::i;:::-;48809:24;48815:8;48825:7;48809:5;:24::i;32935:396::-;33055:4;33077:224;33100:10;33125:7;33147:143;33202:15;33147:143;;;;;;;;;;;;;;;;;33159:10;33147:23;;;;:11;:23;;;;;;;;-1:-1:-1;;;;;33147:32:0;;;;;;;;;;;:143;:36;:143::i;29884:214::-;30006:4;30028:40;30038:10;30050:9;30061:6;30028:9;:40::i;46538:289::-;43524:6;;-1:-1:-1;;;;;43524:6:0;43534:10;43524:20;43516:65;;;;;-1:-1:-1;;;43516:65:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;43516:65:0;;;;;;;;;;;;;;;46644:47:::1;:20;46669:21:::0;46644:24:::1;:47::i;:::-;46622:143;;;;-1:-1:-1::0;;;46622:143:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46781:38;::::0;-1:-1:-1;;;;;46781:38:0;::::1;::::0;::::1;::::0;;;::::1;46538:289:::0;:::o;45763:30::-;;;;:::o;41485:959::-;41730:8;41711:15;:27;;41703:64;;;;;-1:-1:-1;;;41703:64:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;41963:14:0;;41780:18;41963:14;;;:7;:14;;;;;40783:66;;41888:5;;41912:7;;41938:6;;41963:24;;:22;:24::i;:::-;41825:204;;;;;;;;;;;-1:-1:-1;;;;;41825:204:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;41801:239;;;;;;42126:16;;-1:-1:-1;;;42093:62:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42069:97;;;;;;;;;-1:-1:-1;42196:25:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;41801:239;;-1:-1:-1;42069:97:0;;42196:25;;;;;;;-1:-1:-1;;42196:25:0;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;42196:25:0;;-1:-1:-1;;42196:25:0;;;-1:-1:-1;;;;;;;42254:20:0;;;;;;:39;;;42288:5;-1:-1:-1;;;;;42278:15:0;:6;-1:-1:-1;;;;;42278:15:0;;42254:39;42232:122;;;;-1:-1:-1;;;42232:122:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;42367:14:0;;;;;;:7;:14;;;;;:26;;:24;:26::i;:::-;42404:32;42413:5;42420:7;42429:6;42404:8;:32::i;:::-;41485:959;;;;;;;;;;:::o;30187:201::-;-1:-1:-1;;;;;30353:18:0;;;30321:7;30353:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;30187:201::o;46835:288::-;43524:6;;-1:-1:-1;;;;;43524:6:0;43534:10;43524:20;43516:65;;;;;-1:-1:-1;;;43516:65:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;43516:65:0;;;;;;;;;;;;;;;46942:48:::1;:20;46970:19:::0;46942:27:::1;:48::i;:::-;46920:141;;;;-1:-1:-1::0;;;46920:141:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47077:38;::::0;-1:-1:-1;;;;;47077:38:0;::::1;::::0;::::1;::::0;;;::::1;46835:288:::0;:::o;44264:335::-;43524:6;;-1:-1:-1;;;;;43524:6:0;43534:10;43524:20;43516:65;;;;;-1:-1:-1;;;43516:65:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;43516:65:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;44418:23:0;::::1;44396:111;;;;-1:-1:-1::0;;;44396:111:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44544:6;::::0;44523:39:::1;::::0;-1:-1:-1;;;;;44523:39:0;;::::1;::::0;44544:6:::1;::::0;44523:39:::1;::::0;44544:6:::1;::::0;44523:39:::1;44573:6;:18:::0;;-1:-1:-1;;;;;;44573:18:0::1;-1:-1:-1::0;;;;;44573:18:0;;;::::1;::::0;;;::::1;::::0;;44264:335::o;44883:79::-;44948:6;;-1:-1:-1;;;;;44948:6:0;44883:79;:::o;20272:181::-;20330:7;20362:5;;;20386:6;;;;20378:46;;;;;-1:-1:-1;;;20378:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;20444:1;20272:181;-1:-1:-1;;;20272:181:0:o;12114:190::-;12221:4;12250:46;12260:3;-1:-1:-1;;;;;12280:14:0;;12250:9;:46::i;36408:380::-;-1:-1:-1;;;;;36544:19:0;;36536:68;;;;-1:-1:-1;;;36536:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;36623:21:0;;36615:68;;;;-1:-1:-1;;;36615:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;36696:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;36748:32;;;;;;;;;;;;;;;;;36408:380;;;:::o;33821:610::-;-1:-1:-1;;;;;33961:20:0;;33953:70;;;;-1:-1:-1;;;33953:70:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;34042:23:0;;34034:71;;;;-1:-1:-1;;;34034:71:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;34118:47;34139:6;34147:9;34158:6;34118:20;:47::i;:::-;34198:108;34234:6;34198:108;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;34198:17:0;;:9;:17;;;;;;;;;;;;:108;:21;:108::i;:::-;-1:-1:-1;;;;;34178:17:0;;;:9;:17;;;;;;;;;;;:128;;;;34340:20;;;;;;;:32;;34365:6;34340:24;:32::i;:::-;-1:-1:-1;;;;;34317:20:0;;;:9;:20;;;;;;;;;;;;:55;;;;34388:35;;;;;;;34317:20;;34388:35;;;;;;;;;;;;;33821:610;;;:::o;21175:226::-;21295:7;21331:12;21323:6;;;;21315:29;;;;-1:-1:-1;;;21315:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;21367:5:0;;;21175:226::o;35489:455::-;-1:-1:-1;;;;;35573:21:0;;35565:67;;;;-1:-1:-1;;;35565:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;35645:49;35666:7;35683:1;35687:6;35645:20;:49::i;:::-;35728:105;35765:6;35728:105;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;35728:18:0;;:9;:18;;;;;;;;;;;;:105;:22;:105::i;:::-;-1:-1:-1;;;;;35707:18:0;;:9;:18;;;;;;;;;;:126;35859:12;;:24;;35876:6;35859:16;:24::i;:::-;35844:12;:39;35899:37;;;;;;;;35925:1;;-1:-1:-1;;;;;35899:37:0;;;;;;;;;;;;35489:455;;:::o;38555:114::-;38647:14;;38555:114::o;11514:166::-;11602:4;11631:41;11636:3;-1:-1:-1;;;;;11656:14:0;;11631:4;:41::i;38677:181::-;38831:19;;38849:1;38831:19;;;38677:181::o;11856:172::-;11947:4;11976:44;11984:3;-1:-1:-1;;;;;12004:14:0;;11976:7;:44::i;4733:161::-;4833:4;4862:19;;;:12;;;;;:19;;;;;;:24;;;4733:161::o;47484:409::-;47634:36;:20;47664:5;47634:29;:36::i;:::-;47630:256;;;47687:41;47705:5;47712:15;;47687:17;:41::i;:::-;47630:256;;;47765:34;:20;47795:3;47765:29;:34::i;:::-;47761:114;;;47820:39;47838:3;47843:15;;47820:17;:39::i;20736:136::-;20794:7;20821:43;20825:1;20828;20821:43;;;;;;;;;;;;;;;;;:3;:43::i;2487:414::-;2550:4;2572:21;2582:3;2587:5;2572:9;:21::i;:::-;2567:327;;-1:-1:-1;2610:23:0;;;;;;;;:11;:23;;;;;;;;;;;;;2793:18;;2771:19;;;:12;;;:19;;;;;;:40;;;;2826:11;;2567:327;-1:-1:-1;2877:5:0;2870:12;;3077:1570;3143:4;3282:19;;;:12;;;:19;;;;;;3318:15;;3314:1326;;3766:18;;-1:-1:-1;;3717:14:0;;;;3766:22;;;;3693:21;;3766:3;;:22;;4053;;;;;;;;;;;;;;4033:42;;4199:9;4170:3;:11;;4182:13;4170:26;;;;;;;;;;;;;;;;;;;:38;;;;4276:23;;;4318:1;4276:12;;;:23;;;;;;4302:17;;;4276:43;;4441:17;;4276:3;;4441:17;;;;;;;;;;;;;;;;;;;;;;4536:3;:12;;:19;4549:5;4536:19;;;;;;;;;;;4529:26;;;4579:4;4572:11;;;;;;;;3314:1326;4623:5;4616:12;;;;;47131:345;47271:51;:20;47301;47271:29;:51::i;:::-;47267:202;;;47339:10;;:118;;;-1:-1:-1;;;47339:118:0;;-1:-1:-1;;;;;47339:118:0;;;;;;;;;;;;;;;:10;;;;;:21;;:118;;;;;;;;;;;;;;:10;;:118;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;47131:345:0;;:::o

Swarm Source

ipfs://850d3a13fed8051600c024ff5abf12c4956fcb7ec85bf0c0ae432a4e50d7c087
Block Transaction Gas Used Reward
Age Block Fee Address BC Fee Address Voting Power Jailed Incoming
Validator ID :
0 FTM

Amount Staked
0

Amount Delegated
0

Staking Total
0

Staking Start Epoch
0

Staking Start Time
0

Proof of Importance
0

Origination Score
0

Validation Score
0

Active
0

Online
0

Downtime
0 s
Address Amount claimed Rewards Created On Epoch Created On
Block Uncle Number Difficulty Gas Used Reward
Loading
Loading
Make sure to use the "Vote Down" button for any spammy posts, and the "Vote Up" for interesting conversations.