Transaction Hash:
Block:
19660832 at Apr-15-2024 12:12:47 PM +UTC
Transaction Fee:
0.000324691362263092 ETH
$1.23
Gas Used:
26,668 Gas / 12.175317319 Gwei
Emitted Events:
339 |
DSToken.Approval( src=[Sender] 0x47f7ea0dd4418aa1cec00786f5c47623ac37ba42, guy=0x0eEe3E38...d1A9dF5ea, wad=0 )
|
Account State Difference:
Address | Before | After | State Difference | ||
---|---|---|---|---|---|
0x47F7EA0d...3aC37bA42 |
0.293846428196578266 Eth
Nonce: 1894
|
0.293521736834315174 Eth
Nonce: 1895
| 0.000324691362263092 | ||
0x95222290...5CC4BAfe5
Miner
| (beaverbuild) | 7.916175425377068377 Eth | 7.916176758777068377 Eth | 0.0000013334 | |
0xeb269732...D32a83549 |
Execution Trace
DSToken.approve( guy=0x0eEe3E3828A45f7601D5F54bF49bB01d1A9dF5ea, wad=0 ) => ( True )
approve[DSToken (ln:283)]
approve[DSToken (ln:285)]
pragma solidity ^0.5.2; contract DSMath { function add(uint x, uint y) internal pure returns (uint z) { require((z = x + y) >= x, "ds-math-add-overflow"); } function sub(uint x, uint y) internal pure returns (uint z) { require((z = x - y) <= x, "ds-math-sub-underflow"); } function mul(uint x, uint y) internal pure returns (uint z) { require(y == 0 || (z = x * y) / y == x, "ds-math-mul-overflow"); } function div(uint x, uint y) internal pure returns (uint z) { require(y > 0, "ds-math-div-overflow"); z = x / y; } function min(uint x, uint y) internal pure returns (uint z) { return x <= y ? x : y; } function max(uint x, uint y) internal pure returns (uint z) { return x >= y ? x : y; } // function imin(int x, int y) internal pure returns (int z) { // return x <= y ? x : y; // } // function imax(int x, int y) internal pure returns (int z) { // return x >= y ? x : y; // } uint constant WAD = 10 ** 18; // uint constant RAY = 10 ** 27; // function wmul(uint x, uint y) internal pure returns (uint z) { // z = add(mul(x, y), WAD / 2) / WAD; // } // function rmul(uint x, uint y) internal pure returns (uint z) { // z = add(mul(x, y), RAY / 2) / RAY; // } function wdiv(uint x, uint y) internal pure returns (uint z) { z = add(mul(x, WAD), y / 2) / y; } // function rdiv(uint x, uint y) internal pure returns (uint z) { // z = add(mul(x, RAY), y / 2) / y; // } // This famous algorithm is called "exponentiation by squaring" // and calculates x^n with x as fixed-point and n as regular unsigned. // // It's O(log n), instead of O(n) for naive repeated multiplication. // // These facts are why it works: // // If n is even, then x^n = (x^2)^(n/2). // If n is odd, then x^n = x * x^(n-1), // and applying the equation for even x gives // x^n = x * (x^2)^((n-1) / 2). // // Also, EVM division is flooring and // floor[(n-1) / 2] = floor[n / 2]. // // function rpow(uint _x, uint n) internal pure returns (uint z) { // uint x = _x; // z = n % 2 != 0 ? x : RAY; // for (n /= 2; n != 0; n /= 2) { // x = rmul(x, x); // if (n % 2 != 0) { // z = rmul(z, x); // } // } // } /** * @dev x to the power of y power(base, exponent) */ function pow(uint256 base, uint256 exponent) public pure returns (uint256) { if (exponent == 0) { return 1; } else if (exponent == 1) { return base; } else if (base == 0 && exponent != 0) { return 0; } else { uint256 z = base; for (uint256 i = 1; i < exponent; i++) z = mul(z, base); return z; } } } contract DSAuthEvents { event LogSetAuthority (address indexed authority); event LogSetOwner (address indexed owner); } contract DSAuth is DSAuthEvents { address public authority; address public owner; constructor() public { owner = msg.sender; emit LogSetOwner(msg.sender); } function setOwner(address owner_) public onlyOwner { require(owner_ != address(0), "invalid owner address"); owner = owner_; emit LogSetOwner(owner); } function setAuthority(address authority_) public onlyOwner { authority = authority_; emit LogSetAuthority(address(authority)); } modifier auth { require(isAuthorized(msg.sender), "ds-auth-unauthorized"); _; } modifier onlyOwner { require(isOwner(msg.sender), "ds-auth-non-owner"); _; } function isOwner(address src) public view returns (bool) { return bool(src == owner); } function isAuthorized(address src) internal view returns (bool) { if (src == address(this)) { return true; } else if (src == owner) { return true; } else if (authority == address(0)) { return false; } else if (src == authority) { return true; } else { return false; } } } contract DSNote { event LogNote( bytes4 indexed sig, address indexed guy, bytes32 indexed foo, bytes32 indexed bar, uint256 wad, bytes fax ) anonymous; modifier note { bytes32 foo; bytes32 bar; uint256 wad; assembly { foo := calldataload(4) bar := calldataload(36) wad := callvalue } emit LogNote(msg.sig, msg.sender, foo, bar, wad, msg.data); _; } } contract DSStop is DSNote, DSAuth, DSMath { bool public stopped; modifier stoppable { require(!stopped, "ds-stop-is-stopped"); _; } function stop() public onlyOwner note { stopped = true; } function start() public onlyOwner note { stopped = false; } } contract ERC20Events { event Approval(address indexed src, address indexed guy, uint wad); event Transfer(address indexed src, address indexed dst, uint wad); } contract ERC20 is ERC20Events { function totalSupply() public view returns (uint); function balanceOf(address guy) public view returns (uint); function allowance(address src, address guy) public view returns (uint); function approve(address guy, uint wad) public returns (bool); function transfer(address dst, uint wad) public returns (bool); function transferFrom(address src, address dst, uint wad) public returns (bool); } contract DSTokenBase is ERC20, DSMath { uint256 _supply; mapping (address => uint256) _balances; mapping (address => mapping (address => uint256)) _approvals; constructor(uint supply) public { _supply = supply; } function totalSupply() public view returns (uint) { return _supply; } function balanceOf(address src) public view returns (uint) { return _balances[src]; } function allowance(address src, address guy) public view returns (uint) { return _approvals[src][guy]; } function transfer(address dst, uint wad) public returns (bool) { return transferFrom(msg.sender, dst, wad); } function transferFrom(address src, address dst, uint wad) public returns (bool) { if (src != msg.sender) { require(_approvals[src][msg.sender] >= wad, "ds-token-insufficient-approval"); _approvals[src][msg.sender] = sub(_approvals[src][msg.sender], wad); } require(_balances[src] >= wad, "ds-token-insufficient-balance"); _balances[src] = sub(_balances[src], wad); _balances[dst] = add(_balances[dst], wad); emit Transfer(src, dst, wad); return true; } function approve(address guy, uint wad) public returns (bool) { _approvals[msg.sender][guy] = wad; emit Approval(msg.sender, guy, wad); return true; } } contract DSToken is DSTokenBase(0), DSStop { bytes32 public name = ""; bytes32 public symbol; uint256 public decimals = 18; constructor(bytes32 symbol_) public { symbol = symbol_; } function setName(bytes32 name_) public onlyOwner { name = name_; } function approvex(address guy) public stoppable returns (bool) { return super.approve(guy, uint(-1)); } function approve(address guy, uint wad) public stoppable returns (bool) { require(_approvals[msg.sender][guy] == 0 || wad == 0); //take care of re-approve. return super.approve(guy, wad); } function transferFrom(address src, address dst, uint wad) public stoppable returns (bool) { if (src != msg.sender && _approvals[src][msg.sender] != uint(-1)) { require(_approvals[src][msg.sender] >= wad, "ds-token-insufficient-approval"); _approvals[src][msg.sender] = sub(_approvals[src][msg.sender], wad); } require(_balances[src] >= wad, "ds-token-insufficient-balance"); _balances[src] = sub(_balances[src], wad); _balances[dst] = add(_balances[dst], wad); emit Transfer(src, dst, wad); return true; } function mint(address guy, uint wad) public auth stoppable { _mint(guy, wad); } function burn(address guy, uint wad) public auth stoppable { _burn(guy, wad); } function _mint(address guy, uint wad) internal { require(guy != address(0), "ds-token-mint: mint to the zero address"); _balances[guy] = add(_balances[guy], wad); _supply = add(_supply, wad); emit Transfer(address(0), guy, wad); } function _burn(address guy, uint wad) internal { require(guy != address(0), "ds-token-burn: burn from the zero address"); require(_balances[guy] >= wad, "ds-token-insufficient-balance"); if (guy != msg.sender && _approvals[guy][msg.sender] != uint(-1)) { require(_approvals[guy][msg.sender] >= wad, "ds-token-insufficient-approval"); _approvals[guy][msg.sender] = sub(_approvals[guy][msg.sender], wad); } _balances[guy] = sub(_balances[guy], wad); _supply = sub(_supply, wad); emit Transfer(guy, address(0), wad); } }