Contract 0x95a1199eba84ac5f19546519e287d43d2f0e1b41

 
 
Txn Hash
Block
From
To
Value [Txn Fee]
0xb864eef7740971e2b9fbd9b415c2069c02309cd2c47603402793082862a1f4ed94626342021-07-25 10:05:217 mins ago0xc36deb75eaf853eaaf5e36fe63b78f1f16c5a2ac IN  Rabbit Finance: RABBIT Token0 BNB0.00022203
0xc38dfece826bca6ae761db53d0a1d6aebbfaa19b1654ca01cfa7f1ddfa87c61f94624692021-07-25 9:56:2416 mins ago0x273855e453f095a03957ef458b15bc40ea5b5239 IN  Rabbit Finance: RABBIT Token0 BNB0.00022203
0x42e80a983b1254fab7dd18de5016025fef48038b2e661afccac70f43a5d8bbfb94623972021-07-25 9:52:4819 mins ago0xc014fb41aabf2a5ca2bdb7ee06dfe4ca01ed6a3d IN  Rabbit Finance: RABBIT Token0 BNB0.00022203
0xade8e64f12453f3d704cf0875ae1510eb494a1087e85038fb128fdcc0a23c80994623322021-07-25 9:49:3322 mins ago0xfb79b5295d9a48e2a6064b746f77ec66d15bb2cb IN  Rabbit Finance: RABBIT Token0 BNB0.00022203
0xc88338a4c74c3eabb854dc820d5d4768589a7485279e5b091793e7c37c73b2ed94622662021-07-25 9:46:1526 mins ago0x124f6f5b8b8c205b2a77dbd142bb4610f7a0e225 IN  Rabbit Finance: RABBIT Token0 BNB0.0002264706
0x4950dd9f5ae69af97ea2287839f83955a831c52a69b46460c82faaad2c7d243b94622432021-07-25 9:45:0627 mins ago0x124d9bf2fecbc16b54ec4accdb14d44c2144f012 IN  Rabbit Finance: RABBIT Token0 BNB0.000306972
0xd715eb04bcf573a23a3368dd7f426420d386c6f27b04f90ab6b2f07b5b4f051394620812021-07-25 9:37:0035 mins ago0x6032aba638efd2e779abe86469d475ed70441e28 IN  Rabbit Finance: RABBIT Token0 BNB0.00022203
0xbd246f09735b4b5999d722d23f4f506a99560ed7d6ed4e5ac68c2c6bc88419e994620472021-07-25 9:35:1837 mins agoHotbit 2 IN  Rabbit Finance: RABBIT Token0 BNB0.00035805
0x8766986b30b9598da7dcb593a6481cfa581d5fb19b0d5b10d709071b77f4212894620042021-07-25 9:33:0939 mins ago0x0cd902ea42b42b06ff44c05fd8c3b4417fdf8426 IN  Rabbit Finance: RABBIT Token0 BNB0.00022203
0x853ed28926b08b5a45f77308c253a6c10405b1f40fd054f3a99ed6812ba694b894619962021-07-25 9:32:4539 mins ago0xe288bf7826834bf7f6e2b9711040a930d825cb03 IN  Rabbit Finance: RABBIT Token0 BNB0.00022203
0x620fc5db7e94ccb9be2be1c682434c9d94249ecf71d11567481cf0f059ba37a694619592021-07-25 9:30:5441 mins ago0xa401910043fa6cb72fa06256711dec93f4e88f6b IN  Rabbit Finance: RABBIT Token0 BNB0.0000740061
0x42a3b99732af71ac08a81558b2f59ad7acd6042e394a41242f8e47a6a394c6ae94618842021-07-25 9:27:0945 mins ago0x29e77e1bf755780b9a9fe44e7b639798349db471 IN  Rabbit Finance: RABBIT Token0 BNB0.00022203
0xdda4c5ea1e796560555930176c1531baaa65c39dd88a2814c9a171f74d2d887494618332021-07-25 9:24:3647 mins ago0x8e06ec89c77f6482236f44e2b7c3d39c8c5a3498 IN  Rabbit Finance: RABBIT Token0 BNB0.000087066
0x7a9ef90bbeb4542b295493e0488e6c4e79a0a53a3f0b84a7a9c730accb2ffaf894618232021-07-25 9:24:0648 mins ago0x46e64e008ea78f9410a7eb66fb101eeaf04fa921 IN  Rabbit Finance: RABBIT Token0 BNB0.00022203
0xa6214b9aa7e84fae08610eefd1f3db6efa4b293b3cd5e48aa8ad97a6870eeaec94617842021-07-25 9:22:0950 mins ago0x77f79d3acbee3c58f5c7295e2511e658dad08c9d IN  Rabbit Finance: RABBIT Token0 BNB0.0002264706
0x8dd62f91ed0649dc0e2bc4476c5359055c66c1e5c29e9f48c55bc47539c6b8bb94617332021-07-25 9:19:3652 mins ago0x0f46e60689de2bf74f2f06f11ae3a9bf3c017d03 IN  Rabbit Finance: RABBIT Token0 BNB0.00022203
0xe31669e5791b630333e8ea00278abccf4887dd3dd62dae023fddb5cfe7f1053294616502021-07-25 9:15:2757 mins ago0x7fa416ae5b070b3cb36da8c56497c6ce753e3c29 IN  Rabbit Finance: RABBIT Token0 BNB0.00013881
0x9bc75f77b6d6b93cbf06a60b7065afa1a2711310406dc6b5a8452c56312113f294616192021-07-25 9:13:5458 mins ago0x748cab38aeae6c4de9b8fecd355234ab746a67f2 IN  Rabbit Finance: RABBIT Token0 BNB0.00022203
0x58745389a257e851e942e1a189164a3ac4860cdc0b9f770eceb9c287e8eaccf894616172021-07-25 9:13:4858 mins ago0x62b84e5d78e7a6ceb6c11ab2e95bdbadda5161e6 IN  Rabbit Finance: RABBIT Token0 BNB0.000266436
0x293f700ff924477aae9562e322dee57ce0ef62488a9574a34fa7868b0f262a8594615052021-07-25 9:08:121 hr 4 mins ago0x776868422dce28ed26b7953b1a4a8882212be9b3 IN  Rabbit Finance: RABBIT Token0 BNB0.00022203
0x5b65bc9364c8575cae3ec09de1bba87ebc6b248fad14728d946fa3e0e0139e4694614522021-07-25 9:05:331 hr 6 mins ago0x492cbd0af3031df3c2f910b635557a94db698063 IN  Rabbit Finance: RABBIT Token0 BNB0.00022203
0x790156fd3efd9c4fad438c80f215a98f7ecde964a316befb2e70b4f1c05bec1494613912021-07-25 9:02:301 hr 10 mins ago0xaa02ed14bef59169d01f6da662972a0accb7adf5 IN  Rabbit Finance: RABBIT Token0 BNB0.00022203
0x7867ca268f93300b4bfd0cac18cd77bcb6c0ec5a1ebce554430be9756bf731ba94612252021-07-25 8:53:571 hr 18 mins ago0xa9106b5044084ed7425d7ada0a8c3c0d393d6d70 IN  Rabbit Finance: RABBIT Token0 BNB0.00022203
0x3526e0038fb7cfe814cedba4fbccbed6cb2b841ff77c7000141b004414f8a02794611972021-07-25 8:52:331 hr 19 mins ago0x809b8a4a7fd1215519ce29b327c4629abf9e0dc7 IN  Rabbit Finance: RABBIT Token0 BNB0.0002264706
0xbb5de63b0341e721ab2c010b081635aa95261f2a29a0748071a011d591823dc094611912021-07-25 8:52:151 hr 20 mins ago0xe1fb40733e1182ab52202122d93916751a0d0fb5 IN  Rabbit Finance: RABBIT Token0 BNB0.00022203
[ Download CSV Export 

OVERVIEW

Rabbit Finance is a lending protocol allowing leveraged yield farming function on the Binance Smart Chain released by Rabbit Finance Lab. It supports users participating in liquidity farming through over-lending plus leverage to get more revenue.

Parent Txn Hash Block From To Value
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
Rabbit

Compiler Version
v0.6.12+commit.27d51765

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, None license

Contract Source Code (Solidity)

/**
 *Submitted for verification at BscScan.com on 2021-05-19
*/

// File: @openzeppelin/contracts/GSN/Context.sol

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.0;

/*
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with GSN meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address payable) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes memory) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

// File: @openzeppelin/contracts/access/Ownable.sol


pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor () internal {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(_owner == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = address(0);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

// File: contracts/owner/Operator.sol

pragma solidity ^0.6.0;



contract Operator is Context, Ownable {
    address private _operator;

    event OperatorTransferred(
        address indexed previousOperator,
        address indexed newOperator
    );

    constructor() internal {
        _operator = _msgSender();
        emit OperatorTransferred(address(0), _operator);
    }

    function operator() public view returns (address) {
        return _operator;
    }

    modifier onlyOperator() {
        require(
            _operator == msg.sender,
            'operator: caller is not the operator'
        );
        _;
    }

    function isOperator() public view returns (bool) {
        return _msgSender() == _operator;
    }

    function transferOperator(address newOperator_) public onlyOwner {
        _transferOperator(newOperator_);
    }

    function _transferOperator(address newOperator_) internal {
        require(
            newOperator_ != address(0),
            'operator: zero address given for new operator'
        );
        emit OperatorTransferred(address(0), newOperator_);
        _operator = newOperator_;
    }
}

// File: @openzeppelin/contracts/token/ERC20/IERC20.sol


pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

// File: @openzeppelin/contracts/math/SafeMath.sol


pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

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

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

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

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

        return c;
    }

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

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

// File: @openzeppelin/contracts/token/ERC20/ERC20.sol


pragma solidity >=0.6.0 <0.8.0;




/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin guidelines: functions revert instead
 * of returning `false` on failure. This behavior is nonetheless conventional
 * and does not conflict with the expectations of ERC20 applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20 is Context, IERC20 {
    using SafeMath for uint256;

    mapping (address => uint256) private _balances;

    mapping (address => mapping (address => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;
    uint8 private _decimals;

    /**
     * @dev Sets the values for {name} and {symbol}, initializes {decimals} with
     * a default value of 18.
     *
     * To select a different value for {decimals}, use {_setupDecimals}.
     *
     * All three of these values are immutable: they can only be set once during
     * construction.
     */
    constructor (string memory name_, string memory symbol_) public {
        _name = name_;
        _symbol = symbol_;
        _decimals = 18;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5,05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the value {ERC20} uses, unless {_setupDecimals} is
     * called.
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view returns (uint8) {
        return _decimals;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view override returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view override returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `recipient` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view virtual override returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        _approve(_msgSender(), spender, amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * Requirements:
     *
     * - `sender` and `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     * - the caller must have allowance for ``sender``'s tokens of at least
     * `amount`.
     */
    function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(sender, recipient, amount);
        _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
        return true;
    }

    /**
     * @dev Moves tokens `amount` from `sender` to `recipient`.
     *
     * This is internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `sender` cannot be the zero address.
     * - `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     */
    function _transfer(address sender, address recipient, uint256 amount) internal virtual {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");

        // _beforeTokenTransfer(sender, recipient, amount);

        _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
        _balances[recipient] = _balances[recipient].add(amount);
        emit Transfer(sender, recipient, amount);
    }

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        // _beforeTokenTransfer(address(0), account, amount);

        _totalSupply = _totalSupply.add(amount);
        _balances[account] = _balances[account].add(amount);
        emit Transfer(address(0), account, amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        // _beforeTokenTransfer(account, address(0), amount);

        _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
        _totalSupply = _totalSupply.sub(amount);
        emit Transfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(address owner, address spender, uint256 amount) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    /**
     * @dev Sets {decimals} to a value other than the default one of 18.
     *
     * WARNING: This function should only be called from the constructor. Most
     * applications that interact with token contracts will not expect
     * {decimals} to ever change, and may work incorrectly if it does.
     */
    // function _setupDecimals(uint8 decimals_) internal {
    //     _decimals = decimals_;
    // }

    /**
     * @dev Hook that is called before any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * will be to transferred to `to`.
     * - when `from` is zero, `amount` tokens will be minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    // function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}

// File: @openzeppelin/contracts/token/ERC20/ERC20Burnable.sol


pragma solidity >=0.6.0 <0.8.0;



/**
 * @dev Extension of {ERC20} that allows token holders to destroy both their own
 * tokens and those that they have an allowance for, in a way that can be
 * recognized off-chain (via event analysis).
 */
abstract contract ERC20Burnable is Context, ERC20 {
    using SafeMath for uint256;

    /**
     * @dev Destroys `amount` tokens from the caller.
     *
     * See {ERC20-_burn}.
     */
    function burn(uint256 amount) public virtual {
        _burn(_msgSender(), amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, deducting from the caller's
     * allowance.
     *
     * See {ERC20-_burn} and {ERC20-allowance}.
     *
     * Requirements:
     *
     * - the caller must have allowance for ``accounts``'s tokens of at least
     * `amount`.
     */
    function burnFrom(address account, uint256 amount) public virtual {
        uint256 decreasedAllowance = allowance(account, _msgSender()).sub(amount, "ERC20: burn amount exceeds allowance");

        _approve(account, _msgSender(), decreasedAllowance);
        _burn(account, amount);
    }
}

pragma solidity ^0.6.0;



contract Rabbit is ERC20Burnable, Operator {
    constructor() public ERC20('Rabbit Coin', 'RABBIT') {
        // Mints 1 Basis Share to contract creator for initial Uniswap oracle deployment.
        // Will be burned after oracle deployment
        _mint(msg.sender, 1 * 10**18);
    }

    /**
     * @notice Operator mints basis cash to a recipient
     * @param recipient_ The address of recipient
     * @param amount_ The amount of basis cash to mint to
     */
    function mint(address recipient_, uint256 amount_)
        public
        onlyOperator
        returns (bool)
    {
        uint256 balanceBefore = balanceOf(recipient_);
        _mint(recipient_, amount_);
        uint256 balanceAfter = balanceOf(recipient_);
        return balanceAfter >= balanceBefore;
    }

    function burn(uint256 amount) public override onlyOperator {
        super.burn(amount);
    }

    function burnFrom(address account, uint256 amount)
        public
        override
        onlyOperator
    {
        super.burnFrom(account, amount);
    }
}

Contract ABI

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOperator","type":"address"},{"indexed":true,"internalType":"address","name":"newOperator","type":"address"}],"name":"OperatorTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","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":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"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":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burnFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"isOperator","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient_","type":"address"},{"internalType":"uint256","name":"amount_","type":"uint256"}],"name":"mint","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"operator","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOperator_","type":"address"}],"name":"transferOperator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

Deployed ByteCode Sourcemap

25002:1083:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14892:83;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16998:169;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;16998:169:0;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;15967:100;;;:::i;:::-;;;;;;;;;;;;;;;;17649:321;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;17649:321:0;;;;;;;;;;;;;;;;;:::i;4102:115::-;;;;;;;;;;;;;;;;-1:-1:-1;4102:115:0;-1:-1:-1;;;;;4102:115:0;;:::i;:::-;;15819:83;;;:::i;:::-;;;;;;;;;;;;;;;;;;;18379:218;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;18379:218:0;;;;;;;;:::i;25487:321::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;25487:321:0;;;;;;;;:::i;25816:96::-;;;;;;;;;;;;;;;;-1:-1:-1;25816:96:0;;:::i;3994:100::-;;;:::i;3729:85::-;;;:::i;:::-;;;;-1:-1:-1;;;;;3729:85:0;;;;;;;;;;;;;;16130:119;;;;;;;;;;;;;;;;-1:-1:-1;16130:119:0;-1:-1:-1;;;;;16130:119:0;;:::i;2770:148::-;;;:::i;25920:162::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;25920:162:0;;;;;;;;:::i;2128:79::-;;;:::i;15094:87::-;;;:::i;19100:269::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;19100:269:0;;;;;;;;:::i;16462:175::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;16462:175:0;;;;;;;;:::i;16700:151::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;16700:151:0;;;;;;;;;;:::i;3073:244::-;;;;;;;;;;;;;;;;-1:-1:-1;3073:244:0;-1:-1:-1;;;;;3073:244:0;;:::i;14892:83::-;14962:5;14955:12;;;;;;;;-1:-1:-1;;14955:12:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14929:13;;14955:12;;14962:5;;14955:12;;14962:5;14955:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14892:83;:::o;16998:169::-;17081:4;17098:39;17107:12;:10;:12::i;:::-;17121:7;17130:6;17098:8;:39::i;:::-;-1:-1:-1;17155:4:0;16998:169;;;;:::o;15967:100::-;16047:12;;15967:100;:::o;17649:321::-;17755:4;17772:36;17782:6;17790:9;17801:6;17772:9;:36::i;:::-;17819:121;17828:6;17836:12;:10;:12::i;:::-;17850:89;17888:6;17850:89;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;17850:19:0;;;;;;:11;:19;;;;;;17870:12;:10;:12::i;:::-;-1:-1:-1;;;;;17850:33:0;;;;;;;;;;;;-1:-1:-1;17850:33:0;;;:89;:37;:89::i;:::-;17819:8;:121::i;:::-;-1:-1:-1;17958:4:0;17649:321;;;;;:::o;4102:115::-;2350:12;:10;:12::i;:::-;2340:6;;;;;-1:-1:-1;;;;;2340:6:0;;;:22;;;2332:67;;;;;-1:-1:-1;;;2332:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4178:31:::1;4196:12;4178:17;:31::i;:::-;4102:115:::0;:::o;15819:83::-;15885:9;;;;15819:83;:::o;18379:218::-;18467:4;18484:83;18493:12;:10;:12::i;:::-;18507:7;18516:50;18555:10;18516:11;:25;18528:12;:10;:12::i;:::-;-1:-1:-1;;;;;18516:25:0;;;;;;;;;;;;;;;;;-1:-1:-1;18516:25:0;;;:34;;;;;;;;;;;:38;:50::i;25487:321::-;3879:9;;25594:4;;-1:-1:-1;;;;;3879:9:0;3892:10;3879:23;3857:109;;;;-1:-1:-1;;;3857:109:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25616:21:::1;25640;25650:10;25640:9;:21::i;:::-;25616:45;;25672:26;25678:10;25690:7;25672:5;:26::i;:::-;25709:20;25732:21;25742:10;25732:9;:21::i;:::-;25771:29:::0;;;::::1;;::::0;25487:321;-1:-1:-1;;;;25487:321:0:o;25816:96::-;3879:9;;-1:-1:-1;;;;;3879:9:0;3892:10;3879:23;3857:109;;;;-1:-1:-1;;;3857:109:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25886:18:::1;25897:6;25886:10;:18::i;3994:100::-:0;4077:9;;4037:4;;-1:-1:-1;;;;;4077:9:0;4061:12;:10;:12::i;:::-;-1:-1:-1;;;;;4061:25:0;;4054:32;;3994:100;:::o;3729:85::-;3797:9;;-1:-1:-1;;;;;3797:9:0;3729:85;:::o;16130:119::-;-1:-1:-1;;;;;16223:18:0;16196:7;16223:18;;;;;;;;;;;;16130:119::o;2770:148::-;2350:12;:10;:12::i;:::-;2340:6;;;;;-1:-1:-1;;;;;2340:6:0;;;:22;;;2332:67;;;;;-1:-1:-1;;;2332:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2861:6:::1;::::0;2840:40:::1;::::0;2877:1:::1;::::0;2861:6:::1;::::0;::::1;-1:-1:-1::0;;;;;2861:6:0::1;::::0;2840:40:::1;::::0;2877:1;;2840:40:::1;2891:6;:19:::0;;-1:-1:-1;;;;;;2891:19:0::1;::::0;;2770:148::o;25920:162::-;3879:9;;-1:-1:-1;;;;;3879:9:0;3892:10;3879:23;3857:109;;;;-1:-1:-1;;;3857:109:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26043:31:::1;26058:7;26067:6;26043:14;:31::i;:::-;25920:162:::0;;:::o;2128:79::-;2193:6;;;;;-1:-1:-1;;;;;2193:6:0;;2128:79::o;15094:87::-;15166:7;15159:14;;;;;;;;-1:-1:-1;;15159:14:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15133:13;;15159:14;;15166:7;;15159:14;;15166:7;15159:14;;;;;;;;;;;;;;;;;;;;;;;;19100:269;19193:4;19210:129;19219:12;:10;:12::i;:::-;19233:7;19242:96;19281:15;19242:96;;;;;;;;;;;;;;;;;:11;:25;19254:12;:10;:12::i;:::-;-1:-1:-1;;;;;19242:25:0;;;;;;;;;;;;;;;;;-1:-1:-1;19242:25:0;;;:34;;;;;;;;;;;:96;:38;:96::i;16462:175::-;16548:4;16565:42;16575:12;:10;:12::i;:::-;16589:9;16600:6;16565:9;:42::i;16700:151::-;-1:-1:-1;;;;;16816:18:0;;;16789:7;16816:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;16700:151::o;3073:244::-;2350:12;:10;:12::i;:::-;2340:6;;;;;-1:-1:-1;;;;;2340:6:0;;;:22;;;2332:67;;;;;-1:-1:-1;;;2332:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;3162:22:0;::::1;3154:73;;;;-1:-1:-1::0;;;3154:73:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3264:6;::::0;3243:38:::1;::::0;-1:-1:-1;;;;;3243:38:0;;::::1;::::0;3264:6:::1;::::0;::::1;;::::0;3243:38:::1;::::0;;;::::1;3292:6;:17:::0;;-1:-1:-1;;;;;3292:17:0;;::::1;;;-1:-1:-1::0;;;;;;3292:17:0;;::::1;::::0;;;::::1;::::0;;3073:244::o;8266:181::-;8324:7;8356:5;;;8380:6;;;;8372:46;;;;;-1:-1:-1;;;8372:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;8438:1;8266:181;-1:-1:-1;;;8266:181:0:o;665:106::-;753:10;665:106;:::o;22256:346::-;-1:-1:-1;;;;;22358:19:0;;22350:68;;;;-1:-1:-1;;;22350:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;22437:21:0;;22429:68;;;;-1:-1:-1;;;22429:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;22510:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;22562:32;;;;;;;;;;;;;;;;;22256:346;;;:::o;19859:542::-;-1:-1:-1;;;;;19965:20:0;;19957:70;;;;-1:-1:-1;;;19957:70:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;20046:23:0;;20038:71;;;;-1:-1:-1;;;20038:71:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20205;20227:6;20205:71;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;20205:17:0;;:9;:17;;;;;;;;;;;;:71;:21;:71::i;:::-;-1:-1:-1;;;;;20185:17:0;;;:9;:17;;;;;;;;;;;:91;;;;20310:20;;;;;;;:32;;20335:6;20310:24;:32::i;:::-;-1:-1:-1;;;;;20287:20:0;;;:9;:20;;;;;;;;;;;;:55;;;;20358:35;;;;;;;20287:20;;20358:35;;;;;;;;;;;;;19859:542;;;:::o;9169:192::-;9255:7;9291:12;9283:6;;;;9275:29;;;;-1:-1:-1;;;9275:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;9327:5:0;;;9169:192::o;4225:294::-;-1:-1:-1;;;;;4316:26:0;;4294:121;;;;-1:-1:-1;;;4294:121:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4431:45;;-1:-1:-1;;;;;4431:45:0;;;4459:1;;4431:45;;4459:1;;4431:45;4487:9;:24;;-1:-1:-1;;;;;;4487:24:0;-1:-1:-1;;;;;4487:24:0;;;;;;;;;;4225:294::o;20683:381::-;-1:-1:-1;;;;;20767:21:0;;20759:65;;;;;-1:-1:-1;;;20759:65:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;20917:12;;:24;;20934:6;20917:16;:24::i;:::-;20902:12;:39;-1:-1:-1;;;;;20973:18:0;;:9;:18;;;;;;;;;;;:30;;20996:6;20973:22;:30::i;:::-;-1:-1:-1;;;;;20952:18:0;;:9;:18;;;;;;;;;;;:51;;;;21019:37;;;;;;;20952:18;;:9;;21019:37;;;;;;;;;;20683:381;;:::o;24259:91::-;24315:27;24321:12;:10;:12::i;:::-;24335:6;24315:5;:27::i;24669:295::-;24746:26;24775:84;24812:6;24775:84;;;;;;;;;;;;;;;;;:32;24785:7;24794:12;:10;:12::i;:::-;24775:9;:32::i;:::-;:36;:84;:36;:84::i;:::-;24746:113;;24872:51;24881:7;24890:12;:10;:12::i;:::-;24904:18;24872:8;:51::i;:::-;24934:22;24940:7;24949:6;24934:5;:22::i;:::-;24669:295;;;:::o;21397:421::-;-1:-1:-1;;;;;21481:21:0;;21473:67;;;;-1:-1:-1;;;21473:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21639:68;21662:6;21639:68;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;21639:18:0;;:9;:18;;;;;;;;;;;;:68;:22;:68::i;:::-;-1:-1:-1;;;;;21618:18:0;;:9;:18;;;;;;;;;;:89;21733:12;;:24;;21750:6;21733:16;:24::i;:::-;21718:12;:39;21773:37;;;;;;;;21799:1;;-1:-1:-1;;;;;21773:37:0;;;;;;;;;;;;21397:421;;:::o;8730:136::-;8788:7;8815:43;8819:1;8822;8815:43;;;;;;;;;;;;;;;;;:3;:43::i

Swarm Source

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