ETH Price: $3,983.03 (+1.88%)

Contract

0xEEF9f339514298C6A857EfCfC1A762aF84438dEE
 

Multichain Info

No addresses found
Transaction Hash
Method
Block
From
To
Approve213292572024-12-04 12:52:472 days ago1733316767IN
Hermez Network: HEZ Token
0 ETH0.0010124321.85502111
Transfer213290512024-12-04 12:11:232 days ago1733314283IN
Hermez Network: HEZ Token
0 ETH0.0011402622.09944972
Approve213217922024-12-03 11:51:113 days ago1733226671IN
Hermez Network: HEZ Token
0 ETH0.0011501924.79675419
Approve213211382024-12-03 9:39:353 days ago1733218775IN
Hermez Network: HEZ Token
0 ETH0.0008803219.1170532
Approve213006872024-11-30 13:07:356 days ago1732972055IN
Hermez Network: HEZ Token
0 ETH0.000433089.34877684
Approve212480052024-11-23 4:19:3513 days ago1732335575IN
Hermez Network: HEZ Token
0 ETH0.0007506216.18251322
Approve212423502024-11-22 9:23:1114 days ago1732267391IN
Hermez Network: HEZ Token
0 ETH0.000429369.31682469
Approve212187762024-11-19 2:25:4718 days ago1731983147IN
Hermez Network: HEZ Token
0 ETH0.000478410.39177617
Approve212040042024-11-17 1:00:3520 days ago1731805235IN
Hermez Network: HEZ Token
0 ETH0.0005224511.26334897
Transfer212039772024-11-17 0:55:1120 days ago1731804911IN
Hermez Network: HEZ Token
0 ETH0.0005010610.70452659
Approve211988152024-11-16 7:38:3520 days ago1731742715IN
Hermez Network: HEZ Token
0 ETH0.0006202913.37267204
Transfer211883192024-11-14 20:28:2322 days ago1731616103IN
Hermez Network: HEZ Token
0 ETH0.000791526.66340598
Approve211737282024-11-12 19:35:2324 days ago1731440123IN
Hermez Network: HEZ Token
0 ETH0.001492232.18656686
Transfer211737122024-11-12 19:32:1124 days ago1731439931IN
Hermez Network: HEZ Token
0 ETH0.0020722644.25920816
Approve211722882024-11-12 14:45:5924 days ago1731422759IN
Hermez Network: HEZ Token
0 ETH0.0011595725.148646
Transfer211626812024-11-11 6:34:5925 days ago1731306899IN
Hermez Network: HEZ Token
0 ETH0.0003700712.46168093
Approve211601182024-11-10 22:00:1126 days ago1731276011IN
Hermez Network: HEZ Token
0 ETH0.0009242819.92646788
Approve211601072024-11-10 21:57:5926 days ago1731275879IN
Hermez Network: HEZ Token
0 ETH0.0010215522.02335739
Transfer211557042024-11-10 7:14:3526 days ago1731222875IN
Hermez Network: HEZ Token
0 ETH0.000469879.10661054
Approve211503352024-11-09 13:15:5927 days ago1731158159IN
Hermez Network: HEZ Token
0 ETH0.0007136715.48207545
Transfer211448592024-11-08 18:57:1128 days ago1731092231IN
Hermez Network: HEZ Token
0 ETH0.0008720616.90534928
Approve211410712024-11-08 6:16:1128 days ago1731046571IN
Hermez Network: HEZ Token
0 ETH0.000458359.88147725
Approve211269062024-11-06 6:45:2330 days ago1730875523IN
Hermez Network: HEZ Token
0 ETH0.0016176434.87429206
Approve211170632024-11-04 21:46:3532 days ago1730756795IN
Hermez Network: HEZ Token
0 ETH0.0005420211.74926651
Approve211163522024-11-04 19:23:4732 days ago1730748227IN
Hermez Network: HEZ Token
0 ETH0.000149676.21049555
View all transactions

View more zero value Internal Transactions in Advanced View mode

Advanced mode:
Loading...
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
HEZ

Compiler Version
v0.6.12+commit.27d51765

Optimization Enabled:
Yes with 999999 runs

Other Settings:
default evmVersion, GNU GPLv3 license
File 1 of 14 : HEZToken.sol
// SPDX-License-Identifier: GPL-3.0

pragma solidity 0.6.12;

import "./interfaces/IERC20.sol";
import "./libraries/SafeMath.sol";

// Lightweight token modelled after UNI-LP: 
// https://github.com/Uniswap/uniswap-v2-core/blob/v1.0.1/contracts/UniswapV2ERC20.sol
// Adds:
//   - An exposed `burn()`
//   - ERC-3009 (`transferWithAuthorization()`)
//   - domainSeparator is computed inside `_validateSignedData` to avoid reply-attacks due to Hardforks
//   - to != address(this) && to != address(0); To avoid people sending tokens to this smartcontract and 
//          to distinguish burn events from transfer

