ETH Price: $3,043.14 (-2.23%)
Gas: 6 Gwei

Contract

0xBf74C12D6e6A8C2Bd7f36a917250e2bf8BFFEFC1
 

Overview

ETH Balance

0 ETH

Eth Value

$0.00

Multichain Info

No addresses found
Transaction Hash
Method
Block
From
To
Value
Withdraw GNO123983332021-05-09 5:39:091077 days ago1620538749IN
0xBf74C12D...f8BFFEFC1
0 ETH0.0043579890
Withdraw GNO113339832020-11-26 12:23:231240 days ago1606393403IN
0xBf74C12D...f8BFFEFC1
0 ETH0.0040059388.00000171
Withdraw GNO113339742020-11-26 12:21:131240 days ago1606393273IN
0xBf74C12D...f8BFFEFC1
0 ETH0.004142591.00000171
Withdraw GNO113337912020-11-26 11:42:121240 days ago1606390932IN
0xBf74C12D...f8BFFEFC1
0 ETH0.00496189109
Withdraw GNO113337912020-11-26 11:42:121240 days ago1606390932IN
0xBf74C12D...f8BFFEFC1
0 ETH0.00500742110
Withdraw GNO99555832020-04-27 16:28:321453 days ago1588004912IN
0xBf74C12D...f8BFFEFC1
0 ETH0.000167875.50000023
Withdraw GNO93702612020-01-28 11:29:301543 days ago1580210970IN
0xBf74C12D...f8BFFEFC1
0 ETH0.000045521
Withdraw GNO92971692020-01-17 6:45:341555 days ago1579243534IN
0xBf74C12D...f8BFFEFC1
0 ETH0.000244178
Withdraw GNO91374372019-12-20 21:20:371582 days ago1576876837IN
0xBf74C12D...f8BFFEFC1
0 ETH0.000227615
Withdraw GNO91074062019-12-14 22:23:011588 days ago1576362181IN
0xBf74C12D...f8BFFEFC1
0 ETH0.000055081.21
Withdraw GNO86699832019-10-03 15:19:411660 days ago1570115981IN
0xBf74C12D...f8BFFEFC1
0 ETH0.0006024514.3
Withdraw GNO86699822019-10-03 15:19:401660 days ago1570115980IN
0xBf74C12D...f8BFFEFC1
0 ETH0.000042131
Withdraw GNO84280892019-08-26 20:48:541698 days ago1566852534IN
0xBf74C12D...f8BFFEFC1
0 ETH0.000126393
Withdraw GNO80809652019-07-03 21:58:171752 days ago1562191097IN
0xBf74C12D...f8BFFEFC1
0 ETH0.000050551.2
Withdraw GNO80777762019-07-03 10:03:001752 days ago1562148180IN
0xBf74C12D...f8BFFEFC1
0 ETH0.000315977.5
Withdraw GNO80454242019-06-28 9:00:161758 days ago1561712416IN
0xBf74C12D...f8BFFEFC1
0 ETH0.000126393
Withdraw GNO79867072019-06-19 4:58:231767 days ago1560920303IN
0xBf74C12D...f8BFFEFC1
0 ETH0.000421310
Withdraw GNO79835542019-06-18 17:08:401767 days ago1560877720IN
0xBf74C12D...f8BFFEFC1
0 ETH0.000148293.52
Withdraw GNO79521752019-06-13 19:17:151772 days ago1560453435IN
0xBf74C12D...f8BFFEFC1
0 ETH0.000042131
Withdraw GNO79320572019-06-10 15:43:371775 days ago1560181417IN
0xBf74C12D...f8BFFEFC1
0 ETH0.000842620
Withdraw GNO79252192019-06-09 14:18:011776 days ago1560089881IN
0xBf74C12D...f8BFFEFC1
0 ETH0.000027131
Withdraw GNO78990362019-06-05 11:44:461780 days ago1559735086IN
0xBf74C12D...f8BFFEFC1
0 ETH0.000042131
Withdraw GNO78711532019-06-01 2:41:331785 days ago1559356893IN
0xBf74C12D...f8BFFEFC1
0 ETH0.000168524
Withdraw GNO78629202019-05-30 19:58:281786 days ago1559246308IN
0xBf74C12D...f8BFFEFC1
0 ETH0.000042131
Withdraw GNO78627562019-05-30 19:19:221786 days ago1559243962IN
0xBf74C12D...f8BFFEFC1
0 ETH0.000054262
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:
OWLAirdrop

