Contract 0x6B01c3170ae1EFEBEe1a3159172CB3F7A5ECf9E5 5

 
 
Txn Hash
Method
Block
From
To
Value
0xbfaf6f1a3a93ed9a47248a2c05888871ebbe2afcd7d88d3bdf0e2c7b3f7c01dbTransfer142999572022-03-01 8:18:19169 days 20 mins agoENS Name stepbrother.eth IN  BOOTY: BOOTY Token0 Ether0.‍00186477 36.‍14465655
0x6d64afe05dc689234178483facfd8c9b9c6c986b0d155f2f30eda1c98e78cc50Transfer130598222021-08-20 3:46:58362 days 4 hrs ago0xb43a2e523e9ff551a2d3e0881830565b06fc741b IN  BOOTY: BOOTY Token0 Ether0.‍00119046 25.‍42216551
0xafd4c7af643217f65d1beae9952ce44e4f5f5d1caefa853df9b9ce7002c7fbc1Transfer129880682021-08-09 1:48:42373 days 6 hrs ago0x831f8796ebfce24f61e2cda3e92de64f433f3d51 IN  BOOTY: BOOTY Token0 Ether0.‍001008735
0x2732805a199ab0527646e76d2abe922ed5e423a0f490eed7aaecb8cc7bc45393Approve128151692021-07-12 22:37:04400 days 10 hrs ago0xccd3d32eb89b2d44861dcadd25aef9d309bcb847 IN  BOOTY: BOOTY Token0 Ether0.‍0010154322
0x5b11980a111560083b1ebb27194e7c987dd3c71067fdce6e45ba3044c4bec8fdApprove127794922021-07-07 9:26:49405 days 23 hrs ago0xa7aaca83c140db8b16dbe6caf5bda06c96d23db3 IN  BOOTY: BOOTY Token0 Ether0.‍0013385229
0x6772bb1c89117b2def560f0a811fd9305b6f011d65d3874590c8211f6ce63c48Approve127669252021-07-05 10:28:51407 days 22 hrs ago0xe495012c6064559795c4e4c166130b0279dbc304 IN  BOOTY: BOOTY Token0 Ether0.‍0005077111
0x19eb6930e3e799e50bab9b7d17b38fa9717a792aecd65aa56fe9b886444bfa82Transfer127605962021-07-04 10:47:44408 days 21 hrs ago0x82b44f333068bb040cde35b80c0a16d8744cf261 IN  BOOTY: BOOTY Token0 Ether0.‍000219626
0xb8f3159b3684b16f321d4a8001dfe25b35f8ee7d963ec3d10420487b9b6a4cb5Transfer127356482021-06-30 13:33:43412 days 19 hrs ago0x82b44f333068bb040cde35b80c0a16d8744cf261 IN  BOOTY: BOOTY Token0 Ether0.‍0003712713.‍8
0x4699625eabae1247d6f573dd908e88cf61d204e2ac49bd1a53c103ecbca6db6fApprove125484892021-06-01 12:13:48441 days 20 hrs ago0xef2ebb268e7080ee6024b17d00fc48cc9d4673b1 IN  BOOTY: BOOTY Token0 Ether0.‍0010154322
0x92c1343e00129181379e0de7e09e94dd446bb150384b747d09617aaf47f48e87Approve125455282021-06-01 1:03:28442 days 7 hrs ago0xc70c205d232383182895933df2ee9e25e730ea52 IN  BOOTY: BOOTY Token0 Ether0.‍0012923628
0x07c89e954e1f9ba4e2c8c7ce8dd93b7cf7033035552eca18bee3ee9c61d49806Transfer125375212021-05-30 19:16:07443 days 13 hrs ago0xe95aa9b232fedd8bf0189d5ead0ea476f4191d78 IN  BOOTY: BOOTY Token0 Ether0.‍0006643634
0xdbe8eddef4d40720df90b71037f41eda831c70ed4fbc9a7452bc19f63b9c2967Transfer124859382021-05-22 19:15:17451 days 13 hrs ago0xb11e7ceaaa33c9e8438addf7c872086d688fcc9f IN  BOOTY: BOOTY Token0 Ether0.‍0015388842
0xfaf37f7451c59a62e9636487987962d5f34b7532b4c6faf0e61ed8d56b9ea477Approve124014602021-05-09 17:21:05464 days 15 hrs ago0x258f3ee2d43293dfd07ae5fa811757a73255e77c IN  BOOTY: BOOTY Token0 Ether0.‍0045232898
0x1b2d93cd86a4b9fdcc7abfb70c48500ae65fe145b1448d0501dab5fac318810dTransfer121692772021-04-03 22:22:34500 days 10 hrs ago0x0ef936f2fc7e140e84872dd83f7a969abee64db8 IN  BOOTY: BOOTY Token0 Ether0.‍00320871147
0xd140130a464ec94da56a53961c7ac6dece8154d876736f0f55e9e29f04a70402Transfer121673292021-04-03 15:11:56500 days 17 hrs ago0xc5c447a5417dc3d3690290bb5ef14fcb7722223c IN  BOOTY: BOOTY Token0 Ether0.‍00281581129
0x64398fda6bc11967473f61a6971978a34636d48cf6d206e657f72d2793dce65fTransfer121673042021-04-03 15:07:07500 days 17 hrs ago0x02cbf96ab23c3bf40b9a6c51671a4376b7d21607 IN  BOOTY: BOOTY Token0 Ether0.‍00290312133
0x0aa7386c8bebf30bc6cc4bda4bc3349a9b99ef69884576e015c3f729efd2ea3aTransfer120977732021-03-23 22:18:17511 days 10 hrs ago0x3c04028143c775bc4581717d38d8a20a599f4848 IN  BOOTY: BOOTY Token0 Ether0.‍00500208136
0x62907ea91afea2a4b351124b3ab301d2a6e73110486e4bf125eb29522dcb8665Transfer120977562021-03-23 22:15:05511 days 10 hrs agoENS Name ibrahimtester.eth IN  BOOTY: BOOTY Token0 Ether0.‍0080259155
0x52f51cb3cf018f7160240340510fe90f2741bd6ff4c198d473699d048e7c45a0Transfer120443022021-03-15 16:44:56519 days 15 hrs ago0x3c04028143c775bc4581717d38d8a20a599f4848 IN  BOOTY: BOOTY Token0 Ether0.‍00991069191.‍4
0x50f1091c29e0785fd0fd4151ccd57f07b7b1ebf3ce9905457d1fb2f47a2ac0adApprove120265442021-03-12 23:01:43522 days 9 hrs ago0x3c04028143c775bc4581717d38d8a20a599f4848 IN  BOOTY: BOOTY Token0 Ether0.‍00589707134
0xf8b39d16b0a2617ad180d584d2801a97d89e75b421f87ccfd83cce10ae2b284cTransfer120133092021-03-10 21:43:29524 days 10 hrs agoENS Name tehllama.eth IN  BOOTY: BOOTY Token0 Ether0.‍001919888
0x4c0788a1941b1a16349b8af3fc2a9d629fec5119521bbb9b4251fb2efbefd096Transfer119843602021-03-06 10:39:16528 days 21 hrs ago0x7c66344e588e1708a015ef9b3ed7552d8b7dcdbc IN  BOOTY: BOOTY Token0 Ether0.‍001484368
0x03188f7622132c41c8ea80d19bb94476733d8af6084d1b8d6dcbadcfe6e85f08Transfer119843572021-03-06 10:38:25528 days 22 hrs ago0xd6ae43e2446cc17378926291f5197a1e87d772dd IN  BOOTY: BOOTY Token0 Ether0.‍001484368
0xcb0df21a4a110a127a8c4e536422531b393e58ff45ce2b64379da6dd9f85fea1Transfer118956402021-02-20 19:12:52542 days 13 hrs ago0x66ab525022c5291c0c3d7a7199a38b827586f30c IN  BOOTY: BOOTY Token0 Ether0.‍00283764130
0x5812a68e39e558f3dfdaf510c8fec216d598e075cf4e4f69f9af57abf9664d4dTransfer118956172021-02-20 19:08:15542 days 13 hrs ago0x66ab525022c5291c0c3d7a7199a38b827586f30c IN  BOOTY: BOOTY Token0 Ether0.‍00356832126
[ Download CSV Export 

OVERVIEW

Platform and payment services for the adult industry.

Latest 1 internal transaction
Parent Txn Hash Block From To Value
0xc6123eea98af9db149313005d9799eefd323baf1566adfaa53d25cc37622954362760452018-09-05 11:38:131441 days 21 hrs ago BOOTY: Deployer  Contract Creation0 Ether
[ Download CSV Export 
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
MintAndBurnToken

Compiler Version
v0.4.24+commit.e67f0147

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, MIT license

Contract Source Code (Solidity)

/**
 *Submitted for verification at Etherscan.io on 2020-06-19
*/

pragma solidity 0.4.24;

// File: contracts/BytesLib.sol

library BytesLib {
    function concat(bytes memory _preBytes, bytes memory _postBytes) internal pure returns (bytes) {
        bytes memory tempBytes;

        assembly {
            // Get a location of some free memory and store it in tempBytes as
            // Solidity does for memory variables.
            tempBytes := mload(0x40)

            // Store the length of the first bytes array at the beginning of
            // the memory for tempBytes.
            let length := mload(_preBytes)
            mstore(tempBytes, length)

            // Maintain a memory counter for the current write location in the
            // temp bytes array by adding the 32 bytes for the array length to
            // the starting location.
            let mc := add(tempBytes, 0x20)
            // Stop copying when the memory counter reaches the length of the
            // first bytes array.
            let end := add(mc, length)

            for {
                // Initialize a copy counter to the start of the _preBytes data,
                // 32 bytes into its memory.
                let cc := add(_preBytes, 0x20)
            } lt(mc, end) {
                // Increase both counters by 32 bytes each iteration.
                mc := add(mc, 0x20)
                cc := add(cc, 0x20)
            } {
                // Write the _preBytes data into the tempBytes memory 32 bytes
                // at a time.
                mstore(mc, mload(cc))
            }

            // Add the length of _postBytes to the current length of tempBytes
            // and store it as the new length in the first 32 bytes of the
            // tempBytes memory.
            length := mload(_postBytes)
            mstore(tempBytes, add(length, mload(tempBytes)))

            // Move the memory counter back from a multiple of 0x20 to the
            // actual end of the _preBytes data.
            mc := end
            // Stop copying when the memory counter reaches the new combined
            // length of the arrays.
            end := add(mc, length)

            for {
                let cc := add(_postBytes, 0x20)
            } lt(mc, end) {
                mc := add(mc, 0x20)
                cc := add(cc, 0x20)
            } {
                mstore(mc, mload(cc))
            }

            // Update the free-memory pointer by padding our last write location
            // to 32 bytes: add 31 bytes to the end of tempBytes to move to the
            // next 32 byte block, then round down to the nearest multiple of
            // 32. If the sum of the length of the two arrays is zero then add 
            // one before rounding down to leave a blank 32 bytes (the length block with 0).
            mstore(0x40, and(
              add(add(end, iszero(add(length, mload(_preBytes)))), 31),
              not(31) // Round down to the nearest 32 bytes.
            ))
        }

        return tempBytes;
    }

    function concatStorage(bytes storage _preBytes, bytes memory _postBytes) internal {
        assembly {
            // Read the first 32 bytes of _preBytes storage, which is the length
            // of the array. (We don't need to use the offset into the slot
            // because arrays use the entire slot.)
            let fslot := sload(_preBytes_slot)
            // Arrays of 31 bytes or less have an even value in their slot,
            // while longer arrays have an odd value. The actual length is
            // the slot divided by two for odd values, and the lowest order
            // byte divided by two for even values.
            // If the slot is even, bitwise and the slot with 255 and divide by
            // two to get the length. If the slot is odd, bitwise and the slot
            // with -1 and divide by two.
            let slength := div(and(fslot, sub(mul(0x100, iszero(and(fslot, 1))), 1)), 2)
            let mlength := mload(_postBytes)
            let newlength := add(slength, mlength)
            // slength can contain both the length and contents of the array
            // if length < 32 bytes so let's prepare for that
            // v. http://solidity.readthedocs.io/en/latest/miscellaneous.html#layout-of-state-variables-in-storage
            switch add(lt(slength, 32), lt(newlength, 32))
            case 2 {
                // Since the new array still fits in the slot, we just need to
                // update the contents of the slot.
                // uint256(bytes_storage) = uint256(bytes_storage) + uint256(bytes_memory) + new_length
                sstore(
                    _preBytes_slot,
                    // all the modifications to the slot are inside this
                    // next block
                    add(
                        // we can just add to the slot contents because the
                        // bytes we want to change are the LSBs
                        fslot,
                        add(
                            mul(
                                div(
                                    // load the bytes from memory
                                    mload(add(_postBytes, 0x20)),
                                    // zero all bytes to the right
                                    exp(0x100, sub(32, mlength))
                                ),
                                // and now shift left the number of bytes to
                                // leave space for the length in the slot
                                exp(0x100, sub(32, newlength))
                            ),
                            // increase length by the double of the memory
                            // bytes length
                            mul(mlength, 2)
                        )
                    )
                )
            }
            case 1 {
                // The stored value fits in the slot, but the combined value
                // will exceed it.
                // get the keccak hash to get the contents of the array
                mstore(0x0, _preBytes_slot)
                let sc := add(keccak256(0x0, 0x20), div(slength, 32))

                // save new length
                sstore(_preBytes_slot, add(mul(newlength, 2), 1))

                // The contents of the _postBytes array start 32 bytes into
                // the structure. Our first read should obtain the `submod`
                // bytes that can fit into the unused space in the last word
                // of the stored array. To get this, we read 32 bytes starting
                // from `submod`, so the data we read overlaps with the array
                // contents by `submod` bytes. Masking the lowest-order
                // `submod` bytes allows us to add that value directly to the
                // stored value.

                let submod := sub(32, slength)
                let mc := add(_postBytes, submod)
                let end := add(_postBytes, mlength)
                let mask := sub(exp(0x100, submod), 1)

                sstore(
                    sc,
                    add(
                        and(
                            fslot,
                            0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00
                        ),
                        and(mload(mc), mask)
                    )
                )

                for {
                    mc := add(mc, 0x20)
                    sc := add(sc, 1)
                } lt(mc, end) {
                    sc := add(sc, 1)
                    mc := add(mc, 0x20)
                } {
                    sstore(sc, mload(mc))
                }

                mask := exp(0x100, sub(mc, end))

                sstore(sc, mul(div(mload(mc), mask), mask))
            }
            default {
                // get the keccak hash to get the contents of the array
                mstore(0x0, _preBytes_slot)
                // Start copying to the last used word of the stored array.
                let sc := add(keccak256(0x0, 0x20), div(slength, 32))

                // save new length
                sstore(_preBytes_slot, add(mul(newlength, 2), 1))

                // Copy over the first `submod` bytes of the new data as in
                // case 1 above.
                let slengthmod := mod(slength, 32)
                let mlengthmod := mod(mlength, 32)
                let submod := sub(32, slengthmod)
                let mc := add(_postBytes, submod)
                let end := add(_postBytes, mlength)
                let mask := sub(exp(0x100, submod), 1)

                sstore(sc, add(sload(sc), and(mload(mc), mask)))
                
                for { 
                    sc := add(sc, 1)
                    mc := add(mc, 0x20)
                } lt(mc, end) {
                    sc := add(sc, 1)
                    mc := add(mc, 0x20)
                } {
                    sstore(sc, mload(mc))
                }

                mask := exp(0x100, sub(mc, end))

                sstore(sc, mul(div(mload(mc), mask), mask))
            }
        }
    }

    function slice(bytes _bytes, uint _start, uint _length) internal  pure returns (bytes) {
        require(_bytes.length >= (_start + _length));

        bytes memory tempBytes;

        assembly {
            switch iszero(_length)
            case 0 {
                // Get a location of some free memory and store it in tempBytes as
                // Solidity does for memory variables.
                tempBytes := mload(0x40)

                // The first word of the slice result is potentially a partial
                // word read from the original array. To read it, we calculate
                // the length of that partial word and start copying that many
                // bytes into the array. The first word we copy will start with
                // data we don't care about, but the last `lengthmod` bytes will
                // land at the beginning of the contents of the new array. When
                // we're done copying, we overwrite the full first word with
                // the actual length of the slice.
                let lengthmod := and(_length, 31)

                // The multiplication in the next line is necessary
                // because when slicing multiples of 32 bytes (lengthmod == 0)
                // the following copy loop was copying the origin's length
                // and then ending prematurely not copying everything it should.
                let mc := add(add(tempBytes, lengthmod), mul(0x20, iszero(lengthmod)))
                let end := add(mc, _length)

                for {
                    // The multiplication in the next line has the same exact purpose
                    // as the one above.
                    let cc := add(add(add(_bytes, lengthmod), mul(0x20, iszero(lengthmod))), _start)
                } lt(mc, end) {
                    mc := add(mc, 0x20)
                    cc := add(cc, 0x20)
                } {
                    mstore(mc, mload(cc))
                }

                mstore(tempBytes, _length)

                //update free-memory pointer
                //allocating the array padded to 32 bytes like the compiler does now
                mstore(0x40, and(add(mc, 31), not(31)))
            }
            //if we want a zero-length slice let's just return a zero-length array
            default {
                tempBytes := mload(0x40)

                mstore(0x40, add(tempBytes, 0x20))
            }
        }

        return tempBytes;
    }

    function toAddress(bytes _bytes, uint _start) internal  pure returns (address) {
        require(_bytes.length >= (_start + 20));
        address tempAddress;

        assembly {
            tempAddress := div(mload(add(add(_bytes, 0x20), _start)), 0x1000000000000000000000000)
        }

        return tempAddress;
    }

    function toUint(bytes _bytes, uint _start) internal  pure returns (uint256) {
        require(_bytes.length >= (_start + 32));
        uint256 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0x20), _start))
        }

        return tempUint;
    }

    function equal(bytes memory _preBytes, bytes memory _postBytes) internal pure returns (bool) {
        bool success = true;

        assembly {
            let length := mload(_preBytes)

            // if lengths don't match the arrays are not equal
            switch eq(length, mload(_postBytes))
            case 1 {
                // cb is a circuit breaker in the for loop since there's
                //  no said feature for inline assembly loops
                // cb = 1 - don't breaker
                // cb = 0 - break
                let cb := 1

                let mc := add(_preBytes, 0x20)
                let end := add(mc, length)

                for {
                    let cc := add(_postBytes, 0x20)
                // the next line is the loop condition:
                // while(uint(mc < end) + cb == 2)
                } eq(add(lt(mc, end), cb), 2) {
                    mc := add(mc, 0x20)
                    cc := add(cc, 0x20)
                } {
                    // if any of these checks fails then arrays are not equal
                    if iszero(eq(mload(mc), mload(cc))) {
                        // unsuccess:
                        success := 0
                        cb := 0
                    }
                }
            }
            default {
                // unsuccess:
                success := 0
            }
        }

        return success;
    }

    function equalStorage(bytes storage _preBytes, bytes memory _postBytes) internal view returns (bool) {
        bool success = true;

        assembly {
            // we know _preBytes_offset is 0
            let fslot := sload(_preBytes_slot)
            // Decode the length of the stored array like in concatStorage().
            let slength := div(and(fslot, sub(mul(0x100, iszero(and(fslot, 1))), 1)), 2)
            let mlength := mload(_postBytes)

            // if lengths don't match the arrays are not equal
            switch eq(slength, mlength)
            case 1 {
                // slength can contain both the length and contents of the array
                // if length < 32 bytes so let's prepare for that
                // v. http://solidity.readthedocs.io/en/latest/miscellaneous.html#layout-of-state-variables-in-storage
                if iszero(iszero(slength)) {
                    switch lt(slength, 32)
                    case 1 {
                        // blank the last byte which is the length
                        fslot := mul(div(fslot, 0x100), 0x100)

                        if iszero(eq(fslot, mload(add(_postBytes, 0x20)))) {
                            // unsuccess:
                            success := 0
                        }
                    }
                    default {
                        // cb is a circuit breaker in the for loop since there's
                        //  no said feature for inline assembly loops
                        // cb = 1 - don't breaker
                        // cb = 0 - break
                        let cb := 1

                        // get the keccak hash to get the contents of the array
                        mstore(0x0, _preBytes_slot)
                        let sc := keccak256(0x0, 0x20)

                        let mc := add(_postBytes, 0x20)
                        let end := add(mc, mlength)

                        // the next line is the loop condition:
                        // while(uint(mc < end) + cb == 2)
                        for {} eq(add(lt(mc, end), cb), 2) {
                            sc := add(sc, 1)
                            mc := add(mc, 0x20)
                        } {
                            if iszero(eq(sload(sc), mload(mc))) {
                                // unsuccess:
                                success := 0
                                cb := 0
                            }
                        }
                    }
                }
            }
            default {
                // unsuccess:
                success := 0
            }
        }

        return success;
    }
}

