Contract Overview
Balance:
1 CRO
CRO Value:
$0.15 (@ $0.15/CRO)
My Name Tag:
Not Available, login to update
Txn Hash | Method |
Block
|
From
|
To
|
Value | [Txn Fee] | |||
---|---|---|---|---|---|---|---|---|---|
0x941aafc1ba1fc6bb04f58c9b9653cbb20b9465091ee60785c5089c10aa979f85 | Transfer | 2234334 | 722 days 14 hrs ago | 0x0000098330357f1a147f7223fa53780cff15285c | IN | 0x2f02e5e6884ad4e03414336b4c28fd710a62c963 | 1 CRO | 0.1052 |
[ Download CSV Export ]
Latest 1 internal transaction
Parent Txn Hash | Block | From | To | Value | |||
---|---|---|---|---|---|---|---|
0x3cd469846bc3da8161d5d2f5229026234182b02222cd9e1906cea406191fde31 | 2234239 | 722 days 14 hrs ago | 0xe49b25e51a791306d2ce13d27922dea35aee3be9 | Contract Creation | 0 CRO |
[ Download CSV Export ]
This contract may be a proxy contract. Click on More Options and select Is this a proxy? to confirm and enable the "Read as Proxy" & "Write as Proxy" tabs.
Similar Match Source Code This contract matches the deployed Bytecode of the Source Code for Contract 0xa8855FdAdE3e74248FB799718f6CF80a67d35231 The constructor portion of the code might be different and could alter the actual behaviour of the contract
Contract Name:
DSProxy
Compiler Version
v0.5.17+commit.d19bba13
Contract Source Code (Solidity)
/** *Submitted for verification at cronoscan.com on 2022-04-06 */ /** *Submitted for verification at polygonscan.com on 2021-08-11 */ // SPDX-License-Identifier: AGPL-3.0-or-later /// ProxyRegistry.sol // Copyright (C) 2018-2021 Dai Foundation // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU Affero General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU Affero General Public License for more details. // // You should have received a copy of the GNU Affero General Public License // along with this program. If not, see <https://www.gnu.org/licenses/>. // SPDX-License-Identifier: GPL-3.0-or-later // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. pragma solidity >=0.4.23; contract DSTest { event log (string); event logs (bytes); event log_address (address); event log_bytes32 (bytes32); event log_int (int); event log_uint (uint); event log_bytes (bytes); event log_string (string); event log_named_address (string key, address val); event log_named_bytes32 (string key, bytes32 val); event log_named_decimal_int (string key, int val, uint decimals); event log_named_decimal_uint (string key, uint val, uint decimals); event log_named_int (string key, int val); event log_named_uint (string key, uint val); event log_named_bytes (string key, bytes val); event log_named_string (string key, string val); bool public IS_TEST = true; bool public failed; address constant HEVM_ADDRESS = address(bytes20(uint160(uint256(keccak256('hevm cheat code'))))); modifier mayRevert() { _; } modifier testopts(string memory) { _; } function fail() internal { failed = true; } modifier logs_gas() { uint startGas = gasleft(); _; uint endGas = gasleft(); emit log_named_uint("gas", startGas - endGas); } function assertTrue(bool condition) internal { if (!condition) { emit log("Error: Assertion Failed"); fail(); } } function assertTrue(bool condition, string memory err) internal { if (!condition) { emit log_named_string("Error", err); assertTrue(condition); } } function assertEq(address a, address b) internal { if (a != b) { emit log("Error: a == b not satisfied [address]"); emit log_named_address(" Expected", b); emit log_named_address(" Actual", a); fail(); } } function assertEq(address a, address b, string memory err) internal { if (a != b) { emit log_named_string ("Error", err); assertEq(a, b); } } function assertEq(bytes32 a, bytes32 b) internal { if (a != b) { emit log("Error: a == b not satisfied [bytes32]"); emit log_named_bytes32(" Expected", b); emit log_named_bytes32(" Actual", a); fail(); } } function assertEq(bytes32 a, bytes32 b, string memory err) internal { if (a != b) { emit log_named_string ("Error", err); assertEq(a, b); } } function assertEq32(bytes32 a, bytes32 b) internal { assertEq(a, b); } function assertEq32(bytes32 a, bytes32 b, string memory err) internal { assertEq(a, b, err); } function assertEq(int a, int b) internal { if (a != b) { emit log("Error: a == b not satisfied [int]"); emit log_named_int(" Expected", b); emit log_named_int(" Actual", a); fail(); } } function assertEq(int a, int b, string memory err) internal { if (a != b) { emit log_named_string("Error", err); assertEq(a, b); } } function assertEq(uint a, uint b) internal { if (a != b) { emit log("Error: a == b not satisfied [uint]"); emit log_named_uint(" Expected", b); emit log_named_uint(" Actual", a); fail(); } } function assertEq(uint a, uint b, string memory err) internal { if (a != b) { emit log_named_string("Error", err); assertEq(a, b); } } function assertEqDecimal(int a, int b, uint decimals) internal { if (a != b) { emit log("Error: a == b not satisfied [decimal int]"); emit log_named_decimal_int(" Expected", b, decimals); emit log_named_decimal_int(" Actual", a, decimals); fail(); } } function assertEqDecimal(int a, int b, uint decimals, string memory err) internal { if (a != b) { emit log_named_string("Error", err); assertEqDecimal(a, b, decimals); } } function assertEqDecimal(uint a, uint b, uint decimals) internal { if (a != b) { emit log("Error: a == b not satisfied [decimal uint]"); emit log_named_decimal_uint(" Expected", b, decimals); emit log_named_decimal_uint(" Actual", a, decimals); fail(); } } function assertEqDecimal(uint a, uint b, uint decimals, string memory err) internal { if (a != b) { emit log_named_string("Error", err); assertEqDecimal(a, b, decimals); } } function assertGt(uint a, uint b) internal { if (a <= b) { emit log("Error: a > b not satisfied [uint]"); emit log_named_uint(" Value a", a); emit log_named_uint(" Value b", b); fail(); } } function assertGt(uint a, uint b, string memory err) internal { if (a <= b) { emit log_named_string("Error", err); assertGt(a, b); } } function assertGt(int a, int b) internal { if (a <= b) { emit log("Error: a > b not satisfied [int]"); emit log_named_int(" Value a", a); emit log_named_int(" Value b", b); fail(); } } function assertGt(int a, int b, string memory err) internal { if (a <= b) { emit log_named_string("Error", err); assertGt(a, b); } } function assertGtDecimal(int a, int b, uint decimals) internal { if (a <= b) { emit log("Error: a > b not satisfied [decimal int]"); emit log_named_decimal_int(" Value a", a, decimals); emit log_named_decimal_int(" Value b", b, decimals); fail(); } } function assertGtDecimal(int a, int b, uint decimals, string memory err) internal { if (a <= b) { emit log_named_string("Error", err); assertGtDecimal(a, b, decimals); } } function assertGtDecimal(uint a, uint b, uint decimals) internal { if (a <= b) { emit log("Error: a > b not satisfied [decimal uint]"); emit log_named_decimal_uint(" Value a", a, decimals); emit log_named_decimal_uint(" Value b", b, decimals); fail(); } } function assertGtDecimal(uint a, uint b, uint decimals, string memory err) internal { if (a <= b) { emit log_named_string("Error", err); assertGtDecimal(a, b, decimals); } } function assertGe(uint a, uint b) internal { if (a < b) { emit log("Error: a >= b not satisfied [uint]"); emit log_named_uint(" Value a", a); emit log_named_uint(" Value b", b); fail(); } } function assertGe(uint a, uint b, string memory err) internal { if (a < b) { emit log_named_string("Error", err); assertGe(a, b); } } function assertGe(int a, int b) internal { if (a < b) { emit log("Error: a >= b not satisfied [int]"); emit log_named_int(" Value a", a); emit log_named_int(" Value b", b); fail(); } } function assertGe(int a, int b, string memory err) internal { if (a < b) { emit log_named_string("Error", err); assertGe(a, b); } } function assertGeDecimal(int a, int b, uint decimals) internal { if (a < b) { emit log("Error: a >= b not satisfied [decimal int]"); emit log_named_decimal_int(" Value a", a, decimals); emit log_named_decimal_int(" Value b", b, decimals); fail(); } } function assertGeDecimal(int a, int b, uint decimals, string memory err) internal { if (a < b) { emit log_named_string("Error", err); assertGeDecimal(a, b, decimals); } } function assertGeDecimal(uint a, uint b, uint decimals) internal { if (a < b) { emit log("Error: a >= b not satisfied [decimal uint]"); emit log_named_decimal_uint(" Value a", a, decimals); emit log_named_decimal_uint(" Value b", b, decimals); fail(); } } function assertGeDecimal(uint a, uint b, uint decimals, string memory err) internal { if (a < b) { emit log_named_string("Error", err); assertGeDecimal(a, b, decimals); } } function assertLt(uint a, uint b) internal { if (a >= b) { emit log("Error: a < b not satisfied [uint]"); emit log_named_uint(" Value a", a); emit log_named_uint(" Value b", b); fail(); } } function assertLt(uint a, uint b, string memory err) internal { if (a >= b) { emit log_named_string("Error", err); assertLt(a, b); } } function assertLt(int a, int b) internal { if (a >= b) { emit log("Error: a < b not satisfied [int]"); emit log_named_int(" Value a", a); emit log_named_int(" Value b", b); fail(); } } function assertLt(int a, int b, string memory err) internal { if (a >= b) { emit log_named_string("Error", err); assertLt(a, b); } } function assertLtDecimal(int a, int b, uint decimals) internal { if (a >= b) { emit log("Error: a < b not satisfied [decimal int]"); emit log_named_decimal_int(" Value a", a, decimals); emit log_named_decimal_int(" Value b", b, decimals); fail(); } } function assertLtDecimal(int a, int b, uint decimals, string memory err) internal { if (a >= b) { emit log_named_string("Error", err); assertLtDecimal(a, b, decimals); } } function assertLtDecimal(uint a, uint b, uint decimals) internal { if (a >= b) { emit log("Error: a < b not satisfied [decimal uint]"); emit log_named_decimal_uint(" Value a", a, decimals); emit log_named_decimal_uint(" Value b", b, decimals); fail(); } } function assertLtDecimal(uint a, uint b, uint decimals, string memory err) internal { if (a >= b) { emit log_named_string("Error", err); assertLtDecimal(a, b, decimals); } } function assertLe(uint a, uint b) internal { if (a > b) { emit log("Error: a <= b not satisfied [uint]"); emit log_named_uint(" Value a", a); emit log_named_uint(" Value b", b); fail(); } } function assertLe(uint a, uint b, string memory err) internal { if (a > b) { emit log_named_string("Error", err); assertLe(a, b); } } function assertLe(int a, int b) internal { if (a > b) { emit log("Error: a <= b not satisfied [int]"); emit log_named_int(" Value a", a); emit log_named_int(" Value b", b); fail(); } } function assertLe(int a, int b, string memory err) internal { if (a > b) { emit log_named_string("Error", err); assertLe(a, b); } } function assertLeDecimal(int a, int b, uint decimals) internal { if (a > b) { emit log("Error: a <= b not satisfied [decimal int]"); emit log_named_decimal_int(" Value a", a, decimals); emit log_named_decimal_int(" Value b", b, decimals); fail(); } } function assertLeDecimal(int a, int b, uint decimals, string memory err) internal { if (a > b) { emit log_named_string("Error", err); assertLeDecimal(a, b, decimals); } } function assertLeDecimal(uint a, uint b, uint decimals) internal { if (a > b) { emit log("Error: a <= b not satisfied [decimal uint]"); emit log_named_decimal_uint(" Value a", a, decimals); emit log_named_decimal_uint(" Value b", b, decimals); fail(); } } function assertLeDecimal(uint a, uint b, uint decimals, string memory err) internal { if (a > b) { emit log_named_string("Error", err); assertGeDecimal(a, b, decimals); } } function assertEq(string memory a, string memory b) internal { if (keccak256(abi.encodePacked(a)) != keccak256(abi.encodePacked(b))) { emit log("Error: a == b not satisfied [string]"); emit log_named_string(" Value a", a); emit log_named_string(" Value b", b); fail(); } } function assertEq(string memory a, string memory b, string memory err) internal { if (keccak256(abi.encodePacked(a)) != keccak256(abi.encodePacked(b))) { emit log_named_string("Error", err); assertEq(a, b); } } function checkEq0(bytes memory a, bytes memory b) internal pure returns (bool ok) { ok = true; if (a.length == b.length) { for (uint i = 0; i < a.length; i++) { if (a[i] != b[i]) { ok = false; } } } else { ok = false; } } function assertEq0(bytes memory a, bytes memory b) internal { if (!checkEq0(a, b)) { emit log("Error: a == b not satisfied [bytes]"); emit log_named_bytes(" Expected", a); emit log_named_bytes(" Actual", b); fail(); } } function assertEq0(bytes memory a, bytes memory b, string memory err) internal { if (!checkEq0(a, b)) { emit log_named_string("Error", err); assertEq0(a, b); } } } /// note.sol -- the `note' modifier, for logging calls as events // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. pragma solidity >=0.4.23; 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); } } // SPDX-License-Identifier: GNU-3 // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. pragma solidity >=0.4.23; interface DSAuthority { function canCall( address src, address dst, bytes4 sig ) external view returns (bool); } contract DSAuthEvents { event LogSetAuthority (address indexed authority); event LogSetOwner (address indexed owner); } contract DSAuth is DSAuthEvents { DSAuthority public authority; address public owner; constructor() public { owner = msg.sender; emit LogSetOwner(msg.sender); } function setOwner(address owner_) public auth { owner = owner_; emit LogSetOwner(owner); } function setAuthority(DSAuthority authority_) public auth { authority = authority_; emit LogSetAuthority(address(authority)); } modifier auth { require(isAuthorized(msg.sender, msg.sig), "ds-auth-unauthorized"); _; } function isAuthorized(address src, bytes4 sig) internal view returns (bool) { if (src == address(this)) { return true; } else if (src == owner) { return true; } else if (authority == DSAuthority(address(0))) { return false; } else { return authority.canCall(src, address(this), sig); } } } // proxy.sol - execute actions atomically through the proxy's identity // Copyright (C) 2017 DappHub, LLC // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. pragma solidity >=0.5.0 <0.6.0; // import "ds-auth/auth.sol"; // import "ds-note/note.sol"; // DSProxy // Allows code execution using a persistant identity This can be very // useful to execute a sequence of atomic actions. Since the owner of // the proxy can be changed, this allows for dynamic ownership models // i.e. a multisig contract DSProxy is DSAuth, DSNote { DSProxyCache public cache; // global cache for contracts constructor(address _cacheAddr) public { setCache(_cacheAddr); } function() external payable { } // use the proxy to execute calldata _data on contract _code function execute(bytes memory _code, bytes memory _data) public payable returns (address target, bytes memory response) { target = cache.read(_code); if (target == address(0)) { // deploy contract & store its address in cache target = cache.write(_code); } response = execute(target, _data); } function execute(address _target, bytes memory _data) public auth note payable returns (bytes memory response) { require(_target != address(0), "ds-proxy-target-address-required"); // call contract in current context assembly { let succeeded := delegatecall(sub(gas, 5000), _target, add(_data, 0x20), mload(_data), 0, 0) let size := returndatasize response := mload(0x40) mstore(0x40, add(response, and(add(add(size, 0x20), 0x1f), not(0x1f)))) mstore(response, size) returndatacopy(add(response, 0x20), 0, size) switch iszero(succeeded) case 1 { // throw if delegatecall failed revert(add(response, 0x20), size) } } } //set new cache function setCache(address _cacheAddr) public auth note returns (bool) { require(_cacheAddr != address(0), "ds-proxy-cache-address-required"); cache = DSProxyCache(_cacheAddr); // overwrite cache return true; } } // DSProxyFactory // This factory deploys new proxy instances through build() // Deployed proxy addresses are logged contract DSProxyFactory { event Created(address indexed sender, address indexed owner, address proxy, address cache); mapping(address=>bool) public isProxy; DSProxyCache public cache; constructor() public { cache = new DSProxyCache(); } // deploys a new proxy instance // sets owner of proxy to caller function build() public returns (address payable proxy) { proxy = build(msg.sender); } // deploys a new proxy instance // sets custom owner of proxy function build(address owner) public returns (address payable proxy) { proxy = address(new DSProxy(address(cache))); emit Created(msg.sender, owner, address(proxy), address(cache)); DSProxy(proxy).setOwner(owner); isProxy[proxy] = true; } } // DSProxyCache // This global cache stores addresses of contracts previously deployed // by a proxy. This saves gas from repeat deployment of the same // contracts and eliminates blockchain bloat. // By default, all proxies deployed from the same factory store // contracts in the same cache. The cache a proxy instance uses can be // changed. The cache uses the sha3 hash of a contract's bytecode to // lookup the address contract DSProxyCache { mapping(bytes32 => address) cache; function read(bytes memory _code) public view returns (address) { bytes32 hash = keccak256(_code); return cache[hash]; } function write(bytes memory _code) public returns (address target) { assembly { target := create(0, add(_code, 0x20), mload(_code)) switch iszero(extcodesize(target)) case 1 { // throw if contract failed to deploy revert(0, 0) } } bytes32 hash = keccak256(_code); cache[hash] = target; } } pragma solidity >=0.5.0; // This Registry deploys new proxy instances through DSProxyFactory.build(address) and keeps a registry of owner => proxy contract ProxyRegistry { mapping(address => DSProxy) public proxies; DSProxyFactory factory; constructor(address factory_) public { factory = DSProxyFactory(factory_); } // deploys a new proxy instance // sets owner of proxy to caller function build() public returns (address payable proxy) { proxy = build(msg.sender); } // deploys a new proxy instance // sets custom owner of proxy function build(address owner) public returns (address payable proxy) { require(proxies[owner] == DSProxy(0) || proxies[owner].owner() != owner); // Not allow new proxy if the user already has one and remains being the owner proxy = factory.build(owner); proxies[owner] = DSProxy(proxy); } }
[{"inputs":[{"internalType":"address","name":"_cacheAddr","type":"address"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"anonymous":true,"inputs":[{"indexed":true,"internalType":"bytes4","name":"sig","type":"bytes4"},{"indexed":true,"internalType":"address","name":"guy","type":"address"},{"indexed":true,"internalType":"bytes32","name":"foo","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"bar","type":"bytes32"},{"indexed":false,"internalType":"uint256","name":"wad","type":"uint256"},{"indexed":false,"internalType":"bytes","name":"fax","type":"bytes"}],"name":"LogNote","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"authority","type":"address"}],"name":"LogSetAuthority","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"}],"name":"LogSetOwner","type":"event"},{"payable":true,"stateMutability":"payable","type":"fallback"},{"constant":true,"inputs":[],"name":"authority","outputs":[{"internalType":"contract DSAuthority","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"cache","outputs":[{"internalType":"contract DSProxyCache","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_target","type":"address"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"execute","outputs":[{"internalType":"bytes","name":"response","type":"bytes"}],"payable":true,"stateMutability":"payable","type":"function"},{"constant":false,"inputs":[{"internalType":"bytes","name":"_code","type":"bytes"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"execute","outputs":[{"internalType":"address","name":"target","type":"address"},{"internalType":"bytes","name":"response","type":"bytes"}],"payable":true,"stateMutability":"payable","type":"function"},{"constant":true,"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"contract DSAuthority","name":"authority_","type":"address"}],"name":"setAuthority","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_cacheAddr","type":"address"}],"name":"setCache","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"owner_","type":"address"}],"name":"setOwner","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"}]
Deployed Bytecode
0x60806040526004361061007b5760003560e01c80637a9e5e4b1161004e5780637a9e5e4b146104775780638da5cb5b146104c8578063948f50761461051f578063bf7e214f146105885761007b565b806313af40351461007d5780631cff79cd146100ce5780631f6a1eb91461022257806360c7d29514610420575b005b34801561008957600080fd5b506100cc600480360360208110156100a057600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff1690602001909291905050506105df565b005b6101a7600480360360408110156100e457600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff1690602001909291908035906020019064010000000081111561012157600080fd5b82018360208201111561013357600080fd5b8035906020019184600183028401116401000000008311171561015557600080fd5b91908080601f016020809104026020016040519081016040528093929190818152602001838380828437600081840152601f19601f820116905080830192505050505050509192919290505050610728565b6040518080602001828103825283818151815260200191508051906020019080838360005b838110156101e75780820151818401526020810190506101cc565b50505050905090810190601f1680156102145780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b6103726004803603604081101561023857600080fd5b810190808035906020019064010000000081111561025557600080fd5b82018360208201111561026757600080fd5b8035906020019184600183028401116401000000008311171561028957600080fd5b91908080601f016020809104026020016040519081016040528093929190818152602001838380828437600081840152601f19601f820116905080830192505050505050509192919290803590602001906401000000008111156102ec57600080fd5b8201836020820111156102fe57600080fd5b8035906020019184600183028401116401000000008311171561032057600080fd5b91908080601f016020809104026020016040519081016040528093929190818152602001838380828437600081840152601f19601f82011690508083019250505050505050919291929050505061097a565b604051808373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200180602001828103825283818151815260200191508051906020019080838360005b838110156103e45780820151818401526020810190506103c9565b50505050905090810190601f1680156104115780820380516001836020036101000a031916815260200191505b50935050505060405180910390f35b34801561042c57600080fd5b50610435610bf3565b604051808273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390f35b34801561048357600080fd5b506104c66004803603602081101561049a57600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff169060200190929190505050610c19565b005b3480156104d457600080fd5b506104dd610d60565b604051808273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390f35b34801561052b57600080fd5b5061056e6004803603602081101561054257600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff169060200190929190505050610d86565b604051808215151515815260200191505060405180910390f35b34801561059457600080fd5b5061059d610fd2565b604051808273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390f35b61060d336000357fffffffff0000000000000000000000000000000000000000000000000000000016610ff7565b61067f576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260148152602001807f64732d617574682d756e617574686f72697a656400000000000000000000000081525060200191505060405180910390fd5b80600160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff167fce241d7ca1f669fee44b6fc00b8eba2df3bb514eed0f6f668f8f89096e81ed9460405160405180910390a250565b6060610758336000357fffffffff0000000000000000000000000000000000000000000000000000000016610ff7565b6107ca576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260148152602001807f64732d617574682d756e617574686f72697a656400000000000000000000000081525060200191505060405180910390fd5b600080600060043592506024359150349050600073ffffffffffffffffffffffffffffffffffffffff168673ffffffffffffffffffffffffffffffffffffffff16141561087f576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260208152602001807f64732d70726f78792d7461726765742d616464726573732d726571756972656481525060200191505060405180910390fd5b600080865160208801896113885a03f43d6040519550601f19601f6020830101168601604052808652806000602088013e8115600181146108bf576108c6565b8160208801fd5b50505081833373ffffffffffffffffffffffffffffffffffffffff166000357fffffffff00000000000000000000000000000000000000000000000000000000167bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19168460003660405180848152602001806020018281038252848482818152602001925080828437600081840152601f19601f82011690508083019250505094505050505060405180910390a450505092915050565b60006060600260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16638bf4515c856040518263ffffffff1660e01b81526004018080602001828103825283818151815260200191508051906020019080838360005b83811015610a0c5780820151818401526020810190506109f1565b50505050905090810190601f168015610a395780820380516001836020036101000a031916815260200191505b509250505060206040518083038186803b158015610a5657600080fd5b505afa158015610a6a573d6000803e3d6000fd5b505050506040513d6020811015610a8057600080fd5b81019080805190602001909291905050509150600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff161415610be057600260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16637ed0c3b2856040518263ffffffff1660e01b81526004018080602001828103825283818151815260200191508051906020019080838360005b83811015610b56578082015181840152602081019050610b3b565b50505050905090810190601f168015610b835780820380516001836020036101000a031916815260200191505b5092505050602060405180830381600087803b158015610ba257600080fd5b505af1158015610bb6573d6000803e3d6000fd5b505050506040513d6020811015610bcc57600080fd5b810190808051906020019092919050505091505b610bea8284610728565b90509250929050565b600260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b610c47336000357fffffffff0000000000000000000000000000000000000000000000000000000016610ff7565b610cb9576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260148152602001807f64732d617574682d756e617574686f72697a656400000000000000000000000081525060200191505060405180910390fd5b806000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055506000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff167f1abebea81bfa2637f28358c371278fb15ede7ea8dd28d2e03b112ff6d936ada460405160405180910390a250565b600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b6000610db6336000357fffffffff0000000000000000000000000000000000000000000000000000000016610ff7565b610e28576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260148152602001807f64732d617574682d756e617574686f72697a656400000000000000000000000081525060200191505060405180910390fd5b600080600060043592506024359150349050600073ffffffffffffffffffffffffffffffffffffffff168573ffffffffffffffffffffffffffffffffffffffff161415610edd576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252601f8152602001807f64732d70726f78792d63616368652d616464726573732d72657175697265640081525060200191505060405180910390fd5b84600260006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055506001935081833373ffffffffffffffffffffffffffffffffffffffff166000357fffffffff00000000000000000000000000000000000000000000000000000000167bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19168460003660405180848152602001806020018281038252848482818152602001925080828437600081840152601f19601f82011690508083019250505094505050505060405180910390a4505050919050565b6000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b60003073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff161415611036576001905061124a565b600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff161415611095576001905061124a565b600073ffffffffffffffffffffffffffffffffffffffff166000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1614156110f4576000905061124a565b6000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663b70096138430856040518463ffffffff1660e01b8152600401808473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020018373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001827bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19167bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19168152602001935050505060206040518083038186803b15801561120c57600080fd5b505afa158015611220573d6000803e3d6000fd5b505050506040513d602081101561123657600080fd5b810190808051906020019092919050505090505b9291505056fea265627a7a723158202c26a0efddc508e8fe88e2e44c61b34c801f30fbfabba550631808613eaa2b1564736f6c63430005110032
Deployed ByteCode Sourcemap
20743:1885:0:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18788:136;;8:9:-1;5:2;;;30:1;27;20:12;5:2;18788:136:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;18788:136:0;;;;;;;;;;;;;;;;;;;:::i;:::-;;21448:865;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;21448:865:0;;;;;;;;;;;;;;;;;;;;;21:11:-1;8;5:28;2:2;;;46:1;43;36:12;2:2;21448:865:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;21448:865:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;39:11;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;21448:865:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;93:3;85:6;81:16;74:27;137:4;133:9;126:4;121:3;117:14;113:30;106:37;;169:3;161:6;157:16;147:26;;21448:865:0;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;99:1;94:3;90:11;84:18;80:1;75:3;71:11;64:39;52:2;49:1;45:10;40:15;;8:100;;;12:14;21448:865:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21046:394;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;21046:394:0;;;;;;;;;;21:11:-1;8;5:28;2:2;;;46:1;43;36:12;2:2;21046:394:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;21046:394:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;39:11;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;21046:394:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;93:3;85:6;81:16;74:27;137:4;133:9;126:4;121:3;117:14;113:30;106:37;;169:3;161:6;157:16;147:26;;21046:394:0;;;;;;;;;;;;;;;;;21:11:-1;8;5:28;2:2;;;46:1;43;36:12;2:2;21046:394:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;21046:394:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;39:11;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;21046:394:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;93:3;85:6;81:16;74:27;137:4;133:9;126:4;121:3;117:14;113:30;106:37;;169:3;161:6;157:16;147:26;;21046:394:0;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;99:1;94:3;90:11;84:18;80:1;75:3;71:11;64:39;52:2;49:1;45:10;40:15;;8:100;;;12:14;21046:394:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20785:25;;8:9:-1;5:2;;;30:1;27;20:12;5:2;20785:25:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;18932:173;;8:9:-1;5:2;;;30:1;27;20:12;5:2;18932:173:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;18932:173:0;;;;;;;;;;;;;;;;;;;:::i;:::-;;18648:26;;8:9:-1;5:2;;;30:1;27;20:12;5:2;18648:26:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;22342:283;;8:9:-1;5:2;;;30:1;27;20:12;5:2;22342:283:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;22342:283:0;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;18611:30;;8:9:-1;5:2;;;30:1;27;20:12;5:2;18611:30:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;18788:136;19146:33;19159:10;19171:7;;;;19146:12;:33::i;:::-;19138:66;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18876:6;18868:5;;:14;;;;;;;;;;;;;;;;;;18910:5;;;;;;;;;;;18898:18;;;;;;;;;;;;18788:136;:::o;21448:865::-;21581:21;19146:33;19159:10;19171:7;;;;19146:12;:33::i;:::-;19138:66;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17283:11;17305;17327;17395:1;17382:15;17375:22;;17431:2;17418:16;17411:23;;17455:11;17448:18;;21647:1;21628:21;;:7;:21;;;;21620:66;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21858:1;21855;21847:5;21841:12;21834:4;21827:5;21823:16;21814:7;21807:4;21802:3;21798:14;21785:75;21886:14;21934:4;21928:11;21916:23;;22016:4;22012:9;22005:4;21998;21992;21988:15;21984:26;21980:42;21970:8;21966:57;21960:4;21953:71;22055:4;22045:8;22038:22;22113:4;22110:1;22103:4;22093:8;22089:19;22074:44;22148:9;22141:17;22177:1;22172:123;;;;22134:161;;22172:123;22275:4;22268;22258:8;22254:19;22247:33;22134:161;;21753:553;;17542:3;17537;17525:10;17508:53;;17516:7;;;;17508:53;;;17547:3;17552:8;;17508:53;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;93:3;85:6;81:16;74:27;137:4;133:9;126:4;121:3;117:14;113:30;106:37;;169:3;161:6;157:16;147:26;;17508:53:0;;;;;;;;;;;;;;;19215:1;;;21448:865;;;;:::o;21046:394::-;21154:14;21170:21;21218:5;;;;;;;;;;;:10;;;21229:5;21218:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;99:1;94:3;90:11;84:18;80:1;75:3;71:11;64:39;52:2;49:1;45:10;40:15;;8:100;;;12:14;21218:17:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;21218:17:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;21218:17:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;21218:17:0;;;;;;;;;;;;;;;;21209:26;;21268:1;21250:20;;:6;:20;;;21246:141;;;21357:5;;;;;;;;;;;:11;;;21369:5;21357:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;99:1;94:3;90:11;84:18;80:1;75:3;71:11;64:39;52:2;49:1;45:10;40:15;;8:100;;;12:14;21357:18:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;21357:18:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;21357:18:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;21357:18:0;;;;;;;;;;;;;;;;21348:27;;21246:141;21410:22;21418:6;21426:5;21410:7;:22::i;:::-;21399:33;;21046:394;;;;;:::o;20785:25::-;;;;;;;;;;;;;:::o;18932:173::-;19146:33;19159:10;19171:7;;;;19146:12;:33::i;:::-;19138:66;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19036:10;19024:9;;:22;;;;;;;;;;;;;;;;;;19086:9;;;;;;;;;;;19062:35;;;;;;;;;;;;18932:173;:::o;18648:26::-;;;;;;;;;;;;;:::o;22342:283::-;22442:4;19146:33;19159:10;19171:7;;;;19146:12;:33::i;:::-;19138:66;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17283:11;17305;17327;17395:1;17382:15;17375:22;;17431:2;17418:16;17411:23;;17455:11;17448:18;;22494:1;22472:24;;:10;:24;;;;22464:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22564:10;22543:5;;:32;;;;;;;;;;;;;;;;;;22613:4;22606:11;;17542:3;17537;17525:10;17508:53;;17516:7;;;;17508:53;;;17547:3;17552:8;;17508:53;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;93:3;85:6;81:16;74:27;137:4;133:9;126:4;121:3;117:14;113:30;106:37;;169:3;161:6;157:16;147:26;;17508:53:0;;;;;;;;;;;;;;;19215:1;;;22342:283;;;:::o;18611:30::-;;;;;;;;;;;;;:::o;19232:389::-;19302:4;19338;19323:20;;:3;:20;;;19319:295;;;19367:4;19360:11;;;;19319:295;19400:5;;;;;;;;;;;19393:12;;:3;:12;;;19389:225;;;19429:4;19422:11;;;;19389:225;19488:1;19455:36;;:9;;;;;;;;;;;:36;;;19451:163;;;19515:5;19508:12;;;;19451:163;19560:9;;;;;;;;;;;:17;;;19578:3;19591:4;19598:3;19560:42;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;19560:42:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;19560:42:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;19560:42:0;;;;;;;;;;;;;;;;19553:49;;19232:389;;;;;:::o
Swarm Source
bzzr://2c26a0efddc508e8fe88e2e44c61b34c801f30fbfabba550631808613eaa2b15
Age | Block | Fee Address | BC Fee Address | Voting Power | Jailed | Incoming |
---|
Make sure to use the "Vote Down" button for any spammy posts, and the "Vote Up" for interesting conversations.