Compiler Version
v0.5.2+commit.1df8f40c

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion

Contract Source Code (Solidity)

/**
 *Submitted for verification at Etherscan.io on 2019-04-15
*/

// File: @gnosis.pm/util-contracts/contracts/Token.sol

/// Implements ERC 20 Token standard: https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
pragma solidity ^0.5.2;

/// @title Abstract token contract - Functions to be implemented by token contracts
contract Token {
    /*
     *  Events
     */
    event Transfer(address indexed from, address indexed to, uint value);
    event Approval(address indexed owner, address indexed spender, uint value);

    /*
     *  Public functions
     */
    function transfer(address to, uint value) public returns (bool);
    function transferFrom(address from, address to, uint value) public returns (bool);
    function approve(address spender, uint value) public returns (bool);
    function balanceOf(address owner) public view returns (uint);
    function allowance(address owner, address spender) public view returns (uint);
    function totalSupply() public view returns (uint);
}

// File: @gnosis.pm/util-contracts/contracts/Math.sol

pragma solidity ^0.5.2;

/// @title Math library - Allows calculation of logarithmic and exponential functions
/// @author Alan Lu - <[email protected]>
/// @author Stefan George - <[email protected]>
library GnosisMath {
    /*
     *  Constants
     */
    // This is equal to 1 in our calculations
    uint public constant ONE = 0x10000000000000000;
    uint public constant LN2 = 0xb17217f7d1cf79ac;
    uint public constant LOG2_E = 0x171547652b82fe177;

    /*
     *  Public functions
     */
    /// @dev Returns natural exponential function value of given x
    /// @param x x
    /// @return e**x
    function exp(int x) public pure returns (uint) {
        // revert if x is > MAX_POWER, where
        // MAX_POWER = int(mp.floor(mp.log(mpf(2**256 - 1) / ONE) * ONE))
        require(x <= 2454971259878909886679);
        // return 0 if exp(x) is tiny, using
        // MIN_POWER = int(mp.floor(mp.log(mpf(1) / ONE) * ONE))
        if (x < -818323753292969962227) return 0;
        // Transform so that e^x -> 2^x
        x = x * int(ONE) / int(LN2);
        // 2^x = 2^whole(x) * 2^frac(x)
        //       ^^^^^^^^^^ is a bit shift
        // so Taylor expand on z = frac(x)
        int shift;
        uint z;
        if (x >= 0) {
            shift = x / int(ONE);
            z = uint(x % int(ONE));
        } else {
            shift = x / int(ONE) - 1;
            z = ONE - uint(-x % int(ONE));
        }
        // 2^x = 1 + (ln 2) x + (ln 2)^2/2! x^2 + ...
        //
        // Can generate the z coefficients using mpmath and the following lines
        // >>> from mpmath import mp
        // >>> mp.dps = 100
        // >>> ONE =  0x10000000000000000
        // >>> print('\n'.join(hex(int(mp.log(2)**i / mp.factorial(i) * ONE)) for i in range(1, 7)))
        // 0xb17217f7d1cf79ab
        // 0x3d7f7bff058b1d50
        // 0xe35846b82505fc5
        // 0x276556df749cee5
        // 0x5761ff9e299cc4
        // 0xa184897c363c3
        uint zpow = z;
        uint result = ONE;
        result += 0xb17217f7d1cf79ab * zpow / ONE;
        zpow = zpow * z / ONE;
        result += 0x3d7f7bff058b1d50 * zpow / ONE;
        zpow = zpow * z / ONE;
        result += 0xe35846b82505fc5 * zpow / ONE;
        zpow = zpow * z / ONE;
        result += 0x276556df749cee5 * zpow / ONE;
        zpow = zpow * z / ONE;
        result += 0x5761ff9e299cc4 * zpow / ONE;
        zpow = zpow * z / ONE;
        result += 0xa184897c363c3 * zpow / ONE;
        zpow = zpow * z / ONE;
        result += 0xffe5fe2c4586 * zpow / ONE;
        zpow = zpow * z / ONE;
        result += 0x162c0223a5c8 * zpow / ONE;
        zpow = zpow * z / ONE;
        result += 0x1b5253d395e * zpow / ONE;
        zpow = zpow * z / ONE;
        result += 0x1e4cf5158b * zpow / ONE;
        zpow = zpow * z / ONE;
        result += 0x1e8cac735 * zpow / ONE;
        zpow = zpow * z / ONE;
        result += 0x1c3bd650 * zpow / ONE;
        zpow = zpow * z / ONE;
        result += 0x1816193 * zpow / ONE;
        zpow = zpow * z / ONE;
        result += 0x131496 * zpow / ONE;
        zpow = zpow * z / ONE;
        result += 0xe1b7 * zpow / ONE;
        zpow = zpow * z / ONE;
        result += 0x9c7 * zpow / ONE;
        if (shift >= 0) {
            if (result >> (256 - shift) > 0) return (2 ** 256 - 1);
            return result << shift;
        } else return result >> (-shift);
    }

    /// @dev Returns natural logarithm value of given x
    /// @param x x
    /// @return ln(x)
    function ln(uint x) public pure returns (int) {
        require(x > 0);
        // binary search for floor(log2(x))
        int ilog2 = floorLog2(x);
        int z;
        if (ilog2 < 0) z = int(x << uint(-ilog2));
        else z = int(x >> uint(ilog2));
        // z = x * 2^-⌊log₂x⌋
        // so 1 <= z < 2
        // and ln z = ln x - ⌊log₂x⌋/log₂e
        // so just compute ln z using artanh series
        // and calculate ln x from that
        int term = (z - int(ONE)) * int(ONE) / (z + int(ONE));
        int halflnz = term;
        int termpow = term * term / int(ONE) * term / int(ONE);
        halflnz += termpow / 3;
        termpow = termpow * term / int(ONE) * term / int(ONE);
        halflnz += termpow / 5;
        termpow = termpow * term / int(ONE) * term / int(ONE);
        halflnz += termpow / 7;
        termpow = termpow * term / int(ONE) * term / int(ONE);
        halflnz += termpow / 9;
        termpow = termpow * term / int(ONE) * term / int(ONE);
        halflnz += termpow / 11;
        termpow = termpow * term / int(ONE) * term / int(ONE);
        halflnz += termpow / 13;
        termpow = termpow * term / int(ONE) * term / int(ONE);
        halflnz += termpow / 15;
        termpow = termpow * term / int(ONE) * term / int(ONE);
        halflnz += termpow / 17;
        termpow = termpow * term / int(ONE) * term / int(ONE);
        halflnz += termpow / 19;
        termpow = termpow * term / int(ONE) * term / int(ONE);
        halflnz += termpow / 21;
        termpow = termpow * term / int(ONE) * term / int(ONE);
        halflnz += termpow / 23;
        termpow = termpow * term / int(ONE) * term / int(ONE);
        halflnz += termpow / 25;
        return (ilog2 * int(ONE)) * int(ONE) / int(LOG2_E) + 2 * halflnz;
    }

    /// @dev Returns base 2 logarithm value of given x
    /// @param x x
    /// @return logarithmic value
    function floorLog2(uint x) public pure returns (int lo) {
        lo = -64;
        int hi = 193;
        // I use a shift here instead of / 2 because it floors instead of rounding towards 0
        int mid = (hi + lo) >> 1;
        while ((lo + 1) < hi) {
            if (mid < 0 && x << uint(-mid) < ONE || mid >= 0 && x >> uint(mid) < ONE) hi = mid;
            else lo = mid;
            mid = (hi + lo) >> 1;
        }
    }

    /// @dev Returns maximum of an array
    /// @param nums Numbers to look through
    /// @return Maximum number
    function max(int[] memory nums) public pure returns (int maxNum) {
        require(nums.length > 0);
        maxNum = -2 ** 255;
        for (uint i = 0; i < nums.length; i++) if (nums[i] > maxNum) maxNum = nums[i];
    }

    /// @dev Returns whether an add operation causes an overflow
    /// @param a First addend
    /// @param b Second addend
    /// @return Did no overflow occur?
    function safeToAdd(uint a, uint b) internal pure returns (bool) {
        return a + b >= a;
    }

    /// @dev Returns whether a subtraction operation causes an underflow
    /// @param a Minuend
    /// @param b Subtrahend
    /// @return Did no underflow occur?
    function safeToSub(uint a, uint b) internal pure returns (bool) {
        return a >= b;
    }

    /// @dev Returns whether a multiply operation causes an overflow
    /// @param a First factor
    /// @param b Second factor
    /// @return Did no overflow occur?
    function safeToMul(uint a, uint b) internal pure returns (bool) {
        return b == 0 || a * b / b == a;
    }

    /// @dev Returns sum if no overflow occurred
    /// @param a First addend
    /// @param b Second addend
    /// @return Sum
    function add(uint a, uint b) internal pure returns (uint) {
        require(safeToAdd(a, b));
        return a + b;
    }

    /// @dev Returns difference if no overflow occurred
    /// @param a Minuend
    /// @param b Subtrahend
    /// @return Difference
    function sub(uint a, uint b) internal pure returns (uint) {
        require(safeToSub(a, b));
        return a - b;
    }

    /// @dev Returns product if no overflow occurred
    /// @param a First factor
    /// @param b Second factor
    /// @return Product
    function mul(uint a, uint b) internal pure returns (uint) {
        require(safeToMul(a, b));
        return a * b;
    }

    /// @dev Returns whether an add operation causes an overflow
    /// @param a First addend
    /// @param b Second addend
    /// @return Did no overflow occur?
    function safeToAdd(int a, int b) internal pure returns (bool) {
        return (b >= 0 && a + b >= a) || (b < 0 && a + b < a);
    }

    /// @dev Returns whether a subtraction operation causes an underflow
    /// @param a Minuend
    /// @param b Subtrahend
    /// @return Did no underflow occur?
    function safeToSub(int a, int b) internal pure returns (bool) {
        return (b >= 0 && a - b <= a) || (b < 0 && a - b > a);
    }

    /// @dev Returns whether a multiply operation causes an overflow
    /// @param a First factor
    /// @param b Second factor
    /// @return Did no overflow occur?
    function safeToMul(int a, int b) internal pure returns (bool) {
        return (b == 0) || (a * b / b == a);
    }

    /// @dev Returns sum if no overflow occurred
    /// @param a First addend
    /// @param b Second addend
    /// @return Sum
    function add(int a, int b) internal pure returns (int) {
        require(safeToAdd(a, b));
        return a + b;
    }

    /// @dev Returns difference if no overflow occurred
    /// @param a Minuend
    /// @param b Subtrahend
    /// @return Difference
    function sub(int a, int b) internal pure returns (int) {
        require(safeToSub(a, b));
        return a - b;
    }

    /// @dev Returns product if no overflow occurred
    /// @param a First factor
    /// @param b Second factor
    /// @return Product
    function mul(int a, int b) internal pure returns (int) {
        require(safeToMul(a, b));
        return a * b;
    }
}

