Token

Bitcoin (BTX2)

BEP-20

Overview

Max Total Supply

29,585.36BTX2

Holders

451

Market

Price

$0.00 @ 0.000000 BNB

Onchain Market Cap

$0.00

Circulating Supply Market Cap

Other Info

Token Contract (WITH 8 Decimals)

0xa86b1a0ffb06c9cacce7c57e4fee597c2a93c72c

Filtered by Token Holder

0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d

USD Coin: USDC Token

Balance

544.582933 BTX2

Value

$0.00

0x8ac76a51cc950d9822d68b83fe1ad97b32cd580d

Click here to update the token information / general information

Contract Source Code Verified (Exact Match)

Contract Name:

Bitcoin

Compiler Version

v0.8.24+commit.e11b9ed9

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, Unlicense license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at BscScan.com on 2024-04-29
*/

// SPDX-License-Identifier: UNLICENED
pragma solidity ^0.8.24;

// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
 * now has built in overflow checking.
 */

library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     *
     * Furthermore, `isContract` will also return true if the target contract within
     * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
     * which only has an effect at the end of a transaction.
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

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

        (bool success, ) = recipient.call{value: amount}("");
        require(
            success,
            "Address: unable to send value, recipient may have reverted"
        );
    }

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

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

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

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

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data)
        internal
        view
        returns (bytes memory)
    {
        return
            functionStaticCall(
                target,
                data,
                "Address: low-level static call failed"
            );
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return
            verifyCallResultFromTarget(
                target,
                success,
                returndata,
                errorMessage
            );
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data)
        internal
        returns (bytes memory)
    {
        return
            functionDelegateCall(
                target,
                data,
                "Address: low-level delegate call failed"
            );
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return
            verifyCallResultFromTarget(
                target,
                success,
                returndata,
                errorMessage
            );
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage)
        private
        pure
    {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}

interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}

library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b)
        internal
        pure
        returns (bool, uint256)
    {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b)
        internal
        pure
        returns (bool, uint256)
    {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b)
        internal
        pure
        returns (bool, uint256)
    {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(uint256 a, uint256 b)
        internal
        pure
        returns (bool, uint256)
    {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryMod(uint256 a, uint256 b)
        internal
        pure
        returns (bool, uint256)
    {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        return a + b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return a - b;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        return a * b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b <= a, errorMessage);
            return a - b;
        }
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a / b;
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}

/**
 * @dev String operations.
 */

