Token

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

library AddressUtils    - function isContract(address _addr) interface ERC165    - function supportsInterface(bytes4 _in ...  contract SupportsInterfaceWithLook ...    - function supportsInterface(bytes4 _in ...    - function _registerInterface(bytes4 _i ... library SafeMath    - function mul(uint256 _a, uint256 _b)    - function div(uint256 _a, uint256 _b)    - function sub(uint256 _a, uint256 _b)    - function add(uint256 _a, uint256 _b)  contract ERC721Basic is ERC165    - function balanceOf(address _owner)    - function ownerOf(uint256 _tokenId)    - function exists(uint256 _tokenId)    - function approve(address _to, uint256 ...    - function getApproved(uint256 _tokenId ...    - function setApprovalForAll(address _o ...    - function isApprovedForAll(address _ow ...    - function transferFrom(address _from, ...    - function safeTransferFrom(address _fr ...    - function safeTransferFrom(  contract ERC721Enumerable is ERC72 ...    - function totalSupply()    - function tokenOfOwnerByIndex(    - function tokenByIndex(uint256 _index)  contract ERC721Metadata is ERC721B ...    - function name()    - function symbol()    - function tokenURI(uint256 _tokenId)  contract ERC721 is ERC721Basic, ER ...  contract ERC721BasicToken is Suppo ...    - function balanceOf(address _owner)    - function ownerOf(uint256 _tokenId)    - function exists(uint256 _tokenId)    - function approve(address _to, uint256 ...    - function getApproved(uint256 _tokenId ...    - function setApprovalForAll(address _t ...    - function isApprovedForAll(    - function transferFrom(    - function safeTransferFrom(    - function safeTransferFrom(    - function isApprovedOrOwner(    - function _mint(address _to, uint256 _ ...    - function _burn(address _owner, uint25 ...    - function clearApproval(address _owner ...    - function addTokenTo(address _to, uint ...    - function removeTokenFrom(address _fro ...    - function checkAndCallSafeTransfer(  contract Trophy is SupportsInterfa ... *    - function name()    - function symbol()    - function tokenURI(uint256 _tokenId)    - function tokenOfOwnerByIndex(    - function totalSupply()    - function tokenByIndex(uint256 _index)    - function implementsERC721()    - function createType(address _issuer)    - function issue(address _issuer, addre ...    - function issueBatch(address _issuer, ...    - function revoke(uint256 _tokenId)    - function transferIssuer(uint256 _type ...    - function transferAll(uint256 _type, a ...    - function transferFrom(address _from, ...    - function safeTransferFrom(address _fr ...    - function setApprovalForAll(address _t ...    - function approve(address _to, uint256 ...    - function _mint(address _to, uint256 _ ...    - function _burn(address _owner, uint25 ...    - function addTokenTo(address _to, uint ...    - function removeTokenFrom(address _fro ...    - function uint2str(uint256 i)  contract ERC721Receiver    - function onERC721Received( library strings    - function memcpy(uint dest, uint src, ...    - function toSlice(string memory self)    - function len(bytes32 self)    - function toSliceB32(bytes32 self)    - function copy(slice memory self)    - function toString(slice memory self)    - function len(slice memory self)    - function empty(slice memory self)    - function compare(slice memory self, s ...    - function equals(slice memory self, sl ...    - function nextRune(slice memory self, ...    - function nextRune(slice memory self)    - function ord(slice memory self)    - function keccak(slice memory self)    - function startsWith(slice memory self ...    - function beyond(slice memory self, sl ...    - function endsWith(slice memory self, ...    - function until(slice memory self, sli ...    - function findPtr(uint selflen, uint s ...    - function rfindPtr(uint selflen, uint ...    - function find(slice memory self, slic ...    - function rfind(slice memory self, sli ...    - function split(slice memory self, sli ...    - function split(slice memory self, sli ...    - function rsplit(slice memory self, sl ...    - function rsplit(slice memory self, sl ...    - function count(slice memory self, sli ...    - function contains(slice memory self, ...    - function concat(slice memory self, sl ...    - function join(slice memory self, slic ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2018-08-31
*/

pragma solidity ^0.4.13;

library AddressUtils {

  /**
   * Returns whether the target address is a contract
   * @dev This function will return false if invoked during the constructor of a contract,
   * as the code is not actually created until after the constructor finishes.
   * @param _addr address to check
   * @return whether the target address is a contract
   */
  function isContract(address _addr) internal view returns (bool) {
    uint256 size;
    // XXX Currently there is no better way to check if there is a contract in an address
    // than to check the size of the code at that address.
    // See https://ethereum.stackexchange.com/a/14016/36603
    // for more details about how this works.
    // TODO Check this again before the Serenity release, because all addresses will be
    // contracts then.
    // solium-disable-next-line security/no-inline-assembly
    assembly { size := extcodesize(_addr) }
    return size > 0;
  }

}

interface ERC165 {

  /**
   * @notice Query if a contract implements an interface
   * @param _interfaceId The interface identifier, as specified in ERC-165
   * @dev Interface identification is specified in ERC-165. This function
   * uses less than 30,000 gas.
   */
  function supportsInterface(bytes4 _interfaceId)
    external
    view
    returns (bool);
}

contract SupportsInterfaceWithLookup is ERC165 {

  bytes4 public constant InterfaceId_ERC165 = 0x01ffc9a7;
  /**
   * 0x01ffc9a7 ===
   *   bytes4(keccak256('supportsInterface(bytes4)'))
   */

  /**
   * @dev a mapping of interface id to whether or not it's supported
   */
  mapping(bytes4 => bool) internal supportedInterfaces;

  /**
   * @dev A contract implementing SupportsInterfaceWithLookup
   * implement ERC165 itself
   */
  constructor()
    public
  {
    _registerInterface(InterfaceId_ERC165);
  }

  /**
   * @dev implement supportsInterface(bytes4) using a lookup table
   */
  function supportsInterface(bytes4 _interfaceId)
    external
    view
    returns (bool)
  {
    return supportedInterfaces[_interfaceId];
  }

  /**
   * @dev private method for registering an interface
   */
  function _registerInterface(bytes4 _interfaceId)
    internal
  {
    require(_interfaceId != 0xffffffff);
    supportedInterfaces[_interfaceId] = true;
  }
}

library SafeMath {

  /**
  * @dev Multiplies two numbers, throws on overflow.
  */
  function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
    // Gas optimization: this is cheaper than asserting 'a' not being zero, but the
    // benefit is lost if 'b' is also tested.
    // See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
    if (_a == 0) {
      return 0;
    }

    c = _a * _b;
    assert(c / _a == _b);
    return c;
  }

  /**
  * @dev Integer division of two numbers, truncating the quotient.
  */
  function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
    // assert(_b > 0); // Solidity automatically throws when dividing by 0
    // uint256 c = _a / _b;
    // assert(_a == _b * c + _a % _b); // There is no case in which this doesn't hold
    return _a / _b;
  }

  /**
  * @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
  */
  function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
    assert(_b <= _a);
    return _a - _b;
  }

  /**
  * @dev Adds two numbers, throws on overflow.
  */
  function add(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
    c = _a + _b;
    assert(c >= _a);
    return c;
  }
}

contract ERC721Basic is ERC165 {

  bytes4 internal constant InterfaceId_ERC721 = 0x80ac58cd;
  /*
   * 0x80ac58cd ===
   *   bytes4(keccak256('balanceOf(address)')) ^
   *   bytes4(keccak256('ownerOf(uint256)')) ^
   *   bytes4(keccak256('approve(address,uint256)')) ^
   *   bytes4(keccak256('getApproved(uint256)')) ^
   *   bytes4(keccak256('setApprovalForAll(address,bool)')) ^
   *   bytes4(keccak256('isApprovedForAll(address,address)')) ^
   *   bytes4(keccak256('transferFrom(address,address,uint256)')) ^
   *   bytes4(keccak256('safeTransferFrom(address,address,uint256)')) ^
   *   bytes4(keccak256('safeTransferFrom(address,address,uint256,bytes)'))
   */

  bytes4 internal constant InterfaceId_ERC721Exists = 0x4f558e79;
  /*
   * 0x4f558e79 ===
   *   bytes4(keccak256('exists(uint256)'))
   */

  bytes4 internal constant InterfaceId_ERC721Enumerable = 0x780e9d63;
  /**
   * 0x780e9d63 ===
   *   bytes4(keccak256('totalSupply()')) ^
   *   bytes4(keccak256('tokenOfOwnerByIndex(address,uint256)')) ^
   *   bytes4(keccak256('tokenByIndex(uint256)'))
   */

  bytes4 internal constant InterfaceId_ERC721Metadata = 0x5b5e139f;
  /**
   * 0x5b5e139f ===
   *   bytes4(keccak256('name()')) ^
   *   bytes4(keccak256('symbol()')) ^
   *   bytes4(keccak256('tokenURI(uint256)'))
   */

  event Transfer(
    address indexed _from,
    address indexed _to,
    uint256 indexed _tokenId
  );
  event Approval(
    address indexed _owner,
    address indexed _approved,
    uint256 indexed _tokenId
  );
  event ApprovalForAll(
    address indexed _owner,
    address indexed _operator,
    bool _approved
  );

  function balanceOf(address _owner) public view returns (uint256 _balance);
  function ownerOf(uint256 _tokenId) public view returns (address _owner);
  function exists(uint256 _tokenId) public view returns (bool _exists);

  function approve(address _to, uint256 _tokenId) public;
  function getApproved(uint256 _tokenId)
    public view returns (address _operator);

  function setApprovalForAll(address _operator, bool _approved) public;
  function isApprovedForAll(address _owner, address _operator)
    public view returns (bool);

  function transferFrom(address _from, address _to, uint256 _tokenId) public;
  function safeTransferFrom(address _from, address _to, uint256 _tokenId)
    public;

  function safeTransferFrom(
    address _from,
    address _to,
    uint256 _tokenId,
    bytes _data
  )
    public;
}

contract ERC721Enumerable is ERC721Basic {
  function totalSupply() public view returns (uint256);
  function tokenOfOwnerByIndex(
    address _owner,
    uint256 _index
  )
    public
    view
    returns (uint256 _tokenId);

  function tokenByIndex(uint256 _index) public view returns (uint256);
}

contract ERC721Metadata is ERC721Basic {
  function name() external view returns (string _name);
  function symbol() external view returns (string _symbol);
  function tokenURI(uint256 _tokenId) public view returns (string);
}

contract ERC721 is ERC721Basic, ERC721Enumerable, ERC721Metadata {
}

contract ERC721BasicToken is SupportsInterfaceWithLookup, ERC721Basic {

  using SafeMath for uint256;
  using AddressUtils for address;

  // Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
  // which can be also obtained as `ERC721Receiver(0).onERC721Received.selector`
  bytes4 private constant ERC721_RECEIVED = 0x150b7a02;

  // Mapping from token ID to owner
  mapping (uint256 => address) internal tokenOwner;

  // Mapping from token ID to approved address
  mapping (uint256 => address) internal tokenApprovals;

  // Mapping from owner to number of owned token
  mapping (address => uint256) internal ownedTokensCount;

  // Mapping from owner to operator approvals
  mapping (address => mapping (address => bool)) internal operatorApprovals;

  constructor()
    public
  {
    // register the supported interfaces to conform to ERC721 via ERC165
    _registerInterface(InterfaceId_ERC721);
    _registerInterface(InterfaceId_ERC721Exists);
  }

  /**
   * @dev Gets the balance of the specified address
   * @param _owner address to query the balance of
   * @return uint256 representing the amount owned by the passed address
   */
  function balanceOf(address _owner) public view returns (uint256) {
    require(_owner != address(0));
    return ownedTokensCount[_owner];
  }

  /**
   * @dev Gets the owner of the specified token ID
   * @param _tokenId uint256 ID of the token to query the owner of
   * @return owner address currently marked as the owner of the given token ID
   */
  function ownerOf(uint256 _tokenId) public view returns (address) {
    address owner = tokenOwner[_tokenId];
    require(owner != address(0));
    return owner;
  }

  /**
   * @dev Returns whether the specified token exists
   * @param _tokenId uint256 ID of the token to query the existence of
   * @return whether the token exists
   */
  function exists(uint256 _tokenId) public view returns (bool) {
    address owner = tokenOwner[_tokenId];
    return owner != address(0);
  }

  /**
   * @dev Approves another address to transfer the given token ID
   * The zero address indicates there is no approved address.
   * There can only be one approved address per token at a given time.
   * Can only be called by the token owner or an approved operator.
   * @param _to address to be approved for the given token ID
   * @param _tokenId uint256 ID of the token to be approved
   */
  function approve(address _to, uint256 _tokenId) public {
    address owner = ownerOf(_tokenId);
    require(_to != owner);
    require(msg.sender == owner || isApprovedForAll(owner, msg.sender));

    tokenApprovals[_tokenId] = _to;
    emit Approval(owner, _to, _tokenId);
  }

  /**
   * @dev Gets the approved address for a token ID, or zero if no address set
   * @param _tokenId uint256 ID of the token to query the approval of
   * @return address currently approved for the given token ID
   */
  function getApproved(uint256 _tokenId) public view returns (address) {
    return tokenApprovals[_tokenId];
  }

  /**
   * @dev Sets or unsets the approval of a given operator
   * An operator is allowed to transfer all tokens of the sender on their behalf
   * @param _to operator address to set the approval
   * @param _approved representing the status of the approval to be set
   */
  function setApprovalForAll(address _to, bool _approved) public {
    require(_to != msg.sender);
    operatorApprovals[msg.sender][_to] = _approved;
    emit ApprovalForAll(msg.sender, _to, _approved);
  }

  /**
   * @dev Tells whether an operator is approved by a given owner
   * @param _owner owner address which you want to query the approval of
   * @param _operator operator address which you want to query the approval of
   * @return bool whether the given operator is approved by the given owner
   */
  function isApprovedForAll(
    address _owner,
    address _operator
  )
    public
    view
    returns (bool)
  {
    return operatorApprovals[_owner][_operator];
  }

  /**
   * @dev Transfers the ownership of a given token ID to another address
   * Usage of this method is discouraged, use `safeTransferFrom` whenever possible
   * Requires the msg sender to be the owner, approved, or operator
   * @param _from current owner of the token
   * @param _to address to receive the ownership of the given token ID
   * @param _tokenId uint256 ID of the token to be transferred
  */
  function transferFrom(
    address _from,
    address _to,
    uint256 _tokenId
  )
    public
  {
    require(isApprovedOrOwner(msg.sender, _tokenId));
    require(_from != address(0));
    require(_to != address(0));

    clearApproval(_from, _tokenId);
    removeTokenFrom(_from, _tokenId);
    addTokenTo(_to, _tokenId);

    emit Transfer(_from, _to, _tokenId);
  }

  /**
   * @dev Safely transfers the ownership of a given token ID to another address
   * If the target address is a contract, it must implement `onERC721Received`,
   * which is called upon a safe transfer, and return the magic value
   * `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`; otherwise,
   * the transfer is reverted.
   *
   * Requires the msg sender to be the owner, approved, or operator
   * @param _from current owner of the token
   * @param _to address to receive the ownership of the given token ID
   * @param _tokenId uint256 ID of the token to be transferred
  */
  function safeTransferFrom(
    address _from,
    address _to,
    uint256 _tokenId
  )
    public
  {
    // solium-disable-next-line arg-overflow
    safeTransferFrom(_from, _to, _tokenId, "");
  }

  /**
   * @dev Safely transfers the ownership of a given token ID to another address
   * If the target address is a contract, it must implement `onERC721Received`,
   * which is called upon a safe transfer, and return the magic value
   * `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`; otherwise,
   * the transfer is reverted.
   * Requires the msg sender to be the owner, approved, or operator
   * @param _from current owner of the token
   * @param _to address to receive the ownership of the given token ID
   * @param _tokenId uint256 ID of the token to be transferred
   * @param _data bytes data to send along with a safe transfer check
   */
  function safeTransferFrom(
    address _from,
    address _to,
    uint256 _tokenId,
    bytes _data
  )
    public
  {
    transferFrom(_from, _to, _tokenId);
    // solium-disable-next-line arg-overflow
    require(checkAndCallSafeTransfer(_from, _to, _tokenId, _data));
  }

  /**
   * @dev Returns whether the given spender can transfer a given token ID
   * @param _spender address of the spender to query
   * @param _tokenId uint256 ID of the token to be transferred
   * @return bool whether the msg.sender is approved for the given token ID,
   *  is an operator of the owner, or is the owner of the token
   */
  function isApprovedOrOwner(
    address _spender,
    uint256 _tokenId
  )
    internal
    view
    returns (bool)
  {
    address owner = ownerOf(_tokenId);
    // Disable solium check because of
    // https://github.com/duaraghav8/Solium/issues/175
    // solium-disable-next-line operator-whitespace
    return (
      _spender == owner ||
      getApproved(_tokenId) == _spender ||
      isApprovedForAll(owner, _spender)
    );
  }

  /**
   * @dev Internal function to mint a new token
   * Reverts if the given token ID already exists
   * @param _to The address that will own the minted token
   * @param _tokenId uint256 ID of the token to be minted by the msg.sender
   */
  function _mint(address _to, uint256 _tokenId) internal {
    require(_to != address(0));
    addTokenTo(_to, _tokenId);
    emit Transfer(address(0), _to, _tokenId);
  }

  /**
   * @dev Internal function to burn a specific token
   * Reverts if the token does not exist
   * @param _tokenId uint256 ID of the token being burned by the msg.sender
   */
  function _burn(address _owner, uint256 _tokenId) internal {
    clearApproval(_owner, _tokenId);
    removeTokenFrom(_owner, _tokenId);
    emit Transfer(_owner, address(0), _tokenId);
  }

  /**
   * @dev Internal function to clear current approval of a given token ID
   * Reverts if the given address is not indeed the owner of the token
   * @param _owner owner of the token
   * @param _tokenId uint256 ID of the token to be transferred
   */
  function clearApproval(address _owner, uint256 _tokenId) internal {
    require(ownerOf(_tokenId) == _owner);
    if (tokenApprovals[_tokenId] != address(0)) {
      tokenApprovals[_tokenId] = address(0);
    }
  }

  /**
   * @dev Internal function to add a token ID to the list of a given address
   * @param _to address representing the new owner of the given token ID
   * @param _tokenId uint256 ID of the token to be added to the tokens list of the given address
   */
  function addTokenTo(address _to, uint256 _tokenId) internal {
    require(tokenOwner[_tokenId] == address(0));
    tokenOwner[_tokenId] = _to;
    ownedTokensCount[_to] = ownedTokensCount[_to].add(1);
  }

  /**
   * @dev Internal function to remove a token ID from the list of a given address
   * @param _from address representing the previous owner of the given token ID
   * @param _tokenId uint256 ID of the token to be removed from the tokens list of the given address
   */
  function removeTokenFrom(address _from, uint256 _tokenId) internal {
    require(ownerOf(_tokenId) == _from);
    ownedTokensCount[_from] = ownedTokensCount[_from].sub(1);
    tokenOwner[_tokenId] = address(0);
  }

  /**
   * @dev Internal function to invoke `onERC721Received` on a target address
   * The call is not executed if the target address is not a contract
   * @param _from address representing the previous owner of the given token ID
   * @param _to target address that will receive the tokens
   * @param _tokenId uint256 ID of the token to be transferred
   * @param _data bytes optional data to send along with the call
   * @return whether the call correctly returned the expected magic value
   */
  function checkAndCallSafeTransfer(
    address _from,
    address _to,
    uint256 _tokenId,
    bytes _data
  )
    internal
    returns (bool)
  {
    if (!_to.isContract()) {
      return true;
    }
    bytes4 retval = ERC721Receiver(_to).onERC721Received(
      msg.sender, _from, _tokenId, _data);
    return (retval == ERC721_RECEIVED);
  }
}

contract Trophy is SupportsInterfaceWithLookup, ERC721BasicToken, ERC721 {

    // Use solidity-stringutils
    using strings for *;

    // Token name
    string internal name_;

    // Token symbol
    string internal symbol_;

    // Mapping from owner to list of owned token IDs
    mapping(address => uint256[]) public ownedTokens;

    // Mapping from token ID to index of the owner tokens list
    mapping(uint256 => uint256) public ownedTokensIndex;

    // Array with all token ids, used for enumeration
    uint256[] public allTokens;

    // Mapping from token id to position in the allTokens array
    mapping(uint256 => uint256) public allTokensIndex;

    // Super administrator for this contract
    address public manager;

    // Next token identifier
    uint256 public nextTokenId = 1;

    // Next token type
    uint256 public nextTokenType = 1;

    // URI prefix for all token URIs
    string public tokenURIPrefix;

    // Types associated with tokens
    mapping (uint256 => uint256) public tokenTypes;

    // Owners of types
    mapping (uint256 => address) public tokenTypeIssuers;

    // A mapping of token id to issuer
    mapping (uint256 => address) public tokenIssuer;

    // A map of tokens by a type
    mapping (uint256 => uint256[]) public tokensByType;

    // Event emitted upon token type creation
    event TokenTypeCreated(
        address _issuer,
        uint256 _type,
        uint256 _timestamp
    );

    // Event emmited upon token is issued
    event TokenIssued(
        address _issuer,
        address _owner,
        uint256 _type,
        uint256 _tokenId,
        uint256 _timestamp
    );

    // Event emmited upon token is revoked
    event TokenRevoked(
        address _issuer,
        address _owner,
        uint256 _type,
        uint256 _tokenId,
        uint256 _timestamp
    );

    // Event emmited upon token issuance is transferred
    event IssuanceTransferred(
        uint256 _type,
        address _oldIssuer,
        address _newIssuer,
        uint256 _timestamp
    );

    // Event emmited upon transfer all tokens
    event TransferAll(
        address _oldAddress,
        address _newAddress,
        uint256 _timestamp
    );

    /**
    * @dev Constructor function
    */
    constructor(string _name, string _symbol, string _tokenURIPrefix) public {
        name_ = _name;
        symbol_ = _symbol;
        manager = msg.sender;
        tokenURIPrefix = _tokenURIPrefix;

        // register the supported interfaces to conform to ERC721 via ERC165
        _registerInterface(InterfaceId_ERC721Enumerable);
        _registerInterface(InterfaceId_ERC721Metadata);
    }

    /**
     * @dev Gets the token name
     * @return string representing the token name
     */
    function name() external view returns (string) {
        return name_;
    }

    /**
     * @dev Gets the token symbol
     * @return string representing the token symbol
     */
    function symbol() external view returns (string) {
        return symbol_;
    }

    /**
     * @dev Returns an URI for a given token ID
     * Throws if the token ID does not exist. May return an empty string.
     * @param _tokenId uint256 ID of the token to query
     */
    function tokenURI(uint256 _tokenId) public view returns (string) {
        require(tokenOwner[_tokenId] != address(0));
        return tokenURIPrefix.toSlice().concat(uint2str(_tokenId).toSlice());
    }

    /**
     * @dev Gets the token ID at a given index of the tokens list of the requested owner
     * @param _owner address owning the tokens list to be accessed
     * @param _index uint256 representing the index to be accessed of the requested tokens list
     * @return uint256 token ID at the given index of the tokens list owned by the requested address
     */
    function tokenOfOwnerByIndex(
        address _owner,
        uint256 _index
    )
    public
    view
    returns (uint256)
    {
        require(_index < balanceOf(_owner));
        return ownedTokens[_owner][_index];
    }

    /**
    * @dev Gets the total amount of tokens stored by the contract
    * @return uint256 representing the total amount of tokens
     */
    function totalSupply() public view returns (uint256) {
        return allTokens.length;
    }

    /**
    * @dev Gets the token ID at a given index of all the tokens in this contract
    * Reverts if the index is greater or equal to the total number of tokens
    * @param _index uint256 representing the index to be accessed of the tokens list
    * @return uint256 token ID at the given index of the tokens list
     */
    function tokenByIndex(uint256 _index) public view returns (uint256) {
        require(_index < totalSupply());
        return allTokens[_index];
    }

    /**
     * @dev Implements ERC 721
     */
    function implementsERC721() public pure returns (bool) {
        return true;
    }

    /**
    * @dev Creates a new token type
    * @param _issuer address of the new token type issuer
    */
    function createType(address _issuer) external {
        require(
            msg.sender == manager || msg.sender == _issuer,
            "Only managers can issue trophies on behalf of others."
        );

        tokenTypeIssuers[nextTokenType] = _issuer;
        emit TokenTypeCreated(_issuer, nextTokenType, block.timestamp); // solium-disable-line security/no-block-members
        nextTokenType++;
    }

    /**
     * @dev Issues a new token
     * @param _issuer address of the new token type issuer
     */
    function issue(address _issuer, address _owner, uint256 _type) public {
        require(
            (msg.sender == manager && tokenTypeIssuers[_type] != 0) || (msg.sender == _issuer && tokenTypeIssuers[_type] == _issuer), // solium-disable-line indentation
            "Only managers and issuers can issue trophies."
        );

        _mint(_owner, nextTokenId);
        tokenTypes[nextTokenId] = _type;
        tokensByType[_type].push(nextTokenId);

        emit TokenIssued(
            _issuer,
            _owner,
            _type,
            nextTokenId,
            block.timestamp // solium-disable-line security/no-block-members
        );

        nextTokenId++;
    }

    /**
     * @dev issues the same token to many addresses
     * @param _issuer address of the new token type issuer
     * @param _owners an array of addresses of token holders
     * @param _type type of an token
     */
    function issueBatch(address _issuer, address[] _owners, uint256 _type) external {
        require(_owners.length > 0, "Owners cannot be empty");

        for (uint256 index = 0; index < _owners.length; index++ ) {
            issue(_issuer, _owners[index], _type);
        }
    }

    /**
     * @dev Revokes issuance permissions to another address
     */
    function revoke(uint256 _tokenId) external {
        address owner = tokenOwner[_tokenId];
        uint256 tokenType = tokenTypes[_tokenId];
        address issuer = tokenTypeIssuers[tokenType];

        require(
            msg.sender == manager || msg.sender == issuer || msg.sender == owner,
            "Only managers, owners, and issuers of the trophy can revoke them."
        );

        _burn(owner, _tokenId);

        uint256 tokenIndex;
        bool tokenFound;
        for (uint256 i = 0; i < tokensByType[tokenType].length; i++) {
            if (tokensByType[tokenType][i] == _tokenId) {
                tokenIndex = i;
                tokenFound = true;
                break;
            }
        }
        require(tokenFound, "token not found");

        uint256 lastTokenIndex = tokensByType[tokenType].length.sub(1);
        uint256 lastToken = tokensByType[tokenType][lastTokenIndex];

        tokensByType[tokenType][tokenIndex] = lastToken;
        tokensByType[tokenType][lastTokenIndex] = 0;

        emit TokenRevoked(
            issuer,
            owner,
            tokenType,
            _tokenId,
            block.timestamp // solium-disable-line security/no-block-members
        );
    }

    /**
    * @dev Transfers issuance permissions to another address
    */
    function transferIssuer(uint256 _type, address _oldIssuer, address _newIssuer) external {
        require(
            msg.sender == manager || (msg.sender == _oldIssuer && tokenTypeIssuers[_type] == _oldIssuer),
            "Only managers and issuers can transfer issuance of trophies."
        );

        tokenTypeIssuers[_type] = _newIssuer;
        emit IssuanceTransferred(
            _type,
            _oldIssuer,
            _newIssuer,
            block.timestamp // solium-disable-line security/no-block-members
        );
    }

    /**
    * @dev Transfers all tokens to a new address
     */
    function transferAll(uint256 _type, address _oldAddress, address _newAddress) external {
        require(
            msg.sender == manager || (msg.sender == _oldAddress && tokenTypeIssuers[_type] == _oldAddress),
            "Only managers and issuers can transfer all tokens to a new address."
        );

        for (uint256 i = 0; i < ownedTokens[_oldAddress].length; i++) {
            uint256 token = ownedTokens[_oldAddress][i];
            removeTokenFrom(_oldAddress, token);
            addTokenTo(_newAddress, token);
        }
        emit TransferAll(_oldAddress, _newAddress, block.timestamp); // solium-disable-line security/no-block-members
    }

    /**
     * @dev Restrict all transfers
     */
    function transferFrom(address _from, address _to, uint256 _tokenId) public {
        require(false, "Transfers of trophies are not allowed.");
    }

    /**
     * @dev Restrict all transfers
     */
    function safeTransferFrom(address _from, address _to, uint256 _tokenId) public {
        require(false, "Transfers of trophies are not allowed.");
    }

    /**
     * @dev Restrict all transfers
     */
    function setApprovalForAll(address _to, bool _approved) public {
        require(false, "Transfers of trophies are not allowed.");
    }

    /**
     * @dev Restrict all transfers
     */
    function approve(address _to, uint256 _tokenId) public {
        require(false, "Transfers of trophies are not allowed.");
    }

    /**
     * @dev Internal function to mint a new token
     * Reverts if the given token ID already exists
     * @param _to address the beneficiary that will own the minted token
     * @param _tokenId uint256 ID of the token to be minted by the msg.sender
     */
    function _mint(address _to, uint256 _tokenId) internal {
        super._mint(_to, _tokenId);

        allTokensIndex[_tokenId] = allTokens.length;
        allTokens.push(_tokenId);
    }

    /**
    * @dev Internal function to burn a specific token
    * Reverts if the token does not exist
        * @param _owner owner of the token to burn
        * @param _tokenId uint256 ID of the token being burned by the msg.sender
     */
    function _burn(address _owner, uint256 _tokenId) internal {
        super._burn(_owner, _tokenId);

        // Reorg all tokens array
        uint256 tokenIndex = allTokensIndex[_tokenId];
        uint256 lastTokenIndex = allTokens.length.sub(1);
        uint256 lastToken = allTokens[lastTokenIndex];

        allTokens[tokenIndex] = lastToken;
        allTokens[lastTokenIndex] = 0;

        allTokens.length--;
        allTokensIndex[_tokenId] = 0;
        allTokensIndex[lastToken] = tokenIndex;
    }

    /**
    * @dev Internal function to add a token ID to the list of a given address
    * @param _to address representing the new owner of the given token ID
    * @param _tokenId uint256 ID of the token to be added to the tokens list of the given address
     */
    function addTokenTo(address _to, uint256 _tokenId) internal {
        super.addTokenTo(_to, _tokenId);
        uint256 length = ownedTokens[_to].length;
        ownedTokens[_to].push(_tokenId);
        ownedTokensIndex[_tokenId] = length;
    }

    /**
    * @dev Internal function to remove a token ID from the list of a given address
    * @param _from address representing the previous owner of the given token ID
    * @param _tokenId uint256 ID of the token to be removed from the tokens list of the given address
     */
    function removeTokenFrom(address _from, uint256 _tokenId) internal {
        super.removeTokenFrom(_from, _tokenId);

        // To prevent a gap in the array, we store the last token in the index of the token to delete, and
        // then delete the last slot.
        uint256 tokenIndex = ownedTokensIndex[_tokenId];
        uint256 lastTokenIndex = ownedTokens[_from].length.sub(1);
        uint256 lastToken = ownedTokens[_from][lastTokenIndex];

        ownedTokens[_from][tokenIndex] = lastToken;
        // This also deletes the contents at the last position of the array
        ownedTokens[_from].length--;

        // Note that this will handle single-element arrays. In that case, both tokenIndex and lastTokenIndex are going to
        // be zero. Then we can make sure that we will remove _tokenId from the ownedTokens list since we are first swapping
        // the lastToken to the first position, and then dropping the element placed in the last position of the list

        ownedTokensIndex[_tokenId] = 0;
        ownedTokensIndex[lastToken] = tokenIndex;
    }

    /**
    * @dev Converts a uint256 to a decimal string
    */
    function uint2str(uint256 i) internal pure returns (string) {
        if (i == 0) return "0";
        uint256 j = i;
        uint256 m = i;
        uint256 length;
        while (j != 0){
            length++;
            j /= 10;
        }
        bytes memory bstr = new bytes(length);
        uint256 k = length - 1;
        while (m != 0){
            bstr[k--] = byte(48 + m % 10);
            m /= 10;
        }
        return string(bstr);
    }
}

contract ERC721Receiver {
  /**
   * @dev Magic value to be returned upon successful reception of an NFT
   *  Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`,
   *  which can be also obtained as `ERC721Receiver(0).onERC721Received.selector`
   */
  bytes4 internal constant ERC721_RECEIVED = 0x150b7a02;

  /**
   * @notice Handle the receipt of an NFT
   * @dev The ERC721 smart contract calls this function on the recipient
   * after a `safetransfer`. This function MAY throw to revert and reject the
   * transfer. Return of other than the magic value MUST result in the
   * transaction being reverted.
   * Note: the contract address is always the message sender.
   * @param _operator The address which called `safeTransferFrom` function
   * @param _from The address which previously owned the token
   * @param _tokenId The NFT identifier which is being transferred
   * @param _data Additional data with no specified format
   * @return `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
   */
  function onERC721Received(
    address _operator,
    address _from,
    uint256 _tokenId,
    bytes _data
  )
    public
    returns(bytes4);
}

library strings {
    struct slice {
        uint _len;
        uint _ptr;
    }

    function memcpy(uint dest, uint src, uint len) private pure {
        // Copy word-length chunks while possible
        for(; len >= 32; len -= 32) {
            assembly {
                mstore(dest, mload(src))
            }
            dest += 32;
            src += 32;
        }

        // Copy remaining bytes
        uint mask = 256 ** (32 - len) - 1;
        assembly {
            let srcpart := and(mload(src), not(mask))
            let destpart := and(mload(dest), mask)
            mstore(dest, or(destpart, srcpart))
        }
    }

    /*
     * @dev Returns a slice containing the entire string.
     * @param self The string to make a slice from.
     * @return A newly allocated slice containing the entire string.
     */
    function toSlice(string memory self) internal pure returns (slice memory) {
        uint ptr;
        assembly {
            ptr := add(self, 0x20)
        }
        return slice(bytes(self).length, ptr);
    }

    /*
     * @dev Returns the length of a null-terminated bytes32 string.
     * @param self The value to find the length of.
     * @return The length of the string, from 0 to 32.
     */
    function len(bytes32 self) internal pure returns (uint) {
        uint ret;
        if (self == 0)
            return 0;
        if (self & 0xffffffffffffffffffffffffffffffff == 0) {
            ret += 16;
            self = bytes32(uint(self) / 0x100000000000000000000000000000000);
        }
        if (self & 0xffffffffffffffff == 0) {
            ret += 8;
            self = bytes32(uint(self) / 0x10000000000000000);
        }
        if (self & 0xffffffff == 0) {
            ret += 4;
            self = bytes32(uint(self) / 0x100000000);
        }
        if (self & 0xffff == 0) {
            ret += 2;
            self = bytes32(uint(self) / 0x10000);
        }
        if (self & 0xff == 0) {
            ret += 1;
        }
        return 32 - ret;
    }

    /*
     * @dev Returns a slice containing the entire bytes32, interpreted as a
     *      null-terminated utf-8 string.
     * @param self The bytes32 value to convert to a slice.
     * @return A new slice containing the value of the input argument up to the
     *         first null.
     */
    function toSliceB32(bytes32 self) internal pure returns (slice memory ret) {
        // Allocate space for `self` in memory, copy it there, and point ret at it
        assembly {
            let ptr := mload(0x40)
            mstore(0x40, add(ptr, 0x20))
            mstore(ptr, self)
            mstore(add(ret, 0x20), ptr)
        }
        ret._len = len(self);
    }

    /*
     * @dev Returns a new slice containing the same data as the current slice.
     * @param self The slice to copy.
     * @return A new slice containing the same data as `self`.
     */
    function copy(slice memory self) internal pure returns (slice memory) {
        return slice(self._len, self._ptr);
    }

    /*
     * @dev Copies a slice to a new string.
     * @param self The slice to copy.
     * @return A newly allocated string containing the slice's text.
     */
    function toString(slice memory self) internal pure returns (string memory) {
        string memory ret = new string(self._len);
        uint retptr;
        assembly { retptr := add(ret, 32) }

        memcpy(retptr, self._ptr, self._len);
        return ret;
    }

    /*
     * @dev Returns the length in runes of the slice. Note that this operation
     *      takes time proportional to the length of the slice; avoid using it
     *      in loops, and call `slice.empty()` if you only need to know whether
     *      the slice is empty or not.
     * @param self The slice to operate on.
     * @return The length of the slice in runes.
     */
    function len(slice memory self) internal pure returns (uint l) {
        // Starting at ptr-31 means the LSB will be the byte we care about
        uint ptr = self._ptr - 31;
        uint end = ptr + self._len;
        for (l = 0; ptr < end; l++) {
            uint8 b;
            assembly { b := and(mload(ptr), 0xFF) }
            if (b < 0x80) {
                ptr += 1;
            } else if(b < 0xE0) {
                ptr += 2;
            } else if(b < 0xF0) {
                ptr += 3;
            } else if(b < 0xF8) {
                ptr += 4;
            } else if(b < 0xFC) {
                ptr += 5;
            } else {
                ptr += 6;
            }
        }
    }

    /*
     * @dev Returns true if the slice is empty (has a length of 0).
     * @param self The slice to operate on.
     * @return True if the slice is empty, False otherwise.
     */
    function empty(slice memory self) internal pure returns (bool) {
        return self._len == 0;
    }

    /*
     * @dev Returns a positive number if `other` comes lexicographically after
     *      `self`, a negative number if it comes before, or zero if the
     *      contents of the two slices are equal. Comparison is done per-rune,
     *      on unicode codepoints.
     * @param self The first slice to compare.
     * @param other The second slice to compare.
     * @return The result of the comparison.
     */
    function compare(slice memory self, slice memory other) internal pure returns (int) {
        uint shortest = self._len;
        if (other._len < self._len)
            shortest = other._len;

        uint selfptr = self._ptr;
        uint otherptr = other._ptr;
        for (uint idx = 0; idx < shortest; idx += 32) {
            uint a;
            uint b;
            assembly {
                a := mload(selfptr)
                b := mload(otherptr)
            }
            if (a != b) {
                // Mask out irrelevant bytes and check again
                uint256 mask = uint256(-1); // 0xffff...
                if(shortest < 32) {
                  mask = ~(2 ** (8 * (32 - shortest + idx)) - 1);
                }
                uint256 diff = (a & mask) - (b & mask);
                if (diff != 0)
                    return int(diff);
            }
            selfptr += 32;
            otherptr += 32;
        }
        return int(self._len) - int(other._len);
    }

    /*
     * @dev Returns true if the two slices contain the same text.
     * @param self The first slice to compare.
     * @param self The second slice to compare.
     * @return True if the slices are equal, false otherwise.
     */
    function equals(slice memory self, slice memory other) internal pure returns (bool) {
        return compare(self, other) == 0;
    }

    /*
     * @dev Extracts the first rune in the slice into `rune`, advancing the
     *      slice to point to the next rune and returning `self`.
     * @param self The slice to operate on.
     * @param rune The slice that will contain the first rune.
     * @return `rune`.
     */
    function nextRune(slice memory self, slice memory rune) internal pure returns (slice memory) {
        rune._ptr = self._ptr;

        if (self._len == 0) {
            rune._len = 0;
            return rune;
        }

        uint l;
        uint b;
        // Load the first byte of the rune into the LSBs of b
        assembly { b := and(mload(sub(mload(add(self, 32)), 31)), 0xFF) }
        if (b < 0x80) {
            l = 1;
        } else if(b < 0xE0) {
            l = 2;
        } else if(b < 0xF0) {
            l = 3;
        } else {
            l = 4;
        }

        // Check for truncated codepoints
        if (l > self._len) {
            rune._len = self._len;
            self._ptr += self._len;
            self._len = 0;
            return rune;
        }

        self._ptr += l;
        self._len -= l;
        rune._len = l;
        return rune;
    }

    /*
     * @dev Returns the first rune in the slice, advancing the slice to point
     *      to the next rune.
     * @param self The slice to operate on.
     * @return A slice containing only the first rune from `self`.
     */
    function nextRune(slice memory self) internal pure returns (slice memory ret) {
        nextRune(self, ret);
    }

    /*
     * @dev Returns the number of the first codepoint in the slice.
     * @param self The slice to operate on.
     * @return The number of the first codepoint in the slice.
     */
    function ord(slice memory self) internal pure returns (uint ret) {
        if (self._len == 0) {
            return 0;
        }

        uint word;
        uint length;
        uint divisor = 2 ** 248;

        // Load the rune into the MSBs of b
        assembly { word:= mload(mload(add(self, 32))) }
        uint b = word / divisor;
        if (b < 0x80) {
            ret = b;
            length = 1;
        } else if(b < 0xE0) {
            ret = b & 0x1F;
            length = 2;
        } else if(b < 0xF0) {
            ret = b & 0x0F;
            length = 3;
        } else {
            ret = b & 0x07;
            length = 4;
        }

        // Check for truncated codepoints
        if (length > self._len) {
            return 0;
        }

        for (uint i = 1; i < length; i++) {
            divisor = divisor / 256;
            b = (word / divisor) & 0xFF;
            if (b & 0xC0 != 0x80) {
                // Invalid UTF-8 sequence
                return 0;
            }
            ret = (ret * 64) | (b & 0x3F);
        }

        return ret;
    }

    /*
     * @dev Returns the keccak-256 hash of the slice.
     * @param self The slice to hash.
     * @return The hash of the slice.
     */
    function keccak(slice memory self) internal pure returns (bytes32 ret) {
        assembly {
            ret := keccak256(mload(add(self, 32)), mload(self))
        }
    }

    /*
     * @dev Returns true if `self` starts with `needle`.
     * @param self The slice to operate on.
     * @param needle The slice to search for.
     * @return True if the slice starts with the provided text, false otherwise.
     */
    function startsWith(slice memory self, slice memory needle) internal pure returns (bool) {
        if (self._len < needle._len) {
            return false;
        }

        if (self._ptr == needle._ptr) {
            return true;
        }

        bool equal;
        assembly {
            let length := mload(needle)
            let selfptr := mload(add(self, 0x20))
            let needleptr := mload(add(needle, 0x20))
            equal := eq(keccak256(selfptr, length), keccak256(needleptr, length))
        }
        return equal;
    }

    /*
     * @dev If `self` starts with `needle`, `needle` is removed from the
     *      beginning of `self`. Otherwise, `self` is unmodified.
     * @param self The slice to operate on.
     * @param needle The slice to search for.
     * @return `self`
     */
    function beyond(slice memory self, slice memory needle) internal pure returns (slice memory) {
        if (self._len < needle._len) {
            return self;
        }

        bool equal = true;
        if (self._ptr != needle._ptr) {
            assembly {
                let length := mload(needle)
                let selfptr := mload(add(self, 0x20))
                let needleptr := mload(add(needle, 0x20))
                equal := eq(keccak256(selfptr, length), keccak256(needleptr, length))
            }
        }

        if (equal) {
            self._len -= needle._len;
            self._ptr += needle._len;
        }

        return self;
    }

    /*
     * @dev Returns true if the slice ends with `needle`.
     * @param self The slice to operate on.
     * @param needle The slice to search for.
     * @return True if the slice starts with the provided text, false otherwise.
     */
    function endsWith(slice memory self, slice memory needle) internal pure returns (bool) {
        if (self._len < needle._len) {
            return false;
        }

        uint selfptr = self._ptr + self._len - needle._len;

        if (selfptr == needle._ptr) {
            return true;
        }

        bool equal;
        assembly {
            let length := mload(needle)
            let needleptr := mload(add(needle, 0x20))
            equal := eq(keccak256(selfptr, length), keccak256(needleptr, length))
        }

        return equal;
    }

    /*
     * @dev If `self` ends with `needle`, `needle` is removed from the
     *      end of `self`. Otherwise, `self` is unmodified.
     * @param self The slice to operate on.
     * @param needle The slice to search for.
     * @return `self`
     */
    function until(slice memory self, slice memory needle) internal pure returns (slice memory) {
        if (self._len < needle._len) {
            return self;
        }

        uint selfptr = self._ptr + self._len - needle._len;
        bool equal = true;
        if (selfptr != needle._ptr) {
            assembly {
                let length := mload(needle)
                let needleptr := mload(add(needle, 0x20))
                equal := eq(keccak256(selfptr, length), keccak256(needleptr, length))
            }
        }

        if (equal) {
            self._len -= needle._len;
        }

        return self;
    }

    // Returns the memory address of the first byte of the first occurrence of
    // `needle` in `self`, or the first byte after `self` if not found.
    function findPtr(uint selflen, uint selfptr, uint needlelen, uint needleptr) private pure returns (uint) {
        uint ptr = selfptr;
        uint idx;

        if (needlelen <= selflen) {
            if (needlelen <= 32) {
                bytes32 mask = bytes32(~(2 ** (8 * (32 - needlelen)) - 1));

                bytes32 needledata;
                assembly { needledata := and(mload(needleptr), mask) }

                uint end = selfptr + selflen - needlelen;
                bytes32 ptrdata;
                assembly { ptrdata := and(mload(ptr), mask) }

                while (ptrdata != needledata) {
                    if (ptr >= end)
                        return selfptr + selflen;
                    ptr++;
                    assembly { ptrdata := and(mload(ptr), mask) }
                }
                return ptr;
            } else {
                // For long needles, use hashing
                bytes32 hash;
                assembly { hash := keccak256(needleptr, needlelen) }

                for (idx = 0; idx <= selflen - needlelen; idx++) {
                    bytes32 testHash;
                    assembly { testHash := keccak256(ptr, needlelen) }
                    if (hash == testHash)
                        return ptr;
                    ptr += 1;
                }
            }
        }
        return selfptr + selflen;
    }

    // Returns the memory address of the first byte after the last occurrence of
    // `needle` in `self`, or the address of `self` if not found.
    function rfindPtr(uint selflen, uint selfptr, uint needlelen, uint needleptr) private pure returns (uint) {
        uint ptr;

        if (needlelen <= selflen) {
            if (needlelen <= 32) {
                bytes32 mask = bytes32(~(2 ** (8 * (32 - needlelen)) - 1));

                bytes32 needledata;
                assembly { needledata := and(mload(needleptr), mask) }

                ptr = selfptr + selflen - needlelen;
                bytes32 ptrdata;
                assembly { ptrdata := and(mload(ptr), mask) }

                while (ptrdata != needledata) {
                    if (ptr <= selfptr)
                        return selfptr;
                    ptr--;
                    assembly { ptrdata := and(mload(ptr), mask) }
                }
                return ptr + needlelen;
            } else {
                // For long needles, use hashing
                bytes32 hash;
                assembly { hash := keccak256(needleptr, needlelen) }
                ptr = selfptr + (selflen - needlelen);
                while (ptr >= selfptr) {
                    bytes32 testHash;
                    assembly { testHash := keccak256(ptr, needlelen) }
                    if (hash == testHash)
                        return ptr + needlelen;
                    ptr -= 1;
                }
            }
        }
        return selfptr;
    }

    /*
     * @dev Modifies `self` to contain everything from the first occurrence of
     *      `needle` to the end of the slice. `self` is set to the empty slice
     *      if `needle` is not found.
     * @param self The slice to search and modify.
     * @param needle The text to search for.
     * @return `self`.
     */
    function find(slice memory self, slice memory needle) internal pure returns (slice memory) {
        uint ptr = findPtr(self._len, self._ptr, needle._len, needle._ptr);
        self._len -= ptr - self._ptr;
        self._ptr = ptr;
        return self;
    }

    /*
     * @dev Modifies `self` to contain the part of the string from the start of
     *      `self` to the end of the first occurrence of `needle`. If `needle`
     *      is not found, `self` is set to the empty slice.
     * @param self The slice to search and modify.
     * @param needle The text to search for.
     * @return `self`.
     */
    function rfind(slice memory self, slice memory needle) internal pure returns (slice memory) {
        uint ptr = rfindPtr(self._len, self._ptr, needle._len, needle._ptr);
        self._len = ptr - self._ptr;
        return self;
    }

    /*
     * @dev Splits the slice, setting `self` to everything after the first
     *      occurrence of `needle`, and `token` to everything before it. If
     *      `needle` does not occur in `self`, `self` is set to the empty slice,
     *      and `token` is set to the entirety of `self`.
     * @param self The slice to split.
     * @param needle The text to search for in `self`.
     * @param token An output parameter to which the first token is written.
     * @return `token`.
     */
    function split(slice memory self, slice memory needle, slice memory token) internal pure returns (slice memory) {
        uint ptr = findPtr(self._len, self._ptr, needle._len, needle._ptr);
        token._ptr = self._ptr;
        token._len = ptr - self._ptr;
        if (ptr == self._ptr + self._len) {
            // Not found
            self._len = 0;
        } else {
            self._len -= token._len + needle._len;
            self._ptr = ptr + needle._len;
        }
        return token;
    }

    /*
     * @dev Splits the slice, setting `self` to everything after the first
     *      occurrence of `needle`, and returning everything before it. If
     *      `needle` does not occur in `self`, `self` is set to the empty slice,
     *      and the entirety of `self` is returned.
     * @param self The slice to split.
     * @param needle The text to search for in `self`.
     * @return The part of `self` up to the first occurrence of `delim`.
     */
    function split(slice memory self, slice memory needle) internal pure returns (slice memory token) {
        split(self, needle, token);
    }

    /*
     * @dev Splits the slice, setting `self` to everything before the last
     *      occurrence of `needle`, and `token` to everything after it. If
     *      `needle` does not occur in `self`, `self` is set to the empty slice,
     *      and `token` is set to the entirety of `self`.
     * @param self The slice to split.
     * @param needle The text to search for in `self`.
     * @param token An output parameter to which the first token is written.
     * @return `token`.
     */
    function rsplit(slice memory self, slice memory needle, slice memory token) internal pure returns (slice memory) {
        uint ptr = rfindPtr(self._len, self._ptr, needle._len, needle._ptr);
        token._ptr = ptr;
        token._len = self._len - (ptr - self._ptr);
        if (ptr == self._ptr) {
            // Not found
            self._len = 0;
        } else {
            self._len -= token._len + needle._len;
        }
        return token;
    }

    /*
     * @dev Splits the slice, setting `self` to everything before the last
     *      occurrence of `needle`, and returning everything after it. If
     *      `needle` does not occur in `self`, `self` is set to the empty slice,
     *      and the entirety of `self` is returned.
     * @param self The slice to split.
     * @param needle The text to search for in `self`.
     * @return The part of `self` after the last occurrence of `delim`.
     */
    function rsplit(slice memory self, slice memory needle) internal pure returns (slice memory token) {
        rsplit(self, needle, token);
    }

    /*
     * @dev Counts the number of nonoverlapping occurrences of `needle` in `self`.
     * @param self The slice to search.
     * @param needle The text to search for in `self`.
     * @return The number of occurrences of `needle` found in `self`.
     */
    function count(slice memory self, slice memory needle) internal pure returns (uint cnt) {
        uint ptr = findPtr(self._len, self._ptr, needle._len, needle._ptr) + needle._len;
        while (ptr <= self._ptr + self._len) {
            cnt++;
            ptr = findPtr(self._len - (ptr - self._ptr), ptr, needle._len, needle._ptr) + needle._len;
        }
    }

    /*
     * @dev Returns True if `self` contains `needle`.
     * @param self The slice to search.
     * @param needle The text to search for in `self`.
     * @return True if `needle` is found in `self`, false otherwise.
     */
    function contains(slice memory self, slice memory needle) internal pure returns (bool) {
        return rfindPtr(self._len, self._ptr, needle._len, needle._ptr) != self._ptr;
    }

    /*
     * @dev Returns a newly allocated string containing the concatenation of
     *      `self` and `other`.
     * @param self The first slice to concatenate.
     * @param other The second slice to concatenate.
     * @return The concatenation of the two strings.
     */
    function concat(slice memory self, slice memory other) internal pure returns (string memory) {
        string memory ret = new string(self._len + other._len);
        uint retptr;
        assembly { retptr := add(ret, 32) }
        memcpy(retptr, self._ptr, self._len);
        memcpy(retptr + self._len, other._ptr, other._len);
        return ret;
    }

    /*
     * @dev Joins an array of slices, using `self` as a delimiter, returning a
     *      newly allocated string.
     * @param self The delimiter to use.
     * @param parts A list of slices to join.
     * @return A newly allocated string containing all the slices in `parts`,
     *         joined with `self`.
     */
    function join(slice memory self, slice[] memory parts) internal pure returns (string memory) {
        if (parts.length == 0)
            return "";

        uint length = self._len * (parts.length - 1);
        for(uint i = 0; i < parts.length; i++)
            length += parts[i]._len;

        string memory ret = new string(length);
        uint retptr;
        assembly { retptr := add(ret, 32) }

        for(i = 0; i < parts.length; i++) {
            memcpy(retptr, parts[i]._ptr, parts[i]._len);
            retptr += parts[i]._len;
            if (i < parts.length - 1) {
                memcpy(retptr, self._ptr, self._len);
                retptr += self._len;
            }
        }

        return ret;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"constant":true,"inputs":[{"name":"_interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"name","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"_tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_to","type":"address"},{"name":"_tokenId","type":"uint256"}],"name":"approve","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"implementsERC721","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"pure","type":"function"},{"constant":true,"inputs":[],"name":"totalSupply","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"InterfaceId_ERC165","outputs":[{"name":"","type":"bytes4"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_tokenId","type":"uint256"}],"name":"revoke","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_from","type":"address"},{"name":"_to","type":"address"},{"name":"_tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"_owner","type":"address"},{"name":"_index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"","type":"uint256"}],"name":"tokenTypes","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_from","type":"address"},{"name":"_to","type":"address"},{"name":"_tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"","type":"uint256"}],"name":"allTokensIndex","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"manager","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"_tokenId","type":"uint256"}],"name":"exists","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"_index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_type","type":"uint256"},{"name":"_oldIssuer","type":"address"},{"name":"_newIssuer","type":"address"}],"name":"transferIssuer","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"","type":"uint256"}],"name":"allTokens","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"_tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"_owner","type":"address"}],"name":"balanceOf","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"","type":"uint256"}],"name":"ownedTokensIndex","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"nextTokenId","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_type","type":"uint256"},{"name":"_oldAddress","type":"address"},{"name":"_newAddress","type":"address"}],"name":"transferAll","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_issuer","type":"address"},{"name":"_owners","type":"address[]"},{"name":"_type","type":"uint256"}],"name":"issueBatch","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"symbol","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"nextTokenType","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_to","type":"address"},{"name":"_approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"","type":"uint256"}],"name":"tokenTypeIssuers","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_issuer","type":"address"},{"name":"_owner","type":"address"},{"name":"_type","type":"uint256"}],"name":"issue","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_from","type":"address"},{"name":"_to","type":"address"},{"name":"_tokenId","type":"uint256"},{"name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"","type":"uint256"}],"name":"tokenIssuer","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"tokenURIPrefix","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"_tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"},{"name":"","type":"uint256"}],"name":"ownedTokens","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"","type":"uint256"},{"name":"","type":"uint256"}],"name":"tokensByType","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"_owner","type":"address"},{"name":"_operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_issuer","type":"address"}],"name":"createType","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"inputs":[{"name":"_name","type":"string"},{"name":"_symbol","type":"string"},{"name":"_tokenURIPrefix","type":"string"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"name":"_issuer","type":"address"},{"indexed":false,"name":"_type","type":"uint256"},{"indexed":false,"name":"_timestamp","type":"uint256"}],"name":"TokenTypeCreated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"_issuer","type":"address"},{"indexed":false,"name":"_owner","type":"address"},{"indexed":false,"name":"_type","type":"uint256"},{"indexed":false,"name":"_tokenId","type":"uint256"},{"indexed":false,"name":"_timestamp","type":"uint256"}],"name":"TokenIssued","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"_issuer","type":"address"},{"indexed":false,"name":"_owner","type":"address"},{"indexed":false,"name":"_type","type":"uint256"},{"indexed":false,"name":"_tokenId","type":"uint256"},{"indexed":false,"name":"_timestamp","type":"uint256"}],"name":"TokenRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"_type","type":"uint256"},{"indexed":false,"name":"_oldIssuer","type":"address"},{"indexed":false,"name":"_newIssuer","type":"address"},{"indexed":false,"name":"_timestamp","type":"uint256"}],"name":"IssuanceTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"_oldAddress","type":"address"},{"indexed":false,"name":"_newAddress","type":"address"},{"indexed":false,"name":"_timestamp","type":"uint256"}],"name":"TransferAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"_from","type":"address"},{"indexed":true,"name":"_to","type":"address"},{"indexed":true,"name":"_tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"_owner","type":"address"},{"indexed":true,"name":"_approved","type":"address"},{"indexed":true,"name":"_tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"_owner","type":"address"},{"indexed":true,"name":"_operator","type":"address"},{"indexed":false,"name":"_approved","type":"bool"}],"name":"ApprovalForAll","type":"event"}]

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

000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000e00000000000000000000000000000000000000000000000000000000000000011436f696e626173652054726f706869657300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000034342540000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002868747470733a2f2f63622d74726f70686965732e6865726f6b756170702e636f6d2f746f6b656e2f000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : _name (string): Coinbase Trophies
Arg [1] : _symbol (string): CBT
Arg [2] : _tokenURIPrefix (string): https://cb-trophies.herokuapp.com/token/

-----Encoded View---------------
10 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000060
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000a0
Arg [2] : 00000000000000000000000000000000000000000000000000000000000000e0
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000011
Arg [4] : 436f696e626173652054726f7068696573000000000000000000000000000000
Arg [5] : 0000000000000000000000000000000000000000000000000000000000000003
Arg [6] : 4342540000000000000000000000000000000000000000000000000000000000
Arg [7] : 0000000000000000000000000000000000000000000000000000000000000028
Arg [8] : 68747470733a2f2f63622d74726f70686965732e6865726f6b756170702e636f
Arg [9] : 6d2f746f6b656e2f000000000000000000000000000000000000000000000000

bzzr://7f47d5388ed5393a7994fe9382ac1c4e3ac2e7abf322fbd0aa7dee90c1dae7bc