Overview
ETH Balance
0.904159097513909215 ETH
Eth Value
$2,792.65 (@ $3,088.67/ETH)Token Holdings
More Info
Private Name Tags
ContractCreator
Latest 1 from a total of 1 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
Value | ||||
---|---|---|---|---|---|---|---|---|---|
Transfer | 9318951 | 1566 days ago | IN | 20 ETH | 0.00033723 |
Latest 15 internal transactions
Advanced mode:
Parent Transaction Hash | Block | From | To | Value | ||
---|---|---|---|---|---|---|
13318776 | 948 days ago | 548 ETH | ||||
12993463 | 999 days ago | 4.66415909 ETH | ||||
11698380 | 1199 days ago | 4 ETH | ||||
11419855 | 1242 days ago | 167 ETH | ||||
11336164 | 1255 days ago | 500 ETH | ||||
11052481 | 1298 days ago | 1.5 ETH | ||||
10937137 | 1316 days ago | 38.59 ETH | ||||
10821411 | 1334 days ago | 94 ETH | ||||
10469986 | 1388 days ago | 49.07 ETH | ||||
10420506 | 1396 days ago | 4.5 ETH | ||||
10360179 | 1405 days ago | 195.59999999 ETH | ||||
10069836 | 1450 days ago | 196 ETH | ||||
10017651 | 1458 days ago | 25.5 ETH | ||||
10013640 | 1459 days ago | 800 ETH | ||||
9130041 | 1598 days ago | Contract Creation | 0 ETH |
Loading...
Loading
Similar Match Source Code This contract matches the deployed Bytecode of the Source Code for Contract 0xB914983F...BE47cCBBE The constructor portion of the code might be different and could alter the actual behaviour of the contract
Contract Name:
Avatar
Compiler Version
v0.5.13+commit.5b0b510c
Contract Source Code (Solidity)
/** *Submitted for verification at Etherscan.io on 2019-12-16 */ // File: openzeppelin-solidity/contracts/ownership/Ownable.sol pragma solidity ^0.5.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. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be aplied to your functions to restrict their use to * the owner. */ contract Ownable { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ constructor () internal { _owner = msg.sender; emit OwnershipTransferred(address(0), _owner); } /** * @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(isOwner(), "Ownable: caller is not the owner"); _; } /** * @dev Returns true if the caller is the current owner. */ function isOwner() public view returns (bool) { return msg.sender == _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 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 onlyOwner { _transferOwnership(newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). */ function _transferOwnership(address newOwner) internal { require(newOwner != address(0), "Ownable: new owner is the zero address"); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } } // File: @daostack/infra/contracts/Reputation.sol pragma solidity ^0.5.11; /** * @title Reputation system * @dev A DAO has Reputation System which allows peers to rate other peers in order to build trust . * A reputation is use to assign influence measure to a DAO'S peers. * Reputation is similar to regular tokens but with one crucial difference: It is non-transferable. * The Reputation contract maintain a map of address to reputation value. * It provides an onlyOwner functions to mint and burn reputation _to (or _from) a specific address. */ contract Reputation is Ownable { uint8 public decimals = 18; //Number of decimals of the smallest unit // Event indicating minting of reputation to an address. event Mint(address indexed _to, uint256 _amount); // Event indicating burning of reputation for an address. event Burn(address indexed _from, uint256 _amount); /// @dev `Checkpoint` is the structure that attaches a block number to a /// given value, the block number attached is the one that last changed the /// value struct Checkpoint { // `fromBlock` is the block number that the value was generated from uint128 fromBlock; // `value` is the amount of reputation at a specific block number uint128 value; } // `balances` is the map that tracks the balance of each address, in this // contract when the balance changes the block number that the change // occurred is also included in the map mapping (address => Checkpoint[]) balances; // Tracks the history of the `totalSupply` of the reputation Checkpoint[] totalSupplyHistory; /// @notice Constructor to create a Reputation constructor( ) public { } /// @dev This function makes it easy to get the total number of reputation /// @return The total number of reputation function totalSupply() public view returns (uint256) { return totalSupplyAt(block.number); } //////////////// // Query balance and totalSupply in History //////////////// /** * @dev return the reputation amount of a given owner * @param _owner an address of the owner which we want to get his reputation */ function balanceOf(address _owner) public view returns (uint256 balance) { return balanceOfAt(_owner, block.number); } /// @dev Queries the balance of `_owner` at a specific `_blockNumber` /// @param _owner The address from which the balance will be retrieved /// @param _blockNumber The block number when the balance is queried /// @return The balance at `_blockNumber` function balanceOfAt(address _owner, uint256 _blockNumber) public view returns (uint256) { if ((balances[_owner].length == 0) || (balances[_owner][0].fromBlock > _blockNumber)) { return 0; // This will return the expected balance during normal situations } else { return getValueAt(balances[_owner], _blockNumber); } } /// @notice Total amount of reputation at a specific `_blockNumber`. /// @param _blockNumber The block number when the totalSupply is queried /// @return The total amount of reputation at `_blockNumber` function totalSupplyAt(uint256 _blockNumber) public view returns(uint256) { if ((totalSupplyHistory.length == 0) || (totalSupplyHistory[0].fromBlock > _blockNumber)) { return 0; // This will return the expected totalSupply during normal situations } else { return getValueAt(totalSupplyHistory, _blockNumber); } } /// @notice Generates `_amount` reputation that are assigned to `_owner` /// @param _user The address that will be assigned the new reputation /// @param _amount The quantity of reputation generated /// @return True if the reputation are generated correctly function mint(address _user, uint256 _amount) public onlyOwner returns (bool) { uint256 curTotalSupply = totalSupply(); require(curTotalSupply + _amount >= curTotalSupply); // Check for overflow uint256 previousBalanceTo = balanceOf(_user); require(previousBalanceTo + _amount >= previousBalanceTo); // Check for overflow updateValueAtNow(totalSupplyHistory, curTotalSupply + _amount); updateValueAtNow(balances[_user], previousBalanceTo + _amount); emit Mint(_user, _amount); return true; } /// @notice Burns `_amount` reputation from `_owner` /// @param _user The address that will lose the reputation /// @param _amount The quantity of reputation to burn /// @return True if the reputation are burned correctly function burn(address _user, uint256 _amount) public onlyOwner returns (bool) { uint256 curTotalSupply = totalSupply(); uint256 amountBurned = _amount; uint256 previousBalanceFrom = balanceOf(_user); if (previousBalanceFrom < amountBurned) { amountBurned = previousBalanceFrom; } updateValueAtNow(totalSupplyHistory, curTotalSupply - amountBurned); updateValueAtNow(balances[_user], previousBalanceFrom - amountBurned); emit Burn(_user, amountBurned); return true; } //////////////// // Internal helper functions to query and set a value in a snapshot array //////////////// /// @dev `getValueAt` retrieves the number of reputation at a given block number /// @param checkpoints The history of values being queried /// @param _block The block number to retrieve the value at /// @return The number of reputation being queried function getValueAt(Checkpoint[] storage checkpoints, uint256 _block) internal view returns (uint256) { if (checkpoints.length == 0) { return 0; } // Shortcut for the actual value if (_block >= checkpoints[checkpoints.length-1].fromBlock) { return checkpoints[checkpoints.length-1].value; } if (_block < checkpoints[0].fromBlock) { return 0; } // Binary search of the value in the array uint256 min = 0; uint256 max = checkpoints.length-1; while (max > min) { uint256 mid = (max + min + 1) / 2; if (checkpoints[mid].fromBlock<=_block) { min = mid; } else { max = mid-1; } } return checkpoints[min].value; } /// @dev `updateValueAtNow` used to update the `balances` map and the /// `totalSupplyHistory` /// @param checkpoints The history of data being updated /// @param _value The new number of reputation function updateValueAtNow(Checkpoint[] storage checkpoints, uint256 _value) internal { require(uint128(_value) == _value); //check value is in the 128 bits bounderies if ((checkpoints.length == 0) || (checkpoints[checkpoints.length - 1].fromBlock < block.number)) { Checkpoint storage newCheckPoint = checkpoints[checkpoints.length++]; newCheckPoint.fromBlock = uint128(block.number); newCheckPoint.value = uint128(_value); } else { Checkpoint storage oldCheckPoint = checkpoints[checkpoints.length-1]; oldCheckPoint.value = uint128(_value); } } } // File: openzeppelin-solidity/contracts/token/ERC20/IERC20.sol pragma solidity ^0.5.0; /** * @dev Interface of the ERC20 standard as defined in the EIP. Does not include * the optional functions; to access them see `ERC20Detailed`. */ 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. * * > 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-solidity/contracts/math/SafeMath.sol pragma solidity ^0.5.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) { require(b <= a, "SafeMath: subtraction overflow"); 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-solidity/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) { // Solidity only automatically asserts when dividing by 0 require(b > 0, "SafeMath: division by zero"); 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) { require(b != 0, "SafeMath: modulo by zero"); return a % b; } } // File: openzeppelin-solidity/contracts/token/ERC20/ERC20.sol pragma solidity ^0.5.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 `ERC20Mintable`. * * *For a detailed writeup see our guide [How to implement supply * mechanisms](https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226).* * * 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 { using SafeMath for uint256; mapping (address => uint256) private _balances; mapping (address => mapping (address => uint256)) private _allowances; uint256 private _totalSupply; /** * @dev See `IERC20.totalSupply`. */ function totalSupply() public view returns (uint256) { return _totalSupply; } /** * @dev See `IERC20.balanceOf`. */ function balanceOf(address account) public view 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 returns (bool) { _transfer(msg.sender, recipient, amount); return true; } /** * @dev See `IERC20.allowance`. */ function allowance(address owner, address spender) public view returns (uint256) { return _allowances[owner][spender]; } /** * @dev See `IERC20.approve`. * * Requirements: * * - `spender` cannot be the zero address. */ function approve(address spender, uint256 value) public returns (bool) { _approve(msg.sender, spender, value); 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 `value`. * - the caller must have allowance for `sender`'s tokens of at least * `amount`. */ function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) { _transfer(sender, recipient, amount); _approve(sender, msg.sender, _allowances[sender][msg.sender].sub(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 returns (bool) { _approve(msg.sender, spender, _allowances[msg.sender][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 returns (bool) { _approve(msg.sender, spender, _allowances[msg.sender][spender].sub(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 { require(sender != address(0), "ERC20: transfer from the zero address"); require(recipient != address(0), "ERC20: transfer to the zero address"); _balances[sender] = _balances[sender].sub(amount); _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 { require(account != address(0), "ERC20: mint to the zero address"); _totalSupply = _totalSupply.add(amount); _balances[account] = _balances[account].add(amount); emit Transfer(address(0), account, amount); } /** * @dev Destoys `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 value) internal { require(account != address(0), "ERC20: burn from the zero address"); _totalSupply = _totalSupply.sub(value); _balances[account] = _balances[account].sub(value); emit Transfer(account, address(0), value); } /** * @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens. * * This is 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 value) internal { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = value; emit Approval(owner, spender, value); } /** * @dev Destoys `amount` tokens from `account`.`amount` is then deducted * from the caller's allowance. * * See `_burn` and `_approve`. */ function _burnFrom(address account, uint256 amount) internal { _burn(account, amount); _approve(account, msg.sender, _allowances[account][msg.sender].sub(amount)); } } // File: openzeppelin-solidity/contracts/token/ERC20/ERC20Burnable.sol pragma solidity ^0.5.0; /** * @dev Extension of `ERC20` that allows token holders to destroy both their own * tokens and those that they have an allowance for, in a way that can be * recognized off-chain (via event analysis). */ contract ERC20Burnable is ERC20 { /** * @dev Destoys `amount` tokens from the caller. * * See `ERC20._burn`. */ function burn(uint256 amount) public { _burn(msg.sender, amount); } /** * @dev See `ERC20._burnFrom`. */ function burnFrom(address account, uint256 amount) public { _burnFrom(account, amount); } } // File: contracts/controller/DAOToken.sol pragma solidity 0.5.13; /** * @title DAOToken, base on zeppelin contract. * @dev ERC20 compatible token. It is a mintable, burnable token. */ contract DAOToken is ERC20, ERC20Burnable, Ownable { string public name; string public symbol; // solhint-disable-next-line const-name-snakecase uint8 public constant decimals = 18; uint256 public cap; /** * @dev Constructor * @param _name - token name * @param _symbol - token symbol * @param _cap - token cap - 0 value means no cap */ constructor(string memory _name, string memory _symbol, uint256 _cap) public { name = _name; symbol = _symbol; cap = _cap; } /** * @dev Function to mint tokens * @param _to The address that will receive the minted tokens. * @param _amount The amount of tokens to mint. */ function mint(address _to, uint256 _amount) public onlyOwner returns (bool) { if (cap > 0) require(totalSupply().add(_amount) <= cap); _mint(_to, _amount); return true; } } // File: openzeppelin-solidity/contracts/utils/Address.sol pragma solidity ^0.5.0; /** * @dev Collection of functions related to the address type, */ library Address { /** * @dev Returns true if `account` is a contract. * * This test is non-exhaustive, and there may be false-negatives: during the * execution of a contract's constructor, its address will be reported as * not containing a contract. * * > It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. */ function isContract(address account) internal view returns (bool) { // This method relies in extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. uint256 size; // solhint-disable-next-line no-inline-assembly assembly { size := extcodesize(account) } return size > 0; } } // File: contracts/libs/SafeERC20.sol /* SafeERC20 by daostack. The code is based on a fix by SECBIT Team. USE WITH CAUTION & NO WARRANTY REFERENCE & RELATED READING - https://github.com/ethereum/solidity/issues/4116 - https://medium.com/@chris_77367/explaining-unexpected-reverts-starting-with-solidity-0-4-22-3ada6e82308c - https://medium.com/coinmonks/missing-return-value-bug-at-least-130-tokens-affected-d67bf08521ca - https://gist.github.com/BrendanChou/88a2eeb80947ff00bcf58ffdafeaeb61 */ pragma solidity 0.5.13; library SafeERC20 { using Address for address; bytes4 constant private TRANSFER_SELECTOR = bytes4(keccak256(bytes("transfer(address,uint256)"))); bytes4 constant private TRANSFERFROM_SELECTOR = bytes4(keccak256(bytes("transferFrom(address,address,uint256)"))); bytes4 constant private APPROVE_SELECTOR = bytes4(keccak256(bytes("approve(address,uint256)"))); function safeTransfer(address _erc20Addr, address _to, uint256 _value) internal { // Must be a contract addr first! require(_erc20Addr.isContract()); (bool success, bytes memory returnValue) = // solhint-disable-next-line avoid-low-level-calls _erc20Addr.call(abi.encodeWithSelector(TRANSFER_SELECTOR, _to, _value)); // call return false when something wrong require(success); //check return value require(returnValue.length == 0 || (returnValue.length == 32 && (returnValue[31] != 0))); } function safeTransferFrom(address _erc20Addr, address _from, address _to, uint256 _value) internal { // Must be a contract addr first! require(_erc20Addr.isContract()); (bool success, bytes memory returnValue) = // solhint-disable-next-line avoid-low-level-calls _erc20Addr.call(abi.encodeWithSelector(TRANSFERFROM_SELECTOR, _from, _to, _value)); // call return false when something wrong require(success); //check return value require(returnValue.length == 0 || (returnValue.length == 32 && (returnValue[31] != 0))); } function safeApprove(address _erc20Addr, address _spender, uint256 _value) internal { // Must be a contract addr first! require(_erc20Addr.isContract()); // safeApprove should only be called when setting an initial allowance, // or when resetting it to zero. require((_value == 0) || (IERC20(_erc20Addr).allowance(address(this), _spender) == 0)); (bool success, bytes memory returnValue) = // solhint-disable-next-line avoid-low-level-calls _erc20Addr.call(abi.encodeWithSelector(APPROVE_SELECTOR, _spender, _value)); // call return false when something wrong require(success); //check return value require(returnValue.length == 0 || (returnValue.length == 32 && (returnValue[31] != 0))); } } // File: contracts/controller/Avatar.sol pragma solidity 0.5.13; /** * @title An Avatar holds tokens, reputation and ether for a controller */ contract Avatar is Ownable { using SafeERC20 for address; string public orgName; DAOToken public nativeToken; Reputation public nativeReputation; event GenericCall(address indexed _contract, bytes _data, uint _value, bool _success); event SendEther(uint256 _amountInWei, address indexed _to); event ExternalTokenTransfer(address indexed _externalToken, address indexed _to, uint256 _value); event ExternalTokenTransferFrom(address indexed _externalToken, address _from, address _to, uint256 _value); event ExternalTokenApproval(address indexed _externalToken, address _spender, uint256 _value); event ReceiveEther(address indexed _sender, uint256 _value); event MetaData(string _metaData); /** * @dev the constructor takes organization name, native token and reputation system and creates an avatar for a controller */ constructor(string memory _orgName, DAOToken _nativeToken, Reputation _nativeReputation) public { orgName = _orgName; nativeToken = _nativeToken; nativeReputation = _nativeReputation; } /** * @dev enables an avatar to receive ethers */ function() external payable { emit ReceiveEther(msg.sender, msg.value); } /** * @dev perform a generic call to an arbitrary contract * @param _contract the contract's address to call * @param _data ABI-encoded contract call to call `_contract` address. * @param _value value (ETH) to transfer with the transaction * @return bool success or fail * bytes - the return bytes of the called contract's function. */ function genericCall(address _contract, bytes memory _data, uint256 _value) public onlyOwner returns(bool success, bytes memory returnValue) { // solhint-disable-next-line avoid-call-value (success, returnValue) = _contract.call.value(_value)(_data); emit GenericCall(_contract, _data, _value, success); } /** * @dev send ethers from the avatar's wallet * @param _amountInWei amount to send in Wei units * @param _to send the ethers to this address * @return bool which represents success */ function sendEther(uint256 _amountInWei, address payable _to) public onlyOwner returns(bool) { _to.transfer(_amountInWei); emit SendEther(_amountInWei, _to); return true; } /** * @dev external token transfer * @param _externalToken the token contract * @param _to the destination address * @param _value the amount of tokens to transfer * @return bool which represents success */ function externalTokenTransfer(IERC20 _externalToken, address _to, uint256 _value) public onlyOwner returns(bool) { address(_externalToken).safeTransfer(_to, _value); emit ExternalTokenTransfer(address(_externalToken), _to, _value); return true; } /** * @dev external token transfer from a specific account * @param _externalToken the token contract * @param _from the account to spend token from * @param _to the destination address * @param _value the amount of tokens to transfer * @return bool which represents success */ function externalTokenTransferFrom( IERC20 _externalToken, address _from, address _to, uint256 _value ) public onlyOwner returns(bool) { address(_externalToken).safeTransferFrom(_from, _to, _value); emit ExternalTokenTransferFrom(address(_externalToken), _from, _to, _value); return true; } /** * @dev externalTokenApproval approve the spender address to spend a specified amount of tokens * on behalf of msg.sender. * @param _externalToken the address of the Token Contract * @param _spender address * @param _value the amount of ether (in Wei) which the approval is referring to. * @return bool which represents a success */ function externalTokenApproval(IERC20 _externalToken, address _spender, uint256 _value) public onlyOwner returns(bool) { address(_externalToken).safeApprove(_spender, _value); emit ExternalTokenApproval(address(_externalToken), _spender, _value); return true; } /** * @dev metaData emits an event with a string, should contain the hash of some meta data. * @param _metaData a string representing a hash of the meta data * @return bool which represents a success */ function metaData(string memory _metaData) public onlyOwner returns(bool) { emit MetaData(_metaData); return true; } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"string","name":"_orgName","type":"string"},{"internalType":"contract DAOToken","name":"_nativeToken","type":"address"},{"internalType":"contract Reputation","name":"_nativeReputation","type":"address"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"_externalToken","type":"address"},{"indexed":false,"internalType":"address","name":"_spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"_value","type":"uint256"}],"name":"ExternalTokenApproval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"_externalToken","type":"address"},{"indexed":true,"internalType":"address","name":"_to","type":"address"},{"indexed":false,"internalType":"uint256","name":"_value","type":"uint256"}],"name":"ExternalTokenTransfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"_externalToken","type":"address"},{"indexed":false,"internalType":"address","name":"_from","type":"address"},{"indexed":false,"internalType":"address","name":"_to","type":"address"},{"indexed":false,"internalType":"uint256","name":"_value","type":"uint256"}],"name":"ExternalTokenTransferFrom","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"_contract","type":"address"},{"indexed":false,"internalType":"bytes","name":"_data","type":"bytes"},{"indexed":false,"internalType":"uint256","name":"_value","type":"uint256"},{"indexed":false,"internalType":"bool","name":"_success","type":"bool"}],"name":"GenericCall","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"_metaData","type":"string"}],"name":"MetaData","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"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"_sender","type":"address"},{"indexed":false,"internalType":"uint256","name":"_value","type":"uint256"}],"name":"ReceiveEther","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"_amountInWei","type":"uint256"},{"indexed":true,"internalType":"address","name":"_to","type":"address"}],"name":"SendEther","type":"event"},{"payable":true,"stateMutability":"payable","type":"fallback"},{"constant":false,"inputs":[{"internalType":"contract IERC20","name":"_externalToken","type":"address"},{"internalType":"address","name":"_spender","type":"address"},{"internalType":"uint256","name":"_value","type":"uint256"}],"name":"externalTokenApproval","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"contract IERC20","name":"_externalToken","type":"address"},{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_value","type":"uint256"}],"name":"externalTokenTransfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"contract IERC20","name":"_externalToken","type":"address"},{"internalType":"address","name":"_from","type":"address"},{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_value","type":"uint256"}],"name":"externalTokenTransferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_contract","type":"address"},{"internalType":"bytes","name":"_data","type":"bytes"},{"internalType":"uint256","name":"_value","type":"uint256"}],"name":"genericCall","outputs":[{"internalType":"bool","name":"success","type":"bool"},{"internalType":"bytes","name":"returnValue","type":"bytes"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"isOwner","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"string","name":"_metaData","type":"string"}],"name":"metaData","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"nativeReputation","outputs":[{"internalType":"contract Reputation","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"nativeToken","outputs":[{"internalType":"contract DAOToken","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"orgName","outputs":[{"internalType":"string","name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"renounceOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"_amountInWei","type":"uint256"},{"internalType":"address payable","name":"_to","type":"address"}],"name":"sendEther","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"}]
Deployed Bytecode
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
Deployed Bytecode Sourcemap
30747:4768:0:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;31986:35;;;32011:9;31986:35;;;;31999:10;;31986:35;;;;;;;;;;30747:4768;30817:21;;8:9:-1;5:2;;;30:1;27;20:12;5:2;30817:21:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:100:-1;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;30817:21:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;32425:350;;8:9:-1;5:2;;;30:1;27;20:12;5:2;32425:350:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;32425:350:0;;;;;;;;;;;;;;;21:11:-1;5:28;;2:2;;;46:1;43;36:12;2:2;32425:350:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;32425:350: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;32425:350:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;32425:350:0;;-1:-1:-1;;32425:350:0;;;-1:-1:-1;32425:350:0;;-1:-1:-1;;32425:350:0:i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;32425:350:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1718:140;;8:9:-1;5:2;;;30:1;27;20:12;5:2;1718:140:0;;;:::i;:::-;;35369:139;;8:9:-1;5:2;;;30:1;27;20:12;5:2;35369:139:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;35369:139:0;;;;;;;;21:11:-1;5:28;;2:2;;;46:1;43;36:12;2:2;35369:139:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;35369:139: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;35369:139:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;35369:139:0;;-1:-1:-1;35369:139:0;;-1:-1:-1;;;;;35369:139:0:i;:::-;;;;;;;;;;;;;;;;;;30879:34;;8:9:-1;5:2;;;30:1;27;20:12;5:2;30879:34:0;;;:::i;:::-;;;;-1:-1:-1;;;;;30879:34:0;;;;;;;;;;;;;;907:79;;8:9:-1;5:2;;;30:1;27;20:12;5:2;907:79:0;;;:::i;1273:92::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;1273:92:0;;;:::i;34830:303::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;34830:303:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;34830:303:0;;;;;;;;;;;;;;;;;:::i;34068:373::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;34068:373:0;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;;;;;;34068:373:0;;;;;;;;;;;;;;;;;;;;;;:::i;32999:204::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;32999:204:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;32999:204:0;;;;;;-1:-1:-1;;;;;32999:204:0;;:::i;33453:289::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;33453:289:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;33453:289:0;;;;;;;;;;;;;;;;;:::i;30845:27::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;30845:27:0;;;:::i;2013:109::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;2013:109:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;2013:109:0;-1:-1:-1;;;;;2013:109:0;;:::i;30817:21::-;;;;;;;;;;;;;;;-1:-1:-1;;30817:21:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;32425:350::-;32541:12;32555:24;1119:9;:7;:9::i;:::-;1111:54;;;;;-1:-1:-1;;;1111:54:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;1111:54:0;;;;;;;;;;;;;;;32670:9;-1:-1:-1;;;;;32670:14:0;32691:6;32699:5;32670:35;;;;;;;;;;;;;36:153:-1;66:2;61:3;58:11;36:153;;176:10;;164:23;;-1:-1;;139:12;;;;98:2;89:12;;;;114;36:153;;;274:1;267:3;263:2;259:12;254:3;250:22;246:30;315:4;311:9;305:3;299:10;295:26;356:4;350:3;344:10;340:21;389:7;380;377:20;372:3;365:33;3:399;;;32670:35:0;;;;;;;;;;;;;;;;;;;;;;;;;14:1:-1;21;16:31;;;;75:4;69:11;64:16;;144:4;140:9;133:4;115:16;111:27;107:43;104:1;100:51;94:4;87:65;169:16;166:1;159:27;225:16;222:1;215:4;212:1;208:12;193:49;7:242;;16:31;36:4;31:9;;7:242;;32645:60:0;;;;;;;;32733:9;-1:-1:-1;;;;;32721:46:0;;32744:5;32751:6;32759:7;32721:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;32721:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;32425:350;;;;;;:::o;1718:140::-;1119:9;:7;:9::i;:::-;1111:54;;;;;-1:-1:-1;;;1111:54:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;1111:54:0;;;;;;;;;;;;;;;1817:1;1801:6;;1780:40;;-1:-1:-1;;;;;1801:6:0;;;;1780:40;;1817:1;;1780:40;1848:1;1831:19;;-1:-1:-1;;;;;;1831:19:0;;;1718:140::o;35369:139::-;35437:4;1119:9;:7;:9::i;:::-;1111:54;;;;;-1:-1:-1;;;1111:54:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;1111:54:0;;;;;;;;;;;;;;;35459:19;35468:9;35459:19;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;35459:19:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;35496:4:0;35369:139;;;:::o;30879:34::-;;;-1:-1:-1;;;;;30879:34:0;;:::o;907:79::-;945:7;972:6;-1:-1:-1;;;;;972:6:0;907:79;:::o;1273:92::-;1313:4;1351:6;-1:-1:-1;;;;;1351:6:0;1337:10;:20;;1273:92::o;34830:303::-;34948:4;1119:9;:7;:9::i;:::-;1111:54;;;;;-1:-1:-1;;;1111:54:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;1111:54:0;;;;;;;;;;;;;;;34970:53;-1:-1:-1;;;;;34970:35:0;;35006:8;35016:6;34970:53;:35;:53;:::i;:::-;35039:64;;;-1:-1:-1;;;;;35039:64:0;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;35121:4:0;34830:303;;;;;:::o;34068:373::-;34243:4;1119:9;:7;:9::i;:::-;1111:54;;;;;-1:-1:-1;;;1111:54:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;1111:54:0;;;;;;;;;;;;;;;34265:60;-1:-1:-1;;;;;34265:40:0;;34306:5;34313:3;34318:6;34265:60;:40;:60;:::i;:::-;34341:70;;;-1:-1:-1;;;;;34341:70:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;34429:4:0;34068:373;;;;;;:::o;32999:204::-;33086:4;1119:9;:7;:9::i;:::-;1111:54;;;;;-1:-1:-1;;;1111:54:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;1111:54:0;;;;;;;;;;;;;;;33103:26;;-1:-1:-1;;;;;33103:12:0;;;:26;;;;;33116:12;;33103:26;;;;33116:12;33103;:26;;;;;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;-1:-1;33145:28:0;;;;;;;;-1:-1:-1;;;;;33145:28:0;;;;;;;;;;;;;-1:-1:-1;33191:4:0;32999:204;;;;:::o;33453:289::-;33566:4;1119:9;:7;:9::i;:::-;1111:54;;;;;-1:-1:-1;;;1111:54:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;1111:54:0;;;;;;;;;;;;;;;33588:49;-1:-1:-1;;;;;33588:36:0;;33625:3;33630:6;33588:49;:36;:49;:::i;:::-;33700:3;-1:-1:-1;;;;;33653:59:0;33683:14;-1:-1:-1;;;;;33653:59:0;;33705:6;33653:59;;;;;;;;;;;;;;;;;;-1:-1:-1;33730:4:0;33453:289;;;;;:::o;30845:27::-;;;-1:-1:-1;;;;;30845:27:0;;:::o;2013:109::-;1119:9;:7;:9::i;:::-;1111:54;;;;;-1:-1:-1;;;1111:54:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;1111:54:0;;;;;;;;;;;;;;;2086:28;2105:8;2086:18;:28::i;:::-;2013:109;:::o;29765:809::-;29913:23;:10;-1:-1:-1;;;;;29913:21:0;;:23::i;:::-;29905:32;;;;;;30082:11;;;30081:77;;-1:-1:-1;30099:53:0;;;-1:-1:-1;;;30099:53:0;;30136:4;30099:53;;;;-1:-1:-1;;;;;30099:53:0;;;;;;;;;:28;;;;;;:53;;;;;;;;;;;;;;;:28;:53;;;5:2:-1;;;;30:1;27;20:12;5:2;30099:53:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;30099:53:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;30099:53:0;:58;30081:77;30073:86;;;;;;28517:33;;;;;;;;;;;;;;;;;30300:58;;-1:-1:-1;;;;;30300:58:0;;;;;;;;;;;;;;;;26:21:-1;;;22:32;;;6:49;;30300:58:0;;;;;;25:18:-1;;;61:17;;-1:-1;;;;;182:15;-1:-1;;;179:29;160:49;;30284:75:0;;;;30173:12;;30187:24;;30284:15;;;30300:58;30284:75;;;25:18:-1;30284:75:0;;25:18:-1;36:153;66:2;61:3;58:11;36:153;;176:10;;164:23;;-1:-1;;139:12;;;;98:2;89:12;;;;114;36:153;;;274:1;267:3;263:2;259:12;254:3;250:22;246:30;315:4;311:9;305:3;299:10;295:26;356:4;350:3;344:10;340:21;389:7;380;377:20;372:3;365:33;3:399;;;30284:75:0;;;;;;;;;;;;;;;;;;;;;;;;14:1:-1;21;16:31;;;;75:4;69:11;64:16;;144:4;140:9;133:4;115:16;111:27;107:43;104:1;100:51;94:4;87:65;169:16;166:1;159:27;225:16;222:1;215:4;212:1;208:12;193:49;7:242;;16:31;36:4;31:9;;7:242;;30172:187:0;;;;30429:7;30421:16;;;;;;30486:18;;:23;;:79;;;30514:11;:18;30536:2;30514:24;:50;;;;;30543:11;30555:2;30543:15;;;;;;;;;;;;-1:-1:-1;;;;;;30543:15:0;:20;;30514:50;30478:88;;;;;;29765:809;;;;;:::o;29148:609::-;29311:23;:10;-1:-1:-1;;;;;29311:21:0;;:23::i;:::-;29303:32;;;;;;29349:12;29363:24;29460:10;-1:-1:-1;;;;;29460:15:0;28402:46;;;;;;;;;;;;;;;;;28392:57;;;;;;;29476:65;;;-1:-1:-1;;;;;29476:65:0;;;;;;;;;;;;;;;;;;;;;;26:21:-1;;;22:32;;;6:49;;29476:65:0;;;;;;25:18:-1;;;61:17;;-1:-1;;;;;182:15;-1:-1;;;;;;29476:65:0;;;179:29:-1;;;;160:49;;29460:82:0;;;;;;;;;25:18:-1;36:153;66:2;61:3;58:11;36:153;;176:10;;164:23;;-1:-1;;139:12;;;;98:2;89:12;;;;114;36:153;;;274:1;267:3;263:2;259:12;254:3;250:22;246:30;315:4;311:9;305:3;299:10;295:26;356:4;350:3;344:10;340:21;389:7;380;377:20;372:3;365:33;3:399;;;29460:82:0;;;;;;;;;;;;;;;;;;;;;;;;14:1:-1;21;16:31;;;;75:4;69:11;64:16;;144:4;140:9;133:4;115:16;111:27;107:43;104:1;100:51;94:4;87:65;169:16;166:1;159:27;225:16;222:1;215:4;212:1;208:12;193:49;7:242;;16:31;36:4;31:9;;7:242;;29348:194:0;;;;29612:7;29604:16;;;;;;29669:18;;:23;;:79;;;29697:11;:18;29719:2;29697:24;:50;;;;;29726:11;29738:2;29726:15;;;;;;;;;;;;-1:-1:-1;;;;;;29726:15:0;:20;;29697:50;29661:88;;;;;;29148:609;;;;;;:::o;28561:579::-;28705:23;:10;-1:-1:-1;;;;;28705:21:0;;:23::i;:::-;28697:32;;;;;;28294:34;;;;;;;;;;;;;;;;;28870:54;;-1:-1:-1;;;;;28870:54:0;;;;;;;;;;;;;;;;26:21:-1;;;22:32;;;6:49;;28870:54:0;;;;;;25:18:-1;;;61:17;;-1:-1;;;;;182:15;-1:-1;;;179:29;160:49;;28854:71:0;;;;28743:12;;28757:24;;28854:15;;;28870:54;28854:71;;;25:18:-1;28854:71:0;;25:18:-1;66:2;61:3;58:11;36:153;;176:10;;164:23;;-1:-1;;139:12;;;;98:2;89:12;;;;114;36:153;;2228:229:0;-1:-1:-1;;;;;2302:22:0;;2294:73;;;;-1:-1:-1;;;2294:73:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2404:6;;;2383:38;;-1:-1:-1;;;;;2383:38:0;;;;2404:6;;;2383:38;;;2432:6;:17;;-1:-1:-1;;;;;;2432:17:0;-1:-1:-1;;;;;2432:17:0;;;;;;;;;;2228:229::o;27197:422::-;27564:20;27603:8;;;27197:422::o
Swarm Source
bzzr://14b898b9e17bb4dd0c37a08faa23b1fe08fcd9598dc9d19200587a2ffdd1e96d
Loading...
Loading
Loading...
Loading
Loading...
Loading
[ Download: CSV Export ]
[ Download: CSV Export ]
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.