Contract 0x1fdeaf938267ca43388ed1fdb879eaf91e920c7a

 
 
Txn Hash Method
Block
From
To
Value [Txn Fee]
0x35bf409dfc9faa4d592781261e4d6cdd13181f6633fa7f438a92e8fc903717ebApprove339218042022-10-04 13:29:398 hrs 42 mins ago0xcd0b67a61e5e8f4616c19e421e929813b6d947df IN  0x1fdeaf938267ca43388ed1fdb879eaf91e920c7a0 MATIC0.00139374 30.00000002
0x9095309f9f5e654ec79dcd7eb179ed92514f3624c611b958e65a10467cac5131Approve339099482022-10-04 6:40:5215 hrs 30 mins ago0x0c368d683c616073d48fa26f7796dfe3f8d46526 IN  0x1fdeaf938267ca43388ed1fdb879eaf91e920c7a0 MATIC0.000874594777 32.931500021
0xcc5ebfd78b2f6abafdcc4018e91ef374e850bb72a77a63d4f05e8708ddf5e5b3Approve339099322022-10-04 6:40:2015 hrs 31 mins ago0x0c368d683c616073d48fa26f7796dfe3f8d46526 IN  0x1fdeaf938267ca43388ed1fdb879eaf91e920c7a0 MATIC0.001663083 35.797559101
0xa47bfd38c40d1314e5d1d824d270caec02f8385c57ff4c86b3ee6c8bdedbf9a1Approve339082392022-10-04 5:42:0816 hrs 29 mins ago0x5f8977576c04b9f35e32167e296c10559833ba86 IN  0x1fdeaf938267ca43388ed1fdb879eaf91e920c7a0 MATIC0.00139374 30.000000012
0xb991bc10e76abee9e9196207792bfd6a3f6893e3a58bb53e6270a2e77a630da5Approve339036872022-10-04 3:05:2419 hrs 6 mins ago0xe6ec83200fa6f55a3ada624e074e599d74cffa86 IN  0x1fdeaf938267ca43388ed1fdb879eaf91e920c7a0 MATIC0.00139374 30.000000014
0x92748c6ae6728bbe566e8d9a24544562552af2d1401f36ab237ce2511ee4d1e1Approve338960362022-10-03 22:42:0323 hrs 29 mins ago0xb029d64c615c97483f31ca78b5b3b2e4a1f9a5f4 IN  0x1fdeaf938267ca43388ed1fdb879eaf91e920c7a0 MATIC0.001411013285 30.37180433
0x993faefe78be57f006e73c79805369a8904ba1a1ceed3dd5d10e51ef7713f07dApprove338649052022-10-03 4:39:491 day 17 hrs ago0x48e9e2f211371bd2462e44af3d2d1aa610437f82 IN  0x1fdeaf938267ca43388ed1fdb879eaf91e920c7a0 MATIC0.00157044 60.000000021
0x0485c9fa3875f7b9e1e5d82d72c30c7e90610cbe879873136da5b99f96745109Approve338649022022-10-03 4:39:431 day 17 hrs ago0x48e9e2f211371bd2462e44af3d2d1aa610437f82 IN  0x1fdeaf938267ca43388ed1fdb879eaf91e920c7a0 MATIC0.00145044 60.000000021
0x48b24493883ca2945de638bd8cbe115d15874917fdd6e6e03189952396c9876fTransfer338631582022-10-03 3:39:251 day 18 hrs ago0xc40dbd75ee1b14e0ef289d91485faa6058d0f41f IN  0x1fdeaf938267ca43388ed1fdb879eaf91e920c7a0 MATIC0.001429821302 30.555001651
0x767541aad802df725ab2e9fc3c925339071f60f445f946392a582fcb146b79faApprove338329502022-10-02 10:14:452 days 11 hrs ago0x5a4b09693ccaa2c3218592d0bafa7788a01f4600 IN  0x1fdeaf938267ca43388ed1fdb879eaf91e920c7a0 MATIC0.001393740009 30.000000196
0x9a258648fcf0cde7df058fd8d89939e0e0f00a4c47312a00842c1b8369d31167Approve338306152022-10-02 8:54:272 days 13 hrs ago0xe95ad50106453cc72dbea4d0e9df2010fa578adb IN  0x1fdeaf938267ca43388ed1fdb879eaf91e920c7a0 MATIC0.00079674 30.000000015
0x729588343a0befab18d18a0e6f1f96069a258a63ed41144e1341f59a93c91fb8Approve338306012022-10-02 8:53:592 days 13 hrs ago0xe95ad50106453cc72dbea4d0e9df2010fa578adb IN  0x1fdeaf938267ca43388ed1fdb879eaf91e920c7a0 MATIC0.00139374 30.000000015
0x1d93701306c7fb0f98a314f3daab17b0c6852f481d96aa8fe486a8ffcfb75537Approve338280402022-10-02 7:21:412 days 14 hrs ago0x10c598cf1da2a558561820d9224a7c8535eb24ce IN  0x1fdeaf938267ca43388ed1fdb879eaf91e920c7a0 MATIC0.00072522 30.000000017
0x4c9f83845bcc3b4c6b22f2c2abf0c68b4aa55b07b6c3139a5e7da23b19580036Approve338277102022-10-02 7:10:172 days 15 hrs ago0x8c91d3f4329efdec76dedf418375fae260f0b44b IN  0x1fdeaf938267ca43388ed1fdb879eaf91e920c7a0 MATIC0.00139374 30.000000014
0x3df4667634ad10307a3c7e7633d22c2dbe443d7f00fa5e2daf3209d17794a974Approve338250172022-10-02 5:35:352 days 16 hrs ago0x3db00d1334b5fadd2a897d8a702cdcbb6f159d87 IN  0x1fdeaf938267ca43388ed1fdb879eaf91e920c7a0 MATIC0.00072691218 30.070000001
0x2e8ba5a2103315fd650150db439febc7709e01f6fabd7379f342e8a14f01533eApprove337991592022-10-01 14:37:523 days 7 hrs ago0x6f62b316f561877828d432d6121a0e03d6d410c2 IN  0x1fdeaf938267ca43388ed1fdb879eaf91e920c7a0 MATIC0.001393740002 30.000000049
0xcfacc4e5ee8d176d08f10597562625de773e54f0f15089399f81fc1b254999cfApprove337850402022-10-01 6:29:013 days 15 hrs ago0x1e081471ebc8174b5e8ba2d985777c4d9d193ceb IN  0x1fdeaf938267ca43388ed1fdb879eaf91e920c7a0 MATIC0.001484033678 31.943555012
0x152b333a0da0c437c939e9d0628a05f6b1a958efb4cb06102fa5deb09969adb9Approve337842572022-10-01 6:02:073 days 16 hrs ago0x4a2e3806fb3803fe6b2a5d9a884ccef6b0fdd37a IN  0x1fdeaf938267ca43388ed1fdb879eaf91e920c7a0 MATIC0.001403301056 30.205800001
0x521a9c62a7dc4447941c71b63d7fa59a9b0da7720600cb94f4300335b5e5035aApprove337645552022-09-30 18:35:244 days 3 hrs ago0x30c1fd89217ddb02ee8547c419edcb6042404bd1 IN  0x1fdeaf938267ca43388ed1fdb879eaf91e920c7a0 MATIC0.001689909751 36.375000036
0x7a8ff7180805634622f4cd5dde763621b06d44c34c2fd1958e49afe07227263aApprove337573702022-09-30 14:26:054 days 7 hrs ago0xfb0f768f4b045f527f80f1949d0d89568ba40e81 IN  0x1fdeaf938267ca43388ed1fdb879eaf91e920c7a0 MATIC0.001425497025 30.683564208
0x232e17e055b582fed350b4881798c5c808f569f122cadf58f394eca72afb1e91Approve337522052022-09-30 11:24:074 days 10 hrs ago0x697d84b5f295e5c10814c73bd385d628925d3017 IN  0x1fdeaf938267ca43388ed1fdb879eaf91e920c7a0 MATIC0.001393740001 30.00000004
0x09a14d581fd69b2e6955f0549e5a60835918f282b0dd5e9b1ca784e0c5b49f75Approve337434782022-09-30 6:21:494 days 15 hrs ago0x543009285dc2aa291bca060df6f9d06c81b08429 IN  0x1fdeaf938267ca43388ed1fdb879eaf91e920c7a0 MATIC0.00139374 30.000000015
0x97362eb6dc2204996a846445eb11504a9ad1f5e0b2443f6ef1054933296dd797Approve337285022022-09-29 21:37:355 days 34 mins ago0x0e4851f6464471004bc9736fe8f66eb82591650e IN  0x1fdeaf938267ca43388ed1fdb879eaf91e920c7a0 MATIC0.00166737762 35.890000013
0xb82a23c84b6190eb21db48d171d061a5aec314e943ef37fa84371003315c1880Approve337176572022-09-29 15:16:425 days 6 hrs ago0x8bea1147f760ba125ff15cfad09b7b92005c12a7 IN  0x1fdeaf938267ca43388ed1fdb879eaf91e920c7a0 MATIC0.001557452288 33.523877228
0x54f4020cd160d3e4ce71a8559ae702675084b8ca2df2bf2b49f0254c8ed711e9Approve337151382022-09-29 13:44:455 days 8 hrs ago0x69726bd5df6deb7523a50ac951d8e6ae099b3cdd IN  0x1fdeaf938267ca43388ed1fdb879eaf91e920c7a0 MATIC0.001478107831 31.816002236
[ Download CSV Export 
Parent Txn Hash Block From To Value
Loading

Similar Match Source Code
Note: This contract matches the deployed ByteCode of the Source Code for Contract 0x9ec9551d4A1a1593b0ee8124D98590CC71b3B09D

Contract Name:
HopBridgeToken

Compiler Version
v0.6.12+commit.27d51765

Optimization Enabled:
Yes with 50000 runs

Other Settings:
default evmVersion, MIT license

Contract Source Code (Solidity)

/**
 *Submitted for verification at polygonscan.com on 2021-07-25
*/

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

/*
 * @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;
    }
}

/**
 * @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);
}

/**
 * @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, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        uint256 c = a + b;
        if (c < a) return (false, 0);
        return (true, c);
    }

    /**
     * @dev Returns the substraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        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) {
        // 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) {
        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) {
        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) {
        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) {
        require(b <= a, "SafeMath: subtraction overflow");
        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) {
        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, reverting 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) {
        require(b > 0, "SafeMath: division by zero");
        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) {
        require(b > 0, "SafeMath: modulo by zero");
        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) {
        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.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryDiv}.
     *
     * 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);
        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) {
        require(b > 0, errorMessage);
        return a % b;
    }
}

/**
 * @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 virtual returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual 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 virtual returns (uint8) {
        return _decimals;
    }

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

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual 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 virtual {
        _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 { }
}

/**
 * @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 virtual 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;
    }
}

/**
 * @dev Hop Bridge Tokens or "hTokens" are layer-2 tokens that represent a deposit in the L1_Bridge
 * contract. Each Hop Bridge Token is a regular ERC20 that can be minted and burned by the L2_Bridge
 * that owns it.
 */

contract HopBridgeToken is ERC20, Ownable {

    constructor (
        string memory name,
        string memory symbol,
        uint8 decimals
    )
        public
        ERC20(name, symbol)
    {
        _setupDecimals(decimals);
    }

    /**
     * @dev Mint new hToken for the account
     * @param account The account being minted for
     * @param amount The amount being minted
     */
    function mint(address account, uint256 amount) external onlyOwner {
        _mint(account, amount);
    }

    /**
     * @dev Burn hToken from the account
     * @param account The account being burned from
     * @param amount The amount being burned
     */
    function burn(address account, uint256 amount) external onlyOwner {
        _burn(account, amount);
    }
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"symbol","type":"string"},{"internalType":"uint8","name":"decimals","type":"uint8"}],"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":"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":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burn","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":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"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":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

