Contract 0x5b6ef1f87d5cec1e8508ddb5de7e895869e7a4a3

 
Txn Hash
Block
From
To
Value [Txn Fee]
0x5999710968c98600e7315c17702d80547d31507a76c914cf8344d77dcd28bdd482320812021-06-12 11:50:1322 mins ago0xe33b75dbb331c4041c0fe62bf5c5d0e7e7757a81 IN  CrossPad: CROSS Token0 BNB0.00029882
0x7b024be2d654a75f632cad684d965cbb493d95782e6bebb5dc0ee69d038584e882299402021-06-12 10:02:212 hrs 10 mins ago0x2759460a6181129531b3f4d7a1b73e3268db8652 IN  CrossPad: CROSS Token0 BNB0.00022579
0x09d2bc565858eddcca1a6b4eb15c7487ab3137ee5d4ade146c579a158b7033dd82295402021-06-12 9:42:212 hrs 30 mins ago0xb47f765b004d5daeddd0516f04d24b328d82b389 IN  CrossPad: CROSS Token0 BNB0.00022579
0xc7c2e7326a3b9aa7db21293622fefed1c3121d442c734bda95bdbd26cc84384382272332021-06-12 7:47:004 hrs 25 mins ago0xd27ee7f31e1b82c9b1b6dfacd9ac8c9dbd6d3c97 IN  CrossPad: CROSS Token0 BNB0.00022579
0x2066fbdfdc1f480f16b968444365b42240eeaa4f0404aba5b083d2518e8f504582267602021-06-12 7:23:194 hrs 49 mins ago0x8b07a91b45dee2b0580820d71fe18a4e1a1bd28a IN  CrossPad: CROSS Token0 BNB0.00022579
0xdf6631dca3c23c5c8cc2516fb972ea8faf4eafa1bad9b233fa3d919689e65a3f82258832021-06-12 6:39:285 hrs 33 mins ago0x414a7e4a5f319fa4a1649d6632dac1b11da790cf IN  CrossPad: CROSS Token0 BNB0.00011424
0x6c1b512a8ea3c498b9081b8c8db9d18915109cfb7e3251efc77d3681e430876682248142021-06-12 5:45:586 hrs 26 mins ago0x3097a2f4a7298e0cc251588c41978d81230aae1a IN  CrossPad: CROSS Token0 BNB0.00022579
0x6e1234101b9804a1584d6d191c9f4307b26acb514c1f5847e0046d70bd80d27d82238622021-06-12 4:58:147 hrs 14 mins ago0x3048b35a5ad6b1a10405ab481b61f758475c2956 IN  CrossPad: CROSS Token0 BNB0.00018912
0x496255ac6b9325242f0be35fe5c331759911ae69bfc1cf086836b27ba75a178482224432021-06-12 3:47:178 hrs 25 mins ago0xa8665306f68effb2ad39ed6c0d329682d5ddc29e IN  CrossPad: CROSS Token0 BNB0.00022579
0x79297a510eb8eb9c4885b4bffc76f3a0cf267ecfee41bfb31ca9d91876aeba2182211372021-06-12 2:41:379 hrs 30 mins ago0x9c1ba303118960cb1064f5c78db7a7c34e7266e3 IN  CrossPad: CROSS Token0 BNB0.000104209
0x6cc05b98440f428933cf1bcb0115e3f095677e9aa186daa26b150995238fba3f82179692021-06-12 0:02:3912 hrs 9 mins ago0x291d2be578438090a49eb9967232cff9ed754d79 IN  CrossPad: CROSS Token0 BNB0.000179522
0x46aaf38cf67347105a1aa3c52753a0a3b225214f1b7ab14379c4c5b569c911ba82179512021-06-12 0:01:4512 hrs 10 mins ago0x291d2be578438090a49eb9967232cff9ed754d79 IN  CrossPad: CROSS Token0 BNB0.00022423
0x1d29e847b35f4968efb3ae903cd586520aff28d67cb46721afdfadde5304577682179442021-06-12 0:01:2412 hrs 11 mins ago0xe33b75dbb331c4041c0fe62bf5c5d0e7e7757a81 IN  CrossPad: CROSS Token0 BNB0.00026406
0x808f0a4f5db12a99a32bae52e82267b4447a46882b4157ab6a4d7e66fb85662e82178862021-06-11 23:58:3012 hrs 14 mins ago0x291d2be578438090a49eb9967232cff9ed754d79 IN  CrossPad: CROSS Token0 BNB0.00022423
0x3b54de6499f2385a016436d10344c220136c04b664d923af4e90f5d98a7710c582178822021-06-11 23:58:1812 hrs 14 mins ago0xe33b75dbb331c4041c0fe62bf5c5d0e7e7757a81 IN  CrossPad: CROSS Token0 BNB0.00026406
0x6bf38e19cd4bedff0ea74687c09d4d069536a50eef789b022b491cd42da6d29c82178292021-06-11 23:55:3912 hrs 16 mins ago0xc4c792389764db8eab991357339ec2be49290882 IN  CrossPad: CROSS Token0 BNB0.00022423
0x1aa8b25e38dbb8f2cfb627319a5f51ed183059f567c976ac3844fd20d196079782178232021-06-11 23:55:2112 hrs 17 mins ago0xe33b75dbb331c4041c0fe62bf5c5d0e7e7757a81 IN  CrossPad: CROSS Token0 BNB0.00026406
0x4010613aa01e4b8c58539eb43b9c077ebac4c3ede40de6355df57424bf67147a82177712021-06-11 23:52:4512 hrs 19 mins ago0x5a93b7496e1b7097ffe893c9f90ecd68c8546fd2 IN  CrossPad: CROSS Token0 BNB0.00012823
0x33722bf7f8fe3130fe873eb836d5c5a94bf88060b4c79ed12995223ebc56be2782177572021-06-11 23:52:0312 hrs 20 mins ago0x5a93b7496e1b7097ffe893c9f90ecd68c8546fd2 IN  CrossPad: CROSS Token0 BNB0.000179076
0x305dc649bb7bfd66d053195a39f20d02c05bcd88b6eeb14ecf26cba33dc1b0f682177522021-06-11 23:51:4812 hrs 20 mins ago0xe33b75dbb331c4041c0fe62bf5c5d0e7e7757a81 IN  CrossPad: CROSS Token0 BNB0.00018906
0x096e80021a9f28e114e8b2d1d9e348e61313f31cac3741192e6fc5a019eb86a282177392021-06-11 23:51:0912 hrs 21 mins ago0x5a93b7496e1b7097ffe893c9f90ecd68c8546fd2 IN  CrossPad: CROSS Token0 BNB0.000153876
0x016c29f3c56a62628bea6789eb1077454b791822f6a56461e720483bf97b5ee882177302021-06-11 23:50:4212 hrs 21 mins ago0x5a93b7496e1b7097ffe893c9f90ecd68c8546fd2 IN  CrossPad: CROSS Token0 BNB0.000269076
0x66ed24497fa9ac1e5a2045603c5da2a53c97ef5cc72aaef0f6f4efdc7dd16a3782177232021-06-11 23:50:2112 hrs 22 mins ago0xe33b75dbb331c4041c0fe62bf5c5d0e7e7757a81 IN  CrossPad: CROSS Token0 BNB0.00026406
0xec0396e8e07440695b4d4ba1ec93cfc6106b5b5e6f7ea4898282bc362d20f7f982176602021-06-11 23:47:1212 hrs 25 mins ago0x83c435233ed32f3dff301c3caa19d248f9391aa9 IN  CrossPad: CROSS Token0 BNB0.000153876
0xbb0090d38ca9dc93d23e9678c56f2e70e4f6b36b82e65dccbc5052411d9269b582176282021-06-11 23:45:3612 hrs 26 mins ago0x83c435233ed32f3dff301c3caa19d248f9391aa9 IN  CrossPad: CROSS Token0 BNB0.00022423
[ Download CSV Export 

OVERVIEW

The first native decentralized Multi Chain powered launchpad.

Parent Txn Hash Block From To Value
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
CrossPadFinance

Compiler Version
v0.5.8+commit.23d335f2

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, MIT license

Contract Source Code (Solidity)

/**
 *Submitted for verification at BscScan.com on 2021-04-20
*/

/**

 CrossPad: first native Multi Chain Launchpad
 CrossPad is the solution for multichain oriented projects, being the bridge
 to a new organic way of fundraising across the smart-contract-based blockchains.
 
 * Website: https://www.crosspad.finance
 * Twitter: https://twitter.com/CrossPadFinance
 * Medium: https://crosspad.medium.com/
 * Telegram group: https://t.me/CrossPad
 * Telegrm channel: https://t.me/CrossPadAnnouncement

*/

pragma solidity 0.5.8; 

// File: openzeppelin-solidity/contracts/token/ERC20/ERC20Basic.sol

/**
 * @title ERC20Basic
 * @dev Simpler version of ERC20 interface
 * @dev see https://github.com/ethereum/EIPs/issues/179
 */
contract ERC20Basic {
    function totalSupply() public view returns (uint256);
    function balanceOf(address who) public view returns (uint256);
    function transfer(address to, uint256 value) public returns (bool);
    event Transfer(address indexed from, address indexed to, uint256 value);
}

/**
 * @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.
     *
     * _Available since v2.4.0._
     */
    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.
     *
     * _Available since v2.4.0._
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        // Solidity only automatically asserts when dividing by 0
        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.
     *
     * _Available since v2.4.0._
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}
// File: openzeppelin-solidity/contracts/token/ERC20/BasicToken.sol

