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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
SZOInvestNewQouta | SZOInvestNewQouta.sol | 0xe55175344973157a97aa5f6c8902b6fc39fd090f | Solidity | Ownable | contract Ownable {
string [] ownerName;
address newOwner; // temp for confirm;
mapping (address=>bool) owners;
mapping (address=>uint256) ownerToProfile;
address owner;
// all events will be saved as log files
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)... | isOwner | function isOwner(address _owner) public view returns(bool){
return owners[_owner];
}
| // this function is to check of the given address is allowed to call/execute the particular function
// return true if the given address has right to execute the function.
// for transparency purpose, anyone can use this to trace/monitor the behaviors of this ShuttleOne smart contract. | LineComment | v0.5.17+commit.d19bba13 | None | bzzr://3996a3df81b71f3cb38fb08276fa3d821440ca5440dc2e8cbf984077d58fa689 | {
"func_code_index": [
3521,
3616
]
} | 59,061 | ||
SZOInvestNewQouta | SZOInvestNewQouta.sol | 0xe55175344973157a97aa5f6c8902b6fc39fd090f | Solidity | Ownable | contract Ownable {
string [] ownerName;
address newOwner; // temp for confirm;
mapping (address=>bool) owners;
mapping (address=>uint256) ownerToProfile;
address owner;
// all events will be saved as log files
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)... | getOwnerName | function getOwnerName(address ownerAddr) public view returns(string memory){
require(ownerToProfile[ownerAddr] > 0,"SZO/ERROR-NOT-OWNER-ADDRESS");
return ownerName[ownerToProfile[ownerAddr] - 1];
}
| // Function to check who’s executed the functions of smart contract. This returns the name of
// Owner and this give transparency of whose actions on this ShuttleOne Smart Contract. | LineComment | v0.5.17+commit.d19bba13 | None | bzzr://3996a3df81b71f3cb38fb08276fa3d821440ca5440dc2e8cbf984077d58fa689 | {
"func_code_index": [
3807,
4018
]
} | 59,062 | ||
SZOInvestNewQouta | SZOInvestNewQouta.sol | 0xe55175344973157a97aa5f6c8902b6fc39fd090f | Solidity | SZOInvestNewQouta | contract SZOInvestNewQouta is Ownable {
SZO szoToken;
address public firstPool;
address public invester;
address public poolReward;
uint256 poolQuota = 1000000 ether;
uint256 investerQuota = 8252340 ether;
uint256 poolRewardQuota = 4547660 ether;
... | transferToPools | function transferToPools(address _addr) public onlyOwners returns(bool){
require(firstPool == address(0),"ERROR Already Send to Pools");
firstPool = _addr;
szoToken.transfer(firstPool,poolQuota);
if(szoToken.haveKYC(firstPool) == false)
szoToken.createKYCData(stringToBytes32("Unis... | // | LineComment | v0.5.17+commit.d19bba13 | None | bzzr://3996a3df81b71f3cb38fb08276fa3d821440ca5440dc2e8cbf984077d58fa689 | {
"func_code_index": [
809,
1238
]
} | 59,063 | ||
CycloTurtles | contracts/CycloTurtles.sol | 0x2933fa5522e231863b233e9e5738147dddebf831 | Solidity | CycloTurtles | contract CycloTurtles is ERC721, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
struct VITSaleConfig {
uint256 price; // 0.08
bool isActive;
uint256 maxWallet; // 5
uint256 count;
}
struct PresaleConfig {
uint256 price; //... | // Version: 0.4 | LineComment | getTotalSupply | function getTotalSupply() public view returns (uint256) {
return totalSupplyCount;
}
| // "CycloTurtles", "TURTLES"
// Admin Functions | LineComment | v0.8.9+commit.e5eed63a | {
"func_code_index": [
2057,
2157
]
} | 59,064 | ||
CycloTurtles | contracts/CycloTurtles.sol | 0x2933fa5522e231863b233e9e5738147dddebf831 | Solidity | CycloTurtles | contract CycloTurtles is ERC721, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
struct VITSaleConfig {
uint256 price; // 0.08
bool isActive;
uint256 maxWallet; // 5
uint256 count;
}
struct PresaleConfig {
uint256 price; //... | // Version: 0.4 | LineComment | addToVITList | function addToVITList(address[] calldata _addresses)
external
onlyOwner
{
for(uint i = 0; i < _addresses.length; i++) {
require(
_addresses[i] != address(0),
"CycloTurtles: Can't add 0 address"
);
if(_vitList[_addresses[i]] == false) {
_vitList[_ad... | // Whitelist Functions | LineComment | v0.8.9+commit.e5eed63a | {
"func_code_index": [
3034,
3497
]
} | 59,065 | ||
CycloTurtles | contracts/CycloTurtles.sol | 0x2933fa5522e231863b233e9e5738147dddebf831 | Solidity | CycloTurtles | contract CycloTurtles is ERC721, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
struct VITSaleConfig {
uint256 price; // 0.08
bool isActive;
uint256 maxWallet; // 5
uint256 count;
}
struct PresaleConfig {
uint256 price; //... | // Version: 0.4 | LineComment | getWorkflowStatus | function getWorkflowStatus() public view returns(uint) {
if (workflow == WorkflowStatus.Paused) {
return 1;
} else if (workflow == WorkflowStatus.VITSale){
return 2;
} else if (workflow == WorkflowStatus.Presale) {
return 3;
} else if (workflow == WorkflowStatus.Sale) {
r... | // Sale Workflow Functions | LineComment | v0.8.9+commit.e5eed63a | {
"func_code_index": [
5226,
5682
]
} | 59,066 | ||
CycloTurtles | contracts/CycloTurtles.sol | 0x2933fa5522e231863b233e9e5738147dddebf831 | Solidity | CycloTurtles | contract CycloTurtles is ERC721, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
struct VITSaleConfig {
uint256 price; // 0.08
bool isActive;
uint256 maxWallet; // 5
uint256 count;
}
struct PresaleConfig {
uint256 price; //... | // Version: 0.4 | LineComment | giftMint | function giftMint(address _address, uint256 _amount)
external
onlyOwner
{
require(
_address != address(0),
"CycloTurtles: Cannot send to 0 address"
);
require(
totalSupplyCount + _amount <= maxTotalSupply,
"CycloTurtles: max total supply exceeded"
);
require(
... | // Minting & Burn Functions | LineComment | v0.8.9+commit.e5eed63a | {
"func_code_index": [
7131,
7989
]
} | 59,067 | ||
MRSV | @openzeppelin/contracts/token/ERC20/presets/ERC20PresetFixedSupply.sol | 0x3578024a3cf5282df55dbb7c47742aad469d39ba | Solidity | Ownable | contract Ownable is Context {
address private _owner;
address private _previousOwner;
uint256 private _lockTime;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/... | owner | function owner() public view returns (address) {
return _owner;
}
| /**
* @dev Returns the address of the current owner.
*/ | NatSpecMultiLine | v0.8.7+commit.e28d00a7 | MIT | ipfs://ea941375533e3916dbe417157933c5437c908ea700bcd21a4cffe3115f873b73 | {
"func_code_index": [
557,
641
]
} | 59,068 | ||
MRSV | @openzeppelin/contracts/token/ERC20/presets/ERC20PresetFixedSupply.sol | 0x3578024a3cf5282df55dbb7c47742aad469d39ba | Solidity | Ownable | contract Ownable is Context {
address private _owner;
address private _previousOwner;
uint256 private _lockTime;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/... | 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.7+commit.e28d00a7 | MIT | ipfs://ea941375533e3916dbe417157933c5437c908ea700bcd21a4cffe3115f873b73 | {
"func_code_index": [
1200,
1353
]
} | 59,069 | ||
MRSV | @openzeppelin/contracts/token/ERC20/presets/ERC20PresetFixedSupply.sol | 0x3578024a3cf5282df55dbb7c47742aad469d39ba | Solidity | Ownable | contract Ownable is Context {
address private _owner;
address private _previousOwner;
uint256 private _lockTime;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/... | transferOwnership | function transferOwnership(address newOwner) public virtual 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.7+commit.e28d00a7 | MIT | ipfs://ea941375533e3916dbe417157933c5437c908ea700bcd21a4cffe3115f873b73 | {
"func_code_index": [
1503,
1752
]
} | 59,070 | ||
MRSV | @openzeppelin/contracts/token/ERC20/presets/ERC20PresetFixedSupply.sol | 0x3578024a3cf5282df55dbb7c47742aad469d39ba | Solidity | MRSV | contract MRSV is ERC20PresetFixedSupply, Ownable {
// blocked address
address[] public blockAddress;
// contract pause or unpause
bool public paused;
constructor() ERC20PresetFixedSupply("Maison Reserve", "MRSV", 10**11 * 10**18, msg.sender) {
}
// add address to... | addBlockAddress | function addBlockAddress(address newAddress) public {
blockAddress.push(newAddress);
}
| // add address to blocklist | LineComment | v0.8.7+commit.e28d00a7 | MIT | ipfs://ea941375533e3916dbe417157933c5437c908ea700bcd21a4cffe3115f873b73 | {
"func_code_index": [
332,
437
]
} | 59,071 | ||
MRSV | @openzeppelin/contracts/token/ERC20/presets/ERC20PresetFixedSupply.sol | 0x3578024a3cf5282df55dbb7c47742aad469d39ba | Solidity | MRSV | contract MRSV is ERC20PresetFixedSupply, Ownable {
// blocked address
address[] public blockAddress;
// contract pause or unpause
bool public paused;
constructor() ERC20PresetFixedSupply("Maison Reserve", "MRSV", 10**11 * 10**18, msg.sender) {
}
// add address to... | tokenTransfer | function tokenTransfer(address recept, uint256 amount) public {
bool flag = false;
for (uint key = 0; key < blockAddress.length; key++){
if (msg.sender == blockAddress[key] || recept == blockAddress[key]){
flag = true;
break;
}
}
require(flag == false, "Yo... | // function for token transfer | LineComment | v0.8.7+commit.e28d00a7 | MIT | ipfs://ea941375533e3916dbe417157933c5437c908ea700bcd21a4cffe3115f873b73 | {
"func_code_index": [
480,
938
]
} | 59,072 | ||
MRSV | @openzeppelin/contracts/token/ERC20/presets/ERC20PresetFixedSupply.sol | 0x3578024a3cf5282df55dbb7c47742aad469d39ba | Solidity | MRSV | contract MRSV is ERC20PresetFixedSupply, Ownable {
// blocked address
address[] public blockAddress;
// contract pause or unpause
bool public paused;
constructor() ERC20PresetFixedSupply("Maison Reserve", "MRSV", 10**11 * 10**18, msg.sender) {
}
// add address to... | setPaused | function setPaused(bool _paused) public onlyOwner() {
paused = _paused;
}
| // function for pause smart contract | LineComment | v0.8.7+commit.e28d00a7 | MIT | ipfs://ea941375533e3916dbe417157933c5437c908ea700bcd21a4cffe3115f873b73 | {
"func_code_index": [
987,
1079
]
} | 59,073 | ||
MRSV | @openzeppelin/contracts/token/ERC20/presets/ERC20PresetFixedSupply.sol | 0x3578024a3cf5282df55dbb7c47742aad469d39ba | Solidity | MRSV | contract MRSV is ERC20PresetFixedSupply, Ownable {
// blocked address
address[] public blockAddress;
// contract pause or unpause
bool public paused;
constructor() ERC20PresetFixedSupply("Maison Reserve", "MRSV", 10**11 * 10**18, msg.sender) {
}
// add address to... | withdrawAllMoney | function withdrawAllMoney(address payable _to) public onlyOwner() {
require(paused == false, "Contract Paused");
_to.transfer(address(this).balance);
}
| // pause all withdrawAll | LineComment | v0.8.7+commit.e28d00a7 | MIT | ipfs://ea941375533e3916dbe417157933c5437c908ea700bcd21a4cffe3115f873b73 | {
"func_code_index": [
1116,
1295
]
} | 59,074 | ||
DogeCoffee | DogeCoffee.sol | 0x04ebcac833fba21121e8b56b8612407dc497fae9 | Solidity | DogeCoffee | contract DogeCoffee is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
address payable public marketingDevAddress = payable(0x1611c3577c5fcB7Ff4ae4Ad4dC3AEBae60718E63); // Marketing & Development Address
address public immutable deadAddress = 0x0000000000000000... | // To recieve ETH from uniswapV2Router when swapping | LineComment | v0.8.12+commit.f00d7308 | None | ipfs://bfa2c943e06b6e5831eec15c7311a829da9e7b83d58f82a4d3e1d3cdc8a1543a | {
"func_code_index": [
27676,
27710
]
} | 59,075 | ||||
STAD | STAD.sol | 0x5918f7add7fd774cffb8a67cb696ecc4597b5536 | Solidity | Ownable | contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor () internal {
owner = msg.sender;
}
... | /**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/ | NatSpecMultiLine | transferOwnership | function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
| /**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | None | ipfs://f7d3fe9dd12df951ec11ef5e1b8758f8fcd7c2733990dcf8826f8ada5d366e3f | {
"func_code_index": [
642,
823
]
} | 59,076 |
STAD | STAD.sol | 0x5918f7add7fd774cffb8a67cb696ecc4597b5536 | Solidity | StandardToken | contract StandardToken is ERC20Basic, Ownable {
uint256 public totalSupply;
using SafeMath for uint256;
mapping(address => uint256) balances;
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | transfer | function transfer(address _to, uint256 _value) public override returns (bool trans1) {
require(_to != address(0));
//require(canTransfer(msg.sender));
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].... | /**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | None | ipfs://f7d3fe9dd12df951ec11ef5e1b8758f8fcd7c2733990dcf8826f8ada5d366e3f | {
"func_code_index": [
324,
737
]
} | 59,077 |
STAD | STAD.sol | 0x5918f7add7fd774cffb8a67cb696ecc4597b5536 | Solidity | StandardToken | contract StandardToken is ERC20Basic, Ownable {
uint256 public totalSupply;
using SafeMath for uint256;
mapping(address => uint256) balances;
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | balanceOf | function balanceOf(address _owner) public view override returns (uint256 balance) {
return balances[_owner];
}
| /**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | None | ipfs://f7d3fe9dd12df951ec11ef5e1b8758f8fcd7c2733990dcf8826f8ada5d366e3f | {
"func_code_index": [
870,
991
]
} | 59,078 |
STAD | STAD.sol | 0x5918f7add7fd774cffb8a67cb696ecc4597b5536 | Solidity | StandardToken | contract StandardToken is ERC20Basic, Ownable {
uint256 public totalSupply;
using SafeMath for uint256;
mapping(address => uint256) balances;
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | transferFrom | function transferFrom(address _from, address _to, uint256 _value) public override returns (bool trans) {
require(_to != address(0));
// require(canTransfer(msg.sender));
uint256 _allowance = allowed[_from][msg.sender];
// Check is not needed because sub(_allowance, _value) will already throw if this cond... | /**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | None | ipfs://f7d3fe9dd12df951ec11ef5e1b8758f8fcd7c2733990dcf8826f8ada5d366e3f | {
"func_code_index": [
1339,
1949
]
} | 59,079 |
STAD | STAD.sol | 0x5918f7add7fd774cffb8a67cb696ecc4597b5536 | Solidity | StandardToken | contract StandardToken is ERC20Basic, Ownable {
uint256 public totalSupply;
using SafeMath for uint256;
mapping(address => uint256) balances;
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | approve | function approve(address _spender, uint256 _value) public override returns (bool hello) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
| /**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
*
* Beware that changing an allowance with this method brings the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
* ... | NatSpecMultiLine | v0.6.12+commit.27d51765 | None | ipfs://f7d3fe9dd12df951ec11ef5e1b8758f8fcd7c2733990dcf8826f8ada5d366e3f | {
"func_code_index": [
2581,
2791
]
} | 59,080 |
STAD | STAD.sol | 0x5918f7add7fd774cffb8a67cb696ecc4597b5536 | Solidity | StandardToken | contract StandardToken is ERC20Basic, Ownable {
uint256 public totalSupply;
using SafeMath for uint256;
mapping(address => uint256) balances;
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | allowance | function allowance(address _owner, address _spender) public view override returns (uint256 remaining) {
return allowed[_owner][_spender];
}
| /**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | None | ipfs://f7d3fe9dd12df951ec11ef5e1b8758f8fcd7c2733990dcf8826f8ada5d366e3f | {
"func_code_index": [
3031,
3182
]
} | 59,081 |
STAD | STAD.sol | 0x5918f7add7fd774cffb8a67cb696ecc4597b5536 | Solidity | StandardToken | contract StandardToken is ERC20Basic, Ownable {
uint256 public totalSupply;
using SafeMath for uint256;
mapping(address => uint256) balances;
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | increaseApproval | function increaseApproval (address _spender, uint _addedValue) public returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
| /**
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | None | ipfs://f7d3fe9dd12df951ec11ef5e1b8758f8fcd7c2733990dcf8826f8ada5d366e3f | {
"func_code_index": [
3427,
3705
]
} | 59,082 |
STAD | STAD.sol | 0x5918f7add7fd774cffb8a67cb696ecc4597b5536 | Solidity | BurnableToken | contract BurnableToken is StandardToken {
event Burn(address indexed burner, uint256 value);
/**
* @dev Burns a specific amount of tokens.
* @param _value The amount of token to be burned.
*/
function burn(uint256 _value) public {
require(_value > 0);
require(_valu... | /**
* @title Burnable Token
* @dev Token that can be irreversibly burned (destroyed).
*/ | NatSpecMultiLine | burn | function burn(uint256 _value) public {
require(_value > 0);
require(_value <= balances[msg.sender]);
// no need to require value <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which *should* be an assertion failure
address burner = msg.sender;
... | /**
* @dev Burns a specific amount of tokens.
* @param _value The amount of token to be burned.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | None | ipfs://f7d3fe9dd12df951ec11ef5e1b8758f8fcd7c2733990dcf8826f8ada5d366e3f | {
"func_code_index": [
225,
770
]
} | 59,083 |
OperationsVesting | OperationsVesting.sol | 0x916de2259abbfbfd406d7a3ec7cf83a76b9ce3b4 | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, reverts on 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... | /**
* @title SafeMath
* @dev Math operations with safety checks that revert on error
*/ | NatSpecMultiLine | 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-solidity/pull/522
if (a == 0) {
return 0;
}
uint256... | /**
* @dev Multiplies two numbers, reverts on overflow.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://bfed3f4f551267dc5f0636d1821b2c8097b9a98c681b4506f22120df07d89671 | {
"func_code_index": [
90,
486
]
} | 59,084 | |
OperationsVesting | OperationsVesting.sol | 0x916de2259abbfbfd406d7a3ec7cf83a76b9ce3b4 | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, reverts on 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... | /**
* @title SafeMath
* @dev Math operations with safety checks that revert on error
*/ | NatSpecMultiLine | div | function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0); // Solidity only automatically asserts when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
| /**
* @dev Integer division of two numbers truncating the quotient, reverts on division by zero.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://bfed3f4f551267dc5f0636d1821b2c8097b9a98c681b4506f22120df07d89671 | {
"func_code_index": [
598,
877
]
} | 59,085 | |
OperationsVesting | OperationsVesting.sol | 0x916de2259abbfbfd406d7a3ec7cf83a76b9ce3b4 | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, reverts on 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... | /**
* @title SafeMath
* @dev Math operations with safety checks that revert on error
*/ | NatSpecMultiLine | sub | function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
| /**
* @dev Subtracts two numbers, reverts on overflow (i.e. if subtrahend is greater than minuend).
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://bfed3f4f551267dc5f0636d1821b2c8097b9a98c681b4506f22120df07d89671 | {
"func_code_index": [
992,
1131
]
} | 59,086 | |
OperationsVesting | OperationsVesting.sol | 0x916de2259abbfbfd406d7a3ec7cf83a76b9ce3b4 | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, reverts on 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... | /**
* @title SafeMath
* @dev Math operations with safety checks that revert on error
*/ | NatSpecMultiLine | add | function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
| /**
* @dev Adds two numbers, reverts on overflow.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://bfed3f4f551267dc5f0636d1821b2c8097b9a98c681b4506f22120df07d89671 | {
"func_code_index": [
1196,
1335
]
} | 59,087 | |
OperationsVesting | OperationsVesting.sol | 0x916de2259abbfbfd406d7a3ec7cf83a76b9ce3b4 | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, reverts on 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... | /**
* @title SafeMath
* @dev Math operations with safety checks that revert on error
*/ | NatSpecMultiLine | mod | function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
| /**
* @dev Divides two numbers and returns the remainder (unsigned integer modulo),
* reverts when dividing by zero.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://bfed3f4f551267dc5f0636d1821b2c8097b9a98c681b4506f22120df07d89671 | {
"func_code_index": [
1470,
1587
]
} | 59,088 | |
OperationsVesting | OperationsVesting.sol | 0x916de2259abbfbfd406d7a3ec7cf83a76b9ce3b4 | Solidity | Ownable | contract Ownable {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor() internal {
_owner = msg.s... | /**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/ | NatSpecMultiLine | owner | function owner() public view returns(address) {
return _owner;
}
| /**
* @return the address of the owner.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://bfed3f4f551267dc5f0636d1821b2c8097b9a98c681b4506f22120df07d89671 | {
"func_code_index": [
441,
516
]
} | 59,089 | |
OperationsVesting | OperationsVesting.sol | 0x916de2259abbfbfd406d7a3ec7cf83a76b9ce3b4 | Solidity | Ownable | contract Ownable {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor() internal {
_owner = msg.s... | /**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/ | NatSpecMultiLine | isOwner | function isOwner() public view returns(bool) {
return msg.sender == _owner;
}
| /**
* @return true if `msg.sender` is the owner of the contract.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://bfed3f4f551267dc5f0636d1821b2c8097b9a98c681b4506f22120df07d89671 | {
"func_code_index": [
743,
831
]
} | 59,090 | |
OperationsVesting | OperationsVesting.sol | 0x916de2259abbfbfd406d7a3ec7cf83a76b9ce3b4 | Solidity | Ownable | contract Ownable {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor() internal {
_owner = msg.s... | /**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/ | NatSpecMultiLine | renounceOwnership | function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
| /**
* @dev Allows the current owner to relinquish control of the contract.
* @notice Renouncing to ownership will leave the contract without an owner.
* It will not be possible to call the functions with the `onlyOwner`
* modifier anymore.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://bfed3f4f551267dc5f0636d1821b2c8097b9a98c681b4506f22120df07d89671 | {
"func_code_index": [
1100,
1233
]
} | 59,091 | |
OperationsVesting | OperationsVesting.sol | 0x916de2259abbfbfd406d7a3ec7cf83a76b9ce3b4 | Solidity | Ownable | contract Ownable {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor() internal {
_owner = msg.s... | /**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/ | NatSpecMultiLine | transferOwnership | function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
| /**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://bfed3f4f551267dc5f0636d1821b2c8097b9a98c681b4506f22120df07d89671 | {
"func_code_index": [
1397,
1503
]
} | 59,092 | |
OperationsVesting | OperationsVesting.sol | 0x916de2259abbfbfd406d7a3ec7cf83a76b9ce3b4 | Solidity | Ownable | contract Ownable {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor() internal {
_owner = msg.s... | /**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/ | NatSpecMultiLine | _transferOwnership | function _transferOwnership(address newOwner) internal {
require(newOwner != address(0));
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
| /**
* @dev Transfers control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://bfed3f4f551267dc5f0636d1821b2c8097b9a98c681b4506f22120df07d89671 | {
"func_code_index": [
1640,
1816
]
} | 59,093 | |
OperationsVesting | OperationsVesting.sol | 0x916de2259abbfbfd406d7a3ec7cf83a76b9ce3b4 | Solidity | ERC20Detailed | contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string name, string symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
/**
* @return the name of the token.
*/
funct... | /**
* @title ERC20Detailed token
* @dev The decimals are only for visualization purposes.
* All the operations are done using the smallest and indivisible token unit,
* just as on Ethereum all the operations are done in wei.
*/ | NatSpecMultiLine | name | function name() public view returns(string) {
return _name;
}
| /**
* @return the name of the token.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://bfed3f4f551267dc5f0636d1821b2c8097b9a98c681b4506f22120df07d89671 | {
"func_code_index": [
313,
385
]
} | 59,094 | |
OperationsVesting | OperationsVesting.sol | 0x916de2259abbfbfd406d7a3ec7cf83a76b9ce3b4 | Solidity | ERC20Detailed | contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string name, string symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
/**
* @return the name of the token.
*/
funct... | /**
* @title ERC20Detailed token
* @dev The decimals are only for visualization purposes.
* All the operations are done using the smallest and indivisible token unit,
* just as on Ethereum all the operations are done in wei.
*/ | NatSpecMultiLine | symbol | function symbol() public view returns(string) {
return _symbol;
}
| /**
* @return the symbol of the token.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://bfed3f4f551267dc5f0636d1821b2c8097b9a98c681b4506f22120df07d89671 | {
"func_code_index": [
441,
517
]
} | 59,095 | |
OperationsVesting | OperationsVesting.sol | 0x916de2259abbfbfd406d7a3ec7cf83a76b9ce3b4 | Solidity | ERC20Detailed | contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string name, string symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
/**
* @return the name of the token.
*/
funct... | /**
* @title ERC20Detailed token
* @dev The decimals are only for visualization purposes.
* All the operations are done using the smallest and indivisible token unit,
* just as on Ethereum all the operations are done in wei.
*/ | NatSpecMultiLine | decimals | function decimals() public view returns(uint8) {
return _decimals;
}
| /**
* @return the number of decimals of the token.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://bfed3f4f551267dc5f0636d1821b2c8097b9a98c681b4506f22120df07d89671 | {
"func_code_index": [
585,
664
]
} | 59,096 | |
OperationsVesting | OperationsVesting.sol | 0x916de2259abbfbfd406d7a3ec7cf83a76b9ce3b4 | Solidity | ERC20 | contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
/**
* @dev Total number of tokens in existence
*/
function totalSupply() public view re... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
* Originally based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | totalSupply | function totalSupply() public view returns (uint256) {
return _totalSupply;
}
| /**
* @dev Total number of tokens in existence
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://bfed3f4f551267dc5f0636d1821b2c8097b9a98c681b4506f22120df07d89671 | {
"func_code_index": [
281,
369
]
} | 59,097 | |
OperationsVesting | OperationsVesting.sol | 0x916de2259abbfbfd406d7a3ec7cf83a76b9ce3b4 | Solidity | ERC20 | contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
/**
* @dev Total number of tokens in existence
*/
function totalSupply() public view re... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
* Originally based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | balanceOf | function balanceOf(address owner) public view returns (uint256) {
return _balances[owner];
}
| /**
* @dev Gets the balance of the specified address.
* @param owner The address to query the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://bfed3f4f551267dc5f0636d1821b2c8097b9a98c681b4506f22120df07d89671 | {
"func_code_index": [
570,
673
]
} | 59,098 | |
OperationsVesting | OperationsVesting.sol | 0x916de2259abbfbfd406d7a3ec7cf83a76b9ce3b4 | Solidity | ERC20 | contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
/**
* @dev Total number of tokens in existence
*/
function totalSupply() public view re... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
* Originally based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | allowance | function allowance(
address owner,
address spender
)
public
view
returns (uint256)
{
return _allowed[owner][spender];
}
| /**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param owner address The address which owns the funds.
* @param spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://bfed3f4f551267dc5f0636d1821b2c8097b9a98c681b4506f22120df07d89671 | {
"func_code_index": [
995,
1157
]
} | 59,099 | |
OperationsVesting | OperationsVesting.sol | 0x916de2259abbfbfd406d7a3ec7cf83a76b9ce3b4 | Solidity | ERC20 | contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
/**
* @dev Total number of tokens in existence
*/
function totalSupply() public view re... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
* Originally based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | transfer | function transfer(address to, uint256 value) public returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
| /**
* @dev Transfer token for a specified address
* @param to The address to transfer to.
* @param value The amount to be transferred.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://bfed3f4f551267dc5f0636d1821b2c8097b9a98c681b4506f22120df07d89671 | {
"func_code_index": [
1313,
1446
]
} | 59,100 | |
OperationsVesting | OperationsVesting.sol | 0x916de2259abbfbfd406d7a3ec7cf83a76b9ce3b4 | Solidity | ERC20 | contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
/**
* @dev Total number of tokens in existence
*/
function totalSupply() public view re... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
* Originally based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | approve | function approve(address spender, uint256 value) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
| /**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
* Beware that changing an allowance with this method brings the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
* race... | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://bfed3f4f551267dc5f0636d1821b2c8097b9a98c681b4506f22120df07d89671 | {
"func_code_index": [
2070,
2299
]
} | 59,101 | |
OperationsVesting | OperationsVesting.sol | 0x916de2259abbfbfd406d7a3ec7cf83a76b9ce3b4 | Solidity | ERC20 | contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
/**
* @dev Total number of tokens in existence
*/
function totalSupply() public view re... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
* Originally based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | transferFrom | function transferFrom(
address from,
address to,
uint256 value
)
public
returns (bool)
{
require(value <= _allowed[from][msg.sender]);
_allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value);
_transfer(from, to, value);
return true;
}
| /**
* @dev Transfer tokens from one address to another
* @param from address The address which you want to send tokens from
* @param to address The address which you want to transfer to
* @param value uint256 the amount of tokens to be transferred
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://bfed3f4f551267dc5f0636d1821b2c8097b9a98c681b4506f22120df07d89671 | {
"func_code_index": [
2576,
2880
]
} | 59,102 | |
OperationsVesting | OperationsVesting.sol | 0x916de2259abbfbfd406d7a3ec7cf83a76b9ce3b4 | Solidity | ERC20 | contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
/**
* @dev Total number of tokens in existence
*/
function totalSupply() public view re... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
* Originally based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | increaseAllowance | function increaseAllowance(
address spender,
uint256 addedValue
)
public
returns (bool)
{
require(spender != address(0));
_allowed[msg.sender][spender] = (
_allowed[msg.sender][spender].add(addedValue));
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
... | /**
* @dev Increase the amount of tokens that an owner allowed to a spender.
* approve should be called when allowed_[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param spender T... | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://bfed3f4f551267dc5f0636d1821b2c8097b9a98c681b4506f22120df07d89671 | {
"func_code_index": [
3339,
3685
]
} | 59,103 | |
OperationsVesting | OperationsVesting.sol | 0x916de2259abbfbfd406d7a3ec7cf83a76b9ce3b4 | Solidity | ERC20 | contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
/**
* @dev Total number of tokens in existence
*/
function totalSupply() public view re... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
* Originally based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | decreaseAllowance | function decreaseAllowance(
address spender,
uint256 subtractedValue
)
public
returns (bool)
{
require(spender != address(0));
_allowed[msg.sender][spender] = (
_allowed[msg.sender][spender].sub(subtractedValue));
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return... | /**
* @dev Decrease the amount of tokens that an owner allowed to a spender.
* approve should be called when allowed_[_spender] == 0. To decrement
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param spender T... | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://bfed3f4f551267dc5f0636d1821b2c8097b9a98c681b4506f22120df07d89671 | {
"func_code_index": [
4149,
4505
]
} | 59,104 | |
OperationsVesting | OperationsVesting.sol | 0x916de2259abbfbfd406d7a3ec7cf83a76b9ce3b4 | Solidity | ERC20 | contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
/**
* @dev Total number of tokens in existence
*/
function totalSupply() public view re... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
* Originally based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | _transfer | function _transfer(address from, address to, uint256 value) internal {
require(value <= _balances[from]);
require(to != address(0));
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
}
| /**
* @dev Transfer token for a specified addresses
* @param from The address to transfer from.
* @param to The address to transfer to.
* @param value The amount to be transferred.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://bfed3f4f551267dc5f0636d1821b2c8097b9a98c681b4506f22120df07d89671 | {
"func_code_index": [
4710,
4997
]
} | 59,105 | |
OperationsVesting | OperationsVesting.sol | 0x916de2259abbfbfd406d7a3ec7cf83a76b9ce3b4 | Solidity | ERC20 | contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
/**
* @dev Total number of tokens in existence
*/
function totalSupply() public view re... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
* Originally based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | _mint | function _mint(address account, uint256 value) internal {
require(account != 0);
_totalSupply = _totalSupply.add(value);
_balances[account] = _balances[account].add(value);
emit Transfer(address(0), account, value);
}
| /**
* @dev Internal function that mints an amount of the token and assigns it to
* an account. This encapsulates the modification of balances such that the
* proper events are emitted.
* @param account The account that will receive the created tokens.
* @param value The amount that will be created.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://bfed3f4f551267dc5f0636d1821b2c8097b9a98c681b4506f22120df07d89671 | {
"func_code_index": [
5330,
5573
]
} | 59,106 | |
OperationsVesting | OperationsVesting.sol | 0x916de2259abbfbfd406d7a3ec7cf83a76b9ce3b4 | Solidity | ERC20 | contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
/**
* @dev Total number of tokens in existence
*/
function totalSupply() public view re... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
* Originally based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | _burn | function _burn(address account, uint256 value) internal {
require(account != 0);
require(value <= _balances[account]);
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
| /**
* @dev Internal function that burns an amount of the token of a given
* account.
* @param account The account whose tokens will be burnt.
* @param value The amount that will be burnt.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://bfed3f4f551267dc5f0636d1821b2c8097b9a98c681b4506f22120df07d89671 | {
"func_code_index": [
5790,
6078
]
} | 59,107 | |
OperationsVesting | OperationsVesting.sol | 0x916de2259abbfbfd406d7a3ec7cf83a76b9ce3b4 | Solidity | ERC20 | contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
/**
* @dev Total number of tokens in existence
*/
function totalSupply() public view re... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
* Originally based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | _burnFrom | function _burnFrom(address account, uint256 value) internal {
require(value <= _allowed[account][msg.sender]);
// Should https://github.com/OpenZeppelin/zeppelin-solidity/issues/707 be accepted,
// this function needs to emit an event with the updated approval.
_allowed[account][msg.sender] = _allowed[acc... | /**
* @dev Internal function that burns an amount of the token of a given
* account, deducting from the sender's allowance for said account. Uses the
* internal burn function.
* @param account The account whose tokens will be burnt.
* @param value The amount that will be burnt.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://bfed3f4f551267dc5f0636d1821b2c8097b9a98c681b4506f22120df07d89671 | {
"func_code_index": [
6390,
6791
]
} | 59,108 | |
OperationsVesting | OperationsVesting.sol | 0x916de2259abbfbfd406d7a3ec7cf83a76b9ce3b4 | Solidity | Roles | library Roles {
struct Role {
mapping (address => bool) bearer;
}
/**
* @dev give an account access to this role
*/
function add(Role storage role, address account) internal {
require(account != address(0));
require(!has(role, account));
role.bearer[account] = true;
}
... | /**
* @title Roles
* @dev Library for managing addresses assigned to a Role.
*/ | NatSpecMultiLine | add | function add(Role storage role, address account) internal {
require(account != address(0));
require(!has(role, account));
role.bearer[account] = true;
}
| /**
* @dev give an account access to this role
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://bfed3f4f551267dc5f0636d1821b2c8097b9a98c681b4506f22120df07d89671 | {
"func_code_index": [
141,
316
]
} | 59,109 | |
OperationsVesting | OperationsVesting.sol | 0x916de2259abbfbfd406d7a3ec7cf83a76b9ce3b4 | Solidity | Roles | library Roles {
struct Role {
mapping (address => bool) bearer;
}
/**
* @dev give an account access to this role
*/
function add(Role storage role, address account) internal {
require(account != address(0));
require(!has(role, account));
role.bearer[account] = true;
}
... | /**
* @title Roles
* @dev Library for managing addresses assigned to a Role.
*/ | NatSpecMultiLine | remove | function remove(Role storage role, address account) internal {
require(account != address(0));
require(has(role, account));
role.bearer[account] = false;
}
| /**
* @dev remove an account's access to this role
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://bfed3f4f551267dc5f0636d1821b2c8097b9a98c681b4506f22120df07d89671 | {
"func_code_index": [
384,
562
]
} | 59,110 | |
OperationsVesting | OperationsVesting.sol | 0x916de2259abbfbfd406d7a3ec7cf83a76b9ce3b4 | Solidity | Roles | library Roles {
struct Role {
mapping (address => bool) bearer;
}
/**
* @dev give an account access to this role
*/
function add(Role storage role, address account) internal {
require(account != address(0));
require(!has(role, account));
role.bearer[account] = true;
}
... | /**
* @title Roles
* @dev Library for managing addresses assigned to a Role.
*/ | NatSpecMultiLine | has | function has(Role storage role, address account)
internal
view
returns (bool)
{
require(account != address(0));
return role.bearer[account];
}
| /**
* @dev check if an account has this role
* @return bool
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://bfed3f4f551267dc5f0636d1821b2c8097b9a98c681b4506f22120df07d89671 | {
"func_code_index": [
643,
819
]
} | 59,111 | |
OperationsVesting | OperationsVesting.sol | 0x916de2259abbfbfd406d7a3ec7cf83a76b9ce3b4 | Solidity | Pausable | contract Pausable is PauserRole {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor() internal {
_paused = false;
}
/**
* @return true if the contract is paused, false otherwise.
*/
function paused() public view returns(bool) {
... | /**
* @title Pausable
* @dev Base contract which allows children to implement an emergency stop mechanism.
*/ | NatSpecMultiLine | paused | function paused() public view returns(bool) {
return _paused;
}
| /**
* @return true if the contract is paused, false otherwise.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://bfed3f4f551267dc5f0636d1821b2c8097b9a98c681b4506f22120df07d89671 | {
"func_code_index": [
268,
342
]
} | 59,112 | |
OperationsVesting | OperationsVesting.sol | 0x916de2259abbfbfd406d7a3ec7cf83a76b9ce3b4 | Solidity | Pausable | contract Pausable is PauserRole {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor() internal {
_paused = false;
}
/**
* @return true if the contract is paused, false otherwise.
*/
function paused() public view returns(bool) {
... | /**
* @title Pausable
* @dev Base contract which allows children to implement an emergency stop mechanism.
*/ | NatSpecMultiLine | pause | function pause() public onlyPauser whenNotPaused {
_paused = true;
emit Paused(msg.sender);
}
| /**
* @dev called by the owner to pause, triggers stopped state
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://bfed3f4f551267dc5f0636d1821b2c8097b9a98c681b4506f22120df07d89671 | {
"func_code_index": [
753,
862
]
} | 59,113 | |
OperationsVesting | OperationsVesting.sol | 0x916de2259abbfbfd406d7a3ec7cf83a76b9ce3b4 | Solidity | Pausable | contract Pausable is PauserRole {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor() internal {
_paused = false;
}
/**
* @return true if the contract is paused, false otherwise.
*/
function paused() public view returns(bool) {
... | /**
* @title Pausable
* @dev Base contract which allows children to implement an emergency stop mechanism.
*/ | NatSpecMultiLine | unpause | function unpause() public onlyPauser whenPaused {
_paused = false;
emit Unpaused(msg.sender);
}
| /**
* @dev called by the owner to unpause, returns to normal state
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://bfed3f4f551267dc5f0636d1821b2c8097b9a98c681b4506f22120df07d89671 | {
"func_code_index": [
946,
1057
]
} | 59,114 | |
OperationsVesting | OperationsVesting.sol | 0x916de2259abbfbfd406d7a3ec7cf83a76b9ce3b4 | Solidity | ERC20Burnable | contract ERC20Burnable is ERC20 {
/**
* @dev Burns a specific amount of tokens.
* @param value The amount of token to be burned.
*/
function burn(uint256 value) public {
_burn(msg.sender, value);
}
/**
* @dev Burns a specific amount of tokens from the target address and decrements a... | /**
* @title Burnable Token
* @dev Token that can be irreversibly burned (destroyed).
*/ | NatSpecMultiLine | burn | function burn(uint256 value) public {
_burn(msg.sender, value);
}
| /**
* @dev Burns a specific amount of tokens.
* @param value The amount of token to be burned.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://bfed3f4f551267dc5f0636d1821b2c8097b9a98c681b4506f22120df07d89671 | {
"func_code_index": [
150,
226
]
} | 59,115 | |
OperationsVesting | OperationsVesting.sol | 0x916de2259abbfbfd406d7a3ec7cf83a76b9ce3b4 | Solidity | ERC20Burnable | contract ERC20Burnable is ERC20 {
/**
* @dev Burns a specific amount of tokens.
* @param value The amount of token to be burned.
*/
function burn(uint256 value) public {
_burn(msg.sender, value);
}
/**
* @dev Burns a specific amount of tokens from the target address and decrements a... | /**
* @title Burnable Token
* @dev Token that can be irreversibly burned (destroyed).
*/ | NatSpecMultiLine | burnFrom | function burnFrom(address from, uint256 value) public {
_burnFrom(from, value);
}
| /**
* @dev Burns a specific amount of tokens from the target address and decrements allowance
* @param from address The address which you want to send tokens from
* @param value uint256 The amount of token to be burned
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://bfed3f4f551267dc5f0636d1821b2c8097b9a98c681b4506f22120df07d89671 | {
"func_code_index": [
470,
562
]
} | 59,116 | |
OperationsVesting | OperationsVesting.sol | 0x916de2259abbfbfd406d7a3ec7cf83a76b9ce3b4 | Solidity | ERC20Mintable | contract ERC20Mintable is ERC20, MinterRole {
/**
* @dev Function to mint tokens
* @param to The address that will receive the minted tokens.
* @param value The amount of tokens to mint.
* @return A boolean that indicates if the operation was successful.
*/
function mint(
address to,
... | /**
* @title ERC20Mintable
* @dev ERC20 minting logic
*/ | NatSpecMultiLine | mint | function mint(
address to,
uint256 value
)
public
onlyMinter
returns (bool)
{
_mint(to, value);
return true;
}
| /**
* @dev Function to mint tokens
* @param to The address that will receive the minted tokens.
* @param value The amount of tokens to mint.
* @return A boolean that indicates if the operation was successful.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://bfed3f4f551267dc5f0636d1821b2c8097b9a98c681b4506f22120df07d89671 | {
"func_code_index": [
282,
439
]
} | 59,117 | |
OperationsVesting | OperationsVesting.sol | 0x916de2259abbfbfd406d7a3ec7cf83a76b9ce3b4 | Solidity | ERC20Capped | contract ERC20Capped is ERC20Mintable {
uint256 private _cap;
constructor(uint256 cap)
public
{
require(cap > 0);
_cap = cap;
}
/**
* @return the cap for the token minting.
*/
function cap() public view returns(uint256) {
return _cap;
}
function _mint(address ... | /**
* @title Capped token
* @dev Mintable token with a token cap.
*/ | NatSpecMultiLine | cap | function cap() public view returns(uint256) {
return _cap;
}
| /**
* @return the cap for the token minting.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://bfed3f4f551267dc5f0636d1821b2c8097b9a98c681b4506f22120df07d89671 | {
"func_code_index": [
221,
292
]
} | 59,118 | |
OperationsVesting | OperationsVesting.sol | 0x916de2259abbfbfd406d7a3ec7cf83a76b9ce3b4 | Solidity | SgmToken | contract SgmToken is Ownable, ERC20Detailed, ERC20Pausable, ERC20Burnable, ERC20Mintable, ERC20Capped {
using SafeERC20 for ERC20;
/**
* @dev Constructor
* @param name Name of the token to be created
* @param symbol Symbol of the token to be created
* @param decimals Decimals of the ... | /**
* @title Sgame token
* @author Validity Labs AG <info@validitylabs.org>
*/ | NatSpecMultiLine | reclaimToken | function reclaimToken(ERC20 recoveredToken) public onlyOwner {
uint256 balance = recoveredToken.balanceOf(address(this));
recoveredToken.safeTransfer(owner(), balance);
}
| /**
* @dev Reclaim all ERC20 compatible tokens accidentally sent to the SGM token contract
* @param recoveredToken ERC20 The address of the token contract
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://bfed3f4f551267dc5f0636d1821b2c8097b9a98c681b4506f22120df07d89671 | {
"func_code_index": [
858,
1056
]
} | 59,119 | |
OperationsVesting | OperationsVesting.sol | 0x916de2259abbfbfd406d7a3ec7cf83a76b9ce3b4 | Solidity | SgmToken | contract SgmToken is Ownable, ERC20Detailed, ERC20Pausable, ERC20Burnable, ERC20Mintable, ERC20Capped {
using SafeERC20 for ERC20;
/**
* @dev Constructor
* @param name Name of the token to be created
* @param symbol Symbol of the token to be created
* @param decimals Decimals of the ... | /**
* @title Sgame token
* @author Validity Labs AG <info@validitylabs.org>
*/ | NatSpecMultiLine | roleSetup | function roleSetup(address newOwner) internal {
addPauser(newOwner);
_removePauser(msg.sender);
addMinter(newOwner);
_removeMinter(msg.sender);
}
| /**
* @dev setup roles for new Sgame token
* @param newOwner address of the client owner
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://bfed3f4f551267dc5f0636d1821b2c8097b9a98c681b4506f22120df07d89671 | {
"func_code_index": [
1174,
1367
]
} | 59,120 | |
OperationsVesting | OperationsVesting.sol | 0x916de2259abbfbfd406d7a3ec7cf83a76b9ce3b4 | Solidity | OperationsVesting | contract OperationsVesting is Ownable {
using SafeMath for uint256;
using SafeERC20 for ERC20;
uint256 private constant DECIMAL_FACTOR = 10**uint256(18);
uint256 private constant CLIFF_DURATION = 30 days; // period after which the tokens will start to vest
uint256 private constant DURATION =... | /**
* @title OperationsVesting
* @dev Contract to hold tokens which will be realeased once they have vested
* 10% of total balance will be realeased after the start of the vesting period
* 90% of total balance will vest continuously until start + duration. By then all
* of the balance will have vested
* @au... | NatSpecMultiLine | duration | function duration() public view returns (uint256) {
return DURATION;
}
| /**
* @return the duration of the token vesting
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://bfed3f4f551267dc5f0636d1821b2c8097b9a98c681b4506f22120df07d89671 | {
"func_code_index": [
1541,
1630
]
} | 59,121 | |
OperationsVesting | OperationsVesting.sol | 0x916de2259abbfbfd406d7a3ec7cf83a76b9ce3b4 | Solidity | OperationsVesting | contract OperationsVesting is Ownable {
using SafeMath for uint256;
using SafeERC20 for ERC20;
uint256 private constant DECIMAL_FACTOR = 10**uint256(18);
uint256 private constant CLIFF_DURATION = 30 days; // period after which the tokens will start to vest
uint256 private constant DURATION =... | /**
* @title OperationsVesting
* @dev Contract to hold tokens which will be realeased once they have vested
* 10% of total balance will be realeased after the start of the vesting period
* 90% of total balance will vest continuously until start + duration. By then all
* of the balance will have vested
* @au... | NatSpecMultiLine | beneficiary | function beneficiary() public view returns (address) {
return _beneficiary;
}
| /**
* @return the beneficiary of the tokens
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://bfed3f4f551267dc5f0636d1821b2c8097b9a98c681b4506f22120df07d89671 | {
"func_code_index": [
1697,
1793
]
} | 59,122 | |
OperationsVesting | OperationsVesting.sol | 0x916de2259abbfbfd406d7a3ec7cf83a76b9ce3b4 | Solidity | OperationsVesting | contract OperationsVesting is Ownable {
using SafeMath for uint256;
using SafeERC20 for ERC20;
uint256 private constant DECIMAL_FACTOR = 10**uint256(18);
uint256 private constant CLIFF_DURATION = 30 days; // period after which the tokens will start to vest
uint256 private constant DURATION =... | /**
* @title OperationsVesting
* @dev Contract to hold tokens which will be realeased once they have vested
* 10% of total balance will be realeased after the start of the vesting period
* 90% of total balance will vest continuously until start + duration. By then all
* of the balance will have vested
* @au... | NatSpecMultiLine | start | function start() public view returns (uint256) {
return _start;
}
| /**
* @return the start time of the token vesting
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://bfed3f4f551267dc5f0636d1821b2c8097b9a98c681b4506f22120df07d89671 | {
"func_code_index": [
1866,
1950
]
} | 59,123 | |
OperationsVesting | OperationsVesting.sol | 0x916de2259abbfbfd406d7a3ec7cf83a76b9ce3b4 | Solidity | OperationsVesting | contract OperationsVesting is Ownable {
using SafeMath for uint256;
using SafeERC20 for ERC20;
uint256 private constant DECIMAL_FACTOR = 10**uint256(18);
uint256 private constant CLIFF_DURATION = 30 days; // period after which the tokens will start to vest
uint256 private constant DURATION =... | /**
* @title OperationsVesting
* @dev Contract to hold tokens which will be realeased once they have vested
* 10% of total balance will be realeased after the start of the vesting period
* 90% of total balance will vest continuously until start + duration. By then all
* of the balance will have vested
* @au... | NatSpecMultiLine | cliff | function cliff() public view returns (uint256) {
return _cliff;
}
| /**
* @return the cliff time of the token vesting
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://bfed3f4f551267dc5f0636d1821b2c8097b9a98c681b4506f22120df07d89671 | {
"func_code_index": [
2023,
2107
]
} | 59,124 | |
OperationsVesting | OperationsVesting.sol | 0x916de2259abbfbfd406d7a3ec7cf83a76b9ce3b4 | Solidity | OperationsVesting | contract OperationsVesting is Ownable {
using SafeMath for uint256;
using SafeERC20 for ERC20;
uint256 private constant DECIMAL_FACTOR = 10**uint256(18);
uint256 private constant CLIFF_DURATION = 30 days; // period after which the tokens will start to vest
uint256 private constant DURATION =... | /**
* @title OperationsVesting
* @dev Contract to hold tokens which will be realeased once they have vested
* 10% of total balance will be realeased after the start of the vesting period
* 90% of total balance will vest continuously until start + duration. By then all
* of the balance will have vested
* @au... | NatSpecMultiLine | token | function token() public view returns (ERC20) {
return _token;
}
| /**
* @return the token address of the token vesting
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://bfed3f4f551267dc5f0636d1821b2c8097b9a98c681b4506f22120df07d89671 | {
"func_code_index": [
2183,
2265
]
} | 59,125 | |
OperationsVesting | OperationsVesting.sol | 0x916de2259abbfbfd406d7a3ec7cf83a76b9ce3b4 | Solidity | OperationsVesting | contract OperationsVesting is Ownable {
using SafeMath for uint256;
using SafeERC20 for ERC20;
uint256 private constant DECIMAL_FACTOR = 10**uint256(18);
uint256 private constant CLIFF_DURATION = 30 days; // period after which the tokens will start to vest
uint256 private constant DURATION =... | /**
* @title OperationsVesting
* @dev Contract to hold tokens which will be realeased once they have vested
* 10% of total balance will be realeased after the start of the vesting period
* 90% of total balance will vest continuously until start + duration. By then all
* of the balance will have vested
* @au... | NatSpecMultiLine | released | function released() public view returns (uint256) {
return _released;
}
| /**
* @return the amount of tokens that have been released
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://bfed3f4f551267dc5f0636d1821b2c8097b9a98c681b4506f22120df07d89671 | {
"func_code_index": [
2347,
2437
]
} | 59,126 | |
OperationsVesting | OperationsVesting.sol | 0x916de2259abbfbfd406d7a3ec7cf83a76b9ce3b4 | Solidity | OperationsVesting | contract OperationsVesting is Ownable {
using SafeMath for uint256;
using SafeERC20 for ERC20;
uint256 private constant DECIMAL_FACTOR = 10**uint256(18);
uint256 private constant CLIFF_DURATION = 30 days; // period after which the tokens will start to vest
uint256 private constant DURATION =... | /**
* @title OperationsVesting
* @dev Contract to hold tokens which will be realeased once they have vested
* 10% of total balance will be realeased after the start of the vesting period
* 90% of total balance will vest continuously until start + duration. By then all
* of the balance will have vested
* @au... | NatSpecMultiLine | reclaimToken | function reclaimToken(ERC20 recoveredToken) public onlyOwner {
uint256 balance = recoveredToken.balanceOf(address(this));
uint256 lockedBalance;
uint256 recoveredBalance;
// if SGM tokens are sent by mistake to this contract
if (recoveredToken == _token) {
lockedBalance = ALLOCATION.su... | /**
* @dev Reclaim all ERC20 compatible tokens accidentally sent to the SGM token contract
* @param recoveredToken ERC20 The address of the token contract
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://bfed3f4f551267dc5f0636d1821b2c8097b9a98c681b4506f22120df07d89671 | {
"func_code_index": [
2621,
3122
]
} | 59,127 | |
OperationsVesting | OperationsVesting.sol | 0x916de2259abbfbfd406d7a3ec7cf83a76b9ce3b4 | Solidity | OperationsVesting | contract OperationsVesting is Ownable {
using SafeMath for uint256;
using SafeERC20 for ERC20;
uint256 private constant DECIMAL_FACTOR = 10**uint256(18);
uint256 private constant CLIFF_DURATION = 30 days; // period after which the tokens will start to vest
uint256 private constant DURATION =... | /**
* @title OperationsVesting
* @dev Contract to hold tokens which will be realeased once they have vested
* 10% of total balance will be realeased after the start of the vesting period
* 90% of total balance will vest continuously until start + duration. By then all
* of the balance will have vested
* @au... | NatSpecMultiLine | release | function release() public {
uint256 unreleased = releasableAmount();
require(unreleased > 0);
_released = _released.add(unreleased);
_token.safeTransfer(_beneficiary, unreleased);
}
| /**
* @dev Allows the caller to transfer vested tokens to the company's wallet
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://bfed3f4f551267dc5f0636d1821b2c8097b9a98c681b4506f22120df07d89671 | {
"func_code_index": [
3224,
3453
]
} | 59,128 | |
OperationsVesting | OperationsVesting.sol | 0x916de2259abbfbfd406d7a3ec7cf83a76b9ce3b4 | Solidity | OperationsVesting | contract OperationsVesting is Ownable {
using SafeMath for uint256;
using SafeERC20 for ERC20;
uint256 private constant DECIMAL_FACTOR = 10**uint256(18);
uint256 private constant CLIFF_DURATION = 30 days; // period after which the tokens will start to vest
uint256 private constant DURATION =... | /**
* @title OperationsVesting
* @dev Contract to hold tokens which will be realeased once they have vested
* 10% of total balance will be realeased after the start of the vesting period
* 90% of total balance will vest continuously until start + duration. By then all
* of the balance will have vested
* @au... | NatSpecMultiLine | releasableAmount | function releasableAmount() private view returns (uint256) {
return vestedAmount().sub(_released);
}
| /**
* @dev Calculates the amount that has already vested but hasn't been released yet
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://bfed3f4f551267dc5f0636d1821b2c8097b9a98c681b4506f22120df07d89671 | {
"func_code_index": [
3562,
3681
]
} | 59,129 | |
OperationsVesting | OperationsVesting.sol | 0x916de2259abbfbfd406d7a3ec7cf83a76b9ce3b4 | Solidity | OperationsVesting | contract OperationsVesting is Ownable {
using SafeMath for uint256;
using SafeERC20 for ERC20;
uint256 private constant DECIMAL_FACTOR = 10**uint256(18);
uint256 private constant CLIFF_DURATION = 30 days; // period after which the tokens will start to vest
uint256 private constant DURATION =... | /**
* @title OperationsVesting
* @dev Contract to hold tokens which will be realeased once they have vested
* 10% of total balance will be realeased after the start of the vesting period
* 90% of total balance will vest continuously until start + duration. By then all
* of the balance will have vested
* @au... | NatSpecMultiLine | vestedAmount | function vestedAmount() private view returns (uint256) {
uint256 vested = 0;
if (block.timestamp >= _start) {
// after start, release 10% of the allocation
vested = ALLOCATION.mul(FIRST_RELEASE_PERCENTAGE).div(D_RELEASE);
}
if (block.timestamp >= _cliff && block.timestamp < _star... | /**
* @dev Calculates the amount that has already vested.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://bfed3f4f551267dc5f0636d1821b2c8097b9a98c681b4506f22120df07d89671 | {
"func_code_index": [
3762,
4522
]
} | 59,130 | |
BlockchainMindToken | BlockchainMindToken.sol | 0x9620366a3e732f484b2dc63103bb0eef0dde1f33 | 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 ... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | 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.7.5+commit.eb77ed08 | MIT | ipfs://fd582fefc7c48cf20da441eaac33242399adbcbd93e2ed7836df9506ad6125e6 | {
"func_code_index": [
259,
445
]
} | 59,131 |
BlockchainMindToken | BlockchainMindToken.sol | 0x9620366a3e732f484b2dc63103bb0eef0dde1f33 | 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 ... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | 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.7.5+commit.eb77ed08 | MIT | ipfs://fd582fefc7c48cf20da441eaac33242399adbcbd93e2ed7836df9506ad6125e6 | {
"func_code_index": [
723,
864
]
} | 59,132 |
BlockchainMindToken | BlockchainMindToken.sol | 0x9620366a3e732f484b2dc63103bb0eef0dde1f33 | 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 ... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | 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.7.5+commit.eb77ed08 | MIT | ipfs://fd582fefc7c48cf20da441eaac33242399adbcbd93e2ed7836df9506ad6125e6 | {
"func_code_index": [
1162,
1359
]
} | 59,133 |
BlockchainMindToken | BlockchainMindToken.sol | 0x9620366a3e732f484b2dc63103bb0eef0dde1f33 | 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 ... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | 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;
... | /**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/ | NatSpecMultiLine | v0.7.5+commit.eb77ed08 | MIT | ipfs://fd582fefc7c48cf20da441eaac33242399adbcbd93e2ed7836df9506ad6125e6 | {
"func_code_index": [
1613,
2089
]
} | 59,134 |
BlockchainMindToken | BlockchainMindToken.sol | 0x9620366a3e732f484b2dc63103bb0eef0dde1f33 | 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 ... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | 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 reve... | NatSpecMultiLine | v0.7.5+commit.eb77ed08 | MIT | ipfs://fd582fefc7c48cf20da441eaac33242399adbcbd93e2ed7836df9506ad6125e6 | {
"func_code_index": [
2560,
2697
]
} | 59,135 |
BlockchainMindToken | BlockchainMindToken.sol | 0x9620366a3e732f484b2dc63103bb0eef0dde1f33 | 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 ... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | 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 in... | NatSpecMultiLine | v0.7.5+commit.eb77ed08 | MIT | ipfs://fd582fefc7c48cf20da441eaac33242399adbcbd93e2ed7836df9506ad6125e6 | {
"func_code_index": [
3188,
3471
]
} | 59,136 |
BlockchainMindToken | BlockchainMindToken.sol | 0x9620366a3e732f484b2dc63103bb0eef0dde1f33 | 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 ... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | 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 (consumi... | NatSpecMultiLine | v0.7.5+commit.eb77ed08 | MIT | ipfs://fd582fefc7c48cf20da441eaac33242399adbcbd93e2ed7836df9506ad6125e6 | {
"func_code_index": [
3931,
4066
]
} | 59,137 |
BlockchainMindToken | BlockchainMindToken.sol | 0x9620366a3e732f484b2dc63103bb0eef0dde1f33 | 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 ... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | 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 opcod... | NatSpecMultiLine | v0.7.5+commit.eb77ed08 | MIT | ipfs://fd582fefc7c48cf20da441eaac33242399adbcbd93e2ed7836df9506ad6125e6 | {
"func_code_index": [
4546,
4717
]
} | 59,138 |
BlockchainMindToken | BlockchainMindToken.sol | 0x9620366a3e732f484b2dc63103bb0eef0dde1f33 | 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 Interface of the ERC20 standard as defined in the EIP.
*/ | NatSpecMultiLine | totalSupply | function totalSupply() external view returns (uint256);
| /**
* @dev Returns the amount of tokens in existence.
*/ | NatSpecMultiLine | v0.7.5+commit.eb77ed08 | MIT | ipfs://fd582fefc7c48cf20da441eaac33242399adbcbd93e2ed7836df9506ad6125e6 | {
"func_code_index": [
94,
154
]
} | 59,139 |
BlockchainMindToken | BlockchainMindToken.sol | 0x9620366a3e732f484b2dc63103bb0eef0dde1f33 | 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 Interface of the ERC20 standard as defined in the EIP.
*/ | NatSpecMultiLine | balanceOf | function balanceOf(address account) external view returns (uint256);
| /**
* @dev Returns the amount of tokens owned by `account`.
*/ | NatSpecMultiLine | v0.7.5+commit.eb77ed08 | MIT | ipfs://fd582fefc7c48cf20da441eaac33242399adbcbd93e2ed7836df9506ad6125e6 | {
"func_code_index": [
237,
310
]
} | 59,140 |
BlockchainMindToken | BlockchainMindToken.sol | 0x9620366a3e732f484b2dc63103bb0eef0dde1f33 | 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 Interface of the ERC20 standard as defined in the EIP.
*/ | NatSpecMultiLine | 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.
*
* Emits a {Transfer} event.
*/ | NatSpecMultiLine | v0.7.5+commit.eb77ed08 | MIT | ipfs://fd582fefc7c48cf20da441eaac33242399adbcbd93e2ed7836df9506ad6125e6 | {
"func_code_index": [
534,
616
]
} | 59,141 |
BlockchainMindToken | BlockchainMindToken.sol | 0x9620366a3e732f484b2dc63103bb0eef0dde1f33 | 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 Interface of the ERC20 standard as defined in the EIP.
*/ | NatSpecMultiLine | 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.7.5+commit.eb77ed08 | MIT | ipfs://fd582fefc7c48cf20da441eaac33242399adbcbd93e2ed7836df9506ad6125e6 | {
"func_code_index": [
895,
983
]
} | 59,142 |
BlockchainMindToken | BlockchainMindToken.sol | 0x9620366a3e732f484b2dc63103bb0eef0dde1f33 | 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 Interface of the ERC20 standard as defined in the EIP.
*/ | NatSpecMultiLine | 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
... | NatSpecMultiLine | v0.7.5+commit.eb77ed08 | MIT | ipfs://fd582fefc7c48cf20da441eaac33242399adbcbd93e2ed7836df9506ad6125e6 | {
"func_code_index": [
1647,
1726
]
} | 59,143 |
BlockchainMindToken | BlockchainMindToken.sol | 0x9620366a3e732f484b2dc63103bb0eef0dde1f33 | 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 Interface of the ERC20 standard as defined in the EIP.
*/ | NatSpecMultiLine | 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.7.5+commit.eb77ed08 | MIT | ipfs://fd582fefc7c48cf20da441eaac33242399adbcbd93e2ed7836df9506ad6125e6 | {
"func_code_index": [
2039,
2141
]
} | 59,144 |
BlockchainMindToken | BlockchainMindToken.sol | 0x9620366a3e732f484b2dc63103bb0eef0dde1f33 | Solidity | ERC20 | contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _dec... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our... | NatSpecMultiLine | name | function name() public view returns (string memory) {
return _name;
}
| /**
* @dev Returns the name of the token.
*/ | NatSpecMultiLine | v0.7.5+commit.eb77ed08 | MIT | ipfs://fd582fefc7c48cf20da441eaac33242399adbcbd93e2ed7836df9506ad6125e6 | {
"func_code_index": [
874,
962
]
} | 59,145 |
BlockchainMindToken | BlockchainMindToken.sol | 0x9620366a3e732f484b2dc63103bb0eef0dde1f33 | Solidity | ERC20 | contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _dec... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our... | NatSpecMultiLine | symbol | function symbol() public view returns (string memory) {
return _symbol;
}
| /**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/ | NatSpecMultiLine | v0.7.5+commit.eb77ed08 | MIT | ipfs://fd582fefc7c48cf20da441eaac33242399adbcbd93e2ed7836df9506ad6125e6 | {
"func_code_index": [
1076,
1168
]
} | 59,146 |
BlockchainMindToken | BlockchainMindToken.sol | 0x9620366a3e732f484b2dc63103bb0eef0dde1f33 | Solidity | ERC20 | contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _dec... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our... | NatSpecMultiLine | decimals | function decimals() public view returns (uint8) {
return _decimals;
}
| /**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is... | NatSpecMultiLine | v0.7.5+commit.eb77ed08 | MIT | ipfs://fd582fefc7c48cf20da441eaac33242399adbcbd93e2ed7836df9506ad6125e6 | {
"func_code_index": [
1801,
1889
]
} | 59,147 |
BlockchainMindToken | BlockchainMindToken.sol | 0x9620366a3e732f484b2dc63103bb0eef0dde1f33 | Solidity | ERC20 | contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _dec... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our... | NatSpecMultiLine | totalSupply | function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
| /**
* @dev See {IERC20-totalSupply}.
*/ | NatSpecMultiLine | v0.7.5+commit.eb77ed08 | MIT | ipfs://fd582fefc7c48cf20da441eaac33242399adbcbd93e2ed7836df9506ad6125e6 | {
"func_code_index": [
1949,
2054
]
} | 59,148 |
BlockchainMindToken | BlockchainMindToken.sol | 0x9620366a3e732f484b2dc63103bb0eef0dde1f33 | Solidity | ERC20 | contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _dec... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our... | NatSpecMultiLine | balanceOf | function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
| /**
* @dev See {IERC20-balanceOf}.
*/ | NatSpecMultiLine | v0.7.5+commit.eb77ed08 | MIT | ipfs://fd582fefc7c48cf20da441eaac33242399adbcbd93e2ed7836df9506ad6125e6 | {
"func_code_index": [
2112,
2236
]
} | 59,149 |
BlockchainMindToken | BlockchainMindToken.sol | 0x9620366a3e732f484b2dc63103bb0eef0dde1f33 | Solidity | ERC20 | contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _dec... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our... | NatSpecMultiLine | transfer | function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
| /**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/ | NatSpecMultiLine | v0.7.5+commit.eb77ed08 | MIT | ipfs://fd582fefc7c48cf20da441eaac33242399adbcbd93e2ed7836df9506ad6125e6 | {
"func_code_index": [
2444,
2624
]
} | 59,150 |
BlockchainMindToken | BlockchainMindToken.sol | 0x9620366a3e732f484b2dc63103bb0eef0dde1f33 | Solidity | ERC20 | contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _dec... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our... | NatSpecMultiLine | allowance | function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
| /**
* @dev See {IERC20-allowance}.
*/ | NatSpecMultiLine | v0.7.5+commit.eb77ed08 | MIT | ipfs://fd582fefc7c48cf20da441eaac33242399adbcbd93e2ed7836df9506ad6125e6 | {
"func_code_index": [
2682,
2838
]
} | 59,151 |
BlockchainMindToken | BlockchainMindToken.sol | 0x9620366a3e732f484b2dc63103bb0eef0dde1f33 | Solidity | ERC20 | contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _dec... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our... | NatSpecMultiLine | approve | function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
| /**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/ | NatSpecMultiLine | v0.7.5+commit.eb77ed08 | MIT | ipfs://fd582fefc7c48cf20da441eaac33242399adbcbd93e2ed7836df9506ad6125e6 | {
"func_code_index": [
2980,
3154
]
} | 59,152 |
BlockchainMindToken | BlockchainMindToken.sol | 0x9620366a3e732f484b2dc63103bb0eef0dde1f33 | Solidity | ERC20 | contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _dec... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our... | NatSpecMultiLine | transferFrom | function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
| /**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* Requirements:
*
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `... | NatSpecMultiLine | v0.7.5+commit.eb77ed08 | MIT | ipfs://fd582fefc7c48cf20da441eaac33242399adbcbd93e2ed7836df9506ad6125e6 | {
"func_code_index": [
3631,
3957
]
} | 59,153 |
BlockchainMindToken | BlockchainMindToken.sol | 0x9620366a3e732f484b2dc63103bb0eef0dde1f33 | Solidity | ERC20 | contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _dec... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our... | NatSpecMultiLine | increaseAllowance | function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
| /**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` c... | NatSpecMultiLine | v0.7.5+commit.eb77ed08 | MIT | ipfs://fd582fefc7c48cf20da441eaac33242399adbcbd93e2ed7836df9506ad6125e6 | {
"func_code_index": [
4361,
4584
]
} | 59,154 |
BlockchainMindToken | BlockchainMindToken.sol | 0x9620366a3e732f484b2dc63103bb0eef0dde1f33 | Solidity | ERC20 | contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _dec... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our... | NatSpecMultiLine | decreaseAllowance | function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
| /**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` c... | NatSpecMultiLine | v0.7.5+commit.eb77ed08 | MIT | ipfs://fd582fefc7c48cf20da441eaac33242399adbcbd93e2ed7836df9506ad6125e6 | {
"func_code_index": [
5082,
5356
]
} | 59,155 |
BlockchainMindToken | BlockchainMindToken.sol | 0x9620366a3e732f484b2dc63103bb0eef0dde1f33 | Solidity | ERC20 | contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _dec... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our... | NatSpecMultiLine | _transfer | function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sen... | /**
* @dev Moves tokens `amount` from `sender` to `recipient`.
*
* This is internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `sender` cannot be the zero address.
*... | NatSpecMultiLine | v0.7.5+commit.eb77ed08 | MIT | ipfs://fd582fefc7c48cf20da441eaac33242399adbcbd93e2ed7836df9506ad6125e6 | {
"func_code_index": [
5841,
6385
]
} | 59,156 |
BlockchainMindToken | BlockchainMindToken.sol | 0x9620366a3e732f484b2dc63103bb0eef0dde1f33 | Solidity | ERC20 | contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _dec... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our... | NatSpecMultiLine | _mint | function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfe... | /** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements:
*
* - `to` cannot be the zero address.
*/ | NatSpecMultiLine | v0.7.5+commit.eb77ed08 | MIT | ipfs://fd582fefc7c48cf20da441eaac33242399adbcbd93e2ed7836df9506ad6125e6 | {
"func_code_index": [
6662,
7045
]
} | 59,157 |
BlockchainMindToken | BlockchainMindToken.sol | 0x9620366a3e732f484b2dc63103bb0eef0dde1f33 | Solidity | ERC20 | contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _dec... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our... | NatSpecMultiLine | _burn | function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _to... | /**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/ | NatSpecMultiLine | v0.7.5+commit.eb77ed08 | MIT | ipfs://fd582fefc7c48cf20da441eaac33242399adbcbd93e2ed7836df9506ad6125e6 | {
"func_code_index": [
7373,
7796
]
} | 59,158 |
BlockchainMindToken | BlockchainMindToken.sol | 0x9620366a3e732f484b2dc63103bb0eef0dde1f33 | Solidity | ERC20 | contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _dec... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our... | NatSpecMultiLine | _approve | function _approve(address owner, address spender, uint256 amount) internal virtual {
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, amoun... | /**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero a... | NatSpecMultiLine | v0.7.5+commit.eb77ed08 | MIT | ipfs://fd582fefc7c48cf20da441eaac33242399adbcbd93e2ed7836df9506ad6125e6 | {
"func_code_index": [
8229,
8580
]
} | 59,159 |
BlockchainMindToken | BlockchainMindToken.sol | 0x9620366a3e732f484b2dc63103bb0eef0dde1f33 | Solidity | ERC20 | contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _dec... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our... | NatSpecMultiLine | _setupDecimals | function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
| /**
* @dev Sets {decimals} to a value other than the default one of 18.
*
* WARNING: This function should only be called from the constructor. Most
* applications that interact with token contracts will not expect
* {decimals} to ever change, and may work incorrectly if it does.
*/ | NatSpecMultiLine | v0.7.5+commit.eb77ed08 | MIT | ipfs://fd582fefc7c48cf20da441eaac33242399adbcbd93e2ed7836df9506ad6125e6 | {
"func_code_index": [
8907,
9002
]
} | 59,160 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.