// File: @gnosis.pm/util-contracts/contracts/Proxy.sol

pragma solidity ^0.5.2;

/// @title Proxied - indicates that a contract will be proxied. Also defines storage requirements for Proxy.
/// @author Alan Lu - <[email protected]>
contract Proxied {
    address public masterCopy;
}

/// @title Proxy - Generic proxy contract allows to execute all transactions applying the code of a master contract.
/// @author Stefan George - <[email protected]>
contract Proxy is Proxied {
    /// @dev Constructor function sets address of master copy contract.
    /// @param _masterCopy Master copy address.
    constructor(address _masterCopy) public {
        require(_masterCopy != address(0), "The master copy is required");
        masterCopy = _masterCopy;
    }

    /// @dev Fallback function forwards all transactions and returns all received return data.
    function() external payable {
        address _masterCopy = masterCopy;
        assembly {
            calldatacopy(0, 0, calldatasize)
            let success := delegatecall(not(0), _masterCopy, 0, calldatasize, 0, 0)
            returndatacopy(0, 0, returndatasize)
            switch success
                case 0 {
                    revert(0, returndatasize)
                }
                default {
                    return(0, returndatasize)
                }
        }
    }
}

// File: @gnosis.pm/util-contracts/contracts/GnosisStandardToken.sol

