/**
*Submitted for verification at Etherscan.io on 2019-07-02
*/
/**
/**
*Submitted for verification at Etherscan.io on 2019-05-21
*Submitted for verification at Etherscan.io on 2019-05-21
*/
*/
pragma solidity ^0.5.0;
pragma solidity ^0.5.0;
// Bitfinex LEO Token 2019
// Bitfinex LEO Token 2019
// Based on Giveth's MiniMe Token framework
// Based on Giveth's MiniMe Token framework
contract Ownable {
contract Ownable {
address public owner;
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
constructor() public {
owner = msg.sender;
owner = msg.sender;
}
}
modifier onlyOwner() {
modifier onlyOwner() {
require(msg.sender == owner);
require(msg.sender == owner);
_;
_;
}
}
function transferOwnership(address newOwner) public onlyOwner {
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
owner = newOwner;
}
}
}
}
// Modified 2019, Will Harborne
// Modified 2019, Will Harborne
/*
/*
Copyright 2016, Jordi Baylina
Copyright 2016, Jordi Baylina
This program is free software: you can redistribute it and/or modify
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
(at your option) any later version.
This program is distributed in the hope that it will be useful,
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
*/
/// @title MiniMeToken Contract
/// @title MiniMeToken Contract
/// @author Jordi Baylina
/// @author Jordi Baylina
/// @dev This token contract's goal is to make it easy for anyone to clone this
/// @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
/// 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
/// and DApps to upgrade their features in a decentralized manner without
/// affecting the original token
/// affecting the original token
/// @dev It is ERC20 compliant, but still needs to under go further testing.
/// @dev It is ERC20 compliant, but still needs to under go further testing.
contract Controlled {
contract Controlled {
event ControlTransferred(address indexed previousControler, address indexed newController);
event ControlTransferred(address indexed previousControler, address indexed newController);
/// @notice The address of the controller is the only address that can call
/// @notice The address of the controller is the only address that can call
/// a function with this modifier
/// a function with this modifier
modifier onlyController { require(msg.sender == controller); _; }
modifier onlyController { require(msg.sender == controller); _; }
address public controller;
address public controller;
constructor() public { controller = msg.sender;}
constructor() public { controller = msg.sender;}
/// @notice Changes the controller of the contract
/// @notice Changes the controller of the contract
/// @param _newController The new controller of the contract
/// @param _newController The new controller of the contract
function changeController(address _newController) public onlyController {
function changeController(address _newController) public onlyController {
emit ControlTransferred(controller, _newController);
emit ControlTransferred(controller, _newController);
controller = _newController;
controller = _newController;
}
}
}
}
contract TokenController {
contract TokenController {
/// @notice Called when `_owner` sends ether to the MiniMe Token contract
/// @notice Called when `_owner` sends ether to the MiniMe Token contract
/// @param _owner The address that sent the ether to create tokens
/// @param _owner The address that sent the ether to create tokens
/// @return True if the ether is accepted, false if it throws
/// @return True if the ether is accepted, false if it throws
function proxyPayment(address _owner) public payable returns(bool);
function proxyPayment(address _owner) public payable returns(bool);
/// @notice Notifies the controller about a token transfer allowing the
/// @notice Notifies the controller about a token transfer allowing the
/// controller to react if desired
/// controller to react if desired
/// @param _from The origin of the transfer
/// @param _from The origin of the transfer
/// @param _to The destination of the transfer
/// @param _to The destination of the transfer
/// @param _amount The amount of the transfer
/// @param _amount The amount of the transfer
/// @return False if the controller does not authorize the transfer
/// @return False if the controller does not authorize the transfer
function onTransfer(address _from, address _to, uint _amount) public returns(bool);
function onTransfer(address _from, address _to, uint _amount) public returns(bool);
/// @notice Notifies the controller about an approval allowing the
/// @notice Notifies the controller about an approval allowing the
/// controller to react if desired
/// controller to react if desired
/// @param _owner The address that calls `approve()`
/// @param _owner The address that calls `approve()`
/// @param _spender The spender in the `approve()` call
/// @param _spender The spender in the `approve()` call
/// @param _amount The amount in the `approve()` call
/// @param _amount The amount in the `approve()` call
/// @return False if the controller does not authorize the approval
/// @return False if the controller does not authorize the approval
function onApprove(address _owner, address _spender, uint _amount) public
function onApprove(address _owner, address _spender, uint _amount) public
returns(bool);
returns(bool);
}
}
contract ApproveAndCallFallBack {
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 _amount, address _token, bytes memory _data) public;
function receiveApproval(address from, uint256 _amount, address _token, bytes memory _data) public;
}
}
/// @dev The actual token contract, the default controller is the msg.sender
/// @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
/// that deploys the contract, so usually this token will be deployed by a
/// token controller contract, which Giveth will call a "Campaign"
/// token controller contract, which Giveth will call a "Campaign"
/// @dev The actual token contract, the default controller is the msg.sender
/// @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
/// that deploys the contract, so usually this token will be deployed by a
/// token controller contract, which Giveth will call a "Campaign"
/// token controller contract, which Giveth will call a "Campaign"
contract MiniMeToken is Controlled {
contract MiniMeToken is Controlled {
string public name; //The Token's name: e.g. DigixDAO Tokens
string public name; //The Token's name: e.g. DigixDAO Tokens
uint8 public decimals; //Number of decimals of the smallest unit
uint8 public decimals; //Number of decimals of the smallest unit
string public symbol; //An identifier: e.g. REP
string public symbol; //An identifier: e.g. REP
string public version = '3.0.0'; //An arbitrary versioning scheme
string public version = '3.0.0'; //An arbitrary versioning scheme
/// @dev `Checkpoint` is the structure that attaches a block number to a
/// @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
/// given value, the block number attached is the one that last changed the
/// value
/// value
struct Checkpoint {
struct Checkpoint {
// `fromBlock` is the block number that the value was generated from
// `fromBlock` is the block number that the value was generated from
uint256 fromBlock;
uint256 fromBlock;
// `value` is the amount of tokens at a specific block number
// `value` is the amount of tokens at a specific block number
uint256 value;
uint256 value;
}
}
// `parentToken` is the Token address that was cloned to produce this token;
// `parentToken` is the Token address that was cloned to produce this token;
// it will be 0x0 for a token that was not cloned
// it will be 0x0 for a token that was not cloned
MiniMeToken public parentToken;
MiniMeToken public parentToken;
// `parentSnapShotBlock` is the block number from the Parent Token that was
// `parentSnapShotBlock` is the block number from the Parent Token that was
// used to determine the initial distribution of the Clone Token
// used to determine the initial distribution of the Clone Token
uint public parentSnapShotBlock;
uint public parentSnapShotBlock;
// `creationBlock` is the block number that the Clone Token was created
// `creationBlock` is the block number that the Clone Token was created
uint public creationBlock;
uint public creationBlock;
// `balances` is the map that tracks the balance of each address, in this
// `balances` is the map that tracks the balance of each address, in this
// contract when the balance changes the block number that the change
// contract when the balance changes the block number that the change
// occurred is also included in the map
// occurred is also included in the map
mapping (address => Checkpoint[]) balances;
mapping (address => Checkpoint[]) balances;
// `allowed` tracks any extra transfer rights as in all ERC20 tokens
// `allowed` tracks any extra transfer rights as in all ERC20 tokens
mapping (address => mapping (address => uint256)) allowed;
mapping (address => mapping (address => uint256)) allowed;
// Tracks the history of the `totalSupply` of the token
// Tracks the history of the `totalSupply` of the token
Checkpoint[] totalSupplyHistory;
Checkpoint[] totalSupplyHistory;
// Flag that determines if the token is transferable or not.
// Flag that determines if the token is transferable or not.
bool public transfersEnabled;
bool public transfersEnabled;
// The factory used to create new clone tokens
// The factory used to create new clone tokens
MiniMeTokenFactory public tokenFactory;
MiniMeTokenFactory public tokenFactory;
////////////////
////////////////
// Constructor
// Constructor
////////////////
////////////////
/// @notice Constructor to create a MiniMeToken
/// @notice Constructor to create a MiniMeToken
/// @param _tokenFactory The address of the MiniMeTokenFactory contract that
/// @param _tokenFactory The address of the MiniMeTokenFactory contract that
/// will create the Clone token contracts, the token factory needs to be
/// will create the Clone token contracts, the token factory needs to be
/// deployed first
/// deployed first
/// @param _parentToken Address of the parent token, set to 0x0 if it is a
/// @param _parentToken Address of the parent token, set to 0x0 if it is a
/// new token
/// new token
/// @param _parentSnapShotBlock Block of the parent token that will
/// @param _parentSnapShotBlock Block of the parent token that will
/// determine the initial distribution of the clone token, set to 0 if it
/// determine the initial distribution of the clone token, set to 0 if it
/// is a new token
/// is a new token
/// @param _tokenName Name of the new token
/// @param _tokenName Name of the new token
/// @param _decimalUnits Number of decimals of the new token
/// @param _decimalUnits Number of decimals of the new token
/// @param _tokenSymbol Token Symbol for the new token
/// @param _tokenSymbol Token Symbol for the new token
/// @param _transfersEnabled If true, tokens will be able to be transferred
/// @param _transfersEnabled If true, tokens will be able to be transferred
constructor(
constructor(
address _tokenFactory,
address _tokenFactory,
address payable _parentToken,
address payable _parentToken,
uint _parentSnapShotBlock,
uint _parentSnapShotBlock,
string memory _tokenName,
string memory _tokenName,
uint8 _decimalUnits,
uint8 _decimalUnits,
string memory _tokenSymbol,
string memory _tokenSymbol,
bool _transfersEnabled
bool _transfersEnabled
) public {
) public {
tokenFactory = MiniMeTokenFactory(_tokenFactory);
tokenFactory = MiniMeTokenFactory(_tokenFactory);
name = _tokenName; // Set the name
name = _tokenName; // Set the name
decimals = _decimalUnits; // Set the decimals
decimals = _decimalUnits; // Set the decimals
symbol = _tokenSymbol; // Set the symbol
symbol = _tokenSymbol; // Set the symbol
parentToken = MiniMeToken(_parentToken);
parentToken = MiniMeToken(_parentToken);
parentSnapShotBlock = _parentSnapShotBlock;
parentSnapShotBlock = _parentSnapShotBlock;
transfersEnabled = _transfersEnabled;
transfersEnabled = _transfersEnabled;
creationBlock = block.number;
creationBlock = block.number;
}
}
///////////////////
///////////////////
// ERC20 Methods
// ERC20 Methods
///////////////////
///////////////////
uint constant MAX_UINT = 2**256 - 1;
uint constant MAX_UINT = 2**256 - 1;
/// @notice Send `_amount` tokens to `_to` from `msg.sender`
/// @notice Send `_amount` tokens to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _to The address of the recipient
/// @param _amount The amount of tokens to be transferred
/// @param _amount The amount of tokens to be transferred
/// @return Whether the transfer was successful or not
/// @return Whether the transfer was successful or not
function transfer(address _to, uint256 _amount) public returns (bool success) {
function transfer(address _to, uint256 _amount) public returns (bool success) {
require(transfersEnabled);
require(transfersEnabled);
doTransfer(msg.sender, _to, _amount);
doTransfer(msg.sender, _to, _amount);
return true;
return true;
}
}
/// @notice Send `_amount` tokens to `_to` from `_from` on the condition it
/// @notice Send `_amount` tokens to `_to` from `_from` on the condition it
/// is approved by `_from`
/// is approved by `_from`
/// @param _from The address holding the tokens being transferred
/// @param _from The address holding the tokens being transferred
/// @param _to The address of the recipient
/// @param _to The address of the recipient
/// @param _amount The amount of tokens to be transferred
/// @param _amount The amount of tokens to be transferred
/// @return True if the transfer was successful
/// @return True if the transfer was successful
function transferFrom(address _from, address _to, uint256 _amount
function transferFrom(address _from, address _to, uint256 _amount
) public returns (bool success) {
) public returns (bool success) {
// The controller of this contract can move tokens around at will,
// The controller of this contract can move tokens around at will,
// this is important to recognize! Confirm that you trust the
// this is important to recognize! Confirm that you trust the
// controller of this contract, which in most situations should be
// controller of this contract, which in most situations should be
// another open source smart contract or 0x0
// another open source smart contract or 0x0
if (msg.sender != controller) {
if (msg.sender != controller) {
require(transfersEnabled);
require(transfersEnabled);
// The standard ERC 20 transferFrom functionality
// The standard ERC 20 transferFrom functionality
if (allowed[_from][msg.sender] < MAX_UINT) {
if (allowed[_from][msg.sender] < MAX_UINT) {
require(allowed[_from][msg.sender] >= _amount);
require(allowed[_from][msg.sender] >= _amount);
allowed[_from][msg.sender] -= _amount;
allowed[_from][msg.sender] -= _amount;
}
}
}
}
doTransfer(_from, _to, _amount);
doTransfer(_from, _to, _amount);
return true;
return true;
}
}
/// @dev This is the actual transfer function in the token contract, it can
/// @dev This is the actual transfer function in the token contract, it can
/// only be called by other functions in this contract.
/// only be called by other functions in this contract.
/// @param _from The address holding the tokens being transferred
/// @param _from The address holding the tokens being transferred
/// @param _to The address of the recipient
/// @param _to The address of the recipient
/// @param _amount The amount of tokens to be transferred
/// @param _amount The amount of tokens to be transferred
/// @return True if the transfer was successful
/// @return True if the transfer was successful
function doTransfer(address _from, address _to, uint _amount
function doTransfer(address _from, address _to, uint _amount
) internal {
) internal {
if (_amount == 0) {
if (_amount == 0) {
emit Transfer(_from, _to, _amount); // Follow the spec to louch the event when transfer 0
emit Transfer(_from, _to, _amount); // Follow the spec to louch the event when transfer 0
return;
return;
}
}
require(parentSnapShotBlock < block.number);
require(parentSnapShotBlock < block.number);
// Do not allow transfer to 0x0 or the token contract itself
// Do not allow transfer to 0x0 or the token contract itself
require((_to != address(0)) && (_to != address(this)));
require((_to != address(0)) && (_to != address(this)));
// If the amount being transfered is more than the balance of the
// If the amount being transfered is more than the balance of the
// account the transfer throws
// account the transfer throws
uint256 previousBalanceFrom = balanceOfAt(_from, block.number);
uint256 previousBalanceFrom = balanceOfAt(_from, block.number);
require(previousBalanceFrom >= _amount);
require(previousBalanceFrom >= _amount);
// Alerts the token controller of the transfer
// Alerts the token controller of the transfer
if (isContract(controller)) {
if (isContract(controller)) {
require(TokenController(controller).onTransfer(_from, _to, _amount));
require(TokenController(controller).onTransfer(_from, _to, _amount));
}
}
// First update the balance array with the new value for the address
// First update the balance array with the new value for the address
// sending the tokens
// sending the tokens
updateValueAtNow(balances[_from], previousBalanceFrom - _amount);
updateValueAtNow(balances[_from], previousBalanceFrom - _amount);
// Then update the balance array with the new value for the address
// Then update the balance array with the new value for the address
// receiving the tokens
// receiving the tokens
uint256 previousBalanceTo = balanceOfAt(_to, block.number);
uint256 previousBalanceTo = balanceOfAt(_to, block.number);
require(previousBalanceTo + _amount >= previousBalanceTo); // Check for overflow
require(previousBalanceTo + _amount >= previousBalanceTo); // Check for overflow
updateValueAtNow(balances[_to], previousBalanceTo + _amount);
updateValueAtNow(balances[_to], previousBalanceTo + _amount);
// An event to make the transfer easy to find on the blockchain
// An event to make the transfer easy to find on the blockchain
emit Transfer(_from, _to, _amount);
emit Transfer(_from, _to, _amount);
}
}
/// @param _owner The address that's balance is being requested
/// @param _owner The address that's balance is being requested
/// @return The balance of `_owner` at the current block
/// @return The balance of `_owner` at the current block
function balanceOf(address _owner) public view returns (uint256 balance) {
function balanceOf(address _owner) public view returns (uint256 balance) {
return balanceOfAt(_owner, block.number);
return balanceOfAt(_owner, block.number);
}
}
/// @notice `msg.sender` approves `_spender` to spend `_amount` tokens on
/// @notice `msg.sender` approves `_spender` to spend `_amount` tokens on
/// its behalf. This is a modified version of the ERC20 approve function
/// its behalf. This is a modified version of the ERC20 approve function
/// to be a little bit safer
/// to be a little bit safer
/// @param _spender The address of the account able to transfer the tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _amount The amount of tokens to be approved for transfer
/// @param _amount The amount of tokens to be approved for transfer
/// @return True if the approval was successful
/// @return True if the approval was successful
function approve(address _spender, uint256 _amount) public returns (bool success) {
function approve(address _spender, uint256 _amount) public returns (bool success) {
require(transfersEnabled);
require(transfersEnabled);
// To change the approve amount you first have to reduce the addresses`
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender,0)` if it is not
// allowance to zero by calling `approve(_spender,0)` if it is not
// already 0 to mitigate the race condition described here:
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
require((_amount == 0) || (allowed[msg.sender][_spender] == 0));
require((_amount == 0) || (allowed[msg.sender][_spender] == 0));
// Alerts the token controller of the approve function call
// Alerts the token controller of the approve function call
if (isContract(controller)) {
if (isContract(controller)) {
require(TokenController(controller).onApprove(msg.sender, _spender, _amount));
require(TokenController(controller).onApprove(msg.sender, _spender, _amount));
}
}
allowed[msg.sender][_spender] = _amount;
allowed[msg.sender][_spender] = _amount;
emit Approval(msg.sender, _spender, _amount);
emit Approval(msg.sender, _spender, _amount);
return true;
return true;
}
}
/// @dev This function makes it easy to read the `allowed[]` map
/// @dev This function makes it easy to read the `allowed[]` map
/// @param _owner The address of the account that owns the token
/// @param _owner The address of the account that owns the token
/// @param _spender The address of the account able to transfer the tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens of _owner that _spender is allowed
/// @return Amount of remaining tokens of _owner that _spender is allowed
/// to spend
/// to spend
function allowance(address _owner, address _spender
function allowance(address _owner, address _spender
) public view returns (uint256 remaining) {
) public view returns (uint256 remaining) {
return allowed[_owner][_spender];
return allowed[_owner][_spender];
}
}
/// @notice `msg.sender` approves `_spender` to send `_amount` tokens on
/// @notice `msg.sender` approves `_spender` to send `_amount` tokens on
/// its behalf, and then a function is triggered in the contract that is
/// its behalf, and then a function is triggered in the contract that is
/// being approved, `_spender`. This allows users to use their tokens to
/// being approved, `_spender`. This allows users to use their tokens to
/// interact with contracts in one function call instead of two
/// interact with contracts in one function call instead of two
/// @param _spender The address of the contract able to transfer the tokens
/// @param _spender The address of the contract able to transfer the tokens
/// @param _amount The amount of tokens to be approved for transfer
/// @param _amount The amount of tokens to be approved for transfer
/// @return True if the function call was successful
/// @return True if the function call was successful
function approveAndCall(address _spender, uint256 _amount, bytes memory _extraData
function approveAndCall(address _spender, uint256 _amount, bytes memory _extraData
) public returns (bool success) {
) public returns (bool success) {
require(approve(_spender, _amount));
require(approve(_spender, _amount));
ApproveAndCallFallBack(_spender).receiveApproval(
ApproveAndCallFallBack(_spender).receiveApproval(
msg.sender,
msg.sender,
_amount,
_amount,
address(this),
address(this),
_extraData
_extraData
);
);
return true;
return true;
}
}
/// @dev This function makes it easy to get the total number of tokens
/// @dev This function makes it easy to get the total number of tokens
/// @return The total number of tokens
/// @return The total number of tokens
function totalSupply() public view returns (uint) {
function totalSupply() public view returns (uint) {
return totalSupplyAt(block.number);
return totalSupplyAt(block.number);
}
}
////////////////
////////////////
// Query balance and totalSupply in History
// Query balance and totalSupply in History
////////////////
////////////////
/// @dev Queries the balance of `_owner` at a specific `_blockNumber`
/// @dev Queries the balance of `_owner` at a specific `_blockNumber`
/// @param _owner The address from which the balance will be retrieved
/// @param _owner The address from which the balance will be retrieved
/// @param _blockNumber The block number when the balance is queried
/// @param _blockNumber The block number when the balance is queried
/// @return The balance at `_blockNumber`
/// @return The balance at `_blockNumber`
function balanceOfAt(address _owner, uint _blockNumber) public view
function balanceOfAt(address _owner, uint _blockNumber) public view
returns (uint) {
returns (uint) {
// These next few lines are used when the balance of the token is
// These next few lines are used when the balance of the token is
// requested before a check point was ever created for this token, it
// requested before a check point was ever created for this token, it
// requires that the `parentToken.balanceOfAt` be queried at the
// requires that the `parentToken.balanceOfAt` be queried at the
// genesis block for that token as this contains initial balance of
// genesis block for that token as this contains initial balance of
// this token
// this token
if ((balances[_owner].length == 0)
if ((balances[_owner].length == 0)
|| (balances[_owner][0].fromBlock > _blockNumber)) {
|| (balances[_owner][0].fromBlock > _blockNumber)) {
if (address(parentToken) != address(0)) {
if (address(parentToken) != address(0)) {
return parentToken.balanceOfAt(_owner, min(_blockNumber, parentSnapShotBlock));
return parentToken.balanceOfAt(_owner, min(_blockNumber, parentSnapShotBlock));
} else {
} else {
// Has no parent
// Has no parent
return 0;
return 0;
}
}
// This will return the expected balance during normal situations
// This will return the expected balance during normal situations
} else {
} else {
return getValueAt(balances[_owner], _blockNumber);
return getValueAt(balances[_owner], _blockNumber);
}
}
}
}
/// @notice Total amount of tokens at a specific `_blockNumber`.
/// @notice Total amount of tokens at a specific `_blockNumber`.
/// @param _blockNumber The block number when the totalSupply is queried
/// @param _blockNumber The block number when the totalSupply is queried
/// @return The total amount of tokens at `_blockNumber`
/// @return The total amount of tokens at `_blockNumber`
function totalSupplyAt(uint _blockNumber) public view returns(uint) {
function totalSupplyAt(uint _blockNumber) public view returns(uint) {
// These next few lines are used when the totalSupply of the token is
// 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
// requested before a check point was ever created for this token, it
// requires that the `parentToken.totalSupplyAt` be queried at the
// requires that the `parentToken.totalSupplyAt` be queried at the
// genesis block for this token as that contains totalSupply of this
// genesis block for this token as that contains totalSupply of this
// token at this block number.
// token at this block number.
if ((totalSupplyHistory.length == 0)
if ((totalSupplyHistory.length == 0)
|| (totalSupplyHistory[0].fromBlock > _blockNumber)) {
|| (totalSupplyHistory[0].fromBlock > _blockNumber)) {
if (address(parentToken) != address(0)) {
if (address(parentToken) != address(0)) {
return parentToken.totalSupplyAt(min(_blockNumber, parentSnapShotBlock));
return parentToken.totalSupplyAt(min(_blockNumber, parentSnapShotBlock));
} else {
} else {
return 0;
return 0;
}
}
// This will return the expected totalSupply during normal situations
// This will return the expected totalSupply during normal situations
} else {
} else {
return getValueAt(totalSupplyHistory, _blockNumber);
return getValueAt(totalSupplyHistory, _blockNumber);
}
}
}
}
////////////////
////////////////
// Clone Token Method
// Clone Token Method
////////////////
////////////////
/// @notice Creates a new clone token with the initial distribution being
/// @notice Creates a new clone token with the initial distribution being
/// this token at `_snapshotBlock`
/// this token at `_snapshotBlock`
/// @param _cloneTokenName Name of the clone token
/// @param _cloneTokenName Name of the clone token
/// @param _cloneDecimalUnits Number of decimals of the smallest unit
/// @param _cloneDecimalUnits Number of decimals of the smallest unit
/// @param _cloneTokenSymbol Symbol of the clone token
/// @param _cloneTokenSymbol Symbol of the clone token
/// @param _snapshotBlock Block when the distribution of the parent token is
/// @param _snapshotBlock Block when the distribution of the parent token is
/// copied to set the initial distribution of the new clone token;
/// 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
/// if the block is zero than the actual block, the current block is used
/// @param _transfersEnabled True if transfers are allowed in the clone
/// @param _transfersEnabled True if transfers are allowed in the clone
/// @return The address of the new MiniMeToken Contract
/// @return The address of the new MiniMeToken Contract
function createCloneToken(
function createCloneToken(
string memory _cloneTokenName,
string memory _cloneTokenName,
uint8 _cloneDecimalUnits,
uint8 _cloneDecimalUnits,
string memory _cloneTokenSymbol,
string memory _cloneTokenSymbol,
uint _snapshotBlock,
uint _snapshotBlock,
bool _transfersEnabled
bool _transfersEnabled
) public returns(address) {
) public returns(address) {
if (_snapshotBlock == 0) _snapshotBlock = block.number;
if (_snapshotBlock == 0) _snapshotBlock = block.number;
MiniMeToken cloneToken = tokenFactory.createCloneToken(
MiniMeToken cloneToken = tokenFactory.createCloneToken(
address(this),
address(this),
_snapshotBlock,
_snapshotBlock,
_cloneTokenName,
_cloneTokenName,
_cloneDecimalUnits,
_cloneDecimalUnits,
_cloneTokenSymbol,
_cloneTokenSymbol,
_transfersEnabled
_transfersEnabled
);
);
cloneToken.changeController(msg.sender);
cloneToken.changeController(msg.sender);
// An event to make the token easy to find on the blockchain
// An event to make the token easy to find on the blockchain
emit NewCloneToken(address(cloneToken), _snapshotBlock);
emit NewCloneToken(address(cloneToken), _snapshotBlock);
return address(cloneToken);
return address(cloneToken);
}
}
////////////////
////////////////
// Generate and destroy tokens
// Generate and destroy tokens
////////////////
////////////////
/// @notice Generates `_amount` tokens that are assigned to `_owner`
/// @notice Generates `_amount` tokens that are assigned to `_owner`
/// @param _owner The address that will be assigned the new tokens
/// @param _owner The address that will be assigned the new tokens
/// @param _amount The quantity of tokens generated
/// @param _amount The quantity of tokens generated
/// @return True if the tokens are generated correctly
/// @return True if the tokens are generated correctly
function generateTokens(address _owner, uint _amount
function generateTokens(address _owner, uint _amount
) public onlyController returns (bool) {
) public onlyController returns (bool) {
uint curTotalSupply = totalSupply();
uint curTotalSupply = totalSupply();
require(curTotalSupply + _amount >= curTotalSupply); // Check for overflow
require(curTotalSupply + _amount >= curTotalSupply); // Check for overflow
uint previousBalanceTo = balanceOf(_owner);
uint previousBalanceTo = balanceOf(_owner);
require(previousBalanceTo + _amount >= previousBalanceTo); // Check for overflow
require(previousBalanceTo + _amount >= previousBalanceTo); // Check for overflow
updateValueAtNow(totalSupplyHistory, curTotalSupply + _amount);
updateValueAtNow(totalSupplyHistory, curTotalSupply + _amount);
updateValueAtNow(balances[_owner], previousBalanceTo + _amount);
updateValueAtNow(balances[_owner], previousBalanceTo + _amount);
emit Transfer(address(0), _owner, _amount);
emit Transfer(address(0), _owner, _amount);
return true;
return true;
}
}
/// @notice Burns `_amount` tokens from `_owner`
/// @notice Burns `_amount` tokens from `_owner`
/// @param _owner The address that will lose the tokens
/// @param _owner The address that will lose the tokens
/// @param _amount The quantity of tokens to burn
/// @param _amount The quantity of tokens to burn
/// @return True if the tokens are burned correctly
/// @return True if the tokens are burned correctly
function destroyTokens(address _owner, uint _amount
function destroyTokens(address _owner, uint _amount
) onlyController public returns (bool) {
) onlyController public returns (bool) {
uint curTotalSupply = totalSupply();
uint curTotalSupply = totalSupply();
require(curTotalSupply >= _amount);
require(curTotalSupply >= _amount);
uint previousBalanceFrom = balanceOf(_owner);
uint previousBalanceFrom = balanceOf(_owner);
require(previousBalanceFrom >= _amount);
require(previousBalanceFrom >= _amount);
updateValueAtNow(totalSupplyHistory, curTotalSupply - _amount);
updateValueAtNow(totalSupplyHistory, curTotalSupply - _amount);
updateValueAtNow(balances[_owner], previousBalanceFrom - _amount);
updateValueAtNow(balances[_owner], previousBalanceFrom - _amount);
emit Transfer(_owner, address(0), _amount);
emit Transfer(_owner, address(0), _amount);
return true;
return true;
}
}
////////////////
////////////////
// Enable tokens transfers
// Enable tokens transfers
////////////////
////////////////
/// @notice Enables token holders to transfer their tokens freely if true
/// @notice Enables token holders to transfer their tokens freely if true
/// @param _transfersEnabled True if transfers are allowed in the clone
/// @param _transfersEnabled True if transfers are allowed in the clone
function enableTransfers(bool _transfersEnabled) public onlyController {
function enableTransfers(bool _transfersEnabled) public onlyController {
transfersEnabled = _transfersEnabled;
transfersEnabled = _transfersEnabled;
}
}
////////////////
////////////////
// Internal helper functions to query and set a value in a snapshot array
// 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
/// @dev `getValueAt` retrieves the number of tokens at a given block number
/// @param checkpoints The history of values being queried
/// @param checkpoints The history of values being queried
/// @param _block The block number to retrieve the value at
/// @param _block The block number to retrieve the value at
/// @return The number of tokens being queried
/// @return The number of tokens being queried
function getValueAt(Checkpoint[] storage checkpoints, uint _block
function getValueAt(Checkpoint[] storage checkpoints, uint _block
) view internal returns (uint) {
) view internal returns (uint) {
if (checkpoints.length == 0) return 0;
if (checkpoints.length == 0) return 0;
// Shortcut for the actual value
// Shortcut for the actual value
if (_block >= checkpoints[checkpoints.length-1].fromBlock)
if (_block >= checkpoints[checkpoints.length-1].fromBlock)
return checkpoints[checkpoints.length-1].value;
return checkpoints[checkpoints.length-1].value;
if (_block < checkpoints[0].fromBlock) return 0;
if (_block < checkpoints[0].fromBlock) return 0;
// Binary search of the value in the array
// Binary search of the value in the array
uint min = 0;
uint min = 0;
uint max = checkpoints.length-1;
uint max = checkpoints.length-1;
uint mid = 0;
uint mid = 0;
while (max > min) {
while (max > min) {
mid = (max + min + 1)/ 2;
mid = (max + min + 1)/ 2;
if (checkpoints[mid].fromBlock<=_block) {
if (checkpoints[mid].fromBlock<=_block) {
min = mid;
min = mid;
} else {
} else {
max = mid-1;
max = mid-1;
}
}
}
}
return checkpoints[min].value;
return checkpoints[min].value;
}
}
/// @dev `updateValueAtNow` used to update the `balances` map and the
/// @dev `updateValueAtNow` used to update the `balances` map and the
/// `totalSupplyHistory`
/// `totalSupplyHistory`
/// @param checkpoints The history of data being updated
/// @param checkpoints The history of data being updated
/// @param _value The new number of tokens
/// @param _value The new number of tokens
function updateValueAtNow(Checkpoint[] storage checkpoints, uint _value
function updateValueAtNow(Checkpoint[] storage checkpoints, uint _value
) internal {
) internal {
if ((checkpoints.length == 0)
if ((checkpoints.length == 0)
|| (checkpoints[checkpoints.length -1].fromBlock < block.number)) {
|| (checkpoints[checkpoints.length -1].fromBlock < block.number)) {
Checkpoint storage newCheckPoint = checkpoints[ checkpoints.length++ ];
Checkpoint storage newCheckPoint = checkpoints[ checkpoints.length++ ];
newCheckPoint.fromBlock = uint256(block.number);
newCheckPoint.fromBlock = uint256(block.number);
newCheckPoint.value = uint256(_value);
newCheckPoint.value = uint256(_value);
} else {
} else {
Checkpoint storage oldCheckPoint = checkpoints[checkpoints.length-1];
Checkpoint storage oldCheckPoint = checkpoints[checkpoints.length-1];
oldCheckPoint.value = uint256(_value);
oldCheckPoint.value = uint256(_value);
}
}
}
}
/// @dev Internal function to determine if an address is a contract
/// @dev Internal function to determine if an address is a contract
/// @param _addr The address being queried
/// @param _addr The address being queried
/// @return True if `_addr` is a contract
/// @return True if `_addr` is a contract
function isContract(address _addr) view internal returns(bool) {
function isContract(address _addr) view internal returns(bool) {
uint size;
uint size;
if (_addr == address(0)) return false;
if (_addr == address(0)) return false;
assembly {
assembly {
size := extcodesize(_addr)
size := extcodesize(_addr)
}
}
return size>0;
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) pure internal returns (uint) {
function min(uint a, uint b) pure internal returns (uint) {
return a < b ? a : b;
return a < b ? a : b;
}
}
/// @notice The fallback function: If the contract's controller has not been
/// @notice The fallback function: If the contract's controller has not been
/// set to 0, then the `proxyPayment` method is called which relays the
/// set to 0, then the `proxyPayment` method is called which relays the
/// ether and creates tokens as described in the token controller contract
/// ether and creates tokens as described in the token controller contract
function () external payable {
function () external payable {
require(isContract(controller));
require(isContract(controller));
require(TokenController(controller).proxyPayment.value(msg.value)(msg.sender));
require(TokenController(controller).proxyPayment.value(msg.value)(msg.sender));
}
}
////////////////
////////////////
// Events
// Events
////////////////
////////////////
event ClaimedTokens(address indexed _token, address indexed _controller, uint _amount);
event ClaimedTokens(address indexed _token, address indexed _controller, uint _amount);
event Transfer(address indexed _from, address indexed _to, uint256 _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(
event Approval(
address indexed _owner,
address indexed _owner,
address indexed _spender,
address indexed _spender,
uint256 _amount
uint256 _amount
);
);
}
}
////////////////
////////////////
// MiniMeTokenFactory
// MiniMeTokenFactory
////////////////
////////////////
/// @dev This contract is used to generate clone contracts from a contract.
/// @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
/// In solidity this is the way to create a contract from a contract of the
/// same class
/// same class
contract MiniMeTokenFactory {
contract MiniMeTokenFactory {
/// @notice Update the DApp by creating a new token with new functionalities
/// @notice Update the DApp by creating a new token with new functionalities
/// the msg.sender becomes the controller of this clone token
/// the msg.sender becomes the controller of this clone token
/// @param _parentToken Address of the token being cloned
/// @param _parentToken Address of the token being cloned
/// @param _snapshotBlock Block of the parent token that will
/// @param _snapshotBlock Block of the parent token that will
/// determine the initial distribution of the clone token
/// determine the initial distribution of the clone token
/// @param _tokenName Name of the new token
/// @param _tokenName Name of the new token
/// @param _decimalUnits Number of decimals of the new token
/// @param _decimalUnits Number of decimals of the new token
/// @param _tokenSymbol Token Symbol for the new token
/// @param _tokenSymbol Token Symbol for the new token
/// @param _transfersEnabled If true, tokens will be able to be transferred
/// @param _transfersEnabled If true, tokens will be able to be transferred
/// @return The address of the new token contract
/// @return The address of the new token contract
function createCloneToken(
function createCloneToken(
address payable _parentToken,
address payable _parentToken,
uint _snapshotBlock,
uint _snapshotBlock,
string memory _tokenName,
string memory _tokenName,
uint8 _decimalUnits,
uint8 _decimalUnits,
string memory _tokenSymbol,
string memory _tokenSymbol,
bool _transfersEnabled
bool _transfersEnabled
) public returns (MiniMeToken) {
) public returns (MiniMeToken) {
MiniMeToken newToken = new MiniMeToken(
MiniMeToken newToken = new MiniMeToken(
address(this),
address(this),
_parentToken,
_parentToken,
_snapshotBlock,
_tokenName,
_decimal