Contract 0x4e78011ce80ee02d2c3e649fb657e45898257815 6

 
 
Txn Hash Method
Block
From
To
Value [Txn Fee]
0x01b2d5aa744fca1ee4c836e8a2e597507b7fc49c95f64547fb5495705ca12b7fApprove242999762022-01-29 10:18:3614 mins ago0xd46a08c7ddad58baff410fa71355a2671416305e IN  KlimaDAO: KLIMA Token0 MATIC0.000116258387 2.500019082
0x1eeb7409ed102802c122dbcf344716e027eaae72c80a820d970c9d1b51ee390fApprove242999152022-01-29 10:13:0220 mins ago0xda70410eddad12162e65ce56a56d2b3924a24fc4 IN  KlimaDAO: KLIMA Token0 MATIC0.001380302031 29.681999684
0x2362319a510437621a31b63578f4bc77643e18f930f27a2f507450b5c921dffdApprove242998292022-01-29 10:09:1424 mins ago0xbb5d0cccd907b5e28eb1ef29d6dfada029fd3e79 IN  KlimaDAO: KLIMA Token0 MATIC0.001503906971 32.339998948
0xf52dc1fa34c4c87cc1478b92fb848995e967048f200d7245441134887edf117bApprove242998112022-01-29 10:08:3824 mins ago0x0f537e426c2223f9aa6a9b998ec09877c3016516 IN  KlimaDAO: KLIMA Token0 MATIC0.0046503100
0x2683416df9596d2aac31921784e7c4011c1dd278afa84f21e73aeaaa8fb2d1d7Approve242997462022-01-29 10:05:2627 mins ago0x27030b72396a0b44aa646a608c2b568dedfc615f IN  KlimaDAO: KLIMA Token0 MATIC0.000112013655 2.42501041
0x552b7050ab2e8850ca1fdf55a39a07e07b1995c7321ec85b93dfe75708386ac8Transfer242996872022-01-29 10:02:1431 mins ago0xb34ed85bc0b9da2fa3c5e5d2f4b24f8ee96ce4e9 IN  KlimaDAO: KLIMA Token0 MATIC0.0024331577443.29
0x9e30578d80c6377490a06f796776c6ba39753de3e26bd74b8b8387c977bec95eApprove242995242022-01-29 9:56:4036 mins ago0x6bcde04e02bf373c204edd68a29176da62171db2 IN  KlimaDAO: KLIMA Token0 MATIC0.001371041261 29.681999997
0x4fc89094fda386a2488c17548ca6b197e2467a560d806ccc944c10bfe67807a2Approve242983682022-01-29 9:12:401 hr 20 mins ago0xbfb7a6a4634f69209a393f3d51f989bc6d125316 IN  KlimaDAO: KLIMA Token0 MATIC0.001434216686 31.049699864
0x57a0f989f452089d5b40813b9baed7e639f14ba99d02e0b3c7ceaef6b41f94a7Approve242983562022-01-29 9:12:121 hr 21 mins ago0x4b2df21cd87de1ef2b96e493e2de6bf166a78dd9 IN  KlimaDAO: KLIMA Token0 MATIC0.001400587034 30.118208166
0xefe09a42e38e1bf90e009cff989ac14fb5d7533c6e5c9ce6b329d9103ba13592Approve242981462022-01-29 9:05:001 hr 28 mins ago0x0f03d543f782c99da39552a12e37a443fbd80e70 IN  KlimaDAO: KLIMA Token0 MATIC0.000736722605 30.419200009
0x649cc73bdeb85985c8b975507535d41b841032b7721e3cda44f577781d2187ecApprove242980612022-01-29 9:02:061 hr 31 mins ago0x0f03d543f782c99da39552a12e37a443fbd80e70 IN  KlimaDAO: KLIMA Token0 MATIC0.001041417 43
0xdf6bc8b515923d8cccbc52087835735e9456f032bb6e1c42beb98c520f613a58Approve242978042022-01-29 8:53:161 hr 40 mins ago0x955fd2319a34efe97bab0e99f24a1c8b69cab12d IN  KlimaDAO: KLIMA Token0 MATIC0.000315755428 6.790001259
0x3cd7c8ef5d8f74a5706b8d57adc70da2debc6ea3428700878de4b25d58063ee9Transfer242975192022-01-29 8:39:101 hr 54 mins ago0x9a8d7776e69a146917ab036c5711112c76655839 IN  KlimaDAO: KLIMA Token0 MATIC0.000077109002 1.500000043
0xa27331ba1309a75385ccc6ec2098a303cde280b204e387526c5ce2a24b60ca53Approve242974892022-01-29 8:38:101 hr 55 mins ago0x5fabca0984fdaa6e71ad4d5a5a1ef1ce660ed9d9 IN  KlimaDAO: KLIMA Token0 MATIC0.000115417501 2.500000022
0xd861b6a1388212da27d2ef17e5e4d36d46e65acf52599ca1c7beb8cf1bd57839Approve242974702022-01-29 8:37:281 hr 55 mins ago0x6bf3e91f782abf63d2268db76fdf1020c2fac3c6 IN  KlimaDAO: KLIMA Token0 MATIC0.0027901893 60.000200007
0x2fabaf2f25f21b15baf0676e8df8b5c391cc5c1a3d526b94501931eccd30c9faApprove242973722022-01-29 8:34:081 hr 59 mins ago0x87171be25f5e6e18701dd1e4f1dda6c3148345ec IN  KlimaDAO: KLIMA Token0 MATIC0.001503907019 32.339999997
0x4503b96911ee6e240743bc7ddd84d59d8e5a7da783dd784d317d61913eb9611aTransfer242973652022-01-29 8:33:541 hr 59 mins ago0xf8c3ebfd59268ca76278aece363b209d159db6d7 IN  KlimaDAO: KLIMA Token0 MATIC0.001065230719 31.039999999
0xa6483619088a8a1183c33174dc8618c8b48ff9321385b5c697340ad60cab97b0Transfer242973222022-01-29 8:32:242 hrs ago0x0793f3ef476266c30da37ebc4f6ff52d4af1656f IN  KlimaDAO: KLIMA Token0 MATIC0.001720301789 33.464999999
0xb1c9a244e80b2d96ca059290a0f1e62e404466282bee5f8541cda5b018927575Approve242973192022-01-29 8:32:182 hrs ago0x2ccf9d36c748f2dcb843c683eae67dbcfe8646fe IN  KlimaDAO: KLIMA Token0 MATIC0.001509536208 32.461050004
0x964e67cbc26d7aae7831aaee50435814ac04a96be7aff104c4d74d12d37441a0Approve242968082022-01-29 8:14:442 hrs 18 mins ago0x8e5af6a9622f24154237df087add09e0d889beed IN  KlimaDAO: KLIMA Token0 MATIC0.0000692871621.500014335
0x337f554f429415a70207ebb55237f5a51651fb5de7e02282d8b10708029d901dApprove242968082022-01-29 8:14:442 hrs 18 mins ago0xa93c7e239ae00c6e916bc2721cf4e616579bd67b IN  KlimaDAO: KLIMA Token0 MATIC0.000069287197 1.50001509
0x7cb0112b41ee3ddc1986eb4bcebc027599e106949b53fc0bd612666e520eaee5Approve242967792022-01-29 8:13:462 hrs 19 mins ago0x22f3936cb87d7078b98ba297ef012bd4af4cecea IN  KlimaDAO: KLIMA Token0 MATIC0.000510045442 19.400001618
0xa1c7c0606c8d3fa85c9d1760156aeb531d506b112a11c9081326d0faa1cfdd21Approve242967652022-01-29 8:13:062 hrs 20 mins ago0x22f3936cb87d7078b98ba297ef012bd4af4cecea IN  KlimaDAO: KLIMA Token0 MATIC0.000069286683 1.500003968
0xc419a76fbeae301fb8cfdc0d5bb9cbe38458684cc5b26c89a81916188d0e00e7Transfer242966652022-01-29 8:05:342 hrs 27 mins ago0xf00c4646c0bd559d80263ccdebc7f11f0b9c1828 IN  KlimaDAO: KLIMA Token0 MATIC0.001695369879 32.979999984
0x54dc0f20419012b8fddeaadae5abbb9d1a4ba37924f7c75959c92db62f1c2235Approve242965982022-01-29 8:03:162 hrs 30 mins ago0xd5742420a50e266325caf106f0ac294d4eb04a90 IN  KlimaDAO: KLIMA Token0 MATIC0.00141458405 30.419199857
[ Download CSV Export 

OVERVIEW

KlimaDAO's mission is to accelerate price pressure on the voluntary carbon market and make it more costly for large corporations to emit harmful greenhouse gasses - catalyzing humanity's transition toward a lower-carbon future.

Parent Txn Hash Block From To Value
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
KlimaToken

Compiler Version
v0.7.5+commit.eb77ed08

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, MIT license

Contract Source Code (Solidity)

/**
 *Submitted for verification at polygonscan.com on 2021-10-04
*/

// ██╗  ██╗██╗     ██╗███╗   ███╗ █████╗     ██████╗  █████╗  ██████╗
// ██║ ██╔╝██║     ██║████╗ ████║██╔══██╗    ██╔══██╗██╔══██╗██╔═══██╗
// █████╔╝ ██║     ██║██╔████╔██║███████║    ██║  ██║███████║██║   ██║
// ██╔═██╗ ██║     ██║██║╚██╔╝██║██╔══██║    ██║  ██║██╔══██║██║   ██║
// ██║  ██╗███████╗██║██║ ╚═╝ ██║██║  ██║    ██████╔╝██║  ██║╚██████╔╝
// ╚═╝  ╚═╝╚══════╝╚═╝╚═╝     ╚═╝╚═╝  ╚═╝    ╚═════╝ ╚═╝  ╚═╝ ╚═════╝

//.            ..          .       .  .            '
//            ''......................'.           .
//             ..                    ..            .
//              ..                  ..             .
//               ..      ....      ..              .
//                ..    ......    ..               .
//                 ..  ..    .. ...                .
//                ...,,.......','...               .
//             ......,;'......';,......            .
//                 ......    .. ..                 .
//                ..    ......   ...               .
//               ..      .'..     ...              .
//              ..                  ..             .
//             ..                    ..            .
//            ...                    .'.           .
//.           ....                  ....           '
//'                                                :



// 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_, uint epochPeriod_ ) external returns ( uint32 );

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

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

    function updateTWAP( address uniV2CompatPairAddressToUpdate_, uint 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 (uint c) {
        if (a > 3) {
            c = a;
            uint 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 constant private 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( uint previousTWAPEpochPeriod, uint newTWAPEpochPeriod );
    event TWAPSourceAdded( address indexed newTWAPSource );
    event TWAPSourceRemoved( address indexed removedTWAPSource );

    EnumerableSet.AddressSet private _dexPoolsTWAPSources;

    ITWAPOracle public twapOracle;

    uint 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( uint 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_ ), "KlimaERC20TOken: TWAP Source already stored." );
        emit TWAPSourceAdded( newTWAPSourceDexPool_ );
    }

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

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

    function _beforeTokenTransfer( address from_, address to_, uint256 amount_ ) internal override virtual {
        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 KlimaToken is Divine {

    using SafeMath for uint256;

    constructor() Divine("Klima DAO", "KLIMA", 9) {
    }

    function mint(address account_, uint256 amount_) external onlyVault() {
        _mint(account_, amount_);
    }

    /**
     * @dev Destroys `amount` tokens from the caller.
     *
     * See {ERC20-_burn}.
     */
    function burn(uint256 amount) public virtual {
        _burn(msg.sender, amount);
    }
    /*
     * @dev Destroys `amount` tokens from `account`, deducting from the caller's
     * allowance.
     *
     * See {ERC20-_burn} and {ERC20-allowance}.
     *
     * Requirements:
     *
     * - the caller must have allowance for ``accounts``'s tokens of at least
     * `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_);
    }
}

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":[{"internalType":"address","name":"account_","type":"address"},{"internalType":"uint256","name":"amount_","type":"uint256"}],"name":"mint","outputs":[],"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"}]

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

Deployed ByteCode Sourcemap

47246:1245:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;28463:83;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30803:167;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;30803:167:0;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;29616:100;;;:::i;:::-;;;;;;;;;;;;;;;;31478:317;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;31478:317:0;;;;;;;;;;;;;;;;;:::i;40418:108::-;;;:::i;29442:83::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;;45284:205;;;;;;;;;;;;;;;;-1:-1:-1;45284:205:0;-1:-1:-1;;;;;45284:205:0;;:::i;:::-;;40535:31;;;:::i;32204:214::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;32204:214:0;;;;;;;;:::i;47382:113::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;47382:113:0;;;;;;;;:::i;47611:89::-;;;;;;;;;;;;;;;;-1:-1:-1;47611:89:0;;:::i;45497:317::-;;;;;;;;;;;;;;;;-1:-1:-1;45497:317:0;;:::i;44041:132::-;;;;;;;;;;;;;;;;-1:-1:-1;44041:132:0;-1:-1:-1;;;;;44041:132:0;;:::i;29805:127::-;;;;;;;;;;;;;;;;-1:-1:-1;29805:127:0;-1:-1:-1;;;;;29805:127:0;;:::i;43382:161::-;;;:::i;48018:115::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;48018:115:0;;;;;;;;:::i;41956:120::-;;;;;;;;;;;;;;;;-1:-1:-1;41956:120:0;-1:-1:-1;;;;;41956:120:0;;:::i;42731:88::-;;;:::i;:::-;;;;-1:-1:-1;;;;;42731:88:0;;;;;;;;;;;;;;45054:29;;;:::i;28691:87::-;;;:::i;48141:347::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;48141:347:0;;;;;;;;:::i;32921:265::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;32921:265:0;;;;;;;;:::i;30217:173::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;30217:173:0;;;;;;;;:::i;45822:260::-;;;;;;;;;;;;;;;;-1:-1:-1;45822:260:0;-1:-1:-1;;;;;45822:260:0;;:::i;45092:27::-;;;:::i;41122:766::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;41122:766:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;30479:151::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;30479:151:0;;;;;;;;;;:::i;46090:259::-;;;;;;;;;;;;;;;;-1:-1:-1;46090:259:0;-1:-1:-1;;;;;46090:259:0;;:::i;43698:264::-;;;;;;;;;;;;;;;;-1:-1:-1;43698:264:0;-1:-1:-1;;;;;43698:264:0;;:::i;44254:79::-;;;:::i;28463:83::-;28533:5;28526:12;;;;;;;;-1:-1:-1;;28526:12:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;28500:13;;28526:12;;28533:5;;28526:12;;28533:5;28526:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;28463:83;:::o;30803:167::-;30886:4;30903:37;30912:10;30924:7;30933:6;30903:8;:37::i;:::-;-1:-1:-1;30958:4:0;30803:167;;;;;:::o;29616:100::-;29696:12;;29616:100;:::o;31478:317::-;31584:4;31601:36;31611:6;31619:9;31630:6;31601:9;:36::i;:::-;31648:117;31657:6;31665:10;31677:87;31713:6;31677:87;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;31677:19:0;;;;;;:11;:19;;;;;;;;31697:10;31677:31;;;;;;;;;:87;:35;:87::i;:::-;31648:8;:117::i;:::-;-1:-1:-1;31783:4:0;31478:317;;;;;:::o;40418:108::-;40460:66;40418:108;:::o;29442:83::-;29508:9;;;;29442:83;:::o;45284:205::-;42953:6;;-1:-1:-1;;;;;42953:6:0;42963:10;42953:20;42944:67;;;;;-1:-1:-1;;;42944:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;42944:67:0;;;;;;;;;;;;;;;45400:10:::1;::::0;45373:55:::1;::::0;-1:-1:-1;;;;;45373:55:0;;::::1;::::0;45400:10:::1;::::0;45373:55:::1;::::0;45400:10:::1;::::0;45373:55:::1;45439:10;:42:::0;;-1:-1:-1;;;;;;45439:42:0::1;-1:-1:-1::0;;;;;45439:42:0;;;::::1;::::0;;;::::1;::::0;;45284:205::o;40535:31::-;;;;:::o;32204:214::-;32318:10;32292:4;32339:23;;;:11;:23;;;;;;;;-1:-1:-1;;;;;32339:32:0;;;;;;;;;;32292:4;;32309:79;;32330:7;;32339:48;;32376:10;32339:36;:48::i;47382:113::-;44467:6;;-1:-1:-1;;;;;44467:6:0;44477:10;44467:20;44458:70;;;;-1:-1:-1;;;44458:70:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47463:24:::1;47469:8;47479:7;47463:5;:24::i;:::-;47382:113:::0;;:::o;47611:89::-;47667:25;47673:10;47685:6;47667:5;:25::i;:::-;47611:89;:::o;45497:317::-;42953:6;;-1:-1:-1;;;;;42953:6:0;42963:10;42953:20;42944:67;;;;;-1:-1:-1;;;42944:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;42944:67:0;;;;;;;;;;;;;;;45619:1:::1;45597:19;:23;45588:98;;;;-1:-1:-1::0;;;45588:98:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;45720:15;::::0;45702:56:::1;::::0;;;;;::::1;::::0;::::1;::::0;;;;;::::1;::::0;;;;;;;;::::1;45769:15;:37:::0;45497:317::o;44041:132::-;42953:6;;44108:4;;-1:-1:-1;;;;;42953:6:0;42963:10;42953:20;42944:67;;;;;-1:-1:-1;;;42944:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;42944:67:0;;;;;;;;;;;;;;;-1:-1:-1;44126:6:0::1;:15:::0;;-1:-1:-1;;;;;44126:15:0;::::1;-1:-1:-1::0;;;;;;44126:15:0;;::::1;;::::0;;;44041:132;;;:::o;29805:127::-;-1:-1:-1;;;;;29906:18:0;29879:7;29906:18;;;;;;;;;;;;29805:127::o;43382:161::-;42953:6;;-1:-1:-1;;;;;42953:6:0;42963:10;42953:20;42944:67;;;;;-1:-1:-1;;;42944:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;42944:67:0;;;;;;;;;;;;;;;43485:6:::1;::::0;43463:42:::1;::::0;43501:1:::1;::::0;-1:-1:-1;;;;;43485:6:0::1;::::0;43463:42:::1;::::0;43501:1;;43463:42:::1;43516:6;:19:::0;;-1:-1:-1;;;;;;43516:19:0::1;::::0;;43382:161::o;48018:115::-;48097:28;48107:8;48117:7;48097:9;:28::i;41956:120::-;-1:-1:-1;;;;;42044:14:0;;42017:7;42044:14;;;:7;:14;;;;;:24;;:22;:24::i;42731:88::-;42805:6;;-1:-1:-1;;;;;42805:6:0;42731:88;:::o;45054:29::-;;;-1:-1:-1;;;;;45054:29:0;;:::o;28691:87::-;28763:7;28756:14;;;;;;;;-1:-1:-1;;28756:14:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;28730:13;;28756:14;;28763:7;;28756:14;;28763:7;28756:14;;;;;;;;;;;;;;;;;;;;;;;;48141:347;48221:27;48260:121;48310:7;48260:121;;;;;;;;;;;;;;;;;:31;48270:8;48280:10;48260:9;:31::i;:::-;:35;:121;:35;:121::i;:::-;48221:160;;48394:51;48403:8;48413:10;48425:19;48394:8;:51::i;:::-;48456:24;48462:8;48472:7;48456:5;:24::i;:::-;48141:347;;;:::o;32921:265::-;33014:4;33031:125;33040:10;33052:7;33061:94;33098:15;33061:94;;;;;;;;;;;;;;;;;33073:10;33061:23;;;;:11;:23;;;;;;;;-1:-1:-1;;;;;33061:32:0;;;;;;;;;;;:94;:36;:94::i;30217:173::-;30303:4;30320:40;30330:10;30342:9;30353:6;30320:9;:40::i;45822:260::-;42953:6;;-1:-1:-1;;;;;42953:6:0;42963:10;42953:20;42944:67;;;;;-1:-1:-1;;;42944:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;42944:67:0;;;;;;;;;;;;;;;45919:49:::1;:20;45945:21:::0;45919:24:::1;:49::i;:::-;45910:108;;;;-1:-1:-1::0;;;45910:108:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46034:40;::::0;-1:-1:-1;;;;;46034:40:0;::::1;::::0;::::1;::::0;;;::::1;45822:260:::0;:::o;45092:27::-;;;;:::o;41122:766::-;41367:8;41348:15;:27;;41340:64;;;;;-1:-1:-1;;;41340:64:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;41509:14:0;;41417:18;41509:14;;;:7;:14;;;;;40460:66;;41485:5;;41492:7;;41501:6;;41509:24;;:22;:24::i;:::-;41457:87;;;;;;;;;;;-1:-1:-1;;;;;41457:87:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;41447:98;;;;;;41617:16;;-1:-1:-1;;;41584:62:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;41574:73;;;;;;;;;-1:-1:-1;41677:25:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;41447:98;;-1:-1:-1;41574:73:0;;41677:25;;;;;;;-1:-1:-1;;41677:25:0;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;41677:25:0;;-1:-1:-1;;41677:25:0;;;-1:-1:-1;;;;;;;41721:20:0;;;;;;:39;;;41755:5;-1:-1:-1;;;;;41745:15:0;:6;-1:-1:-1;;;;;41745:15:0;;41721:39;41713:85;;;;-1:-1:-1;;;41713:85:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;41811:14:0;;;;;;:7;:14;;;;;:26;;:24;:26::i;:::-;41848:32;41857:5;41864:7;41873:6;41848:8;:32::i;:::-;41122:766;;;;;;;;;;:::o;30479:151::-;-1:-1:-1;;;;;30595:18:0;;;30568:7;30595:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;30479:151::o;46090:259::-;42953:6;;-1:-1:-1;;;;;42953:6:0;42963:10;42953:20;42944:67;;;;;-1:-1:-1;;;42944:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;42944:67:0;;;;;;;;;;;;;;;46188:50:::1;:20;46217:19:::0;46188:27:::1;:50::i;:::-;46179:106;;;;-1:-1:-1::0;;;46179:106:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46301:40;::::0;-1:-1:-1;;;;;46301:40:0;::::1;::::0;::::1;::::0;;;::::1;46090:259:::0;:::o;43698:264::-;42953:6;;-1:-1:-1;;;;;42953:6:0;42963:10;42953:20;42944:67;;;;;-1:-1:-1;;;42944:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;42944:67:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;43802:23:0;::::1;43793:75;;;;-1:-1:-1::0;;;43793:75:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43906:6;::::0;43884:41:::1;::::0;-1:-1:-1;;;;;43884:41:0;;::::1;::::0;43906:6:::1;::::0;43884:41:::1;::::0;43906:6:::1;::::0;43884:41:::1;43936:6;:18:::0;;-1:-1:-1;;;;;;43936:18:0::1;-1:-1:-1::0;;;;;43936:18:0;;;::::1;::::0;;;::::1;::::0;;43698:264::o;44254:79::-;44319:6;;-1:-1:-1;;;;;44319:6:0;44254:79;:::o;36159:346::-;-1:-1:-1;;;;;36261:19:0;;36253:68;;;;-1:-1:-1;;;36253:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;36340:21:0;;36332:68;;;;-1:-1:-1;;;36332:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;36413:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;36465:32;;;;;;;;;;;;;;;;;36159:346;;;:::o;33676:539::-;-1:-1:-1;;;;;33782:20:0;;33774:70;;;;-1:-1:-1;;;33774:70:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;33863:23:0;;33855:71;;;;-1:-1:-1;;;33855:71:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;33939:47;33960:6;33968:9;33979:6;33939:20;:47::i;:::-;34019:71;34041:6;34019:71;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;34019:17:0;;:9;:17;;;;;;;;;;;;:71;:21;:71::i;:::-;-1:-1:-1;;;;;33999:17:0;;;:9;:17;;;;;;;;;;;:91;;;;34124:20;;;;;;;:32;;34149:6;34124:24;:32::i;:::-;-1:-1:-1;;;;;34101:20:0;;;:9;:20;;;;;;;;;;;;:55;;;;34172:35;;;;;;;34101:20;;34172:35;;;;;;;;;;;;;33676:539;;;:::o;21821:192::-;21907:7;21943:12;21935:6;;;;21927:29;;;;-1:-1:-1;;;21927:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;21979:5:0;;;21821:192::o;20918:181::-;20976:7;21008:5;;;21032:6;;;;21024:46;;;;;-1:-1:-1;;;21024:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;21090:1;20918:181;-1:-1:-1;;;20918:181:0:o;34523:395::-;-1:-1:-1;;;;;34609:22:0;;34601:66;;;;;-1:-1:-1;;;34601:66:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;34678:56;34708:4;34716:8;34726:7;34678:20;:56::i;:::-;34760:12;;:25;;34777:7;34760:16;:25::i;:::-;34745:12;:40;-1:-1:-1;;;;;34818:19:0;;:9;:19;;;;;;;;;;;:32;;34842:7;34818:23;:32::i;:::-;-1:-1:-1;;;;;34796:19:0;;:9;:19;;;;;;;;;;;;:54;;;;34866:44;;;;;;;34796:19;;34884:4;;34866:44;;;;;;;;;;34523:395;;:::o;35277:418::-;-1:-1:-1;;;;;35361:21:0;;35353:67;;;;-1:-1:-1;;;35353:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;35433:49;35454:7;35471:1;35475:6;35433:20;:49::i;:::-;35516:68;35539:6;35516:68;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;35516:18:0;;:9;:18;;;;;;;;;;;;:68;:22;:68::i;:::-;-1:-1:-1;;;;;35495:18:0;;:9;:18;;;;;;;;;;:89;35610:12;;:24;;35627:6;35610:16;:24::i;:::-;35595:12;:39;35650:37;;;;;;;;35676:1;;-1:-1:-1;;;;;35650:37:0;;;;;;;;;;;;35277:418;;:::o;38241:114::-;38333:14;;38241:114::o;12681:143::-;12751:4;12775:41;12780:3;-1:-1:-1;;;;;12800:14:0;;12775:4;:41::i;38363:181::-;38517:19;;38535:1;38517:19;;;38363:181::o;13000:149::-;13073:4;13097:44;13105:3;-1:-1:-1;;;;;13125:14:0;;13097:7;:44::i;46640:388::-;46758:38;:20;46789:5;46758:29;:38::i;:::-;46754:267;;;46814:43;46833:5;46840:15;;46814:17;:43::i;:::-;46754:267;;;46895:36;:20;46926:3;46895:29;:36::i;:::-;46890:120;;;46953:41;46972:3;46977:15;;46953:17;:41::i;21382:136::-;21440:7;21467:43;21471:1;21474;21467:43;;;;;;;;;;;;;;;;;:3;:43::i;4255:414::-;4318:4;4340:21;4350:3;4355:5;4340:9;:21::i;:::-;4335:327;;-1:-1:-1;4378:23:0;;;;;;;;:11;:23;;;;;;;;;;;;;4561:18;;4539:19;;;:12;;;:19;;;;;;:40;;;;4594:11;;4335:327;-1:-1:-1;4645:5:0;4638:12;;4845:1544;4911:4;5050:19;;;:12;;;:19;;;;;;5086:15;;5082:1300;;5521:18;;-1:-1:-1;;5472:14:0;;;;5521:22;;;;5448:21;;5521:3;;:22;;5808;;;;;;;;;;;;;;5788:42;;5954:9;5925:3;:11;;5937:13;5925:26;;;;;;;;;;;;;;;;;;;:38;;;;6031:23;;;6073:1;6031:12;;;:23;;;;;;6057:17;;;6031:43;;6183:17;;6031:3;;6183:17;;;;;;;;;;;;;;;;;;;;;;6278:3;:12;;:19;6291:5;6278:19;;;;;;;;;;;6271:26;;;6321:4;6314:11;;;;;;;;5082:1300;6365:5;6358:12;;;;;13235:158;13315:4;13339:46;13349:3;-1:-1:-1;;;;;13369:14:0;;13339:9;:46::i;46357:275::-;46472:53;:20;46503;46472:29;:53::i;:::-;46467:158;;;46542:10;;:71;;;-1:-1:-1;;;46542:71:0;;-1:-1:-1;;;;;46542:71:0;;;;;;;;;;;;;;;:10;;;;;:21;;:71;;;;;;;;;;;;;;:10;;:71;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;46357:275:0;;:::o;6475:129::-;6548:4;6572:19;;;:12;;;;;:19;;;;;;:24;;;6475:129::o

Swarm Source

ipfs://ab5dd5d39686d305673b205afc20fda435e60f406e62ad386608fec5ffbfe3f2
Block Transaction Gas Used Reward
Age Block Fee Address BC Fee Address Voting Power Jailed Incoming
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.