contract HEZ is IERC20 {
    using SafeMath for uint256;

    uint8 public constant decimals = 18;    
    string public constant symbol = "HEZ";
    string public constant name = "Hermez Network Token";
    uint256 public constant initialBalance = 100_000_000 * (1e18);

    // bytes32 public constant PERMIT_TYPEHASH = 
    //      keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
    bytes32 public constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
    // bytes32 public constant TRANSFER_WITH_AUTHORIZATION_TYPEHASH =
    //      keccak256("TransferWithAuthorization(address from,address to,uint256 value,uint256 validAfter,uint256 validBefore,bytes32 nonce)");
    bytes32 public constant TRANSFER_WITH_AUTHORIZATION_TYPEHASH = 0x7c7c6cdb67a18743f49ec6fa9b35f50d52ed05cbed4cc592e13b44501c1a2267;
    // bytes32 public constant EIP712DOMAIN_HASH =
    //      keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)")
    bytes32 public constant EIP712DOMAIN_HASH = 0x8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f;
    // bytes32 public constant NAME_HASH =
    //      keccak256("Hermez Network Token")
    bytes32 public constant NAME_HASH = 0x64c0a41a0260272b78f2a5bd50d5ff7c1779bc3bba16dcff4550c7c642b0e4b4;
    // bytes32 public constant VERSION_HASH =
    //      keccak256("1")
    bytes32 public constant VERSION_HASH = 0xc89efdaa54c0f20c7adf612882df0950f5a951637e0307cdcb4c672f298b8bc6;

    uint256 public override totalSupply;
    mapping(address => uint256) public override balanceOf;
    mapping(address => mapping(address => uint256)) public override allowance;
    mapping(address => uint256) public nonces;
    mapping(address => mapping(bytes32 => bool)) public authorizationState;

    event Approval(address indexed owner, address indexed spender, uint256 value);
    event Transfer(address indexed from, address indexed to, uint256 value);
    event AuthorizationUsed(address indexed authorizer, bytes32 indexed nonce);

    constructor(address initialHolder) public {
        _mint(initialHolder, initialBalance);
    }

    function _validateSignedData(
        address signer,
        bytes32 encodeData,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal view {
        bytes32 domainSeparator = keccak256(
            abi.encode(
                EIP712DOMAIN_HASH,
                NAME_HASH,
                VERSION_HASH,
                getChainId(),
                address(this)
            )
        );

        bytes32 digest = keccak256(
            abi.encodePacked("\x19\x01", domainSeparator, encodeData)
        );
        address recoveredAddress = ecrecover(digest, v, r, s);
        // Explicitly disallow authorizations for address(0) as ecrecover returns address(0) on malformed messages
        require(
            recoveredAddress != address(0) && recoveredAddress == signer,
            "HEZ::_validateSignedData: INVALID_SIGNATURE"
        );
    }

    function getChainId() public pure returns (uint256 chainId){
        assembly { chainId := chainid() }
    }

    function _mint(address to, uint256 value) internal {
        totalSupply = totalSupply.add(value);
        balanceOf[to] = balanceOf[to].add(value);
        emit Transfer(address(0), to, value);
    }

    function _burn(address from, uint value) internal {
        // Balance is implicitly checked with SafeMath's underflow protection
        balanceOf[from] = balanceOf[from].sub(value);
        totalSupply = totalSupply.sub(value);
        emit Transfer(from, address(0), value);
    }

    function _approve(
        address owner,
        address spender,
        uint256 value
    ) private {
        allowance[owner][spender] = value;
        emit Approval(owner, spender, value);
    }

    function _transfer(
        address from,
        address to,
        uint256 value
    ) private {
        require(
            to != address(this) && to != address(0),
            "HEZ::_transfer: NOT_VALID_TRANSFER"
        );
        // Balance is implicitly checked with SafeMath's underflow protection
        balanceOf[from] = balanceOf[from].sub(value);
        balanceOf[to] = balanceOf[to].add(value);
        emit Transfer(from, to, value);
    }

    function burn(uint256 value) external returns (bool) {
        _burn(msg.sender, value);
        return true;
    }

    function approve(address spender, uint256 value)
        external
        override
        returns (bool)
    {
        _approve(msg.sender, spender, value);
        return true;
    }

    function transfer(address to, uint256 value)
        external
        override
        returns (bool)
    {
        _transfer(msg.sender, to, value);
        return true;
    }

    function transferFrom(
        address from,
        address to,
        uint256 value
    ) external override returns (bool) {
        uint256 fromAllowance = allowance[from][msg.sender];
        if (fromAllowance != uint256(-1)) {
            // Allowance is implicitly checked with SafeMath's underflow protection
            allowance[from][msg.sender] = fromAllowance.sub(value);
        }
        _transfer(from, to, value);
        return true;
    }

    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external {
        require(deadline >= block.timestamp, "HEZ::permit: AUTH_EXPIRED");
        bytes32 encodeData = keccak256(
            abi.encode(
                PERMIT_TYPEHASH,
                owner,
                spender,
                value,
                nonces[owner]++,
                deadline
            )
        );
        _validateSignedData(owner, encodeData, v, r, s);
        _approve(owner, spender, value);
    }

    function transferWithAuthorization(
        address from,
        address to,
        uint256 value,
        uint256 validAfter,
        uint256 validBefore,
        bytes32 nonce,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external {
        require(block.timestamp > validAfter, "HEZ::transferWithAuthorization: AUTH_NOT_YET_VALID");
        require(block.timestamp < validBefore, "HEZ::transferWithAuthorization: AUTH_EXPIRED");
        require(!authorizationState[from][nonce], "HEZ::transferWithAuthorization: AUTH_ALREADY_USED");

        bytes32 encodeData = keccak256(
            abi.encode(
                TRANSFER_WITH_AUTHORIZATION_TYPEHASH,
                from,
                to,
                value,
                validAfter,
                validBefore,
                nonce
            )
        );
        _validateSignedData(from, encodeData, v, r, s);

        authorizationState[from][nonce] = true;
        _transfer(from, to, value);
        emit AuthorizationUsed(from, nonce);
    }
}

File 2 of 14 : BootstrapDistribution.sol
// SPDX-License-Identifier: GPL-3.0

import "@openzeppelin/contracts/math/SafeMath.sol";

pragma solidity 0.6.12;
interface HermezVesting {
    function move(address recipient, uint256 amount) external;
    function changeAddress(address newAddress) external;
} 
interface HEZ {
    function approve(address spender, uint256 amount) external returns (bool);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address recipient, uint256 amount) external returns (bool);
}

contract BootstrapDistribution {
    using SafeMath for uint256;

    HEZ public constant TOKEN_ADDRESS = HEZ(0xEEF9f339514298C6A857EfCfC1A762aF84438dEE);
    HermezVesting public constant VESTING_0 = HermezVesting(0x8109dfB06D4d9e694a8349B855cBF493A0B22186);
    HermezVesting public constant VESTING_1 = HermezVesting(0xDd90cA911a5dbfB1624fF7Eb586901a9b4BFC53D);
    HermezVesting public constant VESTING_2 = HermezVesting(0xB213aeAeF76f82e42263fe896433A260EF018df2);
    HermezVesting public constant VESTING_3 = HermezVesting(0x3049399e1308db7d2b28488880C6cFE9Aa003275);
    address public constant MULTISIG_VESTING_2  = 0xC21BE548060cB6E07017bFc0b926A71b5E638e09;
    address public constant MULTISIG_VESTING_3  = 0x5Fa543E23a1B62e45d010f81AFC0602456BD1F1d;
    address public constant VESTING_0_ADDRESS_0 = 0x94E886bB17451A7B82E594db12570a5AdFC2D453;
    address public constant VESTING_0_ADDRESS_1 = 0x4FE10B3e306aC1F4b966Db07f031ae5780BC48fB;
    address public constant VESTING_0_ADDRESS_2 = 0x6629300128CCdda1e88641Ba2941a22Ce82F5df9;
    address public constant VESTING_0_ADDRESS_3 = 0xEb60e28Ce3aCa617d1E0293791c1903cF022b9Cd;
    address public constant VESTING_0_ADDRESS_4 = 0x9a415E0cE643abc4AD953B651b2D7e4db2FF3bEa;
    address public constant VESTING_0_ADDRESS_5 = 0x15b54c53093aF3e11d787db86e268a6C4F2F72A2;
    address public constant VESTING_0_ADDRESS_6 = 0x3279c71F132833190F6cd1D6a9975FFBf8d7C6dC;
    address public constant VESTING_0_ADDRESS_7 = 0x312e6f33155177774CDa1A3C4e9f077D93266063;
    address public constant VESTING_0_ADDRESS_8 = 0x47690A724Ed551fe2ff1A5eBa335B7c1B7a40990;
    address public constant VESTING_1_ADDRESS_0 = 0x80FbB6dd386FC98D2B387F37845A373c8441c069;
    address public constant VESTING_2_ADDRESS_0 = 0xBd48F607E26d94772FB21ED1d814F9F116dBD95C;
    address public constant VESTING_3_ADDRESS_0 = 0x520Cf70a2D0B3dfB7386A2Bc9F800321F62a5c3a;
    address public constant NO_VESTED_ADDRESS_0 = 0x4D4a7675CC0eb0a3B1d81CbDcd828c4BD0D74155;
    address public constant NO_VESTED_ADDRESS_1 = 0x9CdaeBd2bcEED9EB05a3B3cccd601A40CB0026be;
    address public constant NO_VESTED_ADDRESS_2 = 0x9315F815002d472A3E993ac9dc7461f2601A3c09;
    address public constant NO_VESTED_ADDRESS_3 = 0xF96A39d61F6972d8dC0CCd2A3c082eD922E096a7;
    address public constant NO_VESTED_ADDRESS_4 = 0xA93Bb239509D16827B7ee9DA7dA6Fc8478837247;
    address public constant NO_VESTED_ADDRESS_5 = 0x99Ae889E171B82BB04FD22E254024716932e5F2f;
    uint256 public constant VESTING_0_AMOUNT            = 20_000_000 ether;
    uint256 public constant VESTING_1_AMOUNT            = 10_000_000 ether;
    uint256 public constant VESTING_2_AMOUNT            =  6_200_000 ether;
    uint256 public constant VESTING_3_AMOUNT            = 17_500_000 ether;    
    uint256 public constant VESTING_0_ADDRESS_0_AMOUNT  = 12_000_000 ether;
    uint256 public constant VESTING_0_ADDRESS_1_AMOUNT  =  1_850_000 ether;
    uint256 public constant VESTING_0_ADDRESS_2_AMOUNT  =  1_675_000 ether;
    uint256 public constant VESTING_0_ADDRESS_3_AMOUNT  =  1_300_000 ether;
    uint256 public constant VESTING_0_ADDRESS_4_AMOUNT  =  1_000_000 ether;
    uint256 public constant VESTING_0_ADDRESS_5_AMOUNT  =    750_000 ether;
    uint256 public constant VESTING_0_ADDRESS_6_AMOUNT  =    625_000 ether;
    uint256 public constant VESTING_0_ADDRESS_7_AMOUNT  =    525_000 ether;
    uint256 public constant VESTING_0_ADDRESS_8_AMOUNT  =    275_000 ether;
    uint256 public constant VESTING_1_ADDRESS_0_AMOUNT  = 10_000_000 ether;
    uint256 public constant VESTING_2_ADDRESS_0_AMOUNT  =    500_000 ether;
    uint256 public constant VESTING_3_ADDRESS_0_AMOUNT  =    300_000 ether;
    uint256 public constant NO_VESTED_ADDRESS_0_AMOUNT  = 19_000_000 ether;
    uint256 public constant NO_VESTED_ADDRESS_1_AMOUNT  =  9_000_000 ether;
    uint256 public constant NO_VESTED_ADDRESS_2_AMOUNT  =  7_500_000 ether;
    uint256 public constant NO_VESTED_ADDRESS_3_AMOUNT  =  5_000_000 ether;
    uint256 public constant NO_VESTED_ADDRESS_4_AMOUNT  =  3_000_000 ether;
    uint256 public constant NO_VESTED_ADDRESS_5_AMOUNT  =  2_800_000 ether;
    uint256 public constant INTERMEDIATE_BALANCE        = 46_300_000 ether;

    function distribute() public {
        require(
            TOKEN_ADDRESS.balanceOf(address(this)) == (100_000_000 ether), 
            "BootstrapDistribution::distribute NOT_ENOUGH_BALANCE"
        );

        // Vested Tokens
        // Transfer HEZ tokens
        TOKEN_ADDRESS.transfer(address(VESTING_0),VESTING_0_AMOUNT);
        TOKEN_ADDRESS.transfer(address(VESTING_1),VESTING_1_AMOUNT);
        TOKEN_ADDRESS.transfer(address(VESTING_2),VESTING_2_AMOUNT);
        TOKEN_ADDRESS.transfer(address(VESTING_3),VESTING_3_AMOUNT);
        // Transfer vested tokens
        transferVestedTokens0();
        transferVestedTokens1();
        transferVestedTokens2();
        transferVestedTokens3();

        // Check intermediate balance
        require(
            TOKEN_ADDRESS.balanceOf(address(this)) == INTERMEDIATE_BALANCE,
            "BootstrapDistribution::distribute NOT_ENOUGH_NO_VESTED_BALANCE"
        );

        // No Vested Tokens
        TOKEN_ADDRESS.transfer(NO_VESTED_ADDRESS_0, NO_VESTED_ADDRESS_0_AMOUNT);
        TOKEN_ADDRESS.transfer(NO_VESTED_ADDRESS_1, NO_VESTED_ADDRESS_1_AMOUNT);
        TOKEN_ADDRESS.transfer(NO_VESTED_ADDRESS_2, NO_VESTED_ADDRESS_2_AMOUNT);
        TOKEN_ADDRESS.transfer(NO_VESTED_ADDRESS_3, NO_VESTED_ADDRESS_3_AMOUNT);
        TOKEN_ADDRESS.transfer(NO_VESTED_ADDRESS_4, NO_VESTED_ADDRESS_4_AMOUNT);
        TOKEN_ADDRESS.transfer(NO_VESTED_ADDRESS_5, NO_VESTED_ADDRESS_5_AMOUNT);

        require(
            TOKEN_ADDRESS.balanceOf(address(this)) == 0, 
            "BootstrapDistribution::distribute PENDING_BALANCE"
        );
    }

    function transferVestedTokens0() internal {
        VESTING_0.move(VESTING_0_ADDRESS_0, VESTING_0_ADDRESS_0_AMOUNT);
        VESTING_0.move(VESTING_0_ADDRESS_1, VESTING_0_ADDRESS_1_AMOUNT);
        VESTING_0.move(VESTING_0_ADDRESS_2, VESTING_0_ADDRESS_2_AMOUNT);
        VESTING_0.move(VESTING_0_ADDRESS_3, VESTING_0_ADDRESS_3_AMOUNT);
        VESTING_0.move(VESTING_0_ADDRESS_4, VESTING_0_ADDRESS_4_AMOUNT);
        VESTING_0.move(VESTING_0_ADDRESS_5, VESTING_0_ADDRESS_5_AMOUNT);
        VESTING_0.move(VESTING_0_ADDRESS_6, VESTING_0_ADDRESS_6_AMOUNT);
        VESTING_0.move(VESTING_0_ADDRESS_7, VESTING_0_ADDRESS_7_AMOUNT);
        VESTING_0.move(VESTING_0_ADDRESS_8, VESTING_0_ADDRESS_8_AMOUNT);
        VESTING_0.changeAddress(address(0));
    }

    function transferVestedTokens1() internal {
        VESTING_1.move(VESTING_1_ADDRESS_0, VESTING_1_ADDRESS_0_AMOUNT);
        VESTING_1.changeAddress(address(0));
    }

    function transferVestedTokens2() internal {
        VESTING_2.move(VESTING_2_ADDRESS_0, VESTING_2_ADDRESS_0_AMOUNT);
        VESTING_2.changeAddress(MULTISIG_VESTING_2);    
    }

    function transferVestedTokens3() internal {
        VESTING_3.move(VESTING_3_ADDRESS_0, VESTING_3_ADDRESS_0_AMOUNT);
        VESTING_3.changeAddress(MULTISIG_VESTING_3);  
    }
}

File 3 of 14 : SafeMath.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.6.0;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
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;
    }
}

