Contract 0x37d1ebc3af809b8fadb45dce7077efc629b2b5bb 3

 
 
Txn Hash Method
Block
From
To
Value [Txn Fee]
0xbc41db17911cac762be1479b484d102649b64f12370b4e1ff1ef47751d1fb62aApprove338101732022-10-01 21:01:061 day 23 hrs ago0xb38a4f3ab914bdbaa8a3f53b4322885984b6835f IN  0x37d1ebc3af809b8fadb45dce7077efc629b2b5bb0 MATIC0.0013960629 30.050000009
0x7cce8a7ccc62a8f8b1da0f9151a55b7056c29d954fa3170366130d1f777efcdcApprove331545702022-09-15 22:56:0017 days 21 hrs ago0xb38a4f3ab914bdbaa8a3f53b4322885984b6835f IN  0x37d1ebc3af809b8fadb45dce7077efc629b2b5bb0 MATIC0.0007264287 30.050000014
0xf331d6751eb2d88a158f6b28ebaa02ab37169987551875ae7b1cd5a92eb99291Approve330225102022-09-12 18:44:2721 days 2 hrs ago0xb22981ba3fe1de2325935c91a3b717168fb86714 IN  0x37d1ebc3af809b8fadb45dce7077efc629b2b5bb0 MATIC0.001612620037 34.711353001
0xa0efe2d63804ae42ecbbba17c1d3f0f528ebca3f20451aecc33217f0a8c36d90Approve328044132022-09-07 12:28:0326 days 8 hrs ago0xb38a4f3ab914bdbaa8a3f53b4322885984b6835f IN  0x37d1ebc3af809b8fadb45dce7077efc629b2b5bb0 MATIC0.001396062908 30.050000186
0x3041ad1960e65df361eaa9c563e629a5ccb16700349deede8e75f2009c3cd0ecApprove323439782022-08-26 13:32:0138 days 7 hrs ago0xb38a4f3ab914bdbaa8a3f53b4322885984b6835f IN  0x37d1ebc3af809b8fadb45dce7077efc629b2b5bb0 MATIC0.00118669231 49.089613258
0xa53192c1dc39ee621dc16196c2f8c48275d7fcc864501ad898d7522309aa662bApprove323409772022-08-26 11:26:5838 days 9 hrs ago0xb38a4f3ab914bdbaa8a3f53b4322885984b6835f IN  0x37d1ebc3af809b8fadb45dce7077efc629b2b5bb0 MATIC0.007956000789 171.251469918
0xeffeed61d0adec4f37d6e00e60ef80acbdd565ba42666d54cf4db994d0377bedApprove323030252022-08-25 10:43:0139 days 10 hrs ago0xb38a4f3ab914bdbaa8a3f53b4322885984b6835f IN  0x37d1ebc3af809b8fadb45dce7077efc629b2b5bb0 MATIC0.000775332911 32.073008653
0x94fe335c6f95870fcbf19f1a6ad0d1491d5adfb98fab287c068b0bbd8fbc5561Approve322960392022-08-25 6:29:5839 days 14 hrs ago0x740d618e92484b6f142e49b3644b26cc370232be IN  0x37d1ebc3af809b8fadb45dce7077efc629b2b5bb0 MATIC0.00139374 30.000000013
0x6094b7a2437d3d9cdde3ddafccc15a9d32d5a2d3a2646d1d94c417586e5522acApprove318755132022-08-14 9:17:1850 days 11 hrs ago0x116ceb3d8d258e2a97a1f05c901ef508809f55ec IN  0x37d1ebc3af809b8fadb45dce7077efc629b2b5bb0 MATIC0.00139374 30.000000012
0xee7685b977e11c227f290d6acf35ac6e9fb038bb3888b461346092e13bc8af0dApprove306547842022-07-12 20:51:5382 days 23 hrs ago0xb38a4f3ab914bdbaa8a3f53b4322885984b6835f IN  0x37d1ebc3af809b8fadb45dce7077efc629b2b5bb0 MATIC0.001406411094 30.272743009
0xf681a3593fd0996dc7a304397b7fb54e5baf401d8572c622df3298099326f031Approve299437412022-06-24 11:58:39101 days 8 hrs ago0x3ec269fa04127d2a9f6c37d2461eb3442373483c IN  0x37d1ebc3af809b8fadb45dce7077efc629b2b5bb0 MATIC0.001545704146 33.271000612
0xc66a78a5824f37a0806fef76c6414e050d9c730d3328d31a375cef33f130df57Approve299155672022-06-23 18:21:45102 days 2 hrs ago0xea96eddf997b45e22dd7cdb0ee45744f53e33693 IN  0x37d1ebc3af809b8fadb45dce7077efc629b2b5bb0 MATIC0.000725220099 30.0000041
0xd51041570ec1e9528b1f1841aa6d5a8b262161164b76c66c12b1929fe04e644dApprove292955742022-06-08 0:41:13117 days 20 hrs ago0xff75e131c711e4310c045317779d39b3b4f718c4 IN  0x37d1ebc3af809b8fadb45dce7077efc629b2b5bb0 MATIC0.000886187345 33.368000038
0x8219412819696d590a8058c3b992e6a97ea86cae422c97a300fc4505a0909d36Approve292955702022-06-08 0:40:57117 days 20 hrs ago0xff75e131c711e4310c045317779d39b3b4f718c4 IN  0x37d1ebc3af809b8fadb45dce7077efc629b2b5bb0 MATIC0.0015772491 33.95000001
0xd48d11caa75f64bc246fdde911932b3b5510f16c3e8147fdd26a38a98878cea8Transfer287690562022-05-25 22:36:35130 days 22 hrs ago0x8467f76ba0b033232e37c9b8cc4c28756400553a IN  0x37d1ebc3af809b8fadb45dce7077efc629b2b5bb0 MATIC0.001187840
0x9c32b2e015c71dd02ebab07d5d212445c66a67c9e7e8af5565c5b53085f484d4Transfer283595192022-05-15 19:29:25141 days 1 hr ago0x9a30c93e8c483b0082be78b1beb73a30ae187c23 IN  0x37d1ebc3af809b8fadb45dce7077efc629b2b5bb0 MATIC0.00332159371
0x6c27ae9f397c0d73c0643af7819be352b99de6e9adcc70dbf2fb70520bae5155Approve281358522022-05-10 3:05:44146 days 17 hrs ago0x8ee4afd8862b3b2e4c56e708d2cfa94b7b525db6 IN  0x37d1ebc3af809b8fadb45dce7077efc629b2b5bb0 MATIC0.005100714211
0xab2e53a938f8cf6f9efe52b29c8ac07b90513b174f97cc9433c6e0debd918a08Approve281336752022-05-10 1:46:25146 days 19 hrs ago0xd751ced587de8f2d61cc294293bdb937f1759d4c IN  0x37d1ebc3af809b8fadb45dce7077efc629b2b5bb0 MATIC0.00797742330
0x2fe0213cc446c9b8ec4a06350b87b03697ddd45a0fa261c42a8d4079e370078dApprove280483922022-05-07 22:09:07148 days 22 hrs ago0x7d0c62a79805600f2c751c4d4be01c9c5a7d0339 IN  0x37d1ebc3af809b8fadb45dce7077efc629b2b5bb0 MATIC0.003885292622 83.630217018
0x4050c1c361f5d9f564a456b61bc18485695f6062fa130d5e9bdf3801be5682e3Approve274670102022-04-23 3:43:17163 days 17 hrs ago0xd5aa05d319ad96e832e600561c9e17707f484c4d IN  0x37d1ebc3af809b8fadb45dce7077efc629b2b5bb0 MATIC0.001422836361 30.626293892
0xda9bfadc626ccd09248d8359298ab882ec93516450b51dcfa15c18001001beeaTransfer274126772022-04-21 19:09:14165 days 1 hr ago0x242e6fd94720e169f8078d8f08e1c3ab0b08cbea IN  0x37d1ebc3af809b8fadb45dce7077efc629b2b5bb0 MATIC0.001060405316 35.70989449
0x3505997bd37593526bd419c37fac408767799f4c4e90d139f519001a38eeb301Transfer274126672022-04-21 19:08:50165 days 1 hr ago0xf4c7685e996bbac45132ef41928494e05933e64e IN  0x37d1ebc3af809b8fadb45dce7077efc629b2b5bb0 MATIC0.001093920988 36.838558303
0x1ae07ceeef0d4be48d53e9b163f8b91100d150b6185a4a3a999942e7e10fe8c8Transfer274126252022-04-21 19:07:26165 days 1 hr ago0x49d9c379407e6d046cffea3cd74f38b5fb2537a3 IN  0x37d1ebc3af809b8fadb45dce7077efc629b2b5bb0 MATIC0.001099702546 37.033256322
0x079ff27aa809920e1701c1ad5470d50a1a6668300d0fef55f0ec464cdaf73c29Transfer274126072022-04-21 19:06:46165 days 1 hr ago0x21748c3df0d81089c25ec851f83189bed229a4a5 IN  0x37d1ebc3af809b8fadb45dce7077efc629b2b5bb0 MATIC0.001090868689 36.735769994
0x2a0382e91a82a6373f60d5c9a4c13b0cf3ce28ff1b4dd7e64ba0ef80132b4dccApprove264230162022-03-27 12:49:36190 days 8 hrs ago0x5ece1adeb045b45f1089abfed307919c5689a4b8 IN  0x37d1ebc3af809b8fadb45dce7077efc629b2b5bb0 MATIC0.00153867409333.119679998
[ Download CSV Export 
Parent Txn Hash Block From To Value
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
CombToken

Compiler Version
v0.7.6+commit.7338295f

Optimization Enabled:
Yes with 10000 runs

Other Settings:
default evmVersion, GNU GPLv3 license

Contract Source Code (Solidity)

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

// original repo: https://github.com/1hive/honeyswap-farm
// SPDX-License-Identifier: GPL-3.0-only

// File: @openzeppelin/contracts/utils/Context.sol
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/token/ERC20/IERC20.sol


pragma solidity ^0.7.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.7.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, 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;
    }
}

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


