Contract 0xa0446d8804611944f1b527ecd37d7dcbe442caba 17
Contract Overview
My Name Tag:
Not Available
[ Download CSV Export ]
Latest 25 internal transaction
[ Download CSV Export ]
Contract Name:
GovernanceLeftoverExchanger
Compiler Version
v0.6.12+commit.27d51765
Contract Source Code (Solidity)
/** *Submitted for verification at Arbiscan.io on 2021-09-13 */ // File: @openzeppelin/contracts/GSN/Context.sol // SPDX-License-Identifier: MIT pragma solidity ^0.6.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/access/Ownable.sol pragma solidity ^0.6.0; /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * By default, the owner account will be the one that deploys the contract. This * can later be changed with {transferOwnership}. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ constructor () internal { address msgSender = _msgSender(); _owner = msgSender; emit OwnershipTransferred(address(0), msgSender); } /** * @dev Returns the address of the current owner. */ function owner() public view returns (address) { return _owner; } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { require(_owner == _msgSender(), "Ownable: caller is not the owner"); _; } /** * @dev Leaves the contract without owner. It will not be possible to call * `onlyOwner` functions anymore. Can only be called by the current owner. * * NOTE: Renouncing ownership will leave the contract without an owner, * thereby removing any functionality that is only available to the owner. */ function renounceOwnership() public virtual onlyOwner { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Can only be called by the current owner. */ function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } } // File: @openzeppelin/contracts/math/SafeMath.sol pragma solidity ^0.6.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, 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) { return sub(a, b, "SafeMath: subtraction overflow"); } /** * @dev Returns the subtraction of two unsigned integers, reverting with custom message on * overflow (when the result is negative). * * 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); uint256 c = a - b; return c; } /** * @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) { // 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 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } /** * @dev Returns the integer division of two unsigned integers. Reverts 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) { return div(a, b, "SafeMath: division by zero"); } /** * @dev Returns the integer division of two unsigned integers. Reverts with custom message 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, string memory errorMessage) internal pure returns (uint256) { require(b > 0, errorMessage); uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * Reverts 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) { return mod(a, b, "SafeMath: modulo by zero"); } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * Reverts with custom message 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, string memory errorMessage) internal pure returns (uint256) { require(b != 0, errorMessage); return a % b; } } // File: @openzeppelin/contracts/token/ERC20/IERC20.sol pragma solidity ^0.6.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: contracts/helpers/UniERC20.sol pragma solidity ^0.6.12; library UniERC20 { using SafeMath for uint256; IERC20 private constant _ETH_ADDRESS = IERC20(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE); IERC20 private constant _ZERO_ADDRESS = IERC20(0); function isETH(IERC20 token) internal pure returns (bool) { return (token == _ZERO_ADDRESS || token == _ETH_ADDRESS); } function uniBalanceOf(IERC20 token, address account) internal view returns (uint256) { if (isETH(token)) { return account.balance; } else { return token.balanceOf(account); } } function uniTransfer(IERC20 token, address payable to, uint256 amount) internal { if (amount > 0) { if (isETH(token)) { to.transfer(amount); } else { _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, amount)); } } } function uniApprove(IERC20 token, address to, uint256 amount) internal { require(!isETH(token), "Approve called on ETH"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = address(token).call(abi.encodeWithSelector(token.approve.selector, to, amount)); if (!success || (returndata.length > 0 && !abi.decode(returndata, (bool)))) { _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, to, 0)); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, to, amount)); } } function _callOptionalReturn(IERC20 token, bytes memory data) private { // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = address(token).call(data); require(success, "low-level call failed"); if (returndata.length > 0) { // Return data is optional require(abi.decode(returndata, (bool)), "ERC20 operation did not succeed"); } } } // File: contracts/GovernanceLeftoverExchanger.sol pragma solidity ^0.6.12; pragma experimental ABIEncoderV2; contract GovernanceLeftoverExchanger is Ownable { using UniERC20 for IERC20; event Action (bool success, address to, bytes result); struct Call { address to; uint256 value; bytes data; } receive() external payable {} // payable for paths with 0x function makeCallsNoThrow(Call[] calldata calls) external payable onlyOwner { uint256 startGas = gasleft(); for (uint i = 0; i < calls.length; i++) { (bool ok, bytes memory result) = calls[i].to.call{value : calls[i].value}(calls[i].data); emit Action(ok, calls[i].to, result); } uint256 gasRefund = (startGas - gasleft() + 21000 + (msg.data.length * 7) + 2000) * tx.gasprice; if (address(this).balance >= gasRefund) { tx.origin.transfer(gasRefund); } } // payable for paths with 0x function makeCalls(Call[] calldata calls) external payable onlyOwner { for (uint i = 0; i < calls.length; i++) { (bool ok,) = calls[i].to.call{value : calls[i].value}(calls[i].data); require(ok, "swap failed"); } } function rescueFunds(IERC20 token, uint256 amount) external onlyOwner { token.uniTransfer(msg.sender, amount); } }
[{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bool","name":"success","type":"bool"},{"indexed":false,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"bytes","name":"result","type":"bytes"}],"name":"Action","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"inputs":[{"components":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"internalType":"struct GovernanceLeftoverExchanger.Call[]","name":"calls","type":"tuple[]"}],"name":"makeCalls","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"internalType":"struct GovernanceLeftoverExchanger.Call[]","name":"calls","type":"tuple[]"}],"name":"makeCallsNoThrow","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"rescueFunds","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]
Contract Creation Code
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
Deployed Bytecode
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
Deployed ByteCode Sourcemap
13709:1309:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14025:551;;;;;;:::i;:::-;;:::i;:::-;;2745:148;;;;;;;;;;;;;:::i;14618:263::-;;;;;;:::i;:::-;;:::i;14889:126::-;;;;;;;;;;-1:-1:-1;14889:126:0;;;;;:::i;:::-;;:::i;2103:79::-;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3048:244;;;;;;;;;;-1:-1:-1;3048:244:0;;;;;:::i;:::-;;:::i;14025:551::-;2325:12;:10;:12::i;:::-;2315:6;;:22;:6;;;:22;;;2307:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;14112:16:::1;14131:9;14112:28;;14156:6;14151:206;14168:16:::0;;::::1;14151:206;;;14207:7;14216:19;14239:5;;14245:1;14239:8;;;;;;;;;;;;;;;;;;:::i;:::-;:11;::::0;::::1;::::0;::::1;::::0;::::1;:::i;:::-;:16;;14264:5;;14270:1;14264:8;;;;;;;;;;;;;;;;;;:::i;:::-;:14;;;14280:5;;14286:1;14280:8;;;;;;;;;;;;;;;;;;:::i;:::-;:13;::::0;::::1;::::0;::::1;::::0;::::1;:::i;:::-;14239:55;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14206:88;;;;14314:31;14321:2;14325:5;;14331:1;14325:8;;;;;;;;;;;;;;;;;;:::i;:::-;:11;::::0;::::1;::::0;::::1;::::0;::::1;:::i;:::-;14338:6;14314:31;;;;;;;;:::i;:::-;;;;;;;;-1:-1:-1::0;;14186:3:0::1;;14151:206;;;-1:-1:-1::0;14367:17:0::1;14451:11;14438:1;14420:8;:19;14399:9;14388:8;:20;14411:5;14388:28;:52;14443:4;14388:59;14387:75;14367:95;;14502:9;14477:21;:34;14473:96;;14528:29;::::0;:9:::1;::::0;:29;::::1;;;::::0;14547:9;;14528:29:::1;::::0;;;14547:9;14528;:29;::::1;;;;;;;;;;;;;::::0;::::1;;;;;;14473:96;2385:1;;14025:551:::0;;:::o;2745:148::-;2325:12;:10;:12::i;:::-;2315:6;;:22;:6;;;:22;;;2307:67;;;;;;;;;;;;:::i;:::-;2852:1:::1;2836:6:::0;;2815:40:::1;::::0;::::1;2836:6:::0;;::::1;::::0;2815:40:::1;::::0;2852:1;;2815:40:::1;2883:1;2866:19:::0;;;::::1;::::0;;2745:148::o;14618:263::-;2325:12;:10;:12::i;:::-;2315:6;;:22;:6;;;:22;;;2307:67;;;;;;;;;;;;:::i;:::-;14703:6:::1;14698:176;14715:16:::0;;::::1;14698:176;;;14754:7;14766:5;;14772:1;14766:8;;;;;;;;;;;;;;;;;;:::i;:::-;:11;::::0;::::1;::::0;::::1;::::0;::::1;:::i;:::-;:16;;14791:5;;14797:1;14791:8;;;;;;;;;;;;;;;;;;:::i;:::-;:14;;;14807:5;;14813:1;14807:8;;;;;;;;;;;;;;;;;;:::i;:::-;:13;::::0;::::1;::::0;::::1;::::0;::::1;:::i;:::-;14766:55;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14753:68;;;14844:2;14836:26;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;14733:3:0::1;;14698:176;;;;14618:263:::0;;:::o;14889:126::-;2325:12;:10;:12::i;:::-;2315:6;;:22;:6;;;:22;;;2307:67;;;;;;;;;;;;:::i;:::-;14970:37:::1;:17;::::0;::::1;14988:10;15000:6:::0;14970:17:::1;:37::i;:::-;14889:126:::0;;:::o;2103:79::-;2141:7;2168:6;;;2103:79;:::o;3048:244::-;2325:12;:10;:12::i;:::-;2315:6;;:22;:6;;;:22;;;2307:67;;;;;;;;;;;;:::i;:::-;3137:22:::1;::::0;::::1;3129:73;;;;;;;;;;;;:::i;:::-;3239:6;::::0;;3218:38:::1;::::0;::::1;::::0;;::::1;::::0;3239:6;::::1;::::0;3218:38:::1;::::0;::::1;3267:6;:17:::0;;;::::1;;::::0;;;::::1;::::0;;;::::1;::::0;;3048:244::o;657:106::-;745:10;657:106;:::o;12158:340::-;12253:10;;12249:242;;12284:12;12290:5;12284;:12::i;:::-;12280:200;;;12317:19;;:11;;;;:19;;;;;12329:6;;12317:19;;;;12329:6;12317:11;:19;;;;;;;;;;;;;;;;;;;;;12280:200;;;12377:87;12397:5;12427:23;;;12452:2;12456:6;12404:59;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12377:19;:87::i;11775:133::-;11827:4;11852:22;;;;;:47;;-1:-1:-1;11878:21:0;;;11667:42;11878:21;11852:47;11844:56;11775:133;-1:-1:-1;;11775:133:0:o;13142:435::-;13284:12;13298:23;13333:5;13325:19;;13345:4;13325:25;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13283:67;;;;13369:7;13361:41;;;;;;;;;;;;:::i;:::-;13419:17;;:21;13415:155;;13503:10;13492:30;;;;;;;;;;;;:::i;:::-;13484:74;;;;;;;;;;;;:::i;1012:241:-1:-;;1116:2;1104:9;1095:7;1091:23;1087:32;1084:2;;;-1:-1;;1122:12;1084:2;85:6;72:20;97:33;124:5;97:33;:::i;:::-;1174:63;1078:175;-1:-1;;;1078:175::o;1260:443::-;;;1422:2;1410:9;1401:7;1397:23;1393:32;1390:2;;;-1:-1;;1428:12;1390:2;1486:17;1473:31;1524:18;;1516:6;1513:30;1510:2;;;-1:-1;;1546:12;1510:2;1670:6;1659:9;1655:22;;;345:3;338:4;330:6;326:17;322:27;312:2;;-1:-1;;353:12;312:2;396:6;383:20;1524:18;415:6;412:30;409:2;;;-1:-1;;445:12;409:2;540:3;1422:2;;524:6;520:17;481:6;506:32;;503:41;500:2;;;-1:-1;;547:12;500:2;1422;477:17;;;;;1566:121;;-1:-1;1384:319;;-1:-1;;;;1384:319::o;1710:257::-;;1822:2;1810:9;1801:7;1797:23;1793:32;1790:2;;;-1:-1;;1828:12;1790:2;656:6;650:13;12267:5;11181:13;11174:21;12245:5;12242:32;12232:2;;-1:-1;;12278:12;1974:394;;;2109:2;2097:9;2088:7;2084:23;2080:32;2077:2;;;-1:-1;;2115:12;2077:2;804:6;791:20;816:47;857:5;816:47;:::i;:::-;2167:77;2281:2;2320:22;;;;942:20;;-1:-1;;;2071:297::o;5639:291::-;;11608:6;11603:3;11598;11585:30;11646:16;;11639:27;;;11646:16;5783:147;-1:-1;5783:147::o;5937:271::-;;3601:5;10374:12;3712:52;3757:6;3752:3;3745:4;3738:5;3734:16;3712:52;:::i;:::-;3776:16;;;;;6071:137;-1:-1;;6071:137::o;6215:222::-;11392:42;11381:54;;;;2462:45;;6342:2;6327:18;;6313:124::o;6444:365::-;11392:42;11381:54;;;;2462:45;;6795:2;6780:18;;5590:37;6615:2;6600:18;;6586:223::o;6816:516::-;;2731:5;11181:13;11174:21;2711:3;2704:34;11392:42;2500:5;11381:54;7169:2;7158:9;7154:18;2462:45;7011:2;7206;7195:9;7191:18;7184:48;3233:5;10374:12;10530:6;7011:2;7000:9;6996:18;10518:19;3326:52;3371:6;10558:14;7000:9;10558:14;7169:2;3352:5;3348:16;3326:52;:::i;:::-;12045:2;12025:14;12041:7;12021:28;3390:39;;;;10558:14;3390:39;;6982:350;-1:-1;;;;6982:350::o;7339:416::-;7539:2;7553:47;;;4029:2;7524:18;;;10518:19;4065:34;10558:14;;;4045:55;4134:8;4120:12;;;4113:30;4162:12;;;7510:245::o;7762:416::-;7962:2;7976:47;;;7947:18;;;10518:19;4449:34;10558:14;;;4429:55;4503:12;;;7933:245::o;8185:416::-;8385:2;8399:47;;;4754:2;8370:18;;;10518:19;4790:33;10558:14;;;4770:54;4843:12;;;8356:245::o;8608:416::-;8808:2;8822:47;;;5094:2;8793:18;;;10518:19;5130:23;10558:14;;;5110:44;5173:12;;;8779:245::o;9031:416::-;9231:2;9245:47;;;5424:2;9216:18;;;10518:19;5460:13;10558:14;;;5440:34;5493:12;;;9202:245::o;9454:506::-;;;9589:11;9576:25;9640:48;9664:8;9648:14;9644:29;9640:48;9620:18;9616:73;9606:2;;-1:-1;;9693:12;9606:2;9720:33;;9774:18;;;-1:-1;9812:18;9801:30;;9798:2;;;-1:-1;;9834:12;9798:2;9679:4;9862:13;;-1:-1;9648:14;9894:38;;;9884:49;;9881:2;;;9946:1;;9936:12;9881:2;9544:416;;;;;:::o;9967:313::-;;10106:11;10093:25;10157:48;10181:8;10165:14;10161:29;10157:48;10137:18;10133:73;10123:2;;-1:-1;;10210:12;11681:268;11746:1;11753:101;11767:6;11764:1;11761:13;11753:101;;;11834:11;;;11828:18;11815:11;;;11808:39;11789:2;11782:10;11753:101;;;11869:6;11866:1;11863:13;11860:2;;;-1:-1;;11746:1;11916:16;;11909:27;11730:219::o;12062:117::-;11392:42;12149:5;11381:54;12124:5;12121:35;12111:2;;12170:1;;12160:12;12111:2;12105:74;:::o
Metadata Hash
41a6e0a4c21616ceae9ecbb4c6985b53eda41c83a9e4c801ed4a90f805d33fe2
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.