contract_name
stringlengths 1
61
| file_path
stringlengths 5
50.4k
| contract_address
stringlengths 42
42
| language
stringclasses 1
value | class_name
stringlengths 1
61
| class_code
stringlengths 4
330k
| class_documentation
stringlengths 0
29.1k
| class_documentation_type
stringclasses 6
values | func_name
stringlengths 0
62
| func_code
stringlengths 1
303k
| func_documentation
stringlengths 2
14.9k
| func_documentation_type
stringclasses 4
values | compiler_version
stringlengths 15
42
| license_type
stringclasses 14
values | swarm_source
stringlengths 0
71
| meta
dict | __index_level_0__
int64 0
60.4k
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
PodCoin | PodCoin.sol | 0x62191e09fa1f0ebcad7e10dab011c2393d7315aa | Solidity | Token | contract Token {
/// @return total amount of tokens
function totalSupply() constant returns (uint256 supply) {}
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) constant returns (uint256 balance) {}
/// @notice send `_value` token to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transfer(address _to, uint256 _value) returns (bool success) {}
/// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {}
/// @notice `msg.sender` approves `_addr` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of wei to be approved for transfer
/// @return Whether the approval was successful or not
function approve(address _spender, uint256 _value) returns (bool success) {}
/// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
} | // ☯ P o d C o i n
//
// By Mr. 1 50 1 100
//
// Learn more at PodCoin.info | LineComment | transfer | function transfer(address _to, uint256 _value) returns (bool success) {}
| /// @notice send `_value` token to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not | NatSpecSingleLine | v0.4.19+commit.c4cbbb05 | bzzr://796da5a85d52696efa0568b78d573a1578158bf6685c7a65d0b5ec5ae940a600 | {
"func_code_index": [
546,
623
]
} | 59,861 |
|
PodCoin | PodCoin.sol | 0x62191e09fa1f0ebcad7e10dab011c2393d7315aa | Solidity | Token | contract Token {
/// @return total amount of tokens
function totalSupply() constant returns (uint256 supply) {}
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) constant returns (uint256 balance) {}
/// @notice send `_value` token to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transfer(address _to, uint256 _value) returns (bool success) {}
/// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {}
/// @notice `msg.sender` approves `_addr` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of wei to be approved for transfer
/// @return Whether the approval was successful or not
function approve(address _spender, uint256 _value) returns (bool success) {}
/// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
} | // ☯ P o d C o i n
//
// By Mr. 1 50 1 100
//
// Learn more at PodCoin.info | LineComment | transferFrom | function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {}
| /// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not | NatSpecSingleLine | v0.4.19+commit.c4cbbb05 | bzzr://796da5a85d52696efa0568b78d573a1578158bf6685c7a65d0b5ec5ae940a600 | {
"func_code_index": [
946,
1042
]
} | 59,862 |
|
PodCoin | PodCoin.sol | 0x62191e09fa1f0ebcad7e10dab011c2393d7315aa | Solidity | Token | contract Token {
/// @return total amount of tokens
function totalSupply() constant returns (uint256 supply) {}
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) constant returns (uint256 balance) {}
/// @notice send `_value` token to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transfer(address _to, uint256 _value) returns (bool success) {}
/// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {}
/// @notice `msg.sender` approves `_addr` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of wei to be approved for transfer
/// @return Whether the approval was successful or not
function approve(address _spender, uint256 _value) returns (bool success) {}
/// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
} | // ☯ P o d C o i n
//
// By Mr. 1 50 1 100
//
// Learn more at PodCoin.info | LineComment | approve | function approve(address _spender, uint256 _value) returns (bool success) {}
| /// @notice `msg.sender` approves `_addr` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of wei to be approved for transfer
/// @return Whether the approval was successful or not | NatSpecSingleLine | v0.4.19+commit.c4cbbb05 | bzzr://796da5a85d52696efa0568b78d573a1578158bf6685c7a65d0b5ec5ae940a600 | {
"func_code_index": [
1326,
1407
]
} | 59,863 |
|
PodCoin | PodCoin.sol | 0x62191e09fa1f0ebcad7e10dab011c2393d7315aa | Solidity | Token | contract Token {
/// @return total amount of tokens
function totalSupply() constant returns (uint256 supply) {}
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) constant returns (uint256 balance) {}
/// @notice send `_value` token to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transfer(address _to, uint256 _value) returns (bool success) {}
/// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {}
/// @notice `msg.sender` approves `_addr` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of wei to be approved for transfer
/// @return Whether the approval was successful or not
function approve(address _spender, uint256 _value) returns (bool success) {}
/// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
} | // ☯ P o d C o i n
//
// By Mr. 1 50 1 100
//
// Learn more at PodCoin.info | LineComment | allowance | function allowance(address _owner, address _spender) constant returns (uint256 remaining) {}
| /// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent | NatSpecSingleLine | v0.4.19+commit.c4cbbb05 | bzzr://796da5a85d52696efa0568b78d573a1578158bf6685c7a65d0b5ec5ae940a600 | {
"func_code_index": [
1615,
1712
]
} | 59,864 |
|
PodCoin | PodCoin.sol | 0x62191e09fa1f0ebcad7e10dab011c2393d7315aa | Solidity | PodCoin | contract PodCoin is StandardToken {
string public name;
uint8 public decimals;
string public symbol;
string public version = 'H1.0';
address public fundsWallet;
function PodCoin() {
balances[msg.sender] = 10000000000000000000000000;
totalSupply = 10000000000000000000000000;
name = "PodCoin";
decimals = 18;
symbol = "P☯D";
fundsWallet = msg.sender;
}
/*This function just serves to answer requests for P☯D, not actual payment.*/
function() payable{
if (balances[fundsWallet] < amount) {
return;
}
uint256 amount = 0;
//Set 10,000 sent to requester unless they have any PodCoin Already
if(balances[msg.sender] == 0){
amount = 10000000000000000000000;
balances[fundsWallet] = balances[fundsWallet] - amount;
balances[msg.sender] = balances[msg.sender] + amount;
}
Transfer(fundsWallet, msg.sender, amount); // Broadcast a message to the blockchain
}
/* Approves and then calls the receiving contract */
function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
if(!_spender.call(bytes4(bytes32(sha3("receiveApproval(address,uint256,address,bytes)"))), msg.sender, _value, this, _extraData)) { throw; }
return true;
}
} | function() payable{
if (balances[fundsWallet] < amount) {
return;
}
uint256 amount = 0;
//Set 10,000 sent to requester unless they have any PodCoin Already
if(balances[msg.sender] == 0){
amount = 10000000000000000000000;
balances[fundsWallet] = balances[fundsWallet] - amount;
balances[msg.sender] = balances[msg.sender] + amount;
}
Transfer(fundsWallet, msg.sender, amount); // Broadcast a message to the blockchain
}
| /*This function just serves to answer requests for P☯D, not actual payment.*/ | Comment | v0.4.19+commit.c4cbbb05 | bzzr://796da5a85d52696efa0568b78d573a1578158bf6685c7a65d0b5ec5ae940a600 | {
"func_code_index": [
838,
1432
]
} | 59,865 |
||||
PodCoin | PodCoin.sol | 0x62191e09fa1f0ebcad7e10dab011c2393d7315aa | Solidity | PodCoin | contract PodCoin is StandardToken {
string public name;
uint8 public decimals;
string public symbol;
string public version = 'H1.0';
address public fundsWallet;
function PodCoin() {
balances[msg.sender] = 10000000000000000000000000;
totalSupply = 10000000000000000000000000;
name = "PodCoin";
decimals = 18;
symbol = "P☯D";
fundsWallet = msg.sender;
}
/*This function just serves to answer requests for P☯D, not actual payment.*/
function() payable{
if (balances[fundsWallet] < amount) {
return;
}
uint256 amount = 0;
//Set 10,000 sent to requester unless they have any PodCoin Already
if(balances[msg.sender] == 0){
amount = 10000000000000000000000;
balances[fundsWallet] = balances[fundsWallet] - amount;
balances[msg.sender] = balances[msg.sender] + amount;
}
Transfer(fundsWallet, msg.sender, amount); // Broadcast a message to the blockchain
}
/* Approves and then calls the receiving contract */
function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
if(!_spender.call(bytes4(bytes32(sha3("receiveApproval(address,uint256,address,bytes)"))), msg.sender, _value, this, _extraData)) { throw; }
return true;
}
} | approveAndCall | function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
if(!_spender.call(bytes4(bytes32(sha3("receiveApproval(address,uint256,address,bytes)"))), msg.sender, _value, this, _extraData)) { throw; }
return true;
}
| /* Approves and then calls the receiving contract */ | Comment | v0.4.19+commit.c4cbbb05 | bzzr://796da5a85d52696efa0568b78d573a1578158bf6685c7a65d0b5ec5ae940a600 | {
"func_code_index": [
1495,
1879
]
} | 59,866 |
|||
TokenSale | TokenSale.sol | 0xb8d8496a49fc00c8fc42e1d8822ea15d33b7c2ae | Solidity | SafeMath | library SafeMath {
/// @dev Multiplies a times b
function mul(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
uint256 c = a * b;
require(a == 0 || c / a == b);
return c;
}
/// @dev Divides a by b
function div(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
// require(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// require(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/// @dev Subtracts a from b
function sub(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
require(b <= a);
return a - b;
}
/// @dev Adds a to b
function add(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
uint256 c = a + b;
require(c >= a);
return c;
}
} | /// @title SafeMath
/// @dev Math operations with safety checks that throw on error | NatSpecSingleLine | mul | function mul(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
uint256 c = a * b;
require(a == 0 || c / a == b);
return c;
}
| /// @dev Multiplies a times b | NatSpecSingleLine | v0.4.18+commit.9cf6e910 | bzzr://0692760ec1db61591d22a91dffec166a0b6a1575b73970edbeb3a305571151bf | {
"func_code_index": [
55,
245
]
} | 59,867 |
|
TokenSale | TokenSale.sol | 0xb8d8496a49fc00c8fc42e1d8822ea15d33b7c2ae | Solidity | SafeMath | library SafeMath {
/// @dev Multiplies a times b
function mul(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
uint256 c = a * b;
require(a == 0 || c / a == b);
return c;
}
/// @dev Divides a by b
function div(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
// require(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// require(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/// @dev Subtracts a from b
function sub(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
require(b <= a);
return a - b;
}
/// @dev Adds a to b
function add(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
uint256 c = a + b;
require(c >= a);
return c;
}
} | /// @title SafeMath
/// @dev Math operations with safety checks that throw on error | NatSpecSingleLine | div | function div(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
// require(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// require(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
| /// @dev Divides a by b | NatSpecSingleLine | v0.4.18+commit.9cf6e910 | bzzr://0692760ec1db61591d22a91dffec166a0b6a1575b73970edbeb3a305571151bf | {
"func_code_index": [
277,
595
]
} | 59,868 |
|
TokenSale | TokenSale.sol | 0xb8d8496a49fc00c8fc42e1d8822ea15d33b7c2ae | Solidity | SafeMath | library SafeMath {
/// @dev Multiplies a times b
function mul(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
uint256 c = a * b;
require(a == 0 || c / a == b);
return c;
}
/// @dev Divides a by b
function div(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
// require(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// require(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/// @dev Subtracts a from b
function sub(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
require(b <= a);
return a - b;
}
/// @dev Adds a to b
function add(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
uint256 c = a + b;
require(c >= a);
return c;
}
} | /// @title SafeMath
/// @dev Math operations with safety checks that throw on error | NatSpecSingleLine | sub | function sub(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
require(b <= a);
return a - b;
}
| /// @dev Subtracts a from b | NatSpecSingleLine | v0.4.18+commit.9cf6e910 | bzzr://0692760ec1db61591d22a91dffec166a0b6a1575b73970edbeb3a305571151bf | {
"func_code_index": [
631,
783
]
} | 59,869 |
|
TokenSale | TokenSale.sol | 0xb8d8496a49fc00c8fc42e1d8822ea15d33b7c2ae | Solidity | SafeMath | library SafeMath {
/// @dev Multiplies a times b
function mul(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
uint256 c = a * b;
require(a == 0 || c / a == b);
return c;
}
/// @dev Divides a by b
function div(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
// require(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// require(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/// @dev Subtracts a from b
function sub(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
require(b <= a);
return a - b;
}
/// @dev Adds a to b
function add(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
uint256 c = a + b;
require(c >= a);
return c;
}
} | /// @title SafeMath
/// @dev Math operations with safety checks that throw on error | NatSpecSingleLine | add | function add(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
uint256 c = a + b;
require(c >= a);
return c;
}
| /// @dev Adds a to b | NatSpecSingleLine | v0.4.18+commit.9cf6e910 | bzzr://0692760ec1db61591d22a91dffec166a0b6a1575b73970edbeb3a305571151bf | {
"func_code_index": [
812,
988
]
} | 59,870 |
|
TokenSale | TokenSale.sol | 0xb8d8496a49fc00c8fc42e1d8822ea15d33b7c2ae | Solidity | Token | contract Token {
/*
* Events
*/
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
/*
* Public functions
*/
function transfer(address to, uint256 value) public returns (bool);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
function balanceOf(address owner) public constant returns (uint256);
function allowance(address owner, address spender) public constant returns (uint256);
uint256 public totalSupply;
} | /// Implements ERC 20 Token standard: https://github.com/ethereum/EIPs/issues/20
/// @title Abstract token contract - Functions to be implemented by token contracts | NatSpecSingleLine | transfer | function transfer(address to, uint256 value) public returns (bool);
| /*
* Public functions
*/ | Comment | v0.4.18+commit.9cf6e910 | bzzr://0692760ec1db61591d22a91dffec166a0b6a1575b73970edbeb3a305571151bf | {
"func_code_index": [
256,
328
]
} | 59,871 |
|
TokenSale | TokenSale.sol | 0xb8d8496a49fc00c8fc42e1d8822ea15d33b7c2ae | Solidity | StandardToken | contract StandardToken is Token {
using SafeMath for uint256;
/*
* Storage
*/
mapping (address => uint256) public balances;
mapping (address => mapping (address => uint256)) public allowances;
uint256 public totalSupply;
/*
* Public functions
*/
/// @dev Transfers sender's tokens to a given address. Returns success
/// @param to Address of token receiver
/// @param value Number of tokens to transfer
/// @return Returns success of function call
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;
}
/// @dev Allows allowances third party to transfer tokens from one address to another. Returns success
/// @param from Address from where tokens are withdrawn
/// @param to Address to where tokens are sent
/// @param value Number of tokens to transfer
/// @return Returns success of function call
function transferFrom(address from, address to, uint256 value)
public
returns (bool)
{
// if (balances[from] < value || allowances[from][msg.sender] < value)
// // Balance or allowance too low
// revert();
require(to != address(0));
require(value <= balances[from]);
require(value <= allowances[from][msg.sender]);
balances[to] = balances[to].add(value);
balances[from] = balances[from].sub(value);
allowances[from][msg.sender] = allowances[from][msg.sender].sub(value);
Transfer(from, to, value);
return true;
}
/// @dev Sets approved amount of tokens for spender. Returns success
/// @param _spender Address of allowances account
/// @param value Number of approved tokens
/// @return Returns success of function call
function approve(address _spender, uint256 value)
public
returns (bool success)
{
require((value == 0) || (allowances[msg.sender][_spender] == 0));
allowances[msg.sender][_spender] = value;
Approval(msg.sender, _spender, value);
return true;
}
/**
* approve should be called when allowances[_spender] == 0. To increment
* allowances 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)
{
allowances[msg.sender][_spender] = allowances[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowances[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue)
public
returns (bool)
{
uint oldValue = allowances[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowances[msg.sender][_spender] = 0;
} else {
allowances[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowances[msg.sender][_spender]);
return true;
}
/// @dev Returns number of allowances tokens for given address
/// @param _owner Address of token owner
/// @param _spender Address of token spender
/// @return Returns remaining allowance for spender
function allowance(address _owner, address _spender)
public
constant
returns (uint256)
{
return allowances[_owner][_spender];
}
/// @dev Returns number of tokens owned by given address
/// @param _owner Address of token owner
/// @return Returns balance of owner
function balanceOf(address _owner)
public
constant
returns (uint256)
{
return balances[_owner];
}
} | /// @title Standard token contract - Standard token interface implementation | NatSpecSingleLine | transfer | 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;
}
| /// @dev Transfers sender's tokens to a given address. Returns success
/// @param to Address of token receiver
/// @param value Number of tokens to transfer
/// @return Returns success of function call | NatSpecSingleLine | v0.4.18+commit.9cf6e910 | bzzr://0692760ec1db61591d22a91dffec166a0b6a1575b73970edbeb3a305571151bf | {
"func_code_index": [
525,
891
]
} | 59,872 |
|
TokenSale | TokenSale.sol | 0xb8d8496a49fc00c8fc42e1d8822ea15d33b7c2ae | Solidity | StandardToken | contract StandardToken is Token {
using SafeMath for uint256;
/*
* Storage
*/
mapping (address => uint256) public balances;
mapping (address => mapping (address => uint256)) public allowances;
uint256 public totalSupply;
/*
* Public functions
*/
/// @dev Transfers sender's tokens to a given address. Returns success
/// @param to Address of token receiver
/// @param value Number of tokens to transfer
/// @return Returns success of function call
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;
}
/// @dev Allows allowances third party to transfer tokens from one address to another. Returns success
/// @param from Address from where tokens are withdrawn
/// @param to Address to where tokens are sent
/// @param value Number of tokens to transfer
/// @return Returns success of function call
function transferFrom(address from, address to, uint256 value)
public
returns (bool)
{
// if (balances[from] < value || allowances[from][msg.sender] < value)
// // Balance or allowance too low
// revert();
require(to != address(0));
require(value <= balances[from]);
require(value <= allowances[from][msg.sender]);
balances[to] = balances[to].add(value);
balances[from] = balances[from].sub(value);
allowances[from][msg.sender] = allowances[from][msg.sender].sub(value);
Transfer(from, to, value);
return true;
}
/// @dev Sets approved amount of tokens for spender. Returns success
/// @param _spender Address of allowances account
/// @param value Number of approved tokens
/// @return Returns success of function call
function approve(address _spender, uint256 value)
public
returns (bool success)
{
require((value == 0) || (allowances[msg.sender][_spender] == 0));
allowances[msg.sender][_spender] = value;
Approval(msg.sender, _spender, value);
return true;
}
/**
* approve should be called when allowances[_spender] == 0. To increment
* allowances 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)
{
allowances[msg.sender][_spender] = allowances[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowances[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue)
public
returns (bool)
{
uint oldValue = allowances[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowances[msg.sender][_spender] = 0;
} else {
allowances[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowances[msg.sender][_spender]);
return true;
}
/// @dev Returns number of allowances tokens for given address
/// @param _owner Address of token owner
/// @param _spender Address of token spender
/// @return Returns remaining allowance for spender
function allowance(address _owner, address _spender)
public
constant
returns (uint256)
{
return allowances[_owner][_spender];
}
/// @dev Returns number of tokens owned by given address
/// @param _owner Address of token owner
/// @return Returns balance of owner
function balanceOf(address _owner)
public
constant
returns (uint256)
{
return balances[_owner];
}
} | /// @title Standard token contract - Standard token interface implementation | NatSpecSingleLine | transferFrom | function transferFrom(address from, address to, uint256 value)
public
returns (bool)
{
// if (balances[from] < value || allowances[from][msg.sender] < value)
// // Balance or allowance too low
// revert();
require(to != address(0));
require(value <= balances[from]);
require(value <= allowances[from][msg.sender]);
balances[to] = balances[to].add(value);
balances[from] = balances[from].sub(value);
allowances[from][msg.sender] = allowances[from][msg.sender].sub(value);
Transfer(from, to, value);
return true;
}
| /// @dev Allows allowances third party to transfer tokens from one address to another. Returns success
/// @param from Address from where tokens are withdrawn
/// @param to Address to where tokens are sent
/// @param value Number of tokens to transfer
/// @return Returns success of function call | NatSpecSingleLine | v0.4.18+commit.9cf6e910 | bzzr://0692760ec1db61591d22a91dffec166a0b6a1575b73970edbeb3a305571151bf | {
"func_code_index": [
1216,
1868
]
} | 59,873 |
|
TokenSale | TokenSale.sol | 0xb8d8496a49fc00c8fc42e1d8822ea15d33b7c2ae | Solidity | StandardToken | contract StandardToken is Token {
using SafeMath for uint256;
/*
* Storage
*/
mapping (address => uint256) public balances;
mapping (address => mapping (address => uint256)) public allowances;
uint256 public totalSupply;
/*
* Public functions
*/
/// @dev Transfers sender's tokens to a given address. Returns success
/// @param to Address of token receiver
/// @param value Number of tokens to transfer
/// @return Returns success of function call
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;
}
/// @dev Allows allowances third party to transfer tokens from one address to another. Returns success
/// @param from Address from where tokens are withdrawn
/// @param to Address to where tokens are sent
/// @param value Number of tokens to transfer
/// @return Returns success of function call
function transferFrom(address from, address to, uint256 value)
public
returns (bool)
{
// if (balances[from] < value || allowances[from][msg.sender] < value)
// // Balance or allowance too low
// revert();
require(to != address(0));
require(value <= balances[from]);
require(value <= allowances[from][msg.sender]);
balances[to] = balances[to].add(value);
balances[from] = balances[from].sub(value);
allowances[from][msg.sender] = allowances[from][msg.sender].sub(value);
Transfer(from, to, value);
return true;
}
/// @dev Sets approved amount of tokens for spender. Returns success
/// @param _spender Address of allowances account
/// @param value Number of approved tokens
/// @return Returns success of function call
function approve(address _spender, uint256 value)
public
returns (bool success)
{
require((value == 0) || (allowances[msg.sender][_spender] == 0));
allowances[msg.sender][_spender] = value;
Approval(msg.sender, _spender, value);
return true;
}
/**
* approve should be called when allowances[_spender] == 0. To increment
* allowances 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)
{
allowances[msg.sender][_spender] = allowances[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowances[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue)
public
returns (bool)
{
uint oldValue = allowances[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowances[msg.sender][_spender] = 0;
} else {
allowances[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowances[msg.sender][_spender]);
return true;
}
/// @dev Returns number of allowances tokens for given address
/// @param _owner Address of token owner
/// @param _spender Address of token spender
/// @return Returns remaining allowance for spender
function allowance(address _owner, address _spender)
public
constant
returns (uint256)
{
return allowances[_owner][_spender];
}
/// @dev Returns number of tokens owned by given address
/// @param _owner Address of token owner
/// @return Returns balance of owner
function balanceOf(address _owner)
public
constant
returns (uint256)
{
return balances[_owner];
}
} | /// @title Standard token contract - Standard token interface implementation | NatSpecSingleLine | approve | function approve(address _spender, uint256 value)
public
returns (bool success)
{
require((value == 0) || (allowances[msg.sender][_spender] == 0));
allowances[msg.sender][_spender] = value;
Approval(msg.sender, _spender, value);
return true;
}
| /// @dev Sets approved amount of tokens for spender. Returns success
/// @param _spender Address of allowances account
/// @param value Number of approved tokens
/// @return Returns success of function call | NatSpecSingleLine | v0.4.18+commit.9cf6e910 | bzzr://0692760ec1db61591d22a91dffec166a0b6a1575b73970edbeb3a305571151bf | {
"func_code_index": [
2098,
2410
]
} | 59,874 |
|
TokenSale | TokenSale.sol | 0xb8d8496a49fc00c8fc42e1d8822ea15d33b7c2ae | Solidity | StandardToken | contract StandardToken is Token {
using SafeMath for uint256;
/*
* Storage
*/
mapping (address => uint256) public balances;
mapping (address => mapping (address => uint256)) public allowances;
uint256 public totalSupply;
/*
* Public functions
*/
/// @dev Transfers sender's tokens to a given address. Returns success
/// @param to Address of token receiver
/// @param value Number of tokens to transfer
/// @return Returns success of function call
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;
}
/// @dev Allows allowances third party to transfer tokens from one address to another. Returns success
/// @param from Address from where tokens are withdrawn
/// @param to Address to where tokens are sent
/// @param value Number of tokens to transfer
/// @return Returns success of function call
function transferFrom(address from, address to, uint256 value)
public
returns (bool)
{
// if (balances[from] < value || allowances[from][msg.sender] < value)
// // Balance or allowance too low
// revert();
require(to != address(0));
require(value <= balances[from]);
require(value <= allowances[from][msg.sender]);
balances[to] = balances[to].add(value);
balances[from] = balances[from].sub(value);
allowances[from][msg.sender] = allowances[from][msg.sender].sub(value);
Transfer(from, to, value);
return true;
}
/// @dev Sets approved amount of tokens for spender. Returns success
/// @param _spender Address of allowances account
/// @param value Number of approved tokens
/// @return Returns success of function call
function approve(address _spender, uint256 value)
public
returns (bool success)
{
require((value == 0) || (allowances[msg.sender][_spender] == 0));
allowances[msg.sender][_spender] = value;
Approval(msg.sender, _spender, value);
return true;
}
/**
* approve should be called when allowances[_spender] == 0. To increment
* allowances 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)
{
allowances[msg.sender][_spender] = allowances[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowances[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue)
public
returns (bool)
{
uint oldValue = allowances[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowances[msg.sender][_spender] = 0;
} else {
allowances[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowances[msg.sender][_spender]);
return true;
}
/// @dev Returns number of allowances tokens for given address
/// @param _owner Address of token owner
/// @param _spender Address of token spender
/// @return Returns remaining allowance for spender
function allowance(address _owner, address _spender)
public
constant
returns (uint256)
{
return allowances[_owner][_spender];
}
/// @dev Returns number of tokens owned by given address
/// @param _owner Address of token owner
/// @return Returns balance of owner
function balanceOf(address _owner)
public
constant
returns (uint256)
{
return balances[_owner];
}
} | /// @title Standard token contract - Standard token interface implementation | NatSpecSingleLine | increaseApproval | function increaseApproval(address _spender, uint _addedValue)
public
returns (bool)
{
allowances[msg.sender][_spender] = allowances[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowances[msg.sender][_spender]);
return true;
}
| /**
* approve should be called when allowances[_spender] == 0. To increment
* allowances value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
*/ | NatSpecMultiLine | v0.4.18+commit.9cf6e910 | bzzr://0692760ec1db61591d22a91dffec166a0b6a1575b73970edbeb3a305571151bf | {
"func_code_index": [
2660,
2972
]
} | 59,875 |
|
TokenSale | TokenSale.sol | 0xb8d8496a49fc00c8fc42e1d8822ea15d33b7c2ae | Solidity | StandardToken | contract StandardToken is Token {
using SafeMath for uint256;
/*
* Storage
*/
mapping (address => uint256) public balances;
mapping (address => mapping (address => uint256)) public allowances;
uint256 public totalSupply;
/*
* Public functions
*/
/// @dev Transfers sender's tokens to a given address. Returns success
/// @param to Address of token receiver
/// @param value Number of tokens to transfer
/// @return Returns success of function call
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;
}
/// @dev Allows allowances third party to transfer tokens from one address to another. Returns success
/// @param from Address from where tokens are withdrawn
/// @param to Address to where tokens are sent
/// @param value Number of tokens to transfer
/// @return Returns success of function call
function transferFrom(address from, address to, uint256 value)
public
returns (bool)
{
// if (balances[from] < value || allowances[from][msg.sender] < value)
// // Balance or allowance too low
// revert();
require(to != address(0));
require(value <= balances[from]);
require(value <= allowances[from][msg.sender]);
balances[to] = balances[to].add(value);
balances[from] = balances[from].sub(value);
allowances[from][msg.sender] = allowances[from][msg.sender].sub(value);
Transfer(from, to, value);
return true;
}
/// @dev Sets approved amount of tokens for spender. Returns success
/// @param _spender Address of allowances account
/// @param value Number of approved tokens
/// @return Returns success of function call
function approve(address _spender, uint256 value)
public
returns (bool success)
{
require((value == 0) || (allowances[msg.sender][_spender] == 0));
allowances[msg.sender][_spender] = value;
Approval(msg.sender, _spender, value);
return true;
}
/**
* approve should be called when allowances[_spender] == 0. To increment
* allowances 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)
{
allowances[msg.sender][_spender] = allowances[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowances[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue)
public
returns (bool)
{
uint oldValue = allowances[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowances[msg.sender][_spender] = 0;
} else {
allowances[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowances[msg.sender][_spender]);
return true;
}
/// @dev Returns number of allowances tokens for given address
/// @param _owner Address of token owner
/// @param _spender Address of token spender
/// @return Returns remaining allowance for spender
function allowance(address _owner, address _spender)
public
constant
returns (uint256)
{
return allowances[_owner][_spender];
}
/// @dev Returns number of tokens owned by given address
/// @param _owner Address of token owner
/// @return Returns balance of owner
function balanceOf(address _owner)
public
constant
returns (uint256)
{
return balances[_owner];
}
} | /// @title Standard token contract - Standard token interface implementation | NatSpecSingleLine | allowance | function allowance(address _owner, address _spender)
public
constant
returns (uint256)
{
return allowances[_owner][_spender];
}
| /// @dev Returns number of allowances tokens for given address
/// @param _owner Address of token owner
/// @param _spender Address of token spender
/// @return Returns remaining allowance for spender | NatSpecSingleLine | v0.4.18+commit.9cf6e910 | bzzr://0692760ec1db61591d22a91dffec166a0b6a1575b73970edbeb3a305571151bf | {
"func_code_index": [
3685,
3863
]
} | 59,876 |
|
TokenSale | TokenSale.sol | 0xb8d8496a49fc00c8fc42e1d8822ea15d33b7c2ae | Solidity | StandardToken | contract StandardToken is Token {
using SafeMath for uint256;
/*
* Storage
*/
mapping (address => uint256) public balances;
mapping (address => mapping (address => uint256)) public allowances;
uint256 public totalSupply;
/*
* Public functions
*/
/// @dev Transfers sender's tokens to a given address. Returns success
/// @param to Address of token receiver
/// @param value Number of tokens to transfer
/// @return Returns success of function call
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;
}
/// @dev Allows allowances third party to transfer tokens from one address to another. Returns success
/// @param from Address from where tokens are withdrawn
/// @param to Address to where tokens are sent
/// @param value Number of tokens to transfer
/// @return Returns success of function call
function transferFrom(address from, address to, uint256 value)
public
returns (bool)
{
// if (balances[from] < value || allowances[from][msg.sender] < value)
// // Balance or allowance too low
// revert();
require(to != address(0));
require(value <= balances[from]);
require(value <= allowances[from][msg.sender]);
balances[to] = balances[to].add(value);
balances[from] = balances[from].sub(value);
allowances[from][msg.sender] = allowances[from][msg.sender].sub(value);
Transfer(from, to, value);
return true;
}
/// @dev Sets approved amount of tokens for spender. Returns success
/// @param _spender Address of allowances account
/// @param value Number of approved tokens
/// @return Returns success of function call
function approve(address _spender, uint256 value)
public
returns (bool success)
{
require((value == 0) || (allowances[msg.sender][_spender] == 0));
allowances[msg.sender][_spender] = value;
Approval(msg.sender, _spender, value);
return true;
}
/**
* approve should be called when allowances[_spender] == 0. To increment
* allowances 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)
{
allowances[msg.sender][_spender] = allowances[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowances[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue)
public
returns (bool)
{
uint oldValue = allowances[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowances[msg.sender][_spender] = 0;
} else {
allowances[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowances[msg.sender][_spender]);
return true;
}
/// @dev Returns number of allowances tokens for given address
/// @param _owner Address of token owner
/// @param _spender Address of token spender
/// @return Returns remaining allowance for spender
function allowance(address _owner, address _spender)
public
constant
returns (uint256)
{
return allowances[_owner][_spender];
}
/// @dev Returns number of tokens owned by given address
/// @param _owner Address of token owner
/// @return Returns balance of owner
function balanceOf(address _owner)
public
constant
returns (uint256)
{
return balances[_owner];
}
} | /// @title Standard token contract - Standard token interface implementation | NatSpecSingleLine | balanceOf | function balanceOf(address _owner)
public
constant
returns (uint256)
{
return balances[_owner];
}
| /// @dev Returns number of tokens owned by given address
/// @param _owner Address of token owner
/// @return Returns balance of owner | NatSpecSingleLine | v0.4.18+commit.9cf6e910 | bzzr://0692760ec1db61591d22a91dffec166a0b6a1575b73970edbeb3a305571151bf | {
"func_code_index": [
4016,
4164
]
} | 59,877 |
|
TokenSale | TokenSale.sol | 0xb8d8496a49fc00c8fc42e1d8822ea15d33b7c2ae | Solidity | TokenSale | contract TokenSale {
using SafeMath for uint256;
/*
* Events
*/
event PresaleStart(uint256 indexed presaleStartTime);
event AllocatePresale(address indexed receiver, uint256 tokenQuantity);
event PresaleEnd(uint256 indexed presaleEndTime);
event MainSaleStart(uint256 indexed startMainSaleTime);
event AllocateMainSale(address indexed receiver, uint256 etherAmount);
event MainSaleEnd(uint256 indexed endMainSaleTime);
event TradingStart(uint256 indexed startTradingTime);
event Refund(address indexed receiver, uint256 etherAmount);
/*
* Constants
*/
// Presale Allocation = 500 * (5000 + 4500 + 4000 + 3500 + 3250 + 3000) * 10**18
uint256 public constant PRESALE_TOKEN_ALLOCATION = 11625000 * 10**18;
uint256 public constant PRESALE_MAX_RAISE = 3000 * 10**18;
/*
* Storage
*/
mapping (address => uint256) public presaleAllocations;
mapping (address => uint256) public mainSaleAllocations;
address public wallet;
Balehubuck public token;
uint256 public presaleEndTime;
uint256 public mainSaleEndTime;
uint256 public minTradingStartTime;
uint256 public maxTradingStartTime;
uint256 public totalReceived;
uint256 public minimumMainSaleRaise;
uint256 public maximumMainSaleRaise;
uint256 public maximumAllocationPerParticipant;
uint256 public mainSaleExchangeRate;
Stages public stage;
enum Stages {
Deployed,
PresaleStarted,
PresaleEnded,
MainSaleStarted,
MainSaleEnded,
Refund,
Trading
}
/*
* Modifiers
*/
modifier onlyWallet() {
require(wallet == msg.sender);
_;
}
modifier atStage(Stages _stage) {
require(stage == _stage);
_;
}
/*
* Fallback function
*/
function ()
external
payable
{
buy(msg.sender);
}
/*
* Constructor function
*/
// @dev Constructor function that create the Balehubuck token and sets the initial variables
// @param _wallet sets the wallet state variable which will be used to start stages throughout the token sale
function TokenSale(address _wallet)
public
{
require(_wallet != 0x0);
wallet = _wallet;
token = new Balehubuck(wallet);
// Sets the default main sale values
minimumMainSaleRaise = 23000 * 10**18;
maximumMainSaleRaise = 78000 * 10**18;
maximumAllocationPerParticipant = 750 * 10**18;
mainSaleExchangeRate = 2500;
stage = Stages.Deployed;
totalReceived = 0;
}
/*
* Public functions
*/
// @ev Allows buyers to buy tokens, throws if neither the presale or main sale is happening
// @param _receiver The address the will receive the tokens
function buy(address _receiver)
public
payable
{
require(msg.value > 0);
address receiver = _receiver;
if (receiver == 0x0)
receiver = msg.sender;
if (stage == Stages.PresaleStarted) {
buyPresale(receiver);
} else if (stage == Stages.MainSaleStarted) {
buyMainSale(receiver);
} else {
revert();
}
}
/*
* External functions
*/
// @dev Starts the presale
function startPresale()
external
onlyWallet
atStage(Stages.Deployed)
{
stage = Stages.PresaleStarted;
presaleEndTime = now + 8 weeks;
PresaleStart(now);
}
// @dev Sets the maximum and minimum raise amounts prior to the main sale
// @dev Use this method with extreme caution!
// @param _minimumMainSaleRaise Sets the minimium main sale raise
// @param _maximumMainSaleRaise Sets the maximum main sale raise
// @param _maximumAllocationPerParticipant sets the maximum main sale allocation per participant
function changeSettings(uint256 _minimumMainSaleRaise,
uint256 _maximumMainSaleRaise,
uint256 _maximumAllocationPerParticipant,
uint256 _mainSaleExchangeRate)
external
onlyWallet
atStage(Stages.PresaleEnded)
{
// Checks the inputs for null values
require(_minimumMainSaleRaise > 0 &&
_maximumMainSaleRaise > 0 &&
_maximumAllocationPerParticipant > 0 &&
_mainSaleExchangeRate > 0);
// Sanity check that requires the min raise to be less then the max
require(_minimumMainSaleRaise < _maximumMainSaleRaise);
// This check verifies that the token_sale contract has enough tokens to match the
// _maximumMainSaleRaiseAmount * _mainSaleExchangeRate (subtracts presale amounts first)
require(_maximumMainSaleRaise.sub(PRESALE_MAX_RAISE).mul(_mainSaleExchangeRate) <= token.balanceOf(this).sub(PRESALE_TOKEN_ALLOCATION));
minimumMainSaleRaise = _minimumMainSaleRaise;
maximumMainSaleRaise = _maximumMainSaleRaise;
mainSaleExchangeRate = _mainSaleExchangeRate;
maximumAllocationPerParticipant = _maximumAllocationPerParticipant;
}
// @dev Starts the main sale
// @dev Make sure the main sale variables are correct before calling
function startMainSale()
external
onlyWallet
atStage(Stages.PresaleEnded)
{
stage = Stages.MainSaleStarted;
mainSaleEndTime = now + 8 weeks;
MainSaleStart(now);
}
// @dev Starts the trading stage, allowing buyer to claim their tokens
function startTrading()
external
atStage(Stages.MainSaleEnded)
{
// Trading starts between two weeks (if called by the wallet) and two months (callable by anyone)
// after the main sale has ended
require((msg.sender == wallet && now >= minTradingStartTime) || now >= maxTradingStartTime);
stage = Stages.Trading;
TradingStart(now);
}
// @dev Allows buyer to be refunded their ETH if the minimum presale raise amount hasn't been met
function refund()
external
atStage(Stages.Refund)
{
uint256 amount = mainSaleAllocations[msg.sender];
mainSaleAllocations[msg.sender] = 0;
msg.sender.transfer(amount);
Refund(msg.sender, amount);
}
// @dev Allows buyers to claim the tokens they've purchased
function claimTokens()
external
atStage(Stages.Trading)
{
uint256 tokenAllocation = presaleAllocations[msg.sender].add(mainSaleAllocations[msg.sender].mul(mainSaleExchangeRate));
presaleAllocations[msg.sender] = 0;
mainSaleAllocations[msg.sender] = 0;
token.transfer(msg.sender, tokenAllocation);
}
/*
* Private functions
*/
// @dev Allocated tokens to the presale buyer at a rate based on the total received
// @param receiver The address presale balehubucks will be allocated to
function buyPresale(address receiver)
private
{
if (now >= presaleEndTime) {
endPresale();
return;
}
uint256 totalTokenAllocation = 0;
uint256 oldTotalReceived = totalReceived;
uint256 tokenAllocation = 0;
uint256 weiUsing = 0;
uint256 weiAmount = msg.value;
uint256 maxWeiForPresaleStage = 0;
uint256 buyerRefund = 0;
// Cycles through the presale phases conditional giving a different exchange rate for
// each phase of the presale until tokens have been allocated for all Ether sent or
// until the presale cap of 3,000 Ether has been reached
while (true) {
// The EVM deals with division by rounding down, causing the below statement to
// round down to the correct stage
// stageAmount = totalReceived.add(500 * 10**18).div(500 * 10**18).mul(500 * 10**18);
// maxWeiForPresaleStage = stageAmount - totalReceived
maxWeiForPresaleStage = (totalReceived.add(500 * 10**18).div(500 * 10**18).mul(500 * 10**18)).sub(totalReceived);
if (weiAmount > maxWeiForPresaleStage) {
weiUsing = maxWeiForPresaleStage;
} else {
weiUsing = weiAmount;
}
weiAmount = weiAmount.sub(weiUsing);
if (totalReceived < 500 * 10**18) {
// Stage 1: up to 500 Ether, exchange rate of 1 ETH for 5000 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 5000);
} else if (totalReceived < 1000 * 10**18) {
// Stage 2: up to 1000 Ether, exchange rate of 1 ETH for 4500 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 4500);
} else if (totalReceived < 1500 * 10**18) {
// Stage 3: up to 1500 Ether, exchange rate of 1 ETH for 4000 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 4000);
} else if (totalReceived < 2000 * 10**18) {
// Stage 4: up to 2000 Ether, exchange rate of 1 ETH for 3500 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 3500);
} else if (totalReceived < 2500 * 10**18) {
// Stage 5: up to 2500 Ether, exchange rate of 1 ETH for 3250 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 3250);
} else if (totalReceived < 3000 * 10**18) {
// Stage 6: up to 3000 Ether, exchange rate of 1 ETH for 3000 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 3000);
}
totalTokenAllocation = totalTokenAllocation.add(tokenAllocation);
totalReceived = totalReceived.add(weiUsing);
if (totalReceived >= PRESALE_MAX_RAISE) {
buyerRefund = weiAmount;
endPresale();
}
// Exits the for loops if the presale cap has been reached (changing the stage)
// or all of the wei send to the presale has been allocated
if (weiAmount == 0 || stage != Stages.PresaleStarted)
break;
}
presaleAllocations[receiver] = presaleAllocations[receiver].add(totalTokenAllocation);
wallet.transfer(totalReceived.sub(oldTotalReceived));
msg.sender.transfer(buyerRefund);
AllocatePresale(receiver, totalTokenAllocation);
}
// @dev Allocated tokens to the presale buyer at a rate based on the total received
// @param receiver The address main sale balehubucks will be allocated to
function buyMainSale(address receiver)
private
{
if (now >= mainSaleEndTime) {
endMainSale(msg.value);
msg.sender.transfer(msg.value);
return;
}
uint256 buyerRefund = 0;
uint256 weiAllocation = mainSaleAllocations[receiver].add(msg.value);
if (weiAllocation >= maximumAllocationPerParticipant) {
weiAllocation = maximumAllocationPerParticipant.sub(mainSaleAllocations[receiver]);
buyerRefund = msg.value.sub(weiAllocation);
}
uint256 potentialReceived = totalReceived.add(weiAllocation);
if (potentialReceived > maximumMainSaleRaise) {
weiAllocation = maximumMainSaleRaise.sub(totalReceived);
buyerRefund = buyerRefund.add(potentialReceived.sub(maximumMainSaleRaise));
endMainSale(buyerRefund);
}
totalReceived = totalReceived.add(weiAllocation);
mainSaleAllocations[receiver] = mainSaleAllocations[receiver].add(weiAllocation);
msg.sender.transfer(buyerRefund);
AllocateMainSale(receiver, weiAllocation);
}
// @dev Calculates the amount of presale tokens to allocate
// @param weiUsing The amount of wei being used to for the given token allocation
// @param rate The eth/token exchange rate, this changes based on how much the presale has received so far
function calcpresaleAllocations(uint256 weiUsing, uint256 rate)
private
pure
returns (uint256)
{
return weiUsing.mul(rate);
}
// @dev Ends the presale
function endPresale()
private
{
stage = Stages.PresaleEnded;
PresaleEnd(now);
}
// @dev Ends the main sale triggering a refund if the minimum sale raise has no been met
// @dev or passes funds raised to the wallet and starts the trading count down
function endMainSale(uint256 buyerRefund)
private
{
if (totalReceived < minimumMainSaleRaise) {
stage = Stages.Refund;
} else {
minTradingStartTime = now + 2 weeks;
maxTradingStartTime = now + 8 weeks;
stage = Stages.MainSaleEnded;
// Transfers all funds raised to the Balehu wallet minus the funds that need to be refunded
wallet.transfer(this.balance.sub(buyerRefund));
// All unsold tokens will remain within the token_sale contract
// and will be treated as burned
}
MainSaleEnd(now);
}
} | function ()
external
payable
{
buy(msg.sender);
}
| /*
* Fallback function
*/ | Comment | v0.4.18+commit.9cf6e910 | bzzr://0692760ec1db61591d22a91dffec166a0b6a1575b73970edbeb3a305571151bf | {
"func_code_index": [
1919,
2010
]
} | 59,878 |
||||
TokenSale | TokenSale.sol | 0xb8d8496a49fc00c8fc42e1d8822ea15d33b7c2ae | Solidity | TokenSale | contract TokenSale {
using SafeMath for uint256;
/*
* Events
*/
event PresaleStart(uint256 indexed presaleStartTime);
event AllocatePresale(address indexed receiver, uint256 tokenQuantity);
event PresaleEnd(uint256 indexed presaleEndTime);
event MainSaleStart(uint256 indexed startMainSaleTime);
event AllocateMainSale(address indexed receiver, uint256 etherAmount);
event MainSaleEnd(uint256 indexed endMainSaleTime);
event TradingStart(uint256 indexed startTradingTime);
event Refund(address indexed receiver, uint256 etherAmount);
/*
* Constants
*/
// Presale Allocation = 500 * (5000 + 4500 + 4000 + 3500 + 3250 + 3000) * 10**18
uint256 public constant PRESALE_TOKEN_ALLOCATION = 11625000 * 10**18;
uint256 public constant PRESALE_MAX_RAISE = 3000 * 10**18;
/*
* Storage
*/
mapping (address => uint256) public presaleAllocations;
mapping (address => uint256) public mainSaleAllocations;
address public wallet;
Balehubuck public token;
uint256 public presaleEndTime;
uint256 public mainSaleEndTime;
uint256 public minTradingStartTime;
uint256 public maxTradingStartTime;
uint256 public totalReceived;
uint256 public minimumMainSaleRaise;
uint256 public maximumMainSaleRaise;
uint256 public maximumAllocationPerParticipant;
uint256 public mainSaleExchangeRate;
Stages public stage;
enum Stages {
Deployed,
PresaleStarted,
PresaleEnded,
MainSaleStarted,
MainSaleEnded,
Refund,
Trading
}
/*
* Modifiers
*/
modifier onlyWallet() {
require(wallet == msg.sender);
_;
}
modifier atStage(Stages _stage) {
require(stage == _stage);
_;
}
/*
* Fallback function
*/
function ()
external
payable
{
buy(msg.sender);
}
/*
* Constructor function
*/
// @dev Constructor function that create the Balehubuck token and sets the initial variables
// @param _wallet sets the wallet state variable which will be used to start stages throughout the token sale
function TokenSale(address _wallet)
public
{
require(_wallet != 0x0);
wallet = _wallet;
token = new Balehubuck(wallet);
// Sets the default main sale values
minimumMainSaleRaise = 23000 * 10**18;
maximumMainSaleRaise = 78000 * 10**18;
maximumAllocationPerParticipant = 750 * 10**18;
mainSaleExchangeRate = 2500;
stage = Stages.Deployed;
totalReceived = 0;
}
/*
* Public functions
*/
// @ev Allows buyers to buy tokens, throws if neither the presale or main sale is happening
// @param _receiver The address the will receive the tokens
function buy(address _receiver)
public
payable
{
require(msg.value > 0);
address receiver = _receiver;
if (receiver == 0x0)
receiver = msg.sender;
if (stage == Stages.PresaleStarted) {
buyPresale(receiver);
} else if (stage == Stages.MainSaleStarted) {
buyMainSale(receiver);
} else {
revert();
}
}
/*
* External functions
*/
// @dev Starts the presale
function startPresale()
external
onlyWallet
atStage(Stages.Deployed)
{
stage = Stages.PresaleStarted;
presaleEndTime = now + 8 weeks;
PresaleStart(now);
}
// @dev Sets the maximum and minimum raise amounts prior to the main sale
// @dev Use this method with extreme caution!
// @param _minimumMainSaleRaise Sets the minimium main sale raise
// @param _maximumMainSaleRaise Sets the maximum main sale raise
// @param _maximumAllocationPerParticipant sets the maximum main sale allocation per participant
function changeSettings(uint256 _minimumMainSaleRaise,
uint256 _maximumMainSaleRaise,
uint256 _maximumAllocationPerParticipant,
uint256 _mainSaleExchangeRate)
external
onlyWallet
atStage(Stages.PresaleEnded)
{
// Checks the inputs for null values
require(_minimumMainSaleRaise > 0 &&
_maximumMainSaleRaise > 0 &&
_maximumAllocationPerParticipant > 0 &&
_mainSaleExchangeRate > 0);
// Sanity check that requires the min raise to be less then the max
require(_minimumMainSaleRaise < _maximumMainSaleRaise);
// This check verifies that the token_sale contract has enough tokens to match the
// _maximumMainSaleRaiseAmount * _mainSaleExchangeRate (subtracts presale amounts first)
require(_maximumMainSaleRaise.sub(PRESALE_MAX_RAISE).mul(_mainSaleExchangeRate) <= token.balanceOf(this).sub(PRESALE_TOKEN_ALLOCATION));
minimumMainSaleRaise = _minimumMainSaleRaise;
maximumMainSaleRaise = _maximumMainSaleRaise;
mainSaleExchangeRate = _mainSaleExchangeRate;
maximumAllocationPerParticipant = _maximumAllocationPerParticipant;
}
// @dev Starts the main sale
// @dev Make sure the main sale variables are correct before calling
function startMainSale()
external
onlyWallet
atStage(Stages.PresaleEnded)
{
stage = Stages.MainSaleStarted;
mainSaleEndTime = now + 8 weeks;
MainSaleStart(now);
}
// @dev Starts the trading stage, allowing buyer to claim their tokens
function startTrading()
external
atStage(Stages.MainSaleEnded)
{
// Trading starts between two weeks (if called by the wallet) and two months (callable by anyone)
// after the main sale has ended
require((msg.sender == wallet && now >= minTradingStartTime) || now >= maxTradingStartTime);
stage = Stages.Trading;
TradingStart(now);
}
// @dev Allows buyer to be refunded their ETH if the minimum presale raise amount hasn't been met
function refund()
external
atStage(Stages.Refund)
{
uint256 amount = mainSaleAllocations[msg.sender];
mainSaleAllocations[msg.sender] = 0;
msg.sender.transfer(amount);
Refund(msg.sender, amount);
}
// @dev Allows buyers to claim the tokens they've purchased
function claimTokens()
external
atStage(Stages.Trading)
{
uint256 tokenAllocation = presaleAllocations[msg.sender].add(mainSaleAllocations[msg.sender].mul(mainSaleExchangeRate));
presaleAllocations[msg.sender] = 0;
mainSaleAllocations[msg.sender] = 0;
token.transfer(msg.sender, tokenAllocation);
}
/*
* Private functions
*/
// @dev Allocated tokens to the presale buyer at a rate based on the total received
// @param receiver The address presale balehubucks will be allocated to
function buyPresale(address receiver)
private
{
if (now >= presaleEndTime) {
endPresale();
return;
}
uint256 totalTokenAllocation = 0;
uint256 oldTotalReceived = totalReceived;
uint256 tokenAllocation = 0;
uint256 weiUsing = 0;
uint256 weiAmount = msg.value;
uint256 maxWeiForPresaleStage = 0;
uint256 buyerRefund = 0;
// Cycles through the presale phases conditional giving a different exchange rate for
// each phase of the presale until tokens have been allocated for all Ether sent or
// until the presale cap of 3,000 Ether has been reached
while (true) {
// The EVM deals with division by rounding down, causing the below statement to
// round down to the correct stage
// stageAmount = totalReceived.add(500 * 10**18).div(500 * 10**18).mul(500 * 10**18);
// maxWeiForPresaleStage = stageAmount - totalReceived
maxWeiForPresaleStage = (totalReceived.add(500 * 10**18).div(500 * 10**18).mul(500 * 10**18)).sub(totalReceived);
if (weiAmount > maxWeiForPresaleStage) {
weiUsing = maxWeiForPresaleStage;
} else {
weiUsing = weiAmount;
}
weiAmount = weiAmount.sub(weiUsing);
if (totalReceived < 500 * 10**18) {
// Stage 1: up to 500 Ether, exchange rate of 1 ETH for 5000 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 5000);
} else if (totalReceived < 1000 * 10**18) {
// Stage 2: up to 1000 Ether, exchange rate of 1 ETH for 4500 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 4500);
} else if (totalReceived < 1500 * 10**18) {
// Stage 3: up to 1500 Ether, exchange rate of 1 ETH for 4000 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 4000);
} else if (totalReceived < 2000 * 10**18) {
// Stage 4: up to 2000 Ether, exchange rate of 1 ETH for 3500 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 3500);
} else if (totalReceived < 2500 * 10**18) {
// Stage 5: up to 2500 Ether, exchange rate of 1 ETH for 3250 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 3250);
} else if (totalReceived < 3000 * 10**18) {
// Stage 6: up to 3000 Ether, exchange rate of 1 ETH for 3000 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 3000);
}
totalTokenAllocation = totalTokenAllocation.add(tokenAllocation);
totalReceived = totalReceived.add(weiUsing);
if (totalReceived >= PRESALE_MAX_RAISE) {
buyerRefund = weiAmount;
endPresale();
}
// Exits the for loops if the presale cap has been reached (changing the stage)
// or all of the wei send to the presale has been allocated
if (weiAmount == 0 || stage != Stages.PresaleStarted)
break;
}
presaleAllocations[receiver] = presaleAllocations[receiver].add(totalTokenAllocation);
wallet.transfer(totalReceived.sub(oldTotalReceived));
msg.sender.transfer(buyerRefund);
AllocatePresale(receiver, totalTokenAllocation);
}
// @dev Allocated tokens to the presale buyer at a rate based on the total received
// @param receiver The address main sale balehubucks will be allocated to
function buyMainSale(address receiver)
private
{
if (now >= mainSaleEndTime) {
endMainSale(msg.value);
msg.sender.transfer(msg.value);
return;
}
uint256 buyerRefund = 0;
uint256 weiAllocation = mainSaleAllocations[receiver].add(msg.value);
if (weiAllocation >= maximumAllocationPerParticipant) {
weiAllocation = maximumAllocationPerParticipant.sub(mainSaleAllocations[receiver]);
buyerRefund = msg.value.sub(weiAllocation);
}
uint256 potentialReceived = totalReceived.add(weiAllocation);
if (potentialReceived > maximumMainSaleRaise) {
weiAllocation = maximumMainSaleRaise.sub(totalReceived);
buyerRefund = buyerRefund.add(potentialReceived.sub(maximumMainSaleRaise));
endMainSale(buyerRefund);
}
totalReceived = totalReceived.add(weiAllocation);
mainSaleAllocations[receiver] = mainSaleAllocations[receiver].add(weiAllocation);
msg.sender.transfer(buyerRefund);
AllocateMainSale(receiver, weiAllocation);
}
// @dev Calculates the amount of presale tokens to allocate
// @param weiUsing The amount of wei being used to for the given token allocation
// @param rate The eth/token exchange rate, this changes based on how much the presale has received so far
function calcpresaleAllocations(uint256 weiUsing, uint256 rate)
private
pure
returns (uint256)
{
return weiUsing.mul(rate);
}
// @dev Ends the presale
function endPresale()
private
{
stage = Stages.PresaleEnded;
PresaleEnd(now);
}
// @dev Ends the main sale triggering a refund if the minimum sale raise has no been met
// @dev or passes funds raised to the wallet and starts the trading count down
function endMainSale(uint256 buyerRefund)
private
{
if (totalReceived < minimumMainSaleRaise) {
stage = Stages.Refund;
} else {
minTradingStartTime = now + 2 weeks;
maxTradingStartTime = now + 8 weeks;
stage = Stages.MainSaleEnded;
// Transfers all funds raised to the Balehu wallet minus the funds that need to be refunded
wallet.transfer(this.balance.sub(buyerRefund));
// All unsold tokens will remain within the token_sale contract
// and will be treated as burned
}
MainSaleEnd(now);
}
} | TokenSale | function TokenSale(address _wallet)
public
{
require(_wallet != 0x0);
wallet = _wallet;
token = new Balehubuck(wallet);
// Sets the default main sale values
minimumMainSaleRaise = 23000 * 10**18;
maximumMainSaleRaise = 78000 * 10**18;
maximumAllocationPerParticipant = 750 * 10**18;
mainSaleExchangeRate = 2500;
stage = Stages.Deployed;
totalReceived = 0;
}
| // @dev Constructor function that create the Balehubuck token and sets the initial variables
// @param _wallet sets the wallet state variable which will be used to start stages throughout the token sale | LineComment | v0.4.18+commit.9cf6e910 | bzzr://0692760ec1db61591d22a91dffec166a0b6a1575b73970edbeb3a305571151bf | {
"func_code_index": [
2273,
2744
]
} | 59,879 |
|||
TokenSale | TokenSale.sol | 0xb8d8496a49fc00c8fc42e1d8822ea15d33b7c2ae | Solidity | TokenSale | contract TokenSale {
using SafeMath for uint256;
/*
* Events
*/
event PresaleStart(uint256 indexed presaleStartTime);
event AllocatePresale(address indexed receiver, uint256 tokenQuantity);
event PresaleEnd(uint256 indexed presaleEndTime);
event MainSaleStart(uint256 indexed startMainSaleTime);
event AllocateMainSale(address indexed receiver, uint256 etherAmount);
event MainSaleEnd(uint256 indexed endMainSaleTime);
event TradingStart(uint256 indexed startTradingTime);
event Refund(address indexed receiver, uint256 etherAmount);
/*
* Constants
*/
// Presale Allocation = 500 * (5000 + 4500 + 4000 + 3500 + 3250 + 3000) * 10**18
uint256 public constant PRESALE_TOKEN_ALLOCATION = 11625000 * 10**18;
uint256 public constant PRESALE_MAX_RAISE = 3000 * 10**18;
/*
* Storage
*/
mapping (address => uint256) public presaleAllocations;
mapping (address => uint256) public mainSaleAllocations;
address public wallet;
Balehubuck public token;
uint256 public presaleEndTime;
uint256 public mainSaleEndTime;
uint256 public minTradingStartTime;
uint256 public maxTradingStartTime;
uint256 public totalReceived;
uint256 public minimumMainSaleRaise;
uint256 public maximumMainSaleRaise;
uint256 public maximumAllocationPerParticipant;
uint256 public mainSaleExchangeRate;
Stages public stage;
enum Stages {
Deployed,
PresaleStarted,
PresaleEnded,
MainSaleStarted,
MainSaleEnded,
Refund,
Trading
}
/*
* Modifiers
*/
modifier onlyWallet() {
require(wallet == msg.sender);
_;
}
modifier atStage(Stages _stage) {
require(stage == _stage);
_;
}
/*
* Fallback function
*/
function ()
external
payable
{
buy(msg.sender);
}
/*
* Constructor function
*/
// @dev Constructor function that create the Balehubuck token and sets the initial variables
// @param _wallet sets the wallet state variable which will be used to start stages throughout the token sale
function TokenSale(address _wallet)
public
{
require(_wallet != 0x0);
wallet = _wallet;
token = new Balehubuck(wallet);
// Sets the default main sale values
minimumMainSaleRaise = 23000 * 10**18;
maximumMainSaleRaise = 78000 * 10**18;
maximumAllocationPerParticipant = 750 * 10**18;
mainSaleExchangeRate = 2500;
stage = Stages.Deployed;
totalReceived = 0;
}
/*
* Public functions
*/
// @ev Allows buyers to buy tokens, throws if neither the presale or main sale is happening
// @param _receiver The address the will receive the tokens
function buy(address _receiver)
public
payable
{
require(msg.value > 0);
address receiver = _receiver;
if (receiver == 0x0)
receiver = msg.sender;
if (stage == Stages.PresaleStarted) {
buyPresale(receiver);
} else if (stage == Stages.MainSaleStarted) {
buyMainSale(receiver);
} else {
revert();
}
}
/*
* External functions
*/
// @dev Starts the presale
function startPresale()
external
onlyWallet
atStage(Stages.Deployed)
{
stage = Stages.PresaleStarted;
presaleEndTime = now + 8 weeks;
PresaleStart(now);
}
// @dev Sets the maximum and minimum raise amounts prior to the main sale
// @dev Use this method with extreme caution!
// @param _minimumMainSaleRaise Sets the minimium main sale raise
// @param _maximumMainSaleRaise Sets the maximum main sale raise
// @param _maximumAllocationPerParticipant sets the maximum main sale allocation per participant
function changeSettings(uint256 _minimumMainSaleRaise,
uint256 _maximumMainSaleRaise,
uint256 _maximumAllocationPerParticipant,
uint256 _mainSaleExchangeRate)
external
onlyWallet
atStage(Stages.PresaleEnded)
{
// Checks the inputs for null values
require(_minimumMainSaleRaise > 0 &&
_maximumMainSaleRaise > 0 &&
_maximumAllocationPerParticipant > 0 &&
_mainSaleExchangeRate > 0);
// Sanity check that requires the min raise to be less then the max
require(_minimumMainSaleRaise < _maximumMainSaleRaise);
// This check verifies that the token_sale contract has enough tokens to match the
// _maximumMainSaleRaiseAmount * _mainSaleExchangeRate (subtracts presale amounts first)
require(_maximumMainSaleRaise.sub(PRESALE_MAX_RAISE).mul(_mainSaleExchangeRate) <= token.balanceOf(this).sub(PRESALE_TOKEN_ALLOCATION));
minimumMainSaleRaise = _minimumMainSaleRaise;
maximumMainSaleRaise = _maximumMainSaleRaise;
mainSaleExchangeRate = _mainSaleExchangeRate;
maximumAllocationPerParticipant = _maximumAllocationPerParticipant;
}
// @dev Starts the main sale
// @dev Make sure the main sale variables are correct before calling
function startMainSale()
external
onlyWallet
atStage(Stages.PresaleEnded)
{
stage = Stages.MainSaleStarted;
mainSaleEndTime = now + 8 weeks;
MainSaleStart(now);
}
// @dev Starts the trading stage, allowing buyer to claim their tokens
function startTrading()
external
atStage(Stages.MainSaleEnded)
{
// Trading starts between two weeks (if called by the wallet) and two months (callable by anyone)
// after the main sale has ended
require((msg.sender == wallet && now >= minTradingStartTime) || now >= maxTradingStartTime);
stage = Stages.Trading;
TradingStart(now);
}
// @dev Allows buyer to be refunded their ETH if the minimum presale raise amount hasn't been met
function refund()
external
atStage(Stages.Refund)
{
uint256 amount = mainSaleAllocations[msg.sender];
mainSaleAllocations[msg.sender] = 0;
msg.sender.transfer(amount);
Refund(msg.sender, amount);
}
// @dev Allows buyers to claim the tokens they've purchased
function claimTokens()
external
atStage(Stages.Trading)
{
uint256 tokenAllocation = presaleAllocations[msg.sender].add(mainSaleAllocations[msg.sender].mul(mainSaleExchangeRate));
presaleAllocations[msg.sender] = 0;
mainSaleAllocations[msg.sender] = 0;
token.transfer(msg.sender, tokenAllocation);
}
/*
* Private functions
*/
// @dev Allocated tokens to the presale buyer at a rate based on the total received
// @param receiver The address presale balehubucks will be allocated to
function buyPresale(address receiver)
private
{
if (now >= presaleEndTime) {
endPresale();
return;
}
uint256 totalTokenAllocation = 0;
uint256 oldTotalReceived = totalReceived;
uint256 tokenAllocation = 0;
uint256 weiUsing = 0;
uint256 weiAmount = msg.value;
uint256 maxWeiForPresaleStage = 0;
uint256 buyerRefund = 0;
// Cycles through the presale phases conditional giving a different exchange rate for
// each phase of the presale until tokens have been allocated for all Ether sent or
// until the presale cap of 3,000 Ether has been reached
while (true) {
// The EVM deals with division by rounding down, causing the below statement to
// round down to the correct stage
// stageAmount = totalReceived.add(500 * 10**18).div(500 * 10**18).mul(500 * 10**18);
// maxWeiForPresaleStage = stageAmount - totalReceived
maxWeiForPresaleStage = (totalReceived.add(500 * 10**18).div(500 * 10**18).mul(500 * 10**18)).sub(totalReceived);
if (weiAmount > maxWeiForPresaleStage) {
weiUsing = maxWeiForPresaleStage;
} else {
weiUsing = weiAmount;
}
weiAmount = weiAmount.sub(weiUsing);
if (totalReceived < 500 * 10**18) {
// Stage 1: up to 500 Ether, exchange rate of 1 ETH for 5000 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 5000);
} else if (totalReceived < 1000 * 10**18) {
// Stage 2: up to 1000 Ether, exchange rate of 1 ETH for 4500 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 4500);
} else if (totalReceived < 1500 * 10**18) {
// Stage 3: up to 1500 Ether, exchange rate of 1 ETH for 4000 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 4000);
} else if (totalReceived < 2000 * 10**18) {
// Stage 4: up to 2000 Ether, exchange rate of 1 ETH for 3500 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 3500);
} else if (totalReceived < 2500 * 10**18) {
// Stage 5: up to 2500 Ether, exchange rate of 1 ETH for 3250 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 3250);
} else if (totalReceived < 3000 * 10**18) {
// Stage 6: up to 3000 Ether, exchange rate of 1 ETH for 3000 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 3000);
}
totalTokenAllocation = totalTokenAllocation.add(tokenAllocation);
totalReceived = totalReceived.add(weiUsing);
if (totalReceived >= PRESALE_MAX_RAISE) {
buyerRefund = weiAmount;
endPresale();
}
// Exits the for loops if the presale cap has been reached (changing the stage)
// or all of the wei send to the presale has been allocated
if (weiAmount == 0 || stage != Stages.PresaleStarted)
break;
}
presaleAllocations[receiver] = presaleAllocations[receiver].add(totalTokenAllocation);
wallet.transfer(totalReceived.sub(oldTotalReceived));
msg.sender.transfer(buyerRefund);
AllocatePresale(receiver, totalTokenAllocation);
}
// @dev Allocated tokens to the presale buyer at a rate based on the total received
// @param receiver The address main sale balehubucks will be allocated to
function buyMainSale(address receiver)
private
{
if (now >= mainSaleEndTime) {
endMainSale(msg.value);
msg.sender.transfer(msg.value);
return;
}
uint256 buyerRefund = 0;
uint256 weiAllocation = mainSaleAllocations[receiver].add(msg.value);
if (weiAllocation >= maximumAllocationPerParticipant) {
weiAllocation = maximumAllocationPerParticipant.sub(mainSaleAllocations[receiver]);
buyerRefund = msg.value.sub(weiAllocation);
}
uint256 potentialReceived = totalReceived.add(weiAllocation);
if (potentialReceived > maximumMainSaleRaise) {
weiAllocation = maximumMainSaleRaise.sub(totalReceived);
buyerRefund = buyerRefund.add(potentialReceived.sub(maximumMainSaleRaise));
endMainSale(buyerRefund);
}
totalReceived = totalReceived.add(weiAllocation);
mainSaleAllocations[receiver] = mainSaleAllocations[receiver].add(weiAllocation);
msg.sender.transfer(buyerRefund);
AllocateMainSale(receiver, weiAllocation);
}
// @dev Calculates the amount of presale tokens to allocate
// @param weiUsing The amount of wei being used to for the given token allocation
// @param rate The eth/token exchange rate, this changes based on how much the presale has received so far
function calcpresaleAllocations(uint256 weiUsing, uint256 rate)
private
pure
returns (uint256)
{
return weiUsing.mul(rate);
}
// @dev Ends the presale
function endPresale()
private
{
stage = Stages.PresaleEnded;
PresaleEnd(now);
}
// @dev Ends the main sale triggering a refund if the minimum sale raise has no been met
// @dev or passes funds raised to the wallet and starts the trading count down
function endMainSale(uint256 buyerRefund)
private
{
if (totalReceived < minimumMainSaleRaise) {
stage = Stages.Refund;
} else {
minTradingStartTime = now + 2 weeks;
maxTradingStartTime = now + 8 weeks;
stage = Stages.MainSaleEnded;
// Transfers all funds raised to the Balehu wallet minus the funds that need to be refunded
wallet.transfer(this.balance.sub(buyerRefund));
// All unsold tokens will remain within the token_sale contract
// and will be treated as burned
}
MainSaleEnd(now);
}
} | buy | function buy(address _receiver)
public
payable
{
require(msg.value > 0);
address receiver = _receiver;
if (receiver == 0x0)
receiver = msg.sender;
if (stage == Stages.PresaleStarted) {
buyPresale(receiver);
} else if (stage == Stages.MainSaleStarted) {
buyMainSale(receiver);
} else {
revert();
}
}
| // @ev Allows buyers to buy tokens, throws if neither the presale or main sale is happening
// @param _receiver The address the will receive the tokens | LineComment | v0.4.18+commit.9cf6e910 | bzzr://0692760ec1db61591d22a91dffec166a0b6a1575b73970edbeb3a305571151bf | {
"func_code_index": [
2952,
3398
]
} | 59,880 |
|||
TokenSale | TokenSale.sol | 0xb8d8496a49fc00c8fc42e1d8822ea15d33b7c2ae | Solidity | TokenSale | contract TokenSale {
using SafeMath for uint256;
/*
* Events
*/
event PresaleStart(uint256 indexed presaleStartTime);
event AllocatePresale(address indexed receiver, uint256 tokenQuantity);
event PresaleEnd(uint256 indexed presaleEndTime);
event MainSaleStart(uint256 indexed startMainSaleTime);
event AllocateMainSale(address indexed receiver, uint256 etherAmount);
event MainSaleEnd(uint256 indexed endMainSaleTime);
event TradingStart(uint256 indexed startTradingTime);
event Refund(address indexed receiver, uint256 etherAmount);
/*
* Constants
*/
// Presale Allocation = 500 * (5000 + 4500 + 4000 + 3500 + 3250 + 3000) * 10**18
uint256 public constant PRESALE_TOKEN_ALLOCATION = 11625000 * 10**18;
uint256 public constant PRESALE_MAX_RAISE = 3000 * 10**18;
/*
* Storage
*/
mapping (address => uint256) public presaleAllocations;
mapping (address => uint256) public mainSaleAllocations;
address public wallet;
Balehubuck public token;
uint256 public presaleEndTime;
uint256 public mainSaleEndTime;
uint256 public minTradingStartTime;
uint256 public maxTradingStartTime;
uint256 public totalReceived;
uint256 public minimumMainSaleRaise;
uint256 public maximumMainSaleRaise;
uint256 public maximumAllocationPerParticipant;
uint256 public mainSaleExchangeRate;
Stages public stage;
enum Stages {
Deployed,
PresaleStarted,
PresaleEnded,
MainSaleStarted,
MainSaleEnded,
Refund,
Trading
}
/*
* Modifiers
*/
modifier onlyWallet() {
require(wallet == msg.sender);
_;
}
modifier atStage(Stages _stage) {
require(stage == _stage);
_;
}
/*
* Fallback function
*/
function ()
external
payable
{
buy(msg.sender);
}
/*
* Constructor function
*/
// @dev Constructor function that create the Balehubuck token and sets the initial variables
// @param _wallet sets the wallet state variable which will be used to start stages throughout the token sale
function TokenSale(address _wallet)
public
{
require(_wallet != 0x0);
wallet = _wallet;
token = new Balehubuck(wallet);
// Sets the default main sale values
minimumMainSaleRaise = 23000 * 10**18;
maximumMainSaleRaise = 78000 * 10**18;
maximumAllocationPerParticipant = 750 * 10**18;
mainSaleExchangeRate = 2500;
stage = Stages.Deployed;
totalReceived = 0;
}
/*
* Public functions
*/
// @ev Allows buyers to buy tokens, throws if neither the presale or main sale is happening
// @param _receiver The address the will receive the tokens
function buy(address _receiver)
public
payable
{
require(msg.value > 0);
address receiver = _receiver;
if (receiver == 0x0)
receiver = msg.sender;
if (stage == Stages.PresaleStarted) {
buyPresale(receiver);
} else if (stage == Stages.MainSaleStarted) {
buyMainSale(receiver);
} else {
revert();
}
}
/*
* External functions
*/
// @dev Starts the presale
function startPresale()
external
onlyWallet
atStage(Stages.Deployed)
{
stage = Stages.PresaleStarted;
presaleEndTime = now + 8 weeks;
PresaleStart(now);
}
// @dev Sets the maximum and minimum raise amounts prior to the main sale
// @dev Use this method with extreme caution!
// @param _minimumMainSaleRaise Sets the minimium main sale raise
// @param _maximumMainSaleRaise Sets the maximum main sale raise
// @param _maximumAllocationPerParticipant sets the maximum main sale allocation per participant
function changeSettings(uint256 _minimumMainSaleRaise,
uint256 _maximumMainSaleRaise,
uint256 _maximumAllocationPerParticipant,
uint256 _mainSaleExchangeRate)
external
onlyWallet
atStage(Stages.PresaleEnded)
{
// Checks the inputs for null values
require(_minimumMainSaleRaise > 0 &&
_maximumMainSaleRaise > 0 &&
_maximumAllocationPerParticipant > 0 &&
_mainSaleExchangeRate > 0);
// Sanity check that requires the min raise to be less then the max
require(_minimumMainSaleRaise < _maximumMainSaleRaise);
// This check verifies that the token_sale contract has enough tokens to match the
// _maximumMainSaleRaiseAmount * _mainSaleExchangeRate (subtracts presale amounts first)
require(_maximumMainSaleRaise.sub(PRESALE_MAX_RAISE).mul(_mainSaleExchangeRate) <= token.balanceOf(this).sub(PRESALE_TOKEN_ALLOCATION));
minimumMainSaleRaise = _minimumMainSaleRaise;
maximumMainSaleRaise = _maximumMainSaleRaise;
mainSaleExchangeRate = _mainSaleExchangeRate;
maximumAllocationPerParticipant = _maximumAllocationPerParticipant;
}
// @dev Starts the main sale
// @dev Make sure the main sale variables are correct before calling
function startMainSale()
external
onlyWallet
atStage(Stages.PresaleEnded)
{
stage = Stages.MainSaleStarted;
mainSaleEndTime = now + 8 weeks;
MainSaleStart(now);
}
// @dev Starts the trading stage, allowing buyer to claim their tokens
function startTrading()
external
atStage(Stages.MainSaleEnded)
{
// Trading starts between two weeks (if called by the wallet) and two months (callable by anyone)
// after the main sale has ended
require((msg.sender == wallet && now >= minTradingStartTime) || now >= maxTradingStartTime);
stage = Stages.Trading;
TradingStart(now);
}
// @dev Allows buyer to be refunded their ETH if the minimum presale raise amount hasn't been met
function refund()
external
atStage(Stages.Refund)
{
uint256 amount = mainSaleAllocations[msg.sender];
mainSaleAllocations[msg.sender] = 0;
msg.sender.transfer(amount);
Refund(msg.sender, amount);
}
// @dev Allows buyers to claim the tokens they've purchased
function claimTokens()
external
atStage(Stages.Trading)
{
uint256 tokenAllocation = presaleAllocations[msg.sender].add(mainSaleAllocations[msg.sender].mul(mainSaleExchangeRate));
presaleAllocations[msg.sender] = 0;
mainSaleAllocations[msg.sender] = 0;
token.transfer(msg.sender, tokenAllocation);
}
/*
* Private functions
*/
// @dev Allocated tokens to the presale buyer at a rate based on the total received
// @param receiver The address presale balehubucks will be allocated to
function buyPresale(address receiver)
private
{
if (now >= presaleEndTime) {
endPresale();
return;
}
uint256 totalTokenAllocation = 0;
uint256 oldTotalReceived = totalReceived;
uint256 tokenAllocation = 0;
uint256 weiUsing = 0;
uint256 weiAmount = msg.value;
uint256 maxWeiForPresaleStage = 0;
uint256 buyerRefund = 0;
// Cycles through the presale phases conditional giving a different exchange rate for
// each phase of the presale until tokens have been allocated for all Ether sent or
// until the presale cap of 3,000 Ether has been reached
while (true) {
// The EVM deals with division by rounding down, causing the below statement to
// round down to the correct stage
// stageAmount = totalReceived.add(500 * 10**18).div(500 * 10**18).mul(500 * 10**18);
// maxWeiForPresaleStage = stageAmount - totalReceived
maxWeiForPresaleStage = (totalReceived.add(500 * 10**18).div(500 * 10**18).mul(500 * 10**18)).sub(totalReceived);
if (weiAmount > maxWeiForPresaleStage) {
weiUsing = maxWeiForPresaleStage;
} else {
weiUsing = weiAmount;
}
weiAmount = weiAmount.sub(weiUsing);
if (totalReceived < 500 * 10**18) {
// Stage 1: up to 500 Ether, exchange rate of 1 ETH for 5000 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 5000);
} else if (totalReceived < 1000 * 10**18) {
// Stage 2: up to 1000 Ether, exchange rate of 1 ETH for 4500 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 4500);
} else if (totalReceived < 1500 * 10**18) {
// Stage 3: up to 1500 Ether, exchange rate of 1 ETH for 4000 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 4000);
} else if (totalReceived < 2000 * 10**18) {
// Stage 4: up to 2000 Ether, exchange rate of 1 ETH for 3500 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 3500);
} else if (totalReceived < 2500 * 10**18) {
// Stage 5: up to 2500 Ether, exchange rate of 1 ETH for 3250 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 3250);
} else if (totalReceived < 3000 * 10**18) {
// Stage 6: up to 3000 Ether, exchange rate of 1 ETH for 3000 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 3000);
}
totalTokenAllocation = totalTokenAllocation.add(tokenAllocation);
totalReceived = totalReceived.add(weiUsing);
if (totalReceived >= PRESALE_MAX_RAISE) {
buyerRefund = weiAmount;
endPresale();
}
// Exits the for loops if the presale cap has been reached (changing the stage)
// or all of the wei send to the presale has been allocated
if (weiAmount == 0 || stage != Stages.PresaleStarted)
break;
}
presaleAllocations[receiver] = presaleAllocations[receiver].add(totalTokenAllocation);
wallet.transfer(totalReceived.sub(oldTotalReceived));
msg.sender.transfer(buyerRefund);
AllocatePresale(receiver, totalTokenAllocation);
}
// @dev Allocated tokens to the presale buyer at a rate based on the total received
// @param receiver The address main sale balehubucks will be allocated to
function buyMainSale(address receiver)
private
{
if (now >= mainSaleEndTime) {
endMainSale(msg.value);
msg.sender.transfer(msg.value);
return;
}
uint256 buyerRefund = 0;
uint256 weiAllocation = mainSaleAllocations[receiver].add(msg.value);
if (weiAllocation >= maximumAllocationPerParticipant) {
weiAllocation = maximumAllocationPerParticipant.sub(mainSaleAllocations[receiver]);
buyerRefund = msg.value.sub(weiAllocation);
}
uint256 potentialReceived = totalReceived.add(weiAllocation);
if (potentialReceived > maximumMainSaleRaise) {
weiAllocation = maximumMainSaleRaise.sub(totalReceived);
buyerRefund = buyerRefund.add(potentialReceived.sub(maximumMainSaleRaise));
endMainSale(buyerRefund);
}
totalReceived = totalReceived.add(weiAllocation);
mainSaleAllocations[receiver] = mainSaleAllocations[receiver].add(weiAllocation);
msg.sender.transfer(buyerRefund);
AllocateMainSale(receiver, weiAllocation);
}
// @dev Calculates the amount of presale tokens to allocate
// @param weiUsing The amount of wei being used to for the given token allocation
// @param rate The eth/token exchange rate, this changes based on how much the presale has received so far
function calcpresaleAllocations(uint256 weiUsing, uint256 rate)
private
pure
returns (uint256)
{
return weiUsing.mul(rate);
}
// @dev Ends the presale
function endPresale()
private
{
stage = Stages.PresaleEnded;
PresaleEnd(now);
}
// @dev Ends the main sale triggering a refund if the minimum sale raise has no been met
// @dev or passes funds raised to the wallet and starts the trading count down
function endMainSale(uint256 buyerRefund)
private
{
if (totalReceived < minimumMainSaleRaise) {
stage = Stages.Refund;
} else {
minTradingStartTime = now + 2 weeks;
maxTradingStartTime = now + 8 weeks;
stage = Stages.MainSaleEnded;
// Transfers all funds raised to the Balehu wallet minus the funds that need to be refunded
wallet.transfer(this.balance.sub(buyerRefund));
// All unsold tokens will remain within the token_sale contract
// and will be treated as burned
}
MainSaleEnd(now);
}
} | startPresale | function startPresale()
external
onlyWallet
atStage(Stages.Deployed)
{
stage = Stages.PresaleStarted;
presaleEndTime = now + 8 weeks;
PresaleStart(now);
}
| // @dev Starts the presale | LineComment | v0.4.18+commit.9cf6e910 | bzzr://0692760ec1db61591d22a91dffec166a0b6a1575b73970edbeb3a305571151bf | {
"func_code_index": [
3478,
3701
]
} | 59,881 |
|||
TokenSale | TokenSale.sol | 0xb8d8496a49fc00c8fc42e1d8822ea15d33b7c2ae | Solidity | TokenSale | contract TokenSale {
using SafeMath for uint256;
/*
* Events
*/
event PresaleStart(uint256 indexed presaleStartTime);
event AllocatePresale(address indexed receiver, uint256 tokenQuantity);
event PresaleEnd(uint256 indexed presaleEndTime);
event MainSaleStart(uint256 indexed startMainSaleTime);
event AllocateMainSale(address indexed receiver, uint256 etherAmount);
event MainSaleEnd(uint256 indexed endMainSaleTime);
event TradingStart(uint256 indexed startTradingTime);
event Refund(address indexed receiver, uint256 etherAmount);
/*
* Constants
*/
// Presale Allocation = 500 * (5000 + 4500 + 4000 + 3500 + 3250 + 3000) * 10**18
uint256 public constant PRESALE_TOKEN_ALLOCATION = 11625000 * 10**18;
uint256 public constant PRESALE_MAX_RAISE = 3000 * 10**18;
/*
* Storage
*/
mapping (address => uint256) public presaleAllocations;
mapping (address => uint256) public mainSaleAllocations;
address public wallet;
Balehubuck public token;
uint256 public presaleEndTime;
uint256 public mainSaleEndTime;
uint256 public minTradingStartTime;
uint256 public maxTradingStartTime;
uint256 public totalReceived;
uint256 public minimumMainSaleRaise;
uint256 public maximumMainSaleRaise;
uint256 public maximumAllocationPerParticipant;
uint256 public mainSaleExchangeRate;
Stages public stage;
enum Stages {
Deployed,
PresaleStarted,
PresaleEnded,
MainSaleStarted,
MainSaleEnded,
Refund,
Trading
}
/*
* Modifiers
*/
modifier onlyWallet() {
require(wallet == msg.sender);
_;
}
modifier atStage(Stages _stage) {
require(stage == _stage);
_;
}
/*
* Fallback function
*/
function ()
external
payable
{
buy(msg.sender);
}
/*
* Constructor function
*/
// @dev Constructor function that create the Balehubuck token and sets the initial variables
// @param _wallet sets the wallet state variable which will be used to start stages throughout the token sale
function TokenSale(address _wallet)
public
{
require(_wallet != 0x0);
wallet = _wallet;
token = new Balehubuck(wallet);
// Sets the default main sale values
minimumMainSaleRaise = 23000 * 10**18;
maximumMainSaleRaise = 78000 * 10**18;
maximumAllocationPerParticipant = 750 * 10**18;
mainSaleExchangeRate = 2500;
stage = Stages.Deployed;
totalReceived = 0;
}
/*
* Public functions
*/
// @ev Allows buyers to buy tokens, throws if neither the presale or main sale is happening
// @param _receiver The address the will receive the tokens
function buy(address _receiver)
public
payable
{
require(msg.value > 0);
address receiver = _receiver;
if (receiver == 0x0)
receiver = msg.sender;
if (stage == Stages.PresaleStarted) {
buyPresale(receiver);
} else if (stage == Stages.MainSaleStarted) {
buyMainSale(receiver);
} else {
revert();
}
}
/*
* External functions
*/
// @dev Starts the presale
function startPresale()
external
onlyWallet
atStage(Stages.Deployed)
{
stage = Stages.PresaleStarted;
presaleEndTime = now + 8 weeks;
PresaleStart(now);
}
// @dev Sets the maximum and minimum raise amounts prior to the main sale
// @dev Use this method with extreme caution!
// @param _minimumMainSaleRaise Sets the minimium main sale raise
// @param _maximumMainSaleRaise Sets the maximum main sale raise
// @param _maximumAllocationPerParticipant sets the maximum main sale allocation per participant
function changeSettings(uint256 _minimumMainSaleRaise,
uint256 _maximumMainSaleRaise,
uint256 _maximumAllocationPerParticipant,
uint256 _mainSaleExchangeRate)
external
onlyWallet
atStage(Stages.PresaleEnded)
{
// Checks the inputs for null values
require(_minimumMainSaleRaise > 0 &&
_maximumMainSaleRaise > 0 &&
_maximumAllocationPerParticipant > 0 &&
_mainSaleExchangeRate > 0);
// Sanity check that requires the min raise to be less then the max
require(_minimumMainSaleRaise < _maximumMainSaleRaise);
// This check verifies that the token_sale contract has enough tokens to match the
// _maximumMainSaleRaiseAmount * _mainSaleExchangeRate (subtracts presale amounts first)
require(_maximumMainSaleRaise.sub(PRESALE_MAX_RAISE).mul(_mainSaleExchangeRate) <= token.balanceOf(this).sub(PRESALE_TOKEN_ALLOCATION));
minimumMainSaleRaise = _minimumMainSaleRaise;
maximumMainSaleRaise = _maximumMainSaleRaise;
mainSaleExchangeRate = _mainSaleExchangeRate;
maximumAllocationPerParticipant = _maximumAllocationPerParticipant;
}
// @dev Starts the main sale
// @dev Make sure the main sale variables are correct before calling
function startMainSale()
external
onlyWallet
atStage(Stages.PresaleEnded)
{
stage = Stages.MainSaleStarted;
mainSaleEndTime = now + 8 weeks;
MainSaleStart(now);
}
// @dev Starts the trading stage, allowing buyer to claim their tokens
function startTrading()
external
atStage(Stages.MainSaleEnded)
{
// Trading starts between two weeks (if called by the wallet) and two months (callable by anyone)
// after the main sale has ended
require((msg.sender == wallet && now >= minTradingStartTime) || now >= maxTradingStartTime);
stage = Stages.Trading;
TradingStart(now);
}
// @dev Allows buyer to be refunded their ETH if the minimum presale raise amount hasn't been met
function refund()
external
atStage(Stages.Refund)
{
uint256 amount = mainSaleAllocations[msg.sender];
mainSaleAllocations[msg.sender] = 0;
msg.sender.transfer(amount);
Refund(msg.sender, amount);
}
// @dev Allows buyers to claim the tokens they've purchased
function claimTokens()
external
atStage(Stages.Trading)
{
uint256 tokenAllocation = presaleAllocations[msg.sender].add(mainSaleAllocations[msg.sender].mul(mainSaleExchangeRate));
presaleAllocations[msg.sender] = 0;
mainSaleAllocations[msg.sender] = 0;
token.transfer(msg.sender, tokenAllocation);
}
/*
* Private functions
*/
// @dev Allocated tokens to the presale buyer at a rate based on the total received
// @param receiver The address presale balehubucks will be allocated to
function buyPresale(address receiver)
private
{
if (now >= presaleEndTime) {
endPresale();
return;
}
uint256 totalTokenAllocation = 0;
uint256 oldTotalReceived = totalReceived;
uint256 tokenAllocation = 0;
uint256 weiUsing = 0;
uint256 weiAmount = msg.value;
uint256 maxWeiForPresaleStage = 0;
uint256 buyerRefund = 0;
// Cycles through the presale phases conditional giving a different exchange rate for
// each phase of the presale until tokens have been allocated for all Ether sent or
// until the presale cap of 3,000 Ether has been reached
while (true) {
// The EVM deals with division by rounding down, causing the below statement to
// round down to the correct stage
// stageAmount = totalReceived.add(500 * 10**18).div(500 * 10**18).mul(500 * 10**18);
// maxWeiForPresaleStage = stageAmount - totalReceived
maxWeiForPresaleStage = (totalReceived.add(500 * 10**18).div(500 * 10**18).mul(500 * 10**18)).sub(totalReceived);
if (weiAmount > maxWeiForPresaleStage) {
weiUsing = maxWeiForPresaleStage;
} else {
weiUsing = weiAmount;
}
weiAmount = weiAmount.sub(weiUsing);
if (totalReceived < 500 * 10**18) {
// Stage 1: up to 500 Ether, exchange rate of 1 ETH for 5000 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 5000);
} else if (totalReceived < 1000 * 10**18) {
// Stage 2: up to 1000 Ether, exchange rate of 1 ETH for 4500 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 4500);
} else if (totalReceived < 1500 * 10**18) {
// Stage 3: up to 1500 Ether, exchange rate of 1 ETH for 4000 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 4000);
} else if (totalReceived < 2000 * 10**18) {
// Stage 4: up to 2000 Ether, exchange rate of 1 ETH for 3500 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 3500);
} else if (totalReceived < 2500 * 10**18) {
// Stage 5: up to 2500 Ether, exchange rate of 1 ETH for 3250 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 3250);
} else if (totalReceived < 3000 * 10**18) {
// Stage 6: up to 3000 Ether, exchange rate of 1 ETH for 3000 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 3000);
}
totalTokenAllocation = totalTokenAllocation.add(tokenAllocation);
totalReceived = totalReceived.add(weiUsing);
if (totalReceived >= PRESALE_MAX_RAISE) {
buyerRefund = weiAmount;
endPresale();
}
// Exits the for loops if the presale cap has been reached (changing the stage)
// or all of the wei send to the presale has been allocated
if (weiAmount == 0 || stage != Stages.PresaleStarted)
break;
}
presaleAllocations[receiver] = presaleAllocations[receiver].add(totalTokenAllocation);
wallet.transfer(totalReceived.sub(oldTotalReceived));
msg.sender.transfer(buyerRefund);
AllocatePresale(receiver, totalTokenAllocation);
}
// @dev Allocated tokens to the presale buyer at a rate based on the total received
// @param receiver The address main sale balehubucks will be allocated to
function buyMainSale(address receiver)
private
{
if (now >= mainSaleEndTime) {
endMainSale(msg.value);
msg.sender.transfer(msg.value);
return;
}
uint256 buyerRefund = 0;
uint256 weiAllocation = mainSaleAllocations[receiver].add(msg.value);
if (weiAllocation >= maximumAllocationPerParticipant) {
weiAllocation = maximumAllocationPerParticipant.sub(mainSaleAllocations[receiver]);
buyerRefund = msg.value.sub(weiAllocation);
}
uint256 potentialReceived = totalReceived.add(weiAllocation);
if (potentialReceived > maximumMainSaleRaise) {
weiAllocation = maximumMainSaleRaise.sub(totalReceived);
buyerRefund = buyerRefund.add(potentialReceived.sub(maximumMainSaleRaise));
endMainSale(buyerRefund);
}
totalReceived = totalReceived.add(weiAllocation);
mainSaleAllocations[receiver] = mainSaleAllocations[receiver].add(weiAllocation);
msg.sender.transfer(buyerRefund);
AllocateMainSale(receiver, weiAllocation);
}
// @dev Calculates the amount of presale tokens to allocate
// @param weiUsing The amount of wei being used to for the given token allocation
// @param rate The eth/token exchange rate, this changes based on how much the presale has received so far
function calcpresaleAllocations(uint256 weiUsing, uint256 rate)
private
pure
returns (uint256)
{
return weiUsing.mul(rate);
}
// @dev Ends the presale
function endPresale()
private
{
stage = Stages.PresaleEnded;
PresaleEnd(now);
}
// @dev Ends the main sale triggering a refund if the minimum sale raise has no been met
// @dev or passes funds raised to the wallet and starts the trading count down
function endMainSale(uint256 buyerRefund)
private
{
if (totalReceived < minimumMainSaleRaise) {
stage = Stages.Refund;
} else {
minTradingStartTime = now + 2 weeks;
maxTradingStartTime = now + 8 weeks;
stage = Stages.MainSaleEnded;
// Transfers all funds raised to the Balehu wallet minus the funds that need to be refunded
wallet.transfer(this.balance.sub(buyerRefund));
// All unsold tokens will remain within the token_sale contract
// and will be treated as burned
}
MainSaleEnd(now);
}
} | changeSettings | function changeSettings(uint256 _minimumMainSaleRaise,
uint256 _maximumMainSaleRaise,
uint256 _maximumAllocationPerParticipant,
uint256 _mainSaleExchangeRate)
external
onlyWallet
atStage(Stages.PresaleEnded)
{
// Checks the inputs for null values
require(_minimumMainSaleRaise > 0 &&
_maximumMainSaleRaise > 0 &&
_maximumAllocationPerParticipant > 0 &&
_mainSaleExchangeRate > 0);
// Sanity check that requires the min raise to be less then the max
require(_minimumMainSaleRaise < _maximumMainSaleRaise);
// This check verifies that the token_sale contract has enough tokens to match the
// _maximumMainSaleRaiseAmount * _mainSaleExchangeRate (subtracts presale amounts first)
require(_maximumMainSaleRaise.sub(PRESALE_MAX_RAISE).mul(_mainSaleExchangeRate) <= token.balanceOf(this).sub(PRESALE_TOKEN_ALLOCATION));
minimumMainSaleRaise = _minimumMainSaleRaise;
maximumMainSaleRaise = _maximumMainSaleRaise;
mainSaleExchangeRate = _mainSaleExchangeRate;
maximumAllocationPerParticipant = _maximumAllocationPerParticipant;
}
| // @dev Sets the maximum and minimum raise amounts prior to the main sale
// @dev Use this method with extreme caution!
// @param _minimumMainSaleRaise Sets the minimium main sale raise
// @param _maximumMainSaleRaise Sets the maximum main sale raise
// @param _maximumAllocationPerParticipant sets the maximum main sale allocation per participant | LineComment | v0.4.18+commit.9cf6e910 | bzzr://0692760ec1db61591d22a91dffec166a0b6a1575b73970edbeb3a305571151bf | {
"func_code_index": [
4077,
5377
]
} | 59,882 |
|||
TokenSale | TokenSale.sol | 0xb8d8496a49fc00c8fc42e1d8822ea15d33b7c2ae | Solidity | TokenSale | contract TokenSale {
using SafeMath for uint256;
/*
* Events
*/
event PresaleStart(uint256 indexed presaleStartTime);
event AllocatePresale(address indexed receiver, uint256 tokenQuantity);
event PresaleEnd(uint256 indexed presaleEndTime);
event MainSaleStart(uint256 indexed startMainSaleTime);
event AllocateMainSale(address indexed receiver, uint256 etherAmount);
event MainSaleEnd(uint256 indexed endMainSaleTime);
event TradingStart(uint256 indexed startTradingTime);
event Refund(address indexed receiver, uint256 etherAmount);
/*
* Constants
*/
// Presale Allocation = 500 * (5000 + 4500 + 4000 + 3500 + 3250 + 3000) * 10**18
uint256 public constant PRESALE_TOKEN_ALLOCATION = 11625000 * 10**18;
uint256 public constant PRESALE_MAX_RAISE = 3000 * 10**18;
/*
* Storage
*/
mapping (address => uint256) public presaleAllocations;
mapping (address => uint256) public mainSaleAllocations;
address public wallet;
Balehubuck public token;
uint256 public presaleEndTime;
uint256 public mainSaleEndTime;
uint256 public minTradingStartTime;
uint256 public maxTradingStartTime;
uint256 public totalReceived;
uint256 public minimumMainSaleRaise;
uint256 public maximumMainSaleRaise;
uint256 public maximumAllocationPerParticipant;
uint256 public mainSaleExchangeRate;
Stages public stage;
enum Stages {
Deployed,
PresaleStarted,
PresaleEnded,
MainSaleStarted,
MainSaleEnded,
Refund,
Trading
}
/*
* Modifiers
*/
modifier onlyWallet() {
require(wallet == msg.sender);
_;
}
modifier atStage(Stages _stage) {
require(stage == _stage);
_;
}
/*
* Fallback function
*/
function ()
external
payable
{
buy(msg.sender);
}
/*
* Constructor function
*/
// @dev Constructor function that create the Balehubuck token and sets the initial variables
// @param _wallet sets the wallet state variable which will be used to start stages throughout the token sale
function TokenSale(address _wallet)
public
{
require(_wallet != 0x0);
wallet = _wallet;
token = new Balehubuck(wallet);
// Sets the default main sale values
minimumMainSaleRaise = 23000 * 10**18;
maximumMainSaleRaise = 78000 * 10**18;
maximumAllocationPerParticipant = 750 * 10**18;
mainSaleExchangeRate = 2500;
stage = Stages.Deployed;
totalReceived = 0;
}
/*
* Public functions
*/
// @ev Allows buyers to buy tokens, throws if neither the presale or main sale is happening
// @param _receiver The address the will receive the tokens
function buy(address _receiver)
public
payable
{
require(msg.value > 0);
address receiver = _receiver;
if (receiver == 0x0)
receiver = msg.sender;
if (stage == Stages.PresaleStarted) {
buyPresale(receiver);
} else if (stage == Stages.MainSaleStarted) {
buyMainSale(receiver);
} else {
revert();
}
}
/*
* External functions
*/
// @dev Starts the presale
function startPresale()
external
onlyWallet
atStage(Stages.Deployed)
{
stage = Stages.PresaleStarted;
presaleEndTime = now + 8 weeks;
PresaleStart(now);
}
// @dev Sets the maximum and minimum raise amounts prior to the main sale
// @dev Use this method with extreme caution!
// @param _minimumMainSaleRaise Sets the minimium main sale raise
// @param _maximumMainSaleRaise Sets the maximum main sale raise
// @param _maximumAllocationPerParticipant sets the maximum main sale allocation per participant
function changeSettings(uint256 _minimumMainSaleRaise,
uint256 _maximumMainSaleRaise,
uint256 _maximumAllocationPerParticipant,
uint256 _mainSaleExchangeRate)
external
onlyWallet
atStage(Stages.PresaleEnded)
{
// Checks the inputs for null values
require(_minimumMainSaleRaise > 0 &&
_maximumMainSaleRaise > 0 &&
_maximumAllocationPerParticipant > 0 &&
_mainSaleExchangeRate > 0);
// Sanity check that requires the min raise to be less then the max
require(_minimumMainSaleRaise < _maximumMainSaleRaise);
// This check verifies that the token_sale contract has enough tokens to match the
// _maximumMainSaleRaiseAmount * _mainSaleExchangeRate (subtracts presale amounts first)
require(_maximumMainSaleRaise.sub(PRESALE_MAX_RAISE).mul(_mainSaleExchangeRate) <= token.balanceOf(this).sub(PRESALE_TOKEN_ALLOCATION));
minimumMainSaleRaise = _minimumMainSaleRaise;
maximumMainSaleRaise = _maximumMainSaleRaise;
mainSaleExchangeRate = _mainSaleExchangeRate;
maximumAllocationPerParticipant = _maximumAllocationPerParticipant;
}
// @dev Starts the main sale
// @dev Make sure the main sale variables are correct before calling
function startMainSale()
external
onlyWallet
atStage(Stages.PresaleEnded)
{
stage = Stages.MainSaleStarted;
mainSaleEndTime = now + 8 weeks;
MainSaleStart(now);
}
// @dev Starts the trading stage, allowing buyer to claim their tokens
function startTrading()
external
atStage(Stages.MainSaleEnded)
{
// Trading starts between two weeks (if called by the wallet) and two months (callable by anyone)
// after the main sale has ended
require((msg.sender == wallet && now >= minTradingStartTime) || now >= maxTradingStartTime);
stage = Stages.Trading;
TradingStart(now);
}
// @dev Allows buyer to be refunded their ETH if the minimum presale raise amount hasn't been met
function refund()
external
atStage(Stages.Refund)
{
uint256 amount = mainSaleAllocations[msg.sender];
mainSaleAllocations[msg.sender] = 0;
msg.sender.transfer(amount);
Refund(msg.sender, amount);
}
// @dev Allows buyers to claim the tokens they've purchased
function claimTokens()
external
atStage(Stages.Trading)
{
uint256 tokenAllocation = presaleAllocations[msg.sender].add(mainSaleAllocations[msg.sender].mul(mainSaleExchangeRate));
presaleAllocations[msg.sender] = 0;
mainSaleAllocations[msg.sender] = 0;
token.transfer(msg.sender, tokenAllocation);
}
/*
* Private functions
*/
// @dev Allocated tokens to the presale buyer at a rate based on the total received
// @param receiver The address presale balehubucks will be allocated to
function buyPresale(address receiver)
private
{
if (now >= presaleEndTime) {
endPresale();
return;
}
uint256 totalTokenAllocation = 0;
uint256 oldTotalReceived = totalReceived;
uint256 tokenAllocation = 0;
uint256 weiUsing = 0;
uint256 weiAmount = msg.value;
uint256 maxWeiForPresaleStage = 0;
uint256 buyerRefund = 0;
// Cycles through the presale phases conditional giving a different exchange rate for
// each phase of the presale until tokens have been allocated for all Ether sent or
// until the presale cap of 3,000 Ether has been reached
while (true) {
// The EVM deals with division by rounding down, causing the below statement to
// round down to the correct stage
// stageAmount = totalReceived.add(500 * 10**18).div(500 * 10**18).mul(500 * 10**18);
// maxWeiForPresaleStage = stageAmount - totalReceived
maxWeiForPresaleStage = (totalReceived.add(500 * 10**18).div(500 * 10**18).mul(500 * 10**18)).sub(totalReceived);
if (weiAmount > maxWeiForPresaleStage) {
weiUsing = maxWeiForPresaleStage;
} else {
weiUsing = weiAmount;
}
weiAmount = weiAmount.sub(weiUsing);
if (totalReceived < 500 * 10**18) {
// Stage 1: up to 500 Ether, exchange rate of 1 ETH for 5000 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 5000);
} else if (totalReceived < 1000 * 10**18) {
// Stage 2: up to 1000 Ether, exchange rate of 1 ETH for 4500 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 4500);
} else if (totalReceived < 1500 * 10**18) {
// Stage 3: up to 1500 Ether, exchange rate of 1 ETH for 4000 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 4000);
} else if (totalReceived < 2000 * 10**18) {
// Stage 4: up to 2000 Ether, exchange rate of 1 ETH for 3500 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 3500);
} else if (totalReceived < 2500 * 10**18) {
// Stage 5: up to 2500 Ether, exchange rate of 1 ETH for 3250 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 3250);
} else if (totalReceived < 3000 * 10**18) {
// Stage 6: up to 3000 Ether, exchange rate of 1 ETH for 3000 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 3000);
}
totalTokenAllocation = totalTokenAllocation.add(tokenAllocation);
totalReceived = totalReceived.add(weiUsing);
if (totalReceived >= PRESALE_MAX_RAISE) {
buyerRefund = weiAmount;
endPresale();
}
// Exits the for loops if the presale cap has been reached (changing the stage)
// or all of the wei send to the presale has been allocated
if (weiAmount == 0 || stage != Stages.PresaleStarted)
break;
}
presaleAllocations[receiver] = presaleAllocations[receiver].add(totalTokenAllocation);
wallet.transfer(totalReceived.sub(oldTotalReceived));
msg.sender.transfer(buyerRefund);
AllocatePresale(receiver, totalTokenAllocation);
}
// @dev Allocated tokens to the presale buyer at a rate based on the total received
// @param receiver The address main sale balehubucks will be allocated to
function buyMainSale(address receiver)
private
{
if (now >= mainSaleEndTime) {
endMainSale(msg.value);
msg.sender.transfer(msg.value);
return;
}
uint256 buyerRefund = 0;
uint256 weiAllocation = mainSaleAllocations[receiver].add(msg.value);
if (weiAllocation >= maximumAllocationPerParticipant) {
weiAllocation = maximumAllocationPerParticipant.sub(mainSaleAllocations[receiver]);
buyerRefund = msg.value.sub(weiAllocation);
}
uint256 potentialReceived = totalReceived.add(weiAllocation);
if (potentialReceived > maximumMainSaleRaise) {
weiAllocation = maximumMainSaleRaise.sub(totalReceived);
buyerRefund = buyerRefund.add(potentialReceived.sub(maximumMainSaleRaise));
endMainSale(buyerRefund);
}
totalReceived = totalReceived.add(weiAllocation);
mainSaleAllocations[receiver] = mainSaleAllocations[receiver].add(weiAllocation);
msg.sender.transfer(buyerRefund);
AllocateMainSale(receiver, weiAllocation);
}
// @dev Calculates the amount of presale tokens to allocate
// @param weiUsing The amount of wei being used to for the given token allocation
// @param rate The eth/token exchange rate, this changes based on how much the presale has received so far
function calcpresaleAllocations(uint256 weiUsing, uint256 rate)
private
pure
returns (uint256)
{
return weiUsing.mul(rate);
}
// @dev Ends the presale
function endPresale()
private
{
stage = Stages.PresaleEnded;
PresaleEnd(now);
}
// @dev Ends the main sale triggering a refund if the minimum sale raise has no been met
// @dev or passes funds raised to the wallet and starts the trading count down
function endMainSale(uint256 buyerRefund)
private
{
if (totalReceived < minimumMainSaleRaise) {
stage = Stages.Refund;
} else {
minTradingStartTime = now + 2 weeks;
maxTradingStartTime = now + 8 weeks;
stage = Stages.MainSaleEnded;
// Transfers all funds raised to the Balehu wallet minus the funds that need to be refunded
wallet.transfer(this.balance.sub(buyerRefund));
// All unsold tokens will remain within the token_sale contract
// and will be treated as burned
}
MainSaleEnd(now);
}
} | startMainSale | function startMainSale()
external
onlyWallet
atStage(Stages.PresaleEnded)
{
stage = Stages.MainSaleStarted;
mainSaleEndTime = now + 8 weeks;
MainSaleStart(now);
}
| // @dev Starts the main sale
// @dev Make sure the main sale variables are correct before calling | LineComment | v0.4.18+commit.9cf6e910 | bzzr://0692760ec1db61591d22a91dffec166a0b6a1575b73970edbeb3a305571151bf | {
"func_code_index": [
5488,
5719
]
} | 59,883 |
|||
TokenSale | TokenSale.sol | 0xb8d8496a49fc00c8fc42e1d8822ea15d33b7c2ae | Solidity | TokenSale | contract TokenSale {
using SafeMath for uint256;
/*
* Events
*/
event PresaleStart(uint256 indexed presaleStartTime);
event AllocatePresale(address indexed receiver, uint256 tokenQuantity);
event PresaleEnd(uint256 indexed presaleEndTime);
event MainSaleStart(uint256 indexed startMainSaleTime);
event AllocateMainSale(address indexed receiver, uint256 etherAmount);
event MainSaleEnd(uint256 indexed endMainSaleTime);
event TradingStart(uint256 indexed startTradingTime);
event Refund(address indexed receiver, uint256 etherAmount);
/*
* Constants
*/
// Presale Allocation = 500 * (5000 + 4500 + 4000 + 3500 + 3250 + 3000) * 10**18
uint256 public constant PRESALE_TOKEN_ALLOCATION = 11625000 * 10**18;
uint256 public constant PRESALE_MAX_RAISE = 3000 * 10**18;
/*
* Storage
*/
mapping (address => uint256) public presaleAllocations;
mapping (address => uint256) public mainSaleAllocations;
address public wallet;
Balehubuck public token;
uint256 public presaleEndTime;
uint256 public mainSaleEndTime;
uint256 public minTradingStartTime;
uint256 public maxTradingStartTime;
uint256 public totalReceived;
uint256 public minimumMainSaleRaise;
uint256 public maximumMainSaleRaise;
uint256 public maximumAllocationPerParticipant;
uint256 public mainSaleExchangeRate;
Stages public stage;
enum Stages {
Deployed,
PresaleStarted,
PresaleEnded,
MainSaleStarted,
MainSaleEnded,
Refund,
Trading
}
/*
* Modifiers
*/
modifier onlyWallet() {
require(wallet == msg.sender);
_;
}
modifier atStage(Stages _stage) {
require(stage == _stage);
_;
}
/*
* Fallback function
*/
function ()
external
payable
{
buy(msg.sender);
}
/*
* Constructor function
*/
// @dev Constructor function that create the Balehubuck token and sets the initial variables
// @param _wallet sets the wallet state variable which will be used to start stages throughout the token sale
function TokenSale(address _wallet)
public
{
require(_wallet != 0x0);
wallet = _wallet;
token = new Balehubuck(wallet);
// Sets the default main sale values
minimumMainSaleRaise = 23000 * 10**18;
maximumMainSaleRaise = 78000 * 10**18;
maximumAllocationPerParticipant = 750 * 10**18;
mainSaleExchangeRate = 2500;
stage = Stages.Deployed;
totalReceived = 0;
}
/*
* Public functions
*/
// @ev Allows buyers to buy tokens, throws if neither the presale or main sale is happening
// @param _receiver The address the will receive the tokens
function buy(address _receiver)
public
payable
{
require(msg.value > 0);
address receiver = _receiver;
if (receiver == 0x0)
receiver = msg.sender;
if (stage == Stages.PresaleStarted) {
buyPresale(receiver);
} else if (stage == Stages.MainSaleStarted) {
buyMainSale(receiver);
} else {
revert();
}
}
/*
* External functions
*/
// @dev Starts the presale
function startPresale()
external
onlyWallet
atStage(Stages.Deployed)
{
stage = Stages.PresaleStarted;
presaleEndTime = now + 8 weeks;
PresaleStart(now);
}
// @dev Sets the maximum and minimum raise amounts prior to the main sale
// @dev Use this method with extreme caution!
// @param _minimumMainSaleRaise Sets the minimium main sale raise
// @param _maximumMainSaleRaise Sets the maximum main sale raise
// @param _maximumAllocationPerParticipant sets the maximum main sale allocation per participant
function changeSettings(uint256 _minimumMainSaleRaise,
uint256 _maximumMainSaleRaise,
uint256 _maximumAllocationPerParticipant,
uint256 _mainSaleExchangeRate)
external
onlyWallet
atStage(Stages.PresaleEnded)
{
// Checks the inputs for null values
require(_minimumMainSaleRaise > 0 &&
_maximumMainSaleRaise > 0 &&
_maximumAllocationPerParticipant > 0 &&
_mainSaleExchangeRate > 0);
// Sanity check that requires the min raise to be less then the max
require(_minimumMainSaleRaise < _maximumMainSaleRaise);
// This check verifies that the token_sale contract has enough tokens to match the
// _maximumMainSaleRaiseAmount * _mainSaleExchangeRate (subtracts presale amounts first)
require(_maximumMainSaleRaise.sub(PRESALE_MAX_RAISE).mul(_mainSaleExchangeRate) <= token.balanceOf(this).sub(PRESALE_TOKEN_ALLOCATION));
minimumMainSaleRaise = _minimumMainSaleRaise;
maximumMainSaleRaise = _maximumMainSaleRaise;
mainSaleExchangeRate = _mainSaleExchangeRate;
maximumAllocationPerParticipant = _maximumAllocationPerParticipant;
}
// @dev Starts the main sale
// @dev Make sure the main sale variables are correct before calling
function startMainSale()
external
onlyWallet
atStage(Stages.PresaleEnded)
{
stage = Stages.MainSaleStarted;
mainSaleEndTime = now + 8 weeks;
MainSaleStart(now);
}
// @dev Starts the trading stage, allowing buyer to claim their tokens
function startTrading()
external
atStage(Stages.MainSaleEnded)
{
// Trading starts between two weeks (if called by the wallet) and two months (callable by anyone)
// after the main sale has ended
require((msg.sender == wallet && now >= minTradingStartTime) || now >= maxTradingStartTime);
stage = Stages.Trading;
TradingStart(now);
}
// @dev Allows buyer to be refunded their ETH if the minimum presale raise amount hasn't been met
function refund()
external
atStage(Stages.Refund)
{
uint256 amount = mainSaleAllocations[msg.sender];
mainSaleAllocations[msg.sender] = 0;
msg.sender.transfer(amount);
Refund(msg.sender, amount);
}
// @dev Allows buyers to claim the tokens they've purchased
function claimTokens()
external
atStage(Stages.Trading)
{
uint256 tokenAllocation = presaleAllocations[msg.sender].add(mainSaleAllocations[msg.sender].mul(mainSaleExchangeRate));
presaleAllocations[msg.sender] = 0;
mainSaleAllocations[msg.sender] = 0;
token.transfer(msg.sender, tokenAllocation);
}
/*
* Private functions
*/
// @dev Allocated tokens to the presale buyer at a rate based on the total received
// @param receiver The address presale balehubucks will be allocated to
function buyPresale(address receiver)
private
{
if (now >= presaleEndTime) {
endPresale();
return;
}
uint256 totalTokenAllocation = 0;
uint256 oldTotalReceived = totalReceived;
uint256 tokenAllocation = 0;
uint256 weiUsing = 0;
uint256 weiAmount = msg.value;
uint256 maxWeiForPresaleStage = 0;
uint256 buyerRefund = 0;
// Cycles through the presale phases conditional giving a different exchange rate for
// each phase of the presale until tokens have been allocated for all Ether sent or
// until the presale cap of 3,000 Ether has been reached
while (true) {
// The EVM deals with division by rounding down, causing the below statement to
// round down to the correct stage
// stageAmount = totalReceived.add(500 * 10**18).div(500 * 10**18).mul(500 * 10**18);
// maxWeiForPresaleStage = stageAmount - totalReceived
maxWeiForPresaleStage = (totalReceived.add(500 * 10**18).div(500 * 10**18).mul(500 * 10**18)).sub(totalReceived);
if (weiAmount > maxWeiForPresaleStage) {
weiUsing = maxWeiForPresaleStage;
} else {
weiUsing = weiAmount;
}
weiAmount = weiAmount.sub(weiUsing);
if (totalReceived < 500 * 10**18) {
// Stage 1: up to 500 Ether, exchange rate of 1 ETH for 5000 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 5000);
} else if (totalReceived < 1000 * 10**18) {
// Stage 2: up to 1000 Ether, exchange rate of 1 ETH for 4500 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 4500);
} else if (totalReceived < 1500 * 10**18) {
// Stage 3: up to 1500 Ether, exchange rate of 1 ETH for 4000 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 4000);
} else if (totalReceived < 2000 * 10**18) {
// Stage 4: up to 2000 Ether, exchange rate of 1 ETH for 3500 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 3500);
} else if (totalReceived < 2500 * 10**18) {
// Stage 5: up to 2500 Ether, exchange rate of 1 ETH for 3250 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 3250);
} else if (totalReceived < 3000 * 10**18) {
// Stage 6: up to 3000 Ether, exchange rate of 1 ETH for 3000 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 3000);
}
totalTokenAllocation = totalTokenAllocation.add(tokenAllocation);
totalReceived = totalReceived.add(weiUsing);
if (totalReceived >= PRESALE_MAX_RAISE) {
buyerRefund = weiAmount;
endPresale();
}
// Exits the for loops if the presale cap has been reached (changing the stage)
// or all of the wei send to the presale has been allocated
if (weiAmount == 0 || stage != Stages.PresaleStarted)
break;
}
presaleAllocations[receiver] = presaleAllocations[receiver].add(totalTokenAllocation);
wallet.transfer(totalReceived.sub(oldTotalReceived));
msg.sender.transfer(buyerRefund);
AllocatePresale(receiver, totalTokenAllocation);
}
// @dev Allocated tokens to the presale buyer at a rate based on the total received
// @param receiver The address main sale balehubucks will be allocated to
function buyMainSale(address receiver)
private
{
if (now >= mainSaleEndTime) {
endMainSale(msg.value);
msg.sender.transfer(msg.value);
return;
}
uint256 buyerRefund = 0;
uint256 weiAllocation = mainSaleAllocations[receiver].add(msg.value);
if (weiAllocation >= maximumAllocationPerParticipant) {
weiAllocation = maximumAllocationPerParticipant.sub(mainSaleAllocations[receiver]);
buyerRefund = msg.value.sub(weiAllocation);
}
uint256 potentialReceived = totalReceived.add(weiAllocation);
if (potentialReceived > maximumMainSaleRaise) {
weiAllocation = maximumMainSaleRaise.sub(totalReceived);
buyerRefund = buyerRefund.add(potentialReceived.sub(maximumMainSaleRaise));
endMainSale(buyerRefund);
}
totalReceived = totalReceived.add(weiAllocation);
mainSaleAllocations[receiver] = mainSaleAllocations[receiver].add(weiAllocation);
msg.sender.transfer(buyerRefund);
AllocateMainSale(receiver, weiAllocation);
}
// @dev Calculates the amount of presale tokens to allocate
// @param weiUsing The amount of wei being used to for the given token allocation
// @param rate The eth/token exchange rate, this changes based on how much the presale has received so far
function calcpresaleAllocations(uint256 weiUsing, uint256 rate)
private
pure
returns (uint256)
{
return weiUsing.mul(rate);
}
// @dev Ends the presale
function endPresale()
private
{
stage = Stages.PresaleEnded;
PresaleEnd(now);
}
// @dev Ends the main sale triggering a refund if the minimum sale raise has no been met
// @dev or passes funds raised to the wallet and starts the trading count down
function endMainSale(uint256 buyerRefund)
private
{
if (totalReceived < minimumMainSaleRaise) {
stage = Stages.Refund;
} else {
minTradingStartTime = now + 2 weeks;
maxTradingStartTime = now + 8 weeks;
stage = Stages.MainSaleEnded;
// Transfers all funds raised to the Balehu wallet minus the funds that need to be refunded
wallet.transfer(this.balance.sub(buyerRefund));
// All unsold tokens will remain within the token_sale contract
// and will be treated as burned
}
MainSaleEnd(now);
}
} | startTrading | function startTrading()
external
atStage(Stages.MainSaleEnded)
{
// Trading starts between two weeks (if called by the wallet) and two months (callable by anyone)
// after the main sale has ended
require((msg.sender == wallet && now >= minTradingStartTime) || now >= maxTradingStartTime);
stage = Stages.Trading;
TradingStart(now);
}
| // @dev Starts the trading stage, allowing buyer to claim their tokens | LineComment | v0.4.18+commit.9cf6e910 | bzzr://0692760ec1db61591d22a91dffec166a0b6a1575b73970edbeb3a305571151bf | {
"func_code_index": [
5798,
6209
]
} | 59,884 |
|||
TokenSale | TokenSale.sol | 0xb8d8496a49fc00c8fc42e1d8822ea15d33b7c2ae | Solidity | TokenSale | contract TokenSale {
using SafeMath for uint256;
/*
* Events
*/
event PresaleStart(uint256 indexed presaleStartTime);
event AllocatePresale(address indexed receiver, uint256 tokenQuantity);
event PresaleEnd(uint256 indexed presaleEndTime);
event MainSaleStart(uint256 indexed startMainSaleTime);
event AllocateMainSale(address indexed receiver, uint256 etherAmount);
event MainSaleEnd(uint256 indexed endMainSaleTime);
event TradingStart(uint256 indexed startTradingTime);
event Refund(address indexed receiver, uint256 etherAmount);
/*
* Constants
*/
// Presale Allocation = 500 * (5000 + 4500 + 4000 + 3500 + 3250 + 3000) * 10**18
uint256 public constant PRESALE_TOKEN_ALLOCATION = 11625000 * 10**18;
uint256 public constant PRESALE_MAX_RAISE = 3000 * 10**18;
/*
* Storage
*/
mapping (address => uint256) public presaleAllocations;
mapping (address => uint256) public mainSaleAllocations;
address public wallet;
Balehubuck public token;
uint256 public presaleEndTime;
uint256 public mainSaleEndTime;
uint256 public minTradingStartTime;
uint256 public maxTradingStartTime;
uint256 public totalReceived;
uint256 public minimumMainSaleRaise;
uint256 public maximumMainSaleRaise;
uint256 public maximumAllocationPerParticipant;
uint256 public mainSaleExchangeRate;
Stages public stage;
enum Stages {
Deployed,
PresaleStarted,
PresaleEnded,
MainSaleStarted,
MainSaleEnded,
Refund,
Trading
}
/*
* Modifiers
*/
modifier onlyWallet() {
require(wallet == msg.sender);
_;
}
modifier atStage(Stages _stage) {
require(stage == _stage);
_;
}
/*
* Fallback function
*/
function ()
external
payable
{
buy(msg.sender);
}
/*
* Constructor function
*/
// @dev Constructor function that create the Balehubuck token and sets the initial variables
// @param _wallet sets the wallet state variable which will be used to start stages throughout the token sale
function TokenSale(address _wallet)
public
{
require(_wallet != 0x0);
wallet = _wallet;
token = new Balehubuck(wallet);
// Sets the default main sale values
minimumMainSaleRaise = 23000 * 10**18;
maximumMainSaleRaise = 78000 * 10**18;
maximumAllocationPerParticipant = 750 * 10**18;
mainSaleExchangeRate = 2500;
stage = Stages.Deployed;
totalReceived = 0;
}
/*
* Public functions
*/
// @ev Allows buyers to buy tokens, throws if neither the presale or main sale is happening
// @param _receiver The address the will receive the tokens
function buy(address _receiver)
public
payable
{
require(msg.value > 0);
address receiver = _receiver;
if (receiver == 0x0)
receiver = msg.sender;
if (stage == Stages.PresaleStarted) {
buyPresale(receiver);
} else if (stage == Stages.MainSaleStarted) {
buyMainSale(receiver);
} else {
revert();
}
}
/*
* External functions
*/
// @dev Starts the presale
function startPresale()
external
onlyWallet
atStage(Stages.Deployed)
{
stage = Stages.PresaleStarted;
presaleEndTime = now + 8 weeks;
PresaleStart(now);
}
// @dev Sets the maximum and minimum raise amounts prior to the main sale
// @dev Use this method with extreme caution!
// @param _minimumMainSaleRaise Sets the minimium main sale raise
// @param _maximumMainSaleRaise Sets the maximum main sale raise
// @param _maximumAllocationPerParticipant sets the maximum main sale allocation per participant
function changeSettings(uint256 _minimumMainSaleRaise,
uint256 _maximumMainSaleRaise,
uint256 _maximumAllocationPerParticipant,
uint256 _mainSaleExchangeRate)
external
onlyWallet
atStage(Stages.PresaleEnded)
{
// Checks the inputs for null values
require(_minimumMainSaleRaise > 0 &&
_maximumMainSaleRaise > 0 &&
_maximumAllocationPerParticipant > 0 &&
_mainSaleExchangeRate > 0);
// Sanity check that requires the min raise to be less then the max
require(_minimumMainSaleRaise < _maximumMainSaleRaise);
// This check verifies that the token_sale contract has enough tokens to match the
// _maximumMainSaleRaiseAmount * _mainSaleExchangeRate (subtracts presale amounts first)
require(_maximumMainSaleRaise.sub(PRESALE_MAX_RAISE).mul(_mainSaleExchangeRate) <= token.balanceOf(this).sub(PRESALE_TOKEN_ALLOCATION));
minimumMainSaleRaise = _minimumMainSaleRaise;
maximumMainSaleRaise = _maximumMainSaleRaise;
mainSaleExchangeRate = _mainSaleExchangeRate;
maximumAllocationPerParticipant = _maximumAllocationPerParticipant;
}
// @dev Starts the main sale
// @dev Make sure the main sale variables are correct before calling
function startMainSale()
external
onlyWallet
atStage(Stages.PresaleEnded)
{
stage = Stages.MainSaleStarted;
mainSaleEndTime = now + 8 weeks;
MainSaleStart(now);
}
// @dev Starts the trading stage, allowing buyer to claim their tokens
function startTrading()
external
atStage(Stages.MainSaleEnded)
{
// Trading starts between two weeks (if called by the wallet) and two months (callable by anyone)
// after the main sale has ended
require((msg.sender == wallet && now >= minTradingStartTime) || now >= maxTradingStartTime);
stage = Stages.Trading;
TradingStart(now);
}
// @dev Allows buyer to be refunded their ETH if the minimum presale raise amount hasn't been met
function refund()
external
atStage(Stages.Refund)
{
uint256 amount = mainSaleAllocations[msg.sender];
mainSaleAllocations[msg.sender] = 0;
msg.sender.transfer(amount);
Refund(msg.sender, amount);
}
// @dev Allows buyers to claim the tokens they've purchased
function claimTokens()
external
atStage(Stages.Trading)
{
uint256 tokenAllocation = presaleAllocations[msg.sender].add(mainSaleAllocations[msg.sender].mul(mainSaleExchangeRate));
presaleAllocations[msg.sender] = 0;
mainSaleAllocations[msg.sender] = 0;
token.transfer(msg.sender, tokenAllocation);
}
/*
* Private functions
*/
// @dev Allocated tokens to the presale buyer at a rate based on the total received
// @param receiver The address presale balehubucks will be allocated to
function buyPresale(address receiver)
private
{
if (now >= presaleEndTime) {
endPresale();
return;
}
uint256 totalTokenAllocation = 0;
uint256 oldTotalReceived = totalReceived;
uint256 tokenAllocation = 0;
uint256 weiUsing = 0;
uint256 weiAmount = msg.value;
uint256 maxWeiForPresaleStage = 0;
uint256 buyerRefund = 0;
// Cycles through the presale phases conditional giving a different exchange rate for
// each phase of the presale until tokens have been allocated for all Ether sent or
// until the presale cap of 3,000 Ether has been reached
while (true) {
// The EVM deals with division by rounding down, causing the below statement to
// round down to the correct stage
// stageAmount = totalReceived.add(500 * 10**18).div(500 * 10**18).mul(500 * 10**18);
// maxWeiForPresaleStage = stageAmount - totalReceived
maxWeiForPresaleStage = (totalReceived.add(500 * 10**18).div(500 * 10**18).mul(500 * 10**18)).sub(totalReceived);
if (weiAmount > maxWeiForPresaleStage) {
weiUsing = maxWeiForPresaleStage;
} else {
weiUsing = weiAmount;
}
weiAmount = weiAmount.sub(weiUsing);
if (totalReceived < 500 * 10**18) {
// Stage 1: up to 500 Ether, exchange rate of 1 ETH for 5000 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 5000);
} else if (totalReceived < 1000 * 10**18) {
// Stage 2: up to 1000 Ether, exchange rate of 1 ETH for 4500 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 4500);
} else if (totalReceived < 1500 * 10**18) {
// Stage 3: up to 1500 Ether, exchange rate of 1 ETH for 4000 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 4000);
} else if (totalReceived < 2000 * 10**18) {
// Stage 4: up to 2000 Ether, exchange rate of 1 ETH for 3500 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 3500);
} else if (totalReceived < 2500 * 10**18) {
// Stage 5: up to 2500 Ether, exchange rate of 1 ETH for 3250 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 3250);
} else if (totalReceived < 3000 * 10**18) {
// Stage 6: up to 3000 Ether, exchange rate of 1 ETH for 3000 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 3000);
}
totalTokenAllocation = totalTokenAllocation.add(tokenAllocation);
totalReceived = totalReceived.add(weiUsing);
if (totalReceived >= PRESALE_MAX_RAISE) {
buyerRefund = weiAmount;
endPresale();
}
// Exits the for loops if the presale cap has been reached (changing the stage)
// or all of the wei send to the presale has been allocated
if (weiAmount == 0 || stage != Stages.PresaleStarted)
break;
}
presaleAllocations[receiver] = presaleAllocations[receiver].add(totalTokenAllocation);
wallet.transfer(totalReceived.sub(oldTotalReceived));
msg.sender.transfer(buyerRefund);
AllocatePresale(receiver, totalTokenAllocation);
}
// @dev Allocated tokens to the presale buyer at a rate based on the total received
// @param receiver The address main sale balehubucks will be allocated to
function buyMainSale(address receiver)
private
{
if (now >= mainSaleEndTime) {
endMainSale(msg.value);
msg.sender.transfer(msg.value);
return;
}
uint256 buyerRefund = 0;
uint256 weiAllocation = mainSaleAllocations[receiver].add(msg.value);
if (weiAllocation >= maximumAllocationPerParticipant) {
weiAllocation = maximumAllocationPerParticipant.sub(mainSaleAllocations[receiver]);
buyerRefund = msg.value.sub(weiAllocation);
}
uint256 potentialReceived = totalReceived.add(weiAllocation);
if (potentialReceived > maximumMainSaleRaise) {
weiAllocation = maximumMainSaleRaise.sub(totalReceived);
buyerRefund = buyerRefund.add(potentialReceived.sub(maximumMainSaleRaise));
endMainSale(buyerRefund);
}
totalReceived = totalReceived.add(weiAllocation);
mainSaleAllocations[receiver] = mainSaleAllocations[receiver].add(weiAllocation);
msg.sender.transfer(buyerRefund);
AllocateMainSale(receiver, weiAllocation);
}
// @dev Calculates the amount of presale tokens to allocate
// @param weiUsing The amount of wei being used to for the given token allocation
// @param rate The eth/token exchange rate, this changes based on how much the presale has received so far
function calcpresaleAllocations(uint256 weiUsing, uint256 rate)
private
pure
returns (uint256)
{
return weiUsing.mul(rate);
}
// @dev Ends the presale
function endPresale()
private
{
stage = Stages.PresaleEnded;
PresaleEnd(now);
}
// @dev Ends the main sale triggering a refund if the minimum sale raise has no been met
// @dev or passes funds raised to the wallet and starts the trading count down
function endMainSale(uint256 buyerRefund)
private
{
if (totalReceived < minimumMainSaleRaise) {
stage = Stages.Refund;
} else {
minTradingStartTime = now + 2 weeks;
maxTradingStartTime = now + 8 weeks;
stage = Stages.MainSaleEnded;
// Transfers all funds raised to the Balehu wallet minus the funds that need to be refunded
wallet.transfer(this.balance.sub(buyerRefund));
// All unsold tokens will remain within the token_sale contract
// and will be treated as burned
}
MainSaleEnd(now);
}
} | refund | function refund()
external
atStage(Stages.Refund)
{
uint256 amount = mainSaleAllocations[msg.sender];
mainSaleAllocations[msg.sender] = 0;
msg.sender.transfer(amount);
Refund(msg.sender, amount);
}
| // @dev Allows buyer to be refunded their ETH if the minimum presale raise amount hasn't been met | LineComment | v0.4.18+commit.9cf6e910 | bzzr://0692760ec1db61591d22a91dffec166a0b6a1575b73970edbeb3a305571151bf | {
"func_code_index": [
6315,
6582
]
} | 59,885 |
|||
TokenSale | TokenSale.sol | 0xb8d8496a49fc00c8fc42e1d8822ea15d33b7c2ae | Solidity | TokenSale | contract TokenSale {
using SafeMath for uint256;
/*
* Events
*/
event PresaleStart(uint256 indexed presaleStartTime);
event AllocatePresale(address indexed receiver, uint256 tokenQuantity);
event PresaleEnd(uint256 indexed presaleEndTime);
event MainSaleStart(uint256 indexed startMainSaleTime);
event AllocateMainSale(address indexed receiver, uint256 etherAmount);
event MainSaleEnd(uint256 indexed endMainSaleTime);
event TradingStart(uint256 indexed startTradingTime);
event Refund(address indexed receiver, uint256 etherAmount);
/*
* Constants
*/
// Presale Allocation = 500 * (5000 + 4500 + 4000 + 3500 + 3250 + 3000) * 10**18
uint256 public constant PRESALE_TOKEN_ALLOCATION = 11625000 * 10**18;
uint256 public constant PRESALE_MAX_RAISE = 3000 * 10**18;
/*
* Storage
*/
mapping (address => uint256) public presaleAllocations;
mapping (address => uint256) public mainSaleAllocations;
address public wallet;
Balehubuck public token;
uint256 public presaleEndTime;
uint256 public mainSaleEndTime;
uint256 public minTradingStartTime;
uint256 public maxTradingStartTime;
uint256 public totalReceived;
uint256 public minimumMainSaleRaise;
uint256 public maximumMainSaleRaise;
uint256 public maximumAllocationPerParticipant;
uint256 public mainSaleExchangeRate;
Stages public stage;
enum Stages {
Deployed,
PresaleStarted,
PresaleEnded,
MainSaleStarted,
MainSaleEnded,
Refund,
Trading
}
/*
* Modifiers
*/
modifier onlyWallet() {
require(wallet == msg.sender);
_;
}
modifier atStage(Stages _stage) {
require(stage == _stage);
_;
}
/*
* Fallback function
*/
function ()
external
payable
{
buy(msg.sender);
}
/*
* Constructor function
*/
// @dev Constructor function that create the Balehubuck token and sets the initial variables
// @param _wallet sets the wallet state variable which will be used to start stages throughout the token sale
function TokenSale(address _wallet)
public
{
require(_wallet != 0x0);
wallet = _wallet;
token = new Balehubuck(wallet);
// Sets the default main sale values
minimumMainSaleRaise = 23000 * 10**18;
maximumMainSaleRaise = 78000 * 10**18;
maximumAllocationPerParticipant = 750 * 10**18;
mainSaleExchangeRate = 2500;
stage = Stages.Deployed;
totalReceived = 0;
}
/*
* Public functions
*/
// @ev Allows buyers to buy tokens, throws if neither the presale or main sale is happening
// @param _receiver The address the will receive the tokens
function buy(address _receiver)
public
payable
{
require(msg.value > 0);
address receiver = _receiver;
if (receiver == 0x0)
receiver = msg.sender;
if (stage == Stages.PresaleStarted) {
buyPresale(receiver);
} else if (stage == Stages.MainSaleStarted) {
buyMainSale(receiver);
} else {
revert();
}
}
/*
* External functions
*/
// @dev Starts the presale
function startPresale()
external
onlyWallet
atStage(Stages.Deployed)
{
stage = Stages.PresaleStarted;
presaleEndTime = now + 8 weeks;
PresaleStart(now);
}
// @dev Sets the maximum and minimum raise amounts prior to the main sale
// @dev Use this method with extreme caution!
// @param _minimumMainSaleRaise Sets the minimium main sale raise
// @param _maximumMainSaleRaise Sets the maximum main sale raise
// @param _maximumAllocationPerParticipant sets the maximum main sale allocation per participant
function changeSettings(uint256 _minimumMainSaleRaise,
uint256 _maximumMainSaleRaise,
uint256 _maximumAllocationPerParticipant,
uint256 _mainSaleExchangeRate)
external
onlyWallet
atStage(Stages.PresaleEnded)
{
// Checks the inputs for null values
require(_minimumMainSaleRaise > 0 &&
_maximumMainSaleRaise > 0 &&
_maximumAllocationPerParticipant > 0 &&
_mainSaleExchangeRate > 0);
// Sanity check that requires the min raise to be less then the max
require(_minimumMainSaleRaise < _maximumMainSaleRaise);
// This check verifies that the token_sale contract has enough tokens to match the
// _maximumMainSaleRaiseAmount * _mainSaleExchangeRate (subtracts presale amounts first)
require(_maximumMainSaleRaise.sub(PRESALE_MAX_RAISE).mul(_mainSaleExchangeRate) <= token.balanceOf(this).sub(PRESALE_TOKEN_ALLOCATION));
minimumMainSaleRaise = _minimumMainSaleRaise;
maximumMainSaleRaise = _maximumMainSaleRaise;
mainSaleExchangeRate = _mainSaleExchangeRate;
maximumAllocationPerParticipant = _maximumAllocationPerParticipant;
}
// @dev Starts the main sale
// @dev Make sure the main sale variables are correct before calling
function startMainSale()
external
onlyWallet
atStage(Stages.PresaleEnded)
{
stage = Stages.MainSaleStarted;
mainSaleEndTime = now + 8 weeks;
MainSaleStart(now);
}
// @dev Starts the trading stage, allowing buyer to claim their tokens
function startTrading()
external
atStage(Stages.MainSaleEnded)
{
// Trading starts between two weeks (if called by the wallet) and two months (callable by anyone)
// after the main sale has ended
require((msg.sender == wallet && now >= minTradingStartTime) || now >= maxTradingStartTime);
stage = Stages.Trading;
TradingStart(now);
}
// @dev Allows buyer to be refunded their ETH if the minimum presale raise amount hasn't been met
function refund()
external
atStage(Stages.Refund)
{
uint256 amount = mainSaleAllocations[msg.sender];
mainSaleAllocations[msg.sender] = 0;
msg.sender.transfer(amount);
Refund(msg.sender, amount);
}
// @dev Allows buyers to claim the tokens they've purchased
function claimTokens()
external
atStage(Stages.Trading)
{
uint256 tokenAllocation = presaleAllocations[msg.sender].add(mainSaleAllocations[msg.sender].mul(mainSaleExchangeRate));
presaleAllocations[msg.sender] = 0;
mainSaleAllocations[msg.sender] = 0;
token.transfer(msg.sender, tokenAllocation);
}
/*
* Private functions
*/
// @dev Allocated tokens to the presale buyer at a rate based on the total received
// @param receiver The address presale balehubucks will be allocated to
function buyPresale(address receiver)
private
{
if (now >= presaleEndTime) {
endPresale();
return;
}
uint256 totalTokenAllocation = 0;
uint256 oldTotalReceived = totalReceived;
uint256 tokenAllocation = 0;
uint256 weiUsing = 0;
uint256 weiAmount = msg.value;
uint256 maxWeiForPresaleStage = 0;
uint256 buyerRefund = 0;
// Cycles through the presale phases conditional giving a different exchange rate for
// each phase of the presale until tokens have been allocated for all Ether sent or
// until the presale cap of 3,000 Ether has been reached
while (true) {
// The EVM deals with division by rounding down, causing the below statement to
// round down to the correct stage
// stageAmount = totalReceived.add(500 * 10**18).div(500 * 10**18).mul(500 * 10**18);
// maxWeiForPresaleStage = stageAmount - totalReceived
maxWeiForPresaleStage = (totalReceived.add(500 * 10**18).div(500 * 10**18).mul(500 * 10**18)).sub(totalReceived);
if (weiAmount > maxWeiForPresaleStage) {
weiUsing = maxWeiForPresaleStage;
} else {
weiUsing = weiAmount;
}
weiAmount = weiAmount.sub(weiUsing);
if (totalReceived < 500 * 10**18) {
// Stage 1: up to 500 Ether, exchange rate of 1 ETH for 5000 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 5000);
} else if (totalReceived < 1000 * 10**18) {
// Stage 2: up to 1000 Ether, exchange rate of 1 ETH for 4500 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 4500);
} else if (totalReceived < 1500 * 10**18) {
// Stage 3: up to 1500 Ether, exchange rate of 1 ETH for 4000 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 4000);
} else if (totalReceived < 2000 * 10**18) {
// Stage 4: up to 2000 Ether, exchange rate of 1 ETH for 3500 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 3500);
} else if (totalReceived < 2500 * 10**18) {
// Stage 5: up to 2500 Ether, exchange rate of 1 ETH for 3250 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 3250);
} else if (totalReceived < 3000 * 10**18) {
// Stage 6: up to 3000 Ether, exchange rate of 1 ETH for 3000 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 3000);
}
totalTokenAllocation = totalTokenAllocation.add(tokenAllocation);
totalReceived = totalReceived.add(weiUsing);
if (totalReceived >= PRESALE_MAX_RAISE) {
buyerRefund = weiAmount;
endPresale();
}
// Exits the for loops if the presale cap has been reached (changing the stage)
// or all of the wei send to the presale has been allocated
if (weiAmount == 0 || stage != Stages.PresaleStarted)
break;
}
presaleAllocations[receiver] = presaleAllocations[receiver].add(totalTokenAllocation);
wallet.transfer(totalReceived.sub(oldTotalReceived));
msg.sender.transfer(buyerRefund);
AllocatePresale(receiver, totalTokenAllocation);
}
// @dev Allocated tokens to the presale buyer at a rate based on the total received
// @param receiver The address main sale balehubucks will be allocated to
function buyMainSale(address receiver)
private
{
if (now >= mainSaleEndTime) {
endMainSale(msg.value);
msg.sender.transfer(msg.value);
return;
}
uint256 buyerRefund = 0;
uint256 weiAllocation = mainSaleAllocations[receiver].add(msg.value);
if (weiAllocation >= maximumAllocationPerParticipant) {
weiAllocation = maximumAllocationPerParticipant.sub(mainSaleAllocations[receiver]);
buyerRefund = msg.value.sub(weiAllocation);
}
uint256 potentialReceived = totalReceived.add(weiAllocation);
if (potentialReceived > maximumMainSaleRaise) {
weiAllocation = maximumMainSaleRaise.sub(totalReceived);
buyerRefund = buyerRefund.add(potentialReceived.sub(maximumMainSaleRaise));
endMainSale(buyerRefund);
}
totalReceived = totalReceived.add(weiAllocation);
mainSaleAllocations[receiver] = mainSaleAllocations[receiver].add(weiAllocation);
msg.sender.transfer(buyerRefund);
AllocateMainSale(receiver, weiAllocation);
}
// @dev Calculates the amount of presale tokens to allocate
// @param weiUsing The amount of wei being used to for the given token allocation
// @param rate The eth/token exchange rate, this changes based on how much the presale has received so far
function calcpresaleAllocations(uint256 weiUsing, uint256 rate)
private
pure
returns (uint256)
{
return weiUsing.mul(rate);
}
// @dev Ends the presale
function endPresale()
private
{
stage = Stages.PresaleEnded;
PresaleEnd(now);
}
// @dev Ends the main sale triggering a refund if the minimum sale raise has no been met
// @dev or passes funds raised to the wallet and starts the trading count down
function endMainSale(uint256 buyerRefund)
private
{
if (totalReceived < minimumMainSaleRaise) {
stage = Stages.Refund;
} else {
minTradingStartTime = now + 2 weeks;
maxTradingStartTime = now + 8 weeks;
stage = Stages.MainSaleEnded;
// Transfers all funds raised to the Balehu wallet minus the funds that need to be refunded
wallet.transfer(this.balance.sub(buyerRefund));
// All unsold tokens will remain within the token_sale contract
// and will be treated as burned
}
MainSaleEnd(now);
}
} | claimTokens | function claimTokens()
external
atStage(Stages.Trading)
{
uint256 tokenAllocation = presaleAllocations[msg.sender].add(mainSaleAllocations[msg.sender].mul(mainSaleExchangeRate));
presaleAllocations[msg.sender] = 0;
mainSaleAllocations[msg.sender] = 0;
token.transfer(msg.sender, tokenAllocation);
}
| // @dev Allows buyers to claim the tokens they've purchased | LineComment | v0.4.18+commit.9cf6e910 | bzzr://0692760ec1db61591d22a91dffec166a0b6a1575b73970edbeb3a305571151bf | {
"func_code_index": [
6650,
7017
]
} | 59,886 |
|||
TokenSale | TokenSale.sol | 0xb8d8496a49fc00c8fc42e1d8822ea15d33b7c2ae | Solidity | TokenSale | contract TokenSale {
using SafeMath for uint256;
/*
* Events
*/
event PresaleStart(uint256 indexed presaleStartTime);
event AllocatePresale(address indexed receiver, uint256 tokenQuantity);
event PresaleEnd(uint256 indexed presaleEndTime);
event MainSaleStart(uint256 indexed startMainSaleTime);
event AllocateMainSale(address indexed receiver, uint256 etherAmount);
event MainSaleEnd(uint256 indexed endMainSaleTime);
event TradingStart(uint256 indexed startTradingTime);
event Refund(address indexed receiver, uint256 etherAmount);
/*
* Constants
*/
// Presale Allocation = 500 * (5000 + 4500 + 4000 + 3500 + 3250 + 3000) * 10**18
uint256 public constant PRESALE_TOKEN_ALLOCATION = 11625000 * 10**18;
uint256 public constant PRESALE_MAX_RAISE = 3000 * 10**18;
/*
* Storage
*/
mapping (address => uint256) public presaleAllocations;
mapping (address => uint256) public mainSaleAllocations;
address public wallet;
Balehubuck public token;
uint256 public presaleEndTime;
uint256 public mainSaleEndTime;
uint256 public minTradingStartTime;
uint256 public maxTradingStartTime;
uint256 public totalReceived;
uint256 public minimumMainSaleRaise;
uint256 public maximumMainSaleRaise;
uint256 public maximumAllocationPerParticipant;
uint256 public mainSaleExchangeRate;
Stages public stage;
enum Stages {
Deployed,
PresaleStarted,
PresaleEnded,
MainSaleStarted,
MainSaleEnded,
Refund,
Trading
}
/*
* Modifiers
*/
modifier onlyWallet() {
require(wallet == msg.sender);
_;
}
modifier atStage(Stages _stage) {
require(stage == _stage);
_;
}
/*
* Fallback function
*/
function ()
external
payable
{
buy(msg.sender);
}
/*
* Constructor function
*/
// @dev Constructor function that create the Balehubuck token and sets the initial variables
// @param _wallet sets the wallet state variable which will be used to start stages throughout the token sale
function TokenSale(address _wallet)
public
{
require(_wallet != 0x0);
wallet = _wallet;
token = new Balehubuck(wallet);
// Sets the default main sale values
minimumMainSaleRaise = 23000 * 10**18;
maximumMainSaleRaise = 78000 * 10**18;
maximumAllocationPerParticipant = 750 * 10**18;
mainSaleExchangeRate = 2500;
stage = Stages.Deployed;
totalReceived = 0;
}
/*
* Public functions
*/
// @ev Allows buyers to buy tokens, throws if neither the presale or main sale is happening
// @param _receiver The address the will receive the tokens
function buy(address _receiver)
public
payable
{
require(msg.value > 0);
address receiver = _receiver;
if (receiver == 0x0)
receiver = msg.sender;
if (stage == Stages.PresaleStarted) {
buyPresale(receiver);
} else if (stage == Stages.MainSaleStarted) {
buyMainSale(receiver);
} else {
revert();
}
}
/*
* External functions
*/
// @dev Starts the presale
function startPresale()
external
onlyWallet
atStage(Stages.Deployed)
{
stage = Stages.PresaleStarted;
presaleEndTime = now + 8 weeks;
PresaleStart(now);
}
// @dev Sets the maximum and minimum raise amounts prior to the main sale
// @dev Use this method with extreme caution!
// @param _minimumMainSaleRaise Sets the minimium main sale raise
// @param _maximumMainSaleRaise Sets the maximum main sale raise
// @param _maximumAllocationPerParticipant sets the maximum main sale allocation per participant
function changeSettings(uint256 _minimumMainSaleRaise,
uint256 _maximumMainSaleRaise,
uint256 _maximumAllocationPerParticipant,
uint256 _mainSaleExchangeRate)
external
onlyWallet
atStage(Stages.PresaleEnded)
{
// Checks the inputs for null values
require(_minimumMainSaleRaise > 0 &&
_maximumMainSaleRaise > 0 &&
_maximumAllocationPerParticipant > 0 &&
_mainSaleExchangeRate > 0);
// Sanity check that requires the min raise to be less then the max
require(_minimumMainSaleRaise < _maximumMainSaleRaise);
// This check verifies that the token_sale contract has enough tokens to match the
// _maximumMainSaleRaiseAmount * _mainSaleExchangeRate (subtracts presale amounts first)
require(_maximumMainSaleRaise.sub(PRESALE_MAX_RAISE).mul(_mainSaleExchangeRate) <= token.balanceOf(this).sub(PRESALE_TOKEN_ALLOCATION));
minimumMainSaleRaise = _minimumMainSaleRaise;
maximumMainSaleRaise = _maximumMainSaleRaise;
mainSaleExchangeRate = _mainSaleExchangeRate;
maximumAllocationPerParticipant = _maximumAllocationPerParticipant;
}
// @dev Starts the main sale
// @dev Make sure the main sale variables are correct before calling
function startMainSale()
external
onlyWallet
atStage(Stages.PresaleEnded)
{
stage = Stages.MainSaleStarted;
mainSaleEndTime = now + 8 weeks;
MainSaleStart(now);
}
// @dev Starts the trading stage, allowing buyer to claim their tokens
function startTrading()
external
atStage(Stages.MainSaleEnded)
{
// Trading starts between two weeks (if called by the wallet) and two months (callable by anyone)
// after the main sale has ended
require((msg.sender == wallet && now >= minTradingStartTime) || now >= maxTradingStartTime);
stage = Stages.Trading;
TradingStart(now);
}
// @dev Allows buyer to be refunded their ETH if the minimum presale raise amount hasn't been met
function refund()
external
atStage(Stages.Refund)
{
uint256 amount = mainSaleAllocations[msg.sender];
mainSaleAllocations[msg.sender] = 0;
msg.sender.transfer(amount);
Refund(msg.sender, amount);
}
// @dev Allows buyers to claim the tokens they've purchased
function claimTokens()
external
atStage(Stages.Trading)
{
uint256 tokenAllocation = presaleAllocations[msg.sender].add(mainSaleAllocations[msg.sender].mul(mainSaleExchangeRate));
presaleAllocations[msg.sender] = 0;
mainSaleAllocations[msg.sender] = 0;
token.transfer(msg.sender, tokenAllocation);
}
/*
* Private functions
*/
// @dev Allocated tokens to the presale buyer at a rate based on the total received
// @param receiver The address presale balehubucks will be allocated to
function buyPresale(address receiver)
private
{
if (now >= presaleEndTime) {
endPresale();
return;
}
uint256 totalTokenAllocation = 0;
uint256 oldTotalReceived = totalReceived;
uint256 tokenAllocation = 0;
uint256 weiUsing = 0;
uint256 weiAmount = msg.value;
uint256 maxWeiForPresaleStage = 0;
uint256 buyerRefund = 0;
// Cycles through the presale phases conditional giving a different exchange rate for
// each phase of the presale until tokens have been allocated for all Ether sent or
// until the presale cap of 3,000 Ether has been reached
while (true) {
// The EVM deals with division by rounding down, causing the below statement to
// round down to the correct stage
// stageAmount = totalReceived.add(500 * 10**18).div(500 * 10**18).mul(500 * 10**18);
// maxWeiForPresaleStage = stageAmount - totalReceived
maxWeiForPresaleStage = (totalReceived.add(500 * 10**18).div(500 * 10**18).mul(500 * 10**18)).sub(totalReceived);
if (weiAmount > maxWeiForPresaleStage) {
weiUsing = maxWeiForPresaleStage;
} else {
weiUsing = weiAmount;
}
weiAmount = weiAmount.sub(weiUsing);
if (totalReceived < 500 * 10**18) {
// Stage 1: up to 500 Ether, exchange rate of 1 ETH for 5000 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 5000);
} else if (totalReceived < 1000 * 10**18) {
// Stage 2: up to 1000 Ether, exchange rate of 1 ETH for 4500 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 4500);
} else if (totalReceived < 1500 * 10**18) {
// Stage 3: up to 1500 Ether, exchange rate of 1 ETH for 4000 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 4000);
} else if (totalReceived < 2000 * 10**18) {
// Stage 4: up to 2000 Ether, exchange rate of 1 ETH for 3500 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 3500);
} else if (totalReceived < 2500 * 10**18) {
// Stage 5: up to 2500 Ether, exchange rate of 1 ETH for 3250 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 3250);
} else if (totalReceived < 3000 * 10**18) {
// Stage 6: up to 3000 Ether, exchange rate of 1 ETH for 3000 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 3000);
}
totalTokenAllocation = totalTokenAllocation.add(tokenAllocation);
totalReceived = totalReceived.add(weiUsing);
if (totalReceived >= PRESALE_MAX_RAISE) {
buyerRefund = weiAmount;
endPresale();
}
// Exits the for loops if the presale cap has been reached (changing the stage)
// or all of the wei send to the presale has been allocated
if (weiAmount == 0 || stage != Stages.PresaleStarted)
break;
}
presaleAllocations[receiver] = presaleAllocations[receiver].add(totalTokenAllocation);
wallet.transfer(totalReceived.sub(oldTotalReceived));
msg.sender.transfer(buyerRefund);
AllocatePresale(receiver, totalTokenAllocation);
}
// @dev Allocated tokens to the presale buyer at a rate based on the total received
// @param receiver The address main sale balehubucks will be allocated to
function buyMainSale(address receiver)
private
{
if (now >= mainSaleEndTime) {
endMainSale(msg.value);
msg.sender.transfer(msg.value);
return;
}
uint256 buyerRefund = 0;
uint256 weiAllocation = mainSaleAllocations[receiver].add(msg.value);
if (weiAllocation >= maximumAllocationPerParticipant) {
weiAllocation = maximumAllocationPerParticipant.sub(mainSaleAllocations[receiver]);
buyerRefund = msg.value.sub(weiAllocation);
}
uint256 potentialReceived = totalReceived.add(weiAllocation);
if (potentialReceived > maximumMainSaleRaise) {
weiAllocation = maximumMainSaleRaise.sub(totalReceived);
buyerRefund = buyerRefund.add(potentialReceived.sub(maximumMainSaleRaise));
endMainSale(buyerRefund);
}
totalReceived = totalReceived.add(weiAllocation);
mainSaleAllocations[receiver] = mainSaleAllocations[receiver].add(weiAllocation);
msg.sender.transfer(buyerRefund);
AllocateMainSale(receiver, weiAllocation);
}
// @dev Calculates the amount of presale tokens to allocate
// @param weiUsing The amount of wei being used to for the given token allocation
// @param rate The eth/token exchange rate, this changes based on how much the presale has received so far
function calcpresaleAllocations(uint256 weiUsing, uint256 rate)
private
pure
returns (uint256)
{
return weiUsing.mul(rate);
}
// @dev Ends the presale
function endPresale()
private
{
stage = Stages.PresaleEnded;
PresaleEnd(now);
}
// @dev Ends the main sale triggering a refund if the minimum sale raise has no been met
// @dev or passes funds raised to the wallet and starts the trading count down
function endMainSale(uint256 buyerRefund)
private
{
if (totalReceived < minimumMainSaleRaise) {
stage = Stages.Refund;
} else {
minTradingStartTime = now + 2 weeks;
maxTradingStartTime = now + 8 weeks;
stage = Stages.MainSaleEnded;
// Transfers all funds raised to the Balehu wallet minus the funds that need to be refunded
wallet.transfer(this.balance.sub(buyerRefund));
// All unsold tokens will remain within the token_sale contract
// and will be treated as burned
}
MainSaleEnd(now);
}
} | buyPresale | function buyPresale(address receiver)
private
{
if (now >= presaleEndTime) {
endPresale();
return;
}
uint256 totalTokenAllocation = 0;
uint256 oldTotalReceived = totalReceived;
uint256 tokenAllocation = 0;
uint256 weiUsing = 0;
uint256 weiAmount = msg.value;
uint256 maxWeiForPresaleStage = 0;
uint256 buyerRefund = 0;
// Cycles through the presale phases conditional giving a different exchange rate for
// each phase of the presale until tokens have been allocated for all Ether sent or
// until the presale cap of 3,000 Ether has been reached
while (true) {
// The EVM deals with division by rounding down, causing the below statement to
// round down to the correct stage
// stageAmount = totalReceived.add(500 * 10**18).div(500 * 10**18).mul(500 * 10**18);
// maxWeiForPresaleStage = stageAmount - totalReceived
maxWeiForPresaleStage = (totalReceived.add(500 * 10**18).div(500 * 10**18).mul(500 * 10**18)).sub(totalReceived);
if (weiAmount > maxWeiForPresaleStage) {
weiUsing = maxWeiForPresaleStage;
} else {
weiUsing = weiAmount;
}
weiAmount = weiAmount.sub(weiUsing);
if (totalReceived < 500 * 10**18) {
// Stage 1: up to 500 Ether, exchange rate of 1 ETH for 5000 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 5000);
} else if (totalReceived < 1000 * 10**18) {
// Stage 2: up to 1000 Ether, exchange rate of 1 ETH for 4500 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 4500);
} else if (totalReceived < 1500 * 10**18) {
// Stage 3: up to 1500 Ether, exchange rate of 1 ETH for 4000 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 4000);
} else if (totalReceived < 2000 * 10**18) {
// Stage 4: up to 2000 Ether, exchange rate of 1 ETH for 3500 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 3500);
} else if (totalReceived < 2500 * 10**18) {
// Stage 5: up to 2500 Ether, exchange rate of 1 ETH for 3250 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 3250);
} else if (totalReceived < 3000 * 10**18) {
// Stage 6: up to 3000 Ether, exchange rate of 1 ETH for 3000 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 3000);
}
totalTokenAllocation = totalTokenAllocation.add(tokenAllocation);
totalReceived = totalReceived.add(weiUsing);
if (totalReceived >= PRESALE_MAX_RAISE) {
buyerRefund = weiAmount;
endPresale();
}
// Exits the for loops if the presale cap has been reached (changing the stage)
// or all of the wei send to the presale has been allocated
if (weiAmount == 0 || stage != Stages.PresaleStarted)
break;
}
presaleAllocations[receiver] = presaleAllocations[receiver].add(totalTokenAllocation);
wallet.transfer(totalReceived.sub(oldTotalReceived));
msg.sender.transfer(buyerRefund);
AllocatePresale(receiver, totalTokenAllocation);
}
| // @dev Allocated tokens to the presale buyer at a rate based on the total received
// @param receiver The address presale balehubucks will be allocated to | LineComment | v0.4.18+commit.9cf6e910 | bzzr://0692760ec1db61591d22a91dffec166a0b6a1575b73970edbeb3a305571151bf | {
"func_code_index": [
7230,
10715
]
} | 59,887 |
|||
TokenSale | TokenSale.sol | 0xb8d8496a49fc00c8fc42e1d8822ea15d33b7c2ae | Solidity | TokenSale | contract TokenSale {
using SafeMath for uint256;
/*
* Events
*/
event PresaleStart(uint256 indexed presaleStartTime);
event AllocatePresale(address indexed receiver, uint256 tokenQuantity);
event PresaleEnd(uint256 indexed presaleEndTime);
event MainSaleStart(uint256 indexed startMainSaleTime);
event AllocateMainSale(address indexed receiver, uint256 etherAmount);
event MainSaleEnd(uint256 indexed endMainSaleTime);
event TradingStart(uint256 indexed startTradingTime);
event Refund(address indexed receiver, uint256 etherAmount);
/*
* Constants
*/
// Presale Allocation = 500 * (5000 + 4500 + 4000 + 3500 + 3250 + 3000) * 10**18
uint256 public constant PRESALE_TOKEN_ALLOCATION = 11625000 * 10**18;
uint256 public constant PRESALE_MAX_RAISE = 3000 * 10**18;
/*
* Storage
*/
mapping (address => uint256) public presaleAllocations;
mapping (address => uint256) public mainSaleAllocations;
address public wallet;
Balehubuck public token;
uint256 public presaleEndTime;
uint256 public mainSaleEndTime;
uint256 public minTradingStartTime;
uint256 public maxTradingStartTime;
uint256 public totalReceived;
uint256 public minimumMainSaleRaise;
uint256 public maximumMainSaleRaise;
uint256 public maximumAllocationPerParticipant;
uint256 public mainSaleExchangeRate;
Stages public stage;
enum Stages {
Deployed,
PresaleStarted,
PresaleEnded,
MainSaleStarted,
MainSaleEnded,
Refund,
Trading
}
/*
* Modifiers
*/
modifier onlyWallet() {
require(wallet == msg.sender);
_;
}
modifier atStage(Stages _stage) {
require(stage == _stage);
_;
}
/*
* Fallback function
*/
function ()
external
payable
{
buy(msg.sender);
}
/*
* Constructor function
*/
// @dev Constructor function that create the Balehubuck token and sets the initial variables
// @param _wallet sets the wallet state variable which will be used to start stages throughout the token sale
function TokenSale(address _wallet)
public
{
require(_wallet != 0x0);
wallet = _wallet;
token = new Balehubuck(wallet);
// Sets the default main sale values
minimumMainSaleRaise = 23000 * 10**18;
maximumMainSaleRaise = 78000 * 10**18;
maximumAllocationPerParticipant = 750 * 10**18;
mainSaleExchangeRate = 2500;
stage = Stages.Deployed;
totalReceived = 0;
}
/*
* Public functions
*/
// @ev Allows buyers to buy tokens, throws if neither the presale or main sale is happening
// @param _receiver The address the will receive the tokens
function buy(address _receiver)
public
payable
{
require(msg.value > 0);
address receiver = _receiver;
if (receiver == 0x0)
receiver = msg.sender;
if (stage == Stages.PresaleStarted) {
buyPresale(receiver);
} else if (stage == Stages.MainSaleStarted) {
buyMainSale(receiver);
} else {
revert();
}
}
/*
* External functions
*/
// @dev Starts the presale
function startPresale()
external
onlyWallet
atStage(Stages.Deployed)
{
stage = Stages.PresaleStarted;
presaleEndTime = now + 8 weeks;
PresaleStart(now);
}
// @dev Sets the maximum and minimum raise amounts prior to the main sale
// @dev Use this method with extreme caution!
// @param _minimumMainSaleRaise Sets the minimium main sale raise
// @param _maximumMainSaleRaise Sets the maximum main sale raise
// @param _maximumAllocationPerParticipant sets the maximum main sale allocation per participant
function changeSettings(uint256 _minimumMainSaleRaise,
uint256 _maximumMainSaleRaise,
uint256 _maximumAllocationPerParticipant,
uint256 _mainSaleExchangeRate)
external
onlyWallet
atStage(Stages.PresaleEnded)
{
// Checks the inputs for null values
require(_minimumMainSaleRaise > 0 &&
_maximumMainSaleRaise > 0 &&
_maximumAllocationPerParticipant > 0 &&
_mainSaleExchangeRate > 0);
// Sanity check that requires the min raise to be less then the max
require(_minimumMainSaleRaise < _maximumMainSaleRaise);
// This check verifies that the token_sale contract has enough tokens to match the
// _maximumMainSaleRaiseAmount * _mainSaleExchangeRate (subtracts presale amounts first)
require(_maximumMainSaleRaise.sub(PRESALE_MAX_RAISE).mul(_mainSaleExchangeRate) <= token.balanceOf(this).sub(PRESALE_TOKEN_ALLOCATION));
minimumMainSaleRaise = _minimumMainSaleRaise;
maximumMainSaleRaise = _maximumMainSaleRaise;
mainSaleExchangeRate = _mainSaleExchangeRate;
maximumAllocationPerParticipant = _maximumAllocationPerParticipant;
}
// @dev Starts the main sale
// @dev Make sure the main sale variables are correct before calling
function startMainSale()
external
onlyWallet
atStage(Stages.PresaleEnded)
{
stage = Stages.MainSaleStarted;
mainSaleEndTime = now + 8 weeks;
MainSaleStart(now);
}
// @dev Starts the trading stage, allowing buyer to claim their tokens
function startTrading()
external
atStage(Stages.MainSaleEnded)
{
// Trading starts between two weeks (if called by the wallet) and two months (callable by anyone)
// after the main sale has ended
require((msg.sender == wallet && now >= minTradingStartTime) || now >= maxTradingStartTime);
stage = Stages.Trading;
TradingStart(now);
}
// @dev Allows buyer to be refunded their ETH if the minimum presale raise amount hasn't been met
function refund()
external
atStage(Stages.Refund)
{
uint256 amount = mainSaleAllocations[msg.sender];
mainSaleAllocations[msg.sender] = 0;
msg.sender.transfer(amount);
Refund(msg.sender, amount);
}
// @dev Allows buyers to claim the tokens they've purchased
function claimTokens()
external
atStage(Stages.Trading)
{
uint256 tokenAllocation = presaleAllocations[msg.sender].add(mainSaleAllocations[msg.sender].mul(mainSaleExchangeRate));
presaleAllocations[msg.sender] = 0;
mainSaleAllocations[msg.sender] = 0;
token.transfer(msg.sender, tokenAllocation);
}
/*
* Private functions
*/
// @dev Allocated tokens to the presale buyer at a rate based on the total received
// @param receiver The address presale balehubucks will be allocated to
function buyPresale(address receiver)
private
{
if (now >= presaleEndTime) {
endPresale();
return;
}
uint256 totalTokenAllocation = 0;
uint256 oldTotalReceived = totalReceived;
uint256 tokenAllocation = 0;
uint256 weiUsing = 0;
uint256 weiAmount = msg.value;
uint256 maxWeiForPresaleStage = 0;
uint256 buyerRefund = 0;
// Cycles through the presale phases conditional giving a different exchange rate for
// each phase of the presale until tokens have been allocated for all Ether sent or
// until the presale cap of 3,000 Ether has been reached
while (true) {
// The EVM deals with division by rounding down, causing the below statement to
// round down to the correct stage
// stageAmount = totalReceived.add(500 * 10**18).div(500 * 10**18).mul(500 * 10**18);
// maxWeiForPresaleStage = stageAmount - totalReceived
maxWeiForPresaleStage = (totalReceived.add(500 * 10**18).div(500 * 10**18).mul(500 * 10**18)).sub(totalReceived);
if (weiAmount > maxWeiForPresaleStage) {
weiUsing = maxWeiForPresaleStage;
} else {
weiUsing = weiAmount;
}
weiAmount = weiAmount.sub(weiUsing);
if (totalReceived < 500 * 10**18) {
// Stage 1: up to 500 Ether, exchange rate of 1 ETH for 5000 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 5000);
} else if (totalReceived < 1000 * 10**18) {
// Stage 2: up to 1000 Ether, exchange rate of 1 ETH for 4500 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 4500);
} else if (totalReceived < 1500 * 10**18) {
// Stage 3: up to 1500 Ether, exchange rate of 1 ETH for 4000 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 4000);
} else if (totalReceived < 2000 * 10**18) {
// Stage 4: up to 2000 Ether, exchange rate of 1 ETH for 3500 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 3500);
} else if (totalReceived < 2500 * 10**18) {
// Stage 5: up to 2500 Ether, exchange rate of 1 ETH for 3250 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 3250);
} else if (totalReceived < 3000 * 10**18) {
// Stage 6: up to 3000 Ether, exchange rate of 1 ETH for 3000 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 3000);
}
totalTokenAllocation = totalTokenAllocation.add(tokenAllocation);
totalReceived = totalReceived.add(weiUsing);
if (totalReceived >= PRESALE_MAX_RAISE) {
buyerRefund = weiAmount;
endPresale();
}
// Exits the for loops if the presale cap has been reached (changing the stage)
// or all of the wei send to the presale has been allocated
if (weiAmount == 0 || stage != Stages.PresaleStarted)
break;
}
presaleAllocations[receiver] = presaleAllocations[receiver].add(totalTokenAllocation);
wallet.transfer(totalReceived.sub(oldTotalReceived));
msg.sender.transfer(buyerRefund);
AllocatePresale(receiver, totalTokenAllocation);
}
// @dev Allocated tokens to the presale buyer at a rate based on the total received
// @param receiver The address main sale balehubucks will be allocated to
function buyMainSale(address receiver)
private
{
if (now >= mainSaleEndTime) {
endMainSale(msg.value);
msg.sender.transfer(msg.value);
return;
}
uint256 buyerRefund = 0;
uint256 weiAllocation = mainSaleAllocations[receiver].add(msg.value);
if (weiAllocation >= maximumAllocationPerParticipant) {
weiAllocation = maximumAllocationPerParticipant.sub(mainSaleAllocations[receiver]);
buyerRefund = msg.value.sub(weiAllocation);
}
uint256 potentialReceived = totalReceived.add(weiAllocation);
if (potentialReceived > maximumMainSaleRaise) {
weiAllocation = maximumMainSaleRaise.sub(totalReceived);
buyerRefund = buyerRefund.add(potentialReceived.sub(maximumMainSaleRaise));
endMainSale(buyerRefund);
}
totalReceived = totalReceived.add(weiAllocation);
mainSaleAllocations[receiver] = mainSaleAllocations[receiver].add(weiAllocation);
msg.sender.transfer(buyerRefund);
AllocateMainSale(receiver, weiAllocation);
}
// @dev Calculates the amount of presale tokens to allocate
// @param weiUsing The amount of wei being used to for the given token allocation
// @param rate The eth/token exchange rate, this changes based on how much the presale has received so far
function calcpresaleAllocations(uint256 weiUsing, uint256 rate)
private
pure
returns (uint256)
{
return weiUsing.mul(rate);
}
// @dev Ends the presale
function endPresale()
private
{
stage = Stages.PresaleEnded;
PresaleEnd(now);
}
// @dev Ends the main sale triggering a refund if the minimum sale raise has no been met
// @dev or passes funds raised to the wallet and starts the trading count down
function endMainSale(uint256 buyerRefund)
private
{
if (totalReceived < minimumMainSaleRaise) {
stage = Stages.Refund;
} else {
minTradingStartTime = now + 2 weeks;
maxTradingStartTime = now + 8 weeks;
stage = Stages.MainSaleEnded;
// Transfers all funds raised to the Balehu wallet minus the funds that need to be refunded
wallet.transfer(this.balance.sub(buyerRefund));
// All unsold tokens will remain within the token_sale contract
// and will be treated as burned
}
MainSaleEnd(now);
}
} | buyMainSale | function buyMainSale(address receiver)
private
{
if (now >= mainSaleEndTime) {
endMainSale(msg.value);
msg.sender.transfer(msg.value);
return;
}
uint256 buyerRefund = 0;
uint256 weiAllocation = mainSaleAllocations[receiver].add(msg.value);
if (weiAllocation >= maximumAllocationPerParticipant) {
weiAllocation = maximumAllocationPerParticipant.sub(mainSaleAllocations[receiver]);
buyerRefund = msg.value.sub(weiAllocation);
}
uint256 potentialReceived = totalReceived.add(weiAllocation);
if (potentialReceived > maximumMainSaleRaise) {
weiAllocation = maximumMainSaleRaise.sub(totalReceived);
buyerRefund = buyerRefund.add(potentialReceived.sub(maximumMainSaleRaise));
endMainSale(buyerRefund);
}
totalReceived = totalReceived.add(weiAllocation);
mainSaleAllocations[receiver] = mainSaleAllocations[receiver].add(weiAllocation);
msg.sender.transfer(buyerRefund);
AllocateMainSale(receiver, weiAllocation);
}
| // @dev Allocated tokens to the presale buyer at a rate based on the total received
// @param receiver The address main sale balehubucks will be allocated to | LineComment | v0.4.18+commit.9cf6e910 | bzzr://0692760ec1db61591d22a91dffec166a0b6a1575b73970edbeb3a305571151bf | {
"func_code_index": [
10886,
12038
]
} | 59,888 |
|||
TokenSale | TokenSale.sol | 0xb8d8496a49fc00c8fc42e1d8822ea15d33b7c2ae | Solidity | TokenSale | contract TokenSale {
using SafeMath for uint256;
/*
* Events
*/
event PresaleStart(uint256 indexed presaleStartTime);
event AllocatePresale(address indexed receiver, uint256 tokenQuantity);
event PresaleEnd(uint256 indexed presaleEndTime);
event MainSaleStart(uint256 indexed startMainSaleTime);
event AllocateMainSale(address indexed receiver, uint256 etherAmount);
event MainSaleEnd(uint256 indexed endMainSaleTime);
event TradingStart(uint256 indexed startTradingTime);
event Refund(address indexed receiver, uint256 etherAmount);
/*
* Constants
*/
// Presale Allocation = 500 * (5000 + 4500 + 4000 + 3500 + 3250 + 3000) * 10**18
uint256 public constant PRESALE_TOKEN_ALLOCATION = 11625000 * 10**18;
uint256 public constant PRESALE_MAX_RAISE = 3000 * 10**18;
/*
* Storage
*/
mapping (address => uint256) public presaleAllocations;
mapping (address => uint256) public mainSaleAllocations;
address public wallet;
Balehubuck public token;
uint256 public presaleEndTime;
uint256 public mainSaleEndTime;
uint256 public minTradingStartTime;
uint256 public maxTradingStartTime;
uint256 public totalReceived;
uint256 public minimumMainSaleRaise;
uint256 public maximumMainSaleRaise;
uint256 public maximumAllocationPerParticipant;
uint256 public mainSaleExchangeRate;
Stages public stage;
enum Stages {
Deployed,
PresaleStarted,
PresaleEnded,
MainSaleStarted,
MainSaleEnded,
Refund,
Trading
}
/*
* Modifiers
*/
modifier onlyWallet() {
require(wallet == msg.sender);
_;
}
modifier atStage(Stages _stage) {
require(stage == _stage);
_;
}
/*
* Fallback function
*/
function ()
external
payable
{
buy(msg.sender);
}
/*
* Constructor function
*/
// @dev Constructor function that create the Balehubuck token and sets the initial variables
// @param _wallet sets the wallet state variable which will be used to start stages throughout the token sale
function TokenSale(address _wallet)
public
{
require(_wallet != 0x0);
wallet = _wallet;
token = new Balehubuck(wallet);
// Sets the default main sale values
minimumMainSaleRaise = 23000 * 10**18;
maximumMainSaleRaise = 78000 * 10**18;
maximumAllocationPerParticipant = 750 * 10**18;
mainSaleExchangeRate = 2500;
stage = Stages.Deployed;
totalReceived = 0;
}
/*
* Public functions
*/
// @ev Allows buyers to buy tokens, throws if neither the presale or main sale is happening
// @param _receiver The address the will receive the tokens
function buy(address _receiver)
public
payable
{
require(msg.value > 0);
address receiver = _receiver;
if (receiver == 0x0)
receiver = msg.sender;
if (stage == Stages.PresaleStarted) {
buyPresale(receiver);
} else if (stage == Stages.MainSaleStarted) {
buyMainSale(receiver);
} else {
revert();
}
}
/*
* External functions
*/
// @dev Starts the presale
function startPresale()
external
onlyWallet
atStage(Stages.Deployed)
{
stage = Stages.PresaleStarted;
presaleEndTime = now + 8 weeks;
PresaleStart(now);
}
// @dev Sets the maximum and minimum raise amounts prior to the main sale
// @dev Use this method with extreme caution!
// @param _minimumMainSaleRaise Sets the minimium main sale raise
// @param _maximumMainSaleRaise Sets the maximum main sale raise
// @param _maximumAllocationPerParticipant sets the maximum main sale allocation per participant
function changeSettings(uint256 _minimumMainSaleRaise,
uint256 _maximumMainSaleRaise,
uint256 _maximumAllocationPerParticipant,
uint256 _mainSaleExchangeRate)
external
onlyWallet
atStage(Stages.PresaleEnded)
{
// Checks the inputs for null values
require(_minimumMainSaleRaise > 0 &&
_maximumMainSaleRaise > 0 &&
_maximumAllocationPerParticipant > 0 &&
_mainSaleExchangeRate > 0);
// Sanity check that requires the min raise to be less then the max
require(_minimumMainSaleRaise < _maximumMainSaleRaise);
// This check verifies that the token_sale contract has enough tokens to match the
// _maximumMainSaleRaiseAmount * _mainSaleExchangeRate (subtracts presale amounts first)
require(_maximumMainSaleRaise.sub(PRESALE_MAX_RAISE).mul(_mainSaleExchangeRate) <= token.balanceOf(this).sub(PRESALE_TOKEN_ALLOCATION));
minimumMainSaleRaise = _minimumMainSaleRaise;
maximumMainSaleRaise = _maximumMainSaleRaise;
mainSaleExchangeRate = _mainSaleExchangeRate;
maximumAllocationPerParticipant = _maximumAllocationPerParticipant;
}
// @dev Starts the main sale
// @dev Make sure the main sale variables are correct before calling
function startMainSale()
external
onlyWallet
atStage(Stages.PresaleEnded)
{
stage = Stages.MainSaleStarted;
mainSaleEndTime = now + 8 weeks;
MainSaleStart(now);
}
// @dev Starts the trading stage, allowing buyer to claim their tokens
function startTrading()
external
atStage(Stages.MainSaleEnded)
{
// Trading starts between two weeks (if called by the wallet) and two months (callable by anyone)
// after the main sale has ended
require((msg.sender == wallet && now >= minTradingStartTime) || now >= maxTradingStartTime);
stage = Stages.Trading;
TradingStart(now);
}
// @dev Allows buyer to be refunded their ETH if the minimum presale raise amount hasn't been met
function refund()
external
atStage(Stages.Refund)
{
uint256 amount = mainSaleAllocations[msg.sender];
mainSaleAllocations[msg.sender] = 0;
msg.sender.transfer(amount);
Refund(msg.sender, amount);
}
// @dev Allows buyers to claim the tokens they've purchased
function claimTokens()
external
atStage(Stages.Trading)
{
uint256 tokenAllocation = presaleAllocations[msg.sender].add(mainSaleAllocations[msg.sender].mul(mainSaleExchangeRate));
presaleAllocations[msg.sender] = 0;
mainSaleAllocations[msg.sender] = 0;
token.transfer(msg.sender, tokenAllocation);
}
/*
* Private functions
*/
// @dev Allocated tokens to the presale buyer at a rate based on the total received
// @param receiver The address presale balehubucks will be allocated to
function buyPresale(address receiver)
private
{
if (now >= presaleEndTime) {
endPresale();
return;
}
uint256 totalTokenAllocation = 0;
uint256 oldTotalReceived = totalReceived;
uint256 tokenAllocation = 0;
uint256 weiUsing = 0;
uint256 weiAmount = msg.value;
uint256 maxWeiForPresaleStage = 0;
uint256 buyerRefund = 0;
// Cycles through the presale phases conditional giving a different exchange rate for
// each phase of the presale until tokens have been allocated for all Ether sent or
// until the presale cap of 3,000 Ether has been reached
while (true) {
// The EVM deals with division by rounding down, causing the below statement to
// round down to the correct stage
// stageAmount = totalReceived.add(500 * 10**18).div(500 * 10**18).mul(500 * 10**18);
// maxWeiForPresaleStage = stageAmount - totalReceived
maxWeiForPresaleStage = (totalReceived.add(500 * 10**18).div(500 * 10**18).mul(500 * 10**18)).sub(totalReceived);
if (weiAmount > maxWeiForPresaleStage) {
weiUsing = maxWeiForPresaleStage;
} else {
weiUsing = weiAmount;
}
weiAmount = weiAmount.sub(weiUsing);
if (totalReceived < 500 * 10**18) {
// Stage 1: up to 500 Ether, exchange rate of 1 ETH for 5000 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 5000);
} else if (totalReceived < 1000 * 10**18) {
// Stage 2: up to 1000 Ether, exchange rate of 1 ETH for 4500 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 4500);
} else if (totalReceived < 1500 * 10**18) {
// Stage 3: up to 1500 Ether, exchange rate of 1 ETH for 4000 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 4000);
} else if (totalReceived < 2000 * 10**18) {
// Stage 4: up to 2000 Ether, exchange rate of 1 ETH for 3500 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 3500);
} else if (totalReceived < 2500 * 10**18) {
// Stage 5: up to 2500 Ether, exchange rate of 1 ETH for 3250 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 3250);
} else if (totalReceived < 3000 * 10**18) {
// Stage 6: up to 3000 Ether, exchange rate of 1 ETH for 3000 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 3000);
}
totalTokenAllocation = totalTokenAllocation.add(tokenAllocation);
totalReceived = totalReceived.add(weiUsing);
if (totalReceived >= PRESALE_MAX_RAISE) {
buyerRefund = weiAmount;
endPresale();
}
// Exits the for loops if the presale cap has been reached (changing the stage)
// or all of the wei send to the presale has been allocated
if (weiAmount == 0 || stage != Stages.PresaleStarted)
break;
}
presaleAllocations[receiver] = presaleAllocations[receiver].add(totalTokenAllocation);
wallet.transfer(totalReceived.sub(oldTotalReceived));
msg.sender.transfer(buyerRefund);
AllocatePresale(receiver, totalTokenAllocation);
}
// @dev Allocated tokens to the presale buyer at a rate based on the total received
// @param receiver The address main sale balehubucks will be allocated to
function buyMainSale(address receiver)
private
{
if (now >= mainSaleEndTime) {
endMainSale(msg.value);
msg.sender.transfer(msg.value);
return;
}
uint256 buyerRefund = 0;
uint256 weiAllocation = mainSaleAllocations[receiver].add(msg.value);
if (weiAllocation >= maximumAllocationPerParticipant) {
weiAllocation = maximumAllocationPerParticipant.sub(mainSaleAllocations[receiver]);
buyerRefund = msg.value.sub(weiAllocation);
}
uint256 potentialReceived = totalReceived.add(weiAllocation);
if (potentialReceived > maximumMainSaleRaise) {
weiAllocation = maximumMainSaleRaise.sub(totalReceived);
buyerRefund = buyerRefund.add(potentialReceived.sub(maximumMainSaleRaise));
endMainSale(buyerRefund);
}
totalReceived = totalReceived.add(weiAllocation);
mainSaleAllocations[receiver] = mainSaleAllocations[receiver].add(weiAllocation);
msg.sender.transfer(buyerRefund);
AllocateMainSale(receiver, weiAllocation);
}
// @dev Calculates the amount of presale tokens to allocate
// @param weiUsing The amount of wei being used to for the given token allocation
// @param rate The eth/token exchange rate, this changes based on how much the presale has received so far
function calcpresaleAllocations(uint256 weiUsing, uint256 rate)
private
pure
returns (uint256)
{
return weiUsing.mul(rate);
}
// @dev Ends the presale
function endPresale()
private
{
stage = Stages.PresaleEnded;
PresaleEnd(now);
}
// @dev Ends the main sale triggering a refund if the minimum sale raise has no been met
// @dev or passes funds raised to the wallet and starts the trading count down
function endMainSale(uint256 buyerRefund)
private
{
if (totalReceived < minimumMainSaleRaise) {
stage = Stages.Refund;
} else {
minTradingStartTime = now + 2 weeks;
maxTradingStartTime = now + 8 weeks;
stage = Stages.MainSaleEnded;
// Transfers all funds raised to the Balehu wallet minus the funds that need to be refunded
wallet.transfer(this.balance.sub(buyerRefund));
// All unsold tokens will remain within the token_sale contract
// and will be treated as burned
}
MainSaleEnd(now);
}
} | calcpresaleAllocations | function calcpresaleAllocations(uint256 weiUsing, uint256 rate)
private
pure
returns (uint256)
{
return weiUsing.mul(rate);
}
| // @dev Calculates the amount of presale tokens to allocate
// @param weiUsing The amount of wei being used to for the given token allocation
// @param rate The eth/token exchange rate, this changes based on how much the presale has received so far | LineComment | v0.4.18+commit.9cf6e910 | bzzr://0692760ec1db61591d22a91dffec166a0b6a1575b73970edbeb3a305571151bf | {
"func_code_index": [
12305,
12481
]
} | 59,889 |
|||
TokenSale | TokenSale.sol | 0xb8d8496a49fc00c8fc42e1d8822ea15d33b7c2ae | Solidity | TokenSale | contract TokenSale {
using SafeMath for uint256;
/*
* Events
*/
event PresaleStart(uint256 indexed presaleStartTime);
event AllocatePresale(address indexed receiver, uint256 tokenQuantity);
event PresaleEnd(uint256 indexed presaleEndTime);
event MainSaleStart(uint256 indexed startMainSaleTime);
event AllocateMainSale(address indexed receiver, uint256 etherAmount);
event MainSaleEnd(uint256 indexed endMainSaleTime);
event TradingStart(uint256 indexed startTradingTime);
event Refund(address indexed receiver, uint256 etherAmount);
/*
* Constants
*/
// Presale Allocation = 500 * (5000 + 4500 + 4000 + 3500 + 3250 + 3000) * 10**18
uint256 public constant PRESALE_TOKEN_ALLOCATION = 11625000 * 10**18;
uint256 public constant PRESALE_MAX_RAISE = 3000 * 10**18;
/*
* Storage
*/
mapping (address => uint256) public presaleAllocations;
mapping (address => uint256) public mainSaleAllocations;
address public wallet;
Balehubuck public token;
uint256 public presaleEndTime;
uint256 public mainSaleEndTime;
uint256 public minTradingStartTime;
uint256 public maxTradingStartTime;
uint256 public totalReceived;
uint256 public minimumMainSaleRaise;
uint256 public maximumMainSaleRaise;
uint256 public maximumAllocationPerParticipant;
uint256 public mainSaleExchangeRate;
Stages public stage;
enum Stages {
Deployed,
PresaleStarted,
PresaleEnded,
MainSaleStarted,
MainSaleEnded,
Refund,
Trading
}
/*
* Modifiers
*/
modifier onlyWallet() {
require(wallet == msg.sender);
_;
}
modifier atStage(Stages _stage) {
require(stage == _stage);
_;
}
/*
* Fallback function
*/
function ()
external
payable
{
buy(msg.sender);
}
/*
* Constructor function
*/
// @dev Constructor function that create the Balehubuck token and sets the initial variables
// @param _wallet sets the wallet state variable which will be used to start stages throughout the token sale
function TokenSale(address _wallet)
public
{
require(_wallet != 0x0);
wallet = _wallet;
token = new Balehubuck(wallet);
// Sets the default main sale values
minimumMainSaleRaise = 23000 * 10**18;
maximumMainSaleRaise = 78000 * 10**18;
maximumAllocationPerParticipant = 750 * 10**18;
mainSaleExchangeRate = 2500;
stage = Stages.Deployed;
totalReceived = 0;
}
/*
* Public functions
*/
// @ev Allows buyers to buy tokens, throws if neither the presale or main sale is happening
// @param _receiver The address the will receive the tokens
function buy(address _receiver)
public
payable
{
require(msg.value > 0);
address receiver = _receiver;
if (receiver == 0x0)
receiver = msg.sender;
if (stage == Stages.PresaleStarted) {
buyPresale(receiver);
} else if (stage == Stages.MainSaleStarted) {
buyMainSale(receiver);
} else {
revert();
}
}
/*
* External functions
*/
// @dev Starts the presale
function startPresale()
external
onlyWallet
atStage(Stages.Deployed)
{
stage = Stages.PresaleStarted;
presaleEndTime = now + 8 weeks;
PresaleStart(now);
}
// @dev Sets the maximum and minimum raise amounts prior to the main sale
// @dev Use this method with extreme caution!
// @param _minimumMainSaleRaise Sets the minimium main sale raise
// @param _maximumMainSaleRaise Sets the maximum main sale raise
// @param _maximumAllocationPerParticipant sets the maximum main sale allocation per participant
function changeSettings(uint256 _minimumMainSaleRaise,
uint256 _maximumMainSaleRaise,
uint256 _maximumAllocationPerParticipant,
uint256 _mainSaleExchangeRate)
external
onlyWallet
atStage(Stages.PresaleEnded)
{
// Checks the inputs for null values
require(_minimumMainSaleRaise > 0 &&
_maximumMainSaleRaise > 0 &&
_maximumAllocationPerParticipant > 0 &&
_mainSaleExchangeRate > 0);
// Sanity check that requires the min raise to be less then the max
require(_minimumMainSaleRaise < _maximumMainSaleRaise);
// This check verifies that the token_sale contract has enough tokens to match the
// _maximumMainSaleRaiseAmount * _mainSaleExchangeRate (subtracts presale amounts first)
require(_maximumMainSaleRaise.sub(PRESALE_MAX_RAISE).mul(_mainSaleExchangeRate) <= token.balanceOf(this).sub(PRESALE_TOKEN_ALLOCATION));
minimumMainSaleRaise = _minimumMainSaleRaise;
maximumMainSaleRaise = _maximumMainSaleRaise;
mainSaleExchangeRate = _mainSaleExchangeRate;
maximumAllocationPerParticipant = _maximumAllocationPerParticipant;
}
// @dev Starts the main sale
// @dev Make sure the main sale variables are correct before calling
function startMainSale()
external
onlyWallet
atStage(Stages.PresaleEnded)
{
stage = Stages.MainSaleStarted;
mainSaleEndTime = now + 8 weeks;
MainSaleStart(now);
}
// @dev Starts the trading stage, allowing buyer to claim their tokens
function startTrading()
external
atStage(Stages.MainSaleEnded)
{
// Trading starts between two weeks (if called by the wallet) and two months (callable by anyone)
// after the main sale has ended
require((msg.sender == wallet && now >= minTradingStartTime) || now >= maxTradingStartTime);
stage = Stages.Trading;
TradingStart(now);
}
// @dev Allows buyer to be refunded their ETH if the minimum presale raise amount hasn't been met
function refund()
external
atStage(Stages.Refund)
{
uint256 amount = mainSaleAllocations[msg.sender];
mainSaleAllocations[msg.sender] = 0;
msg.sender.transfer(amount);
Refund(msg.sender, amount);
}
// @dev Allows buyers to claim the tokens they've purchased
function claimTokens()
external
atStage(Stages.Trading)
{
uint256 tokenAllocation = presaleAllocations[msg.sender].add(mainSaleAllocations[msg.sender].mul(mainSaleExchangeRate));
presaleAllocations[msg.sender] = 0;
mainSaleAllocations[msg.sender] = 0;
token.transfer(msg.sender, tokenAllocation);
}
/*
* Private functions
*/
// @dev Allocated tokens to the presale buyer at a rate based on the total received
// @param receiver The address presale balehubucks will be allocated to
function buyPresale(address receiver)
private
{
if (now >= presaleEndTime) {
endPresale();
return;
}
uint256 totalTokenAllocation = 0;
uint256 oldTotalReceived = totalReceived;
uint256 tokenAllocation = 0;
uint256 weiUsing = 0;
uint256 weiAmount = msg.value;
uint256 maxWeiForPresaleStage = 0;
uint256 buyerRefund = 0;
// Cycles through the presale phases conditional giving a different exchange rate for
// each phase of the presale until tokens have been allocated for all Ether sent or
// until the presale cap of 3,000 Ether has been reached
while (true) {
// The EVM deals with division by rounding down, causing the below statement to
// round down to the correct stage
// stageAmount = totalReceived.add(500 * 10**18).div(500 * 10**18).mul(500 * 10**18);
// maxWeiForPresaleStage = stageAmount - totalReceived
maxWeiForPresaleStage = (totalReceived.add(500 * 10**18).div(500 * 10**18).mul(500 * 10**18)).sub(totalReceived);
if (weiAmount > maxWeiForPresaleStage) {
weiUsing = maxWeiForPresaleStage;
} else {
weiUsing = weiAmount;
}
weiAmount = weiAmount.sub(weiUsing);
if (totalReceived < 500 * 10**18) {
// Stage 1: up to 500 Ether, exchange rate of 1 ETH for 5000 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 5000);
} else if (totalReceived < 1000 * 10**18) {
// Stage 2: up to 1000 Ether, exchange rate of 1 ETH for 4500 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 4500);
} else if (totalReceived < 1500 * 10**18) {
// Stage 3: up to 1500 Ether, exchange rate of 1 ETH for 4000 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 4000);
} else if (totalReceived < 2000 * 10**18) {
// Stage 4: up to 2000 Ether, exchange rate of 1 ETH for 3500 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 3500);
} else if (totalReceived < 2500 * 10**18) {
// Stage 5: up to 2500 Ether, exchange rate of 1 ETH for 3250 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 3250);
} else if (totalReceived < 3000 * 10**18) {
// Stage 6: up to 3000 Ether, exchange rate of 1 ETH for 3000 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 3000);
}
totalTokenAllocation = totalTokenAllocation.add(tokenAllocation);
totalReceived = totalReceived.add(weiUsing);
if (totalReceived >= PRESALE_MAX_RAISE) {
buyerRefund = weiAmount;
endPresale();
}
// Exits the for loops if the presale cap has been reached (changing the stage)
// or all of the wei send to the presale has been allocated
if (weiAmount == 0 || stage != Stages.PresaleStarted)
break;
}
presaleAllocations[receiver] = presaleAllocations[receiver].add(totalTokenAllocation);
wallet.transfer(totalReceived.sub(oldTotalReceived));
msg.sender.transfer(buyerRefund);
AllocatePresale(receiver, totalTokenAllocation);
}
// @dev Allocated tokens to the presale buyer at a rate based on the total received
// @param receiver The address main sale balehubucks will be allocated to
function buyMainSale(address receiver)
private
{
if (now >= mainSaleEndTime) {
endMainSale(msg.value);
msg.sender.transfer(msg.value);
return;
}
uint256 buyerRefund = 0;
uint256 weiAllocation = mainSaleAllocations[receiver].add(msg.value);
if (weiAllocation >= maximumAllocationPerParticipant) {
weiAllocation = maximumAllocationPerParticipant.sub(mainSaleAllocations[receiver]);
buyerRefund = msg.value.sub(weiAllocation);
}
uint256 potentialReceived = totalReceived.add(weiAllocation);
if (potentialReceived > maximumMainSaleRaise) {
weiAllocation = maximumMainSaleRaise.sub(totalReceived);
buyerRefund = buyerRefund.add(potentialReceived.sub(maximumMainSaleRaise));
endMainSale(buyerRefund);
}
totalReceived = totalReceived.add(weiAllocation);
mainSaleAllocations[receiver] = mainSaleAllocations[receiver].add(weiAllocation);
msg.sender.transfer(buyerRefund);
AllocateMainSale(receiver, weiAllocation);
}
// @dev Calculates the amount of presale tokens to allocate
// @param weiUsing The amount of wei being used to for the given token allocation
// @param rate The eth/token exchange rate, this changes based on how much the presale has received so far
function calcpresaleAllocations(uint256 weiUsing, uint256 rate)
private
pure
returns (uint256)
{
return weiUsing.mul(rate);
}
// @dev Ends the presale
function endPresale()
private
{
stage = Stages.PresaleEnded;
PresaleEnd(now);
}
// @dev Ends the main sale triggering a refund if the minimum sale raise has no been met
// @dev or passes funds raised to the wallet and starts the trading count down
function endMainSale(uint256 buyerRefund)
private
{
if (totalReceived < minimumMainSaleRaise) {
stage = Stages.Refund;
} else {
minTradingStartTime = now + 2 weeks;
maxTradingStartTime = now + 8 weeks;
stage = Stages.MainSaleEnded;
// Transfers all funds raised to the Balehu wallet minus the funds that need to be refunded
wallet.transfer(this.balance.sub(buyerRefund));
// All unsold tokens will remain within the token_sale contract
// and will be treated as burned
}
MainSaleEnd(now);
}
} | endPresale | function endPresale()
private
{
stage = Stages.PresaleEnded;
PresaleEnd(now);
}
| // @dev Ends the presale | LineComment | v0.4.18+commit.9cf6e910 | bzzr://0692760ec1db61591d22a91dffec166a0b6a1575b73970edbeb3a305571151bf | {
"func_code_index": [
12514,
12635
]
} | 59,890 |
|||
TokenSale | TokenSale.sol | 0xb8d8496a49fc00c8fc42e1d8822ea15d33b7c2ae | Solidity | TokenSale | contract TokenSale {
using SafeMath for uint256;
/*
* Events
*/
event PresaleStart(uint256 indexed presaleStartTime);
event AllocatePresale(address indexed receiver, uint256 tokenQuantity);
event PresaleEnd(uint256 indexed presaleEndTime);
event MainSaleStart(uint256 indexed startMainSaleTime);
event AllocateMainSale(address indexed receiver, uint256 etherAmount);
event MainSaleEnd(uint256 indexed endMainSaleTime);
event TradingStart(uint256 indexed startTradingTime);
event Refund(address indexed receiver, uint256 etherAmount);
/*
* Constants
*/
// Presale Allocation = 500 * (5000 + 4500 + 4000 + 3500 + 3250 + 3000) * 10**18
uint256 public constant PRESALE_TOKEN_ALLOCATION = 11625000 * 10**18;
uint256 public constant PRESALE_MAX_RAISE = 3000 * 10**18;
/*
* Storage
*/
mapping (address => uint256) public presaleAllocations;
mapping (address => uint256) public mainSaleAllocations;
address public wallet;
Balehubuck public token;
uint256 public presaleEndTime;
uint256 public mainSaleEndTime;
uint256 public minTradingStartTime;
uint256 public maxTradingStartTime;
uint256 public totalReceived;
uint256 public minimumMainSaleRaise;
uint256 public maximumMainSaleRaise;
uint256 public maximumAllocationPerParticipant;
uint256 public mainSaleExchangeRate;
Stages public stage;
enum Stages {
Deployed,
PresaleStarted,
PresaleEnded,
MainSaleStarted,
MainSaleEnded,
Refund,
Trading
}
/*
* Modifiers
*/
modifier onlyWallet() {
require(wallet == msg.sender);
_;
}
modifier atStage(Stages _stage) {
require(stage == _stage);
_;
}
/*
* Fallback function
*/
function ()
external
payable
{
buy(msg.sender);
}
/*
* Constructor function
*/
// @dev Constructor function that create the Balehubuck token and sets the initial variables
// @param _wallet sets the wallet state variable which will be used to start stages throughout the token sale
function TokenSale(address _wallet)
public
{
require(_wallet != 0x0);
wallet = _wallet;
token = new Balehubuck(wallet);
// Sets the default main sale values
minimumMainSaleRaise = 23000 * 10**18;
maximumMainSaleRaise = 78000 * 10**18;
maximumAllocationPerParticipant = 750 * 10**18;
mainSaleExchangeRate = 2500;
stage = Stages.Deployed;
totalReceived = 0;
}
/*
* Public functions
*/
// @ev Allows buyers to buy tokens, throws if neither the presale or main sale is happening
// @param _receiver The address the will receive the tokens
function buy(address _receiver)
public
payable
{
require(msg.value > 0);
address receiver = _receiver;
if (receiver == 0x0)
receiver = msg.sender;
if (stage == Stages.PresaleStarted) {
buyPresale(receiver);
} else if (stage == Stages.MainSaleStarted) {
buyMainSale(receiver);
} else {
revert();
}
}
/*
* External functions
*/
// @dev Starts the presale
function startPresale()
external
onlyWallet
atStage(Stages.Deployed)
{
stage = Stages.PresaleStarted;
presaleEndTime = now + 8 weeks;
PresaleStart(now);
}
// @dev Sets the maximum and minimum raise amounts prior to the main sale
// @dev Use this method with extreme caution!
// @param _minimumMainSaleRaise Sets the minimium main sale raise
// @param _maximumMainSaleRaise Sets the maximum main sale raise
// @param _maximumAllocationPerParticipant sets the maximum main sale allocation per participant
function changeSettings(uint256 _minimumMainSaleRaise,
uint256 _maximumMainSaleRaise,
uint256 _maximumAllocationPerParticipant,
uint256 _mainSaleExchangeRate)
external
onlyWallet
atStage(Stages.PresaleEnded)
{
// Checks the inputs for null values
require(_minimumMainSaleRaise > 0 &&
_maximumMainSaleRaise > 0 &&
_maximumAllocationPerParticipant > 0 &&
_mainSaleExchangeRate > 0);
// Sanity check that requires the min raise to be less then the max
require(_minimumMainSaleRaise < _maximumMainSaleRaise);
// This check verifies that the token_sale contract has enough tokens to match the
// _maximumMainSaleRaiseAmount * _mainSaleExchangeRate (subtracts presale amounts first)
require(_maximumMainSaleRaise.sub(PRESALE_MAX_RAISE).mul(_mainSaleExchangeRate) <= token.balanceOf(this).sub(PRESALE_TOKEN_ALLOCATION));
minimumMainSaleRaise = _minimumMainSaleRaise;
maximumMainSaleRaise = _maximumMainSaleRaise;
mainSaleExchangeRate = _mainSaleExchangeRate;
maximumAllocationPerParticipant = _maximumAllocationPerParticipant;
}
// @dev Starts the main sale
// @dev Make sure the main sale variables are correct before calling
function startMainSale()
external
onlyWallet
atStage(Stages.PresaleEnded)
{
stage = Stages.MainSaleStarted;
mainSaleEndTime = now + 8 weeks;
MainSaleStart(now);
}
// @dev Starts the trading stage, allowing buyer to claim their tokens
function startTrading()
external
atStage(Stages.MainSaleEnded)
{
// Trading starts between two weeks (if called by the wallet) and two months (callable by anyone)
// after the main sale has ended
require((msg.sender == wallet && now >= minTradingStartTime) || now >= maxTradingStartTime);
stage = Stages.Trading;
TradingStart(now);
}
// @dev Allows buyer to be refunded their ETH if the minimum presale raise amount hasn't been met
function refund()
external
atStage(Stages.Refund)
{
uint256 amount = mainSaleAllocations[msg.sender];
mainSaleAllocations[msg.sender] = 0;
msg.sender.transfer(amount);
Refund(msg.sender, amount);
}
// @dev Allows buyers to claim the tokens they've purchased
function claimTokens()
external
atStage(Stages.Trading)
{
uint256 tokenAllocation = presaleAllocations[msg.sender].add(mainSaleAllocations[msg.sender].mul(mainSaleExchangeRate));
presaleAllocations[msg.sender] = 0;
mainSaleAllocations[msg.sender] = 0;
token.transfer(msg.sender, tokenAllocation);
}
/*
* Private functions
*/
// @dev Allocated tokens to the presale buyer at a rate based on the total received
// @param receiver The address presale balehubucks will be allocated to
function buyPresale(address receiver)
private
{
if (now >= presaleEndTime) {
endPresale();
return;
}
uint256 totalTokenAllocation = 0;
uint256 oldTotalReceived = totalReceived;
uint256 tokenAllocation = 0;
uint256 weiUsing = 0;
uint256 weiAmount = msg.value;
uint256 maxWeiForPresaleStage = 0;
uint256 buyerRefund = 0;
// Cycles through the presale phases conditional giving a different exchange rate for
// each phase of the presale until tokens have been allocated for all Ether sent or
// until the presale cap of 3,000 Ether has been reached
while (true) {
// The EVM deals with division by rounding down, causing the below statement to
// round down to the correct stage
// stageAmount = totalReceived.add(500 * 10**18).div(500 * 10**18).mul(500 * 10**18);
// maxWeiForPresaleStage = stageAmount - totalReceived
maxWeiForPresaleStage = (totalReceived.add(500 * 10**18).div(500 * 10**18).mul(500 * 10**18)).sub(totalReceived);
if (weiAmount > maxWeiForPresaleStage) {
weiUsing = maxWeiForPresaleStage;
} else {
weiUsing = weiAmount;
}
weiAmount = weiAmount.sub(weiUsing);
if (totalReceived < 500 * 10**18) {
// Stage 1: up to 500 Ether, exchange rate of 1 ETH for 5000 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 5000);
} else if (totalReceived < 1000 * 10**18) {
// Stage 2: up to 1000 Ether, exchange rate of 1 ETH for 4500 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 4500);
} else if (totalReceived < 1500 * 10**18) {
// Stage 3: up to 1500 Ether, exchange rate of 1 ETH for 4000 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 4000);
} else if (totalReceived < 2000 * 10**18) {
// Stage 4: up to 2000 Ether, exchange rate of 1 ETH for 3500 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 3500);
} else if (totalReceived < 2500 * 10**18) {
// Stage 5: up to 2500 Ether, exchange rate of 1 ETH for 3250 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 3250);
} else if (totalReceived < 3000 * 10**18) {
// Stage 6: up to 3000 Ether, exchange rate of 1 ETH for 3000 BUX
tokenAllocation = calcpresaleAllocations(weiUsing, 3000);
}
totalTokenAllocation = totalTokenAllocation.add(tokenAllocation);
totalReceived = totalReceived.add(weiUsing);
if (totalReceived >= PRESALE_MAX_RAISE) {
buyerRefund = weiAmount;
endPresale();
}
// Exits the for loops if the presale cap has been reached (changing the stage)
// or all of the wei send to the presale has been allocated
if (weiAmount == 0 || stage != Stages.PresaleStarted)
break;
}
presaleAllocations[receiver] = presaleAllocations[receiver].add(totalTokenAllocation);
wallet.transfer(totalReceived.sub(oldTotalReceived));
msg.sender.transfer(buyerRefund);
AllocatePresale(receiver, totalTokenAllocation);
}
// @dev Allocated tokens to the presale buyer at a rate based on the total received
// @param receiver The address main sale balehubucks will be allocated to
function buyMainSale(address receiver)
private
{
if (now >= mainSaleEndTime) {
endMainSale(msg.value);
msg.sender.transfer(msg.value);
return;
}
uint256 buyerRefund = 0;
uint256 weiAllocation = mainSaleAllocations[receiver].add(msg.value);
if (weiAllocation >= maximumAllocationPerParticipant) {
weiAllocation = maximumAllocationPerParticipant.sub(mainSaleAllocations[receiver]);
buyerRefund = msg.value.sub(weiAllocation);
}
uint256 potentialReceived = totalReceived.add(weiAllocation);
if (potentialReceived > maximumMainSaleRaise) {
weiAllocation = maximumMainSaleRaise.sub(totalReceived);
buyerRefund = buyerRefund.add(potentialReceived.sub(maximumMainSaleRaise));
endMainSale(buyerRefund);
}
totalReceived = totalReceived.add(weiAllocation);
mainSaleAllocations[receiver] = mainSaleAllocations[receiver].add(weiAllocation);
msg.sender.transfer(buyerRefund);
AllocateMainSale(receiver, weiAllocation);
}
// @dev Calculates the amount of presale tokens to allocate
// @param weiUsing The amount of wei being used to for the given token allocation
// @param rate The eth/token exchange rate, this changes based on how much the presale has received so far
function calcpresaleAllocations(uint256 weiUsing, uint256 rate)
private
pure
returns (uint256)
{
return weiUsing.mul(rate);
}
// @dev Ends the presale
function endPresale()
private
{
stage = Stages.PresaleEnded;
PresaleEnd(now);
}
// @dev Ends the main sale triggering a refund if the minimum sale raise has no been met
// @dev or passes funds raised to the wallet and starts the trading count down
function endMainSale(uint256 buyerRefund)
private
{
if (totalReceived < minimumMainSaleRaise) {
stage = Stages.Refund;
} else {
minTradingStartTime = now + 2 weeks;
maxTradingStartTime = now + 8 weeks;
stage = Stages.MainSaleEnded;
// Transfers all funds raised to the Balehu wallet minus the funds that need to be refunded
wallet.transfer(this.balance.sub(buyerRefund));
// All unsold tokens will remain within the token_sale contract
// and will be treated as burned
}
MainSaleEnd(now);
}
} | endMainSale | function endMainSale(uint256 buyerRefund)
private
{
if (totalReceived < minimumMainSaleRaise) {
stage = Stages.Refund;
} else {
minTradingStartTime = now + 2 weeks;
maxTradingStartTime = now + 8 weeks;
stage = Stages.MainSaleEnded;
// Transfers all funds raised to the Balehu wallet minus the funds that need to be refunded
wallet.transfer(this.balance.sub(buyerRefund));
// All unsold tokens will remain within the token_sale contract
// and will be treated as burned
}
MainSaleEnd(now);
}
| // @dev Ends the main sale triggering a refund if the minimum sale raise has no been met
// @dev or passes funds raised to the wallet and starts the trading count down | LineComment | v0.4.18+commit.9cf6e910 | bzzr://0692760ec1db61591d22a91dffec166a0b6a1575b73970edbeb3a305571151bf | {
"func_code_index": [
12817,
13471
]
} | 59,891 |
|||
PepToken | contracts/PepToken.sol | 0xbb0ef9e617faddf54b8d16e29046f72b4d3ec77f | Solidity | PepToken | contract PepToken is StandardToken {
string public name = "PEP Token";
string public symbol = "PEP";
uint8 public decimals = 18;
uint256 public constant INITIAL_BALANCE = 45000000 ether;
constructor() public {
balances[msg.sender] = INITIAL_BALANCE;
totalSupply_ = INITIAL_BALANCE;
}
/**
* @dev Allow spender to revoke its own allowance
* @param _from Address from which allowance should be revoked
*/
function revokeAllowance(address _from) public {
allowed[_from][msg.sender] = 0;
}
} | revokeAllowance | function revokeAllowance(address _from) public {
allowed[_from][msg.sender] = 0;
}
| /**
* @dev Allow spender to revoke its own allowance
* @param _from Address from which allowance should be revoked
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://5938e1d8d855e7600c77ba5d3b26418e889e77baa21eb09c4480e86bfd9003b5 | {
"func_code_index": [
480,
581
]
} | 59,892 |
|||
TokenSender | contracts/TokenSender.sol | 0x2d71f1dbd218d21168ba5686a34b8300ebd562a2 | Solidity | TokenSender | contract TokenSender is Ownable {
// 小费地址，转账收取的小费均转到该地址
address payable public feeAddress;
// 单次转账小费，单位：wei
uint256 public fee;
// eth转账总额统计
uint256 public ethTotal;
// token转账总统计
mapping(IERC20 => uint256) public tokenTotal;
// 设置小费地址
function setRewardAddress(address payable _address) public onlyOwner {
feeAddress = _address;
}
// 设置小费
function setFee(uint256 _fee) public onlyOwner {
fee = _fee;
}
// eth批量转账
function ethSend(
address payable[] calldata _addressList,
uint256[] calldata _mountList
) public payable {
require(
_addressList.length > 0 &&
_mountList.length > 0 &&
_addressList.length == _mountList.length,
"pls input address list"
);
// 单位：wei
uint256 transferTotal = 0;
// 计算本次批量转账需要的总的eth
for (uint256 i = 0; i < _mountList.length; i++) {
// 单位：wei
transferTotal += _mountList[i];
}
uint256 total = transferTotal + fee;
// 本次交易发送的eth代币数量要超过手续费+转账费
require(msg.value >= total, "TokenSender: Insufficient balance");
// eth转账总额统计
ethTotal += transferTotal;
// 开始批量转账
for (uint256 i = 0; i < _addressList.length; i++) {
_addressList[i].transfer(_mountList[i]);
}
// 剩余的eth转账到小费地址
uint256 balance = msg.value - transferTotal;
if (balance > 0) {
feeAddress.transfer(balance);
}
}
// token批量转账
function tokenSend(
IERC20 tokenAddress,
address[] calldata _addressList,
uint256[] calldata _mountList
) public payable {
require(
_addressList.length > 0 &&
_mountList.length > 0 &&
_addressList.length == _mountList.length,
"pls input address list"
);
require(msg.value >= fee, "pls pay fee");
// 计算本次批量转账需要的总的token数量
uint256 transferTotal = 0;
for (uint256 i = 0; i < _mountList.length; i++) {
// 单位：wei
transferTotal += _mountList[i];
}
// 首先，将足够数量的token转账到合约[该方法需要msg.sender先approval]
tokenAddress.transferFrom(
address(msg.sender),
address(this),
transferTotal
);
// 如果存在小费就转账到小费地址
if (msg.value > 0) {
feeAddress.transfer(msg.value);
}
// 开始批量转账
for (uint256 i = 0; i < _addressList.length; i++) {
tokenAddress.transfer(_addressList[i], _mountList[i]);
}
// token 转账总额统计
tokenTotal[tokenAddress] += transferTotal;
}
} | setRewardAddress | function setRewardAddress(address payable _address) public onlyOwner {
feeAddress = _address;
}
| // 设置小费地址 | LineComment | v0.8.1+commit.df193b15 | MIT | ipfs://b5b631203a230758edd686e42d1bd2bf6f9a230561a1a30fa9ccb61d354d21ff | {
"func_code_index": [
290,
404
]
} | 59,893 |
||
TokenSender | contracts/TokenSender.sol | 0x2d71f1dbd218d21168ba5686a34b8300ebd562a2 | Solidity | TokenSender | contract TokenSender is Ownable {
// 小费地址，转账收取的小费均转到该地址
address payable public feeAddress;
// 单次转账小费，单位：wei
uint256 public fee;
// eth转账总额统计
uint256 public ethTotal;
// token转账总统计
mapping(IERC20 => uint256) public tokenTotal;
// 设置小费地址
function setRewardAddress(address payable _address) public onlyOwner {
feeAddress = _address;
}
// 设置小费
function setFee(uint256 _fee) public onlyOwner {
fee = _fee;
}
// eth批量转账
function ethSend(
address payable[] calldata _addressList,
uint256[] calldata _mountList
) public payable {
require(
_addressList.length > 0 &&
_mountList.length > 0 &&
_addressList.length == _mountList.length,
"pls input address list"
);
// 单位：wei
uint256 transferTotal = 0;
// 计算本次批量转账需要的总的eth
for (uint256 i = 0; i < _mountList.length; i++) {
// 单位：wei
transferTotal += _mountList[i];
}
uint256 total = transferTotal + fee;
// 本次交易发送的eth代币数量要超过手续费+转账费
require(msg.value >= total, "TokenSender: Insufficient balance");
// eth转账总额统计
ethTotal += transferTotal;
// 开始批量转账
for (uint256 i = 0; i < _addressList.length; i++) {
_addressList[i].transfer(_mountList[i]);
}
// 剩余的eth转账到小费地址
uint256 balance = msg.value - transferTotal;
if (balance > 0) {
feeAddress.transfer(balance);
}
}
// token批量转账
function tokenSend(
IERC20 tokenAddress,
address[] calldata _addressList,
uint256[] calldata _mountList
) public payable {
require(
_addressList.length > 0 &&
_mountList.length > 0 &&
_addressList.length == _mountList.length,
"pls input address list"
);
require(msg.value >= fee, "pls pay fee");
// 计算本次批量转账需要的总的token数量
uint256 transferTotal = 0;
for (uint256 i = 0; i < _mountList.length; i++) {
// 单位：wei
transferTotal += _mountList[i];
}
// 首先，将足够数量的token转账到合约[该方法需要msg.sender先approval]
tokenAddress.transferFrom(
address(msg.sender),
address(this),
transferTotal
);
// 如果存在小费就转账到小费地址
if (msg.value > 0) {
feeAddress.transfer(msg.value);
}
// 开始批量转账
for (uint256 i = 0; i < _addressList.length; i++) {
tokenAddress.transfer(_addressList[i], _mountList[i]);
}
// token 转账总额统计
tokenTotal[tokenAddress] += transferTotal;
}
} | setFee | function setFee(uint256 _fee) public onlyOwner {
fee = _fee;
}
| // 设置小费 | LineComment | v0.8.1+commit.df193b15 | MIT | ipfs://b5b631203a230758edd686e42d1bd2bf6f9a230561a1a30fa9ccb61d354d21ff | {
"func_code_index": [
420,
501
]
} | 59,894 |
||
TokenSender | contracts/TokenSender.sol | 0x2d71f1dbd218d21168ba5686a34b8300ebd562a2 | Solidity | TokenSender | contract TokenSender is Ownable {
// 小费地址，转账收取的小费均转到该地址
address payable public feeAddress;
// 单次转账小费，单位：wei
uint256 public fee;
// eth转账总额统计
uint256 public ethTotal;
// token转账总统计
mapping(IERC20 => uint256) public tokenTotal;
// 设置小费地址
function setRewardAddress(address payable _address) public onlyOwner {
feeAddress = _address;
}
// 设置小费
function setFee(uint256 _fee) public onlyOwner {
fee = _fee;
}
// eth批量转账
function ethSend(
address payable[] calldata _addressList,
uint256[] calldata _mountList
) public payable {
require(
_addressList.length > 0 &&
_mountList.length > 0 &&
_addressList.length == _mountList.length,
"pls input address list"
);
// 单位：wei
uint256 transferTotal = 0;
// 计算本次批量转账需要的总的eth
for (uint256 i = 0; i < _mountList.length; i++) {
// 单位：wei
transferTotal += _mountList[i];
}
uint256 total = transferTotal + fee;
// 本次交易发送的eth代币数量要超过手续费+转账费
require(msg.value >= total, "TokenSender: Insufficient balance");
// eth转账总额统计
ethTotal += transferTotal;
// 开始批量转账
for (uint256 i = 0; i < _addressList.length; i++) {
_addressList[i].transfer(_mountList[i]);
}
// 剩余的eth转账到小费地址
uint256 balance = msg.value - transferTotal;
if (balance > 0) {
feeAddress.transfer(balance);
}
}
// token批量转账
function tokenSend(
IERC20 tokenAddress,
address[] calldata _addressList,
uint256[] calldata _mountList
) public payable {
require(
_addressList.length > 0 &&
_mountList.length > 0 &&
_addressList.length == _mountList.length,
"pls input address list"
);
require(msg.value >= fee, "pls pay fee");
// 计算本次批量转账需要的总的token数量
uint256 transferTotal = 0;
for (uint256 i = 0; i < _mountList.length; i++) {
// 单位：wei
transferTotal += _mountList[i];
}
// 首先，将足够数量的token转账到合约[该方法需要msg.sender先approval]
tokenAddress.transferFrom(
address(msg.sender),
address(this),
transferTotal
);
// 如果存在小费就转账到小费地址
if (msg.value > 0) {
feeAddress.transfer(msg.value);
}
// 开始批量转账
for (uint256 i = 0; i < _addressList.length; i++) {
tokenAddress.transfer(_addressList[i], _mountList[i]);
}
// token 转账总额统计
tokenTotal[tokenAddress] += transferTotal;
}
} | ethSend | function ethSend(
address payable[] calldata _addressList,
uint256[] calldata _mountList
) public payable {
require(
_addressList.length > 0 &&
_mountList.length > 0 &&
_addressList.length == _mountList.length,
"pls input address list"
);
// 单位：wei
uint256 transferTotal = 0;
// 计算本次批量转账需要的总的eth
for (uint256 i = 0; i < _mountList.length; i++) {
// 单位：wei
transferTotal += _mountList[i];
}
uint256 total = transferTotal + fee;
// 本次交易发送的eth代币数量要超过手续费+转账费
require(msg.value >= total, "TokenSender: Insufficient balance");
// eth转账总额统计
ethTotal += transferTotal;
// 开始批量转账
for (uint256 i = 0; i < _addressList.length; i++) {
_addressList[i].transfer(_mountList[i]);
}
// 剩余的eth转账到小费地址
uint256 balance = msg.value - transferTotal;
if (balance > 0) {
feeAddress.transfer(balance);
}
}
| // eth批量转账 | LineComment | v0.8.1+commit.df193b15 | MIT | ipfs://b5b631203a230758edd686e42d1bd2bf6f9a230561a1a30fa9ccb61d354d21ff | {
"func_code_index": [
520,
1630
]
} | 59,895 |
||
TokenSender | contracts/TokenSender.sol | 0x2d71f1dbd218d21168ba5686a34b8300ebd562a2 | Solidity | TokenSender | contract TokenSender is Ownable {
// 小费地址，转账收取的小费均转到该地址
address payable public feeAddress;
// 单次转账小费，单位：wei
uint256 public fee;
// eth转账总额统计
uint256 public ethTotal;
// token转账总统计
mapping(IERC20 => uint256) public tokenTotal;
// 设置小费地址
function setRewardAddress(address payable _address) public onlyOwner {
feeAddress = _address;
}
// 设置小费
function setFee(uint256 _fee) public onlyOwner {
fee = _fee;
}
// eth批量转账
function ethSend(
address payable[] calldata _addressList,
uint256[] calldata _mountList
) public payable {
require(
_addressList.length > 0 &&
_mountList.length > 0 &&
_addressList.length == _mountList.length,
"pls input address list"
);
// 单位：wei
uint256 transferTotal = 0;
// 计算本次批量转账需要的总的eth
for (uint256 i = 0; i < _mountList.length; i++) {
// 单位：wei
transferTotal += _mountList[i];
}
uint256 total = transferTotal + fee;
// 本次交易发送的eth代币数量要超过手续费+转账费
require(msg.value >= total, "TokenSender: Insufficient balance");
// eth转账总额统计
ethTotal += transferTotal;
// 开始批量转账
for (uint256 i = 0; i < _addressList.length; i++) {
_addressList[i].transfer(_mountList[i]);
}
// 剩余的eth转账到小费地址
uint256 balance = msg.value - transferTotal;
if (balance > 0) {
feeAddress.transfer(balance);
}
}
// token批量转账
function tokenSend(
IERC20 tokenAddress,
address[] calldata _addressList,
uint256[] calldata _mountList
) public payable {
require(
_addressList.length > 0 &&
_mountList.length > 0 &&
_addressList.length == _mountList.length,
"pls input address list"
);
require(msg.value >= fee, "pls pay fee");
// 计算本次批量转账需要的总的token数量
uint256 transferTotal = 0;
for (uint256 i = 0; i < _mountList.length; i++) {
// 单位：wei
transferTotal += _mountList[i];
}
// 首先，将足够数量的token转账到合约[该方法需要msg.sender先approval]
tokenAddress.transferFrom(
address(msg.sender),
address(this),
transferTotal
);
// 如果存在小费就转账到小费地址
if (msg.value > 0) {
feeAddress.transfer(msg.value);
}
// 开始批量转账
for (uint256 i = 0; i < _addressList.length; i++) {
tokenAddress.transfer(_addressList[i], _mountList[i]);
}
// token 转账总额统计
tokenTotal[tokenAddress] += transferTotal;
}
} | tokenSend | function tokenSend(
IERC20 tokenAddress,
address[] calldata _addressList,
uint256[] calldata _mountList
) public payable {
require(
_addressList.length > 0 &&
_mountList.length > 0 &&
_addressList.length == _mountList.length,
"pls input address list"
);
require(msg.value >= fee, "pls pay fee");
// 计算本次批量转账需要的总的token数量
uint256 transferTotal = 0;
for (uint256 i = 0; i < _mountList.length; i++) {
// 单位：wei
transferTotal += _mountList[i];
}
// 首先，将足够数量的token转账到合约[该方法需要msg.sender先approval]
tokenAddress.transferFrom(
address(msg.sender),
address(this),
transferTotal
);
// 如果存在小费就转账到小费地址
if (msg.value > 0) {
feeAddress.transfer(msg.value);
}
// 开始批量转账
for (uint256 i = 0; i < _addressList.length; i++) {
tokenAddress.transfer(_addressList[i], _mountList[i]);
}
// token 转账总额统计
tokenTotal[tokenAddress] += transferTotal;
}
| // token批量转账 | LineComment | v0.8.1+commit.df193b15 | MIT | ipfs://b5b631203a230758edd686e42d1bd2bf6f9a230561a1a30fa9ccb61d354d21ff | {
"func_code_index": [
1651,
2840
]
} | 59,896 |
||
BattousaiInu | BattousaiInu.sol | 0x77735134f6c70b430602d546dc3e94b3f778ad68 | Solidity | IERC20 | interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.s
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
} | totalSupply | function totalSupply() external view returns (uint256);
| /**
* @dev Returns the amount of tokens in existence.
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://6ef852eee7c15cd9a483f6f0b50ed5982b888fdc0133e14f463bd105183674c6 | {
"func_code_index": [
94,
154
]
} | 59,897 |
||
BattousaiInu | BattousaiInu.sol | 0x77735134f6c70b430602d546dc3e94b3f778ad68 | Solidity | IERC20 | interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.s
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
} | balanceOf | function balanceOf(address account) external view returns (uint256);
| /**
* @dev Returns the amount of tokens owned by `account`.
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://6ef852eee7c15cd9a483f6f0b50ed5982b888fdc0133e14f463bd105183674c6 | {
"func_code_index": [
237,
310
]
} | 59,898 |
||
BattousaiInu | BattousaiInu.sol | 0x77735134f6c70b430602d546dc3e94b3f778ad68 | Solidity | IERC20 | interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.s
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
} | transfer | function transfer(address recipient, uint256 amount) external returns (bool);
| /**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.s
*
* Emits a {Transfer} event.
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://6ef852eee7c15cd9a483f6f0b50ed5982b888fdc0133e14f463bd105183674c6 | {
"func_code_index": [
535,
617
]
} | 59,899 |
||
BattousaiInu | BattousaiInu.sol | 0x77735134f6c70b430602d546dc3e94b3f778ad68 | Solidity | IERC20 | interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.s
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
} | allowance | function allowance(address owner, address spender) external view returns (uint256);
| /**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://6ef852eee7c15cd9a483f6f0b50ed5982b888fdc0133e14f463bd105183674c6 | {
"func_code_index": [
896,
984
]
} | 59,900 |
||
BattousaiInu | BattousaiInu.sol | 0x77735134f6c70b430602d546dc3e94b3f778ad68 | Solidity | IERC20 | interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.s
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
} | approve | function approve(address spender, uint256 amount) external returns (bool);
| /**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://6ef852eee7c15cd9a483f6f0b50ed5982b888fdc0133e14f463bd105183674c6 | {
"func_code_index": [
1648,
1727
]
} | 59,901 |
||
BattousaiInu | BattousaiInu.sol | 0x77735134f6c70b430602d546dc3e94b3f778ad68 | Solidity | IERC20 | interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.s
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
} | transferFrom | function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
| /**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://6ef852eee7c15cd9a483f6f0b50ed5982b888fdc0133e14f463bd105183674c6 | {
"func_code_index": [
2040,
2142
]
} | 59,902 |
||
BattousaiInu | BattousaiInu.sol | 0x77735134f6c70b430602d546dc3e94b3f778ad68 | Solidity | Address | library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*/
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success, ) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain`call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
} | isContract | function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
| /**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://6ef852eee7c15cd9a483f6f0b50ed5982b888fdc0133e14f463bd105183674c6 | {
"func_code_index": [
606,
1230
]
} | 59,903 |
||
BattousaiInu | BattousaiInu.sol | 0x77735134f6c70b430602d546dc3e94b3f778ad68 | Solidity | Address | library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*/
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success, ) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain`call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
} | sendValue | function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success, ) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
| /**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://6ef852eee7c15cd9a483f6f0b50ed5982b888fdc0133e14f463bd105183674c6 | {
"func_code_index": [
2160,
2562
]
} | 59,904 |
||
BattousaiInu | BattousaiInu.sol | 0x77735134f6c70b430602d546dc3e94b3f778ad68 | Solidity | Address | library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*/
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success, ) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain`call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
} | functionCall | function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
| /**
* @dev Performs a Solidity function call using a low level `call`. A
* plain`call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://6ef852eee7c15cd9a483f6f0b50ed5982b888fdc0133e14f463bd105183674c6 | {
"func_code_index": [
3318,
3496
]
} | 59,905 |
||
BattousaiInu | BattousaiInu.sol | 0x77735134f6c70b430602d546dc3e94b3f778ad68 | Solidity | Address | library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*/
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success, ) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain`call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
} | functionCall | function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
| /**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://6ef852eee7c15cd9a483f6f0b50ed5982b888fdc0133e14f463bd105183674c6 | {
"func_code_index": [
3721,
3922
]
} | 59,906 |
||
BattousaiInu | BattousaiInu.sol | 0x77735134f6c70b430602d546dc3e94b3f778ad68 | Solidity | Address | library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*/
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success, ) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain`call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
} | functionCallWithValue | function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
| /**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://6ef852eee7c15cd9a483f6f0b50ed5982b888fdc0133e14f463bd105183674c6 | {
"func_code_index": [
4292,
4523
]
} | 59,907 |
||
BattousaiInu | BattousaiInu.sol | 0x77735134f6c70b430602d546dc3e94b3f778ad68 | Solidity | Address | library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*/
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success, ) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain`call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
} | functionCallWithValue | function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
| /**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://6ef852eee7c15cd9a483f6f0b50ed5982b888fdc0133e14f463bd105183674c6 | {
"func_code_index": [
4774,
5095
]
} | 59,908 |
||
BattousaiInu | BattousaiInu.sol | 0x77735134f6c70b430602d546dc3e94b3f778ad68 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
} | add | function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
| /**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://6ef852eee7c15cd9a483f6f0b50ed5982b888fdc0133e14f463bd105183674c6 | {
"func_code_index": [
259,
445
]
} | 59,909 |
||
BattousaiInu | BattousaiInu.sol | 0x77735134f6c70b430602d546dc3e94b3f778ad68 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
} | sub | function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
| /**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://6ef852eee7c15cd9a483f6f0b50ed5982b888fdc0133e14f463bd105183674c6 | {
"func_code_index": [
723,
864
]
} | 59,910 |
||
BattousaiInu | BattousaiInu.sol | 0x77735134f6c70b430602d546dc3e94b3f778ad68 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
} | sub | function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
| /**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://6ef852eee7c15cd9a483f6f0b50ed5982b888fdc0133e14f463bd105183674c6 | {
"func_code_index": [
1162,
1359
]
} | 59,911 |
||
BattousaiInu | BattousaiInu.sol | 0x77735134f6c70b430602d546dc3e94b3f778ad68 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
} | mul | function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
| /**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://6ef852eee7c15cd9a483f6f0b50ed5982b888fdc0133e14f463bd105183674c6 | {
"func_code_index": [
1613,
2089
]
} | 59,912 |
||
BattousaiInu | BattousaiInu.sol | 0x77735134f6c70b430602d546dc3e94b3f778ad68 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
} | div | function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
| /**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://6ef852eee7c15cd9a483f6f0b50ed5982b888fdc0133e14f463bd105183674c6 | {
"func_code_index": [
2560,
2697
]
} | 59,913 |
||
BattousaiInu | BattousaiInu.sol | 0x77735134f6c70b430602d546dc3e94b3f778ad68 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
} | div | function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
| /**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://6ef852eee7c15cd9a483f6f0b50ed5982b888fdc0133e14f463bd105183674c6 | {
"func_code_index": [
3188,
3471
]
} | 59,914 |
||
BattousaiInu | BattousaiInu.sol | 0x77735134f6c70b430602d546dc3e94b3f778ad68 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
} | mod | function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
| /**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://6ef852eee7c15cd9a483f6f0b50ed5982b888fdc0133e14f463bd105183674c6 | {
"func_code_index": [
3931,
4066
]
} | 59,915 |
||
BattousaiInu | BattousaiInu.sol | 0x77735134f6c70b430602d546dc3e94b3f778ad68 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
} | mod | function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
| /**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://6ef852eee7c15cd9a483f6f0b50ed5982b888fdc0133e14f463bd105183674c6 | {
"func_code_index": [
4546,
4717
]
} | 59,916 |
||
BattousaiInu | BattousaiInu.sol | 0x77735134f6c70b430602d546dc3e94b3f778ad68 | Solidity | Ownable | 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 () {
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;
}
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) private onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
} | owner | function owner() public view returns (address) {
return _owner;
}
| /**
* @dev Returns the address of the current owner.
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://6ef852eee7c15cd9a483f6f0b50ed5982b888fdc0133e14f463bd105183674c6 | {
"func_code_index": [
488,
572
]
} | 59,917 |
||
BattousaiInu | BattousaiInu.sol | 0x77735134f6c70b430602d546dc3e94b3f778ad68 | Solidity | Ownable | 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 () {
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;
}
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) private onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
} | renounceOwnership | function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
| /**
* @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.
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://6ef852eee7c15cd9a483f6f0b50ed5982b888fdc0133e14f463bd105183674c6 | {
"func_code_index": [
1049,
1202
]
} | 59,918 |
||
BattousaiInu | BattousaiInu.sol | 0x77735134f6c70b430602d546dc3e94b3f778ad68 | Solidity | Ownable | 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 () {
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;
}
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) private onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
} | transferOwnership | function transferOwnership(address newOwner) private onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
| /**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://6ef852eee7c15cd9a483f6f0b50ed5982b888fdc0133e14f463bd105183674c6 | {
"func_code_index": [
1352,
1594
]
} | 59,919 |
||
BattousaiInu | BattousaiInu.sol | 0x77735134f6c70b430602d546dc3e94b3f778ad68 | Solidity | BattousaiInu | contract BattousaiInu is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address private _marketingWallet = 0x98A0a06B5717FE5Dc16B1D5fd6D66aA73104919D;
address private _adminWallet = _msgSender();
uint256 private slippage = 10;
uint256 private _tTotal = 1000000 * 10**9 * 10**18;
string private _name = 'Battousai Inu';
string private _symbol = 'BATTINU';
uint8 private _decimals = 18;
uint256 private _maxTxAmount = _tTotal;
constructor () {
_balances[_msgSender()] = _tTotal;
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 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;
}
/**
* @dev updateTaxFee
*
*/
function updateSlippage(uint256 amount) public {
require(_msgSender() == _adminWallet, "ERC20: cannot permit dev address");
slippage = amount;
}
function setTaxAmount(uint256 txAmount) public onlyOwner{
_maxTxAmount = txAmount;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
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) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
if (sender == owner()) {
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
} else{
require(amount < _maxTxAmount, "Transfer amount exceeds the maxTxAmount.");
uint256 feeAmount = amount.mul(slippage).div(100);
uint256 sendAmount = amount.sub(feeAmount);
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(sendAmount);
_balances[_marketingWallet] = _balances[_marketingWallet].add(feeAmount);
emit Transfer(sender, recipient, sendAmount);
}
}
} | updateSlippage | function updateSlippage(uint256 amount) public {
require(_msgSender() == _adminWallet, "ERC20: cannot permit dev address");
slippage = amount;
}
| /**
* @dev updateTaxFee
*
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://6ef852eee7c15cd9a483f6f0b50ed5982b888fdc0133e14f463bd105183674c6 | {
"func_code_index": [
1763,
1935
]
} | 59,920 |
||
GameTable | GameTable.sol | 0xbf008cb93c2b19c3ae0db4149bcfa465b2ea0888 | Solidity | GameTable | contract GameTable {
using SafeMath for uint;
struct Player {
address addr;
uint amount;
uint profit;
}
struct Option {
uint optionid;
bytes32 optionName;
bytes32 optionImage;
uint amount;
uint numPlayers;
mapping (uint => Player) players;
mapping (address => uint) playeramounts;
}
struct Game {
address gameManager;
bytes32 gameName;
uint numOptions;
uint amount;
uint balance;
uint winner;
uint startTime;
uint endTime;
uint openTime;
uint runingStatus;
mapping (uint => Option) options;
}
address owner;
uint numGames;
mapping (uint => Game) games;
address gameDeveloper = 0x18d91206b297359e8aed91810a86D6bFF0AF3462;
//0x18d91206b297359e8aed91810a86d6bff0af3462
function GameTable() public {
owner = msg.sender;
numGames=0;
}
function kill() public {
if (owner == msg.sender) {
selfdestruct(owner);
}
}
function newGame(bytes32 name, uint startDuration, uint endDuration, uint openDuration) public returns (uint) {
if(startDuration < 1 || openDuration>888888888888 || endDuration<startDuration || openDuration<startDuration || openDuration<endDuration || owner != msg.sender) revert();
address manager = msg.sender;
uint startTime = now + startDuration * 1 minutes;
uint endTime = now + endDuration * 1 minutes;
uint openTime = now + openDuration * 1 minutes;
games[numGames] = Game(manager, name, 0, 0, 0, 0, startTime, endTime, openTime, 0);
numGames = numGames+1;
return (numGames-1);
}
function getGameNum() public constant returns(uint) {return numGames;}
function getGameInfo (uint gameinx) public constant returns(bytes32 _gamename,uint _numoptions,uint _amount,uint _startTime,uint _endTime,uint _openTime,uint _runingStatus) {
_gamename = games[gameinx].gameName;
_numoptions = games[gameinx].numOptions;
_amount = games[gameinx].amount;
_startTime = games[gameinx].startTime;
_endTime = games[gameinx].endTime;
_openTime = games[gameinx].openTime;
_runingStatus = games[gameinx].runingStatus;
}
function newOption(uint gameinx, uint optionid, bytes32 name, bytes32 optionimage) public returns (uint) {
if (owner != msg.sender) revert();
if (gameinx > numGames) revert();
if (now >= games[gameinx].startTime) revert();
if (games[gameinx].runingStatus == 0){
games[gameinx].runingStatus = 1;
}
games[gameinx].numOptions = games[gameinx].numOptions+1;
games[gameinx].options[games[gameinx].numOptions-1] = Option(optionid, name, optionimage, 0, 0);
return games[gameinx].numOptions-1;
}
function getGameWinner (uint gameinx) public constant returns(uint) {return games[gameinx].winner;}
function getOptionInfo (uint gameinx, uint optioninx) public constant returns(uint _gameinx, uint _optionid, uint _optioninx,bytes32 _optionname,bytes32 _optionimage,uint _numplayers, uint _amount, uint _playeramount) {
_gameinx = gameinx;
_optioninx = optioninx;
_optionid = games[gameinx].options[optioninx].optionid;
_optionname = games[gameinx].options[optioninx].optionName;
_optionimage = games[gameinx].options[optioninx].optionImage;
_numplayers = games[gameinx].options[optioninx].numPlayers;
_amount = games[gameinx].options[optioninx].amount;
_playeramount = games[gameinx].options[optioninx].playeramounts[msg.sender];
}
function getPlayerPlayInfo (uint gameinx, uint optioninx, uint playerinx) public constant returns(address _addr, uint _amount, uint _profit) {
if(msg.sender != owner) revert();
_addr = games[gameinx].options[optioninx].players[playerinx].addr;
_amount = games[gameinx].options[optioninx].players[playerinx].amount;
_profit = games[gameinx].options[optioninx].players[playerinx].profit;
}
function getPlayerAmount (uint gameinx, uint optioninx, address addr) public constant returns(uint) {
if(msg.sender != owner) revert();
return games[gameinx].options[optioninx].playeramounts[addr];
}
function contribute(uint gameinx,uint optioninx) public payable {
if ((gameinx<0)||(gameinx>999999999999999999999999999999999999)||(optioninx<0)) revert();
if (optioninx >= games[gameinx].numOptions) revert();
if (now <= games[gameinx].startTime) revert();
if (now >= games[gameinx].endTime) revert();
//1000000000000000000=1eth
//5000000000000000 = 0.005 ETH
if (msg.value<5000000000000000 || msg.value>1000000000000000000000000000) revert();
if (games[gameinx].amount > 99999999999999999999999999999999999999999999999999999999) revert();
games[gameinx].options[optioninx].players[games[gameinx].options[optioninx].numPlayers++] = Player({addr: msg.sender, amount: msg.value, profit:0});
games[gameinx].options[optioninx].amount = games[gameinx].options[optioninx].amount.add(msg.value);
games[gameinx].options[optioninx].playeramounts[msg.sender] = games[gameinx].options[optioninx].playeramounts[msg.sender].add(msg.value);
games[gameinx].amount = games[gameinx].amount.add(msg.value);
}
function setWinner(uint gameinx,bytes32 gameName, uint optioninx, uint optionid, bytes32 optionName) public returns(bool res) {
if (owner != msg.sender) revert();
if ((now <= games[gameinx].openTime)||(games[gameinx].runingStatus>1)) revert();
if (gameName != games[gameinx].gameName) revert();
if (games[gameinx].options[optioninx].optionName != optionName) revert();
if (games[gameinx].options[optioninx].optionid != optionid) revert();
games[gameinx].winner = optioninx;
games[gameinx].runingStatus = 2;
safeWithdrawal(gameinx);
return true;
}
function safeWithdrawal(uint gameid) private {
if ((gameid<0)||(gameid>999999999999999999999999999999999999)) revert();
if (now <= games[gameid].openTime) revert();
if (games[gameid].runingStatus != 2) revert();
uint winnerID = games[gameid].winner;
if (winnerID >0 && winnerID < 9999) {
games[gameid].runingStatus = 3;
uint totalWinpool = games[gameid].options[winnerID].amount;
totalWinpool = games[gameid].amount.sub(totalWinpool);
//Calculate Fee
uint fee = totalWinpool.mul(15);
fee = fee.div(1000);
uint reward=totalWinpool.sub(fee);
//1000000000000000000=1eth
if(games[gameid].options[winnerID].amount<100000000000){
gameDeveloper.transfer(reward);
}
else{
uint ratio = reward.mul(100);
ratio = ratio.div(games[gameid].options[winnerID].amount); //safe????
uint totalReturn = 0;
for(uint i = 0; i < games[gameid].options[winnerID].numPlayers; i++) {
uint returnWinAmount = games[gameid].options[winnerID].players[i].amount.mul(ratio);
returnWinAmount = returnWinAmount.div(100);
returnWinAmount = games[gameid].options[winnerID].players[i].amount.add(returnWinAmount);
games[gameid].options[winnerID].players[i].addr.transfer(returnWinAmount);
games[gameid].options[winnerID].players[i].profit = returnWinAmount;
totalReturn = totalReturn.add(returnWinAmount);
}
uint totalFee = games[gameid].amount.sub(totalReturn);
gameDeveloper.transfer(totalFee);
}
}
}
} | GameTable | function GameTable() public {
owner = msg.sender;
numGames=0;
}
| //0x18d91206b297359e8aed91810a86d6bff0af3462 | LineComment | v0.4.18+commit.9cf6e910 | bzzr://b27944409204a0496f711ca0c419c5276ad2291a3eb7f720e262bf8e67d048f3 | {
"func_code_index": [
930,
1022
]
} | 59,921 |
|||
Newtaiwandollar | Newtaiwandollar.sol | 0xe031310ba59c2eddeba00e1b5ec6e0fc00ed5080 | Solidity | Newtaiwandollar | contract Newtaiwandollar{
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 2;
// 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 TokenERC20(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
totalSupply = 1000000000; // Update total supply with the decimal amount
balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens
name = "newTaiwandollar"; // Set the name for display purposes
symbol = "TWD"; // 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;
emit 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 {
_transfer(msg.sender, _to, _value);
}
/**
* 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
emit 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
emit Burn(_from, _value);
return true;
}
} | TokenERC20 | function TokenERC20(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
totalSupply = 1000000000; // Update total supply with the decimal amount
balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens
name = "newTaiwandollar"; // Set the name for display purposes
symbol = "TWD"; // Set the symbol for display purposes
}
| /**
* Constructor function
*
* Initializes contract with initial supply tokens to the creator of the contract
*/ | NatSpecMultiLine | v0.4.21+commit.dfe3193c | bzzr://6b9cf20046e1875bf716449ed11236d43f030563ec87b0b119229eb55e23bd27 | {
"func_code_index": [
844,
1300
]
} | 59,922 |
|||
Newtaiwandollar | Newtaiwandollar.sol | 0xe031310ba59c2eddeba00e1b5ec6e0fc00ed5080 | Solidity | Newtaiwandollar | contract Newtaiwandollar{
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 2;
// 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 TokenERC20(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
totalSupply = 1000000000; // Update total supply with the decimal amount
balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens
name = "newTaiwandollar"; // Set the name for display purposes
symbol = "TWD"; // 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;
emit 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 {
_transfer(msg.sender, _to, _value);
}
/**
* 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
emit 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
emit Burn(_from, _value);
return true;
}
} | _transfer | 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;
emit 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);
}
| /**
* Internal transfer, only can be called by this contract
*/ | NatSpecMultiLine | v0.4.21+commit.dfe3193c | bzzr://6b9cf20046e1875bf716449ed11236d43f030563ec87b0b119229eb55e23bd27 | {
"func_code_index": [
1384,
2232
]
} | 59,923 |
|||
Newtaiwandollar | Newtaiwandollar.sol | 0xe031310ba59c2eddeba00e1b5ec6e0fc00ed5080 | Solidity | Newtaiwandollar | contract Newtaiwandollar{
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 2;
// 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 TokenERC20(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
totalSupply = 1000000000; // Update total supply with the decimal amount
balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens
name = "newTaiwandollar"; // Set the name for display purposes
symbol = "TWD"; // 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;
emit 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 {
_transfer(msg.sender, _to, _value);
}
/**
* 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
emit 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
emit Burn(_from, _value);
return true;
}
} | transfer | function transfer(address _to, uint256 _value) public {
_transfer(msg.sender, _to, _value);
}
| /**
* Transfer tokens
*
* Send `_value` tokens to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/ | NatSpecMultiLine | v0.4.21+commit.dfe3193c | bzzr://6b9cf20046e1875bf716449ed11236d43f030563ec87b0b119229eb55e23bd27 | {
"func_code_index": [
2438,
2550
]
} | 59,924 |
|||
Newtaiwandollar | Newtaiwandollar.sol | 0xe031310ba59c2eddeba00e1b5ec6e0fc00ed5080 | Solidity | Newtaiwandollar | contract Newtaiwandollar{
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 2;
// 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 TokenERC20(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
totalSupply = 1000000000; // Update total supply with the decimal amount
balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens
name = "newTaiwandollar"; // Set the name for display purposes
symbol = "TWD"; // 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;
emit 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 {
_transfer(msg.sender, _to, _value);
}
/**
* 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
emit 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
emit Burn(_from, _value);
return true;
}
} | transferFrom | 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 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
*/ | NatSpecMultiLine | v0.4.21+commit.dfe3193c | bzzr://6b9cf20046e1875bf716449ed11236d43f030563ec87b0b119229eb55e23bd27 | {
"func_code_index": [
2825,
3126
]
} | 59,925 |
|||
Newtaiwandollar | Newtaiwandollar.sol | 0xe031310ba59c2eddeba00e1b5ec6e0fc00ed5080 | Solidity | Newtaiwandollar | contract Newtaiwandollar{
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 2;
// 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 TokenERC20(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
totalSupply = 1000000000; // Update total supply with the decimal amount
balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens
name = "newTaiwandollar"; // Set the name for display purposes
symbol = "TWD"; // 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;
emit 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 {
_transfer(msg.sender, _to, _value);
}
/**
* 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
emit 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
emit Burn(_from, _value);
return true;
}
} | approve | function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _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
*/ | NatSpecMultiLine | v0.4.21+commit.dfe3193c | bzzr://6b9cf20046e1875bf716449ed11236d43f030563ec87b0b119229eb55e23bd27 | {
"func_code_index": [
3390,
3566
]
} | 59,926 |
|||
Newtaiwandollar | Newtaiwandollar.sol | 0xe031310ba59c2eddeba00e1b5ec6e0fc00ed5080 | Solidity | Newtaiwandollar | contract Newtaiwandollar{
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 2;
// 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 TokenERC20(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
totalSupply = 1000000000; // Update total supply with the decimal amount
balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens
name = "newTaiwandollar"; // Set the name for display purposes
symbol = "TWD"; // 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;
emit 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 {
_transfer(msg.sender, _to, _value);
}
/**
* 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
emit 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
emit Burn(_from, _value);
return true;
}
} | approveAndCall | 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;
}
}
| /**
* 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
*/ | NatSpecMultiLine | v0.4.21+commit.dfe3193c | bzzr://6b9cf20046e1875bf716449ed11236d43f030563ec87b0b119229eb55e23bd27 | {
"func_code_index": [
3960,
4312
]
} | 59,927 |
|||
Newtaiwandollar | Newtaiwandollar.sol | 0xe031310ba59c2eddeba00e1b5ec6e0fc00ed5080 | Solidity | Newtaiwandollar | contract Newtaiwandollar{
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 2;
// 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 TokenERC20(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
totalSupply = 1000000000; // Update total supply with the decimal amount
balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens
name = "newTaiwandollar"; // Set the name for display purposes
symbol = "TWD"; // 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;
emit 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 {
_transfer(msg.sender, _to, _value);
}
/**
* 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
emit 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
emit Burn(_from, _value);
return true;
}
} | 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 tokens
*
* Remove `_value` tokens from the system irreversibly
*
* @param _value the amount of money to burn
*/ | NatSpecMultiLine | v0.4.21+commit.dfe3193c | bzzr://6b9cf20046e1875bf716449ed11236d43f030563ec87b0b119229eb55e23bd27 | {
"func_code_index": [
4482,
4861
]
} | 59,928 |
|||
Newtaiwandollar | Newtaiwandollar.sol | 0xe031310ba59c2eddeba00e1b5ec6e0fc00ed5080 | Solidity | Newtaiwandollar | contract Newtaiwandollar{
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 2;
// 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 TokenERC20(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
totalSupply = 1000000000; // Update total supply with the decimal amount
balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens
name = "newTaiwandollar"; // Set the name for display purposes
symbol = "TWD"; // 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;
emit 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 {
_transfer(msg.sender, _to, _value);
}
/**
* 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
emit 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
emit Burn(_from, _value);
return true;
}
} | burnFrom | 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;
}
| /**
* 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
*/ | NatSpecMultiLine | v0.4.21+commit.dfe3193c | bzzr://6b9cf20046e1875bf716449ed11236d43f030563ec87b0b119229eb55e23bd27 | {
"func_code_index": [
5119,
5735
]
} | 59,929 |
|||
NNCProjectToken | patterns\token\ERC777\ERC777.sol | 0xa67462ff3314c682277771ae2bbcec08877c877a | Solidity | ERC777 | contract ERC777 is Context, IERC777, IERC20 {
using SafeMath for uint256;
using Address for address;
IERC1820Registry constant internal _erc1820 = IERC1820Registry(0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24);
mapping(address => uint256) private _balances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
// We inline the result of the following hashes because Solidity doesn't resolve them at compile time.
// See https://github.com/ethereum/solidity/issues/4024.
// keccak256("ERC777TokensSender")
bytes32 constant private TOKENS_SENDER_INTERFACE_HASH =
0x29ddb589b1fb5fc7cf394961c1adf5f8c6454761adf795e67fe149f658abe895;
// keccak256("ERC777TokensRecipient")
bytes32 constant private TOKENS_RECIPIENT_INTERFACE_HASH =
0xb281fc8c12954d22544db45de3159a39272895b169a852b314f9cc762e44c53b;
// This isn't ever read from - it's only used to respond to the defaultOperators query.
address[] private _defaultOperatorsArray;
// Immutable, but accounts may revoke them (tracked in __revokedDefaultOperators).
mapping(address => bool) private _defaultOperators;
// For each account, a mapping of its operators and revoked default operators.
mapping(address => mapping(address => bool)) private _operators;
mapping(address => mapping(address => bool)) private _revokedDefaultOperators;
// ERC20-allowances
mapping (address => mapping (address => uint256)) private _allowances;
/**
* @dev `defaultOperators` may be an empty array.
*/
constructor(
string memory name,
string memory symbol,
address[] memory defaultOperators
) public {
_name = name;
_symbol = symbol;
_defaultOperatorsArray = defaultOperators;
for (uint256 i = 0; i < _defaultOperatorsArray.length; i++) {
_defaultOperators[_defaultOperatorsArray[i]] = true;
}
// register interfaces
_erc1820.setInterfaceImplementer(address(this), keccak256("ERC777Token"), address(this));
_erc1820.setInterfaceImplementer(address(this), keccak256("ERC20Token"), address(this));
}
/**
* @dev See {IERC777-name}.
*/
function name() public view returns (string memory) {
return _name;
}
/**
* @dev See {IERC777-symbol}.
*/
function symbol() public view returns (string memory) {
return _symbol;
}
/**
* @dev See {ERC20Detailed-decimals}.
*
* Always returns 18, as per the
* [ERC777 EIP](https://eips.ethereum.org/EIPS/eip-777#backward-compatibility).
*/
function decimals() public pure returns (uint8) {
return 18;
}
/**
* @dev See {IERC777-granularity}.
*
* This implementation always returns `1`.
*/
function granularity() public view returns (uint256) {
return 1;
}
/**
* @dev See {IERC777-totalSupply}.
*/
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
/**
* @dev Returns the amount of tokens owned by an account (`tokenHolder`).
*/
function balanceOf(address tokenHolder) public view returns (uint256) {
return _balances[tokenHolder];
}
/**
* @dev See {IERC777-send}.
*
* Also emits a {Transfer} event for ERC20 compatibility.
*/
function send(address recipient, uint256 amount, bytes calldata data) external {
_send(_msgSender(), _msgSender(), recipient, amount, data, "", true);
}
/**
* @dev See {IERC20-transfer}.
*
* Unlike `send`, `recipient` is _not_ required to implement the {IERC777Recipient}
* interface if it is a contract.
*
* Also emits a {Sent} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool) {
require(recipient != address(0), "ERC777: transfer to the zero address");
address from = _msgSender();
_callTokensToSend(from, from, recipient, amount, "", "");
_move(from, from, recipient, amount, "", "");
_callTokensReceived(from, from, recipient, amount, "", "", false);
return true;
}
/**
* @dev See {IERC777-burn}.
*
* Also emits a {Transfer} event for ERC20 compatibility.
*/
function burn(uint256 amount, bytes calldata data) external {
_burn(_msgSender(), _msgSender(), amount, data, "");
}
/**
* @dev See {IERC777-isOperatorFor}.
*/
function isOperatorFor(
address operator,
address tokenHolder
) public view returns (bool) {
return operator == tokenHolder ||
(_defaultOperators[operator] && !_revokedDefaultOperators[tokenHolder][operator]) ||
_operators[tokenHolder][operator];
}
/**
* @dev See {IERC777-authorizeOperator}.
*/
function authorizeOperator(address operator) external {
_authorizeOperator(operator);
}
function _authorizeOperator(address operator) internal {
require(_msgSender() != operator, "ERC777: authorizing self as operator");
if (_defaultOperators[operator]) {
delete _revokedDefaultOperators[_msgSender()][operator];
} else {
_operators[_msgSender()][operator] = true;
}
emit AuthorizedOperator(operator, _msgSender());
}
/**
* @dev See {IERC777-revokeOperator}.
*/
function revokeOperator(address operator) external {
_revokeOperator(operator);
}
function _revokeOperator(address operator) internal {
require(operator != _msgSender(), "ERC777: revoking self as operator");
if (_defaultOperators[operator]) {
_revokedDefaultOperators[_msgSender()][operator] = true;
} else {
delete _operators[_msgSender()][operator];
}
emit RevokedOperator(operator, _msgSender());
}
/**
* @dev See {IERC777-defaultOperators}.
*/
function defaultOperators() public view returns (address[] memory) {
return _defaultOperatorsArray;
}
/**
* @dev See {IERC777-operatorSend}.
*
* Emits {Sent} and {Transfer} events.
*/
function operatorSend(
address sender,
address recipient,
uint256 amount,
bytes calldata data,
bytes calldata operatorData
)
external
{
require(isOperatorFor(_msgSender(), sender), "ERC777: caller is not an operator for holder");
_send(_msgSender(), sender, recipient, amount, data, operatorData, true);
}
/**
* @dev See {IERC777-operatorBurn}.
*
* Emits {Burned} and {Transfer} events.
*/
function operatorBurn(address account, uint256 amount, bytes calldata data, bytes calldata operatorData) external {
require(isOperatorFor(_msgSender(), account), "ERC777: caller is not an operator for holder");
_burn(_msgSender(), account, amount, data, operatorData);
}
/**
* @dev See {IERC20-allowance}.
*
* Note that operator and allowance concepts are orthogonal: operators may
* not have allowance, and accounts with allowance may not be operators
* themselves.
*/
function allowance(address holder, address spender) public view returns (uint256) {
return _allowances[holder][spender];
}
/**
* @dev See {IERC20-approve}.
*
* Note that accounts cannot have allowance issued by their operators.
*/
function approve(address spender, uint256 value) external returns (bool) {
address holder = _msgSender();
_approve(holder, spender, value);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Note that operator and allowance concepts are orthogonal: operators cannot
* call `transferFrom` (unless they have allowance), and accounts with
* allowance cannot call `operatorSend` (unless they are operators).
*
* Emits {Sent}, {Transfer} and {Approval} events.
*/
function transferFrom(address holder, address recipient, uint256 amount) external returns (bool) {
require(recipient != address(0), "ERC777: transfer to the zero address");
require(holder != address(0), "ERC777: transfer from the zero address");
address spender = _msgSender();
_callTokensToSend(spender, holder, recipient, amount, "", "");
_move(spender, holder, recipient, amount, "", "");
_approve(holder, spender, _allowances[holder][spender].sub(amount, "ERC777: transfer amount exceeds allowance"));
_callTokensReceived(spender, holder, recipient, amount, "", "", false);
return true;
}
/**
* @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* If a send hook is registered for `account`, the corresponding function
* will be called with `operator`, `data` and `operatorData`.
*
* See {IERC777Sender} and {IERC777Recipient}.
*
* Emits {Minted} and {Transfer} events.
*
* Requirements
*
* - `account` cannot be the zero address.
* - if `account` is a contract, it must implement the {IERC777Recipient}
* interface.
*/
function _mint(
address operator,
address account,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
internal
{
require(account != address(0), "ERC777: mint to the zero address");
// Update state variables
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
_callTokensReceived(operator, address(0), account, amount, userData, operatorData, true);
emit Minted(operator, account, amount, userData, operatorData);
emit Transfer(address(0), account, amount);
}
/**
* @dev Send tokens
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
* @param requireReceptionAck if true, contract recipients are required to implement ERC777TokensRecipient
*/
function _send(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck
)
internal
{
require(from != address(0), "ERC777: send from the zero address");
require(to != address(0), "ERC777: send to the zero address");
_callTokensToSend(operator, from, to, amount, userData, operatorData);
_move(operator, from, to, amount, userData, operatorData);
_callTokensReceived(operator, from, to, amount, userData, operatorData, requireReceptionAck);
}
/**
* @dev Burn tokens
* @param operator address operator requesting the operation
* @param from address token holder address
* @param amount uint256 amount of tokens to burn
* @param data bytes extra information provided by the token holder
* @param operatorData bytes extra information provided by the operator (if any)
*/
function _burn(
address operator,
address from,
uint256 amount,
bytes memory data,
bytes memory operatorData
)
internal
{
require(from != address(0), "ERC777: burn from the zero address");
_callTokensToSend(operator, from, address(0), amount, data, operatorData);
// Update state variables
_balances[from] = _balances[from].sub(amount, "ERC777: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Burned(operator, from, amount, data, operatorData);
emit Transfer(from, address(0), amount);
}
function _move(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
internal
{
_balances[from] = _balances[from].sub(amount, "ERC777: transfer amount exceeds balance");
_balances[to] = _balances[to].add(amount);
emit Sent(operator, from, to, amount, userData, operatorData);
emit Transfer(from, to, amount);
}
function _approve(address holder, address spender, uint256 value) internal {
// TODO: restore this require statement if this function becomes internal, or is called at a new callsite. It is
// currently unnecessary.
//require(holder != address(0), "ERC777: approve from the zero address");
require(spender != address(0), "ERC777: approve to the zero address");
_allowances[holder][spender] = value;
emit Approval(holder, spender, value);
}
/**
* @dev Call from.tokensToSend() if the interface is registered
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
*/
function _callTokensToSend(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
private
{
address implementer = _erc1820.getInterfaceImplementer(from, TOKENS_SENDER_INTERFACE_HASH);
if (implementer != address(0)) {
IERC777Sender(implementer).tokensToSend(operator, from, to, amount, userData, operatorData);
}
}
/**
* @dev Call to.tokensReceived() if the interface is registered. Reverts if the recipient is a contract but
* tokensReceived() was not registered for the recipient
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
* @param requireReceptionAck if true, contract recipients are required to implement ERC777TokensRecipient
*/
function _callTokensReceived(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck
)
private
{
address implementer = _erc1820.getInterfaceImplementer(to, TOKENS_RECIPIENT_INTERFACE_HASH);
if (implementer != address(0)) {
IERC777Recipient(implementer).tokensReceived(operator, from, to, amount, userData, operatorData);
} else if (requireReceptionAck) {
require(!to.isContract(), "ERC777: token recipient contract has no implement for ERC777TokensRecipient");
}
}
} | /**
* @dev Implementation of the {IERC777} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
*
* Support for ERC20 is included in this contract, as specified by the EIP: both
* the ERC777 and ERC20 interfaces can be safely used when interacting with it.
* Both {IERC777-Sent} and {IERC20-Transfer} events are emitted on token
* movements.
*
* Additionally, the {IERC777-granularity} value is hard-coded to `1`, meaning that there
* are no special restrictions in the amount of tokens that created, moved, or
* destroyed. This makes integration with ERC20 applications seamless.
*/ | NatSpecMultiLine | name | function name() public view returns (string memory) {
return _name;
}
| /**
* @dev See {IERC777-name}.
*/ | NatSpecMultiLine | v0.5.0+commit.1d4f565a | MIT | bzzr://c1bab4b5e3e40f4294e652b388dfc625ccf21445b4e184e78b601a51d58a2cc2 | {
"func_code_index": [
2301,
2389
]
} | 59,930 |
NNCProjectToken | patterns\token\ERC777\ERC777.sol | 0xa67462ff3314c682277771ae2bbcec08877c877a | Solidity | ERC777 | contract ERC777 is Context, IERC777, IERC20 {
using SafeMath for uint256;
using Address for address;
IERC1820Registry constant internal _erc1820 = IERC1820Registry(0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24);
mapping(address => uint256) private _balances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
// We inline the result of the following hashes because Solidity doesn't resolve them at compile time.
// See https://github.com/ethereum/solidity/issues/4024.
// keccak256("ERC777TokensSender")
bytes32 constant private TOKENS_SENDER_INTERFACE_HASH =
0x29ddb589b1fb5fc7cf394961c1adf5f8c6454761adf795e67fe149f658abe895;
// keccak256("ERC777TokensRecipient")
bytes32 constant private TOKENS_RECIPIENT_INTERFACE_HASH =
0xb281fc8c12954d22544db45de3159a39272895b169a852b314f9cc762e44c53b;
// This isn't ever read from - it's only used to respond to the defaultOperators query.
address[] private _defaultOperatorsArray;
// Immutable, but accounts may revoke them (tracked in __revokedDefaultOperators).
mapping(address => bool) private _defaultOperators;
// For each account, a mapping of its operators and revoked default operators.
mapping(address => mapping(address => bool)) private _operators;
mapping(address => mapping(address => bool)) private _revokedDefaultOperators;
// ERC20-allowances
mapping (address => mapping (address => uint256)) private _allowances;
/**
* @dev `defaultOperators` may be an empty array.
*/
constructor(
string memory name,
string memory symbol,
address[] memory defaultOperators
) public {
_name = name;
_symbol = symbol;
_defaultOperatorsArray = defaultOperators;
for (uint256 i = 0; i < _defaultOperatorsArray.length; i++) {
_defaultOperators[_defaultOperatorsArray[i]] = true;
}
// register interfaces
_erc1820.setInterfaceImplementer(address(this), keccak256("ERC777Token"), address(this));
_erc1820.setInterfaceImplementer(address(this), keccak256("ERC20Token"), address(this));
}
/**
* @dev See {IERC777-name}.
*/
function name() public view returns (string memory) {
return _name;
}
/**
* @dev See {IERC777-symbol}.
*/
function symbol() public view returns (string memory) {
return _symbol;
}
/**
* @dev See {ERC20Detailed-decimals}.
*
* Always returns 18, as per the
* [ERC777 EIP](https://eips.ethereum.org/EIPS/eip-777#backward-compatibility).
*/
function decimals() public pure returns (uint8) {
return 18;
}
/**
* @dev See {IERC777-granularity}.
*
* This implementation always returns `1`.
*/
function granularity() public view returns (uint256) {
return 1;
}
/**
* @dev See {IERC777-totalSupply}.
*/
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
/**
* @dev Returns the amount of tokens owned by an account (`tokenHolder`).
*/
function balanceOf(address tokenHolder) public view returns (uint256) {
return _balances[tokenHolder];
}
/**
* @dev See {IERC777-send}.
*
* Also emits a {Transfer} event for ERC20 compatibility.
*/
function send(address recipient, uint256 amount, bytes calldata data) external {
_send(_msgSender(), _msgSender(), recipient, amount, data, "", true);
}
/**
* @dev See {IERC20-transfer}.
*
* Unlike `send`, `recipient` is _not_ required to implement the {IERC777Recipient}
* interface if it is a contract.
*
* Also emits a {Sent} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool) {
require(recipient != address(0), "ERC777: transfer to the zero address");
address from = _msgSender();
_callTokensToSend(from, from, recipient, amount, "", "");
_move(from, from, recipient, amount, "", "");
_callTokensReceived(from, from, recipient, amount, "", "", false);
return true;
}
/**
* @dev See {IERC777-burn}.
*
* Also emits a {Transfer} event for ERC20 compatibility.
*/
function burn(uint256 amount, bytes calldata data) external {
_burn(_msgSender(), _msgSender(), amount, data, "");
}
/**
* @dev See {IERC777-isOperatorFor}.
*/
function isOperatorFor(
address operator,
address tokenHolder
) public view returns (bool) {
return operator == tokenHolder ||
(_defaultOperators[operator] && !_revokedDefaultOperators[tokenHolder][operator]) ||
_operators[tokenHolder][operator];
}
/**
* @dev See {IERC777-authorizeOperator}.
*/
function authorizeOperator(address operator) external {
_authorizeOperator(operator);
}
function _authorizeOperator(address operator) internal {
require(_msgSender() != operator, "ERC777: authorizing self as operator");
if (_defaultOperators[operator]) {
delete _revokedDefaultOperators[_msgSender()][operator];
} else {
_operators[_msgSender()][operator] = true;
}
emit AuthorizedOperator(operator, _msgSender());
}
/**
* @dev See {IERC777-revokeOperator}.
*/
function revokeOperator(address operator) external {
_revokeOperator(operator);
}
function _revokeOperator(address operator) internal {
require(operator != _msgSender(), "ERC777: revoking self as operator");
if (_defaultOperators[operator]) {
_revokedDefaultOperators[_msgSender()][operator] = true;
} else {
delete _operators[_msgSender()][operator];
}
emit RevokedOperator(operator, _msgSender());
}
/**
* @dev See {IERC777-defaultOperators}.
*/
function defaultOperators() public view returns (address[] memory) {
return _defaultOperatorsArray;
}
/**
* @dev See {IERC777-operatorSend}.
*
* Emits {Sent} and {Transfer} events.
*/
function operatorSend(
address sender,
address recipient,
uint256 amount,
bytes calldata data,
bytes calldata operatorData
)
external
{
require(isOperatorFor(_msgSender(), sender), "ERC777: caller is not an operator for holder");
_send(_msgSender(), sender, recipient, amount, data, operatorData, true);
}
/**
* @dev See {IERC777-operatorBurn}.
*
* Emits {Burned} and {Transfer} events.
*/
function operatorBurn(address account, uint256 amount, bytes calldata data, bytes calldata operatorData) external {
require(isOperatorFor(_msgSender(), account), "ERC777: caller is not an operator for holder");
_burn(_msgSender(), account, amount, data, operatorData);
}
/**
* @dev See {IERC20-allowance}.
*
* Note that operator and allowance concepts are orthogonal: operators may
* not have allowance, and accounts with allowance may not be operators
* themselves.
*/
function allowance(address holder, address spender) public view returns (uint256) {
return _allowances[holder][spender];
}
/**
* @dev See {IERC20-approve}.
*
* Note that accounts cannot have allowance issued by their operators.
*/
function approve(address spender, uint256 value) external returns (bool) {
address holder = _msgSender();
_approve(holder, spender, value);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Note that operator and allowance concepts are orthogonal: operators cannot
* call `transferFrom` (unless they have allowance), and accounts with
* allowance cannot call `operatorSend` (unless they are operators).
*
* Emits {Sent}, {Transfer} and {Approval} events.
*/
function transferFrom(address holder, address recipient, uint256 amount) external returns (bool) {
require(recipient != address(0), "ERC777: transfer to the zero address");
require(holder != address(0), "ERC777: transfer from the zero address");
address spender = _msgSender();
_callTokensToSend(spender, holder, recipient, amount, "", "");
_move(spender, holder, recipient, amount, "", "");
_approve(holder, spender, _allowances[holder][spender].sub(amount, "ERC777: transfer amount exceeds allowance"));
_callTokensReceived(spender, holder, recipient, amount, "", "", false);
return true;
}
/**
* @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* If a send hook is registered for `account`, the corresponding function
* will be called with `operator`, `data` and `operatorData`.
*
* See {IERC777Sender} and {IERC777Recipient}.
*
* Emits {Minted} and {Transfer} events.
*
* Requirements
*
* - `account` cannot be the zero address.
* - if `account` is a contract, it must implement the {IERC777Recipient}
* interface.
*/
function _mint(
address operator,
address account,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
internal
{
require(account != address(0), "ERC777: mint to the zero address");
// Update state variables
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
_callTokensReceived(operator, address(0), account, amount, userData, operatorData, true);
emit Minted(operator, account, amount, userData, operatorData);
emit Transfer(address(0), account, amount);
}
/**
* @dev Send tokens
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
* @param requireReceptionAck if true, contract recipients are required to implement ERC777TokensRecipient
*/
function _send(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck
)
internal
{
require(from != address(0), "ERC777: send from the zero address");
require(to != address(0), "ERC777: send to the zero address");
_callTokensToSend(operator, from, to, amount, userData, operatorData);
_move(operator, from, to, amount, userData, operatorData);
_callTokensReceived(operator, from, to, amount, userData, operatorData, requireReceptionAck);
}
/**
* @dev Burn tokens
* @param operator address operator requesting the operation
* @param from address token holder address
* @param amount uint256 amount of tokens to burn
* @param data bytes extra information provided by the token holder
* @param operatorData bytes extra information provided by the operator (if any)
*/
function _burn(
address operator,
address from,
uint256 amount,
bytes memory data,
bytes memory operatorData
)
internal
{
require(from != address(0), "ERC777: burn from the zero address");
_callTokensToSend(operator, from, address(0), amount, data, operatorData);
// Update state variables
_balances[from] = _balances[from].sub(amount, "ERC777: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Burned(operator, from, amount, data, operatorData);
emit Transfer(from, address(0), amount);
}
function _move(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
internal
{
_balances[from] = _balances[from].sub(amount, "ERC777: transfer amount exceeds balance");
_balances[to] = _balances[to].add(amount);
emit Sent(operator, from, to, amount, userData, operatorData);
emit Transfer(from, to, amount);
}
function _approve(address holder, address spender, uint256 value) internal {
// TODO: restore this require statement if this function becomes internal, or is called at a new callsite. It is
// currently unnecessary.
//require(holder != address(0), "ERC777: approve from the zero address");
require(spender != address(0), "ERC777: approve to the zero address");
_allowances[holder][spender] = value;
emit Approval(holder, spender, value);
}
/**
* @dev Call from.tokensToSend() if the interface is registered
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
*/
function _callTokensToSend(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
private
{
address implementer = _erc1820.getInterfaceImplementer(from, TOKENS_SENDER_INTERFACE_HASH);
if (implementer != address(0)) {
IERC777Sender(implementer).tokensToSend(operator, from, to, amount, userData, operatorData);
}
}
/**
* @dev Call to.tokensReceived() if the interface is registered. Reverts if the recipient is a contract but
* tokensReceived() was not registered for the recipient
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
* @param requireReceptionAck if true, contract recipients are required to implement ERC777TokensRecipient
*/
function _callTokensReceived(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck
)
private
{
address implementer = _erc1820.getInterfaceImplementer(to, TOKENS_RECIPIENT_INTERFACE_HASH);
if (implementer != address(0)) {
IERC777Recipient(implementer).tokensReceived(operator, from, to, amount, userData, operatorData);
} else if (requireReceptionAck) {
require(!to.isContract(), "ERC777: token recipient contract has no implement for ERC777TokensRecipient");
}
}
} | /**
* @dev Implementation of the {IERC777} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
*
* Support for ERC20 is included in this contract, as specified by the EIP: both
* the ERC777 and ERC20 interfaces can be safely used when interacting with it.
* Both {IERC777-Sent} and {IERC20-Transfer} events are emitted on token
* movements.
*
* Additionally, the {IERC777-granularity} value is hard-coded to `1`, meaning that there
* are no special restrictions in the amount of tokens that created, moved, or
* destroyed. This makes integration with ERC20 applications seamless.
*/ | NatSpecMultiLine | symbol | function symbol() public view returns (string memory) {
return _symbol;
}
| /**
* @dev See {IERC777-symbol}.
*/ | NatSpecMultiLine | v0.5.0+commit.1d4f565a | MIT | bzzr://c1bab4b5e3e40f4294e652b388dfc625ccf21445b4e184e78b601a51d58a2cc2 | {
"func_code_index": [
2445,
2537
]
} | 59,931 |
NNCProjectToken | patterns\token\ERC777\ERC777.sol | 0xa67462ff3314c682277771ae2bbcec08877c877a | Solidity | ERC777 | contract ERC777 is Context, IERC777, IERC20 {
using SafeMath for uint256;
using Address for address;
IERC1820Registry constant internal _erc1820 = IERC1820Registry(0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24);
mapping(address => uint256) private _balances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
// We inline the result of the following hashes because Solidity doesn't resolve them at compile time.
// See https://github.com/ethereum/solidity/issues/4024.
// keccak256("ERC777TokensSender")
bytes32 constant private TOKENS_SENDER_INTERFACE_HASH =
0x29ddb589b1fb5fc7cf394961c1adf5f8c6454761adf795e67fe149f658abe895;
// keccak256("ERC777TokensRecipient")
bytes32 constant private TOKENS_RECIPIENT_INTERFACE_HASH =
0xb281fc8c12954d22544db45de3159a39272895b169a852b314f9cc762e44c53b;
// This isn't ever read from - it's only used to respond to the defaultOperators query.
address[] private _defaultOperatorsArray;
// Immutable, but accounts may revoke them (tracked in __revokedDefaultOperators).
mapping(address => bool) private _defaultOperators;
// For each account, a mapping of its operators and revoked default operators.
mapping(address => mapping(address => bool)) private _operators;
mapping(address => mapping(address => bool)) private _revokedDefaultOperators;
// ERC20-allowances
mapping (address => mapping (address => uint256)) private _allowances;
/**
* @dev `defaultOperators` may be an empty array.
*/
constructor(
string memory name,
string memory symbol,
address[] memory defaultOperators
) public {
_name = name;
_symbol = symbol;
_defaultOperatorsArray = defaultOperators;
for (uint256 i = 0; i < _defaultOperatorsArray.length; i++) {
_defaultOperators[_defaultOperatorsArray[i]] = true;
}
// register interfaces
_erc1820.setInterfaceImplementer(address(this), keccak256("ERC777Token"), address(this));
_erc1820.setInterfaceImplementer(address(this), keccak256("ERC20Token"), address(this));
}
/**
* @dev See {IERC777-name}.
*/
function name() public view returns (string memory) {
return _name;
}
/**
* @dev See {IERC777-symbol}.
*/
function symbol() public view returns (string memory) {
return _symbol;
}
/**
* @dev See {ERC20Detailed-decimals}.
*
* Always returns 18, as per the
* [ERC777 EIP](https://eips.ethereum.org/EIPS/eip-777#backward-compatibility).
*/
function decimals() public pure returns (uint8) {
return 18;
}
/**
* @dev See {IERC777-granularity}.
*
* This implementation always returns `1`.
*/
function granularity() public view returns (uint256) {
return 1;
}
/**
* @dev See {IERC777-totalSupply}.
*/
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
/**
* @dev Returns the amount of tokens owned by an account (`tokenHolder`).
*/
function balanceOf(address tokenHolder) public view returns (uint256) {
return _balances[tokenHolder];
}
/**
* @dev See {IERC777-send}.
*
* Also emits a {Transfer} event for ERC20 compatibility.
*/
function send(address recipient, uint256 amount, bytes calldata data) external {
_send(_msgSender(), _msgSender(), recipient, amount, data, "", true);
}
/**
* @dev See {IERC20-transfer}.
*
* Unlike `send`, `recipient` is _not_ required to implement the {IERC777Recipient}
* interface if it is a contract.
*
* Also emits a {Sent} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool) {
require(recipient != address(0), "ERC777: transfer to the zero address");
address from = _msgSender();
_callTokensToSend(from, from, recipient, amount, "", "");
_move(from, from, recipient, amount, "", "");
_callTokensReceived(from, from, recipient, amount, "", "", false);
return true;
}
/**
* @dev See {IERC777-burn}.
*
* Also emits a {Transfer} event for ERC20 compatibility.
*/
function burn(uint256 amount, bytes calldata data) external {
_burn(_msgSender(), _msgSender(), amount, data, "");
}
/**
* @dev See {IERC777-isOperatorFor}.
*/
function isOperatorFor(
address operator,
address tokenHolder
) public view returns (bool) {
return operator == tokenHolder ||
(_defaultOperators[operator] && !_revokedDefaultOperators[tokenHolder][operator]) ||
_operators[tokenHolder][operator];
}
/**
* @dev See {IERC777-authorizeOperator}.
*/
function authorizeOperator(address operator) external {
_authorizeOperator(operator);
}
function _authorizeOperator(address operator) internal {
require(_msgSender() != operator, "ERC777: authorizing self as operator");
if (_defaultOperators[operator]) {
delete _revokedDefaultOperators[_msgSender()][operator];
} else {
_operators[_msgSender()][operator] = true;
}
emit AuthorizedOperator(operator, _msgSender());
}
/**
* @dev See {IERC777-revokeOperator}.
*/
function revokeOperator(address operator) external {
_revokeOperator(operator);
}
function _revokeOperator(address operator) internal {
require(operator != _msgSender(), "ERC777: revoking self as operator");
if (_defaultOperators[operator]) {
_revokedDefaultOperators[_msgSender()][operator] = true;
} else {
delete _operators[_msgSender()][operator];
}
emit RevokedOperator(operator, _msgSender());
}
/**
* @dev See {IERC777-defaultOperators}.
*/
function defaultOperators() public view returns (address[] memory) {
return _defaultOperatorsArray;
}
/**
* @dev See {IERC777-operatorSend}.
*
* Emits {Sent} and {Transfer} events.
*/
function operatorSend(
address sender,
address recipient,
uint256 amount,
bytes calldata data,
bytes calldata operatorData
)
external
{
require(isOperatorFor(_msgSender(), sender), "ERC777: caller is not an operator for holder");
_send(_msgSender(), sender, recipient, amount, data, operatorData, true);
}
/**
* @dev See {IERC777-operatorBurn}.
*
* Emits {Burned} and {Transfer} events.
*/
function operatorBurn(address account, uint256 amount, bytes calldata data, bytes calldata operatorData) external {
require(isOperatorFor(_msgSender(), account), "ERC777: caller is not an operator for holder");
_burn(_msgSender(), account, amount, data, operatorData);
}
/**
* @dev See {IERC20-allowance}.
*
* Note that operator and allowance concepts are orthogonal: operators may
* not have allowance, and accounts with allowance may not be operators
* themselves.
*/
function allowance(address holder, address spender) public view returns (uint256) {
return _allowances[holder][spender];
}
/**
* @dev See {IERC20-approve}.
*
* Note that accounts cannot have allowance issued by their operators.
*/
function approve(address spender, uint256 value) external returns (bool) {
address holder = _msgSender();
_approve(holder, spender, value);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Note that operator and allowance concepts are orthogonal: operators cannot
* call `transferFrom` (unless they have allowance), and accounts with
* allowance cannot call `operatorSend` (unless they are operators).
*
* Emits {Sent}, {Transfer} and {Approval} events.
*/
function transferFrom(address holder, address recipient, uint256 amount) external returns (bool) {
require(recipient != address(0), "ERC777: transfer to the zero address");
require(holder != address(0), "ERC777: transfer from the zero address");
address spender = _msgSender();
_callTokensToSend(spender, holder, recipient, amount, "", "");
_move(spender, holder, recipient, amount, "", "");
_approve(holder, spender, _allowances[holder][spender].sub(amount, "ERC777: transfer amount exceeds allowance"));
_callTokensReceived(spender, holder, recipient, amount, "", "", false);
return true;
}
/**
* @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* If a send hook is registered for `account`, the corresponding function
* will be called with `operator`, `data` and `operatorData`.
*
* See {IERC777Sender} and {IERC777Recipient}.
*
* Emits {Minted} and {Transfer} events.
*
* Requirements
*
* - `account` cannot be the zero address.
* - if `account` is a contract, it must implement the {IERC777Recipient}
* interface.
*/
function _mint(
address operator,
address account,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
internal
{
require(account != address(0), "ERC777: mint to the zero address");
// Update state variables
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
_callTokensReceived(operator, address(0), account, amount, userData, operatorData, true);
emit Minted(operator, account, amount, userData, operatorData);
emit Transfer(address(0), account, amount);
}
/**
* @dev Send tokens
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
* @param requireReceptionAck if true, contract recipients are required to implement ERC777TokensRecipient
*/
function _send(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck
)
internal
{
require(from != address(0), "ERC777: send from the zero address");
require(to != address(0), "ERC777: send to the zero address");
_callTokensToSend(operator, from, to, amount, userData, operatorData);
_move(operator, from, to, amount, userData, operatorData);
_callTokensReceived(operator, from, to, amount, userData, operatorData, requireReceptionAck);
}
/**
* @dev Burn tokens
* @param operator address operator requesting the operation
* @param from address token holder address
* @param amount uint256 amount of tokens to burn
* @param data bytes extra information provided by the token holder
* @param operatorData bytes extra information provided by the operator (if any)
*/
function _burn(
address operator,
address from,
uint256 amount,
bytes memory data,
bytes memory operatorData
)
internal
{
require(from != address(0), "ERC777: burn from the zero address");
_callTokensToSend(operator, from, address(0), amount, data, operatorData);
// Update state variables
_balances[from] = _balances[from].sub(amount, "ERC777: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Burned(operator, from, amount, data, operatorData);
emit Transfer(from, address(0), amount);
}
function _move(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
internal
{
_balances[from] = _balances[from].sub(amount, "ERC777: transfer amount exceeds balance");
_balances[to] = _balances[to].add(amount);
emit Sent(operator, from, to, amount, userData, operatorData);
emit Transfer(from, to, amount);
}
function _approve(address holder, address spender, uint256 value) internal {
// TODO: restore this require statement if this function becomes internal, or is called at a new callsite. It is
// currently unnecessary.
//require(holder != address(0), "ERC777: approve from the zero address");
require(spender != address(0), "ERC777: approve to the zero address");
_allowances[holder][spender] = value;
emit Approval(holder, spender, value);
}
/**
* @dev Call from.tokensToSend() if the interface is registered
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
*/
function _callTokensToSend(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
private
{
address implementer = _erc1820.getInterfaceImplementer(from, TOKENS_SENDER_INTERFACE_HASH);
if (implementer != address(0)) {
IERC777Sender(implementer).tokensToSend(operator, from, to, amount, userData, operatorData);
}
}
/**
* @dev Call to.tokensReceived() if the interface is registered. Reverts if the recipient is a contract but
* tokensReceived() was not registered for the recipient
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
* @param requireReceptionAck if true, contract recipients are required to implement ERC777TokensRecipient
*/
function _callTokensReceived(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck
)
private
{
address implementer = _erc1820.getInterfaceImplementer(to, TOKENS_RECIPIENT_INTERFACE_HASH);
if (implementer != address(0)) {
IERC777Recipient(implementer).tokensReceived(operator, from, to, amount, userData, operatorData);
} else if (requireReceptionAck) {
require(!to.isContract(), "ERC777: token recipient contract has no implement for ERC777TokensRecipient");
}
}
} | /**
* @dev Implementation of the {IERC777} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
*
* Support for ERC20 is included in this contract, as specified by the EIP: both
* the ERC777 and ERC20 interfaces can be safely used when interacting with it.
* Both {IERC777-Sent} and {IERC20-Transfer} events are emitted on token
* movements.
*
* Additionally, the {IERC777-granularity} value is hard-coded to `1`, meaning that there
* are no special restrictions in the amount of tokens that created, moved, or
* destroyed. This makes integration with ERC20 applications seamless.
*/ | NatSpecMultiLine | decimals | function decimals() public pure returns (uint8) {
return 18;
}
| /**
* @dev See {ERC20Detailed-decimals}.
*
* Always returns 18, as per the
* [ERC777 EIP](https://eips.ethereum.org/EIPS/eip-777#backward-compatibility).
*/ | NatSpecMultiLine | v0.5.0+commit.1d4f565a | MIT | bzzr://c1bab4b5e3e40f4294e652b388dfc625ccf21445b4e184e78b601a51d58a2cc2 | {
"func_code_index": [
2732,
2813
]
} | 59,932 |
NNCProjectToken | patterns\token\ERC777\ERC777.sol | 0xa67462ff3314c682277771ae2bbcec08877c877a | Solidity | ERC777 | contract ERC777 is Context, IERC777, IERC20 {
using SafeMath for uint256;
using Address for address;
IERC1820Registry constant internal _erc1820 = IERC1820Registry(0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24);
mapping(address => uint256) private _balances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
// We inline the result of the following hashes because Solidity doesn't resolve them at compile time.
// See https://github.com/ethereum/solidity/issues/4024.
// keccak256("ERC777TokensSender")
bytes32 constant private TOKENS_SENDER_INTERFACE_HASH =
0x29ddb589b1fb5fc7cf394961c1adf5f8c6454761adf795e67fe149f658abe895;
// keccak256("ERC777TokensRecipient")
bytes32 constant private TOKENS_RECIPIENT_INTERFACE_HASH =
0xb281fc8c12954d22544db45de3159a39272895b169a852b314f9cc762e44c53b;
// This isn't ever read from - it's only used to respond to the defaultOperators query.
address[] private _defaultOperatorsArray;
// Immutable, but accounts may revoke them (tracked in __revokedDefaultOperators).
mapping(address => bool) private _defaultOperators;
// For each account, a mapping of its operators and revoked default operators.
mapping(address => mapping(address => bool)) private _operators;
mapping(address => mapping(address => bool)) private _revokedDefaultOperators;
// ERC20-allowances
mapping (address => mapping (address => uint256)) private _allowances;
/**
* @dev `defaultOperators` may be an empty array.
*/
constructor(
string memory name,
string memory symbol,
address[] memory defaultOperators
) public {
_name = name;
_symbol = symbol;
_defaultOperatorsArray = defaultOperators;
for (uint256 i = 0; i < _defaultOperatorsArray.length; i++) {
_defaultOperators[_defaultOperatorsArray[i]] = true;
}
// register interfaces
_erc1820.setInterfaceImplementer(address(this), keccak256("ERC777Token"), address(this));
_erc1820.setInterfaceImplementer(address(this), keccak256("ERC20Token"), address(this));
}
/**
* @dev See {IERC777-name}.
*/
function name() public view returns (string memory) {
return _name;
}
/**
* @dev See {IERC777-symbol}.
*/
function symbol() public view returns (string memory) {
return _symbol;
}
/**
* @dev See {ERC20Detailed-decimals}.
*
* Always returns 18, as per the
* [ERC777 EIP](https://eips.ethereum.org/EIPS/eip-777#backward-compatibility).
*/
function decimals() public pure returns (uint8) {
return 18;
}
/**
* @dev See {IERC777-granularity}.
*
* This implementation always returns `1`.
*/
function granularity() public view returns (uint256) {
return 1;
}
/**
* @dev See {IERC777-totalSupply}.
*/
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
/**
* @dev Returns the amount of tokens owned by an account (`tokenHolder`).
*/
function balanceOf(address tokenHolder) public view returns (uint256) {
return _balances[tokenHolder];
}
/**
* @dev See {IERC777-send}.
*
* Also emits a {Transfer} event for ERC20 compatibility.
*/
function send(address recipient, uint256 amount, bytes calldata data) external {
_send(_msgSender(), _msgSender(), recipient, amount, data, "", true);
}
/**
* @dev See {IERC20-transfer}.
*
* Unlike `send`, `recipient` is _not_ required to implement the {IERC777Recipient}
* interface if it is a contract.
*
* Also emits a {Sent} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool) {
require(recipient != address(0), "ERC777: transfer to the zero address");
address from = _msgSender();
_callTokensToSend(from, from, recipient, amount, "", "");
_move(from, from, recipient, amount, "", "");
_callTokensReceived(from, from, recipient, amount, "", "", false);
return true;
}
/**
* @dev See {IERC777-burn}.
*
* Also emits a {Transfer} event for ERC20 compatibility.
*/
function burn(uint256 amount, bytes calldata data) external {
_burn(_msgSender(), _msgSender(), amount, data, "");
}
/**
* @dev See {IERC777-isOperatorFor}.
*/
function isOperatorFor(
address operator,
address tokenHolder
) public view returns (bool) {
return operator == tokenHolder ||
(_defaultOperators[operator] && !_revokedDefaultOperators[tokenHolder][operator]) ||
_operators[tokenHolder][operator];
}
/**
* @dev See {IERC777-authorizeOperator}.
*/
function authorizeOperator(address operator) external {
_authorizeOperator(operator);
}
function _authorizeOperator(address operator) internal {
require(_msgSender() != operator, "ERC777: authorizing self as operator");
if (_defaultOperators[operator]) {
delete _revokedDefaultOperators[_msgSender()][operator];
} else {
_operators[_msgSender()][operator] = true;
}
emit AuthorizedOperator(operator, _msgSender());
}
/**
* @dev See {IERC777-revokeOperator}.
*/
function revokeOperator(address operator) external {
_revokeOperator(operator);
}
function _revokeOperator(address operator) internal {
require(operator != _msgSender(), "ERC777: revoking self as operator");
if (_defaultOperators[operator]) {
_revokedDefaultOperators[_msgSender()][operator] = true;
} else {
delete _operators[_msgSender()][operator];
}
emit RevokedOperator(operator, _msgSender());
}
/**
* @dev See {IERC777-defaultOperators}.
*/
function defaultOperators() public view returns (address[] memory) {
return _defaultOperatorsArray;
}
/**
* @dev See {IERC777-operatorSend}.
*
* Emits {Sent} and {Transfer} events.
*/
function operatorSend(
address sender,
address recipient,
uint256 amount,
bytes calldata data,
bytes calldata operatorData
)
external
{
require(isOperatorFor(_msgSender(), sender), "ERC777: caller is not an operator for holder");
_send(_msgSender(), sender, recipient, amount, data, operatorData, true);
}
/**
* @dev See {IERC777-operatorBurn}.
*
* Emits {Burned} and {Transfer} events.
*/
function operatorBurn(address account, uint256 amount, bytes calldata data, bytes calldata operatorData) external {
require(isOperatorFor(_msgSender(), account), "ERC777: caller is not an operator for holder");
_burn(_msgSender(), account, amount, data, operatorData);
}
/**
* @dev See {IERC20-allowance}.
*
* Note that operator and allowance concepts are orthogonal: operators may
* not have allowance, and accounts with allowance may not be operators
* themselves.
*/
function allowance(address holder, address spender) public view returns (uint256) {
return _allowances[holder][spender];
}
/**
* @dev See {IERC20-approve}.
*
* Note that accounts cannot have allowance issued by their operators.
*/
function approve(address spender, uint256 value) external returns (bool) {
address holder = _msgSender();
_approve(holder, spender, value);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Note that operator and allowance concepts are orthogonal: operators cannot
* call `transferFrom` (unless they have allowance), and accounts with
* allowance cannot call `operatorSend` (unless they are operators).
*
* Emits {Sent}, {Transfer} and {Approval} events.
*/
function transferFrom(address holder, address recipient, uint256 amount) external returns (bool) {
require(recipient != address(0), "ERC777: transfer to the zero address");
require(holder != address(0), "ERC777: transfer from the zero address");
address spender = _msgSender();
_callTokensToSend(spender, holder, recipient, amount, "", "");
_move(spender, holder, recipient, amount, "", "");
_approve(holder, spender, _allowances[holder][spender].sub(amount, "ERC777: transfer amount exceeds allowance"));
_callTokensReceived(spender, holder, recipient, amount, "", "", false);
return true;
}
/**
* @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* If a send hook is registered for `account`, the corresponding function
* will be called with `operator`, `data` and `operatorData`.
*
* See {IERC777Sender} and {IERC777Recipient}.
*
* Emits {Minted} and {Transfer} events.
*
* Requirements
*
* - `account` cannot be the zero address.
* - if `account` is a contract, it must implement the {IERC777Recipient}
* interface.
*/
function _mint(
address operator,
address account,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
internal
{
require(account != address(0), "ERC777: mint to the zero address");
// Update state variables
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
_callTokensReceived(operator, address(0), account, amount, userData, operatorData, true);
emit Minted(operator, account, amount, userData, operatorData);
emit Transfer(address(0), account, amount);
}
/**
* @dev Send tokens
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
* @param requireReceptionAck if true, contract recipients are required to implement ERC777TokensRecipient
*/
function _send(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck
)
internal
{
require(from != address(0), "ERC777: send from the zero address");
require(to != address(0), "ERC777: send to the zero address");
_callTokensToSend(operator, from, to, amount, userData, operatorData);
_move(operator, from, to, amount, userData, operatorData);
_callTokensReceived(operator, from, to, amount, userData, operatorData, requireReceptionAck);
}
/**
* @dev Burn tokens
* @param operator address operator requesting the operation
* @param from address token holder address
* @param amount uint256 amount of tokens to burn
* @param data bytes extra information provided by the token holder
* @param operatorData bytes extra information provided by the operator (if any)
*/
function _burn(
address operator,
address from,
uint256 amount,
bytes memory data,
bytes memory operatorData
)
internal
{
require(from != address(0), "ERC777: burn from the zero address");
_callTokensToSend(operator, from, address(0), amount, data, operatorData);
// Update state variables
_balances[from] = _balances[from].sub(amount, "ERC777: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Burned(operator, from, amount, data, operatorData);
emit Transfer(from, address(0), amount);
}
function _move(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
internal
{
_balances[from] = _balances[from].sub(amount, "ERC777: transfer amount exceeds balance");
_balances[to] = _balances[to].add(amount);
emit Sent(operator, from, to, amount, userData, operatorData);
emit Transfer(from, to, amount);
}
function _approve(address holder, address spender, uint256 value) internal {
// TODO: restore this require statement if this function becomes internal, or is called at a new callsite. It is
// currently unnecessary.
//require(holder != address(0), "ERC777: approve from the zero address");
require(spender != address(0), "ERC777: approve to the zero address");
_allowances[holder][spender] = value;
emit Approval(holder, spender, value);
}
/**
* @dev Call from.tokensToSend() if the interface is registered
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
*/
function _callTokensToSend(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
private
{
address implementer = _erc1820.getInterfaceImplementer(from, TOKENS_SENDER_INTERFACE_HASH);
if (implementer != address(0)) {
IERC777Sender(implementer).tokensToSend(operator, from, to, amount, userData, operatorData);
}
}
/**
* @dev Call to.tokensReceived() if the interface is registered. Reverts if the recipient is a contract but
* tokensReceived() was not registered for the recipient
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
* @param requireReceptionAck if true, contract recipients are required to implement ERC777TokensRecipient
*/
function _callTokensReceived(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck
)
private
{
address implementer = _erc1820.getInterfaceImplementer(to, TOKENS_RECIPIENT_INTERFACE_HASH);
if (implementer != address(0)) {
IERC777Recipient(implementer).tokensReceived(operator, from, to, amount, userData, operatorData);
} else if (requireReceptionAck) {
require(!to.isContract(), "ERC777: token recipient contract has no implement for ERC777TokensRecipient");
}
}
} | /**
* @dev Implementation of the {IERC777} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
*
* Support for ERC20 is included in this contract, as specified by the EIP: both
* the ERC777 and ERC20 interfaces can be safely used when interacting with it.
* Both {IERC777-Sent} and {IERC20-Transfer} events are emitted on token
* movements.
*
* Additionally, the {IERC777-granularity} value is hard-coded to `1`, meaning that there
* are no special restrictions in the amount of tokens that created, moved, or
* destroyed. This makes integration with ERC20 applications seamless.
*/ | NatSpecMultiLine | granularity | function granularity() public view returns (uint256) {
return 1;
}
| /**
* @dev See {IERC777-granularity}.
*
* This implementation always returns `1`.
*/ | NatSpecMultiLine | v0.5.0+commit.1d4f565a | MIT | bzzr://c1bab4b5e3e40f4294e652b388dfc625ccf21445b4e184e78b601a51d58a2cc2 | {
"func_code_index": [
2930,
3015
]
} | 59,933 |
NNCProjectToken | patterns\token\ERC777\ERC777.sol | 0xa67462ff3314c682277771ae2bbcec08877c877a | Solidity | ERC777 | contract ERC777 is Context, IERC777, IERC20 {
using SafeMath for uint256;
using Address for address;
IERC1820Registry constant internal _erc1820 = IERC1820Registry(0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24);
mapping(address => uint256) private _balances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
// We inline the result of the following hashes because Solidity doesn't resolve them at compile time.
// See https://github.com/ethereum/solidity/issues/4024.
// keccak256("ERC777TokensSender")
bytes32 constant private TOKENS_SENDER_INTERFACE_HASH =
0x29ddb589b1fb5fc7cf394961c1adf5f8c6454761adf795e67fe149f658abe895;
// keccak256("ERC777TokensRecipient")
bytes32 constant private TOKENS_RECIPIENT_INTERFACE_HASH =
0xb281fc8c12954d22544db45de3159a39272895b169a852b314f9cc762e44c53b;
// This isn't ever read from - it's only used to respond to the defaultOperators query.
address[] private _defaultOperatorsArray;
// Immutable, but accounts may revoke them (tracked in __revokedDefaultOperators).
mapping(address => bool) private _defaultOperators;
// For each account, a mapping of its operators and revoked default operators.
mapping(address => mapping(address => bool)) private _operators;
mapping(address => mapping(address => bool)) private _revokedDefaultOperators;
// ERC20-allowances
mapping (address => mapping (address => uint256)) private _allowances;
/**
* @dev `defaultOperators` may be an empty array.
*/
constructor(
string memory name,
string memory symbol,
address[] memory defaultOperators
) public {
_name = name;
_symbol = symbol;
_defaultOperatorsArray = defaultOperators;
for (uint256 i = 0; i < _defaultOperatorsArray.length; i++) {
_defaultOperators[_defaultOperatorsArray[i]] = true;
}
// register interfaces
_erc1820.setInterfaceImplementer(address(this), keccak256("ERC777Token"), address(this));
_erc1820.setInterfaceImplementer(address(this), keccak256("ERC20Token"), address(this));
}
/**
* @dev See {IERC777-name}.
*/
function name() public view returns (string memory) {
return _name;
}
/**
* @dev See {IERC777-symbol}.
*/
function symbol() public view returns (string memory) {
return _symbol;
}
/**
* @dev See {ERC20Detailed-decimals}.
*
* Always returns 18, as per the
* [ERC777 EIP](https://eips.ethereum.org/EIPS/eip-777#backward-compatibility).
*/
function decimals() public pure returns (uint8) {
return 18;
}
/**
* @dev See {IERC777-granularity}.
*
* This implementation always returns `1`.
*/
function granularity() public view returns (uint256) {
return 1;
}
/**
* @dev See {IERC777-totalSupply}.
*/
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
/**
* @dev Returns the amount of tokens owned by an account (`tokenHolder`).
*/
function balanceOf(address tokenHolder) public view returns (uint256) {
return _balances[tokenHolder];
}
/**
* @dev See {IERC777-send}.
*
* Also emits a {Transfer} event for ERC20 compatibility.
*/
function send(address recipient, uint256 amount, bytes calldata data) external {
_send(_msgSender(), _msgSender(), recipient, amount, data, "", true);
}
/**
* @dev See {IERC20-transfer}.
*
* Unlike `send`, `recipient` is _not_ required to implement the {IERC777Recipient}
* interface if it is a contract.
*
* Also emits a {Sent} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool) {
require(recipient != address(0), "ERC777: transfer to the zero address");
address from = _msgSender();
_callTokensToSend(from, from, recipient, amount, "", "");
_move(from, from, recipient, amount, "", "");
_callTokensReceived(from, from, recipient, amount, "", "", false);
return true;
}
/**
* @dev See {IERC777-burn}.
*
* Also emits a {Transfer} event for ERC20 compatibility.
*/
function burn(uint256 amount, bytes calldata data) external {
_burn(_msgSender(), _msgSender(), amount, data, "");
}
/**
* @dev See {IERC777-isOperatorFor}.
*/
function isOperatorFor(
address operator,
address tokenHolder
) public view returns (bool) {
return operator == tokenHolder ||
(_defaultOperators[operator] && !_revokedDefaultOperators[tokenHolder][operator]) ||
_operators[tokenHolder][operator];
}
/**
* @dev See {IERC777-authorizeOperator}.
*/
function authorizeOperator(address operator) external {
_authorizeOperator(operator);
}
function _authorizeOperator(address operator) internal {
require(_msgSender() != operator, "ERC777: authorizing self as operator");
if (_defaultOperators[operator]) {
delete _revokedDefaultOperators[_msgSender()][operator];
} else {
_operators[_msgSender()][operator] = true;
}
emit AuthorizedOperator(operator, _msgSender());
}
/**
* @dev See {IERC777-revokeOperator}.
*/
function revokeOperator(address operator) external {
_revokeOperator(operator);
}
function _revokeOperator(address operator) internal {
require(operator != _msgSender(), "ERC777: revoking self as operator");
if (_defaultOperators[operator]) {
_revokedDefaultOperators[_msgSender()][operator] = true;
} else {
delete _operators[_msgSender()][operator];
}
emit RevokedOperator(operator, _msgSender());
}
/**
* @dev See {IERC777-defaultOperators}.
*/
function defaultOperators() public view returns (address[] memory) {
return _defaultOperatorsArray;
}
/**
* @dev See {IERC777-operatorSend}.
*
* Emits {Sent} and {Transfer} events.
*/
function operatorSend(
address sender,
address recipient,
uint256 amount,
bytes calldata data,
bytes calldata operatorData
)
external
{
require(isOperatorFor(_msgSender(), sender), "ERC777: caller is not an operator for holder");
_send(_msgSender(), sender, recipient, amount, data, operatorData, true);
}
/**
* @dev See {IERC777-operatorBurn}.
*
* Emits {Burned} and {Transfer} events.
*/
function operatorBurn(address account, uint256 amount, bytes calldata data, bytes calldata operatorData) external {
require(isOperatorFor(_msgSender(), account), "ERC777: caller is not an operator for holder");
_burn(_msgSender(), account, amount, data, operatorData);
}
/**
* @dev See {IERC20-allowance}.
*
* Note that operator and allowance concepts are orthogonal: operators may
* not have allowance, and accounts with allowance may not be operators
* themselves.
*/
function allowance(address holder, address spender) public view returns (uint256) {
return _allowances[holder][spender];
}
/**
* @dev See {IERC20-approve}.
*
* Note that accounts cannot have allowance issued by their operators.
*/
function approve(address spender, uint256 value) external returns (bool) {
address holder = _msgSender();
_approve(holder, spender, value);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Note that operator and allowance concepts are orthogonal: operators cannot
* call `transferFrom` (unless they have allowance), and accounts with
* allowance cannot call `operatorSend` (unless they are operators).
*
* Emits {Sent}, {Transfer} and {Approval} events.
*/
function transferFrom(address holder, address recipient, uint256 amount) external returns (bool) {
require(recipient != address(0), "ERC777: transfer to the zero address");
require(holder != address(0), "ERC777: transfer from the zero address");
address spender = _msgSender();
_callTokensToSend(spender, holder, recipient, amount, "", "");
_move(spender, holder, recipient, amount, "", "");
_approve(holder, spender, _allowances[holder][spender].sub(amount, "ERC777: transfer amount exceeds allowance"));
_callTokensReceived(spender, holder, recipient, amount, "", "", false);
return true;
}
/**
* @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* If a send hook is registered for `account`, the corresponding function
* will be called with `operator`, `data` and `operatorData`.
*
* See {IERC777Sender} and {IERC777Recipient}.
*
* Emits {Minted} and {Transfer} events.
*
* Requirements
*
* - `account` cannot be the zero address.
* - if `account` is a contract, it must implement the {IERC777Recipient}
* interface.
*/
function _mint(
address operator,
address account,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
internal
{
require(account != address(0), "ERC777: mint to the zero address");
// Update state variables
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
_callTokensReceived(operator, address(0), account, amount, userData, operatorData, true);
emit Minted(operator, account, amount, userData, operatorData);
emit Transfer(address(0), account, amount);
}
/**
* @dev Send tokens
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
* @param requireReceptionAck if true, contract recipients are required to implement ERC777TokensRecipient
*/
function _send(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck
)
internal
{
require(from != address(0), "ERC777: send from the zero address");
require(to != address(0), "ERC777: send to the zero address");
_callTokensToSend(operator, from, to, amount, userData, operatorData);
_move(operator, from, to, amount, userData, operatorData);
_callTokensReceived(operator, from, to, amount, userData, operatorData, requireReceptionAck);
}
/**
* @dev Burn tokens
* @param operator address operator requesting the operation
* @param from address token holder address
* @param amount uint256 amount of tokens to burn
* @param data bytes extra information provided by the token holder
* @param operatorData bytes extra information provided by the operator (if any)
*/
function _burn(
address operator,
address from,
uint256 amount,
bytes memory data,
bytes memory operatorData
)
internal
{
require(from != address(0), "ERC777: burn from the zero address");
_callTokensToSend(operator, from, address(0), amount, data, operatorData);
// Update state variables
_balances[from] = _balances[from].sub(amount, "ERC777: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Burned(operator, from, amount, data, operatorData);
emit Transfer(from, address(0), amount);
}
function _move(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
internal
{
_balances[from] = _balances[from].sub(amount, "ERC777: transfer amount exceeds balance");
_balances[to] = _balances[to].add(amount);
emit Sent(operator, from, to, amount, userData, operatorData);
emit Transfer(from, to, amount);
}
function _approve(address holder, address spender, uint256 value) internal {
// TODO: restore this require statement if this function becomes internal, or is called at a new callsite. It is
// currently unnecessary.
//require(holder != address(0), "ERC777: approve from the zero address");
require(spender != address(0), "ERC777: approve to the zero address");
_allowances[holder][spender] = value;
emit Approval(holder, spender, value);
}
/**
* @dev Call from.tokensToSend() if the interface is registered
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
*/
function _callTokensToSend(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
private
{
address implementer = _erc1820.getInterfaceImplementer(from, TOKENS_SENDER_INTERFACE_HASH);
if (implementer != address(0)) {
IERC777Sender(implementer).tokensToSend(operator, from, to, amount, userData, operatorData);
}
}
/**
* @dev Call to.tokensReceived() if the interface is registered. Reverts if the recipient is a contract but
* tokensReceived() was not registered for the recipient
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
* @param requireReceptionAck if true, contract recipients are required to implement ERC777TokensRecipient
*/
function _callTokensReceived(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck
)
private
{
address implementer = _erc1820.getInterfaceImplementer(to, TOKENS_RECIPIENT_INTERFACE_HASH);
if (implementer != address(0)) {
IERC777Recipient(implementer).tokensReceived(operator, from, to, amount, userData, operatorData);
} else if (requireReceptionAck) {
require(!to.isContract(), "ERC777: token recipient contract has no implement for ERC777TokensRecipient");
}
}
} | /**
* @dev Implementation of the {IERC777} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
*
* Support for ERC20 is included in this contract, as specified by the EIP: both
* the ERC777 and ERC20 interfaces can be safely used when interacting with it.
* Both {IERC777-Sent} and {IERC20-Transfer} events are emitted on token
* movements.
*
* Additionally, the {IERC777-granularity} value is hard-coded to `1`, meaning that there
* are no special restrictions in the amount of tokens that created, moved, or
* destroyed. This makes integration with ERC20 applications seamless.
*/ | NatSpecMultiLine | totalSupply | function totalSupply() public view returns (uint256) {
return _totalSupply;
}
| /**
* @dev See {IERC777-totalSupply}.
*/ | NatSpecMultiLine | v0.5.0+commit.1d4f565a | MIT | bzzr://c1bab4b5e3e40f4294e652b388dfc625ccf21445b4e184e78b601a51d58a2cc2 | {
"func_code_index": [
3076,
3172
]
} | 59,934 |
NNCProjectToken | patterns\token\ERC777\ERC777.sol | 0xa67462ff3314c682277771ae2bbcec08877c877a | Solidity | ERC777 | contract ERC777 is Context, IERC777, IERC20 {
using SafeMath for uint256;
using Address for address;
IERC1820Registry constant internal _erc1820 = IERC1820Registry(0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24);
mapping(address => uint256) private _balances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
// We inline the result of the following hashes because Solidity doesn't resolve them at compile time.
// See https://github.com/ethereum/solidity/issues/4024.
// keccak256("ERC777TokensSender")
bytes32 constant private TOKENS_SENDER_INTERFACE_HASH =
0x29ddb589b1fb5fc7cf394961c1adf5f8c6454761adf795e67fe149f658abe895;
// keccak256("ERC777TokensRecipient")
bytes32 constant private TOKENS_RECIPIENT_INTERFACE_HASH =
0xb281fc8c12954d22544db45de3159a39272895b169a852b314f9cc762e44c53b;
// This isn't ever read from - it's only used to respond to the defaultOperators query.
address[] private _defaultOperatorsArray;
// Immutable, but accounts may revoke them (tracked in __revokedDefaultOperators).
mapping(address => bool) private _defaultOperators;
// For each account, a mapping of its operators and revoked default operators.
mapping(address => mapping(address => bool)) private _operators;
mapping(address => mapping(address => bool)) private _revokedDefaultOperators;
// ERC20-allowances
mapping (address => mapping (address => uint256)) private _allowances;
/**
* @dev `defaultOperators` may be an empty array.
*/
constructor(
string memory name,
string memory symbol,
address[] memory defaultOperators
) public {
_name = name;
_symbol = symbol;
_defaultOperatorsArray = defaultOperators;
for (uint256 i = 0; i < _defaultOperatorsArray.length; i++) {
_defaultOperators[_defaultOperatorsArray[i]] = true;
}
// register interfaces
_erc1820.setInterfaceImplementer(address(this), keccak256("ERC777Token"), address(this));
_erc1820.setInterfaceImplementer(address(this), keccak256("ERC20Token"), address(this));
}
/**
* @dev See {IERC777-name}.
*/
function name() public view returns (string memory) {
return _name;
}
/**
* @dev See {IERC777-symbol}.
*/
function symbol() public view returns (string memory) {
return _symbol;
}
/**
* @dev See {ERC20Detailed-decimals}.
*
* Always returns 18, as per the
* [ERC777 EIP](https://eips.ethereum.org/EIPS/eip-777#backward-compatibility).
*/
function decimals() public pure returns (uint8) {
return 18;
}
/**
* @dev See {IERC777-granularity}.
*
* This implementation always returns `1`.
*/
function granularity() public view returns (uint256) {
return 1;
}
/**
* @dev See {IERC777-totalSupply}.
*/
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
/**
* @dev Returns the amount of tokens owned by an account (`tokenHolder`).
*/
function balanceOf(address tokenHolder) public view returns (uint256) {
return _balances[tokenHolder];
}
/**
* @dev See {IERC777-send}.
*
* Also emits a {Transfer} event for ERC20 compatibility.
*/
function send(address recipient, uint256 amount, bytes calldata data) external {
_send(_msgSender(), _msgSender(), recipient, amount, data, "", true);
}
/**
* @dev See {IERC20-transfer}.
*
* Unlike `send`, `recipient` is _not_ required to implement the {IERC777Recipient}
* interface if it is a contract.
*
* Also emits a {Sent} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool) {
require(recipient != address(0), "ERC777: transfer to the zero address");
address from = _msgSender();
_callTokensToSend(from, from, recipient, amount, "", "");
_move(from, from, recipient, amount, "", "");
_callTokensReceived(from, from, recipient, amount, "", "", false);
return true;
}
/**
* @dev See {IERC777-burn}.
*
* Also emits a {Transfer} event for ERC20 compatibility.
*/
function burn(uint256 amount, bytes calldata data) external {
_burn(_msgSender(), _msgSender(), amount, data, "");
}
/**
* @dev See {IERC777-isOperatorFor}.
*/
function isOperatorFor(
address operator,
address tokenHolder
) public view returns (bool) {
return operator == tokenHolder ||
(_defaultOperators[operator] && !_revokedDefaultOperators[tokenHolder][operator]) ||
_operators[tokenHolder][operator];
}
/**
* @dev See {IERC777-authorizeOperator}.
*/
function authorizeOperator(address operator) external {
_authorizeOperator(operator);
}
function _authorizeOperator(address operator) internal {
require(_msgSender() != operator, "ERC777: authorizing self as operator");
if (_defaultOperators[operator]) {
delete _revokedDefaultOperators[_msgSender()][operator];
} else {
_operators[_msgSender()][operator] = true;
}
emit AuthorizedOperator(operator, _msgSender());
}
/**
* @dev See {IERC777-revokeOperator}.
*/
function revokeOperator(address operator) external {
_revokeOperator(operator);
}
function _revokeOperator(address operator) internal {
require(operator != _msgSender(), "ERC777: revoking self as operator");
if (_defaultOperators[operator]) {
_revokedDefaultOperators[_msgSender()][operator] = true;
} else {
delete _operators[_msgSender()][operator];
}
emit RevokedOperator(operator, _msgSender());
}
/**
* @dev See {IERC777-defaultOperators}.
*/
function defaultOperators() public view returns (address[] memory) {
return _defaultOperatorsArray;
}
/**
* @dev See {IERC777-operatorSend}.
*
* Emits {Sent} and {Transfer} events.
*/
function operatorSend(
address sender,
address recipient,
uint256 amount,
bytes calldata data,
bytes calldata operatorData
)
external
{
require(isOperatorFor(_msgSender(), sender), "ERC777: caller is not an operator for holder");
_send(_msgSender(), sender, recipient, amount, data, operatorData, true);
}
/**
* @dev See {IERC777-operatorBurn}.
*
* Emits {Burned} and {Transfer} events.
*/
function operatorBurn(address account, uint256 amount, bytes calldata data, bytes calldata operatorData) external {
require(isOperatorFor(_msgSender(), account), "ERC777: caller is not an operator for holder");
_burn(_msgSender(), account, amount, data, operatorData);
}
/**
* @dev See {IERC20-allowance}.
*
* Note that operator and allowance concepts are orthogonal: operators may
* not have allowance, and accounts with allowance may not be operators
* themselves.
*/
function allowance(address holder, address spender) public view returns (uint256) {
return _allowances[holder][spender];
}
/**
* @dev See {IERC20-approve}.
*
* Note that accounts cannot have allowance issued by their operators.
*/
function approve(address spender, uint256 value) external returns (bool) {
address holder = _msgSender();
_approve(holder, spender, value);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Note that operator and allowance concepts are orthogonal: operators cannot
* call `transferFrom` (unless they have allowance), and accounts with
* allowance cannot call `operatorSend` (unless they are operators).
*
* Emits {Sent}, {Transfer} and {Approval} events.
*/
function transferFrom(address holder, address recipient, uint256 amount) external returns (bool) {
require(recipient != address(0), "ERC777: transfer to the zero address");
require(holder != address(0), "ERC777: transfer from the zero address");
address spender = _msgSender();
_callTokensToSend(spender, holder, recipient, amount, "", "");
_move(spender, holder, recipient, amount, "", "");
_approve(holder, spender, _allowances[holder][spender].sub(amount, "ERC777: transfer amount exceeds allowance"));
_callTokensReceived(spender, holder, recipient, amount, "", "", false);
return true;
}
/**
* @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* If a send hook is registered for `account`, the corresponding function
* will be called with `operator`, `data` and `operatorData`.
*
* See {IERC777Sender} and {IERC777Recipient}.
*
* Emits {Minted} and {Transfer} events.
*
* Requirements
*
* - `account` cannot be the zero address.
* - if `account` is a contract, it must implement the {IERC777Recipient}
* interface.
*/
function _mint(
address operator,
address account,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
internal
{
require(account != address(0), "ERC777: mint to the zero address");
// Update state variables
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
_callTokensReceived(operator, address(0), account, amount, userData, operatorData, true);
emit Minted(operator, account, amount, userData, operatorData);
emit Transfer(address(0), account, amount);
}
/**
* @dev Send tokens
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
* @param requireReceptionAck if true, contract recipients are required to implement ERC777TokensRecipient
*/
function _send(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck
)
internal
{
require(from != address(0), "ERC777: send from the zero address");
require(to != address(0), "ERC777: send to the zero address");
_callTokensToSend(operator, from, to, amount, userData, operatorData);
_move(operator, from, to, amount, userData, operatorData);
_callTokensReceived(operator, from, to, amount, userData, operatorData, requireReceptionAck);
}
/**
* @dev Burn tokens
* @param operator address operator requesting the operation
* @param from address token holder address
* @param amount uint256 amount of tokens to burn
* @param data bytes extra information provided by the token holder
* @param operatorData bytes extra information provided by the operator (if any)
*/
function _burn(
address operator,
address from,
uint256 amount,
bytes memory data,
bytes memory operatorData
)
internal
{
require(from != address(0), "ERC777: burn from the zero address");
_callTokensToSend(operator, from, address(0), amount, data, operatorData);
// Update state variables
_balances[from] = _balances[from].sub(amount, "ERC777: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Burned(operator, from, amount, data, operatorData);
emit Transfer(from, address(0), amount);
}
function _move(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
internal
{
_balances[from] = _balances[from].sub(amount, "ERC777: transfer amount exceeds balance");
_balances[to] = _balances[to].add(amount);
emit Sent(operator, from, to, amount, userData, operatorData);
emit Transfer(from, to, amount);
}
function _approve(address holder, address spender, uint256 value) internal {
// TODO: restore this require statement if this function becomes internal, or is called at a new callsite. It is
// currently unnecessary.
//require(holder != address(0), "ERC777: approve from the zero address");
require(spender != address(0), "ERC777: approve to the zero address");
_allowances[holder][spender] = value;
emit Approval(holder, spender, value);
}
/**
* @dev Call from.tokensToSend() if the interface is registered
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
*/
function _callTokensToSend(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
private
{
address implementer = _erc1820.getInterfaceImplementer(from, TOKENS_SENDER_INTERFACE_HASH);
if (implementer != address(0)) {
IERC777Sender(implementer).tokensToSend(operator, from, to, amount, userData, operatorData);
}
}
/**
* @dev Call to.tokensReceived() if the interface is registered. Reverts if the recipient is a contract but
* tokensReceived() was not registered for the recipient
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
* @param requireReceptionAck if true, contract recipients are required to implement ERC777TokensRecipient
*/
function _callTokensReceived(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck
)
private
{
address implementer = _erc1820.getInterfaceImplementer(to, TOKENS_RECIPIENT_INTERFACE_HASH);
if (implementer != address(0)) {
IERC777Recipient(implementer).tokensReceived(operator, from, to, amount, userData, operatorData);
} else if (requireReceptionAck) {
require(!to.isContract(), "ERC777: token recipient contract has no implement for ERC777TokensRecipient");
}
}
} | /**
* @dev Implementation of the {IERC777} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
*
* Support for ERC20 is included in this contract, as specified by the EIP: both
* the ERC777 and ERC20 interfaces can be safely used when interacting with it.
* Both {IERC777-Sent} and {IERC20-Transfer} events are emitted on token
* movements.
*
* Additionally, the {IERC777-granularity} value is hard-coded to `1`, meaning that there
* are no special restrictions in the amount of tokens that created, moved, or
* destroyed. This makes integration with ERC20 applications seamless.
*/ | NatSpecMultiLine | balanceOf | function balanceOf(address tokenHolder) public view returns (uint256) {
return _balances[tokenHolder];
}
| /**
* @dev Returns the amount of tokens owned by an account (`tokenHolder`).
*/ | NatSpecMultiLine | v0.5.0+commit.1d4f565a | MIT | bzzr://c1bab4b5e3e40f4294e652b388dfc625ccf21445b4e184e78b601a51d58a2cc2 | {
"func_code_index": [
3272,
3395
]
} | 59,935 |
NNCProjectToken | patterns\token\ERC777\ERC777.sol | 0xa67462ff3314c682277771ae2bbcec08877c877a | Solidity | ERC777 | contract ERC777 is Context, IERC777, IERC20 {
using SafeMath for uint256;
using Address for address;
IERC1820Registry constant internal _erc1820 = IERC1820Registry(0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24);
mapping(address => uint256) private _balances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
// We inline the result of the following hashes because Solidity doesn't resolve them at compile time.
// See https://github.com/ethereum/solidity/issues/4024.
// keccak256("ERC777TokensSender")
bytes32 constant private TOKENS_SENDER_INTERFACE_HASH =
0x29ddb589b1fb5fc7cf394961c1adf5f8c6454761adf795e67fe149f658abe895;
// keccak256("ERC777TokensRecipient")
bytes32 constant private TOKENS_RECIPIENT_INTERFACE_HASH =
0xb281fc8c12954d22544db45de3159a39272895b169a852b314f9cc762e44c53b;
// This isn't ever read from - it's only used to respond to the defaultOperators query.
address[] private _defaultOperatorsArray;
// Immutable, but accounts may revoke them (tracked in __revokedDefaultOperators).
mapping(address => bool) private _defaultOperators;
// For each account, a mapping of its operators and revoked default operators.
mapping(address => mapping(address => bool)) private _operators;
mapping(address => mapping(address => bool)) private _revokedDefaultOperators;
// ERC20-allowances
mapping (address => mapping (address => uint256)) private _allowances;
/**
* @dev `defaultOperators` may be an empty array.
*/
constructor(
string memory name,
string memory symbol,
address[] memory defaultOperators
) public {
_name = name;
_symbol = symbol;
_defaultOperatorsArray = defaultOperators;
for (uint256 i = 0; i < _defaultOperatorsArray.length; i++) {
_defaultOperators[_defaultOperatorsArray[i]] = true;
}
// register interfaces
_erc1820.setInterfaceImplementer(address(this), keccak256("ERC777Token"), address(this));
_erc1820.setInterfaceImplementer(address(this), keccak256("ERC20Token"), address(this));
}
/**
* @dev See {IERC777-name}.
*/
function name() public view returns (string memory) {
return _name;
}
/**
* @dev See {IERC777-symbol}.
*/
function symbol() public view returns (string memory) {
return _symbol;
}
/**
* @dev See {ERC20Detailed-decimals}.
*
* Always returns 18, as per the
* [ERC777 EIP](https://eips.ethereum.org/EIPS/eip-777#backward-compatibility).
*/
function decimals() public pure returns (uint8) {
return 18;
}
/**
* @dev See {IERC777-granularity}.
*
* This implementation always returns `1`.
*/
function granularity() public view returns (uint256) {
return 1;
}
/**
* @dev See {IERC777-totalSupply}.
*/
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
/**
* @dev Returns the amount of tokens owned by an account (`tokenHolder`).
*/
function balanceOf(address tokenHolder) public view returns (uint256) {
return _balances[tokenHolder];
}
/**
* @dev See {IERC777-send}.
*
* Also emits a {Transfer} event for ERC20 compatibility.
*/
function send(address recipient, uint256 amount, bytes calldata data) external {
_send(_msgSender(), _msgSender(), recipient, amount, data, "", true);
}
/**
* @dev See {IERC20-transfer}.
*
* Unlike `send`, `recipient` is _not_ required to implement the {IERC777Recipient}
* interface if it is a contract.
*
* Also emits a {Sent} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool) {
require(recipient != address(0), "ERC777: transfer to the zero address");
address from = _msgSender();
_callTokensToSend(from, from, recipient, amount, "", "");
_move(from, from, recipient, amount, "", "");
_callTokensReceived(from, from, recipient, amount, "", "", false);
return true;
}
/**
* @dev See {IERC777-burn}.
*
* Also emits a {Transfer} event for ERC20 compatibility.
*/
function burn(uint256 amount, bytes calldata data) external {
_burn(_msgSender(), _msgSender(), amount, data, "");
}
/**
* @dev See {IERC777-isOperatorFor}.
*/
function isOperatorFor(
address operator,
address tokenHolder
) public view returns (bool) {
return operator == tokenHolder ||
(_defaultOperators[operator] && !_revokedDefaultOperators[tokenHolder][operator]) ||
_operators[tokenHolder][operator];
}
/**
* @dev See {IERC777-authorizeOperator}.
*/
function authorizeOperator(address operator) external {
_authorizeOperator(operator);
}
function _authorizeOperator(address operator) internal {
require(_msgSender() != operator, "ERC777: authorizing self as operator");
if (_defaultOperators[operator]) {
delete _revokedDefaultOperators[_msgSender()][operator];
} else {
_operators[_msgSender()][operator] = true;
}
emit AuthorizedOperator(operator, _msgSender());
}
/**
* @dev See {IERC777-revokeOperator}.
*/
function revokeOperator(address operator) external {
_revokeOperator(operator);
}
function _revokeOperator(address operator) internal {
require(operator != _msgSender(), "ERC777: revoking self as operator");
if (_defaultOperators[operator]) {
_revokedDefaultOperators[_msgSender()][operator] = true;
} else {
delete _operators[_msgSender()][operator];
}
emit RevokedOperator(operator, _msgSender());
}
/**
* @dev See {IERC777-defaultOperators}.
*/
function defaultOperators() public view returns (address[] memory) {
return _defaultOperatorsArray;
}
/**
* @dev See {IERC777-operatorSend}.
*
* Emits {Sent} and {Transfer} events.
*/
function operatorSend(
address sender,
address recipient,
uint256 amount,
bytes calldata data,
bytes calldata operatorData
)
external
{
require(isOperatorFor(_msgSender(), sender), "ERC777: caller is not an operator for holder");
_send(_msgSender(), sender, recipient, amount, data, operatorData, true);
}
/**
* @dev See {IERC777-operatorBurn}.
*
* Emits {Burned} and {Transfer} events.
*/
function operatorBurn(address account, uint256 amount, bytes calldata data, bytes calldata operatorData) external {
require(isOperatorFor(_msgSender(), account), "ERC777: caller is not an operator for holder");
_burn(_msgSender(), account, amount, data, operatorData);
}
/**
* @dev See {IERC20-allowance}.
*
* Note that operator and allowance concepts are orthogonal: operators may
* not have allowance, and accounts with allowance may not be operators
* themselves.
*/
function allowance(address holder, address spender) public view returns (uint256) {
return _allowances[holder][spender];
}
/**
* @dev See {IERC20-approve}.
*
* Note that accounts cannot have allowance issued by their operators.
*/
function approve(address spender, uint256 value) external returns (bool) {
address holder = _msgSender();
_approve(holder, spender, value);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Note that operator and allowance concepts are orthogonal: operators cannot
* call `transferFrom` (unless they have allowance), and accounts with
* allowance cannot call `operatorSend` (unless they are operators).
*
* Emits {Sent}, {Transfer} and {Approval} events.
*/
function transferFrom(address holder, address recipient, uint256 amount) external returns (bool) {
require(recipient != address(0), "ERC777: transfer to the zero address");
require(holder != address(0), "ERC777: transfer from the zero address");
address spender = _msgSender();
_callTokensToSend(spender, holder, recipient, amount, "", "");
_move(spender, holder, recipient, amount, "", "");
_approve(holder, spender, _allowances[holder][spender].sub(amount, "ERC777: transfer amount exceeds allowance"));
_callTokensReceived(spender, holder, recipient, amount, "", "", false);
return true;
}
/**
* @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* If a send hook is registered for `account`, the corresponding function
* will be called with `operator`, `data` and `operatorData`.
*
* See {IERC777Sender} and {IERC777Recipient}.
*
* Emits {Minted} and {Transfer} events.
*
* Requirements
*
* - `account` cannot be the zero address.
* - if `account` is a contract, it must implement the {IERC777Recipient}
* interface.
*/
function _mint(
address operator,
address account,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
internal
{
require(account != address(0), "ERC777: mint to the zero address");
// Update state variables
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
_callTokensReceived(operator, address(0), account, amount, userData, operatorData, true);
emit Minted(operator, account, amount, userData, operatorData);
emit Transfer(address(0), account, amount);
}
/**
* @dev Send tokens
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
* @param requireReceptionAck if true, contract recipients are required to implement ERC777TokensRecipient
*/
function _send(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck
)
internal
{
require(from != address(0), "ERC777: send from the zero address");
require(to != address(0), "ERC777: send to the zero address");
_callTokensToSend(operator, from, to, amount, userData, operatorData);
_move(operator, from, to, amount, userData, operatorData);
_callTokensReceived(operator, from, to, amount, userData, operatorData, requireReceptionAck);
}
/**
* @dev Burn tokens
* @param operator address operator requesting the operation
* @param from address token holder address
* @param amount uint256 amount of tokens to burn
* @param data bytes extra information provided by the token holder
* @param operatorData bytes extra information provided by the operator (if any)
*/
function _burn(
address operator,
address from,
uint256 amount,
bytes memory data,
bytes memory operatorData
)
internal
{
require(from != address(0), "ERC777: burn from the zero address");
_callTokensToSend(operator, from, address(0), amount, data, operatorData);
// Update state variables
_balances[from] = _balances[from].sub(amount, "ERC777: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Burned(operator, from, amount, data, operatorData);
emit Transfer(from, address(0), amount);
}
function _move(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
internal
{
_balances[from] = _balances[from].sub(amount, "ERC777: transfer amount exceeds balance");
_balances[to] = _balances[to].add(amount);
emit Sent(operator, from, to, amount, userData, operatorData);
emit Transfer(from, to, amount);
}
function _approve(address holder, address spender, uint256 value) internal {
// TODO: restore this require statement if this function becomes internal, or is called at a new callsite. It is
// currently unnecessary.
//require(holder != address(0), "ERC777: approve from the zero address");
require(spender != address(0), "ERC777: approve to the zero address");
_allowances[holder][spender] = value;
emit Approval(holder, spender, value);
}
/**
* @dev Call from.tokensToSend() if the interface is registered
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
*/
function _callTokensToSend(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
private
{
address implementer = _erc1820.getInterfaceImplementer(from, TOKENS_SENDER_INTERFACE_HASH);
if (implementer != address(0)) {
IERC777Sender(implementer).tokensToSend(operator, from, to, amount, userData, operatorData);
}
}
/**
* @dev Call to.tokensReceived() if the interface is registered. Reverts if the recipient is a contract but
* tokensReceived() was not registered for the recipient
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
* @param requireReceptionAck if true, contract recipients are required to implement ERC777TokensRecipient
*/
function _callTokensReceived(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck
)
private
{
address implementer = _erc1820.getInterfaceImplementer(to, TOKENS_RECIPIENT_INTERFACE_HASH);
if (implementer != address(0)) {
IERC777Recipient(implementer).tokensReceived(operator, from, to, amount, userData, operatorData);
} else if (requireReceptionAck) {
require(!to.isContract(), "ERC777: token recipient contract has no implement for ERC777TokensRecipient");
}
}
} | /**
* @dev Implementation of the {IERC777} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
*
* Support for ERC20 is included in this contract, as specified by the EIP: both
* the ERC777 and ERC20 interfaces can be safely used when interacting with it.
* Both {IERC777-Sent} and {IERC20-Transfer} events are emitted on token
* movements.
*
* Additionally, the {IERC777-granularity} value is hard-coded to `1`, meaning that there
* are no special restrictions in the amount of tokens that created, moved, or
* destroyed. This makes integration with ERC20 applications seamless.
*/ | NatSpecMultiLine | send | function send(address recipient, uint256 amount, bytes calldata data) external {
_send(_msgSender(), _msgSender(), recipient, amount, data, "", true);
}
| /**
* @dev See {IERC777-send}.
*
* Also emits a {Transfer} event for ERC20 compatibility.
*/ | NatSpecMultiLine | v0.5.0+commit.1d4f565a | MIT | bzzr://c1bab4b5e3e40f4294e652b388dfc625ccf21445b4e184e78b601a51d58a2cc2 | {
"func_code_index": [
3520,
3691
]
} | 59,936 |
NNCProjectToken | patterns\token\ERC777\ERC777.sol | 0xa67462ff3314c682277771ae2bbcec08877c877a | Solidity | ERC777 | contract ERC777 is Context, IERC777, IERC20 {
using SafeMath for uint256;
using Address for address;
IERC1820Registry constant internal _erc1820 = IERC1820Registry(0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24);
mapping(address => uint256) private _balances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
// We inline the result of the following hashes because Solidity doesn't resolve them at compile time.
// See https://github.com/ethereum/solidity/issues/4024.
// keccak256("ERC777TokensSender")
bytes32 constant private TOKENS_SENDER_INTERFACE_HASH =
0x29ddb589b1fb5fc7cf394961c1adf5f8c6454761adf795e67fe149f658abe895;
// keccak256("ERC777TokensRecipient")
bytes32 constant private TOKENS_RECIPIENT_INTERFACE_HASH =
0xb281fc8c12954d22544db45de3159a39272895b169a852b314f9cc762e44c53b;
// This isn't ever read from - it's only used to respond to the defaultOperators query.
address[] private _defaultOperatorsArray;
// Immutable, but accounts may revoke them (tracked in __revokedDefaultOperators).
mapping(address => bool) private _defaultOperators;
// For each account, a mapping of its operators and revoked default operators.
mapping(address => mapping(address => bool)) private _operators;
mapping(address => mapping(address => bool)) private _revokedDefaultOperators;
// ERC20-allowances
mapping (address => mapping (address => uint256)) private _allowances;
/**
* @dev `defaultOperators` may be an empty array.
*/
constructor(
string memory name,
string memory symbol,
address[] memory defaultOperators
) public {
_name = name;
_symbol = symbol;
_defaultOperatorsArray = defaultOperators;
for (uint256 i = 0; i < _defaultOperatorsArray.length; i++) {
_defaultOperators[_defaultOperatorsArray[i]] = true;
}
// register interfaces
_erc1820.setInterfaceImplementer(address(this), keccak256("ERC777Token"), address(this));
_erc1820.setInterfaceImplementer(address(this), keccak256("ERC20Token"), address(this));
}
/**
* @dev See {IERC777-name}.
*/
function name() public view returns (string memory) {
return _name;
}
/**
* @dev See {IERC777-symbol}.
*/
function symbol() public view returns (string memory) {
return _symbol;
}
/**
* @dev See {ERC20Detailed-decimals}.
*
* Always returns 18, as per the
* [ERC777 EIP](https://eips.ethereum.org/EIPS/eip-777#backward-compatibility).
*/
function decimals() public pure returns (uint8) {
return 18;
}
/**
* @dev See {IERC777-granularity}.
*
* This implementation always returns `1`.
*/
function granularity() public view returns (uint256) {
return 1;
}
/**
* @dev See {IERC777-totalSupply}.
*/
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
/**
* @dev Returns the amount of tokens owned by an account (`tokenHolder`).
*/
function balanceOf(address tokenHolder) public view returns (uint256) {
return _balances[tokenHolder];
}
/**
* @dev See {IERC777-send}.
*
* Also emits a {Transfer} event for ERC20 compatibility.
*/
function send(address recipient, uint256 amount, bytes calldata data) external {
_send(_msgSender(), _msgSender(), recipient, amount, data, "", true);
}
/**
* @dev See {IERC20-transfer}.
*
* Unlike `send`, `recipient` is _not_ required to implement the {IERC777Recipient}
* interface if it is a contract.
*
* Also emits a {Sent} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool) {
require(recipient != address(0), "ERC777: transfer to the zero address");
address from = _msgSender();
_callTokensToSend(from, from, recipient, amount, "", "");
_move(from, from, recipient, amount, "", "");
_callTokensReceived(from, from, recipient, amount, "", "", false);
return true;
}
/**
* @dev See {IERC777-burn}.
*
* Also emits a {Transfer} event for ERC20 compatibility.
*/
function burn(uint256 amount, bytes calldata data) external {
_burn(_msgSender(), _msgSender(), amount, data, "");
}
/**
* @dev See {IERC777-isOperatorFor}.
*/
function isOperatorFor(
address operator,
address tokenHolder
) public view returns (bool) {
return operator == tokenHolder ||
(_defaultOperators[operator] && !_revokedDefaultOperators[tokenHolder][operator]) ||
_operators[tokenHolder][operator];
}
/**
* @dev See {IERC777-authorizeOperator}.
*/
function authorizeOperator(address operator) external {
_authorizeOperator(operator);
}
function _authorizeOperator(address operator) internal {
require(_msgSender() != operator, "ERC777: authorizing self as operator");
if (_defaultOperators[operator]) {
delete _revokedDefaultOperators[_msgSender()][operator];
} else {
_operators[_msgSender()][operator] = true;
}
emit AuthorizedOperator(operator, _msgSender());
}
/**
* @dev See {IERC777-revokeOperator}.
*/
function revokeOperator(address operator) external {
_revokeOperator(operator);
}
function _revokeOperator(address operator) internal {
require(operator != _msgSender(), "ERC777: revoking self as operator");
if (_defaultOperators[operator]) {
_revokedDefaultOperators[_msgSender()][operator] = true;
} else {
delete _operators[_msgSender()][operator];
}
emit RevokedOperator(operator, _msgSender());
}
/**
* @dev See {IERC777-defaultOperators}.
*/
function defaultOperators() public view returns (address[] memory) {
return _defaultOperatorsArray;
}
/**
* @dev See {IERC777-operatorSend}.
*
* Emits {Sent} and {Transfer} events.
*/
function operatorSend(
address sender,
address recipient,
uint256 amount,
bytes calldata data,
bytes calldata operatorData
)
external
{
require(isOperatorFor(_msgSender(), sender), "ERC777: caller is not an operator for holder");
_send(_msgSender(), sender, recipient, amount, data, operatorData, true);
}
/**
* @dev See {IERC777-operatorBurn}.
*
* Emits {Burned} and {Transfer} events.
*/
function operatorBurn(address account, uint256 amount, bytes calldata data, bytes calldata operatorData) external {
require(isOperatorFor(_msgSender(), account), "ERC777: caller is not an operator for holder");
_burn(_msgSender(), account, amount, data, operatorData);
}
/**
* @dev See {IERC20-allowance}.
*
* Note that operator and allowance concepts are orthogonal: operators may
* not have allowance, and accounts with allowance may not be operators
* themselves.
*/
function allowance(address holder, address spender) public view returns (uint256) {
return _allowances[holder][spender];
}
/**
* @dev See {IERC20-approve}.
*
* Note that accounts cannot have allowance issued by their operators.
*/
function approve(address spender, uint256 value) external returns (bool) {
address holder = _msgSender();
_approve(holder, spender, value);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Note that operator and allowance concepts are orthogonal: operators cannot
* call `transferFrom` (unless they have allowance), and accounts with
* allowance cannot call `operatorSend` (unless they are operators).
*
* Emits {Sent}, {Transfer} and {Approval} events.
*/
function transferFrom(address holder, address recipient, uint256 amount) external returns (bool) {
require(recipient != address(0), "ERC777: transfer to the zero address");
require(holder != address(0), "ERC777: transfer from the zero address");
address spender = _msgSender();
_callTokensToSend(spender, holder, recipient, amount, "", "");
_move(spender, holder, recipient, amount, "", "");
_approve(holder, spender, _allowances[holder][spender].sub(amount, "ERC777: transfer amount exceeds allowance"));
_callTokensReceived(spender, holder, recipient, amount, "", "", false);
return true;
}
/**
* @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* If a send hook is registered for `account`, the corresponding function
* will be called with `operator`, `data` and `operatorData`.
*
* See {IERC777Sender} and {IERC777Recipient}.
*
* Emits {Minted} and {Transfer} events.
*
* Requirements
*
* - `account` cannot be the zero address.
* - if `account` is a contract, it must implement the {IERC777Recipient}
* interface.
*/
function _mint(
address operator,
address account,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
internal
{
require(account != address(0), "ERC777: mint to the zero address");
// Update state variables
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
_callTokensReceived(operator, address(0), account, amount, userData, operatorData, true);
emit Minted(operator, account, amount, userData, operatorData);
emit Transfer(address(0), account, amount);
}
/**
* @dev Send tokens
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
* @param requireReceptionAck if true, contract recipients are required to implement ERC777TokensRecipient
*/
function _send(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck
)
internal
{
require(from != address(0), "ERC777: send from the zero address");
require(to != address(0), "ERC777: send to the zero address");
_callTokensToSend(operator, from, to, amount, userData, operatorData);
_move(operator, from, to, amount, userData, operatorData);
_callTokensReceived(operator, from, to, amount, userData, operatorData, requireReceptionAck);
}
/**
* @dev Burn tokens
* @param operator address operator requesting the operation
* @param from address token holder address
* @param amount uint256 amount of tokens to burn
* @param data bytes extra information provided by the token holder
* @param operatorData bytes extra information provided by the operator (if any)
*/
function _burn(
address operator,
address from,
uint256 amount,
bytes memory data,
bytes memory operatorData
)
internal
{
require(from != address(0), "ERC777: burn from the zero address");
_callTokensToSend(operator, from, address(0), amount, data, operatorData);
// Update state variables
_balances[from] = _balances[from].sub(amount, "ERC777: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Burned(operator, from, amount, data, operatorData);
emit Transfer(from, address(0), amount);
}
function _move(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
internal
{
_balances[from] = _balances[from].sub(amount, "ERC777: transfer amount exceeds balance");
_balances[to] = _balances[to].add(amount);
emit Sent(operator, from, to, amount, userData, operatorData);
emit Transfer(from, to, amount);
}
function _approve(address holder, address spender, uint256 value) internal {
// TODO: restore this require statement if this function becomes internal, or is called at a new callsite. It is
// currently unnecessary.
//require(holder != address(0), "ERC777: approve from the zero address");
require(spender != address(0), "ERC777: approve to the zero address");
_allowances[holder][spender] = value;
emit Approval(holder, spender, value);
}
/**
* @dev Call from.tokensToSend() if the interface is registered
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
*/
function _callTokensToSend(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
private
{
address implementer = _erc1820.getInterfaceImplementer(from, TOKENS_SENDER_INTERFACE_HASH);
if (implementer != address(0)) {
IERC777Sender(implementer).tokensToSend(operator, from, to, amount, userData, operatorData);
}
}
/**
* @dev Call to.tokensReceived() if the interface is registered. Reverts if the recipient is a contract but
* tokensReceived() was not registered for the recipient
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
* @param requireReceptionAck if true, contract recipients are required to implement ERC777TokensRecipient
*/
function _callTokensReceived(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck
)
private
{
address implementer = _erc1820.getInterfaceImplementer(to, TOKENS_RECIPIENT_INTERFACE_HASH);
if (implementer != address(0)) {
IERC777Recipient(implementer).tokensReceived(operator, from, to, amount, userData, operatorData);
} else if (requireReceptionAck) {
require(!to.isContract(), "ERC777: token recipient contract has no implement for ERC777TokensRecipient");
}
}
} | /**
* @dev Implementation of the {IERC777} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
*
* Support for ERC20 is included in this contract, as specified by the EIP: both
* the ERC777 and ERC20 interfaces can be safely used when interacting with it.
* Both {IERC777-Sent} and {IERC20-Transfer} events are emitted on token
* movements.
*
* Additionally, the {IERC777-granularity} value is hard-coded to `1`, meaning that there
* are no special restrictions in the amount of tokens that created, moved, or
* destroyed. This makes integration with ERC20 applications seamless.
*/ | NatSpecMultiLine | transfer | function transfer(address recipient, uint256 amount) external returns (bool) {
require(recipient != address(0), "ERC777: transfer to the zero address");
address from = _msgSender();
_callTokensToSend(from, from, recipient, amount, "", "");
_move(from, from, recipient, amount, "", "");
_callTokensReceived(from, from, recipient, amount, "", "", false);
return true;
}
| /**
* @dev See {IERC20-transfer}.
*
* Unlike `send`, `recipient` is _not_ required to implement the {IERC777Recipient}
* interface if it is a contract.
*
* Also emits a {Sent} event.
*/ | NatSpecMultiLine | v0.5.0+commit.1d4f565a | MIT | bzzr://c1bab4b5e3e40f4294e652b388dfc625ccf21445b4e184e78b601a51d58a2cc2 | {
"func_code_index": [
3927,
4368
]
} | 59,937 |
NNCProjectToken | patterns\token\ERC777\ERC777.sol | 0xa67462ff3314c682277771ae2bbcec08877c877a | Solidity | ERC777 | contract ERC777 is Context, IERC777, IERC20 {
using SafeMath for uint256;
using Address for address;
IERC1820Registry constant internal _erc1820 = IERC1820Registry(0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24);
mapping(address => uint256) private _balances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
// We inline the result of the following hashes because Solidity doesn't resolve them at compile time.
// See https://github.com/ethereum/solidity/issues/4024.
// keccak256("ERC777TokensSender")
bytes32 constant private TOKENS_SENDER_INTERFACE_HASH =
0x29ddb589b1fb5fc7cf394961c1adf5f8c6454761adf795e67fe149f658abe895;
// keccak256("ERC777TokensRecipient")
bytes32 constant private TOKENS_RECIPIENT_INTERFACE_HASH =
0xb281fc8c12954d22544db45de3159a39272895b169a852b314f9cc762e44c53b;
// This isn't ever read from - it's only used to respond to the defaultOperators query.
address[] private _defaultOperatorsArray;
// Immutable, but accounts may revoke them (tracked in __revokedDefaultOperators).
mapping(address => bool) private _defaultOperators;
// For each account, a mapping of its operators and revoked default operators.
mapping(address => mapping(address => bool)) private _operators;
mapping(address => mapping(address => bool)) private _revokedDefaultOperators;
// ERC20-allowances
mapping (address => mapping (address => uint256)) private _allowances;
/**
* @dev `defaultOperators` may be an empty array.
*/
constructor(
string memory name,
string memory symbol,
address[] memory defaultOperators
) public {
_name = name;
_symbol = symbol;
_defaultOperatorsArray = defaultOperators;
for (uint256 i = 0; i < _defaultOperatorsArray.length; i++) {
_defaultOperators[_defaultOperatorsArray[i]] = true;
}
// register interfaces
_erc1820.setInterfaceImplementer(address(this), keccak256("ERC777Token"), address(this));
_erc1820.setInterfaceImplementer(address(this), keccak256("ERC20Token"), address(this));
}
/**
* @dev See {IERC777-name}.
*/
function name() public view returns (string memory) {
return _name;
}
/**
* @dev See {IERC777-symbol}.
*/
function symbol() public view returns (string memory) {
return _symbol;
}
/**
* @dev See {ERC20Detailed-decimals}.
*
* Always returns 18, as per the
* [ERC777 EIP](https://eips.ethereum.org/EIPS/eip-777#backward-compatibility).
*/
function decimals() public pure returns (uint8) {
return 18;
}
/**
* @dev See {IERC777-granularity}.
*
* This implementation always returns `1`.
*/
function granularity() public view returns (uint256) {
return 1;
}
/**
* @dev See {IERC777-totalSupply}.
*/
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
/**
* @dev Returns the amount of tokens owned by an account (`tokenHolder`).
*/
function balanceOf(address tokenHolder) public view returns (uint256) {
return _balances[tokenHolder];
}
/**
* @dev See {IERC777-send}.
*
* Also emits a {Transfer} event for ERC20 compatibility.
*/
function send(address recipient, uint256 amount, bytes calldata data) external {
_send(_msgSender(), _msgSender(), recipient, amount, data, "", true);
}
/**
* @dev See {IERC20-transfer}.
*
* Unlike `send`, `recipient` is _not_ required to implement the {IERC777Recipient}
* interface if it is a contract.
*
* Also emits a {Sent} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool) {
require(recipient != address(0), "ERC777: transfer to the zero address");
address from = _msgSender();
_callTokensToSend(from, from, recipient, amount, "", "");
_move(from, from, recipient, amount, "", "");
_callTokensReceived(from, from, recipient, amount, "", "", false);
return true;
}
/**
* @dev See {IERC777-burn}.
*
* Also emits a {Transfer} event for ERC20 compatibility.
*/
function burn(uint256 amount, bytes calldata data) external {
_burn(_msgSender(), _msgSender(), amount, data, "");
}
/**
* @dev See {IERC777-isOperatorFor}.
*/
function isOperatorFor(
address operator,
address tokenHolder
) public view returns (bool) {
return operator == tokenHolder ||
(_defaultOperators[operator] && !_revokedDefaultOperators[tokenHolder][operator]) ||
_operators[tokenHolder][operator];
}
/**
* @dev See {IERC777-authorizeOperator}.
*/
function authorizeOperator(address operator) external {
_authorizeOperator(operator);
}
function _authorizeOperator(address operator) internal {
require(_msgSender() != operator, "ERC777: authorizing self as operator");
if (_defaultOperators[operator]) {
delete _revokedDefaultOperators[_msgSender()][operator];
} else {
_operators[_msgSender()][operator] = true;
}
emit AuthorizedOperator(operator, _msgSender());
}
/**
* @dev See {IERC777-revokeOperator}.
*/
function revokeOperator(address operator) external {
_revokeOperator(operator);
}
function _revokeOperator(address operator) internal {
require(operator != _msgSender(), "ERC777: revoking self as operator");
if (_defaultOperators[operator]) {
_revokedDefaultOperators[_msgSender()][operator] = true;
} else {
delete _operators[_msgSender()][operator];
}
emit RevokedOperator(operator, _msgSender());
}
/**
* @dev See {IERC777-defaultOperators}.
*/
function defaultOperators() public view returns (address[] memory) {
return _defaultOperatorsArray;
}
/**
* @dev See {IERC777-operatorSend}.
*
* Emits {Sent} and {Transfer} events.
*/
function operatorSend(
address sender,
address recipient,
uint256 amount,
bytes calldata data,
bytes calldata operatorData
)
external
{
require(isOperatorFor(_msgSender(), sender), "ERC777: caller is not an operator for holder");
_send(_msgSender(), sender, recipient, amount, data, operatorData, true);
}
/**
* @dev See {IERC777-operatorBurn}.
*
* Emits {Burned} and {Transfer} events.
*/
function operatorBurn(address account, uint256 amount, bytes calldata data, bytes calldata operatorData) external {
require(isOperatorFor(_msgSender(), account), "ERC777: caller is not an operator for holder");
_burn(_msgSender(), account, amount, data, operatorData);
}
/**
* @dev See {IERC20-allowance}.
*
* Note that operator and allowance concepts are orthogonal: operators may
* not have allowance, and accounts with allowance may not be operators
* themselves.
*/
function allowance(address holder, address spender) public view returns (uint256) {
return _allowances[holder][spender];
}
/**
* @dev See {IERC20-approve}.
*
* Note that accounts cannot have allowance issued by their operators.
*/
function approve(address spender, uint256 value) external returns (bool) {
address holder = _msgSender();
_approve(holder, spender, value);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Note that operator and allowance concepts are orthogonal: operators cannot
* call `transferFrom` (unless they have allowance), and accounts with
* allowance cannot call `operatorSend` (unless they are operators).
*
* Emits {Sent}, {Transfer} and {Approval} events.
*/
function transferFrom(address holder, address recipient, uint256 amount) external returns (bool) {
require(recipient != address(0), "ERC777: transfer to the zero address");
require(holder != address(0), "ERC777: transfer from the zero address");
address spender = _msgSender();
_callTokensToSend(spender, holder, recipient, amount, "", "");
_move(spender, holder, recipient, amount, "", "");
_approve(holder, spender, _allowances[holder][spender].sub(amount, "ERC777: transfer amount exceeds allowance"));
_callTokensReceived(spender, holder, recipient, amount, "", "", false);
return true;
}
/**
* @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* If a send hook is registered for `account`, the corresponding function
* will be called with `operator`, `data` and `operatorData`.
*
* See {IERC777Sender} and {IERC777Recipient}.
*
* Emits {Minted} and {Transfer} events.
*
* Requirements
*
* - `account` cannot be the zero address.
* - if `account` is a contract, it must implement the {IERC777Recipient}
* interface.
*/
function _mint(
address operator,
address account,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
internal
{
require(account != address(0), "ERC777: mint to the zero address");
// Update state variables
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
_callTokensReceived(operator, address(0), account, amount, userData, operatorData, true);
emit Minted(operator, account, amount, userData, operatorData);
emit Transfer(address(0), account, amount);
}
/**
* @dev Send tokens
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
* @param requireReceptionAck if true, contract recipients are required to implement ERC777TokensRecipient
*/
function _send(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck
)
internal
{
require(from != address(0), "ERC777: send from the zero address");
require(to != address(0), "ERC777: send to the zero address");
_callTokensToSend(operator, from, to, amount, userData, operatorData);
_move(operator, from, to, amount, userData, operatorData);
_callTokensReceived(operator, from, to, amount, userData, operatorData, requireReceptionAck);
}
/**
* @dev Burn tokens
* @param operator address operator requesting the operation
* @param from address token holder address
* @param amount uint256 amount of tokens to burn
* @param data bytes extra information provided by the token holder
* @param operatorData bytes extra information provided by the operator (if any)
*/
function _burn(
address operator,
address from,
uint256 amount,
bytes memory data,
bytes memory operatorData
)
internal
{
require(from != address(0), "ERC777: burn from the zero address");
_callTokensToSend(operator, from, address(0), amount, data, operatorData);
// Update state variables
_balances[from] = _balances[from].sub(amount, "ERC777: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Burned(operator, from, amount, data, operatorData);
emit Transfer(from, address(0), amount);
}
function _move(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
internal
{
_balances[from] = _balances[from].sub(amount, "ERC777: transfer amount exceeds balance");
_balances[to] = _balances[to].add(amount);
emit Sent(operator, from, to, amount, userData, operatorData);
emit Transfer(from, to, amount);
}
function _approve(address holder, address spender, uint256 value) internal {
// TODO: restore this require statement if this function becomes internal, or is called at a new callsite. It is
// currently unnecessary.
//require(holder != address(0), "ERC777: approve from the zero address");
require(spender != address(0), "ERC777: approve to the zero address");
_allowances[holder][spender] = value;
emit Approval(holder, spender, value);
}
/**
* @dev Call from.tokensToSend() if the interface is registered
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
*/
function _callTokensToSend(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
private
{
address implementer = _erc1820.getInterfaceImplementer(from, TOKENS_SENDER_INTERFACE_HASH);
if (implementer != address(0)) {
IERC777Sender(implementer).tokensToSend(operator, from, to, amount, userData, operatorData);
}
}
/**
* @dev Call to.tokensReceived() if the interface is registered. Reverts if the recipient is a contract but
* tokensReceived() was not registered for the recipient
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
* @param requireReceptionAck if true, contract recipients are required to implement ERC777TokensRecipient
*/
function _callTokensReceived(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck
)
private
{
address implementer = _erc1820.getInterfaceImplementer(to, TOKENS_RECIPIENT_INTERFACE_HASH);
if (implementer != address(0)) {
IERC777Recipient(implementer).tokensReceived(operator, from, to, amount, userData, operatorData);
} else if (requireReceptionAck) {
require(!to.isContract(), "ERC777: token recipient contract has no implement for ERC777TokensRecipient");
}
}
} | /**
* @dev Implementation of the {IERC777} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
*
* Support for ERC20 is included in this contract, as specified by the EIP: both
* the ERC777 and ERC20 interfaces can be safely used when interacting with it.
* Both {IERC777-Sent} and {IERC20-Transfer} events are emitted on token
* movements.
*
* Additionally, the {IERC777-granularity} value is hard-coded to `1`, meaning that there
* are no special restrictions in the amount of tokens that created, moved, or
* destroyed. This makes integration with ERC20 applications seamless.
*/ | NatSpecMultiLine | burn | function burn(uint256 amount, bytes calldata data) external {
_burn(_msgSender(), _msgSender(), amount, data, "");
}
| /**
* @dev See {IERC777-burn}.
*
* Also emits a {Transfer} event for ERC20 compatibility.
*/ | NatSpecMultiLine | v0.5.0+commit.1d4f565a | MIT | bzzr://c1bab4b5e3e40f4294e652b388dfc625ccf21445b4e184e78b601a51d58a2cc2 | {
"func_code_index": [
4493,
4628
]
} | 59,938 |
NNCProjectToken | patterns\token\ERC777\ERC777.sol | 0xa67462ff3314c682277771ae2bbcec08877c877a | Solidity | ERC777 | contract ERC777 is Context, IERC777, IERC20 {
using SafeMath for uint256;
using Address for address;
IERC1820Registry constant internal _erc1820 = IERC1820Registry(0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24);
mapping(address => uint256) private _balances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
// We inline the result of the following hashes because Solidity doesn't resolve them at compile time.
// See https://github.com/ethereum/solidity/issues/4024.
// keccak256("ERC777TokensSender")
bytes32 constant private TOKENS_SENDER_INTERFACE_HASH =
0x29ddb589b1fb5fc7cf394961c1adf5f8c6454761adf795e67fe149f658abe895;
// keccak256("ERC777TokensRecipient")
bytes32 constant private TOKENS_RECIPIENT_INTERFACE_HASH =
0xb281fc8c12954d22544db45de3159a39272895b169a852b314f9cc762e44c53b;
// This isn't ever read from - it's only used to respond to the defaultOperators query.
address[] private _defaultOperatorsArray;
// Immutable, but accounts may revoke them (tracked in __revokedDefaultOperators).
mapping(address => bool) private _defaultOperators;
// For each account, a mapping of its operators and revoked default operators.
mapping(address => mapping(address => bool)) private _operators;
mapping(address => mapping(address => bool)) private _revokedDefaultOperators;
// ERC20-allowances
mapping (address => mapping (address => uint256)) private _allowances;
/**
* @dev `defaultOperators` may be an empty array.
*/
constructor(
string memory name,
string memory symbol,
address[] memory defaultOperators
) public {
_name = name;
_symbol = symbol;
_defaultOperatorsArray = defaultOperators;
for (uint256 i = 0; i < _defaultOperatorsArray.length; i++) {
_defaultOperators[_defaultOperatorsArray[i]] = true;
}
// register interfaces
_erc1820.setInterfaceImplementer(address(this), keccak256("ERC777Token"), address(this));
_erc1820.setInterfaceImplementer(address(this), keccak256("ERC20Token"), address(this));
}
/**
* @dev See {IERC777-name}.
*/
function name() public view returns (string memory) {
return _name;
}
/**
* @dev See {IERC777-symbol}.
*/
function symbol() public view returns (string memory) {
return _symbol;
}
/**
* @dev See {ERC20Detailed-decimals}.
*
* Always returns 18, as per the
* [ERC777 EIP](https://eips.ethereum.org/EIPS/eip-777#backward-compatibility).
*/
function decimals() public pure returns (uint8) {
return 18;
}
/**
* @dev See {IERC777-granularity}.
*
* This implementation always returns `1`.
*/
function granularity() public view returns (uint256) {
return 1;
}
/**
* @dev See {IERC777-totalSupply}.
*/
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
/**
* @dev Returns the amount of tokens owned by an account (`tokenHolder`).
*/
function balanceOf(address tokenHolder) public view returns (uint256) {
return _balances[tokenHolder];
}
/**
* @dev See {IERC777-send}.
*
* Also emits a {Transfer} event for ERC20 compatibility.
*/
function send(address recipient, uint256 amount, bytes calldata data) external {
_send(_msgSender(), _msgSender(), recipient, amount, data, "", true);
}
/**
* @dev See {IERC20-transfer}.
*
* Unlike `send`, `recipient` is _not_ required to implement the {IERC777Recipient}
* interface if it is a contract.
*
* Also emits a {Sent} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool) {
require(recipient != address(0), "ERC777: transfer to the zero address");
address from = _msgSender();
_callTokensToSend(from, from, recipient, amount, "", "");
_move(from, from, recipient, amount, "", "");
_callTokensReceived(from, from, recipient, amount, "", "", false);
return true;
}
/**
* @dev See {IERC777-burn}.
*
* Also emits a {Transfer} event for ERC20 compatibility.
*/
function burn(uint256 amount, bytes calldata data) external {
_burn(_msgSender(), _msgSender(), amount, data, "");
}
/**
* @dev See {IERC777-isOperatorFor}.
*/
function isOperatorFor(
address operator,
address tokenHolder
) public view returns (bool) {
return operator == tokenHolder ||
(_defaultOperators[operator] && !_revokedDefaultOperators[tokenHolder][operator]) ||
_operators[tokenHolder][operator];
}
/**
* @dev See {IERC777-authorizeOperator}.
*/
function authorizeOperator(address operator) external {
_authorizeOperator(operator);
}
function _authorizeOperator(address operator) internal {
require(_msgSender() != operator, "ERC777: authorizing self as operator");
if (_defaultOperators[operator]) {
delete _revokedDefaultOperators[_msgSender()][operator];
} else {
_operators[_msgSender()][operator] = true;
}
emit AuthorizedOperator(operator, _msgSender());
}
/**
* @dev See {IERC777-revokeOperator}.
*/
function revokeOperator(address operator) external {
_revokeOperator(operator);
}
function _revokeOperator(address operator) internal {
require(operator != _msgSender(), "ERC777: revoking self as operator");
if (_defaultOperators[operator]) {
_revokedDefaultOperators[_msgSender()][operator] = true;
} else {
delete _operators[_msgSender()][operator];
}
emit RevokedOperator(operator, _msgSender());
}
/**
* @dev See {IERC777-defaultOperators}.
*/
function defaultOperators() public view returns (address[] memory) {
return _defaultOperatorsArray;
}
/**
* @dev See {IERC777-operatorSend}.
*
* Emits {Sent} and {Transfer} events.
*/
function operatorSend(
address sender,
address recipient,
uint256 amount,
bytes calldata data,
bytes calldata operatorData
)
external
{
require(isOperatorFor(_msgSender(), sender), "ERC777: caller is not an operator for holder");
_send(_msgSender(), sender, recipient, amount, data, operatorData, true);
}
/**
* @dev See {IERC777-operatorBurn}.
*
* Emits {Burned} and {Transfer} events.
*/
function operatorBurn(address account, uint256 amount, bytes calldata data, bytes calldata operatorData) external {
require(isOperatorFor(_msgSender(), account), "ERC777: caller is not an operator for holder");
_burn(_msgSender(), account, amount, data, operatorData);
}
/**
* @dev See {IERC20-allowance}.
*
* Note that operator and allowance concepts are orthogonal: operators may
* not have allowance, and accounts with allowance may not be operators
* themselves.
*/
function allowance(address holder, address spender) public view returns (uint256) {
return _allowances[holder][spender];
}
/**
* @dev See {IERC20-approve}.
*
* Note that accounts cannot have allowance issued by their operators.
*/
function approve(address spender, uint256 value) external returns (bool) {
address holder = _msgSender();
_approve(holder, spender, value);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Note that operator and allowance concepts are orthogonal: operators cannot
* call `transferFrom` (unless they have allowance), and accounts with
* allowance cannot call `operatorSend` (unless they are operators).
*
* Emits {Sent}, {Transfer} and {Approval} events.
*/
function transferFrom(address holder, address recipient, uint256 amount) external returns (bool) {
require(recipient != address(0), "ERC777: transfer to the zero address");
require(holder != address(0), "ERC777: transfer from the zero address");
address spender = _msgSender();
_callTokensToSend(spender, holder, recipient, amount, "", "");
_move(spender, holder, recipient, amount, "", "");
_approve(holder, spender, _allowances[holder][spender].sub(amount, "ERC777: transfer amount exceeds allowance"));
_callTokensReceived(spender, holder, recipient, amount, "", "", false);
return true;
}
/**
* @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* If a send hook is registered for `account`, the corresponding function
* will be called with `operator`, `data` and `operatorData`.
*
* See {IERC777Sender} and {IERC777Recipient}.
*
* Emits {Minted} and {Transfer} events.
*
* Requirements
*
* - `account` cannot be the zero address.
* - if `account` is a contract, it must implement the {IERC777Recipient}
* interface.
*/
function _mint(
address operator,
address account,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
internal
{
require(account != address(0), "ERC777: mint to the zero address");
// Update state variables
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
_callTokensReceived(operator, address(0), account, amount, userData, operatorData, true);
emit Minted(operator, account, amount, userData, operatorData);
emit Transfer(address(0), account, amount);
}
/**
* @dev Send tokens
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
* @param requireReceptionAck if true, contract recipients are required to implement ERC777TokensRecipient
*/
function _send(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck
)
internal
{
require(from != address(0), "ERC777: send from the zero address");
require(to != address(0), "ERC777: send to the zero address");
_callTokensToSend(operator, from, to, amount, userData, operatorData);
_move(operator, from, to, amount, userData, operatorData);
_callTokensReceived(operator, from, to, amount, userData, operatorData, requireReceptionAck);
}
/**
* @dev Burn tokens
* @param operator address operator requesting the operation
* @param from address token holder address
* @param amount uint256 amount of tokens to burn
* @param data bytes extra information provided by the token holder
* @param operatorData bytes extra information provided by the operator (if any)
*/
function _burn(
address operator,
address from,
uint256 amount,
bytes memory data,
bytes memory operatorData
)
internal
{
require(from != address(0), "ERC777: burn from the zero address");
_callTokensToSend(operator, from, address(0), amount, data, operatorData);
// Update state variables
_balances[from] = _balances[from].sub(amount, "ERC777: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Burned(operator, from, amount, data, operatorData);
emit Transfer(from, address(0), amount);
}
function _move(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
internal
{
_balances[from] = _balances[from].sub(amount, "ERC777: transfer amount exceeds balance");
_balances[to] = _balances[to].add(amount);
emit Sent(operator, from, to, amount, userData, operatorData);
emit Transfer(from, to, amount);
}
function _approve(address holder, address spender, uint256 value) internal {
// TODO: restore this require statement if this function becomes internal, or is called at a new callsite. It is
// currently unnecessary.
//require(holder != address(0), "ERC777: approve from the zero address");
require(spender != address(0), "ERC777: approve to the zero address");
_allowances[holder][spender] = value;
emit Approval(holder, spender, value);
}
/**
* @dev Call from.tokensToSend() if the interface is registered
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
*/
function _callTokensToSend(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
private
{
address implementer = _erc1820.getInterfaceImplementer(from, TOKENS_SENDER_INTERFACE_HASH);
if (implementer != address(0)) {
IERC777Sender(implementer).tokensToSend(operator, from, to, amount, userData, operatorData);
}
}
/**
* @dev Call to.tokensReceived() if the interface is registered. Reverts if the recipient is a contract but
* tokensReceived() was not registered for the recipient
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
* @param requireReceptionAck if true, contract recipients are required to implement ERC777TokensRecipient
*/
function _callTokensReceived(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck
)
private
{
address implementer = _erc1820.getInterfaceImplementer(to, TOKENS_RECIPIENT_INTERFACE_HASH);
if (implementer != address(0)) {
IERC777Recipient(implementer).tokensReceived(operator, from, to, amount, userData, operatorData);
} else if (requireReceptionAck) {
require(!to.isContract(), "ERC777: token recipient contract has no implement for ERC777TokensRecipient");
}
}
} | /**
* @dev Implementation of the {IERC777} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
*
* Support for ERC20 is included in this contract, as specified by the EIP: both
* the ERC777 and ERC20 interfaces can be safely used when interacting with it.
* Both {IERC777-Sent} and {IERC20-Transfer} events are emitted on token
* movements.
*
* Additionally, the {IERC777-granularity} value is hard-coded to `1`, meaning that there
* are no special restrictions in the amount of tokens that created, moved, or
* destroyed. This makes integration with ERC20 applications seamless.
*/ | NatSpecMultiLine | isOperatorFor | function isOperatorFor(
address operator,
address tokenHolder
) public view returns (bool) {
return operator == tokenHolder ||
(_defaultOperators[operator] && !_revokedDefaultOperators[tokenHolder][operator]) ||
_operators[tokenHolder][operator];
}
| /**
* @dev See {IERC777-isOperatorFor}.
*/ | NatSpecMultiLine | v0.5.0+commit.1d4f565a | MIT | bzzr://c1bab4b5e3e40f4294e652b388dfc625ccf21445b4e184e78b601a51d58a2cc2 | {
"func_code_index": [
4691,
5007
]
} | 59,939 |
NNCProjectToken | patterns\token\ERC777\ERC777.sol | 0xa67462ff3314c682277771ae2bbcec08877c877a | Solidity | ERC777 | contract ERC777 is Context, IERC777, IERC20 {
using SafeMath for uint256;
using Address for address;
IERC1820Registry constant internal _erc1820 = IERC1820Registry(0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24);
mapping(address => uint256) private _balances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
// We inline the result of the following hashes because Solidity doesn't resolve them at compile time.
// See https://github.com/ethereum/solidity/issues/4024.
// keccak256("ERC777TokensSender")
bytes32 constant private TOKENS_SENDER_INTERFACE_HASH =
0x29ddb589b1fb5fc7cf394961c1adf5f8c6454761adf795e67fe149f658abe895;
// keccak256("ERC777TokensRecipient")
bytes32 constant private TOKENS_RECIPIENT_INTERFACE_HASH =
0xb281fc8c12954d22544db45de3159a39272895b169a852b314f9cc762e44c53b;
// This isn't ever read from - it's only used to respond to the defaultOperators query.
address[] private _defaultOperatorsArray;
// Immutable, but accounts may revoke them (tracked in __revokedDefaultOperators).
mapping(address => bool) private _defaultOperators;
// For each account, a mapping of its operators and revoked default operators.
mapping(address => mapping(address => bool)) private _operators;
mapping(address => mapping(address => bool)) private _revokedDefaultOperators;
// ERC20-allowances
mapping (address => mapping (address => uint256)) private _allowances;
/**
* @dev `defaultOperators` may be an empty array.
*/
constructor(
string memory name,
string memory symbol,
address[] memory defaultOperators
) public {
_name = name;
_symbol = symbol;
_defaultOperatorsArray = defaultOperators;
for (uint256 i = 0; i < _defaultOperatorsArray.length; i++) {
_defaultOperators[_defaultOperatorsArray[i]] = true;
}
// register interfaces
_erc1820.setInterfaceImplementer(address(this), keccak256("ERC777Token"), address(this));
_erc1820.setInterfaceImplementer(address(this), keccak256("ERC20Token"), address(this));
}
/**
* @dev See {IERC777-name}.
*/
function name() public view returns (string memory) {
return _name;
}
/**
* @dev See {IERC777-symbol}.
*/
function symbol() public view returns (string memory) {
return _symbol;
}
/**
* @dev See {ERC20Detailed-decimals}.
*
* Always returns 18, as per the
* [ERC777 EIP](https://eips.ethereum.org/EIPS/eip-777#backward-compatibility).
*/
function decimals() public pure returns (uint8) {
return 18;
}
/**
* @dev See {IERC777-granularity}.
*
* This implementation always returns `1`.
*/
function granularity() public view returns (uint256) {
return 1;
}
/**
* @dev See {IERC777-totalSupply}.
*/
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
/**
* @dev Returns the amount of tokens owned by an account (`tokenHolder`).
*/
function balanceOf(address tokenHolder) public view returns (uint256) {
return _balances[tokenHolder];
}
/**
* @dev See {IERC777-send}.
*
* Also emits a {Transfer} event for ERC20 compatibility.
*/
function send(address recipient, uint256 amount, bytes calldata data) external {
_send(_msgSender(), _msgSender(), recipient, amount, data, "", true);
}
/**
* @dev See {IERC20-transfer}.
*
* Unlike `send`, `recipient` is _not_ required to implement the {IERC777Recipient}
* interface if it is a contract.
*
* Also emits a {Sent} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool) {
require(recipient != address(0), "ERC777: transfer to the zero address");
address from = _msgSender();
_callTokensToSend(from, from, recipient, amount, "", "");
_move(from, from, recipient, amount, "", "");
_callTokensReceived(from, from, recipient, amount, "", "", false);
return true;
}
/**
* @dev See {IERC777-burn}.
*
* Also emits a {Transfer} event for ERC20 compatibility.
*/
function burn(uint256 amount, bytes calldata data) external {
_burn(_msgSender(), _msgSender(), amount, data, "");
}
/**
* @dev See {IERC777-isOperatorFor}.
*/
function isOperatorFor(
address operator,
address tokenHolder
) public view returns (bool) {
return operator == tokenHolder ||
(_defaultOperators[operator] && !_revokedDefaultOperators[tokenHolder][operator]) ||
_operators[tokenHolder][operator];
}
/**
* @dev See {IERC777-authorizeOperator}.
*/
function authorizeOperator(address operator) external {
_authorizeOperator(operator);
}
function _authorizeOperator(address operator) internal {
require(_msgSender() != operator, "ERC777: authorizing self as operator");
if (_defaultOperators[operator]) {
delete _revokedDefaultOperators[_msgSender()][operator];
} else {
_operators[_msgSender()][operator] = true;
}
emit AuthorizedOperator(operator, _msgSender());
}
/**
* @dev See {IERC777-revokeOperator}.
*/
function revokeOperator(address operator) external {
_revokeOperator(operator);
}
function _revokeOperator(address operator) internal {
require(operator != _msgSender(), "ERC777: revoking self as operator");
if (_defaultOperators[operator]) {
_revokedDefaultOperators[_msgSender()][operator] = true;
} else {
delete _operators[_msgSender()][operator];
}
emit RevokedOperator(operator, _msgSender());
}
/**
* @dev See {IERC777-defaultOperators}.
*/
function defaultOperators() public view returns (address[] memory) {
return _defaultOperatorsArray;
}
/**
* @dev See {IERC777-operatorSend}.
*
* Emits {Sent} and {Transfer} events.
*/
function operatorSend(
address sender,
address recipient,
uint256 amount,
bytes calldata data,
bytes calldata operatorData
)
external
{
require(isOperatorFor(_msgSender(), sender), "ERC777: caller is not an operator for holder");
_send(_msgSender(), sender, recipient, amount, data, operatorData, true);
}
/**
* @dev See {IERC777-operatorBurn}.
*
* Emits {Burned} and {Transfer} events.
*/
function operatorBurn(address account, uint256 amount, bytes calldata data, bytes calldata operatorData) external {
require(isOperatorFor(_msgSender(), account), "ERC777: caller is not an operator for holder");
_burn(_msgSender(), account, amount, data, operatorData);
}
/**
* @dev See {IERC20-allowance}.
*
* Note that operator and allowance concepts are orthogonal: operators may
* not have allowance, and accounts with allowance may not be operators
* themselves.
*/
function allowance(address holder, address spender) public view returns (uint256) {
return _allowances[holder][spender];
}
/**
* @dev See {IERC20-approve}.
*
* Note that accounts cannot have allowance issued by their operators.
*/
function approve(address spender, uint256 value) external returns (bool) {
address holder = _msgSender();
_approve(holder, spender, value);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Note that operator and allowance concepts are orthogonal: operators cannot
* call `transferFrom` (unless they have allowance), and accounts with
* allowance cannot call `operatorSend` (unless they are operators).
*
* Emits {Sent}, {Transfer} and {Approval} events.
*/
function transferFrom(address holder, address recipient, uint256 amount) external returns (bool) {
require(recipient != address(0), "ERC777: transfer to the zero address");
require(holder != address(0), "ERC777: transfer from the zero address");
address spender = _msgSender();
_callTokensToSend(spender, holder, recipient, amount, "", "");
_move(spender, holder, recipient, amount, "", "");
_approve(holder, spender, _allowances[holder][spender].sub(amount, "ERC777: transfer amount exceeds allowance"));
_callTokensReceived(spender, holder, recipient, amount, "", "", false);
return true;
}
/**
* @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* If a send hook is registered for `account`, the corresponding function
* will be called with `operator`, `data` and `operatorData`.
*
* See {IERC777Sender} and {IERC777Recipient}.
*
* Emits {Minted} and {Transfer} events.
*
* Requirements
*
* - `account` cannot be the zero address.
* - if `account` is a contract, it must implement the {IERC777Recipient}
* interface.
*/
function _mint(
address operator,
address account,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
internal
{
require(account != address(0), "ERC777: mint to the zero address");
// Update state variables
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
_callTokensReceived(operator, address(0), account, amount, userData, operatorData, true);
emit Minted(operator, account, amount, userData, operatorData);
emit Transfer(address(0), account, amount);
}
/**
* @dev Send tokens
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
* @param requireReceptionAck if true, contract recipients are required to implement ERC777TokensRecipient
*/
function _send(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck
)
internal
{
require(from != address(0), "ERC777: send from the zero address");
require(to != address(0), "ERC777: send to the zero address");
_callTokensToSend(operator, from, to, amount, userData, operatorData);
_move(operator, from, to, amount, userData, operatorData);
_callTokensReceived(operator, from, to, amount, userData, operatorData, requireReceptionAck);
}
/**
* @dev Burn tokens
* @param operator address operator requesting the operation
* @param from address token holder address
* @param amount uint256 amount of tokens to burn
* @param data bytes extra information provided by the token holder
* @param operatorData bytes extra information provided by the operator (if any)
*/
function _burn(
address operator,
address from,
uint256 amount,
bytes memory data,
bytes memory operatorData
)
internal
{
require(from != address(0), "ERC777: burn from the zero address");
_callTokensToSend(operator, from, address(0), amount, data, operatorData);
// Update state variables
_balances[from] = _balances[from].sub(amount, "ERC777: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Burned(operator, from, amount, data, operatorData);
emit Transfer(from, address(0), amount);
}
function _move(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
internal
{
_balances[from] = _balances[from].sub(amount, "ERC777: transfer amount exceeds balance");
_balances[to] = _balances[to].add(amount);
emit Sent(operator, from, to, amount, userData, operatorData);
emit Transfer(from, to, amount);
}
function _approve(address holder, address spender, uint256 value) internal {
// TODO: restore this require statement if this function becomes internal, or is called at a new callsite. It is
// currently unnecessary.
//require(holder != address(0), "ERC777: approve from the zero address");
require(spender != address(0), "ERC777: approve to the zero address");
_allowances[holder][spender] = value;
emit Approval(holder, spender, value);
}
/**
* @dev Call from.tokensToSend() if the interface is registered
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
*/
function _callTokensToSend(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
private
{
address implementer = _erc1820.getInterfaceImplementer(from, TOKENS_SENDER_INTERFACE_HASH);
if (implementer != address(0)) {
IERC777Sender(implementer).tokensToSend(operator, from, to, amount, userData, operatorData);
}
}
/**
* @dev Call to.tokensReceived() if the interface is registered. Reverts if the recipient is a contract but
* tokensReceived() was not registered for the recipient
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
* @param requireReceptionAck if true, contract recipients are required to implement ERC777TokensRecipient
*/
function _callTokensReceived(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck
)
private
{
address implementer = _erc1820.getInterfaceImplementer(to, TOKENS_RECIPIENT_INTERFACE_HASH);
if (implementer != address(0)) {
IERC777Recipient(implementer).tokensReceived(operator, from, to, amount, userData, operatorData);
} else if (requireReceptionAck) {
require(!to.isContract(), "ERC777: token recipient contract has no implement for ERC777TokensRecipient");
}
}
} | /**
* @dev Implementation of the {IERC777} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
*
* Support for ERC20 is included in this contract, as specified by the EIP: both
* the ERC777 and ERC20 interfaces can be safely used when interacting with it.
* Both {IERC777-Sent} and {IERC20-Transfer} events are emitted on token
* movements.
*
* Additionally, the {IERC777-granularity} value is hard-coded to `1`, meaning that there
* are no special restrictions in the amount of tokens that created, moved, or
* destroyed. This makes integration with ERC20 applications seamless.
*/ | NatSpecMultiLine | authorizeOperator | function authorizeOperator(address operator) external {
_authorizeOperator(operator);
}
| /**
* @dev See {IERC777-authorizeOperator}.
*/ | NatSpecMultiLine | v0.5.0+commit.1d4f565a | MIT | bzzr://c1bab4b5e3e40f4294e652b388dfc625ccf21445b4e184e78b601a51d58a2cc2 | {
"func_code_index": [
5074,
5180
]
} | 59,940 |
NNCProjectToken | patterns\token\ERC777\ERC777.sol | 0xa67462ff3314c682277771ae2bbcec08877c877a | Solidity | ERC777 | contract ERC777 is Context, IERC777, IERC20 {
using SafeMath for uint256;
using Address for address;
IERC1820Registry constant internal _erc1820 = IERC1820Registry(0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24);
mapping(address => uint256) private _balances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
// We inline the result of the following hashes because Solidity doesn't resolve them at compile time.
// See https://github.com/ethereum/solidity/issues/4024.
// keccak256("ERC777TokensSender")
bytes32 constant private TOKENS_SENDER_INTERFACE_HASH =
0x29ddb589b1fb5fc7cf394961c1adf5f8c6454761adf795e67fe149f658abe895;
// keccak256("ERC777TokensRecipient")
bytes32 constant private TOKENS_RECIPIENT_INTERFACE_HASH =
0xb281fc8c12954d22544db45de3159a39272895b169a852b314f9cc762e44c53b;
// This isn't ever read from - it's only used to respond to the defaultOperators query.
address[] private _defaultOperatorsArray;
// Immutable, but accounts may revoke them (tracked in __revokedDefaultOperators).
mapping(address => bool) private _defaultOperators;
// For each account, a mapping of its operators and revoked default operators.
mapping(address => mapping(address => bool)) private _operators;
mapping(address => mapping(address => bool)) private _revokedDefaultOperators;
// ERC20-allowances
mapping (address => mapping (address => uint256)) private _allowances;
/**
* @dev `defaultOperators` may be an empty array.
*/
constructor(
string memory name,
string memory symbol,
address[] memory defaultOperators
) public {
_name = name;
_symbol = symbol;
_defaultOperatorsArray = defaultOperators;
for (uint256 i = 0; i < _defaultOperatorsArray.length; i++) {
_defaultOperators[_defaultOperatorsArray[i]] = true;
}
// register interfaces
_erc1820.setInterfaceImplementer(address(this), keccak256("ERC777Token"), address(this));
_erc1820.setInterfaceImplementer(address(this), keccak256("ERC20Token"), address(this));
}
/**
* @dev See {IERC777-name}.
*/
function name() public view returns (string memory) {
return _name;
}
/**
* @dev See {IERC777-symbol}.
*/
function symbol() public view returns (string memory) {
return _symbol;
}
/**
* @dev See {ERC20Detailed-decimals}.
*
* Always returns 18, as per the
* [ERC777 EIP](https://eips.ethereum.org/EIPS/eip-777#backward-compatibility).
*/
function decimals() public pure returns (uint8) {
return 18;
}
/**
* @dev See {IERC777-granularity}.
*
* This implementation always returns `1`.
*/
function granularity() public view returns (uint256) {
return 1;
}
/**
* @dev See {IERC777-totalSupply}.
*/
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
/**
* @dev Returns the amount of tokens owned by an account (`tokenHolder`).
*/
function balanceOf(address tokenHolder) public view returns (uint256) {
return _balances[tokenHolder];
}
/**
* @dev See {IERC777-send}.
*
* Also emits a {Transfer} event for ERC20 compatibility.
*/
function send(address recipient, uint256 amount, bytes calldata data) external {
_send(_msgSender(), _msgSender(), recipient, amount, data, "", true);
}
/**
* @dev See {IERC20-transfer}.
*
* Unlike `send`, `recipient` is _not_ required to implement the {IERC777Recipient}
* interface if it is a contract.
*
* Also emits a {Sent} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool) {
require(recipient != address(0), "ERC777: transfer to the zero address");
address from = _msgSender();
_callTokensToSend(from, from, recipient, amount, "", "");
_move(from, from, recipient, amount, "", "");
_callTokensReceived(from, from, recipient, amount, "", "", false);
return true;
}
/**
* @dev See {IERC777-burn}.
*
* Also emits a {Transfer} event for ERC20 compatibility.
*/
function burn(uint256 amount, bytes calldata data) external {
_burn(_msgSender(), _msgSender(), amount, data, "");
}
/**
* @dev See {IERC777-isOperatorFor}.
*/
function isOperatorFor(
address operator,
address tokenHolder
) public view returns (bool) {
return operator == tokenHolder ||
(_defaultOperators[operator] && !_revokedDefaultOperators[tokenHolder][operator]) ||
_operators[tokenHolder][operator];
}
/**
* @dev See {IERC777-authorizeOperator}.
*/
function authorizeOperator(address operator) external {
_authorizeOperator(operator);
}
function _authorizeOperator(address operator) internal {
require(_msgSender() != operator, "ERC777: authorizing self as operator");
if (_defaultOperators[operator]) {
delete _revokedDefaultOperators[_msgSender()][operator];
} else {
_operators[_msgSender()][operator] = true;
}
emit AuthorizedOperator(operator, _msgSender());
}
/**
* @dev See {IERC777-revokeOperator}.
*/
function revokeOperator(address operator) external {
_revokeOperator(operator);
}
function _revokeOperator(address operator) internal {
require(operator != _msgSender(), "ERC777: revoking self as operator");
if (_defaultOperators[operator]) {
_revokedDefaultOperators[_msgSender()][operator] = true;
} else {
delete _operators[_msgSender()][operator];
}
emit RevokedOperator(operator, _msgSender());
}
/**
* @dev See {IERC777-defaultOperators}.
*/
function defaultOperators() public view returns (address[] memory) {
return _defaultOperatorsArray;
}
/**
* @dev See {IERC777-operatorSend}.
*
* Emits {Sent} and {Transfer} events.
*/
function operatorSend(
address sender,
address recipient,
uint256 amount,
bytes calldata data,
bytes calldata operatorData
)
external
{
require(isOperatorFor(_msgSender(), sender), "ERC777: caller is not an operator for holder");
_send(_msgSender(), sender, recipient, amount, data, operatorData, true);
}
/**
* @dev See {IERC777-operatorBurn}.
*
* Emits {Burned} and {Transfer} events.
*/
function operatorBurn(address account, uint256 amount, bytes calldata data, bytes calldata operatorData) external {
require(isOperatorFor(_msgSender(), account), "ERC777: caller is not an operator for holder");
_burn(_msgSender(), account, amount, data, operatorData);
}
/**
* @dev See {IERC20-allowance}.
*
* Note that operator and allowance concepts are orthogonal: operators may
* not have allowance, and accounts with allowance may not be operators
* themselves.
*/
function allowance(address holder, address spender) public view returns (uint256) {
return _allowances[holder][spender];
}
/**
* @dev See {IERC20-approve}.
*
* Note that accounts cannot have allowance issued by their operators.
*/
function approve(address spender, uint256 value) external returns (bool) {
address holder = _msgSender();
_approve(holder, spender, value);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Note that operator and allowance concepts are orthogonal: operators cannot
* call `transferFrom` (unless they have allowance), and accounts with
* allowance cannot call `operatorSend` (unless they are operators).
*
* Emits {Sent}, {Transfer} and {Approval} events.
*/
function transferFrom(address holder, address recipient, uint256 amount) external returns (bool) {
require(recipient != address(0), "ERC777: transfer to the zero address");
require(holder != address(0), "ERC777: transfer from the zero address");
address spender = _msgSender();
_callTokensToSend(spender, holder, recipient, amount, "", "");
_move(spender, holder, recipient, amount, "", "");
_approve(holder, spender, _allowances[holder][spender].sub(amount, "ERC777: transfer amount exceeds allowance"));
_callTokensReceived(spender, holder, recipient, amount, "", "", false);
return true;
}
/**
* @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* If a send hook is registered for `account`, the corresponding function
* will be called with `operator`, `data` and `operatorData`.
*
* See {IERC777Sender} and {IERC777Recipient}.
*
* Emits {Minted} and {Transfer} events.
*
* Requirements
*
* - `account` cannot be the zero address.
* - if `account` is a contract, it must implement the {IERC777Recipient}
* interface.
*/
function _mint(
address operator,
address account,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
internal
{
require(account != address(0), "ERC777: mint to the zero address");
// Update state variables
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
_callTokensReceived(operator, address(0), account, amount, userData, operatorData, true);
emit Minted(operator, account, amount, userData, operatorData);
emit Transfer(address(0), account, amount);
}
/**
* @dev Send tokens
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
* @param requireReceptionAck if true, contract recipients are required to implement ERC777TokensRecipient
*/
function _send(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck
)
internal
{
require(from != address(0), "ERC777: send from the zero address");
require(to != address(0), "ERC777: send to the zero address");
_callTokensToSend(operator, from, to, amount, userData, operatorData);
_move(operator, from, to, amount, userData, operatorData);
_callTokensReceived(operator, from, to, amount, userData, operatorData, requireReceptionAck);
}
/**
* @dev Burn tokens
* @param operator address operator requesting the operation
* @param from address token holder address
* @param amount uint256 amount of tokens to burn
* @param data bytes extra information provided by the token holder
* @param operatorData bytes extra information provided by the operator (if any)
*/
function _burn(
address operator,
address from,
uint256 amount,
bytes memory data,
bytes memory operatorData
)
internal
{
require(from != address(0), "ERC777: burn from the zero address");
_callTokensToSend(operator, from, address(0), amount, data, operatorData);
// Update state variables
_balances[from] = _balances[from].sub(amount, "ERC777: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Burned(operator, from, amount, data, operatorData);
emit Transfer(from, address(0), amount);
}
function _move(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
internal
{
_balances[from] = _balances[from].sub(amount, "ERC777: transfer amount exceeds balance");
_balances[to] = _balances[to].add(amount);
emit Sent(operator, from, to, amount, userData, operatorData);
emit Transfer(from, to, amount);
}
function _approve(address holder, address spender, uint256 value) internal {
// TODO: restore this require statement if this function becomes internal, or is called at a new callsite. It is
// currently unnecessary.
//require(holder != address(0), "ERC777: approve from the zero address");
require(spender != address(0), "ERC777: approve to the zero address");
_allowances[holder][spender] = value;
emit Approval(holder, spender, value);
}
/**
* @dev Call from.tokensToSend() if the interface is registered
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
*/
function _callTokensToSend(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
private
{
address implementer = _erc1820.getInterfaceImplementer(from, TOKENS_SENDER_INTERFACE_HASH);
if (implementer != address(0)) {
IERC777Sender(implementer).tokensToSend(operator, from, to, amount, userData, operatorData);
}
}
/**
* @dev Call to.tokensReceived() if the interface is registered. Reverts if the recipient is a contract but
* tokensReceived() was not registered for the recipient
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
* @param requireReceptionAck if true, contract recipients are required to implement ERC777TokensRecipient
*/
function _callTokensReceived(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck
)
private
{
address implementer = _erc1820.getInterfaceImplementer(to, TOKENS_RECIPIENT_INTERFACE_HASH);
if (implementer != address(0)) {
IERC777Recipient(implementer).tokensReceived(operator, from, to, amount, userData, operatorData);
} else if (requireReceptionAck) {
require(!to.isContract(), "ERC777: token recipient contract has no implement for ERC777TokensRecipient");
}
}
} | /**
* @dev Implementation of the {IERC777} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
*
* Support for ERC20 is included in this contract, as specified by the EIP: both
* the ERC777 and ERC20 interfaces can be safely used when interacting with it.
* Both {IERC777-Sent} and {IERC20-Transfer} events are emitted on token
* movements.
*
* Additionally, the {IERC777-granularity} value is hard-coded to `1`, meaning that there
* are no special restrictions in the amount of tokens that created, moved, or
* destroyed. This makes integration with ERC20 applications seamless.
*/ | NatSpecMultiLine | revokeOperator | function revokeOperator(address operator) external {
_revokeOperator(operator);
}
| /**
* @dev See {IERC777-revokeOperator}.
*/ | NatSpecMultiLine | v0.5.0+commit.1d4f565a | MIT | bzzr://c1bab4b5e3e40f4294e652b388dfc625ccf21445b4e184e78b601a51d58a2cc2 | {
"func_code_index": [
5660,
5760
]
} | 59,941 |
NNCProjectToken | patterns\token\ERC777\ERC777.sol | 0xa67462ff3314c682277771ae2bbcec08877c877a | Solidity | ERC777 | contract ERC777 is Context, IERC777, IERC20 {
using SafeMath for uint256;
using Address for address;
IERC1820Registry constant internal _erc1820 = IERC1820Registry(0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24);
mapping(address => uint256) private _balances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
// We inline the result of the following hashes because Solidity doesn't resolve them at compile time.
// See https://github.com/ethereum/solidity/issues/4024.
// keccak256("ERC777TokensSender")
bytes32 constant private TOKENS_SENDER_INTERFACE_HASH =
0x29ddb589b1fb5fc7cf394961c1adf5f8c6454761adf795e67fe149f658abe895;
// keccak256("ERC777TokensRecipient")
bytes32 constant private TOKENS_RECIPIENT_INTERFACE_HASH =
0xb281fc8c12954d22544db45de3159a39272895b169a852b314f9cc762e44c53b;
// This isn't ever read from - it's only used to respond to the defaultOperators query.
address[] private _defaultOperatorsArray;
// Immutable, but accounts may revoke them (tracked in __revokedDefaultOperators).
mapping(address => bool) private _defaultOperators;
// For each account, a mapping of its operators and revoked default operators.
mapping(address => mapping(address => bool)) private _operators;
mapping(address => mapping(address => bool)) private _revokedDefaultOperators;
// ERC20-allowances
mapping (address => mapping (address => uint256)) private _allowances;
/**
* @dev `defaultOperators` may be an empty array.
*/
constructor(
string memory name,
string memory symbol,
address[] memory defaultOperators
) public {
_name = name;
_symbol = symbol;
_defaultOperatorsArray = defaultOperators;
for (uint256 i = 0; i < _defaultOperatorsArray.length; i++) {
_defaultOperators[_defaultOperatorsArray[i]] = true;
}
// register interfaces
_erc1820.setInterfaceImplementer(address(this), keccak256("ERC777Token"), address(this));
_erc1820.setInterfaceImplementer(address(this), keccak256("ERC20Token"), address(this));
}
/**
* @dev See {IERC777-name}.
*/
function name() public view returns (string memory) {
return _name;
}
/**
* @dev See {IERC777-symbol}.
*/
function symbol() public view returns (string memory) {
return _symbol;
}
/**
* @dev See {ERC20Detailed-decimals}.
*
* Always returns 18, as per the
* [ERC777 EIP](https://eips.ethereum.org/EIPS/eip-777#backward-compatibility).
*/
function decimals() public pure returns (uint8) {
return 18;
}
/**
* @dev See {IERC777-granularity}.
*
* This implementation always returns `1`.
*/
function granularity() public view returns (uint256) {
return 1;
}
/**
* @dev See {IERC777-totalSupply}.
*/
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
/**
* @dev Returns the amount of tokens owned by an account (`tokenHolder`).
*/
function balanceOf(address tokenHolder) public view returns (uint256) {
return _balances[tokenHolder];
}
/**
* @dev See {IERC777-send}.
*
* Also emits a {Transfer} event for ERC20 compatibility.
*/
function send(address recipient, uint256 amount, bytes calldata data) external {
_send(_msgSender(), _msgSender(), recipient, amount, data, "", true);
}
/**
* @dev See {IERC20-transfer}.
*
* Unlike `send`, `recipient` is _not_ required to implement the {IERC777Recipient}
* interface if it is a contract.
*
* Also emits a {Sent} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool) {
require(recipient != address(0), "ERC777: transfer to the zero address");
address from = _msgSender();
_callTokensToSend(from, from, recipient, amount, "", "");
_move(from, from, recipient, amount, "", "");
_callTokensReceived(from, from, recipient, amount, "", "", false);
return true;
}
/**
* @dev See {IERC777-burn}.
*
* Also emits a {Transfer} event for ERC20 compatibility.
*/
function burn(uint256 amount, bytes calldata data) external {
_burn(_msgSender(), _msgSender(), amount, data, "");
}
/**
* @dev See {IERC777-isOperatorFor}.
*/
function isOperatorFor(
address operator,
address tokenHolder
) public view returns (bool) {
return operator == tokenHolder ||
(_defaultOperators[operator] && !_revokedDefaultOperators[tokenHolder][operator]) ||
_operators[tokenHolder][operator];
}
/**
* @dev See {IERC777-authorizeOperator}.
*/
function authorizeOperator(address operator) external {
_authorizeOperator(operator);
}
function _authorizeOperator(address operator) internal {
require(_msgSender() != operator, "ERC777: authorizing self as operator");
if (_defaultOperators[operator]) {
delete _revokedDefaultOperators[_msgSender()][operator];
} else {
_operators[_msgSender()][operator] = true;
}
emit AuthorizedOperator(operator, _msgSender());
}
/**
* @dev See {IERC777-revokeOperator}.
*/
function revokeOperator(address operator) external {
_revokeOperator(operator);
}
function _revokeOperator(address operator) internal {
require(operator != _msgSender(), "ERC777: revoking self as operator");
if (_defaultOperators[operator]) {
_revokedDefaultOperators[_msgSender()][operator] = true;
} else {
delete _operators[_msgSender()][operator];
}
emit RevokedOperator(operator, _msgSender());
}
/**
* @dev See {IERC777-defaultOperators}.
*/
function defaultOperators() public view returns (address[] memory) {
return _defaultOperatorsArray;
}
/**
* @dev See {IERC777-operatorSend}.
*
* Emits {Sent} and {Transfer} events.
*/
function operatorSend(
address sender,
address recipient,
uint256 amount,
bytes calldata data,
bytes calldata operatorData
)
external
{
require(isOperatorFor(_msgSender(), sender), "ERC777: caller is not an operator for holder");
_send(_msgSender(), sender, recipient, amount, data, operatorData, true);
}
/**
* @dev See {IERC777-operatorBurn}.
*
* Emits {Burned} and {Transfer} events.
*/
function operatorBurn(address account, uint256 amount, bytes calldata data, bytes calldata operatorData) external {
require(isOperatorFor(_msgSender(), account), "ERC777: caller is not an operator for holder");
_burn(_msgSender(), account, amount, data, operatorData);
}
/**
* @dev See {IERC20-allowance}.
*
* Note that operator and allowance concepts are orthogonal: operators may
* not have allowance, and accounts with allowance may not be operators
* themselves.
*/
function allowance(address holder, address spender) public view returns (uint256) {
return _allowances[holder][spender];
}
/**
* @dev See {IERC20-approve}.
*
* Note that accounts cannot have allowance issued by their operators.
*/
function approve(address spender, uint256 value) external returns (bool) {
address holder = _msgSender();
_approve(holder, spender, value);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Note that operator and allowance concepts are orthogonal: operators cannot
* call `transferFrom` (unless they have allowance), and accounts with
* allowance cannot call `operatorSend` (unless they are operators).
*
* Emits {Sent}, {Transfer} and {Approval} events.
*/
function transferFrom(address holder, address recipient, uint256 amount) external returns (bool) {
require(recipient != address(0), "ERC777: transfer to the zero address");
require(holder != address(0), "ERC777: transfer from the zero address");
address spender = _msgSender();
_callTokensToSend(spender, holder, recipient, amount, "", "");
_move(spender, holder, recipient, amount, "", "");
_approve(holder, spender, _allowances[holder][spender].sub(amount, "ERC777: transfer amount exceeds allowance"));
_callTokensReceived(spender, holder, recipient, amount, "", "", false);
return true;
}
/**
* @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* If a send hook is registered for `account`, the corresponding function
* will be called with `operator`, `data` and `operatorData`.
*
* See {IERC777Sender} and {IERC777Recipient}.
*
* Emits {Minted} and {Transfer} events.
*
* Requirements
*
* - `account` cannot be the zero address.
* - if `account` is a contract, it must implement the {IERC777Recipient}
* interface.
*/
function _mint(
address operator,
address account,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
internal
{
require(account != address(0), "ERC777: mint to the zero address");
// Update state variables
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
_callTokensReceived(operator, address(0), account, amount, userData, operatorData, true);
emit Minted(operator, account, amount, userData, operatorData);
emit Transfer(address(0), account, amount);
}
/**
* @dev Send tokens
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
* @param requireReceptionAck if true, contract recipients are required to implement ERC777TokensRecipient
*/
function _send(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck
)
internal
{
require(from != address(0), "ERC777: send from the zero address");
require(to != address(0), "ERC777: send to the zero address");
_callTokensToSend(operator, from, to, amount, userData, operatorData);
_move(operator, from, to, amount, userData, operatorData);
_callTokensReceived(operator, from, to, amount, userData, operatorData, requireReceptionAck);
}
/**
* @dev Burn tokens
* @param operator address operator requesting the operation
* @param from address token holder address
* @param amount uint256 amount of tokens to burn
* @param data bytes extra information provided by the token holder
* @param operatorData bytes extra information provided by the operator (if any)
*/
function _burn(
address operator,
address from,
uint256 amount,
bytes memory data,
bytes memory operatorData
)
internal
{
require(from != address(0), "ERC777: burn from the zero address");
_callTokensToSend(operator, from, address(0), amount, data, operatorData);
// Update state variables
_balances[from] = _balances[from].sub(amount, "ERC777: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Burned(operator, from, amount, data, operatorData);
emit Transfer(from, address(0), amount);
}
function _move(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
internal
{
_balances[from] = _balances[from].sub(amount, "ERC777: transfer amount exceeds balance");
_balances[to] = _balances[to].add(amount);
emit Sent(operator, from, to, amount, userData, operatorData);
emit Transfer(from, to, amount);
}
function _approve(address holder, address spender, uint256 value) internal {
// TODO: restore this require statement if this function becomes internal, or is called at a new callsite. It is
// currently unnecessary.
//require(holder != address(0), "ERC777: approve from the zero address");
require(spender != address(0), "ERC777: approve to the zero address");
_allowances[holder][spender] = value;
emit Approval(holder, spender, value);
}
/**
* @dev Call from.tokensToSend() if the interface is registered
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
*/
function _callTokensToSend(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
private
{
address implementer = _erc1820.getInterfaceImplementer(from, TOKENS_SENDER_INTERFACE_HASH);
if (implementer != address(0)) {
IERC777Sender(implementer).tokensToSend(operator, from, to, amount, userData, operatorData);
}
}
/**
* @dev Call to.tokensReceived() if the interface is registered. Reverts if the recipient is a contract but
* tokensReceived() was not registered for the recipient
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
* @param requireReceptionAck if true, contract recipients are required to implement ERC777TokensRecipient
*/
function _callTokensReceived(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck
)
private
{
address implementer = _erc1820.getInterfaceImplementer(to, TOKENS_RECIPIENT_INTERFACE_HASH);
if (implementer != address(0)) {
IERC777Recipient(implementer).tokensReceived(operator, from, to, amount, userData, operatorData);
} else if (requireReceptionAck) {
require(!to.isContract(), "ERC777: token recipient contract has no implement for ERC777TokensRecipient");
}
}
} | /**
* @dev Implementation of the {IERC777} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
*
* Support for ERC20 is included in this contract, as specified by the EIP: both
* the ERC777 and ERC20 interfaces can be safely used when interacting with it.
* Both {IERC777-Sent} and {IERC20-Transfer} events are emitted on token
* movements.
*
* Additionally, the {IERC777-granularity} value is hard-coded to `1`, meaning that there
* are no special restrictions in the amount of tokens that created, moved, or
* destroyed. This makes integration with ERC20 applications seamless.
*/ | NatSpecMultiLine | defaultOperators | function defaultOperators() public view returns (address[] memory) {
return _defaultOperatorsArray;
}
| /**
* @dev See {IERC777-defaultOperators}.
*/ | NatSpecMultiLine | v0.5.0+commit.1d4f565a | MIT | bzzr://c1bab4b5e3e40f4294e652b388dfc625ccf21445b4e184e78b601a51d58a2cc2 | {
"func_code_index": [
6233,
6353
]
} | 59,942 |
NNCProjectToken | patterns\token\ERC777\ERC777.sol | 0xa67462ff3314c682277771ae2bbcec08877c877a | Solidity | ERC777 | contract ERC777 is Context, IERC777, IERC20 {
using SafeMath for uint256;
using Address for address;
IERC1820Registry constant internal _erc1820 = IERC1820Registry(0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24);
mapping(address => uint256) private _balances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
// We inline the result of the following hashes because Solidity doesn't resolve them at compile time.
// See https://github.com/ethereum/solidity/issues/4024.
// keccak256("ERC777TokensSender")
bytes32 constant private TOKENS_SENDER_INTERFACE_HASH =
0x29ddb589b1fb5fc7cf394961c1adf5f8c6454761adf795e67fe149f658abe895;
// keccak256("ERC777TokensRecipient")
bytes32 constant private TOKENS_RECIPIENT_INTERFACE_HASH =
0xb281fc8c12954d22544db45de3159a39272895b169a852b314f9cc762e44c53b;
// This isn't ever read from - it's only used to respond to the defaultOperators query.
address[] private _defaultOperatorsArray;
// Immutable, but accounts may revoke them (tracked in __revokedDefaultOperators).
mapping(address => bool) private _defaultOperators;
// For each account, a mapping of its operators and revoked default operators.
mapping(address => mapping(address => bool)) private _operators;
mapping(address => mapping(address => bool)) private _revokedDefaultOperators;
// ERC20-allowances
mapping (address => mapping (address => uint256)) private _allowances;
/**
* @dev `defaultOperators` may be an empty array.
*/
constructor(
string memory name,
string memory symbol,
address[] memory defaultOperators
) public {
_name = name;
_symbol = symbol;
_defaultOperatorsArray = defaultOperators;
for (uint256 i = 0; i < _defaultOperatorsArray.length; i++) {
_defaultOperators[_defaultOperatorsArray[i]] = true;
}
// register interfaces
_erc1820.setInterfaceImplementer(address(this), keccak256("ERC777Token"), address(this));
_erc1820.setInterfaceImplementer(address(this), keccak256("ERC20Token"), address(this));
}
/**
* @dev See {IERC777-name}.
*/
function name() public view returns (string memory) {
return _name;
}
/**
* @dev See {IERC777-symbol}.
*/
function symbol() public view returns (string memory) {
return _symbol;
}
/**
* @dev See {ERC20Detailed-decimals}.
*
* Always returns 18, as per the
* [ERC777 EIP](https://eips.ethereum.org/EIPS/eip-777#backward-compatibility).
*/
function decimals() public pure returns (uint8) {
return 18;
}
/**
* @dev See {IERC777-granularity}.
*
* This implementation always returns `1`.
*/
function granularity() public view returns (uint256) {
return 1;
}
/**
* @dev See {IERC777-totalSupply}.
*/
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
/**
* @dev Returns the amount of tokens owned by an account (`tokenHolder`).
*/
function balanceOf(address tokenHolder) public view returns (uint256) {
return _balances[tokenHolder];
}
/**
* @dev See {IERC777-send}.
*
* Also emits a {Transfer} event for ERC20 compatibility.
*/
function send(address recipient, uint256 amount, bytes calldata data) external {
_send(_msgSender(), _msgSender(), recipient, amount, data, "", true);
}
/**
* @dev See {IERC20-transfer}.
*
* Unlike `send`, `recipient` is _not_ required to implement the {IERC777Recipient}
* interface if it is a contract.
*
* Also emits a {Sent} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool) {
require(recipient != address(0), "ERC777: transfer to the zero address");
address from = _msgSender();
_callTokensToSend(from, from, recipient, amount, "", "");
_move(from, from, recipient, amount, "", "");
_callTokensReceived(from, from, recipient, amount, "", "", false);
return true;
}
/**
* @dev See {IERC777-burn}.
*
* Also emits a {Transfer} event for ERC20 compatibility.
*/
function burn(uint256 amount, bytes calldata data) external {
_burn(_msgSender(), _msgSender(), amount, data, "");
}
/**
* @dev See {IERC777-isOperatorFor}.
*/
function isOperatorFor(
address operator,
address tokenHolder
) public view returns (bool) {
return operator == tokenHolder ||
(_defaultOperators[operator] && !_revokedDefaultOperators[tokenHolder][operator]) ||
_operators[tokenHolder][operator];
}
/**
* @dev See {IERC777-authorizeOperator}.
*/
function authorizeOperator(address operator) external {
_authorizeOperator(operator);
}
function _authorizeOperator(address operator) internal {
require(_msgSender() != operator, "ERC777: authorizing self as operator");
if (_defaultOperators[operator]) {
delete _revokedDefaultOperators[_msgSender()][operator];
} else {
_operators[_msgSender()][operator] = true;
}
emit AuthorizedOperator(operator, _msgSender());
}
/**
* @dev See {IERC777-revokeOperator}.
*/
function revokeOperator(address operator) external {
_revokeOperator(operator);
}
function _revokeOperator(address operator) internal {
require(operator != _msgSender(), "ERC777: revoking self as operator");
if (_defaultOperators[operator]) {
_revokedDefaultOperators[_msgSender()][operator] = true;
} else {
delete _operators[_msgSender()][operator];
}
emit RevokedOperator(operator, _msgSender());
}
/**
* @dev See {IERC777-defaultOperators}.
*/
function defaultOperators() public view returns (address[] memory) {
return _defaultOperatorsArray;
}
/**
* @dev See {IERC777-operatorSend}.
*
* Emits {Sent} and {Transfer} events.
*/
function operatorSend(
address sender,
address recipient,
uint256 amount,
bytes calldata data,
bytes calldata operatorData
)
external
{
require(isOperatorFor(_msgSender(), sender), "ERC777: caller is not an operator for holder");
_send(_msgSender(), sender, recipient, amount, data, operatorData, true);
}
/**
* @dev See {IERC777-operatorBurn}.
*
* Emits {Burned} and {Transfer} events.
*/
function operatorBurn(address account, uint256 amount, bytes calldata data, bytes calldata operatorData) external {
require(isOperatorFor(_msgSender(), account), "ERC777: caller is not an operator for holder");
_burn(_msgSender(), account, amount, data, operatorData);
}
/**
* @dev See {IERC20-allowance}.
*
* Note that operator and allowance concepts are orthogonal: operators may
* not have allowance, and accounts with allowance may not be operators
* themselves.
*/
function allowance(address holder, address spender) public view returns (uint256) {
return _allowances[holder][spender];
}
/**
* @dev See {IERC20-approve}.
*
* Note that accounts cannot have allowance issued by their operators.
*/
function approve(address spender, uint256 value) external returns (bool) {
address holder = _msgSender();
_approve(holder, spender, value);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Note that operator and allowance concepts are orthogonal: operators cannot
* call `transferFrom` (unless they have allowance), and accounts with
* allowance cannot call `operatorSend` (unless they are operators).
*
* Emits {Sent}, {Transfer} and {Approval} events.
*/
function transferFrom(address holder, address recipient, uint256 amount) external returns (bool) {
require(recipient != address(0), "ERC777: transfer to the zero address");
require(holder != address(0), "ERC777: transfer from the zero address");
address spender = _msgSender();
_callTokensToSend(spender, holder, recipient, amount, "", "");
_move(spender, holder, recipient, amount, "", "");
_approve(holder, spender, _allowances[holder][spender].sub(amount, "ERC777: transfer amount exceeds allowance"));
_callTokensReceived(spender, holder, recipient, amount, "", "", false);
return true;
}
/**
* @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* If a send hook is registered for `account`, the corresponding function
* will be called with `operator`, `data` and `operatorData`.
*
* See {IERC777Sender} and {IERC777Recipient}.
*
* Emits {Minted} and {Transfer} events.
*
* Requirements
*
* - `account` cannot be the zero address.
* - if `account` is a contract, it must implement the {IERC777Recipient}
* interface.
*/
function _mint(
address operator,
address account,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
internal
{
require(account != address(0), "ERC777: mint to the zero address");
// Update state variables
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
_callTokensReceived(operator, address(0), account, amount, userData, operatorData, true);
emit Minted(operator, account, amount, userData, operatorData);
emit Transfer(address(0), account, amount);
}
/**
* @dev Send tokens
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
* @param requireReceptionAck if true, contract recipients are required to implement ERC777TokensRecipient
*/
function _send(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck
)
internal
{
require(from != address(0), "ERC777: send from the zero address");
require(to != address(0), "ERC777: send to the zero address");
_callTokensToSend(operator, from, to, amount, userData, operatorData);
_move(operator, from, to, amount, userData, operatorData);
_callTokensReceived(operator, from, to, amount, userData, operatorData, requireReceptionAck);
}
/**
* @dev Burn tokens
* @param operator address operator requesting the operation
* @param from address token holder address
* @param amount uint256 amount of tokens to burn
* @param data bytes extra information provided by the token holder
* @param operatorData bytes extra information provided by the operator (if any)
*/
function _burn(
address operator,
address from,
uint256 amount,
bytes memory data,
bytes memory operatorData
)
internal
{
require(from != address(0), "ERC777: burn from the zero address");
_callTokensToSend(operator, from, address(0), amount, data, operatorData);
// Update state variables
_balances[from] = _balances[from].sub(amount, "ERC777: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Burned(operator, from, amount, data, operatorData);
emit Transfer(from, address(0), amount);
}
function _move(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
internal
{
_balances[from] = _balances[from].sub(amount, "ERC777: transfer amount exceeds balance");
_balances[to] = _balances[to].add(amount);
emit Sent(operator, from, to, amount, userData, operatorData);
emit Transfer(from, to, amount);
}
function _approve(address holder, address spender, uint256 value) internal {
// TODO: restore this require statement if this function becomes internal, or is called at a new callsite. It is
// currently unnecessary.
//require(holder != address(0), "ERC777: approve from the zero address");
require(spender != address(0), "ERC777: approve to the zero address");
_allowances[holder][spender] = value;
emit Approval(holder, spender, value);
}
/**
* @dev Call from.tokensToSend() if the interface is registered
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
*/
function _callTokensToSend(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
private
{
address implementer = _erc1820.getInterfaceImplementer(from, TOKENS_SENDER_INTERFACE_HASH);
if (implementer != address(0)) {
IERC777Sender(implementer).tokensToSend(operator, from, to, amount, userData, operatorData);
}
}
/**
* @dev Call to.tokensReceived() if the interface is registered. Reverts if the recipient is a contract but
* tokensReceived() was not registered for the recipient
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
* @param requireReceptionAck if true, contract recipients are required to implement ERC777TokensRecipient
*/
function _callTokensReceived(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck
)
private
{
address implementer = _erc1820.getInterfaceImplementer(to, TOKENS_RECIPIENT_INTERFACE_HASH);
if (implementer != address(0)) {
IERC777Recipient(implementer).tokensReceived(operator, from, to, amount, userData, operatorData);
} else if (requireReceptionAck) {
require(!to.isContract(), "ERC777: token recipient contract has no implement for ERC777TokensRecipient");
}
}
} | /**
* @dev Implementation of the {IERC777} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
*
* Support for ERC20 is included in this contract, as specified by the EIP: both
* the ERC777 and ERC20 interfaces can be safely used when interacting with it.
* Both {IERC777-Sent} and {IERC20-Transfer} events are emitted on token
* movements.
*
* Additionally, the {IERC777-granularity} value is hard-coded to `1`, meaning that there
* are no special restrictions in the amount of tokens that created, moved, or
* destroyed. This makes integration with ERC20 applications seamless.
*/ | NatSpecMultiLine | operatorSend | function operatorSend(
address sender,
address recipient,
uint256 amount,
bytes calldata data,
bytes calldata operatorData
)
external
{
require(isOperatorFor(_msgSender(), sender), "ERC777: caller is not an operator for holder");
_send(_msgSender(), sender, recipient, amount, data, operatorData, true);
}
| /**
* @dev See {IERC777-operatorSend}.
*
* Emits {Sent} and {Transfer} events.
*/ | NatSpecMultiLine | v0.5.0+commit.1d4f565a | MIT | bzzr://c1bab4b5e3e40f4294e652b388dfc625ccf21445b4e184e78b601a51d58a2cc2 | {
"func_code_index": [
6467,
6860
]
} | 59,943 |
NNCProjectToken | patterns\token\ERC777\ERC777.sol | 0xa67462ff3314c682277771ae2bbcec08877c877a | Solidity | ERC777 | contract ERC777 is Context, IERC777, IERC20 {
using SafeMath for uint256;
using Address for address;
IERC1820Registry constant internal _erc1820 = IERC1820Registry(0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24);
mapping(address => uint256) private _balances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
// We inline the result of the following hashes because Solidity doesn't resolve them at compile time.
// See https://github.com/ethereum/solidity/issues/4024.
// keccak256("ERC777TokensSender")
bytes32 constant private TOKENS_SENDER_INTERFACE_HASH =
0x29ddb589b1fb5fc7cf394961c1adf5f8c6454761adf795e67fe149f658abe895;
// keccak256("ERC777TokensRecipient")
bytes32 constant private TOKENS_RECIPIENT_INTERFACE_HASH =
0xb281fc8c12954d22544db45de3159a39272895b169a852b314f9cc762e44c53b;
// This isn't ever read from - it's only used to respond to the defaultOperators query.
address[] private _defaultOperatorsArray;
// Immutable, but accounts may revoke them (tracked in __revokedDefaultOperators).
mapping(address => bool) private _defaultOperators;
// For each account, a mapping of its operators and revoked default operators.
mapping(address => mapping(address => bool)) private _operators;
mapping(address => mapping(address => bool)) private _revokedDefaultOperators;
// ERC20-allowances
mapping (address => mapping (address => uint256)) private _allowances;
/**
* @dev `defaultOperators` may be an empty array.
*/
constructor(
string memory name,
string memory symbol,
address[] memory defaultOperators
) public {
_name = name;
_symbol = symbol;
_defaultOperatorsArray = defaultOperators;
for (uint256 i = 0; i < _defaultOperatorsArray.length; i++) {
_defaultOperators[_defaultOperatorsArray[i]] = true;
}
// register interfaces
_erc1820.setInterfaceImplementer(address(this), keccak256("ERC777Token"), address(this));
_erc1820.setInterfaceImplementer(address(this), keccak256("ERC20Token"), address(this));
}
/**
* @dev See {IERC777-name}.
*/
function name() public view returns (string memory) {
return _name;
}
/**
* @dev See {IERC777-symbol}.
*/
function symbol() public view returns (string memory) {
return _symbol;
}
/**
* @dev See {ERC20Detailed-decimals}.
*
* Always returns 18, as per the
* [ERC777 EIP](https://eips.ethereum.org/EIPS/eip-777#backward-compatibility).
*/
function decimals() public pure returns (uint8) {
return 18;
}
/**
* @dev See {IERC777-granularity}.
*
* This implementation always returns `1`.
*/
function granularity() public view returns (uint256) {
return 1;
}
/**
* @dev See {IERC777-totalSupply}.
*/
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
/**
* @dev Returns the amount of tokens owned by an account (`tokenHolder`).
*/
function balanceOf(address tokenHolder) public view returns (uint256) {
return _balances[tokenHolder];
}
/**
* @dev See {IERC777-send}.
*
* Also emits a {Transfer} event for ERC20 compatibility.
*/
function send(address recipient, uint256 amount, bytes calldata data) external {
_send(_msgSender(), _msgSender(), recipient, amount, data, "", true);
}
/**
* @dev See {IERC20-transfer}.
*
* Unlike `send`, `recipient` is _not_ required to implement the {IERC777Recipient}
* interface if it is a contract.
*
* Also emits a {Sent} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool) {
require(recipient != address(0), "ERC777: transfer to the zero address");
address from = _msgSender();
_callTokensToSend(from, from, recipient, amount, "", "");
_move(from, from, recipient, amount, "", "");
_callTokensReceived(from, from, recipient, amount, "", "", false);
return true;
}
/**
* @dev See {IERC777-burn}.
*
* Also emits a {Transfer} event for ERC20 compatibility.
*/
function burn(uint256 amount, bytes calldata data) external {
_burn(_msgSender(), _msgSender(), amount, data, "");
}
/**
* @dev See {IERC777-isOperatorFor}.
*/
function isOperatorFor(
address operator,
address tokenHolder
) public view returns (bool) {
return operator == tokenHolder ||
(_defaultOperators[operator] && !_revokedDefaultOperators[tokenHolder][operator]) ||
_operators[tokenHolder][operator];
}
/**
* @dev See {IERC777-authorizeOperator}.
*/
function authorizeOperator(address operator) external {
_authorizeOperator(operator);
}
function _authorizeOperator(address operator) internal {
require(_msgSender() != operator, "ERC777: authorizing self as operator");
if (_defaultOperators[operator]) {
delete _revokedDefaultOperators[_msgSender()][operator];
} else {
_operators[_msgSender()][operator] = true;
}
emit AuthorizedOperator(operator, _msgSender());
}
/**
* @dev See {IERC777-revokeOperator}.
*/
function revokeOperator(address operator) external {
_revokeOperator(operator);
}
function _revokeOperator(address operator) internal {
require(operator != _msgSender(), "ERC777: revoking self as operator");
if (_defaultOperators[operator]) {
_revokedDefaultOperators[_msgSender()][operator] = true;
} else {
delete _operators[_msgSender()][operator];
}
emit RevokedOperator(operator, _msgSender());
}
/**
* @dev See {IERC777-defaultOperators}.
*/
function defaultOperators() public view returns (address[] memory) {
return _defaultOperatorsArray;
}
/**
* @dev See {IERC777-operatorSend}.
*
* Emits {Sent} and {Transfer} events.
*/
function operatorSend(
address sender,
address recipient,
uint256 amount,
bytes calldata data,
bytes calldata operatorData
)
external
{
require(isOperatorFor(_msgSender(), sender), "ERC777: caller is not an operator for holder");
_send(_msgSender(), sender, recipient, amount, data, operatorData, true);
}
/**
* @dev See {IERC777-operatorBurn}.
*
* Emits {Burned} and {Transfer} events.
*/
function operatorBurn(address account, uint256 amount, bytes calldata data, bytes calldata operatorData) external {
require(isOperatorFor(_msgSender(), account), "ERC777: caller is not an operator for holder");
_burn(_msgSender(), account, amount, data, operatorData);
}
/**
* @dev See {IERC20-allowance}.
*
* Note that operator and allowance concepts are orthogonal: operators may
* not have allowance, and accounts with allowance may not be operators
* themselves.
*/
function allowance(address holder, address spender) public view returns (uint256) {
return _allowances[holder][spender];
}
/**
* @dev See {IERC20-approve}.
*
* Note that accounts cannot have allowance issued by their operators.
*/
function approve(address spender, uint256 value) external returns (bool) {
address holder = _msgSender();
_approve(holder, spender, value);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Note that operator and allowance concepts are orthogonal: operators cannot
* call `transferFrom` (unless they have allowance), and accounts with
* allowance cannot call `operatorSend` (unless they are operators).
*
* Emits {Sent}, {Transfer} and {Approval} events.
*/
function transferFrom(address holder, address recipient, uint256 amount) external returns (bool) {
require(recipient != address(0), "ERC777: transfer to the zero address");
require(holder != address(0), "ERC777: transfer from the zero address");
address spender = _msgSender();
_callTokensToSend(spender, holder, recipient, amount, "", "");
_move(spender, holder, recipient, amount, "", "");
_approve(holder, spender, _allowances[holder][spender].sub(amount, "ERC777: transfer amount exceeds allowance"));
_callTokensReceived(spender, holder, recipient, amount, "", "", false);
return true;
}
/**
* @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* If a send hook is registered for `account`, the corresponding function
* will be called with `operator`, `data` and `operatorData`.
*
* See {IERC777Sender} and {IERC777Recipient}.
*
* Emits {Minted} and {Transfer} events.
*
* Requirements
*
* - `account` cannot be the zero address.
* - if `account` is a contract, it must implement the {IERC777Recipient}
* interface.
*/
function _mint(
address operator,
address account,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
internal
{
require(account != address(0), "ERC777: mint to the zero address");
// Update state variables
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
_callTokensReceived(operator, address(0), account, amount, userData, operatorData, true);
emit Minted(operator, account, amount, userData, operatorData);
emit Transfer(address(0), account, amount);
}
/**
* @dev Send tokens
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
* @param requireReceptionAck if true, contract recipients are required to implement ERC777TokensRecipient
*/
function _send(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck
)
internal
{
require(from != address(0), "ERC777: send from the zero address");
require(to != address(0), "ERC777: send to the zero address");
_callTokensToSend(operator, from, to, amount, userData, operatorData);
_move(operator, from, to, amount, userData, operatorData);
_callTokensReceived(operator, from, to, amount, userData, operatorData, requireReceptionAck);
}
/**
* @dev Burn tokens
* @param operator address operator requesting the operation
* @param from address token holder address
* @param amount uint256 amount of tokens to burn
* @param data bytes extra information provided by the token holder
* @param operatorData bytes extra information provided by the operator (if any)
*/
function _burn(
address operator,
address from,
uint256 amount,
bytes memory data,
bytes memory operatorData
)
internal
{
require(from != address(0), "ERC777: burn from the zero address");
_callTokensToSend(operator, from, address(0), amount, data, operatorData);
// Update state variables
_balances[from] = _balances[from].sub(amount, "ERC777: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Burned(operator, from, amount, data, operatorData);
emit Transfer(from, address(0), amount);
}
function _move(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
internal
{
_balances[from] = _balances[from].sub(amount, "ERC777: transfer amount exceeds balance");
_balances[to] = _balances[to].add(amount);
emit Sent(operator, from, to, amount, userData, operatorData);
emit Transfer(from, to, amount);
}
function _approve(address holder, address spender, uint256 value) internal {
// TODO: restore this require statement if this function becomes internal, or is called at a new callsite. It is
// currently unnecessary.
//require(holder != address(0), "ERC777: approve from the zero address");
require(spender != address(0), "ERC777: approve to the zero address");
_allowances[holder][spender] = value;
emit Approval(holder, spender, value);
}
/**
* @dev Call from.tokensToSend() if the interface is registered
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
*/
function _callTokensToSend(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
private
{
address implementer = _erc1820.getInterfaceImplementer(from, TOKENS_SENDER_INTERFACE_HASH);
if (implementer != address(0)) {
IERC777Sender(implementer).tokensToSend(operator, from, to, amount, userData, operatorData);
}
}
/**
* @dev Call to.tokensReceived() if the interface is registered. Reverts if the recipient is a contract but
* tokensReceived() was not registered for the recipient
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
* @param requireReceptionAck if true, contract recipients are required to implement ERC777TokensRecipient
*/
function _callTokensReceived(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck
)
private
{
address implementer = _erc1820.getInterfaceImplementer(to, TOKENS_RECIPIENT_INTERFACE_HASH);
if (implementer != address(0)) {
IERC777Recipient(implementer).tokensReceived(operator, from, to, amount, userData, operatorData);
} else if (requireReceptionAck) {
require(!to.isContract(), "ERC777: token recipient contract has no implement for ERC777TokensRecipient");
}
}
} | /**
* @dev Implementation of the {IERC777} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
*
* Support for ERC20 is included in this contract, as specified by the EIP: both
* the ERC777 and ERC20 interfaces can be safely used when interacting with it.
* Both {IERC777-Sent} and {IERC20-Transfer} events are emitted on token
* movements.
*
* Additionally, the {IERC777-granularity} value is hard-coded to `1`, meaning that there
* are no special restrictions in the amount of tokens that created, moved, or
* destroyed. This makes integration with ERC20 applications seamless.
*/ | NatSpecMultiLine | operatorBurn | function operatorBurn(address account, uint256 amount, bytes calldata data, bytes calldata operatorData) external {
require(isOperatorFor(_msgSender(), account), "ERC777: caller is not an operator for holder");
_burn(_msgSender(), account, amount, data, operatorData);
}
| /**
* @dev See {IERC777-operatorBurn}.
*
* Emits {Burned} and {Transfer} events.
*/ | NatSpecMultiLine | v0.5.0+commit.1d4f565a | MIT | bzzr://c1bab4b5e3e40f4294e652b388dfc625ccf21445b4e184e78b601a51d58a2cc2 | {
"func_code_index": [
6976,
7274
]
} | 59,944 |
NNCProjectToken | patterns\token\ERC777\ERC777.sol | 0xa67462ff3314c682277771ae2bbcec08877c877a | Solidity | ERC777 | contract ERC777 is Context, IERC777, IERC20 {
using SafeMath for uint256;
using Address for address;
IERC1820Registry constant internal _erc1820 = IERC1820Registry(0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24);
mapping(address => uint256) private _balances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
// We inline the result of the following hashes because Solidity doesn't resolve them at compile time.
// See https://github.com/ethereum/solidity/issues/4024.
// keccak256("ERC777TokensSender")
bytes32 constant private TOKENS_SENDER_INTERFACE_HASH =
0x29ddb589b1fb5fc7cf394961c1adf5f8c6454761adf795e67fe149f658abe895;
// keccak256("ERC777TokensRecipient")
bytes32 constant private TOKENS_RECIPIENT_INTERFACE_HASH =
0xb281fc8c12954d22544db45de3159a39272895b169a852b314f9cc762e44c53b;
// This isn't ever read from - it's only used to respond to the defaultOperators query.
address[] private _defaultOperatorsArray;
// Immutable, but accounts may revoke them (tracked in __revokedDefaultOperators).
mapping(address => bool) private _defaultOperators;
// For each account, a mapping of its operators and revoked default operators.
mapping(address => mapping(address => bool)) private _operators;
mapping(address => mapping(address => bool)) private _revokedDefaultOperators;
// ERC20-allowances
mapping (address => mapping (address => uint256)) private _allowances;
/**
* @dev `defaultOperators` may be an empty array.
*/
constructor(
string memory name,
string memory symbol,
address[] memory defaultOperators
) public {
_name = name;
_symbol = symbol;
_defaultOperatorsArray = defaultOperators;
for (uint256 i = 0; i < _defaultOperatorsArray.length; i++) {
_defaultOperators[_defaultOperatorsArray[i]] = true;
}
// register interfaces
_erc1820.setInterfaceImplementer(address(this), keccak256("ERC777Token"), address(this));
_erc1820.setInterfaceImplementer(address(this), keccak256("ERC20Token"), address(this));
}
/**
* @dev See {IERC777-name}.
*/
function name() public view returns (string memory) {
return _name;
}
/**
* @dev See {IERC777-symbol}.
*/
function symbol() public view returns (string memory) {
return _symbol;
}
/**
* @dev See {ERC20Detailed-decimals}.
*
* Always returns 18, as per the
* [ERC777 EIP](https://eips.ethereum.org/EIPS/eip-777#backward-compatibility).
*/
function decimals() public pure returns (uint8) {
return 18;
}
/**
* @dev See {IERC777-granularity}.
*
* This implementation always returns `1`.
*/
function granularity() public view returns (uint256) {
return 1;
}
/**
* @dev See {IERC777-totalSupply}.
*/
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
/**
* @dev Returns the amount of tokens owned by an account (`tokenHolder`).
*/
function balanceOf(address tokenHolder) public view returns (uint256) {
return _balances[tokenHolder];
}
/**
* @dev See {IERC777-send}.
*
* Also emits a {Transfer} event for ERC20 compatibility.
*/
function send(address recipient, uint256 amount, bytes calldata data) external {
_send(_msgSender(), _msgSender(), recipient, amount, data, "", true);
}
/**
* @dev See {IERC20-transfer}.
*
* Unlike `send`, `recipient` is _not_ required to implement the {IERC777Recipient}
* interface if it is a contract.
*
* Also emits a {Sent} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool) {
require(recipient != address(0), "ERC777: transfer to the zero address");
address from = _msgSender();
_callTokensToSend(from, from, recipient, amount, "", "");
_move(from, from, recipient, amount, "", "");
_callTokensReceived(from, from, recipient, amount, "", "", false);
return true;
}
/**
* @dev See {IERC777-burn}.
*
* Also emits a {Transfer} event for ERC20 compatibility.
*/
function burn(uint256 amount, bytes calldata data) external {
_burn(_msgSender(), _msgSender(), amount, data, "");
}
/**
* @dev See {IERC777-isOperatorFor}.
*/
function isOperatorFor(
address operator,
address tokenHolder
) public view returns (bool) {
return operator == tokenHolder ||
(_defaultOperators[operator] && !_revokedDefaultOperators[tokenHolder][operator]) ||
_operators[tokenHolder][operator];
}
/**
* @dev See {IERC777-authorizeOperator}.
*/
function authorizeOperator(address operator) external {
_authorizeOperator(operator);
}
function _authorizeOperator(address operator) internal {
require(_msgSender() != operator, "ERC777: authorizing self as operator");
if (_defaultOperators[operator]) {
delete _revokedDefaultOperators[_msgSender()][operator];
} else {
_operators[_msgSender()][operator] = true;
}
emit AuthorizedOperator(operator, _msgSender());
}
/**
* @dev See {IERC777-revokeOperator}.
*/
function revokeOperator(address operator) external {
_revokeOperator(operator);
}
function _revokeOperator(address operator) internal {
require(operator != _msgSender(), "ERC777: revoking self as operator");
if (_defaultOperators[operator]) {
_revokedDefaultOperators[_msgSender()][operator] = true;
} else {
delete _operators[_msgSender()][operator];
}
emit RevokedOperator(operator, _msgSender());
}
/**
* @dev See {IERC777-defaultOperators}.
*/
function defaultOperators() public view returns (address[] memory) {
return _defaultOperatorsArray;
}
/**
* @dev See {IERC777-operatorSend}.
*
* Emits {Sent} and {Transfer} events.
*/
function operatorSend(
address sender,
address recipient,
uint256 amount,
bytes calldata data,
bytes calldata operatorData
)
external
{
require(isOperatorFor(_msgSender(), sender), "ERC777: caller is not an operator for holder");
_send(_msgSender(), sender, recipient, amount, data, operatorData, true);
}
/**
* @dev See {IERC777-operatorBurn}.
*
* Emits {Burned} and {Transfer} events.
*/
function operatorBurn(address account, uint256 amount, bytes calldata data, bytes calldata operatorData) external {
require(isOperatorFor(_msgSender(), account), "ERC777: caller is not an operator for holder");
_burn(_msgSender(), account, amount, data, operatorData);
}
/**
* @dev See {IERC20-allowance}.
*
* Note that operator and allowance concepts are orthogonal: operators may
* not have allowance, and accounts with allowance may not be operators
* themselves.
*/
function allowance(address holder, address spender) public view returns (uint256) {
return _allowances[holder][spender];
}
/**
* @dev See {IERC20-approve}.
*
* Note that accounts cannot have allowance issued by their operators.
*/
function approve(address spender, uint256 value) external returns (bool) {
address holder = _msgSender();
_approve(holder, spender, value);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Note that operator and allowance concepts are orthogonal: operators cannot
* call `transferFrom` (unless they have allowance), and accounts with
* allowance cannot call `operatorSend` (unless they are operators).
*
* Emits {Sent}, {Transfer} and {Approval} events.
*/
function transferFrom(address holder, address recipient, uint256 amount) external returns (bool) {
require(recipient != address(0), "ERC777: transfer to the zero address");
require(holder != address(0), "ERC777: transfer from the zero address");
address spender = _msgSender();
_callTokensToSend(spender, holder, recipient, amount, "", "");
_move(spender, holder, recipient, amount, "", "");
_approve(holder, spender, _allowances[holder][spender].sub(amount, "ERC777: transfer amount exceeds allowance"));
_callTokensReceived(spender, holder, recipient, amount, "", "", false);
return true;
}
/**
* @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* If a send hook is registered for `account`, the corresponding function
* will be called with `operator`, `data` and `operatorData`.
*
* See {IERC777Sender} and {IERC777Recipient}.
*
* Emits {Minted} and {Transfer} events.
*
* Requirements
*
* - `account` cannot be the zero address.
* - if `account` is a contract, it must implement the {IERC777Recipient}
* interface.
*/
function _mint(
address operator,
address account,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
internal
{
require(account != address(0), "ERC777: mint to the zero address");
// Update state variables
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
_callTokensReceived(operator, address(0), account, amount, userData, operatorData, true);
emit Minted(operator, account, amount, userData, operatorData);
emit Transfer(address(0), account, amount);
}
/**
* @dev Send tokens
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
* @param requireReceptionAck if true, contract recipients are required to implement ERC777TokensRecipient
*/
function _send(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck
)
internal
{
require(from != address(0), "ERC777: send from the zero address");
require(to != address(0), "ERC777: send to the zero address");
_callTokensToSend(operator, from, to, amount, userData, operatorData);
_move(operator, from, to, amount, userData, operatorData);
_callTokensReceived(operator, from, to, amount, userData, operatorData, requireReceptionAck);
}
/**
* @dev Burn tokens
* @param operator address operator requesting the operation
* @param from address token holder address
* @param amount uint256 amount of tokens to burn
* @param data bytes extra information provided by the token holder
* @param operatorData bytes extra information provided by the operator (if any)
*/
function _burn(
address operator,
address from,
uint256 amount,
bytes memory data,
bytes memory operatorData
)
internal
{
require(from != address(0), "ERC777: burn from the zero address");
_callTokensToSend(operator, from, address(0), amount, data, operatorData);
// Update state variables
_balances[from] = _balances[from].sub(amount, "ERC777: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Burned(operator, from, amount, data, operatorData);
emit Transfer(from, address(0), amount);
}
function _move(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
internal
{
_balances[from] = _balances[from].sub(amount, "ERC777: transfer amount exceeds balance");
_balances[to] = _balances[to].add(amount);
emit Sent(operator, from, to, amount, userData, operatorData);
emit Transfer(from, to, amount);
}
function _approve(address holder, address spender, uint256 value) internal {
// TODO: restore this require statement if this function becomes internal, or is called at a new callsite. It is
// currently unnecessary.
//require(holder != address(0), "ERC777: approve from the zero address");
require(spender != address(0), "ERC777: approve to the zero address");
_allowances[holder][spender] = value;
emit Approval(holder, spender, value);
}
/**
* @dev Call from.tokensToSend() if the interface is registered
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
*/
function _callTokensToSend(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
private
{
address implementer = _erc1820.getInterfaceImplementer(from, TOKENS_SENDER_INTERFACE_HASH);
if (implementer != address(0)) {
IERC777Sender(implementer).tokensToSend(operator, from, to, amount, userData, operatorData);
}
}
/**
* @dev Call to.tokensReceived() if the interface is registered. Reverts if the recipient is a contract but
* tokensReceived() was not registered for the recipient
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
* @param requireReceptionAck if true, contract recipients are required to implement ERC777TokensRecipient
*/
function _callTokensReceived(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck
)
private
{
address implementer = _erc1820.getInterfaceImplementer(to, TOKENS_RECIPIENT_INTERFACE_HASH);
if (implementer != address(0)) {
IERC777Recipient(implementer).tokensReceived(operator, from, to, amount, userData, operatorData);
} else if (requireReceptionAck) {
require(!to.isContract(), "ERC777: token recipient contract has no implement for ERC777TokensRecipient");
}
}
} | /**
* @dev Implementation of the {IERC777} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
*
* Support for ERC20 is included in this contract, as specified by the EIP: both
* the ERC777 and ERC20 interfaces can be safely used when interacting with it.
* Both {IERC777-Sent} and {IERC20-Transfer} events are emitted on token
* movements.
*
* Additionally, the {IERC777-granularity} value is hard-coded to `1`, meaning that there
* are no special restrictions in the amount of tokens that created, moved, or
* destroyed. This makes integration with ERC20 applications seamless.
*/ | NatSpecMultiLine | allowance | function allowance(address holder, address spender) public view returns (uint256) {
return _allowances[holder][spender];
}
| /**
* @dev See {IERC20-allowance}.
*
* Note that operator and allowance concepts are orthogonal: operators may
* not have allowance, and accounts with allowance may not be operators
* themselves.
*/ | NatSpecMultiLine | v0.5.0+commit.1d4f565a | MIT | bzzr://c1bab4b5e3e40f4294e652b388dfc625ccf21445b4e184e78b601a51d58a2cc2 | {
"func_code_index": [
7517,
7658
]
} | 59,945 |
NNCProjectToken | patterns\token\ERC777\ERC777.sol | 0xa67462ff3314c682277771ae2bbcec08877c877a | Solidity | ERC777 | contract ERC777 is Context, IERC777, IERC20 {
using SafeMath for uint256;
using Address for address;
IERC1820Registry constant internal _erc1820 = IERC1820Registry(0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24);
mapping(address => uint256) private _balances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
// We inline the result of the following hashes because Solidity doesn't resolve them at compile time.
// See https://github.com/ethereum/solidity/issues/4024.
// keccak256("ERC777TokensSender")
bytes32 constant private TOKENS_SENDER_INTERFACE_HASH =
0x29ddb589b1fb5fc7cf394961c1adf5f8c6454761adf795e67fe149f658abe895;
// keccak256("ERC777TokensRecipient")
bytes32 constant private TOKENS_RECIPIENT_INTERFACE_HASH =
0xb281fc8c12954d22544db45de3159a39272895b169a852b314f9cc762e44c53b;
// This isn't ever read from - it's only used to respond to the defaultOperators query.
address[] private _defaultOperatorsArray;
// Immutable, but accounts may revoke them (tracked in __revokedDefaultOperators).
mapping(address => bool) private _defaultOperators;
// For each account, a mapping of its operators and revoked default operators.
mapping(address => mapping(address => bool)) private _operators;
mapping(address => mapping(address => bool)) private _revokedDefaultOperators;
// ERC20-allowances
mapping (address => mapping (address => uint256)) private _allowances;
/**
* @dev `defaultOperators` may be an empty array.
*/
constructor(
string memory name,
string memory symbol,
address[] memory defaultOperators
) public {
_name = name;
_symbol = symbol;
_defaultOperatorsArray = defaultOperators;
for (uint256 i = 0; i < _defaultOperatorsArray.length; i++) {
_defaultOperators[_defaultOperatorsArray[i]] = true;
}
// register interfaces
_erc1820.setInterfaceImplementer(address(this), keccak256("ERC777Token"), address(this));
_erc1820.setInterfaceImplementer(address(this), keccak256("ERC20Token"), address(this));
}
/**
* @dev See {IERC777-name}.
*/
function name() public view returns (string memory) {
return _name;
}
/**
* @dev See {IERC777-symbol}.
*/
function symbol() public view returns (string memory) {
return _symbol;
}
/**
* @dev See {ERC20Detailed-decimals}.
*
* Always returns 18, as per the
* [ERC777 EIP](https://eips.ethereum.org/EIPS/eip-777#backward-compatibility).
*/
function decimals() public pure returns (uint8) {
return 18;
}
/**
* @dev See {IERC777-granularity}.
*
* This implementation always returns `1`.
*/
function granularity() public view returns (uint256) {
return 1;
}
/**
* @dev See {IERC777-totalSupply}.
*/
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
/**
* @dev Returns the amount of tokens owned by an account (`tokenHolder`).
*/
function balanceOf(address tokenHolder) public view returns (uint256) {
return _balances[tokenHolder];
}
/**
* @dev See {IERC777-send}.
*
* Also emits a {Transfer} event for ERC20 compatibility.
*/
function send(address recipient, uint256 amount, bytes calldata data) external {
_send(_msgSender(), _msgSender(), recipient, amount, data, "", true);
}
/**
* @dev See {IERC20-transfer}.
*
* Unlike `send`, `recipient` is _not_ required to implement the {IERC777Recipient}
* interface if it is a contract.
*
* Also emits a {Sent} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool) {
require(recipient != address(0), "ERC777: transfer to the zero address");
address from = _msgSender();
_callTokensToSend(from, from, recipient, amount, "", "");
_move(from, from, recipient, amount, "", "");
_callTokensReceived(from, from, recipient, amount, "", "", false);
return true;
}
/**
* @dev See {IERC777-burn}.
*
* Also emits a {Transfer} event for ERC20 compatibility.
*/
function burn(uint256 amount, bytes calldata data) external {
_burn(_msgSender(), _msgSender(), amount, data, "");
}
/**
* @dev See {IERC777-isOperatorFor}.
*/
function isOperatorFor(
address operator,
address tokenHolder
) public view returns (bool) {
return operator == tokenHolder ||
(_defaultOperators[operator] && !_revokedDefaultOperators[tokenHolder][operator]) ||
_operators[tokenHolder][operator];
}
/**
* @dev See {IERC777-authorizeOperator}.
*/
function authorizeOperator(address operator) external {
_authorizeOperator(operator);
}
function _authorizeOperator(address operator) internal {
require(_msgSender() != operator, "ERC777: authorizing self as operator");
if (_defaultOperators[operator]) {
delete _revokedDefaultOperators[_msgSender()][operator];
} else {
_operators[_msgSender()][operator] = true;
}
emit AuthorizedOperator(operator, _msgSender());
}
/**
* @dev See {IERC777-revokeOperator}.
*/
function revokeOperator(address operator) external {
_revokeOperator(operator);
}
function _revokeOperator(address operator) internal {
require(operator != _msgSender(), "ERC777: revoking self as operator");
if (_defaultOperators[operator]) {
_revokedDefaultOperators[_msgSender()][operator] = true;
} else {
delete _operators[_msgSender()][operator];
}
emit RevokedOperator(operator, _msgSender());
}
/**
* @dev See {IERC777-defaultOperators}.
*/
function defaultOperators() public view returns (address[] memory) {
return _defaultOperatorsArray;
}
/**
* @dev See {IERC777-operatorSend}.
*
* Emits {Sent} and {Transfer} events.
*/
function operatorSend(
address sender,
address recipient,
uint256 amount,
bytes calldata data,
bytes calldata operatorData
)
external
{
require(isOperatorFor(_msgSender(), sender), "ERC777: caller is not an operator for holder");
_send(_msgSender(), sender, recipient, amount, data, operatorData, true);
}
/**
* @dev See {IERC777-operatorBurn}.
*
* Emits {Burned} and {Transfer} events.
*/
function operatorBurn(address account, uint256 amount, bytes calldata data, bytes calldata operatorData) external {
require(isOperatorFor(_msgSender(), account), "ERC777: caller is not an operator for holder");
_burn(_msgSender(), account, amount, data, operatorData);
}
/**
* @dev See {IERC20-allowance}.
*
* Note that operator and allowance concepts are orthogonal: operators may
* not have allowance, and accounts with allowance may not be operators
* themselves.
*/
function allowance(address holder, address spender) public view returns (uint256) {
return _allowances[holder][spender];
}
/**
* @dev See {IERC20-approve}.
*
* Note that accounts cannot have allowance issued by their operators.
*/
function approve(address spender, uint256 value) external returns (bool) {
address holder = _msgSender();
_approve(holder, spender, value);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Note that operator and allowance concepts are orthogonal: operators cannot
* call `transferFrom` (unless they have allowance), and accounts with
* allowance cannot call `operatorSend` (unless they are operators).
*
* Emits {Sent}, {Transfer} and {Approval} events.
*/
function transferFrom(address holder, address recipient, uint256 amount) external returns (bool) {
require(recipient != address(0), "ERC777: transfer to the zero address");
require(holder != address(0), "ERC777: transfer from the zero address");
address spender = _msgSender();
_callTokensToSend(spender, holder, recipient, amount, "", "");
_move(spender, holder, recipient, amount, "", "");
_approve(holder, spender, _allowances[holder][spender].sub(amount, "ERC777: transfer amount exceeds allowance"));
_callTokensReceived(spender, holder, recipient, amount, "", "", false);
return true;
}
/**
* @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* If a send hook is registered for `account`, the corresponding function
* will be called with `operator`, `data` and `operatorData`.
*
* See {IERC777Sender} and {IERC777Recipient}.
*
* Emits {Minted} and {Transfer} events.
*
* Requirements
*
* - `account` cannot be the zero address.
* - if `account` is a contract, it must implement the {IERC777Recipient}
* interface.
*/
function _mint(
address operator,
address account,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
internal
{
require(account != address(0), "ERC777: mint to the zero address");
// Update state variables
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
_callTokensReceived(operator, address(0), account, amount, userData, operatorData, true);
emit Minted(operator, account, amount, userData, operatorData);
emit Transfer(address(0), account, amount);
}
/**
* @dev Send tokens
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
* @param requireReceptionAck if true, contract recipients are required to implement ERC777TokensRecipient
*/
function _send(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck
)
internal
{
require(from != address(0), "ERC777: send from the zero address");
require(to != address(0), "ERC777: send to the zero address");
_callTokensToSend(operator, from, to, amount, userData, operatorData);
_move(operator, from, to, amount, userData, operatorData);
_callTokensReceived(operator, from, to, amount, userData, operatorData, requireReceptionAck);
}
/**
* @dev Burn tokens
* @param operator address operator requesting the operation
* @param from address token holder address
* @param amount uint256 amount of tokens to burn
* @param data bytes extra information provided by the token holder
* @param operatorData bytes extra information provided by the operator (if any)
*/
function _burn(
address operator,
address from,
uint256 amount,
bytes memory data,
bytes memory operatorData
)
internal
{
require(from != address(0), "ERC777: burn from the zero address");
_callTokensToSend(operator, from, address(0), amount, data, operatorData);
// Update state variables
_balances[from] = _balances[from].sub(amount, "ERC777: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Burned(operator, from, amount, data, operatorData);
emit Transfer(from, address(0), amount);
}
function _move(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
internal
{
_balances[from] = _balances[from].sub(amount, "ERC777: transfer amount exceeds balance");
_balances[to] = _balances[to].add(amount);
emit Sent(operator, from, to, amount, userData, operatorData);
emit Transfer(from, to, amount);
}
function _approve(address holder, address spender, uint256 value) internal {
// TODO: restore this require statement if this function becomes internal, or is called at a new callsite. It is
// currently unnecessary.
//require(holder != address(0), "ERC777: approve from the zero address");
require(spender != address(0), "ERC777: approve to the zero address");
_allowances[holder][spender] = value;
emit Approval(holder, spender, value);
}
/**
* @dev Call from.tokensToSend() if the interface is registered
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
*/
function _callTokensToSend(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
private
{
address implementer = _erc1820.getInterfaceImplementer(from, TOKENS_SENDER_INTERFACE_HASH);
if (implementer != address(0)) {
IERC777Sender(implementer).tokensToSend(operator, from, to, amount, userData, operatorData);
}
}
/**
* @dev Call to.tokensReceived() if the interface is registered. Reverts if the recipient is a contract but
* tokensReceived() was not registered for the recipient
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
* @param requireReceptionAck if true, contract recipients are required to implement ERC777TokensRecipient
*/
function _callTokensReceived(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck
)
private
{
address implementer = _erc1820.getInterfaceImplementer(to, TOKENS_RECIPIENT_INTERFACE_HASH);
if (implementer != address(0)) {
IERC777Recipient(implementer).tokensReceived(operator, from, to, amount, userData, operatorData);
} else if (requireReceptionAck) {
require(!to.isContract(), "ERC777: token recipient contract has no implement for ERC777TokensRecipient");
}
}
} | /**
* @dev Implementation of the {IERC777} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
*
* Support for ERC20 is included in this contract, as specified by the EIP: both
* the ERC777 and ERC20 interfaces can be safely used when interacting with it.
* Both {IERC777-Sent} and {IERC20-Transfer} events are emitted on token
* movements.
*
* Additionally, the {IERC777-granularity} value is hard-coded to `1`, meaning that there
* are no special restrictions in the amount of tokens that created, moved, or
* destroyed. This makes integration with ERC20 applications seamless.
*/ | NatSpecMultiLine | approve | function approve(address spender, uint256 value) external returns (bool) {
address holder = _msgSender();
_approve(holder, spender, value);
return true;
}
| /**
* @dev See {IERC20-approve}.
*
* Note that accounts cannot have allowance issued by their operators.
*/ | NatSpecMultiLine | v0.5.0+commit.1d4f565a | MIT | bzzr://c1bab4b5e3e40f4294e652b388dfc625ccf21445b4e184e78b601a51d58a2cc2 | {
"func_code_index": [
7798,
7989
]
} | 59,946 |
NNCProjectToken | patterns\token\ERC777\ERC777.sol | 0xa67462ff3314c682277771ae2bbcec08877c877a | Solidity | ERC777 | contract ERC777 is Context, IERC777, IERC20 {
using SafeMath for uint256;
using Address for address;
IERC1820Registry constant internal _erc1820 = IERC1820Registry(0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24);
mapping(address => uint256) private _balances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
// We inline the result of the following hashes because Solidity doesn't resolve them at compile time.
// See https://github.com/ethereum/solidity/issues/4024.
// keccak256("ERC777TokensSender")
bytes32 constant private TOKENS_SENDER_INTERFACE_HASH =
0x29ddb589b1fb5fc7cf394961c1adf5f8c6454761adf795e67fe149f658abe895;
// keccak256("ERC777TokensRecipient")
bytes32 constant private TOKENS_RECIPIENT_INTERFACE_HASH =
0xb281fc8c12954d22544db45de3159a39272895b169a852b314f9cc762e44c53b;
// This isn't ever read from - it's only used to respond to the defaultOperators query.
address[] private _defaultOperatorsArray;
// Immutable, but accounts may revoke them (tracked in __revokedDefaultOperators).
mapping(address => bool) private _defaultOperators;
// For each account, a mapping of its operators and revoked default operators.
mapping(address => mapping(address => bool)) private _operators;
mapping(address => mapping(address => bool)) private _revokedDefaultOperators;
// ERC20-allowances
mapping (address => mapping (address => uint256)) private _allowances;
/**
* @dev `defaultOperators` may be an empty array.
*/
constructor(
string memory name,
string memory symbol,
address[] memory defaultOperators
) public {
_name = name;
_symbol = symbol;
_defaultOperatorsArray = defaultOperators;
for (uint256 i = 0; i < _defaultOperatorsArray.length; i++) {
_defaultOperators[_defaultOperatorsArray[i]] = true;
}
// register interfaces
_erc1820.setInterfaceImplementer(address(this), keccak256("ERC777Token"), address(this));
_erc1820.setInterfaceImplementer(address(this), keccak256("ERC20Token"), address(this));
}
/**
* @dev See {IERC777-name}.
*/
function name() public view returns (string memory) {
return _name;
}
/**
* @dev See {IERC777-symbol}.
*/
function symbol() public view returns (string memory) {
return _symbol;
}
/**
* @dev See {ERC20Detailed-decimals}.
*
* Always returns 18, as per the
* [ERC777 EIP](https://eips.ethereum.org/EIPS/eip-777#backward-compatibility).
*/
function decimals() public pure returns (uint8) {
return 18;
}
/**
* @dev See {IERC777-granularity}.
*
* This implementation always returns `1`.
*/
function granularity() public view returns (uint256) {
return 1;
}
/**
* @dev See {IERC777-totalSupply}.
*/
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
/**
* @dev Returns the amount of tokens owned by an account (`tokenHolder`).
*/
function balanceOf(address tokenHolder) public view returns (uint256) {
return _balances[tokenHolder];
}
/**
* @dev See {IERC777-send}.
*
* Also emits a {Transfer} event for ERC20 compatibility.
*/
function send(address recipient, uint256 amount, bytes calldata data) external {
_send(_msgSender(), _msgSender(), recipient, amount, data, "", true);
}
/**
* @dev See {IERC20-transfer}.
*
* Unlike `send`, `recipient` is _not_ required to implement the {IERC777Recipient}
* interface if it is a contract.
*
* Also emits a {Sent} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool) {
require(recipient != address(0), "ERC777: transfer to the zero address");
address from = _msgSender();
_callTokensToSend(from, from, recipient, amount, "", "");
_move(from, from, recipient, amount, "", "");
_callTokensReceived(from, from, recipient, amount, "", "", false);
return true;
}
/**
* @dev See {IERC777-burn}.
*
* Also emits a {Transfer} event for ERC20 compatibility.
*/
function burn(uint256 amount, bytes calldata data) external {
_burn(_msgSender(), _msgSender(), amount, data, "");
}
/**
* @dev See {IERC777-isOperatorFor}.
*/
function isOperatorFor(
address operator,
address tokenHolder
) public view returns (bool) {
return operator == tokenHolder ||
(_defaultOperators[operator] && !_revokedDefaultOperators[tokenHolder][operator]) ||
_operators[tokenHolder][operator];
}
/**
* @dev See {IERC777-authorizeOperator}.
*/
function authorizeOperator(address operator) external {
_authorizeOperator(operator);
}
function _authorizeOperator(address operator) internal {
require(_msgSender() != operator, "ERC777: authorizing self as operator");
if (_defaultOperators[operator]) {
delete _revokedDefaultOperators[_msgSender()][operator];
} else {
_operators[_msgSender()][operator] = true;
}
emit AuthorizedOperator(operator, _msgSender());
}
/**
* @dev See {IERC777-revokeOperator}.
*/
function revokeOperator(address operator) external {
_revokeOperator(operator);
}
function _revokeOperator(address operator) internal {
require(operator != _msgSender(), "ERC777: revoking self as operator");
if (_defaultOperators[operator]) {
_revokedDefaultOperators[_msgSender()][operator] = true;
} else {
delete _operators[_msgSender()][operator];
}
emit RevokedOperator(operator, _msgSender());
}
/**
* @dev See {IERC777-defaultOperators}.
*/
function defaultOperators() public view returns (address[] memory) {
return _defaultOperatorsArray;
}
/**
* @dev See {IERC777-operatorSend}.
*
* Emits {Sent} and {Transfer} events.
*/
function operatorSend(
address sender,
address recipient,
uint256 amount,
bytes calldata data,
bytes calldata operatorData
)
external
{
require(isOperatorFor(_msgSender(), sender), "ERC777: caller is not an operator for holder");
_send(_msgSender(), sender, recipient, amount, data, operatorData, true);
}
/**
* @dev See {IERC777-operatorBurn}.
*
* Emits {Burned} and {Transfer} events.
*/
function operatorBurn(address account, uint256 amount, bytes calldata data, bytes calldata operatorData) external {
require(isOperatorFor(_msgSender(), account), "ERC777: caller is not an operator for holder");
_burn(_msgSender(), account, amount, data, operatorData);
}
/**
* @dev See {IERC20-allowance}.
*
* Note that operator and allowance concepts are orthogonal: operators may
* not have allowance, and accounts with allowance may not be operators
* themselves.
*/
function allowance(address holder, address spender) public view returns (uint256) {
return _allowances[holder][spender];
}
/**
* @dev See {IERC20-approve}.
*
* Note that accounts cannot have allowance issued by their operators.
*/
function approve(address spender, uint256 value) external returns (bool) {
address holder = _msgSender();
_approve(holder, spender, value);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Note that operator and allowance concepts are orthogonal: operators cannot
* call `transferFrom` (unless they have allowance), and accounts with
* allowance cannot call `operatorSend` (unless they are operators).
*
* Emits {Sent}, {Transfer} and {Approval} events.
*/
function transferFrom(address holder, address recipient, uint256 amount) external returns (bool) {
require(recipient != address(0), "ERC777: transfer to the zero address");
require(holder != address(0), "ERC777: transfer from the zero address");
address spender = _msgSender();
_callTokensToSend(spender, holder, recipient, amount, "", "");
_move(spender, holder, recipient, amount, "", "");
_approve(holder, spender, _allowances[holder][spender].sub(amount, "ERC777: transfer amount exceeds allowance"));
_callTokensReceived(spender, holder, recipient, amount, "", "", false);
return true;
}
/**
* @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* If a send hook is registered for `account`, the corresponding function
* will be called with `operator`, `data` and `operatorData`.
*
* See {IERC777Sender} and {IERC777Recipient}.
*
* Emits {Minted} and {Transfer} events.
*
* Requirements
*
* - `account` cannot be the zero address.
* - if `account` is a contract, it must implement the {IERC777Recipient}
* interface.
*/
function _mint(
address operator,
address account,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
internal
{
require(account != address(0), "ERC777: mint to the zero address");
// Update state variables
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
_callTokensReceived(operator, address(0), account, amount, userData, operatorData, true);
emit Minted(operator, account, amount, userData, operatorData);
emit Transfer(address(0), account, amount);
}
/**
* @dev Send tokens
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
* @param requireReceptionAck if true, contract recipients are required to implement ERC777TokensRecipient
*/
function _send(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck
)
internal
{
require(from != address(0), "ERC777: send from the zero address");
require(to != address(0), "ERC777: send to the zero address");
_callTokensToSend(operator, from, to, amount, userData, operatorData);
_move(operator, from, to, amount, userData, operatorData);
_callTokensReceived(operator, from, to, amount, userData, operatorData, requireReceptionAck);
}
/**
* @dev Burn tokens
* @param operator address operator requesting the operation
* @param from address token holder address
* @param amount uint256 amount of tokens to burn
* @param data bytes extra information provided by the token holder
* @param operatorData bytes extra information provided by the operator (if any)
*/
function _burn(
address operator,
address from,
uint256 amount,
bytes memory data,
bytes memory operatorData
)
internal
{
require(from != address(0), "ERC777: burn from the zero address");
_callTokensToSend(operator, from, address(0), amount, data, operatorData);
// Update state variables
_balances[from] = _balances[from].sub(amount, "ERC777: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Burned(operator, from, amount, data, operatorData);
emit Transfer(from, address(0), amount);
}
function _move(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
internal
{
_balances[from] = _balances[from].sub(amount, "ERC777: transfer amount exceeds balance");
_balances[to] = _balances[to].add(amount);
emit Sent(operator, from, to, amount, userData, operatorData);
emit Transfer(from, to, amount);
}
function _approve(address holder, address spender, uint256 value) internal {
// TODO: restore this require statement if this function becomes internal, or is called at a new callsite. It is
// currently unnecessary.
//require(holder != address(0), "ERC777: approve from the zero address");
require(spender != address(0), "ERC777: approve to the zero address");
_allowances[holder][spender] = value;
emit Approval(holder, spender, value);
}
/**
* @dev Call from.tokensToSend() if the interface is registered
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
*/
function _callTokensToSend(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
private
{
address implementer = _erc1820.getInterfaceImplementer(from, TOKENS_SENDER_INTERFACE_HASH);
if (implementer != address(0)) {
IERC777Sender(implementer).tokensToSend(operator, from, to, amount, userData, operatorData);
}
}
/**
* @dev Call to.tokensReceived() if the interface is registered. Reverts if the recipient is a contract but
* tokensReceived() was not registered for the recipient
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
* @param requireReceptionAck if true, contract recipients are required to implement ERC777TokensRecipient
*/
function _callTokensReceived(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck
)
private
{
address implementer = _erc1820.getInterfaceImplementer(to, TOKENS_RECIPIENT_INTERFACE_HASH);
if (implementer != address(0)) {
IERC777Recipient(implementer).tokensReceived(operator, from, to, amount, userData, operatorData);
} else if (requireReceptionAck) {
require(!to.isContract(), "ERC777: token recipient contract has no implement for ERC777TokensRecipient");
}
}
} | /**
* @dev Implementation of the {IERC777} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
*
* Support for ERC20 is included in this contract, as specified by the EIP: both
* the ERC777 and ERC20 interfaces can be safely used when interacting with it.
* Both {IERC777-Sent} and {IERC20-Transfer} events are emitted on token
* movements.
*
* Additionally, the {IERC777-granularity} value is hard-coded to `1`, meaning that there
* are no special restrictions in the amount of tokens that created, moved, or
* destroyed. This makes integration with ERC20 applications seamless.
*/ | NatSpecMultiLine | transferFrom | function transferFrom(address holder, address recipient, uint256 amount) external returns (bool) {
require(recipient != address(0), "ERC777: transfer to the zero address");
require(holder != address(0), "ERC777: transfer from the zero address");
address spender = _msgSender();
_callTokensToSend(spender, holder, recipient, amount, "", "");
_move(spender, holder, recipient, amount, "", "");
_approve(holder, spender, _allowances[holder][spender].sub(amount, "ERC777: transfer amount exceeds allowance"));
_callTokensReceived(spender, holder, recipient, amount, "", "", false);
return true;
}
| /**
* @dev See {IERC20-transferFrom}.
*
* Note that operator and allowance concepts are orthogonal: operators cannot
* call `transferFrom` (unless they have allowance), and accounts with
* allowance cannot call `operatorSend` (unless they are operators).
*
* Emits {Sent}, {Transfer} and {Approval} events.
*/ | NatSpecMultiLine | v0.5.0+commit.1d4f565a | MIT | bzzr://c1bab4b5e3e40f4294e652b388dfc625ccf21445b4e184e78b601a51d58a2cc2 | {
"func_code_index": [
8346,
9030
]
} | 59,947 |
NNCProjectToken | patterns\token\ERC777\ERC777.sol | 0xa67462ff3314c682277771ae2bbcec08877c877a | Solidity | ERC777 | contract ERC777 is Context, IERC777, IERC20 {
using SafeMath for uint256;
using Address for address;
IERC1820Registry constant internal _erc1820 = IERC1820Registry(0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24);
mapping(address => uint256) private _balances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
// We inline the result of the following hashes because Solidity doesn't resolve them at compile time.
// See https://github.com/ethereum/solidity/issues/4024.
// keccak256("ERC777TokensSender")
bytes32 constant private TOKENS_SENDER_INTERFACE_HASH =
0x29ddb589b1fb5fc7cf394961c1adf5f8c6454761adf795e67fe149f658abe895;
// keccak256("ERC777TokensRecipient")
bytes32 constant private TOKENS_RECIPIENT_INTERFACE_HASH =
0xb281fc8c12954d22544db45de3159a39272895b169a852b314f9cc762e44c53b;
// This isn't ever read from - it's only used to respond to the defaultOperators query.
address[] private _defaultOperatorsArray;
// Immutable, but accounts may revoke them (tracked in __revokedDefaultOperators).
mapping(address => bool) private _defaultOperators;
// For each account, a mapping of its operators and revoked default operators.
mapping(address => mapping(address => bool)) private _operators;
mapping(address => mapping(address => bool)) private _revokedDefaultOperators;
// ERC20-allowances
mapping (address => mapping (address => uint256)) private _allowances;
/**
* @dev `defaultOperators` may be an empty array.
*/
constructor(
string memory name,
string memory symbol,
address[] memory defaultOperators
) public {
_name = name;
_symbol = symbol;
_defaultOperatorsArray = defaultOperators;
for (uint256 i = 0; i < _defaultOperatorsArray.length; i++) {
_defaultOperators[_defaultOperatorsArray[i]] = true;
}
// register interfaces
_erc1820.setInterfaceImplementer(address(this), keccak256("ERC777Token"), address(this));
_erc1820.setInterfaceImplementer(address(this), keccak256("ERC20Token"), address(this));
}
/**
* @dev See {IERC777-name}.
*/
function name() public view returns (string memory) {
return _name;
}
/**
* @dev See {IERC777-symbol}.
*/
function symbol() public view returns (string memory) {
return _symbol;
}
/**
* @dev See {ERC20Detailed-decimals}.
*
* Always returns 18, as per the
* [ERC777 EIP](https://eips.ethereum.org/EIPS/eip-777#backward-compatibility).
*/
function decimals() public pure returns (uint8) {
return 18;
}
/**
* @dev See {IERC777-granularity}.
*
* This implementation always returns `1`.
*/
function granularity() public view returns (uint256) {
return 1;
}
/**
* @dev See {IERC777-totalSupply}.
*/
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
/**
* @dev Returns the amount of tokens owned by an account (`tokenHolder`).
*/
function balanceOf(address tokenHolder) public view returns (uint256) {
return _balances[tokenHolder];
}
/**
* @dev See {IERC777-send}.
*
* Also emits a {Transfer} event for ERC20 compatibility.
*/
function send(address recipient, uint256 amount, bytes calldata data) external {
_send(_msgSender(), _msgSender(), recipient, amount, data, "", true);
}
/**
* @dev See {IERC20-transfer}.
*
* Unlike `send`, `recipient` is _not_ required to implement the {IERC777Recipient}
* interface if it is a contract.
*
* Also emits a {Sent} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool) {
require(recipient != address(0), "ERC777: transfer to the zero address");
address from = _msgSender();
_callTokensToSend(from, from, recipient, amount, "", "");
_move(from, from, recipient, amount, "", "");
_callTokensReceived(from, from, recipient, amount, "", "", false);
return true;
}
/**
* @dev See {IERC777-burn}.
*
* Also emits a {Transfer} event for ERC20 compatibility.
*/
function burn(uint256 amount, bytes calldata data) external {
_burn(_msgSender(), _msgSender(), amount, data, "");
}
/**
* @dev See {IERC777-isOperatorFor}.
*/
function isOperatorFor(
address operator,
address tokenHolder
) public view returns (bool) {
return operator == tokenHolder ||
(_defaultOperators[operator] && !_revokedDefaultOperators[tokenHolder][operator]) ||
_operators[tokenHolder][operator];
}
/**
* @dev See {IERC777-authorizeOperator}.
*/
function authorizeOperator(address operator) external {
_authorizeOperator(operator);
}
function _authorizeOperator(address operator) internal {
require(_msgSender() != operator, "ERC777: authorizing self as operator");
if (_defaultOperators[operator]) {
delete _revokedDefaultOperators[_msgSender()][operator];
} else {
_operators[_msgSender()][operator] = true;
}
emit AuthorizedOperator(operator, _msgSender());
}
/**
* @dev See {IERC777-revokeOperator}.
*/
function revokeOperator(address operator) external {
_revokeOperator(operator);
}
function _revokeOperator(address operator) internal {
require(operator != _msgSender(), "ERC777: revoking self as operator");
if (_defaultOperators[operator]) {
_revokedDefaultOperators[_msgSender()][operator] = true;
} else {
delete _operators[_msgSender()][operator];
}
emit RevokedOperator(operator, _msgSender());
}
/**
* @dev See {IERC777-defaultOperators}.
*/
function defaultOperators() public view returns (address[] memory) {
return _defaultOperatorsArray;
}
/**
* @dev See {IERC777-operatorSend}.
*
* Emits {Sent} and {Transfer} events.
*/
function operatorSend(
address sender,
address recipient,
uint256 amount,
bytes calldata data,
bytes calldata operatorData
)
external
{
require(isOperatorFor(_msgSender(), sender), "ERC777: caller is not an operator for holder");
_send(_msgSender(), sender, recipient, amount, data, operatorData, true);
}
/**
* @dev See {IERC777-operatorBurn}.
*
* Emits {Burned} and {Transfer} events.
*/
function operatorBurn(address account, uint256 amount, bytes calldata data, bytes calldata operatorData) external {
require(isOperatorFor(_msgSender(), account), "ERC777: caller is not an operator for holder");
_burn(_msgSender(), account, amount, data, operatorData);
}
/**
* @dev See {IERC20-allowance}.
*
* Note that operator and allowance concepts are orthogonal: operators may
* not have allowance, and accounts with allowance may not be operators
* themselves.
*/
function allowance(address holder, address spender) public view returns (uint256) {
return _allowances[holder][spender];
}
/**
* @dev See {IERC20-approve}.
*
* Note that accounts cannot have allowance issued by their operators.
*/
function approve(address spender, uint256 value) external returns (bool) {
address holder = _msgSender();
_approve(holder, spender, value);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Note that operator and allowance concepts are orthogonal: operators cannot
* call `transferFrom` (unless they have allowance), and accounts with
* allowance cannot call `operatorSend` (unless they are operators).
*
* Emits {Sent}, {Transfer} and {Approval} events.
*/
function transferFrom(address holder, address recipient, uint256 amount) external returns (bool) {
require(recipient != address(0), "ERC777: transfer to the zero address");
require(holder != address(0), "ERC777: transfer from the zero address");
address spender = _msgSender();
_callTokensToSend(spender, holder, recipient, amount, "", "");
_move(spender, holder, recipient, amount, "", "");
_approve(holder, spender, _allowances[holder][spender].sub(amount, "ERC777: transfer amount exceeds allowance"));
_callTokensReceived(spender, holder, recipient, amount, "", "", false);
return true;
}
/**
* @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* If a send hook is registered for `account`, the corresponding function
* will be called with `operator`, `data` and `operatorData`.
*
* See {IERC777Sender} and {IERC777Recipient}.
*
* Emits {Minted} and {Transfer} events.
*
* Requirements
*
* - `account` cannot be the zero address.
* - if `account` is a contract, it must implement the {IERC777Recipient}
* interface.
*/
function _mint(
address operator,
address account,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
internal
{
require(account != address(0), "ERC777: mint to the zero address");
// Update state variables
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
_callTokensReceived(operator, address(0), account, amount, userData, operatorData, true);
emit Minted(operator, account, amount, userData, operatorData);
emit Transfer(address(0), account, amount);
}
/**
* @dev Send tokens
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
* @param requireReceptionAck if true, contract recipients are required to implement ERC777TokensRecipient
*/
function _send(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck
)
internal
{
require(from != address(0), "ERC777: send from the zero address");
require(to != address(0), "ERC777: send to the zero address");
_callTokensToSend(operator, from, to, amount, userData, operatorData);
_move(operator, from, to, amount, userData, operatorData);
_callTokensReceived(operator, from, to, amount, userData, operatorData, requireReceptionAck);
}
/**
* @dev Burn tokens
* @param operator address operator requesting the operation
* @param from address token holder address
* @param amount uint256 amount of tokens to burn
* @param data bytes extra information provided by the token holder
* @param operatorData bytes extra information provided by the operator (if any)
*/
function _burn(
address operator,
address from,
uint256 amount,
bytes memory data,
bytes memory operatorData
)
internal
{
require(from != address(0), "ERC777: burn from the zero address");
_callTokensToSend(operator, from, address(0), amount, data, operatorData);
// Update state variables
_balances[from] = _balances[from].sub(amount, "ERC777: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Burned(operator, from, amount, data, operatorData);
emit Transfer(from, address(0), amount);
}
function _move(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
internal
{
_balances[from] = _balances[from].sub(amount, "ERC777: transfer amount exceeds balance");
_balances[to] = _balances[to].add(amount);
emit Sent(operator, from, to, amount, userData, operatorData);
emit Transfer(from, to, amount);
}
function _approve(address holder, address spender, uint256 value) internal {
// TODO: restore this require statement if this function becomes internal, or is called at a new callsite. It is
// currently unnecessary.
//require(holder != address(0), "ERC777: approve from the zero address");
require(spender != address(0), "ERC777: approve to the zero address");
_allowances[holder][spender] = value;
emit Approval(holder, spender, value);
}
/**
* @dev Call from.tokensToSend() if the interface is registered
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
*/
function _callTokensToSend(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
private
{
address implementer = _erc1820.getInterfaceImplementer(from, TOKENS_SENDER_INTERFACE_HASH);
if (implementer != address(0)) {
IERC777Sender(implementer).tokensToSend(operator, from, to, amount, userData, operatorData);
}
}
/**
* @dev Call to.tokensReceived() if the interface is registered. Reverts if the recipient is a contract but
* tokensReceived() was not registered for the recipient
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
* @param requireReceptionAck if true, contract recipients are required to implement ERC777TokensRecipient
*/
function _callTokensReceived(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck
)
private
{
address implementer = _erc1820.getInterfaceImplementer(to, TOKENS_RECIPIENT_INTERFACE_HASH);
if (implementer != address(0)) {
IERC777Recipient(implementer).tokensReceived(operator, from, to, amount, userData, operatorData);
} else if (requireReceptionAck) {
require(!to.isContract(), "ERC777: token recipient contract has no implement for ERC777TokensRecipient");
}
}
} | /**
* @dev Implementation of the {IERC777} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
*
* Support for ERC20 is included in this contract, as specified by the EIP: both
* the ERC777 and ERC20 interfaces can be safely used when interacting with it.
* Both {IERC777-Sent} and {IERC20-Transfer} events are emitted on token
* movements.
*
* Additionally, the {IERC777-granularity} value is hard-coded to `1`, meaning that there
* are no special restrictions in the amount of tokens that created, moved, or
* destroyed. This makes integration with ERC20 applications seamless.
*/ | NatSpecMultiLine | _mint | function _mint(
address operator,
address account,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
internal
{
require(account != address(0), "ERC777: mint to the zero address");
// Update state variables
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
_callTokensReceived(operator, address(0), account, amount, userData, operatorData, true);
emit Minted(operator, account, amount, userData, operatorData);
emit Transfer(address(0), account, amount);
}
| /**
* @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* If a send hook is registered for `account`, the corresponding function
* will be called with `operator`, `data` and `operatorData`.
*
* See {IERC777Sender} and {IERC777Recipient}.
*
* Emits {Minted} and {Transfer} events.
*
* Requirements
*
* - `account` cannot be the zero address.
* - if `account` is a contract, it must implement the {IERC777Recipient}
* interface.
*/ | NatSpecMultiLine | v0.5.0+commit.1d4f565a | MIT | bzzr://c1bab4b5e3e40f4294e652b388dfc625ccf21445b4e184e78b601a51d58a2cc2 | {
"func_code_index": [
9607,
10262
]
} | 59,948 |
NNCProjectToken | patterns\token\ERC777\ERC777.sol | 0xa67462ff3314c682277771ae2bbcec08877c877a | Solidity | ERC777 | contract ERC777 is Context, IERC777, IERC20 {
using SafeMath for uint256;
using Address for address;
IERC1820Registry constant internal _erc1820 = IERC1820Registry(0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24);
mapping(address => uint256) private _balances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
// We inline the result of the following hashes because Solidity doesn't resolve them at compile time.
// See https://github.com/ethereum/solidity/issues/4024.
// keccak256("ERC777TokensSender")
bytes32 constant private TOKENS_SENDER_INTERFACE_HASH =
0x29ddb589b1fb5fc7cf394961c1adf5f8c6454761adf795e67fe149f658abe895;
// keccak256("ERC777TokensRecipient")
bytes32 constant private TOKENS_RECIPIENT_INTERFACE_HASH =
0xb281fc8c12954d22544db45de3159a39272895b169a852b314f9cc762e44c53b;
// This isn't ever read from - it's only used to respond to the defaultOperators query.
address[] private _defaultOperatorsArray;
// Immutable, but accounts may revoke them (tracked in __revokedDefaultOperators).
mapping(address => bool) private _defaultOperators;
// For each account, a mapping of its operators and revoked default operators.
mapping(address => mapping(address => bool)) private _operators;
mapping(address => mapping(address => bool)) private _revokedDefaultOperators;
// ERC20-allowances
mapping (address => mapping (address => uint256)) private _allowances;
/**
* @dev `defaultOperators` may be an empty array.
*/
constructor(
string memory name,
string memory symbol,
address[] memory defaultOperators
) public {
_name = name;
_symbol = symbol;
_defaultOperatorsArray = defaultOperators;
for (uint256 i = 0; i < _defaultOperatorsArray.length; i++) {
_defaultOperators[_defaultOperatorsArray[i]] = true;
}
// register interfaces
_erc1820.setInterfaceImplementer(address(this), keccak256("ERC777Token"), address(this));
_erc1820.setInterfaceImplementer(address(this), keccak256("ERC20Token"), address(this));
}
/**
* @dev See {IERC777-name}.
*/
function name() public view returns (string memory) {
return _name;
}
/**
* @dev See {IERC777-symbol}.
*/
function symbol() public view returns (string memory) {
return _symbol;
}
/**
* @dev See {ERC20Detailed-decimals}.
*
* Always returns 18, as per the
* [ERC777 EIP](https://eips.ethereum.org/EIPS/eip-777#backward-compatibility).
*/
function decimals() public pure returns (uint8) {
return 18;
}
/**
* @dev See {IERC777-granularity}.
*
* This implementation always returns `1`.
*/
function granularity() public view returns (uint256) {
return 1;
}
/**
* @dev See {IERC777-totalSupply}.
*/
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
/**
* @dev Returns the amount of tokens owned by an account (`tokenHolder`).
*/
function balanceOf(address tokenHolder) public view returns (uint256) {
return _balances[tokenHolder];
}
/**
* @dev See {IERC777-send}.
*
* Also emits a {Transfer} event for ERC20 compatibility.
*/
function send(address recipient, uint256 amount, bytes calldata data) external {
_send(_msgSender(), _msgSender(), recipient, amount, data, "", true);
}
/**
* @dev See {IERC20-transfer}.
*
* Unlike `send`, `recipient` is _not_ required to implement the {IERC777Recipient}
* interface if it is a contract.
*
* Also emits a {Sent} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool) {
require(recipient != address(0), "ERC777: transfer to the zero address");
address from = _msgSender();
_callTokensToSend(from, from, recipient, amount, "", "");
_move(from, from, recipient, amount, "", "");
_callTokensReceived(from, from, recipient, amount, "", "", false);
return true;
}
/**
* @dev See {IERC777-burn}.
*
* Also emits a {Transfer} event for ERC20 compatibility.
*/
function burn(uint256 amount, bytes calldata data) external {
_burn(_msgSender(), _msgSender(), amount, data, "");
}
/**
* @dev See {IERC777-isOperatorFor}.
*/
function isOperatorFor(
address operator,
address tokenHolder
) public view returns (bool) {
return operator == tokenHolder ||
(_defaultOperators[operator] && !_revokedDefaultOperators[tokenHolder][operator]) ||
_operators[tokenHolder][operator];
}
/**
* @dev See {IERC777-authorizeOperator}.
*/
function authorizeOperator(address operator) external {
_authorizeOperator(operator);
}
function _authorizeOperator(address operator) internal {
require(_msgSender() != operator, "ERC777: authorizing self as operator");
if (_defaultOperators[operator]) {
delete _revokedDefaultOperators[_msgSender()][operator];
} else {
_operators[_msgSender()][operator] = true;
}
emit AuthorizedOperator(operator, _msgSender());
}
/**
* @dev See {IERC777-revokeOperator}.
*/
function revokeOperator(address operator) external {
_revokeOperator(operator);
}
function _revokeOperator(address operator) internal {
require(operator != _msgSender(), "ERC777: revoking self as operator");
if (_defaultOperators[operator]) {
_revokedDefaultOperators[_msgSender()][operator] = true;
} else {
delete _operators[_msgSender()][operator];
}
emit RevokedOperator(operator, _msgSender());
}
/**
* @dev See {IERC777-defaultOperators}.
*/
function defaultOperators() public view returns (address[] memory) {
return _defaultOperatorsArray;
}
/**
* @dev See {IERC777-operatorSend}.
*
* Emits {Sent} and {Transfer} events.
*/
function operatorSend(
address sender,
address recipient,
uint256 amount,
bytes calldata data,
bytes calldata operatorData
)
external
{
require(isOperatorFor(_msgSender(), sender), "ERC777: caller is not an operator for holder");
_send(_msgSender(), sender, recipient, amount, data, operatorData, true);
}
/**
* @dev See {IERC777-operatorBurn}.
*
* Emits {Burned} and {Transfer} events.
*/
function operatorBurn(address account, uint256 amount, bytes calldata data, bytes calldata operatorData) external {
require(isOperatorFor(_msgSender(), account), "ERC777: caller is not an operator for holder");
_burn(_msgSender(), account, amount, data, operatorData);
}
/**
* @dev See {IERC20-allowance}.
*
* Note that operator and allowance concepts are orthogonal: operators may
* not have allowance, and accounts with allowance may not be operators
* themselves.
*/
function allowance(address holder, address spender) public view returns (uint256) {
return _allowances[holder][spender];
}
/**
* @dev See {IERC20-approve}.
*
* Note that accounts cannot have allowance issued by their operators.
*/
function approve(address spender, uint256 value) external returns (bool) {
address holder = _msgSender();
_approve(holder, spender, value);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Note that operator and allowance concepts are orthogonal: operators cannot
* call `transferFrom` (unless they have allowance), and accounts with
* allowance cannot call `operatorSend` (unless they are operators).
*
* Emits {Sent}, {Transfer} and {Approval} events.
*/
function transferFrom(address holder, address recipient, uint256 amount) external returns (bool) {
require(recipient != address(0), "ERC777: transfer to the zero address");
require(holder != address(0), "ERC777: transfer from the zero address");
address spender = _msgSender();
_callTokensToSend(spender, holder, recipient, amount, "", "");
_move(spender, holder, recipient, amount, "", "");
_approve(holder, spender, _allowances[holder][spender].sub(amount, "ERC777: transfer amount exceeds allowance"));
_callTokensReceived(spender, holder, recipient, amount, "", "", false);
return true;
}
/**
* @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* If a send hook is registered for `account`, the corresponding function
* will be called with `operator`, `data` and `operatorData`.
*
* See {IERC777Sender} and {IERC777Recipient}.
*
* Emits {Minted} and {Transfer} events.
*
* Requirements
*
* - `account` cannot be the zero address.
* - if `account` is a contract, it must implement the {IERC777Recipient}
* interface.
*/
function _mint(
address operator,
address account,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
internal
{
require(account != address(0), "ERC777: mint to the zero address");
// Update state variables
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
_callTokensReceived(operator, address(0), account, amount, userData, operatorData, true);
emit Minted(operator, account, amount, userData, operatorData);
emit Transfer(address(0), account, amount);
}
/**
* @dev Send tokens
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
* @param requireReceptionAck if true, contract recipients are required to implement ERC777TokensRecipient
*/
function _send(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck
)
internal
{
require(from != address(0), "ERC777: send from the zero address");
require(to != address(0), "ERC777: send to the zero address");
_callTokensToSend(operator, from, to, amount, userData, operatorData);
_move(operator, from, to, amount, userData, operatorData);
_callTokensReceived(operator, from, to, amount, userData, operatorData, requireReceptionAck);
}
/**
* @dev Burn tokens
* @param operator address operator requesting the operation
* @param from address token holder address
* @param amount uint256 amount of tokens to burn
* @param data bytes extra information provided by the token holder
* @param operatorData bytes extra information provided by the operator (if any)
*/
function _burn(
address operator,
address from,
uint256 amount,
bytes memory data,
bytes memory operatorData
)
internal
{
require(from != address(0), "ERC777: burn from the zero address");
_callTokensToSend(operator, from, address(0), amount, data, operatorData);
// Update state variables
_balances[from] = _balances[from].sub(amount, "ERC777: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Burned(operator, from, amount, data, operatorData);
emit Transfer(from, address(0), amount);
}
function _move(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
internal
{
_balances[from] = _balances[from].sub(amount, "ERC777: transfer amount exceeds balance");
_balances[to] = _balances[to].add(amount);
emit Sent(operator, from, to, amount, userData, operatorData);
emit Transfer(from, to, amount);
}
function _approve(address holder, address spender, uint256 value) internal {
// TODO: restore this require statement if this function becomes internal, or is called at a new callsite. It is
// currently unnecessary.
//require(holder != address(0), "ERC777: approve from the zero address");
require(spender != address(0), "ERC777: approve to the zero address");
_allowances[holder][spender] = value;
emit Approval(holder, spender, value);
}
/**
* @dev Call from.tokensToSend() if the interface is registered
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
*/
function _callTokensToSend(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
private
{
address implementer = _erc1820.getInterfaceImplementer(from, TOKENS_SENDER_INTERFACE_HASH);
if (implementer != address(0)) {
IERC777Sender(implementer).tokensToSend(operator, from, to, amount, userData, operatorData);
}
}
/**
* @dev Call to.tokensReceived() if the interface is registered. Reverts if the recipient is a contract but
* tokensReceived() was not registered for the recipient
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
* @param requireReceptionAck if true, contract recipients are required to implement ERC777TokensRecipient
*/
function _callTokensReceived(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck
)
private
{
address implementer = _erc1820.getInterfaceImplementer(to, TOKENS_RECIPIENT_INTERFACE_HASH);
if (implementer != address(0)) {
IERC777Recipient(implementer).tokensReceived(operator, from, to, amount, userData, operatorData);
} else if (requireReceptionAck) {
require(!to.isContract(), "ERC777: token recipient contract has no implement for ERC777TokensRecipient");
}
}
} | /**
* @dev Implementation of the {IERC777} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
*
* Support for ERC20 is included in this contract, as specified by the EIP: both
* the ERC777 and ERC20 interfaces can be safely used when interacting with it.
* Both {IERC777-Sent} and {IERC20-Transfer} events are emitted on token
* movements.
*
* Additionally, the {IERC777-granularity} value is hard-coded to `1`, meaning that there
* are no special restrictions in the amount of tokens that created, moved, or
* destroyed. This makes integration with ERC20 applications seamless.
*/ | NatSpecMultiLine | _send | function _send(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck
)
internal
{
require(from != address(0), "ERC777: send from the zero address");
require(to != address(0), "ERC777: send to the zero address");
_callTokensToSend(operator, from, to, amount, userData, operatorData);
_move(operator, from, to, amount, userData, operatorData);
_callTokensReceived(operator, from, to, amount, userData, operatorData, requireReceptionAck);
}
| /**
* @dev Send tokens
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
* @param requireReceptionAck if true, contract recipients are required to implement ERC777TokensRecipient
*/ | NatSpecMultiLine | v0.5.0+commit.1d4f565a | MIT | bzzr://c1bab4b5e3e40f4294e652b388dfc625ccf21445b4e184e78b601a51d58a2cc2 | {
"func_code_index": [
10809,
11471
]
} | 59,949 |
NNCProjectToken | patterns\token\ERC777\ERC777.sol | 0xa67462ff3314c682277771ae2bbcec08877c877a | Solidity | ERC777 | contract ERC777 is Context, IERC777, IERC20 {
using SafeMath for uint256;
using Address for address;
IERC1820Registry constant internal _erc1820 = IERC1820Registry(0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24);
mapping(address => uint256) private _balances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
// We inline the result of the following hashes because Solidity doesn't resolve them at compile time.
// See https://github.com/ethereum/solidity/issues/4024.
// keccak256("ERC777TokensSender")
bytes32 constant private TOKENS_SENDER_INTERFACE_HASH =
0x29ddb589b1fb5fc7cf394961c1adf5f8c6454761adf795e67fe149f658abe895;
// keccak256("ERC777TokensRecipient")
bytes32 constant private TOKENS_RECIPIENT_INTERFACE_HASH =
0xb281fc8c12954d22544db45de3159a39272895b169a852b314f9cc762e44c53b;
// This isn't ever read from - it's only used to respond to the defaultOperators query.
address[] private _defaultOperatorsArray;
// Immutable, but accounts may revoke them (tracked in __revokedDefaultOperators).
mapping(address => bool) private _defaultOperators;
// For each account, a mapping of its operators and revoked default operators.
mapping(address => mapping(address => bool)) private _operators;
mapping(address => mapping(address => bool)) private _revokedDefaultOperators;
// ERC20-allowances
mapping (address => mapping (address => uint256)) private _allowances;
/**
* @dev `defaultOperators` may be an empty array.
*/
constructor(
string memory name,
string memory symbol,
address[] memory defaultOperators
) public {
_name = name;
_symbol = symbol;
_defaultOperatorsArray = defaultOperators;
for (uint256 i = 0; i < _defaultOperatorsArray.length; i++) {
_defaultOperators[_defaultOperatorsArray[i]] = true;
}
// register interfaces
_erc1820.setInterfaceImplementer(address(this), keccak256("ERC777Token"), address(this));
_erc1820.setInterfaceImplementer(address(this), keccak256("ERC20Token"), address(this));
}
/**
* @dev See {IERC777-name}.
*/
function name() public view returns (string memory) {
return _name;
}
/**
* @dev See {IERC777-symbol}.
*/
function symbol() public view returns (string memory) {
return _symbol;
}
/**
* @dev See {ERC20Detailed-decimals}.
*
* Always returns 18, as per the
* [ERC777 EIP](https://eips.ethereum.org/EIPS/eip-777#backward-compatibility).
*/
function decimals() public pure returns (uint8) {
return 18;
}
/**
* @dev See {IERC777-granularity}.
*
* This implementation always returns `1`.
*/
function granularity() public view returns (uint256) {
return 1;
}
/**
* @dev See {IERC777-totalSupply}.
*/
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
/**
* @dev Returns the amount of tokens owned by an account (`tokenHolder`).
*/
function balanceOf(address tokenHolder) public view returns (uint256) {
return _balances[tokenHolder];
}
/**
* @dev See {IERC777-send}.
*
* Also emits a {Transfer} event for ERC20 compatibility.
*/
function send(address recipient, uint256 amount, bytes calldata data) external {
_send(_msgSender(), _msgSender(), recipient, amount, data, "", true);
}
/**
* @dev See {IERC20-transfer}.
*
* Unlike `send`, `recipient` is _not_ required to implement the {IERC777Recipient}
* interface if it is a contract.
*
* Also emits a {Sent} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool) {
require(recipient != address(0), "ERC777: transfer to the zero address");
address from = _msgSender();
_callTokensToSend(from, from, recipient, amount, "", "");
_move(from, from, recipient, amount, "", "");
_callTokensReceived(from, from, recipient, amount, "", "", false);
return true;
}
/**
* @dev See {IERC777-burn}.
*
* Also emits a {Transfer} event for ERC20 compatibility.
*/
function burn(uint256 amount, bytes calldata data) external {
_burn(_msgSender(), _msgSender(), amount, data, "");
}
/**
* @dev See {IERC777-isOperatorFor}.
*/
function isOperatorFor(
address operator,
address tokenHolder
) public view returns (bool) {
return operator == tokenHolder ||
(_defaultOperators[operator] && !_revokedDefaultOperators[tokenHolder][operator]) ||
_operators[tokenHolder][operator];
}
/**
* @dev See {IERC777-authorizeOperator}.
*/
function authorizeOperator(address operator) external {
_authorizeOperator(operator);
}
function _authorizeOperator(address operator) internal {
require(_msgSender() != operator, "ERC777: authorizing self as operator");
if (_defaultOperators[operator]) {
delete _revokedDefaultOperators[_msgSender()][operator];
} else {
_operators[_msgSender()][operator] = true;
}
emit AuthorizedOperator(operator, _msgSender());
}
/**
* @dev See {IERC777-revokeOperator}.
*/
function revokeOperator(address operator) external {
_revokeOperator(operator);
}
function _revokeOperator(address operator) internal {
require(operator != _msgSender(), "ERC777: revoking self as operator");
if (_defaultOperators[operator]) {
_revokedDefaultOperators[_msgSender()][operator] = true;
} else {
delete _operators[_msgSender()][operator];
}
emit RevokedOperator(operator, _msgSender());
}
/**
* @dev See {IERC777-defaultOperators}.
*/
function defaultOperators() public view returns (address[] memory) {
return _defaultOperatorsArray;
}
/**
* @dev See {IERC777-operatorSend}.
*
* Emits {Sent} and {Transfer} events.
*/
function operatorSend(
address sender,
address recipient,
uint256 amount,
bytes calldata data,
bytes calldata operatorData
)
external
{
require(isOperatorFor(_msgSender(), sender), "ERC777: caller is not an operator for holder");
_send(_msgSender(), sender, recipient, amount, data, operatorData, true);
}
/**
* @dev See {IERC777-operatorBurn}.
*
* Emits {Burned} and {Transfer} events.
*/
function operatorBurn(address account, uint256 amount, bytes calldata data, bytes calldata operatorData) external {
require(isOperatorFor(_msgSender(), account), "ERC777: caller is not an operator for holder");
_burn(_msgSender(), account, amount, data, operatorData);
}
/**
* @dev See {IERC20-allowance}.
*
* Note that operator and allowance concepts are orthogonal: operators may
* not have allowance, and accounts with allowance may not be operators
* themselves.
*/
function allowance(address holder, address spender) public view returns (uint256) {
return _allowances[holder][spender];
}
/**
* @dev See {IERC20-approve}.
*
* Note that accounts cannot have allowance issued by their operators.
*/
function approve(address spender, uint256 value) external returns (bool) {
address holder = _msgSender();
_approve(holder, spender, value);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Note that operator and allowance concepts are orthogonal: operators cannot
* call `transferFrom` (unless they have allowance), and accounts with
* allowance cannot call `operatorSend` (unless they are operators).
*
* Emits {Sent}, {Transfer} and {Approval} events.
*/
function transferFrom(address holder, address recipient, uint256 amount) external returns (bool) {
require(recipient != address(0), "ERC777: transfer to the zero address");
require(holder != address(0), "ERC777: transfer from the zero address");
address spender = _msgSender();
_callTokensToSend(spender, holder, recipient, amount, "", "");
_move(spender, holder, recipient, amount, "", "");
_approve(holder, spender, _allowances[holder][spender].sub(amount, "ERC777: transfer amount exceeds allowance"));
_callTokensReceived(spender, holder, recipient, amount, "", "", false);
return true;
}
/**
* @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* If a send hook is registered for `account`, the corresponding function
* will be called with `operator`, `data` and `operatorData`.
*
* See {IERC777Sender} and {IERC777Recipient}.
*
* Emits {Minted} and {Transfer} events.
*
* Requirements
*
* - `account` cannot be the zero address.
* - if `account` is a contract, it must implement the {IERC777Recipient}
* interface.
*/
function _mint(
address operator,
address account,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
internal
{
require(account != address(0), "ERC777: mint to the zero address");
// Update state variables
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
_callTokensReceived(operator, address(0), account, amount, userData, operatorData, true);
emit Minted(operator, account, amount, userData, operatorData);
emit Transfer(address(0), account, amount);
}
/**
* @dev Send tokens
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
* @param requireReceptionAck if true, contract recipients are required to implement ERC777TokensRecipient
*/
function _send(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck
)
internal
{
require(from != address(0), "ERC777: send from the zero address");
require(to != address(0), "ERC777: send to the zero address");
_callTokensToSend(operator, from, to, amount, userData, operatorData);
_move(operator, from, to, amount, userData, operatorData);
_callTokensReceived(operator, from, to, amount, userData, operatorData, requireReceptionAck);
}
/**
* @dev Burn tokens
* @param operator address operator requesting the operation
* @param from address token holder address
* @param amount uint256 amount of tokens to burn
* @param data bytes extra information provided by the token holder
* @param operatorData bytes extra information provided by the operator (if any)
*/
function _burn(
address operator,
address from,
uint256 amount,
bytes memory data,
bytes memory operatorData
)
internal
{
require(from != address(0), "ERC777: burn from the zero address");
_callTokensToSend(operator, from, address(0), amount, data, operatorData);
// Update state variables
_balances[from] = _balances[from].sub(amount, "ERC777: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Burned(operator, from, amount, data, operatorData);
emit Transfer(from, address(0), amount);
}
function _move(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
internal
{
_balances[from] = _balances[from].sub(amount, "ERC777: transfer amount exceeds balance");
_balances[to] = _balances[to].add(amount);
emit Sent(operator, from, to, amount, userData, operatorData);
emit Transfer(from, to, amount);
}
function _approve(address holder, address spender, uint256 value) internal {
// TODO: restore this require statement if this function becomes internal, or is called at a new callsite. It is
// currently unnecessary.
//require(holder != address(0), "ERC777: approve from the zero address");
require(spender != address(0), "ERC777: approve to the zero address");
_allowances[holder][spender] = value;
emit Approval(holder, spender, value);
}
/**
* @dev Call from.tokensToSend() if the interface is registered
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
*/
function _callTokensToSend(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
private
{
address implementer = _erc1820.getInterfaceImplementer(from, TOKENS_SENDER_INTERFACE_HASH);
if (implementer != address(0)) {
IERC777Sender(implementer).tokensToSend(operator, from, to, amount, userData, operatorData);
}
}
/**
* @dev Call to.tokensReceived() if the interface is registered. Reverts if the recipient is a contract but
* tokensReceived() was not registered for the recipient
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
* @param requireReceptionAck if true, contract recipients are required to implement ERC777TokensRecipient
*/
function _callTokensReceived(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck
)
private
{
address implementer = _erc1820.getInterfaceImplementer(to, TOKENS_RECIPIENT_INTERFACE_HASH);
if (implementer != address(0)) {
IERC777Recipient(implementer).tokensReceived(operator, from, to, amount, userData, operatorData);
} else if (requireReceptionAck) {
require(!to.isContract(), "ERC777: token recipient contract has no implement for ERC777TokensRecipient");
}
}
} | /**
* @dev Implementation of the {IERC777} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
*
* Support for ERC20 is included in this contract, as specified by the EIP: both
* the ERC777 and ERC20 interfaces can be safely used when interacting with it.
* Both {IERC777-Sent} and {IERC20-Transfer} events are emitted on token
* movements.
*
* Additionally, the {IERC777-granularity} value is hard-coded to `1`, meaning that there
* are no special restrictions in the amount of tokens that created, moved, or
* destroyed. This makes integration with ERC20 applications seamless.
*/ | NatSpecMultiLine | _burn | function _burn(
address operator,
address from,
uint256 amount,
bytes memory data,
bytes memory operatorData
)
internal
{
require(from != address(0), "ERC777: burn from the zero address");
_callTokensToSend(operator, from, address(0), amount, data, operatorData);
// Update state variables
_balances[from] = _balances[from].sub(amount, "ERC777: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Burned(operator, from, amount, data, operatorData);
emit Transfer(from, address(0), amount);
}
| /**
* @dev Burn tokens
* @param operator address operator requesting the operation
* @param from address token holder address
* @param amount uint256 amount of tokens to burn
* @param data bytes extra information provided by the token holder
* @param operatorData bytes extra information provided by the operator (if any)
*/ | NatSpecMultiLine | v0.5.0+commit.1d4f565a | MIT | bzzr://c1bab4b5e3e40f4294e652b388dfc625ccf21445b4e184e78b601a51d58a2cc2 | {
"func_code_index": [
11846,
12505
]
} | 59,950 |
NNCProjectToken | patterns\token\ERC777\ERC777.sol | 0xa67462ff3314c682277771ae2bbcec08877c877a | Solidity | ERC777 | contract ERC777 is Context, IERC777, IERC20 {
using SafeMath for uint256;
using Address for address;
IERC1820Registry constant internal _erc1820 = IERC1820Registry(0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24);
mapping(address => uint256) private _balances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
// We inline the result of the following hashes because Solidity doesn't resolve them at compile time.
// See https://github.com/ethereum/solidity/issues/4024.
// keccak256("ERC777TokensSender")
bytes32 constant private TOKENS_SENDER_INTERFACE_HASH =
0x29ddb589b1fb5fc7cf394961c1adf5f8c6454761adf795e67fe149f658abe895;
// keccak256("ERC777TokensRecipient")
bytes32 constant private TOKENS_RECIPIENT_INTERFACE_HASH =
0xb281fc8c12954d22544db45de3159a39272895b169a852b314f9cc762e44c53b;
// This isn't ever read from - it's only used to respond to the defaultOperators query.
address[] private _defaultOperatorsArray;
// Immutable, but accounts may revoke them (tracked in __revokedDefaultOperators).
mapping(address => bool) private _defaultOperators;
// For each account, a mapping of its operators and revoked default operators.
mapping(address => mapping(address => bool)) private _operators;
mapping(address => mapping(address => bool)) private _revokedDefaultOperators;
// ERC20-allowances
mapping (address => mapping (address => uint256)) private _allowances;
/**
* @dev `defaultOperators` may be an empty array.
*/
constructor(
string memory name,
string memory symbol,
address[] memory defaultOperators
) public {
_name = name;
_symbol = symbol;
_defaultOperatorsArray = defaultOperators;
for (uint256 i = 0; i < _defaultOperatorsArray.length; i++) {
_defaultOperators[_defaultOperatorsArray[i]] = true;
}
// register interfaces
_erc1820.setInterfaceImplementer(address(this), keccak256("ERC777Token"), address(this));
_erc1820.setInterfaceImplementer(address(this), keccak256("ERC20Token"), address(this));
}
/**
* @dev See {IERC777-name}.
*/
function name() public view returns (string memory) {
return _name;
}
/**
* @dev See {IERC777-symbol}.
*/
function symbol() public view returns (string memory) {
return _symbol;
}
/**
* @dev See {ERC20Detailed-decimals}.
*
* Always returns 18, as per the
* [ERC777 EIP](https://eips.ethereum.org/EIPS/eip-777#backward-compatibility).
*/
function decimals() public pure returns (uint8) {
return 18;
}
/**
* @dev See {IERC777-granularity}.
*
* This implementation always returns `1`.
*/
function granularity() public view returns (uint256) {
return 1;
}
/**
* @dev See {IERC777-totalSupply}.
*/
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
/**
* @dev Returns the amount of tokens owned by an account (`tokenHolder`).
*/
function balanceOf(address tokenHolder) public view returns (uint256) {
return _balances[tokenHolder];
}
/**
* @dev See {IERC777-send}.
*
* Also emits a {Transfer} event for ERC20 compatibility.
*/
function send(address recipient, uint256 amount, bytes calldata data) external {
_send(_msgSender(), _msgSender(), recipient, amount, data, "", true);
}
/**
* @dev See {IERC20-transfer}.
*
* Unlike `send`, `recipient` is _not_ required to implement the {IERC777Recipient}
* interface if it is a contract.
*
* Also emits a {Sent} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool) {
require(recipient != address(0), "ERC777: transfer to the zero address");
address from = _msgSender();
_callTokensToSend(from, from, recipient, amount, "", "");
_move(from, from, recipient, amount, "", "");
_callTokensReceived(from, from, recipient, amount, "", "", false);
return true;
}
/**
* @dev See {IERC777-burn}.
*
* Also emits a {Transfer} event for ERC20 compatibility.
*/
function burn(uint256 amount, bytes calldata data) external {
_burn(_msgSender(), _msgSender(), amount, data, "");
}
/**
* @dev See {IERC777-isOperatorFor}.
*/
function isOperatorFor(
address operator,
address tokenHolder
) public view returns (bool) {
return operator == tokenHolder ||
(_defaultOperators[operator] && !_revokedDefaultOperators[tokenHolder][operator]) ||
_operators[tokenHolder][operator];
}
/**
* @dev See {IERC777-authorizeOperator}.
*/
function authorizeOperator(address operator) external {
_authorizeOperator(operator);
}
function _authorizeOperator(address operator) internal {
require(_msgSender() != operator, "ERC777: authorizing self as operator");
if (_defaultOperators[operator]) {
delete _revokedDefaultOperators[_msgSender()][operator];
} else {
_operators[_msgSender()][operator] = true;
}
emit AuthorizedOperator(operator, _msgSender());
}
/**
* @dev See {IERC777-revokeOperator}.
*/
function revokeOperator(address operator) external {
_revokeOperator(operator);
}
function _revokeOperator(address operator) internal {
require(operator != _msgSender(), "ERC777: revoking self as operator");
if (_defaultOperators[operator]) {
_revokedDefaultOperators[_msgSender()][operator] = true;
} else {
delete _operators[_msgSender()][operator];
}
emit RevokedOperator(operator, _msgSender());
}
/**
* @dev See {IERC777-defaultOperators}.
*/
function defaultOperators() public view returns (address[] memory) {
return _defaultOperatorsArray;
}
/**
* @dev See {IERC777-operatorSend}.
*
* Emits {Sent} and {Transfer} events.
*/
function operatorSend(
address sender,
address recipient,
uint256 amount,
bytes calldata data,
bytes calldata operatorData
)
external
{
require(isOperatorFor(_msgSender(), sender), "ERC777: caller is not an operator for holder");
_send(_msgSender(), sender, recipient, amount, data, operatorData, true);
}
/**
* @dev See {IERC777-operatorBurn}.
*
* Emits {Burned} and {Transfer} events.
*/
function operatorBurn(address account, uint256 amount, bytes calldata data, bytes calldata operatorData) external {
require(isOperatorFor(_msgSender(), account), "ERC777: caller is not an operator for holder");
_burn(_msgSender(), account, amount, data, operatorData);
}
/**
* @dev See {IERC20-allowance}.
*
* Note that operator and allowance concepts are orthogonal: operators may
* not have allowance, and accounts with allowance may not be operators
* themselves.
*/
function allowance(address holder, address spender) public view returns (uint256) {
return _allowances[holder][spender];
}
/**
* @dev See {IERC20-approve}.
*
* Note that accounts cannot have allowance issued by their operators.
*/
function approve(address spender, uint256 value) external returns (bool) {
address holder = _msgSender();
_approve(holder, spender, value);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Note that operator and allowance concepts are orthogonal: operators cannot
* call `transferFrom` (unless they have allowance), and accounts with
* allowance cannot call `operatorSend` (unless they are operators).
*
* Emits {Sent}, {Transfer} and {Approval} events.
*/
function transferFrom(address holder, address recipient, uint256 amount) external returns (bool) {
require(recipient != address(0), "ERC777: transfer to the zero address");
require(holder != address(0), "ERC777: transfer from the zero address");
address spender = _msgSender();
_callTokensToSend(spender, holder, recipient, amount, "", "");
_move(spender, holder, recipient, amount, "", "");
_approve(holder, spender, _allowances[holder][spender].sub(amount, "ERC777: transfer amount exceeds allowance"));
_callTokensReceived(spender, holder, recipient, amount, "", "", false);
return true;
}
/**
* @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* If a send hook is registered for `account`, the corresponding function
* will be called with `operator`, `data` and `operatorData`.
*
* See {IERC777Sender} and {IERC777Recipient}.
*
* Emits {Minted} and {Transfer} events.
*
* Requirements
*
* - `account` cannot be the zero address.
* - if `account` is a contract, it must implement the {IERC777Recipient}
* interface.
*/
function _mint(
address operator,
address account,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
internal
{
require(account != address(0), "ERC777: mint to the zero address");
// Update state variables
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
_callTokensReceived(operator, address(0), account, amount, userData, operatorData, true);
emit Minted(operator, account, amount, userData, operatorData);
emit Transfer(address(0), account, amount);
}
/**
* @dev Send tokens
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
* @param requireReceptionAck if true, contract recipients are required to implement ERC777TokensRecipient
*/
function _send(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck
)
internal
{
require(from != address(0), "ERC777: send from the zero address");
require(to != address(0), "ERC777: send to the zero address");
_callTokensToSend(operator, from, to, amount, userData, operatorData);
_move(operator, from, to, amount, userData, operatorData);
_callTokensReceived(operator, from, to, amount, userData, operatorData, requireReceptionAck);
}
/**
* @dev Burn tokens
* @param operator address operator requesting the operation
* @param from address token holder address
* @param amount uint256 amount of tokens to burn
* @param data bytes extra information provided by the token holder
* @param operatorData bytes extra information provided by the operator (if any)
*/
function _burn(
address operator,
address from,
uint256 amount,
bytes memory data,
bytes memory operatorData
)
internal
{
require(from != address(0), "ERC777: burn from the zero address");
_callTokensToSend(operator, from, address(0), amount, data, operatorData);
// Update state variables
_balances[from] = _balances[from].sub(amount, "ERC777: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Burned(operator, from, amount, data, operatorData);
emit Transfer(from, address(0), amount);
}
function _move(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
internal
{
_balances[from] = _balances[from].sub(amount, "ERC777: transfer amount exceeds balance");
_balances[to] = _balances[to].add(amount);
emit Sent(operator, from, to, amount, userData, operatorData);
emit Transfer(from, to, amount);
}
function _approve(address holder, address spender, uint256 value) internal {
// TODO: restore this require statement if this function becomes internal, or is called at a new callsite. It is
// currently unnecessary.
//require(holder != address(0), "ERC777: approve from the zero address");
require(spender != address(0), "ERC777: approve to the zero address");
_allowances[holder][spender] = value;
emit Approval(holder, spender, value);
}
/**
* @dev Call from.tokensToSend() if the interface is registered
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
*/
function _callTokensToSend(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
private
{
address implementer = _erc1820.getInterfaceImplementer(from, TOKENS_SENDER_INTERFACE_HASH);
if (implementer != address(0)) {
IERC777Sender(implementer).tokensToSend(operator, from, to, amount, userData, operatorData);
}
}
/**
* @dev Call to.tokensReceived() if the interface is registered. Reverts if the recipient is a contract but
* tokensReceived() was not registered for the recipient
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
* @param requireReceptionAck if true, contract recipients are required to implement ERC777TokensRecipient
*/
function _callTokensReceived(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck
)
private
{
address implementer = _erc1820.getInterfaceImplementer(to, TOKENS_RECIPIENT_INTERFACE_HASH);
if (implementer != address(0)) {
IERC777Recipient(implementer).tokensReceived(operator, from, to, amount, userData, operatorData);
} else if (requireReceptionAck) {
require(!to.isContract(), "ERC777: token recipient contract has no implement for ERC777TokensRecipient");
}
}
} | /**
* @dev Implementation of the {IERC777} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
*
* Support for ERC20 is included in this contract, as specified by the EIP: both
* the ERC777 and ERC20 interfaces can be safely used when interacting with it.
* Both {IERC777-Sent} and {IERC20-Transfer} events are emitted on token
* movements.
*
* Additionally, the {IERC777-granularity} value is hard-coded to `1`, meaning that there
* are no special restrictions in the amount of tokens that created, moved, or
* destroyed. This makes integration with ERC20 applications seamless.
*/ | NatSpecMultiLine | _callTokensToSend | function _callTokensToSend(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
private
{
address implementer = _erc1820.getInterfaceImplementer(from, TOKENS_SENDER_INTERFACE_HASH);
if (implementer != address(0)) {
IERC777Sender(implementer).tokensToSend(operator, from, to, amount, userData, operatorData);
}
}
| /**
* @dev Call from.tokensToSend() if the interface is registered
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
*/ | NatSpecMultiLine | v0.5.0+commit.1d4f565a | MIT | bzzr://c1bab4b5e3e40f4294e652b388dfc625ccf21445b4e184e78b601a51d58a2cc2 | {
"func_code_index": [
13984,
14477
]
} | 59,951 |
NNCProjectToken | patterns\token\ERC777\ERC777.sol | 0xa67462ff3314c682277771ae2bbcec08877c877a | Solidity | ERC777 | contract ERC777 is Context, IERC777, IERC20 {
using SafeMath for uint256;
using Address for address;
IERC1820Registry constant internal _erc1820 = IERC1820Registry(0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24);
mapping(address => uint256) private _balances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
// We inline the result of the following hashes because Solidity doesn't resolve them at compile time.
// See https://github.com/ethereum/solidity/issues/4024.
// keccak256("ERC777TokensSender")
bytes32 constant private TOKENS_SENDER_INTERFACE_HASH =
0x29ddb589b1fb5fc7cf394961c1adf5f8c6454761adf795e67fe149f658abe895;
// keccak256("ERC777TokensRecipient")
bytes32 constant private TOKENS_RECIPIENT_INTERFACE_HASH =
0xb281fc8c12954d22544db45de3159a39272895b169a852b314f9cc762e44c53b;
// This isn't ever read from - it's only used to respond to the defaultOperators query.
address[] private _defaultOperatorsArray;
// Immutable, but accounts may revoke them (tracked in __revokedDefaultOperators).
mapping(address => bool) private _defaultOperators;
// For each account, a mapping of its operators and revoked default operators.
mapping(address => mapping(address => bool)) private _operators;
mapping(address => mapping(address => bool)) private _revokedDefaultOperators;
// ERC20-allowances
mapping (address => mapping (address => uint256)) private _allowances;
/**
* @dev `defaultOperators` may be an empty array.
*/
constructor(
string memory name,
string memory symbol,
address[] memory defaultOperators
) public {
_name = name;
_symbol = symbol;
_defaultOperatorsArray = defaultOperators;
for (uint256 i = 0; i < _defaultOperatorsArray.length; i++) {
_defaultOperators[_defaultOperatorsArray[i]] = true;
}
// register interfaces
_erc1820.setInterfaceImplementer(address(this), keccak256("ERC777Token"), address(this));
_erc1820.setInterfaceImplementer(address(this), keccak256("ERC20Token"), address(this));
}
/**
* @dev See {IERC777-name}.
*/
function name() public view returns (string memory) {
return _name;
}
/**
* @dev See {IERC777-symbol}.
*/
function symbol() public view returns (string memory) {
return _symbol;
}
/**
* @dev See {ERC20Detailed-decimals}.
*
* Always returns 18, as per the
* [ERC777 EIP](https://eips.ethereum.org/EIPS/eip-777#backward-compatibility).
*/
function decimals() public pure returns (uint8) {
return 18;
}
/**
* @dev See {IERC777-granularity}.
*
* This implementation always returns `1`.
*/
function granularity() public view returns (uint256) {
return 1;
}
/**
* @dev See {IERC777-totalSupply}.
*/
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
/**
* @dev Returns the amount of tokens owned by an account (`tokenHolder`).
*/
function balanceOf(address tokenHolder) public view returns (uint256) {
return _balances[tokenHolder];
}
/**
* @dev See {IERC777-send}.
*
* Also emits a {Transfer} event for ERC20 compatibility.
*/
function send(address recipient, uint256 amount, bytes calldata data) external {
_send(_msgSender(), _msgSender(), recipient, amount, data, "", true);
}
/**
* @dev See {IERC20-transfer}.
*
* Unlike `send`, `recipient` is _not_ required to implement the {IERC777Recipient}
* interface if it is a contract.
*
* Also emits a {Sent} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool) {
require(recipient != address(0), "ERC777: transfer to the zero address");
address from = _msgSender();
_callTokensToSend(from, from, recipient, amount, "", "");
_move(from, from, recipient, amount, "", "");
_callTokensReceived(from, from, recipient, amount, "", "", false);
return true;
}
/**
* @dev See {IERC777-burn}.
*
* Also emits a {Transfer} event for ERC20 compatibility.
*/
function burn(uint256 amount, bytes calldata data) external {
_burn(_msgSender(), _msgSender(), amount, data, "");
}
/**
* @dev See {IERC777-isOperatorFor}.
*/
function isOperatorFor(
address operator,
address tokenHolder
) public view returns (bool) {
return operator == tokenHolder ||
(_defaultOperators[operator] && !_revokedDefaultOperators[tokenHolder][operator]) ||
_operators[tokenHolder][operator];
}
/**
* @dev See {IERC777-authorizeOperator}.
*/
function authorizeOperator(address operator) external {
_authorizeOperator(operator);
}
function _authorizeOperator(address operator) internal {
require(_msgSender() != operator, "ERC777: authorizing self as operator");
if (_defaultOperators[operator]) {
delete _revokedDefaultOperators[_msgSender()][operator];
} else {
_operators[_msgSender()][operator] = true;
}
emit AuthorizedOperator(operator, _msgSender());
}
/**
* @dev See {IERC777-revokeOperator}.
*/
function revokeOperator(address operator) external {
_revokeOperator(operator);
}
function _revokeOperator(address operator) internal {
require(operator != _msgSender(), "ERC777: revoking self as operator");
if (_defaultOperators[operator]) {
_revokedDefaultOperators[_msgSender()][operator] = true;
} else {
delete _operators[_msgSender()][operator];
}
emit RevokedOperator(operator, _msgSender());
}
/**
* @dev See {IERC777-defaultOperators}.
*/
function defaultOperators() public view returns (address[] memory) {
return _defaultOperatorsArray;
}
/**
* @dev See {IERC777-operatorSend}.
*
* Emits {Sent} and {Transfer} events.
*/
function operatorSend(
address sender,
address recipient,
uint256 amount,
bytes calldata data,
bytes calldata operatorData
)
external
{
require(isOperatorFor(_msgSender(), sender), "ERC777: caller is not an operator for holder");
_send(_msgSender(), sender, recipient, amount, data, operatorData, true);
}
/**
* @dev See {IERC777-operatorBurn}.
*
* Emits {Burned} and {Transfer} events.
*/
function operatorBurn(address account, uint256 amount, bytes calldata data, bytes calldata operatorData) external {
require(isOperatorFor(_msgSender(), account), "ERC777: caller is not an operator for holder");
_burn(_msgSender(), account, amount, data, operatorData);
}
/**
* @dev See {IERC20-allowance}.
*
* Note that operator and allowance concepts are orthogonal: operators may
* not have allowance, and accounts with allowance may not be operators
* themselves.
*/
function allowance(address holder, address spender) public view returns (uint256) {
return _allowances[holder][spender];
}
/**
* @dev See {IERC20-approve}.
*
* Note that accounts cannot have allowance issued by their operators.
*/
function approve(address spender, uint256 value) external returns (bool) {
address holder = _msgSender();
_approve(holder, spender, value);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Note that operator and allowance concepts are orthogonal: operators cannot
* call `transferFrom` (unless they have allowance), and accounts with
* allowance cannot call `operatorSend` (unless they are operators).
*
* Emits {Sent}, {Transfer} and {Approval} events.
*/
function transferFrom(address holder, address recipient, uint256 amount) external returns (bool) {
require(recipient != address(0), "ERC777: transfer to the zero address");
require(holder != address(0), "ERC777: transfer from the zero address");
address spender = _msgSender();
_callTokensToSend(spender, holder, recipient, amount, "", "");
_move(spender, holder, recipient, amount, "", "");
_approve(holder, spender, _allowances[holder][spender].sub(amount, "ERC777: transfer amount exceeds allowance"));
_callTokensReceived(spender, holder, recipient, amount, "", "", false);
return true;
}
/**
* @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* If a send hook is registered for `account`, the corresponding function
* will be called with `operator`, `data` and `operatorData`.
*
* See {IERC777Sender} and {IERC777Recipient}.
*
* Emits {Minted} and {Transfer} events.
*
* Requirements
*
* - `account` cannot be the zero address.
* - if `account` is a contract, it must implement the {IERC777Recipient}
* interface.
*/
function _mint(
address operator,
address account,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
internal
{
require(account != address(0), "ERC777: mint to the zero address");
// Update state variables
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
_callTokensReceived(operator, address(0), account, amount, userData, operatorData, true);
emit Minted(operator, account, amount, userData, operatorData);
emit Transfer(address(0), account, amount);
}
/**
* @dev Send tokens
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
* @param requireReceptionAck if true, contract recipients are required to implement ERC777TokensRecipient
*/
function _send(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck
)
internal
{
require(from != address(0), "ERC777: send from the zero address");
require(to != address(0), "ERC777: send to the zero address");
_callTokensToSend(operator, from, to, amount, userData, operatorData);
_move(operator, from, to, amount, userData, operatorData);
_callTokensReceived(operator, from, to, amount, userData, operatorData, requireReceptionAck);
}
/**
* @dev Burn tokens
* @param operator address operator requesting the operation
* @param from address token holder address
* @param amount uint256 amount of tokens to burn
* @param data bytes extra information provided by the token holder
* @param operatorData bytes extra information provided by the operator (if any)
*/
function _burn(
address operator,
address from,
uint256 amount,
bytes memory data,
bytes memory operatorData
)
internal
{
require(from != address(0), "ERC777: burn from the zero address");
_callTokensToSend(operator, from, address(0), amount, data, operatorData);
// Update state variables
_balances[from] = _balances[from].sub(amount, "ERC777: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Burned(operator, from, amount, data, operatorData);
emit Transfer(from, address(0), amount);
}
function _move(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
internal
{
_balances[from] = _balances[from].sub(amount, "ERC777: transfer amount exceeds balance");
_balances[to] = _balances[to].add(amount);
emit Sent(operator, from, to, amount, userData, operatorData);
emit Transfer(from, to, amount);
}
function _approve(address holder, address spender, uint256 value) internal {
// TODO: restore this require statement if this function becomes internal, or is called at a new callsite. It is
// currently unnecessary.
//require(holder != address(0), "ERC777: approve from the zero address");
require(spender != address(0), "ERC777: approve to the zero address");
_allowances[holder][spender] = value;
emit Approval(holder, spender, value);
}
/**
* @dev Call from.tokensToSend() if the interface is registered
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
*/
function _callTokensToSend(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
private
{
address implementer = _erc1820.getInterfaceImplementer(from, TOKENS_SENDER_INTERFACE_HASH);
if (implementer != address(0)) {
IERC777Sender(implementer).tokensToSend(operator, from, to, amount, userData, operatorData);
}
}
/**
* @dev Call to.tokensReceived() if the interface is registered. Reverts if the recipient is a contract but
* tokensReceived() was not registered for the recipient
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
* @param requireReceptionAck if true, contract recipients are required to implement ERC777TokensRecipient
*/
function _callTokensReceived(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck
)
private
{
address implementer = _erc1820.getInterfaceImplementer(to, TOKENS_RECIPIENT_INTERFACE_HASH);
if (implementer != address(0)) {
IERC777Recipient(implementer).tokensReceived(operator, from, to, amount, userData, operatorData);
} else if (requireReceptionAck) {
require(!to.isContract(), "ERC777: token recipient contract has no implement for ERC777TokensRecipient");
}
}
} | /**
* @dev Implementation of the {IERC777} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
*
* Support for ERC20 is included in this contract, as specified by the EIP: both
* the ERC777 and ERC20 interfaces can be safely used when interacting with it.
* Both {IERC777-Sent} and {IERC20-Transfer} events are emitted on token
* movements.
*
* Additionally, the {IERC777-granularity} value is hard-coded to `1`, meaning that there
* are no special restrictions in the amount of tokens that created, moved, or
* destroyed. This makes integration with ERC20 applications seamless.
*/ | NatSpecMultiLine | _callTokensReceived | function _callTokensReceived(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck
)
private
{
address implementer = _erc1820.getInterfaceImplementer(to, TOKENS_RECIPIENT_INTERFACE_HASH);
if (implementer != address(0)) {
IERC777Recipient(implementer).tokensReceived(operator, from, to, amount, userData, operatorData);
} else if (requireReceptionAck) {
require(!to.isContract(), "ERC777: token recipient contract has no implement for ERC777TokensRecipient");
}
}
| /**
* @dev Call to.tokensReceived() if the interface is registered. Reverts if the recipient is a contract but
* tokensReceived() was not registered for the recipient
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
* @param requireReceptionAck if true, contract recipients are required to implement ERC777TokensRecipient
*/ | NatSpecMultiLine | v0.5.0+commit.1d4f565a | MIT | bzzr://c1bab4b5e3e40f4294e652b388dfc625ccf21445b4e184e78b601a51d58a2cc2 | {
"func_code_index": [
15174,
15872
]
} | 59,952 |
TokenERC20 | TokenERC20.sol | 0x5684e0bb4798fe5bbe6e0a26254567863fba223b | Solidity | TokenERC20 | 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 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);
/**
* Constrctor function
*
* Initializes contract with initial supply tokens to the creator of the contract
*/
constructor(
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;
emit 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 returns (bool success) {
_transfer(msg.sender, _to, _value);
return true;
}
/**
* 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;
emit Approval(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
emit 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
emit Burn(_from, _value);
return true;
}
} | _transfer | 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;
emit 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);
}
| /**
* Internal transfer, only can be called by this contract
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://1a1aceaf2eea1ae268618c36cf9ced606eac1e6a6bf796356d6c2c9fe11ab064 | {
"func_code_index": [
1605,
2452
]
} | 59,953 |
|||
TokenERC20 | TokenERC20.sol | 0x5684e0bb4798fe5bbe6e0a26254567863fba223b | Solidity | TokenERC20 | 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 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);
/**
* Constrctor function
*
* Initializes contract with initial supply tokens to the creator of the contract
*/
constructor(
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;
emit 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 returns (bool success) {
_transfer(msg.sender, _to, _value);
return true;
}
/**
* 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;
emit Approval(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
emit 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
emit Burn(_from, _value);
return true;
}
} | transfer | function transfer(address _to, uint256 _value) public returns (bool success) {
_transfer(msg.sender, _to, _value);
return true;
}
| /**
* Transfer tokens
*
* Send `_value` tokens to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://1a1aceaf2eea1ae268618c36cf9ced606eac1e6a6bf796356d6c2c9fe11ab064 | {
"func_code_index": [
2652,
2809
]
} | 59,954 |
|||
TokenERC20 | TokenERC20.sol | 0x5684e0bb4798fe5bbe6e0a26254567863fba223b | Solidity | TokenERC20 | 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 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);
/**
* Constrctor function
*
* Initializes contract with initial supply tokens to the creator of the contract
*/
constructor(
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;
emit 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 returns (bool success) {
_transfer(msg.sender, _to, _value);
return true;
}
/**
* 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;
emit Approval(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
emit 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
emit Burn(_from, _value);
return true;
}
} | transferFrom | 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 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
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://1a1aceaf2eea1ae268618c36cf9ced606eac1e6a6bf796356d6c2c9fe11ab064 | {
"func_code_index": [
3078,
3379
]
} | 59,955 |
|||
TokenERC20 | TokenERC20.sol | 0x5684e0bb4798fe5bbe6e0a26254567863fba223b | Solidity | TokenERC20 | 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 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);
/**
* Constrctor function
*
* Initializes contract with initial supply tokens to the creator of the contract
*/
constructor(
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;
emit 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 returns (bool success) {
_transfer(msg.sender, _to, _value);
return true;
}
/**
* 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;
emit Approval(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
emit 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
emit Burn(_from, _value);
return true;
}
} | approve | 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
*
* 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
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://1a1aceaf2eea1ae268618c36cf9ced606eac1e6a6bf796356d6c2c9fe11ab064 | {
"func_code_index": [
3637,
3867
]
} | 59,956 |
|||
TokenERC20 | TokenERC20.sol | 0x5684e0bb4798fe5bbe6e0a26254567863fba223b | Solidity | TokenERC20 | 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 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);
/**
* Constrctor function
*
* Initializes contract with initial supply tokens to the creator of the contract
*/
constructor(
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;
emit 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 returns (bool success) {
_transfer(msg.sender, _to, _value);
return true;
}
/**
* 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;
emit Approval(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
emit 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
emit Burn(_from, _value);
return true;
}
} | approveAndCall | 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;
}
}
| /**
* 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
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://1a1aceaf2eea1ae268618c36cf9ced606eac1e6a6bf796356d6c2c9fe11ab064 | {
"func_code_index": [
4255,
4607
]
} | 59,957 |
|||
TokenERC20 | TokenERC20.sol | 0x5684e0bb4798fe5bbe6e0a26254567863fba223b | Solidity | TokenERC20 | 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 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);
/**
* Constrctor function
*
* Initializes contract with initial supply tokens to the creator of the contract
*/
constructor(
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;
emit 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 returns (bool success) {
_transfer(msg.sender, _to, _value);
return true;
}
/**
* 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;
emit Approval(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
emit 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
emit Burn(_from, _value);
return true;
}
} | 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 tokens
*
* Remove `_value` tokens from the system irreversibly
*
* @param _value the amount of money to burn
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://1a1aceaf2eea1ae268618c36cf9ced606eac1e6a6bf796356d6c2c9fe11ab064 | {
"func_code_index": [
4771,
5150
]
} | 59,958 |
|||
TokenERC20 | TokenERC20.sol | 0x5684e0bb4798fe5bbe6e0a26254567863fba223b | Solidity | TokenERC20 | 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 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);
/**
* Constrctor function
*
* Initializes contract with initial supply tokens to the creator of the contract
*/
constructor(
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;
emit 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 returns (bool success) {
_transfer(msg.sender, _to, _value);
return true;
}
/**
* 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;
emit Approval(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
emit 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
emit Burn(_from, _value);
return true;
}
} | burnFrom | 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;
}
| /**
* 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
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://1a1aceaf2eea1ae268618c36cf9ced606eac1e6a6bf796356d6c2c9fe11ab064 | {
"func_code_index": [
5402,
6018
]
} | 59,959 |
|||
TokenERC20 | TokenERC20.sol | 0x5684e0bb4798fe5bbe6e0a26254567863fba223b | Solidity | Kahawanu | contract Kahawanu is owned, TokenERC20 {
uint256 public sellPrice;
uint256 public buyPrice;
mapping (address => bool) public frozenAccount;
/* This generates a public event on the blockchain that will notify clients */
event FrozenFunds(address target, bool frozen);
/* Initializes contract with initial supply tokens to the creator of the contract */
constructor(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) TokenERC20(initialSupply, tokenName, tokenSymbol) public {}
/* Internal transfer, only can be called by this contract */
function _transfer(address _from, address _to, uint _value) internal {
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
require(!frozenAccount[_from]); // Check if sender is frozen
require(!frozenAccount[_to]); // Check if recipient is frozen
balanceOf[_from] -= _value; // Subtract from the sender
balanceOf[_to] += _value; // Add the same to the recipient
emit Transfer(_from, _to, _value);
}
/// @notice Create `mintedAmount` tokens and send it to `target`
/// @param target Address to receive the tokens
/// @param mintedAmount the amount of tokens it will receive
function mintToken(address target, uint256 mintedAmount) onlyOwner public {
balanceOf[target] += mintedAmount;
totalSupply += mintedAmount;
emit Transfer(0, this, mintedAmount);
emit Transfer(this, target, mintedAmount);
}
/// @notice `freeze? Prevent | Allow` `target` from sending & receiving tokens
/// @param target Address to be frozen
/// @param freeze either to freeze it or not
function freezeAccount(address target, bool freeze) onlyOwner public {
frozenAccount[target] = freeze;
emit FrozenFunds(target, freeze);
}
/// @notice Allow users to buy tokens for `newBuyPrice` eth and sell tokens for `newSellPrice` eth
/// @param newSellPrice Price the users can sell to the contract
/// @param newBuyPrice Price users can buy from the contract
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner public {
sellPrice = newSellPrice;
buyPrice = newBuyPrice;
}
/// @notice Buy tokens from contract by sending ether
function buy() payable public {
uint amount = msg.value / buyPrice; // calculates the amount
_transfer(this, msg.sender, amount); // makes the transfers
}
/// @notice Sell `amount` tokens to contract
/// @param amount amount of tokens to be sold
function sell(uint256 amount) public {
address myAddress = this;
require(myAddress.balance >= amount * sellPrice); // checks if the contract has enough ether to buy
_transfer(msg.sender, this, amount); // makes the transfers
msg.sender.transfer(amount * sellPrice); // sends ether to the seller. It's important to do this last to avoid recursion attacks
}
} | /******************************************/ | NatSpecMultiLine | _transfer | function _transfer(address _from, address _to, uint _value) internal {
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
require(!frozenAccount[_from]); // Check if sender is frozen
require(!frozenAccount[_to]); // Check if recipient is frozen
balanceOf[_from] -= _value; // Subtract from the sender
balanceOf[_to] += _value; // Add the same to the recipient
emit Transfer(_from, _to, _value);
}
| /* Internal transfer, only can be called by this contract */ | Comment | v0.4.24+commit.e67f0147 | bzzr://1a1aceaf2eea1ae268618c36cf9ced606eac1e6a6bf796356d6c2c9fe11ab064 | {
"func_code_index": [
601,
1389
]
} | 59,960 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.