pragma solidity ^0.7.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_) {
        _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 { }
}

// File: contracts/XDaiCombToken.sol

pragma solidity ^0.7.6;


contract CombToken is ERC20 {
    constructor(string memory _name, string memory _symbol) ERC20(_name, _symbol) {
        // 1 million initial supply
        _mint(msg.sender, 10**6 * 1e18);
    }
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"string","name":"_name","type":"string"},{"internalType":"string","name":"_symbol","type":"string"}],"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":"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":[],"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":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","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"}]

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

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

000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000013506f6c79676f6e204e617469766520436f6d6200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000570434f4d42000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : _name (string): Polygon Native Comb
Arg [1] : _symbol (string): pCOMB

-----Encoded View---------------
6 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000040
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000080
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000013
Arg [3] : 506f6c79676f6e204e617469766520436f6d6200000000000000000000000000
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000005
Arg [5] : 70434f4d42000000000000000000000000000000000000000000000000000000


Deployed ByteCode Sourcemap

22435:203:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13493:91;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15639:169;;;;;;;;;;;;;;;;-1:-1:-1;15639:169:0;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;14592:108;;;:::i;:::-;;;;;;;;;;;;;;;;16290:321;;;;;;;;;;;;;;;;-1:-1:-1;16290:321:0;;;;;;;;;;;;;;;;;;:::i;14436:91::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;;17020:218;;;;;;;;;;;;;;;;-1:-1:-1;17020:218:0;;;;;;;;;:::i;14763:127::-;;;;;;;;;;;;;;;;-1:-1:-1;14763:127:0;;;;:::i;13703:95::-;;;:::i;17741:269::-;;;;;;;;;;;;;;;;-1:-1:-1;17741:269:0;;;;;;;;;:::i;15103:175::-;;;;;;;;;;;;;;;;-1:-1:-1;15103:175:0;;;;;;;;;:::i;15341:151::-;;;;;;;;;;;;;;;;-1:-1:-1;15341:151:0;;;;;;;;;;;:::i;13493:91::-;13571:5;13564:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13538:13;;13564:12;;13571:5;;13564:12;;13571:5;13564:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13493:91;:::o;15639:169::-;15722:4;15739:39;15748:12;:10;:12::i;:::-;15762:7;15771:6;15739:8;:39::i;:::-;-1:-1:-1;15796:4:0;15639:169;;;;:::o;14592:108::-;14680:12;;14592:108;:::o;16290:321::-;16396:4;16413:36;16423:6;16431:9;16442:6;16413:9;:36::i;:::-;16460:121;16469:6;16477:12;:10;:12::i;:::-;16491:89;16529:6;16491:89;;;;;;;;;;;;;;;;;:19;;;;;;;:11;:19;;;;;;16511:12;:10;:12::i;:::-;16491:33;;;;;;;;;;;;;-1:-1:-1;16491:33:0;;;:89;:37;:89::i;:::-;16460:8;:121::i;:::-;-1:-1:-1;16599:4:0;16290:321;;;;;:::o;14436:91::-;14510:9;;;;14436:91;:::o;17020:218::-;17108:4;17125:83;17134:12;:10;:12::i;:::-;17148:7;17157:50;17196:10;17157:11;:25;17169:12;:10;:12::i;:::-;17157:25;;;;;;;;;;;;;;;;;;-1:-1:-1;17157:25:0;;;:34;;;;;;;;;;;:38;:50::i;14763:127::-;14864:18;;14837:7;14864:18;;;;;;;;;;;;14763:127::o;13703:95::-;13783:7;13776:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13750:13;;13776:14;;13783:7;;13776:14;;13783:7;13776:14;;;;;;;;;;;;;;;;;;;;;;;;17741:269;17834:4;17851:129;17860:12;:10;:12::i;:::-;17874:7;17883:96;17922:15;17883:96;;;;;;;;;;;;;;;;;:11;:25;17895:12;:10;:12::i;:::-;17883:25;;;;;;;;;;;;;;;;;;-1:-1:-1;17883:25:0;;;:34;;;;;;;;;;;:96;:38;:96::i;15103:175::-;15189:4;15206:42;15216:12;:10;:12::i;:::-;15230:9;15241:6;15206:9;:42::i;15341:151::-;15457:18;;;;15430:7;15457:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;15341:151::o;6675:179::-;6733:7;6765:5;;;6789:6;;;;6781:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6845:1;6675:179;-1:-1:-1;;;6675:179:0:o;733:106::-;821:10;733:106;:::o;20888:346::-;20990:19;;;20982:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21069:21;;;21061:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21142:18;;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;21194:32;;;;;;;;;;;;;;;;;20888:346;;;:::o;18500:539::-;18606:20;;;18598:70;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18687:23;;;18679:71;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18763:47;18784:6;18792:9;18803:6;18763:20;:47::i;:::-;18843:71;18865:6;18843:71;;;;;;;;;;;;;;;;;:17;;;:9;:17;;;;;;;;;;;;:71;:21;:71::i;:::-;18823:17;;;;:9;:17;;;;;;;;;;;:91;;;;18948:20;;;;;;;:32;;18973:6;18948:24;:32::i;:::-;18925:20;;;;:9;:20;;;;;;;;;;;;:55;;;;18996:35;;;;;;;18925:20;;18996:35;;;;;;;;;;;;;18500:539;;;:::o;9502:166::-;9588:7;9624:12;9616:6;;;;9608:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;9655:5:0;;;9502:166::o;22267:92::-;;;;:::o

Swarm Source

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