Deployed ByteCode Sourcemap

24436:802:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13108:91;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15254:169;;;;;;;;;;;;;;;;-1:-1:-1;15254:169:0;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;14207:108;;;:::i;:::-;;;;;;;;;;;;;;;;15905:321;;;;;;;;;;;;;;;;-1:-1:-1;15905:321:0;;;;;;;;;;;;;;;;;;:::i;14051:91::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;;16635:218;;;;;;;;;;;;;;;;-1:-1:-1;16635:218:0;;;;;;;;;:::i;24854:107::-;;;;;;;;;;;;;;;;-1:-1:-1;24854:107:0;;;;;;;;;:::i;:::-;;14378:127;;;;;;;;;;;;;;;;-1:-1:-1;14378:127:0;;;;:::i;23649:148::-;;;:::i;22998:87::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;;13318:95;;;:::i;25128:107::-;;;;;;;;;;;;;;;;-1:-1:-1;25128:107:0;;;;;;;;;:::i;17356:269::-;;;;;;;;;;;;;;;;-1:-1:-1;17356:269:0;;;;;;;;;:::i;14718:175::-;;;;;;;;;;;;;;;;-1:-1:-1;14718:175:0;;;;;;;;;:::i;14956:151::-;;;;;;;;;;;;;;;;-1:-1:-1;14956:151:0;;;;;;;;;;;:::i;23952:244::-;;;;;;;;;;;;;;;;-1:-1:-1;23952:244:0;;;;:::i;13108:91::-;13186:5;13179:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13153:13;;13179:12;;13186:5;;13179:12;;13186:5;13179:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13108:91;:::o;15254:169::-;15337:4;15354:39;15363:12;:10;:12::i;:::-;15377:7;15386:6;15354:8;:39::i;:::-;-1:-1:-1;15411:4:0;15254:169;;;;:::o;14207:108::-;14295:12;;14207:108;:::o;15905:321::-;16011:4;16028:36;16038:6;16046:9;16057:6;16028:9;:36::i;:::-;16075:121;16084:6;16092:12;:10;:12::i;:::-;16106:89;16144:6;16106:89;;;;;;;;;;;;;;;;;:19;;;;;;;:11;:19;;;;;;16126:12;:10;:12::i;:::-;16106:33;;;;;;;;;;;;;-1:-1:-1;16106:33:0;;;:89;:37;:89::i;:::-;16075:8;:121::i;:::-;-1:-1:-1;16214:4:0;15905:321;;;;;:::o;14051:91::-;14125:9;;;;14051:91;:::o;16635:218::-;16723:4;16740:83;16749:12;:10;:12::i;:::-;16763:7;16772:50;16811:10;16772:11;:25;16784:12;:10;:12::i;:::-;16772:25;;;;;;;;;;;;;;;;;;-1:-1:-1;16772:25:0;;;:34;;;;;;;;;;;:38;:50::i;24854:107::-;23229:12;:10;:12::i;:::-;23218:23;;:7;:5;:7::i;:::-;:23;;;23210:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24931:22:::1;24937:7;24946:6;24931:5;:22::i;:::-;24854:107:::0;;:::o;14378:127::-;14479:18;;14452:7;14479:18;;;;;;;;;;;;14378:127::o;23649:148::-;23229:12;:10;:12::i;:::-;23218:23;;:7;:5;:7::i;:::-;:23;;;23210:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23740:6:::1;::::0;23719:40:::1;::::0;23756:1:::1;::::0;23740:6:::1;::::0;::::1;23719:40;23740:6;::::0;23719:40:::1;::::0;23756:1;;23719:40:::1;23770:6;:19:::0;;;::::1;::::0;;23649:148::o;22998:87::-;23071:6;;;;;;;;22998:87::o;13318:95::-;13398:7;13391:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13365:13;;13391:14;;13398:7;;13391:14;;13398:7;13391:14;;;;;;;;;;;;;;;;;;;;;;;;25128:107;23229:12;:10;:12::i;:::-;23218:23;;:7;:5;:7::i;:::-;:23;;;23210:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25205:22:::1;25211:7;25220:6;25205:5;:22::i;17356:269::-:0;17449:4;17466:129;17475:12;:10;:12::i;:::-;17489:7;17498:96;17537:15;17498:96;;;;;;;;;;;;;;;;;:11;:25;17510:12;:10;:12::i;:::-;17498:25;;;;;;;;;;;;;;;;;;-1:-1:-1;17498:25:0;;;:34;;;;;;;;;;;:96;:38;:96::i;14718:175::-;14804:4;14821:42;14831:12;:10;:12::i;:::-;14845:9;14856:6;14821:9;:42::i;14956:151::-;15072:18;;;;15045:7;15072:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;14956:151::o;23952:244::-;23229:12;:10;:12::i;:::-;23218:23;;:7;:5;:7::i;:::-;:23;;;23210:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24041:22:::1;::::0;::::1;24033:73;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24143:6;::::0;24122:38:::1;::::0;::::1;::::0;;::::1;::::0;24143:6:::1;::::0;::::1;;::::0;24122:38:::1;::::0;;;::::1;24171:6;:17:::0;;::::1;::::0;;::::1;;;::::0;;;::::1;::::0;;;::::1;::::0;;23952:244::o;605:106::-;693:10;605:106;:::o;20503:346::-;20605:19;;;20597:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20684:21;;;20676:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20757:18;;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;20809:32;;;;;;;;;;;;;;;;;20503:346;;;:::o;18115:539::-;18221:20;;;18213:70;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18302:23;;;18294:71;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18378:47;18399:6;18407:9;18418:6;18378:20;:47::i;:::-;18458:71;18480:6;18458:71;;;;;;;;;;;;;;;;;:17;;;:9;:17;;;;;;;;;;;;:71;:21;:71::i;:::-;18438:17;;;;:9;:17;;;;;;;;;;;:91;;;;18563:20;;;;;;;:32;;18588:6;18563:24;:32::i;:::-;18540:20;;;;:9;:20;;;;;;;;;;;;:55;;;;18611:35;;;;;;;18540:20;;18611:35;;;;;;;;;;;;;18115:539;;;:::o;9203:166::-;9289:7;9325:12;9317:6;;;;9309:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;9356:5:0;;;9203:166::o;6376:179::-;6434:7;6466:5;;;6490:6;;;;6482:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6546:1;6376:179;-1:-1:-1;;;6376:179:0:o;18936:378::-;19020:21;;;19012:65;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19090:49;19119:1;19123:7;19132:6;19090:20;:49::i;:::-;19167:12;;:24;;19184:6;19167:16;:24::i;:::-;19152:12;:39;19223:18;;;:9;:18;;;;;;;;;;;:30;;19246:6;19223:22;:30::i;:::-;19202:18;;;:9;:18;;;;;;;;;;;:51;;;;19269:37;;;;;;;19202:18;;:9;;19269:37;;;;;;;;;;18936:378;;:::o;19647:418::-;19731:21;;;19723:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19803:49;19824:7;19841:1;19845:6;19803:20;:49::i;:::-;19886:68;19909:6;19886:68;;;;;;;;;;;;;;;;;:18;;;:9;:18;;;;;;;;;;;;:68;:22;:68::i;:::-;19865:18;;;:9;:18;;;;;;;;;;:89;19980:12;;:24;;19997:6;19980:16;:24::i;:::-;19965:12;:39;20020:37;;;;;;;;20046:1;;20020:37;;;;;;;;;;;;;19647:418;;:::o;21882:92::-;;;;:::o;6838:158::-;6896:7;6929:1;6924;:6;;6916:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;6983:5:0;;;6838:158::o

Swarm Source

ipfs://dc0b3783223eeab2eb0fda514e03bff9f5ae07b96cb39eb0c6a9a44f0a1e4d70
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.