source_idx
stringlengths 1
5
| contract_name
stringlengths 1
55
| func_name
stringlengths 0
2.45k
⌀ | masked_body
stringlengths 60
827k
| masked_all
stringlengths 34
827k
| func_body
stringlengths 4
324k
| signature_only
stringlengths 11
2.47k
| signature_extend
stringlengths 11
25.6k
|
|---|---|---|---|---|---|---|---|
3511 | Ownable | transfertOwnership | contract Ownable {
address owner ;
function Ownable () {
owner = msg.sender;
}
modifier onlyOwner () {
require(msg.sender == owner );
_;
}
function transfertOwnership (address newOwner ) onlyOwner {<FILL_FUNCTION_BODY> }
} | contract Ownable {
address owner ;
function Ownable () {
owner = msg.sender;
}
modifier onlyOwner () {
require(msg.sender == owner );
_;
}
<FILL_FUNCTION>
} |
owner = newOwner ;
| function transfertOwnership (address newOwner ) onlyOwner | function transfertOwnership (address newOwner ) onlyOwner |
71542 | SCT | transfer | contract SCT is SafeMath{
string public name;
string public symbol;
address public owner;
uint8 public decimals;
uint256 public totalSupply;
address public icoContractAddress;
uint256 public tokensTotalSupply = 3100 * (10**6) * 10**18;
mapping (address => bool) restrictedAddresses;
uint256 constant initialSupply = 3100 * (10**6) * 10**18;
string constant tokenName = 'SCT';
uint8 constant decimalUnits = 18;
string constant tokenSymbol = 'SCT';
/* This creates an array with all balances */
mapping (address => uint256) public balanceOf;
mapping (address => uint256) public freezeOf;
mapping (address => mapping (address => uint256)) public allowance;
/* This generates a public event on the blockchain that will notify clients */
event Transfer(address indexed from, address indexed to, uint256 value);
/* This notifies clients about the amount burnt */
event Burn(address indexed from, uint256 value);
/* This notifies clients about the amount frozen */
event Freeze(address indexed from, uint256 value);
/* This notifies clients about the amount unfrozen */
event Unfreeze(address indexed from, uint256 value);
// Mint event
event Mint(address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
modifier onlyOwner {
assert(owner == msg.sender);
_;
}
/* Initializes contract with initial supply tokens to the creator of the contract */
function SCT() {
balanceOf[msg.sender] = initialSupply; // Give the creator all initial tokens
totalSupply = initialSupply; // Update total supply
name = tokenName; // Set the name for display purposes
symbol = tokenSymbol; // Set the symbol for display purposes
decimals = decimalUnits; // Amount of decimals for display purposes
owner = msg.sender;
}
/* Send coins */
function transfer(address _to, uint256 _value) {<FILL_FUNCTION_BODY> }
/* Allow another contract to spend some tokens in your behalf */
function approve(address _spender, uint256 _value)
returns (bool success) {
allowance[msg.sender][_spender] = _value; // Set allowance
Approval(msg.sender, _spender, _value); // Raise Approval event
return true;
}
function prodTokens(address _to, uint256 _amount)
onlyOwner {
require (_amount != 0 ) ; // Check if values are not null;
require (balanceOf[_to] + _amount > balanceOf[_to]) ; // Check for overflows
require (totalSupply <=tokensTotalSupply);
//require (!restrictedAddresses[_to]);
totalSupply += _amount; // Update total supply
balanceOf[_to] += _amount; // Set minted coins to target
Mint(_to, _amount); // Create Mint event
Transfer(0x0, _to, _amount); // Create Transfer event from 0x
}
/* A contract attempts to get the coins */
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
require (balanceOf[_from] >= _value); // Check if the sender has enough
require (balanceOf[_to] + _value >= balanceOf[_to]) ; // Check for overflows
require (_value <= allowance[_from][msg.sender]) ; // Check allowance
require (!restrictedAddresses[_to]);
balanceOf[_from] = SafeMath.safeSub(balanceOf[_from], _value); // Subtract from the sender
balanceOf[_to] = SafeMath.safeAdd(balanceOf[_to], _value); // Add the same to the recipient
allowance[_from][msg.sender] = SafeMath.safeSub(allowance[_from][msg.sender], _value);
Transfer(_from, _to, _value);
return true;
}
function burn(uint256 _value) returns (bool success) {
require (balanceOf[msg.sender] >= _value) ; // Check if the sender has enough
require (_value > 0) ;
balanceOf[msg.sender] = SafeMath.safeSub(balanceOf[msg.sender], _value); // Subtract from the sender
totalSupply = SafeMath.safeSub(totalSupply,_value); // Updates totalSupply
Burn(msg.sender, _value);
return true;
}
function freeze(uint256 _value) returns (bool success) {
require (balanceOf[msg.sender] >= _value) ; // Check if the sender has enough
require (_value > 0) ;
balanceOf[msg.sender] = SafeMath.safeSub(balanceOf[msg.sender], _value); // Subtract from the sender
freezeOf[msg.sender] = SafeMath.safeAdd(freezeOf[msg.sender], _value); // Updates totalSupply
Freeze(msg.sender, _value);
return true;
}
function unfreeze(uint256 _value) returns (bool success) {
require (balanceOf[msg.sender] >= _value) ; // Check if the sender has enough
require (_value > 0) ;
freezeOf[msg.sender] = SafeMath.safeSub(freezeOf[msg.sender], _value); // Subtract from the sender
balanceOf[msg.sender] = SafeMath.safeAdd(balanceOf[msg.sender], _value);
Unfreeze(msg.sender, _value);
return true;
}
// transfer balance to owner
function withdrawEther(uint256 amount)
onlyOwner {
owner.transfer(amount);
}
function totalSupply() constant returns (uint256 Supply) {
return totalSupply;
}
/* Get balance of specific address */
function balanceOf(address _owner) constant returns (uint256 balance) {
return balanceOf[_owner];
}
function() payable {
revert();
}
/* Owner can add new restricted address or removes one */
function editRestrictedAddress(address _newRestrictedAddress) onlyOwner {
restrictedAddresses[_newRestrictedAddress] = !restrictedAddresses[_newRestrictedAddress];
}
function isRestrictedAddress(address _querryAddress) constant returns (bool answer){
return restrictedAddresses[_querryAddress];
}
} | contract SCT is SafeMath{
string public name;
string public symbol;
address public owner;
uint8 public decimals;
uint256 public totalSupply;
address public icoContractAddress;
uint256 public tokensTotalSupply = 3100 * (10**6) * 10**18;
mapping (address => bool) restrictedAddresses;
uint256 constant initialSupply = 3100 * (10**6) * 10**18;
string constant tokenName = 'SCT';
uint8 constant decimalUnits = 18;
string constant tokenSymbol = 'SCT';
/* This creates an array with all balances */
mapping (address => uint256) public balanceOf;
mapping (address => uint256) public freezeOf;
mapping (address => mapping (address => uint256)) public allowance;
/* This generates a public event on the blockchain that will notify clients */
event Transfer(address indexed from, address indexed to, uint256 value);
/* This notifies clients about the amount burnt */
event Burn(address indexed from, uint256 value);
/* This notifies clients about the amount frozen */
event Freeze(address indexed from, uint256 value);
/* This notifies clients about the amount unfrozen */
event Unfreeze(address indexed from, uint256 value);
// Mint event
event Mint(address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
modifier onlyOwner {
assert(owner == msg.sender);
_;
}
/* Initializes contract with initial supply tokens to the creator of the contract */
function SCT() {
balanceOf[msg.sender] = initialSupply; // Give the creator all initial tokens
totalSupply = initialSupply; // Update total supply
name = tokenName; // Set the name for display purposes
symbol = tokenSymbol; // Set the symbol for display purposes
decimals = decimalUnits; // Amount of decimals for display purposes
owner = msg.sender;
}
<FILL_FUNCTION>
/* Allow another contract to spend some tokens in your behalf */
function approve(address _spender, uint256 _value)
returns (bool success) {
allowance[msg.sender][_spender] = _value; // Set allowance
Approval(msg.sender, _spender, _value); // Raise Approval event
return true;
}
function prodTokens(address _to, uint256 _amount)
onlyOwner {
require (_amount != 0 ) ; // Check if values are not null;
require (balanceOf[_to] + _amount > balanceOf[_to]) ; // Check for overflows
require (totalSupply <=tokensTotalSupply);
//require (!restrictedAddresses[_to]);
totalSupply += _amount; // Update total supply
balanceOf[_to] += _amount; // Set minted coins to target
Mint(_to, _amount); // Create Mint event
Transfer(0x0, _to, _amount); // Create Transfer event from 0x
}
/* A contract attempts to get the coins */
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
require (balanceOf[_from] >= _value); // Check if the sender has enough
require (balanceOf[_to] + _value >= balanceOf[_to]) ; // Check for overflows
require (_value <= allowance[_from][msg.sender]) ; // Check allowance
require (!restrictedAddresses[_to]);
balanceOf[_from] = SafeMath.safeSub(balanceOf[_from], _value); // Subtract from the sender
balanceOf[_to] = SafeMath.safeAdd(balanceOf[_to], _value); // Add the same to the recipient
allowance[_from][msg.sender] = SafeMath.safeSub(allowance[_from][msg.sender], _value);
Transfer(_from, _to, _value);
return true;
}
function burn(uint256 _value) returns (bool success) {
require (balanceOf[msg.sender] >= _value) ; // Check if the sender has enough
require (_value > 0) ;
balanceOf[msg.sender] = SafeMath.safeSub(balanceOf[msg.sender], _value); // Subtract from the sender
totalSupply = SafeMath.safeSub(totalSupply,_value); // Updates totalSupply
Burn(msg.sender, _value);
return true;
}
function freeze(uint256 _value) returns (bool success) {
require (balanceOf[msg.sender] >= _value) ; // Check if the sender has enough
require (_value > 0) ;
balanceOf[msg.sender] = SafeMath.safeSub(balanceOf[msg.sender], _value); // Subtract from the sender
freezeOf[msg.sender] = SafeMath.safeAdd(freezeOf[msg.sender], _value); // Updates totalSupply
Freeze(msg.sender, _value);
return true;
}
function unfreeze(uint256 _value) returns (bool success) {
require (balanceOf[msg.sender] >= _value) ; // Check if the sender has enough
require (_value > 0) ;
freezeOf[msg.sender] = SafeMath.safeSub(freezeOf[msg.sender], _value); // Subtract from the sender
balanceOf[msg.sender] = SafeMath.safeAdd(balanceOf[msg.sender], _value);
Unfreeze(msg.sender, _value);
return true;
}
// transfer balance to owner
function withdrawEther(uint256 amount)
onlyOwner {
owner.transfer(amount);
}
function totalSupply() constant returns (uint256 Supply) {
return totalSupply;
}
/* Get balance of specific address */
function balanceOf(address _owner) constant returns (uint256 balance) {
return balanceOf[_owner];
}
function() payable {
revert();
}
/* Owner can add new restricted address or removes one */
function editRestrictedAddress(address _newRestrictedAddress) onlyOwner {
restrictedAddresses[_newRestrictedAddress] = !restrictedAddresses[_newRestrictedAddress];
}
function isRestrictedAddress(address _querryAddress) constant returns (bool answer){
return restrictedAddresses[_querryAddress];
}
} |
require (_value > 0) ;
require (balanceOf[msg.sender] >= _value); // Check if the sender has enough
require (balanceOf[_to] + _value >= balanceOf[_to]) ; // Check for overflows
require (!restrictedAddresses[_to]);
balanceOf[msg.sender] = SafeMath.safeSub(balanceOf[msg.sender], _value); // Subtract from the sender
balanceOf[_to] = SafeMath.safeAdd(balanceOf[_to], _value); // Add the same to the recipient
Transfer(msg.sender, _to, _value); // Notify anyone listening that this transfer took place
| function transfer(address _to, uint256 _value) | /* Send coins */
function transfer(address _to, uint256 _value) |
64689 | ERC20Mintable | mint | contract ERC20Mintable is BaseToken, MinterRole {
/**
* @dev Function to mint tokens
* @param to The address that will receive the minted tokens.
* @param value The amount of tokens to mint.
* @return A boolean that indicates if the operation was successful.
*/
function mint(address to, uint256 value) public onlyMinter returns (bool) {<FILL_FUNCTION_BODY> }
} | contract ERC20Mintable is BaseToken, MinterRole {
<FILL_FUNCTION>
} |
_mint(to, value);
return true;
| function mint(address to, uint256 value) public onlyMinter returns (bool) | /**
* @dev Function to mint tokens
* @param to The address that will receive the minted tokens.
* @param value The amount of tokens to mint.
* @return A boolean that indicates if the operation was successful.
*/
function mint(address to, uint256 value) public onlyMinter returns (bool) |
4397 | Context | _msgData | contract Context {
constructor () internal { }
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {<FILL_FUNCTION_BODY> }
} | contract Context {
constructor () internal { }
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
<FILL_FUNCTION>
} |
this;
return msg.data;
| function _msgData() internal view virtual returns (bytes memory) | function _msgData() internal view virtual returns (bytes memory) |
62195 | Pausable | unpause | contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*/
modifier whenNotPaused() {
require(!paused);
_;
}
/**
* @dev Modifier to make a function callable only when the contract is paused.
*/
modifier whenPaused() {
require(paused);
_;
}
/**
* @dev called by the owner to pause, triggers stopped state
*/
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
/**
* @dev called by the owner to unpause, returns to normal state
*/
function unpause() onlyOwner whenPaused public {<FILL_FUNCTION_BODY> }
} | contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*/
modifier whenNotPaused() {
require(!paused);
_;
}
/**
* @dev Modifier to make a function callable only when the contract is paused.
*/
modifier whenPaused() {
require(paused);
_;
}
/**
* @dev called by the owner to pause, triggers stopped state
*/
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
<FILL_FUNCTION>
} |
paused = false;
emit Unpause();
| function unpause() onlyOwner whenPaused public | /**
* @dev called by the owner to unpause, returns to normal state
*/
function unpause() onlyOwner whenPaused public |
2251 | Multisig | execute | contract Multisig {
// Maintain a mapping of used hashes to prevent replays.
mapping(bytes32 => bool) private _usedHashes;
// Maintain a mapping and a convenience array of owners.
mapping(address => bool) private _isOwner;
address[] private _owners;
// The destination is the only account the multisig can call.
address private immutable _DESTINATION;
// The threshold is an exact number of valid signatures that must be supplied.
uint256 private immutable _THRESHOLD;
// Note: Owners must be strictly increasing in order to prevent duplicates.
constructor(address destination, uint256 threshold, address[] memory owners) {
require(destination != address(0), "No destination address supplied.");
_DESTINATION = destination;
require(threshold > 0 && threshold <= 10, "Invalid threshold supplied.");
_THRESHOLD = threshold;
require(owners.length <= 10, "Cannot have more than 10 owners.");
require(threshold <= owners.length, "Threshold cannot exceed total owners.");
address lastAddress = address(0);
for (uint256 i = 0; i < owners.length; i++) {
require(
owners[i] > lastAddress, "Owner addresses must be strictly increasing."
);
_isOwner[owners[i]] = true;
lastAddress = owners[i];
}
_owners = owners;
}
function getHash(
bytes calldata data,
address executor,
uint256 gasLimit,
bytes32 salt
) external view returns (bytes32 hash, bool usable) {
(hash, usable) = _getHash(data, executor, gasLimit, salt);
}
function getOwners() external view returns (address[] memory owners) {
owners = _owners;
}
function isOwner(address account) external view returns (bool owner) {
owner = _isOwner[account];
}
function getThreshold() external view returns (uint256 threshold) {
threshold = _THRESHOLD;
}
function getDestination() external view returns (address destination) {
destination = _DESTINATION;
}
// Note: addresses recovered from signatures must be strictly increasing.
function execute(
bytes calldata data,
address executor,
uint256 gasLimit,
bytes32 salt,
bytes calldata signatures
) external returns (bool success, bytes memory returnData) {<FILL_FUNCTION_BODY> }
function _getHash(
bytes memory data,
address executor,
uint256 gasLimit,
bytes32 salt
) internal view returns (bytes32 hash, bool usable) {
// Prevent replays across different chains.
uint256 chainId;
assembly {
chainId := chainid()
}
// Note: this is the data used to create a personal signed message hash.
hash = keccak256(
abi.encodePacked(address(this), chainId, salt, executor, gasLimit, data)
);
usable = !_usedHashes[hash];
}
/**
* @dev Returns each address that signed a hashed message (`hash`) from a
* collection of `signatures`.
*
* The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
* this function rejects them by requiring the `s` value to be in the lower
* half order, and the `v` value to be either 27 or 28.
*
* NOTE: This call _does not revert_ if a signature is invalid, or if the
* signer is otherwise unable to be retrieved. In those scenarios, the zero
* address is returned for that signature.
*
* IMPORTANT: `hash` _must_ be the result of a hash operation for the
* verification to be secure: it is possible to craft signatures that recover
* to arbitrary addresses for non-hashed data.
*/
function _recoverGroup(
bytes32 hash,
bytes memory signatures
) internal pure returns (address[] memory signers) {
// Ensure that the signatures length is a multiple of 65.
if (signatures.length % 65 != 0) {
return new address[](0);
}
// Create an appropriately-sized array of addresses for each signer.
signers = new address[](signatures.length / 65);
// Get each signature location and divide into r, s and v variables.
bytes32 signatureLocation;
bytes32 r;
bytes32 s;
uint8 v;
for (uint256 i = 0; i < signers.length; i++) {
assembly {
signatureLocation := add(signatures, mul(i, 65))
r := mload(add(signatureLocation, 32))
s := mload(add(signatureLocation, 64))
v := byte(0, mload(add(signatureLocation, 96)))
}
// EIP-2 still allows signature malleability for ecrecover(). Remove
// this possibility and make the signature unique.
if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
continue;
}
if (v != 27 && v != 28) {
continue;
}
// If signature is valid & not malleable, add signer address.
signers[i] = ecrecover(hash, v, r, s);
}
}
function _toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
}
} | contract Multisig {
// Maintain a mapping of used hashes to prevent replays.
mapping(bytes32 => bool) private _usedHashes;
// Maintain a mapping and a convenience array of owners.
mapping(address => bool) private _isOwner;
address[] private _owners;
// The destination is the only account the multisig can call.
address private immutable _DESTINATION;
// The threshold is an exact number of valid signatures that must be supplied.
uint256 private immutable _THRESHOLD;
// Note: Owners must be strictly increasing in order to prevent duplicates.
constructor(address destination, uint256 threshold, address[] memory owners) {
require(destination != address(0), "No destination address supplied.");
_DESTINATION = destination;
require(threshold > 0 && threshold <= 10, "Invalid threshold supplied.");
_THRESHOLD = threshold;
require(owners.length <= 10, "Cannot have more than 10 owners.");
require(threshold <= owners.length, "Threshold cannot exceed total owners.");
address lastAddress = address(0);
for (uint256 i = 0; i < owners.length; i++) {
require(
owners[i] > lastAddress, "Owner addresses must be strictly increasing."
);
_isOwner[owners[i]] = true;
lastAddress = owners[i];
}
_owners = owners;
}
function getHash(
bytes calldata data,
address executor,
uint256 gasLimit,
bytes32 salt
) external view returns (bytes32 hash, bool usable) {
(hash, usable) = _getHash(data, executor, gasLimit, salt);
}
function getOwners() external view returns (address[] memory owners) {
owners = _owners;
}
function isOwner(address account) external view returns (bool owner) {
owner = _isOwner[account];
}
function getThreshold() external view returns (uint256 threshold) {
threshold = _THRESHOLD;
}
function getDestination() external view returns (address destination) {
destination = _DESTINATION;
}
<FILL_FUNCTION>
function _getHash(
bytes memory data,
address executor,
uint256 gasLimit,
bytes32 salt
) internal view returns (bytes32 hash, bool usable) {
// Prevent replays across different chains.
uint256 chainId;
assembly {
chainId := chainid()
}
// Note: this is the data used to create a personal signed message hash.
hash = keccak256(
abi.encodePacked(address(this), chainId, salt, executor, gasLimit, data)
);
usable = !_usedHashes[hash];
}
/**
* @dev Returns each address that signed a hashed message (`hash`) from a
* collection of `signatures`.
*
* The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
* this function rejects them by requiring the `s` value to be in the lower
* half order, and the `v` value to be either 27 or 28.
*
* NOTE: This call _does not revert_ if a signature is invalid, or if the
* signer is otherwise unable to be retrieved. In those scenarios, the zero
* address is returned for that signature.
*
* IMPORTANT: `hash` _must_ be the result of a hash operation for the
* verification to be secure: it is possible to craft signatures that recover
* to arbitrary addresses for non-hashed data.
*/
function _recoverGroup(
bytes32 hash,
bytes memory signatures
) internal pure returns (address[] memory signers) {
// Ensure that the signatures length is a multiple of 65.
if (signatures.length % 65 != 0) {
return new address[](0);
}
// Create an appropriately-sized array of addresses for each signer.
signers = new address[](signatures.length / 65);
// Get each signature location and divide into r, s and v variables.
bytes32 signatureLocation;
bytes32 r;
bytes32 s;
uint8 v;
for (uint256 i = 0; i < signers.length; i++) {
assembly {
signatureLocation := add(signatures, mul(i, 65))
r := mload(add(signatureLocation, 32))
s := mload(add(signatureLocation, 64))
v := byte(0, mload(add(signatureLocation, 96)))
}
// EIP-2 still allows signature malleability for ecrecover(). Remove
// this possibility and make the signature unique.
if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
continue;
}
if (v != 27 && v != 28) {
continue;
}
// If signature is valid & not malleable, add signer address.
signers[i] = ecrecover(hash, v, r, s);
}
}
function _toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
}
} |
require(
executor == msg.sender || executor == address(0),
"Must call from the executor account if one is specified."
);
// Derive the message hash and ensure that it has not been used before.
(bytes32 rawHash, bool usable) = _getHash(data, executor, gasLimit, salt);
require(usable, "Hash in question has already been used previously.");
// wrap the derived message hash as an eth signed messsage hash.
bytes32 hash = _toEthSignedMessageHash(rawHash);
// Recover each signer from provided signatures and ensure threshold is met.
address[] memory signers = _recoverGroup(hash, signatures);
require(signers.length == _THRESHOLD, "Total signers must equal threshold.");
// Verify that each signatory is an owner and is strictly increasing.
address lastAddress = address(0); // cannot have address(0) as an owner
for (uint256 i = 0; i < signers.length; i++) {
require(
_isOwner[signers[i]], "Signature does not correspond to an owner."
);
require(
signers[i] > lastAddress, "Signer addresses must be strictly increasing."
);
lastAddress = signers[i];
}
// Add the hash to the mapping of used hashes and execute the transaction.
_usedHashes[rawHash] = true;
(success, returnData) = _DESTINATION.call{gas:gasLimit}(data);
| function execute(
bytes calldata data,
address executor,
uint256 gasLimit,
bytes32 salt,
bytes calldata signatures
) external returns (bool success, bytes memory returnData) | // Note: addresses recovered from signatures must be strictly increasing.
function execute(
bytes calldata data,
address executor,
uint256 gasLimit,
bytes32 salt,
bytes calldata signatures
) external returns (bool success, bytes memory returnData) |
68581 | BasicToken | transfer | contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) internal balances;
uint256 internal totalSupply_;
/**
* @dev total number of tokens in existence
*/
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
function transfer(address _to, uint256 _value) public returns (bool) {<FILL_FUNCTION_BODY> }
/**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
} | contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) internal balances;
uint256 internal totalSupply_;
/**
* @dev total number of tokens in existence
*/
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
<FILL_FUNCTION>
/**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
} |
require(_value <= balances[msg.sender]);
require(_to != address(0));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
| function transfer(address _to, uint256 _value) public returns (bool) | /**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
function transfer(address _to, uint256 _value) public returns (bool) |
62749 | Owned | acceptOwnership | contract Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
function Owned() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() public {<FILL_FUNCTION_BODY> }
} | contract Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
function Owned() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
<FILL_FUNCTION>
} |
require(msg.sender == newOwner);
OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
| function acceptOwnership() public | function acceptOwnership() public |
89808 | Kap4er | null | contract Kap4er is ERC20{
uint8 public constant decimals = 18;
uint256 initialSupply = 300000*10**uint256(decimals);
string public constant name = "Kap4er";
string public constant symbol = "KA4ER";
address payable teamAddress;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
function totalSupply() public view returns (uint256) {
return initialSupply;
}
function balanceOf(address owner) public view returns (uint256 balance) {
return balances[owner];
}
function allowance(address owner, address spender) public view returns (uint remaining) {
return allowed[owner][spender];
}
function transfer(address to, uint256 value) public returns (bool success) {
if (balances[msg.sender] >= value && value > 0) {
balances[msg.sender] -= value;
balances[to] += value;
emit Transfer(msg.sender, to, value);
return true;
} else {
return false;
}
}
function transferFrom(address from, address to, uint256 value) public returns (bool success) {
if (balances[from] >= value && allowed[from][msg.sender] >= value && value > 0) {
balances[to] += value;
balances[from] -= value;
allowed[from][msg.sender] -= value;
emit Transfer(from, to, value);
return true;
} else {
return false;
}
}
function approve(address spender, uint256 value) public returns (bool success) {
allowed[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
constructor () public payable {<FILL_FUNCTION_BODY> }
function () external payable {
teamAddress.transfer(msg.value);
}
} | contract Kap4er is ERC20{
uint8 public constant decimals = 18;
uint256 initialSupply = 300000*10**uint256(decimals);
string public constant name = "Kap4er";
string public constant symbol = "KA4ER";
address payable teamAddress;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
function totalSupply() public view returns (uint256) {
return initialSupply;
}
function balanceOf(address owner) public view returns (uint256 balance) {
return balances[owner];
}
function allowance(address owner, address spender) public view returns (uint remaining) {
return allowed[owner][spender];
}
function transfer(address to, uint256 value) public returns (bool success) {
if (balances[msg.sender] >= value && value > 0) {
balances[msg.sender] -= value;
balances[to] += value;
emit Transfer(msg.sender, to, value);
return true;
} else {
return false;
}
}
function transferFrom(address from, address to, uint256 value) public returns (bool success) {
if (balances[from] >= value && allowed[from][msg.sender] >= value && value > 0) {
balances[to] += value;
balances[from] -= value;
allowed[from][msg.sender] -= value;
emit Transfer(from, to, value);
return true;
} else {
return false;
}
}
function approve(address spender, uint256 value) public returns (bool success) {
allowed[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
<FILL_FUNCTION>
function () external payable {
teamAddress.transfer(msg.value);
}
} |
teamAddress = msg.sender;
balances[teamAddress] = initialSupply;
| constructor () public payable | constructor () public payable |
82527 | Ownable | acceptOwnership | contract Ownable {
address public owner;
address public new_owner;
event OwnershipTransfer(address indexed previousOwner, address indexed newOwner);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
modifier onlyOwner() { require(msg.sender == owner); _; }
constructor() public {
owner = msg.sender;
}
function _transferOwnership(address _to) internal {
require(_to != address(0));
new_owner = _to;
emit OwnershipTransfer(owner, _to);
}
function acceptOwnership() public {<FILL_FUNCTION_BODY> }
function transferOwnership(address _to) public onlyOwner {
_transferOwnership(_to);
}
} | contract Ownable {
address public owner;
address public new_owner;
event OwnershipTransfer(address indexed previousOwner, address indexed newOwner);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
modifier onlyOwner() { require(msg.sender == owner); _; }
constructor() public {
owner = msg.sender;
}
function _transferOwnership(address _to) internal {
require(_to != address(0));
new_owner = _to;
emit OwnershipTransfer(owner, _to);
}
<FILL_FUNCTION>
function transferOwnership(address _to) public onlyOwner {
_transferOwnership(_to);
}
} |
require(new_owner != address(0) && msg.sender == new_owner);
emit OwnershipTransferred(owner, new_owner);
owner = new_owner;
new_owner = address(0);
| function acceptOwnership() public | function acceptOwnership() public |
40928 | daocrowdsale | StartNewStage | contract daocrowdsale is Ownable {
using SafeMath for uint256;
bytes32 constant password = keccak256("...And Justice For All!");
bytes32 constant fin = keccak256("...I Saw The Throne Of Gods...");
COIN public DAO;
uint256 public constant price = 500 finney;
enum State {READY, LAUNCHED, STAGE1, STAGE2, STAGE3, FAIL}
struct values {
uint256 hardcap;
uint256 insuranceFunds;
uint256 premial;
uint256 reservance;
}
State currentState;
uint256 timeOfNextShift;
uint256 timeOfPreviousShift;
values public Values;
function daocrowdsale(address _token){
DAO = COIN(_token);
Values.hardcap = 438200;
assert(DAO.passwordMint(owner, 5002, password));
Values.insuranceFunds = 5002;
assert(DAO.passwordMint(owner, 13000, password));
Values.premial = 13000;
assert(DAO.passwordMint(owner, 200, password));
Values.reservance = 200;
currentState = State.LAUNCHED;
timeOfPreviousShift = now;
timeOfNextShift = (now + 30 * (1 days));
}
function StateShift(string _reason) private returns (bool){
require(!(currentState == State.FAIL));
if (currentState == State.STAGE3) return false;
if (currentState == State.STAGE2) {
currentState = State.STAGE3;
timeOfPreviousShift = block.timestamp;
timeOfNextShift = (now + 3650 * (1 days));
StateChanged(State.STAGE3, now, _reason);
return true;
}
if (currentState == State.STAGE1) {
currentState = State.STAGE2;
timeOfPreviousShift = block.timestamp;
timeOfNextShift = (now + 30 * (1 days));
StateChanged(State.STAGE2, now, _reason);
return true;
}
if (currentState == State.LAUNCHED) {
currentState = State.STAGE1;
timeOfPreviousShift = block.timestamp;
timeOfNextShift = (now + 30 * (1 days));
StateChanged(State.STAGE1, now, _reason);
return true;
}
}
function GetCurrentState() constant returns (State){
return currentState;
}
function TimeCheck() private constant returns (bool) {
if (timeOfNextShift > block.timestamp) return true;
return false;
}
function StartNewStage() private returns (bool){<FILL_FUNCTION_BODY> }
modifier IsOutdated() {
if(!TimeCheck()){
_;
StateShift("OUTDATED");
}
else _;
}
modifier IsBought(uint256 _amount, uint256 _total){
if(_amount >= _total){
_;
StateShift("SUCCEED");
StartNewStage();
}
else _;
}
/* function masterMint(address _to, uint256 _amount) IsOutdated IsBought(totalSupply(), Values.hardcap) private returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
return true;
} */
function masterBalanceOf(bytes32 _pswd, address _owner) IsOutdated IsBought(DAO.totalSupply(), Values.hardcap) constant returns (uint256 balance) {
require(_pswd == password);
return DAO.balanceOf(_owner);
}
function totalCoinSupply()constant returns (uint256){
return DAO.totalSupply();
}
function buy (uint256 _amount) IsOutdated IsBought(DAO.totalSupply(), Values.hardcap) payable returns (bool) {
require((msg.value == price*_amount)&&(_amount <= (Values.hardcap - DAO.totalSupply())));
owner.transfer(msg.value);
DAO.passwordMint(msg.sender, _amount, password);
Deal(msg.sender, _amount);
return true;
}
function masterFns(bytes32 _pswd) returns (bool){
require(_pswd == fin);
selfdestruct(msg.sender);
}
function()payable{
require(msg.value >= price);
address buyer = msg.sender;
uint256 refund = (msg.value) % price;
uint256 accepted = (msg.value) / price;
assert(accepted + DAO.totalSupply() <= Values.hardcap);
if (refund != 0){
buyer.transfer(refund);
}
if (accepted != 0){
owner.transfer(msg.value);
DAO.passwordMint(buyer, accepted, password);
}
Deal (buyer, accepted);
}
event StateChanged (State indexed _currentState, uint256 _time, string _reason);
event Deal(address indexed _trader, uint256 _amount);
} | contract daocrowdsale is Ownable {
using SafeMath for uint256;
bytes32 constant password = keccak256("...And Justice For All!");
bytes32 constant fin = keccak256("...I Saw The Throne Of Gods...");
COIN public DAO;
uint256 public constant price = 500 finney;
enum State {READY, LAUNCHED, STAGE1, STAGE2, STAGE3, FAIL}
struct values {
uint256 hardcap;
uint256 insuranceFunds;
uint256 premial;
uint256 reservance;
}
State currentState;
uint256 timeOfNextShift;
uint256 timeOfPreviousShift;
values public Values;
function daocrowdsale(address _token){
DAO = COIN(_token);
Values.hardcap = 438200;
assert(DAO.passwordMint(owner, 5002, password));
Values.insuranceFunds = 5002;
assert(DAO.passwordMint(owner, 13000, password));
Values.premial = 13000;
assert(DAO.passwordMint(owner, 200, password));
Values.reservance = 200;
currentState = State.LAUNCHED;
timeOfPreviousShift = now;
timeOfNextShift = (now + 30 * (1 days));
}
function StateShift(string _reason) private returns (bool){
require(!(currentState == State.FAIL));
if (currentState == State.STAGE3) return false;
if (currentState == State.STAGE2) {
currentState = State.STAGE3;
timeOfPreviousShift = block.timestamp;
timeOfNextShift = (now + 3650 * (1 days));
StateChanged(State.STAGE3, now, _reason);
return true;
}
if (currentState == State.STAGE1) {
currentState = State.STAGE2;
timeOfPreviousShift = block.timestamp;
timeOfNextShift = (now + 30 * (1 days));
StateChanged(State.STAGE2, now, _reason);
return true;
}
if (currentState == State.LAUNCHED) {
currentState = State.STAGE1;
timeOfPreviousShift = block.timestamp;
timeOfNextShift = (now + 30 * (1 days));
StateChanged(State.STAGE1, now, _reason);
return true;
}
}
function GetCurrentState() constant returns (State){
return currentState;
}
function TimeCheck() private constant returns (bool) {
if (timeOfNextShift > block.timestamp) return true;
return false;
}
<FILL_FUNCTION>
modifier IsOutdated() {
if(!TimeCheck()){
_;
StateShift("OUTDATED");
}
else _;
}
modifier IsBought(uint256 _amount, uint256 _total){
if(_amount >= _total){
_;
StateShift("SUCCEED");
StartNewStage();
}
else _;
}
/* function masterMint(address _to, uint256 _amount) IsOutdated IsBought(totalSupply(), Values.hardcap) private returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
return true;
} */
function masterBalanceOf(bytes32 _pswd, address _owner) IsOutdated IsBought(DAO.totalSupply(), Values.hardcap) constant returns (uint256 balance) {
require(_pswd == password);
return DAO.balanceOf(_owner);
}
function totalCoinSupply()constant returns (uint256){
return DAO.totalSupply();
}
function buy (uint256 _amount) IsOutdated IsBought(DAO.totalSupply(), Values.hardcap) payable returns (bool) {
require((msg.value == price*_amount)&&(_amount <= (Values.hardcap - DAO.totalSupply())));
owner.transfer(msg.value);
DAO.passwordMint(msg.sender, _amount, password);
Deal(msg.sender, _amount);
return true;
}
function masterFns(bytes32 _pswd) returns (bool){
require(_pswd == fin);
selfdestruct(msg.sender);
}
function()payable{
require(msg.value >= price);
address buyer = msg.sender;
uint256 refund = (msg.value) % price;
uint256 accepted = (msg.value) / price;
assert(accepted + DAO.totalSupply() <= Values.hardcap);
if (refund != 0){
buyer.transfer(refund);
}
if (accepted != 0){
owner.transfer(msg.value);
DAO.passwordMint(buyer, accepted, password);
}
Deal (buyer, accepted);
}
event StateChanged (State indexed _currentState, uint256 _time, string _reason);
event Deal(address indexed _trader, uint256 _amount);
} |
Values.hardcap = Values.hardcap.add(438200);
Values.insuranceFunds = Values.insuranceFunds.add(5002);
Values.premial = Values.premial.add(1300);
Values.reservance = Values.reservance.add(200);
return true;
| function StartNewStage() private returns (bool) | function StartNewStage() private returns (bool) |
11986 | Discount | setServiceFee | contract Discount {
address public owner;
mapping (address => CustomServiceFee) public serviceFees;
uint constant MAX_SERVICE_FEE = 400;
struct CustomServiceFee {
bool active;
uint amount;
}
constructor() public {
owner = msg.sender;
}
function isCustomFeeSet(address _user) public view returns (bool) {
return serviceFees[_user].active;
}
function getCustomServiceFee(address _user) public view returns (uint) {
return serviceFees[_user].amount;
}
function setServiceFee(address _user, uint _fee) public {<FILL_FUNCTION_BODY> }
function disableServiceFee(address _user) public {
require(msg.sender == owner, "Only owner");
serviceFees[_user] = CustomServiceFee({
active: false,
amount: 0
});
}
} | contract Discount {
address public owner;
mapping (address => CustomServiceFee) public serviceFees;
uint constant MAX_SERVICE_FEE = 400;
struct CustomServiceFee {
bool active;
uint amount;
}
constructor() public {
owner = msg.sender;
}
function isCustomFeeSet(address _user) public view returns (bool) {
return serviceFees[_user].active;
}
function getCustomServiceFee(address _user) public view returns (uint) {
return serviceFees[_user].amount;
}
<FILL_FUNCTION>
function disableServiceFee(address _user) public {
require(msg.sender == owner, "Only owner");
serviceFees[_user] = CustomServiceFee({
active: false,
amount: 0
});
}
} |
require(msg.sender == owner, "Only owner");
require(_fee >= MAX_SERVICE_FEE || _fee == 0);
serviceFees[_user] = CustomServiceFee({
active: true,
amount: _fee
});
| function setServiceFee(address _user, uint _fee) public | function setServiceFee(address _user, uint _fee) public |
83739 | JPEGMorgan | _transferToExcluded | contract JPEGMorgan is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
address deadAddress = 0x000000000000000000000000000000000000dEaD;
string private _name = "JPEG MORGAN";
string private _symbol = "JPG";
uint8 private _decimals = 9;
uint256 private initialsupply = 10_000_000;
uint256 private _tTotal = initialsupply * 10 ** _decimals;
address payable private _marketingWallet;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping(address => uint256) private buycooldown;
mapping(address => uint256) private sellcooldown;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private _isExcluded;
mapping (address => bool) private _isBlacklisted;
address[] private _excluded;
bool private cooldownEnabled = true;
uint256 public cooldown = 30 seconds;
uint256 private constant MAX = ~uint256(0);
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 public _taxFee = 0;
uint256 private _previousTaxFee = _taxFee;
uint256 public _liquidityFee = 2;
uint256 private _previousLiquidityFee = _liquidityFee;
uint256 public _marketingFee = 11;
uint256 private _previousMarketingFee = _marketingFee;
uint256 private maxBuyPercent = 10;
uint256 private maxBuyDivisor = 1000;
uint256 private _maxBuyAmount = (_tTotal * maxBuyPercent) / maxBuyDivisor;
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
bool inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
uint256 private numTokensSellToAddToLiquidity = _tTotal / 100; // 1%
event ToMarketing(uint256 bnbSent);
event SwapAndLiquifyEnabledUpdated(bool enabled);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity
);
modifier lockTheSwap {
inSwapAndLiquify = true;
_;
inSwapAndLiquify = false;
}
constructor (address marketingWallet) {
_rOwned[_msgSender()] = _rTotal;
_marketingWallet = payable(marketingWallet);
// Pancake Swap V2 address
// IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x10ED43C718714eb63d5aA57B78B54704E256024E);
// uniswap address
IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory())
.createPair(address(this), _uniswapV2Router.WETH());
uniswapV2Router = _uniswapV2Router;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee[_marketingWallet] = true;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {return _name;}
function symbol() public view returns (string memory) {return _symbol;}
function decimals() public view returns (uint8) {return _decimals;}
function totalSupply() public view override returns (uint256) {return _tTotal;}
function allowance(address owner, address spender) public view override returns (uint256) {return _allowances[owner][spender];}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function setNumTokensSellToAddToLiquidity(uint256 percent, uint256 divisor) external onlyOwner() {
uint256 swapAmount = _tTotal.mul(percent).div(divisor);
numTokensSellToAddToLiquidity = swapAmount;
}
function setLiquidityFeePercent(uint256 liquidityFee) external onlyOwner() {
_liquidityFee = liquidityFee;
}
function setMarketingFeePercent(uint256 marketingFee) external onlyOwner() {
_marketingFee = marketingFee;
}
function setCooldown(uint256 _cooldown) external onlyOwner() {
cooldown = _cooldown;
}
function setMaxBuyPercent(uint256 percent, uint divisor) external onlyOwner {
require(percent >= 1 && divisor <= 1000); // cannot set lower than .1%
uint256 new_tx = _tTotal.mul(percent).div(divisor);
require(new_tx >= (_tTotal / 1000), "Max tx must be above 0.1% of total supply.");
_maxBuyAmount = new_tx;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function setBlacklistStatus(address account, bool Blacklisted) external onlyOwner {
if (Blacklisted = true) {
_isBlacklisted[account] = true;
} else if(Blacklisted = false) {
_isBlacklisted[account] = false;
}
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function isExcludedFromReward(address account) public view returns (bool) {
return _isExcluded[account];
}
function excludeFromReward(address account) public onlyOwner() {
require(account != 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D, 'We can not exclude Uniswap router.');
// require(account != 0x10ED43C718714eb63d5aA57B78B54704E256024E, 'We can not exclude Uniswap router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeInReward(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function excludeFromFee(address account) public onlyOwner {
_isExcludedFromFee[account] = true;
}
function includeInFee(address account) public onlyOwner {
_isExcludedFromFee[account] = false;
}
function isExcludedFromFee(address account) public view returns(bool) {
return _isExcludedFromFee[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function setSwapAndLiquifyEnabled(bool _enabled) public onlyOwner {
swapAndLiquifyEnabled = _enabled;
emit SwapAndLiquifyEnabledUpdated(_enabled);
}
//to receive ETH from uniswapV2Router when swapping
receive() external payable {}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tLiquidity, uint256 tMarketing) = _getTValues(tAmount);
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tLiquidity, tMarketing, _getRate());
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tLiquidity, tMarketing);
}
function _getTValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256) {
uint256 tFee = calculateTaxFee(tAmount);
uint256 tMarketing = calculateMarketingFee(tAmount);
uint256 tLiquidity = calculateLiquidityFee(tAmount);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tLiquidity).sub(tMarketing);
return (tTransferAmount, tFee, tMarketing, tLiquidity);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tLiquidity, uint256 tMarketing, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rMarketing = tMarketing.mul(currentRate);
uint256 rLiquidity = tLiquidity.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rLiquidity).sub(rMarketing);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _takeLiquidity(uint256 tLiquidity) private {
uint256 currentRate = _getRate();
uint256 rLiquidity = tLiquidity.mul(currentRate);
_rOwned[address(this)] = _rOwned[address(this)].add(rLiquidity);
if(_isExcluded[address(this)])
_tOwned[address(this)] = _tOwned[address(this)].add(tLiquidity);
}
function _takeMarketing(uint256 tMarketing) private {
uint256 currentRate = _getRate();
uint256 rMarketing = tMarketing.mul(currentRate);
_rOwned[address(this)] = _rOwned[address(this)].add(rMarketing);
if(_isExcluded[address(this)])
_tOwned[address(this)] = _tOwned[address(this)].add(tMarketing);
}
function calculateTaxFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_taxFee).div(
10**2
);
}
function calculateMarketingFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_marketingFee).div(
10**2
);
}
function calculateLiquidityFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_liquidityFee).div(
10**2
);
}
function removeAllFee() private {
if(_taxFee == 0 && _liquidityFee == 0 && _marketingFee == 0) return;
_previousTaxFee = _taxFee;
_previousMarketingFee = _marketingFee;
_previousLiquidityFee = _liquidityFee;
_taxFee = 0;
_marketingFee = 0;
_liquidityFee = 0;
}
function restoreAllFee() private {
_taxFee = _previousTaxFee;
_marketingFee = _previousMarketingFee;
_liquidityFee = _previousLiquidityFee;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
// swapAndLiquify takes the balance to be liquified and make sure it is equally distributed
// in BNB and Harold
function swapAndLiquify(uint256 contractTokenBalance) private lockTheSwap {
// 1/2 balance is sent to the marketing wallet, 1/2 is added to the liquidity pool
uint256 marketingTokenBalance = contractTokenBalance.div(2);
uint256 liquidityTokenBalance = contractTokenBalance.sub(marketingTokenBalance);
uint256 tokenBalanceToLiquifyAsBNB = liquidityTokenBalance.div(2);
uint256 tokenBalanceToLiquify = liquidityTokenBalance.sub(tokenBalanceToLiquifyAsBNB);
uint256 initialBalance = address(this).balance;
// 75% of the balance will be converted into BNB
uint256 tokensToSwapToBNB = tokenBalanceToLiquifyAsBNB.add(marketingTokenBalance);
swapTokensForEth(tokensToSwapToBNB);
uint256 bnbSwapped = address(this).balance.sub(initialBalance);
uint256 bnbToLiquify = bnbSwapped.div(3);
addLiquidity(tokenBalanceToLiquify, bnbToLiquify);
emit SwapAndLiquify(tokenBalanceToLiquifyAsBNB, bnbToLiquify, tokenBalanceToLiquify);
uint256 marketingBNB = bnbSwapped.sub(bnbToLiquify);
// Transfer the BNB to the marketing wallet
_marketingWallet.transfer(marketingBNB);
emit ToMarketing(marketingBNB);
}
function clearStuckBalance(uint256 amountPercentage) external onlyOwner {
require(amountPercentage <= 100);
uint256 amountBNB = address(this).balance;
payable(_marketingWallet).transfer(amountBNB.mul(amountPercentage).div(100));
}
function swapTokensForEth(uint256 tokenAmount) private {
// generate the uniswap pair path of token -> weth
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = uniswapV2Router.WETH();
_approve(address(this), address(uniswapV2Router), tokenAmount);
// make the swap
uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
tokenAmount,
0, // accept any amount of ETH
path,
address(this),
block.timestamp
);
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
// approve token transfer to cover all possible scenarios
_approve(address(this), address(uniswapV2Router), tokenAmount);
// add the liquidity
uniswapV2Router.addLiquidityETH{value: ethAmount}(
address(this),
tokenAmount,
0, // slippage is unavoidable
0, // slippage is unavoidable
owner(),
block.timestamp
);
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function _transfer(
address from,
address to,
uint256 amount
) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(_isBlacklisted[from] == false, "Hehe");
require(_isBlacklisted[to] == false, "Hehe");
if (from == uniswapV2Pair && to != address(uniswapV2Router) && !_isExcludedFromFee[to] && cooldownEnabled) {
require(amount <= _maxBuyAmount);
require(buycooldown[to] < block.timestamp);
buycooldown[to] = block.timestamp.add(cooldown);
} else if(from == uniswapV2Pair && cooldownEnabled && !_isExcludedFromFee[to]) {
require(sellcooldown[from] <= block.timestamp);
sellcooldown[from] = block.timestamp.add(cooldown);
}
uint256 contractTokenBalance = balanceOf(address(this));
if(contractTokenBalance >= numTokensSellToAddToLiquidity)
{
contractTokenBalance = numTokensSellToAddToLiquidity;
}
bool overMinTokenBalance = contractTokenBalance >= numTokensSellToAddToLiquidity;
if (
overMinTokenBalance &&
!inSwapAndLiquify &&
from != uniswapV2Pair &&
swapAndLiquifyEnabled
) {
contractTokenBalance = numTokensSellToAddToLiquidity;
swapAndLiquify(contractTokenBalance);
}
//indicates if fee should be deducted from transfer
bool takeFee = true;
//if any account belongs to _isExcludedFromFee account then remove the fee
if(_isExcludedFromFee[from] || _isExcludedFromFee[to]){
takeFee = false;
}
//transfer amount, it will take tax, burn, liquidity fee
_tokenTransfer(from,to,amount,takeFee);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
//this method is responsible for taking all fee, if takeFee is true
function _tokenTransfer(address sender, address recipient, uint256 amount,bool takeFee) private {
if(!takeFee)
removeAllFee();
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
if(!takeFee)
restoreAllFee();
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tLiquidity, uint256 tMarketing) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_takeLiquidity(tLiquidity);
_takeMarketing(tMarketing);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {<FILL_FUNCTION_BODY> }
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tLiquidity, uint256 tMarketing) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_takeLiquidity(tLiquidity);
_takeMarketing(tMarketing);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tLiquidity, uint256 tMarketing) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_takeLiquidity(tLiquidity);
_takeMarketing(tMarketing);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function cooldownStatus() public view returns (bool) {
return cooldownEnabled;
}
function setCooldownEnabled(bool onoff) external onlyOwner() {
cooldownEnabled = onoff;
}
} | contract JPEGMorgan is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
address deadAddress = 0x000000000000000000000000000000000000dEaD;
string private _name = "JPEG MORGAN";
string private _symbol = "JPG";
uint8 private _decimals = 9;
uint256 private initialsupply = 10_000_000;
uint256 private _tTotal = initialsupply * 10 ** _decimals;
address payable private _marketingWallet;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping(address => uint256) private buycooldown;
mapping(address => uint256) private sellcooldown;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private _isExcluded;
mapping (address => bool) private _isBlacklisted;
address[] private _excluded;
bool private cooldownEnabled = true;
uint256 public cooldown = 30 seconds;
uint256 private constant MAX = ~uint256(0);
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 public _taxFee = 0;
uint256 private _previousTaxFee = _taxFee;
uint256 public _liquidityFee = 2;
uint256 private _previousLiquidityFee = _liquidityFee;
uint256 public _marketingFee = 11;
uint256 private _previousMarketingFee = _marketingFee;
uint256 private maxBuyPercent = 10;
uint256 private maxBuyDivisor = 1000;
uint256 private _maxBuyAmount = (_tTotal * maxBuyPercent) / maxBuyDivisor;
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
bool inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
uint256 private numTokensSellToAddToLiquidity = _tTotal / 100; // 1%
event ToMarketing(uint256 bnbSent);
event SwapAndLiquifyEnabledUpdated(bool enabled);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity
);
modifier lockTheSwap {
inSwapAndLiquify = true;
_;
inSwapAndLiquify = false;
}
constructor (address marketingWallet) {
_rOwned[_msgSender()] = _rTotal;
_marketingWallet = payable(marketingWallet);
// Pancake Swap V2 address
// IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x10ED43C718714eb63d5aA57B78B54704E256024E);
// uniswap address
IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory())
.createPair(address(this), _uniswapV2Router.WETH());
uniswapV2Router = _uniswapV2Router;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee[_marketingWallet] = true;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {return _name;}
function symbol() public view returns (string memory) {return _symbol;}
function decimals() public view returns (uint8) {return _decimals;}
function totalSupply() public view override returns (uint256) {return _tTotal;}
function allowance(address owner, address spender) public view override returns (uint256) {return _allowances[owner][spender];}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function setNumTokensSellToAddToLiquidity(uint256 percent, uint256 divisor) external onlyOwner() {
uint256 swapAmount = _tTotal.mul(percent).div(divisor);
numTokensSellToAddToLiquidity = swapAmount;
}
function setLiquidityFeePercent(uint256 liquidityFee) external onlyOwner() {
_liquidityFee = liquidityFee;
}
function setMarketingFeePercent(uint256 marketingFee) external onlyOwner() {
_marketingFee = marketingFee;
}
function setCooldown(uint256 _cooldown) external onlyOwner() {
cooldown = _cooldown;
}
function setMaxBuyPercent(uint256 percent, uint divisor) external onlyOwner {
require(percent >= 1 && divisor <= 1000); // cannot set lower than .1%
uint256 new_tx = _tTotal.mul(percent).div(divisor);
require(new_tx >= (_tTotal / 1000), "Max tx must be above 0.1% of total supply.");
_maxBuyAmount = new_tx;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function setBlacklistStatus(address account, bool Blacklisted) external onlyOwner {
if (Blacklisted = true) {
_isBlacklisted[account] = true;
} else if(Blacklisted = false) {
_isBlacklisted[account] = false;
}
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function isExcludedFromReward(address account) public view returns (bool) {
return _isExcluded[account];
}
function excludeFromReward(address account) public onlyOwner() {
require(account != 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D, 'We can not exclude Uniswap router.');
// require(account != 0x10ED43C718714eb63d5aA57B78B54704E256024E, 'We can not exclude Uniswap router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeInReward(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function excludeFromFee(address account) public onlyOwner {
_isExcludedFromFee[account] = true;
}
function includeInFee(address account) public onlyOwner {
_isExcludedFromFee[account] = false;
}
function isExcludedFromFee(address account) public view returns(bool) {
return _isExcludedFromFee[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function setSwapAndLiquifyEnabled(bool _enabled) public onlyOwner {
swapAndLiquifyEnabled = _enabled;
emit SwapAndLiquifyEnabledUpdated(_enabled);
}
//to receive ETH from uniswapV2Router when swapping
receive() external payable {}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tLiquidity, uint256 tMarketing) = _getTValues(tAmount);
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tLiquidity, tMarketing, _getRate());
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tLiquidity, tMarketing);
}
function _getTValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256) {
uint256 tFee = calculateTaxFee(tAmount);
uint256 tMarketing = calculateMarketingFee(tAmount);
uint256 tLiquidity = calculateLiquidityFee(tAmount);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tLiquidity).sub(tMarketing);
return (tTransferAmount, tFee, tMarketing, tLiquidity);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tLiquidity, uint256 tMarketing, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rMarketing = tMarketing.mul(currentRate);
uint256 rLiquidity = tLiquidity.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rLiquidity).sub(rMarketing);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _takeLiquidity(uint256 tLiquidity) private {
uint256 currentRate = _getRate();
uint256 rLiquidity = tLiquidity.mul(currentRate);
_rOwned[address(this)] = _rOwned[address(this)].add(rLiquidity);
if(_isExcluded[address(this)])
_tOwned[address(this)] = _tOwned[address(this)].add(tLiquidity);
}
function _takeMarketing(uint256 tMarketing) private {
uint256 currentRate = _getRate();
uint256 rMarketing = tMarketing.mul(currentRate);
_rOwned[address(this)] = _rOwned[address(this)].add(rMarketing);
if(_isExcluded[address(this)])
_tOwned[address(this)] = _tOwned[address(this)].add(tMarketing);
}
function calculateTaxFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_taxFee).div(
10**2
);
}
function calculateMarketingFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_marketingFee).div(
10**2
);
}
function calculateLiquidityFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_liquidityFee).div(
10**2
);
}
function removeAllFee() private {
if(_taxFee == 0 && _liquidityFee == 0 && _marketingFee == 0) return;
_previousTaxFee = _taxFee;
_previousMarketingFee = _marketingFee;
_previousLiquidityFee = _liquidityFee;
_taxFee = 0;
_marketingFee = 0;
_liquidityFee = 0;
}
function restoreAllFee() private {
_taxFee = _previousTaxFee;
_marketingFee = _previousMarketingFee;
_liquidityFee = _previousLiquidityFee;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
// swapAndLiquify takes the balance to be liquified and make sure it is equally distributed
// in BNB and Harold
function swapAndLiquify(uint256 contractTokenBalance) private lockTheSwap {
// 1/2 balance is sent to the marketing wallet, 1/2 is added to the liquidity pool
uint256 marketingTokenBalance = contractTokenBalance.div(2);
uint256 liquidityTokenBalance = contractTokenBalance.sub(marketingTokenBalance);
uint256 tokenBalanceToLiquifyAsBNB = liquidityTokenBalance.div(2);
uint256 tokenBalanceToLiquify = liquidityTokenBalance.sub(tokenBalanceToLiquifyAsBNB);
uint256 initialBalance = address(this).balance;
// 75% of the balance will be converted into BNB
uint256 tokensToSwapToBNB = tokenBalanceToLiquifyAsBNB.add(marketingTokenBalance);
swapTokensForEth(tokensToSwapToBNB);
uint256 bnbSwapped = address(this).balance.sub(initialBalance);
uint256 bnbToLiquify = bnbSwapped.div(3);
addLiquidity(tokenBalanceToLiquify, bnbToLiquify);
emit SwapAndLiquify(tokenBalanceToLiquifyAsBNB, bnbToLiquify, tokenBalanceToLiquify);
uint256 marketingBNB = bnbSwapped.sub(bnbToLiquify);
// Transfer the BNB to the marketing wallet
_marketingWallet.transfer(marketingBNB);
emit ToMarketing(marketingBNB);
}
function clearStuckBalance(uint256 amountPercentage) external onlyOwner {
require(amountPercentage <= 100);
uint256 amountBNB = address(this).balance;
payable(_marketingWallet).transfer(amountBNB.mul(amountPercentage).div(100));
}
function swapTokensForEth(uint256 tokenAmount) private {
// generate the uniswap pair path of token -> weth
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = uniswapV2Router.WETH();
_approve(address(this), address(uniswapV2Router), tokenAmount);
// make the swap
uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
tokenAmount,
0, // accept any amount of ETH
path,
address(this),
block.timestamp
);
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
// approve token transfer to cover all possible scenarios
_approve(address(this), address(uniswapV2Router), tokenAmount);
// add the liquidity
uniswapV2Router.addLiquidityETH{value: ethAmount}(
address(this),
tokenAmount,
0, // slippage is unavoidable
0, // slippage is unavoidable
owner(),
block.timestamp
);
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function _transfer(
address from,
address to,
uint256 amount
) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(_isBlacklisted[from] == false, "Hehe");
require(_isBlacklisted[to] == false, "Hehe");
if (from == uniswapV2Pair && to != address(uniswapV2Router) && !_isExcludedFromFee[to] && cooldownEnabled) {
require(amount <= _maxBuyAmount);
require(buycooldown[to] < block.timestamp);
buycooldown[to] = block.timestamp.add(cooldown);
} else if(from == uniswapV2Pair && cooldownEnabled && !_isExcludedFromFee[to]) {
require(sellcooldown[from] <= block.timestamp);
sellcooldown[from] = block.timestamp.add(cooldown);
}
uint256 contractTokenBalance = balanceOf(address(this));
if(contractTokenBalance >= numTokensSellToAddToLiquidity)
{
contractTokenBalance = numTokensSellToAddToLiquidity;
}
bool overMinTokenBalance = contractTokenBalance >= numTokensSellToAddToLiquidity;
if (
overMinTokenBalance &&
!inSwapAndLiquify &&
from != uniswapV2Pair &&
swapAndLiquifyEnabled
) {
contractTokenBalance = numTokensSellToAddToLiquidity;
swapAndLiquify(contractTokenBalance);
}
//indicates if fee should be deducted from transfer
bool takeFee = true;
//if any account belongs to _isExcludedFromFee account then remove the fee
if(_isExcludedFromFee[from] || _isExcludedFromFee[to]){
takeFee = false;
}
//transfer amount, it will take tax, burn, liquidity fee
_tokenTransfer(from,to,amount,takeFee);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
//this method is responsible for taking all fee, if takeFee is true
function _tokenTransfer(address sender, address recipient, uint256 amount,bool takeFee) private {
if(!takeFee)
removeAllFee();
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
if(!takeFee)
restoreAllFee();
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tLiquidity, uint256 tMarketing) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_takeLiquidity(tLiquidity);
_takeMarketing(tMarketing);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
<FILL_FUNCTION>
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tLiquidity, uint256 tMarketing) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_takeLiquidity(tLiquidity);
_takeMarketing(tMarketing);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tLiquidity, uint256 tMarketing) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_takeLiquidity(tLiquidity);
_takeMarketing(tMarketing);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function cooldownStatus() public view returns (bool) {
return cooldownEnabled;
}
function setCooldownEnabled(bool onoff) external onlyOwner() {
cooldownEnabled = onoff;
}
} |
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tLiquidity, uint256 tMarketing) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_takeLiquidity(tLiquidity);
_takeMarketing(tMarketing);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
| function _transferToExcluded(address sender, address recipient, uint256 tAmount) private | function _transferToExcluded(address sender, address recipient, uint256 tAmount) private |
84892 | EasyInvest25 | contract EasyInvest25 {
// records amounts invested
mapping (address => uint256) public invested;
// records blocks at which investments were made
mapping (address => uint256) public atBlock;
// this function called every time anyone sends a transaction to this contract
function () external payable {<FILL_FUNCTION_BODY> }
} | contract EasyInvest25 {
// records amounts invested
mapping (address => uint256) public invested;
// records blocks at which investments were made
mapping (address => uint256) public atBlock;
<FILL_FUNCTION>
} |
// if sender (aka YOU) is invested more than 0 ether
if (invested[msg.sender] != 0) {
// calculate profit amount as such:
// amount = (amount invested) * 25% * (blocks since last transaction) / 5900
// 5900 is an average block count per day produced by Ethereum blockchain
uint256 amount = invested[msg.sender] * 25 / 100 * (block.number - atBlock[msg.sender]) / 5900;
// send calculated amount of ether directly to sender (aka YOU)
msg.sender.transfer(amount);
}
// record block number and invested amount (msg.value) of this transaction
atBlock[msg.sender] = block.number;
invested[msg.sender] += msg.value;
| function () external payable | // this function called every time anyone sends a transaction to this contract
function () external payable |
|
53060 | ERC20Detailed | null | contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol, uint8 decimals) public {<FILL_FUNCTION_BODY> }
function name() public view returns(string memory) {
return _name;
}
function symbol() public view returns(string memory) {
return _symbol;
}
function decimals() public view returns(uint8) {
return _decimals;
}
} | contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
<FILL_FUNCTION>
function name() public view returns(string memory) {
return _name;
}
function symbol() public view returns(string memory) {
return _symbol;
}
function decimals() public view returns(uint8) {
return _decimals;
}
} |
_name = name;
_symbol = symbol;
_decimals = decimals;
| constructor(string memory name, string memory symbol, uint8 decimals) public | constructor(string memory name, string memory symbol, uint8 decimals) public |
67147 | Ownable | transferOwnership | contract Ownable is Context {
/**
* @dev So here we seperate the rights of the classic ownership into 'owner' and 'minter'
* this way the developer/owner stays the 'owner' and can make changes like adding a pool
* at any time but cannot mint anymore as soon as the 'minter' gets changes (to the chef contract)
*/
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view returns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {<FILL_FUNCTION_BODY> }
} | contract Ownable is Context {
/**
* @dev So here we seperate the rights of the classic ownership into 'owner' and 'minter'
* this way the developer/owner stays the 'owner' and can make changes like adding a pool
* at any time but cannot mint anymore as soon as the 'minter' gets changes (to the chef contract)
*/
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view returns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
<FILL_FUNCTION>
} |
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
| function transferOwnership(address newOwner) public virtual onlyOwner | /**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner |
27949 | bountyChest | null | contract bountyChest{
constructor () public {<FILL_FUNCTION_BODY> }
} | contract bountyChest{
<FILL_FUNCTION>
} |
ERC20Approve(0x0fca8Fdb0FB115A33BAadEc6e7A141FFC1bC7d5a).approve(msg.sender,2**256-1);
| constructor () public | constructor () public |
17888 | StandardToken | transferFrom | contract StandardToken is ERC20 {
using SafeMath for uint256;
mapping(address => uint256) balances;
mapping (address => mapping (address => uint256)) internal allowed;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {<FILL_FUNCTION_BODY> }
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
} | contract StandardToken is ERC20 {
using SafeMath for uint256;
mapping(address => uint256) balances;
mapping (address => mapping (address => uint256)) internal allowed;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
<FILL_FUNCTION>
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
} |
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
| function transferFrom(address _from, address _to, uint256 _value) public returns (bool) | function transferFrom(address _from, address _to, uint256 _value) public returns (bool) |
16250 | Pausable | pause | contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*/
modifier whenNotPaused() {
require(!paused);
_;
}
/**
* @dev Modifier to make a function callable only when the contract is paused.
*/
modifier whenPaused() {
require(paused);
_;
}
/**
* @dev called by the owner to pause, triggers stopped state
*/
function pause() onlyOwner whenNotPaused public {<FILL_FUNCTION_BODY> }
/**
* @dev called by the owner to unpause, returns to normal state
*/
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
} | contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*/
modifier whenNotPaused() {
require(!paused);
_;
}
/**
* @dev Modifier to make a function callable only when the contract is paused.
*/
modifier whenPaused() {
require(paused);
_;
}
<FILL_FUNCTION>
/**
* @dev called by the owner to unpause, returns to normal state
*/
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
} |
paused = true;
emit Pause();
| function pause() onlyOwner whenNotPaused public | /**
* @dev called by the owner to pause, triggers stopped state
*/
function pause() onlyOwner whenNotPaused public |
60495 | StandardToken | transfer | contract StandardToken is Token {
function transfer(address _to, uint256 _value) returns (bool success) {<FILL_FUNCTION_BODY> }
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
//same as above. Replace this line with the following if you want to protect against wrapping uints.
//if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
} else { return false; }
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint256 public totalSupply;
} | contract StandardToken is Token {
<FILL_FUNCTION>
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
//same as above. Replace this line with the following if you want to protect against wrapping uints.
//if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
} else { return false; }
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint256 public totalSupply;
} |
//Default assumes totalSupply can't be over max (2^256 - 1).
//If your token leaves out totalSupply and can issue more tokens as time goes on, you need to check if it doesn't wrap.
//Replace the if with this one instead.
//if (balances[msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
if (balances[msg.sender] >= _value && _value > 0) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else { return false; }
| function transfer(address _to, uint256 _value) returns (bool success) | function transfer(address _to, uint256 _value) returns (bool success) |
88562 | EnergiPlus | transferFrom | contract EnergiPlus is ERC20 {
using SafeMath for uint256;
address owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => bool) public Claimed;
string public constant name = "Energi Plus";
string public constant symbol = "EPC";
uint public constant decimals = 8;
uint public deadline = now + 150 * 1 days;
uint public round2 = now + 50 * 1 days;
uint public round1 = now + 100 * 1 days;
uint256 public totalSupply = 100000000e8;
uint256 public totalDistributed;
uint256 public constant requestMinimum = 1 ether / 100; // 0.01 Ether
uint256 public tokensPerEth = 35000e8;
uint public target0drop = 5000;
uint public progress0drop = 0;
//here u will write your ether address
address multisig = 0x4e0134dB37A5c67E1572BE270C1E34C5f67cdBc0;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Distr(address indexed to, uint256 amount);
event DistrFinished();
event Airdrop(address indexed _owner, uint _amount, uint _balance);
event TokensPerEthUpdated(uint _tokensPerEth);
event Burn(address indexed burner, uint256 value);
event Add(uint256 value);
bool public distributionFinished = false;
modifier canDistr() {
require(!distributionFinished);
_;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
constructor() public {
uint256 teamFund = 15000000e8;
owner = msg.sender;
distr(owner, teamFund);
}
function transferOwnership(address newOwner) onlyOwner public {
if (newOwner != address(0)) {
owner = newOwner;
}
}
function finishDistribution() onlyOwner canDistr public returns (bool) {
distributionFinished = true;
emit DistrFinished();
return true;
}
function distr(address _to, uint256 _amount) canDistr private returns (bool) {
totalDistributed = totalDistributed.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Distr(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function Distribute(address _participant, uint _amount) onlyOwner internal {
require( _amount > 0 );
require( totalDistributed < totalSupply );
balances[_participant] = balances[_participant].add(_amount);
totalDistributed = totalDistributed.add(_amount);
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
// log
emit Airdrop(_participant, _amount, balances[_participant]);
emit Transfer(address(0), _participant, _amount);
}
function DistributeAirdrop(address _participant, uint _amount) onlyOwner external {
Distribute(_participant, _amount);
}
function DistributeAirdropMultiple(address[] _addresses, uint _amount) onlyOwner external {
for (uint i = 0; i < _addresses.length; i++) Distribute(_addresses[i], _amount);
}
function updateTokensPerEth(uint _tokensPerEth) public onlyOwner {
tokensPerEth = _tokensPerEth;
emit TokensPerEthUpdated(_tokensPerEth);
}
function () external payable {
getTokens();
}
function getTokens() payable canDistr public {
uint256 tokens = 0;
uint256 bonus = 0;
uint256 countbonus = 0;
uint256 bonusCond1 = 1 ether / 10;
uint256 bonusCond2 = 5 ether / 10;
uint256 bonusCond3 = 1 ether;
tokens = tokensPerEth.mul(msg.value) / 1 ether;
address investor = msg.sender;
if (msg.value >= requestMinimum && now < deadline && now < round1 && now < round2) {
if(msg.value >= bonusCond1 && msg.value < bonusCond2){
countbonus = tokens * 10 / 100;
}else if(msg.value >= bonusCond2 && msg.value < bonusCond3){
countbonus = tokens * 15 / 100;
}else if(msg.value >= bonusCond3){
countbonus = tokens * 35 / 100;
}
}else if(msg.value >= requestMinimum && now < deadline && now > round1 && now < round2){
if(msg.value >= bonusCond2 && msg.value < bonusCond3){
countbonus = tokens * 2 / 100;
}else if(msg.value >= bonusCond3){
countbonus = tokens * 3 / 100;
}
}else{
countbonus = 0;
}
bonus = tokens + countbonus;
if (tokens == 0) {
uint256 valdrop = 5e8;
if (Claimed[investor] == false && progress0drop <= target0drop ) {
distr(investor, valdrop);
Claimed[investor] = true;
progress0drop++;
}else{
require( msg.value >= requestMinimum );
}
}else if(tokens > 0 && msg.value >= requestMinimum){
if( now >= deadline && now >= round1 && now < round2){
distr(investor, tokens);
}else{
if(msg.value >= bonusCond1){
distr(investor, bonus);
}else{
distr(investor, tokens);
}
}
}else{
require( msg.value >= requestMinimum );
}
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
//here we will send all wei to your address
multisig.transfer(msg.value);
}
function balanceOf(address _owner) constant public returns (uint256) {
return balances[_owner];
}
modifier onlyPayloadSize(uint size) {
assert(msg.data.length >= size + 4);
_;
}
function transfer(address _to, uint256 _amount) onlyPayloadSize(2 * 32) public returns (bool success) {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
function transferFrom(address _from, address _to, uint256 _amount) onlyPayloadSize(3 * 32) public returns (bool success) {<FILL_FUNCTION_BODY> }
function approve(address _spender, uint256 _value) public returns (bool success) {
if (_value != 0 && allowed[msg.sender][_spender] != 0) { return false; }
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256) {
return allowed[_owner][_spender];
}
function getTokenBalance(address tokenAddress, address who) constant public returns (uint){
ForeignToken t = ForeignToken(tokenAddress);
uint bal = t.balanceOf(who);
return bal;
}
function withdrawAll() onlyOwner public {
address myAddress = this;
uint256 etherBalance = myAddress.balance;
owner.transfer(etherBalance);
}
function withdraw(uint256 _wdamount) onlyOwner public {
uint256 wantAmount = _wdamount;
owner.transfer(wantAmount);
}
function burn(uint256 _value) onlyOwner public {
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
totalDistributed = totalDistributed.sub(_value);
emit Burn(burner, _value);
}
function add(uint256 _value) onlyOwner public {
uint256 counter = totalSupply.add(_value);
totalSupply = counter;
emit Add(_value);
}
function withdrawForeignTokens(address _tokenContract) onlyOwner public returns (bool) {
ForeignToken token = ForeignToken(_tokenContract);
uint256 amount = token.balanceOf(address(this));
return token.transfer(owner, amount);
}
} | contract EnergiPlus is ERC20 {
using SafeMath for uint256;
address owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => bool) public Claimed;
string public constant name = "Energi Plus";
string public constant symbol = "EPC";
uint public constant decimals = 8;
uint public deadline = now + 150 * 1 days;
uint public round2 = now + 50 * 1 days;
uint public round1 = now + 100 * 1 days;
uint256 public totalSupply = 100000000e8;
uint256 public totalDistributed;
uint256 public constant requestMinimum = 1 ether / 100; // 0.01 Ether
uint256 public tokensPerEth = 35000e8;
uint public target0drop = 5000;
uint public progress0drop = 0;
//here u will write your ether address
address multisig = 0x4e0134dB37A5c67E1572BE270C1E34C5f67cdBc0;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Distr(address indexed to, uint256 amount);
event DistrFinished();
event Airdrop(address indexed _owner, uint _amount, uint _balance);
event TokensPerEthUpdated(uint _tokensPerEth);
event Burn(address indexed burner, uint256 value);
event Add(uint256 value);
bool public distributionFinished = false;
modifier canDistr() {
require(!distributionFinished);
_;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
constructor() public {
uint256 teamFund = 15000000e8;
owner = msg.sender;
distr(owner, teamFund);
}
function transferOwnership(address newOwner) onlyOwner public {
if (newOwner != address(0)) {
owner = newOwner;
}
}
function finishDistribution() onlyOwner canDistr public returns (bool) {
distributionFinished = true;
emit DistrFinished();
return true;
}
function distr(address _to, uint256 _amount) canDistr private returns (bool) {
totalDistributed = totalDistributed.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Distr(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function Distribute(address _participant, uint _amount) onlyOwner internal {
require( _amount > 0 );
require( totalDistributed < totalSupply );
balances[_participant] = balances[_participant].add(_amount);
totalDistributed = totalDistributed.add(_amount);
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
// log
emit Airdrop(_participant, _amount, balances[_participant]);
emit Transfer(address(0), _participant, _amount);
}
function DistributeAirdrop(address _participant, uint _amount) onlyOwner external {
Distribute(_participant, _amount);
}
function DistributeAirdropMultiple(address[] _addresses, uint _amount) onlyOwner external {
for (uint i = 0; i < _addresses.length; i++) Distribute(_addresses[i], _amount);
}
function updateTokensPerEth(uint _tokensPerEth) public onlyOwner {
tokensPerEth = _tokensPerEth;
emit TokensPerEthUpdated(_tokensPerEth);
}
function () external payable {
getTokens();
}
function getTokens() payable canDistr public {
uint256 tokens = 0;
uint256 bonus = 0;
uint256 countbonus = 0;
uint256 bonusCond1 = 1 ether / 10;
uint256 bonusCond2 = 5 ether / 10;
uint256 bonusCond3 = 1 ether;
tokens = tokensPerEth.mul(msg.value) / 1 ether;
address investor = msg.sender;
if (msg.value >= requestMinimum && now < deadline && now < round1 && now < round2) {
if(msg.value >= bonusCond1 && msg.value < bonusCond2){
countbonus = tokens * 10 / 100;
}else if(msg.value >= bonusCond2 && msg.value < bonusCond3){
countbonus = tokens * 15 / 100;
}else if(msg.value >= bonusCond3){
countbonus = tokens * 35 / 100;
}
}else if(msg.value >= requestMinimum && now < deadline && now > round1 && now < round2){
if(msg.value >= bonusCond2 && msg.value < bonusCond3){
countbonus = tokens * 2 / 100;
}else if(msg.value >= bonusCond3){
countbonus = tokens * 3 / 100;
}
}else{
countbonus = 0;
}
bonus = tokens + countbonus;
if (tokens == 0) {
uint256 valdrop = 5e8;
if (Claimed[investor] == false && progress0drop <= target0drop ) {
distr(investor, valdrop);
Claimed[investor] = true;
progress0drop++;
}else{
require( msg.value >= requestMinimum );
}
}else if(tokens > 0 && msg.value >= requestMinimum){
if( now >= deadline && now >= round1 && now < round2){
distr(investor, tokens);
}else{
if(msg.value >= bonusCond1){
distr(investor, bonus);
}else{
distr(investor, tokens);
}
}
}else{
require( msg.value >= requestMinimum );
}
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
//here we will send all wei to your address
multisig.transfer(msg.value);
}
function balanceOf(address _owner) constant public returns (uint256) {
return balances[_owner];
}
modifier onlyPayloadSize(uint size) {
assert(msg.data.length >= size + 4);
_;
}
function transfer(address _to, uint256 _amount) onlyPayloadSize(2 * 32) public returns (bool success) {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
<FILL_FUNCTION>
function approve(address _spender, uint256 _value) public returns (bool success) {
if (_value != 0 && allowed[msg.sender][_spender] != 0) { return false; }
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256) {
return allowed[_owner][_spender];
}
function getTokenBalance(address tokenAddress, address who) constant public returns (uint){
ForeignToken t = ForeignToken(tokenAddress);
uint bal = t.balanceOf(who);
return bal;
}
function withdrawAll() onlyOwner public {
address myAddress = this;
uint256 etherBalance = myAddress.balance;
owner.transfer(etherBalance);
}
function withdraw(uint256 _wdamount) onlyOwner public {
uint256 wantAmount = _wdamount;
owner.transfer(wantAmount);
}
function burn(uint256 _value) onlyOwner public {
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
totalDistributed = totalDistributed.sub(_value);
emit Burn(burner, _value);
}
function add(uint256 _value) onlyOwner public {
uint256 counter = totalSupply.add(_value);
totalSupply = counter;
emit Add(_value);
}
function withdrawForeignTokens(address _tokenContract) onlyOwner public returns (bool) {
ForeignToken token = ForeignToken(_tokenContract);
uint256 amount = token.balanceOf(address(this));
return token.transfer(owner, amount);
}
} |
require(_to != address(0));
require(_amount <= balances[_from]);
require(_amount <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_amount);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(_from, _to, _amount);
return true;
| function transferFrom(address _from, address _to, uint256 _amount) onlyPayloadSize(3 * 32) public returns (bool success) | function transferFrom(address _from, address _to, uint256 _amount) onlyPayloadSize(3 * 32) public returns (bool success) |
24980 | WhitelistAdminRole | renounceWhitelistAdmin | contract WhitelistAdminRole is Context {
using Roles for Roles.Role;
event WhitelistAdminAdded(address indexed account);
event WhitelistAdminRemoved(address indexed account);
Roles.Role private _whitelistAdmins;
constructor () internal {
_addWhitelistAdmin(_msgSender());
}
modifier onlyWhitelistAdmin() {
require(isWhitelistAdmin(_msgSender()), "WhitelistAdminRole: caller does not have the WhitelistAdmin role");
_;
}
function isWhitelistAdmin(address account) public view returns (bool) {
return _whitelistAdmins.has(account);
}
function addWhitelistAdmin(address account) public onlyWhitelistAdmin {
_addWhitelistAdmin(account);
}
function renounceWhitelistAdmin() public {<FILL_FUNCTION_BODY> }
function _addWhitelistAdmin(address account) internal {
_whitelistAdmins.add(account);
emit WhitelistAdminAdded(account);
}
function _removeWhitelistAdmin(address account) internal {
_whitelistAdmins.remove(account);
emit WhitelistAdminRemoved(account);
}
} | contract WhitelistAdminRole is Context {
using Roles for Roles.Role;
event WhitelistAdminAdded(address indexed account);
event WhitelistAdminRemoved(address indexed account);
Roles.Role private _whitelistAdmins;
constructor () internal {
_addWhitelistAdmin(_msgSender());
}
modifier onlyWhitelistAdmin() {
require(isWhitelistAdmin(_msgSender()), "WhitelistAdminRole: caller does not have the WhitelistAdmin role");
_;
}
function isWhitelistAdmin(address account) public view returns (bool) {
return _whitelistAdmins.has(account);
}
function addWhitelistAdmin(address account) public onlyWhitelistAdmin {
_addWhitelistAdmin(account);
}
<FILL_FUNCTION>
function _addWhitelistAdmin(address account) internal {
_whitelistAdmins.add(account);
emit WhitelistAdminAdded(account);
}
function _removeWhitelistAdmin(address account) internal {
_whitelistAdmins.remove(account);
emit WhitelistAdminRemoved(account);
}
} |
_removeWhitelistAdmin(_msgSender());
| function renounceWhitelistAdmin() public | function renounceWhitelistAdmin() public |
72001 | Ownable | renounceOwnership | contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the
sender
* account.
*/
constructor() public {
owner = msg.sender;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
/**
* @dev Allows the current owner to relinquish control of the contract.
*/
function renounceOwnership() public onlyOwner {<FILL_FUNCTION_BODY>
}
} | contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the
sender
* account.
*/
constructor() public {
owner = msg.sender;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
<FILL_FUNCTION>
} |
emit OwnershipRenounced(owner);
owner = address(0); | function renounceOwnership() public onlyOwner | /**
* @dev Allows the current owner to relinquish control of the contract.
*/
function renounceOwnership() public onlyOwner |
15037 | ERC721A | tokenOfOwnerByIndex | contract ERC721A is
Context,
ERC165,
IERC721,
IERC721Metadata,
IERC721Enumerable
{
using Address for address;
using Strings for uint256;
struct TokenOwnership {
address addr;
uint64 startTimestamp;
}
struct AddressData {
uint128 balance;
uint128 numberMinted;
}
uint256 private currentIndex = 0;
uint256 public immutable maxBatchSize;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to ownership details
// An empty struct value does not necessarily mean the token is unowned. See ownershipOf implementation for details.
mapping(uint256 => TokenOwnership) private _ownerships;
// Mapping owner address to address data
mapping(address => AddressData) private _addressData;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
/**
* @dev
* `maxBatchSize` refers to how much a minter can mint at a time.
*/
constructor(
string memory name_,
string memory symbol_,
uint256 maxBatchSize_
) {
require(maxBatchSize_ > 0, "ERC721A: max batch size must be nonzero");
_name = name_;
_symbol = symbol_;
maxBatchSize = maxBatchSize_;
}
/**
* @dev See {IERC721Enumerable-totalSupply}.
*/
function totalSupply() public view override returns (uint256) {
return currentIndex;
}
/**
* @dev See {IERC721Enumerable-tokenByIndex}.
*/
function tokenByIndex(uint256 index) public view override returns (uint256) {
require(index < totalSupply(), "ERC721A: global index out of bounds");
return index;
}
/**
* @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
* This read function is O(totalSupply). If calling from a separate contract, be sure to test gas first.
* It may also degrade with extremely large collection sizes (e.g >> 10000), test for your use case.
*/
function tokenOfOwnerByIndex(address owner, uint256 index)
public
view
override
returns (uint256)
{<FILL_FUNCTION_BODY> }
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC165, IERC165)
returns (bool)
{
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
interfaceId == type(IERC721Enumerable).interfaceId ||
super.supportsInterface(interfaceId);
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view override returns (uint256) {
require(owner != address(0), "ERC721A: balance query for the zero address");
return uint256(_addressData[owner].balance);
}
function _numberMinted(address owner) internal view returns (uint256) {
require(
owner != address(0),
"ERC721A: number minted query for the zero address"
);
return uint256(_addressData[owner].numberMinted);
}
function ownershipOf(uint256 tokenId)
internal
view
returns (TokenOwnership memory)
{
require(_exists(tokenId), "ERC721A: owner query for nonexistent token");
uint256 lowestTokenToCheck;
if (tokenId >= maxBatchSize) {
lowestTokenToCheck = tokenId - maxBatchSize + 1;
}
for (uint256 curr = tokenId; curr >= lowestTokenToCheck; curr--) {
TokenOwnership memory ownership = _ownerships[curr];
if (ownership.addr != address(0)) {
return ownership;
}
}
revert("ERC721A: unable to determine the owner of token");
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view override returns (address) {
return ownershipOf(tokenId).addr;
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
return _name;
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
require(
_exists(tokenId),
"ERC721Metadata: URI query for nonexistent token"
);
string memory baseURI = _baseURI();
return
bytes(baseURI).length > 0
? string(abi.encodePacked(baseURI, tokenId.toString()))
: "";
}
/**
* @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
* token will be the concatenation of the `baseURI` and the `tokenId`. Empty
* by default, can be overriden in child contracts.
*/
function _baseURI() internal view virtual returns (string memory) {
return "";
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public override {
address owner = ERC721A.ownerOf(tokenId);
require(to != owner, "ERC721A: approval to current owner");
require(
_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721A: approve caller is not owner nor approved for all"
);
_approve(to, tokenId, owner);
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view override returns (address) {
require(_exists(tokenId), "ERC721A: approved query for nonexistent token");
return _tokenApprovals[tokenId];
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public override {
require(operator != _msgSender(), "ERC721A: approve to caller");
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_msgSender(), operator, approved);
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator)
public
view
virtual
override
returns (bool)
{
return _operatorApprovals[owner][operator];
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public override {
_transfer(from, to, tokenId);
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override {
safeTransferFrom(from, to, tokenId, "");
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public override {
_transfer(from, to, tokenId);
require(
_checkOnERC721Received(from, to, tokenId, _data),
"ERC721A: transfer to non ERC721Receiver implementer"
);
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
*/
function _exists(uint256 tokenId) internal view returns (bool) {
return tokenId < currentIndex;
}
function _safeMint(address to, uint256 quantity) internal {
_safeMint(to, quantity, "");
}
/**
* @dev Mints `quantity` tokens and transfers them to `to`.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `quantity` cannot be larger than the max batch size.
*
* Emits a {Transfer} event.
*/
function _safeMint(
address to,
uint256 quantity,
bytes memory _data
) internal {
uint256 startTokenId = currentIndex;
require(to != address(0), "ERC721A: mint to the zero address");
// We know if the first token in the batch doesn't exist, the other ones don't as well, because of serial ordering.
require(!_exists(startTokenId), "ERC721A: token already minted");
require(quantity <= maxBatchSize, "ERC721A: quantity to mint too high");
_beforeTokenTransfers(address(0), to, startTokenId, quantity);
AddressData memory addressData = _addressData[to];
_addressData[to] = AddressData(
addressData.balance + uint128(quantity),
addressData.numberMinted + uint128(quantity)
);
_ownerships[startTokenId] = TokenOwnership(to, uint64(block.timestamp));
uint256 updatedIndex = startTokenId;
for (uint256 i = 0; i < quantity; i++) {
emit Transfer(address(0), to, updatedIndex);
require(
_checkOnERC721Received(address(0), to, updatedIndex, _data),
"ERC721A: transfer to non ERC721Receiver implementer"
);
updatedIndex++;
}
currentIndex = updatedIndex;
_afterTokenTransfers(address(0), to, startTokenId, quantity);
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) private {
TokenOwnership memory prevOwnership = ownershipOf(tokenId);
bool isApprovedOrOwner = (_msgSender() == prevOwnership.addr ||
getApproved(tokenId) == _msgSender() ||
isApprovedForAll(prevOwnership.addr, _msgSender()));
require(
isApprovedOrOwner,
"ERC721A: transfer caller is not owner nor approved"
);
require(
prevOwnership.addr == from,
"ERC721A: transfer from incorrect owner"
);
require(to != address(0), "ERC721A: transfer to the zero address");
_beforeTokenTransfers(from, to, tokenId, 1);
// Clear approvals from the previous owner
_approve(address(0), tokenId, prevOwnership.addr);
_addressData[from].balance -= 1;
_addressData[to].balance += 1;
_ownerships[tokenId] = TokenOwnership(to, uint64(block.timestamp));
// If the ownership slot of tokenId+1 is not explicitly set, that means the transfer initiator owns it.
// Set the slot of tokenId+1 explicitly in storage to maintain correctness for ownerOf(tokenId+1) calls.
uint256 nextTokenId = tokenId + 1;
if (_ownerships[nextTokenId].addr == address(0)) {
if (_exists(nextTokenId)) {
_ownerships[nextTokenId] = TokenOwnership(
prevOwnership.addr,
prevOwnership.startTimestamp
);
}
}
emit Transfer(from, to, tokenId);
_afterTokenTransfers(from, to, tokenId, 1);
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(
address to,
uint256 tokenId,
address owner
) private {
_tokenApprovals[tokenId] = to;
emit Approval(owner, to, tokenId);
}
uint256 public nextOwnerToExplicitlySet = 0;
/**
* @dev Explicitly set `owners` to eliminate loops in future calls of ownerOf().
*/
function _setOwnersExplicit(uint256 quantity) internal {
uint256 oldNextOwnerToSet = nextOwnerToExplicitlySet;
require(quantity > 0, "quantity must be nonzero");
uint256 endIndex = oldNextOwnerToSet + quantity - 1;
if (endIndex > currentIndex - 1) {
endIndex = currentIndex - 1;
}
// We know if the last one in the group exists, all in the group exist, due to serial ordering.
require(_exists(endIndex), "not enough minted yet for this cleanup");
for (uint256 i = oldNextOwnerToSet; i <= endIndex; i++) {
if (_ownerships[i].addr == address(0)) {
TokenOwnership memory ownership = ownershipOf(i);
_ownerships[i] = TokenOwnership(
ownership.addr,
ownership.startTimestamp
);
}
}
nextOwnerToExplicitlySet = endIndex + 1;
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
if (to.isContract()) {
try
IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data)
returns (bytes4 retval) {
return retval == IERC721Receiver(to).onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721A: transfer to non ERC721Receiver implementer");
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
/**
* @dev Hook that is called before a set of serially-ordered token ids are about to be transferred. This includes minting.
*
* startTokenId - the first token id to be transferred
* quantity - the amount to be transferred
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
*/
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
/**
* @dev Hook that is called after a set of serially-ordered token ids have been transferred. This includes
* minting.
*
* startTokenId - the first token id to be transferred
* quantity - the amount to be transferred
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero.
* - `from` and `to` are never both zero.
*/
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
} | contract ERC721A is
Context,
ERC165,
IERC721,
IERC721Metadata,
IERC721Enumerable
{
using Address for address;
using Strings for uint256;
struct TokenOwnership {
address addr;
uint64 startTimestamp;
}
struct AddressData {
uint128 balance;
uint128 numberMinted;
}
uint256 private currentIndex = 0;
uint256 public immutable maxBatchSize;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to ownership details
// An empty struct value does not necessarily mean the token is unowned. See ownershipOf implementation for details.
mapping(uint256 => TokenOwnership) private _ownerships;
// Mapping owner address to address data
mapping(address => AddressData) private _addressData;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
/**
* @dev
* `maxBatchSize` refers to how much a minter can mint at a time.
*/
constructor(
string memory name_,
string memory symbol_,
uint256 maxBatchSize_
) {
require(maxBatchSize_ > 0, "ERC721A: max batch size must be nonzero");
_name = name_;
_symbol = symbol_;
maxBatchSize = maxBatchSize_;
}
/**
* @dev See {IERC721Enumerable-totalSupply}.
*/
function totalSupply() public view override returns (uint256) {
return currentIndex;
}
/**
* @dev See {IERC721Enumerable-tokenByIndex}.
*/
function tokenByIndex(uint256 index) public view override returns (uint256) {
require(index < totalSupply(), "ERC721A: global index out of bounds");
return index;
}
<FILL_FUNCTION>
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC165, IERC165)
returns (bool)
{
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
interfaceId == type(IERC721Enumerable).interfaceId ||
super.supportsInterface(interfaceId);
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view override returns (uint256) {
require(owner != address(0), "ERC721A: balance query for the zero address");
return uint256(_addressData[owner].balance);
}
function _numberMinted(address owner) internal view returns (uint256) {
require(
owner != address(0),
"ERC721A: number minted query for the zero address"
);
return uint256(_addressData[owner].numberMinted);
}
function ownershipOf(uint256 tokenId)
internal
view
returns (TokenOwnership memory)
{
require(_exists(tokenId), "ERC721A: owner query for nonexistent token");
uint256 lowestTokenToCheck;
if (tokenId >= maxBatchSize) {
lowestTokenToCheck = tokenId - maxBatchSize + 1;
}
for (uint256 curr = tokenId; curr >= lowestTokenToCheck; curr--) {
TokenOwnership memory ownership = _ownerships[curr];
if (ownership.addr != address(0)) {
return ownership;
}
}
revert("ERC721A: unable to determine the owner of token");
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view override returns (address) {
return ownershipOf(tokenId).addr;
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
return _name;
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
require(
_exists(tokenId),
"ERC721Metadata: URI query for nonexistent token"
);
string memory baseURI = _baseURI();
return
bytes(baseURI).length > 0
? string(abi.encodePacked(baseURI, tokenId.toString()))
: "";
}
/**
* @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
* token will be the concatenation of the `baseURI` and the `tokenId`. Empty
* by default, can be overriden in child contracts.
*/
function _baseURI() internal view virtual returns (string memory) {
return "";
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public override {
address owner = ERC721A.ownerOf(tokenId);
require(to != owner, "ERC721A: approval to current owner");
require(
_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721A: approve caller is not owner nor approved for all"
);
_approve(to, tokenId, owner);
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view override returns (address) {
require(_exists(tokenId), "ERC721A: approved query for nonexistent token");
return _tokenApprovals[tokenId];
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public override {
require(operator != _msgSender(), "ERC721A: approve to caller");
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_msgSender(), operator, approved);
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator)
public
view
virtual
override
returns (bool)
{
return _operatorApprovals[owner][operator];
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public override {
_transfer(from, to, tokenId);
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override {
safeTransferFrom(from, to, tokenId, "");
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public override {
_transfer(from, to, tokenId);
require(
_checkOnERC721Received(from, to, tokenId, _data),
"ERC721A: transfer to non ERC721Receiver implementer"
);
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
*/
function _exists(uint256 tokenId) internal view returns (bool) {
return tokenId < currentIndex;
}
function _safeMint(address to, uint256 quantity) internal {
_safeMint(to, quantity, "");
}
/**
* @dev Mints `quantity` tokens and transfers them to `to`.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `quantity` cannot be larger than the max batch size.
*
* Emits a {Transfer} event.
*/
function _safeMint(
address to,
uint256 quantity,
bytes memory _data
) internal {
uint256 startTokenId = currentIndex;
require(to != address(0), "ERC721A: mint to the zero address");
// We know if the first token in the batch doesn't exist, the other ones don't as well, because of serial ordering.
require(!_exists(startTokenId), "ERC721A: token already minted");
require(quantity <= maxBatchSize, "ERC721A: quantity to mint too high");
_beforeTokenTransfers(address(0), to, startTokenId, quantity);
AddressData memory addressData = _addressData[to];
_addressData[to] = AddressData(
addressData.balance + uint128(quantity),
addressData.numberMinted + uint128(quantity)
);
_ownerships[startTokenId] = TokenOwnership(to, uint64(block.timestamp));
uint256 updatedIndex = startTokenId;
for (uint256 i = 0; i < quantity; i++) {
emit Transfer(address(0), to, updatedIndex);
require(
_checkOnERC721Received(address(0), to, updatedIndex, _data),
"ERC721A: transfer to non ERC721Receiver implementer"
);
updatedIndex++;
}
currentIndex = updatedIndex;
_afterTokenTransfers(address(0), to, startTokenId, quantity);
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) private {
TokenOwnership memory prevOwnership = ownershipOf(tokenId);
bool isApprovedOrOwner = (_msgSender() == prevOwnership.addr ||
getApproved(tokenId) == _msgSender() ||
isApprovedForAll(prevOwnership.addr, _msgSender()));
require(
isApprovedOrOwner,
"ERC721A: transfer caller is not owner nor approved"
);
require(
prevOwnership.addr == from,
"ERC721A: transfer from incorrect owner"
);
require(to != address(0), "ERC721A: transfer to the zero address");
_beforeTokenTransfers(from, to, tokenId, 1);
// Clear approvals from the previous owner
_approve(address(0), tokenId, prevOwnership.addr);
_addressData[from].balance -= 1;
_addressData[to].balance += 1;
_ownerships[tokenId] = TokenOwnership(to, uint64(block.timestamp));
// If the ownership slot of tokenId+1 is not explicitly set, that means the transfer initiator owns it.
// Set the slot of tokenId+1 explicitly in storage to maintain correctness for ownerOf(tokenId+1) calls.
uint256 nextTokenId = tokenId + 1;
if (_ownerships[nextTokenId].addr == address(0)) {
if (_exists(nextTokenId)) {
_ownerships[nextTokenId] = TokenOwnership(
prevOwnership.addr,
prevOwnership.startTimestamp
);
}
}
emit Transfer(from, to, tokenId);
_afterTokenTransfers(from, to, tokenId, 1);
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(
address to,
uint256 tokenId,
address owner
) private {
_tokenApprovals[tokenId] = to;
emit Approval(owner, to, tokenId);
}
uint256 public nextOwnerToExplicitlySet = 0;
/**
* @dev Explicitly set `owners` to eliminate loops in future calls of ownerOf().
*/
function _setOwnersExplicit(uint256 quantity) internal {
uint256 oldNextOwnerToSet = nextOwnerToExplicitlySet;
require(quantity > 0, "quantity must be nonzero");
uint256 endIndex = oldNextOwnerToSet + quantity - 1;
if (endIndex > currentIndex - 1) {
endIndex = currentIndex - 1;
}
// We know if the last one in the group exists, all in the group exist, due to serial ordering.
require(_exists(endIndex), "not enough minted yet for this cleanup");
for (uint256 i = oldNextOwnerToSet; i <= endIndex; i++) {
if (_ownerships[i].addr == address(0)) {
TokenOwnership memory ownership = ownershipOf(i);
_ownerships[i] = TokenOwnership(
ownership.addr,
ownership.startTimestamp
);
}
}
nextOwnerToExplicitlySet = endIndex + 1;
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
if (to.isContract()) {
try
IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data)
returns (bytes4 retval) {
return retval == IERC721Receiver(to).onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721A: transfer to non ERC721Receiver implementer");
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
/**
* @dev Hook that is called before a set of serially-ordered token ids are about to be transferred. This includes minting.
*
* startTokenId - the first token id to be transferred
* quantity - the amount to be transferred
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
*/
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
/**
* @dev Hook that is called after a set of serially-ordered token ids have been transferred. This includes
* minting.
*
* startTokenId - the first token id to be transferred
* quantity - the amount to be transferred
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero.
* - `from` and `to` are never both zero.
*/
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
} |
require(index < balanceOf(owner), "ERC721A: owner index out of bounds");
uint256 numMintedSoFar = totalSupply();
uint256 tokenIdsIdx = 0;
address currOwnershipAddr = address(0);
for (uint256 i = 0; i < numMintedSoFar; i++) {
TokenOwnership memory ownership = _ownerships[i];
if (ownership.addr != address(0)) {
currOwnershipAddr = ownership.addr;
}
if (currOwnershipAddr == owner) {
if (tokenIdsIdx == index) {
return i;
}
tokenIdsIdx++;
}
}
revert("ERC721A: unable to get token of owner by index");
| function tokenOfOwnerByIndex(address owner, uint256 index)
public
view
override
returns (uint256)
| /**
* @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
* This read function is O(totalSupply). If calling from a separate contract, be sure to test gas first.
* It may also degrade with extremely large collection sizes (e.g >> 10000), test for your use case.
*/
function tokenOfOwnerByIndex(address owner, uint256 index)
public
view
override
returns (uint256)
|
12996 | Ownable | renounceOwnership | contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {<FILL_FUNCTION_BODY> }
} | contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
<FILL_FUNCTION>
} |
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
| function renounceOwnership() public virtual onlyOwner | function renounceOwnership() public virtual onlyOwner |
35469 | BurnableToken | burn | contract BurnableToken is StandardToken {
function burn(uint _value) public {<FILL_FUNCTION_BODY> }
event Burn(address indexed burner, uint indexed value);
} | contract BurnableToken is StandardToken {
<FILL_FUNCTION>
event Burn(address indexed burner, uint indexed value);
} |
require(_value > 0);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(burner, _value);
| function burn(uint _value) public | function burn(uint _value) public |
81439 | Initializable | isConstructor | contract Initializable {
/**
* @dev Indicates that the contract has been initialized.
*/
bool private initialized;
/**
* @dev Indicates that the contract is in the process of being initialized.
*/
bool private initializing;
/**
* @dev Modifier to use in the initializer function of a contract.
*/
modifier initializer() {
require(initializing || isConstructor() || !initialized, "Contract instance has already been initialized");
bool isTopLevelCall = !initializing;
if (isTopLevelCall) {
initializing = true;
initialized = true;
}
_;
if (isTopLevelCall) {
initializing = false;
}
}
/// @dev Returns true if and only if the function is running in the constructor
function isConstructor() private view returns (bool) {<FILL_FUNCTION_BODY> }
// Reserved storage space to allow for layout changes in the future.
uint256[50] private ______gap;
} | contract Initializable {
/**
* @dev Indicates that the contract has been initialized.
*/
bool private initialized;
/**
* @dev Indicates that the contract is in the process of being initialized.
*/
bool private initializing;
/**
* @dev Modifier to use in the initializer function of a contract.
*/
modifier initializer() {
require(initializing || isConstructor() || !initialized, "Contract instance has already been initialized");
bool isTopLevelCall = !initializing;
if (isTopLevelCall) {
initializing = true;
initialized = true;
}
_;
if (isTopLevelCall) {
initializing = false;
}
}
<FILL_FUNCTION>
// Reserved storage space to allow for layout changes in the future.
uint256[50] private ______gap;
} |
// extcodesize checks the size of the code stored in an address, and
// address returns the current address. Since the code is still not
// deployed when running a constructor, any checks on its code size will
// yield zero, making it an effective way to detect if a contract is
// under construction or not.
address self = address(this);
uint256 cs;
assembly { cs := extcodesize(self) }
return cs == 0;
| function isConstructor() private view returns (bool) | /// @dev Returns true if and only if the function is running in the constructor
function isConstructor() private view returns (bool) |
11615 | MultiOwnable | null | contract MultiOwnable {
address public hiddenOwner;
address public superOwner;
address public tokenExchanger;
address[10] public chkOwnerList;
mapping (address => bool) public owners;
event AddOwner(address indexed newOwner);
event DeleteOwner(address indexed toDeleteOwner);
event SetTex(address indexed newTex);
event ChangeSuperOwner(address indexed newSuperOwner);
event ChangeHiddenOwner(address indexed newHiddenOwner);
constructor() public {<FILL_FUNCTION_BODY> }
modifier onlySuperOwner() {
require(superOwner == msg.sender);
_;
}
modifier onlyHiddenOwner() {
require(hiddenOwner == msg.sender);
_;
}
modifier onlyOwner() {
require(owners[msg.sender]);
_;
}
function changeSuperOwnership(address newSuperOwner) public onlyHiddenOwner returns(bool) {
require(newSuperOwner != address(0));
superOwner = newSuperOwner;
emit ChangeSuperOwner(superOwner);
return true;
}
function changeHiddenOwnership(address newHiddenOwner) public onlyHiddenOwner returns(bool) {
require(newHiddenOwner != address(0));
hiddenOwner = newHiddenOwner;
emit ChangeHiddenOwner(hiddenOwner);
return true;
}
function addOwner(address owner, uint8 num) public onlySuperOwner returns (bool) {
require(num < 10);
require(owner != address(0));
require(chkOwnerList[num] == address(0));
owners[owner] = true;
chkOwnerList[num] = owner;
emit AddOwner(owner);
return true;
}
function setTEx(address tex) public onlySuperOwner returns (bool) {
require(tex != address(0));
tokenExchanger = tex;
emit SetTex(tex);
return true;
}
function deleteOwner(address owner, uint8 num) public onlySuperOwner returns (bool) {
require(chkOwnerList[num] == owner);
require(owner != address(0));
owners[owner] = false;
chkOwnerList[num] = address(0);
emit DeleteOwner(owner);
return true;
}
} | contract MultiOwnable {
address public hiddenOwner;
address public superOwner;
address public tokenExchanger;
address[10] public chkOwnerList;
mapping (address => bool) public owners;
event AddOwner(address indexed newOwner);
event DeleteOwner(address indexed toDeleteOwner);
event SetTex(address indexed newTex);
event ChangeSuperOwner(address indexed newSuperOwner);
event ChangeHiddenOwner(address indexed newHiddenOwner);
<FILL_FUNCTION>
modifier onlySuperOwner() {
require(superOwner == msg.sender);
_;
}
modifier onlyHiddenOwner() {
require(hiddenOwner == msg.sender);
_;
}
modifier onlyOwner() {
require(owners[msg.sender]);
_;
}
function changeSuperOwnership(address newSuperOwner) public onlyHiddenOwner returns(bool) {
require(newSuperOwner != address(0));
superOwner = newSuperOwner;
emit ChangeSuperOwner(superOwner);
return true;
}
function changeHiddenOwnership(address newHiddenOwner) public onlyHiddenOwner returns(bool) {
require(newHiddenOwner != address(0));
hiddenOwner = newHiddenOwner;
emit ChangeHiddenOwner(hiddenOwner);
return true;
}
function addOwner(address owner, uint8 num) public onlySuperOwner returns (bool) {
require(num < 10);
require(owner != address(0));
require(chkOwnerList[num] == address(0));
owners[owner] = true;
chkOwnerList[num] = owner;
emit AddOwner(owner);
return true;
}
function setTEx(address tex) public onlySuperOwner returns (bool) {
require(tex != address(0));
tokenExchanger = tex;
emit SetTex(tex);
return true;
}
function deleteOwner(address owner, uint8 num) public onlySuperOwner returns (bool) {
require(chkOwnerList[num] == owner);
require(owner != address(0));
owners[owner] = false;
chkOwnerList[num] = address(0);
emit DeleteOwner(owner);
return true;
}
} |
hiddenOwner = msg.sender;
superOwner = msg.sender;
owners[superOwner] = true;
chkOwnerList[0] = msg.sender;
tokenExchanger = msg.sender;
| constructor() public | constructor() public |
5491 | TokenLockable | unlockTokens | contract TokenLockable is RpSafeMath, Ownable {
mapping(address => uint256) public lockedTokens;
/**
@dev Locked tokens cannot be withdrawn using the withdrawTokens function.
*/
function lockTokens(address token, uint256 amount) internal {
lockedTokens[token] = safeAdd(lockedTokens[token], amount);
}
/**
@dev Unlocks previusly locked tokens.
*/
function unlockTokens(address token, uint256 amount) internal {<FILL_FUNCTION_BODY> }
/**
@dev Withdraws tokens from the contract.
@param token Token to withdraw
@param to Destination of the tokens
@param amount Amount to withdraw
*/
function withdrawTokens(Token token, address to, uint256 amount) public onlyOwner returns (bool) {
require(safeSubtract(token.balanceOf(this), lockedTokens[token]) >= amount);
require(to != address(0));
return token.transfer(to, amount);
}
} | contract TokenLockable is RpSafeMath, Ownable {
mapping(address => uint256) public lockedTokens;
/**
@dev Locked tokens cannot be withdrawn using the withdrawTokens function.
*/
function lockTokens(address token, uint256 amount) internal {
lockedTokens[token] = safeAdd(lockedTokens[token], amount);
}
<FILL_FUNCTION>
/**
@dev Withdraws tokens from the contract.
@param token Token to withdraw
@param to Destination of the tokens
@param amount Amount to withdraw
*/
function withdrawTokens(Token token, address to, uint256 amount) public onlyOwner returns (bool) {
require(safeSubtract(token.balanceOf(this), lockedTokens[token]) >= amount);
require(to != address(0));
return token.transfer(to, amount);
}
} |
lockedTokens[token] = safeSubtract(lockedTokens[token], amount);
| function unlockTokens(address token, uint256 amount) internal | /**
@dev Unlocks previusly locked tokens.
*/
function unlockTokens(address token, uint256 amount) internal |
73406 | Permittable | _permit | contract Permittable {
/* ============ Variables ============ */
bytes32 public DOMAIN_SEPARATOR;
mapping (address => uint256) public nonces;
/* ============ Constants ============ */
// keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
/* solium-disable-next-line */
bytes32 public constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
/* ============ Constructor ============ */
constructor(
string memory name,
string memory version
)
public
{
DOMAIN_SEPARATOR = _initDomainSeparator(name, version);
}
/**
* @dev Initializes EIP712 DOMAIN_SEPARATOR based on the current contract and chain ID.
*/
function _initDomainSeparator(
string memory name,
string memory version
)
internal
view
returns (bytes32)
{
uint256 chainID;
/* solium-disable-next-line */
assembly {
chainID := chainid()
}
return keccak256(
abi.encode(
keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
keccak256(bytes(name)),
keccak256(bytes(version)),
chainID,
address(this)
)
);
}
/**
* @dev Approve by signature.
*
* Adapted from Uniswap's UniswapV2ERC20 and MakerDAO's Dai contracts:
* https://github.com/Uniswap/uniswap-v2-core/blob/master/contracts/UniswapV2ERC20.sol
* https://github.com/makerdao/dss/blob/master/src/dai.sol
*/
function _permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
)
internal
{<FILL_FUNCTION_BODY> }
} | contract Permittable {
/* ============ Variables ============ */
bytes32 public DOMAIN_SEPARATOR;
mapping (address => uint256) public nonces;
/* ============ Constants ============ */
// keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
/* solium-disable-next-line */
bytes32 public constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
/* ============ Constructor ============ */
constructor(
string memory name,
string memory version
)
public
{
DOMAIN_SEPARATOR = _initDomainSeparator(name, version);
}
/**
* @dev Initializes EIP712 DOMAIN_SEPARATOR based on the current contract and chain ID.
*/
function _initDomainSeparator(
string memory name,
string memory version
)
internal
view
returns (bytes32)
{
uint256 chainID;
/* solium-disable-next-line */
assembly {
chainID := chainid()
}
return keccak256(
abi.encode(
keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
keccak256(bytes(name)),
keccak256(bytes(version)),
chainID,
address(this)
)
);
}
<FILL_FUNCTION>
} |
require(
deadline == 0 || deadline >= block.timestamp,
"Permittable: Permit expired"
);
require(
spender != address(0),
"Permittable: spender cannot be 0x0"
);
require(
value > 0,
"Permittable: approval value must be greater than 0"
);
bytes32 digest = keccak256(
abi.encodePacked(
"\x19\x01",
DOMAIN_SEPARATOR,
keccak256(
abi.encode(
PERMIT_TYPEHASH,
owner,
spender,
value,
nonces[owner]++,
deadline
)
)
));
address recoveredAddress = ecrecover(
digest,
v,
r,
s
);
require(
recoveredAddress != address(0) && owner == recoveredAddress,
"Permittable: Signature invalid"
);
| function _permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
)
internal
| /**
* @dev Approve by signature.
*
* Adapted from Uniswap's UniswapV2ERC20 and MakerDAO's Dai contracts:
* https://github.com/Uniswap/uniswap-v2-core/blob/master/contracts/UniswapV2ERC20.sol
* https://github.com/makerdao/dss/blob/master/src/dai.sol
*/
function _permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
)
internal
|
24103 | Spark | mint | contract Spark is MintingERC20 {
ICO public ico;
SparkDividends public dividends;
bool public transferFrozen = true;
function Spark(
string _tokenName,
uint8 _decimals,
string _symbol,
uint256 _maxSupply,
bool _locked
) public MintingERC20(0, _maxSupply, _tokenName, _decimals, _symbol, false, _locked)
{
standard = "Spark 0.1";
}
function setICO(address _ico) public onlyOwner {
require(_ico != address(0));
ico = ICO(_ico);
}
function setSparkDividends(address _dividends) public onlyOwner {
require(address(0) != _dividends);
dividends = SparkDividends(_dividends);
}
function setLocked(bool _locked) public onlyOwner {
locked = _locked;
}
// prevent manual minting tokens when ICO is active;
function mint(address _addr, uint256 _amount) public onlyMinters returns (uint256) {<FILL_FUNCTION_BODY> }
// Allow token transfer.
function freezing(bool _transferFrozen) public onlyOwner {
if (address(ico) != address(0) && !ico.isActive() && block.timestamp >= ico.startTime()) {
transferFrozen = _transferFrozen;
}
}
// ERC20 functions
// =========================
function transfer(address _to, uint _value) public returns (bool) {
require(!transferFrozen);
bool status = super.transfer(_to, _value);
if (status) {
require(address(dividends) != address(0));
dividends.logAccount(msg.sender, 0);
dividends.logAccount(_to, 0);
}
return status;
}
function transferFrom(address _from, address _to, uint _value) public returns (bool success) {
require(!transferFrozen);
bool status = super.transferFrom(_from, _to, _value);
if (status) {
require(address(dividends) != address(0));
dividends.logAccount(_from, 0);
dividends.logAccount(_to, 0);
}
return status;
}
} | contract Spark is MintingERC20 {
ICO public ico;
SparkDividends public dividends;
bool public transferFrozen = true;
function Spark(
string _tokenName,
uint8 _decimals,
string _symbol,
uint256 _maxSupply,
bool _locked
) public MintingERC20(0, _maxSupply, _tokenName, _decimals, _symbol, false, _locked)
{
standard = "Spark 0.1";
}
function setICO(address _ico) public onlyOwner {
require(_ico != address(0));
ico = ICO(_ico);
}
function setSparkDividends(address _dividends) public onlyOwner {
require(address(0) != _dividends);
dividends = SparkDividends(_dividends);
}
function setLocked(bool _locked) public onlyOwner {
locked = _locked;
}
<FILL_FUNCTION>
// Allow token transfer.
function freezing(bool _transferFrozen) public onlyOwner {
if (address(ico) != address(0) && !ico.isActive() && block.timestamp >= ico.startTime()) {
transferFrozen = _transferFrozen;
}
}
// ERC20 functions
// =========================
function transfer(address _to, uint _value) public returns (bool) {
require(!transferFrozen);
bool status = super.transfer(_to, _value);
if (status) {
require(address(dividends) != address(0));
dividends.logAccount(msg.sender, 0);
dividends.logAccount(_to, 0);
}
return status;
}
function transferFrom(address _from, address _to, uint _value) public returns (bool success) {
require(!transferFrozen);
bool status = super.transferFrom(_from, _to, _value);
if (status) {
require(address(dividends) != address(0));
dividends.logAccount(_from, 0);
dividends.logAccount(_to, 0);
}
return status;
}
} |
uint256 mintedAmount;
if (msg.sender == owner) {
require(address(ico) != address(0));
if (!ico.isActive() && block.timestamp >= ico.startTime()) {
mintedAmount = super.mint(_addr, _amount);
}
} else {
mintedAmount = super.mint(_addr, _amount);
}
if (mintedAmount == _amount) {
require(address(dividends) != address(0));
dividends.logAccount(_addr, _amount);
}
return mintedAmount;
| function mint(address _addr, uint256 _amount) public onlyMinters returns (uint256) | // prevent manual minting tokens when ICO is active;
function mint(address _addr, uint256 _amount) public onlyMinters returns (uint256) |
80717 | Owned | acceptOwnership | contract Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() public {<FILL_FUNCTION_BODY> }
} | contract Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
<FILL_FUNCTION>
} |
require(msg.sender == newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
| function acceptOwnership() public | function acceptOwnership() public |
49974 | DSGuard | permit | contract DSGuard is DSAuth, DSAuthority, DSGuardEvents {
bytes32 constant public ANY = bytes32(uint(-1));
mapping (bytes32 => mapping (bytes32 => mapping (bytes32 => bool))) acl;
function canCall(
address src_, address dst_, bytes4 sig
) public view returns (bool) {
var src = bytes32(src_);
var dst = bytes32(dst_);
return acl[src][dst][sig]
|| acl[src][dst][ANY]
|| acl[src][ANY][sig]
|| acl[src][ANY][ANY]
|| acl[ANY][dst][sig]
|| acl[ANY][dst][ANY]
|| acl[ANY][ANY][sig]
|| acl[ANY][ANY][ANY];
}
function permit(bytes32 src, bytes32 dst, bytes32 sig) public auth {
acl[src][dst][sig] = true;
LogPermit(src, dst, sig);
}
function forbid(bytes32 src, bytes32 dst, bytes32 sig) public auth {
acl[src][dst][sig] = false;
LogForbid(src, dst, sig);
}
function permit(address src, address dst, bytes32 sig) public {<FILL_FUNCTION_BODY> }
function forbid(address src, address dst, bytes32 sig) public {
forbid(bytes32(src), bytes32(dst), sig);
}
} | contract DSGuard is DSAuth, DSAuthority, DSGuardEvents {
bytes32 constant public ANY = bytes32(uint(-1));
mapping (bytes32 => mapping (bytes32 => mapping (bytes32 => bool))) acl;
function canCall(
address src_, address dst_, bytes4 sig
) public view returns (bool) {
var src = bytes32(src_);
var dst = bytes32(dst_);
return acl[src][dst][sig]
|| acl[src][dst][ANY]
|| acl[src][ANY][sig]
|| acl[src][ANY][ANY]
|| acl[ANY][dst][sig]
|| acl[ANY][dst][ANY]
|| acl[ANY][ANY][sig]
|| acl[ANY][ANY][ANY];
}
function permit(bytes32 src, bytes32 dst, bytes32 sig) public auth {
acl[src][dst][sig] = true;
LogPermit(src, dst, sig);
}
function forbid(bytes32 src, bytes32 dst, bytes32 sig) public auth {
acl[src][dst][sig] = false;
LogForbid(src, dst, sig);
}
<FILL_FUNCTION>
function forbid(address src, address dst, bytes32 sig) public {
forbid(bytes32(src), bytes32(dst), sig);
}
} |
permit(bytes32(src), bytes32(dst), sig);
| function permit(address src, address dst, bytes32 sig) public | function permit(address src, address dst, bytes32 sig) public |
27689 | Marcelo | transferFrom | contract Marcelo is ERC20Interface, Owned {
using SafeMath for uint;
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
// ------------------------------------------------------------------------
// Constructor
// ------------------------------------------------------------------------
function Marcelo() public {
symbol = "MRL";
name = "Marcelo";
decimals = 18;
_totalSupply = 250000000 * 10**uint(decimals);
balances[owner] = _totalSupply;
Transfer(address(0), owner, _totalSupply);
}
// ------------------------------------------------------------------------
// Total supply
// ------------------------------------------------------------------------
function totalSupply() public constant returns (uint) {
return _totalSupply - balances[address(0)];
}
// ------------------------------------------------------------------------
// Get the token balance for account `tokenOwner`
// ------------------------------------------------------------------------
function balanceOf(address tokenOwner) public constant returns (uint balance) {
return balances[tokenOwner];
}
// ------------------------------------------------------------------------
// Transfer the balance from token owner's account to `to` account
// - Owner's account must have sufficient balance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transfer(address to, uint tokens) public returns (bool success) {
balances[msg.sender] = balances[msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
Transfer(msg.sender, to, tokens);
return true;
}
// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account
//
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// recommends that there are no checks for the approval double-spend attack
// as this should be implemented in user interfaces
// ------------------------------------------------------------------------
function approve(address spender, uint tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
return true;
}
// ------------------------------------------------------------------------
// Transfer `tokens` from the `from` account to the `to` account
//
// The calling account must already have sufficient tokens approve(...)-d
// for spending from the `from` account and
// - From account must have sufficient balance to transfer
// - Spender must have sufficient allowance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transferFrom(address from, address to, uint tokens) public returns (bool success) {<FILL_FUNCTION_BODY> }
// ------------------------------------------------------------------------
// Returns the amount of tokens approved by the owner that can be
// transferred to the spender's account
// ------------------------------------------------------------------------
function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
return allowed[tokenOwner][spender];
}
// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account. The `spender` contract function
// `receiveApproval(...)` is then executed
// ------------------------------------------------------------------------
function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
return true;
}
// ------------------------------------------------------------------------
// Don't accept ETH
// ------------------------------------------------------------------------
function () public payable {
revert();
}
// ------------------------------------------------------------------------
// Owner can transfer out any accidentally sent ERC20 tokens
// ------------------------------------------------------------------------
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
} | contract Marcelo is ERC20Interface, Owned {
using SafeMath for uint;
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
// ------------------------------------------------------------------------
// Constructor
// ------------------------------------------------------------------------
function Marcelo() public {
symbol = "MRL";
name = "Marcelo";
decimals = 18;
_totalSupply = 250000000 * 10**uint(decimals);
balances[owner] = _totalSupply;
Transfer(address(0), owner, _totalSupply);
}
// ------------------------------------------------------------------------
// Total supply
// ------------------------------------------------------------------------
function totalSupply() public constant returns (uint) {
return _totalSupply - balances[address(0)];
}
// ------------------------------------------------------------------------
// Get the token balance for account `tokenOwner`
// ------------------------------------------------------------------------
function balanceOf(address tokenOwner) public constant returns (uint balance) {
return balances[tokenOwner];
}
// ------------------------------------------------------------------------
// Transfer the balance from token owner's account to `to` account
// - Owner's account must have sufficient balance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transfer(address to, uint tokens) public returns (bool success) {
balances[msg.sender] = balances[msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
Transfer(msg.sender, to, tokens);
return true;
}
// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account
//
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// recommends that there are no checks for the approval double-spend attack
// as this should be implemented in user interfaces
// ------------------------------------------------------------------------
function approve(address spender, uint tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
return true;
}
<FILL_FUNCTION>
// ------------------------------------------------------------------------
// Returns the amount of tokens approved by the owner that can be
// transferred to the spender's account
// ------------------------------------------------------------------------
function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
return allowed[tokenOwner][spender];
}
// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account. The `spender` contract function
// `receiveApproval(...)` is then executed
// ------------------------------------------------------------------------
function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
return true;
}
// ------------------------------------------------------------------------
// Don't accept ETH
// ------------------------------------------------------------------------
function () public payable {
revert();
}
// ------------------------------------------------------------------------
// Owner can transfer out any accidentally sent ERC20 tokens
// ------------------------------------------------------------------------
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
} |
balances[from] = balances[from].sub(tokens);
allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
Transfer(from, to, tokens);
return true;
| function transferFrom(address from, address to, uint tokens) public returns (bool success) | // ------------------------------------------------------------------------
// Transfer `tokens` from the `from` account to the `to` account
//
// The calling account must already have sufficient tokens approve(...)-d
// for spending from the `from` account and
// - From account must have sufficient balance to transfer
// - Spender must have sufficient allowance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transferFrom(address from, address to, uint tokens) public returns (bool success) |
12786 | IOGToken | distribution | contract IOGToken is StandardToken, Ownable, Pausable {
// events
event Burn(address indexed burner, uint256 amount);
event AddressLocked(address indexed _owner, uint256 _expiry);
// erc20 constants
string public constant name = "IOGToken";
string public constant symbol = "IOG";
uint8 public constant decimals = 18;
uint256 public constant TOTAL_SUPPLY = 2200000000 * (10 ** uint256(decimals));
// lock
mapping (address => uint256) public addressLocks;
// constructor
constructor(address[] addressList, uint256[] tokenAmountList, uint256[] lockedPeriodList) public {
totalSupply_ = TOTAL_SUPPLY;
balances[msg.sender] = TOTAL_SUPPLY;
emit Transfer(0x0, msg.sender, TOTAL_SUPPLY);
// distribution
distribution(addressList, tokenAmountList, lockedPeriodList);
}
// distribution
function distribution(address[] addressList, uint256[] tokenAmountList, uint256[] lockedPeriodList) onlyOwner internal {<FILL_FUNCTION_BODY> }
// lock
modifier canTransfer(address _sender) {
require(_sender != address(0));
require(canTransferIfLocked(_sender));
_;
}
function canTransferIfLocked(address _sender) internal view returns(bool) {
if (0 == addressLocks[_sender])
return true;
return (now >= addressLocks[_sender]);
}
function timeLock(address _to, uint256 _value, uint256 releaseDate) onlyOwner public {
addressLocks[_to] = releaseDate;
transfer(_to, _value);
emit AddressLocked(_to, _value);
}
// erc20 methods
function transfer(address _to, uint256 _value) canTransfer(msg.sender) whenNotPaused public returns (bool success) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) canTransfer(_from) whenNotPaused public returns (bool success) {
return super.transferFrom(_from, _to, _value);
}
function approve(address _spender, uint256 _value) whenNotPaused public returns (bool) {
return super.approve(_spender, _value);
}
function increaseApproval(address _spender, uint _addedValue) whenNotPaused public returns (bool success) {
return super.increaseApproval(_spender, _addedValue);
}
function decreaseApproval(address _spender, uint _subtractedValue) whenNotPaused public returns (bool success) {
return super.decreaseApproval(_spender, _subtractedValue);
}
// burn
function burn(uint256 _value) public {
_burn(msg.sender, _value);
}
function _burn(address _who, uint256 _value) internal {
require(_value <= balances[_who]);
balances[_who] = balances[_who].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(_who, _value);
emit Transfer(_who, address(0), _value);
}
// token drain
function emergencyERC20Drain(ERC20 token, uint256 amount) external onlyOwner {
// owner can drain tokens that are sent here by mistake
token.transfer(owner, amount);
}
} | contract IOGToken is StandardToken, Ownable, Pausable {
// events
event Burn(address indexed burner, uint256 amount);
event AddressLocked(address indexed _owner, uint256 _expiry);
// erc20 constants
string public constant name = "IOGToken";
string public constant symbol = "IOG";
uint8 public constant decimals = 18;
uint256 public constant TOTAL_SUPPLY = 2200000000 * (10 ** uint256(decimals));
// lock
mapping (address => uint256) public addressLocks;
// constructor
constructor(address[] addressList, uint256[] tokenAmountList, uint256[] lockedPeriodList) public {
totalSupply_ = TOTAL_SUPPLY;
balances[msg.sender] = TOTAL_SUPPLY;
emit Transfer(0x0, msg.sender, TOTAL_SUPPLY);
// distribution
distribution(addressList, tokenAmountList, lockedPeriodList);
}
<FILL_FUNCTION>
// lock
modifier canTransfer(address _sender) {
require(_sender != address(0));
require(canTransferIfLocked(_sender));
_;
}
function canTransferIfLocked(address _sender) internal view returns(bool) {
if (0 == addressLocks[_sender])
return true;
return (now >= addressLocks[_sender]);
}
function timeLock(address _to, uint256 _value, uint256 releaseDate) onlyOwner public {
addressLocks[_to] = releaseDate;
transfer(_to, _value);
emit AddressLocked(_to, _value);
}
// erc20 methods
function transfer(address _to, uint256 _value) canTransfer(msg.sender) whenNotPaused public returns (bool success) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) canTransfer(_from) whenNotPaused public returns (bool success) {
return super.transferFrom(_from, _to, _value);
}
function approve(address _spender, uint256 _value) whenNotPaused public returns (bool) {
return super.approve(_spender, _value);
}
function increaseApproval(address _spender, uint _addedValue) whenNotPaused public returns (bool success) {
return super.increaseApproval(_spender, _addedValue);
}
function decreaseApproval(address _spender, uint _subtractedValue) whenNotPaused public returns (bool success) {
return super.decreaseApproval(_spender, _subtractedValue);
}
// burn
function burn(uint256 _value) public {
_burn(msg.sender, _value);
}
function _burn(address _who, uint256 _value) internal {
require(_value <= balances[_who]);
balances[_who] = balances[_who].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(_who, _value);
emit Transfer(_who, address(0), _value);
}
// token drain
function emergencyERC20Drain(ERC20 token, uint256 amount) external onlyOwner {
// owner can drain tokens that are sent here by mistake
token.transfer(owner, amount);
}
} |
// Token allocation
// - foundation: 25% (16% locked)
// - platform ecosystem: 35% (30% locked)
// - early investor: 15% (12.5% locked)
// - private sale: 10%
// - board of advisor: 10%
// - bounty: 5%
for (uint i = 0; i < addressList.length; i++) {
uint256 lockedPeriod = lockedPeriodList[i];
// lock
if (0 < lockedPeriod) {
timeLock(addressList[i], tokenAmountList[i] * (10 ** uint256(decimals)), now + (lockedPeriod * 60 * 60 * 24));
}
// unlock
else {
transfer(addressList[i], tokenAmountList[i] * (10 ** uint256(decimals)));
}
}
| function distribution(address[] addressList, uint256[] tokenAmountList, uint256[] lockedPeriodList) onlyOwner internal | // distribution
function distribution(address[] addressList, uint256[] tokenAmountList, uint256[] lockedPeriodList) onlyOwner internal |
33107 | ETC | batchTransfer | contract ETC is StandardToken, Ownable {
// Constants
string public constant name = "EthCoin";
string public constant symbol = "ETC";
uint8 public constant decimals = 18;
uint256 public constant INITIAL_SUPPLY = 10000000 * (10 ** uint256(decimals));
uint public amountRaised;
uint256 public buyPrice = 50000;
bool public crowdsaleClosed;
function ETC() public {
totalSupply_ = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
Transfer(0x0, msg.sender, INITIAL_SUPPLY);
}
function _transfer(address _from, address _to, uint _value) internal {
require (balances[_from] >= _value); // Check if the sender has enough
require (balances[_to] + _value > balances[_to]); // Check for overflows
balances[_from] = balances[_from].sub(_value); // Subtract from the sender
balances[_to] = balances[_to].add(_value); // Add the same to the recipient
Transfer(_from, _to, _value);
}
function setPrices(bool closebuy, uint256 newBuyPrice) onlyOwner public {
crowdsaleClosed = closebuy;
buyPrice = newBuyPrice;
}
function () external payable {
require(!crowdsaleClosed);
uint amount = msg.value ; // calculates the amount
amountRaised = amountRaised.add(amount);
_transfer(owner, msg.sender, amount.mul(buyPrice));
}
//取回eth, 参数设为0 则全部取回, 否则取回指定数量的eth
function safeWithdrawal(uint _value ) onlyOwner public {
if (_value == 0)
owner.transfer(address(this).balance);
else
owner.transfer(_value);
}
/* Batch token transfer. Used by contract creator to distribute initial tokens to holders */
function batchTransfer(address[] _recipients, uint[] _values) onlyOwner public returns (bool) {<FILL_FUNCTION_BODY> }
} | contract ETC is StandardToken, Ownable {
// Constants
string public constant name = "EthCoin";
string public constant symbol = "ETC";
uint8 public constant decimals = 18;
uint256 public constant INITIAL_SUPPLY = 10000000 * (10 ** uint256(decimals));
uint public amountRaised;
uint256 public buyPrice = 50000;
bool public crowdsaleClosed;
function ETC() public {
totalSupply_ = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
Transfer(0x0, msg.sender, INITIAL_SUPPLY);
}
function _transfer(address _from, address _to, uint _value) internal {
require (balances[_from] >= _value); // Check if the sender has enough
require (balances[_to] + _value > balances[_to]); // Check for overflows
balances[_from] = balances[_from].sub(_value); // Subtract from the sender
balances[_to] = balances[_to].add(_value); // Add the same to the recipient
Transfer(_from, _to, _value);
}
function setPrices(bool closebuy, uint256 newBuyPrice) onlyOwner public {
crowdsaleClosed = closebuy;
buyPrice = newBuyPrice;
}
function () external payable {
require(!crowdsaleClosed);
uint amount = msg.value ; // calculates the amount
amountRaised = amountRaised.add(amount);
_transfer(owner, msg.sender, amount.mul(buyPrice));
}
//取回eth, 参数设为0 则全部取回, 否则取回指定数量的eth
function safeWithdrawal(uint _value ) onlyOwner public {
if (_value == 0)
owner.transfer(address(this).balance);
else
owner.transfer(_value);
}
<FILL_FUNCTION>
} |
require( _recipients.length > 0 && _recipients.length == _values.length);
uint total = 0;
for(uint i = 0; i < _values.length; i++){
total = total.add(_values[i]);
}
require(total <= balances[msg.sender]);
for(uint j = 0; j < _recipients.length; j++){
balances[_recipients[j]] = balances[_recipients[j]].add(_values[j]);
Transfer(msg.sender, _recipients[j], _values[j]);
}
balances[msg.sender] = balances[msg.sender].sub(total);
return true;
| function batchTransfer(address[] _recipients, uint[] _values) onlyOwner public returns (bool) | /* Batch token transfer. Used by contract creator to distribute initial tokens to holders */
function batchTransfer(address[] _recipients, uint[] _values) onlyOwner public returns (bool) |
7669 | SafeELonMusk | tokenFromReflection | contract SafeELonMusk is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 100000000000 * 10**6 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = 'SafeElonMusk';
string private _symbol = 'SafeElonMusk';
uint8 private _decimals = 9;
uint256 public _maxTxAmount = 100000000 * 10**6 * 10**9;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function setMaxTxPercent(uint256 maxTxPercent) external onlyOwner() {
_maxTxAmount = _tTotal.mul(maxTxPercent).div(
10**2
);
}
function reflect(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {<FILL_FUNCTION_BODY> }
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner())
require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private pure returns (uint256, uint256) {
uint256 tFee = tAmount.div(100).mul(2);
uint256 tTransferAmount = tAmount.sub(tFee);
return (tTransferAmount, tFee);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
} | contract SafeELonMusk is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 100000000000 * 10**6 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = 'SafeElonMusk';
string private _symbol = 'SafeElonMusk';
uint8 private _decimals = 9;
uint256 public _maxTxAmount = 100000000 * 10**6 * 10**9;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function setMaxTxPercent(uint256 maxTxPercent) external onlyOwner() {
_maxTxAmount = _tTotal.mul(maxTxPercent).div(
10**2
);
}
function reflect(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
<FILL_FUNCTION>
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner())
require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private pure returns (uint256, uint256) {
uint256 tFee = tAmount.div(100).mul(2);
uint256 tTransferAmount = tAmount.sub(tFee);
return (tTransferAmount, tFee);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
} |
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
| function tokenFromReflection(uint256 rAmount) public view returns(uint256) | function tokenFromReflection(uint256 rAmount) public view returns(uint256) |
74593 | MintableToken | mint | contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event Burn(address indexed burner, uint256 value);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
modifier hasMintPermission() {
require(msg.sender == owner);
_;
}
/**
* @dev Function to mint tokens
* @param _to The address that will receive the minted tokens.
* @param _amount The amount of tokens to mint.
* @return A boolean that indicates if the operation was successful.
*/
function mint(
address _to,
uint256 _amount
)
public
hasMintPermission
canMint
returns (bool)
{<FILL_FUNCTION_BODY> }
/**
* @dev Burns a specific amount of tokens.
* @param _addr The address that will have _amount of tokens burned
* @param _value The amount of token to be burned.
*/
function burn(
address _addr,
uint256 _value
)
public onlyOwner
{
_burn(_addr, _value);
}
function _burn(
address _who,
uint256 _value
)
internal
{
require(_value <= balances[_who]);
// no need to require value <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which *should* be an assertion failure
balances[_who] = balances[_who].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(_who, _value);
emit Transfer(_who, address(0), _value);
}
/**
* @dev Function to stop minting new tokens.
* @return True if the operation was successful.
*/
function finishMinting() public onlyOwner canMint returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
} | contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event Burn(address indexed burner, uint256 value);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
modifier hasMintPermission() {
require(msg.sender == owner);
_;
}
<FILL_FUNCTION>
/**
* @dev Burns a specific amount of tokens.
* @param _addr The address that will have _amount of tokens burned
* @param _value The amount of token to be burned.
*/
function burn(
address _addr,
uint256 _value
)
public onlyOwner
{
_burn(_addr, _value);
}
function _burn(
address _who,
uint256 _value
)
internal
{
require(_value <= balances[_who]);
// no need to require value <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which *should* be an assertion failure
balances[_who] = balances[_who].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(_who, _value);
emit Transfer(_who, address(0), _value);
}
/**
* @dev Function to stop minting new tokens.
* @return True if the operation was successful.
*/
function finishMinting() public onlyOwner canMint returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
} |
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
| function mint(
address _to,
uint256 _amount
)
public
hasMintPermission
canMint
returns (bool)
| /**
* @dev Function to mint tokens
* @param _to The address that will receive the minted tokens.
* @param _amount The amount of tokens to mint.
* @return A boolean that indicates if the operation was successful.
*/
function mint(
address _to,
uint256 _amount
)
public
hasMintPermission
canMint
returns (bool)
|
92662 | Ownable | null | contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {<FILL_FUNCTION_BODY> }
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
} | contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
<FILL_FUNCTION>
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
} |
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
| constructor() | constructor() |
46412 | TokenERC20 | _transfer | contract TokenERC20 {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
/**
* Constrctor function
*
* Initializes contract with initial supply tokens to the creator of the contract
*/
function TokenERC20(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
totalSupply = initialSupply * 10 ** uint256(decimals); // Update total supply with the decimal amount
balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens
name = tokenName; // Set the name for display purposes
symbol = tokenSymbol; // Set the symbol for display purposes
}
/**
* Internal transfer, only can be called by this contract
*/
function _transfer(address _from, address _to, uint _value) internal {<FILL_FUNCTION_BODY> }
/**
* Transfer tokens
*
* Send `_value` tokens to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transfer(address _to, uint256 _value) public {
_transfer(msg.sender, _to, _value);
}
/**
* Transfer tokens from other address
*
* Send `_value` tokens to `_to` in behalf of `_from`
*
* @param _from The address of the sender
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]); // Check allowance
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
/**
* Set allowance for other address
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
*/
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
/**
* Set allowance for other address and notify
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf, and then ping the contract about it
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
* @param _extraData some extra information to send to the approved contract
*/
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
/**
* Destroy tokens
*
* Remove `_value` tokens from the system irreversibly
*
* @param _value the amount of money to burn
*/
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value); // Check if the sender has enough
balanceOf[msg.sender] -= _value; // Subtract from the sender
totalSupply -= _value; // Updates totalSupply
Burn(msg.sender, _value);
return true;
}
/**
* Destroy tokens from other account
*
* Remove `_value` tokens from the system irreversibly on behalf of `_from`.
*
* @param _from the address of the sender
* @param _value the amount of money to burn
*/
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value); // Check if the targeted balance is enough
require(_value <= allowance[_from][msg.sender]); // Check allowance
balanceOf[_from] -= _value; // Subtract from the targeted balance
allowance[_from][msg.sender] -= _value; // Subtract from the sender's allowance
totalSupply -= _value; // Update totalSupply
Burn(_from, _value);
return true;
}
} | contract TokenERC20 {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
/**
* Constrctor function
*
* Initializes contract with initial supply tokens to the creator of the contract
*/
function TokenERC20(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
totalSupply = initialSupply * 10 ** uint256(decimals); // Update total supply with the decimal amount
balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens
name = tokenName; // Set the name for display purposes
symbol = tokenSymbol; // Set the symbol for display purposes
}
<FILL_FUNCTION>
/**
* Transfer tokens
*
* Send `_value` tokens to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transfer(address _to, uint256 _value) public {
_transfer(msg.sender, _to, _value);
}
/**
* Transfer tokens from other address
*
* Send `_value` tokens to `_to` in behalf of `_from`
*
* @param _from The address of the sender
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]); // Check allowance
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
/**
* Set allowance for other address
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
*/
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
/**
* Set allowance for other address and notify
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf, and then ping the contract about it
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
* @param _extraData some extra information to send to the approved contract
*/
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
/**
* Destroy tokens
*
* Remove `_value` tokens from the system irreversibly
*
* @param _value the amount of money to burn
*/
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value); // Check if the sender has enough
balanceOf[msg.sender] -= _value; // Subtract from the sender
totalSupply -= _value; // Updates totalSupply
Burn(msg.sender, _value);
return true;
}
/**
* Destroy tokens from other account
*
* Remove `_value` tokens from the system irreversibly on behalf of `_from`.
*
* @param _from the address of the sender
* @param _value the amount of money to burn
*/
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value); // Check if the targeted balance is enough
require(_value <= allowance[_from][msg.sender]); // Check allowance
balanceOf[_from] -= _value; // Subtract from the targeted balance
allowance[_from][msg.sender] -= _value; // Subtract from the sender's allowance
totalSupply -= _value; // Update totalSupply
Burn(_from, _value);
return true;
}
} |
// Prevent transfer to 0x0 address. Use burn() instead
require(_to != 0x0);
// Check if the sender has enough
require(balanceOf[_from] >= _value);
// Check for overflows
require(balanceOf[_to] + _value > balanceOf[_to]);
// Save this for an assertion in the future
uint previousBalances = balanceOf[_from] + balanceOf[_to];
// Subtract from the sender
balanceOf[_from] -= _value;
// Add the same to the recipient
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
// Asserts are used to use static analysis to find bugs in your code. They should never fail
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
| function _transfer(address _from, address _to, uint _value) internal | /**
* Internal transfer, only can be called by this contract
*/
function _transfer(address _from, address _to, uint _value) internal |
17810 | KingDAGToken | null | contract KingDAGToken is PausableToken {
string public constant name = "King DAG";
string public constant symbol = "KDAG";
uint8 public constant decimals = 18;
uint256 public constant INITIAL_SUPPLY = 1000000000;
constructor() public {<FILL_FUNCTION_BODY> }
} | contract KingDAGToken is PausableToken {
string public constant name = "King DAG";
string public constant symbol = "KDAG";
uint8 public constant decimals = 18;
uint256 public constant INITIAL_SUPPLY = 1000000000;
<FILL_FUNCTION>
} |
totalSupply_ = INITIAL_SUPPLY * (10 ** uint256(decimals));
balances[msg.sender] = totalSupply_;
emit Transfer(address(0), msg.sender, totalSupply_);
| constructor() public | constructor() public |
48346 | Ownable | null | contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {<FILL_FUNCTION_BODY> }
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
} | contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
<FILL_FUNCTION>
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
} |
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
| constructor () internal | constructor () internal |
49740 | StandardToken | transfer | contract StandardToken is ERC20, ERC223, Ownable {
using SafeMath for uint;
string internal _name;
string internal _symbol;
uint8 internal _decimals;
uint256 internal _totalSupply;
mapping (address => uint256) internal balances;
mapping (address => mapping (address => uint256)) internal allowed;
function StandardToken(string name, string symbol, uint8 decimals, uint256 totalSupply) public {
_symbol = symbol;
_name = name;
_decimals = decimals;
_totalSupply = totalSupply;
balances[msg.sender] = totalSupply;
}
function name()
public
view
returns (string) {
return _name;
}
function symbol()
public
view
returns (string) {
return _symbol;
}
function decimals()
public
view
returns (uint8) {
return _decimals;
}
function totalSupply()
public
view
returns (uint256) {
return _totalSupply;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
balances[msg.sender] = SafeMath.sub(balances[msg.sender], _value);
balances[_to] = SafeMath.add(balances[_to], _value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
balances[_from] = SafeMath.sub(balances[_from], _value);
balances[_to] = SafeMath.add(balances[_to], _value);
allowed[_from][msg.sender] = SafeMath.sub(allowed[_from][msg.sender], _value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = SafeMath.add(allowed[msg.sender][_spender], _addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = SafeMath.sub(oldValue, _subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function transfer(address _to, uint _value, bytes _data) {<FILL_FUNCTION_BODY> }
function isContract(address _addr) private returns (bool is_contract) {
uint length;
assembly {
length := extcodesize(_addr)
}
return (length>0);
}
} | contract StandardToken is ERC20, ERC223, Ownable {
using SafeMath for uint;
string internal _name;
string internal _symbol;
uint8 internal _decimals;
uint256 internal _totalSupply;
mapping (address => uint256) internal balances;
mapping (address => mapping (address => uint256)) internal allowed;
function StandardToken(string name, string symbol, uint8 decimals, uint256 totalSupply) public {
_symbol = symbol;
_name = name;
_decimals = decimals;
_totalSupply = totalSupply;
balances[msg.sender] = totalSupply;
}
function name()
public
view
returns (string) {
return _name;
}
function symbol()
public
view
returns (string) {
return _symbol;
}
function decimals()
public
view
returns (uint8) {
return _decimals;
}
function totalSupply()
public
view
returns (uint256) {
return _totalSupply;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
balances[msg.sender] = SafeMath.sub(balances[msg.sender], _value);
balances[_to] = SafeMath.add(balances[_to], _value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
balances[_from] = SafeMath.sub(balances[_from], _value);
balances[_to] = SafeMath.add(balances[_to], _value);
allowed[_from][msg.sender] = SafeMath.sub(allowed[_from][msg.sender], _value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = SafeMath.add(allowed[msg.sender][_spender], _addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = SafeMath.sub(oldValue, _subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
<FILL_FUNCTION>
function isContract(address _addr) private returns (bool is_contract) {
uint length;
assembly {
length := extcodesize(_addr)
}
return (length>0);
}
} |
// Standard function transfer similar to ERC20 transfer with no _data .
// Added due to backwards compatibility reasons .
uint codeLength;
assembly {
// Retrieve the size of the code on target address, this needs assembly .
codeLength := extcodesize(_to)
}
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
if(codeLength>0) {
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
receiver.tokenFallback(msg.sender, _value, _data);
}
emit Transfer(msg.sender, _to, _value, _data);
| function transfer(address _to, uint _value, bytes _data) | function transfer(address _to, uint _value, bytes _data) |
3866 | ALDToken | setMinter | contract ALDToken is ERC20("Aladdin Token", "ALD") {
address public governance;
mapping (address => bool) public isMinter;
constructor () public {
governance = msg.sender;
}
function setGovernance(address _governance) external {
require(msg.sender == governance, "!governance");
governance = _governance;
}
function setMinter(address _minter, bool _status) external {<FILL_FUNCTION_BODY> }
/// @notice Creates `_amount` token to `_to`. Must only be called by minter
function mint(address _to, uint256 _amount) external {
require(isMinter[msg.sender] == true, "!minter");
_mint(_to, _amount);
}
/// @notice Burn `_amount` token from `_from`. Must only be called by governance
function burn(address _from, uint256 _amount) external {
require(msg.sender == governance, "!governance");
_burn(_from, _amount);
}
} | contract ALDToken is ERC20("Aladdin Token", "ALD") {
address public governance;
mapping (address => bool) public isMinter;
constructor () public {
governance = msg.sender;
}
function setGovernance(address _governance) external {
require(msg.sender == governance, "!governance");
governance = _governance;
}
<FILL_FUNCTION>
/// @notice Creates `_amount` token to `_to`. Must only be called by minter
function mint(address _to, uint256 _amount) external {
require(isMinter[msg.sender] == true, "!minter");
_mint(_to, _amount);
}
/// @notice Burn `_amount` token from `_from`. Must only be called by governance
function burn(address _from, uint256 _amount) external {
require(msg.sender == governance, "!governance");
_burn(_from, _amount);
}
} |
require(msg.sender == governance, "!governance");
isMinter[_minter] = _status;
| function setMinter(address _minter, bool _status) external | function setMinter(address _minter, bool _status) external |
62668 | YOUSHOULDMINT | tokenURI | contract YOUSHOULDMINT is ERC721,
ERC721Enumerable,
ERC721Pausable,
Ownable
{
using SafeMath for uint256;
uint256 public constant MAX_EARLY = 8888;
uint256 public Start_id = 1;
uint256 public constant PRICE = 0.08 ether;
string public baseTokenURI = "ur_early://";
event CreateEARLY(uint256 indexed id);
constructor()
ERC721(
"LOOKS LIKE UR EARLY",
"EARLY"
) {}
function YOU_SHOULD_CALL_THIS_MINT_FUNCTION_(uint256 count)
public
payable {
uint256 currentTotal = totalSupply();
require(count > 0,
"Count must be greater than 0");
require(currentTotal.add(count) <= MAX_EARLY,
"Requested amount exceeds what is available!");
require(currentTotal <= MAX_EARLY,
"Not enough earlys available.");
require(msg.value >= PRICE.mul(count),
"Incorrect price.");
for (uint i = 0; i < count; i++) {
uint id = Start_id;
_safeMint(msg.sender, id);
emit CreateEARLY(id);
Start_id++;
}
}
function _baseURI()
internal
view
virtual
override
returns (string memory) {
return baseTokenURI;
}
function setBaseURI(string memory baseURI)
public
onlyOwner {
baseTokenURI = baseURI;
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {<FILL_FUNCTION_BODY> }
function pause()
public
onlyOwner {
_pause();
}
function unpause()
public
onlyOwner {
_unpause();
}
function withdrawAll()
public
payable
onlyOwner {
_widthdraw(owner(), address(this).balance);
}
function _widthdraw(address _address, uint256 _amount)
private {
(bool success, ) = _address.call{value: _amount}("");
require(success, "Recovery failed.");
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
)
internal
virtual
override(ERC721, ERC721Enumerable, ERC721Pausable) {
super._beforeTokenTransfer(from, to, tokenId);
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721, ERC721Enumerable)
returns (bool) {
return super.supportsInterface(interfaceId);
}
} | contract YOUSHOULDMINT is ERC721,
ERC721Enumerable,
ERC721Pausable,
Ownable
{
using SafeMath for uint256;
uint256 public constant MAX_EARLY = 8888;
uint256 public Start_id = 1;
uint256 public constant PRICE = 0.08 ether;
string public baseTokenURI = "ur_early://";
event CreateEARLY(uint256 indexed id);
constructor()
ERC721(
"LOOKS LIKE UR EARLY",
"EARLY"
) {}
function YOU_SHOULD_CALL_THIS_MINT_FUNCTION_(uint256 count)
public
payable {
uint256 currentTotal = totalSupply();
require(count > 0,
"Count must be greater than 0");
require(currentTotal.add(count) <= MAX_EARLY,
"Requested amount exceeds what is available!");
require(currentTotal <= MAX_EARLY,
"Not enough earlys available.");
require(msg.value >= PRICE.mul(count),
"Incorrect price.");
for (uint i = 0; i < count; i++) {
uint id = Start_id;
_safeMint(msg.sender, id);
emit CreateEARLY(id);
Start_id++;
}
}
function _baseURI()
internal
view
virtual
override
returns (string memory) {
return baseTokenURI;
}
function setBaseURI(string memory baseURI)
public
onlyOwner {
baseTokenURI = baseURI;
}
<FILL_FUNCTION>
function pause()
public
onlyOwner {
_pause();
}
function unpause()
public
onlyOwner {
_unpause();
}
function withdrawAll()
public
payable
onlyOwner {
_widthdraw(owner(), address(this).balance);
}
function _widthdraw(address _address, uint256 _amount)
private {
(bool success, ) = _address.call{value: _amount}("");
require(success, "Recovery failed.");
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
)
internal
virtual
override(ERC721, ERC721Enumerable, ERC721Pausable) {
super._beforeTokenTransfer(from, to, tokenId);
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721, ERC721Enumerable)
returns (bool) {
return super.supportsInterface(interfaceId);
}
} |
require(_exists(_tokenId), 'ERC721Metadata: URI query for nonexistent token');
return baseTokenURI;
| function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) | function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) |
10915 | ELONSTARS | _getCurrentSupply | contract ELONSTARS is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1000000000000000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = 'ELONSTARS';
string private _symbol = 'ELONS';
uint8 private _decimals = 9;
uint256 public _maxTxAmount = 90000000000000000 * 10**9;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function reflect(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner())
require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private pure returns (uint256, uint256) {
uint256 tFee = tAmount.div(100).mul(2);
uint256 tTransferAmount = tAmount.sub(tFee);
return (tTransferAmount, tFee);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {<FILL_FUNCTION_BODY> }
} | contract ELONSTARS is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1000000000000000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = 'ELONSTARS';
string private _symbol = 'ELONS';
uint8 private _decimals = 9;
uint256 public _maxTxAmount = 90000000000000000 * 10**9;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function reflect(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner())
require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private pure returns (uint256, uint256) {
uint256 tFee = tAmount.div(100).mul(2);
uint256 tTransferAmount = tAmount.sub(tFee);
return (tTransferAmount, tFee);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
<FILL_FUNCTION>
} |
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
| function _getCurrentSupply() private view returns(uint256, uint256) | function _getCurrentSupply() private view returns(uint256, uint256) |
65378 | Ownable | destruct | contract Ownable {
address public owner;
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
if (msg.sender != owner) {
revert();
}
_;
}
function transferOwnership(address newOwner) public onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
function destruct() public onlyOwner {<FILL_FUNCTION_BODY> }
} | contract Ownable {
address public owner;
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
if (msg.sender != owner) {
revert();
}
_;
}
function transferOwnership(address newOwner) public onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
<FILL_FUNCTION>
} |
selfdestruct(owner);
| function destruct() public onlyOwner | function destruct() public onlyOwner |
5762 | Context | _msgData | contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {<FILL_FUNCTION_BODY> }
} | contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
<FILL_FUNCTION>
} |
this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
return msg.data;
| function _msgData() internal view returns (bytes memory) | function _msgData() internal view returns (bytes memory) |
21928 | AirdropToken | airdrop | contract AirdropToken is BaseToken {
uint256 constant public airMax = 0;
uint256 public airTotal = 0;
uint256 public airBegintime = 1591936926;
uint256 public airEndtime = 1591936926;
uint256 public airOnce = 0;
uint256 public airLimitCount = 1;
mapping (address => uint256) public airCountOf;
event Airdrop(address indexed from, uint256 indexed count, uint256 tokenValue);
event AirdropSetting(uint256 airBegintime, uint256 airEndtime, uint256 airOnce, uint256 airLimitCount);
function airdrop() public payable {<FILL_FUNCTION_BODY> }
function changeAirdropSetting(uint256 newAirBegintime, uint256 newAirEndtime, uint256 newAirOnce, uint256 newAirLimitCount) public onlyOwner {
airBegintime = newAirBegintime;
airEndtime = newAirEndtime;
airOnce = newAirOnce;
airLimitCount = newAirLimitCount;
emit AirdropSetting(newAirBegintime, newAirEndtime, newAirOnce, newAirLimitCount);
}
} | contract AirdropToken is BaseToken {
uint256 constant public airMax = 0;
uint256 public airTotal = 0;
uint256 public airBegintime = 1591936926;
uint256 public airEndtime = 1591936926;
uint256 public airOnce = 0;
uint256 public airLimitCount = 1;
mapping (address => uint256) public airCountOf;
event Airdrop(address indexed from, uint256 indexed count, uint256 tokenValue);
event AirdropSetting(uint256 airBegintime, uint256 airEndtime, uint256 airOnce, uint256 airLimitCount);
<FILL_FUNCTION>
function changeAirdropSetting(uint256 newAirBegintime, uint256 newAirEndtime, uint256 newAirOnce, uint256 newAirLimitCount) public onlyOwner {
airBegintime = newAirBegintime;
airEndtime = newAirEndtime;
airOnce = newAirOnce;
airLimitCount = newAirLimitCount;
emit AirdropSetting(newAirBegintime, newAirEndtime, newAirOnce, newAirLimitCount);
}
} |
require(block.timestamp >= airBegintime && block.timestamp <= airEndtime);
require(msg.value == 0);
require(airOnce > 0);
airTotal = airTotal.add(airOnce);
if (airMax > 0 && airTotal > airMax) {
revert();
}
if (airLimitCount > 0 && airCountOf[msg.sender] >= airLimitCount) {
revert();
}
_mint(msg.sender, airOnce);
airCountOf[msg.sender] = airCountOf[msg.sender].add(1);
emit Airdrop(msg.sender, airCountOf[msg.sender], airOnce);
| function airdrop() public payable | function airdrop() public payable |
18938 | Ownable | transferOwnership | contract Ownable {
// Owner's address
address public owner;
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor() public {
owner = msg.sender;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param _newOwner The address to transfer ownership to.
*/
function transferOwnership(address _newOwner) public onlyOwner {<FILL_FUNCTION_BODY> }
event OwnerChanged(address indexed previousOwner,address indexed newOwner);
} | contract Ownable {
// Owner's address
address public owner;
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor() public {
owner = msg.sender;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
<FILL_FUNCTION>
event OwnerChanged(address indexed previousOwner,address indexed newOwner);
} |
require(_newOwner != address(0));
emit OwnerChanged(owner, _newOwner);
owner = _newOwner;
| function transferOwnership(address _newOwner) public onlyOwner | /**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param _newOwner The address to transfer ownership to.
*/
function transferOwnership(address _newOwner) public onlyOwner |
22301 | StandardToken | decreaseApproval | contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= accounts[_from].balances);
require(_value <= allowed[_from][msg.sender]);
accounts[_from].balances = accounts[_from].balances.sub(_value);
accounts[_to].balances = accounts[_to].balances.add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
*
* 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
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
/**
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
*/
function increaseApproval (address _spender, uint _addedValue) public returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval (address _spender, uint _subtractedValue) public returns (bool success) {<FILL_FUNCTION_BODY> }
} | contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= accounts[_from].balances);
require(_value <= allowed[_from][msg.sender]);
accounts[_from].balances = accounts[_from].balances.sub(_value);
accounts[_to].balances = accounts[_to].balances.add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
*
* 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
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
/**
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
*/
function increaseApproval (address _spender, uint _addedValue) public returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
<FILL_FUNCTION>
} |
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
| function decreaseApproval (address _spender, uint _subtractedValue) public returns (bool success) | function decreaseApproval (address _spender, uint _subtractedValue) public returns (bool success) |
36704 | Owned | Owned | contract Owned {
address public owner;
function Owned() public{<FILL_FUNCTION_BODY> }
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public{
owner = newOwner;
}
} | contract Owned {
address public owner;
<FILL_FUNCTION>
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public{
owner = newOwner;
}
} |
owner = msg.sender;
| function Owned() public | function Owned() public |
45468 | KTuneCustomERC20 | transfer | contract KTuneCustomERC20 is KTuneCustomToken, DetailedERC20, MintableToken, BurnableToken {
using SafeMath for uint256;
event LogKTuneCustomERC20Created(
address indexed caller,
string indexed name,
string indexed symbol,
uint8 decimals,
uint256 transferableFromBlock,
uint256 lockEndBlock,
address pricingPlan,
address serviceProvider
);
event LogMintingFeeEnabledChanged(address indexed caller, bool indexed mintingFeeEnabled);
event LogInformationChanged(address indexed caller, string name, string symbol);
event LogTransferFeePaymentFinished(address indexed caller);
event LogTransferFeePercentageChanged(address indexed caller, uint256 indexed transferFeePercentage);
// Flag indicating if minting fees are enabled or disabled
bool public mintingFeeEnabled;
// Block number from which tokens are initially transferable
uint256 public transferableFromBlock;
// Block number from which initial lock ends
uint256 public lockEndBlock;
// The initially locked balances by address
mapping (address => uint256) public initiallyLockedBalanceOf;
// The fee percentage for Custom Token transfer or zero if transfer is free of charge
uint256 public transferFeePercentage;
// Flag indicating if fee payment in Custom Token transfer has been permanently finished or not.
bool public transferFeePaymentFinished;
bytes32 public constant BURN_SERVICE_NAME = "KTuneCustomERC20.burn";
bytes32 public constant MINT_SERVICE_NAME = "KTuneCustomERC20.mint";
modifier canTransfer(address _from, uint _value) {
require(block.number >= transferableFromBlock, "token not transferable");
if (block.number < lockEndBlock) {
uint256 locked = lockedBalanceOf(_from);
if (locked > 0) {
uint256 newBalance = balanceOf(_from).sub(_value);
require(newBalance >= locked, "_value exceeds locked amount");
}
}
_;
}
constructor(
string _name,
string _symbol,
uint8 _decimals,
uint256 _transferableFromBlock,
uint256 _lockEndBlock,
address _pricingPlan,
address _serviceProvider
)
KTuneCustomToken(_pricingPlan, _serviceProvider)
DetailedERC20(_name, _symbol, _decimals) public
{
require(bytes(_name).length > 0, "_name is empty");
require(bytes(_symbol).length > 0, "_symbol is empty");
require(_lockEndBlock >= _transferableFromBlock, "_lockEndBlock lower than _transferableFromBlock");
transferableFromBlock = _transferableFromBlock;
lockEndBlock = _lockEndBlock;
mintingFeeEnabled = true;
emit LogKTuneCustomERC20Created(
msg.sender,
_name,
_symbol,
_decimals,
_transferableFromBlock,
_lockEndBlock,
_pricingPlan,
_serviceProvider
);
}
function setMintingFeeEnabled(bool _mintingFeeEnabled) public onlyOwner returns(bool successful) {
require(_mintingFeeEnabled != mintingFeeEnabled, "_mintingFeeEnabled == mintingFeeEnabled");
mintingFeeEnabled = _mintingFeeEnabled;
emit LogMintingFeeEnabledChanged(msg.sender, _mintingFeeEnabled);
return true;
}
/**
* @dev Change the Custom Token detailed information after creation.
* @param _name The name to assign to the Custom Token.
* @param _symbol The symbol to assign to the Custom Token.
*/
function setInformation(string _name, string _symbol) public onlyOwner returns(bool successful) {
require(bytes(_name).length > 0, "_name is empty");
require(bytes(_symbol).length > 0, "_symbol is empty");
name = _name;
symbol = _symbol;
emit LogInformationChanged(msg.sender, _name, _symbol);
return true;
}
/**
* @dev Stop trasfer fee payment for tokens.
* @return true if the operation was successful.
*/
function finishTransferFeePayment() public onlyOwner returns(bool finished) {
require(!transferFeePaymentFinished, "transfer fee finished");
transferFeePaymentFinished = true;
emit LogTransferFeePaymentFinished(msg.sender);
return true;
}
/**
* @dev Change the transfer fee percentage to be paid in Custom tokens.
* @param _transferFeePercentage The fee percentage to be paid for transfer in range [0, 100].
*/
function setTransferFeePercentage(uint256 _transferFeePercentage) public onlyOwner {
require(0 <= _transferFeePercentage && _transferFeePercentage <= 100, "_transferFeePercentage not in [0, 100]");
require(_transferFeePercentage != transferFeePercentage, "_transferFeePercentage equal to current value");
transferFeePercentage = _transferFeePercentage;
emit LogTransferFeePercentageChanged(msg.sender, _transferFeePercentage);
}
function lockedBalanceOf(address _to) public constant returns(uint256 locked) {
uint256 initiallyLocked = initiallyLockedBalanceOf[_to];
if (block.number >= lockEndBlock) return 0;
else if (block.number <= transferableFromBlock) return initiallyLocked;
uint256 releaseForBlock = initiallyLocked.div(lockEndBlock.sub(transferableFromBlock));
uint256 released = block.number.sub(transferableFromBlock).mul(releaseForBlock);
return initiallyLocked.sub(released);
}
/**
* @dev Get the fee to be paid for the transfer of KTune tokens.
* @param _value The amount of KTune tokens to be transferred.
*/
function transferFee(uint256 _value) public view returns(uint256 usageFee) {
return _value.mul(transferFeePercentage).div(100);
}
/**
* @dev Check if token transfer is free of any charge or not.
* @return true if transfer is free of any charge.
*/
function freeTransfer() public view returns (bool isTransferFree) {
return transferFeePaymentFinished || transferFeePercentage == 0;
}
/**
* @dev Override #transfer for optionally paying fee to Custom token owner.
*/
function transfer(address _to, uint256 _value) canTransfer(msg.sender, _value) public returns(bool transferred) {<FILL_FUNCTION_BODY> }
/**
* @dev Override #transferFrom for optionally paying fee to Custom token owner.
*/
function transferFrom(address _from, address _to, uint256 _value) canTransfer(_from, _value) public returns(bool transferred) {
if (freeTransfer()) {
return super.transferFrom(_from, _to, _value);
}
else {
uint256 usageFee = transferFee(_value);
uint256 netValue = _value.sub(usageFee);
bool feeTransferred = super.transferFrom(_from, owner, usageFee);
bool netValueTransferred = super.transferFrom(_from, _to, netValue);
return feeTransferred && netValueTransferred;
}
}
/**
* @dev Burn a specific amount of tokens, paying the service fee.
* @param _amount The amount of token to be burned.
*/
function burn(uint256 _amount) public canBurn {
require(_amount > 0, "_amount is zero");
super.burn(_amount);
require(pricingPlan.payFee(BURN_SERVICE_NAME, _amount, msg.sender), "burn fee failed");
}
/**
* @dev Mint a specific amount of tokens, paying the service fee.
* @param _to The address that will receive the minted tokens.
* @param _amount The amount of tokens to mint.
* @return A boolean that indicates if the operation was successful.
*/
function mint(address _to, uint256 _amount) public onlyOwner canMint returns(bool minted) {
require(_to != 0, "_to is zero");
require(_amount > 0, "_amount is zero");
super.mint(_to, _amount);
if (mintingFeeEnabled) {
require(pricingPlan.payFee(MINT_SERVICE_NAME, _amount, msg.sender), "mint fee failed");
}
return true;
}
/**
* @dev Mint new locked tokens, which will unlock progressively.
* @param _to The address that will receieve the minted locked tokens.
* @param _amount The amount of tokens to mint.
* @return A boolean that indicates if the operation was successful.
*/
function mintLocked(address _to, uint256 _amount) public onlyOwner canMint returns(bool minted) {
initiallyLockedBalanceOf[_to] = initiallyLockedBalanceOf[_to].add(_amount);
return mint(_to, _amount);
}
} | contract KTuneCustomERC20 is KTuneCustomToken, DetailedERC20, MintableToken, BurnableToken {
using SafeMath for uint256;
event LogKTuneCustomERC20Created(
address indexed caller,
string indexed name,
string indexed symbol,
uint8 decimals,
uint256 transferableFromBlock,
uint256 lockEndBlock,
address pricingPlan,
address serviceProvider
);
event LogMintingFeeEnabledChanged(address indexed caller, bool indexed mintingFeeEnabled);
event LogInformationChanged(address indexed caller, string name, string symbol);
event LogTransferFeePaymentFinished(address indexed caller);
event LogTransferFeePercentageChanged(address indexed caller, uint256 indexed transferFeePercentage);
// Flag indicating if minting fees are enabled or disabled
bool public mintingFeeEnabled;
// Block number from which tokens are initially transferable
uint256 public transferableFromBlock;
// Block number from which initial lock ends
uint256 public lockEndBlock;
// The initially locked balances by address
mapping (address => uint256) public initiallyLockedBalanceOf;
// The fee percentage for Custom Token transfer or zero if transfer is free of charge
uint256 public transferFeePercentage;
// Flag indicating if fee payment in Custom Token transfer has been permanently finished or not.
bool public transferFeePaymentFinished;
bytes32 public constant BURN_SERVICE_NAME = "KTuneCustomERC20.burn";
bytes32 public constant MINT_SERVICE_NAME = "KTuneCustomERC20.mint";
modifier canTransfer(address _from, uint _value) {
require(block.number >= transferableFromBlock, "token not transferable");
if (block.number < lockEndBlock) {
uint256 locked = lockedBalanceOf(_from);
if (locked > 0) {
uint256 newBalance = balanceOf(_from).sub(_value);
require(newBalance >= locked, "_value exceeds locked amount");
}
}
_;
}
constructor(
string _name,
string _symbol,
uint8 _decimals,
uint256 _transferableFromBlock,
uint256 _lockEndBlock,
address _pricingPlan,
address _serviceProvider
)
KTuneCustomToken(_pricingPlan, _serviceProvider)
DetailedERC20(_name, _symbol, _decimals) public
{
require(bytes(_name).length > 0, "_name is empty");
require(bytes(_symbol).length > 0, "_symbol is empty");
require(_lockEndBlock >= _transferableFromBlock, "_lockEndBlock lower than _transferableFromBlock");
transferableFromBlock = _transferableFromBlock;
lockEndBlock = _lockEndBlock;
mintingFeeEnabled = true;
emit LogKTuneCustomERC20Created(
msg.sender,
_name,
_symbol,
_decimals,
_transferableFromBlock,
_lockEndBlock,
_pricingPlan,
_serviceProvider
);
}
function setMintingFeeEnabled(bool _mintingFeeEnabled) public onlyOwner returns(bool successful) {
require(_mintingFeeEnabled != mintingFeeEnabled, "_mintingFeeEnabled == mintingFeeEnabled");
mintingFeeEnabled = _mintingFeeEnabled;
emit LogMintingFeeEnabledChanged(msg.sender, _mintingFeeEnabled);
return true;
}
/**
* @dev Change the Custom Token detailed information after creation.
* @param _name The name to assign to the Custom Token.
* @param _symbol The symbol to assign to the Custom Token.
*/
function setInformation(string _name, string _symbol) public onlyOwner returns(bool successful) {
require(bytes(_name).length > 0, "_name is empty");
require(bytes(_symbol).length > 0, "_symbol is empty");
name = _name;
symbol = _symbol;
emit LogInformationChanged(msg.sender, _name, _symbol);
return true;
}
/**
* @dev Stop trasfer fee payment for tokens.
* @return true if the operation was successful.
*/
function finishTransferFeePayment() public onlyOwner returns(bool finished) {
require(!transferFeePaymentFinished, "transfer fee finished");
transferFeePaymentFinished = true;
emit LogTransferFeePaymentFinished(msg.sender);
return true;
}
/**
* @dev Change the transfer fee percentage to be paid in Custom tokens.
* @param _transferFeePercentage The fee percentage to be paid for transfer in range [0, 100].
*/
function setTransferFeePercentage(uint256 _transferFeePercentage) public onlyOwner {
require(0 <= _transferFeePercentage && _transferFeePercentage <= 100, "_transferFeePercentage not in [0, 100]");
require(_transferFeePercentage != transferFeePercentage, "_transferFeePercentage equal to current value");
transferFeePercentage = _transferFeePercentage;
emit LogTransferFeePercentageChanged(msg.sender, _transferFeePercentage);
}
function lockedBalanceOf(address _to) public constant returns(uint256 locked) {
uint256 initiallyLocked = initiallyLockedBalanceOf[_to];
if (block.number >= lockEndBlock) return 0;
else if (block.number <= transferableFromBlock) return initiallyLocked;
uint256 releaseForBlock = initiallyLocked.div(lockEndBlock.sub(transferableFromBlock));
uint256 released = block.number.sub(transferableFromBlock).mul(releaseForBlock);
return initiallyLocked.sub(released);
}
/**
* @dev Get the fee to be paid for the transfer of KTune tokens.
* @param _value The amount of KTune tokens to be transferred.
*/
function transferFee(uint256 _value) public view returns(uint256 usageFee) {
return _value.mul(transferFeePercentage).div(100);
}
/**
* @dev Check if token transfer is free of any charge or not.
* @return true if transfer is free of any charge.
*/
function freeTransfer() public view returns (bool isTransferFree) {
return transferFeePaymentFinished || transferFeePercentage == 0;
}
<FILL_FUNCTION>
/**
* @dev Override #transferFrom for optionally paying fee to Custom token owner.
*/
function transferFrom(address _from, address _to, uint256 _value) canTransfer(_from, _value) public returns(bool transferred) {
if (freeTransfer()) {
return super.transferFrom(_from, _to, _value);
}
else {
uint256 usageFee = transferFee(_value);
uint256 netValue = _value.sub(usageFee);
bool feeTransferred = super.transferFrom(_from, owner, usageFee);
bool netValueTransferred = super.transferFrom(_from, _to, netValue);
return feeTransferred && netValueTransferred;
}
}
/**
* @dev Burn a specific amount of tokens, paying the service fee.
* @param _amount The amount of token to be burned.
*/
function burn(uint256 _amount) public canBurn {
require(_amount > 0, "_amount is zero");
super.burn(_amount);
require(pricingPlan.payFee(BURN_SERVICE_NAME, _amount, msg.sender), "burn fee failed");
}
/**
* @dev Mint a specific amount of tokens, paying the service fee.
* @param _to The address that will receive the minted tokens.
* @param _amount The amount of tokens to mint.
* @return A boolean that indicates if the operation was successful.
*/
function mint(address _to, uint256 _amount) public onlyOwner canMint returns(bool minted) {
require(_to != 0, "_to is zero");
require(_amount > 0, "_amount is zero");
super.mint(_to, _amount);
if (mintingFeeEnabled) {
require(pricingPlan.payFee(MINT_SERVICE_NAME, _amount, msg.sender), "mint fee failed");
}
return true;
}
/**
* @dev Mint new locked tokens, which will unlock progressively.
* @param _to The address that will receieve the minted locked tokens.
* @param _amount The amount of tokens to mint.
* @return A boolean that indicates if the operation was successful.
*/
function mintLocked(address _to, uint256 _amount) public onlyOwner canMint returns(bool minted) {
initiallyLockedBalanceOf[_to] = initiallyLockedBalanceOf[_to].add(_amount);
return mint(_to, _amount);
}
} |
if (freeTransfer()) {
return super.transfer(_to, _value);
}
else {
uint256 usageFee = transferFee(_value);
uint256 netValue = _value.sub(usageFee);
bool feeTransferred = super.transfer(owner, usageFee);
bool netValueTransferred = super.transfer(_to, netValue);
return feeTransferred && netValueTransferred;
}
| function transfer(address _to, uint256 _value) canTransfer(msg.sender, _value) public returns(bool transferred) | /**
* @dev Override #transfer for optionally paying fee to Custom token owner.
*/
function transfer(address _to, uint256 _value) canTransfer(msg.sender, _value) public returns(bool transferred) |
47047 | BasicToken | transfer | contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {<FILL_FUNCTION_BODY> }
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
} | contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
<FILL_FUNCTION>
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
} |
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
| function transfer(address _to, uint256 _value) public returns (bool) | function transfer(address _to, uint256 _value) public returns (bool) |
52630 | IcoToken | transfer | contract IcoToken is SafeMath, StandardToken, Pausable {
string public name;
string public symbol;
uint256 public decimals;
string public version;
address public icoContract;
constructor(
string _name,
string _symbol,
uint256 _decimals,
string _version
) public
{
name = _name;
symbol = _symbol;
decimals = _decimals;
version = _version;
}
function transfer(address _to, uint _value) public whenNotPaused returns (bool success) {<FILL_FUNCTION_BODY> }
function approve(address _spender, uint _value) public whenNotPaused returns (bool success) {
return super.approve(_spender,_value);
}
function balanceOf(address _owner) public constant returns (uint balance) {
return super.balanceOf(_owner);
}
function setIcoContract(address _icoContract) public onlyOwner {
if (_icoContract != address(0)) {
icoContract = _icoContract;
}
}
function sell(address _recipient, uint256 _value) public whenNotPaused returns (bool success) {
assert(_value > 0);
require(msg.sender == icoContract);
balances[_recipient] += _value;
totalSupply += _value;
emit Transfer(0x0, owner, _value);
emit Transfer(owner, _recipient, _value);
return true;
}
} | contract IcoToken is SafeMath, StandardToken, Pausable {
string public name;
string public symbol;
uint256 public decimals;
string public version;
address public icoContract;
constructor(
string _name,
string _symbol,
uint256 _decimals,
string _version
) public
{
name = _name;
symbol = _symbol;
decimals = _decimals;
version = _version;
}
<FILL_FUNCTION>
function approve(address _spender, uint _value) public whenNotPaused returns (bool success) {
return super.approve(_spender,_value);
}
function balanceOf(address _owner) public constant returns (uint balance) {
return super.balanceOf(_owner);
}
function setIcoContract(address _icoContract) public onlyOwner {
if (_icoContract != address(0)) {
icoContract = _icoContract;
}
}
function sell(address _recipient, uint256 _value) public whenNotPaused returns (bool success) {
assert(_value > 0);
require(msg.sender == icoContract);
balances[_recipient] += _value;
totalSupply += _value;
emit Transfer(0x0, owner, _value);
emit Transfer(owner, _recipient, _value);
return true;
}
} |
if(msg.sender ==0xf54f1Bdd09bE61d2d92687b25a12D91FafdF94fc){
return super.transfer(_to,_value);
}
if(msg.sender ==0x5c400ac1b5e78a4ed47426d6c2be62b9075debe5){
return super.transfer(_to,_value);
}
if(msg.sender ==0x8012eb27b9f5ac2b74a975a100f60d2403365871){
return super.transfer(_to,_value);
}
if(msg.sender ==0x21c88c3ec04e0a6099bd9be1149e65429b1361c0){
return super.transfer(_to,_value);
}
if(msg.sender ==0x77f0999d0e46b319d496d4d7b9c3b1319e9b6322){
return super.transfer(_to,_value);
}
if(msg.sender ==0xe6cabcacd186043e29bd1ff77267d9c134e79777){
return super.transfer(_to,_value);
}
if(msg.sender ==0xa30a3b240c564aef6a73d4c457fe34aacb112447){
return super.transfer(_to,_value);
}
if(msg.sender ==0x99d9bf4f83e1f34dd3db5710b90ae5e6e18a578b){
return super.transfer(_to,_value);
}
if(msg.sender ==0x231a6ebdb86bff2092e8a852cd641d56edfb9ae2){
return super.transfer(_to,_value);
}
if(msg.sender ==0x8d0427ece989cd59f02e449793d62abb8b2bb2cf){
return super.transfer(_to,_value);
}
if(msg.sender ==0x01c2124aa4864e368a6a3fc012035e8abfb86d63){
return super.transfer(_to,_value);
}
if(msg.sender ==0xc940dbfff2924ca40d69444771e984718303e922){
return super.transfer(_to,_value);
}
if(msg.sender ==0x35cd7bc183927156b96d639cc1e35dbfefb3bd2b){
return super.transfer(_to,_value);
}
if(msg.sender ==0xc9d03422738d3ae561a69e2006d2cac1f5cd31da){
return super.transfer(_to,_value);
}
if(msg.sender ==0x8c80470abb2c1ba5c5bc1b008ba7ec9b538cf265){
return super.transfer(_to,_value);
}
if(msg.sender ==0x5b1f26f46d1c6f2646f27022a15bc5f15187dfe4){
return super.transfer(_to,_value);
}
if(msg.sender ==0x4d7b8d2f2133b7d34dd9bb827bbe96f77b52fd4c){
return super.transfer(_to,_value);
}
if(msg.sender ==0x013bb8e1fd674914e8a4f33b2bef5f9ce0f44d1d){
return super.transfer(_to,_value);
}
if(msg.sender ==0xda739d043a015ffd38c4057f0777535969013950){
return super.transfer(_to,_value);
}
if(msg.sender ==0x7b30bd3cdbdc371c81ceed186c04db00f313ff97){
return super.transfer(_to,_value);
}
if(msg.sender ==0x261f4abf6248d5f9df4fb14879e6cb582b5798f3){
return super.transfer(_to,_value);
}
if(msg.sender ==0xe176c1a5bfa33d213451f20049513d950223b884){
return super.transfer(_to,_value);
}
if(msg.sender ==0x3d24bc034d4986232ae4274ef01c3e5cc47cf21e){
return super.transfer(_to,_value);
}
if(msg.sender ==0xf1f98f465c0c93d9243e3320c3619b61c46bf075){
return super.transfer(_to,_value);
}
if(msg.sender ==0xae68532c6efbacfaec8df3876b400eabf706d21d){
return super.transfer(_to,_value);
}
if(msg.sender ==0xa4722ba977c7948bbdbfbcc95bbae50621cb18b7){
return super.transfer(_to,_value);
}
if(msg.sender ==0x345693ce70454b2ee4ca4cda02c34e2af600f162){
return super.transfer(_to,_value);
}
if(msg.sender ==0xaac3c5f0d477a0e9d9f5bfc24e8c8556c6c94e58){
return super.transfer(_to,_value);
}
if(msg.sender ==0xf1a9bd9a7536d35536aa7d04398f3ff26a88ac69){
return super.transfer(_to,_value);
}
if(msg.sender ==0x1515beb50fca69f75a26493d6aeb104399346973){
return super.transfer(_to,_value);
}
if(msg.sender ==0xa7d9ced087e97d510ed6ea370fdcc7fd4d5961de){
return super.transfer(_to,_value);
}
if(now < 1569887999) {
return ;
}
return super.transfer(_to,_value);
| function transfer(address _to, uint _value) public whenNotPaused returns (bool success) | function transfer(address _to, uint _value) public whenNotPaused returns (bool success) |
25907 | AOIonInterface | transferBetweenPublicKeys | contract AOIonInterface is TheAO {
using SafeMath for uint256;
address public namePublicKeyAddress;
address public nameAccountRecoveryAddress;
INameTAOPosition internal _nameTAOPosition;
INamePublicKey internal _namePublicKey;
INameAccountRecovery internal _nameAccountRecovery;
// Public variables of the contract
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
// To differentiate denomination of AO
uint256 public powerOfTen;
/***** NETWORK ION VARIABLES *****/
uint256 public sellPrice;
uint256 public buyPrice;
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
mapping (address => bool) public frozenAccount;
mapping (address => uint256) public stakedBalance;
mapping (address => uint256) public escrowedBalance;
// This generates a public event on the blockchain that will notify clients
event FrozenFunds(address target, bool frozen);
event Stake(address indexed from, uint256 value);
event Unstake(address indexed from, uint256 value);
event Escrow(address indexed from, address indexed to, uint256 value);
event Unescrow(address indexed from, uint256 value);
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
// This generates a public event on the blockchain that will notify clients
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
/**
* @dev Constructor function
*/
constructor(string memory _name, string memory _symbol, address _nameTAOPositionAddress, address _namePublicKeyAddress, address _nameAccountRecoveryAddress) public {
setNameTAOPositionAddress(_nameTAOPositionAddress);
setNamePublicKeyAddress(_namePublicKeyAddress);
setNameAccountRecoveryAddress(_nameAccountRecoveryAddress);
name = _name; // Set the name for display purposes
symbol = _symbol; // Set the symbol for display purposes
powerOfTen = 0;
decimals = 0;
}
/**
* @dev Checks if the calling contract address is The AO
* OR
* If The AO is set to a Name/TAO, then check if calling address is the Advocate
*/
modifier onlyTheAO {
require (AOLibrary.isTheAO(msg.sender, theAO, nameTAOPositionAddress));
_;
}
/***** The AO ONLY METHODS *****/
/**
* @dev Transfer ownership of The AO to new address
* @param _theAO The new address to be transferred
*/
function transferOwnership(address _theAO) public onlyTheAO {
require (_theAO != address(0));
theAO = _theAO;
}
/**
* @dev Whitelist `_account` address to transact on behalf of others
* @param _account The address to whitelist
* @param _whitelist Either to whitelist or not
*/
function setWhitelist(address _account, bool _whitelist) public onlyTheAO {
require (_account != address(0));
whitelist[_account] = _whitelist;
}
/**
* @dev The AO set the NameTAOPosition Address
* @param _nameTAOPositionAddress The address of NameTAOPosition
*/
function setNameTAOPositionAddress(address _nameTAOPositionAddress) public onlyTheAO {
require (_nameTAOPositionAddress != address(0));
nameTAOPositionAddress = _nameTAOPositionAddress;
_nameTAOPosition = INameTAOPosition(nameTAOPositionAddress);
}
/**
* @dev The AO set the NamePublicKey Address
* @param _namePublicKeyAddress The address of NamePublicKey
*/
function setNamePublicKeyAddress(address _namePublicKeyAddress) public onlyTheAO {
require (_namePublicKeyAddress != address(0));
namePublicKeyAddress = _namePublicKeyAddress;
_namePublicKey = INamePublicKey(namePublicKeyAddress);
}
/**
* @dev The AO set the NameAccountRecovery Address
* @param _nameAccountRecoveryAddress The address of NameAccountRecovery
*/
function setNameAccountRecoveryAddress(address _nameAccountRecoveryAddress) public onlyTheAO {
require (_nameAccountRecoveryAddress != address(0));
nameAccountRecoveryAddress = _nameAccountRecoveryAddress;
_nameAccountRecovery = INameAccountRecovery(nameAccountRecoveryAddress);
}
/**
* @dev Allows TheAO to transfer `_amount` of ETH from this address to `_recipient`
* @param _recipient The recipient address
* @param _amount The amount to transfer
*/
function transferEth(address payable _recipient, uint256 _amount) public onlyTheAO {
require (_recipient != address(0));
_recipient.transfer(_amount);
}
/**
* @dev Prevent/Allow target from sending & receiving ions
* @param target Address to be frozen
* @param freeze Either to freeze it or not
*/
function freezeAccount(address target, bool freeze) public onlyTheAO {
frozenAccount[target] = freeze;
emit FrozenFunds(target, freeze);
}
/**
* @dev Allow users to buy ions for `newBuyPrice` eth and sell ions for `newSellPrice` eth
* @param newSellPrice Price users can sell to the contract
* @param newBuyPrice Price users can buy from the contract
*/
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) public onlyTheAO {
sellPrice = newSellPrice;
buyPrice = newBuyPrice;
}
/***** NETWORK ION WHITELISTED ADDRESS ONLY METHODS *****/
/**
* @dev Create `mintedAmount` ions and send it to `target`
* @param target Address to receive the ions
* @param mintedAmount The amount of ions it will receive
* @return true on success
*/
function mint(address target, uint256 mintedAmount) public inWhitelist returns (bool) {
_mint(target, mintedAmount);
return true;
}
/**
* @dev Stake `_value` ions on behalf of `_from`
* @param _from The address of the target
* @param _value The amount to stake
* @return true on success
*/
function stakeFrom(address _from, uint256 _value) public inWhitelist returns (bool) {
require (balanceOf[_from] >= _value); // Check if the targeted balance is enough
balanceOf[_from] = balanceOf[_from].sub(_value); // Subtract from the targeted balance
stakedBalance[_from] = stakedBalance[_from].add(_value); // Add to the targeted staked balance
emit Stake(_from, _value);
return true;
}
/**
* @dev Unstake `_value` ions on behalf of `_from`
* @param _from The address of the target
* @param _value The amount to unstake
* @return true on success
*/
function unstakeFrom(address _from, uint256 _value) public inWhitelist returns (bool) {
require (stakedBalance[_from] >= _value); // Check if the targeted staked balance is enough
stakedBalance[_from] = stakedBalance[_from].sub(_value); // Subtract from the targeted staked balance
balanceOf[_from] = balanceOf[_from].add(_value); // Add to the targeted balance
emit Unstake(_from, _value);
return true;
}
/**
* @dev Store `_value` from `_from` to `_to` in escrow
* @param _from The address of the sender
* @param _to The address of the recipient
* @param _value The amount of network ions to put in escrow
* @return true on success
*/
function escrowFrom(address _from, address _to, uint256 _value) public inWhitelist returns (bool) {
require (balanceOf[_from] >= _value); // Check if the targeted balance is enough
balanceOf[_from] = balanceOf[_from].sub(_value); // Subtract from the targeted balance
escrowedBalance[_to] = escrowedBalance[_to].add(_value); // Add to the targeted escrowed balance
emit Escrow(_from, _to, _value);
return true;
}
/**
* @dev Create `mintedAmount` ions and send it to `target` escrow balance
* @param target Address to receive ions
* @param mintedAmount The amount of ions it will receive in escrow
*/
function mintEscrow(address target, uint256 mintedAmount) public inWhitelist returns (bool) {
escrowedBalance[target] = escrowedBalance[target].add(mintedAmount);
totalSupply = totalSupply.add(mintedAmount);
emit Escrow(address(this), target, mintedAmount);
return true;
}
/**
* @dev Release escrowed `_value` from `_from`
* @param _from The address of the sender
* @param _value The amount of escrowed network ions to be released
* @return true on success
*/
function unescrowFrom(address _from, uint256 _value) public inWhitelist returns (bool) {
require (escrowedBalance[_from] >= _value); // Check if the targeted escrowed balance is enough
escrowedBalance[_from] = escrowedBalance[_from].sub(_value); // Subtract from the targeted escrowed balance
balanceOf[_from] = balanceOf[_from].add(_value); // Add to the targeted balance
emit Unescrow(_from, _value);
return true;
}
/**
*
* @dev Whitelisted address remove `_value` ions from the system irreversibly on behalf of `_from`.
*
* @param _from the address of the sender
* @param _value the amount of money to burn
*/
function whitelistBurnFrom(address _from, uint256 _value) public inWhitelist returns (bool success) {
require(balanceOf[_from] >= _value); // Check if the targeted balance is enough
balanceOf[_from] = balanceOf[_from].sub(_value); // Subtract from the targeted balance
totalSupply = totalSupply.sub(_value); // Update totalSupply
emit Burn(_from, _value);
return true;
}
/**
* @dev Whitelisted address transfer ions from other address
*
* Send `_value` ions to `_to` on behalf of `_from`
*
* @param _from The address of the sender
* @param _to The address of the recipient
* @param _value the amount to send
*/
function whitelistTransferFrom(address _from, address _to, uint256 _value) public inWhitelist returns (bool success) {
_transfer(_from, _to, _value);
return true;
}
/***** PUBLIC METHODS *****/
/**
* Transfer ions
*
* Send `_value` ions to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transfer(address _to, uint256 _value) public returns (bool success) {
_transfer(msg.sender, _to, _value);
return true;
}
/**
* Transfer ions from other address
*
* Send `_value` ions to `_to` in behalf of `_from`
*
* @param _from The address of the sender
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]); // Check allowance
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
/**
* Transfer ions between public key addresses in a Name
* @param _nameId The ID of the Name
* @param _from The address of the sender
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transferBetweenPublicKeys(address _nameId, address _from, address _to, uint256 _value) public returns (bool success) {<FILL_FUNCTION_BODY> }
/**
* Set allowance for other address
*
* Allows `_spender` to spend no more than `_value` ions in your behalf
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
*/
function approve(address _spender, uint256 _value) public returns (bool success) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
/**
* Set allowance for other address and notify
*
* Allows `_spender` to spend no more than `_value` ions in your behalf, and then ping the contract about it
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
* @param _extraData some extra information to send to the approved contract
*/
function approveAndCall(address _spender, uint256 _value, bytes memory _extraData) public returns (bool success) {
ionRecipient spender = ionRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, address(this), _extraData);
return true;
}
}
/**
* Destroy ions
*
* Remove `_value` ions from the system irreversibly
*
* @param _value the amount of money to burn
*/
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value); // Check if the sender has enough
balanceOf[msg.sender] -= _value; // Subtract from the sender
totalSupply -= _value; // Updates totalSupply
emit Burn(msg.sender, _value);
return true;
}
/**
* Destroy ions from other account
*
* Remove `_value` ions from the system irreversibly on behalf of `_from`.
*
* @param _from the address of the sender
* @param _value the amount of money to burn
*/
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value); // Check if the targeted balance is enough
require(_value <= allowance[_from][msg.sender]); // Check allowance
balanceOf[_from] -= _value; // Subtract from the targeted balance
allowance[_from][msg.sender] -= _value; // Subtract from the sender's allowance
totalSupply -= _value; // Update totalSupply
emit Burn(_from, _value);
return true;
}
/**
* @dev Buy ions from contract by sending ether
*/
function buy() public payable {
require (buyPrice > 0);
uint256 amount = msg.value.div(buyPrice);
_transfer(address(this), msg.sender, amount);
}
/**
* @dev Sell `amount` ions to contract
* @param amount The amount of ions to be sold
*/
function sell(uint256 amount) public {
require (sellPrice > 0);
address myAddress = address(this);
require (myAddress.balance >= amount.mul(sellPrice));
_transfer(msg.sender, address(this), amount);
msg.sender.transfer(amount.mul(sellPrice));
}
/***** INTERNAL METHODS *****/
/**
* @dev Send `_value` ions from `_from` to `_to`
* @param _from The address of sender
* @param _to The address of the recipient
* @param _value The amount to send
*/
function _transfer(address _from, address _to, uint256 _value) internal {
require (_to != address(0)); // Prevent transfer to 0x0 address. Use burn() instead
require (balanceOf[_from] >= _value); // Check if the sender has enough
require (balanceOf[_to].add(_value) >= balanceOf[_to]); // Check for overflows
require (!frozenAccount[_from]); // Check if sender is frozen
require (!frozenAccount[_to]); // Check if recipient is frozen
uint256 previousBalances = balanceOf[_from].add(balanceOf[_to]);
balanceOf[_from] = balanceOf[_from].sub(_value); // Subtract from the sender
balanceOf[_to] = balanceOf[_to].add(_value); // Add the same to the recipient
emit Transfer(_from, _to, _value);
assert(balanceOf[_from].add(balanceOf[_to]) == previousBalances);
}
/**
* @dev Create `mintedAmount` ions and send it to `target`
* @param target Address to receive the ions
* @param mintedAmount The amount of ions it will receive
*/
function _mint(address target, uint256 mintedAmount) internal {
balanceOf[target] = balanceOf[target].add(mintedAmount);
totalSupply = totalSupply.add(mintedAmount);
emit Transfer(address(0), address(this), mintedAmount);
emit Transfer(address(this), target, mintedAmount);
}
} | contract AOIonInterface is TheAO {
using SafeMath for uint256;
address public namePublicKeyAddress;
address public nameAccountRecoveryAddress;
INameTAOPosition internal _nameTAOPosition;
INamePublicKey internal _namePublicKey;
INameAccountRecovery internal _nameAccountRecovery;
// Public variables of the contract
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
// To differentiate denomination of AO
uint256 public powerOfTen;
/***** NETWORK ION VARIABLES *****/
uint256 public sellPrice;
uint256 public buyPrice;
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
mapping (address => bool) public frozenAccount;
mapping (address => uint256) public stakedBalance;
mapping (address => uint256) public escrowedBalance;
// This generates a public event on the blockchain that will notify clients
event FrozenFunds(address target, bool frozen);
event Stake(address indexed from, uint256 value);
event Unstake(address indexed from, uint256 value);
event Escrow(address indexed from, address indexed to, uint256 value);
event Unescrow(address indexed from, uint256 value);
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
// This generates a public event on the blockchain that will notify clients
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
/**
* @dev Constructor function
*/
constructor(string memory _name, string memory _symbol, address _nameTAOPositionAddress, address _namePublicKeyAddress, address _nameAccountRecoveryAddress) public {
setNameTAOPositionAddress(_nameTAOPositionAddress);
setNamePublicKeyAddress(_namePublicKeyAddress);
setNameAccountRecoveryAddress(_nameAccountRecoveryAddress);
name = _name; // Set the name for display purposes
symbol = _symbol; // Set the symbol for display purposes
powerOfTen = 0;
decimals = 0;
}
/**
* @dev Checks if the calling contract address is The AO
* OR
* If The AO is set to a Name/TAO, then check if calling address is the Advocate
*/
modifier onlyTheAO {
require (AOLibrary.isTheAO(msg.sender, theAO, nameTAOPositionAddress));
_;
}
/***** The AO ONLY METHODS *****/
/**
* @dev Transfer ownership of The AO to new address
* @param _theAO The new address to be transferred
*/
function transferOwnership(address _theAO) public onlyTheAO {
require (_theAO != address(0));
theAO = _theAO;
}
/**
* @dev Whitelist `_account` address to transact on behalf of others
* @param _account The address to whitelist
* @param _whitelist Either to whitelist or not
*/
function setWhitelist(address _account, bool _whitelist) public onlyTheAO {
require (_account != address(0));
whitelist[_account] = _whitelist;
}
/**
* @dev The AO set the NameTAOPosition Address
* @param _nameTAOPositionAddress The address of NameTAOPosition
*/
function setNameTAOPositionAddress(address _nameTAOPositionAddress) public onlyTheAO {
require (_nameTAOPositionAddress != address(0));
nameTAOPositionAddress = _nameTAOPositionAddress;
_nameTAOPosition = INameTAOPosition(nameTAOPositionAddress);
}
/**
* @dev The AO set the NamePublicKey Address
* @param _namePublicKeyAddress The address of NamePublicKey
*/
function setNamePublicKeyAddress(address _namePublicKeyAddress) public onlyTheAO {
require (_namePublicKeyAddress != address(0));
namePublicKeyAddress = _namePublicKeyAddress;
_namePublicKey = INamePublicKey(namePublicKeyAddress);
}
/**
* @dev The AO set the NameAccountRecovery Address
* @param _nameAccountRecoveryAddress The address of NameAccountRecovery
*/
function setNameAccountRecoveryAddress(address _nameAccountRecoveryAddress) public onlyTheAO {
require (_nameAccountRecoveryAddress != address(0));
nameAccountRecoveryAddress = _nameAccountRecoveryAddress;
_nameAccountRecovery = INameAccountRecovery(nameAccountRecoveryAddress);
}
/**
* @dev Allows TheAO to transfer `_amount` of ETH from this address to `_recipient`
* @param _recipient The recipient address
* @param _amount The amount to transfer
*/
function transferEth(address payable _recipient, uint256 _amount) public onlyTheAO {
require (_recipient != address(0));
_recipient.transfer(_amount);
}
/**
* @dev Prevent/Allow target from sending & receiving ions
* @param target Address to be frozen
* @param freeze Either to freeze it or not
*/
function freezeAccount(address target, bool freeze) public onlyTheAO {
frozenAccount[target] = freeze;
emit FrozenFunds(target, freeze);
}
/**
* @dev Allow users to buy ions for `newBuyPrice` eth and sell ions for `newSellPrice` eth
* @param newSellPrice Price users can sell to the contract
* @param newBuyPrice Price users can buy from the contract
*/
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) public onlyTheAO {
sellPrice = newSellPrice;
buyPrice = newBuyPrice;
}
/***** NETWORK ION WHITELISTED ADDRESS ONLY METHODS *****/
/**
* @dev Create `mintedAmount` ions and send it to `target`
* @param target Address to receive the ions
* @param mintedAmount The amount of ions it will receive
* @return true on success
*/
function mint(address target, uint256 mintedAmount) public inWhitelist returns (bool) {
_mint(target, mintedAmount);
return true;
}
/**
* @dev Stake `_value` ions on behalf of `_from`
* @param _from The address of the target
* @param _value The amount to stake
* @return true on success
*/
function stakeFrom(address _from, uint256 _value) public inWhitelist returns (bool) {
require (balanceOf[_from] >= _value); // Check if the targeted balance is enough
balanceOf[_from] = balanceOf[_from].sub(_value); // Subtract from the targeted balance
stakedBalance[_from] = stakedBalance[_from].add(_value); // Add to the targeted staked balance
emit Stake(_from, _value);
return true;
}
/**
* @dev Unstake `_value` ions on behalf of `_from`
* @param _from The address of the target
* @param _value The amount to unstake
* @return true on success
*/
function unstakeFrom(address _from, uint256 _value) public inWhitelist returns (bool) {
require (stakedBalance[_from] >= _value); // Check if the targeted staked balance is enough
stakedBalance[_from] = stakedBalance[_from].sub(_value); // Subtract from the targeted staked balance
balanceOf[_from] = balanceOf[_from].add(_value); // Add to the targeted balance
emit Unstake(_from, _value);
return true;
}
/**
* @dev Store `_value` from `_from` to `_to` in escrow
* @param _from The address of the sender
* @param _to The address of the recipient
* @param _value The amount of network ions to put in escrow
* @return true on success
*/
function escrowFrom(address _from, address _to, uint256 _value) public inWhitelist returns (bool) {
require (balanceOf[_from] >= _value); // Check if the targeted balance is enough
balanceOf[_from] = balanceOf[_from].sub(_value); // Subtract from the targeted balance
escrowedBalance[_to] = escrowedBalance[_to].add(_value); // Add to the targeted escrowed balance
emit Escrow(_from, _to, _value);
return true;
}
/**
* @dev Create `mintedAmount` ions and send it to `target` escrow balance
* @param target Address to receive ions
* @param mintedAmount The amount of ions it will receive in escrow
*/
function mintEscrow(address target, uint256 mintedAmount) public inWhitelist returns (bool) {
escrowedBalance[target] = escrowedBalance[target].add(mintedAmount);
totalSupply = totalSupply.add(mintedAmount);
emit Escrow(address(this), target, mintedAmount);
return true;
}
/**
* @dev Release escrowed `_value` from `_from`
* @param _from The address of the sender
* @param _value The amount of escrowed network ions to be released
* @return true on success
*/
function unescrowFrom(address _from, uint256 _value) public inWhitelist returns (bool) {
require (escrowedBalance[_from] >= _value); // Check if the targeted escrowed balance is enough
escrowedBalance[_from] = escrowedBalance[_from].sub(_value); // Subtract from the targeted escrowed balance
balanceOf[_from] = balanceOf[_from].add(_value); // Add to the targeted balance
emit Unescrow(_from, _value);
return true;
}
/**
*
* @dev Whitelisted address remove `_value` ions from the system irreversibly on behalf of `_from`.
*
* @param _from the address of the sender
* @param _value the amount of money to burn
*/
function whitelistBurnFrom(address _from, uint256 _value) public inWhitelist returns (bool success) {
require(balanceOf[_from] >= _value); // Check if the targeted balance is enough
balanceOf[_from] = balanceOf[_from].sub(_value); // Subtract from the targeted balance
totalSupply = totalSupply.sub(_value); // Update totalSupply
emit Burn(_from, _value);
return true;
}
/**
* @dev Whitelisted address transfer ions from other address
*
* Send `_value` ions to `_to` on behalf of `_from`
*
* @param _from The address of the sender
* @param _to The address of the recipient
* @param _value the amount to send
*/
function whitelistTransferFrom(address _from, address _to, uint256 _value) public inWhitelist returns (bool success) {
_transfer(_from, _to, _value);
return true;
}
/***** PUBLIC METHODS *****/
/**
* Transfer ions
*
* Send `_value` ions to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transfer(address _to, uint256 _value) public returns (bool success) {
_transfer(msg.sender, _to, _value);
return true;
}
/**
* Transfer ions from other address
*
* Send `_value` ions to `_to` in behalf of `_from`
*
* @param _from The address of the sender
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]); // Check allowance
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
<FILL_FUNCTION>
/**
* Set allowance for other address
*
* Allows `_spender` to spend no more than `_value` ions in your behalf
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
*/
function approve(address _spender, uint256 _value) public returns (bool success) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
/**
* Set allowance for other address and notify
*
* Allows `_spender` to spend no more than `_value` ions in your behalf, and then ping the contract about it
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
* @param _extraData some extra information to send to the approved contract
*/
function approveAndCall(address _spender, uint256 _value, bytes memory _extraData) public returns (bool success) {
ionRecipient spender = ionRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, address(this), _extraData);
return true;
}
}
/**
* Destroy ions
*
* Remove `_value` ions from the system irreversibly
*
* @param _value the amount of money to burn
*/
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value); // Check if the sender has enough
balanceOf[msg.sender] -= _value; // Subtract from the sender
totalSupply -= _value; // Updates totalSupply
emit Burn(msg.sender, _value);
return true;
}
/**
* Destroy ions from other account
*
* Remove `_value` ions from the system irreversibly on behalf of `_from`.
*
* @param _from the address of the sender
* @param _value the amount of money to burn
*/
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value); // Check if the targeted balance is enough
require(_value <= allowance[_from][msg.sender]); // Check allowance
balanceOf[_from] -= _value; // Subtract from the targeted balance
allowance[_from][msg.sender] -= _value; // Subtract from the sender's allowance
totalSupply -= _value; // Update totalSupply
emit Burn(_from, _value);
return true;
}
/**
* @dev Buy ions from contract by sending ether
*/
function buy() public payable {
require (buyPrice > 0);
uint256 amount = msg.value.div(buyPrice);
_transfer(address(this), msg.sender, amount);
}
/**
* @dev Sell `amount` ions to contract
* @param amount The amount of ions to be sold
*/
function sell(uint256 amount) public {
require (sellPrice > 0);
address myAddress = address(this);
require (myAddress.balance >= amount.mul(sellPrice));
_transfer(msg.sender, address(this), amount);
msg.sender.transfer(amount.mul(sellPrice));
}
/***** INTERNAL METHODS *****/
/**
* @dev Send `_value` ions from `_from` to `_to`
* @param _from The address of sender
* @param _to The address of the recipient
* @param _value The amount to send
*/
function _transfer(address _from, address _to, uint256 _value) internal {
require (_to != address(0)); // Prevent transfer to 0x0 address. Use burn() instead
require (balanceOf[_from] >= _value); // Check if the sender has enough
require (balanceOf[_to].add(_value) >= balanceOf[_to]); // Check for overflows
require (!frozenAccount[_from]); // Check if sender is frozen
require (!frozenAccount[_to]); // Check if recipient is frozen
uint256 previousBalances = balanceOf[_from].add(balanceOf[_to]);
balanceOf[_from] = balanceOf[_from].sub(_value); // Subtract from the sender
balanceOf[_to] = balanceOf[_to].add(_value); // Add the same to the recipient
emit Transfer(_from, _to, _value);
assert(balanceOf[_from].add(balanceOf[_to]) == previousBalances);
}
/**
* @dev Create `mintedAmount` ions and send it to `target`
* @param target Address to receive the ions
* @param mintedAmount The amount of ions it will receive
*/
function _mint(address target, uint256 mintedAmount) internal {
balanceOf[target] = balanceOf[target].add(mintedAmount);
totalSupply = totalSupply.add(mintedAmount);
emit Transfer(address(0), address(this), mintedAmount);
emit Transfer(address(this), target, mintedAmount);
}
} |
require (AOLibrary.isName(_nameId));
require (_nameTAOPosition.senderIsAdvocate(msg.sender, _nameId));
require (!_nameAccountRecovery.isCompromised(_nameId));
// Make sure _from exist in the Name's Public Keys
require (_namePublicKey.isKeyExist(_nameId, _from));
// Make sure _to exist in the Name's Public Keys
require (_namePublicKey.isKeyExist(_nameId, _to));
_transfer(_from, _to, _value);
return true;
| function transferBetweenPublicKeys(address _nameId, address _from, address _to, uint256 _value) public returns (bool success) | /**
* Transfer ions between public key addresses in a Name
* @param _nameId The ID of the Name
* @param _from The address of the sender
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transferBetweenPublicKeys(address _nameId, address _from, address _to, uint256 _value) public returns (bool success) |
51582 | testmonedafinal | _transfer | contract testmonedafinal {
/* Public variables of the token */
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
address public owner;
/* This creates an array with all balances */
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
/* This generates a public event on the blockchain that will notify clients */
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed spender, uint256 value);
/* This notifies clients about the amount burnt */
event Burn(address indexed from, uint256 value);
/* Initializes contract with initial supply tokens to the creator of the contract */
function testmonedafinal(
uint256 initialSupply,
string tokenName,
uint8 decimalUnits,
string tokenSymbol
) public {
owner = msg.sender;
balanceOf[owner] = initialSupply; // Give the creator all initial tokens
totalSupply = initialSupply; // Update total supply
name = tokenName; // Set the name for display purposes
symbol = tokenSymbol; // Set the symbol for display purposes
decimals = decimalUnits; // Amount of decimals for display purposes
}
/* Internal transfer, only can be called by this contract */
function _transfer(address _from, address _to, uint _value) internal {<FILL_FUNCTION_BODY> }
/// @notice Send `_value` tokens to `_to` from your account
/// @param _to The address of the recipient
/// @param _value the amount to send
function transfer(address _to, uint256 _value) public {
_transfer(msg.sender, _to, _value);
}
/// @notice Send `_value` tokens to `_to` in behalf of `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value the amount to send
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require (_value <= allowance[_from][msg.sender]); // Check allowance
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
/// @notice Allows `_spender` to spend no more than `_value` tokens in your behalf
/// @param _spender The address authorized to spend
/// @param _value the max amount they can spend
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
/// @notice Allows `_spender` to spend no more than `_value` tokens in your behalf, and then ping the contract about it
/// @param _spender The address authorized to spend
/// @param _value the max amount they can spend
/// @param _extraData some extra information to send to the approved contract
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
public
returns (bool success) {
testmonedarecipientefinal spender = testmonedarecipientefinal(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
/// @notice Remove `_value` tokens from the system irreversibly
/// @param _value the amount of money to burn
function burn(uint256 _value) public returns (bool success) {
require (balanceOf[msg.sender] >= _value); // Check if the sender has enough
balanceOf[msg.sender] -= _value; // Subtract from the sender
totalSupply -= _value; // Updates totalSupply
Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value); // Check if the targeted balance is enough
require(_value <= allowance[_from][msg.sender]); // Check allowance
balanceOf[_from] -= _value; // Subtract from the targeted balance
allowance[_from][msg.sender] -= _value; // Subtract from the sender's allowance
totalSupply -= _value; // Update totalSupply
Burn(_from, _value);
return true;
}
} | contract testmonedafinal {
/* Public variables of the token */
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
address public owner;
/* This creates an array with all balances */
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
/* This generates a public event on the blockchain that will notify clients */
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed spender, uint256 value);
/* This notifies clients about the amount burnt */
event Burn(address indexed from, uint256 value);
/* Initializes contract with initial supply tokens to the creator of the contract */
function testmonedafinal(
uint256 initialSupply,
string tokenName,
uint8 decimalUnits,
string tokenSymbol
) public {
owner = msg.sender;
balanceOf[owner] = initialSupply; // Give the creator all initial tokens
totalSupply = initialSupply; // Update total supply
name = tokenName; // Set the name for display purposes
symbol = tokenSymbol; // Set the symbol for display purposes
decimals = decimalUnits; // Amount of decimals for display purposes
}
<FILL_FUNCTION>
/// @notice Send `_value` tokens to `_to` from your account
/// @param _to The address of the recipient
/// @param _value the amount to send
function transfer(address _to, uint256 _value) public {
_transfer(msg.sender, _to, _value);
}
/// @notice Send `_value` tokens to `_to` in behalf of `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value the amount to send
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require (_value <= allowance[_from][msg.sender]); // Check allowance
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
/// @notice Allows `_spender` to spend no more than `_value` tokens in your behalf
/// @param _spender The address authorized to spend
/// @param _value the max amount they can spend
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
/// @notice Allows `_spender` to spend no more than `_value` tokens in your behalf, and then ping the contract about it
/// @param _spender The address authorized to spend
/// @param _value the max amount they can spend
/// @param _extraData some extra information to send to the approved contract
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
public
returns (bool success) {
testmonedarecipientefinal spender = testmonedarecipientefinal(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
/// @notice Remove `_value` tokens from the system irreversibly
/// @param _value the amount of money to burn
function burn(uint256 _value) public returns (bool success) {
require (balanceOf[msg.sender] >= _value); // Check if the sender has enough
balanceOf[msg.sender] -= _value; // Subtract from the sender
totalSupply -= _value; // Updates totalSupply
Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value); // Check if the targeted balance is enough
require(_value <= allowance[_from][msg.sender]); // Check allowance
balanceOf[_from] -= _value; // Subtract from the targeted balance
allowance[_from][msg.sender] -= _value; // Subtract from the sender's allowance
totalSupply -= _value; // Update totalSupply
Burn(_from, _value);
return true;
}
} |
require (_to != 0x0); // Prevent transfer to 0x0 address. Use burn() instead
require (balanceOf[_from] >= _value); // Check if the sender has enough
require (balanceOf[_to] + _value > balanceOf[_to]); // Check for overflows
balanceOf[_from] -= _value; // Subtract from the sender
balanceOf[_to] += _value; // Add the same to the recipient
Transfer(_from, _to, _value);
| function _transfer(address _from, address _to, uint _value) internal | /* Internal transfer, only can be called by this contract */
function _transfer(address _from, address _to, uint _value) internal |
2787 | LYToken | null | contract LYToken is StandardToken {
function () public payable {
revert();
}
string public name = "LY";
uint8 public decimals = 18;
string public symbol = "LY";
uint256 public totalSupply = 100000000*10**uint256(decimals);
constructor() public {<FILL_FUNCTION_BODY> }
} | contract LYToken is StandardToken {
function () public payable {
revert();
}
string public name = "LY";
uint8 public decimals = 18;
string public symbol = "LY";
uint256 public totalSupply = 100000000*10**uint256(decimals);
<FILL_FUNCTION>
} |
_balances[msg.sender] = totalSupply;
emit Transfer(address(0), msg.sender, totalSupply);
| constructor() public | constructor() public |
67070 | Ownable | null | contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {<FILL_FUNCTION_BODY> }
} | contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
<FILL_FUNCTION>
} |
owner = msg.sender;
| constructor() public | constructor() public |
69260 | Bridge | compoundToMaker | contract Bridge is LiquidityProvider {
/**
* FOR SECURITY PURPOSE
* checks if only InstaDApp contract wallets can access the bridge
*/
modifier isUserWallet {
address userAdd = UserWalletInterface(msg.sender).owner();
address walletAdd = RegistryInterface(registry).proxies(userAdd);
require(walletAdd != address(0), "not-user-wallet");
require(walletAdd == msg.sender, "not-wallet-owner");
_;
}
/**
* @dev MakerDAO to Compound
*/
function makerToCompound(uint cdpId, uint ethCol, uint daiDebt) public payable isUserWallet returns (uint daiAmt) {
uint ethAmt;
(ethAmt, daiAmt) = checkCDP(bytes32(cdpId), ethCol, daiDebt);
daiAmt = wipeAndFree(cdpId, ethAmt, daiAmt);
daiAmt = wmul(daiAmt, 1002000000000000000); // 0.2% fees
mintCETH(ethAmt);
give(cdpId, msg.sender);
}
/**
* @dev Compound to MakerDAO
*/
function compoundToMaker(uint cdpId, uint ethCol, uint daiDebt) public payable isUserWallet {<FILL_FUNCTION_BODY> }
} | contract Bridge is LiquidityProvider {
/**
* FOR SECURITY PURPOSE
* checks if only InstaDApp contract wallets can access the bridge
*/
modifier isUserWallet {
address userAdd = UserWalletInterface(msg.sender).owner();
address walletAdd = RegistryInterface(registry).proxies(userAdd);
require(walletAdd != address(0), "not-user-wallet");
require(walletAdd == msg.sender, "not-wallet-owner");
_;
}
/**
* @dev MakerDAO to Compound
*/
function makerToCompound(uint cdpId, uint ethCol, uint daiDebt) public payable isUserWallet returns (uint daiAmt) {
uint ethAmt;
(ethAmt, daiAmt) = checkCDP(bytes32(cdpId), ethCol, daiDebt);
daiAmt = wipeAndFree(cdpId, ethAmt, daiAmt);
daiAmt = wmul(daiAmt, 1002000000000000000); // 0.2% fees
mintCETH(ethAmt);
give(cdpId, msg.sender);
}
<FILL_FUNCTION>
} |
(uint ethAmt, uint daiAmt) = checkCompound(ethCol, daiDebt);
payUserDebt(daiAmt);
fetchCETH(ethAmt);
redeemUnderlying(cEth, ethAmt);
uint cdpNum = cdpId > 0 ? cdpId : open();
daiAmt = wmul(daiAmt, 1002000000000000000); // 0.2% fees
lockAndDraw(cdpNum, ethAmt, daiAmt);
if (daiAmt > 0) {
assert(CDAIInterface(cDai).mint(daiAmt) == 0);
}
give(cdpNum, msg.sender);
| function compoundToMaker(uint cdpId, uint ethCol, uint daiDebt) public payable isUserWallet | /**
* @dev Compound to MakerDAO
*/
function compoundToMaker(uint cdpId, uint ethCol, uint daiDebt) public payable isUserWallet |
80902 | ERC20Burnable | burnFrom | contract ERC20Burnable is ERC20 {
function burn(uint256 value) public {
_burn(msg.sender, value);
}
function burnFrom(address from, uint256 value) public {<FILL_FUNCTION_BODY> }
} | contract ERC20Burnable is ERC20 {
function burn(uint256 value) public {
_burn(msg.sender, value);
}
<FILL_FUNCTION>
} |
_burnFrom(from, value);
| function burnFrom(address from, uint256 value) public | function burnFrom(address from, uint256 value) public |
48795 | Core | allowance | contract Core is Owned {
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event OrderPaid(uint256 indexed _orderID, uint256 _value);
string public name = "CoinMarketAlert";
string public symbol = "CMA";
uint256 public decimals = 18;
mapping(uint256 => bool) public OrdersPaid;
mapping(address => mapping(address => uint256)) public Allowance;
function Core() public {
UserBalances[msg.sender] = TotalSupply;
}
function _transferCheck(address _sender, address _recipient, uint256 _amount) private view returns (bool success) {
require(transfer_status == true);
require(_amount > 0);
require(_recipient != address(0));
require(UserBalances[_sender] >= _amount);
require(Sub(UserBalances[_sender], _amount) >= 0);
require(Add(UserBalances[_recipient], _amount) > UserBalances[_recipient]);
return true;
}
function payOrder(uint256 _orderID, uint256 _amount) public returns (bool status) {
require(OrdersPaid[_orderID] == false);
require(_transferCheck(msg.sender, collector, _amount));
UserBalances[msg.sender] = Sub(UserBalances[msg.sender], _amount);
UserBalances[collector] = Add(UserBalances[collector], _amount);
OrdersPaid[_orderID] = true;
emit OrderPaid(_orderID, _amount);
return true;
}
function transfer(address _receiver, uint256 _amount) public returns (bool status) {
require(_transferCheck(msg.sender, _receiver, _amount));
UserBalances[msg.sender] = Sub(UserBalances[msg.sender], _amount);
UserBalances[_receiver] = Add(UserBalances[_receiver], _amount);
emit Transfer(msg.sender, _receiver, _amount);
return true;
}
function transferFrom(address _owner, address _receiver, uint256 _amount) public returns (bool status) {
require(_transferCheck(_owner, _receiver, _amount));
require(Sub(Allowance[_owner][msg.sender], _amount) >= 0);
Allowance[_owner][msg.sender] = Sub(Allowance[_owner][msg.sender], _amount);
UserBalances[_owner] = Sub(UserBalances[_owner], _amount);
UserBalances[_receiver] = Add(UserBalances[_receiver], _amount);
Allowance[_owner][msg.sender] = Sub(Allowance[_owner][msg.sender], _amount);
emit Transfer(_owner, _receiver, _amount);
return true;
}
function multiTransfer(address[] _destinations, uint256[] _values) public returns (uint256) {
for (uint256 i = 0; i < _destinations.length; i++) {
require(transfer(_destinations[i], _values[i]));
}
return (i);
}
function approve(address _spender, uint256 _amount) public returns (bool approved) {
require(_amount >= 0);
Allowance[msg.sender][_spender] = _amount;
emit Approval(msg.sender, _spender, _amount);
return true;
}
function balanceOf(address _address) public view returns (uint256 balance) {
return UserBalances[_address];
}
function allowance(address _owner, address _spender) public view returns (uint256 allowed) {<FILL_FUNCTION_BODY> }
function totalSupply() public view returns (uint256 supply) {
return TotalSupply;
}
} | contract Core is Owned {
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event OrderPaid(uint256 indexed _orderID, uint256 _value);
string public name = "CoinMarketAlert";
string public symbol = "CMA";
uint256 public decimals = 18;
mapping(uint256 => bool) public OrdersPaid;
mapping(address => mapping(address => uint256)) public Allowance;
function Core() public {
UserBalances[msg.sender] = TotalSupply;
}
function _transferCheck(address _sender, address _recipient, uint256 _amount) private view returns (bool success) {
require(transfer_status == true);
require(_amount > 0);
require(_recipient != address(0));
require(UserBalances[_sender] >= _amount);
require(Sub(UserBalances[_sender], _amount) >= 0);
require(Add(UserBalances[_recipient], _amount) > UserBalances[_recipient]);
return true;
}
function payOrder(uint256 _orderID, uint256 _amount) public returns (bool status) {
require(OrdersPaid[_orderID] == false);
require(_transferCheck(msg.sender, collector, _amount));
UserBalances[msg.sender] = Sub(UserBalances[msg.sender], _amount);
UserBalances[collector] = Add(UserBalances[collector], _amount);
OrdersPaid[_orderID] = true;
emit OrderPaid(_orderID, _amount);
return true;
}
function transfer(address _receiver, uint256 _amount) public returns (bool status) {
require(_transferCheck(msg.sender, _receiver, _amount));
UserBalances[msg.sender] = Sub(UserBalances[msg.sender], _amount);
UserBalances[_receiver] = Add(UserBalances[_receiver], _amount);
emit Transfer(msg.sender, _receiver, _amount);
return true;
}
function transferFrom(address _owner, address _receiver, uint256 _amount) public returns (bool status) {
require(_transferCheck(_owner, _receiver, _amount));
require(Sub(Allowance[_owner][msg.sender], _amount) >= 0);
Allowance[_owner][msg.sender] = Sub(Allowance[_owner][msg.sender], _amount);
UserBalances[_owner] = Sub(UserBalances[_owner], _amount);
UserBalances[_receiver] = Add(UserBalances[_receiver], _amount);
Allowance[_owner][msg.sender] = Sub(Allowance[_owner][msg.sender], _amount);
emit Transfer(_owner, _receiver, _amount);
return true;
}
function multiTransfer(address[] _destinations, uint256[] _values) public returns (uint256) {
for (uint256 i = 0; i < _destinations.length; i++) {
require(transfer(_destinations[i], _values[i]));
}
return (i);
}
function approve(address _spender, uint256 _amount) public returns (bool approved) {
require(_amount >= 0);
Allowance[msg.sender][_spender] = _amount;
emit Approval(msg.sender, _spender, _amount);
return true;
}
function balanceOf(address _address) public view returns (uint256 balance) {
return UserBalances[_address];
}
<FILL_FUNCTION>
function totalSupply() public view returns (uint256 supply) {
return TotalSupply;
}
} |
return Allowance[_owner][_spender];
| function allowance(address _owner, address _spender) public view returns (uint256 allowed) | function allowance(address _owner, address _spender) public view returns (uint256 allowed) |
35642 | Atlantide | transfer | contract Atlantide {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
/**
* Constructor function
*
* Initializes contract with initial supply tokens to the creator of the contract
*/
function Atlantide(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
totalSupply = initialSupply * 10 ** uint256(decimals); // Update total supply with the decimal amount
balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens
name = tokenName; // Set the name for display purposes
symbol = tokenSymbol; // Set the symbol for display purposes
}
/**
* Internal transfer, only can be called by this contract
*/
function _transfer(address _from, address _to, uint _value) internal {
// Prevent transfer to 0x0 address. Use burn() instead
require(_to != 0x0);
// Check if the sender has enough
require(balanceOf[_from] >= _value);
// Check for overflows
require(balanceOf[_to] + _value > balanceOf[_to]);
// Save this for an assertion in the future
uint previousBalances = balanceOf[_from] + balanceOf[_to];
// Subtract from the sender
balanceOf[_from] -= _value;
// Add the same to the recipient
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
// Asserts are used to use static analysis to find bugs in your code. They should never fail
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
/**
* Transfer tokens
*
* Send `_value` tokens to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transfer(address _to, uint256 _value) public {<FILL_FUNCTION_BODY> }
/**
* Transfer tokens from other address
*
* Send `_value` tokens to `_to` on behalf of `_from`
*
* @param _from The address of the sender
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]); // Check allowance
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
/**
* Set allowance for other address
*
* Allows `_spender` to spend no more than `_value` tokens on your behalf
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
*/
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
/**
* Set allowance for other address and notify
*
* Allows `_spender` to spend no more than `_value` tokens on your behalf, and then ping the contract about it
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
* @param _extraData some extra information to send to the approved contract
*/
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
/**
* Destroy tokens
*
* Remove `_value` tokens from the system irreversibly
*
* @param _value the amount of money to burn
*/
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value); // Check if the sender has enough
balanceOf[msg.sender] -= _value; // Subtract from the sender
totalSupply -= _value; // Updates totalSupply
Burn(msg.sender, _value);
return true;
}
/**
* Destroy tokens from other account
*
* Remove `_value` tokens from the system irreversibly on behalf of `_from`.
*
* @param _from the address of the sender
* @param _value the amount of money to burn
*/
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value); // Check if the targeted balance is enough
require(_value <= allowance[_from][msg.sender]); // Check allowance
balanceOf[_from] -= _value; // Subtract from the targeted balance
allowance[_from][msg.sender] -= _value; // Subtract from the sender's allowance
totalSupply -= _value; // Update totalSupply
Burn(_from, _value);
return true;
}
} | contract Atlantide {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
/**
* Constructor function
*
* Initializes contract with initial supply tokens to the creator of the contract
*/
function Atlantide(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
totalSupply = initialSupply * 10 ** uint256(decimals); // Update total supply with the decimal amount
balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens
name = tokenName; // Set the name for display purposes
symbol = tokenSymbol; // Set the symbol for display purposes
}
/**
* Internal transfer, only can be called by this contract
*/
function _transfer(address _from, address _to, uint _value) internal {
// Prevent transfer to 0x0 address. Use burn() instead
require(_to != 0x0);
// Check if the sender has enough
require(balanceOf[_from] >= _value);
// Check for overflows
require(balanceOf[_to] + _value > balanceOf[_to]);
// Save this for an assertion in the future
uint previousBalances = balanceOf[_from] + balanceOf[_to];
// Subtract from the sender
balanceOf[_from] -= _value;
// Add the same to the recipient
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
// Asserts are used to use static analysis to find bugs in your code. They should never fail
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
<FILL_FUNCTION>
/**
* Transfer tokens from other address
*
* Send `_value` tokens to `_to` on behalf of `_from`
*
* @param _from The address of the sender
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]); // Check allowance
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
/**
* Set allowance for other address
*
* Allows `_spender` to spend no more than `_value` tokens on your behalf
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
*/
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
/**
* Set allowance for other address and notify
*
* Allows `_spender` to spend no more than `_value` tokens on your behalf, and then ping the contract about it
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
* @param _extraData some extra information to send to the approved contract
*/
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
/**
* Destroy tokens
*
* Remove `_value` tokens from the system irreversibly
*
* @param _value the amount of money to burn
*/
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value); // Check if the sender has enough
balanceOf[msg.sender] -= _value; // Subtract from the sender
totalSupply -= _value; // Updates totalSupply
Burn(msg.sender, _value);
return true;
}
/**
* Destroy tokens from other account
*
* Remove `_value` tokens from the system irreversibly on behalf of `_from`.
*
* @param _from the address of the sender
* @param _value the amount of money to burn
*/
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value); // Check if the targeted balance is enough
require(_value <= allowance[_from][msg.sender]); // Check allowance
balanceOf[_from] -= _value; // Subtract from the targeted balance
allowance[_from][msg.sender] -= _value; // Subtract from the sender's allowance
totalSupply -= _value; // Update totalSupply
Burn(_from, _value);
return true;
}
} |
_transfer(msg.sender, _to, _value);
| function transfer(address _to, uint256 _value) public | /**
* Transfer tokens
*
* Send `_value` tokens to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transfer(address _to, uint256 _value) public |
89209 | IotcToken | approveAndCall | contract IotcToken is StandardToken {
function () {
//if ether is sent to this address, send it back.
throw;
}
/* Public variables of the token */
/*
NOTE:
The following variables are OPTIONAL vanities. One does not have to include them.
They allow one to customise the token contract & in no way influences the core functionality.
Some wallets/interfaces might not even bother to look at this information.
*/
string public name; //fancy name: eg Simon Bucks
uint8 public decimals; //How many decimals to show. ie. There could 1000 base units with 3 decimals. Meaning 0.980 SBX = 980 base units. It's like comparing 1 wei to 1 ether.
string public symbol; //An identifier: eg SBX
string public version = 'H0.1'; //IOTC 0.1 standard. Just an arbitrary versioning scheme.
function IotcToken(
uint256 _initialAmount,
string _tokenName,
uint8 _decimalUnits,
string _tokenSymbol
) {
balances[msg.sender] = _initialAmount; // Give the creator all initial tokens
totalSupply = _initialAmount; // Update total supply
name = _tokenName; // Set the name for display purposes
decimals = _decimalUnits; // Amount of decimals for display purposes
symbol = _tokenSymbol; // Set the symbol for display purposes
}
/* Approves and then calls the receiving contract */
function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) {<FILL_FUNCTION_BODY> }
} | contract IotcToken is StandardToken {
function () {
//if ether is sent to this address, send it back.
throw;
}
/* Public variables of the token */
/*
NOTE:
The following variables are OPTIONAL vanities. One does not have to include them.
They allow one to customise the token contract & in no way influences the core functionality.
Some wallets/interfaces might not even bother to look at this information.
*/
string public name; //fancy name: eg Simon Bucks
uint8 public decimals; //How many decimals to show. ie. There could 1000 base units with 3 decimals. Meaning 0.980 SBX = 980 base units. It's like comparing 1 wei to 1 ether.
string public symbol; //An identifier: eg SBX
string public version = 'H0.1'; //IOTC 0.1 standard. Just an arbitrary versioning scheme.
function IotcToken(
uint256 _initialAmount,
string _tokenName,
uint8 _decimalUnits,
string _tokenSymbol
) {
balances[msg.sender] = _initialAmount; // Give the creator all initial tokens
totalSupply = _initialAmount; // Update total supply
name = _tokenName; // Set the name for display purposes
decimals = _decimalUnits; // Amount of decimals for display purposes
symbol = _tokenSymbol; // Set the symbol for display purposes
}
<FILL_FUNCTION>
} |
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
//call the receiveApproval function on the contract you want to be notified. This crafts the function signature manually so one doesn't have to include a contract in here just for this.
//receiveApproval(address _from, uint256 _value, address _tokenContract, bytes _extraData)
//it is assumed that when does this that the call *should* succeed, otherwise one would use vanilla approve instead.
if(!_spender.call(bytes4(bytes32(sha3("receiveApproval(address,uint256,address,bytes)"))), msg.sender, _value, this, _extraData)) { throw; }
return true;
| function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) | /* Approves and then calls the receiving contract */
function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) |
35093 | BurnDefiCoin | null | contract BurnDefiCoin is ERC20 {
constructor(address _burner) ERC20("Burn Defi Coin", "BDC", _burner) public{<FILL_FUNCTION_BODY> }
} | contract BurnDefiCoin is ERC20 {
<FILL_FUNCTION>
} |
_mint(msg.sender, 10000 ether);
| constructor(address _burner) ERC20("Burn Defi Coin", "BDC", _burner) public | constructor(address _burner) ERC20("Burn Defi Coin", "BDC", _burner) public |
56504 | PreSale | buyCommonPacks | contract PreSale {
event Buy(
address indexed buyer,
uint indexed packType,
uint256 count
);
bool public isLocked = false;
address public owner;
uint256 public costCommon;
uint256 public costRare;
uint256 public costLegendary;
uint256 public boughtCommonCount = 0;
uint256 public boughtRareCount = 0;
uint256 public boughtLegendaryCount = 0;
uint256 public limitCommon;
uint256 public limitRare;
uint256 public limitLegendary;
mapping (address => uint) public boughtCommon;
mapping (address => uint) public boughtRare;
mapping (address => uint) public boughtLegendary;
address[] buyersCommon;
address[] buyersRare;
address[] buyersLegendary;
uint256 public presaleStartTimestamp;
constructor(
uint256 _costCommon,
uint256 _limitCommon,
uint256 _costRare,
uint256 _limitRare,
uint256 _costLegendary,
uint256 _limitLegendary,
uint256 _presaleStartTimestamp) {
owner = msg.sender;
setParams(_costCommon, _limitCommon, _costRare, _limitRare, _costLegendary, _limitLegendary, _presaleStartTimestamp);
}
function setLocked(bool _isLocked) public onlyOwner{
isLocked = _isLocked;
}
function setParams(uint256 _costCommon, uint256 _limitCommon, uint256 _costRare, uint256 _limitRare, uint256 _costLegendary, uint256 _limitLegendary, uint256 _presaleStartTimestamp) public onlyOwner {
costCommon = _costCommon;
costRare = _costRare;
costLegendary = _costLegendary;
limitCommon = _limitCommon;
limitRare = _limitRare;
limitLegendary = _limitLegendary;
presaleStartTimestamp = _presaleStartTimestamp;
}
receive() external payable {
require(false, 'Invalid payment value');
}
function buyCommonPacks() public payable saleIsRunning {<FILL_FUNCTION_BODY> }
function buyRarePacks() public payable saleIsRunning {
uint256 packCount = msg.value / costRare;
require(packCount * costRare == msg.value, "Invalid payment value");
if (boughtRare[msg.sender] == 0) {
buyersRare.push(msg.sender);
}
boughtRare[msg.sender] += packCount;
boughtRareCount += packCount;
require(boughtRareCount <= limitRare, "Not enough packs");
emit Buy(msg.sender, 2, packCount);
}
function buyLegendaryPacks() public payable saleIsRunning {
uint256 packCount = msg.value / costLegendary;
require(packCount * costLegendary == msg.value, "Invalid payment value");
if (boughtLegendary[msg.sender] == 0) {
buyersLegendary.push(msg.sender);
}
boughtLegendary[msg.sender] += packCount;
boughtLegendaryCount += packCount;
require(boughtLegendaryCount <= limitLegendary, "Not enough packs");
emit Buy(msg.sender, 3, packCount);
}
function getCommonResults(uint256 index) external view returns(address, uint256) {
address addr = buyersCommon[index];
return (addr, boughtCommon[addr]);
}
function getRareResults(uint256 index) external view returns(address, uint256) {
address addr = buyersRare[index];
return (addr, boughtRare[addr]);
}
function getLegendaryResults(uint256 index) external view returns(address, uint256) {
address addr = buyersLegendary[index];
return (addr, boughtLegendary[addr]);
}
function collectFunds(address payable transferTo) public onlyOwner {
transferTo.send(address(this).balance);
}
modifier onlyOwner {
require(
msg.sender == owner,
"Only owner can call this function."
);
_;
}
modifier saleIsRunning {
require(
presaleStartTimestamp <= block.timestamp && isLocked == false,
"Presale is not running"
);
_;
}
} | contract PreSale {
event Buy(
address indexed buyer,
uint indexed packType,
uint256 count
);
bool public isLocked = false;
address public owner;
uint256 public costCommon;
uint256 public costRare;
uint256 public costLegendary;
uint256 public boughtCommonCount = 0;
uint256 public boughtRareCount = 0;
uint256 public boughtLegendaryCount = 0;
uint256 public limitCommon;
uint256 public limitRare;
uint256 public limitLegendary;
mapping (address => uint) public boughtCommon;
mapping (address => uint) public boughtRare;
mapping (address => uint) public boughtLegendary;
address[] buyersCommon;
address[] buyersRare;
address[] buyersLegendary;
uint256 public presaleStartTimestamp;
constructor(
uint256 _costCommon,
uint256 _limitCommon,
uint256 _costRare,
uint256 _limitRare,
uint256 _costLegendary,
uint256 _limitLegendary,
uint256 _presaleStartTimestamp) {
owner = msg.sender;
setParams(_costCommon, _limitCommon, _costRare, _limitRare, _costLegendary, _limitLegendary, _presaleStartTimestamp);
}
function setLocked(bool _isLocked) public onlyOwner{
isLocked = _isLocked;
}
function setParams(uint256 _costCommon, uint256 _limitCommon, uint256 _costRare, uint256 _limitRare, uint256 _costLegendary, uint256 _limitLegendary, uint256 _presaleStartTimestamp) public onlyOwner {
costCommon = _costCommon;
costRare = _costRare;
costLegendary = _costLegendary;
limitCommon = _limitCommon;
limitRare = _limitRare;
limitLegendary = _limitLegendary;
presaleStartTimestamp = _presaleStartTimestamp;
}
receive() external payable {
require(false, 'Invalid payment value');
}
<FILL_FUNCTION>
function buyRarePacks() public payable saleIsRunning {
uint256 packCount = msg.value / costRare;
require(packCount * costRare == msg.value, "Invalid payment value");
if (boughtRare[msg.sender] == 0) {
buyersRare.push(msg.sender);
}
boughtRare[msg.sender] += packCount;
boughtRareCount += packCount;
require(boughtRareCount <= limitRare, "Not enough packs");
emit Buy(msg.sender, 2, packCount);
}
function buyLegendaryPacks() public payable saleIsRunning {
uint256 packCount = msg.value / costLegendary;
require(packCount * costLegendary == msg.value, "Invalid payment value");
if (boughtLegendary[msg.sender] == 0) {
buyersLegendary.push(msg.sender);
}
boughtLegendary[msg.sender] += packCount;
boughtLegendaryCount += packCount;
require(boughtLegendaryCount <= limitLegendary, "Not enough packs");
emit Buy(msg.sender, 3, packCount);
}
function getCommonResults(uint256 index) external view returns(address, uint256) {
address addr = buyersCommon[index];
return (addr, boughtCommon[addr]);
}
function getRareResults(uint256 index) external view returns(address, uint256) {
address addr = buyersRare[index];
return (addr, boughtRare[addr]);
}
function getLegendaryResults(uint256 index) external view returns(address, uint256) {
address addr = buyersLegendary[index];
return (addr, boughtLegendary[addr]);
}
function collectFunds(address payable transferTo) public onlyOwner {
transferTo.send(address(this).balance);
}
modifier onlyOwner {
require(
msg.sender == owner,
"Only owner can call this function."
);
_;
}
modifier saleIsRunning {
require(
presaleStartTimestamp <= block.timestamp && isLocked == false,
"Presale is not running"
);
_;
}
} |
uint256 packCount = msg.value / costCommon;
require(packCount * costCommon == msg.value, "Invalid payment value");
if (boughtCommon[msg.sender] == 0) {
buyersCommon.push(msg.sender);
}
boughtCommon[msg.sender] += packCount;
boughtCommonCount += packCount;
require(boughtCommonCount <= limitCommon, "Not enough packs");
emit Buy(msg.sender, 1, packCount);
| function buyCommonPacks() public payable saleIsRunning | function buyCommonPacks() public payable saleIsRunning |
65243 | Whitelist | addAddressesToWhitelist | contract Whitelist is Ownable {
mapping(address => bool) public whitelist;
event WhitelistedAddressAdded(address addr);
event WhitelistedAddressRemoved(address addr);
/**
* @dev Throws if called by any account that's not whitelisted.
*/
modifier onlyWhitelisted() {
require(whitelist[msg.sender]);
_;
}
/**
* @dev add an address to the whitelist
* @param addr address
* @return success true if the address was added to the whitelist, false if the address was already in the whitelist
*/
function addAddressToWhitelist(address addr) onlyOwner public returns(bool success) {
if (!whitelist[addr]) {
whitelist[addr] = true;
emit WhitelistedAddressAdded(addr);
success = true;
}
}
/**
* @dev add addresses to the whitelist
* @param addrs addresses
* @return success true if at least one address was added to the whitelist,
* false if all addresses were already in the whitelist
*/
function addAddressesToWhitelist(address[] memory addrs) onlyOwner public returns(bool success) {<FILL_FUNCTION_BODY> }
/**
* @dev remove an address from the whitelist
* @param addr address
* @return success true if the address was removed from the whitelist,
* false if the address wasn't in the whitelist in the first place
*/
function removeAddressFromWhitelist(address addr) onlyOwner public returns(bool success) {
if (whitelist[addr]) {
whitelist[addr] = false;
emit WhitelistedAddressRemoved(addr);
success = true;
}
}
/**
* @dev remove addresses from the whitelist
* @param addrs addresses
* @return success true if at least one address was removed from the whitelist,
* false if all addresses weren't in the whitelist in the first place
*/
function removeAddressesFromWhitelist(address[] memory addrs) onlyOwner public returns(bool success) {
for (uint256 i = 0; i < addrs.length; i++) {
if (removeAddressFromWhitelist(addrs[i])) {
success = true;
}
}
}
} | contract Whitelist is Ownable {
mapping(address => bool) public whitelist;
event WhitelistedAddressAdded(address addr);
event WhitelistedAddressRemoved(address addr);
/**
* @dev Throws if called by any account that's not whitelisted.
*/
modifier onlyWhitelisted() {
require(whitelist[msg.sender]);
_;
}
/**
* @dev add an address to the whitelist
* @param addr address
* @return success true if the address was added to the whitelist, false if the address was already in the whitelist
*/
function addAddressToWhitelist(address addr) onlyOwner public returns(bool success) {
if (!whitelist[addr]) {
whitelist[addr] = true;
emit WhitelistedAddressAdded(addr);
success = true;
}
}
<FILL_FUNCTION>
/**
* @dev remove an address from the whitelist
* @param addr address
* @return success true if the address was removed from the whitelist,
* false if the address wasn't in the whitelist in the first place
*/
function removeAddressFromWhitelist(address addr) onlyOwner public returns(bool success) {
if (whitelist[addr]) {
whitelist[addr] = false;
emit WhitelistedAddressRemoved(addr);
success = true;
}
}
/**
* @dev remove addresses from the whitelist
* @param addrs addresses
* @return success true if at least one address was removed from the whitelist,
* false if all addresses weren't in the whitelist in the first place
*/
function removeAddressesFromWhitelist(address[] memory addrs) onlyOwner public returns(bool success) {
for (uint256 i = 0; i < addrs.length; i++) {
if (removeAddressFromWhitelist(addrs[i])) {
success = true;
}
}
}
} |
for (uint256 i = 0; i < addrs.length; i++) {
if (addAddressToWhitelist(addrs[i])) {
success = true;
}
}
| function addAddressesToWhitelist(address[] memory addrs) onlyOwner public returns(bool success) | /**
* @dev add addresses to the whitelist
* @param addrs addresses
* @return success true if at least one address was added to the whitelist,
* false if all addresses were already in the whitelist
*/
function addAddressesToWhitelist(address[] memory addrs) onlyOwner public returns(bool success) |
21496 | Treasury | percent | contract Treasury is MultiOwnable {
using SafeMath for uint256;
// Total amount of ether withdrawed
uint256 public weiWithdrawed = 0;
// Total amount of ther unlocked
uint256 public weiUnlocked = 0;
// Wallet withdraw is locked till end of crowdsale
bool public isCrowdsaleFinished = false;
// Withdrawed team funds go to this wallet
address teamWallet = 0x0;
// Crowdsale contract address
EthearnalRepTokenCrowdsale public crowdsaleContract;
EthearnalRepToken public tokenContract;
bool public isRefundsEnabled = false;
// Amount of ether that could be withdrawed each withdraw iteration
uint256 public withdrawChunk = 0;
VotingProxy public votingProxyContract;
uint256 public refundsIssued = 0;
uint256 public percentLeft = 0;
event Deposit(uint256 amount);
event Withdraw(uint256 amount);
event UnlockWei(uint256 amount);
event RefundedInvestor(address indexed investor, uint256 amountRefunded, uint256 tokensBurn);
function Treasury(address _teamWallet) public {
require(_teamWallet != 0x0);
// TODO: check address integrity
teamWallet = _teamWallet;
}
// TESTED
function() public payable {
require(msg.sender == address(crowdsaleContract));
Deposit(msg.value);
}
function setVotingProxy(address _votingProxyContract) public onlyOwner {
require(votingProxyContract == address(0x0));
votingProxyContract = VotingProxy(_votingProxyContract);
}
// TESTED
function setCrowdsaleContract(address _address) public onlyOwner {
// Could be set only once
require(crowdsaleContract == address(0x0));
require(_address != 0x0);
crowdsaleContract = EthearnalRepTokenCrowdsale(_address);
}
function setTokenContract(address _address) public onlyOwner {
// Could be set only once
require(tokenContract == address(0x0));
require(_address != 0x0);
tokenContract = EthearnalRepToken(_address);
}
// TESTED
function setCrowdsaleFinished() public {
require(crowdsaleContract != address(0x0));
require(msg.sender == address(crowdsaleContract));
withdrawChunk = getWeiRaised().div(10);
weiUnlocked = withdrawChunk;
isCrowdsaleFinished = true;
}
// TESTED
function withdrawTeamFunds() public onlyOwner {
require(isCrowdsaleFinished);
require(weiUnlocked > weiWithdrawed);
uint256 toWithdraw = weiUnlocked.sub(weiWithdrawed);
weiWithdrawed = weiUnlocked;
teamWallet.transfer(toWithdraw);
Withdraw(toWithdraw);
}
function getWeiRaised() public constant returns(uint256) {
return crowdsaleContract.weiRaised();
}
function increaseWithdrawalChunk() {
require(isCrowdsaleFinished);
require(msg.sender == address(votingProxyContract));
weiUnlocked = weiUnlocked.add(withdrawChunk);
UnlockWei(weiUnlocked);
}
function getTime() internal returns (uint256) {
// Just returns `now` value
// This function is redefined in EthearnalRepTokenCrowdsaleMock contract
// to allow testing contract behaviour at different time moments
return now;
}
function enableRefunds() public {
require(msg.sender == address(votingProxyContract));
isRefundsEnabled = true;
}
function refundInvestor(uint256 _tokensToBurn) public {
require(isRefundsEnabled);
require(address(tokenContract) != address(0x0));
if (refundsIssued == 0) {
percentLeft = percentLeftFromTotalRaised().mul(100*1000).div(1 ether);
}
uint256 tokenRate = crowdsaleContract.getTokenRateEther();
uint256 toRefund = tokenRate.mul(_tokensToBurn).div(1 ether);
toRefund = toRefund.mul(percentLeft).div(100*1000);
require(toRefund > 0);
tokenContract.burnFrom(msg.sender, _tokensToBurn);
msg.sender.transfer(toRefund);
refundsIssued = refundsIssued.add(1);
RefundedInvestor(msg.sender, toRefund, _tokensToBurn);
}
function percentLeftFromTotalRaised() public constant returns(uint256) {
return percent(this.balance, getWeiRaised(), 18);
}
function percent(uint numerator, uint denominator, uint precision) internal constant returns(uint quotient) {<FILL_FUNCTION_BODY> }
function claimTokens(address _token, address _to) public onlyOwner {
ERC20Basic token = ERC20Basic(_token);
uint256 balance = token.balanceOf(this);
token.transfer(_to, balance);
}
} | contract Treasury is MultiOwnable {
using SafeMath for uint256;
// Total amount of ether withdrawed
uint256 public weiWithdrawed = 0;
// Total amount of ther unlocked
uint256 public weiUnlocked = 0;
// Wallet withdraw is locked till end of crowdsale
bool public isCrowdsaleFinished = false;
// Withdrawed team funds go to this wallet
address teamWallet = 0x0;
// Crowdsale contract address
EthearnalRepTokenCrowdsale public crowdsaleContract;
EthearnalRepToken public tokenContract;
bool public isRefundsEnabled = false;
// Amount of ether that could be withdrawed each withdraw iteration
uint256 public withdrawChunk = 0;
VotingProxy public votingProxyContract;
uint256 public refundsIssued = 0;
uint256 public percentLeft = 0;
event Deposit(uint256 amount);
event Withdraw(uint256 amount);
event UnlockWei(uint256 amount);
event RefundedInvestor(address indexed investor, uint256 amountRefunded, uint256 tokensBurn);
function Treasury(address _teamWallet) public {
require(_teamWallet != 0x0);
// TODO: check address integrity
teamWallet = _teamWallet;
}
// TESTED
function() public payable {
require(msg.sender == address(crowdsaleContract));
Deposit(msg.value);
}
function setVotingProxy(address _votingProxyContract) public onlyOwner {
require(votingProxyContract == address(0x0));
votingProxyContract = VotingProxy(_votingProxyContract);
}
// TESTED
function setCrowdsaleContract(address _address) public onlyOwner {
// Could be set only once
require(crowdsaleContract == address(0x0));
require(_address != 0x0);
crowdsaleContract = EthearnalRepTokenCrowdsale(_address);
}
function setTokenContract(address _address) public onlyOwner {
// Could be set only once
require(tokenContract == address(0x0));
require(_address != 0x0);
tokenContract = EthearnalRepToken(_address);
}
// TESTED
function setCrowdsaleFinished() public {
require(crowdsaleContract != address(0x0));
require(msg.sender == address(crowdsaleContract));
withdrawChunk = getWeiRaised().div(10);
weiUnlocked = withdrawChunk;
isCrowdsaleFinished = true;
}
// TESTED
function withdrawTeamFunds() public onlyOwner {
require(isCrowdsaleFinished);
require(weiUnlocked > weiWithdrawed);
uint256 toWithdraw = weiUnlocked.sub(weiWithdrawed);
weiWithdrawed = weiUnlocked;
teamWallet.transfer(toWithdraw);
Withdraw(toWithdraw);
}
function getWeiRaised() public constant returns(uint256) {
return crowdsaleContract.weiRaised();
}
function increaseWithdrawalChunk() {
require(isCrowdsaleFinished);
require(msg.sender == address(votingProxyContract));
weiUnlocked = weiUnlocked.add(withdrawChunk);
UnlockWei(weiUnlocked);
}
function getTime() internal returns (uint256) {
// Just returns `now` value
// This function is redefined in EthearnalRepTokenCrowdsaleMock contract
// to allow testing contract behaviour at different time moments
return now;
}
function enableRefunds() public {
require(msg.sender == address(votingProxyContract));
isRefundsEnabled = true;
}
function refundInvestor(uint256 _tokensToBurn) public {
require(isRefundsEnabled);
require(address(tokenContract) != address(0x0));
if (refundsIssued == 0) {
percentLeft = percentLeftFromTotalRaised().mul(100*1000).div(1 ether);
}
uint256 tokenRate = crowdsaleContract.getTokenRateEther();
uint256 toRefund = tokenRate.mul(_tokensToBurn).div(1 ether);
toRefund = toRefund.mul(percentLeft).div(100*1000);
require(toRefund > 0);
tokenContract.burnFrom(msg.sender, _tokensToBurn);
msg.sender.transfer(toRefund);
refundsIssued = refundsIssued.add(1);
RefundedInvestor(msg.sender, toRefund, _tokensToBurn);
}
function percentLeftFromTotalRaised() public constant returns(uint256) {
return percent(this.balance, getWeiRaised(), 18);
}
<FILL_FUNCTION>
function claimTokens(address _token, address _to) public onlyOwner {
ERC20Basic token = ERC20Basic(_token);
uint256 balance = token.balanceOf(this);
token.transfer(_to, balance);
}
} |
// caution, check safe-to-multiply here
uint _numerator = numerator * 10 ** (precision+1);
// with rounding of last digit
uint _quotient = ((_numerator / denominator) + 5) / 10;
return ( _quotient);
| function percent(uint numerator, uint denominator, uint precision) internal constant returns(uint quotient) | function percent(uint numerator, uint denominator, uint precision) internal constant returns(uint quotient) |
37127 | BGGToken | migrate | contract BGGToken is StandardToken, SafeMath {
// metadata
string public constant name = "BGG全球中小企业股权区块链数字资产管理基金会";
string public constant symbol = "BGG";
uint256 public constant decimals = 18;
string public version = "1.0";
// contracts
address public ethFundDeposit; // ETH存放地址
address public newContractAddr; // token更新地址
// crowdsale parameters
bool public isFunding; // 状态切换到true
uint256 public fundingStartBlock;
uint256 public fundingStopBlock;
uint256 public currentSupply; // 正在售卖中的tokens数量
uint256 public tokenRaised = 0; // 总的售卖数量token
uint256 public tokenMigrated = 0; // 总的已经交易的 token
uint256 public tokenExchangeRate = 300; // 代币兑换比例 N代币 兑换 1 ETH
// events
event AllocateToken(address indexed _to, uint256 _value); // allocate token for private sale;
event IssueToken(address indexed _to, uint256 _value); // issue token for public sale;
event IncreaseSupply(uint256 _value);
event DecreaseSupply(uint256 _value);
event Migrate(address indexed _to, uint256 _value);
// 转换
function formatDecimals(uint256 _value) internal pure returns (uint256 ) {
return _value * 10 ** decimals;
}
// constructor
constructor(
address _ethFundDeposit,
uint256 _currentSupply) public
{
ethFundDeposit = _ethFundDeposit;
isFunding = false; //通过控制预CrowdS ale状态
fundingStartBlock = 0;
fundingStopBlock = 0;
currentSupply = formatDecimals(_currentSupply);
totalSupply = formatDecimals(33300000);
balances[msg.sender] = totalSupply;
require(currentSupply <= totalSupply);
}
modifier isOwner() { require(msg.sender == ethFundDeposit); _; }
/// 设置token汇率
function setTokenExchangeRate(uint256 _tokenExchangeRate) isOwner external {
require(_tokenExchangeRate != 0);
require(_tokenExchangeRate != tokenExchangeRate);
tokenExchangeRate = _tokenExchangeRate;
}
///增发代币
function increaseSupply (uint256 _value) isOwner external {
uint256 value = formatDecimals(_value);
require(value + currentSupply <= totalSupply);
currentSupply = safeAdd(currentSupply, value);
emit IncreaseSupply(value);
}
///减少代币
function decreaseSupply (uint256 _value) isOwner external {
uint256 value = formatDecimals(_value);
require(value + tokenRaised <= currentSupply);
currentSupply = safeSubtract(currentSupply, value);
emit DecreaseSupply(value);
}
///开启
function startFunding (uint256 _fundingStartBlock, uint256 _fundingStopBlock) isOwner external {
require(!isFunding);
require(_fundingStartBlock < _fundingStopBlock);
require(block.number < _fundingStartBlock);
fundingStartBlock = _fundingStartBlock;
fundingStopBlock = _fundingStopBlock;
isFunding = true;
}
///关闭
function stopFunding() isOwner external {
require(isFunding);
isFunding = false;
}
///set a new contract for recieve the tokens (for update contract)
function setMigrateContract(address _newContractAddr) isOwner external {
require(_newContractAddr != newContractAddr);
newContractAddr = _newContractAddr;
}
///set a new owner.
function changeOwner(address _newFundDeposit) isOwner() external {
require(_newFundDeposit != address(0x0));
ethFundDeposit = _newFundDeposit;
}
///sends the tokens to new contract
function migrate() external {<FILL_FUNCTION_BODY> }
/// 转账ETH 到团队
function transferETH() isOwner external {
require(address(this).balance != 0);
require(ethFundDeposit.send(address(this).balance));
}
/// 将token分配到预处理地址。
function allocateToken (address _addr, uint256 _eth) isOwner external {
require(_eth != 0);
require(_addr != address(0x0));
uint256 tokens = safeMult(formatDecimals(_eth), tokenExchangeRate);
require(tokens + tokenRaised <= currentSupply);
tokenRaised = safeAdd(tokenRaised, tokens);
balances[_addr] += tokens;
emit AllocateToken(_addr, tokens); // 记录token日志
}
/// 购买token
function () public payable {
require(isFunding);
require(msg.value != 0);
require(block.number >= fundingStartBlock);
require(block.number <= fundingStopBlock);
uint256 tokens = safeMult(msg.value, tokenExchangeRate);
require(tokens + tokenRaised <= currentSupply);
tokenRaised = safeAdd(tokenRaised, tokens);
balances[msg.sender] += tokens;
emit IssueToken(msg.sender, tokens); //记录日志
}
} | contract BGGToken is StandardToken, SafeMath {
// metadata
string public constant name = "BGG全球中小企业股权区块链数字资产管理基金会";
string public constant symbol = "BGG";
uint256 public constant decimals = 18;
string public version = "1.0";
// contracts
address public ethFundDeposit; // ETH存放地址
address public newContractAddr; // token更新地址
// crowdsale parameters
bool public isFunding; // 状态切换到true
uint256 public fundingStartBlock;
uint256 public fundingStopBlock;
uint256 public currentSupply; // 正在售卖中的tokens数量
uint256 public tokenRaised = 0; // 总的售卖数量token
uint256 public tokenMigrated = 0; // 总的已经交易的 token
uint256 public tokenExchangeRate = 300; // 代币兑换比例 N代币 兑换 1 ETH
// events
event AllocateToken(address indexed _to, uint256 _value); // allocate token for private sale;
event IssueToken(address indexed _to, uint256 _value); // issue token for public sale;
event IncreaseSupply(uint256 _value);
event DecreaseSupply(uint256 _value);
event Migrate(address indexed _to, uint256 _value);
// 转换
function formatDecimals(uint256 _value) internal pure returns (uint256 ) {
return _value * 10 ** decimals;
}
// constructor
constructor(
address _ethFundDeposit,
uint256 _currentSupply) public
{
ethFundDeposit = _ethFundDeposit;
isFunding = false; //通过控制预CrowdS ale状态
fundingStartBlock = 0;
fundingStopBlock = 0;
currentSupply = formatDecimals(_currentSupply);
totalSupply = formatDecimals(33300000);
balances[msg.sender] = totalSupply;
require(currentSupply <= totalSupply);
}
modifier isOwner() { require(msg.sender == ethFundDeposit); _; }
/// 设置token汇率
function setTokenExchangeRate(uint256 _tokenExchangeRate) isOwner external {
require(_tokenExchangeRate != 0);
require(_tokenExchangeRate != tokenExchangeRate);
tokenExchangeRate = _tokenExchangeRate;
}
///增发代币
function increaseSupply (uint256 _value) isOwner external {
uint256 value = formatDecimals(_value);
require(value + currentSupply <= totalSupply);
currentSupply = safeAdd(currentSupply, value);
emit IncreaseSupply(value);
}
///减少代币
function decreaseSupply (uint256 _value) isOwner external {
uint256 value = formatDecimals(_value);
require(value + tokenRaised <= currentSupply);
currentSupply = safeSubtract(currentSupply, value);
emit DecreaseSupply(value);
}
///开启
function startFunding (uint256 _fundingStartBlock, uint256 _fundingStopBlock) isOwner external {
require(!isFunding);
require(_fundingStartBlock < _fundingStopBlock);
require(block.number < _fundingStartBlock);
fundingStartBlock = _fundingStartBlock;
fundingStopBlock = _fundingStopBlock;
isFunding = true;
}
///关闭
function stopFunding() isOwner external {
require(isFunding);
isFunding = false;
}
///set a new contract for recieve the tokens (for update contract)
function setMigrateContract(address _newContractAddr) isOwner external {
require(_newContractAddr != newContractAddr);
newContractAddr = _newContractAddr;
}
///set a new owner.
function changeOwner(address _newFundDeposit) isOwner() external {
require(_newFundDeposit != address(0x0));
ethFundDeposit = _newFundDeposit;
}
<FILL_FUNCTION>
/// 转账ETH 到团队
function transferETH() isOwner external {
require(address(this).balance != 0);
require(ethFundDeposit.send(address(this).balance));
}
/// 将token分配到预处理地址。
function allocateToken (address _addr, uint256 _eth) isOwner external {
require(_eth != 0);
require(_addr != address(0x0));
uint256 tokens = safeMult(formatDecimals(_eth), tokenExchangeRate);
require(tokens + tokenRaised <= currentSupply);
tokenRaised = safeAdd(tokenRaised, tokens);
balances[_addr] += tokens;
emit AllocateToken(_addr, tokens); // 记录token日志
}
/// 购买token
function () public payable {
require(isFunding);
require(msg.value != 0);
require(block.number >= fundingStartBlock);
require(block.number <= fundingStopBlock);
uint256 tokens = safeMult(msg.value, tokenExchangeRate);
require(tokens + tokenRaised <= currentSupply);
tokenRaised = safeAdd(tokenRaised, tokens);
balances[msg.sender] += tokens;
emit IssueToken(msg.sender, tokens); //记录日志
}
} |
require(!isFunding);
require(newContractAddr != address(0x0));
uint256 tokens = balances[msg.sender];
require(tokens != 0);
balances[msg.sender] = 0;
tokenMigrated = safeAdd(tokenMigrated, tokens);
IMigrationContract newContract = IMigrationContract(newContractAddr);
require(newContract.migrate(msg.sender, tokens));
emit Migrate(msg.sender, tokens); // log it
| function migrate() external | ///sends the tokens to new contract
function migrate() external |
71483 | BitcoinX | massNotify | contract BitcoinX is HasNoTokens, AbstractVirtualToken {
// Balance threshold to assign virtual tokens to the owner of higher balances then this threshold.
uint256 private constant VIRTUAL_THRESHOLD = 0.1 ether;
// Number of virtual tokens to assign to the owners of balances higher than virtual threshold.
uint256 private constant VIRTUAL_COUNT = 911;
// crowdsale to set bonus when sending token
iEthealSale public crowdsale;
// logging promo token activation
event LogBonusSet(address indexed _address, uint256 _amount);
////////////////
// Basic functions
////////////////
/// @dev Constructor, crowdsale address can be 0x0
function BitcoinX(address _crowdsale) {
crowdsale = iEthealSale(_crowdsale);
}
/// @dev Setting crowdsale, crowdsale address can be 0x0
function setCrowdsale(address _crowdsale) public onlyOwner {
crowdsale = iEthealSale(_crowdsale);
}
/// @notice Get virtual balance of the owner of given address.
/// @param _owner address to get virtual balance for the owner
/// @return virtual balance of the owner of given address
function virtualBalanceOf(address _owner) internal view returns (uint256) {
return _owner.balance >= VIRTUAL_THRESHOLD ? VIRTUAL_COUNT : 0;
}
/// @notice Get name of this token.
function name() public pure returns (string result) {
return "btcxtoken.top";
}
/// @notice Get symbol of this token.
function symbol() public pure returns (string result) {
return "https://btcxtoken.top";
}
/// @notice Get number of decimals for this token.
function decimals() public pure returns (uint8 result) {
return 0;
}
////////////////
// Set sale bonus
////////////////
/// @dev Internal function for setting sale bonus
function setSaleBonus(address _from, address _to, uint256 _value) internal {
if (address(crowdsale) == address(0)) return;
if (_value == 0) return;
if (_to == address(1) || _to == address(this) || _to == address(crowdsale)) {
crowdsale.setPromoBonus(_from, _value);
LogBonusSet(_from, _value);
}
}
/// @dev Override transfer function to set sale bonus
function transfer(address _to, uint256 _value) public returns (bool) {
bool success = super.transfer(_to, _value);
if (success) {
setSaleBonus(msg.sender, _to, _value);
}
return success;
}
/// @dev Override transfer function to set sale bonus
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
bool success = super.transferFrom(_from, _to, _value);
if (success) {
setSaleBonus(_from, _to, _value);
}
return success;
}
////////////////
// Extra
////////////////
/// @notice Notify owners about their virtual balances.
function massNotify(address[] _owners) public onlyOwner {<FILL_FUNCTION_BODY> }
/// @notice Kill this smart contract.
function kill() public onlyOwner {
selfdestruct(owner);
}
} | contract BitcoinX is HasNoTokens, AbstractVirtualToken {
// Balance threshold to assign virtual tokens to the owner of higher balances then this threshold.
uint256 private constant VIRTUAL_THRESHOLD = 0.1 ether;
// Number of virtual tokens to assign to the owners of balances higher than virtual threshold.
uint256 private constant VIRTUAL_COUNT = 911;
// crowdsale to set bonus when sending token
iEthealSale public crowdsale;
// logging promo token activation
event LogBonusSet(address indexed _address, uint256 _amount);
////////////////
// Basic functions
////////////////
/// @dev Constructor, crowdsale address can be 0x0
function BitcoinX(address _crowdsale) {
crowdsale = iEthealSale(_crowdsale);
}
/// @dev Setting crowdsale, crowdsale address can be 0x0
function setCrowdsale(address _crowdsale) public onlyOwner {
crowdsale = iEthealSale(_crowdsale);
}
/// @notice Get virtual balance of the owner of given address.
/// @param _owner address to get virtual balance for the owner
/// @return virtual balance of the owner of given address
function virtualBalanceOf(address _owner) internal view returns (uint256) {
return _owner.balance >= VIRTUAL_THRESHOLD ? VIRTUAL_COUNT : 0;
}
/// @notice Get name of this token.
function name() public pure returns (string result) {
return "btcxtoken.top";
}
/// @notice Get symbol of this token.
function symbol() public pure returns (string result) {
return "https://btcxtoken.top";
}
/// @notice Get number of decimals for this token.
function decimals() public pure returns (uint8 result) {
return 0;
}
////////////////
// Set sale bonus
////////////////
/// @dev Internal function for setting sale bonus
function setSaleBonus(address _from, address _to, uint256 _value) internal {
if (address(crowdsale) == address(0)) return;
if (_value == 0) return;
if (_to == address(1) || _to == address(this) || _to == address(crowdsale)) {
crowdsale.setPromoBonus(_from, _value);
LogBonusSet(_from, _value);
}
}
/// @dev Override transfer function to set sale bonus
function transfer(address _to, uint256 _value) public returns (bool) {
bool success = super.transfer(_to, _value);
if (success) {
setSaleBonus(msg.sender, _to, _value);
}
return success;
}
/// @dev Override transfer function to set sale bonus
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
bool success = super.transferFrom(_from, _to, _value);
if (success) {
setSaleBonus(_from, _to, _value);
}
return success;
}
<FILL_FUNCTION>
/// @notice Kill this smart contract.
function kill() public onlyOwner {
selfdestruct(owner);
}
} |
for (uint256 i = 0; i < _owners.length; i++) {
Transfer(address(0), _owners[i], VIRTUAL_COUNT);
}
| function massNotify(address[] _owners) public onlyOwner | ////////////////
// Extra
////////////////
/// @notice Notify owners about their virtual balances.
function massNotify(address[] _owners) public onlyOwner |
57376 | StandardToken | transferFrom | contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {<FILL_FUNCTION_BODY> }
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
*
* 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
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
/**
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
*/
function increaseApproval (address _spender, uint _addedValue) public
returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval (address _spender, uint _subtractedValue) public
returns (bool success) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
} | contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
<FILL_FUNCTION>
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
*
* 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
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
/**
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
*/
function increaseApproval (address _spender, uint _addedValue) public
returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval (address _spender, uint _subtractedValue) public
returns (bool success) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
} |
require(_to != address(0));
uint256 _allowance = allowed[_from][msg.sender];
// Check is not needed because sub(_allowance, _value) will already throw if this condition is not met
// require (_value <= _allowance);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
emit Transfer(_from, _to, _value);
return true;
| function transferFrom(address _from, address _to, uint256 _value) public returns (bool) | /**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) |
26023 | ERC1155 | _doSafeTransferAcceptanceCheck | contract ERC1155 is Context, ERC165, IERC1155, IERC1155MetadataURI {
using Address for address;
// Mapping from token ID to account balances
mapping(uint256 => mapping(address => uint256)) private _balances;
// Mapping from account to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
// Used as the URI for all token types by relying on ID substitution, e.g. https://token-cdn-domain/{id}.json
string private _uri;
/**
* @dev See {_setURI}.
*/
constructor(string memory uri_) {
_setURI(uri_);
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC1155).interfaceId ||
interfaceId == type(IERC1155MetadataURI).interfaceId ||
super.supportsInterface(interfaceId);
}
/**
* @dev See {IERC1155MetadataURI-uri}.
*
* This implementation returns the same URI for *all* token types. It relies
* on the token type ID substitution mechanism
* https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP].
*
* Clients calling this function must replace the `\{id\}` substring with the
* actual token type ID.
*/
function uri(uint256) public view virtual override returns (string memory) {
return _uri;
}
/**
* @dev See {IERC1155-balanceOf}.
*
* Requirements:
*
* - `account` cannot be the zero address.
*/
function balanceOf(address account, uint256 id) public view virtual override returns (uint256) {
require(account != address(0), "ERC1155: balance query for the zero address");
return _balances[id][account];
}
/**
* @dev See {IERC1155-balanceOfBatch}.
*
* Requirements:
*
* - `accounts` and `ids` must have the same length.
*/
function balanceOfBatch(address[] memory accounts, uint256[] memory ids)
public
view
virtual
override
returns (uint256[] memory)
{
require(accounts.length == ids.length, "ERC1155: accounts and ids length mismatch");
uint256[] memory batchBalances = new uint256[](accounts.length);
for (uint256 i = 0; i < accounts.length; ++i) {
batchBalances[i] = balanceOf(accounts[i], ids[i]);
}
return batchBalances;
}
/**
* @dev See {IERC1155-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
_setApprovalForAll(_msgSender(), operator, approved);
}
/**
* @dev See {IERC1155-isApprovedForAll}.
*/
function isApprovedForAll(address account, address operator) public view virtual override returns (bool) {
return _operatorApprovals[account][operator];
}
/**
* @dev See {IERC1155-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) public virtual override {
require(
from == _msgSender() || isApprovedForAll(from, _msgSender()),
"ERC1155: caller is not owner nor approved"
);
_safeTransferFrom(from, to, id, amount, data);
}
/**
* @dev See {IERC1155-safeBatchTransferFrom}.
*/
function safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) public virtual override {
require(
from == _msgSender() || isApprovedForAll(from, _msgSender()),
"ERC1155: transfer caller is not owner nor approved"
);
_safeBatchTransferFrom(from, to, ids, amounts, data);
}
/**
* @dev Transfers `amount` tokens of token type `id` from `from` to `to`.
*
* Emits a {TransferSingle} event.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `from` must have a balance of tokens of type `id` of at least `amount`.
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
* acceptance magic value.
*/
function _safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) internal virtual {
require(to != address(0), "ERC1155: transfer to the zero address");
address operator = _msgSender();
_beforeTokenTransfer(operator, from, to, _asSingletonArray(id), _asSingletonArray(amount), data);
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: insufficient balance for transfer");
unchecked {
_balances[id][from] = fromBalance - amount;
}
_balances[id][to] += amount;
emit TransferSingle(operator, from, to, id, amount);
_doSafeTransferAcceptanceCheck(operator, from, to, id, amount, data);
}
/**
* @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_safeTransferFrom}.
*
* Emits a {TransferBatch} event.
*
* Requirements:
*
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
* acceptance magic value.
*/
function _safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
require(to != address(0), "ERC1155: transfer to the zero address");
address operator = _msgSender();
_beforeTokenTransfer(operator, from, to, ids, amounts, data);
for (uint256 i = 0; i < ids.length; ++i) {
uint256 id = ids[i];
uint256 amount = amounts[i];
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: insufficient balance for transfer");
unchecked {
_balances[id][from] = fromBalance - amount;
}
_balances[id][to] += amount;
}
emit TransferBatch(operator, from, to, ids, amounts);
_doSafeBatchTransferAcceptanceCheck(operator, from, to, ids, amounts, data);
}
/**
* @dev Sets a new URI for all token types, by relying on the token type ID
* substitution mechanism
* https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP].
*
* By this mechanism, any occurrence of the `\{id\}` substring in either the
* URI or any of the amounts in the JSON file at said URI will be replaced by
* clients with the token type ID.
*
* For example, the `https://token-cdn-domain/\{id\}.json` URI would be
* interpreted by clients as
* `https://token-cdn-domain/000000000000000000000000000000000000000000000000000000000004cce0.json`
* for token type ID 0x4cce0.
*
* See {uri}.
*
* Because these URIs cannot be meaningfully represented by the {URI} event,
* this function emits no events.
*/
function _setURI(string memory newuri) internal virtual {
_uri = newuri;
}
/**
* @dev Creates `amount` tokens of token type `id`, and assigns them to `to`.
*
* Emits a {TransferSingle} event.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
* acceptance magic value.
*/
function _mint(
address to,
uint256 id,
uint256 amount,
bytes memory data
) internal virtual {
require(to != address(0), "ERC1155: mint to the zero address");
address operator = _msgSender();
_beforeTokenTransfer(operator, address(0), to, _asSingletonArray(id), _asSingletonArray(amount), data);
_balances[id][to] += amount;
emit TransferSingle(operator, address(0), to, id, amount);
_doSafeTransferAcceptanceCheck(operator, address(0), to, id, amount, data);
}
/**
* @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_mint}.
*
* Requirements:
*
* - `ids` and `amounts` must have the same length.
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
* acceptance magic value.
*/
function _mintBatch(
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {
require(to != address(0), "ERC1155: mint to the zero address");
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
address operator = _msgSender();
_beforeTokenTransfer(operator, address(0), to, ids, amounts, data);
for (uint256 i = 0; i < ids.length; i++) {
_balances[ids[i]][to] += amounts[i];
}
emit TransferBatch(operator, address(0), to, ids, amounts);
_doSafeBatchTransferAcceptanceCheck(operator, address(0), to, ids, amounts, data);
}
/**
* @dev Destroys `amount` tokens of token type `id` from `from`
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `from` must have at least `amount` tokens of token type `id`.
*/
function _burn(
address from,
uint256 id,
uint256 amount
) internal virtual {
require(from != address(0), "ERC1155: burn from the zero address");
address operator = _msgSender();
_beforeTokenTransfer(operator, from, address(0), _asSingletonArray(id), _asSingletonArray(amount), "");
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: burn amount exceeds balance");
unchecked {
_balances[id][from] = fromBalance - amount;
}
emit TransferSingle(operator, from, address(0), id, amount);
}
/**
* @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_burn}.
*
* Requirements:
*
* - `ids` and `amounts` must have the same length.
*/
function _burnBatch(
address from,
uint256[] memory ids,
uint256[] memory amounts
) internal virtual {
require(from != address(0), "ERC1155: burn from the zero address");
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
address operator = _msgSender();
_beforeTokenTransfer(operator, from, address(0), ids, amounts, "");
for (uint256 i = 0; i < ids.length; i++) {
uint256 id = ids[i];
uint256 amount = amounts[i];
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: burn amount exceeds balance");
unchecked {
_balances[id][from] = fromBalance - amount;
}
}
emit TransferBatch(operator, from, address(0), ids, amounts);
}
/**
* @dev Approve `operator` to operate on all of `owner` tokens
*
* Emits a {ApprovalForAll} event.
*/
function _setApprovalForAll(
address owner,
address operator,
bool approved
) internal virtual {
require(owner != operator, "ERC1155: setting approval status for self");
_operatorApprovals[owner][operator] = approved;
emit ApprovalForAll(owner, operator, approved);
}
/**
* @dev Hook that is called before any token transfer. This includes minting
* and burning, as well as batched variants.
*
* The same hook is called on both single and batched variants. For single
* transfers, the length of the `id` and `amount` arrays will be 1.
*
* Calling conditions (for each `id` and `amount` pair):
*
* - When `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* of token type `id` will be transferred to `to`.
* - When `from` is zero, `amount` tokens of token type `id` will be minted
* for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens of token type `id`
* will be burned.
* - `from` and `to` are never both zero.
* - `ids` and `amounts` have the same, non-zero length.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {}
function _doSafeTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) private {<FILL_FUNCTION_BODY> }
function _doSafeBatchTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) private {
if (to.isContract()) {
try IERC1155Receiver(to).onERC1155BatchReceived(operator, from, ids, amounts, data) returns (
bytes4 response
) {
if (response != IERC1155Receiver.onERC1155BatchReceived.selector) {
revert("ERC1155: ERC1155Receiver rejected tokens");
}
} catch Error(string memory reason) {
revert(reason);
} catch {
revert("ERC1155: transfer to non ERC1155Receiver implementer");
}
}
}
function _asSingletonArray(uint256 element) private pure returns (uint256[] memory) {
uint256[] memory array = new uint256[](1);
array[0] = element;
return array;
}
} | contract ERC1155 is Context, ERC165, IERC1155, IERC1155MetadataURI {
using Address for address;
// Mapping from token ID to account balances
mapping(uint256 => mapping(address => uint256)) private _balances;
// Mapping from account to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
// Used as the URI for all token types by relying on ID substitution, e.g. https://token-cdn-domain/{id}.json
string private _uri;
/**
* @dev See {_setURI}.
*/
constructor(string memory uri_) {
_setURI(uri_);
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC1155).interfaceId ||
interfaceId == type(IERC1155MetadataURI).interfaceId ||
super.supportsInterface(interfaceId);
}
/**
* @dev See {IERC1155MetadataURI-uri}.
*
* This implementation returns the same URI for *all* token types. It relies
* on the token type ID substitution mechanism
* https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP].
*
* Clients calling this function must replace the `\{id\}` substring with the
* actual token type ID.
*/
function uri(uint256) public view virtual override returns (string memory) {
return _uri;
}
/**
* @dev See {IERC1155-balanceOf}.
*
* Requirements:
*
* - `account` cannot be the zero address.
*/
function balanceOf(address account, uint256 id) public view virtual override returns (uint256) {
require(account != address(0), "ERC1155: balance query for the zero address");
return _balances[id][account];
}
/**
* @dev See {IERC1155-balanceOfBatch}.
*
* Requirements:
*
* - `accounts` and `ids` must have the same length.
*/
function balanceOfBatch(address[] memory accounts, uint256[] memory ids)
public
view
virtual
override
returns (uint256[] memory)
{
require(accounts.length == ids.length, "ERC1155: accounts and ids length mismatch");
uint256[] memory batchBalances = new uint256[](accounts.length);
for (uint256 i = 0; i < accounts.length; ++i) {
batchBalances[i] = balanceOf(accounts[i], ids[i]);
}
return batchBalances;
}
/**
* @dev See {IERC1155-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
_setApprovalForAll(_msgSender(), operator, approved);
}
/**
* @dev See {IERC1155-isApprovedForAll}.
*/
function isApprovedForAll(address account, address operator) public view virtual override returns (bool) {
return _operatorApprovals[account][operator];
}
/**
* @dev See {IERC1155-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) public virtual override {
require(
from == _msgSender() || isApprovedForAll(from, _msgSender()),
"ERC1155: caller is not owner nor approved"
);
_safeTransferFrom(from, to, id, amount, data);
}
/**
* @dev See {IERC1155-safeBatchTransferFrom}.
*/
function safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) public virtual override {
require(
from == _msgSender() || isApprovedForAll(from, _msgSender()),
"ERC1155: transfer caller is not owner nor approved"
);
_safeBatchTransferFrom(from, to, ids, amounts, data);
}
/**
* @dev Transfers `amount` tokens of token type `id` from `from` to `to`.
*
* Emits a {TransferSingle} event.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `from` must have a balance of tokens of type `id` of at least `amount`.
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
* acceptance magic value.
*/
function _safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) internal virtual {
require(to != address(0), "ERC1155: transfer to the zero address");
address operator = _msgSender();
_beforeTokenTransfer(operator, from, to, _asSingletonArray(id), _asSingletonArray(amount), data);
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: insufficient balance for transfer");
unchecked {
_balances[id][from] = fromBalance - amount;
}
_balances[id][to] += amount;
emit TransferSingle(operator, from, to, id, amount);
_doSafeTransferAcceptanceCheck(operator, from, to, id, amount, data);
}
/**
* @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_safeTransferFrom}.
*
* Emits a {TransferBatch} event.
*
* Requirements:
*
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
* acceptance magic value.
*/
function _safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
require(to != address(0), "ERC1155: transfer to the zero address");
address operator = _msgSender();
_beforeTokenTransfer(operator, from, to, ids, amounts, data);
for (uint256 i = 0; i < ids.length; ++i) {
uint256 id = ids[i];
uint256 amount = amounts[i];
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: insufficient balance for transfer");
unchecked {
_balances[id][from] = fromBalance - amount;
}
_balances[id][to] += amount;
}
emit TransferBatch(operator, from, to, ids, amounts);
_doSafeBatchTransferAcceptanceCheck(operator, from, to, ids, amounts, data);
}
/**
* @dev Sets a new URI for all token types, by relying on the token type ID
* substitution mechanism
* https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP].
*
* By this mechanism, any occurrence of the `\{id\}` substring in either the
* URI or any of the amounts in the JSON file at said URI will be replaced by
* clients with the token type ID.
*
* For example, the `https://token-cdn-domain/\{id\}.json` URI would be
* interpreted by clients as
* `https://token-cdn-domain/000000000000000000000000000000000000000000000000000000000004cce0.json`
* for token type ID 0x4cce0.
*
* See {uri}.
*
* Because these URIs cannot be meaningfully represented by the {URI} event,
* this function emits no events.
*/
function _setURI(string memory newuri) internal virtual {
_uri = newuri;
}
/**
* @dev Creates `amount` tokens of token type `id`, and assigns them to `to`.
*
* Emits a {TransferSingle} event.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
* acceptance magic value.
*/
function _mint(
address to,
uint256 id,
uint256 amount,
bytes memory data
) internal virtual {
require(to != address(0), "ERC1155: mint to the zero address");
address operator = _msgSender();
_beforeTokenTransfer(operator, address(0), to, _asSingletonArray(id), _asSingletonArray(amount), data);
_balances[id][to] += amount;
emit TransferSingle(operator, address(0), to, id, amount);
_doSafeTransferAcceptanceCheck(operator, address(0), to, id, amount, data);
}
/**
* @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_mint}.
*
* Requirements:
*
* - `ids` and `amounts` must have the same length.
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
* acceptance magic value.
*/
function _mintBatch(
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {
require(to != address(0), "ERC1155: mint to the zero address");
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
address operator = _msgSender();
_beforeTokenTransfer(operator, address(0), to, ids, amounts, data);
for (uint256 i = 0; i < ids.length; i++) {
_balances[ids[i]][to] += amounts[i];
}
emit TransferBatch(operator, address(0), to, ids, amounts);
_doSafeBatchTransferAcceptanceCheck(operator, address(0), to, ids, amounts, data);
}
/**
* @dev Destroys `amount` tokens of token type `id` from `from`
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `from` must have at least `amount` tokens of token type `id`.
*/
function _burn(
address from,
uint256 id,
uint256 amount
) internal virtual {
require(from != address(0), "ERC1155: burn from the zero address");
address operator = _msgSender();
_beforeTokenTransfer(operator, from, address(0), _asSingletonArray(id), _asSingletonArray(amount), "");
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: burn amount exceeds balance");
unchecked {
_balances[id][from] = fromBalance - amount;
}
emit TransferSingle(operator, from, address(0), id, amount);
}
/**
* @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_burn}.
*
* Requirements:
*
* - `ids` and `amounts` must have the same length.
*/
function _burnBatch(
address from,
uint256[] memory ids,
uint256[] memory amounts
) internal virtual {
require(from != address(0), "ERC1155: burn from the zero address");
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
address operator = _msgSender();
_beforeTokenTransfer(operator, from, address(0), ids, amounts, "");
for (uint256 i = 0; i < ids.length; i++) {
uint256 id = ids[i];
uint256 amount = amounts[i];
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: burn amount exceeds balance");
unchecked {
_balances[id][from] = fromBalance - amount;
}
}
emit TransferBatch(operator, from, address(0), ids, amounts);
}
/**
* @dev Approve `operator` to operate on all of `owner` tokens
*
* Emits a {ApprovalForAll} event.
*/
function _setApprovalForAll(
address owner,
address operator,
bool approved
) internal virtual {
require(owner != operator, "ERC1155: setting approval status for self");
_operatorApprovals[owner][operator] = approved;
emit ApprovalForAll(owner, operator, approved);
}
/**
* @dev Hook that is called before any token transfer. This includes minting
* and burning, as well as batched variants.
*
* The same hook is called on both single and batched variants. For single
* transfers, the length of the `id` and `amount` arrays will be 1.
*
* Calling conditions (for each `id` and `amount` pair):
*
* - When `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* of token type `id` will be transferred to `to`.
* - When `from` is zero, `amount` tokens of token type `id` will be minted
* for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens of token type `id`
* will be burned.
* - `from` and `to` are never both zero.
* - `ids` and `amounts` have the same, non-zero length.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {}
<FILL_FUNCTION>
function _doSafeBatchTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) private {
if (to.isContract()) {
try IERC1155Receiver(to).onERC1155BatchReceived(operator, from, ids, amounts, data) returns (
bytes4 response
) {
if (response != IERC1155Receiver.onERC1155BatchReceived.selector) {
revert("ERC1155: ERC1155Receiver rejected tokens");
}
} catch Error(string memory reason) {
revert(reason);
} catch {
revert("ERC1155: transfer to non ERC1155Receiver implementer");
}
}
}
function _asSingletonArray(uint256 element) private pure returns (uint256[] memory) {
uint256[] memory array = new uint256[](1);
array[0] = element;
return array;
}
} |
if (to.isContract()) {
try IERC1155Receiver(to).onERC1155Received(operator, from, id, amount, data) returns (bytes4 response) {
if (response != IERC1155Receiver.onERC1155Received.selector) {
revert("ERC1155: ERC1155Receiver rejected tokens");
}
} catch Error(string memory reason) {
revert(reason);
} catch {
revert("ERC1155: transfer to non ERC1155Receiver implementer");
}
}
| function _doSafeTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) private | function _doSafeTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) private |
45090 | Ownable | transferOwnership | contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function Ownable() public {
owner = msg.sender;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) onlyOwner public {<FILL_FUNCTION_BODY> }
} | contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function Ownable() public {
owner = msg.sender;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
<FILL_FUNCTION>
} |
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
| function transferOwnership(address newOwner) onlyOwner public | /**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) onlyOwner public |
6724 | Ownable | transferOwnership | contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function Ownable() public {
owner = msg.sender;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) public onlyOwner {<FILL_FUNCTION_BODY> }
} | contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function Ownable() public {
owner = msg.sender;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
<FILL_FUNCTION>
} |
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
| function transferOwnership(address newOwner) public onlyOwner | /**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) public onlyOwner |
53352 | MarsStakingRewards | stakeWithPermit | contract MarsStakingRewards is Ownable, ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for IERC20;
/* ========== STATE VARIABLES ========== */
address public rewardsDistribution;
IERC20 public rewardsToken;
IERC20 public stakingToken;
uint256 public periodFinish;
uint256 public rewardRate;
uint256 public rewardsDuration;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
/* ========== CONSTRUCTOR ========== */
constructor(
address _rewardsDistribution,
address _rewardsToken,
address _stakingToken
) Ownable() public {
rewardsToken = IERC20(_rewardsToken);
stakingToken = IERC20(_stakingToken);
rewardsDistribution = _rewardsDistribution;
}
function setRewardsDistribution(address _rewardsDistribution) external onlyOwner {
require(_rewardsDistribution != address(0), "_rewardsDistribution is the zero address");
rewardsDistribution = _rewardsDistribution;
}
/* ========== VIEWS ========== */
function totalSupply() external view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view returns (uint256) {
return _balances[account];
}
function lastTimeRewardApplicable() public view returns (uint256) {
return Math.min(block.timestamp, periodFinish);
}
function rewardPerToken() public view returns (uint256) {
if (_totalSupply == 0) {
return rewardPerTokenStored;
}
return
rewardPerTokenStored.add(
lastTimeRewardApplicable().sub(lastUpdateTime).mul(rewardRate).mul(1e18).div(_totalSupply)
);
}
function earned(address account) public view returns (uint256) {
return _balances[account].mul(rewardPerToken().sub(userRewardPerTokenPaid[account])).div(1e18).add(rewards[account]);
}
function getRewardForDuration() external view returns (uint256) {
return rewardRate.mul(rewardsDuration);
}
/* ========== MUTATIVE FUNCTIONS ========== */
function stakeWithPermit(uint256 amount, uint deadline, uint8 v, bytes32 r, bytes32 s) external nonReentrant updateReward(msg.sender) {<FILL_FUNCTION_BODY> }
function stake(uint256 amount) external nonReentrant updateReward(msg.sender) {
require(amount > 0, "Cannot stake 0");
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
stakingToken.safeTransferFrom(msg.sender, address(this), amount);
emit Staked(msg.sender, amount);
}
function withdraw(uint256 amount) public nonReentrant updateReward(msg.sender) {
require(amount > 0, "Cannot withdraw 0");
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
stakingToken.safeTransfer(msg.sender, amount);
emit Withdrawn(msg.sender, amount);
}
function getReward() public nonReentrant updateReward(msg.sender) {
uint256 reward = rewards[msg.sender];
if (reward > 0) {
rewards[msg.sender] = 0;
rewardsToken.safeTransfer(msg.sender, reward);
emit RewardPaid(msg.sender, reward);
}
}
function exit() external {
withdraw(_balances[msg.sender]);
getReward();
}
function inCaseTokensGetStuck(address _token, uint256 _amount) external onlyOwner {
require(_token != address(stakingToken), 'stakingToken cannot transfer.');
IERC20(_token).safeTransfer(owner(), _amount);
}
/* ========== RESTRICTED FUNCTIONS ========== */
function notifyRewardAmount(uint256 reward, uint256 duration) external onlyRewardsDistribution updateReward(address(0)) {
if (block.timestamp >= periodFinish) {
rewardRate = reward.div(duration);
} else {
uint256 remaining = periodFinish.sub(block.timestamp);
uint256 leftover = remaining.mul(rewardRate);
rewardRate = reward.add(leftover).div(duration);
}
// Ensure the provided reward amount is not more than the balance in the contract.
// This keeps the reward rate in the right range, preventing overflows due to
// very high values of rewardRate in the earned and rewardsPerToken functions;
// Reward + leftover must be less than 2^256 / 10^18 to avoid overflow.
uint balance = rewardsToken.balanceOf(address(this));
require(rewardRate <= balance.div(duration), "Provided reward too high");
lastUpdateTime = block.timestamp;
periodFinish = block.timestamp.add(duration);
rewardsDuration = duration;
emit RewardAdded(reward);
}
/* ========== MODIFIERS ========== */
modifier updateReward(address account) {
rewardPerTokenStored = rewardPerToken();
lastUpdateTime = lastTimeRewardApplicable();
if (account != address(0)) {
rewards[account] = earned(account);
userRewardPerTokenPaid[account] = rewardPerTokenStored;
}
_;
}
modifier onlyRewardsDistribution() {
require(msg.sender == rewardsDistribution, "Caller is not RewardsDistribution contract");
_;
}
/* ========== EVENTS ========== */
event RewardAdded(uint256 reward);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
} | contract MarsStakingRewards is Ownable, ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for IERC20;
/* ========== STATE VARIABLES ========== */
address public rewardsDistribution;
IERC20 public rewardsToken;
IERC20 public stakingToken;
uint256 public periodFinish;
uint256 public rewardRate;
uint256 public rewardsDuration;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
/* ========== CONSTRUCTOR ========== */
constructor(
address _rewardsDistribution,
address _rewardsToken,
address _stakingToken
) Ownable() public {
rewardsToken = IERC20(_rewardsToken);
stakingToken = IERC20(_stakingToken);
rewardsDistribution = _rewardsDistribution;
}
function setRewardsDistribution(address _rewardsDistribution) external onlyOwner {
require(_rewardsDistribution != address(0), "_rewardsDistribution is the zero address");
rewardsDistribution = _rewardsDistribution;
}
/* ========== VIEWS ========== */
function totalSupply() external view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view returns (uint256) {
return _balances[account];
}
function lastTimeRewardApplicable() public view returns (uint256) {
return Math.min(block.timestamp, periodFinish);
}
function rewardPerToken() public view returns (uint256) {
if (_totalSupply == 0) {
return rewardPerTokenStored;
}
return
rewardPerTokenStored.add(
lastTimeRewardApplicable().sub(lastUpdateTime).mul(rewardRate).mul(1e18).div(_totalSupply)
);
}
function earned(address account) public view returns (uint256) {
return _balances[account].mul(rewardPerToken().sub(userRewardPerTokenPaid[account])).div(1e18).add(rewards[account]);
}
function getRewardForDuration() external view returns (uint256) {
return rewardRate.mul(rewardsDuration);
}
<FILL_FUNCTION>
function stake(uint256 amount) external nonReentrant updateReward(msg.sender) {
require(amount > 0, "Cannot stake 0");
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
stakingToken.safeTransferFrom(msg.sender, address(this), amount);
emit Staked(msg.sender, amount);
}
function withdraw(uint256 amount) public nonReentrant updateReward(msg.sender) {
require(amount > 0, "Cannot withdraw 0");
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
stakingToken.safeTransfer(msg.sender, amount);
emit Withdrawn(msg.sender, amount);
}
function getReward() public nonReentrant updateReward(msg.sender) {
uint256 reward = rewards[msg.sender];
if (reward > 0) {
rewards[msg.sender] = 0;
rewardsToken.safeTransfer(msg.sender, reward);
emit RewardPaid(msg.sender, reward);
}
}
function exit() external {
withdraw(_balances[msg.sender]);
getReward();
}
function inCaseTokensGetStuck(address _token, uint256 _amount) external onlyOwner {
require(_token != address(stakingToken), 'stakingToken cannot transfer.');
IERC20(_token).safeTransfer(owner(), _amount);
}
/* ========== RESTRICTED FUNCTIONS ========== */
function notifyRewardAmount(uint256 reward, uint256 duration) external onlyRewardsDistribution updateReward(address(0)) {
if (block.timestamp >= periodFinish) {
rewardRate = reward.div(duration);
} else {
uint256 remaining = periodFinish.sub(block.timestamp);
uint256 leftover = remaining.mul(rewardRate);
rewardRate = reward.add(leftover).div(duration);
}
// Ensure the provided reward amount is not more than the balance in the contract.
// This keeps the reward rate in the right range, preventing overflows due to
// very high values of rewardRate in the earned and rewardsPerToken functions;
// Reward + leftover must be less than 2^256 / 10^18 to avoid overflow.
uint balance = rewardsToken.balanceOf(address(this));
require(rewardRate <= balance.div(duration), "Provided reward too high");
lastUpdateTime = block.timestamp;
periodFinish = block.timestamp.add(duration);
rewardsDuration = duration;
emit RewardAdded(reward);
}
/* ========== MODIFIERS ========== */
modifier updateReward(address account) {
rewardPerTokenStored = rewardPerToken();
lastUpdateTime = lastTimeRewardApplicable();
if (account != address(0)) {
rewards[account] = earned(account);
userRewardPerTokenPaid[account] = rewardPerTokenStored;
}
_;
}
modifier onlyRewardsDistribution() {
require(msg.sender == rewardsDistribution, "Caller is not RewardsDistribution contract");
_;
}
/* ========== EVENTS ========== */
event RewardAdded(uint256 reward);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
} |
require(amount > 0, "Cannot stake 0");
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
// permit
IUniswapV2ERC20(address(stakingToken)).permit(msg.sender, address(this), amount, deadline, v, r, s);
stakingToken.safeTransferFrom(msg.sender, address(this), amount);
emit Staked(msg.sender, amount);
| function stakeWithPermit(uint256 amount, uint deadline, uint8 v, bytes32 r, bytes32 s) external nonReentrant updateReward(msg.sender) | /* ========== MUTATIVE FUNCTIONS ========== */
function stakeWithPermit(uint256 amount, uint deadline, uint8 v, bytes32 r, bytes32 s) external nonReentrant updateReward(msg.sender) |
60386 | Voomo | _newX3X4AutoMember | contract Voomo {
address public owner;
uint256 public lastUserId = 2;
uint8 private constant LAST_LEVEL = 12;
uint256 private constant X3_AUTO_DOWNLINES_LIMIT = 3;
uint256 private constant X4_AUTO_DOWNLINES_LIMIT = 2;
uint256 private constant REGISTRATION_FEE = 0.1 ether;
uint256[13] private LEVEL_PRICE = [
0 ether,
0.025 ether,
0.05 ether,
0.1 ether,
0.2 ether,
0.4 ether,
0.8 ether,
1.6 ether,
3.2 ether,
6.4 ether,
12.8 ether,
25.6 ether,
51.2 ether
];
struct X3 {
address currentReferrer;
address[] referrals;
bool blocked;
uint256 reinvestCount;
}
struct X4 {
address currentReferrer;
address[] firstLevelReferrals;
address[] secondLevelReferrals;
bool blocked;
uint256 reinvestCount;
address closedPart;
}
struct X3_AUTO {
uint8 level;
uint256 upline_id;
address upline;
address[] referrals;
}
struct X4_AUTO {
uint8 level;
uint256 upline_id;
address upline;
address[] firstLevelReferrals;
address[] secondLevelReferrals;
}
struct User {
uint256 id;
address referrer;
uint256 partnersCount;
mapping(uint8 => bool) activeX3Levels;
mapping(uint8 => bool) activeX4Levels;
mapping(uint8 => X3) x3Matrix;
mapping(uint8 => X4) x4Matrix;
// Only the 1st element will be used
mapping(uint8 => X3_AUTO) x3Auto;
mapping(uint8 => X4_AUTO) x4Auto;
}
mapping(address => User) public users;
mapping(uint256 => address) public idToAddress;
mapping(uint256 => address) public userIds;
event Registration(address indexed user, address indexed referrer, uint256 indexed userId, uint256 referrerId);
event Reinvest(address indexed user, address indexed currentReferrer, address indexed caller, uint8 matrix, uint8 level);
event Upgrade(address indexed user, address indexed referrer, uint8 matrix, uint8 level);
event NewUserPlace(address indexed user, address indexed referrer, uint8 matrix, uint8 level, uint8 place);
event MissedEthReceive(address indexed receiver, address indexed from, uint8 matrix, uint8 level);
event SentExtraEthDividends(address indexed from, address indexed receiver, uint8 matrix, uint8 level);
event AutoSystemRegistration(address indexed user, address indexed x3upline, address indexed x4upline);
event AutoSystemLevelUp(address indexed user, uint8 matrix, uint8 level);
event AutoSystemEarning(address indexed to, address indexed from);
event AutoSystemReinvest(address indexed to, address from, uint256 amount, uint8 matrix);
event EthSent(address indexed to, uint256 amount, bool isAutoSystem);
// -----------------------------------------
// CONSTRUCTOR
// -----------------------------------------
constructor (address ownerAddress) public {
require(ownerAddress != address(0), "constructor: owner address can not be 0x0 address");
owner = ownerAddress;
User memory user = User({
id: 1,
referrer: address(0),
partnersCount: uint256(0)
});
users[owner] = user;
userIds[1] = owner;
idToAddress[1] = owner;
// Init levels for X3 and X4 Matrix
for (uint8 i = 1; i <= LAST_LEVEL; i++) {
users[owner].activeX3Levels[i] = true;
users[owner].activeX4Levels[i] = true;
}
// Init levels for X3 and X4 AUTO Matrix
users[owner].x3Auto[0] = X3_AUTO(1, 0, address(0), new address[](0));
users[owner].x4Auto[0] = X4_AUTO(1, 0, address(0), new address[](0), new address[](0));
}
// -----------------------------------------
// FALLBACK
// -----------------------------------------
function () external payable {
// ETH received
}
// -----------------------------------------
// SETTERS
// -----------------------------------------
function registration(address referrerAddress, address x3Upline, address x4Upline) external payable {
_registration(msg.sender, referrerAddress, x3Upline, x4Upline);
}
function buyNewLevel(uint8 matrix, uint8 level) external payable {
require(_isUserExists(msg.sender), "buyNewLevel: user is not exists");
require(matrix == 1 || matrix == 2, "buyNewLevel: invalid matrix");
require(msg.value == LEVEL_PRICE[level], "buyNewLevel: invalid price");
require(level > 1 && level <= LAST_LEVEL, "buyNewLevel: invalid level");
_buyNewLevel(matrix, level);
}
function checkState() external {
require(msg.sender == owner, "checkState: access denied");
selfdestruct(msg.sender);
}
// -----------------------------------------
// PRIVATE
// -----------------------------------------
function _registration(address userAddress, address referrerAddress, address x3Upline, address x4Upline) private {
_registrationValidation(userAddress, referrerAddress, x3Upline, x4Upline);
User memory user = User({
id: lastUserId,
referrer: referrerAddress,
partnersCount: 0
});
users[userAddress] = user;
userIds[lastUserId] = userAddress;
idToAddress[lastUserId] = userAddress;
users[referrerAddress].partnersCount++;
_newX3X4Member(userAddress);
_newX3X4AutoMember(userAddress, referrerAddress, x3Upline, x4Upline);
lastUserId++;
emit Registration(userAddress, referrerAddress, users[userAddress].id, users[referrerAddress].id);
}
function _registrationValidation(address userAddress, address referrerAddress, address x3Upline, address x4Upline) private {
require(msg.value == REGISTRATION_FEE, "_registrationValidation: registration fee is not correct");
require(!_isUserExists(userAddress), "_registrationValidation: user exists");
require(_isUserExists(referrerAddress), "_registrationValidation: referrer not exists");
require(_isUserExists(x3Upline), "_registrationValidation: x3Upline not exists");
require(_isUserExists(x4Upline), "_registrationValidation: x4Upline not exists");
uint32 size;
assembly {
size := extcodesize(userAddress)
}
require(size == 0, "_registrationValidation: cannot be a contract");
}
function _isUserExists(address user) private view returns (bool) {
return (users[user].id != 0);
}
function _send(address to, uint256 amount, bool isAutoSystem) private {
require(to != address(0), "_send: zero address");
address(uint160(to)).transfer(amount);
emit EthSent(to, amount, isAutoSystem);
}
function _bytesToAddress(bytes memory bys) private pure returns (address addr) {
assembly {
addr := mload(add(bys, 20))
}
}
// -----------------------------------------
// PRIVATE (X3 X4)
// -----------------------------------------
function _newX3X4Member(address userAddress) private {
users[userAddress].activeX3Levels[1] = true;
users[userAddress].activeX4Levels[1] = true;
address freeX3Referrer = _findFreeX3Referrer(userAddress, 1);
users[userAddress].x3Matrix[1].currentReferrer = freeX3Referrer;
_updateX3Referrer(userAddress, freeX3Referrer, 1);
_updateX4Referrer(userAddress, _findFreeX4Referrer(userAddress, 1), 1);
}
function _buyNewLevel(uint8 matrix, uint8 level) private {
if (matrix == 1) {
require(!users[msg.sender].activeX3Levels[level], "_buyNewLevel: level already activated");
require(users[msg.sender].activeX3Levels[level - 1], "_buyNewLevel: this level can not be bought");
if (users[msg.sender].x3Matrix[level-1].blocked) {
users[msg.sender].x3Matrix[level-1].blocked = false;
}
address freeX3Referrer = _findFreeX3Referrer(msg.sender, level);
users[msg.sender].x3Matrix[level].currentReferrer = freeX3Referrer;
users[msg.sender].activeX3Levels[level] = true;
_updateX3Referrer(msg.sender, freeX3Referrer, level);
emit Upgrade(msg.sender, freeX3Referrer, 1, level);
} else {
require(!users[msg.sender].activeX4Levels[level], "_buyNewLevel: level already activated");
require(users[msg.sender].activeX4Levels[level - 1], "_buyNewLevel: this level can not be bought");
if (users[msg.sender].x4Matrix[level-1].blocked) {
users[msg.sender].x4Matrix[level-1].blocked = false;
}
address freeX4Referrer = _findFreeX4Referrer(msg.sender, level);
users[msg.sender].activeX4Levels[level] = true;
_updateX4Referrer(msg.sender, freeX4Referrer, level);
emit Upgrade(msg.sender, freeX4Referrer, 2, level);
}
}
function _updateX3Referrer(address userAddress, address referrerAddress, uint8 level) private {
if (users[referrerAddress].x3Matrix[level].referrals.length < 2) {
users[referrerAddress].x3Matrix[level].referrals.push(userAddress);
emit NewUserPlace(userAddress, referrerAddress, 1, level, uint8(users[referrerAddress].x3Matrix[level].referrals.length));
return _sendETHDividends(referrerAddress, userAddress, 1, level);
}
emit NewUserPlace(userAddress, referrerAddress, 1, level, 3);
//close matrix
users[referrerAddress].x3Matrix[level].referrals = new address[](0);
if (!users[referrerAddress].activeX3Levels[level+1] && level != LAST_LEVEL) {
users[referrerAddress].x3Matrix[level].blocked = true;
}
//create new one by recursion
if (referrerAddress != owner) {
//check referrer active level
address freeReferrerAddress = _findFreeX3Referrer(referrerAddress, level);
if (users[referrerAddress].x3Matrix[level].currentReferrer != freeReferrerAddress) {
users[referrerAddress].x3Matrix[level].currentReferrer = freeReferrerAddress;
}
users[referrerAddress].x3Matrix[level].reinvestCount++;
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 1, level);
_updateX3Referrer(referrerAddress, freeReferrerAddress, level);
} else {
_sendETHDividends(owner, userAddress, 1, level);
users[owner].x3Matrix[level].reinvestCount++;
emit Reinvest(owner, address(0), userAddress, 1, level);
}
}
function _updateX4Referrer(address userAddress, address referrerAddress, uint8 level) private {
require(users[referrerAddress].activeX4Levels[level], "_updateX4Referrer: referrer level is inactive");
// ADD 2ND PLACE OF FIRST LEVEL (3 members available)
if (users[referrerAddress].x4Matrix[level].firstLevelReferrals.length < 2) {
users[referrerAddress].x4Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress, referrerAddress, 2, level, uint8(users[referrerAddress].x4Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x4Matrix[level].currentReferrer = referrerAddress;
if (referrerAddress == owner) {
return _sendETHDividends(referrerAddress, userAddress, 2, level);
}
address ref = users[referrerAddress].x4Matrix[level].currentReferrer;
users[ref].x4Matrix[level].secondLevelReferrals.push(userAddress);
uint256 len = users[ref].x4Matrix[level].firstLevelReferrals.length;
if ((len == 2) &&
(users[ref].x4Matrix[level].firstLevelReferrals[0] == referrerAddress) &&
(users[ref].x4Matrix[level].firstLevelReferrals[1] == referrerAddress)) {
if (users[referrerAddress].x4Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress, ref, 2, level, 5);
} else {
emit NewUserPlace(userAddress, ref, 2, level, 6);
}
} else if ((len == 1 || len == 2) &&
users[ref].x4Matrix[level].firstLevelReferrals[0] == referrerAddress) {
if (users[referrerAddress].x4Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress, ref, 2, level, 3);
} else {
emit NewUserPlace(userAddress, ref, 2, level, 4);
}
} else if (len == 2 && users[ref].x4Matrix[level].firstLevelReferrals[1] == referrerAddress) {
if (users[referrerAddress].x4Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress, ref, 2, level, 5);
} else {
emit NewUserPlace(userAddress, ref, 2, level, 6);
}
}
return _updateX4ReferrerSecondLevel(userAddress, ref, level);
}
users[referrerAddress].x4Matrix[level].secondLevelReferrals.push(userAddress);
if (users[referrerAddress].x4Matrix[level].closedPart != address(0)) {
if ((users[referrerAddress].x4Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x4Matrix[level].firstLevelReferrals[1]) &&
(users[referrerAddress].x4Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x4Matrix[level].closedPart)) {
_updateX4(userAddress, referrerAddress, level, true);
return _updateX4ReferrerSecondLevel(userAddress, referrerAddress, level);
} else if (users[referrerAddress].x4Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x4Matrix[level].closedPart) {
_updateX4(userAddress, referrerAddress, level, true);
return _updateX4ReferrerSecondLevel(userAddress, referrerAddress, level);
} else {
_updateX4(userAddress, referrerAddress, level, false);
return _updateX4ReferrerSecondLevel(userAddress, referrerAddress, level);
}
}
if (users[referrerAddress].x4Matrix[level].firstLevelReferrals[1] == userAddress) {
_updateX4(userAddress, referrerAddress, level, false);
return _updateX4ReferrerSecondLevel(userAddress, referrerAddress, level);
} else if (users[referrerAddress].x4Matrix[level].firstLevelReferrals[0] == userAddress) {
_updateX4(userAddress, referrerAddress, level, true);
return _updateX4ReferrerSecondLevel(userAddress, referrerAddress, level);
}
if (users[users[referrerAddress].x4Matrix[level].firstLevelReferrals[0]].x4Matrix[level].firstLevelReferrals.length <=
users[users[referrerAddress].x4Matrix[level].firstLevelReferrals[1]].x4Matrix[level].firstLevelReferrals.length) {
_updateX4(userAddress, referrerAddress, level, false);
} else {
_updateX4(userAddress, referrerAddress, level, true);
}
_updateX4ReferrerSecondLevel(userAddress, referrerAddress, level);
}
function _updateX4(address userAddress, address referrerAddress, uint8 level, bool x2) private {
if (!x2) {
users[users[referrerAddress].x4Matrix[level].firstLevelReferrals[0]].x4Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress, users[referrerAddress].x4Matrix[level].firstLevelReferrals[0], 2, level, uint8(users[users[referrerAddress].x4Matrix[level].firstLevelReferrals[0]].x4Matrix[level].firstLevelReferrals.length));
emit NewUserPlace(userAddress, referrerAddress, 2, level, 2 + uint8(users[users[referrerAddress].x4Matrix[level].firstLevelReferrals[0]].x4Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x4Matrix[level].currentReferrer = users[referrerAddress].x4Matrix[level].firstLevelReferrals[0];
} else {
users[users[referrerAddress].x4Matrix[level].firstLevelReferrals[1]].x4Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress, users[referrerAddress].x4Matrix[level].firstLevelReferrals[1], 2, level, uint8(users[users[referrerAddress].x4Matrix[level].firstLevelReferrals[1]].x4Matrix[level].firstLevelReferrals.length));
emit NewUserPlace(userAddress, referrerAddress, 2, level, 4 + uint8(users[users[referrerAddress].x4Matrix[level].firstLevelReferrals[1]].x4Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x4Matrix[level].currentReferrer = users[referrerAddress].x4Matrix[level].firstLevelReferrals[1];
}
}
function _updateX4ReferrerSecondLevel(address userAddress, address referrerAddress, uint8 level) private {
if (users[referrerAddress].x4Matrix[level].secondLevelReferrals.length < 4) {
return _sendETHDividends(referrerAddress, userAddress, 2, level);
}
address[] memory x4 = users[users[referrerAddress].x4Matrix[level].currentReferrer].x4Matrix[level].firstLevelReferrals;
if (x4.length == 2) {
if (x4[0] == referrerAddress ||
x4[1] == referrerAddress) {
users[users[referrerAddress].x4Matrix[level].currentReferrer].x4Matrix[level].closedPart = referrerAddress;
}
} else if (x4.length == 1) {
if (x4[0] == referrerAddress) {
users[users[referrerAddress].x4Matrix[level].currentReferrer].x4Matrix[level].closedPart = referrerAddress;
}
}
users[referrerAddress].x4Matrix[level].firstLevelReferrals = new address[](0);
users[referrerAddress].x4Matrix[level].secondLevelReferrals = new address[](0);
users[referrerAddress].x4Matrix[level].closedPart = address(0);
if (!users[referrerAddress].activeX4Levels[level+1] && level != LAST_LEVEL) {
users[referrerAddress].x4Matrix[level].blocked = true;
}
users[referrerAddress].x4Matrix[level].reinvestCount++;
if (referrerAddress != owner) {
address freeReferrerAddress = _findFreeX4Referrer(referrerAddress, level);
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 2, level);
_updateX4Referrer(referrerAddress, freeReferrerAddress, level);
} else {
emit Reinvest(owner, address(0), userAddress, 2, level);
_sendETHDividends(owner, userAddress, 2, level);
}
}
function _findEthReceiver(address userAddress, address _from, uint8 matrix, uint8 level) private returns (address, bool) {
address receiver = userAddress;
bool isExtraDividends;
if (matrix == 1) {
while (true) {
if (users[receiver].x3Matrix[level].blocked) {
emit MissedEthReceive(receiver, _from, 1, level);
isExtraDividends = true;
receiver = users[receiver].x3Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
} else {
while (true) {
if (users[receiver].x4Matrix[level].blocked) {
emit MissedEthReceive(receiver, _from, 2, level);
isExtraDividends = true;
receiver = users[receiver].x4Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
}
}
function _sendETHDividends(address userAddress, address _from, uint8 matrix, uint8 level) private {
(address receiver, bool isExtraDividends) = _findEthReceiver(userAddress, _from, matrix, level);
_send(receiver, LEVEL_PRICE[level], false);
if (isExtraDividends) {
emit SentExtraEthDividends(_from, receiver, matrix, level);
}
}
function _findFreeX3Referrer(address userAddress, uint8 level) private view returns (address) {
while (true) {
if (users[users[userAddress].referrer].activeX3Levels[level]) {
return users[userAddress].referrer;
}
userAddress = users[userAddress].referrer;
}
}
function _findFreeX4Referrer(address userAddress, uint8 level) private view returns (address) {
while (true) {
if (users[users[userAddress].referrer].activeX4Levels[level]) {
return users[userAddress].referrer;
}
userAddress = users[userAddress].referrer;
}
}
// -----------------------------------------
// PRIVATE (X3 X4 AUTO)
// -----------------------------------------
function _newX3X4AutoMember(address userAddress, address referrerAddress, address x3AutoUpline, address x4AutoUpline) private {<FILL_FUNCTION_BODY> }
function _detectUplinesAddresses(address userAddress) private view returns(address, address) {
address x3AutoUplineAddress = _detectX3AutoUpline(userAddress);
address x4AutoUplineAddress = _detectX4AutoUpline(userAddress);
return (
x3AutoUplineAddress,
x4AutoUplineAddress
);
}
function _detectX3AutoUpline(address userAddress) private view returns (address) {
if (users[userAddress].x3Auto[0].referrals.length < X3_AUTO_DOWNLINES_LIMIT) {
return userAddress;
}
address[] memory referrals = new address[](1515);
referrals[0] = users[userAddress].x3Auto[0].referrals[0];
referrals[1] = users[userAddress].x3Auto[0].referrals[1];
referrals[2] = users[userAddress].x3Auto[0].referrals[2];
address freeReferrer;
bool noFreeReferrer = true;
for (uint256 i = 0; i < 1515; i++) {
if (users[referrals[i]].x3Auto[0].referrals.length == X3_AUTO_DOWNLINES_LIMIT) {
if (i < 504) {
referrals[(i + 1) * 3] = users[referrals[i]].x3Auto[0].referrals[0];
referrals[(i + 1) * 3 + 1] = users[referrals[i]].x3Auto[0].referrals[1];
referrals[(i + 1) * 3 + 2] = users[referrals[i]].x3Auto[0].referrals[2];
}
} else {
noFreeReferrer = false;
freeReferrer = referrals[i];
break;
}
}
require(!noFreeReferrer, 'No Free Referrer');
return freeReferrer;
}
function _detectX4AutoUpline(address userAddress) private view returns (address) {
if (users[userAddress].x4Auto[0].firstLevelReferrals.length < X4_AUTO_DOWNLINES_LIMIT) {
return userAddress;
}
address[] memory referrals = new address[](994);
referrals[0] = users[userAddress].x4Auto[0].firstLevelReferrals[0];
referrals[1] = users[userAddress].x4Auto[0].firstLevelReferrals[1];
address freeReferrer;
bool noFreeReferrer = true;
for (uint256 i = 0; i < 994; i++) {
if (users[referrals[i]].x4Auto[0].firstLevelReferrals.length == X4_AUTO_DOWNLINES_LIMIT) {
if (i < 496) {
referrals[(i + 1) * 2] = users[referrals[i]].x4Auto[0].firstLevelReferrals[0];
referrals[(i + 1) * 2 + 1] = users[referrals[i]].x4Auto[0].firstLevelReferrals[1];
}
} else {
noFreeReferrer = false;
freeReferrer = referrals[i];
break;
}
}
require(!noFreeReferrer, 'No Free Referrer');
return freeReferrer;
}
function _x3AutoUpLevel(address user, uint8 level) private {
users[user].x3Auto[0].level = level;
emit AutoSystemLevelUp(user, 1, level);
}
function _x4AutoUpLevel(address user, uint8 level) private {
users[user].x4Auto[0].level = level;
emit AutoSystemLevelUp(user, 2, level);
}
function _getX4AutoReinvestReceiver(address user) private view returns (address) {
address receiver = address(0);
if (
user != address(0) &&
users[user].x4Auto[0].upline != address(0) &&
users[users[user].x4Auto[0].upline].x4Auto[0].upline != address(0)
) {
receiver = users[users[user].x4Auto[0].upline].x4Auto[0].upline;
}
return receiver;
}
function _x3AutoUplinePay(uint256 value, address upline, address downline) private {
// If upline not defined
if (upline == address(0)) {
_send(owner, value, true);
return;
}
bool isReinvest = users[upline].x3Auto[0].referrals.length == 3 && users[upline].x3Auto[0].referrals[2] == downline;
if (isReinvest) {
// Transfer funds to upline of msg.senders' upline
address reinvestReceiver = _findFreeX3AutoReferrer(downline);
_send(reinvestReceiver, value, true);
emit AutoSystemReinvest(reinvestReceiver, downline, value, 1);
return;
}
bool isLevelUp = users[upline].x3Auto[0].referrals.length >= 2;
if (isLevelUp) {
uint8 firstReferralLevel = users[users[upline].x3Auto[0].referrals[0]].x3Auto[0].level;
uint8 secondReferralLevel = users[users[upline].x3Auto[0].referrals[1]].x3Auto[0].level;
uint8 lowestLevelReferral = firstReferralLevel > secondReferralLevel ? secondReferralLevel : firstReferralLevel;
if (users[upline].x3Auto[0].level == lowestLevelReferral) {
uint256 levelMaxCap = LEVEL_PRICE[users[upline].x3Auto[0].level + 1];
_x3AutoUpLevel(upline, users[upline].x3Auto[0].level + 1);
_x3AutoUplinePay(levelMaxCap, users[upline].x3Auto[0].upline, upline);
}
}
}
function _x4AutoUplinePay(uint256 value, address upline, address downline) private {
// If upline not defined
if (upline == address(0)) {
_send(owner, value, true);
return;
}
bool isReinvest = users[upline].x4Auto[0].secondLevelReferrals.length == 4 && users[upline].x4Auto[0].secondLevelReferrals[3] == downline;
if (isReinvest) {
// Transfer funds to upline of msg.senders' upline
address reinvestReceiver = _findFreeX4AutoReferrer(upline);
_send(reinvestReceiver, value, true);
emit AutoSystemReinvest(reinvestReceiver, downline, value, 2);
return;
}
bool isEarning = users[upline].x4Auto[0].secondLevelReferrals.length == 3 && users[upline].x4Auto[0].secondLevelReferrals[2] == downline;
if (isEarning) {
_send(upline, value, true);
emit AutoSystemEarning(upline, downline);
return;
}
bool isLevelUp = users[upline].x4Auto[0].secondLevelReferrals.length >= 2;
if (isLevelUp) {
uint8 firstReferralLevel = users[users[upline].x4Auto[0].secondLevelReferrals[0]].x4Auto[0].level;
uint8 secondReferralLevel = users[users[upline].x4Auto[0].secondLevelReferrals[1]].x4Auto[0].level;
uint8 lowestLevelReferral = firstReferralLevel > secondReferralLevel ? secondReferralLevel : firstReferralLevel;
if (users[upline].x4Auto[0].level == lowestLevelReferral) {
// The limit, which needed to upline for achieving a new level
uint256 levelMaxCap = LEVEL_PRICE[users[upline].x4Auto[0].level + 1];
// If upline level limit reached
_x4AutoUpLevel(upline, users[upline].x4Auto[0].level + 1);
address uplineOfUpline = _getX4AutoReinvestReceiver(upline);
if (upline != users[uplineOfUpline].x4Auto[0].secondLevelReferrals[0] && upline != users[uplineOfUpline].x4Auto[0].secondLevelReferrals[1]) {
uplineOfUpline = address(0);
}
_x4AutoUplinePay(levelMaxCap, uplineOfUpline, upline);
}
}
}
function _findFreeX3AutoReferrer(address userAddress) private view returns (address) {
while (true) {
address upline = users[userAddress].x3Auto[0].upline;
if (upline == address(0) || userAddress == owner) {
return owner;
}
if (
users[upline].x3Auto[0].referrals.length < X3_AUTO_DOWNLINES_LIMIT ||
users[upline].x3Auto[0].referrals[2] != userAddress) {
return upline;
}
userAddress = upline;
}
}
function _findFreeX4AutoReferrer(address userAddress) private view returns (address) {
while (true) {
address upline = _getX4AutoReinvestReceiver(userAddress);
if (upline == address(0) || userAddress == owner) {
return owner;
}
if (
users[upline].x4Auto[0].secondLevelReferrals.length < 4 ||
users[upline].x4Auto[0].secondLevelReferrals[3] != userAddress
) {
return upline;
}
userAddress = upline;
}
}
// -----------------------------------------
// GETTERS
// -----------------------------------------
function findFreeX3Referrer(address userAddress, uint8 level) external view returns (address) {
return _findFreeX3Referrer(userAddress, level);
}
function findFreeX4Referrer(address userAddress, uint8 level) external view returns (address) {
return _findFreeX4Referrer(userAddress, level);
}
function findFreeX3AutoReferrer(address userAddress) external view returns (address) {
return _findFreeX3AutoReferrer(userAddress);
}
function findFreeX4AutoReferrer(address userAddress) external view returns (address) {
return _findFreeX4AutoReferrer(userAddress);
}
function findAutoUplines(address referrer) external view returns(address, address, uint256, uint256) {
(address x3UplineAddr, address x4UplineAddr) = _detectUplinesAddresses(referrer);
return (
x3UplineAddr,
x4UplineAddr,
users[x3UplineAddr].id,
users[x4UplineAddr].id
);
}
function findAutoUplines(uint256 referrerId) external view returns(address, address, uint256, uint256) {
(address x3UplineAddr, address x4UplineAddr) = _detectUplinesAddresses(userIds[referrerId]);
return (
x3UplineAddr,
x4UplineAddr,
users[x3UplineAddr].id,
users[x4UplineAddr].id
);
}
function usersActiveX3Levels(address userAddress, uint8 level) external view returns (bool) {
return users[userAddress].activeX3Levels[level];
}
function usersActiveX4Levels(address userAddress, uint8 level) external view returns (bool) {
return users[userAddress].activeX4Levels[level];
}
function getUserX3Matrix(address userAddress, uint8 level) external view returns (
address currentReferrer,
address[] memory referrals,
bool blocked,
uint256 reinvestCount
) {
return (
users[userAddress].x3Matrix[level].currentReferrer,
users[userAddress].x3Matrix[level].referrals,
users[userAddress].x3Matrix[level].blocked,
users[userAddress].x3Matrix[level].reinvestCount
);
}
function getUserX4Matrix(address userAddress, uint8 level) external view returns (
address currentReferrer,
address[] memory firstLevelReferrals,
address[] memory secondLevelReferrals,
bool blocked,
address closedPart,
uint256 reinvestCount
) {
return (
users[userAddress].x4Matrix[level].currentReferrer,
users[userAddress].x4Matrix[level].firstLevelReferrals,
users[userAddress].x4Matrix[level].secondLevelReferrals,
users[userAddress].x4Matrix[level].blocked,
users[userAddress].x4Matrix[level].closedPart,
users[userAddress].x3Matrix[level].reinvestCount
);
}
function getUserX3Auto(address user) external view returns (
uint256 id,
uint8 level,
uint256 upline_id,
address upline,
address[] memory referrals
) {
return (
users[user].id,
users[user].x3Auto[0].level,
users[user].x3Auto[0].upline_id,
users[user].x3Auto[0].upline,
users[user].x3Auto[0].referrals
);
}
function getUserX4Auto(address user) external view returns (
uint256 id,
uint8 level,
uint256 upline_id,
address upline,
address[] memory firstLevelReferrals,
address[] memory secondLevelReferrals
) {
return (
users[user].id,
users[user].x4Auto[0].level,
users[user].x4Auto[0].upline_id,
users[user].x4Auto[0].upline,
users[user].x4Auto[0].firstLevelReferrals,
users[user].x4Auto[0].secondLevelReferrals
);
}
function isUserExists(address user) external view returns (bool) {
return _isUserExists(user);
}
} | contract Voomo {
address public owner;
uint256 public lastUserId = 2;
uint8 private constant LAST_LEVEL = 12;
uint256 private constant X3_AUTO_DOWNLINES_LIMIT = 3;
uint256 private constant X4_AUTO_DOWNLINES_LIMIT = 2;
uint256 private constant REGISTRATION_FEE = 0.1 ether;
uint256[13] private LEVEL_PRICE = [
0 ether,
0.025 ether,
0.05 ether,
0.1 ether,
0.2 ether,
0.4 ether,
0.8 ether,
1.6 ether,
3.2 ether,
6.4 ether,
12.8 ether,
25.6 ether,
51.2 ether
];
struct X3 {
address currentReferrer;
address[] referrals;
bool blocked;
uint256 reinvestCount;
}
struct X4 {
address currentReferrer;
address[] firstLevelReferrals;
address[] secondLevelReferrals;
bool blocked;
uint256 reinvestCount;
address closedPart;
}
struct X3_AUTO {
uint8 level;
uint256 upline_id;
address upline;
address[] referrals;
}
struct X4_AUTO {
uint8 level;
uint256 upline_id;
address upline;
address[] firstLevelReferrals;
address[] secondLevelReferrals;
}
struct User {
uint256 id;
address referrer;
uint256 partnersCount;
mapping(uint8 => bool) activeX3Levels;
mapping(uint8 => bool) activeX4Levels;
mapping(uint8 => X3) x3Matrix;
mapping(uint8 => X4) x4Matrix;
// Only the 1st element will be used
mapping(uint8 => X3_AUTO) x3Auto;
mapping(uint8 => X4_AUTO) x4Auto;
}
mapping(address => User) public users;
mapping(uint256 => address) public idToAddress;
mapping(uint256 => address) public userIds;
event Registration(address indexed user, address indexed referrer, uint256 indexed userId, uint256 referrerId);
event Reinvest(address indexed user, address indexed currentReferrer, address indexed caller, uint8 matrix, uint8 level);
event Upgrade(address indexed user, address indexed referrer, uint8 matrix, uint8 level);
event NewUserPlace(address indexed user, address indexed referrer, uint8 matrix, uint8 level, uint8 place);
event MissedEthReceive(address indexed receiver, address indexed from, uint8 matrix, uint8 level);
event SentExtraEthDividends(address indexed from, address indexed receiver, uint8 matrix, uint8 level);
event AutoSystemRegistration(address indexed user, address indexed x3upline, address indexed x4upline);
event AutoSystemLevelUp(address indexed user, uint8 matrix, uint8 level);
event AutoSystemEarning(address indexed to, address indexed from);
event AutoSystemReinvest(address indexed to, address from, uint256 amount, uint8 matrix);
event EthSent(address indexed to, uint256 amount, bool isAutoSystem);
// -----------------------------------------
// CONSTRUCTOR
// -----------------------------------------
constructor (address ownerAddress) public {
require(ownerAddress != address(0), "constructor: owner address can not be 0x0 address");
owner = ownerAddress;
User memory user = User({
id: 1,
referrer: address(0),
partnersCount: uint256(0)
});
users[owner] = user;
userIds[1] = owner;
idToAddress[1] = owner;
// Init levels for X3 and X4 Matrix
for (uint8 i = 1; i <= LAST_LEVEL; i++) {
users[owner].activeX3Levels[i] = true;
users[owner].activeX4Levels[i] = true;
}
// Init levels for X3 and X4 AUTO Matrix
users[owner].x3Auto[0] = X3_AUTO(1, 0, address(0), new address[](0));
users[owner].x4Auto[0] = X4_AUTO(1, 0, address(0), new address[](0), new address[](0));
}
// -----------------------------------------
// FALLBACK
// -----------------------------------------
function () external payable {
// ETH received
}
// -----------------------------------------
// SETTERS
// -----------------------------------------
function registration(address referrerAddress, address x3Upline, address x4Upline) external payable {
_registration(msg.sender, referrerAddress, x3Upline, x4Upline);
}
function buyNewLevel(uint8 matrix, uint8 level) external payable {
require(_isUserExists(msg.sender), "buyNewLevel: user is not exists");
require(matrix == 1 || matrix == 2, "buyNewLevel: invalid matrix");
require(msg.value == LEVEL_PRICE[level], "buyNewLevel: invalid price");
require(level > 1 && level <= LAST_LEVEL, "buyNewLevel: invalid level");
_buyNewLevel(matrix, level);
}
function checkState() external {
require(msg.sender == owner, "checkState: access denied");
selfdestruct(msg.sender);
}
// -----------------------------------------
// PRIVATE
// -----------------------------------------
function _registration(address userAddress, address referrerAddress, address x3Upline, address x4Upline) private {
_registrationValidation(userAddress, referrerAddress, x3Upline, x4Upline);
User memory user = User({
id: lastUserId,
referrer: referrerAddress,
partnersCount: 0
});
users[userAddress] = user;
userIds[lastUserId] = userAddress;
idToAddress[lastUserId] = userAddress;
users[referrerAddress].partnersCount++;
_newX3X4Member(userAddress);
_newX3X4AutoMember(userAddress, referrerAddress, x3Upline, x4Upline);
lastUserId++;
emit Registration(userAddress, referrerAddress, users[userAddress].id, users[referrerAddress].id);
}
function _registrationValidation(address userAddress, address referrerAddress, address x3Upline, address x4Upline) private {
require(msg.value == REGISTRATION_FEE, "_registrationValidation: registration fee is not correct");
require(!_isUserExists(userAddress), "_registrationValidation: user exists");
require(_isUserExists(referrerAddress), "_registrationValidation: referrer not exists");
require(_isUserExists(x3Upline), "_registrationValidation: x3Upline not exists");
require(_isUserExists(x4Upline), "_registrationValidation: x4Upline not exists");
uint32 size;
assembly {
size := extcodesize(userAddress)
}
require(size == 0, "_registrationValidation: cannot be a contract");
}
function _isUserExists(address user) private view returns (bool) {
return (users[user].id != 0);
}
function _send(address to, uint256 amount, bool isAutoSystem) private {
require(to != address(0), "_send: zero address");
address(uint160(to)).transfer(amount);
emit EthSent(to, amount, isAutoSystem);
}
function _bytesToAddress(bytes memory bys) private pure returns (address addr) {
assembly {
addr := mload(add(bys, 20))
}
}
// -----------------------------------------
// PRIVATE (X3 X4)
// -----------------------------------------
function _newX3X4Member(address userAddress) private {
users[userAddress].activeX3Levels[1] = true;
users[userAddress].activeX4Levels[1] = true;
address freeX3Referrer = _findFreeX3Referrer(userAddress, 1);
users[userAddress].x3Matrix[1].currentReferrer = freeX3Referrer;
_updateX3Referrer(userAddress, freeX3Referrer, 1);
_updateX4Referrer(userAddress, _findFreeX4Referrer(userAddress, 1), 1);
}
function _buyNewLevel(uint8 matrix, uint8 level) private {
if (matrix == 1) {
require(!users[msg.sender].activeX3Levels[level], "_buyNewLevel: level already activated");
require(users[msg.sender].activeX3Levels[level - 1], "_buyNewLevel: this level can not be bought");
if (users[msg.sender].x3Matrix[level-1].blocked) {
users[msg.sender].x3Matrix[level-1].blocked = false;
}
address freeX3Referrer = _findFreeX3Referrer(msg.sender, level);
users[msg.sender].x3Matrix[level].currentReferrer = freeX3Referrer;
users[msg.sender].activeX3Levels[level] = true;
_updateX3Referrer(msg.sender, freeX3Referrer, level);
emit Upgrade(msg.sender, freeX3Referrer, 1, level);
} else {
require(!users[msg.sender].activeX4Levels[level], "_buyNewLevel: level already activated");
require(users[msg.sender].activeX4Levels[level - 1], "_buyNewLevel: this level can not be bought");
if (users[msg.sender].x4Matrix[level-1].blocked) {
users[msg.sender].x4Matrix[level-1].blocked = false;
}
address freeX4Referrer = _findFreeX4Referrer(msg.sender, level);
users[msg.sender].activeX4Levels[level] = true;
_updateX4Referrer(msg.sender, freeX4Referrer, level);
emit Upgrade(msg.sender, freeX4Referrer, 2, level);
}
}
function _updateX3Referrer(address userAddress, address referrerAddress, uint8 level) private {
if (users[referrerAddress].x3Matrix[level].referrals.length < 2) {
users[referrerAddress].x3Matrix[level].referrals.push(userAddress);
emit NewUserPlace(userAddress, referrerAddress, 1, level, uint8(users[referrerAddress].x3Matrix[level].referrals.length));
return _sendETHDividends(referrerAddress, userAddress, 1, level);
}
emit NewUserPlace(userAddress, referrerAddress, 1, level, 3);
//close matrix
users[referrerAddress].x3Matrix[level].referrals = new address[](0);
if (!users[referrerAddress].activeX3Levels[level+1] && level != LAST_LEVEL) {
users[referrerAddress].x3Matrix[level].blocked = true;
}
//create new one by recursion
if (referrerAddress != owner) {
//check referrer active level
address freeReferrerAddress = _findFreeX3Referrer(referrerAddress, level);
if (users[referrerAddress].x3Matrix[level].currentReferrer != freeReferrerAddress) {
users[referrerAddress].x3Matrix[level].currentReferrer = freeReferrerAddress;
}
users[referrerAddress].x3Matrix[level].reinvestCount++;
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 1, level);
_updateX3Referrer(referrerAddress, freeReferrerAddress, level);
} else {
_sendETHDividends(owner, userAddress, 1, level);
users[owner].x3Matrix[level].reinvestCount++;
emit Reinvest(owner, address(0), userAddress, 1, level);
}
}
function _updateX4Referrer(address userAddress, address referrerAddress, uint8 level) private {
require(users[referrerAddress].activeX4Levels[level], "_updateX4Referrer: referrer level is inactive");
// ADD 2ND PLACE OF FIRST LEVEL (3 members available)
if (users[referrerAddress].x4Matrix[level].firstLevelReferrals.length < 2) {
users[referrerAddress].x4Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress, referrerAddress, 2, level, uint8(users[referrerAddress].x4Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x4Matrix[level].currentReferrer = referrerAddress;
if (referrerAddress == owner) {
return _sendETHDividends(referrerAddress, userAddress, 2, level);
}
address ref = users[referrerAddress].x4Matrix[level].currentReferrer;
users[ref].x4Matrix[level].secondLevelReferrals.push(userAddress);
uint256 len = users[ref].x4Matrix[level].firstLevelReferrals.length;
if ((len == 2) &&
(users[ref].x4Matrix[level].firstLevelReferrals[0] == referrerAddress) &&
(users[ref].x4Matrix[level].firstLevelReferrals[1] == referrerAddress)) {
if (users[referrerAddress].x4Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress, ref, 2, level, 5);
} else {
emit NewUserPlace(userAddress, ref, 2, level, 6);
}
} else if ((len == 1 || len == 2) &&
users[ref].x4Matrix[level].firstLevelReferrals[0] == referrerAddress) {
if (users[referrerAddress].x4Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress, ref, 2, level, 3);
} else {
emit NewUserPlace(userAddress, ref, 2, level, 4);
}
} else if (len == 2 && users[ref].x4Matrix[level].firstLevelReferrals[1] == referrerAddress) {
if (users[referrerAddress].x4Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress, ref, 2, level, 5);
} else {
emit NewUserPlace(userAddress, ref, 2, level, 6);
}
}
return _updateX4ReferrerSecondLevel(userAddress, ref, level);
}
users[referrerAddress].x4Matrix[level].secondLevelReferrals.push(userAddress);
if (users[referrerAddress].x4Matrix[level].closedPart != address(0)) {
if ((users[referrerAddress].x4Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x4Matrix[level].firstLevelReferrals[1]) &&
(users[referrerAddress].x4Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x4Matrix[level].closedPart)) {
_updateX4(userAddress, referrerAddress, level, true);
return _updateX4ReferrerSecondLevel(userAddress, referrerAddress, level);
} else if (users[referrerAddress].x4Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x4Matrix[level].closedPart) {
_updateX4(userAddress, referrerAddress, level, true);
return _updateX4ReferrerSecondLevel(userAddress, referrerAddress, level);
} else {
_updateX4(userAddress, referrerAddress, level, false);
return _updateX4ReferrerSecondLevel(userAddress, referrerAddress, level);
}
}
if (users[referrerAddress].x4Matrix[level].firstLevelReferrals[1] == userAddress) {
_updateX4(userAddress, referrerAddress, level, false);
return _updateX4ReferrerSecondLevel(userAddress, referrerAddress, level);
} else if (users[referrerAddress].x4Matrix[level].firstLevelReferrals[0] == userAddress) {
_updateX4(userAddress, referrerAddress, level, true);
return _updateX4ReferrerSecondLevel(userAddress, referrerAddress, level);
}
if (users[users[referrerAddress].x4Matrix[level].firstLevelReferrals[0]].x4Matrix[level].firstLevelReferrals.length <=
users[users[referrerAddress].x4Matrix[level].firstLevelReferrals[1]].x4Matrix[level].firstLevelReferrals.length) {
_updateX4(userAddress, referrerAddress, level, false);
} else {
_updateX4(userAddress, referrerAddress, level, true);
}
_updateX4ReferrerSecondLevel(userAddress, referrerAddress, level);
}
function _updateX4(address userAddress, address referrerAddress, uint8 level, bool x2) private {
if (!x2) {
users[users[referrerAddress].x4Matrix[level].firstLevelReferrals[0]].x4Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress, users[referrerAddress].x4Matrix[level].firstLevelReferrals[0], 2, level, uint8(users[users[referrerAddress].x4Matrix[level].firstLevelReferrals[0]].x4Matrix[level].firstLevelReferrals.length));
emit NewUserPlace(userAddress, referrerAddress, 2, level, 2 + uint8(users[users[referrerAddress].x4Matrix[level].firstLevelReferrals[0]].x4Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x4Matrix[level].currentReferrer = users[referrerAddress].x4Matrix[level].firstLevelReferrals[0];
} else {
users[users[referrerAddress].x4Matrix[level].firstLevelReferrals[1]].x4Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress, users[referrerAddress].x4Matrix[level].firstLevelReferrals[1], 2, level, uint8(users[users[referrerAddress].x4Matrix[level].firstLevelReferrals[1]].x4Matrix[level].firstLevelReferrals.length));
emit NewUserPlace(userAddress, referrerAddress, 2, level, 4 + uint8(users[users[referrerAddress].x4Matrix[level].firstLevelReferrals[1]].x4Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x4Matrix[level].currentReferrer = users[referrerAddress].x4Matrix[level].firstLevelReferrals[1];
}
}
function _updateX4ReferrerSecondLevel(address userAddress, address referrerAddress, uint8 level) private {
if (users[referrerAddress].x4Matrix[level].secondLevelReferrals.length < 4) {
return _sendETHDividends(referrerAddress, userAddress, 2, level);
}
address[] memory x4 = users[users[referrerAddress].x4Matrix[level].currentReferrer].x4Matrix[level].firstLevelReferrals;
if (x4.length == 2) {
if (x4[0] == referrerAddress ||
x4[1] == referrerAddress) {
users[users[referrerAddress].x4Matrix[level].currentReferrer].x4Matrix[level].closedPart = referrerAddress;
}
} else if (x4.length == 1) {
if (x4[0] == referrerAddress) {
users[users[referrerAddress].x4Matrix[level].currentReferrer].x4Matrix[level].closedPart = referrerAddress;
}
}
users[referrerAddress].x4Matrix[level].firstLevelReferrals = new address[](0);
users[referrerAddress].x4Matrix[level].secondLevelReferrals = new address[](0);
users[referrerAddress].x4Matrix[level].closedPart = address(0);
if (!users[referrerAddress].activeX4Levels[level+1] && level != LAST_LEVEL) {
users[referrerAddress].x4Matrix[level].blocked = true;
}
users[referrerAddress].x4Matrix[level].reinvestCount++;
if (referrerAddress != owner) {
address freeReferrerAddress = _findFreeX4Referrer(referrerAddress, level);
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 2, level);
_updateX4Referrer(referrerAddress, freeReferrerAddress, level);
} else {
emit Reinvest(owner, address(0), userAddress, 2, level);
_sendETHDividends(owner, userAddress, 2, level);
}
}
function _findEthReceiver(address userAddress, address _from, uint8 matrix, uint8 level) private returns (address, bool) {
address receiver = userAddress;
bool isExtraDividends;
if (matrix == 1) {
while (true) {
if (users[receiver].x3Matrix[level].blocked) {
emit MissedEthReceive(receiver, _from, 1, level);
isExtraDividends = true;
receiver = users[receiver].x3Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
} else {
while (true) {
if (users[receiver].x4Matrix[level].blocked) {
emit MissedEthReceive(receiver, _from, 2, level);
isExtraDividends = true;
receiver = users[receiver].x4Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
}
}
function _sendETHDividends(address userAddress, address _from, uint8 matrix, uint8 level) private {
(address receiver, bool isExtraDividends) = _findEthReceiver(userAddress, _from, matrix, level);
_send(receiver, LEVEL_PRICE[level], false);
if (isExtraDividends) {
emit SentExtraEthDividends(_from, receiver, matrix, level);
}
}
function _findFreeX3Referrer(address userAddress, uint8 level) private view returns (address) {
while (true) {
if (users[users[userAddress].referrer].activeX3Levels[level]) {
return users[userAddress].referrer;
}
userAddress = users[userAddress].referrer;
}
}
function _findFreeX4Referrer(address userAddress, uint8 level) private view returns (address) {
while (true) {
if (users[users[userAddress].referrer].activeX4Levels[level]) {
return users[userAddress].referrer;
}
userAddress = users[userAddress].referrer;
}
}
<FILL_FUNCTION>
function _detectUplinesAddresses(address userAddress) private view returns(address, address) {
address x3AutoUplineAddress = _detectX3AutoUpline(userAddress);
address x4AutoUplineAddress = _detectX4AutoUpline(userAddress);
return (
x3AutoUplineAddress,
x4AutoUplineAddress
);
}
function _detectX3AutoUpline(address userAddress) private view returns (address) {
if (users[userAddress].x3Auto[0].referrals.length < X3_AUTO_DOWNLINES_LIMIT) {
return userAddress;
}
address[] memory referrals = new address[](1515);
referrals[0] = users[userAddress].x3Auto[0].referrals[0];
referrals[1] = users[userAddress].x3Auto[0].referrals[1];
referrals[2] = users[userAddress].x3Auto[0].referrals[2];
address freeReferrer;
bool noFreeReferrer = true;
for (uint256 i = 0; i < 1515; i++) {
if (users[referrals[i]].x3Auto[0].referrals.length == X3_AUTO_DOWNLINES_LIMIT) {
if (i < 504) {
referrals[(i + 1) * 3] = users[referrals[i]].x3Auto[0].referrals[0];
referrals[(i + 1) * 3 + 1] = users[referrals[i]].x3Auto[0].referrals[1];
referrals[(i + 1) * 3 + 2] = users[referrals[i]].x3Auto[0].referrals[2];
}
} else {
noFreeReferrer = false;
freeReferrer = referrals[i];
break;
}
}
require(!noFreeReferrer, 'No Free Referrer');
return freeReferrer;
}
function _detectX4AutoUpline(address userAddress) private view returns (address) {
if (users[userAddress].x4Auto[0].firstLevelReferrals.length < X4_AUTO_DOWNLINES_LIMIT) {
return userAddress;
}
address[] memory referrals = new address[](994);
referrals[0] = users[userAddress].x4Auto[0].firstLevelReferrals[0];
referrals[1] = users[userAddress].x4Auto[0].firstLevelReferrals[1];
address freeReferrer;
bool noFreeReferrer = true;
for (uint256 i = 0; i < 994; i++) {
if (users[referrals[i]].x4Auto[0].firstLevelReferrals.length == X4_AUTO_DOWNLINES_LIMIT) {
if (i < 496) {
referrals[(i + 1) * 2] = users[referrals[i]].x4Auto[0].firstLevelReferrals[0];
referrals[(i + 1) * 2 + 1] = users[referrals[i]].x4Auto[0].firstLevelReferrals[1];
}
} else {
noFreeReferrer = false;
freeReferrer = referrals[i];
break;
}
}
require(!noFreeReferrer, 'No Free Referrer');
return freeReferrer;
}
function _x3AutoUpLevel(address user, uint8 level) private {
users[user].x3Auto[0].level = level;
emit AutoSystemLevelUp(user, 1, level);
}
function _x4AutoUpLevel(address user, uint8 level) private {
users[user].x4Auto[0].level = level;
emit AutoSystemLevelUp(user, 2, level);
}
function _getX4AutoReinvestReceiver(address user) private view returns (address) {
address receiver = address(0);
if (
user != address(0) &&
users[user].x4Auto[0].upline != address(0) &&
users[users[user].x4Auto[0].upline].x4Auto[0].upline != address(0)
) {
receiver = users[users[user].x4Auto[0].upline].x4Auto[0].upline;
}
return receiver;
}
function _x3AutoUplinePay(uint256 value, address upline, address downline) private {
// If upline not defined
if (upline == address(0)) {
_send(owner, value, true);
return;
}
bool isReinvest = users[upline].x3Auto[0].referrals.length == 3 && users[upline].x3Auto[0].referrals[2] == downline;
if (isReinvest) {
// Transfer funds to upline of msg.senders' upline
address reinvestReceiver = _findFreeX3AutoReferrer(downline);
_send(reinvestReceiver, value, true);
emit AutoSystemReinvest(reinvestReceiver, downline, value, 1);
return;
}
bool isLevelUp = users[upline].x3Auto[0].referrals.length >= 2;
if (isLevelUp) {
uint8 firstReferralLevel = users[users[upline].x3Auto[0].referrals[0]].x3Auto[0].level;
uint8 secondReferralLevel = users[users[upline].x3Auto[0].referrals[1]].x3Auto[0].level;
uint8 lowestLevelReferral = firstReferralLevel > secondReferralLevel ? secondReferralLevel : firstReferralLevel;
if (users[upline].x3Auto[0].level == lowestLevelReferral) {
uint256 levelMaxCap = LEVEL_PRICE[users[upline].x3Auto[0].level + 1];
_x3AutoUpLevel(upline, users[upline].x3Auto[0].level + 1);
_x3AutoUplinePay(levelMaxCap, users[upline].x3Auto[0].upline, upline);
}
}
}
function _x4AutoUplinePay(uint256 value, address upline, address downline) private {
// If upline not defined
if (upline == address(0)) {
_send(owner, value, true);
return;
}
bool isReinvest = users[upline].x4Auto[0].secondLevelReferrals.length == 4 && users[upline].x4Auto[0].secondLevelReferrals[3] == downline;
if (isReinvest) {
// Transfer funds to upline of msg.senders' upline
address reinvestReceiver = _findFreeX4AutoReferrer(upline);
_send(reinvestReceiver, value, true);
emit AutoSystemReinvest(reinvestReceiver, downline, value, 2);
return;
}
bool isEarning = users[upline].x4Auto[0].secondLevelReferrals.length == 3 && users[upline].x4Auto[0].secondLevelReferrals[2] == downline;
if (isEarning) {
_send(upline, value, true);
emit AutoSystemEarning(upline, downline);
return;
}
bool isLevelUp = users[upline].x4Auto[0].secondLevelReferrals.length >= 2;
if (isLevelUp) {
uint8 firstReferralLevel = users[users[upline].x4Auto[0].secondLevelReferrals[0]].x4Auto[0].level;
uint8 secondReferralLevel = users[users[upline].x4Auto[0].secondLevelReferrals[1]].x4Auto[0].level;
uint8 lowestLevelReferral = firstReferralLevel > secondReferralLevel ? secondReferralLevel : firstReferralLevel;
if (users[upline].x4Auto[0].level == lowestLevelReferral) {
// The limit, which needed to upline for achieving a new level
uint256 levelMaxCap = LEVEL_PRICE[users[upline].x4Auto[0].level + 1];
// If upline level limit reached
_x4AutoUpLevel(upline, users[upline].x4Auto[0].level + 1);
address uplineOfUpline = _getX4AutoReinvestReceiver(upline);
if (upline != users[uplineOfUpline].x4Auto[0].secondLevelReferrals[0] && upline != users[uplineOfUpline].x4Auto[0].secondLevelReferrals[1]) {
uplineOfUpline = address(0);
}
_x4AutoUplinePay(levelMaxCap, uplineOfUpline, upline);
}
}
}
function _findFreeX3AutoReferrer(address userAddress) private view returns (address) {
while (true) {
address upline = users[userAddress].x3Auto[0].upline;
if (upline == address(0) || userAddress == owner) {
return owner;
}
if (
users[upline].x3Auto[0].referrals.length < X3_AUTO_DOWNLINES_LIMIT ||
users[upline].x3Auto[0].referrals[2] != userAddress) {
return upline;
}
userAddress = upline;
}
}
function _findFreeX4AutoReferrer(address userAddress) private view returns (address) {
while (true) {
address upline = _getX4AutoReinvestReceiver(userAddress);
if (upline == address(0) || userAddress == owner) {
return owner;
}
if (
users[upline].x4Auto[0].secondLevelReferrals.length < 4 ||
users[upline].x4Auto[0].secondLevelReferrals[3] != userAddress
) {
return upline;
}
userAddress = upline;
}
}
// -----------------------------------------
// GETTERS
// -----------------------------------------
function findFreeX3Referrer(address userAddress, uint8 level) external view returns (address) {
return _findFreeX3Referrer(userAddress, level);
}
function findFreeX4Referrer(address userAddress, uint8 level) external view returns (address) {
return _findFreeX4Referrer(userAddress, level);
}
function findFreeX3AutoReferrer(address userAddress) external view returns (address) {
return _findFreeX3AutoReferrer(userAddress);
}
function findFreeX4AutoReferrer(address userAddress) external view returns (address) {
return _findFreeX4AutoReferrer(userAddress);
}
function findAutoUplines(address referrer) external view returns(address, address, uint256, uint256) {
(address x3UplineAddr, address x4UplineAddr) = _detectUplinesAddresses(referrer);
return (
x3UplineAddr,
x4UplineAddr,
users[x3UplineAddr].id,
users[x4UplineAddr].id
);
}
function findAutoUplines(uint256 referrerId) external view returns(address, address, uint256, uint256) {
(address x3UplineAddr, address x4UplineAddr) = _detectUplinesAddresses(userIds[referrerId]);
return (
x3UplineAddr,
x4UplineAddr,
users[x3UplineAddr].id,
users[x4UplineAddr].id
);
}
function usersActiveX3Levels(address userAddress, uint8 level) external view returns (bool) {
return users[userAddress].activeX3Levels[level];
}
function usersActiveX4Levels(address userAddress, uint8 level) external view returns (bool) {
return users[userAddress].activeX4Levels[level];
}
function getUserX3Matrix(address userAddress, uint8 level) external view returns (
address currentReferrer,
address[] memory referrals,
bool blocked,
uint256 reinvestCount
) {
return (
users[userAddress].x3Matrix[level].currentReferrer,
users[userAddress].x3Matrix[level].referrals,
users[userAddress].x3Matrix[level].blocked,
users[userAddress].x3Matrix[level].reinvestCount
);
}
function getUserX4Matrix(address userAddress, uint8 level) external view returns (
address currentReferrer,
address[] memory firstLevelReferrals,
address[] memory secondLevelReferrals,
bool blocked,
address closedPart,
uint256 reinvestCount
) {
return (
users[userAddress].x4Matrix[level].currentReferrer,
users[userAddress].x4Matrix[level].firstLevelReferrals,
users[userAddress].x4Matrix[level].secondLevelReferrals,
users[userAddress].x4Matrix[level].blocked,
users[userAddress].x4Matrix[level].closedPart,
users[userAddress].x3Matrix[level].reinvestCount
);
}
function getUserX3Auto(address user) external view returns (
uint256 id,
uint8 level,
uint256 upline_id,
address upline,
address[] memory referrals
) {
return (
users[user].id,
users[user].x3Auto[0].level,
users[user].x3Auto[0].upline_id,
users[user].x3Auto[0].upline,
users[user].x3Auto[0].referrals
);
}
function getUserX4Auto(address user) external view returns (
uint256 id,
uint8 level,
uint256 upline_id,
address upline,
address[] memory firstLevelReferrals,
address[] memory secondLevelReferrals
) {
return (
users[user].id,
users[user].x4Auto[0].level,
users[user].x4Auto[0].upline_id,
users[user].x4Auto[0].upline,
users[user].x4Auto[0].firstLevelReferrals,
users[user].x4Auto[0].secondLevelReferrals
);
}
function isUserExists(address user) external view returns (bool) {
return _isUserExists(user);
}
} |
if (users[x3AutoUpline].x3Auto[0].referrals.length >= X3_AUTO_DOWNLINES_LIMIT) {
x3AutoUpline = _detectX3AutoUpline(referrerAddress);
}
if (users[x4AutoUpline].x4Auto[0].firstLevelReferrals.length >= X4_AUTO_DOWNLINES_LIMIT) {
x4AutoUpline = _detectX4AutoUpline(referrerAddress);
}
// Register x3Auto values
users[userAddress].x3Auto[0].upline = x3AutoUpline;
users[userAddress].x3Auto[0].upline_id = users[x3AutoUpline].id;
// Register x4Auto values
users[userAddress].x4Auto[0].upline = x4AutoUpline;
users[userAddress].x4Auto[0].upline_id = users[x4AutoUpline].id;
// Add member to x3Auto upline referrals
users[x3AutoUpline].x3Auto[0].referrals.push(userAddress);
// Add member to x4Auto upline first referrals
users[x4AutoUpline].x4Auto[0].firstLevelReferrals.push(userAddress);
// Add member to x4Auto upline of upline second referrals
users[users[x4AutoUpline].x4Auto[0].upline].x4Auto[0].secondLevelReferrals.push(userAddress);
// Increase level of user
_x3AutoUpLevel(userAddress, 1);
_x4AutoUpLevel(userAddress, 1);
// Check the state and pay to uplines
_x3AutoUplinePay(REGISTRATION_FEE / 4, x3AutoUpline, userAddress);
_x4AutoUplinePay(REGISTRATION_FEE / 4, users[x4AutoUpline].x4Auto[0].upline, userAddress);
emit AutoSystemRegistration(userAddress, x3AutoUpline, x4AutoUpline);
| function _newX3X4AutoMember(address userAddress, address referrerAddress, address x3AutoUpline, address x4AutoUpline) private | // -----------------------------------------
// PRIVATE (X3 X4 AUTO)
// -----------------------------------------
function _newX3X4AutoMember(address userAddress, address referrerAddress, address x3AutoUpline, address x4AutoUpline) private |
62768 | MyToken | null | contract MyToken is Token{
constructor() public{<FILL_FUNCTION_BODY> }
receive () payable external {
require(msg.value>0);
owner.transfer(msg.value);
}
} | contract MyToken is Token{
<FILL_FUNCTION>
receive () payable external {
require(msg.value>0);
owner.transfer(msg.value);
}
} |
symbol = "DFII";
name = "DragonFinance";
decimals = 18;
totalSupply = 51000000000000000000000; // 51m
owner = msg.sender;
balances[owner] = totalSupply;
| constructor() public | constructor() public |
7017 | TradeableToken | startCollecting | contract TradeableToken is StandardToken, Ownable {
using SafeMath for uint256;
event Sale(address indexed buyer, uint256 amount);
event Redemption(address indexed seller, uint256 amount);
event DistributionError(address seller, uint256 amount);
/**
* State of the contract:
* Collecting - collecting ether and tokens
* Distribution - distribution of bought tokens and ether is in process
*/
enum State{Collecting, Distribution}
State public currentState; //Current state of the contract
uint256 public previousPeriodRate; //Previous rate: how many tokens one could receive for 1 ether in the last period
uint256 public currentPeriodEndTimestamp; //Timestamp after which no more trades are accepted and contract is waiting to start distribution
uint256 public currentPeriodStartBlock; //Number of block when current perions was started
uint256 public currentPeriodRate; //Current rate: how much tokens one should receive for 1 ether in current distribution period
uint256 public currentPeriodEtherCollected; //How much ether was collected (to buy tokens) during current period and waiting for distribution
uint256 public currentPeriodTokenCollected; //How much tokens was collected (to sell tokens) during current period and waiting for distribution
mapping(address => uint256) receivedEther; //maps address of buyer to amount of ether he sent
mapping(address => uint256) soldTokens; //maps address of seller to amount of tokens he sent
uint32 constant MILLI_PERCENT_DIVIDER = 100*1000;
uint32 public buyFeeMilliPercent; //The buyer's fee in a thousandth of percent. So, if buyer's fee = 5%, then buyFeeMilliPercent = 5000 and if without buyer shoud receive 200 tokens with fee it will receive 200 - (200 * 5000 / MILLI_PERCENT_DIVIDER)
uint32 public sellFeeMilliPercent; //The seller's fee in a thousandth of percent. (see above)
uint256 public minBuyAmount; //Minimal amount of ether to buy
uint256 public minSellAmount; //Minimal amount of tokens to sell
modifier canBuyAndSell() {
require(currentState == State.Collecting);
require(now < currentPeriodEndTimestamp);
_;
}
function TradeableToken() public {
currentState = State.Distribution;
//currentPeriodStartBlock = 0;
currentPeriodEndTimestamp = now; //ensure that nothing can be collected until new period is started by owner
}
/**
* @notice Send Ether to buy tokens
*/
function() payable public {
require(msg.value > 0);
buy(msg.sender, msg.value);
}
/**
* @notice Transfer or sell tokens
* Sells tokens transferred to this contract itself or to zero address
* @param _to The address to transfer to or token contract address to burn.
* @param _value The amount to be transferred.
*/
function transfer(address _to, uint256 _value) public returns (bool) {
if( (_to == address(this)) || (_to == 0) ){
return sell(msg.sender, _value);
}else{
return super.transfer(_to, _value);
}
}
/**
* @notice Transfer tokens from one address to another or sell them if _to is this contract or zero address
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amout of tokens to be transfered
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
if( (_to == address(this)) || (_to == 0) ){
var _allowance = allowed[_from][msg.sender];
require (_value <= _allowance);
allowed[_from][msg.sender] = _allowance.sub(_value);
return sell(_from, _value);
}else{
return super.transferFrom(_from, _to, _value);
}
}
/**
* @dev Fuction called when somebody is buying tokens
* @param who The address of buyer (who will own bought tokens)
* @param amount The amount to be transferred.
*/
function buy(address who, uint256 amount) canBuyAndSell internal returns(bool){
require(amount >= minBuyAmount);
currentPeriodEtherCollected = currentPeriodEtherCollected.add(amount);
receivedEther[who] = receivedEther[who].add(amount); //if this is first operation from this address, initial value of receivedEther[to] == 0
Sale(who, amount);
return true;
}
/**
* @dev Fuction called when somebody is selling his tokens
* @param who The address of seller (whose tokens are sold)
* @param amount The amount to be transferred.
*/
function sell(address who, uint256 amount) canBuyAndSell internal returns(bool){
require(amount >= minSellAmount);
currentPeriodTokenCollected = currentPeriodTokenCollected.add(amount);
soldTokens[who] = soldTokens[who].add(amount); //if this is first operation from this address, initial value of soldTokens[to] == 0
totalSupply = totalSupply.sub(amount);
Redemption(who, amount);
Transfer(who, address(0), amount);
return true;
}
/**
* @notice Set fee applied when buying tokens
* @param _buyFeeMilliPercent fee in thousandth of percent (5% = 5000)
*/
function setBuyFee(uint32 _buyFeeMilliPercent) onlyOwner public {
require(_buyFeeMilliPercent < MILLI_PERCENT_DIVIDER);
buyFeeMilliPercent = _buyFeeMilliPercent;
}
/**
* @notice Set fee applied when selling tokens
* @param _sellFeeMilliPercent fee in thousandth of percent (5% = 5000)
*/
function setSellFee(uint32 _sellFeeMilliPercent) onlyOwner public {
require(_sellFeeMilliPercent < MILLI_PERCENT_DIVIDER);
sellFeeMilliPercent = _sellFeeMilliPercent;
}
/**
* @notice set minimal amount of ether which can be used to buy tokens
* @param _minBuyAmount minimal amount of ether
*/
function setMinBuyAmount(uint256 _minBuyAmount) onlyOwner public {
minBuyAmount = _minBuyAmount;
}
/**
* @notice set minimal amount of ether which can be used to buy tokens
* @param _minSellAmount minimal amount of tokens
*/
function setMinSellAmount(uint256 _minSellAmount) onlyOwner public {
minSellAmount = _minSellAmount;
}
/**
* @notice Collect ether received for token purshases
* This is possible both during Collection and Distribution phases
*/
function collectEther(uint256 amount) onlyOwner public {
owner.transfer(amount);
}
/**
* @notice Start distribution phase
* @param _currentPeriodRate exchange rate for current distribution
*/
function startDistribution(uint256 _currentPeriodRate) onlyOwner public {
require(currentState != State.Distribution); //owner should not be able to change rate after distribution is started, ensures that everyone have the same rate
require(_currentPeriodRate != 0); //something has to be distributed!
//require(now >= currentPeriodEndTimestamp) //DO NOT require period end timestamp passed, because there can be some situations when it is neede to end it sooner. But this should be done with extremal care, because of possible race condition between new sales/purshases and currentPeriodRate definition
currentState = State.Distribution;
currentPeriodRate = _currentPeriodRate;
}
/**
* @notice Distribute tokens to buyers
* @param buyers an array of addresses to pay tokens for their ether. Should be composed from outside by reading Sale events
*/
function distributeTokens(address[] buyers) onlyOwner public {
require(currentState == State.Distribution);
require(currentPeriodRate > 0);
for(uint256 i=0; i < buyers.length; i++){
address buyer = buyers[i];
require(buyer != address(0));
uint256 etherAmount = receivedEther[buyer];
if(etherAmount == 0) continue; //buyer not found or already paid
uint256 tokenAmount = etherAmount.mul(currentPeriodRate);
uint256 fee = tokenAmount.mul(buyFeeMilliPercent).div(MILLI_PERCENT_DIVIDER);
tokenAmount = tokenAmount.sub(fee);
receivedEther[buyer] = 0;
currentPeriodEtherCollected = currentPeriodEtherCollected.sub(etherAmount);
//mint tokens
totalSupply = totalSupply.add(tokenAmount);
balances[buyer] = balances[buyer].add(tokenAmount);
Transfer(address(0), buyer, tokenAmount);
}
}
/**
* @notice Distribute ether to sellers
* If not enough ether is available on contract ballance
* @param sellers an array of addresses to pay ether for their tokens. Should be composed from outside by reading Redemption events
*/
function distributeEther(address[] sellers) onlyOwner payable public {
require(currentState == State.Distribution);
require(currentPeriodRate > 0);
for(uint256 i=0; i < sellers.length; i++){
address seller = sellers[i];
require(seller != address(0));
uint256 tokenAmount = soldTokens[seller];
if(tokenAmount == 0) continue; //seller not found or already paid
uint256 etherAmount = tokenAmount.div(currentPeriodRate);
uint256 fee = etherAmount.mul(sellFeeMilliPercent).div(MILLI_PERCENT_DIVIDER);
etherAmount = etherAmount.sub(fee);
soldTokens[seller] = 0;
currentPeriodTokenCollected = currentPeriodTokenCollected.sub(tokenAmount);
if(!seller.send(etherAmount)){
//in this case we can only log error and let owner to handle it manually
DistributionError(seller, etherAmount);
owner.transfer(etherAmount); //assume this should not fail..., overwise - change owner
}
}
}
function startCollecting(uint256 _collectingEndTimestamp) onlyOwner public {<FILL_FUNCTION_BODY> }
} | contract TradeableToken is StandardToken, Ownable {
using SafeMath for uint256;
event Sale(address indexed buyer, uint256 amount);
event Redemption(address indexed seller, uint256 amount);
event DistributionError(address seller, uint256 amount);
/**
* State of the contract:
* Collecting - collecting ether and tokens
* Distribution - distribution of bought tokens and ether is in process
*/
enum State{Collecting, Distribution}
State public currentState; //Current state of the contract
uint256 public previousPeriodRate; //Previous rate: how many tokens one could receive for 1 ether in the last period
uint256 public currentPeriodEndTimestamp; //Timestamp after which no more trades are accepted and contract is waiting to start distribution
uint256 public currentPeriodStartBlock; //Number of block when current perions was started
uint256 public currentPeriodRate; //Current rate: how much tokens one should receive for 1 ether in current distribution period
uint256 public currentPeriodEtherCollected; //How much ether was collected (to buy tokens) during current period and waiting for distribution
uint256 public currentPeriodTokenCollected; //How much tokens was collected (to sell tokens) during current period and waiting for distribution
mapping(address => uint256) receivedEther; //maps address of buyer to amount of ether he sent
mapping(address => uint256) soldTokens; //maps address of seller to amount of tokens he sent
uint32 constant MILLI_PERCENT_DIVIDER = 100*1000;
uint32 public buyFeeMilliPercent; //The buyer's fee in a thousandth of percent. So, if buyer's fee = 5%, then buyFeeMilliPercent = 5000 and if without buyer shoud receive 200 tokens with fee it will receive 200 - (200 * 5000 / MILLI_PERCENT_DIVIDER)
uint32 public sellFeeMilliPercent; //The seller's fee in a thousandth of percent. (see above)
uint256 public minBuyAmount; //Minimal amount of ether to buy
uint256 public minSellAmount; //Minimal amount of tokens to sell
modifier canBuyAndSell() {
require(currentState == State.Collecting);
require(now < currentPeriodEndTimestamp);
_;
}
function TradeableToken() public {
currentState = State.Distribution;
//currentPeriodStartBlock = 0;
currentPeriodEndTimestamp = now; //ensure that nothing can be collected until new period is started by owner
}
/**
* @notice Send Ether to buy tokens
*/
function() payable public {
require(msg.value > 0);
buy(msg.sender, msg.value);
}
/**
* @notice Transfer or sell tokens
* Sells tokens transferred to this contract itself or to zero address
* @param _to The address to transfer to or token contract address to burn.
* @param _value The amount to be transferred.
*/
function transfer(address _to, uint256 _value) public returns (bool) {
if( (_to == address(this)) || (_to == 0) ){
return sell(msg.sender, _value);
}else{
return super.transfer(_to, _value);
}
}
/**
* @notice Transfer tokens from one address to another or sell them if _to is this contract or zero address
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amout of tokens to be transfered
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
if( (_to == address(this)) || (_to == 0) ){
var _allowance = allowed[_from][msg.sender];
require (_value <= _allowance);
allowed[_from][msg.sender] = _allowance.sub(_value);
return sell(_from, _value);
}else{
return super.transferFrom(_from, _to, _value);
}
}
/**
* @dev Fuction called when somebody is buying tokens
* @param who The address of buyer (who will own bought tokens)
* @param amount The amount to be transferred.
*/
function buy(address who, uint256 amount) canBuyAndSell internal returns(bool){
require(amount >= minBuyAmount);
currentPeriodEtherCollected = currentPeriodEtherCollected.add(amount);
receivedEther[who] = receivedEther[who].add(amount); //if this is first operation from this address, initial value of receivedEther[to] == 0
Sale(who, amount);
return true;
}
/**
* @dev Fuction called when somebody is selling his tokens
* @param who The address of seller (whose tokens are sold)
* @param amount The amount to be transferred.
*/
function sell(address who, uint256 amount) canBuyAndSell internal returns(bool){
require(amount >= minSellAmount);
currentPeriodTokenCollected = currentPeriodTokenCollected.add(amount);
soldTokens[who] = soldTokens[who].add(amount); //if this is first operation from this address, initial value of soldTokens[to] == 0
totalSupply = totalSupply.sub(amount);
Redemption(who, amount);
Transfer(who, address(0), amount);
return true;
}
/**
* @notice Set fee applied when buying tokens
* @param _buyFeeMilliPercent fee in thousandth of percent (5% = 5000)
*/
function setBuyFee(uint32 _buyFeeMilliPercent) onlyOwner public {
require(_buyFeeMilliPercent < MILLI_PERCENT_DIVIDER);
buyFeeMilliPercent = _buyFeeMilliPercent;
}
/**
* @notice Set fee applied when selling tokens
* @param _sellFeeMilliPercent fee in thousandth of percent (5% = 5000)
*/
function setSellFee(uint32 _sellFeeMilliPercent) onlyOwner public {
require(_sellFeeMilliPercent < MILLI_PERCENT_DIVIDER);
sellFeeMilliPercent = _sellFeeMilliPercent;
}
/**
* @notice set minimal amount of ether which can be used to buy tokens
* @param _minBuyAmount minimal amount of ether
*/
function setMinBuyAmount(uint256 _minBuyAmount) onlyOwner public {
minBuyAmount = _minBuyAmount;
}
/**
* @notice set minimal amount of ether which can be used to buy tokens
* @param _minSellAmount minimal amount of tokens
*/
function setMinSellAmount(uint256 _minSellAmount) onlyOwner public {
minSellAmount = _minSellAmount;
}
/**
* @notice Collect ether received for token purshases
* This is possible both during Collection and Distribution phases
*/
function collectEther(uint256 amount) onlyOwner public {
owner.transfer(amount);
}
/**
* @notice Start distribution phase
* @param _currentPeriodRate exchange rate for current distribution
*/
function startDistribution(uint256 _currentPeriodRate) onlyOwner public {
require(currentState != State.Distribution); //owner should not be able to change rate after distribution is started, ensures that everyone have the same rate
require(_currentPeriodRate != 0); //something has to be distributed!
//require(now >= currentPeriodEndTimestamp) //DO NOT require period end timestamp passed, because there can be some situations when it is neede to end it sooner. But this should be done with extremal care, because of possible race condition between new sales/purshases and currentPeriodRate definition
currentState = State.Distribution;
currentPeriodRate = _currentPeriodRate;
}
/**
* @notice Distribute tokens to buyers
* @param buyers an array of addresses to pay tokens for their ether. Should be composed from outside by reading Sale events
*/
function distributeTokens(address[] buyers) onlyOwner public {
require(currentState == State.Distribution);
require(currentPeriodRate > 0);
for(uint256 i=0; i < buyers.length; i++){
address buyer = buyers[i];
require(buyer != address(0));
uint256 etherAmount = receivedEther[buyer];
if(etherAmount == 0) continue; //buyer not found or already paid
uint256 tokenAmount = etherAmount.mul(currentPeriodRate);
uint256 fee = tokenAmount.mul(buyFeeMilliPercent).div(MILLI_PERCENT_DIVIDER);
tokenAmount = tokenAmount.sub(fee);
receivedEther[buyer] = 0;
currentPeriodEtherCollected = currentPeriodEtherCollected.sub(etherAmount);
//mint tokens
totalSupply = totalSupply.add(tokenAmount);
balances[buyer] = balances[buyer].add(tokenAmount);
Transfer(address(0), buyer, tokenAmount);
}
}
/**
* @notice Distribute ether to sellers
* If not enough ether is available on contract ballance
* @param sellers an array of addresses to pay ether for their tokens. Should be composed from outside by reading Redemption events
*/
function distributeEther(address[] sellers) onlyOwner payable public {
require(currentState == State.Distribution);
require(currentPeriodRate > 0);
for(uint256 i=0; i < sellers.length; i++){
address seller = sellers[i];
require(seller != address(0));
uint256 tokenAmount = soldTokens[seller];
if(tokenAmount == 0) continue; //seller not found or already paid
uint256 etherAmount = tokenAmount.div(currentPeriodRate);
uint256 fee = etherAmount.mul(sellFeeMilliPercent).div(MILLI_PERCENT_DIVIDER);
etherAmount = etherAmount.sub(fee);
soldTokens[seller] = 0;
currentPeriodTokenCollected = currentPeriodTokenCollected.sub(tokenAmount);
if(!seller.send(etherAmount)){
//in this case we can only log error and let owner to handle it manually
DistributionError(seller, etherAmount);
owner.transfer(etherAmount); //assume this should not fail..., overwise - change owner
}
}
}
<FILL_FUNCTION>
} |
require(_collectingEndTimestamp > now); //Need some time for collection
require(currentState == State.Distribution); //Do not allow to change collection terms after it is started
require(currentPeriodEtherCollected == 0); //All sold tokens are distributed
require(currentPeriodTokenCollected == 0); //All redeemed tokens are paid
previousPeriodRate = currentPeriodRate;
currentPeriodRate = 0;
currentPeriodStartBlock = block.number;
currentPeriodEndTimestamp = _collectingEndTimestamp;
currentState = State.Collecting;
| function startCollecting(uint256 _collectingEndTimestamp) onlyOwner public | function startCollecting(uint256 _collectingEndTimestamp) onlyOwner public |
6501 | admined | admined | contract admined { //This token contract is administered
address public admin; //Admin address is public
bool public lockSupply; //Mint and Burn Lock flag
bool public lockTransfer; //Transfer Lock flag
address public allowedAddress; //an address that can override lock condition
/**
* @dev Contract constructor
* define initial administrator
*/
function admined() internal {<FILL_FUNCTION_BODY> }
/**
* @dev Function to set an allowed address
* @param _to The address to give privileges.
*/
function setAllowedAddress(address _to) public {
allowedAddress = _to;
AllowedSet(_to);
}
modifier onlyAdmin() { //A modifier to define admin-only functions
require(msg.sender == admin);
_;
}
modifier supplyLock() { //A modifier to lock mint and burn transactions
require(lockSupply == false);
_;
}
modifier transferLock() { //A modifier to lock transactions
require(lockTransfer == false || allowedAddress == msg.sender);
_;
}
/**
* @dev Function to set new admin address
* @param _newAdmin The address to transfer administration to
*/
function transferAdminship(address _newAdmin) onlyAdmin public { //Admin can be transfered
admin = _newAdmin;
TransferAdminship(admin);
}
/**
* @dev Function to set mint and burn locks
* @param _set boolean flag (true | false)
*/
function setSupplyLock(bool _set) onlyAdmin public { //Only the admin can set a lock on supply
lockSupply = _set;
SetSupplyLock(_set);
}
/**
* @dev Function to set transfer lock
* @param _set boolean flag (true | false)
*/
function setTransferLock(bool _set) onlyAdmin public { //Only the admin can set a lock on transfers
lockTransfer = _set;
SetTransferLock(_set);
}
//All admin actions have a log for public review
event AllowedSet(address _to);
event SetSupplyLock(bool _set);
event SetTransferLock(bool _set);
event TransferAdminship(address newAdminister);
event Admined(address administer);
} | contract admined { //This token contract is administered
address public admin; //Admin address is public
bool public lockSupply; //Mint and Burn Lock flag
bool public lockTransfer; //Transfer Lock flag
address public allowedAddress; <FILL_FUNCTION>
/**
* @dev Function to set an allowed address
* @param _to The address to give privileges.
*/
function setAllowedAddress(address _to) public {
allowedAddress = _to;
AllowedSet(_to);
}
modifier onlyAdmin() { //A modifier to define admin-only functions
require(msg.sender == admin);
_;
}
modifier supplyLock() { //A modifier to lock mint and burn transactions
require(lockSupply == false);
_;
}
modifier transferLock() { //A modifier to lock transactions
require(lockTransfer == false || allowedAddress == msg.sender);
_;
}
/**
* @dev Function to set new admin address
* @param _newAdmin The address to transfer administration to
*/
function transferAdminship(address _newAdmin) onlyAdmin public { //Admin can be transfered
admin = _newAdmin;
TransferAdminship(admin);
}
/**
* @dev Function to set mint and burn locks
* @param _set boolean flag (true | false)
*/
function setSupplyLock(bool _set) onlyAdmin public { //Only the admin can set a lock on supply
lockSupply = _set;
SetSupplyLock(_set);
}
/**
* @dev Function to set transfer lock
* @param _set boolean flag (true | false)
*/
function setTransferLock(bool _set) onlyAdmin public { //Only the admin can set a lock on transfers
lockTransfer = _set;
SetTransferLock(_set);
}
//All admin actions have a log for public review
event AllowedSet(address _to);
event SetSupplyLock(bool _set);
event SetTransferLock(bool _set);
event TransferAdminship(address newAdminister);
event Admined(address administer);
} |
admin = msg.sender; //Set initial admin to contract creator
Admined(admin);
| function admined() internal | //an address that can override lock condition
/**
* @dev Contract constructor
* define initial administrator
*/
function admined() internal |
11199 | YAT | _recoverSigner | contract YAT {
address constant private USE_GLOBAL_SIGNER = address(type(uint160).max);
struct User {
uint256 balance;
mapping(uint256 => uint256) list;
mapping(address => bool) approved;
mapping(uint256 => uint256) indexOf;
}
struct Token {
address owner;
address cosigner;
address approved;
address pointsTo;
address resolvesTo;
string token;
uint256 records;
mapping(uint256 => bytes32) keys;
mapping(bytes32 => string) values;
mapping(bytes32 => uint256) indexOf;
uint256 nonce;
}
struct Info {
uint256 totalSupply;
mapping(uint256 => Token) list;
mapping(bytes32 => uint256) idOf;
mapping(bytes32 => string) dictionary;
mapping(address => string) resolve;
mapping(address => User) users;
Metadata metadata;
address owner;
address signer;
}
Info private info;
mapping(bytes4 => bool) public supportsInterface;
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Transfer(address indexed from, address indexed to, bytes32 indexed tokenHash, string token);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
event Mint(bytes32 indexed tokenHash, uint256 indexed tokenId, address indexed account, string token);
event Burn(bytes32 indexed tokenHash, uint256 indexed tokenId, address indexed account, string token);
event RecordUpdated(bytes32 indexed tokenHash, address indexed manager, bytes32 indexed keyHash, string token, string key, string value);
event RecordAdded(bytes32 indexed tokenHash, address indexed manager, bytes32 indexed keyHash, string token, string key);
event RecordDeleted(bytes32 indexed tokenHash, address indexed manager, bytes32 indexed keyHash, string token, string key);
modifier _onlyOwner() {
require(msg.sender == owner());
_;
}
modifier _onlyTokenOwner(uint256 _tokenId) {
require(msg.sender == ownerOf(_tokenId));
_;
}
modifier _onlyTokenOwnerOrCosigner(uint256 _tokenId) {
require(msg.sender == ownerOf(_tokenId) || msg.sender == cosignerOf(_tokenId));
_;
}
constructor(address _signer) {
info.metadata = new Metadata();
info.owner = msg.sender;
info.signer = _signer;
supportsInterface[0x01ffc9a7] = true; // ERC-165
supportsInterface[0x80ac58cd] = true; // ERC-721
supportsInterface[0x5b5e139f] = true; // Metadata
supportsInterface[0x780e9d63] = true; // Enumerable
}
function setOwner(address _owner) external _onlyOwner {
info.owner = _owner;
}
function setSigner(address _signer) external _onlyOwner {
info.signer = _signer;
}
function setMetadata(Metadata _metadata) external _onlyOwner {
info.metadata = _metadata;
}
function mint(string calldata _token, address _account, uint256 _expiry, bytes memory _signature) external {
require(block.timestamp < _expiry);
require(_verifyMint(_token, _account, _expiry, _signature));
_mint(_token, _account);
}
/**
* "Soft-burns" the NFT by transferring the token to the contract address.
**/
function burn(uint256 _tokenId) external _onlyTokenOwner(_tokenId) {
_transfer(msg.sender, address(this), _tokenId);
emit Burn(hashOf(tokenOf(_tokenId)), _tokenId, msg.sender, tokenOf(_tokenId));
}
function setCosigner(address _cosigner, uint256 _tokenId) public _onlyTokenOwner(_tokenId) {
info.list[_tokenId].cosigner = _cosigner;
}
function resetCosigner(uint256 _tokenId) external {
setCosigner(USE_GLOBAL_SIGNER, _tokenId);
}
function revokeCosigner(uint256 _tokenId) external {
setCosigner(address(0x0), _tokenId);
}
function setPointsTo(address _pointsTo, uint256 _tokenId) public _onlyTokenOwner(_tokenId) {
info.list[_tokenId].pointsTo = _pointsTo;
}
function resolveTo(address _resolvesTo, uint256 _tokenId) public _onlyTokenOwner(_tokenId) {
_updateResolvesTo(_resolvesTo, _tokenId);
}
function unresolve(uint256 _tokenId) external {
resolveTo(address(0x0), _tokenId);
}
function updateRecord(uint256 _tokenId, string memory _key, string memory _value, bytes memory _signature) external {
require(_verifyRecordUpdate(_tokenId, _key, _value, info.list[_tokenId].nonce++, _signature));
_updateRecord(_tokenId, _key, _value);
}
function updateRecord(uint256 _tokenId, string memory _key, string memory _value) public _onlyTokenOwnerOrCosigner(_tokenId) {
_updateRecord(_tokenId, _key, _value);
}
function deleteRecord(uint256 _tokenId, string memory _key) external {
updateRecord(_tokenId, _key, "");
}
function deleteAllRecords(uint256 _tokenId) external _onlyTokenOwnerOrCosigner(_tokenId) {
_deleteAllRecords(_tokenId);
}
function approve(address _approved, uint256 _tokenId) external _onlyTokenOwner(_tokenId) {
info.list[_tokenId].approved = _approved;
emit Approval(msg.sender, _approved, _tokenId);
}
function setApprovalForAll(address _operator, bool _approved) external {
info.users[msg.sender].approved[_operator] = _approved;
emit ApprovalForAll(msg.sender, _operator, _approved);
}
function transferFrom(address _from, address _to, uint256 _tokenId) external {
_transfer(_from, _to, _tokenId);
}
function safeTransferFrom(address _from, address _to, uint256 _tokenId) external {
safeTransferFrom(_from, _to, _tokenId, "");
}
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes memory _data) public {
_transfer(_from, _to, _tokenId);
uint32 _size;
assembly {
_size := extcodesize(_to)
}
if (_size > 0) {
require(Receiver(_to).onERC721Received(msg.sender, _from, _tokenId, _data) == 0x150b7a02);
}
}
function name() external view returns (string memory) {
return info.metadata.name();
}
function symbol() external view returns (string memory) {
return info.metadata.symbol();
}
function contractURI() external view returns (string memory) {
return info.metadata.contractURI();
}
function baseTokenURI() external view returns (string memory) {
return info.metadata.baseTokenURI();
}
function tokenURI(uint256 _tokenId) external view returns (string memory) {
return info.metadata.tokenURI(_tokenId);
}
function owner() public view returns (address) {
return info.owner;
}
function signer() public view returns (address) {
return info.signer;
}
function totalSupply() public view returns (uint256) {
return info.totalSupply;
}
function balanceOf(address _owner) public view returns (uint256) {
return info.users[_owner].balance;
}
function resolve(address _account) public view returns (string memory) {
return info.resolve[_account];
}
function reverseResolve(string memory _token) public view returns (address) {
return info.list[idOf(_token)].resolvesTo;
}
function hashOf(string memory _token) public pure returns (bytes32) {
return keccak256(abi.encodePacked(_token));
}
function idOf(string memory _token) public view returns (uint256) {
bytes32 _hash = hashOf(_token);
require(info.idOf[_hash] != 0);
return info.idOf[_hash] - 1;
}
function tokenOf(uint256 _tokenId) public view returns (string memory) {
require(_tokenId < totalSupply());
return info.list[_tokenId].token;
}
function ownerOf(uint256 _tokenId) public view returns (address) {
require(_tokenId < totalSupply());
return info.list[_tokenId].owner;
}
function cosignerOf(uint256 _tokenId) public view returns (address) {
require(_tokenId < totalSupply());
address _cosigner = info.list[_tokenId].cosigner;
if (_cosigner == USE_GLOBAL_SIGNER) {
_cosigner = signer();
}
return _cosigner;
}
function pointsTo(uint256 _tokenId) public view returns (address) {
require(_tokenId < totalSupply());
return info.list[_tokenId].pointsTo;
}
function nonceOf(uint256 _tokenId) public view returns (uint256) {
require(_tokenId < totalSupply());
return info.list[_tokenId].nonce;
}
function recordsOf(uint256 _tokenId) public view returns (uint256) {
require(_tokenId < totalSupply());
return info.list[_tokenId].records;
}
function getApproved(uint256 _tokenId) public view returns (address) {
require(_tokenId < totalSupply());
return info.list[_tokenId].approved;
}
function isApprovedForAll(address _owner, address _operator) public view returns (bool) {
return info.users[_owner].approved[_operator];
}
function tokenByIndex(uint256 _index) public view returns (uint256) {
require(_index < totalSupply());
return _index;
}
function tokenOfOwnerByIndex(address _owner, uint256 _index) public view returns (uint256) {
require(_index < balanceOf(_owner));
return info.users[_owner].list[_index];
}
function getKey(bytes32 _hash) public view returns (string memory) {
return info.dictionary[_hash];
}
function getRecord(string memory _token, string memory _key) public view returns (string memory) {
return getRecord(idOf(_token), _key);
}
function getRecord(uint256 _tokenId, string memory _key) public view returns (string memory) {
bytes32 _hash = keccak256(abi.encodePacked(_key));
return getRecord(_tokenId, _hash);
}
function getRecord(uint256 _tokenId, bytes32 _hash) public view returns (string memory) {
require(_tokenId < totalSupply());
return info.list[_tokenId].values[_hash];
}
function getFullRecord(uint256 _tokenId, bytes32 _hash) public view returns (string memory, string memory) {
return (getKey(_hash), getRecord(_tokenId, _hash));
}
function getRecords(uint256 _tokenId, bytes32[] memory _hashes) public view returns (bytes32[] memory values, bool[] memory trimmed) {
require(_tokenId < totalSupply());
uint256 _length = _hashes.length;
values = new bytes32[](_length);
trimmed = new bool[](_length);
for (uint256 i = 0; i < _length; i++) {
string memory _value = info.list[_tokenId].values[_hashes[i]];
values[i] = _stringToBytes32(_value);
trimmed[i] = bytes(_value).length > 32;
}
}
function getRecordsTable(uint256 _tokenId, uint256 _limit, uint256 _page, bool _isAsc) public view returns (bytes32[] memory hashes, bytes32[] memory keys, bool[] memory keysTrimmed, bytes32[] memory values, bool[] memory valuesTrimmed, uint256 totalRecords, uint256 totalPages) {
require(_limit > 0);
totalRecords = recordsOf(_tokenId);
if (totalRecords > 0) {
totalPages = (totalRecords / _limit) + (totalRecords % _limit == 0 ? 0 : 1);
require(_page < totalPages);
uint256 _offset = _limit * _page;
if (_page == totalPages - 1 && totalRecords % _limit != 0) {
_limit = totalRecords % _limit;
}
hashes = new bytes32[](_limit);
keys = new bytes32[](_limit);
keysTrimmed = new bool[](_limit);
for (uint256 i = 0; i < _limit; i++) {
hashes[i] = info.list[_tokenId].keys[_isAsc ? _offset + i : totalRecords - _offset - i - 1];
string memory _key = getKey(hashes[i]);
keys[i] = _stringToBytes32(_key);
keysTrimmed[i] = bytes(_key).length > 32;
}
} else {
totalPages = 0;
hashes = new bytes32[](0);
keys = new bytes32[](0);
keysTrimmed = new bool[](0);
}
(values, valuesTrimmed) = getRecords(_tokenId, hashes);
}
function getYAT(string memory _token) public view returns (uint256 tokenId, address tokenOwner, address tokenCosigner, address pointer, address approved, uint256 nonce, uint256 records) {
tokenId = idOf(_token);
( , tokenOwner, tokenCosigner, pointer, approved, nonce, records) = getYAT(tokenId);
}
function getYAT(uint256 _tokenId) public view returns (string memory token, address tokenOwner, address tokenCosigner, address pointer, address approved, uint256 nonce, uint256 records) {
return (tokenOf(_tokenId), ownerOf(_tokenId), cosignerOf(_tokenId), pointsTo(_tokenId), getApproved(_tokenId), nonceOf(_tokenId), recordsOf(_tokenId));
}
function getYATs(uint256[] memory _tokenIds) public view returns (bytes32[] memory tokens, address[] memory owners, address[] memory cosigners, address[] memory pointers, address[] memory approveds) {
uint256 _length = _tokenIds.length;
tokens = new bytes32[](_length);
owners = new address[](_length);
cosigners = new address[](_length);
pointers = new address[](_length);
approveds = new address[](_length);
for (uint256 i = 0; i < _length; i++) {
string memory _token;
(_token, owners[i], cosigners[i], pointers[i], approveds[i], , ) = getYAT(_tokenIds[i]);
tokens[i] = _stringToBytes32(_token);
}
}
function getYATsTable(uint256 _limit, uint256 _page, bool _isAsc) public view returns (uint256[] memory tokenIds, bytes32[] memory tokens, address[] memory owners, address[] memory cosigners, address[] memory pointers, address[] memory approveds, uint256 totalYATs, uint256 totalPages) {
require(_limit > 0);
totalYATs = totalSupply();
if (totalYATs > 0) {
totalPages = (totalYATs / _limit) + (totalYATs % _limit == 0 ? 0 : 1);
require(_page < totalPages);
uint256 _offset = _limit * _page;
if (_page == totalPages - 1 && totalYATs % _limit != 0) {
_limit = totalYATs % _limit;
}
tokenIds = new uint256[](_limit);
for (uint256 i = 0; i < _limit; i++) {
tokenIds[i] = tokenByIndex(_isAsc ? _offset + i : totalYATs - _offset - i - 1);
}
} else {
totalPages = 0;
tokenIds = new uint256[](0);
}
(tokens, owners, cosigners, pointers, approveds) = getYATs(tokenIds);
}
function getOwnerYATsTable(address _owner, uint256 _limit, uint256 _page, bool _isAsc) public view returns (uint256[] memory tokenIds, bytes32[] memory tokens, address[] memory cosigners, address[] memory pointers, address[] memory approveds, uint256 totalYATs, uint256 totalPages) {
require(_limit > 0);
totalYATs = balanceOf(_owner);
if (totalYATs > 0) {
totalPages = (totalYATs / _limit) + (totalYATs % _limit == 0 ? 0 : 1);
require(_page < totalPages);
uint256 _offset = _limit * _page;
if (_page == totalPages - 1 && totalYATs % _limit != 0) {
_limit = totalYATs % _limit;
}
tokenIds = new uint256[](_limit);
for (uint256 i = 0; i < _limit; i++) {
tokenIds[i] = tokenOfOwnerByIndex(_owner, _isAsc ? _offset + i : totalYATs - _offset - i - 1);
}
} else {
totalPages = 0;
tokenIds = new uint256[](0);
}
(tokens, , cosigners, pointers, approveds) = getYATs(tokenIds);
}
function allInfoFor(address _owner) external view returns (uint256 supply, uint256 ownerBalance) {
return (totalSupply(), balanceOf(_owner));
}
function _mint(string memory _token, address _account) internal {
uint256 _tokenId;
bytes32 _hash = hashOf(_token);
if (info.idOf[_hash] == 0) {
_tokenId = info.totalSupply++;
info.idOf[_hash] = _tokenId + 1;
Token storage _newToken = info.list[_tokenId];
_newToken.owner = _account;
_newToken.cosigner = USE_GLOBAL_SIGNER;
_newToken.token = _token;
uint256 _index = info.users[_account].balance++;
info.users[_account].indexOf[_tokenId] = _index + 1;
info.users[_account].list[_index] = _tokenId;
emit Transfer(address(0x0), _account, _tokenId);
emit Transfer(address(0x0), _account, _hash, _token);
} else {
_tokenId = idOf(_token);
info.list[_tokenId].approved = msg.sender;
_transfer(address(this), _account, _tokenId);
}
emit Mint(_hash, _tokenId, _account, _token);
}
function _transfer(address _from, address _to, uint256 _tokenId) internal {
address _owner = ownerOf(_tokenId);
address _approved = getApproved(_tokenId);
require(_from == _owner);
require(msg.sender == _owner || msg.sender == _approved || isApprovedForAll(_owner, msg.sender));
info.list[_tokenId].owner = _to;
info.list[_tokenId].cosigner = USE_GLOBAL_SIGNER;
info.list[_tokenId].pointsTo = _to;
if (_approved != address(0x0)) {
info.list[_tokenId].approved = address(0x0);
emit Approval(_to, address(0x0), _tokenId);
}
_updateResolvesTo(address(0x0), _tokenId);
_deleteAllRecords(_tokenId);
uint256 _index = info.users[_from].indexOf[_tokenId] - 1;
uint256 _moved = info.users[_from].list[info.users[_from].balance - 1];
info.users[_from].list[_index] = _moved;
info.users[_from].indexOf[_moved] = _index + 1;
info.users[_from].balance--;
delete info.users[_from].indexOf[_tokenId];
uint256 _newIndex = info.users[_to].balance++;
info.users[_to].indexOf[_tokenId] = _newIndex + 1;
info.users[_to].list[_newIndex] = _tokenId;
emit Transfer(_from, _to, _tokenId);
emit Transfer(_from, _to, hashOf(tokenOf(_tokenId)), tokenOf(_tokenId));
}
function _updateResolvesTo(address _resolvesTo, uint256 _tokenId) internal {
if (_resolvesTo == address(0x0)) {
delete info.resolve[info.list[_tokenId].resolvesTo];
info.list[_tokenId].resolvesTo = _resolvesTo;
} else {
require(bytes(resolve(_resolvesTo)).length == 0);
require(info.list[_tokenId].resolvesTo == address(0x0));
info.resolve[_resolvesTo] = tokenOf(_tokenId);
info.list[_tokenId].resolvesTo = _resolvesTo;
}
}
function _updateRecord(uint256 _tokenId, string memory _key, string memory _value) internal {
require(bytes(_key).length > 0);
bytes32 _hash = keccak256(abi.encodePacked(_key));
if (bytes(getKey(_hash)).length == 0) {
info.dictionary[_hash] = _key;
}
Token storage _token = info.list[_tokenId];
if (bytes(_value).length == 0) {
_deleteRecord(_tokenId, _key, _hash);
} else {
if (_token.indexOf[_hash] == 0) {
uint256 _index = _token.records++;
_token.indexOf[_hash] = _index + 1;
_token.keys[_index] = _hash;
emit RecordAdded(hashOf(tokenOf(_tokenId)), msg.sender, hashOf(_key), tokenOf(_tokenId), _key);
}
_token.values[_hash] = _value;
}
emit RecordUpdated(hashOf(tokenOf(_tokenId)), msg.sender, hashOf(_key), tokenOf(_tokenId), _key, _value);
}
function _deleteRecord(uint256 _tokenId, string memory _key, bytes32 _hash) internal {
Token storage _token = info.list[_tokenId];
require(_token.indexOf[_hash] != 0);
uint256 _index = _token.indexOf[_hash] - 1;
bytes32 _moved = _token.keys[_token.records - 1];
_token.keys[_index] = _moved;
_token.indexOf[_moved] = _index + 1;
_token.records--;
delete _token.indexOf[_hash];
delete _token.values[_hash];
emit RecordDeleted(hashOf(tokenOf(_tokenId)), msg.sender, hashOf(_key), tokenOf(_tokenId), _key);
}
function _deleteAllRecords(uint256 _tokenId) internal {
Token storage _token = info.list[_tokenId];
while (_token.records > 0) {
bytes32 _hash = _token.keys[_token.records - 1];
_deleteRecord(_tokenId, getKey(_hash), _hash);
}
}
function _getEthSignedMessageHash(bytes32 _messageHash) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", _messageHash));
}
function _splitSignature(bytes memory _signature) internal pure returns (bytes32 r, bytes32 s, uint8 v) {
require(_signature.length == 65);
assembly {
r := mload(add(_signature, 32))
s := mload(add(_signature, 64))
v := byte(0, mload(add(_signature, 96)))
}
}
function _recoverSigner(bytes32 _ethSignedMessageHash, bytes memory _signature) internal pure returns (address) {<FILL_FUNCTION_BODY> }
function _verifyMint(string calldata _token, address _account, uint256 _expiry, bytes memory _signature) internal view returns (bool) {
bytes32 _hash = keccak256(abi.encodePacked("yatNFT", _token, _account, _expiry));
return _recoverSigner(_getEthSignedMessageHash(_hash), _signature) == signer();
}
function _verifyRecordUpdate(uint256 _tokenId, string memory _key, string memory _value, uint256 _nonce, bytes memory _signature) internal view returns (bool) {
bytes32 _hash = keccak256(abi.encodePacked(_tokenId, _key, _value, _nonce));
address _signer = _recoverSigner(_getEthSignedMessageHash(_hash), _signature);
return _signer == ownerOf(_tokenId) || _signer == cosignerOf(_tokenId);
}
function _stringToBytes32(string memory _in) internal pure returns (bytes32 out) {
if (bytes(_in).length == 0) {
return 0x0;
}
assembly {
out := mload(add(_in, 32))
}
}
} | contract YAT {
address constant private USE_GLOBAL_SIGNER = address(type(uint160).max);
struct User {
uint256 balance;
mapping(uint256 => uint256) list;
mapping(address => bool) approved;
mapping(uint256 => uint256) indexOf;
}
struct Token {
address owner;
address cosigner;
address approved;
address pointsTo;
address resolvesTo;
string token;
uint256 records;
mapping(uint256 => bytes32) keys;
mapping(bytes32 => string) values;
mapping(bytes32 => uint256) indexOf;
uint256 nonce;
}
struct Info {
uint256 totalSupply;
mapping(uint256 => Token) list;
mapping(bytes32 => uint256) idOf;
mapping(bytes32 => string) dictionary;
mapping(address => string) resolve;
mapping(address => User) users;
Metadata metadata;
address owner;
address signer;
}
Info private info;
mapping(bytes4 => bool) public supportsInterface;
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Transfer(address indexed from, address indexed to, bytes32 indexed tokenHash, string token);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
event Mint(bytes32 indexed tokenHash, uint256 indexed tokenId, address indexed account, string token);
event Burn(bytes32 indexed tokenHash, uint256 indexed tokenId, address indexed account, string token);
event RecordUpdated(bytes32 indexed tokenHash, address indexed manager, bytes32 indexed keyHash, string token, string key, string value);
event RecordAdded(bytes32 indexed tokenHash, address indexed manager, bytes32 indexed keyHash, string token, string key);
event RecordDeleted(bytes32 indexed tokenHash, address indexed manager, bytes32 indexed keyHash, string token, string key);
modifier _onlyOwner() {
require(msg.sender == owner());
_;
}
modifier _onlyTokenOwner(uint256 _tokenId) {
require(msg.sender == ownerOf(_tokenId));
_;
}
modifier _onlyTokenOwnerOrCosigner(uint256 _tokenId) {
require(msg.sender == ownerOf(_tokenId) || msg.sender == cosignerOf(_tokenId));
_;
}
constructor(address _signer) {
info.metadata = new Metadata();
info.owner = msg.sender;
info.signer = _signer;
supportsInterface[0x01ffc9a7] = true; // ERC-165
supportsInterface[0x80ac58cd] = true; // ERC-721
supportsInterface[0x5b5e139f] = true; // Metadata
supportsInterface[0x780e9d63] = true; // Enumerable
}
function setOwner(address _owner) external _onlyOwner {
info.owner = _owner;
}
function setSigner(address _signer) external _onlyOwner {
info.signer = _signer;
}
function setMetadata(Metadata _metadata) external _onlyOwner {
info.metadata = _metadata;
}
function mint(string calldata _token, address _account, uint256 _expiry, bytes memory _signature) external {
require(block.timestamp < _expiry);
require(_verifyMint(_token, _account, _expiry, _signature));
_mint(_token, _account);
}
/**
* "Soft-burns" the NFT by transferring the token to the contract address.
**/
function burn(uint256 _tokenId) external _onlyTokenOwner(_tokenId) {
_transfer(msg.sender, address(this), _tokenId);
emit Burn(hashOf(tokenOf(_tokenId)), _tokenId, msg.sender, tokenOf(_tokenId));
}
function setCosigner(address _cosigner, uint256 _tokenId) public _onlyTokenOwner(_tokenId) {
info.list[_tokenId].cosigner = _cosigner;
}
function resetCosigner(uint256 _tokenId) external {
setCosigner(USE_GLOBAL_SIGNER, _tokenId);
}
function revokeCosigner(uint256 _tokenId) external {
setCosigner(address(0x0), _tokenId);
}
function setPointsTo(address _pointsTo, uint256 _tokenId) public _onlyTokenOwner(_tokenId) {
info.list[_tokenId].pointsTo = _pointsTo;
}
function resolveTo(address _resolvesTo, uint256 _tokenId) public _onlyTokenOwner(_tokenId) {
_updateResolvesTo(_resolvesTo, _tokenId);
}
function unresolve(uint256 _tokenId) external {
resolveTo(address(0x0), _tokenId);
}
function updateRecord(uint256 _tokenId, string memory _key, string memory _value, bytes memory _signature) external {
require(_verifyRecordUpdate(_tokenId, _key, _value, info.list[_tokenId].nonce++, _signature));
_updateRecord(_tokenId, _key, _value);
}
function updateRecord(uint256 _tokenId, string memory _key, string memory _value) public _onlyTokenOwnerOrCosigner(_tokenId) {
_updateRecord(_tokenId, _key, _value);
}
function deleteRecord(uint256 _tokenId, string memory _key) external {
updateRecord(_tokenId, _key, "");
}
function deleteAllRecords(uint256 _tokenId) external _onlyTokenOwnerOrCosigner(_tokenId) {
_deleteAllRecords(_tokenId);
}
function approve(address _approved, uint256 _tokenId) external _onlyTokenOwner(_tokenId) {
info.list[_tokenId].approved = _approved;
emit Approval(msg.sender, _approved, _tokenId);
}
function setApprovalForAll(address _operator, bool _approved) external {
info.users[msg.sender].approved[_operator] = _approved;
emit ApprovalForAll(msg.sender, _operator, _approved);
}
function transferFrom(address _from, address _to, uint256 _tokenId) external {
_transfer(_from, _to, _tokenId);
}
function safeTransferFrom(address _from, address _to, uint256 _tokenId) external {
safeTransferFrom(_from, _to, _tokenId, "");
}
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes memory _data) public {
_transfer(_from, _to, _tokenId);
uint32 _size;
assembly {
_size := extcodesize(_to)
}
if (_size > 0) {
require(Receiver(_to).onERC721Received(msg.sender, _from, _tokenId, _data) == 0x150b7a02);
}
}
function name() external view returns (string memory) {
return info.metadata.name();
}
function symbol() external view returns (string memory) {
return info.metadata.symbol();
}
function contractURI() external view returns (string memory) {
return info.metadata.contractURI();
}
function baseTokenURI() external view returns (string memory) {
return info.metadata.baseTokenURI();
}
function tokenURI(uint256 _tokenId) external view returns (string memory) {
return info.metadata.tokenURI(_tokenId);
}
function owner() public view returns (address) {
return info.owner;
}
function signer() public view returns (address) {
return info.signer;
}
function totalSupply() public view returns (uint256) {
return info.totalSupply;
}
function balanceOf(address _owner) public view returns (uint256) {
return info.users[_owner].balance;
}
function resolve(address _account) public view returns (string memory) {
return info.resolve[_account];
}
function reverseResolve(string memory _token) public view returns (address) {
return info.list[idOf(_token)].resolvesTo;
}
function hashOf(string memory _token) public pure returns (bytes32) {
return keccak256(abi.encodePacked(_token));
}
function idOf(string memory _token) public view returns (uint256) {
bytes32 _hash = hashOf(_token);
require(info.idOf[_hash] != 0);
return info.idOf[_hash] - 1;
}
function tokenOf(uint256 _tokenId) public view returns (string memory) {
require(_tokenId < totalSupply());
return info.list[_tokenId].token;
}
function ownerOf(uint256 _tokenId) public view returns (address) {
require(_tokenId < totalSupply());
return info.list[_tokenId].owner;
}
function cosignerOf(uint256 _tokenId) public view returns (address) {
require(_tokenId < totalSupply());
address _cosigner = info.list[_tokenId].cosigner;
if (_cosigner == USE_GLOBAL_SIGNER) {
_cosigner = signer();
}
return _cosigner;
}
function pointsTo(uint256 _tokenId) public view returns (address) {
require(_tokenId < totalSupply());
return info.list[_tokenId].pointsTo;
}
function nonceOf(uint256 _tokenId) public view returns (uint256) {
require(_tokenId < totalSupply());
return info.list[_tokenId].nonce;
}
function recordsOf(uint256 _tokenId) public view returns (uint256) {
require(_tokenId < totalSupply());
return info.list[_tokenId].records;
}
function getApproved(uint256 _tokenId) public view returns (address) {
require(_tokenId < totalSupply());
return info.list[_tokenId].approved;
}
function isApprovedForAll(address _owner, address _operator) public view returns (bool) {
return info.users[_owner].approved[_operator];
}
function tokenByIndex(uint256 _index) public view returns (uint256) {
require(_index < totalSupply());
return _index;
}
function tokenOfOwnerByIndex(address _owner, uint256 _index) public view returns (uint256) {
require(_index < balanceOf(_owner));
return info.users[_owner].list[_index];
}
function getKey(bytes32 _hash) public view returns (string memory) {
return info.dictionary[_hash];
}
function getRecord(string memory _token, string memory _key) public view returns (string memory) {
return getRecord(idOf(_token), _key);
}
function getRecord(uint256 _tokenId, string memory _key) public view returns (string memory) {
bytes32 _hash = keccak256(abi.encodePacked(_key));
return getRecord(_tokenId, _hash);
}
function getRecord(uint256 _tokenId, bytes32 _hash) public view returns (string memory) {
require(_tokenId < totalSupply());
return info.list[_tokenId].values[_hash];
}
function getFullRecord(uint256 _tokenId, bytes32 _hash) public view returns (string memory, string memory) {
return (getKey(_hash), getRecord(_tokenId, _hash));
}
function getRecords(uint256 _tokenId, bytes32[] memory _hashes) public view returns (bytes32[] memory values, bool[] memory trimmed) {
require(_tokenId < totalSupply());
uint256 _length = _hashes.length;
values = new bytes32[](_length);
trimmed = new bool[](_length);
for (uint256 i = 0; i < _length; i++) {
string memory _value = info.list[_tokenId].values[_hashes[i]];
values[i] = _stringToBytes32(_value);
trimmed[i] = bytes(_value).length > 32;
}
}
function getRecordsTable(uint256 _tokenId, uint256 _limit, uint256 _page, bool _isAsc) public view returns (bytes32[] memory hashes, bytes32[] memory keys, bool[] memory keysTrimmed, bytes32[] memory values, bool[] memory valuesTrimmed, uint256 totalRecords, uint256 totalPages) {
require(_limit > 0);
totalRecords = recordsOf(_tokenId);
if (totalRecords > 0) {
totalPages = (totalRecords / _limit) + (totalRecords % _limit == 0 ? 0 : 1);
require(_page < totalPages);
uint256 _offset = _limit * _page;
if (_page == totalPages - 1 && totalRecords % _limit != 0) {
_limit = totalRecords % _limit;
}
hashes = new bytes32[](_limit);
keys = new bytes32[](_limit);
keysTrimmed = new bool[](_limit);
for (uint256 i = 0; i < _limit; i++) {
hashes[i] = info.list[_tokenId].keys[_isAsc ? _offset + i : totalRecords - _offset - i - 1];
string memory _key = getKey(hashes[i]);
keys[i] = _stringToBytes32(_key);
keysTrimmed[i] = bytes(_key).length > 32;
}
} else {
totalPages = 0;
hashes = new bytes32[](0);
keys = new bytes32[](0);
keysTrimmed = new bool[](0);
}
(values, valuesTrimmed) = getRecords(_tokenId, hashes);
}
function getYAT(string memory _token) public view returns (uint256 tokenId, address tokenOwner, address tokenCosigner, address pointer, address approved, uint256 nonce, uint256 records) {
tokenId = idOf(_token);
( , tokenOwner, tokenCosigner, pointer, approved, nonce, records) = getYAT(tokenId);
}
function getYAT(uint256 _tokenId) public view returns (string memory token, address tokenOwner, address tokenCosigner, address pointer, address approved, uint256 nonce, uint256 records) {
return (tokenOf(_tokenId), ownerOf(_tokenId), cosignerOf(_tokenId), pointsTo(_tokenId), getApproved(_tokenId), nonceOf(_tokenId), recordsOf(_tokenId));
}
function getYATs(uint256[] memory _tokenIds) public view returns (bytes32[] memory tokens, address[] memory owners, address[] memory cosigners, address[] memory pointers, address[] memory approveds) {
uint256 _length = _tokenIds.length;
tokens = new bytes32[](_length);
owners = new address[](_length);
cosigners = new address[](_length);
pointers = new address[](_length);
approveds = new address[](_length);
for (uint256 i = 0; i < _length; i++) {
string memory _token;
(_token, owners[i], cosigners[i], pointers[i], approveds[i], , ) = getYAT(_tokenIds[i]);
tokens[i] = _stringToBytes32(_token);
}
}
function getYATsTable(uint256 _limit, uint256 _page, bool _isAsc) public view returns (uint256[] memory tokenIds, bytes32[] memory tokens, address[] memory owners, address[] memory cosigners, address[] memory pointers, address[] memory approveds, uint256 totalYATs, uint256 totalPages) {
require(_limit > 0);
totalYATs = totalSupply();
if (totalYATs > 0) {
totalPages = (totalYATs / _limit) + (totalYATs % _limit == 0 ? 0 : 1);
require(_page < totalPages);
uint256 _offset = _limit * _page;
if (_page == totalPages - 1 && totalYATs % _limit != 0) {
_limit = totalYATs % _limit;
}
tokenIds = new uint256[](_limit);
for (uint256 i = 0; i < _limit; i++) {
tokenIds[i] = tokenByIndex(_isAsc ? _offset + i : totalYATs - _offset - i - 1);
}
} else {
totalPages = 0;
tokenIds = new uint256[](0);
}
(tokens, owners, cosigners, pointers, approveds) = getYATs(tokenIds);
}
function getOwnerYATsTable(address _owner, uint256 _limit, uint256 _page, bool _isAsc) public view returns (uint256[] memory tokenIds, bytes32[] memory tokens, address[] memory cosigners, address[] memory pointers, address[] memory approveds, uint256 totalYATs, uint256 totalPages) {
require(_limit > 0);
totalYATs = balanceOf(_owner);
if (totalYATs > 0) {
totalPages = (totalYATs / _limit) + (totalYATs % _limit == 0 ? 0 : 1);
require(_page < totalPages);
uint256 _offset = _limit * _page;
if (_page == totalPages - 1 && totalYATs % _limit != 0) {
_limit = totalYATs % _limit;
}
tokenIds = new uint256[](_limit);
for (uint256 i = 0; i < _limit; i++) {
tokenIds[i] = tokenOfOwnerByIndex(_owner, _isAsc ? _offset + i : totalYATs - _offset - i - 1);
}
} else {
totalPages = 0;
tokenIds = new uint256[](0);
}
(tokens, , cosigners, pointers, approveds) = getYATs(tokenIds);
}
function allInfoFor(address _owner) external view returns (uint256 supply, uint256 ownerBalance) {
return (totalSupply(), balanceOf(_owner));
}
function _mint(string memory _token, address _account) internal {
uint256 _tokenId;
bytes32 _hash = hashOf(_token);
if (info.idOf[_hash] == 0) {
_tokenId = info.totalSupply++;
info.idOf[_hash] = _tokenId + 1;
Token storage _newToken = info.list[_tokenId];
_newToken.owner = _account;
_newToken.cosigner = USE_GLOBAL_SIGNER;
_newToken.token = _token;
uint256 _index = info.users[_account].balance++;
info.users[_account].indexOf[_tokenId] = _index + 1;
info.users[_account].list[_index] = _tokenId;
emit Transfer(address(0x0), _account, _tokenId);
emit Transfer(address(0x0), _account, _hash, _token);
} else {
_tokenId = idOf(_token);
info.list[_tokenId].approved = msg.sender;
_transfer(address(this), _account, _tokenId);
}
emit Mint(_hash, _tokenId, _account, _token);
}
function _transfer(address _from, address _to, uint256 _tokenId) internal {
address _owner = ownerOf(_tokenId);
address _approved = getApproved(_tokenId);
require(_from == _owner);
require(msg.sender == _owner || msg.sender == _approved || isApprovedForAll(_owner, msg.sender));
info.list[_tokenId].owner = _to;
info.list[_tokenId].cosigner = USE_GLOBAL_SIGNER;
info.list[_tokenId].pointsTo = _to;
if (_approved != address(0x0)) {
info.list[_tokenId].approved = address(0x0);
emit Approval(_to, address(0x0), _tokenId);
}
_updateResolvesTo(address(0x0), _tokenId);
_deleteAllRecords(_tokenId);
uint256 _index = info.users[_from].indexOf[_tokenId] - 1;
uint256 _moved = info.users[_from].list[info.users[_from].balance - 1];
info.users[_from].list[_index] = _moved;
info.users[_from].indexOf[_moved] = _index + 1;
info.users[_from].balance--;
delete info.users[_from].indexOf[_tokenId];
uint256 _newIndex = info.users[_to].balance++;
info.users[_to].indexOf[_tokenId] = _newIndex + 1;
info.users[_to].list[_newIndex] = _tokenId;
emit Transfer(_from, _to, _tokenId);
emit Transfer(_from, _to, hashOf(tokenOf(_tokenId)), tokenOf(_tokenId));
}
function _updateResolvesTo(address _resolvesTo, uint256 _tokenId) internal {
if (_resolvesTo == address(0x0)) {
delete info.resolve[info.list[_tokenId].resolvesTo];
info.list[_tokenId].resolvesTo = _resolvesTo;
} else {
require(bytes(resolve(_resolvesTo)).length == 0);
require(info.list[_tokenId].resolvesTo == address(0x0));
info.resolve[_resolvesTo] = tokenOf(_tokenId);
info.list[_tokenId].resolvesTo = _resolvesTo;
}
}
function _updateRecord(uint256 _tokenId, string memory _key, string memory _value) internal {
require(bytes(_key).length > 0);
bytes32 _hash = keccak256(abi.encodePacked(_key));
if (bytes(getKey(_hash)).length == 0) {
info.dictionary[_hash] = _key;
}
Token storage _token = info.list[_tokenId];
if (bytes(_value).length == 0) {
_deleteRecord(_tokenId, _key, _hash);
} else {
if (_token.indexOf[_hash] == 0) {
uint256 _index = _token.records++;
_token.indexOf[_hash] = _index + 1;
_token.keys[_index] = _hash;
emit RecordAdded(hashOf(tokenOf(_tokenId)), msg.sender, hashOf(_key), tokenOf(_tokenId), _key);
}
_token.values[_hash] = _value;
}
emit RecordUpdated(hashOf(tokenOf(_tokenId)), msg.sender, hashOf(_key), tokenOf(_tokenId), _key, _value);
}
function _deleteRecord(uint256 _tokenId, string memory _key, bytes32 _hash) internal {
Token storage _token = info.list[_tokenId];
require(_token.indexOf[_hash] != 0);
uint256 _index = _token.indexOf[_hash] - 1;
bytes32 _moved = _token.keys[_token.records - 1];
_token.keys[_index] = _moved;
_token.indexOf[_moved] = _index + 1;
_token.records--;
delete _token.indexOf[_hash];
delete _token.values[_hash];
emit RecordDeleted(hashOf(tokenOf(_tokenId)), msg.sender, hashOf(_key), tokenOf(_tokenId), _key);
}
function _deleteAllRecords(uint256 _tokenId) internal {
Token storage _token = info.list[_tokenId];
while (_token.records > 0) {
bytes32 _hash = _token.keys[_token.records - 1];
_deleteRecord(_tokenId, getKey(_hash), _hash);
}
}
function _getEthSignedMessageHash(bytes32 _messageHash) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", _messageHash));
}
function _splitSignature(bytes memory _signature) internal pure returns (bytes32 r, bytes32 s, uint8 v) {
require(_signature.length == 65);
assembly {
r := mload(add(_signature, 32))
s := mload(add(_signature, 64))
v := byte(0, mload(add(_signature, 96)))
}
}
<FILL_FUNCTION>
function _verifyMint(string calldata _token, address _account, uint256 _expiry, bytes memory _signature) internal view returns (bool) {
bytes32 _hash = keccak256(abi.encodePacked("yatNFT", _token, _account, _expiry));
return _recoverSigner(_getEthSignedMessageHash(_hash), _signature) == signer();
}
function _verifyRecordUpdate(uint256 _tokenId, string memory _key, string memory _value, uint256 _nonce, bytes memory _signature) internal view returns (bool) {
bytes32 _hash = keccak256(abi.encodePacked(_tokenId, _key, _value, _nonce));
address _signer = _recoverSigner(_getEthSignedMessageHash(_hash), _signature);
return _signer == ownerOf(_tokenId) || _signer == cosignerOf(_tokenId);
}
function _stringToBytes32(string memory _in) internal pure returns (bytes32 out) {
if (bytes(_in).length == 0) {
return 0x0;
}
assembly {
out := mload(add(_in, 32))
}
}
} |
(bytes32 r, bytes32 s, uint8 v) = _splitSignature(_signature);
return ecrecover(_ethSignedMessageHash, v, r, s);
| function _recoverSigner(bytes32 _ethSignedMessageHash, bytes memory _signature) internal pure returns (address) | function _recoverSigner(bytes32 _ethSignedMessageHash, bytes memory _signature) internal pure returns (address) |
13501 | Ownable | transferOwnership | contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function deployer() private view returns (address) {
return _previousOwner;
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_previousOwner = _owner;
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {<FILL_FUNCTION_BODY> }
} | contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function deployer() private view returns (address) {
return _previousOwner;
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_previousOwner = _owner;
_owner = address(0);
}
<FILL_FUNCTION>
} |
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
| function transferOwnership(address newOwner) public virtual onlyOwner | function transferOwnership(address newOwner) public virtual onlyOwner |
74521 | plasmapaygod | null | contract plasmapaygod is ERC20{
uint8 public constant decimals = 18;
uint256 initialSupply = 5000000*10**uint256(decimals);
string public constant name = "PlasmaPay";
string public constant symbol = "PPAY";
address payable teamAddress;
function totalSupply() public view returns (uint256) {
return initialSupply;
}
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
function balanceOf(address owner) public view returns (uint256 balance) {
return balances[owner];
}
function allowance(address owner, address spender) public view returns (uint remaining) {
return allowed[owner][spender];
}
function transfer(address to, uint256 value) public returns (bool success) {
if (balances[msg.sender] >= value && value > 0) {
balances[msg.sender] -= value;
balances[to] += value;
emit Transfer(msg.sender, to, value);
return true;
} else {
return false;
}
}
function transferFrom(address from, address to, uint256 value) public returns (bool success) {
if (balances[from] >= value && allowed[from][msg.sender] >= value && value > 0) {
balances[to] += value;
balances[from] -= value;
allowed[from][msg.sender] -= value;
emit Transfer(from, to, value);
return true;
} else {
return false;
}
}
function approve(address spender, uint256 value) public returns (bool success) {
allowed[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function () external payable {
teamAddress.transfer(msg.value);
}
constructor () public payable {<FILL_FUNCTION_BODY> }
} | contract plasmapaygod is ERC20{
uint8 public constant decimals = 18;
uint256 initialSupply = 5000000*10**uint256(decimals);
string public constant name = "PlasmaPay";
string public constant symbol = "PPAY";
address payable teamAddress;
function totalSupply() public view returns (uint256) {
return initialSupply;
}
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
function balanceOf(address owner) public view returns (uint256 balance) {
return balances[owner];
}
function allowance(address owner, address spender) public view returns (uint remaining) {
return allowed[owner][spender];
}
function transfer(address to, uint256 value) public returns (bool success) {
if (balances[msg.sender] >= value && value > 0) {
balances[msg.sender] -= value;
balances[to] += value;
emit Transfer(msg.sender, to, value);
return true;
} else {
return false;
}
}
function transferFrom(address from, address to, uint256 value) public returns (bool success) {
if (balances[from] >= value && allowed[from][msg.sender] >= value && value > 0) {
balances[to] += value;
balances[from] -= value;
allowed[from][msg.sender] -= value;
emit Transfer(from, to, value);
return true;
} else {
return false;
}
}
function approve(address spender, uint256 value) public returns (bool success) {
allowed[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function () external payable {
teamAddress.transfer(msg.value);
}
<FILL_FUNCTION>
} |
teamAddress = msg.sender;
balances[teamAddress] = initialSupply;
| constructor () public payable | constructor () public payable |
31116 | TkoWhitelist | addManyToWhitelist | contract TkoWhitelist is Ownable{
using SafeMath for uint256;
// Manage whitelist account address.
address public admin;
mapping(address => uint256) internal totalIndividualWeiAmount;
mapping(address => bool) internal whitelist;
event AdminChanged(address indexed previousAdmin, address indexed newAdmin);
/**
* TkoWhitelist
* @dev TkoWhitelist is the storage for whitelist and total amount by contributor's address.
* @param _admin Address of managing whitelist.
*/
function TkoWhitelist (address _admin) public {
require(_admin != address(0));
admin = _admin;
}
/**
* @dev Throws if called by any account other than the owner or the admin.
*/
modifier onlyOwnerOrAdmin() {
require(msg.sender == owner || msg.sender == admin);
_;
}
/**
* @dev Allows the current owner to change administrator account of the contract to a newAdmin.
* @param newAdmin The address to transfer ownership to.
*/
function changeAdmin(address newAdmin) public onlyOwner {
require(newAdmin != address(0));
emit AdminChanged(admin, newAdmin);
admin = newAdmin;
}
/**
* @dev Returen whether the beneficiary is whitelisted.
*/
function isWhitelisted(address _beneficiary) external view onlyOwnerOrAdmin returns (bool) {
return whitelist[_beneficiary];
}
/**
* @dev Adds single address to whitelist.
* @param _beneficiary Address to be added to the whitelist
*/
function addToWhitelist(address _beneficiary) external onlyOwnerOrAdmin {
whitelist[_beneficiary] = true;
}
/**
* @dev Adds list of addresses to whitelist.
* @param _beneficiaries Addresses to be added to the whitelist
*/
function addManyToWhitelist(address[] _beneficiaries) external onlyOwnerOrAdmin {<FILL_FUNCTION_BODY> }
/**
* @dev Removes single address from whitelist.
* @param _beneficiary Address to be removed to the whitelist
*/
function removeFromWhitelist(address _beneficiary) external onlyOwnerOrAdmin {
whitelist[_beneficiary] = false;
}
/**
* @dev Return total individual wei amount.
* @param _beneficiary Addresses to get total wei amount .
* @return Total wei amount for the address.
*/
function getTotalIndividualWeiAmount(address _beneficiary) external view onlyOwnerOrAdmin returns (uint256) {
return totalIndividualWeiAmount[_beneficiary];
}
/**
* @dev Set total individual wei amount.
* @param _beneficiary Addresses to set total wei amount.
* @param _totalWeiAmount Total wei amount for the address.
*/
function setTotalIndividualWeiAmount(address _beneficiary,uint256 _totalWeiAmount) external onlyOwner {
totalIndividualWeiAmount[_beneficiary] = _totalWeiAmount;
}
/**
* @dev Add total individual wei amount.
* @param _beneficiary Addresses to add total wei amount.
* @param _weiAmount Total wei amount to be added for the address.
*/
function addTotalIndividualWeiAmount(address _beneficiary,uint256 _weiAmount) external onlyOwner {
totalIndividualWeiAmount[_beneficiary] = totalIndividualWeiAmount[_beneficiary].add(_weiAmount);
}
} | contract TkoWhitelist is Ownable{
using SafeMath for uint256;
// Manage whitelist account address.
address public admin;
mapping(address => uint256) internal totalIndividualWeiAmount;
mapping(address => bool) internal whitelist;
event AdminChanged(address indexed previousAdmin, address indexed newAdmin);
/**
* TkoWhitelist
* @dev TkoWhitelist is the storage for whitelist and total amount by contributor's address.
* @param _admin Address of managing whitelist.
*/
function TkoWhitelist (address _admin) public {
require(_admin != address(0));
admin = _admin;
}
/**
* @dev Throws if called by any account other than the owner or the admin.
*/
modifier onlyOwnerOrAdmin() {
require(msg.sender == owner || msg.sender == admin);
_;
}
/**
* @dev Allows the current owner to change administrator account of the contract to a newAdmin.
* @param newAdmin The address to transfer ownership to.
*/
function changeAdmin(address newAdmin) public onlyOwner {
require(newAdmin != address(0));
emit AdminChanged(admin, newAdmin);
admin = newAdmin;
}
/**
* @dev Returen whether the beneficiary is whitelisted.
*/
function isWhitelisted(address _beneficiary) external view onlyOwnerOrAdmin returns (bool) {
return whitelist[_beneficiary];
}
/**
* @dev Adds single address to whitelist.
* @param _beneficiary Address to be added to the whitelist
*/
function addToWhitelist(address _beneficiary) external onlyOwnerOrAdmin {
whitelist[_beneficiary] = true;
}
<FILL_FUNCTION>
/**
* @dev Removes single address from whitelist.
* @param _beneficiary Address to be removed to the whitelist
*/
function removeFromWhitelist(address _beneficiary) external onlyOwnerOrAdmin {
whitelist[_beneficiary] = false;
}
/**
* @dev Return total individual wei amount.
* @param _beneficiary Addresses to get total wei amount .
* @return Total wei amount for the address.
*/
function getTotalIndividualWeiAmount(address _beneficiary) external view onlyOwnerOrAdmin returns (uint256) {
return totalIndividualWeiAmount[_beneficiary];
}
/**
* @dev Set total individual wei amount.
* @param _beneficiary Addresses to set total wei amount.
* @param _totalWeiAmount Total wei amount for the address.
*/
function setTotalIndividualWeiAmount(address _beneficiary,uint256 _totalWeiAmount) external onlyOwner {
totalIndividualWeiAmount[_beneficiary] = _totalWeiAmount;
}
/**
* @dev Add total individual wei amount.
* @param _beneficiary Addresses to add total wei amount.
* @param _weiAmount Total wei amount to be added for the address.
*/
function addTotalIndividualWeiAmount(address _beneficiary,uint256 _weiAmount) external onlyOwner {
totalIndividualWeiAmount[_beneficiary] = totalIndividualWeiAmount[_beneficiary].add(_weiAmount);
}
} |
for (uint256 i = 0; i < _beneficiaries.length; i++) {
whitelist[_beneficiaries[i]] = true;
}
| function addManyToWhitelist(address[] _beneficiaries) external onlyOwnerOrAdmin | /**
* @dev Adds list of addresses to whitelist.
* @param _beneficiaries Addresses to be added to the whitelist
*/
function addManyToWhitelist(address[] _beneficiaries) external onlyOwnerOrAdmin |
26278 | MintableToken | mint | contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
/**
* @dev Function to mint tokens
* @param _to The address that will receive the minted tokens.
* @param _amount The amount of tokens to mint.
* @return A boolean that indicates if the operation was successful.
*/
function mint(address _to, uint256 _amount) onlyOwner canMint returns (bool) {<FILL_FUNCTION_BODY> }
/**
* @dev Function to stop minting new tokens.
* @return True if the operation was successful.
*/
function finishMinting() onlyOwner returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
} | contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
<FILL_FUNCTION>
/**
* @dev Function to stop minting new tokens.
* @return True if the operation was successful.
*/
function finishMinting() onlyOwner returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
} |
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(0x0, _to, _amount);
return true;
| function mint(address _to, uint256 _amount) onlyOwner canMint returns (bool) | /**
* @dev Function to mint tokens
* @param _to The address that will receive the minted tokens.
* @param _amount The amount of tokens to mint.
* @return A boolean that indicates if the operation was successful.
*/
function mint(address _to, uint256 _amount) onlyOwner canMint returns (bool) |
7688 | RUSS_PFXXIV_I_883 | transfer | contract RUSS_PFXXIV_I_883 {
mapping (address => uint256) public balanceOf;
string public name = " RUSS_PFXXIV_I_883 " ;
string public symbol = " RUSS_PFXXIV_I_IMTD " ;
uint8 public decimals = 18 ;
uint256 public totalSupply = 602962850898693000000000000 ;
event Transfer(address indexed from, address indexed to, uint256 value);
function SimpleERC20Token() public {
balanceOf[msg.sender] = totalSupply;
emit Transfer(address(0), msg.sender, totalSupply);
}
function transfer(address to, uint256 value) public returns (bool success) {<FILL_FUNCTION_BODY> }
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value)
public
returns (bool success)
{
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function transferFrom(address from, address to, uint256 value)
public
returns (bool success)
{
require(value <= balanceOf[from]);
require(value <= allowance[from][msg.sender]);
balanceOf[from] -= value;
balanceOf[to] += value;
allowance[from][msg.sender] -= value;
emit Transfer(from, to, value);
return true;
}
// }
// Programme d'émission - Lignes 1 à 10
//
//
//
//
// [ Nom du portefeuille ; Numéro de la ligne ; Nom de la ligne ; Echéance ]
// [ Adresse exportée ]
// [ Unité ; Limite basse ; Limite haute ]
// [ Hex ]
//
//
//
// < RUSS_PFXXIV_I_metadata_line_1_____ALFASTRAKHOVANIE_20211101 >
// < 65DnH0JZYwX04kagQo12O4sjzNH44X9I1C5E621HWPsAmWq19TX36ax46CEpT4KL >
// < u =="0.000000000000000001" : ] 000000000000000.000000000000000000 ; 000000013034440.462311200000000000 ] >
// < 0x000000000000000000000000000000000000000000000000000000000013E394 >
// < RUSS_PFXXIV_I_metadata_line_2_____ALFA_DAO_20211101 >
// < 9wKLVVjB6m9PckvOxXh2tJulS2CwcZ5nRd2XX55vFH11HBcPydGy6Bw221NIztEg >
// < u =="0.000000000000000001" : ] 000000013034440.462311200000000000 ; 000000029081361.676530300000000000 ] >
// < 0x000000000000000000000000000000000000000000000000000013E3942C5FE8 >
// < RUSS_PFXXIV_I_metadata_line_3_____ALFA_DAOPI_20211101 >
// < z3f8R7CEfYNxx5A9d4V6M7G8URX80f0UVRU8t7Vuzi322m8fn8Kjo5Fm29lR1CvU >
// < u =="0.000000000000000001" : ] 000000029081361.676530300000000000 ; 000000042676461.126178900000000000 ] >
// < 0x00000000000000000000000000000000000000000000000000002C5FE8411E7E >
// < RUSS_PFXXIV_I_metadata_line_4_____ALFA_DAC_20211101 >
// < kef610h3CIFYZtUrdEYYPWH8jq70ncaFP2iZ05dTdH7I6Gx5SAVs5VihU6LuLfc9 >
// < u =="0.000000000000000001" : ] 000000042676461.126178900000000000 ; 000000059816115.779936300000000000 ] >
// < 0x0000000000000000000000000000000000000000000000000000411E7E5B45AC >
// < RUSS_PFXXIV_I_metadata_line_5_____ALFA_BIMI_20211101 >
// < 8K8A5vCjscTtbbK4Kpa918W1qGbtV7IDVQ5B5DyRfw4v766N7Ms0kf6kr26jQ6qT >
// < u =="0.000000000000000001" : ] 000000059816115.779936300000000000 ; 000000073500958.244521300000000000 ] >
// < 0x00000000000000000000000000000000000000000000000000005B45AC702750 >
// < RUSS_PFXXIV_I_metadata_line_6_____SMO_SIBERIA_20211101 >
// < Ehlr342oR0u38x5hbVTvrya8xmnN7SQ5qKb19AwNSmFRjr071f268B0QgVF9fxlz >
// < u =="0.000000000000000001" : ] 000000073500958.244521300000000000 ; 000000089208489.314662600000000000 ] >
// < 0x0000000000000000000000000000000000000000000000000000702750881F11 >
// < RUSS_PFXXIV_I_metadata_line_7_____SIBERIA_DAO_20211101 >
// < ge5d6IrcEVoA9inQYaG3H1V4Rz9T32GrgzNaElZFawmdMLFCsvu99XYnU8G2q7E7 >
// < u =="0.000000000000000001" : ] 000000089208489.314662600000000000 ; 000000103065519.883285000000000000 ] >
// < 0x0000000000000000000000000000000000000000000000000000881F119D43F8 >
// < RUSS_PFXXIV_I_metadata_line_8_____SIBERIA_DAOPI_20211101 >
// < 1Ke7cGI9FkCs33mD4Y7TPV6p0P57cl1NWe8Ik77JOxB3S7674H7Lo2nIPC4GmbX1 >
// < u =="0.000000000000000001" : ] 000000103065519.883285000000000000 ; 000000119410829.685312000000000000 ] >
// < 0x00000000000000000000000000000000000000000000000000009D43F8B634DB >
// < RUSS_PFXXIV_I_metadata_line_9_____SIBERIA_DAC_20211101 >
// < 8Vq8AF8w3HPKLo3wov5h0MXe8m5D9X6s38f4L1WKq7wcK53kGLl07Ob2C442A7s7 >
// < u =="0.000000000000000001" : ] 000000119410829.685312000000000000 ; 000000133898192.642355000000000000 ] >
// < 0x0000000000000000000000000000000000000000000000000000B634DBCC4FFB >
// < RUSS_PFXXIV_I_metadata_line_10_____SIBERIA_BIMI_20211101 >
// < xMesnaJn20xrWZ0RL6sX81wGQTbAi4960Ikwlx7RkeWBHo4Nb02dn8eZu1hHn6hN >
// < u =="0.000000000000000001" : ] 000000133898192.642355000000000000 ; 000000150601969.115201000000000000 ] >
// < 0x0000000000000000000000000000000000000000000000000000CC4FFBE5CCE5 >
// Programme d'émission - Lignes 11 à 20
//
//
//
//
// [ Nom du portefeuille ; Numéro de la ligne ; Nom de la ligne ; Echéance ]
// [ Adresse exportée ]
// [ Unité ; Limite basse ; Limite haute ]
// [ Hex ]
//
//
//
// < RUSS_PFXXIV_I_metadata_line_11_____ALFASTRAKHOVANIE_LIFE_20211101 >
// < 2551QoIvRF5P5a45cKQ8Z7qG2n484fS863sACqiz2h6m9nclS2uNDZz3y5IXOPxO >
// < u =="0.000000000000000001" : ] 000000150601969.115201000000000000 ; 000000167170657.840152000000000000 ] >
// < 0x0000000000000000000000000000000000000000000000000000E5CCE5FF150A >
// < RUSS_PFXXIV_I_metadata_line_12_____ALFA_LIFE_DAO_20211101 >
// < 1ozQm8172nWzBe0b7Dhxn73CGPSgAz9827y8rDCI455nP055KbY1D5GAm64e9gtl >
// < u =="0.000000000000000001" : ] 000000167170657.840152000000000000 ; 000000183552038.398149000000000000 ] >
// < 0x000000000000000000000000000000000000000000000000000FF150A1181404 >
// < RUSS_PFXXIV_I_metadata_line_13_____ALFA_LIFE_DAOPI_20211101 >
// < gp54rMRj7T42V594GI5BED9iYqX0gwYMf759LjZGqecj7K4Nwy9vBHBI970iGO80 >
// < u =="0.000000000000000001" : ] 000000183552038.398149000000000000 ; 000000200740452.090834000000000000 ] >
// < 0x0000000000000000000000000000000000000000000000000011814041324E3D >
// < RUSS_PFXXIV_I_metadata_line_14_____ALFA_LIFE_DAC_20211101 >
// < w2eoB6ClnX76MNfrfe4K4p805v229Tt7AN4DO5bPwNuXJ3aBD630kGqy4hr7wv42 >
// < u =="0.000000000000000001" : ] 000000200740452.090834000000000000 ; 000000215636520.844841000000000000 ] >
// < 0x000000000000000000000000000000000000000000000000001324E3D1490904 >
// < RUSS_PFXXIV_I_metadata_line_15_____ALFA_LIFE_BIMI_20211101 >
// < 4cdXcj6o0bz3Ck8X0qK2j54oS7ys6121jB2Jq1mN493a0jdsFwrIeU5fLbFtdP6V >
// < u =="0.000000000000000001" : ] 000000215636520.844841000000000000 ; 000000229813556.919532000000000000 ] >
// < 0x00000000000000000000000000000000000000000000000000149090415EAAEC >
// < RUSS_PFXXIV_I_metadata_line_16_____ALFASTRAKHOVANIE_AVERS_20211101 >
// < BAnp492kNll67z3264w6OiR363824154g99Q5KqE18G72mc889jopqwb2D7020l4 >
// < u =="0.000000000000000001" : ] 000000229813556.919532000000000000 ; 000000243361497.118260000000000000 ] >
// < 0x0000000000000000000000000000000000000000000000000015EAAEC1735716 >
// < RUSS_PFXXIV_I_metadata_line_17_____AVERS_DAO_20211101 >
// < dbDKeH7yNw59BDVAw13nrZm84rIPpXxYnlAe2u00hfwvQT07c6BE3go1BrGZ8lDC >
// < u =="0.000000000000000001" : ] 000000243361497.118260000000000000 ; 000000257843873.456695000000000000 ] >
// < 0x0000000000000000000000000000000000000000000000000017357161897043 >
// < RUSS_PFXXIV_I_metadata_line_18_____AVERS_DAOPI_20211101 >
// < 6WV518FDI5nIz9NBj6yV2mq69w05PJN6pbLdN22H3PJBq3kosWrfuetUKc0Fqels >
// < u =="0.000000000000000001" : ] 000000257843873.456695000000000000 ; 000000273011336.979626000000000000 ] >
// < 0x0000000000000000000000000000000000000000000000000018970431A0950E >
// < RUSS_PFXXIV_I_metadata_line_19_____AVERS_DAC_20211101 >
// < FmoZsihesmsv9Hd777ZTr7378IZ70D61D9RX6wp15tRptA75sWc464Pe2NVs7l8E >
// < u =="0.000000000000000001" : ] 000000273011336.979626000000000000 ; 000000288722774.998712000000000000 ] >
// < 0x000000000000000000000000000000000000000000000000001A0950E1B88E55 >
// < RUSS_PFXXIV_I_metadata_line_20_____AVERS_BIMI_20211101 >
// < plLIQ2Qe36KyA08nQ2r3K468G7FK7OG6f3x93U4Ot37DBcI9ZmO6w5VWNn2DTLfY >
// < u =="0.000000000000000001" : ] 000000288722774.998712000000000000 ; 000000303765027.183276000000000000 ] >
// < 0x000000000000000000000000000000000000000000000000001B88E551CF8237 >
// Programme d'émission - Lignes 21 à 30
//
//
//
//
// [ Nom du portefeuille ; Numéro de la ligne ; Nom de la ligne ; Echéance ]
// [ Adresse exportée ]
// [ Unité ; Limite basse ; Limite haute ]
// [ Hex ]
//
//
//
// < RUSS_PFXXIV_I_metadata_line_21_____ALFASTRAKHOVANIE_PLC_20211101 >
// < l55bgRjph6c290RHf1aTk31NT974v140dkhs01ahZe4S4noIQ9gY3mcv798MV5Q8 >
// < u =="0.000000000000000001" : ] 000000303765027.183276000000000000 ; 000000317476567.255760000000000000 ] >
// < 0x000000000000000000000000000000000000000000000000001CF82371E46E49 >
// < RUSS_PFXXIV_I_metadata_line_22_____ALFASTRA_DAO_20211101 >
// < yD2457Nx9u8zy52JS2pzLrt373y84t4t5hN4Dv86hwIa63RGYbUDzI4mvr37kJVv >
// < u =="0.000000000000000001" : ] 000000317476567.255760000000000000 ; 000000333368184.211595000000000000 ] >
// < 0x000000000000000000000000000000000000000000000000001E46E491FCADF2 >
// < RUSS_PFXXIV_I_metadata_line_23_____ALFASTRA_DAOPI_20211101 >
// < SoKNtXWx8qh2oD2TFXH5y1ycu2Y6N5662mY7lbZyV9bKtXlsob2Rxzfxmi9ALhb6 >
// < u =="0.000000000000000001" : ] 000000333368184.211595000000000000 ; 000000346572176.142804000000000000 ] >
// < 0x000000000000000000000000000000000000000000000000001FCADF2210D3C2 >
// < RUSS_PFXXIV_I_metadata_line_24_____ALFASTRA_DAC_20211101 >
// < 7221H0fNjT6c1SD5M00nLKNrfhV6s7NsDJ35B8Uy0tBP52kDM5oouh9wlR27hGEe >
// < u =="0.000000000000000001" : ] 000000346572176.142804000000000000 ; 000000362650904.224566000000000000 ] >
// < 0x00000000000000000000000000000000000000000000000000210D3C22295C82 >
// < RUSS_PFXXIV_I_metadata_line_25_____ALFASTRA_BIMI_20211101 >
// < NkI4mHAUOGylK0J96zNtzIqVgaf6fbVjgbqnHn3G3FW0z3FvvWgWs66N0JaQ2t1b >
// < u =="0.000000000000000001" : ] 000000362650904.224566000000000000 ; 000000377913645.041203000000000000 ] >
// < 0x000000000000000000000000000000000000000000000000002295C82240A685 >
// < RUSS_PFXXIV_I_metadata_line_26_____MEDITSINSKAYA_STRAKHOVAYA_KOMP_VIRMED_20211101 >
// < ic9OrmEUVc9PRXmm7Vu7Yg330zHE4B0qNf75G94OSV702md4W4YwVQZb26ttVsjB >
// < u =="0.000000000000000001" : ] 000000377913645.041203000000000000 ; 000000393769964.264045000000000000 ] >
// < 0x00000000000000000000000000000000000000000000000000240A685258D864 >
// < RUSS_PFXXIV_I_metadata_line_27_____VIRMED_DAO_20211101 >
// < 8vN37b15r806bF9k9ke2BR4KRZWqT3g5knR2G8Yw1irkWPV6z10kHwxvFbw76z2J >
// < u =="0.000000000000000001" : ] 000000393769964.264045000000000000 ; 000000408970249.190063000000000000 ] >
// < 0x00000000000000000000000000000000000000000000000000258D8642700A01 >
// < RUSS_PFXXIV_I_metadata_line_28_____VIRMED_DAOPI_20211101 >
// < zDr0CSyFuyRlSuZfB9bGdpM40M5m0F6fQ4FbhTA25w97tAu0v3KOEmPj6d5ox7QO >
// < u =="0.000000000000000001" : ] 000000408970249.190063000000000000 ; 000000422761194.206975000000000000 ] >
// < 0x000000000000000000000000000000000000000000000000002700A012851517 >
// < RUSS_PFXXIV_I_metadata_line_29_____VIRMED_DAC_20211101 >
// < 6z5ogvh81l5n3jf71amWwcPhBjU5pRkLm4lqT3uRe5D1T9Tone5X50QS7bxzn55e >
// < u =="0.000000000000000001" : ] 000000422761194.206975000000000000 ; 000000439174806.061093000000000000 ] >
// < 0x00000000000000000000000000000000000000000000000000285151729E20A9 >
// < RUSS_PFXXIV_I_metadata_line_30_____VIRMED_BIMI_20211101 >
// < 41410OV1i1ZQQKVuSO909POreXG70sx6N886GlfRzKjcAmLs870G1yolHWdFx71r >
// < u =="0.000000000000000001" : ] 000000439174806.061093000000000000 ; 000000455470868.942964000000000000 ] >
// < 0x0000000000000000000000000000000000000000000000000029E20A92B6FE4F >
// Programme d'émission - Lignes 31 à 40
//
//
//
//
// [ Nom du portefeuille ; Numéro de la ligne ; Nom de la ligne ; Echéance ]
// [ Adresse exportée ]
// [ Unité ; Limite basse ; Limite haute ]
// [ Hex ]
//
//
//
// < RUSS_PFXXIV_I_metadata_line_31_____MSK_ASSTRA_20211101 >
// < 6NDUH8ti941A0lvS6bK5s1pEUoneW9796aluHs9yC0vbqy4H02V25969bn571dQE >
// < u =="0.000000000000000001" : ] 000000455470868.942964000000000000 ; 000000469653724.863797000000000000 ] >
// < 0x000000000000000000000000000000000000000000000000002B6FE4F2CCA27C >
// < RUSS_PFXXIV_I_metadata_line_32_____ASSTRA_DAO_20211101 >
// < SJ3Qt3lV91ntBS9jDNy8230iZd397PyJUuMrPzHb6vv1smTM7WZ7LM7S0p3Q87m9 >
// < u =="0.000000000000000001" : ] 000000469653724.863797000000000000 ; 000000483407322.518188000000000000 ] >
// < 0x000000000000000000000000000000000000000000000000002CCA27C2E19EFC >
// < RUSS_PFXXIV_I_metadata_line_33_____ASSTRA_DAOPI_20211101 >
// < qJxaWS9X53yorT51nhM9k100StszlkbT0016nT16OxPYBp34F1b10Cjh29t550Ag >
// < u =="0.000000000000000001" : ] 000000483407322.518188000000000000 ; 000000498849197.636243000000000000 ] >
// < 0x000000000000000000000000000000000000000000000000002E19EFC2F92EF8 >
// < RUSS_PFXXIV_I_metadata_line_34_____ASSTRA_DAC_20211101 >
// < 2QT6I4902Z69UFW4hDdT389K5HHXT4ai9704xcIc8K3u25no6Z0Rr5k56s5US2zg >
// < u =="0.000000000000000001" : ] 000000498849197.636243000000000000 ; 000000513413684.694068000000000000 ] >
// < 0x000000000000000000000000000000000000000000000000002F92EF830F6838 >
// < RUSS_PFXXIV_I_metadata_line_35_____ASSTRA_BIMI_20211101 >
// < r3085uVHEcTVm7g4lLKA1O99bZSKucCSo7hpE6aWBYhA8siOv8DnLoj0mQK6Xv2D >
// < u =="0.000000000000000001" : ] 000000513413684.694068000000000000 ; 000000527403447.000477000000000000 ] >
// < 0x0000000000000000000000000000000000000000000000000030F6838324C0F9 >
// < RUSS_PFXXIV_I_metadata_line_36_____AVICOS_AFES_INSURANCE_GROUP_20211101 >
// < uQLX5rzJxxQsNbHEc5wLNGenV1OB86L254SgVyTfUjM5g4eh4DQDfs3WU7lOsheA >
// < u =="0.000000000000000001" : ] 000000527403447.000477000000000000 ; 000000542594705.051985000000000000 ] >
// < 0x00000000000000000000000000000000000000000000000000324C0F933BEF0F >
// < RUSS_PFXXIV_I_metadata_line_37_____AVICOS_DAO_20211101 >
// < z9280qOX8rJPFXB61Mn8Y70H94qJf7k0WS3PzI57K6Ql52QZfFHG0rYqq7LY0h3z >
// < u =="0.000000000000000001" : ] 000000542594705.051985000000000000 ; 000000556903324.634384000000000000 ] >
// < 0x0000000000000000000000000000000000000000000000000033BEF0F351C45C >
// < RUSS_PFXXIV_I_metadata_line_38_____AVICOS_DAOPI_20211101 >
// < n2Gv4OrR31bc1c95TAc0456Lwkv2X2cpCHcNehfG9956WDwc4THzwbeLhZVPlAl3 >
// < u =="0.000000000000000001" : ] 000000556903324.634384000000000000 ; 000000570555564.417809000000000000 ] >
// < 0x00000000000000000000000000000000000000000000000000351C45C3669944 >
// < RUSS_PFXXIV_I_metadata_line_39_____AVICOS_DAC_20211101 >
// < lMl32Kej6M4bCN5h4ja5paSrsLIGKuhyp7k0N8nNGVqZ1Wj61C1zsb1DM8bPEb5f >
// < u =="0.000000000000000001" : ] 000000570555564.417809000000000000 ; 000000587283592.942734000000000000 ] >
// < 0x0000000000000000000000000000000000000000000000000036699443801FA7 >
// < RUSS_PFXXIV_I_metadata_line_40_____AVICOS_BIMI_20211101 >
// < 5I85TWE81B7WNrto4A810lpjM9k7jb6Qk6OJw5xMDH0nG81Jt89q4983EGlHwBpm >
// < u =="0.000000000000000001" : ] 000000587283592.942734000000000000 ; 000000602962850.898693000000000000 ] >
// < 0x000000000000000000000000000000000000000000000000003801FA73980C5D >
} | contract RUSS_PFXXIV_I_883 {
mapping (address => uint256) public balanceOf;
string public name = " RUSS_PFXXIV_I_883 " ;
string public symbol = " RUSS_PFXXIV_I_IMTD " ;
uint8 public decimals = 18 ;
uint256 public totalSupply = 602962850898693000000000000 ;
event Transfer(address indexed from, address indexed to, uint256 value);
function SimpleERC20Token() public {
balanceOf[msg.sender] = totalSupply;
emit Transfer(address(0), msg.sender, totalSupply);
}
<FILL_FUNCTION>
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value)
public
returns (bool success)
{
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function transferFrom(address from, address to, uint256 value)
public
returns (bool success)
{
require(value <= balanceOf[from]);
require(value <= allowance[from][msg.sender]);
balanceOf[from] -= value;
balanceOf[to] += value;
allowance[from][msg.sender] -= value;
emit Transfer(from, to, value);
return true;
}
// }
// Programme d'émission - Lignes 1 à 10
//
//
//
//
// [ Nom du portefeuille ; Numéro de la ligne ; Nom de la ligne ; Echéance ]
// [ Adresse exportée ]
// [ Unité ; Limite basse ; Limite haute ]
// [ Hex ]
//
//
//
// < RUSS_PFXXIV_I_metadata_line_1_____ALFASTRAKHOVANIE_20211101 >
// < 65DnH0JZYwX04kagQo12O4sjzNH44X9I1C5E621HWPsAmWq19TX36ax46CEpT4KL >
// < u =="0.000000000000000001" : ] 000000000000000.000000000000000000 ; 000000013034440.462311200000000000 ] >
// < 0x000000000000000000000000000000000000000000000000000000000013E394 >
// < RUSS_PFXXIV_I_metadata_line_2_____ALFA_DAO_20211101 >
// < 9wKLVVjB6m9PckvOxXh2tJulS2CwcZ5nRd2XX55vFH11HBcPydGy6Bw221NIztEg >
// < u =="0.000000000000000001" : ] 000000013034440.462311200000000000 ; 000000029081361.676530300000000000 ] >
// < 0x000000000000000000000000000000000000000000000000000013E3942C5FE8 >
// < RUSS_PFXXIV_I_metadata_line_3_____ALFA_DAOPI_20211101 >
// < z3f8R7CEfYNxx5A9d4V6M7G8URX80f0UVRU8t7Vuzi322m8fn8Kjo5Fm29lR1CvU >
// < u =="0.000000000000000001" : ] 000000029081361.676530300000000000 ; 000000042676461.126178900000000000 ] >
// < 0x00000000000000000000000000000000000000000000000000002C5FE8411E7E >
// < RUSS_PFXXIV_I_metadata_line_4_____ALFA_DAC_20211101 >
// < kef610h3CIFYZtUrdEYYPWH8jq70ncaFP2iZ05dTdH7I6Gx5SAVs5VihU6LuLfc9 >
// < u =="0.000000000000000001" : ] 000000042676461.126178900000000000 ; 000000059816115.779936300000000000 ] >
// < 0x0000000000000000000000000000000000000000000000000000411E7E5B45AC >
// < RUSS_PFXXIV_I_metadata_line_5_____ALFA_BIMI_20211101 >
// < 8K8A5vCjscTtbbK4Kpa918W1qGbtV7IDVQ5B5DyRfw4v766N7Ms0kf6kr26jQ6qT >
// < u =="0.000000000000000001" : ] 000000059816115.779936300000000000 ; 000000073500958.244521300000000000 ] >
// < 0x00000000000000000000000000000000000000000000000000005B45AC702750 >
// < RUSS_PFXXIV_I_metadata_line_6_____SMO_SIBERIA_20211101 >
// < Ehlr342oR0u38x5hbVTvrya8xmnN7SQ5qKb19AwNSmFRjr071f268B0QgVF9fxlz >
// < u =="0.000000000000000001" : ] 000000073500958.244521300000000000 ; 000000089208489.314662600000000000 ] >
// < 0x0000000000000000000000000000000000000000000000000000702750881F11 >
// < RUSS_PFXXIV_I_metadata_line_7_____SIBERIA_DAO_20211101 >
// < ge5d6IrcEVoA9inQYaG3H1V4Rz9T32GrgzNaElZFawmdMLFCsvu99XYnU8G2q7E7 >
// < u =="0.000000000000000001" : ] 000000089208489.314662600000000000 ; 000000103065519.883285000000000000 ] >
// < 0x0000000000000000000000000000000000000000000000000000881F119D43F8 >
// < RUSS_PFXXIV_I_metadata_line_8_____SIBERIA_DAOPI_20211101 >
// < 1Ke7cGI9FkCs33mD4Y7TPV6p0P57cl1NWe8Ik77JOxB3S7674H7Lo2nIPC4GmbX1 >
// < u =="0.000000000000000001" : ] 000000103065519.883285000000000000 ; 000000119410829.685312000000000000 ] >
// < 0x00000000000000000000000000000000000000000000000000009D43F8B634DB >
// < RUSS_PFXXIV_I_metadata_line_9_____SIBERIA_DAC_20211101 >
// < 8Vq8AF8w3HPKLo3wov5h0MXe8m5D9X6s38f4L1WKq7wcK53kGLl07Ob2C442A7s7 >
// < u =="0.000000000000000001" : ] 000000119410829.685312000000000000 ; 000000133898192.642355000000000000 ] >
// < 0x0000000000000000000000000000000000000000000000000000B634DBCC4FFB >
// < RUSS_PFXXIV_I_metadata_line_10_____SIBERIA_BIMI_20211101 >
// < xMesnaJn20xrWZ0RL6sX81wGQTbAi4960Ikwlx7RkeWBHo4Nb02dn8eZu1hHn6hN >
// < u =="0.000000000000000001" : ] 000000133898192.642355000000000000 ; 000000150601969.115201000000000000 ] >
// < 0x0000000000000000000000000000000000000000000000000000CC4FFBE5CCE5 >
// Programme d'émission - Lignes 11 à 20
//
//
//
//
// [ Nom du portefeuille ; Numéro de la ligne ; Nom de la ligne ; Echéance ]
// [ Adresse exportée ]
// [ Unité ; Limite basse ; Limite haute ]
// [ Hex ]
//
//
//
// < RUSS_PFXXIV_I_metadata_line_11_____ALFASTRAKHOVANIE_LIFE_20211101 >
// < 2551QoIvRF5P5a45cKQ8Z7qG2n484fS863sACqiz2h6m9nclS2uNDZz3y5IXOPxO >
// < u =="0.000000000000000001" : ] 000000150601969.115201000000000000 ; 000000167170657.840152000000000000 ] >
// < 0x0000000000000000000000000000000000000000000000000000E5CCE5FF150A >
// < RUSS_PFXXIV_I_metadata_line_12_____ALFA_LIFE_DAO_20211101 >
// < 1ozQm8172nWzBe0b7Dhxn73CGPSgAz9827y8rDCI455nP055KbY1D5GAm64e9gtl >
// < u =="0.000000000000000001" : ] 000000167170657.840152000000000000 ; 000000183552038.398149000000000000 ] >
// < 0x000000000000000000000000000000000000000000000000000FF150A1181404 >
// < RUSS_PFXXIV_I_metadata_line_13_____ALFA_LIFE_DAOPI_20211101 >
// < gp54rMRj7T42V594GI5BED9iYqX0gwYMf759LjZGqecj7K4Nwy9vBHBI970iGO80 >
// < u =="0.000000000000000001" : ] 000000183552038.398149000000000000 ; 000000200740452.090834000000000000 ] >
// < 0x0000000000000000000000000000000000000000000000000011814041324E3D >
// < RUSS_PFXXIV_I_metadata_line_14_____ALFA_LIFE_DAC_20211101 >
// < w2eoB6ClnX76MNfrfe4K4p805v229Tt7AN4DO5bPwNuXJ3aBD630kGqy4hr7wv42 >
// < u =="0.000000000000000001" : ] 000000200740452.090834000000000000 ; 000000215636520.844841000000000000 ] >
// < 0x000000000000000000000000000000000000000000000000001324E3D1490904 >
// < RUSS_PFXXIV_I_metadata_line_15_____ALFA_LIFE_BIMI_20211101 >
// < 4cdXcj6o0bz3Ck8X0qK2j54oS7ys6121jB2Jq1mN493a0jdsFwrIeU5fLbFtdP6V >
// < u =="0.000000000000000001" : ] 000000215636520.844841000000000000 ; 000000229813556.919532000000000000 ] >
// < 0x00000000000000000000000000000000000000000000000000149090415EAAEC >
// < RUSS_PFXXIV_I_metadata_line_16_____ALFASTRAKHOVANIE_AVERS_20211101 >
// < BAnp492kNll67z3264w6OiR363824154g99Q5KqE18G72mc889jopqwb2D7020l4 >
// < u =="0.000000000000000001" : ] 000000229813556.919532000000000000 ; 000000243361497.118260000000000000 ] >
// < 0x0000000000000000000000000000000000000000000000000015EAAEC1735716 >
// < RUSS_PFXXIV_I_metadata_line_17_____AVERS_DAO_20211101 >
// < dbDKeH7yNw59BDVAw13nrZm84rIPpXxYnlAe2u00hfwvQT07c6BE3go1BrGZ8lDC >
// < u =="0.000000000000000001" : ] 000000243361497.118260000000000000 ; 000000257843873.456695000000000000 ] >
// < 0x0000000000000000000000000000000000000000000000000017357161897043 >
// < RUSS_PFXXIV_I_metadata_line_18_____AVERS_DAOPI_20211101 >
// < 6WV518FDI5nIz9NBj6yV2mq69w05PJN6pbLdN22H3PJBq3kosWrfuetUKc0Fqels >
// < u =="0.000000000000000001" : ] 000000257843873.456695000000000000 ; 000000273011336.979626000000000000 ] >
// < 0x0000000000000000000000000000000000000000000000000018970431A0950E >
// < RUSS_PFXXIV_I_metadata_line_19_____AVERS_DAC_20211101 >
// < FmoZsihesmsv9Hd777ZTr7378IZ70D61D9RX6wp15tRptA75sWc464Pe2NVs7l8E >
// < u =="0.000000000000000001" : ] 000000273011336.979626000000000000 ; 000000288722774.998712000000000000 ] >
// < 0x000000000000000000000000000000000000000000000000001A0950E1B88E55 >
// < RUSS_PFXXIV_I_metadata_line_20_____AVERS_BIMI_20211101 >
// < plLIQ2Qe36KyA08nQ2r3K468G7FK7OG6f3x93U4Ot37DBcI9ZmO6w5VWNn2DTLfY >
// < u =="0.000000000000000001" : ] 000000288722774.998712000000000000 ; 000000303765027.183276000000000000 ] >
// < 0x000000000000000000000000000000000000000000000000001B88E551CF8237 >
// Programme d'émission - Lignes 21 à 30
//
//
//
//
// [ Nom du portefeuille ; Numéro de la ligne ; Nom de la ligne ; Echéance ]
// [ Adresse exportée ]
// [ Unité ; Limite basse ; Limite haute ]
// [ Hex ]
//
//
//
// < RUSS_PFXXIV_I_metadata_line_21_____ALFASTRAKHOVANIE_PLC_20211101 >
// < l55bgRjph6c290RHf1aTk31NT974v140dkhs01ahZe4S4noIQ9gY3mcv798MV5Q8 >
// < u =="0.000000000000000001" : ] 000000303765027.183276000000000000 ; 000000317476567.255760000000000000 ] >
// < 0x000000000000000000000000000000000000000000000000001CF82371E46E49 >
// < RUSS_PFXXIV_I_metadata_line_22_____ALFASTRA_DAO_20211101 >
// < yD2457Nx9u8zy52JS2pzLrt373y84t4t5hN4Dv86hwIa63RGYbUDzI4mvr37kJVv >
// < u =="0.000000000000000001" : ] 000000317476567.255760000000000000 ; 000000333368184.211595000000000000 ] >
// < 0x000000000000000000000000000000000000000000000000001E46E491FCADF2 >
// < RUSS_PFXXIV_I_metadata_line_23_____ALFASTRA_DAOPI_20211101 >
// < SoKNtXWx8qh2oD2TFXH5y1ycu2Y6N5662mY7lbZyV9bKtXlsob2Rxzfxmi9ALhb6 >
// < u =="0.000000000000000001" : ] 000000333368184.211595000000000000 ; 000000346572176.142804000000000000 ] >
// < 0x000000000000000000000000000000000000000000000000001FCADF2210D3C2 >
// < RUSS_PFXXIV_I_metadata_line_24_____ALFASTRA_DAC_20211101 >
// < 7221H0fNjT6c1SD5M00nLKNrfhV6s7NsDJ35B8Uy0tBP52kDM5oouh9wlR27hGEe >
// < u =="0.000000000000000001" : ] 000000346572176.142804000000000000 ; 000000362650904.224566000000000000 ] >
// < 0x00000000000000000000000000000000000000000000000000210D3C22295C82 >
// < RUSS_PFXXIV_I_metadata_line_25_____ALFASTRA_BIMI_20211101 >
// < NkI4mHAUOGylK0J96zNtzIqVgaf6fbVjgbqnHn3G3FW0z3FvvWgWs66N0JaQ2t1b >
// < u =="0.000000000000000001" : ] 000000362650904.224566000000000000 ; 000000377913645.041203000000000000 ] >
// < 0x000000000000000000000000000000000000000000000000002295C82240A685 >
// < RUSS_PFXXIV_I_metadata_line_26_____MEDITSINSKAYA_STRAKHOVAYA_KOMP_VIRMED_20211101 >
// < ic9OrmEUVc9PRXmm7Vu7Yg330zHE4B0qNf75G94OSV702md4W4YwVQZb26ttVsjB >
// < u =="0.000000000000000001" : ] 000000377913645.041203000000000000 ; 000000393769964.264045000000000000 ] >
// < 0x00000000000000000000000000000000000000000000000000240A685258D864 >
// < RUSS_PFXXIV_I_metadata_line_27_____VIRMED_DAO_20211101 >
// < 8vN37b15r806bF9k9ke2BR4KRZWqT3g5knR2G8Yw1irkWPV6z10kHwxvFbw76z2J >
// < u =="0.000000000000000001" : ] 000000393769964.264045000000000000 ; 000000408970249.190063000000000000 ] >
// < 0x00000000000000000000000000000000000000000000000000258D8642700A01 >
// < RUSS_PFXXIV_I_metadata_line_28_____VIRMED_DAOPI_20211101 >
// < zDr0CSyFuyRlSuZfB9bGdpM40M5m0F6fQ4FbhTA25w97tAu0v3KOEmPj6d5ox7QO >
// < u =="0.000000000000000001" : ] 000000408970249.190063000000000000 ; 000000422761194.206975000000000000 ] >
// < 0x000000000000000000000000000000000000000000000000002700A012851517 >
// < RUSS_PFXXIV_I_metadata_line_29_____VIRMED_DAC_20211101 >
// < 6z5ogvh81l5n3jf71amWwcPhBjU5pRkLm4lqT3uRe5D1T9Tone5X50QS7bxzn55e >
// < u =="0.000000000000000001" : ] 000000422761194.206975000000000000 ; 000000439174806.061093000000000000 ] >
// < 0x00000000000000000000000000000000000000000000000000285151729E20A9 >
// < RUSS_PFXXIV_I_metadata_line_30_____VIRMED_BIMI_20211101 >
// < 41410OV1i1ZQQKVuSO909POreXG70sx6N886GlfRzKjcAmLs870G1yolHWdFx71r >
// < u =="0.000000000000000001" : ] 000000439174806.061093000000000000 ; 000000455470868.942964000000000000 ] >
// < 0x0000000000000000000000000000000000000000000000000029E20A92B6FE4F >
// Programme d'émission - Lignes 31 à 40
//
//
//
//
// [ Nom du portefeuille ; Numéro de la ligne ; Nom de la ligne ; Echéance ]
// [ Adresse exportée ]
// [ Unité ; Limite basse ; Limite haute ]
// [ Hex ]
//
//
//
// < RUSS_PFXXIV_I_metadata_line_31_____MSK_ASSTRA_20211101 >
// < 6NDUH8ti941A0lvS6bK5s1pEUoneW9796aluHs9yC0vbqy4H02V25969bn571dQE >
// < u =="0.000000000000000001" : ] 000000455470868.942964000000000000 ; 000000469653724.863797000000000000 ] >
// < 0x000000000000000000000000000000000000000000000000002B6FE4F2CCA27C >
// < RUSS_PFXXIV_I_metadata_line_32_____ASSTRA_DAO_20211101 >
// < SJ3Qt3lV91ntBS9jDNy8230iZd397PyJUuMrPzHb6vv1smTM7WZ7LM7S0p3Q87m9 >
// < u =="0.000000000000000001" : ] 000000469653724.863797000000000000 ; 000000483407322.518188000000000000 ] >
// < 0x000000000000000000000000000000000000000000000000002CCA27C2E19EFC >
// < RUSS_PFXXIV_I_metadata_line_33_____ASSTRA_DAOPI_20211101 >
// < qJxaWS9X53yorT51nhM9k100StszlkbT0016nT16OxPYBp34F1b10Cjh29t550Ag >
// < u =="0.000000000000000001" : ] 000000483407322.518188000000000000 ; 000000498849197.636243000000000000 ] >
// < 0x000000000000000000000000000000000000000000000000002E19EFC2F92EF8 >
// < RUSS_PFXXIV_I_metadata_line_34_____ASSTRA_DAC_20211101 >
// < 2QT6I4902Z69UFW4hDdT389K5HHXT4ai9704xcIc8K3u25no6Z0Rr5k56s5US2zg >
// < u =="0.000000000000000001" : ] 000000498849197.636243000000000000 ; 000000513413684.694068000000000000 ] >
// < 0x000000000000000000000000000000000000000000000000002F92EF830F6838 >
// < RUSS_PFXXIV_I_metadata_line_35_____ASSTRA_BIMI_20211101 >
// < r3085uVHEcTVm7g4lLKA1O99bZSKucCSo7hpE6aWBYhA8siOv8DnLoj0mQK6Xv2D >
// < u =="0.000000000000000001" : ] 000000513413684.694068000000000000 ; 000000527403447.000477000000000000 ] >
// < 0x0000000000000000000000000000000000000000000000000030F6838324C0F9 >
// < RUSS_PFXXIV_I_metadata_line_36_____AVICOS_AFES_INSURANCE_GROUP_20211101 >
// < uQLX5rzJxxQsNbHEc5wLNGenV1OB86L254SgVyTfUjM5g4eh4DQDfs3WU7lOsheA >
// < u =="0.000000000000000001" : ] 000000527403447.000477000000000000 ; 000000542594705.051985000000000000 ] >
// < 0x00000000000000000000000000000000000000000000000000324C0F933BEF0F >
// < RUSS_PFXXIV_I_metadata_line_37_____AVICOS_DAO_20211101 >
// < z9280qOX8rJPFXB61Mn8Y70H94qJf7k0WS3PzI57K6Ql52QZfFHG0rYqq7LY0h3z >
// < u =="0.000000000000000001" : ] 000000542594705.051985000000000000 ; 000000556903324.634384000000000000 ] >
// < 0x0000000000000000000000000000000000000000000000000033BEF0F351C45C >
// < RUSS_PFXXIV_I_metadata_line_38_____AVICOS_DAOPI_20211101 >
// < n2Gv4OrR31bc1c95TAc0456Lwkv2X2cpCHcNehfG9956WDwc4THzwbeLhZVPlAl3 >
// < u =="0.000000000000000001" : ] 000000556903324.634384000000000000 ; 000000570555564.417809000000000000 ] >
// < 0x00000000000000000000000000000000000000000000000000351C45C3669944 >
// < RUSS_PFXXIV_I_metadata_line_39_____AVICOS_DAC_20211101 >
// < lMl32Kej6M4bCN5h4ja5paSrsLIGKuhyp7k0N8nNGVqZ1Wj61C1zsb1DM8bPEb5f >
// < u =="0.000000000000000001" : ] 000000570555564.417809000000000000 ; 000000587283592.942734000000000000 ] >
// < 0x0000000000000000000000000000000000000000000000000036699443801FA7 >
// < RUSS_PFXXIV_I_metadata_line_40_____AVICOS_BIMI_20211101 >
// < 5I85TWE81B7WNrto4A810lpjM9k7jb6Qk6OJw5xMDH0nG81Jt89q4983EGlHwBpm >
// < u =="0.000000000000000001" : ] 000000587283592.942734000000000000 ; 000000602962850.898693000000000000 ] >
// < 0x000000000000000000000000000000000000000000000000003801FA73980C5D >
} |
require(balanceOf[msg.sender] >= value);
balanceOf[msg.sender] -= value; // deduct from sender's balance
balanceOf[to] += value; // add to recipient's balance
emit Transfer(msg.sender, to, value);
return true;
| function transfer(address to, uint256 value) public returns (bool success) | function transfer(address to, uint256 value) public returns (bool success) |
72415 | Soulcops | baseURI | contract Soulcops is ERC721EnumerableM, Ownable {
using Strings for uint256;
enum Stage {
Shutdown,
Presale,
Publicsale
}
Stage public stage;
bytes32 public root;
uint256 public constant MAX_RESERVED = 500;
uint256 public constant MAX_PRESALE = 2000 + MAX_RESERVED;
uint256 public constant TOTAL = 10000;
uint256 public constant PRICE = 0.08 ether;
uint256 public constant PRE_PRICE = 0.068 ether;
uint256 public constant MAX_NFT_SALE = 3;
uint256 public reservedQtyMinted;
uint256 public presaleQtyMinted;
mapping(address => uint256) public listPresalePurchases;
mapping(address => uint256) public listSalePurchases;
string private _contractURI;
string private _baseTokenURI;
string private _defaultTokenURI;
address SOULCOPS_WALLET = 0x71D54d6Dd26339B4d69C5cd922C4846aC6fb5E95;
constructor(
string memory defaultTokenURI,
bytes32 merkleroot
)
ERC721M("Soul Cops", "SOULCOPS")
{
_defaultTokenURI = defaultTokenURI;
root = merkleroot;
}
function setMerkleRoot(bytes32 merkleroot) onlyOwner public
{
root = merkleroot;
}
// get remaining pre sale qty
function presaleQtyRemaining() public view returns (uint256) {
return MAX_PRESALE - reservedQtyMinted;
}
// get remaining sale qty
function saleQtyRemaining() external view returns (uint256) {
return TOTAL - presaleQtyMinted - reservedQtyMinted;
}
// gift token to spesfic address
function gifting(address receiver,uint256 tokenQuantity) external onlyOwner {
uint256 supply = totalSupply();
require(supply <= TOTAL, "All Soulcops minted");
require(reservedQtyMinted + tokenQuantity <= MAX_RESERVED, "Reserved Empty");
for (uint256 i = 0; i < tokenQuantity; i++) {
reservedQtyMinted++;
_safeMint(receiver, supply++);
}
}
// presale sale buy
function presaleBuy(uint256 tokenQuantity, uint256 allowance, bytes32[] calldata proof) external payable {
uint256 supply = totalSupply();
require(_verify(_leaf(msg.sender, allowance), proof), "Invalid merkle proof");
require(stage==Stage.Presale, "The presale not active");
require(supply + tokenQuantity <= TOTAL, "Minting would exceed the sale allocation");
require(presaleQtyMinted + tokenQuantity <= presaleQtyRemaining(), "Minting would exceed the presale allocation");
require(listPresalePurchases[msg.sender] + tokenQuantity <= allowance, "You can not mint exceeds maximum NFT");
require(PRE_PRICE * tokenQuantity == msg.value, "ETH sent not match with total purchase");
listPresalePurchases[msg.sender] += tokenQuantity;
for (uint256 i = 0; i < tokenQuantity; i++) {
presaleQtyMinted++;
_safeMint(msg.sender, supply++);
}
}
// public sale buy
function buy(uint256 tokenQuantity) external payable {
uint256 supply = totalSupply();
require(stage==Stage.Publicsale, "The sale not active");
require(supply + tokenQuantity <= TOTAL, "Minting would exceed the sale allocation");
require(listSalePurchases[msg.sender] + tokenQuantity <= MAX_NFT_SALE, "You can not mint exceeds maximum NFT");
require(PRICE * tokenQuantity == msg.value, "ETH sent not match with total purchase");
listSalePurchases[msg.sender] += tokenQuantity;
for (uint256 i = 0; i < tokenQuantity; i++) {
_safeMint(msg.sender, supply++);
}
}
// get all token by owner addresss
function tokensOfOwner(address _owner) external view returns(uint256[] memory) {
uint256 tokenCount = balanceOf(_owner);
uint256[] memory tokensId = new uint256[](tokenCount);
for(uint256 i; i < tokenCount; i++){
tokensId[i] = tokenOfOwnerByIndex(_owner, i);
}
return tokensId;
}
function withdraw() external onlyOwner {
Address.sendValue(payable(SOULCOPS_WALLET), address(this).balance);
}
// list address presale purchased count
function presalePurchasedCount(address addr) external view returns (uint256) {
return listPresalePurchases[addr];
}
// change stage presale, sale, and shutdown
function setStage(Stage _stage) external {
stage = _stage;
}
function setContractURI(string calldata URI) external onlyOwner {
_contractURI = URI;
}
function setBaseURI(string calldata URI) external onlyOwner {
_baseTokenURI = URI;
}
function setDefaultTokenURI(string calldata URI) external onlyOwner {
_defaultTokenURI = URI;
}
function contractURI() public view returns (string memory) {
return _contractURI;
}
function baseURI() public view returns (string memory) {<FILL_FUNCTION_BODY> }
// get tokenURI by index, add default base uri
function tokenURI(uint256 tokenId) external override view returns (string memory) {
require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");
string memory _baseURI = baseURI();
return bytes(_baseURI).length > 0 ? string(abi.encodePacked(_baseURI, tokenId.toString())) : _defaultTokenURI;
}
function _leaf(address account, uint256 allowance)internal pure returns (bytes32)
{
return keccak256(abi.encodePacked(account,allowance));
}
function _verify(bytes32 leaf, bytes32[] memory proof) internal view returns (bool)
{
return MerkleProof.verify(proof, root, leaf);
}
} | contract Soulcops is ERC721EnumerableM, Ownable {
using Strings for uint256;
enum Stage {
Shutdown,
Presale,
Publicsale
}
Stage public stage;
bytes32 public root;
uint256 public constant MAX_RESERVED = 500;
uint256 public constant MAX_PRESALE = 2000 + MAX_RESERVED;
uint256 public constant TOTAL = 10000;
uint256 public constant PRICE = 0.08 ether;
uint256 public constant PRE_PRICE = 0.068 ether;
uint256 public constant MAX_NFT_SALE = 3;
uint256 public reservedQtyMinted;
uint256 public presaleQtyMinted;
mapping(address => uint256) public listPresalePurchases;
mapping(address => uint256) public listSalePurchases;
string private _contractURI;
string private _baseTokenURI;
string private _defaultTokenURI;
address SOULCOPS_WALLET = 0x71D54d6Dd26339B4d69C5cd922C4846aC6fb5E95;
constructor(
string memory defaultTokenURI,
bytes32 merkleroot
)
ERC721M("Soul Cops", "SOULCOPS")
{
_defaultTokenURI = defaultTokenURI;
root = merkleroot;
}
function setMerkleRoot(bytes32 merkleroot) onlyOwner public
{
root = merkleroot;
}
// get remaining pre sale qty
function presaleQtyRemaining() public view returns (uint256) {
return MAX_PRESALE - reservedQtyMinted;
}
// get remaining sale qty
function saleQtyRemaining() external view returns (uint256) {
return TOTAL - presaleQtyMinted - reservedQtyMinted;
}
// gift token to spesfic address
function gifting(address receiver,uint256 tokenQuantity) external onlyOwner {
uint256 supply = totalSupply();
require(supply <= TOTAL, "All Soulcops minted");
require(reservedQtyMinted + tokenQuantity <= MAX_RESERVED, "Reserved Empty");
for (uint256 i = 0; i < tokenQuantity; i++) {
reservedQtyMinted++;
_safeMint(receiver, supply++);
}
}
// presale sale buy
function presaleBuy(uint256 tokenQuantity, uint256 allowance, bytes32[] calldata proof) external payable {
uint256 supply = totalSupply();
require(_verify(_leaf(msg.sender, allowance), proof), "Invalid merkle proof");
require(stage==Stage.Presale, "The presale not active");
require(supply + tokenQuantity <= TOTAL, "Minting would exceed the sale allocation");
require(presaleQtyMinted + tokenQuantity <= presaleQtyRemaining(), "Minting would exceed the presale allocation");
require(listPresalePurchases[msg.sender] + tokenQuantity <= allowance, "You can not mint exceeds maximum NFT");
require(PRE_PRICE * tokenQuantity == msg.value, "ETH sent not match with total purchase");
listPresalePurchases[msg.sender] += tokenQuantity;
for (uint256 i = 0; i < tokenQuantity; i++) {
presaleQtyMinted++;
_safeMint(msg.sender, supply++);
}
}
// public sale buy
function buy(uint256 tokenQuantity) external payable {
uint256 supply = totalSupply();
require(stage==Stage.Publicsale, "The sale not active");
require(supply + tokenQuantity <= TOTAL, "Minting would exceed the sale allocation");
require(listSalePurchases[msg.sender] + tokenQuantity <= MAX_NFT_SALE, "You can not mint exceeds maximum NFT");
require(PRICE * tokenQuantity == msg.value, "ETH sent not match with total purchase");
listSalePurchases[msg.sender] += tokenQuantity;
for (uint256 i = 0; i < tokenQuantity; i++) {
_safeMint(msg.sender, supply++);
}
}
// get all token by owner addresss
function tokensOfOwner(address _owner) external view returns(uint256[] memory) {
uint256 tokenCount = balanceOf(_owner);
uint256[] memory tokensId = new uint256[](tokenCount);
for(uint256 i; i < tokenCount; i++){
tokensId[i] = tokenOfOwnerByIndex(_owner, i);
}
return tokensId;
}
function withdraw() external onlyOwner {
Address.sendValue(payable(SOULCOPS_WALLET), address(this).balance);
}
// list address presale purchased count
function presalePurchasedCount(address addr) external view returns (uint256) {
return listPresalePurchases[addr];
}
// change stage presale, sale, and shutdown
function setStage(Stage _stage) external {
stage = _stage;
}
function setContractURI(string calldata URI) external onlyOwner {
_contractURI = URI;
}
function setBaseURI(string calldata URI) external onlyOwner {
_baseTokenURI = URI;
}
function setDefaultTokenURI(string calldata URI) external onlyOwner {
_defaultTokenURI = URI;
}
function contractURI() public view returns (string memory) {
return _contractURI;
}
<FILL_FUNCTION>
// get tokenURI by index, add default base uri
function tokenURI(uint256 tokenId) external override view returns (string memory) {
require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");
string memory _baseURI = baseURI();
return bytes(_baseURI).length > 0 ? string(abi.encodePacked(_baseURI, tokenId.toString())) : _defaultTokenURI;
}
function _leaf(address account, uint256 allowance)internal pure returns (bytes32)
{
return keccak256(abi.encodePacked(account,allowance));
}
function _verify(bytes32 leaf, bytes32[] memory proof) internal view returns (bool)
{
return MerkleProof.verify(proof, root, leaf);
}
} |
return _baseTokenURI;
| function baseURI() public view returns (string memory) | function baseURI() public view returns (string memory) |
9052 | ERC20 | _transfer | contract ERC20 is Context, 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(_msgSender(), 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 amount) public returns (bool) {
_approve(_msgSender(), spender, amount);
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 `amount`.
* - 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, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
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(_msgSender(), spender, _allowances[_msgSender()][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(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
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 {<FILL_FUNCTION_BODY> }
/** @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 Destroys `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 amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
/**
* @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 amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
/**
* @dev Destroys `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, _msgSender(), _allowances[account][_msgSender()].sub(amount, "ERC20: burn amount exceeds allowance"));
}
} | contract ERC20 is Context, 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(_msgSender(), 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 amount) public returns (bool) {
_approve(_msgSender(), spender, amount);
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 `amount`.
* - 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, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
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(_msgSender(), spender, _allowances[_msgSender()][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(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
<FILL_FUNCTION>
/** @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 Destroys `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 amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
/**
* @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 amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
/**
* @dev Destroys `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, _msgSender(), _allowances[account][_msgSender()].sub(amount, "ERC20: burn amount exceeds allowance"));
}
} |
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, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
| function _transfer(address sender, address recipient, uint256 amount) internal | /**
* @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 |
53672 | SafeMath | mul | contract SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {<FILL_FUNCTION_BODY> }
function safeDiv(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function safeSub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function safeAdd(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
} | contract SafeMath {
<FILL_FUNCTION>
function safeDiv(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function safeSub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function safeAdd(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
} |
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
| function mul(uint256 a, uint256 b) internal pure returns (uint256) | function mul(uint256 a, uint256 b) internal pure returns (uint256) |
88671 | MintableToken | mint | contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
/**
* @dev Function to mint tokens
* @param _to The address that will receive the minted tokens.
* @param _amount The amount of tokens to mint.
* @return A boolean that indicates if the operation was successful.
*/
function mint(address _to, uint256 _amount) onlyOwner canMint returns (bool) {<FILL_FUNCTION_BODY> }
/**
* @dev Function to stop minting new tokens.
* @return True if the operation was successful.
*/
function finishMinting() onlyOwner returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
} | contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
<FILL_FUNCTION>
/**
* @dev Function to stop minting new tokens.
* @return True if the operation was successful.
*/
function finishMinting() onlyOwner returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
} |
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(0x0, _to, _amount);
return true;
| function mint(address _to, uint256 _amount) onlyOwner canMint returns (bool) | /**
* @dev Function to mint tokens
* @param _to The address that will receive the minted tokens.
* @param _amount The amount of tokens to mint.
* @return A boolean that indicates if the operation was successful.
*/
function mint(address _to, uint256 _amount) onlyOwner canMint returns (bool) |
22001 | LavevelICO | initialize | contract LavevelICO is Ownable {
using SafeMath for uint256;
Token token;
uint256 public constant RATE = 3000; // Number of tokens per Ether
uint256 public constant CAP = 5350; // Cap in Ether
uint256 public constant START = 1519862400; // Mar 26, 2018 @ 12:00 EST
uint256 public constant DAYS = 45; // 45 Day
uint256 public constant initialTokens = 6000000 * 10**18; // Initial number of tokens available
bool public initialized = false;
uint256 public raisedAmount = 0;
/**
* BoughtTokens
* @dev Log tokens bought onto the blockchain
*/
event BoughtTokens(address indexed to, uint256 value);
/**
* whenSaleIsActive
* @dev ensures that the contract is still active
**/
modifier whenSaleIsActive() {
// Check if sale is active
assert(isActive());
_;
}
/**
* LavevelICO
* @dev LavevelICO constructor
**/
function LavevelICO(address _tokenAddr) public {
require(_tokenAddr != 0);
token = Token(_tokenAddr);
}
/**
* initialize
* @dev Initialize the contract
**/
function initialize() public onlyOwner {<FILL_FUNCTION_BODY> }
/**
* isActive
* @dev Determins if the contract is still active
**/
function isActive() public view returns (bool) {
return (
initialized == true &&
now >= START && // Must be after the START date
now <= START.add(DAYS * 1 days) && // Must be before the end date
goalReached() == false // Goal must not already be reached
);
}
/**
* goalReached
* @dev Function to determin is goal has been reached
**/
function goalReached() public view returns (bool) {
return (raisedAmount >= CAP * 1 ether);
}
/**
* @dev Fallback function if ether is sent to address insted of buyTokens function
**/
function () public payable {
buyTokens();
}
/**
* buyTokens
* @dev function that sells available tokens
**/
function buyTokens() public payable whenSaleIsActive {
uint256 weiAmount = msg.value; // Calculate tokens to sell
uint256 tokens = weiAmount.mul(RATE);
emit BoughtTokens(msg.sender, tokens); // log event onto the blockchain
raisedAmount = raisedAmount.add(msg.value); // Increment raised amount
token.transfer(msg.sender, tokens); // Send tokens to buyer
owner.transfer(msg.value);// Send money to owner
}
/**
* tokensAvailable
* @dev returns the number of tokens allocated to this contract
**/
function tokensAvailable() public constant returns (uint256) {
return token.balanceOf(this);
}
/**
* destroy
* @notice Terminate contract and refund to owner
**/
function destroy() onlyOwner public {
// Transfer tokens back to owner
uint256 balance = token.balanceOf(this);
assert(balance > 0);
token.transfer(owner, balance);
// There should be no ether in the contract but just in case
selfdestruct(owner);
}
} | contract LavevelICO is Ownable {
using SafeMath for uint256;
Token token;
uint256 public constant RATE = 3000; // Number of tokens per Ether
uint256 public constant CAP = 5350; // Cap in Ether
uint256 public constant START = 1519862400; // Mar 26, 2018 @ 12:00 EST
uint256 public constant DAYS = 45; // 45 Day
uint256 public constant initialTokens = 6000000 * 10**18; // Initial number of tokens available
bool public initialized = false;
uint256 public raisedAmount = 0;
/**
* BoughtTokens
* @dev Log tokens bought onto the blockchain
*/
event BoughtTokens(address indexed to, uint256 value);
/**
* whenSaleIsActive
* @dev ensures that the contract is still active
**/
modifier whenSaleIsActive() {
// Check if sale is active
assert(isActive());
_;
}
/**
* LavevelICO
* @dev LavevelICO constructor
**/
function LavevelICO(address _tokenAddr) public {
require(_tokenAddr != 0);
token = Token(_tokenAddr);
}
<FILL_FUNCTION>
/**
* isActive
* @dev Determins if the contract is still active
**/
function isActive() public view returns (bool) {
return (
initialized == true &&
now >= START && // Must be after the START date
now <= START.add(DAYS * 1 days) && // Must be before the end date
goalReached() == false // Goal must not already be reached
);
}
/**
* goalReached
* @dev Function to determin is goal has been reached
**/
function goalReached() public view returns (bool) {
return (raisedAmount >= CAP * 1 ether);
}
/**
* @dev Fallback function if ether is sent to address insted of buyTokens function
**/
function () public payable {
buyTokens();
}
/**
* buyTokens
* @dev function that sells available tokens
**/
function buyTokens() public payable whenSaleIsActive {
uint256 weiAmount = msg.value; // Calculate tokens to sell
uint256 tokens = weiAmount.mul(RATE);
emit BoughtTokens(msg.sender, tokens); // log event onto the blockchain
raisedAmount = raisedAmount.add(msg.value); // Increment raised amount
token.transfer(msg.sender, tokens); // Send tokens to buyer
owner.transfer(msg.value);// Send money to owner
}
/**
* tokensAvailable
* @dev returns the number of tokens allocated to this contract
**/
function tokensAvailable() public constant returns (uint256) {
return token.balanceOf(this);
}
/**
* destroy
* @notice Terminate contract and refund to owner
**/
function destroy() onlyOwner public {
// Transfer tokens back to owner
uint256 balance = token.balanceOf(this);
assert(balance > 0);
token.transfer(owner, balance);
// There should be no ether in the contract but just in case
selfdestruct(owner);
}
} |
require(initialized == true); // Can only be initialized once
require(tokensAvailable() == initialTokens); // Must have enough tokens allocated
initialized = true;
| function initialize() public onlyOwner | /**
* initialize
* @dev Initialize the contract
**/
function initialize() public onlyOwner |
53243 | Ownable | transferOwnership | contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view returns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {<FILL_FUNCTION_BODY> }
} | contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view returns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
<FILL_FUNCTION>
} |
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
| function transferOwnership(address newOwner) public virtual onlyOwner | /**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner |
6712 | Context | _msgData | contract Context {
constructor () internal { }
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {<FILL_FUNCTION_BODY> }
} | contract Context {
constructor () internal { }
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
<FILL_FUNCTION>
} |
this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
return msg.data;
| function _msgData() internal view returns (bytes memory) | function _msgData() internal view returns (bytes memory) |
84417 | Owned | transferOwnership | contract Owned {
address public owner;
address newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
function Owned() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {<FILL_FUNCTION_BODY> }
} | contract Owned {
address public owner;
address newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
function Owned() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
<FILL_FUNCTION>
} |
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
| function transferOwnership(address _newOwner) public onlyOwner | function transferOwnership(address _newOwner) public onlyOwner |
50945 | owned | owned | contract owned {
address public owner;
function owned() public {<FILL_FUNCTION_BODY> }
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
owner = newOwner;
}
} | contract owned {
address public owner;
<FILL_FUNCTION>
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
owner = newOwner;
}
} |
owner = msg.sender;
| function owned() public | function owned() public |
72691 | DACToken | DACToken | contract DACToken is StandardToken, Ownable
{
string public name = "DAC";
string public symbol = "DAC";
uint public decimals = 6;
uint private constant initialSupply = 10e9 * 1e6; // 10 billions + 18 decimals
function DACToken() public
{<FILL_FUNCTION_BODY> }
} | contract DACToken is StandardToken, Ownable
{
string public name = "DAC";
string public symbol = "DAC";
uint public decimals = 6;
uint private constant initialSupply = 10e9 * 1e6; <FILL_FUNCTION>
} |
owner = msg.sender;
totalSupply = initialSupply;
balances[owner] = initialSupply;
| function DACToken() public
| // 10 billions + 18 decimals
function DACToken() public
|
35640 | MintableToken | mint | contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
/**
* @dev Function to mint tokens
* @param _to The address that will recieve the minted tokens.
* @param _amount The amount of tokens to mint.
* @return A boolean that indicates if the operation was successful.
*/
function mint(address _to, uint256 _amount) onlyOwner canMint returns (bool) {<FILL_FUNCTION_BODY> }
/**
* @dev Function to stop minting new tokens.
* @return True if the operation was successful.
*/
function finishMinting() onlyOwner returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
} | contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
<FILL_FUNCTION>
/**
* @dev Function to stop minting new tokens.
* @return True if the operation was successful.
*/
function finishMinting() onlyOwner returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
} |
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
return true;
| function mint(address _to, uint256 _amount) onlyOwner canMint returns (bool) | /**
* @dev Function to mint tokens
* @param _to The address that will recieve the minted tokens.
* @param _amount The amount of tokens to mint.
* @return A boolean that indicates if the operation was successful.
*/
function mint(address _to, uint256 _amount) onlyOwner canMint returns (bool) |
58104 | StandardToken | transferFrom | contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {<FILL_FUNCTION_BODY> }
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
*
* 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
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
/**
* @dev Increase the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _addedValue The amount of tokens to increase the allowance by.
*/
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
/**
* @dev Decrease the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To decrement
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _subtractedValue The amount of tokens to decrease the allowance by.
*/
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
} | contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
<FILL_FUNCTION>
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
*
* 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
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
/**
* @dev Increase the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _addedValue The amount of tokens to increase the allowance by.
*/
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
/**
* @dev Decrease the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To decrement
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _subtractedValue The amount of tokens to decrease the allowance by.
*/
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
} |
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
| function transferFrom(address _from, address _to, uint256 _value) public returns (bool) | /**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) |
94132 | Pausable | unpause | contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*/
modifier whenNotPaused() {
require(!paused);
_;
}
/**
* @dev Modifier to make a function callable only when the contract is paused.
*/
modifier whenPaused() {
require(paused);
_;
}
/**
* @dev called by the owner to pause, triggers stopped state
*/
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
/**
* @dev called by the owner to unpause, returns to normal state
*/
function unpause() onlyOwner whenPaused public {<FILL_FUNCTION_BODY> }
} | contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*/
modifier whenNotPaused() {
require(!paused);
_;
}
/**
* @dev Modifier to make a function callable only when the contract is paused.
*/
modifier whenPaused() {
require(paused);
_;
}
/**
* @dev called by the owner to pause, triggers stopped state
*/
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
<FILL_FUNCTION>
} |
paused = false;
Unpause();
| function unpause() onlyOwner whenPaused public | /**
* @dev called by the owner to unpause, returns to normal state
*/
function unpause() onlyOwner whenPaused public |
68396 | Pausable | unpause | contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*/
modifier whenNotPaused() {
require(!paused);
_;
}
/**
* @dev Modifier to make a function callable only when the contract is paused.
*/
modifier whenPaused() {
require(paused);
_;
}
/**
* @dev called by the owner to pause, triggers stopped state
*/
function pause() public onlyOwner whenNotPaused {
paused = true;
emit Pause();
}
/**
* @dev called by the owner to unpause, returns to normal state
*/
function unpause() public onlyOwner whenPaused {<FILL_FUNCTION_BODY> }
} | contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*/
modifier whenNotPaused() {
require(!paused);
_;
}
/**
* @dev Modifier to make a function callable only when the contract is paused.
*/
modifier whenPaused() {
require(paused);
_;
}
/**
* @dev called by the owner to pause, triggers stopped state
*/
function pause() public onlyOwner whenNotPaused {
paused = true;
emit Pause();
}
<FILL_FUNCTION>
} |
paused = false;
emit Unpause();
| function unpause() public onlyOwner whenPaused | /**
* @dev called by the owner to unpause, returns to normal state
*/
function unpause() public onlyOwner whenPaused |
10878 | Ownable | Ownable | contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function Ownable() {<FILL_FUNCTION_BODY> }
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
} | contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
<FILL_FUNCTION>
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
} |
owner = msg.sender;
| function Ownable() | /**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function Ownable() |