File 4 of 14 : HermezVesting.sol
// SPDX-License-Identifier: GPL-3.0

pragma solidity 0.6.12;

import "@openzeppelin/contracts/math/SafeMath.sol";
import "./interfaces/IERC20.sol";

contract HermezVesting {
    using SafeMath for uint256;

    address public distributor;

    mapping(address => uint256) public vestedTokens;
    mapping(address => uint256) public withdrawed;
    uint256 public totalVestedTokens;

    uint256 public startTime;
    uint256 public cliffTime;
    uint256 public endTime;
    uint256 public initialPercentage;

    address public constant HEZ = address(
        0xEEF9f339514298C6A857EfCfC1A762aF84438dEE
    );

    event Withdraw(address indexed recipient, uint256 amount);
    event Move(address indexed from, address indexed to, uint256 value);
    event ChangeAddress(address indexed oldAddress, address indexed newAddress);

    constructor(
        address _distributor,
        uint256 _totalVestedTokens,
        uint256 _startTime,
        uint256 _startToCliff,
        uint256 _startToEnd,
        uint256 _initialPercentage
    ) public {
        require(
            _startToEnd >= _startToCliff,
            "HermezVesting::constructor: START_GREATER_THAN_CLIFF"
        );
        require(
            _initialPercentage <= 100,
            "HermezVesting::constructor: INITIALPERCENTAGE_GREATER_THAN_100"
        );
        distributor = _distributor;
        totalVestedTokens = _totalVestedTokens;
        vestedTokens[_distributor] = _totalVestedTokens;
        startTime = _startTime;
        cliffTime = _startTime + _startToCliff;
        endTime = _startTime + _startToEnd;
        initialPercentage = _initialPercentage;
    }

    function totalTokensUnlockedAt(uint256 timestamp)
        public
        view
        returns (uint256)
    {
        if (timestamp < startTime) return 0;
        if (timestamp > endTime) return totalVestedTokens;

        uint256 initialAmount = totalVestedTokens.mul(initialPercentage).div(
            100
        );
        if (timestamp < cliffTime) return initialAmount;

        uint256 deltaT = timestamp.sub(startTime);
        uint256 deltaTTotal = endTime.sub(startTime);
        uint256 deltaAmountTotal = totalVestedTokens.sub(initialAmount);
        return initialAmount.add(deltaT.mul(deltaAmountTotal).div(deltaTTotal));
    }

    function withdrawableTokens(address recipient)
        public
        view
        returns (uint256)
    {
        return withdrawableTokensAt(recipient, block.timestamp);
    }

    function withdrawableTokensAt(address recipient, uint256 timestamp)
        public
        view
        returns (uint256)
    {
        uint256 unlockedAmount = totalTokensUnlockedAt(timestamp)
            .mul(vestedTokens[recipient])
            .div(totalVestedTokens);
        return unlockedAmount.sub(withdrawed[recipient]);
    }

    function withdraw() external {
        require(
            msg.sender != distributor,
            "HermezVesting::withdraw: DISTRIBUTOR_CANNOT_WITHDRAW"
        );

        uint256 remainingToWithdraw = withdrawableTokensAt(
            msg.sender,
            block.timestamp
        );

        withdrawed[msg.sender] = withdrawed[msg.sender].add(
            remainingToWithdraw
        );

        require(
            IERC20(HEZ).transfer(msg.sender, remainingToWithdraw),
            "HermezVesting::withdraw: TOKEN_TRANSFER_ERROR"
        );

        emit Withdraw(msg.sender, remainingToWithdraw);
    }

    function move(address recipient, uint256 amount) external {
        require(
            msg.sender == distributor,
            "HermezVesting::changeAddress: ONLY_DISTRIBUTOR"
        );
        vestedTokens[msg.sender] = vestedTokens[msg.sender].sub(amount);
        vestedTokens[recipient] = vestedTokens[recipient].add(amount);
        emit Move(msg.sender, recipient, amount);
    }

    function changeAddress(address newAddress) external {
        require(
            vestedTokens[newAddress] == 0,
            "HermezVesting::changeAddress: ADDRESS_HAS_BALANCE"
        );
        require(
            withdrawed[newAddress] == 0,
            "HermezVesting::changeAddress: ADDRESS_ALREADY_WITHDRAWED"
        );

        vestedTokens[newAddress] = vestedTokens[msg.sender];
        vestedTokens[msg.sender] = 0;
        withdrawed[newAddress] = withdrawed[msg.sender];
        withdrawed[msg.sender] = 0;

        if (msg.sender == distributor) {
            distributor = newAddress;
        }

        emit ChangeAddress(msg.sender, newAddress);
    }
}