pragma solidity ^0.5.2;




/**
 * Deprecated: Use Open Zeppeling one instead
 */
contract StandardTokenData {
    /*
     *  Storage
     */
    mapping(address => uint) balances;
    mapping(address => mapping(address => uint)) allowances;
    uint totalTokens;
}

/**
 * Deprecated: Use Open Zeppeling one instead
 */
/// @title Standard token contract with overflow protection
contract GnosisStandardToken is Token, StandardTokenData {
    using GnosisMath for *;

    /*
     *  Public functions
     */
    /// @dev Transfers sender's tokens to a given address. Returns success
    /// @param to Address of token receiver
    /// @param value Number of tokens to transfer
    /// @return Was transfer successful?
    function transfer(address to, uint value) public returns (bool) {
        if (!balances[msg.sender].safeToSub(value) || !balances[to].safeToAdd(value)) {
            return false;
        }

        balances[msg.sender] -= value;
        balances[to] += value;
        emit Transfer(msg.sender, to, value);
        return true;
    }

    /// @dev Allows allowed third party to transfer tokens from one address to another. Returns success
    /// @param from Address from where tokens are withdrawn
    /// @param to Address to where tokens are sent
    /// @param value Number of tokens to transfer
    /// @return Was transfer successful?
    function transferFrom(address from, address to, uint value) public returns (bool) {
        if (!balances[from].safeToSub(value) || !allowances[from][msg.sender].safeToSub(
            value
        ) || !balances[to].safeToAdd(value)) {
            return false;
        }
        balances[from] -= value;
        allowances[from][msg.sender] -= value;
        balances[to] += value;
        emit Transfer(from, to, value);
        return true;
    }

    /// @dev Sets approved amount of tokens for spender. Returns success
    /// @param spender Address of allowed account
    /// @param value Number of approved tokens
    /// @return Was approval successful?
    function approve(address spender, uint value) public returns (bool) {
        allowances[msg.sender][spender] = value;
        emit Approval(msg.sender, spender, value);
        return true;
    }

    /// @dev Returns number of allowed tokens for given address
    /// @param owner Address of token owner
    /// @param spender Address of token spender
    /// @return Remaining allowance for spender
    function allowance(address owner, address spender) public view returns (uint) {
        return allowances[owner][spender];
    }

    /// @dev Returns number of tokens owned by given address
    /// @param owner Address of token owner
    /// @return Balance of owner
    function balanceOf(address owner) public view returns (uint) {
        return balances[owner];
    }

    /// @dev Returns total supply of tokens
    /// @return Total supply
    function totalSupply() public view returns (uint) {
        return totalTokens;
    }
}

