diff --git a/contracts/common/Controlled.sol b/contracts/common/Controlled.sol index d2773f3..7b615b6 100644 --- a/contracts/common/Controlled.sol +++ b/contracts/common/Controlled.sol @@ -10,7 +10,7 @@ contract Controlled { address public controller; - constructor() public { + constructor() internal { controller = msg.sender; } diff --git a/contracts/common/Owned.sol b/contracts/common/Owned.sol index 177bf0f..18f03e7 100644 --- a/contracts/common/Owned.sol +++ b/contracts/common/Owned.sol @@ -14,7 +14,7 @@ contract Owned { address public owner; /// @notice The Constructor assigns the message sender to be `owner` - constructor() public { + constructor() internal { owner = msg.sender; } diff --git a/contracts/token/ApproveAndCallFallBack.sol b/contracts/token/ApproveAndCallFallBack.sol index 01bbf9b..accc9c7 100644 --- a/contracts/token/ApproveAndCallFallBack.sol +++ b/contracts/token/ApproveAndCallFallBack.sol @@ -1,5 +1,5 @@ -pragma solidity ^0.4.14; +pragma solidity ^0.4.23; contract ApproveAndCallFallBack { - function receiveApproval(address from, uint256 _amount, address _token, bytes _data) public ; + function receiveApproval(address from, uint256 _amount, address _token, bytes _data) public; } diff --git a/contracts/token/ERC20Token.sol b/contracts/token/ERC20Token.sol index c210342..ff8de15 100644 --- a/contracts/token/ERC20Token.sol +++ b/contracts/token/ERC20Token.sol @@ -1,48 +1,52 @@ -pragma solidity ^0.4.17; +pragma solidity ^0.4.23; // Abstract contract for the full ERC 20 Token standard // https://github.com/ethereum/EIPs/issues/20 -contract ERC20Token { - /* This is a slight change to the ERC20 base standard. - function totalSupply() constant returns (uint256 supply); - is replaced with: - uint256 public totalSupply; - This automatically creates a getter function for the totalSupply. - This is moved to the base contract since public getter functions are not - currently recognised as an implementation of the matching abstract - function by the compiler. - */ - /// total amount of tokens - uint256 public totalSupply; +interface ERC20Token { - /// @notice send `_value` token to `_to` from `msg.sender` - /// @param _to The address of the recipient - /// @param _value The amount of token to be transferred - /// @return Whether the transfer was successful or not - function transfer(address _to, uint256 _value) public returns (bool success); + /** + * @notice send `_value` token to `_to` from `msg.sender` + * @param _to The address of the recipient + * @param _value The amount of token to be transferred + * @return Whether the transfer was successful or not + */ + function transfer(address _to, uint256 _value) external returns (bool success); - /// @notice `msg.sender` approves `_spender` to spend `_value` tokens - /// @param _spender The address of the account able to transfer the tokens - /// @param _value The amount of tokens to be approved for transfer - /// @return Whether the approval was successful or not - function approve(address _spender, uint256 _value) public returns (bool success); + /** + * @notice `msg.sender` approves `_spender` to spend `_value` tokens + * @param _spender The address of the account able to transfer the tokens + * @param _value The amount of tokens to be approved for transfer + * @return Whether the approval was successful or not + */ + function approve(address _spender, uint256 _value) external returns (bool success); - /// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from` - /// @param _from The address of the sender - /// @param _to The address of the recipient - /// @param _value The amount of token to be transferred - /// @return Whether the transfer was successful or not - function transferFrom(address _from, address _to, uint256 _value) public returns (bool success); + /** + * @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from` + * @param _from The address of the sender + * @param _to The address of the recipient + * @param _value The amount of token to be transferred + * @return Whether the transfer was successful or not + */ + function transferFrom(address _from, address _to, uint256 _value) external returns (bool success); - /// @param _owner The address from which the balance will be retrieved - /// @return The balance - function balanceOf(address _owner) public view returns (uint256 balance); + /** + * @param _owner The address from which the balance will be retrieved + * @return The balance + */ + function balanceOf(address _owner) external view returns (uint256 balance); - /// @param _owner The address of the account owning tokens - /// @param _spender The address of the account able to transfer the tokens - /// @return Amount of remaining tokens allowed to spent - function allowance(address _owner, address _spender) public view returns (uint256 remaining); + /** + * @param _owner The address of the account owning tokens + * @param _spender The address of the account able to transfer the tokens + * @return Amount of remaining tokens allowed to spent + */ + function allowance(address _owner, address _spender) external view returns (uint256 remaining); + + /** + * @notice return total supply of tokens + */ + function totalSupply() external view returns (uint256 supply); event Transfer(address indexed _from, address indexed _to, uint256 _value); event Approval(address indexed _owner, address indexed _spender, uint256 _value); diff --git a/contracts/token/MiniMeToken.sol b/contracts/token/MiniMeToken.sol index bf4378b..57a8f1a 100644 --- a/contracts/token/MiniMeToken.sol +++ b/contracts/token/MiniMeToken.sol @@ -1,4 +1,4 @@ -pragma solidity ^0.4.6; +pragma solidity ^0.4.23; /* Copyright 2016, Jordi Baylina @@ -16,14 +16,15 @@ pragma solidity ^0.4.6; You should have received a copy of the GNU General Public License along with this program. If not, see . */ - -/// @title MiniMeToken Contract -/// @author Jordi Baylina -/// @dev This token contract's goal is to make it easy for anyone to clone this -/// token using the token distribution at a given block, this will allow DAO's -/// and DApps to upgrade their features in a decentralized manner without -/// affecting the original token -/// @dev It is ERC20 compliant, but still needs to under go further testing. +/** + * @title MiniMeToken Contract + * @author Jordi Baylina + * @dev This token contract's goal is to make it easy for anyone to clone this + * token using the token distribution at a given block, this will allow DAO's + * and DApps to upgrade their features in a decentralized manner without + * affecting the original token + * @dev It is ERC20 compliant, but still needs to under go further testing. + */ import "../common/Controlled.sol"; import "./TokenController.sol"; @@ -31,9 +32,11 @@ import "./ApproveAndCallFallBack.sol"; import "./MiniMeTokenInterface.sol"; import "./MiniMeTokenFactory.sol"; -/// @dev The actual token contract, the default controller is the msg.sender -/// that deploys the contract, so usually this token will be deployed by a -/// token controller contract, which Giveth will call a "Campaign" +/** + * @dev The actual token contract, the default controller is the msg.sender + * that deploys the contract, so usually this token will be deployed by a + * token controller contract, which Giveth will call a "Campaign" + */ contract MiniMeToken is MiniMeTokenInterface, Controlled { string public name; //The Token's name: e.g. DigixDAO Tokens @@ -41,10 +44,11 @@ contract MiniMeToken is MiniMeTokenInterface, Controlled { string public symbol; //An identifier: e.g. REP string public version = "MMT_0.1"; //An arbitrary versioning scheme - - /// @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 + /** + * @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 @@ -86,20 +90,22 @@ contract MiniMeToken is MiniMeTokenInterface, Controlled { // Constructor //////////////// - /// @notice Constructor to create a MiniMeToken - /// @param _tokenFactory The address of the MiniMeTokenFactory contract that - /// will create the Clone token contracts, the token factory needs to be - /// deployed first - /// @param _parentToken Address of the parent token, set to 0x0 if it is a - /// new token - /// @param _parentSnapShotBlock Block of the parent token that will - /// determine the initial distribution of the clone token, set to 0 if it - /// is a new token - /// @param _tokenName Name of the new token - /// @param _decimalUnits Number of decimals of the new token - /// @param _tokenSymbol Token Symbol for the new token - /// @param _transfersEnabled If true, tokens will be able to be transferred - function MiniMeToken( + /** + * @notice Constructor to create a MiniMeToken + * @param _tokenFactory The address of the MiniMeTokenFactory contract that + * will create the Clone token contracts, the token factory needs to be + * deployed first + * @param _parentToken Address of the parent token, set to 0x0 if it is a + * new token + * @param _parentSnapShotBlock Block of the parent token that will + * determine the initial distribution of the clone token, set to 0 if it + * is a new token + * @param _tokenName Name of the new token + * @param _decimalUnits Number of decimals of the new token + * @param _tokenSymbol Token Symbol for the new token + * @param _transfersEnabled If true, tokens will be able to be transferred + */ + constructor( address _tokenFactory, address _parentToken, uint _parentSnapShotBlock, @@ -125,21 +131,25 @@ contract MiniMeToken is MiniMeTokenInterface, Controlled { // ERC20 Methods /////////////////// - /// @notice Send `_amount` tokens to `_to` from `msg.sender` - /// @param _to The address of the recipient - /// @param _amount The amount of tokens to be transferred - /// @return Whether the transfer was successful or not + /** + * @notice Send `_amount` tokens to `_to` from `msg.sender` + * @param _to The address of the recipient + * @param _amount The amount of tokens to be transferred + * @return Whether the transfer was successful or not + */ function transfer(address _to, uint256 _amount) public returns (bool success) { require(transfersEnabled); return doTransfer(msg.sender, _to, _amount); } - /// @notice Send `_amount` tokens to `_to` from `_from` on the condition it - /// is approved by `_from` - /// @param _from The address holding the tokens being transferred - /// @param _to The address of the recipient - /// @param _amount The amount of tokens to be transferred - /// @return True if the transfer was successful + /** + * @notice Send `_amount` tokens to `_to` from `_from` on the condition it + * is approved by `_from` + * @param _from The address holding the tokens being transferred + * @param _to The address of the recipient + * @param _amount The amount of tokens to be transferred + * @return True if the transfer was successful + */ function transferFrom( address _from, address _to, @@ -165,12 +175,14 @@ contract MiniMeToken is MiniMeTokenInterface, Controlled { return doTransfer(_from, _to, _amount); } - /// @dev This is the actual transfer function in the token contract, it can - /// only be called by other functions in this contract. - /// @param _from The address holding the tokens being transferred - /// @param _to The address of the recipient - /// @param _amount The amount of tokens to be transferred - /// @return True if the transfer was successful + /** + * @dev This is the actual transfer function in the token contract, it can + * only be called by other functions in this contract. + * @param _from The address holding the tokens being transferred + * @param _to The address of the recipient + * @param _amount The amount of tokens to be transferred + * @return True if the transfer was successful + */ function doTransfer( address _from, address _to, @@ -180,106 +192,124 @@ contract MiniMeToken is MiniMeTokenInterface, Controlled { returns(bool) { - if (_amount == 0) { - return true; - } + if (_amount == 0) { + return true; + } - require(parentSnapShotBlock < block.number); + require(parentSnapShotBlock < block.number); - // Do not allow transfer to 0x0 or the token contract itself - require((_to != 0) && (_to != address(this))); + // Do not allow transfer to 0x0 or the token contract itself + require((_to != 0) && (_to != address(this))); - // If the amount being transfered is more than the balance of the - // account the transfer returns false - var previousBalanceFrom = balanceOfAt(_from, block.number); - if (previousBalanceFrom < _amount) { - return false; - } + // If the amount being transfered is more than the balance of the + // account the transfer returns false + uint256 previousBalanceFrom = balanceOfAt(_from, block.number); + if (previousBalanceFrom < _amount) { + return false; + } - // Alerts the token controller of the transfer - if (isContract(controller)) { - require(TokenController(controller).onTransfer(_from, _to, _amount)); - } + // Alerts the token controller of the transfer + if (isContract(controller)) { + require(TokenController(controller).onTransfer(_from, _to, _amount)); + } - // First update the balance array with the new value for the address - // sending the tokens - updateValueAtNow(balances[_from], previousBalanceFrom - _amount); + // First update the balance array with the new value for the address + // sending the tokens + updateValueAtNow(balances[_from], previousBalanceFrom - _amount); - // Then update the balance array with the new value for the address - // receiving the tokens - var previousBalanceTo = balanceOfAt(_to, block.number); - require(previousBalanceTo + _amount >= previousBalanceTo); // Check for overflow - updateValueAtNow(balances[_to], previousBalanceTo + _amount); + // Then update the balance array with the new value for the address + // receiving the tokens + uint256 previousBalanceTo = balanceOfAt(_to, block.number); + require(previousBalanceTo + _amount >= previousBalanceTo); // Check for overflow + updateValueAtNow(balances[_to], previousBalanceTo + _amount); - // An event to make the transfer easy to find on the blockchain - Transfer(_from, _to, _amount); + // An event to make the transfer easy to find on the blockchain + emit Transfer(_from, _to, _amount); - return true; + return true; } - /// @param _owner The address that's balance is being requested - /// @return The balance of `_owner` at the current block - function balanceOf(address _owner) public constant returns (uint256 balance) { - return balanceOfAt(_owner, block.number); - } - - /// @notice `msg.sender` approves `_spender` to spend `_amount` tokens on - /// its behalf. This is a modified version of the ERC20 approve function - /// to be a little bit safer - /// @param _spender The address of the account able to transfer the tokens - /// @param _amount The amount of tokens to be approved for transfer - /// @return True if the approval was successful - function approve(address _spender, uint256 _amount) public returns (bool success) { + function doApprove( + address _from, + address _spender, + uint256 _amount + ) + internal + returns (bool) + { require(transfersEnabled); // To change the approve amount you first have to reduce the addresses` // allowance to zero by calling `approve(_spender,0)` if it is not // already 0 to mitigate the race condition described here: // https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 - require((_amount == 0) || (allowed[msg.sender][_spender] == 0)); + require((_amount == 0) || (allowed[_from][_spender] == 0)); // Alerts the token controller of the approve function call if (isContract(controller)) { - require(TokenController(controller).onApprove(msg.sender, _spender, _amount)); + require(TokenController(controller).onApprove(_from, _spender, _amount)); } - allowed[msg.sender][_spender] = _amount; - Approval(msg.sender, _spender, _amount); + allowed[_from][_spender] = _amount; + emit Approval(_from, _spender, _amount); return true; } - /// @dev This function makes it easy to read the `allowed[]` map - /// @param _owner The address of the account that owns the token - /// @param _spender The address of the account able to transfer the tokens - /// @return Amount of remaining tokens of _owner that _spender is allowed - /// to spend + /** + * @param _owner The address that's balance is being requested + * @return The balance of `_owner` at the current block + */ + function balanceOf(address _owner) external view returns (uint256 balance) { + return balanceOfAt(_owner, block.number); + } + + /** + * @notice `msg.sender` approves `_spender` to spend `_amount` tokens on + * its behalf. This is a modified version of the ERC20 approve function + * to be a little bit safer + * @param _spender The address of the account able to transfer the tokens + * @param _amount The amount of tokens to be approved for transfer + * @return True if the approval was successful + */ + function approve(address _spender, uint256 _amount) external returns (bool success) { + doApprove(msg.sender, _spender, _amount); + } + + /** + * @dev This function makes it easy to read the `allowed[]` map + * @param _owner The address of the account that owns the token + * @param _spender The address of the account able to transfer the tokens + * @return Amount of remaining tokens of _owner that _spender is allowed + * to spend + */ function allowance( address _owner, address _spender ) - public - constant + external + view returns (uint256 remaining) { return allowed[_owner][_spender]; } - - /// @notice `msg.sender` approves `_spender` to send `_amount` tokens on - /// its behalf, and then a function is triggered in the contract that is - /// being approved, `_spender`. This allows users to use their tokens to - /// interact with contracts in one function call instead of two - /// @param _spender The address of the contract able to transfer the tokens - /// @param _amount The amount of tokens to be approved for transfer - /// @return True if the function call was successful + /** + * @notice `msg.sender` approves `_spender` to send `_amount` tokens on + * its behalf, and then a function is triggered in the contract that is + * being approved, `_spender`. This allows users to use their tokens to + * interact with contracts in one function call instead of two + * @param _spender The address of the contract able to transfer the tokens + * @param _amount The amount of tokens to be approved for transfer + * @return True if the function call was successful + */ function approveAndCall( address _spender, uint256 _amount, bytes _extraData ) - public + external returns (bool success) { - require(approve(_spender, _amount)); + require(doApprove(msg.sender, _spender, _amount)); ApproveAndCallFallBack(_spender).receiveApproval( msg.sender, @@ -291,9 +321,11 @@ contract MiniMeToken is MiniMeTokenInterface, Controlled { return true; } - /// @dev This function makes it easy to get the total number of tokens - /// @return The total number of tokens - function totalSupply() public constant returns (uint) { + /** + * @dev This function makes it easy to get the total number of tokens + * @return The total number of tokens + */ + function totalSupply() external view returns (uint) { return totalSupplyAt(block.number); } @@ -302,16 +334,18 @@ contract MiniMeToken is MiniMeTokenInterface, Controlled { // Query balance and totalSupply in History //////////////// - /// @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` + /** + * @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, uint _blockNumber ) public - constant + view returns (uint) { @@ -335,10 +369,12 @@ contract MiniMeToken is MiniMeTokenInterface, Controlled { } } - /// @notice Total amount of tokens at a specific `_blockNumber`. - /// @param _blockNumber The block number when the totalSupply is queried - /// @return The total amount of tokens at `_blockNumber` - function totalSupplyAt(uint _blockNumber) public constant returns(uint) { + /** + * @notice Total amount of tokens at a specific `_blockNumber`. + * @param _blockNumber The block number when the totalSupply is queried + * @return The total amount of tokens at `_blockNumber` + */ + function totalSupplyAt(uint _blockNumber) public view returns(uint) { // These next few lines are used when the totalSupply of the token is // requested before a check point was ever created for this token, it @@ -363,16 +399,18 @@ contract MiniMeToken is MiniMeTokenInterface, Controlled { // Clone Token Method //////////////// - /// @notice Creates a new clone token with the initial distribution being - /// this token at `_snapshotBlock` - /// @param _cloneTokenName Name of the clone token - /// @param _cloneDecimalUnits Number of decimals of the smallest unit - /// @param _cloneTokenSymbol Symbol of the clone token - /// @param _snapshotBlock Block when the distribution of the parent token is - /// copied to set the initial distribution of the new clone token; - /// if the block is zero than the actual block, the current block is used - /// @param _transfersEnabled True if transfers are allowed in the clone - /// @return The address of the new MiniMeToken Contract + /** + * @notice Creates a new clone token with the initial distribution being + * this token at `snapshotBlock` + * @param _cloneTokenName Name of the clone token + * @param _cloneDecimalUnits Number of decimals of the smallest unit + * @param _cloneTokenSymbol Symbol of the clone token + * @param snapshotBlock Block when the distribution of the parent token is + * copied to set the initial distribution of the new clone token; + * if the block is zero than the actual block, the current block is used + * @param _transfersEnabled True if transfers are allowed in the clone + * @return The address of the new MiniMeToken Contract + */ function createCloneToken( string _cloneTokenName, uint8 _cloneDecimalUnits, @@ -383,12 +421,13 @@ contract MiniMeToken is MiniMeTokenInterface, Controlled { public returns(address) { - if (_snapshotBlock == 0) { - _snapshotBlock = block.number; + uint snapshotBlock = _snapshotBlock; + if (snapshotBlock == 0) { + snapshotBlock = block.number; } MiniMeToken cloneToken = tokenFactory.createCloneToken( this, - _snapshotBlock, + snapshotBlock, _cloneTokenName, _cloneDecimalUnits, _cloneTokenSymbol, @@ -398,18 +437,20 @@ contract MiniMeToken is MiniMeTokenInterface, Controlled { cloneToken.changeController(msg.sender); // An event to make the token easy to find on the blockchain - NewCloneToken(address(cloneToken), _snapshotBlock); + emit NewCloneToken(address(cloneToken), snapshotBlock); return address(cloneToken); } //////////////// // Generate and destroy tokens //////////////// - - /// @notice Generates `_amount` tokens that are assigned to `_owner` - /// @param _owner The address that will be assigned the new tokens - /// @param _amount The quantity of tokens generated - /// @return True if the tokens are generated correctly + + /** + * @notice Generates `_amount` tokens that are assigned to `_owner` + * @param _owner The address that will be assigned the new tokens + * @param _amount The quantity of tokens generated + * @return True if the tokens are generated correctly + */ function generateTokens( address _owner, uint _amount @@ -418,21 +459,22 @@ contract MiniMeToken is MiniMeTokenInterface, Controlled { onlyController returns (bool) { - uint curTotalSupply = totalSupply(); + uint curTotalSupply = totalSupplyAt(block.number); require(curTotalSupply + _amount >= curTotalSupply); // Check for overflow - uint previousBalanceTo = balanceOf(_owner); + uint previousBalanceTo = balanceOfAt(_owner, block.number); require(previousBalanceTo + _amount >= previousBalanceTo); // Check for overflow updateValueAtNow(totalSupplyHistory, curTotalSupply + _amount); updateValueAtNow(balances[_owner], previousBalanceTo + _amount); - Transfer(0, _owner, _amount); + emit Transfer(0, _owner, _amount); return true; } - - /// @notice Burns `_amount` tokens from `_owner` - /// @param _owner The address that will lose the tokens - /// @param _amount The quantity of tokens to burn - /// @return True if the tokens are burned correctly + /** + * @notice Burns `_amount` tokens from `_owner` + * @param _owner The address that will lose the tokens + * @param _amount The quantity of tokens to burn + * @return True if the tokens are burned correctly + */ function destroyTokens( address _owner, uint _amount @@ -441,13 +483,13 @@ contract MiniMeToken is MiniMeTokenInterface, Controlled { onlyController returns (bool) { - uint curTotalSupply = totalSupply(); + uint curTotalSupply = totalSupplyAt(block.number); require(curTotalSupply >= _amount); - uint previousBalanceFrom = balanceOf(_owner); + uint previousBalanceFrom = balanceOfAt(_owner, block.number); require(previousBalanceFrom >= _amount); updateValueAtNow(totalSupplyHistory, curTotalSupply - _amount); updateValueAtNow(balances[_owner], previousBalanceFrom - _amount); - Transfer(_owner, 0, _amount); + emit Transfer(_owner, 0, _amount); return true; } @@ -455,9 +497,10 @@ contract MiniMeToken is MiniMeTokenInterface, Controlled { // Enable tokens transfers //////////////// - - /// @notice Enables token holders to transfer their tokens freely if true - /// @param _transfersEnabled True if transfers are allowed in the clone + /** + * @notice Enables token holders to transfer their tokens freely if true + * @param _transfersEnabled True if transfers are allowed in the clone + */ function enableTransfers(bool _transfersEnabled) public onlyController { transfersEnabled = _transfersEnabled; } @@ -466,10 +509,12 @@ contract MiniMeToken is MiniMeTokenInterface, Controlled { // Internal helper functions to query and set a value in a snapshot array //////////////// - /// @dev `getValueAt` retrieves the number of tokens 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 tokens being queried + /** + * @dev `getValueAt` retrieves the number of tokens 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 tokens being queried + */ function getValueAt( Checkpoint[] storage checkpoints, uint _block @@ -479,7 +524,7 @@ contract MiniMeToken is MiniMeTokenInterface, Controlled { returns (uint) { if (checkpoints.length == 0) { - return 0; + return 0; } // Shortcut for the actual value @@ -504,26 +549,30 @@ contract MiniMeToken is MiniMeTokenInterface, Controlled { 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 tokens + /** + * @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 tokens + */ function updateValueAtNow(Checkpoint[] storage checkpoints, uint _value) internal { 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); - } + 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); + } } - /// @dev Internal function to determine if an address is a contract - /// @param _addr The address being queried - /// @return True if `_addr` is a contract - function isContract(address _addr) constant internal returns(bool) { + /** + * @dev Internal function to determine if an address is a contract + * @param _addr The address being queried + * @return True if `_addr` is a contract + */ + function isContract(address _addr) internal view returns(bool) { uint size; if (_addr == 0){ return false; @@ -534,14 +583,18 @@ contract MiniMeToken is MiniMeTokenInterface, Controlled { return size>0; } - /// @dev Helper function to return a min betwen the two uints + /** + * @dev Helper function to return a min betwen the two uints + */ function min(uint a, uint b) internal returns (uint) { return a < b ? a : b; } - /// @notice The fallback function: If the contract's controller has not been - /// set to 0, then the `proxyPayment` method is called which relays the - /// ether and creates tokens as described in the token controller contract + /** + * @notice The fallback function: If the contract's controller has not been + * set to 0, then the `proxyPayment` method is called which relays the + * ether and creates tokens as described in the token controller contract + */ function () public payable { require(isContract(controller)); require(TokenController(controller).proxyPayment.value(msg.value)(msg.sender)); @@ -551,20 +604,22 @@ contract MiniMeToken is MiniMeTokenInterface, Controlled { // Safety Methods ////////// - /// @notice This method can be used by the controller to extract mistakenly - /// sent tokens to this contract. - /// @param _token The address of the token contract that you want to recover - /// set to 0 in case you want to extract ether. + /** + * @notice This method can be used by the controller to extract mistakenly + * sent tokens to this contract. + * @param _token The address of the token contract that you want to recover + * set to 0 in case you want to extract ether. + */ function claimTokens(address _token) public onlyController { if (_token == 0x0) { - controller.transfer(this.balance); + controller.transfer(address(this).balance); return; } MiniMeToken token = MiniMeToken(_token); - uint balance = token.balanceOf(this); + uint balance = token.balanceOf(address(this)); token.transfer(controller, balance); - ClaimedTokens(_token, controller, balance); + emit ClaimedTokens(_token, controller, balance); } //////////////// @@ -572,11 +627,11 @@ contract MiniMeToken is MiniMeTokenInterface, Controlled { //////////////// event ClaimedTokens(address indexed _token, address indexed _controller, uint _amount); event Transfer(address indexed _from, address indexed _to, uint256 _amount); - event NewCloneToken(address indexed _cloneToken, uint _snapshotBlock); + event NewCloneToken(address indexed _cloneToken, uint snapshotBlock); event Approval( address indexed _owner, address indexed _spender, uint256 _amount - ); + ); } \ No newline at end of file diff --git a/contracts/token/MiniMeTokenFactory.sol b/contracts/token/MiniMeTokenFactory.sol index a57eea4..92851d2 100644 --- a/contracts/token/MiniMeTokenFactory.sol +++ b/contracts/token/MiniMeTokenFactory.sol @@ -6,21 +6,25 @@ import "./MiniMeToken.sol"; // MiniMeTokenFactory //////////////// -/// @dev This contract is used to generate clone contracts from a contract. -/// In solidity this is the way to create a contract from a contract of the -/// same class +/** + * @dev This contract is used to generate clone contracts from a contract. + * In solidity this is the way to create a contract from a contract of the + * same class + */ contract MiniMeTokenFactory { - /// @notice Update the DApp by creating a new token with new functionalities - /// the msg.sender becomes the controller of this clone token - /// @param _parentToken Address of the token being cloned - /// @param _snapshotBlock Block of the parent token that will - /// determine the initial distribution of the clone token - /// @param _tokenName Name of the new token - /// @param _decimalUnits Number of decimals of the new token - /// @param _tokenSymbol Token Symbol for the new token - /// @param _transfersEnabled If true, tokens will be able to be transferred - /// @return The address of the new token contract + /** + * @notice Update the DApp by creating a new token with new functionalities + * the msg.sender becomes the controller of this clone token + * @param _parentToken Address of the token being cloned + * @param _snapshotBlock Block of the parent token that will + * determine the initial distribution of the clone token + * @param _tokenName Name of the new token + * @param _decimalUnits Number of decimals of the new token + * @param _tokenSymbol Token Symbol for the new token + * @param _transfersEnabled If true, tokens will be able to be transferred + * @return The address of the new token contract + */ function createCloneToken( address _parentToken, uint _snapshotBlock, diff --git a/contracts/token/MiniMeTokenInterface.sol b/contracts/token/MiniMeTokenInterface.sol index e315956..cc1300c 100644 --- a/contracts/token/MiniMeTokenInterface.sol +++ b/contracts/token/MiniMeTokenInterface.sol @@ -1,49 +1,19 @@ pragma solidity ^0.4.17; -contract MiniMeTokenInterface { +import "./ERC20Token.sol"; - event Transfer(address indexed _from, address indexed _to, uint256 _value); - event Approval(address indexed _owner, address indexed _spender, uint256 _value); - - /// @dev This function makes it easy to get the total number of tokens - /// @return The total number of tokens - function totalSupply() public constant returns (uint); - /// @param _owner The address from which the balance will be retrieved - /// @return The balance - function balanceOf(address _owner) public constant returns (uint256 balance); +contract MiniMeTokenInterface is ERC20Token { - /// @notice send `_value` token to `_to` from `msg.sender` - /// @param _to The address of the recipient - /// @param _value The amount of token to be transferred - /// @return Whether the transfer was successful or not - function transfer(address _to, uint256 _value) public returns (bool success); - - /// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from` - /// @param _from The address of the sender - /// @param _to The address of the recipient - /// @param _value The amount of token to be transferred - /// @return Whether the transfer was successful or not - function transferFrom(address _from, address _to, uint256 _value) public returns (bool success); - - /// @notice `msg.sender` approves `_spender` to spend `_value` tokens - /// @param _spender The address of the account able to transfer the tokens - /// @param _value The amount of tokens to be approved for transfer - /// @return Whether the approval was successful or not - function approve(address _spender, uint256 _value) public returns (bool success); - - /// @param _owner The address of the account owning tokens - /// @param _spender The address of the account able to transfer the tokens - /// @return Amount of remaining tokens allowed to spent - function allowance(address _owner, address _spender) public constant returns (uint256 remaining); - - /// @notice `msg.sender` approves `_spender` to send `_amount` tokens on - /// its behalf, and then a function is triggered in the contract that is - /// being approved, `_spender`. This allows users to use their tokens to - /// interact with contracts in one function call instead of two - /// @param _spender The address of the contract able to transfer the tokens - /// @param _amount The amount of tokens to be approved for transfer - /// @return True if the function call was successful + /** + * @notice `msg.sender` approves `_spender` to send `_amount` tokens on + * its behalf, and then a function is triggered in the contract that is + * being approved, `_spender`. This allows users to use their tokens to + * interact with contracts in one function call instead of two + * @param _spender The address of the contract able to transfer the tokens + * @param _amount The amount of tokens to be approved for transfer + * @return True if the function call was successful + */ function approveAndCall( address _spender, uint256 _amount, @@ -52,17 +22,18 @@ contract MiniMeTokenInterface { public returns (bool success); - - /// @notice Creates a new clone token with the initial distribution being - /// this token at `_snapshotBlock` - /// @param _cloneTokenName Name of the clone token - /// @param _cloneDecimalUnits Number of decimals of the smallest unit - /// @param _cloneTokenSymbol Symbol of the clone token - /// @param _snapshotBlock Block when the distribution of the parent token is - /// copied to set the initial distribution of the new clone token; - /// if the block is zero than the actual block, the current block is used - /// @param _transfersEnabled True if transfers are allowed in the clone - /// @return The address of the new MiniMeToken Contract + /** + * @notice Creates a new clone token with the initial distribution being + * this token at `_snapshotBlock` + * @param _cloneTokenName Name of the clone token + * @param _cloneDecimalUnits Number of decimals of the smallest unit + * @param _cloneTokenSymbol Symbol of the clone token + * @param _snapshotBlock Block when the distribution of the parent token is + * copied to set the initial distribution of the new clone token; + * if the block is zero than the actual block, the current block is used + * @param _transfersEnabled True if transfers are allowed in the clone + * @return The address of the new MiniMeToken Contract + */ function createCloneToken( string _cloneTokenName, uint8 _cloneDecimalUnits, @@ -72,11 +43,13 @@ contract MiniMeTokenInterface { ) public returns(address); - - /// @notice Generates `_amount` tokens that are assigned to `_owner` - /// @param _owner The address that will be assigned the new tokens - /// @param _amount The quantity of tokens generated - /// @return True if the tokens are generated correctly + + /** + * @notice Generates `_amount` tokens that are assigned to `_owner` + * @param _owner The address that will be assigned the new tokens + * @param _amount The quantity of tokens generated + * @return True if the tokens are generated correctly + */ function generateTokens( address _owner, uint _amount @@ -84,10 +57,12 @@ contract MiniMeTokenInterface { public returns (bool); - /// @notice Burns `_amount` tokens from `_owner` - /// @param _owner The address that will lose the tokens - /// @param _amount The quantity of tokens to burn - /// @return True if the tokens are burned correctly + /** + * @notice Burns `_amount` tokens from `_owner` + * @param _owner The address that will lose the tokens + * @param _amount The quantity of tokens to burn + * @return True if the tokens are burned correctly + */ function destroyTokens( address _owner, uint _amount @@ -95,22 +70,26 @@ contract MiniMeTokenInterface { public returns (bool); - - /// @notice Enables token holders to transfer their tokens freely if true - /// @param _transfersEnabled True if transfers are allowed in the clone + /** + * @notice Enables token holders to transfer their tokens freely if true + * @param _transfersEnabled True if transfers are allowed in the clone + */ function enableTransfers(bool _transfersEnabled) public; - - /// @notice This method can be used by the controller to extract mistakenly - /// sent tokens to this contract. - /// @param _token The address of the token contract that you want to recover - /// set to 0 in case you want to extract ether. + /** + * @notice This method can be used by the controller to extract mistakenly + * sent tokens to this contract. + * @param _token The address of the token contract that you want to recover + * set to 0 in case you want to extract ether. + */ function claimTokens(address _token) public; - /// @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` + /** + * @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, uint _blockNumber @@ -119,11 +98,11 @@ contract MiniMeTokenInterface { constant returns (uint); - /// @notice Total amount of tokens at a specific `_blockNumber`. - /// @param _blockNumber The block number when the totalSupply is queried - /// @return The total amount of tokens at `_blockNumber` - function totalSupplyAt(uint _blockNumber) public constant returns(uint); - - + /** + * @notice Total amount of tokens at a specific `_blockNumber`. + * @param _blockNumber The block number when the totalSupply is queried + * @return The total amount of tokens at `_blockNumber` + */ + function totalSupplyAt(uint _blockNumber) public view returns(uint); } \ No newline at end of file diff --git a/contracts/token/StandardToken.sol b/contracts/token/StandardToken.sol index 10ca74a..d42852c 100644 --- a/contracts/token/StandardToken.sol +++ b/contracts/token/StandardToken.sol @@ -4,23 +4,24 @@ import "./ERC20Token.sol"; contract StandardToken is ERC20Token { + uint256 private supply; mapping (address => uint256) balances; mapping (address => mapping (address => uint256)) allowed; constructor() internal { } - + function transfer( address _to, uint256 _value ) - public + external returns (bool success) { return transfer(msg.sender, _to, _value); } function approve(address _spender, uint256 _value) - public + external returns (bool success) { allowed[msg.sender][_spender] = _value; @@ -33,7 +34,7 @@ contract StandardToken is ERC20Token { address _to, uint256 _value ) - public + external returns (bool success) { if (balances[_from] >= _value && @@ -47,7 +48,7 @@ contract StandardToken is ERC20Token { } function allowance(address _owner, address _spender) - public + external view returns (uint256 remaining) { @@ -55,12 +56,31 @@ contract StandardToken is ERC20Token { } function balanceOf(address _owner) - public + external view returns (uint256 balance) { return balances[_owner]; } + + function totalSupply() + external + view + returns(uint256 supply) + { + return supply; + } + + function mint( + address _to, + uint256 _amount + ) + internal + { + balances[_to] += _amount; + supply += _amount; + emit Transfer(0x0, _to, _amount); + } function transfer( address _from, diff --git a/contracts/token/TestToken.sol b/contracts/token/TestToken.sol new file mode 100644 index 0000000..2afff21 --- /dev/null +++ b/contracts/token/TestToken.sol @@ -0,0 +1,19 @@ +pragma solidity ^0.4.23; + +import "./StandardToken.sol"; + +/** + * @notice ERC20Token for test scripts, can be minted by anyone. + */ +contract TestToken is StandardToken { + + constructor() public { } + + /** + * @notice any caller can mint any `_amount` + * @param _amount how much to be minted + */ + function mint(uint256 _amount) public { + mint(msg.sender, _amount); + } +} diff --git a/contracts/token/TokenController.sol b/contracts/token/TokenController.sol index 9dd7f91..b70a228 100644 --- a/contracts/token/TokenController.sol +++ b/contracts/token/TokenController.sol @@ -1,26 +1,33 @@ pragma solidity ^0.4.14; - -/// @dev The token controller contract must implement these functions +/** + * @dev The token controller contract must implement these functions + */ contract TokenController { - /// @notice Called when `_owner` sends ether to the MiniMe Token contract - /// @param _owner The address that sent the ether to create tokens - /// @return True if the ether is accepted, false if it throws + /** + * @notice Called when `_owner` sends ether to the MiniMe Token contract + * @param _owner The address that sent the ether to create tokens + * @return True if the ether is accepted, false if it throws + */ function proxyPayment(address _owner) payable returns(bool); - /// @notice Notifies the controller about a token transfer allowing the - /// controller to react if desired - /// @param _from The origin of the transfer - /// @param _to The destination of the transfer - /// @param _amount The amount of the transfer - /// @return False if the controller does not authorize the transfer + /** + * @notice Notifies the controller about a token transfer allowing the + * controller to react if desired + * @param _from The origin of the transfer + * @param _to The destination of the transfer + * @param _amount The amount of the transfer + * @return False if the controller does not authorize the transfer + */ function onTransfer(address _from, address _to, uint _amount) returns(bool); - /// @notice Notifies the controller about an approval allowing the - /// controller to react if desired - /// @param _owner The address that calls `approve()` - /// @param _spender The spender in the `approve()` call - /// @param _amount The amount in the `approve()` call - /// @return False if the controller does not authorize the approval + /** + * @notice Notifies the controller about an approval allowing the + * controller to react if desired + * @param _owner The address that calls `approve()` + * @param _spender The spender in the `approve()` call + * @param _amount The amount in the `approve()` call + * @return False if the controller does not authorize the approval + */ function onApprove(address _owner, address _spender, uint _amount) returns(bool); }