File 5 of 14 : IERC20.sol
// SPDX-License-Identifier: GPL-3.0

pragma solidity 0.6.12;

interface IERC20 {
    function totalSupply() external view returns (uint256);

    function balanceOf(address account) external view returns (uint256);

    function allowance(address owner, address spender)
        external
        view
        returns (uint256);

    function approve(address spender, uint256 amount) external returns (bool);

    function transfer(address recipient, uint256 amount)
        external
        returns (bool);

    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) external returns (bool);
}

File 6 of 14 : SafeMath.sol
// SPDX-License-Identifier: GPL-3.0

pragma solidity 0.6.12;

// A library for performing overflow-safe math, courtesy of DappHub: https://github.com/dapphub/ds-math/blob/d0ef6d6a5f/src/math.sol
// Modified to include only the essentials
library SafeMath {
    string private constant ERROR_ADD_OVERFLOW = "MATH:ADD_OVERFLOW";
    string private constant ERROR_SUB_UNDERFLOW = "MATH:SUB_UNDERFLOW";

    function add(uint256 x, uint256 y) internal pure returns (uint256 z) {
        require((z = x + y) >= x, ERROR_ADD_OVERFLOW);
    }

    function sub(uint256 x, uint256 y) internal pure returns (uint256 z) {
        require((z = x - y) <= x, ERROR_SUB_UNDERFLOW);
    }
}