/**
 * @title Basic token
 * @dev Basic version of StandardToken, with no allowances.
 */
contract BasicToken is ERC20Basic {
    using SafeMath for uint256;

    mapping(address => uint256) balances;

    uint256 totalSupply_;

    /**
    * @dev total number of tokens in existence
    */
    function totalSupply() public view returns (uint256) {
        return totalSupply_;
    }

    /**
    * @dev transfer token for a specified address
    * @param _to The address to transfer to.
    * @param _value The amount to be transferred.
    */
    function transfer(address _to, uint256 _value) public returns (bool) {
        require(_to != address(0));
        require(_value <= balances[msg.sender]);

        balances[msg.sender] = balances[msg.sender].sub(_value);
        balances[_to] = balances[_to].add(_value);
        emit Transfer(msg.sender, _to, _value);
        return true;
    }

    /**
    * @dev Gets the balance of the specified address.
    * @param _owner The address to query the the balance of.
    * @return An uint256 representing the amount owned by the passed address.
    */
    function balanceOf(address _owner) public view returns (uint256) {
        return balances[_owner];
    }

}

// File: openzeppelin-solidity/contracts/token/ERC20/ERC20.sol

/**
 * @title ERC20 interface
 * @dev see https://github.com/ethereum/EIPs/issues/20
 */