// File: @gnosis.pm/gno-token/contracts/TokenGNO.sol

pragma solidity ^0.5.2;


contract TokenGNO is GnosisStandardToken {
    string public constant symbol = "GNO";
    string public constant name = "Gnosis";
    uint8 public constant decimals = 18;

    constructor(uint amount) public {
        totalTokens = amount;
        balances[msg.sender] = amount;
    }
}

// File: contracts/TokenOWL.sol

pragma solidity ^0.5.2;




contract TokenOWL is Proxied, GnosisStandardToken {
    using GnosisMath for *;

    string public constant name = "OWL Token";
    string public constant symbol = "OWL";
    uint8 public constant decimals = 18;

    struct masterCopyCountdownType {
        address masterCopy;
        uint timeWhenAvailable;
    }

    masterCopyCountdownType masterCopyCountdown;

    address public creator;
    address public minter;

    event Minted(address indexed to, uint256 amount);
    event Burnt(address indexed from, address indexed user, uint256 amount);

    modifier onlyCreator() {
        // R1
        require(msg.sender == creator, "Only the creator can perform the transaction");
        _;
    }
    /// @dev trickers the update process via the proxyMaster for a new address _masterCopy
    /// updating is only possible after 30 days
    function startMasterCopyCountdown(address _masterCopy) public onlyCreator {
        require(address(_masterCopy) != address(0), "The master copy must be a valid address");

        // Update masterCopyCountdown
        masterCopyCountdown.masterCopy = _masterCopy;
        masterCopyCountdown.timeWhenAvailable = now + 30 days;
    }

    /// @dev executes the update process via the proxyMaster for a new address _masterCopy
    function updateMasterCopy() public onlyCreator {
        require(address(masterCopyCountdown.masterCopy) != address(0), "The master copy must be a valid address");
        require(
            block.timestamp >= masterCopyCountdown.timeWhenAvailable,
            "It's not possible to update the master copy during the waiting period"
        );

        // Update masterCopy
        masterCopy = masterCopyCountdown.masterCopy;
    }

    function getMasterCopy() public view returns (address) {
        return masterCopy;
    }

    /// @dev Set minter. Only the creator of this contract can call this.
    /// @param newMinter The new address authorized to mint this token
    function setMinter(address newMinter) public onlyCreator {
        minter = newMinter;
    }

    /// @dev change owner/creator of the contract. Only the creator/owner of this contract can call this.
    /// @param newOwner The new address, which should become the owner
    function setNewOwner(address newOwner) public onlyCreator {
        creator = newOwner;
    }

    /// @dev Mints OWL.
    /// @param to Address to which the minted token will be given
    /// @param amount Amount of OWL to be minted
    function mintOWL(address to, uint amount) public {
        require(minter != address(0), "The minter must be initialized");
        require(msg.sender == minter, "Only the minter can mint OWL");
        balances[to] = balances[to].add(amount);
        totalTokens = totalTokens.add(amount);
        emit Minted(to, amount);
        emit Transfer(address(0), to, amount);
    }

    /// @dev Burns OWL.
    /// @param user Address of OWL owner
    /// @param amount Amount of OWL to be burnt
    function burnOWL(address user, uint amount) public {
        allowances[user][msg.sender] = allowances[user][msg.sender].sub(amount);
        balances[user] = balances[user].sub(amount);
        totalTokens = totalTokens.sub(amount);
        emit Burnt(msg.sender, user, amount);
        emit Transfer(user, address(0), amount);
    }
}