File 7 of 14 : HEZTokenMock.sol
// SPDX-License-Identifier: GPL-3.0

pragma solidity 0.6.12;

import "../HEZToken.sol";

contract HEZMock is HEZ {
    constructor(address initialHolder)
        public
        HEZ(initialHolder)
    {}

    function mint(address to, uint256 value) external {
        super._mint(to, value);
    }
}

File 8 of 14 : UniPool.sol
// SPDX-License-Identifier: GPL-3.0

pragma solidity 0.6.12;

import "@openzeppelin/contracts/math/Math.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC777/IERC777Recipient.sol";
import "@openzeppelin/contracts/introspection/IERC1820Registry.sol";

contract LPTokenWrapper {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;

    // Uniswap v2 HEZ/ETH pair token
    IERC20 public UNI = IERC20(0x4a9EFa254085F36122d4b8BD2111544F8dC77052);

    uint256 private _totalSupply;
    mapping(address => uint256) private _balances;

    function totalSupply() public view returns (uint256) {
        return _totalSupply;
    }

    function balanceOf(address account) public view returns (uint256) {
        return _balances[account];
    }

    function stake(uint256 amount) public virtual {
        _totalSupply = _totalSupply.add(amount);
        _balances[msg.sender] = _balances[msg.sender].add(amount);
        UNI.safeTransferFrom(msg.sender, address(this), amount);
    }

    function withdraw(uint256 amount) public virtual {
        _totalSupply = _totalSupply.sub(amount);
        _balances[msg.sender] = _balances[msg.sender].sub(amount);
        UNI.safeTransfer(msg.sender, amount);
    }
}