contract ERC20 is ERC20Basic {
  function allowance(address owner, address spender) public view returns (uint256);
  function transferFrom(address from, address to, uint256 value) public returns (bool);
  function approve(address spender, uint256 value) public returns (bool);
  event Approval(address indexed owner, address indexed spender, uint256 value);
}

// File: openzeppelin-solidity/contracts/token/ERC20/StandardToken.sol

/**
 * @title Standard ERC20 token
 *
 * @dev Implementation of the basic standard token.
 * @dev https://github.com/ethereum/EIPs/issues/20
 * @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
 */
contract StandardToken is ERC20, BasicToken {

  mapping (address => mapping (address => uint256)) internal allowed;


  /**
   * @dev Transfer tokens from one address to another
   * @param _from address The address which you want to send tokens from
   * @param _to address The address which you want to transfer to
   * @param _value uint256 the amount of tokens to be transferred
   */
  function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
    require(_to != address(0));
    require(_value <= balances[_from]);
    require(_value <= allowed[_from][msg.sender]);

    balances[_from] = balances[_from].sub(_value);
    balances[_to] = balances[_to].add(_value);
    allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
    emit Transfer(_from, _to, _value);
    return true;
  }

  /**
   * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
   *
   * 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
   * @param _spender The address which will spend the funds.
   * @param _value The amount of tokens to be spent.
   */
  function approve(address _spender, uint256 _value) public returns (bool) {
    allowed[msg.sender][_spender] = _value;
    emit Approval(msg.sender, _spender, _value);
    return true;
  }

  /**
   * @dev Function to check the amount of tokens that an owner allowed to a spender.
   * @param _owner address The address which owns the funds.
   * @param _spender address The address which will spend the funds.
   * @return A uint256 specifying the amount of tokens still available for the spender.
   */
  function allowance(address _owner, address _spender) public view returns (uint256) {
    return allowed[_owner][_spender];
  }

  /**
   * @dev Increase the amount of tokens that an owner allowed to a spender.
   *
   * approve should be called when allowed[_spender] == 0. To increment
   * allowed value is better to use this function to avoid 2 calls (and wait until
   * the first transaction is mined)
   * From MonolithDAO Token.sol
   * @param _spender The address which will spend the funds.
   * @param _addedValue The amount of tokens to increase the allowance by.
   */
  function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
    allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
    emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
    return true;
  }

  /**
   * @dev Decrease the amount of tokens that an owner allowed to a spender.
   *
   * approve should be called when allowed[_spender] == 0. To decrement
   * allowed value is better to use this function to avoid 2 calls (and wait until
   * the first transaction is mined)
   * From MonolithDAO Token.sol
   * @param _spender The address which will spend the funds.
   * @param _subtractedValue The amount of tokens to decrease the allowance by.
   */
  function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
    uint oldValue = allowed[msg.sender][_spender];
    if (_subtractedValue > oldValue) {
      allowed[msg.sender][_spender] = 0;
    } else {
      allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
    }
    emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
    return true;
  }

}