// File: contracts/Token.sol

// Abstract contract for the full ERC 20 Token standard
// https://github.com/ethereum/EIPs/issues/20
pragma solidity 0.4.24;

contract Token {
    /* This is a slight change to the ERC20 base standard.
    function totalSupply() constant returns (uint256 supply);
    is replaced with:
    uint256 public totalSupply;
    This automatically creates a getter function for the totalSupply.
    This is moved to the base contract since public getter functions are not
    currently recognised as an implementation of the matching abstract
    function by the compiler.
    */
    /// total amount of tokens
    uint256 public totalSupply;

    /// @param _owner The address from which the balance will be retrieved
    /// @return The balance
    function balanceOf(address _owner) constant public returns (uint256 balance);

    /// @notice send `_value` token to `_to` from `msg.sender`
    /// @param _to The address of the recipient
    /// @param _value The amount of token to be transferred
    /// @return Whether the transfer was successful or not
    function transfer(address _to, uint256 _value) public returns (bool success);

    /// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
    /// @param _from The address of the sender
    /// @param _to The address of the recipient
    /// @param _value The amount of token to be transferred
    /// @return Whether the transfer was successful or not
    function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);

    /// @notice `msg.sender` approves `_spender` to spend `_value` tokens
    /// @param _spender The address of the account able to transfer the tokens
    /// @param _value The amount of tokens to be approved for transfer
    /// @return Whether the approval was successful or not
    function approve(address _spender, uint256 _value) public returns (bool success);

    /// @param _owner The address of the account owning tokens
    /// @param _spender The address of the account able to transfer the tokens
    /// @return Amount of remaining tokens allowed to spent
    function allowance(address _owner, address _spender) public constant returns (uint256 remaining);

    event Transfer(address indexed _from, address indexed _to, uint256 _value);
    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}