contract Unipool is LPTokenWrapper, IERC777Recipient {
    uint256 public constant DURATION = 30 days;
    // Hermez Network Token
    IERC20 public HEZ = IERC20(0xcAEf929782361ccE9618c014D2867E423fE84ae7);

    IERC1820Registry private constant _ERC1820_REGISTRY = IERC1820Registry(
        0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24
    );
    bytes32 private constant _ERC777_RECIPIENT_INTERFACE_HASH = keccak256(
        "ERC777TokensRecipient"
    );

    uint256 public periodFinish;
    uint256 public rewardRate;
    uint256 public lastUpdateTime;
    uint256 public rewardPerTokenStored;
    mapping(address => uint256) public userRewardPerTokenPaid;
    mapping(address => uint256) public rewards;

    event RewardAdded(uint256 reward);
    event Staked(address indexed user, uint256 amount);
    event Withdrawn(address indexed user, uint256 amount);
    event RewardPaid(address indexed user, uint256 reward);

    modifier updateReward(address account) {
        rewardPerTokenStored = rewardPerToken();
        lastUpdateTime = lastTimeRewardApplicable();
        if (account != address(0)) {
            rewards[account] = earned(account);
            userRewardPerTokenPaid[account] = rewardPerTokenStored;
        }
        _;
    }

    constructor() public {
        _ERC1820_REGISTRY.setInterfaceImplementer(
            address(this),
            _ERC777_RECIPIENT_INTERFACE_HASH,
            address(this)
        );
    }

    function lastTimeRewardApplicable() public view returns (uint256) {
        return Math.min(block.timestamp, periodFinish);
    }

    function rewardPerToken() public view returns (uint256) {
        if (totalSupply() == 0) {
            return rewardPerTokenStored;
        }
        require(
            lastTimeRewardApplicable() >= lastUpdateTime,
            "lastTimeRewardApplicable < lastUpdateTime"
        );
        return
            rewardPerTokenStored.add(
                lastTimeRewardApplicable()
                    .sub(lastUpdateTime)
                    .mul(rewardRate)
                    .mul(1e18)
                    .div(totalSupply())
            );
    }

    function earned(address account) public view returns (uint256) {
        require(
            rewardPerToken() >= userRewardPerTokenPaid[account],
            "rewardPerToken() < userRewardPerTokenPaid[account] "
        );
        return
            balanceOf(account)
                .mul(rewardPerToken().sub(userRewardPerTokenPaid[account]))
                .div(1e18)
                .add(rewards[account]);
    }

    // stake visibility is public as overriding LPTokenWrapper's stake() function
    function stake(uint256 amount) public override updateReward(msg.sender) {
        require(amount > 0, "Cannot stake 0");
        super.stake(amount);
        emit Staked(msg.sender, amount);
    }

    function withdraw(uint256 amount) public override updateReward(msg.sender) {
        require(amount > 0, "Cannot withdraw 0");
        super.withdraw(amount);
        emit Withdrawn(msg.sender, amount);
    }

    function exit() external {
        withdraw(balanceOf(msg.sender));
        getReward();
    }

    function getReward() public updateReward(msg.sender) {
        uint256 reward = earned(msg.sender);
        if (reward > 0) {
            rewards[msg.sender] = 0;
            HEZ.safeTransfer(msg.sender, reward);
            emit RewardPaid(msg.sender, reward);
        }
    }

    function tokensReceived(
        // solhint-disable no-unused-vars
        address _operator,
        address _from,
        address _to,
        uint256 _amount,
        bytes calldata _userData,
        bytes calldata _operatorData
    ) external override updateReward(address(0)) {
        require(_amount > 0, "Cannot approve 0");
        require(msg.sender == address(HEZ), "Wrong token");
        require(
            _from == 0xF35960302a07022aBa880DFFaEC2Fdd64d5BF1c1,
            "Not allowed"
        );

        if (block.timestamp >= periodFinish) {
            rewardRate = _amount.div(DURATION);
        } else {
            uint256 remaining = periodFinish.sub(block.timestamp);
            uint256 leftover = remaining.mul(rewardRate);
            rewardRate = _amount.add(leftover).div(DURATION);
        }
        lastUpdateTime = block.timestamp;
        periodFinish = block.timestamp.add(DURATION);

        emit RewardAdded(_amount);
    }
}

File 9 of 14 : Math.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.6.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a >= b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow, so we distribute
        return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
    }
}

File 10 of 14 : SafeERC20.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.6.0;

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

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

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

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

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

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

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

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

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

File 11 of 14 : IERC20.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.6.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

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

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

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

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

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