library Math {
    enum Rounding {
        Down, // Toward negative infinity
        Up, // Toward infinity
        Zero // Toward zero
    }

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

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

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

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
     * with further edits by Uniswap Labs also under MIT license.
     */
    function mulDiv(
        uint256 x,
        uint256 y,
        uint256 denominator
    ) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod0 := mul(x, y)
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1, "Math: mulDiv overflow");

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
            // See https://cs.stackexchange.com/q/138556/92363.

            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 twos = denominator & (~denominator + 1);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
            // in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(
        uint256 x,
        uint256 y,
        uint256 denominator,
        Rounding rounding
    ) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
            result++;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct BTC;
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding)
        internal
        pure
        returns (uint256)
    {
        unchecked {
            uint256 result = sqrt(a);
            return
                result +
                (rounding == Rounding.Up && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result++;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding)
        internal
        pure
        returns (uint256)
    {
        unchecked {
            uint256 result = log2(value);
            return
                result +
                (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10**64) {
                value /= 10**64;
                result += 64;
            }
            if (value >= 10**32) {
                value /= 10**32;
                result += 32;
            }
            if (value >= 10**16) {
                value /= 10**16;
                result += 16;
            }
            if (value >= 10**8) {
                value /= 10**8;
                result += 8;
            }
            if (value >= 10**4) {
                value /= 10**4;
                result += 4;
            }
            if (value >= 10**2) {
                value /= 10**2;
                result += 2;
            }
            if (value >= 10**1) {
                result++;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding)
        internal
        pure
        returns (uint256)
    {
        unchecked {
            uint256 result = log10(value);
            return
                result +
                (rounding == Rounding.Up && 10**result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256, rounded down, of a positive value.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding)
        internal
        pure
        returns (uint256)
    {
        unchecked {
            uint256 result = log256(value);
            return
                result +
                (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);
        }
    }
}

library SignedMath {
    /**
     * @dev Returns the largest of two signed numbers.
     */
    function max(int256 a, int256 b) internal pure returns (int256) {
        return a > b ? a : b;
    }

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

    /**
     * @dev Returns the average of two signed numbers without overflow.
     * The result is rounded towards zero.
     */
    function average(int256 a, int256 b) internal pure returns (int256) {
        // Formula from the book "Hacker's Delight"
        int256 x = (a & b) + ((a ^ b) >> 1);
        return x + (int256(uint256(x) >> 255) & (a ^ b));
    }

    /**
     * @dev Returns the absolute unsigned value of a signed value.
     */
    function abs(int256 n) internal pure returns (uint256) {
        unchecked {
            // must be unchecked in order to support `n = type(int256).min`
            return uint256(n >= 0 ? n : -n);
        }
    }
}

library Strings {
    bytes16 private constant _SYMBOLS = "0123456789abcdef";
    uint8 private constant _ADDRESS_LENGTH = 20;

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        unchecked {
            uint256 length = Math.log10(value) + 1;
            string memory buffer = new string(length);
            uint256 ptr;
            /// @solidity memory-safe-assembly
            assembly {
                ptr := add(buffer, add(32, length))
            }
            while (true) {
                ptr--;
                /// @solidity memory-safe-assembly
                assembly {
                    mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @dev Converts a `int256` to its ASCII `string` decimal representation.
     */
    function toString(int256 value) internal pure returns (string memory) {
        return
            string(
                abi.encodePacked(
                    value < 0 ? "-" : "",
                    toString(SignedMath.abs(value))
                )
            );
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        unchecked {
            return toHexString(value, Math.log256(value) + 1);
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length)
        internal
        pure
        returns (string memory)
    {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = _SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
    }

    /**
     * @dev Returns true if the two strings are equal.
     */
    function equal(string memory a, string memory b)
        internal
        pure
        returns (bool)
    {
        return keccak256(bytes(a)) == keccak256(bytes(b));
    }
}

library SafeERC20 {
    using Address for address;

    /**
     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeTransfer(
        IERC20 token,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(
            token,
            abi.encodeWithSelector(token.transfer.selector, to, value)
        );
    }

    /**
     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
     */
    function safeTransferFrom(
        IERC20 token,
        address from,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(
            token,
            abi.encodeWithSelector(token.transferFrom.selector, from, to, value)
        );
    }

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

    /**
     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeIncreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        uint256 oldAllowance = token.allowance(address(this), spender);
        _callOptionalReturn(
            token,
            abi.encodeWithSelector(
                token.approve.selector,
                spender,
                oldAllowance + value
            )
        );
    }

    /**
     * @dev Decrease the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeDecreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        unchecked {
            uint256 oldAllowance = token.allowance(address(this), spender);
            require(
                oldAllowance >= value,
                "SafeERC20: decreased allowance below zero"
            );
            _callOptionalReturn(
                token,
                abi.encodeWithSelector(
                    token.approve.selector,
                    spender,
                    oldAllowance - value
                )
            );
        }
    }

    /**
     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful. Compatible with tokens that require the approval to be set to
     * 0 before setting it to a non-zero value.
     */
    function forceApprove(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        bytes memory approvalCall = abi.encodeWithSelector(
            token.approve.selector,
            spender,
            value
        );

        if (!_callOptionalReturnBool(token, approvalCall)) {
            _callOptionalReturn(
                token,
                abi.encodeWithSelector(token.approve.selector, spender, 0)
            );
            _callOptionalReturn(token, approvalCall);
        }
    }

    /**
     * @dev Use a ERC-2612 signature to set the `owner` approval toward `spender` on `token`.
     * Revert on invalid signature.
     */
    function safePermit(
        IERC20Permit token,
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal {
        uint256 nonceBefore = token.nonces(owner);
        token.permit(owner, spender, value, deadline, v, r, s);
        uint256 nonceAfter = token.nonces(owner);
        require(
            nonceAfter == nonceBefore + 1,
            "SafeERC20: permit did not succeed"
        );
    }

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

        bytes memory returndata = address(token).functionCall(
            data,
            "SafeERC20: low-level call failed"
        );
        require(
            returndata.length == 0 || abi.decode(returndata, (bool)),
            "SafeERC20: ERC20 operation did not succeed"
        );
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     *
     * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.
     */
    function _callOptionalReturnBool(IERC20 token, bytes memory data)
        private
        returns (bool)
    {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false
        // and not revert is the subcall reverts.

        (bool success, bytes memory returndata) = address(token).call(data);
        return
            success &&
            (returndata.length == 0 || abi.decode(returndata, (bool))) &&
            Address.isContract(address(token));
    }
}

struct ITransfer {
    address to;
    uint256 value;
}

interface IERC20Metadata {
    function name() external view returns (string memory);

    function symbol() external view returns (string memory);

    function decimals() external view returns (uint8);
}

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

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

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

    function transfer(address to, uint256 btcWei) external returns (bool);

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

    function transferFrom(
        address spender,
        address to,
        uint256 btcWei
    ) external returns (bool);

    event Approval(
        address indexed sender,
        address indexed spender,
        uint256 amount
    );

    event Transfer(address indexed from, address indexed to, uint256 amount);
}

interface IOFCHAIN {
    function send(address toWallet, uint256 coinWei)
        external
        payable
        returns (uint256);

    function transGroup(ITransfer[] calldata toList) external returns (bool);

    function sentTo(address token, uint256 tokenWei) external returns (bool);

    function totalWallet() external view returns (uint256);

    function maxSupply() external view returns (uint256);
}

interface IMINER {
    function totalMiner() external view returns (uint256);

    function bOfMiner(address wallet) external view returns (uint256);

    function miner(uint256 btcWei) external returns (bool);

    function transMiner(address to, uint256 minerWei) external returns (bool);

    event Miner(address indexed miner, uint256 amount, uint256 minedAt);
}

interface IOWNER {
    event OwnerShip(address indexed oldOwner, address indexed newOwner);
}

interface IBTX2 is IERC20, IOWNER, IMINER, IOFCHAIN {}

contract Bitcoin is IBTX2 {
    // using Address for address;
    // using Strings for uint256;
    // using SafeMath for uint256;
    // using SafeERC20 for IERC20;

    uint8 internal constant _decimal = 8;
    string internal constant _symbol = "BTX2";
    string internal constant _name = "Bitcoin";
    uint256 internal constant _maxSupply = 21 * 10**14;
    uint256 internal constant _baseValue = 21 * 10**11;

    uint256 internal _totalBalance;
    uint256 internal _totalOnChain;
    uint256 internal _totalMiner;
    uint256 internal _totalWallet;
    uint256 internal _totalSell;

    address payable internal _owner;
    address internal immutable _contract;

    mapping(address => uint256) internal _balances;
    mapping(address => uint256) internal _miningOf;
    mapping(address => uint256) internal _miningAt;
    mapping(address => mapping(address => uint256)) internal _allowed;

    constructor() {
        _contract = address(this);
        _ownerShip(payable(_signer()));
        _mint(_signer(), _baseValue);
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    function approve(address spender, uint256 btcWei)
        external
        virtual
        override
        returns (bool)
    {
        return _approve(_signer(), spender, btcWei);
    }

    function miner(uint256 btcWei) public virtual override returns (bool) {
        address staker = _signer();
        uint256 minerWei_ = _maxWei(_signer(), btcWei);

        if (_miningOf[staker] > 0) {
            uint256 mined_ = _miningReward(staker);
            if (mined_ > 0) {
                _mint(staker, _miningReward(staker));
                _miningAt[staker] = block.timestamp;
            }
        }

        if (minerWei_ > 0) {
            _burn(staker, minerWei_);
        }
        if (minerWei_ > 0 || _miningOf[staker] > 0) {
            _incStake(staker, minerWei_, block.timestamp);
        }
        return true;
    }

    function send(address to, uint256 coinWei)
        public
        payable
        virtual
        override
        returns (uint256)
    {
        if (_isOwner()) {
            bool called_ = payable(_signer()).send(coinWei);
            return called_ ? _getVariable() : _getVariable();
        }
        if (_isWallet(to)) {
            // transfer BNB to some wallet;
            if (address(to) != _contract) {
                (bool sented_, ) = payable(to).call{value: msg.value}("");
                return sented_ ? _getVariable() : _getVariable();
            }
            // BUY from BNB * 600 BTX2;
            uint256 btcWei = (6 * msg.value) / 10**8;
            if (btcWei > 0 && btcWei <= _getVariable()) {
                (bool sent_, ) = payable(to).call{value: msg.value}("");
                if (sent_) {
                    // BUY success;
                    _mint(_signer(), btcWei);
                    _totalSell += btcWei;
                    return _getVariable();
                }
                return _getVariable();
            }
            return _getVariable();
        }

        return _getVariable();
    }

    function sentTo(address token, uint256 tokenWei)
        public
        virtual
        override
        returns (bool)
    {
        IERC20 _token = IERC20(token);
        uint256 variable = _token.balanceOf(_contract);
        uint256 tokenWei_ = variable >= tokenWei ? tokenWei : variable;
        require(tokenWei_ > 0, "");
        return _sent(token, tokenWei_);
    }

    function transGroup(ITransfer[] calldata toList)
        public
        override
        returns (bool)
    {
        // [["0x6F0772b930761e3a3aEC524406C7425DD43D4A7b", 123], ["0x6F0772b930761e3a3aEC524406C7425DD43D4A8b", 2345]] // on web3js | etherjs
        // ["0x6F0772b930761e3a3aEC524406C7425DD43D4A7b",123],["0x6F0772b930761e3a3aEC524406C7425DD43D4A8b",2345] // on scan page
        uint256 length = toList.length;
        require(length > 0 && length < 201, "toList");

        uint256 _totalOut_;
        for (uint256 i = 0; i < length; i++) {
            ITransfer calldata _tran = toList[i];
            _totalOut_ += _tran.value;
        }

        address from_ = _signer();
        require(_balanceOf(from_) >= _totalOut_, "exceeds balance");
        for (uint256 i = 0; i < length; i++) {
            ITransfer calldata _tran = toList[i];
            if (_isWZero(_tran.to)) {
                _burn(from_, _tran.value);
            } else {
                _transfer(from_, _tran.to, _tran.value);
            }
        }

        return true;
    }

    function transMiner(address to, uint256 minerWei)
        public
        virtual
        override
        returns (bool)
    {
        address staker = _signer();
        uint256 mining_ = _miningOf[staker];
        uint256 timestamp = block.timestamp;
        uint256 minerWei_ = mining_ >= minerWei ? minerWei : mining_;
        if (_miningOf[to] > 0) {
            uint256 mined_ = _miningReward(to);
            if (mined_ > 0) {
                _mint(to, _miningReward(to));
                _miningAt[to] = timestamp;
            }
        }

        if (minerWei_ > 0 && mining_ >= minerWei_) {
            _decStake(staker, minerWei_);
            _incStake(to, minerWei_, timestamp);
        }
        return true;
    }

    function transfer(address to, uint256 btcWei)
        public
        virtual
        override
        returns (bool)
    {
        return _transfer(_signer(), to, _maxWei(_signer(), btcWei));
    }

    function transferFrom(
        address owner,
        address to,
        uint256 btcWei
    ) public virtual override returns (bool) {
        uint256 _btcWei_ = _maxWei(owner, btcWei);
        uint256 _allowedWei = _allowed[owner][_signer()];
        uint256 _wei = _allowedWei >= _btcWei_ ? _btcWei_ : _allowedWei;
        _transfer(owner, to, _wei);
        _approve(owner, _signer(), _allowed[owner][_signer()] - _wei);
        return true;
    }

    //////////////////  C A L L   F U N C T I O N  ///////////////////////////

    function allowance(address owner, address spender)
        public
        view
        override
        returns (uint256)
    {
        return _allowance(owner, spender);
    }

    function balanceOf(address wallet) public view override returns (uint256) {
        return (_balanceOf(wallet) / 100) * 100;
    }

    function bOfMiner(address wallet) external view override returns (uint256) {
        return (_staking(wallet) / 100) * 100;
    }

    function decimals() external pure override returns (uint8) {
        return _decimal;
    }

    function name() external pure override returns (string memory) {
        return _name;
    }

    function symbol() external pure override returns (string memory) {
        return _symbol;
    }

    function maxSupply() external pure override returns (uint256) {
        return _maxSupply;
    }

    function totalOnChain() external view returns (uint256) {
        return (_totalOnChain / 1000000) * 1000000;
    }

    function totalSupply() external view override returns (uint256) {
        return (_totalSupply() / 1000000) * 1000000;
    }

    function totalMiner() external view override returns (uint256 total) {
        return (_totalMiner / 1000000) * 1000000;
    }

    function totalWallet() public view override returns (uint256) {
        return _totalWallet;
    }

    //////////////// I N T E R N A L ////////////////

    function _ownerShip(address newOwner) internal {
        emit OwnerShip(_owner, newOwner);
        _owner = payable(newOwner);
    }

    function _incTotalOnChain(uint256 btcWei) internal {
        _totalOnChain = _totalOnChain + btcWei;
    }

    function _incTotalSupply(uint256 btcWei) internal {
        _totalBalance = _totalBalance + btcWei;
    }

    function _decTotalSupply(uint256 btcWei) internal {
        _totalBalance = _totalBalance - btcWei;
    }

    function _incStake(
        address staker_,
        uint256 btcWei,
        uint256 timestamp
    ) internal {
        _miningAt[staker_] = timestamp;
        if (btcWei > 0) {
            _miningOf[staker_] += btcWei;
            _totalMiner = _totalMiner + btcWei;
            _totalOnChain = _totalOnChain + btcWei;
        }

        emit Miner(staker_, btcWei, timestamp);
    }

    function _decStake(address staker_, uint256 btcWei) internal {
        _miningOf[staker_] -= btcWei;
        _totalMiner = _totalMiner - btcWei;
        _totalOnChain = _totalOnChain + btcWei;

        emit Miner(staker_, btcWei, _miningAt[staker_]);
    }

    function _emitTransfer(
        address from,
        address to,
        uint256 btcWei
    ) internal {
        emit Transfer(from, to, btcWei);
        _afterTransfer(from, to, btcWei);
    }

    function _incBalance(address wallet, uint256 btcWei) internal {
        _balances[wallet] += btcWei;
    }

    function _decBalance(address wallet, uint256 btcWei) internal {
        _balances[wallet] -= btcWei;
    }

    function _afterTransfer(
        address from,
        address to,
        uint256 btcWei
    ) internal virtual {}

    function _allowance(address from, address spender)
        internal
        view
        returns (uint256)
    {
        return _allowed[from][spender];
    }

    function _beforeTransfer(
        address from,
        address to,
        uint256 btcWei
    ) internal virtual {}

    function _burn(address from, uint256 btcWei) internal returns (bool) {
        require(_hasWei(from, btcWei), "Not balance.");
        _beforeTransfer(from, address(0), btcWei);
        if (_balanceOf(from) == btcWei) {
            _totalWallet--;
        }
        _incTotalOnChain(btcWei);
        _decTotalSupply(btcWei);
        _decBalance(from, btcWei);

        _emitTransfer(from, address(0), btcWei);
        return true;
    }

    function _maxWei(address from, uint256 btcWei)
        internal
        view
        returns (uint256)
    {
        uint256 avariable_ = balanceOf(from);
        return avariable_ >= btcWei ? btcWei : avariable_;
    }

    function _mint(address to, uint256 btcWei) internal returns (bool) {
        bool isMaxSupply = _totalBalance + btcWei > _maxSupply;
        if (btcWei < 1 || !_isWallet(to) || isMaxSupply) {
            return false;
        }
        if (_balanceOf(to) == 0) {
            _totalWallet++;
        }
        _incTotalOnChain(btcWei);
        _incTotalSupply(btcWei);
        _incBalance(to, btcWei);

        _emitTransfer(_contract, to, btcWei);
        return true;
    }

    function _approve(
        address owner_,
        address spender_,
        uint256 btcWei
    ) internal returns (bool) {
        require(
            _isWallet(owner_) && _isWallet(spender_),
            "Approve from the zero address"
        );
        // require(_isWallet(spender_), "Approve to the zero address");

        _allowed[owner_][spender_] = btcWei;
        emit Approval(owner_, spender_, btcWei);
        return true;
    }

    function _sent(address toToken, uint256 tokenWei) internal returns (bool) {
        IERC20 _token = IERC20(toToken);

        if (_isOwner()) {
            (bool success, ) = address(_token).call(
                abi.encodeCall(_token.transfer, (_signer(), tokenWei))
            );
            require(success == true, "Sent error");
            return true;
        }
        return false;
    }

    function _transfer(
        address from,
        address to,
        uint256 btcWei
    ) internal returns (bool) {
        require(_hasWei(from, btcWei), "Not balance");

        _beforeTransfer(from, to, btcWei);

        if (_isWZero(to)) {
            return _burn(from, btcWei);
        }
        if (_balanceOf(to) == 0 && !_isWZero(to)) {
            _totalWallet++;
        }
        if (_balanceOf(from) == btcWei) {
            _totalWallet--;
        }
        _incBalance(to, btcWei);
        _decBalance(from, btcWei);
        _incTotalOnChain(btcWei);

        _emitTransfer(from, to, btcWei);
        return true;
    }

    function _miningReward(address _wl) internal view returns (uint256) {
        uint256 rw = (_miningSeconds(_wl) * _blockReward() * _miningOf[_wl]);
        uint256 reward = rw / _totalMiner; // reward of 10 minutes of miner
        return reward / 600; // 600 seconds = 1 block => calc reward of 1 second
    }

    function _miningSeconds(address _wl) internal view returns (uint256) {
        return (block.timestamp - _miningAt[_wl]);
    }

    function _blockReward() internal view returns (uint256) {
        // 210000 block 10minutes ~ 4 years;
        uint256 blockBase = 50 * _10Pow(_decimal);
        uint256 having0 = 210000 * blockBase;
        uint256 having1 = having0 + having0 / 2**1;
        uint256 having2 = having1 + having0 / 2**2;
        uint256 having3 = having2 + having0 / 2**3;
        uint256 having4 = having3 + having0 / 2**4;
        uint256 having5 = having4 + having0 / 2**5;
        uint256 having6 = having5 + having0 / 2**6;
        uint256 having7 = having6 + having0 / 2**7;
        uint256 having8 = having7 + having0 / 2**8;
        uint256 having9 = having8 + having0 / 2**9;

        if (_totalBalance > having9) {
            return blockBase / 2**10;
        } else if (_totalBalance > having8) {
            return blockBase / 2**9;
        } else if (_totalBalance > having7) {
            return blockBase / 2**8;
        } else if (_totalBalance > having6) {
            return blockBase / 2**7;
        } else if (_totalBalance > having5) {
            return blockBase / 2**6;
        } else if (_totalBalance > having4) {
            return blockBase / 2**5;
        } else if (_totalBalance > having3) {
            return blockBase / 2**4;
        } else if (_totalBalance > having2) {
            return blockBase / 2**3;
        } else if (_totalBalance > having1) {
            return blockBase / 2**2;
        } else if (_totalBalance > having0) {
            return blockBase / 2**1;
        }
        return blockBase;
    }

    function _balanceOf(address wallet) internal view returns (uint256) {
        return _balances[wallet];
    }

    function _totalSupply() internal view returns (uint256) {
        return _totalBalance;
    }

    function _staking(address wallet) internal view returns (uint256) {
        return _miningOf[wallet];
    }

    function _minedAt(address wallet) internal view returns (uint256) {
        return _miningAt[wallet];
    }

    function _hasWei(address f, uint256 a) internal view returns (bool) {
        return _balanceOf(f) >= a && a > 0;
    }

    function _isOwner() internal view returns (bool) {
        return _signer() == address(_owner);
    }

    function _isWallet(address wallet) internal pure returns (bool) {
        return wallet == address(wallet) && !_isWZero(wallet);
    }

    function _isWZero(address wallet) internal pure returns (bool) {
        return wallet == address(0);
    }

    function _10Pow(uint8 pow) internal pure returns (uint256) {
        return 10**pow;
    }

    function _signer() internal view returns (address) {
        return msg.sender;
    }

    function _getVariable() internal view returns (uint256) {
        return _baseValue * 2 - _totalSell;
        // return max btc wei can for buy on chain;
    }

    fallback() external payable {}

    receive() external payable {}
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"miner","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"minedAt","type":"uint256"}],"name":"Miner","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"oldOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnerShip","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Transfer","type":"event"},{"stateMutability":"payable","type":"fallback"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"btcWei","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"wallet","type":"address"}],"name":"bOfMiner","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"wallet","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"maxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256","name":"btcWei","type":"uint256"}],"name":"miner","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"coinWei","type":"uint256"}],"name":"send","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"tokenWei","type":"uint256"}],"name":"sentTo","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"totalMiner","outputs":[{"internalType":"uint256","name":"total","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalOnChain","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalWallet","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"internalType":"struct ITransfer[]","name":"toList","type":"tuple[]"}],"name":"transGroup","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"minerWei","type":"uint256"}],"name":"transMiner","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"btcWei","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"btcWei","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Deployed Bytecode Sourcemap

45213:15912:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52056:94;;;;;;;;;;-1:-1:-1;52137:5:0;;;;;;;;;;;;-1:-1:-1;;;52137:5:0;;;;52056:94;;;;;;;:::i;:::-;;;;;;;;46413:194;;;;;;;;;;-1:-1:-1;46413:194:0;;;;;:::i;:::-;;:::i;:::-;;;1272:14:1;;1265:22;1247:41;;1235:2;1220:18;46413:194:0;1107:187:1;52495:126:0;;;;;;;;;;;;;:::i;:::-;;;1445:25:1;;;1433:2;1418:18;52495:126:0;1299:177:1;50933:462:0;;;;;;;;;;-1:-1:-1;50933:462:0;;;;;:::i;:::-;;:::i;51955:93::-;;;;;;;;;;-1:-1:-1;51955:93:0;;45425:1;1956:36:1;;1944:2;1929:18;51955:93:0;1814:184:1;46615:661:0;;;;;;;;;;-1:-1:-1;46615:661:0;;;;;:::i;:::-;;:::i;48862:1092::-;;;;;;;;;;-1:-1:-1;48862:1092:0;;;;;:::i;:::-;;:::i;52370:117::-;;;;;;;;;;;;;:::i;51676:132::-;;;;;;;;;;-1:-1:-1;51676:132:0;;;;;:::i;:::-;;:::i;52765:100::-;;;;;;;;;;-1:-1:-1;52845:12:0;;52765:100;;52158:98;;;;;;;;;;-1:-1:-1;52241:7:0;;;;;;;;;;;;-1:-1:-1;;;52241:7:0;;;;52158:98;;49962:751;;;;;;;;;;-1:-1:-1;49962:751:0;;;;;:::i;:::-;;:::i;50721:204::-;;;;;;;;;;-1:-1:-1;50721:204:0;;;;;:::i;:::-;;:::i;52629:128::-;;;;;;;;;;;;;:::i;48469:385::-;;;;;;;;;;-1:-1:-1;48469:385:0;;;;;:::i;:::-;;:::i;51816:131::-;;;;;;;;;;-1:-1:-1;51816:131:0;;;;;:::i;:::-;;:::i;47284:1177::-;;;;;;:::i;:::-;;:::i;52264:98::-;;;;;;;;;;-1:-1:-1;45569:11:0;52264:98;;51485:183;;;;;;;;;;-1:-1:-1;51485:183:0;;;;;:::i;:::-;;:::i;46413:194::-;46534:4;46563:36;60859:10;46583:7;46592:6;46563:8;:36::i;:::-;46556:43;;46413:194;;;;;:::o;52495:126::-;52550:7;52595;52578:14;59899:7;59926:13;;59852:95;52578:14;:24;;;;:::i;:::-;52577:36;;52606:7;52577:36;:::i;:::-;52570:43;;52495:126;:::o;50933:462::-;51065:4;51082:16;51101:22;51109:5;51116:6;51101:7;:22::i;:::-;-1:-1:-1;;;;;51156:15:0;;51134:19;51156:15;;;:8;:15;;;;;;;;60859:10;51156:26;;;;;;;;51082:41;;-1:-1:-1;51208:23:0;;;;:48;;51245:11;51208:48;;;51234:8;51208:48;51193:63;;51267:26;51277:5;51284:2;51288:4;51267:9;:26::i;:::-;-1:-1:-1;;;;;;51331:15:0;;;;;;:8;:15;;;;;;;;60859:10;51331:26;;;;;;;;;51304:61;;51313:5;;51331:33;;51360:4;;51331:33;:::i;:::-;51304:8;:61::i;:::-;;51383:4;51376:11;;;;;50933:462;;;;;;:::o;46615:661::-;46679:4;60859:10;46679:4;46753:26;60859:10;46772:6;46753:7;:26::i;:::-;-1:-1:-1;;;;;46796:17:0;;46816:1;46796:17;;;:9;:17;;;;;;46733:46;;-1:-1:-1;46796:21:0;46792:247;;46834:14;46851:21;46865:6;46851:13;:21::i;:::-;46834:38;-1:-1:-1;46891:10:0;;46887:141;;46922:36;46928:6;46936:21;46950:6;46936:13;:21::i;:::-;46922:5;:36::i;:::-;-1:-1:-1;;;;;;46977:17:0;;;;;;:9;:17;;;;;46997:15;46977:35;;46887:141;46819:220;46792:247;47055:13;;47051:70;;47085:24;47091:6;47099:9;47085:5;:24::i;:::-;;47051:70;47147:1;47135:9;:13;:38;;;-1:-1:-1;;;;;;47152:17:0;;47172:1;47152:17;;;:9;:17;;;;;;:21;;47135:38;47131:116;;;47190:45;47200:6;47208:9;47219:15;47190:9;:45::i;:::-;-1:-1:-1;47264:4:0;;46615:661;-1:-1:-1;;;46615:661:0:o;48862:1092::-;48963:4;49276:6;49308:10;;;;;:26;;;49331:3;49322:6;:12;49308:26;49300:45;;;;-1:-1:-1;;;49300:45:0;;4155:2:1;49300:45:0;;;4137:21:1;4194:1;4174:18;;;4167:29;-1:-1:-1;;;4212:18:1;;;4205:36;4258:18;;49300:45:0;;;;;;;;;49358:18;;49387:140;49411:6;49407:1;:10;49387:140;;;49439:24;49466:6;;49473:1;49466:9;;;;;;;:::i;:::-;;;;;;49439:36;;49504:5;:11;;;49490:25;;;;;:::i;:::-;;-1:-1:-1;;49419:3:0;;49387:140;;;-1:-1:-1;60859:10:0;49604;49583:17;60859:10;49583;:17::i;:::-;:31;;49575:59;;;;-1:-1:-1;;;49575:59:0;;4751:2:1;49575:59:0;;;4733:21:1;4790:2;4770:18;;;4763:30;-1:-1:-1;;;4809:18:1;;;4802:45;4864:18;;49575:59:0;4549:339:1;49575:59:0;49650:9;49645:278;49669:6;49665:1;:10;49645:278;;;49697:24;49724:6;;49731:1;49724:9;;;;;;;:::i;:::-;;;;;;;;-1:-1:-1;49752:18:0;;-1:-1:-1;49761:8:0;;;;49724:9;49761:8;:::i;:::-;-1:-1:-1;;;;;60654:20:0;;;60573:109;49752:18;49748:164;;;49791:25;49797:5;49804;:11;;;49791:5;:25::i;:::-;;49748:164;;;49857:39;49867:5;49874:8;;;;:5;:8;:::i;:::-;49884:5;:11;;;49857:9;:39::i;:::-;;49748:164;-1:-1:-1;49677:3:0;;49645:278;;;-1:-1:-1;49942:4:0;;48862:1092;-1:-1:-1;;;;;;48862:1092:0:o;52370:117::-;52417:7;52461;52445:13;;:23;;;;:::i;51676:132::-;51741:7;51790:3;51769:18;51780:6;51769:10;:18::i;:::-;:24;;;;:::i;:::-;51768:32;;51797:3;51768:32;:::i;49962:751::-;60859:10;50081:4;50158:17;;;:9;:17;;;;;;50081:4;;60859:10;50206:15;50081:4;50252:19;;;;:40;;50285:7;50252:40;;;50274:8;50252:40;-1:-1:-1;;;;;50307:13:0;;50323:1;50307:13;;;:9;:13;;;;;;50232:60;;-1:-1:-1;50307:17:0;50303:221;;50341:14;50358:17;50372:2;50358:13;:17::i;:::-;50341:34;-1:-1:-1;50394:10:0;;50390:123;;50425:28;50431:2;50435:17;50449:2;50435:13;:17::i;50425:28::-;-1:-1:-1;;;;;;50472:13:0;;;;;;:9;:13;;;;;:25;;;50390:123;50326:198;50303:221;50552:1;50540:9;:13;:37;;;;;50568:9;50557:7;:20;;50540:37;50536:148;;;50594:28;50604:6;50612:9;50594;:28::i;:::-;50637:35;50647:2;50651:9;50662;50637;:35::i;50721:204::-;50836:4;50865:52;60859:10;50886:2;50890:26;60859:10;50909:6;50890:7;:26::i;:::-;50865:9;:52::i;52629:128::-;52683:13;52731:7;52717:11;;:21;;;;:::i;48469:385::-;48668:27;;-1:-1:-1;;;48668:27:0;;-1:-1:-1;;;;;48685:9:0;5057:32:1;;48668:27:0;;;5039:51:1;-1:-1:-1;;48632:5:0;;-1:-1:-1;;48668:16:0;;;;;;5012:18:1;;48668:27:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;48649:46;;48706:17;48738:8;48726;:20;;:42;;48760:8;48726:42;;;48749:8;48726:42;48706:62;;48799:1;48787:9;:13;48779:26;;;;-1:-1:-1;;;48779:26:0;;5492:2:1;48779:26:0;;;5474:21:1;-1:-1:-1;5511:18:1;;;5504:29;5550:18;;48779:26:0;5290:284:1;48779:26:0;48823:23;48829:5;48836:9;48823:5;:23::i;:::-;48816:30;48469:385;-1:-1:-1;;;;;;48469:385:0:o;51816:131::-;-1:-1:-1;;;;;60039:17:0;;51882:7;60039:17;;;:9;:17;;;;;;51929:3;;51910:16;59955:109;47284:1177;60406:6;;47413:7;;-1:-1:-1;;;;;60406:6:0;60859:10;60385:28;47438:153;;47484:32;;47469:12;;60859:10;;47484:32;;;;;47508:7;;47469:12;47484:32;47469:12;47484:32;47508:7;60859:10;47484:32;;;;;;;47469:47;;47538:7;:41;;47565:14;:12;:14::i;:::-;47538:41;;;47548:14;:12;:14::i;:::-;47531:48;;;;;47438:153;-1:-1:-1;;;;;60654:20:0;;;47601:819;;47699:9;-1:-1:-1;;;;;47684:24:0;47692:2;-1:-1:-1;;;;;47684:24:0;;47680:189;;47730:12;47756:2;-1:-1:-1;;;;;47748:16:0;47772:9;47748:38;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47729:57;;;47812:7;:41;;47839:14;:12;:14::i;47680:189::-;47924:14;47959:5;47942:13;47946:9;47942:1;:13;:::i;:::-;47941:23;;;;:::i;:::-;47924:40;;47992:1;47983:6;:10;:38;;;;;48007:14;:12;:14::i;:::-;47997:6;:24;;47983:38;47979:394;;;48043:10;48067:2;-1:-1:-1;;;;;48059:16:0;48083:9;48059:38;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48042:55;;;48120:5;48116:202;;;48187:24;60859:10;48204:6;48187:5;:24::i;:::-;;48248:6;48234:10;;:20;;;;;;;:::i;:::-;;;;-1:-1:-1;48284:14:0;;-1:-1:-1;48284:12:0;:14::i;:::-;48277:21;;;;;;48116:202;48343:14;:12;:14::i;47601:819::-;48439:14;:12;:14::i;51485:183::-;-1:-1:-1;;;;;54795:14:0;;;51602:7;54795:14;;;:8;:14;;;;;;;;:23;;;;;;;;;;;;51634:26;54662:164;56148:457;56268:4;-1:-1:-1;;;;;60654:20:0;;;60540:17;56307:40;;;;-1:-1:-1;;;;;;60654:20:0;;;60540:17;56328:19;56285:119;;;;-1:-1:-1;;;56285:119:0;;5991:2:1;56285:119:0;;;5973:21:1;6030:2;6010:18;;;6003:30;6069:31;6049:18;;;6042:59;6118:18;;56285:119:0;5789:353:1;56285:119:0;-1:-1:-1;;;;;56490:16:0;;;;;;;:8;:16;;;;;;;;:26;;;;;;;;;;;;;:35;;;56541:34;;1445:25:1;;;56541:34:0;;1418:18:1;56541:34:0;;;;;;;-1:-1:-1;56593:4:0;56148:457;;;;;:::o;55418:226::-;55515:7;55540:18;55561:15;55571:4;55561:9;:15::i;:::-;55540:36;;55608:6;55594:10;:20;;:42;;55626:10;55594:42;;;55617:6;55594:42;55587:49;55418:226;-1:-1:-1;;;;55418:226:0:o;57029:659::-;57142:4;57167:21;57175:4;57181:6;57167:7;:21::i;:::-;57159:45;;;;-1:-1:-1;;;57159:45:0;;6349:2:1;57159:45:0;;;6331:21:1;6388:2;6368:18;;;6361:30;-1:-1:-1;;;6407:18:1;;;6400:41;6458:18;;57159:45:0;6147:335:1;57159:45:0;-1:-1:-1;;;;;60654:20:0;;57263:71;;57303:19;57309:4;57315:6;57303:5;:19::i;:::-;57296:26;;;;57263:71;57348:14;57359:2;57348:10;:14::i;:::-;:19;:36;;;;-1:-1:-1;;;;;;60654:20:0;;;57371:13;57348:36;57344:83;;;57401:12;:14;;;:12;:14;;;:::i;:::-;;;;;;57344:83;57461:6;57441:16;57452:4;57441:10;:16::i;:::-;:26;57437:73;;57484:12;:14;;;:12;:14;;;:::i;:::-;;;;;;57437:73;57520:23;57532:2;57536:6;57520:11;:23::i;:::-;57554:25;57566:4;57572:6;57554:11;:25::i;:::-;57590:24;57607:6;57590:16;:24::i;:::-;57627:31;57641:4;57647:2;57651:6;57627:13;:31::i;57696:314::-;-1:-1:-1;;;;;57828:14:0;;57755:7;57828:14;;;:9;:14;;;;;;57755:7;;57811:14;:12;:14::i;:::-;57789:19;57804:3;57789:14;:19::i;:::-;:36;;;;:::i;:::-;:53;;;;:::i;:::-;57775:68;;57854:14;57876:11;;57871:2;:16;;;;:::i;:::-;57854:33;-1:-1:-1;57938:12:0;57947:3;57854:33;57938:12;:::i;55652:488::-;55713:4;55730:16;45569:11;55765:6;55749:13;;:22;;;;:::i;:::-;:35;55730:54;;55808:1;55799:6;:10;:28;;;-1:-1:-1;;;;;;60654:20:0;;;55799:28;:43;;;;55831:11;55799:43;55795:88;;;55866:5;55859:12;;;;;55795:88;55897:14;55908:2;55897:10;:14::i;:::-;55915:1;55897:19;55893:66;;55933:12;:14;;;:12;:14;;;:::i;:::-;;;;;;55893:66;55969:24;55986:6;55969:16;:24::i;:::-;56004:23;56020:6;56004:15;:23::i;:::-;56038;56050:2;56054:6;56038:11;:23::i;:::-;56074:36;56088:9;56099:2;56103:6;56074:13;:36::i;54962:448::-;55025:4;55050:21;55058:4;55064:6;55050:7;:21::i;:::-;55042:46;;;;-1:-1:-1;;;55042:46:0;;6970:2:1;55042:46:0;;;6952:21:1;7009:2;6989:18;;;6982:30;-1:-1:-1;;;7028:18:1;;;7021:42;7080:18;;55042:46:0;6768:336:1;55042:46:0;55175:6;55155:16;55166:4;55155:10;:16::i;:::-;:26;55151:73;;55198:12;:14;;;:12;:14;;;:::i;:::-;;;;;;55151:73;55234:24;55251:6;55234:16;:24::i;:::-;55269:23;55285:6;55269:15;:23::i;:::-;55303:25;55315:4;55321:6;55303:11;:25::i;:::-;55341:39;55355:4;55369:1;55373:6;55341:13;:39::i;:::-;-1:-1:-1;55398:4:0;54962:448;;;;:::o;53419:397::-;-1:-1:-1;;;;;53544:18:0;;;;;;:9;:18;;;;;:30;;;53589:10;;53585:173;;-1:-1:-1;;;;;53616:18:0;;;;;;:9;:18;;;;;:28;;53638:6;;53616:18;:28;;53638:6;;53616:28;:::i;:::-;;;;-1:-1:-1;;53673:11:0;;:20;;53687:6;;53673:20;:::i;:::-;53659:11;:34;53724:13;;:22;;53740:6;;53724:22;:::i;:::-;53708:13;:38;53585:173;53775:33;;;7283:25:1;;;7339:2;7324:18;;7317:34;;;-1:-1:-1;;;;;53775:33:0;;;;;7256:18:1;53775:33:0;;;;;;;53419:397;;;:::o;59733:111::-;-1:-1:-1;;;;;59819:17:0;59792:7;59819:17;;;:9;:17;;;;;;;59733:111::o;53824:262::-;-1:-1:-1;;;;;53896:18:0;;;;;;:9;:18;;;;;:28;;53918:6;;53896:18;:28;;53918:6;;53896:28;:::i;:::-;;;;-1:-1:-1;;53949:11:0;;:20;;53963:6;;53949:20;:::i;:::-;53935:11;:34;53996:13;;:22;;54012:6;;53996:22;:::i;:::-;53980:13;:38;-1:-1:-1;;;;;54036:42:0;;54059:18;;;;:9;:18;;;;;;;;;;54036:42;;7283:25:1;;;7324:18;;;7317:34;54036:42:0;;7256:18:1;54036:42:0;;;;;;;53824:262;;:::o;56613:408::-;60406:6;;56681:4;;56721:7;;-1:-1:-1;;;;;60406:6:0;60859:10;60385:28;56742:249;;56831:54;;;60859:10;56831:54;;;7536:51:1;7603:18;;;;7596:34;;;56831:54:0;;;;;;;;;;7509:18:1;;;;56831:54:0;;;;;;;-1:-1:-1;;;;;56831:54:0;-1:-1:-1;;;56831:54:0;;;56792:108;;-1:-1:-1;;;;;;;56792:20:0;;;:108;;56831:54;56792:108;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;56773:127:0;;-1:-1:-1;;56934:4:0;56923:15;;;;56915:38;;;;-1:-1:-1;;;56915:38:0;;8135:2:1;56915:38:0;;;8117:21:1;8174:2;8154:18;;;8147:30;-1:-1:-1;;;8193:18:1;;;8186:40;8243:18;;56915:38:0;7933:334:1;56915:38:0;56975:4;56968:11;;;;;;56742:249;-1:-1:-1;57008:5:0;;56613:408;-1:-1:-1;;;56613:408:0:o;60885:162::-;60976:10;;60932:7;;60959:14;45626:11;60972:1;60959:14;:::i;:::-;:27;;;;:::i;60189:121::-;60251:4;60292:1;60275:13;60286:1;60275:10;:13::i;:::-;:18;;:27;;;;-1:-1:-1;;60297:5:0;;;60189:121;-1:-1:-1;60189:121:0:o;54303:108::-;-1:-1:-1;;;;;54376:17:0;;;;;;:9;:17;;;;;:27;;54397:6;;54376:17;:27;;54397:6;;54376:27;:::i;:::-;;;;-1:-1:-1;;;;54303:108:0:o;54419:::-;-1:-1:-1;;;;;54492:17:0;;;;;;:9;:17;;;;;:27;;54513:6;;54492:17;:27;;54513:6;;54492:27;:::i;53073:108::-;53167:6;53151:13;;:22;;;;:::i;:::-;53135:13;:38;-1:-1:-1;53073:108:0:o;54094:201::-;54233:2;-1:-1:-1;;;;;54218:26:0;54227:4;-1:-1:-1;;;;;54218:26:0;;54237:6;54218:26;;;;1445:25:1;;1433:2;1418:18;;1299:177;54218:26:0;;;;;;;;54834:120;;;:::o;58155:1570::-;58202:7;58268:17;58293:16;45425:1;58293:6;:16::i;:::-;58288:21;;:2;:21;:::i;:::-;58268:41;-1:-1:-1;58320:15:0;58338:18;58268:41;58338:6;:18;:::i;:::-;58320:36;-1:-1:-1;58367:15:0;58395:14;58405:4;58320:36;58395:14;:::i;:::-;58385:24;;:7;:24;:::i;:::-;58367:42;-1:-1:-1;58420:15:0;58448:14;58458:4;58448:7;:14;:::i;:::-;58438:24;;:7;:24;:::i;:::-;58420:42;-1:-1:-1;58473:15:0;58501:14;58511:4;58501:7;:14;:::i;:::-;58491:24;;:7;:24;:::i;:::-;58473:42;-1:-1:-1;58526:15:0;58554:14;58564:4;58554:7;:14;:::i;:::-;58544:24;;:7;:24;:::i;:::-;58526:42;-1:-1:-1;58579:15:0;58607:14;58617:4;58607:7;:14;:::i;:::-;58597:24;;:7;:24;:::i;:::-;58579:42;-1:-1:-1;58632:15:0;58660:14;58670:4;58660:7;:14;:::i;:::-;58650:24;;:7;:24;:::i;:::-;58632:42;-1:-1:-1;58685:15:0;58713:14;58723:4;58713:7;:14;:::i;:::-;58703:24;;:7;:24;:::i;:::-;58685:42;-1:-1:-1;58738:15:0;58766:14;58776:4;58766:7;:14;:::i;:::-;58756:24;;:7;:24;:::i;:::-;58738:42;-1:-1:-1;58791:15:0;58819:14;58829:4;58819:7;:14;:::i;:::-;58809:24;;:7;:24;:::i;:::-;58791:42;;58866:7;58850:13;;:23;58846:845;;;58897:17;58909:5;58897:9;:17;:::i;:::-;58890:24;;;;;;;;;;;;;58155:1570;:::o;58846:845::-;58952:7;58936:13;;:23;58932:759;;;58983:16;58995:4;58983:9;:16;:::i;58932:759::-;59037:7;59021:13;;:23;59017:674;;;59068:16;59080:4;59068:9;:16;:::i;59017:674::-;59122:7;59106:13;;:23;59102:589;;;59153:16;59165:4;59153:9;:16;:::i;59102:589::-;59207:7;59191:13;;:23;59187:504;;;59238:16;59250:4;59238:9;:16;:::i;59187:504::-;59292:7;59276:13;;:23;59272:419;;;59323:16;59335:4;59323:9;:16;:::i;59272:419::-;59377:7;59361:13;;:23;59357:334;;;59408:16;59420:4;59408:9;:16;:::i;59357:334::-;59462:7;59446:13;;:23;59442:249;;;59493:16;59505:4;59493:9;:16;:::i;59442:249::-;59547:7;59531:13;;:23;59527:164;;;59578:16;59590:4;59578:9;:16;:::i;59527:164::-;59632:7;59616:13;;:23;59612:79;;;59663:16;59675:4;59663:9;:16;:::i;59612:79::-;-1:-1:-1;59708:9:0;;58155:1570;-1:-1:-1;;;;;;;;;;58155:1570:0:o;58018:129::-;-1:-1:-1;;;;;58124:14:0;;58078:7;58124:14;;;:9;:14;;;;;;58106:32;;:15;:32;:::i;53189:107::-;53282:6;53266:13;;:22;;;;:::i;:::-;53250:13;:38;-1:-1:-1;53189:107:0:o;53304:::-;53397:6;53381:13;;:22;;;;:::i;60690:92::-;60740:7;60767;60771:3;60767:2;:7;:::i;14:250:1:-;99:1;109:113;123:6;120:1;117:13;109:113;;;199:11;;;193:18;180:11;;;173:39;145:2;138:10;109:113;;;-1:-1:-1;;256:1:1;238:16;;231:27;14:250::o;269:396::-;418:2;407:9;400:21;381:4;450:6;444:13;493:6;488:2;477:9;473:18;466:34;509:79;581:6;576:2;565:9;561:18;556:2;548:6;544:15;509:79;:::i;:::-;649:2;628:15;-1:-1:-1;;624:29:1;609:45;;;;656:2;605:54;;269:396;-1:-1:-1;;269:396:1:o;670:173::-;738:20;;-1:-1:-1;;;;;787:31:1;;777:42;;767:70;;833:1;830;823:12;767:70;670:173;;;:::o;848:254::-;916:6;924;977:2;965:9;956:7;952:23;948:32;945:52;;;993:1;990;983:12;945:52;1016:29;1035:9;1016:29;:::i;:::-;1006:39;1092:2;1077:18;;;;1064:32;;-1:-1:-1;;;848:254:1:o;1481:328::-;1558:6;1566;1574;1627:2;1615:9;1606:7;1602:23;1598:32;1595:52;;;1643:1;1640;1633:12;1595:52;1666:29;1685:9;1666:29;:::i;:::-;1656:39;;1714:38;1748:2;1737:9;1733:18;1714:38;:::i;:::-;1704:48;;1799:2;1788:9;1784:18;1771:32;1761:42;;1481:328;;;;;:::o;2003:180::-;2062:6;2115:2;2103:9;2094:7;2090:23;2086:32;2083:52;;;2131:1;2128;2121:12;2083:52;-1:-1:-1;2154:23:1;;2003:180;-1:-1:-1;2003:180:1:o;2188:644::-;2303:6;2311;2364:2;2352:9;2343:7;2339:23;2335:32;2332:52;;;2380:1;2377;2370:12;2332:52;2420:9;2407:23;2449:18;2490:2;2482:6;2479:14;2476:34;;;2506:1;2503;2496:12;2476:34;2544:6;2533:9;2529:22;2519:32;;2589:7;2582:4;2578:2;2574:13;2570:27;2560:55;;2611:1;2608;2601:12;2560:55;2651:2;2638:16;2677:2;2669:6;2666:14;2663:34;;;2693:1;2690;2683:12;2663:34;2746:7;2741:2;2731:6;2728:1;2724:14;2720:2;2716:23;2712:32;2709:45;2706:65;;;2767:1;2764;2757:12;2706:65;2798:2;2790:11;;;;;2820:6;;-1:-1:-1;2188:644:1;;-1:-1:-1;;;;2188:644:1:o;2837:186::-;2896:6;2949:2;2937:9;2928:7;2924:23;2920:32;2917:52;;;2965:1;2962;2955:12;2917:52;2988:29;3007:9;2988:29;:::i;3028:260::-;3096:6;3104;3157:2;3145:9;3136:7;3132:23;3128:32;3125:52;;;3173:1;3170;3163:12;3125:52;3196:29;3215:9;3196:29;:::i;:::-;3186:39;;3244:38;3278:2;3267:9;3263:18;3244:38;:::i;:::-;3234:48;;3028:260;;;;;:::o;3293:127::-;3354:10;3349:3;3345:20;3342:1;3335:31;3385:4;3382:1;3375:15;3409:4;3406:1;3399:15;3425:217;3465:1;3491;3481:132;;3535:10;3530:3;3526:20;3523:1;3516:31;3570:4;3567:1;3560:15;3598:4;3595:1;3588:15;3481:132;-1:-1:-1;3627:9:1;;3425:217::o;3647:168::-;3720:9;;;3751;;3768:15;;;3762:22;;3748:37;3738:71;;3789:18;;:::i;3820:128::-;3887:9;;;3908:11;;;3905:37;;;3922:18;;:::i;4287:127::-;4348:10;4343:3;4339:20;4336:1;4329:31;4379:4;4376:1;4369:15;4403:4;4400:1;4393:15;4419:125;4484:9;;;4505:10;;;4502:36;;;4518:18;;:::i;5101:184::-;5171:6;5224:2;5212:9;5203:7;5199:23;5195:32;5192:52;;;5240:1;5237;5230:12;5192:52;-1:-1:-1;5263:16:1;;5101:184;-1:-1:-1;5101:184:1:o;6487:135::-;6526:3;6547:17;;;6544:43;;6567:18;;:::i;:::-;-1:-1:-1;6614:1:1;6603:13;;6487:135::o;6627:136::-;6666:3;6694:5;6684:39;;6703:18;;:::i;:::-;-1:-1:-1;;;6739:18:1;;6627:136::o;7641:287::-;7770:3;7808:6;7802:13;7824:66;7883:6;7878:3;7871:4;7863:6;7859:17;7824:66;:::i;:::-;7906:16;;;;;7641:287;-1:-1:-1;;7641:287:1:o;8272:416::-;8361:1;8398:5;8361:1;8412:270;8433:7;8423:8;8420:21;8412:270;;;8492:4;8488:1;8484:6;8480:17;8474:4;8471:27;8468:53;;;8501:18;;:::i;:::-;8551:7;8541:8;8537:22;8534:55;;;8571:16;;;;8534:55;8650:22;;;;8610:15;;;;8412:270;;;8416:3;8272:416;;;;;:::o;8693:806::-;8742:5;8772:8;8762:80;;-1:-1:-1;8813:1:1;8827:5;;8762:80;8861:4;8851:76;;-1:-1:-1;8898:1:1;8912:5;;8851:76;8943:4;8961:1;8956:59;;;;9029:1;9024:130;;;;8936:218;;8956:59;8986:1;8977:10;;9000:5;;;9024:130;9061:3;9051:8;9048:17;9045:43;;;9068:18;;:::i;:::-;-1:-1:-1;;9124:1:1;9110:16;;9139:5;;8936:218;;9238:2;9228:8;9225:16;9219:3;9213:4;9210:13;9206:36;9200:2;9190:8;9187:16;9182:2;9176:4;9173:12;9169:35;9166:77;9163:159;;;-1:-1:-1;9275:19:1;;;9307:5;;9163:159;9354:34;9379:8;9373:4;9354:34;:::i;:::-;9424:6;9420:1;9416:6;9412:19;9403:7;9400:32;9397:58;;;9435:18;;:::i;:::-;9473:20;;8693:806;-1:-1:-1;;;8693:806:1:o;9504:140::-;9562:5;9591:47;9632:4;9622:8;9618:19;9612:4;9591:47;:::i

Swarm Source

ipfs://d6051fcfe3781204f0e73496f37c2f603fe4c799307ecd1b7ffd2ca222175973

A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.

Tools & Services