// File: contracts/StandardToken.sol

/*
You should inherit from StandardToken or, for a token like you would want to
deploy in something like Mist, see HumanStandardToken.sol.
(This implements ONLY the standard functions and NOTHING else.
If you deploy this, you won't have anything useful.)

Implements ERC 20 Token standard: https://github.com/ethereum/EIPs/issues/20
.*/
pragma solidity 0.4.24;



contract StandardToken is Token {

    function transfer(address _to, uint256 _value) public returns (bool success) {
        //Default assumes totalSupply can't be over max (2^256 - 1).
        //If your token leaves out totalSupply and can issue more tokens as time goes on, you need to check if it doesn't wrap.
        //Replace the if with this one instead.
        //require(balances[msg.sender] >= _value && balances[_to] + _value > balances[_to]);
        require(balances[msg.sender] >= _value);
        balances[msg.sender] -= _value;
        balances[_to] += _value;
        emit Transfer(msg.sender, _to, _value);
        return true;
    }

    function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
        //same as above. Replace this line with the following if you want to protect against wrapping uints.
        //require(balances[_from] >= _value && allowed[_from][msg.sender] >= _value && balances[_to] + _value > balances[_to]);
        require(balances[_from] >= _value && allowed[_from][msg.sender] >= _value);
        balances[_to] += _value;
        balances[_from] -= _value;
        allowed[_from][msg.sender] -= _value;
        emit Transfer(_from, _to, _value);
        return true;
    }

    function balanceOf(address _owner) public constant returns (uint256 balance) {
        return balances[_owner];
    }

    function approve(address _spender, uint256 _value) public returns (bool success) {
        allowed[msg.sender][_spender] = _value;
        emit Approval(msg.sender, _spender, _value);
        return true;
    }

    function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
      return allowed[_owner][_spender];
    }

    mapping (address => uint256) balances;
    mapping (address => mapping (address => uint256)) allowed;
}