File 12 of 14 : Address.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.6.2;

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

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

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

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

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

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

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

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

    function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
        require(isContract(target), "Address: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

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

File 13 of 14 : IERC777Recipient.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.6.0;

/**
 * @dev Interface of the ERC777TokensRecipient standard as defined in the EIP.
 *
 * Accounts can be notified of {IERC777} tokens being sent to them by having a
 * contract implement this interface (contract holders can be their own
 * implementer) and registering it on the
 * https://eips.ethereum.org/EIPS/eip-1820[ERC1820 global registry].
 *
 * See {IERC1820Registry} and {ERC1820Implementer}.
 */
interface IERC777Recipient {
    /**
     * @dev Called by an {IERC777} token contract whenever tokens are being
     * moved or created into a registered account (`to`). The type of operation
     * is conveyed by `from` being the zero address or not.
     *
     * This call occurs _after_ the token contract's state is updated, so
     * {IERC777-balanceOf}, etc., can be used to query the post-operation state.
     *
     * This function may revert to prevent the operation from being executed.
     */
    function tokensReceived(
        address operator,
        address from,
        address to,
        uint256 amount,
        bytes calldata userData,
        bytes calldata operatorData
    ) external;
}

File 14 of 14 : IERC1820Registry.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.6.0;

/**
 * @dev Interface of the global ERC1820 Registry, as defined in the
 * https://eips.ethereum.org/EIPS/eip-1820[EIP]. Accounts may register
 * implementers for interfaces in this registry, as well as query support.
 *
 * Implementers may be shared by multiple accounts, and can also implement more
 * than a single interface for each account. Contracts can implement interfaces
 * for themselves, but externally-owned accounts (EOA) must delegate this to a
 * contract.
 *
 * {IERC165} interfaces can also be queried via the registry.
 *
 * For an in-depth explanation and source code analysis, see the EIP text.
 */
interface IERC1820Registry {
    /**
     * @dev Sets `newManager` as the manager for `account`. A manager of an
     * account is able to set interface implementers for it.
     *
     * By default, each account is its own manager. Passing a value of `0x0` in
     * `newManager` will reset the manager to this initial state.
     *
     * Emits a {ManagerChanged} event.
     *
     * Requirements:
     *
     * - the caller must be the current manager for `account`.
     */
    function setManager(address account, address newManager) external;

    /**
     * @dev Returns the manager for `account`.
     *
     * See {setManager}.
     */
    function getManager(address account) external view returns (address);

    /**
     * @dev Sets the `implementer` contract as ``account``'s implementer for
     * `interfaceHash`.
     *
     * `account` being the zero address is an alias for the caller's address.
     * The zero address can also be used in `implementer` to remove an old one.
     *
     * See {interfaceHash} to learn how these are created.
     *
     * Emits an {InterfaceImplementerSet} event.
     *
     * Requirements:
     *
     * - the caller must be the current manager for `account`.
     * - `interfaceHash` must not be an {IERC165} interface id (i.e. it must not
     * end in 28 zeroes).
     * - `implementer` must implement {IERC1820Implementer} and return true when
     * queried for support, unless `implementer` is the caller. See
     * {IERC1820Implementer-canImplementInterfaceForAddress}.
     */
    function setInterfaceImplementer(address account, bytes32 interfaceHash, address implementer) external;

    /**
     * @dev Returns the implementer of `interfaceHash` for `account`. If no such
     * implementer is registered, returns the zero address.
     *
     * If `interfaceHash` is an {IERC165} interface id (i.e. it ends with 28
     * zeroes), `account` will be queried for support of it.
     *
     * `account` being the zero address is an alias for the caller's address.
     */
    function getInterfaceImplementer(address account, bytes32 interfaceHash) external view returns (address);

    /**
     * @dev Returns the interface hash for an `interfaceName`, as defined in the
     * corresponding
     * https://eips.ethereum.org/EIPS/eip-1820#interface-name[section of the EIP].
     */
    function interfaceHash(string calldata interfaceName) external pure returns (bytes32);

    /**
     *  @notice Updates the cache with whether the contract implements an ERC165 interface or not.
     *  @param account Address of the contract for which to update the cache.
     *  @param interfaceId ERC165 interface for which to update the cache.
     */
    function updateERC165Cache(address account, bytes4 interfaceId) external;

    /**
     *  @notice Checks whether a contract implements an ERC165 interface or not.
     *  If the result is not cached a direct lookup on the contract address is performed.
     *  If the result is not cached or the cached value is out-of-date, the cache MUST be updated manually by calling
     *  {updateERC165Cache} with the contract address.
     *  @param account Address of the contract to check.
     *  @param interfaceId ERC165 interface to check.
     *  @return True if `account` implements `interfaceId`, false otherwise.
     */
    function implementsERC165Interface(address account, bytes4 interfaceId) external view returns (bool);

    /**
     *  @notice Checks whether a contract implements an ERC165 interface or not without using nor updating the cache.
     *  @param account Address of the contract to check.
     *  @param interfaceId ERC165 interface to check.
     *  @return True if `account` implements `interfaceId`, false otherwise.
     */
    function implementsERC165InterfaceNoCache(address account, bytes4 interfaceId) external view returns (bool);

    event InterfaceImplementerSet(address indexed account, bytes32 indexed interfaceHash, address indexed implementer);

    event ManagerChanged(address indexed account, address indexed newManager);
}

Settings
{
  "metadata": {
    "useLiteralContent": false
  },
  "optimizer": {
    "enabled": true,
    "runs": 999999
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  }
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"address","name":"initialHolder","type":"address"}],"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":"authorizer","type":"address"},{"indexed":true,"internalType":"bytes32","name":"nonce","type":"bytes32"}],"name":"AuthorizationUsed","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":"EIP712DOMAIN_HASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"NAME_HASH","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":[],"name":"TRANSFER_WITH_AUTHORIZATION_TYPEHASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"VERSION_HASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"bytes32","name":"","type":"bytes32"}],"name":"authorizationState","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"value","type":"uint256"}],"name":"burn","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getChainId","outputs":[{"internalType":"uint256","name":"chainId","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"initialBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"permit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"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":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"validAfter","type":"uint256"},{"internalType":"uint256","name":"validBefore","type":"uint256"},{"internalType":"bytes32","name":"nonce","type":"bytes32"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"transferWithAuthorization","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

Deployed Bytecode

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

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

0000000000000000000000002dbe7d4b7812c32a37c3332c71fab7fde575e065

-----Decoded View---------------
Arg [0] : initialHolder (address): 0x2dbE7d4b7812C32A37c3332c71fAB7Fde575E065

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 0000000000000000000000002dbe7d4b7812c32a37c3332c71fab7fde575e065


Deployed Bytecode Sourcemap

612:6958:8:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1874:102;;;:::i;:::-;;;;;;;;;;;;;;;;762:52;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5081:184;;;;;;;;;;;;;;;;-1:-1:-1;5081:184:8;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;2167:35;;;:::i;820:61::-;;;:::i;5453:457::-;;;;;;;;;;;;;;;;-1:-1:-1;5453:457:8;;;;;;;;;;;;;;;;;;:::i;1047:108::-;;;:::i;674:35::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;;3683:108;;;:::i;4960:115::-;;;;;;;;;;;;;;;;-1:-1:-1;4960:115:8;;:::i;2208:53::-;;;;;;;;;;;;;;;;-1:-1:-1;2208:53:8;;;;:::i;2346:41::-;;;;;;;;;;;;;;;;-1:-1:-1;2346:41:8;;;;:::i;719:37::-;;;:::i;2055:105::-;;;:::i;1375:129::-;;;:::i;5271:176::-;;;;;;;;;;;;;;;;-1:-1:-1;5271:176:8;;;;;;;;;:::i;1669:110::-;;;:::i;5916:614::-;;;;;;;;;;;;;;;;-1:-1:-1;5916:614:8;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;2267:73;;;;;;;;;;;;;;;;-1:-1:-1;2267:73:8;;;;;;;;;;;:::i;6536:1032::-;;;;;;;;;;;;;;;;-1:-1:-1;6536:1032:8;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;2393:70::-;;;;;;;;;;;;;;;;-1:-1:-1;2393:70:8;;;;;;;;;:::i;1874:102::-;1910:66;1874:102;:::o;762:52::-;;;;;;;;;;;;;;;;;;;:::o;5081:184::-;5181:4;5201:36;5210:10;5222:7;5231:5;5201:8;:36::i;:::-;-1:-1:-1;5254:4:8;5081:184;;;;:::o;2167:35::-;;;;:::o;820:61::-;861:20;820:61;:::o;5453:457::-;5613:15;;;5573:4;5613:15;;;:9;:15;;;;;;;;5629:10;5613:27;;;;;;;;5679:2;5654:28;;5650:197;;5812:24;:13;5830:5;5812:17;:24::i;:::-;5782:15;;;;;;;:9;:15;;;;;;;;5798:10;5782:27;;;;;;;:54;5650:197;5856:26;5866:4;5872:2;5876:5;5856:9;:26::i;:::-;-1:-1:-1;5899:4:8;;5453:457;-1:-1:-1;;;;5453:457:8:o;1047:108::-;1089:66;1047:108;:::o;674:35::-;707:2;674:35;:::o;3683:108::-;3774:9;;3761:24::o;4960:115::-;5007:4;5023:24;5029:10;5041:5;5023;:24::i;:::-;-1:-1:-1;5064:4:8;4960:115;;;:::o;2208:53::-;;;;;;;;;;;;;:::o;2346:41::-;;;;;;;;;;;;;:::o;719:37::-;;;;;;;;;;;;;;;;;;;:::o;2055:105::-;2094:66;2055:105;:::o;1375:129::-;1438:66;1375:129;:::o;5271:176::-;5367:4;5387:32;5397:10;5409:2;5413:5;5387:9;:32::i;1669:110::-;1713:66;1669:110;:::o;5916:614::-;6129:15;6117:8;:27;;6109:65;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6360:13;;;;6184:18;6360:13;;;:6;:13;;;;;;;;;:15;;;;;;;;6228:187;;1089:66;6228:187;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6205:220;;;;;6435:47;6289:5;6205:220;6474:1;6477;6480;6435:19;:47::i;:::-;6492:31;6501:5;6508:7;6517:5;6492:8;:31::i;:::-;5916:614;;;;;;;;:::o;2267:73::-;;;;;;;;;;;;;;;;;;;;;;;;:::o;6536:1032::-;6822:10;6804:15;:28;6796:91;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6923:11;6905:15;:29;6897:86;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7002:24;;;;;;;:18;:24;;;;;;;;:31;;;;;;;;;;;7001:32;6993:94;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7142:223;;;1438:66;7142:223;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7119:256;;;;;7385:46;7224:4;7119:256;7423:1;7426;7429;7385:19;:46::i;:::-;7442:24;;;;;;;:18;:24;;;;;;;;:31;;;;;;;;:38;;;;7476:4;7442:38;;;7490:26;7461:4;7506:2;7510:5;7490:9;:26::i;:::-;7531:30;;7555:5;;7531:30;;;;;;;;;6536:1032;;;;;;;;;;:::o;2393:70::-;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;404:131:12:-;509:18;;;;;;;;;;;;;;;;;496:5;;;;491:16;;;;483:45;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;404:131;;;;:::o;4292:199:8:-;4405:16;;;;;;;;:9;:16;;;;;;;;:25;;;;;;;;;;;;;:33;;;4453:31;;;;;;;;;;;;;;;;;4292:199;;;:::o;541:132:12:-;646:19;;;;;;;;;;;;;;;;;633:5;;;;628:16;;;;620:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4497:457:8;4626:19;;;4640:4;4626:19;;;;:39;;-1:-1:-1;4649:16:8;;;;;4626:39;4605:120;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4831:15;;;;;;;:9;:15;;;;;;:26;;4851:5;4831:19;:26::i;:::-;4813:15;;;;;;;;:9;:15;;;;;;:44;;;;4883:13;;;;;;;:24;;4901:5;4883:17;:24::i;:::-;4867:13;;;;;;;;:9;:13;;;;;;;;;:40;;;;4922:25;;;;;;;4867:13;;4922:25;;;;;;;;;;;;;4497:457;;;:::o;4003:283::-;4159:15;;;;;;;:9;:15;;;;;;:26;;4179:5;4159:19;:26::i;:::-;4141:15;;;;;;;:9;:15;;;;;:44;;;;4209:11;:22;;4225:5;4209:15;:22::i;:::-;4195:11;:36;;;4246:33;;;;;;;;;;;;;;;;;;;;;;4003:283;;:::o;2812:865::-;2978:23;1713:66;1910;2094;3147:12;:10;:12::i;:::-;3027:177;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3185:4;3027:177;;;;;;;;;;;;;;;;;;;;;;;3004:210;;;;;;3265:57;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3242:90;;;;;;;;;-1:-1:-1;3369:26:8;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3004:210;;-1:-1:-1;3242:90:8;;-1:-1:-1;;3369:26:8;;;;;;;3027:177;;-1:-1:-1;3369:26:8;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;3369:26:8;;;;;;-1:-1:-1;;3541:30:8;;;;;;;:60;;;3595:6;3575:26;;:16;:26;;;3541:60;3520:150;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Swarm Source

ipfs://fc8586f479aef614f3de250fad8286dc1fba27d726925b3c464bad2b0ec0723d

Block Transaction Difficulty Gas Used Reward
View All Blocks Produced

Block Uncle Number Difficulty Gas Used Reward
View All Uncles
Loading...
Loading
Loading...
Loading

OVERVIEW

Hermez is a decentralized zk-rollup focused on scaling payments and token transfers on top of Ethereum.

Validator Index Block Amount
View All Withdrawals

Transaction Hash Block Value Eth2 PubKey Valid
View All Deposits
Loading...
Loading
[ Download: CSV Export  ]

A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.