// File: openzeppelin-solidity/contracts/ownership/Ownable.sol

/**
 * @title Ownable
 * @dev The Ownable contract has an owner address, and provides basic authorization control
 * functions, this simplifies the implementation of "user permissions".
 */
contract Ownable {
  address public owner;


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


  /**
   * @dev The Ownable constructor sets the original `owner` of the contract to the sender
   * account.
   */
  constructor() public {
    owner = msg.sender;
  }

  /**
   * @dev Throws if called by any account other than the owner.
   */
  modifier onlyOwner() {
    require(msg.sender == owner);
    _;
  }

  /**
   * @dev Allows the current owner to transfer control of the contract to a newOwner.
   * @param newOwner The address to transfer ownership to.
   */
  function transferOwnership(address newOwner) public onlyOwner {
    require(newOwner != address(0));
    emit OwnershipTransferred(owner, newOwner);
    owner = newOwner;
  }

}
// File: openzeppelin-solidity/contracts/token/ERC20/CappedToken.sol

/**
 * @title Capped token
 * @dev Mintable token with a token cap.
 */
contract CappedToken is StandardToken, Ownable{

    uint256 public cap;
    address public distributionContract;
    
    constructor(uint256 _cap, address _distributionContract) public {
        require(_cap > 0);
        cap = _cap;
        totalSupply_ = _cap;
        distributionContract = _distributionContract;
        balances[_distributionContract] = _cap;
    }

}

// File: openzeppelin-solidity/contracts/lifecycle/Pausable.sol

/**
 * @title Pausable
 * @dev Base contract which allows children to implement an emergency stop mechanism.
 */
contract Pausable is Ownable {
    event Pause();
    event Unpause();

    bool public paused = false;


    /**
    * @dev Modifier to make a function callable only when the contract is not paused.
    */
    modifier whenNotPaused() {
        require(!paused);
        _;
    }

    /**
    * @dev Modifier to make a function callable only when the contract is paused.
    */
    modifier whenPaused() {
        require(paused);
        _;
    }

    /**
    * @dev called by the owner to pause, triggers stopped state
    */
    function pause() onlyOwner whenNotPaused public {
        paused = true;
        emit Pause();
    }

    /**
    * @dev called by the owner to unpause, returns to normal state
    */
    function unpause() onlyOwner whenPaused public {
        paused = false;
        emit Unpause();
    }
}

// File: openzeppelin-solidity/contracts/token/ERC20/PausableToken.sol

/**
 * @title Pausable token
 * @dev StandardToken modified with pausable transfers.
 **/