// File: contracts/HumanStandardToken.sol

/*
This Token Contract implements the standard token functionality (https://github.com/ethereum/EIPs/issues/20) as well as the following OPTIONAL extras intended for use by humans.

In other words. This is intended for deployment in something like a Token Factory or Mist wallet, and then used by humans.
Imagine coins, currencies, shares, voting weight, etc.
Machine-based, rapid creation of many tokens would not necessarily need these extra features or will be minted in other manners.

1) Initial Finite Supply (upon creation one specifies how much is minted).
2) In the absence of a token registry: Optional Decimal, Symbol & Name.
3) Optional approveAndCall() functionality to notify a contract if an approval() has occurred.

.*/



pragma solidity 0.4.24;

contract HumanStandardToken is StandardToken {

    /* Public variables of the token */

    /*
    NOTE:
    The following variables are OPTIONAL vanities. One does not have to include them.
    They allow one to customise the token contract & in no way influences the core functionality.
    Some wallets/interfaces might not even bother to look at this information.
    */
    string public name;                   //fancy name: eg Simon Bucks
    uint8 public decimals;                //How many decimals to show. ie. There could 1000 base units with 3 decimals. Meaning 0.980 SBX = 980 base units. It's like comparing 1 wei to 1 ether.
    string public symbol;                 //An identifier: eg SBX
    string public version = 'H0.1';       //human 0.1 standard. Just an arbitrary versioning scheme.

    constructor(
        uint256 _initialAmount,
        string _tokenName,
        uint8 _decimalUnits,
        string _tokenSymbol
        ) public {
        balances[msg.sender] = _initialAmount;               // Give the creator all initial tokens
        totalSupply = _initialAmount;                        // Update total supply
        name = _tokenName;                                   // Set the name for display purposes
        decimals = _decimalUnits;                            // Amount of decimals for display purposes
        symbol = _tokenSymbol;                               // Set the symbol for display purposes
    }

    /* Approves and then calls the receiving contract */
    function approveAndCall(address _spender, uint256 _value, bytes _extraData) public returns (bool success) {
        allowed[msg.sender][_spender] = _value;
        emit Approval(msg.sender, _spender, _value);

        //call the receiveApproval function on the contract you want to be notified. This crafts the function signature manually so one doesn't have to include a contract in here just for this.
        //receiveApproval(address _from, uint256 _value, address _tokenContract, bytes _extraData)
        //it is assumed that when does this that the call *should* succeed, otherwise one would use vanilla approve instead.
        require(_spender.call(bytes4(bytes32(keccak256("receiveApproval(address,uint256,address,bytes)"))), msg.sender, _value, this, _extraData));
        return true;
    }
}