// File: contracts/OWLAirdrop.sol

pragma solidity ^0.5.2;



contract OWLAirdrop {
    using GnosisMath for *;

    TokenOWL public tokenOWL;
    TokenGNO public tokenGNO;
    mapping(address => uint) public lockedGNO;
    uint public endTime;
    uint public multiplier;

    /// @dev Creates and starts the airdrop
    /// @param _tokenOWL The OWL token contract
    /// @param _tokenGNO The GNO token contract
    /// @param _endTime The unix epoch timestamp in seconds of the time airdrop ends
    constructor(TokenOWL _tokenOWL, TokenGNO _tokenGNO, uint _endTime, uint _multiplier) public {
        require(block.timestamp <= _endTime, "The end time cannot be in the past");
        tokenOWL = _tokenOWL;
        tokenGNO = _tokenGNO;
        endTime = _endTime;
        multiplier = _multiplier;
    }

    /// @dev Locks GNO inside this contract and mints OWL for GNO if endTime is not past
    /// @param amount Amount of GNO to lock
    function lockGNO(uint amount) public {
        require(block.timestamp <= endTime, "The locking period has ended");
        require(tokenGNO.transferFrom(msg.sender, address(this), amount), "The GNO transfer must succeed");
        lockedGNO[msg.sender] = lockedGNO[msg.sender].add(amount);
        tokenOWL.mintOWL(msg.sender, amount.mul(multiplier));
    }

    /// @dev Withdraws locked GNO if endTime is past
    function withdrawGNO() public {
        require(block.timestamp > endTime, "It's not allowed to withdraw during the locking time");
        require(tokenGNO.transfer(msg.sender, lockedGNO[msg.sender]), "The GNO withdrawal must succeed");
        lockedGNO[msg.sender] = 0;
    }
}

Contract Security Audit

Contract ABI

[{"constant":false,"inputs":[],"name":"withdrawGNO","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"multiplier","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"endTime","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"tokenOWL","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"}],"name":"lockedGNO","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"amount","type":"uint256"}],"name":"lockGNO","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"tokenGNO","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"inputs":[{"name":"_tokenOWL","type":"address"},{"name":"_tokenGNO","type":"address"},{"name":"_endTime","type":"uint256"},{"name":"_multiplier","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"}]

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

0000000000000000000000001a5f9352af8af974bfc03399e3767df6370d82e40000000000000000000000006810e776880c02933d47db1b9fc05908e5386b96000000000000000000000000000000000000000000000000000000005ce51d640000000000000000000000000000000000000000000000000000000000000002

-----Decoded View---------------
Arg [0] : _tokenOWL (address): 0x1A5F9352Af8aF974bFC03399e3767DF6370d82e4
Arg [1] : _tokenGNO (address): 0x6810e776880C02933D47DB1b9fc05908e5386b96
Arg [2] : _endTime (uint256): 1558519140
Arg [3] : _multiplier (uint256): 2

-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 0000000000000000000000001a5f9352af8af974bfc03399e3767df6370d82e4
Arg [1] : 0000000000000000000000006810e776880c02933d47db1b9fc05908e5386b96
Arg [2] : 000000000000000000000000000000000000000000000000000000005ce51d64
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000002


Swarm Source

bzzr://9703325904a46178bcc99218541cb2d51e1128c554f09e778aa2ae5a573023ea

Block Transaction Difficulty Gas Used Reward
View All Blocks Produced

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

Validator Index Block Amount
View All Withdrawals

Transaction Hash Block Value Eth2 PubKey Valid
View All Deposits
[ 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.