Transaction Hash:
Block:
15343736 at Aug-15-2022 03:36:51 AM +UTC
Transaction Fee:
0.00318623454669156 ETH
$9.78
Gas Used:
235,690 Gas / 13.518751524 Gwei
Emitted Events:
238 |
0xa9d1e08c7793af67e9d92fe308d5697fb81d3e43.0xdc386723e55a1ab06e0a64036ce7bb4fd1e1aea21f6def62d2d577e9d12f9dfc( 0xdc386723e55a1ab06e0a64036ce7bb4fd1e1aea21f6def62d2d577e9d12f9dfc, 0x0000000000000000000000007bef710a5759d197ec0bf621c3df802c2d60d848, 00000000000000000000000000000000000000000000000000571aa9e6ee5000, 000000000000000000000000000000000000000000000000000000000000000a, 0000000000000000000000000000000000000000000000000000000000000060, 0000000000000000000000000000000000000000000000000000000000000019, 6e6f20726561736f6e20737472696e672070726f766964656400000000000000 )
|
Account State Difference:
Address | Before | After | State Difference | ||
---|---|---|---|---|---|
0x01a61eF2...220D37093 | 0.005463422242548967 Eth | 0.021549812242548967 Eth | 0.01608639 | ||
0x11a46824...a12ae6b88 | 0.004187565005180941 Eth | 0.052080245005180941 Eth | 0.04789268 | ||
0x17fCdAD8...5Ea39D73A | 0.004709640144309743 Eth | 0.191468770144309743 Eth | 0.18675913 | ||
0x1eA8E0E5...05d4AB503 | 0.113619392420209252 Eth | 0.363619392420209252 Eth | 0.25 | ||
0x2DaA3596...79C930E5e
Miner
| (Poolin 2) | 226.072953779909288885 Eth | 226.073425159909288885 Eth | 0.00047138 | |
0x2f4f2F3D...783E55751 | 0.05098530841804652 Eth | 0.11323320841804652 Eth | 0.0622479 | ||
0x61018075...c32faaAcF | 1.285 Eth | 1.335 Eth | 0.05 | ||
0x714710e4...94ec9d0e7 | 0.06959597 Eth | 0.07912301 Eth | 0.00952704 | ||
0x7830c87C...31FA86F43 | (Coinbase: Deposit) |
82.226497931649378953 Eth
Nonce: 47768
|
82.223311697102687393 Eth
Nonce: 47769
| 0.00318623454669156 | |
0x7F22A4B1...DbB5C726D | 0.000390947202622246 Eth | 0.015327847202622246 Eth | 0.0149369 | ||
0x975E3284...Ed7Bf7572 | 0 Eth | 0.06671734 Eth | 0.06671734 | ||
0x9e8ddcEB...849E46771 | 0.001894265148298488 Eth | 0.020423075148298488 Eth | 0.01852881 | ||
0x9f0a5c77...Ed54fD980 | 0.006491442092069903 Eth | 0.256813732092069903 Eth | 0.25032229 | ||
0xA9D1e08C...FB81d3E43 | (Coinbase 10) | 19,956.469166117649957097 Eth | 19,955.364961547649957097 Eth | 1.10420457 | |
0xaE506232...468eABd03 | 2.89697641379732081 Eth | 2.94916171379732081 Eth | 0.0521853 | ||
0xb60beF47...04ee05212 | 0.5816968 Eth | 0.60021564 Eth | 0.01851884 | ||
0xC07942aA...72e4C8144 | 0.006237684637020984 Eth | 0.033627114637020984 Eth | 0.02738943 | ||
0xd1a36aD7...993d221Cc | 0.095765292986896039 Eth | 0.105765292986896039 Eth | 0.01 | ||
0xE747e5F8...122Ecc299 | 0 Eth | 0.00113532 Eth | 0.00113532 | ||
0xe8957158...819e40709 | 0.001130089304082484 Eth | 0.004282569304082484 Eth | 0.00315248 | ||
0xFc95E264...eC1DAeF04 | 0.002628092474185652 Eth | 0.012584992474185652 Eth | 0.0099569 | ||
0xFe66F703...34aD5f679 | 0.000827021459477268 Eth | 0.009674841459477268 Eth | 0.00884782 |
Execution Trace
Coinbase 10.1a1da075( )
- ETH 0.00113532
0xe747e5f8691257141b1f4568e65a6fa122ecc299.CALL( )
- ETH 0.00315248
0xe89571589d610f9d6ef8c04d13fdea1819e40709.CALL( )
- ETH 0.00884782
0xfe66f70387047921a8cdb0fcdeedf9d34ad5f679.CALL( )
- ETH 0.00952704
0x714710e485048da0010de2960bcb15194ec9d0e7.CALL( )
- ETH 0.0099569
0xfc95e264601734dace9ffc52683cf68ec1daef04.CALL( )
- ETH 0.01
0xd1a36ad7ebb4378408e02f51fe7588b993d221cc.CALL( )
- ETH 0.0149369
0x7f22a4b1f6b83302490fd19ce90518cdbb5c726d.CALL( )
- ETH 0.01608639
0x01a61ef2b7532882ee53e42e95aa89f220d37093.CALL( )
- ETH 0.01851884
0xb60bef473b7c9487ed964629d028c1304ee05212.CALL( )
- ETH 0.01852881
0x9e8ddceb9b1d279ddb80fd2f3079580849e46771.CALL( )
- ETH 0.02451764
ERC20.CALL( )
- ETH 0.02738943
0xc07942aa0311106e80ad0314f7c8f6c72e4c8144.CALL( )
- ETH 0.04789268
0x11a46824880b9ced58d831d1befedf9a12ae6b88.CALL( )
- ETH 0.05
0x610180750a1d2d0326bab5dface6f62c32faaacf.CALL( )
- ETH 0.0521853
0xae5062325f01eb99e6a17faee828de9468eabd03.CALL( )
- ETH 0.0622479
0x2f4f2f3d2c7a5e9171194837015ce6b783e55751.CALL( )
- ETH 0.06671734
0x975e3284b0b9f049f2edad6b5b4ce8eed7bf7572.CALL( )
- ETH 0.18675913
0x17fcdad8e6fcec87103dc4e88a5597d5ea39d73a.CALL( )
- ETH 0.25
0x1ea8e0e5851b6c1e7e4cc12d74dfe6b05d4ab503.CALL( )
- ETH 0.25032229
0x9f0a5c774a2d4fe90bc03a413a40e77ed54fd980.CALL( )
// SPDX-License-Identifier: MIT pragma solidity 0.7.3; contract Owned { address public owner; address public pendingOwner; modifier onlyOwner { require(msg.sender == owner); _; } modifier onlyPendingOwner { require(msg.sender == pendingOwner); _; } constructor() { owner = msg.sender; } //@dev proposes new manager ownership function transferOwnership(address newOwner) public onlyOwner { pendingOwner = newOwner; } //@dev pending owner must accept it to prevent changing to a wallet who lost their key function acceptOwnership() public onlyPendingOwner { owner = pendingOwner; } } /** * @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 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 IERC20, Owned { mapping (address => uint256) private _balances; mapping (address => mapping (address => uint256)) private _allowances; uint256 private _totalSupply; string private _name; string private _symbol; uint256 immutable private _cap = 500000000000000000000000000; // 0.5 billion /** * @dev Sets the values for {name} and {symbol}. * * The defaut value of {decimals} is 18. To select a different value for * {decimals} you should overload it. * * All two of these values are immutable: they can only be set once during * construction. */ constructor (string memory name_, string memory symbol_) { _name = name_; _symbol = symbol_; } /** * @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(msg.sender, 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(msg.sender, 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); uint256 currentAllowance = _allowances[sender][msg.sender]; require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance"); _approve(sender, msg.sender, currentAllowance - amount); 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(msg.sender, spender, _allowances[msg.sender][spender] + 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) { uint256 currentAllowance = _allowances[msg.sender][spender]; require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero"); _approve(msg.sender, spender, currentAllowance - subtractedValue); 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); uint256 senderBalance = _balances[sender]; require(senderBalance >= amount, "ERC20: transfer amount exceeds balance"); _balances[sender] = senderBalance - amount; _balances[recipient] += 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) public onlyOwner virtual { require(account != address(0), "ERC20: mint to the zero address"); require(totalSupply() + amount <= cap(), "ERC20Capped: cap exceeded"); _beforeTokenTransfer(address(0), account, amount); _totalSupply += amount; _balances[account] += amount; emit Transfer(address(0), account, 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 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 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 this function is * overloaded; * * 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 pure returns (uint8) { return 18; } /** * @dev Returns the cap on the token's total supply. */ function cap() public view virtual returns (uint256) { return _cap; } }