// File: contracts/OZ_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: contracts/SafeMath.sol

/**
 * @title SafeMath
 * @dev Math operations with safety checks that throw on error
 */
library SafeMath {
  function mul(uint256 a, uint256 b) internal pure returns (uint256) {
    uint256 c = a * b;
    assert(a == 0 || c / a == b);
    return c;
  }

  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 c;
  }

  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
    assert(b <= a);
    return a - b;
  }

  function add(uint256 a, uint256 b) internal pure returns (uint256) {
    uint256 c = a + b;
    assert(c >= a);
    return c;
  }
}

// File: contracts/MintAndBurnToken.sol

/**
 * @title Mintable token
 * @dev Simple ERC20 Token example, with mintable token creation
 * @dev Issue: * https://github.com/OpenZeppelin/zeppelin-solidity/issues/120
 * Based on code by TokenMarketNet: https://github.com/TokenMarketNet/ico/blob/master/contracts/MintableToken.sol
 */
contract MintAndBurnToken is StandardToken, Ownable {
  event Mint(address indexed to, uint256 amount);
  event MintFinished();

  bool public mintingFinished = false;


  modifier canMint() {
    require(!mintingFinished);
    _;
  }

/* Public variables of the token */

    /*
    NOTE:
    The following variables are OPTIONAL vanities. One does not have to include them.
    They allow one to customise the token contract & in no way influences the core functionality.
    Some wallets/interfaces might not even bother to look at this information.
    */
    string public name;                   //fancy name: eg Simon Bucks
    uint8 public decimals;                //How many decimals to show. ie. There could 1000 base units with 3 decimals. Meaning 0.980 SBX = 980 base units. It's like comparing 1 wei to 1 ether.
    string public symbol;                 //An identifier: eg SBX
    string public version = 'H0.1';       //human 0.1 standard. Just an arbitrary versioning scheme.

    constructor(
        string _tokenName,
        uint8 _decimalUnits,
        string _tokenSymbol
        ) public {
        name = _tokenName;                                   // Set the name for display purposes
        decimals = _decimalUnits;                            // Amount of decimals for display purposes
        symbol = _tokenSymbol;                               // Set the symbol for display purposes
    }

  /**
   * @dev Function to mint tokens
   * @param _to The address that will receive the minted tokens.
   * @param _amount The amount of tokens to mint.
   * @return A boolean that indicates if the operation was successful.
   */
  function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
    totalSupply = SafeMath.add(_amount, totalSupply);
    balances[_to] = SafeMath.add(_amount,balances[_to]);
    emit Mint(_to, _amount);
    emit Transfer(address(0), _to, _amount);
    return true;
  }

  /**
   * @dev Function to stop minting new tokens.
   * @return True if the operation was successful.
   */
  function finishMinting() onlyOwner canMint public returns (bool) {
    mintingFinished = true;
    emit MintFinished();
    return true;
  }

  // -----------------------------------
  // BURN FUNCTIONS BELOW
  // https://github.com/OpenZeppelin/openzeppelin-solidity/blob/master/contracts/token/ERC20/BurnableToken.sol
  // -----------------------------------

  event Burn(address indexed burner, uint256 value);

  /**
   * @dev Burns a specific amount of tokens.
   * @param _value The amount of token to be burned.
   */
  function burn(uint256 _value) onlyOwner public {
    _burn(msg.sender, _value);
  }

  function _burn(address _who, uint256 _value) internal {
    require(_value <= balances[_who]);
    // no need to require value <= totalSupply, since that would imply the
    // sender's balance is greater than the totalSupply, which *should* be an assertion failure

    balances[_who] = SafeMath.sub(balances[_who],_value);
    totalSupply = SafeMath.sub(totalSupply,_value);
    emit Burn(_who, _value);
    emit Transfer(_who, address(0), _value);
  }
}