contract PausableToken is StandardToken, Pausable {

    function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) {
        return super.transfer(_to, _value);
    }

    function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) {
        return super.transferFrom(_from, _to, _value);
    }

    function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) {
        return super.approve(_spender, _value);
    }

    function increaseApproval(address _spender, uint _addedValue) public whenNotPaused returns (bool success) {
        return super.increaseApproval(_spender, _addedValue);
    }

    function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused returns (bool success) {
        return super.decreaseApproval(_spender, _subtractedValue);
    }
}

// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <https://www.gnu.org/licenses/>.



contract CrossPadFinance is PausableToken, CappedToken {
    string public name = "CrossPad.finance";
    string public symbol = "CROSS";
    uint8 public decimals = 18;
    address public distributionContractAddress;
    // 100 Million <---------|   |-----------------> 10^18
    uint256 constant TOTAL_CAP = 100000000 * 1 ether;

    constructor(address _distributionContract) public CappedToken(TOTAL_CAP, _distributionContract) {
        distributionContractAddress = _distributionContract;
    }
}

Contract ABI

[{"constant":true,"inputs":[],"name":"name","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_spender","type":"address"},{"name":"_value","type":"uint256"}],"name":"approve","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"totalSupply","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"distributionContractAddress","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_from","type":"address"},{"name":"_to","type":"address"},{"name":"_value","type":"uint256"}],"name":"transferFrom","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"decimals","outputs":[{"name":"","type":"uint8"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"cap","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"unpause","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"distributionContract","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"paused","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_spender","type":"address"},{"name":"_subtractedValue","type":"uint256"}],"name":"decreaseApproval","outputs":[{"name":"success","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"_owner","type":"address"}],"name":"balanceOf","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"pause","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"owner","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"symbol","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_to","type":"address"},{"name":"_value","type":"uint256"}],"name":"transfer","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_spender","type":"address"},{"name":"_addedValue","type":"uint256"}],"name":"increaseApproval","outputs":[{"name":"success","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"_owner","type":"address"},{"name":"_spender","type":"address"}],"name":"allowance","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"inputs":[{"name":"_distributionContract","type":"address"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[],"name":"Pause","type":"event"},{"anonymous":false,"inputs":[],"name":"Unpause","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"previousOwner","type":"address"},{"indexed":true,"name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"owner","type":"address"},{"indexed":true,"name":"spender","type":"address"},{"indexed":false,"name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"from","type":"address"},{"indexed":true,"name":"to","type":"address"},{"indexed":false,"name":"value","type":"uint256"}],"name":"Transfer","type":"event"}]

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

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

00000000000000000000000079fe23ad6eb3061b8d39c6499a1b17f9a7937a9d

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 00000000000000000000000079fe23ad6eb3061b8d39c6499a1b17f9a7937a9d


Deployed ByteCode Sourcemap

16814:513:0:-;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;16814:513:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16876:39;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:100:-1;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;16876:39:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15618:144;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;15618:144:0;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;6799:91;;;:::i;:::-;;;;;;;;;;;;;;;;16992:42;;;:::i;:::-;;;;-1:-1:-1;;;;;16992:42:0;;;;;;;;;;;;;;15444:166;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;15444:166:0;;;;;;;;;;;;;;;;;:::i;16959:26::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;;13685:18;;;:::i;14961:105::-;;;:::i;:::-;;13710:35;;;:::i;14286:26::-;;;:::i;15955:187::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;15955:187:0;;;;;;;;:::i;7639:107::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;7639:107:0;-1:-1:-1;;;;;7639:107:0;;:::i;14765:103::-;;;:::i;12682:20::-;;;:::i;16922:30::-;;;:::i;15300:136::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;15300:136:0;;;;;;;;:::i;15770:177::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;15770:177:0;;;;;;;;:::i;10641:128::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;10641:128:0;;;;;;;;;;:::i;13297:178::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;13297:178:0;-1:-1:-1;;;;;13297:178:0;;:::i;16876:39::-;;;;;;;;;;;;;;;-1:-1:-1;;16876:39:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;15618:144::-;14472:6;;15699:4;;-1:-1:-1;;;14472:6:0;;;;14471:7;14463:16;;;;;;15723:31;15737:8;15747:6;15723:13;:31::i;:::-;15716:38;15618:144;-1:-1:-1;;;15618:144:0:o;6799:91::-;6870:12;;6799:91;:::o;16992:42::-;;;;;;-1:-1:-1;;;;;16992:42:0;;:::o;15444:166::-;14472:6;;15540:4;;-1:-1:-1;;;14472:6:0;;;;14471:7;14463:16;;;;;;15564:38;15583:5;15590:3;15595:6;15564:18;:38::i;:::-;15557:45;15444:166;-1:-1:-1;;;;15444:166:0:o;16959:26::-;;;;;;:::o;13685:18::-;;;;:::o;14961:105::-;13110:5;;-1:-1:-1;;;;;13110:5:0;13096:10;:19;13088:28;;;;;;14648:6;;-1:-1:-1;;;14648:6:0;;;;14640:15;;;;;;15019:6;:14;;-1:-1:-1;;;;;;15019:14:0;;;15049:9;;;;15028:5;;15049:9;14961:105::o;13710:35::-;;;-1:-1:-1;;;;;13710:35:0;;:::o;14286:26::-;;;-1:-1:-1;;;14286:26:0;;;;;:::o;15955:187::-;14472:6;;16052:12;;-1:-1:-1;;;14472:6:0;;;;14471:7;14463:16;;;;;;16084:50;16107:8;16117:16;16084:22;:50::i;7639:107::-;-1:-1:-1;;;;;7722:16:0;7695:7;7722:16;;;;;;;;;;;;7639:107::o;14765:103::-;13110:5;;-1:-1:-1;;;;;13110:5:0;13096:10;:19;13088:28;;;;;;14472:6;;-1:-1:-1;;;14472:6:0;;;;14471:7;14463:16;;;;;;14824:6;:13;;-1:-1:-1;;;;;;14824:13:0;-1:-1:-1;;;14824:13:0;;;14853:7;;;;14824:13;;14853:7;14765:103::o;12682:20::-;;;-1:-1:-1;;;;;12682:20:0;;:::o;16922:30::-;;;;;;;;;;;;;;;-1:-1:-1;;16922:30:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15300:136;14472:6;;15377:4;;-1:-1:-1;;;14472:6:0;;;;14471:7;14463:16;;;;;;15401:27;15416:3;15421:6;15401:14;:27::i;15770:177::-;14472:6;;15862:12;;-1:-1:-1;;;14472:6:0;;;;14471:7;14463:16;;;;;;15894:45;15917:8;15927:11;15894:22;:45::i;10641:128::-;-1:-1:-1;;;;;10738:15:0;;;10715:7;10738:15;;;:7;:15;;;;;;;;:25;;;;;;;;;;;;;10641:128::o;13297:178::-;13110:5;;-1:-1:-1;;;;;13110:5:0;13096:10;:19;13088:28;;;;;;-1:-1:-1;;;;;13374:22:0;;13366:31;;;;;;13430:5;;13409:37;;-1:-1:-1;;;;;13409:37:0;;;;13430:5;;13409:37;;13430:5;;13409:37;13453:5;:16;;-1:-1:-1;;;;;;13453:16:0;-1:-1:-1;;;;;13453:16:0;;;;;;;;;;13297:178::o;10122:192::-;10210:10;10189:4;10202:19;;;:7;:19;;;;;;;;-1:-1:-1;;;;;10202:29:0;;;;;;;;;;;:38;;;10252;;;;;;;10189:4;;10202:29;;10210:10;;10252:38;;;;;;;;-1:-1:-1;10304:4:0;10122:192;;;;:::o;9033:454::-;9115:4;-1:-1:-1;;;;;9136:17:0;;9128:26;;;;;;-1:-1:-1;;;;;9179:15:0;;:8;:15;;;;;;;;;;;9169:25;;;9161:34;;;;;;-1:-1:-1;;;;;9220:14:0;;;;;;:7;:14;;;;;;;;9235:10;9220:26;;;;;;;;9210:36;;;9202:45;;;;;;-1:-1:-1;;;;;9274:15:0;;:8;:15;;;;;;;;;;;:27;;9294:6;9274:27;:19;:27;:::i;:::-;-1:-1:-1;;;;;9256:15:0;;;:8;:15;;;;;;;;;;;:45;;;;9324:13;;;;;;;:25;;9342:6;9324:25;:17;:25;:::i;:::-;-1:-1:-1;;;;;9308:13:0;;;:8;:13;;;;;;;;;;;:41;;;;9385:14;;;;;:7;:14;;;;;9400:10;9385:26;;;;;;;:38;;9416:6;9385:38;:30;:38;:::i;:::-;-1:-1:-1;;;;;9356:14:0;;;;;;;:7;:14;;;;;;;;9371:10;9356:26;;;;;;;;:67;;;;9435:28;;;;;;;;;;;9356:14;;9435:28;;;;;;;;;;;-1:-1:-1;9477:4:0;9033:454;;;;;:::o;11978:412::-;12098:10;12061:4;12090:19;;;:7;:19;;;;;;;;-1:-1:-1;;;;;12090:29:0;;;;;;;;;;12130:27;;;12126:168;;;12176:10;12200:1;12168:19;;;:7;:19;;;;;;;;-1:-1:-1;;;;;12168:29:0;;;;;;;;;:33;12126:168;;;12256:30;:8;12269:16;12256:30;:12;:30;:::i;:::-;12232:10;12224:19;;;;:7;:19;;;;;;;;-1:-1:-1;;;;;12224:29:0;;;;;;;;;:62;12126:168;12314:10;12336:19;;;;:7;:19;;;;;;;;-1:-1:-1;;;;;12305:61:0;;12336:29;;;;;;;;;;;12305:61;;;;;;;;;12314:10;12305:61;;;;;;;;;;;-1:-1:-1;12380:4:0;;11978:412;-1:-1:-1;;;11978:412:0:o;7063:355::-;7126:4;-1:-1:-1;;;;;7151:17:0;;7143:26;;;;;;7207:10;7198:8;:20;;;;;;;;;;;7188:30;;;7180:39;;;;;;7264:10;7255:8;:20;;;;;;;;;;;:32;;7280:6;7255:32;:24;:32;:::i;:::-;7241:10;7232:8;:20;;;;;;;;;;;:55;;;;-1:-1:-1;;;;;7314:13:0;;;;;;:25;;7332:6;7314:25;:17;:25;:::i;:::-;-1:-1:-1;;;;;7298:13:0;;:8;:13;;;;;;;;;;;;:41;;;;7355:33;;;;;;;7298:13;;7364:10;;7355:33;;;;;;;;;;-1:-1:-1;7406:4:0;7063:355;;;;:::o;11238:266::-;11369:10;11316:4;11361:19;;;:7;:19;;;;;;;;-1:-1:-1;;;;;11361:29:0;;;;;;;;;;:46;;11395:11;11361:46;:33;:46;:::i;:::-;11337:10;11329:19;;;;:7;:19;;;;;;;;-1:-1:-1;;;;;11329:29:0;;;;;;;;;;;;:78;;;11419:61;;;;;;11329:29;;11419:61;;;;;;;;;;;-1:-1:-1;11494:4:0;11238:266;;;;:::o;2280:136::-;2338:7;2365:43;2369:1;2372;2365:43;;;;;;;;;;;;;;;;;:3;:43::i;1824:181::-;1882:7;1914:5;;;1938:6;;;;1930:46;;;;;-1:-1:-1;;;;;1930:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;2753:192;2839:7;2875:12;2867:6;;;;2859:29;;;;-1:-1:-1;;;;;2859:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;2859:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;2911:5:0;;;2753:192::o

Swarm Source

bzzr://895bc12195ae612b0aeb4d6abdcc3ca38c0f616e09fcf55d8ffcf4f27d677ce4
Block Transaction Gas Used Reward
Age Block Fee Address BC Fee Address Voting Power Jailed Incoming
Block Uncle Number Difficulty Gas Used Reward
Loading
Loading
Make sure to use the "Vote Down" button for any spammy posts, and the "Vote Up" for interesting conversations.