Contract Security Audit

Contract ABI

[{"constant":true,"inputs":[],"name":"mintingFinished","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":false,"inputs":[{"name":"_spender","type":"address"},{"name":"_value","type":"uint256"}],"name":"approve","outputs":[{"name":"success","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"totalSupply","outputs":[{"name":"","type":"uint256"}],"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":"success","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"decimals","outputs":[{"name":"","type":"uint8"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_to","type":"address"},{"name":"_amount","type":"uint256"}],"name":"mint","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_value","type":"uint256"}],"name":"burn","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"version","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"_owner","type":"address"}],"name":"balanceOf","outputs":[{"name":"balance","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"finishMinting","outputs":[{"name":"","type":"bool"}],"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":"success","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"_owner","type":"address"},{"name":"_spender","type":"address"}],"name":"allowance","outputs":[{"name":"remaining","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":"_tokenName","type":"string"},{"name":"_decimalUnits","type":"uint8"},{"name":"_tokenSymbol","type":"string"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"name":"to","type":"address"},{"indexed":false,"name":"amount","type":"uint256"}],"name":"Mint","type":"event"},{"anonymous":false,"inputs":[],"name":"MintFinished","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"burner","type":"address"},{"indexed":false,"name":"value","type":"uint256"}],"name":"Burn","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":"_from","type":"address"},{"indexed":true,"name":"_to","type":"address"},{"indexed":false,"name":"_value","type":"uint256"}],"name":"Transfer","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"}]

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

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

0000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000001200000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000005424f4f54590000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005424f4f5459000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : _tokenName (string): BOOTY
Arg [1] : _decimalUnits (uint8): 18
Arg [2] : _tokenSymbol (string): BOOTY

-----Encoded View---------------
7 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000060
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000012
Arg [2] : 00000000000000000000000000000000000000000000000000000000000000a0
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000005
Arg [4] : 424f4f5459000000000000000000000000000000000000000000000000000000
Arg [5] : 0000000000000000000000000000000000000000000000000000000000000005
Arg [6] : 424f4f5459000000000000000000000000000000000000000000000000000000


Deployed ByteCode Sourcemap

26889:3216:0:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27024:35;;8:9:-1;5:2;;;30:1;27;20:12;5:2;27024:35:0;;;;;;;;;;;;;;;;;;;;;;27473:18;;8:9:-1;5:2;;;30:1;27;20:12;5:2;27473:18:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;27473:18:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20981:214;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;20981:214:0;-1:-1:-1;;;;;20981:214:0;;;;;;;17324:26;;8:9:-1;5:2;;;30:1;27;20:12;5:2;17324:26:0;;;;;;;;;;;;;;;;;;;;20235:611;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;20235:611:0;-1:-1:-1;;;;;20235:611:0;;;;;;;;;;;;27545:21;;8:9:-1;5:2;;;30:1;27;20:12;5:2;27545:21:0;;;;;;;;;;;;;;;;;;;;;;;28586:297;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;28586:297:0;-1:-1:-1;;;;;28586:297:0;;;;;;;29548:85;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;29548:85:0;;;;;;;27807:30;;8:9:-1;5:2;;;30:1;27;20:12;5:2;27807:30:0;;;;20854:119;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;20854:119:0;-1:-1:-1;;;;;20854:119:0;;;;;29003:144;;8:9:-1;5:2;;;30:1;27;20:12;5:2;29003:144:0;;;;24909:20;;8:9:-1;5:2;;;30:1;27;20:12;5:2;24909:20:0;;;;;;;;-1:-1:-1;;;;;24909:20:0;;;;;;;;;;;;;;27740;;8:9:-1;5:2;;;30:1;27;20:12;5:2;27740:20:0;;;;19604:623;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;19604:623:0;-1:-1:-1;;;;;19604:623:0;;;;;;;21203:146;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;21203:146:0;-1:-1:-1;;;;;21203:146:0;;;;;;;;;;25524:178;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;25524:178:0;-1:-1:-1;;;;;25524:178:0;;;;;27024:35;;;;;;;;;:::o;27473:18::-;;;;;;;;;;;;;;;-1:-1:-1;;27473:18:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;20981:214::-;21081:10;21048:12;21073:19;;;:7;:19;;;;;;;;-1:-1:-1;;;;;21073:29:0;;;;;;;;;;;:38;;;21127;;;;;;;21048:12;;21073:29;;21081:10;;21127:38;;;;;;;;-1:-1:-1;21183:4:0;20981:214;;;;:::o;17324:26::-;;;;:::o;20235:611::-;-1:-1:-1;;;;;20589:15:0;;20317:12;20589:15;;;:8;:15;;;;;;:25;-1:-1:-1;20589:25:0;;;:65;;-1:-1:-1;;;;;;20618:14:0;;;;;;:7;:14;;;;;;;;20633:10;20618:26;;;;;;;;:36;-1:-1:-1;20618:36:0;20589:65;20581:74;;;;;;;;-1:-1:-1;;;;;20666:13:0;;;;;;;:8;:13;;;;;;;;:23;;;;;;20700:15;;;;;;;;;:25;;;;;;;20736:7;:14;;;;;20751:10;20736:26;;;;;;;;:36;;;;;;;20788:28;;;;;;;20666:13;;20700:15;;-1:-1:-1;;;;;;;;;;;20788:28:0;;;;;;;;;-1:-1:-1;20834:4:0;20235:611;;;;;:::o;27545:21::-;;;;;;:::o;28586:297::-;25337:5;;28664:4;;-1:-1:-1;;;;;25337:5:0;25323:10;:19;25315:28;;;;;;27103:15;;;;;;;27102:16;27094:25;;;;;;28691:34;28704:7;28713:11;;28691:12;:34::i;:::-;28677:11;:48;;;-1:-1:-1;;;;;28769:13:0;;;;:8;:13;;;;;;28748:35;;28761:7;;28748:12;:35::i;:::-;-1:-1:-1;;;;;28732:13:0;;;;;;:8;:13;;;;;;;;;:51;;;;28795:18;;;;;;;28732:13;;28795:18;;;;;;;;;28825:34;;;;;;;;-1:-1:-1;;;;;28825:34:0;;;28842:1;;-1:-1:-1;;;;;;;;;;;28825:34:0;;;;;;;;-1:-1:-1;28873:4:0;28586:297;;;;:::o;29548:85::-;25337:5;;-1:-1:-1;;;;;25337:5:0;25323:10;:19;25315:28;;;;;;29602:25;29608:10;29620:6;29602:5;:25::i;:::-;29548:85;:::o;27807:30::-;;;;;;;;;;;;;;;-1:-1:-1;;27807:30:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20854:119;-1:-1:-1;;;;;20949:16:0;20914:15;20949:16;;;:8;:16;;;;;;;20854:119::o;29003:144::-;25337:5;;29062:4;;-1:-1:-1;;;;;25337:5:0;25323:10;:19;25315:28;;;;;;27103:15;;;;;;;27102:16;27094:25;;;;;;29075:15;:22;;-1:-1:-1;;29075:22:0;;;;;29109:14;;;;29075:22;;29109:14;-1:-1:-1;29137:4:0;29003:144;:::o;24909:20::-;;;-1:-1:-1;;;;;24909:20:0;;:::o;27740:::-;;;;;;;;;;;;;;;-1:-1:-1;;27740:20:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19604:623;20051:10;19667:12;20042:20;;;:8;:20;;;;;;:30;-1:-1:-1;20042:30:0;20034:39;;;;;;20093:10;20084:20;;;;:8;:20;;;;;;;;:30;;;;;;;-1:-1:-1;;;;;20125:13:0;;;;;;;;;:23;;;;;;20164:33;;;;;;;20125:13;;20093:10;-1:-1:-1;;;;;;;;;;;20164:33:0;;;;;;;;;;-1:-1:-1;20215:4:0;19604:623;;;;:::o;21203:146::-;-1:-1:-1;;;;;21316:15:0;;;21281:17;21316:15;;;:7;:15;;;;;;;;:25;;;;;;;;;;;;;21203:146::o;25524:178::-;25337:5;;-1:-1:-1;;;;;25337:5:0;25323:10;:19;25315:28;;;;;;-1:-1:-1;;;;;25601:22:0;;;;25593:31;;;;;;25657:5;;25636:37;;-1:-1:-1;;;;;25636:37:0;;;;25657:5;;25636:37;;25657:5;;25636:37;25680:5;:16;;-1:-1:-1;;25680:16:0;-1:-1:-1;;;;;25680:16:0;;;;;;;;;;25524:178::o;26410:133::-;26468:7;26496:5;;;26515:6;;;;26508:14;;;;26536:1;26410:133;-1:-1:-1;;;26410:133:0:o;29639:463::-;-1:-1:-1;;;;;29718:14:0;;;;;;:8;:14;;;;;;29708:24;;;29700:33;;;;;;-1:-1:-1;;;;;29945:14:0;;;;;;:8;:14;;;;;;29932:35;;29960:6;29932:12;:35::i;:::-;-1:-1:-1;;;;;29915:14:0;;;;;;:8;:14;;;;;:52;;;;30001:11;29988:32;;30013:6;29988:12;:32::i;:::-;29974:11;:46;30032:18;;;;;;;;-1:-1:-1;;;;;30032:18:0;;;;;;;;;;;;;30062:34;;;;;;;;30085:1;;-1:-1:-1;;;;;30062:34:0;;;-1:-1:-1;;;;;;;;;;;30062:34:0;;;;;;;;29639:463;;:::o;26291:113::-;26349:7;26372:6;;;;26365:14;;;;-1:-1:-1;26393:5:0;;;26291:113::o

Swarm Source

bzzr://7f582d67e99587113a2fcc4a1b03e6a3503de85e27b3a3900b7be0015e96162a
Block Transaction Difficulty Gas Used Reward
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.

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