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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
InfernoHound | contracts\open-zeppelin-contracts\token\ERC20\ERC20.sol | 0x07bc8d1a87c2b7caa596abce2d5bb41efc475c5c | Solidity | ERC20 | contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
/**
* @dev See `IERC20.totalSupply`.
*/
function totalSupply() pub... | /**
* @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 .
*
* *For a detailed writeup see our guide [How to implement supply
* mechanisms](https://forum.zeppelin... | NatSpecMultiLine | approve | function approve(address spender, uint256 value) public returns (bool) {
_approve(msg.sender, spender, value);
return true;
}
| /**
* @dev See `IERC20.approve`.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/ | NatSpecMultiLine | v0.5.0+commit.1d4f565a | None | bzzr://9ecdd37ddbf1fd1a47e80b496ddd930d0cb6d9bb6d48f04230557fd4727dbcd4 | {
"func_code_index": [
1267,
1420
]
} | 8,100 |
InfernoHound | contracts\open-zeppelin-contracts\token\ERC20\ERC20.sol | 0x07bc8d1a87c2b7caa596abce2d5bb41efc475c5c | Solidity | ERC20 | contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
/**
* @dev See `IERC20.totalSupply`.
*/
function totalSupply() pub... | /**
* @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 .
*
* *For a detailed writeup see our guide [How to implement supply
* mechanisms](https://forum.zeppelin... | NatSpecMultiLine | transferFrom | function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount));
return true;
}
| /**
* @dev See `IERC20.transferFrom`.
*
* Emits an `Approval` event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of `ERC20`;
*
* Requirements:
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `valu... | NatSpecMultiLine | v0.5.0+commit.1d4f565a | None | bzzr://9ecdd37ddbf1fd1a47e80b496ddd930d0cb6d9bb6d48f04230557fd4727dbcd4 | {
"func_code_index": [
1886,
2147
]
} | 8,101 |
InfernoHound | contracts\open-zeppelin-contracts\token\ERC20\ERC20.sol | 0x07bc8d1a87c2b7caa596abce2d5bb41efc475c5c | Solidity | ERC20 | contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
/**
* @dev See `IERC20.totalSupply`.
*/
function totalSupply() pub... | /**
* @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 .
*
* *For a detailed writeup see our guide [How to implement supply
* mechanisms](https://forum.zeppelin... | NatSpecMultiLine | increaseAllowance | function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][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.5.0+commit.1d4f565a | None | bzzr://9ecdd37ddbf1fd1a47e80b496ddd930d0cb6d9bb6d48f04230557fd4727dbcd4 | {
"func_code_index": [
2551,
2762
]
} | 8,102 |
InfernoHound | contracts\open-zeppelin-contracts\token\ERC20\ERC20.sol | 0x07bc8d1a87c2b7caa596abce2d5bb41efc475c5c | Solidity | ERC20 | contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
/**
* @dev See `IERC20.totalSupply`.
*/
function totalSupply() pub... | /**
* @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 .
*
* *For a detailed writeup see our guide [How to implement supply
* mechanisms](https://forum.zeppelin... | NatSpecMultiLine | decreaseAllowance | function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue));
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.5.0+commit.1d4f565a | None | bzzr://9ecdd37ddbf1fd1a47e80b496ddd930d0cb6d9bb6d48f04230557fd4727dbcd4 | {
"func_code_index": [
3260,
3481
]
} | 8,103 |
InfernoHound | contracts\open-zeppelin-contracts\token\ERC20\ERC20.sol | 0x07bc8d1a87c2b7caa596abce2d5bb41efc475c5c | Solidity | ERC20 | contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
/**
* @dev See `IERC20.totalSupply`.
*/
function totalSupply() pub... | /**
* @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 .
*
* *For a detailed writeup see our guide [How to implement supply
* mechanisms](https://forum.zeppelin... | NatSpecMultiLine | _transfer | function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount);
_balances[recipient] ... | /**
* @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.5.0+commit.1d4f565a | None | bzzr://9ecdd37ddbf1fd1a47e80b496ddd930d0cb6d9bb6d48f04230557fd4727dbcd4 | {
"func_code_index": [
3966,
4400
]
} | 8,104 |
InfernoHound | contracts\open-zeppelin-contracts\token\ERC20\ERC20.sol | 0x07bc8d1a87c2b7caa596abce2d5bb41efc475c5c | Solidity | ERC20 | contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
/**
* @dev See `IERC20.totalSupply`.
*/
function totalSupply() pub... | /**
* @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 .
*
* *For a detailed writeup see our guide [How to implement supply
* mechanisms](https://forum.zeppelin... | NatSpecMultiLine | _burn | function _burn(address account, uint256 value) internal {
require(account != address(0), "ERC20: burn from the zero address");
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
| /**
* @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.5.0+commit.1d4f565a | None | bzzr://9ecdd37ddbf1fd1a47e80b496ddd930d0cb6d9bb6d48f04230557fd4727dbcd4 | {
"func_code_index": [
5066,
5377
]
} | 8,105 |
InfernoHound | contracts\open-zeppelin-contracts\token\ERC20\ERC20.sol | 0x07bc8d1a87c2b7caa596abce2d5bb41efc475c5c | Solidity | ERC20 | contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
/**
* @dev See `IERC20.totalSupply`.
*/
function totalSupply() pub... | /**
* @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 .
*
* *For a detailed writeup see our guide [How to implement supply
* mechanisms](https://forum.zeppelin... | NatSpecMultiLine | _approve | function _approve(address owner, address spender, uint256 value) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = value;
emit Approval(owner, spender, value);
}
| /**
* @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.
*
* This is internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an `Approval` event.
*
* Requirements:
*
* - `owner` cannot be the zero... | NatSpecMultiLine | v0.5.0+commit.1d4f565a | None | bzzr://9ecdd37ddbf1fd1a47e80b496ddd930d0cb6d9bb6d48f04230557fd4727dbcd4 | {
"func_code_index": [
5812,
6152
]
} | 8,106 |
InfernoHound | contracts\open-zeppelin-contracts\token\ERC20\ERC20.sol | 0x07bc8d1a87c2b7caa596abce2d5bb41efc475c5c | Solidity | ERC20 | contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
/**
* @dev See `IERC20.totalSupply`.
*/
function totalSupply() pub... | /**
* @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 .
*
* *For a detailed writeup see our guide [How to implement supply
* mechanisms](https://forum.zeppelin... | NatSpecMultiLine | _burnFrom | function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account, msg.sender, _allowances[account][msg.sender].sub(amount));
}
| /**
* @dev Destoys `amount` tokens from `account`.`amount` is then deducted
* from the caller's allowance.
*
* See `_burn` and `_approve`.
*/ | NatSpecMultiLine | v0.5.0+commit.1d4f565a | None | bzzr://9ecdd37ddbf1fd1a47e80b496ddd930d0cb6d9bb6d48f04230557fd4727dbcd4 | {
"func_code_index": [
6332,
6525
]
} | 8,107 |
InfernoHound | contracts\open-zeppelin-contracts\token\ERC20\ERC20.sol | 0x07bc8d1a87c2b7caa596abce2d5bb41efc475c5c | Solidity | InfernoHound | contract InfernoHound is ERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
uint private _totalSupply;
constructor(address frominit) public {
_name = "Inferno Hound | t.me/infernohound";
_symbol = "INFERNO🔥";
_decimals = 18;
_tot... | /**
* @title InfernoHound
* @author
*
* @dev Standard ERC20 token with burning and optional functions implemented.
* For full specification of ERC-20 standard see:
* https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
*/ | NatSpecMultiLine | burn | function burn(uint256 value) public {
_burn(msg.sender, value);
}
| /**
* @dev Burns a specific amount of tokens.
* @param value The amount of lowest token units to be burned.
*/ | NatSpecMultiLine | v0.5.0+commit.1d4f565a | None | bzzr://9ecdd37ddbf1fd1a47e80b496ddd930d0cb6d9bb6d48f04230557fd4727dbcd4 | {
"func_code_index": [
605,
687
]
} | 8,108 |
InfernoHound | contracts\open-zeppelin-contracts\token\ERC20\ERC20.sol | 0x07bc8d1a87c2b7caa596abce2d5bb41efc475c5c | Solidity | InfernoHound | contract InfernoHound is ERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
uint private _totalSupply;
constructor(address frominit) public {
_name = "Inferno Hound | t.me/infernohound";
_symbol = "INFERNO🔥";
_decimals = 18;
_tot... | /**
* @title InfernoHound
* @author
*
* @dev Standard ERC20 token with burning and optional functions implemented.
* For full specification of ERC-20 standard see:
* https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
*/ | NatSpecMultiLine | name | function name() public view returns (string memory) {
return _name;
}
| /**
* @return the name of the token.
*/ | NatSpecMultiLine | v0.5.0+commit.1d4f565a | None | bzzr://9ecdd37ddbf1fd1a47e80b496ddd930d0cb6d9bb6d48f04230557fd4727dbcd4 | {
"func_code_index": [
796,
882
]
} | 8,109 |
InfernoHound | contracts\open-zeppelin-contracts\token\ERC20\ERC20.sol | 0x07bc8d1a87c2b7caa596abce2d5bb41efc475c5c | Solidity | InfernoHound | contract InfernoHound is ERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
uint private _totalSupply;
constructor(address frominit) public {
_name = "Inferno Hound | t.me/infernohound";
_symbol = "INFERNO🔥";
_decimals = 18;
_tot... | /**
* @title InfernoHound
* @author
*
* @dev Standard ERC20 token with burning and optional functions implemented.
* For full specification of ERC-20 standard see:
* https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
*/ | NatSpecMultiLine | symbol | function symbol() public view returns (string memory) {
return _symbol;
}
| /**
* @return the symbol of the token.
*/ | NatSpecMultiLine | v0.5.0+commit.1d4f565a | None | bzzr://9ecdd37ddbf1fd1a47e80b496ddd930d0cb6d9bb6d48f04230557fd4727dbcd4 | {
"func_code_index": [
944,
1034
]
} | 8,110 |
InfernoHound | contracts\open-zeppelin-contracts\token\ERC20\ERC20.sol | 0x07bc8d1a87c2b7caa596abce2d5bb41efc475c5c | Solidity | InfernoHound | contract InfernoHound is ERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
uint private _totalSupply;
constructor(address frominit) public {
_name = "Inferno Hound | t.me/infernohound";
_symbol = "INFERNO🔥";
_decimals = 18;
_tot... | /**
* @title InfernoHound
* @author
*
* @dev Standard ERC20 token with burning and optional functions implemented.
* For full specification of ERC-20 standard see:
* https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
*/ | NatSpecMultiLine | decimals | function decimals() public view returns (uint8) {
return _decimals;
}
| /**
* @return the number of decimals of the token.
*/ | NatSpecMultiLine | v0.5.0+commit.1d4f565a | None | bzzr://9ecdd37ddbf1fd1a47e80b496ddd930d0cb6d9bb6d48f04230557fd4727dbcd4 | {
"func_code_index": [
1108,
1194
]
} | 8,111 |
CFS | CFS.sol | 0x794588c30c7d534b7b3a20e5cbd12d4046afc5fa | 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() public {
owner = msg.se... | /**
* @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 {
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.5.11+commit.c082d0b4 | MIT | bzzr://6afeb1230944c391230563da426616fe42df22f431dba0ea6ca17a82ffff805f | {
"func_code_index": [
673,
870
]
} | 8,112 |
CFS | CFS.sol | 0x794588c30c7d534b7b3a20e5cbd12d4046afc5fa | Solidity | BasicToken | contract BasicToken is ERC20Basic, Ownable {
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.
*/
function transfer(addre... | /**
* @title Basic token
* @dev Basic version of StandardToken, with no allowances.
*/ | NatSpecMultiLine | transfer | function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balanceOf(msg.sender));
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_v... | /**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/ | NatSpecMultiLine | v0.5.11+commit.c082d0b4 | MIT | bzzr://6afeb1230944c391230563da426616fe42df22f431dba0ea6ca17a82ffff805f | {
"func_code_index": [
293,
722
]
} | 8,113 |
CFS | CFS.sol | 0x794588c30c7d534b7b3a20e5cbd12d4046afc5fa | Solidity | BasicToken | contract BasicToken is ERC20Basic, Ownable {
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.
*/
function transfer(addre... | /**
* @title Basic token
* @dev Basic version of StandardToken, with no allowances.
*/ | NatSpecMultiLine | balanceOf | function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
| /**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/ | NatSpecMultiLine | v0.5.11+commit.c082d0b4 | MIT | bzzr://6afeb1230944c391230563da426616fe42df22f431dba0ea6ca17a82ffff805f | {
"func_code_index": [
939,
1059
]
} | 8,114 |
CFS | CFS.sol | 0x794588c30c7d534b7b3a20e5cbd12d4046afc5fa | Solidity | StandardToken | contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer t... | /**
* @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 returns (bool) {
require(_to != address(0));
require(allowed[_from][msg.sender] >= _value);
require(balanceOf(_from) >= _value);
require(balances[_to].add(_value) > balances[_to]); // Check for overflows
balances[_from] = ... | /**
* @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.5.11+commit.c082d0b4 | MIT | bzzr://6afeb1230944c391230563da426616fe42df22f431dba0ea6ca17a82ffff805f | {
"func_code_index": [
399,
975
]
} | 8,115 |
CFS | CFS.sol | 0x794588c30c7d534b7b3a20e5cbd12d4046afc5fa | Solidity | StandardToken | contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer t... | /**
* @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 returns (bool) {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/... | /**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/ | NatSpecMultiLine | v0.5.11+commit.c082d0b4 | MIT | bzzr://6afeb1230944c391230563da426616fe42df22f431dba0ea6ca17a82ffff805f | {
"func_code_index": [
1217,
1809
]
} | 8,116 |
CFS | CFS.sol | 0x794588c30c7d534b7b3a20e5cbd12d4046afc5fa | Solidity | StandardToken | contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer t... | /**
* @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 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.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/ | NatSpecMultiLine | v0.5.11+commit.c082d0b4 | MIT | bzzr://6afeb1230944c391230563da426616fe42df22f431dba0ea6ca17a82ffff805f | {
"func_code_index": [
2140,
2289
]
} | 8,117 |
CFS | CFS.sol | 0x794588c30c7d534b7b3a20e5cbd12d4046afc5fa | Solidity | StandardToken | contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer t... | /**
* @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.5.11+commit.c082d0b4 | MIT | bzzr://6afeb1230944c391230563da426616fe42df22f431dba0ea6ca17a82ffff805f | {
"func_code_index": [
2542,
2836
]
} | 8,118 |
CFS | CFS.sol | 0x794588c30c7d534b7b3a20e5cbd12d4046afc5fa | Solidity | Pausable | contract Pausable is StandardToken {
event Pause();
event Unpause();
bool public paused = false;
address public founder;
/**
* @dev modifier to allow actions only when the contract IS paused
*/
modifier whenNotPaused() {
require(!paused || msg.sender == founder... | /**
* @title Pausable
* @dev Base contract which allows children to implement an emergency stop mechanism.
*/ | NatSpecMultiLine | pause | function pause() public onlyOwner whenNotPaused {
paused = true;
emit Pause();
}
| /**
* @dev called by the owner to pause, triggers stopped state
*/ | NatSpecMultiLine | v0.5.11+commit.c082d0b4 | MIT | bzzr://6afeb1230944c391230563da426616fe42df22f431dba0ea6ca17a82ffff805f | {
"func_code_index": [
595,
703
]
} | 8,119 |
CFS | CFS.sol | 0x794588c30c7d534b7b3a20e5cbd12d4046afc5fa | Solidity | Pausable | contract Pausable is StandardToken {
event Pause();
event Unpause();
bool public paused = false;
address public founder;
/**
* @dev modifier to allow actions only when the contract IS paused
*/
modifier whenNotPaused() {
require(!paused || msg.sender == founder... | /**
* @title Pausable
* @dev Base contract which allows children to implement an emergency stop mechanism.
*/ | NatSpecMultiLine | unpause | function unpause() public onlyOwner whenPaused {
paused = false;
emit Unpause();
}
| /**
* @dev called by the owner to unpause, returns to normal state
*/ | NatSpecMultiLine | v0.5.11+commit.c082d0b4 | MIT | bzzr://6afeb1230944c391230563da426616fe42df22f431dba0ea6ca17a82ffff805f | {
"func_code_index": [
791,
901
]
} | 8,120 |
CFS | CFS.sol | 0x794588c30c7d534b7b3a20e5cbd12d4046afc5fa | Solidity | PausableToken | contract PausableToken is Pausable {
function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) {
return super.transf... | approve | function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) {
return super.approve(_spender, _value);
}
| //The functions below surve no real purpose. Even if one were to approve another to spend
//tokens on their behalf, those tokens will still only be transferable when the token contract
//is not paused. | LineComment | v0.5.11+commit.c082d0b4 | MIT | bzzr://6afeb1230944c391230563da426616fe42df22f431dba0ea6ca17a82ffff805f | {
"func_code_index": [
577,
726
]
} | 8,121 | ||
CFS | CFS.sol | 0x794588c30c7d534b7b3a20e5cbd12d4046afc5fa | Solidity | CFS | contract CFS is PausableToken {
string public name;
string public symbol;
uint8 public decimals;
/**
* @dev Constructor that gives the founder all of the existing tokens.
*/
constructor() public {
name = "Crowd Funding Society";
symbol = "CFS";
decimals ... | getFrozenBalance | function getFrozenBalance(address _owner) view public returns(uint256) {
return frozenTokenBalances[_owner];
}
| /**
* @dev Gets the amount of tokens which belong to the specified address BUT are frozen now.
* @param _owner The address to query the the balance of.
* @return An uint256 representing the amount of frozen tokens owned by the passed address.
*/ | NatSpecMultiLine | v0.5.11+commit.c082d0b4 | MIT | bzzr://6afeb1230944c391230563da426616fe42df22f431dba0ea6ca17a82ffff805f | {
"func_code_index": [
2610,
2742
]
} | 8,122 | ||
CFS | CFS.sol | 0x794588c30c7d534b7b3a20e5cbd12d4046afc5fa | Solidity | CFS | contract CFS is PausableToken {
string public name;
string public symbol;
uint8 public decimals;
/**
* @dev Constructor that gives the founder all of the existing tokens.
*/
constructor() public {
name = "Crowd Funding Society";
symbol = "CFS";
decimals ... | burnTokens | function burnTokens(uint256 _tokens) public onlyOwner {
require(balanceOf(msg.sender) >= _tokens);
balances[msg.sender] = balances[msg.sender].sub(_tokens);
totalSupply = totalSupply.sub(_tokens);
emit TokensBurned(msg.sender, _tokens);
}
| /*
* @dev Token burn function
* @param _tokens uint256 amount of tokens to burn
*/ | Comment | v0.5.11+commit.c082d0b4 | MIT | bzzr://6afeb1230944c391230563da426616fe42df22f431dba0ea6ca17a82ffff805f | {
"func_code_index": [
2852,
3136
]
} | 8,123 | ||
XelsToken | XelsToken.sol | 0xe748269494e76c1cec3f627bb1e561e607da9161 | Solidity | Token | contract Token {
/**
* Get total number of tokens in circulation.
*
* @return total number of tokens in circulation
*/
function totalSupply () public view returns (uint256 supply);
/**
* Get number of tokens currently belonging to given owner.
*
* @param _owner address to get numb... | /**
* ERC-20 standard token interface, as defined
* <a href="https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md">here</a>.
*/ | NatSpecMultiLine | totalSupply | function totalSupply () public view returns (uint256 supply);
| /**
* Get total number of tokens in circulation.
*
* @return total number of tokens in circulation
*/ | NatSpecMultiLine | v0.4.20+commit.3155dd80 | None | bzzr://1d020d113b53fea9c655cd9d02e7146ad11042635e72ca51f31d140a09846c49 | {
"func_code_index": [
139,
203
]
} | 8,124 |
XelsToken | XelsToken.sol | 0xe748269494e76c1cec3f627bb1e561e607da9161 | Solidity | Token | contract Token {
/**
* Get total number of tokens in circulation.
*
* @return total number of tokens in circulation
*/
function totalSupply () public view returns (uint256 supply);
/**
* Get number of tokens currently belonging to given owner.
*
* @param _owner address to get numb... | /**
* ERC-20 standard token interface, as defined
* <a href="https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md">here</a>.
*/ | NatSpecMultiLine | balanceOf | function balanceOf (address _owner) public view returns (uint256 balance);
| /**
* Get number of tokens currently belonging to given owner.
*
* @param _owner address to get number of tokens currently belonging to the
* owner of
* @return number of tokens currently belonging to the owner of given address
*/ | NatSpecMultiLine | v0.4.20+commit.3155dd80 | None | bzzr://1d020d113b53fea9c655cd9d02e7146ad11042635e72ca51f31d140a09846c49 | {
"func_code_index": [
471,
548
]
} | 8,125 |
XelsToken | XelsToken.sol | 0xe748269494e76c1cec3f627bb1e561e607da9161 | Solidity | Token | contract Token {
/**
* Get total number of tokens in circulation.
*
* @return total number of tokens in circulation
*/
function totalSupply () public view returns (uint256 supply);
/**
* Get number of tokens currently belonging to given owner.
*
* @param _owner address to get numb... | /**
* ERC-20 standard token interface, as defined
* <a href="https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md">here</a>.
*/ | NatSpecMultiLine | transfer | function transfer (address _to, uint256 _value)
public returns (bool success);
| /**
* Transfer given number of tokens from message sender to given recipient.
*
* @param _to address to transfer tokens to the owner of
* @param _value number of tokens to transfer to the owner of given address
* @return true if tokens were transferred successfully, false otherwise
*/ | NatSpecMultiLine | v0.4.20+commit.3155dd80 | None | bzzr://1d020d113b53fea9c655cd9d02e7146ad11042635e72ca51f31d140a09846c49 | {
"func_code_index": [
864,
948
]
} | 8,126 |
XelsToken | XelsToken.sol | 0xe748269494e76c1cec3f627bb1e561e607da9161 | Solidity | Token | contract Token {
/**
* Get total number of tokens in circulation.
*
* @return total number of tokens in circulation
*/
function totalSupply () public view returns (uint256 supply);
/**
* Get number of tokens currently belonging to given owner.
*
* @param _owner address to get numb... | /**
* ERC-20 standard token interface, as defined
* <a href="https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md">here</a>.
*/ | NatSpecMultiLine | transferFrom | function transferFrom (address _from, address _to, uint256 _value)
public returns (bool success);
| /**
* Transfer given number of tokens from given owner to given recipient.
*
* @param _from address to transfer tokens from the owner of
* @param _to address to transfer tokens to the owner of
* @param _value number of tokens to transfer from given owner to given
* recipient
* @return true if token... | NatSpecMultiLine | v0.4.20+commit.3155dd80 | None | bzzr://1d020d113b53fea9c655cd9d02e7146ad11042635e72ca51f31d140a09846c49 | {
"func_code_index": [
1344,
1447
]
} | 8,127 |
XelsToken | XelsToken.sol | 0xe748269494e76c1cec3f627bb1e561e607da9161 | Solidity | Token | contract Token {
/**
* Get total number of tokens in circulation.
*
* @return total number of tokens in circulation
*/
function totalSupply () public view returns (uint256 supply);
/**
* Get number of tokens currently belonging to given owner.
*
* @param _owner address to get numb... | /**
* ERC-20 standard token interface, as defined
* <a href="https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md">here</a>.
*/ | NatSpecMultiLine | approve | function approve (address _spender, uint256 _value)
public returns (bool success);
| /**
* Allow given spender to transfer given number of tokens from message sender.
*
* @param _spender address to allow the owner of to transfer tokens from
* message sender
* @param _value number of tokens to allow to transfer
* @return true if token transfer was successfully approved, false otherwis... | NatSpecMultiLine | v0.4.20+commit.3155dd80 | None | bzzr://1d020d113b53fea9c655cd9d02e7146ad11042635e72ca51f31d140a09846c49 | {
"func_code_index": [
1794,
1882
]
} | 8,128 |
XelsToken | XelsToken.sol | 0xe748269494e76c1cec3f627bb1e561e607da9161 | Solidity | Token | contract Token {
/**
* Get total number of tokens in circulation.
*
* @return total number of tokens in circulation
*/
function totalSupply () public view returns (uint256 supply);
/**
* Get number of tokens currently belonging to given owner.
*
* @param _owner address to get numb... | /**
* ERC-20 standard token interface, as defined
* <a href="https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md">here</a>.
*/ | NatSpecMultiLine | allowance | function allowance (address _owner, address _spender)
public view returns (uint256 remaining);
| /**
* Tell how many tokens given spender is currently allowed to transfer from
* given owner.
*
* @param _owner address to get number of tokens allowed to be transferred
* from the owner of
* @param _spender address to get number of tokens allowed to be transferred
* by the owner of
* @ret... | NatSpecMultiLine | v0.4.20+commit.3155dd80 | None | bzzr://1d020d113b53fea9c655cd9d02e7146ad11042635e72ca51f31d140a09846c49 | {
"func_code_index": [
2330,
2430
]
} | 8,129 |
XelsToken | XelsToken.sol | 0xe748269494e76c1cec3f627bb1e561e607da9161 | Solidity | SafeMath | contract SafeMath {
uint256 constant private MAX_UINT256 =
0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
/**
* Add two uint256 values, throw in case of overflow.
*
* @param x first value to add
* @param y second value to add
* @return x + y
*/
function safeA... | /**
* Provides methods to safely add, subtract and multiply uint256 numbers.
*/ | NatSpecMultiLine | safeAdd | function safeAdd (uint256 x, uint256 y)
pure internal
returns (uint256 z) {
assert (x <= MAX_UINT256 - y);
return x + y;
}
| /**
* Add two uint256 values, throw in case of overflow.
*
* @param x first value to add
* @param y second value to add
* @return x + y
*/ | NatSpecMultiLine | v0.4.20+commit.3155dd80 | None | bzzr://1d020d113b53fea9c655cd9d02e7146ad11042635e72ca51f31d140a09846c49 | {
"func_code_index": [
304,
448
]
} | 8,130 |
XelsToken | XelsToken.sol | 0xe748269494e76c1cec3f627bb1e561e607da9161 | Solidity | SafeMath | contract SafeMath {
uint256 constant private MAX_UINT256 =
0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
/**
* Add two uint256 values, throw in case of overflow.
*
* @param x first value to add
* @param y second value to add
* @return x + y
*/
function safeA... | /**
* Provides methods to safely add, subtract and multiply uint256 numbers.
*/ | NatSpecMultiLine | safeSub | function safeSub (uint256 x, uint256 y)
pure internal
returns (uint256 z) {
assert (x >= y);
return x - y;
}
| /**
* Subtract one uint256 value from another, throw in case of underflow.
*
* @param x value to subtract from
* @param y value to subtract
* @return x - y
*/ | NatSpecMultiLine | v0.4.20+commit.3155dd80 | None | bzzr://1d020d113b53fea9c655cd9d02e7146ad11042635e72ca51f31d140a09846c49 | {
"func_code_index": [
637,
767
]
} | 8,131 |
XelsToken | XelsToken.sol | 0xe748269494e76c1cec3f627bb1e561e607da9161 | Solidity | SafeMath | contract SafeMath {
uint256 constant private MAX_UINT256 =
0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
/**
* Add two uint256 values, throw in case of overflow.
*
* @param x first value to add
* @param y second value to add
* @return x + y
*/
function safeA... | /**
* Provides methods to safely add, subtract and multiply uint256 numbers.
*/ | NatSpecMultiLine | safeMul | function safeMul (uint256 x, uint256 y)
pure internal
returns (uint256 z) {
if (y == 0) return 0; // Prevent division by zero at the next line
assert (x <= MAX_UINT256 / y);
return x * y;
}
| /**
* Multiply two uint256 values, throw in case of overflow.
*
* @param x first value to multiply
* @param y second value to multiply
* @return x * y
*/ | NatSpecMultiLine | v0.4.20+commit.3155dd80 | None | bzzr://1d020d113b53fea9c655cd9d02e7146ad11042635e72ca51f31d140a09846c49 | {
"func_code_index": [
951,
1167
]
} | 8,132 |
XelsToken | XelsToken.sol | 0xe748269494e76c1cec3f627bb1e561e607da9161 | Solidity | AbstractToken | contract AbstractToken is Token, SafeMath {
/**
* Create new Abstract Token contract.
*/
function AbstractToken () public {
// Do nothing
}
/**
* Get number of tokens currently belonging to given owner.
*
* @param _owner address to get number of tokens currently belonging to the
... | /**
* Abstract Token Smart Contract that could be used as a base contract for
* ERC-20 token contracts.
*/ | NatSpecMultiLine | AbstractToken | function AbstractToken () public {
// Do nothing
}
| /**
* Create new Abstract Token contract.
*/ | NatSpecMultiLine | v0.4.20+commit.3155dd80 | None | bzzr://1d020d113b53fea9c655cd9d02e7146ad11042635e72ca51f31d140a09846c49 | {
"func_code_index": [
101,
162
]
} | 8,133 |
XelsToken | XelsToken.sol | 0xe748269494e76c1cec3f627bb1e561e607da9161 | Solidity | AbstractToken | contract AbstractToken is Token, SafeMath {
/**
* Create new Abstract Token contract.
*/
function AbstractToken () public {
// Do nothing
}
/**
* Get number of tokens currently belonging to given owner.
*
* @param _owner address to get number of tokens currently belonging to the
... | /**
* Abstract Token Smart Contract that could be used as a base contract for
* ERC-20 token contracts.
*/ | NatSpecMultiLine | balanceOf | function balanceOf (address _owner) public view returns (uint256 balance) {
return accounts [_owner];
}
| /**
* Get number of tokens currently belonging to given owner.
*
* @param _owner address to get number of tokens currently belonging to the
* owner of
* @return number of tokens currently belonging to the owner of given address
*/ | NatSpecMultiLine | v0.4.20+commit.3155dd80 | None | bzzr://1d020d113b53fea9c655cd9d02e7146ad11042635e72ca51f31d140a09846c49 | {
"func_code_index": [
430,
544
]
} | 8,134 |
XelsToken | XelsToken.sol | 0xe748269494e76c1cec3f627bb1e561e607da9161 | Solidity | AbstractToken | contract AbstractToken is Token, SafeMath {
/**
* Create new Abstract Token contract.
*/
function AbstractToken () public {
// Do nothing
}
/**
* Get number of tokens currently belonging to given owner.
*
* @param _owner address to get number of tokens currently belonging to the
... | /**
* Abstract Token Smart Contract that could be used as a base contract for
* ERC-20 token contracts.
*/ | NatSpecMultiLine | transfer | function transfer (address _to, uint256 _value)
public returns (bool success) {
uint256 fromBalance = accounts [msg.sender];
if (fromBalance < _value) return false;
if (_value > 0 && msg.sender != _to) {
accounts [msg.sender] = safeSub (fromBalance, _value);
accounts [_to] = safeAdd (accounts [_to],... | /**
* Transfer given number of tokens from message sender to given recipient.
*
* @param _to address to transfer tokens to the owner of
* @param _value number of tokens to transfer to the owner of given address
* @return true if tokens were transferred successfully, false otherwise
*/ | NatSpecMultiLine | v0.4.20+commit.3155dd80 | None | bzzr://1d020d113b53fea9c655cd9d02e7146ad11042635e72ca51f31d140a09846c49 | {
"func_code_index": [
860,
1275
]
} | 8,135 |
XelsToken | XelsToken.sol | 0xe748269494e76c1cec3f627bb1e561e607da9161 | Solidity | AbstractToken | contract AbstractToken is Token, SafeMath {
/**
* Create new Abstract Token contract.
*/
function AbstractToken () public {
// Do nothing
}
/**
* Get number of tokens currently belonging to given owner.
*
* @param _owner address to get number of tokens currently belonging to the
... | /**
* Abstract Token Smart Contract that could be used as a base contract for
* ERC-20 token contracts.
*/ | NatSpecMultiLine | transferFrom | function transferFrom (address _from, address _to, uint256 _value)
public returns (bool success) {
uint256 spenderAllowance = allowances [_from][msg.sender];
if (spenderAllowance < _value) return false;
uint256 fromBalance = accounts [_from];
if (fromBalance < _value) return false;
allowances [_from][... | /**
* Transfer given number of tokens from given owner to given recipient.
*
* @param _from address to transfer tokens from the owner of
* @param _to address to transfer tokens to the owner of
* @param _value number of tokens to transfer from given owner to given
* recipient
* @return true if token... | NatSpecMultiLine | v0.4.20+commit.3155dd80 | None | bzzr://1d020d113b53fea9c655cd9d02e7146ad11042635e72ca51f31d140a09846c49 | {
"func_code_index": [
1671,
2284
]
} | 8,136 |
XelsToken | XelsToken.sol | 0xe748269494e76c1cec3f627bb1e561e607da9161 | Solidity | AbstractToken | contract AbstractToken is Token, SafeMath {
/**
* Create new Abstract Token contract.
*/
function AbstractToken () public {
// Do nothing
}
/**
* Get number of tokens currently belonging to given owner.
*
* @param _owner address to get number of tokens currently belonging to the
... | /**
* Abstract Token Smart Contract that could be used as a base contract for
* ERC-20 token contracts.
*/ | NatSpecMultiLine | approve | function approve (address _spender, uint256 _value)
public returns (bool success) {
allowances [msg.sender][_spender] = _value;
Approval (msg.sender, _spender, _value);
return true;
}
| /**
* Allow given spender to transfer given number of tokens from message sender.
*
* @param _spender address to allow the owner of to transfer tokens from
* message sender
* @param _value number of tokens to allow to transfer
* @return true if token transfer was successfully approved, false otherwis... | NatSpecMultiLine | v0.4.20+commit.3155dd80 | None | bzzr://1d020d113b53fea9c655cd9d02e7146ad11042635e72ca51f31d140a09846c49 | {
"func_code_index": [
2631,
2840
]
} | 8,137 |
XelsToken | XelsToken.sol | 0xe748269494e76c1cec3f627bb1e561e607da9161 | Solidity | AbstractToken | contract AbstractToken is Token, SafeMath {
/**
* Create new Abstract Token contract.
*/
function AbstractToken () public {
// Do nothing
}
/**
* Get number of tokens currently belonging to given owner.
*
* @param _owner address to get number of tokens currently belonging to the
... | /**
* Abstract Token Smart Contract that could be used as a base contract for
* ERC-20 token contracts.
*/ | NatSpecMultiLine | allowance | function allowance (address _owner, address _spender)
public view returns (uint256 remaining) {
return allowances [_owner][_spender];
}
| /**
* Tell how many tokens given spender is currently allowed to transfer from
* given owner.
*
* @param _owner address to get number of tokens allowed to be transferred
* from the owner of
* @param _spender address to get number of tokens allowed to be transferred
* by the owner of
* @ret... | NatSpecMultiLine | v0.4.20+commit.3155dd80 | None | bzzr://1d020d113b53fea9c655cd9d02e7146ad11042635e72ca51f31d140a09846c49 | {
"func_code_index": [
3288,
3437
]
} | 8,138 |
XelsToken | XelsToken.sol | 0xe748269494e76c1cec3f627bb1e561e607da9161 | Solidity | XelsToken | contract XelsToken is AbstractToken {
/**
* Maximum allowed number of tokens in circulation.
*/
uint256 constant MAX_TOKEN_COUNT =
0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
/**
* Address of the owner of this smart contract.
*/
address private owner;
/**
... | /**
* Xels Token smart contract.
*/ | NatSpecMultiLine | XelsToken | function XelsToken () public {
owner = msg.sender;
}
| /**
* Create new Xels Token smart contract and make msg.sender the
* owner of this smart contract.
*/ | NatSpecMultiLine | v0.4.20+commit.3155dd80 | None | bzzr://1d020d113b53fea9c655cd9d02e7146ad11042635e72ca51f31d140a09846c49 | {
"func_code_index": [
631,
694
]
} | 8,139 |
XelsToken | XelsToken.sol | 0xe748269494e76c1cec3f627bb1e561e607da9161 | Solidity | XelsToken | contract XelsToken is AbstractToken {
/**
* Maximum allowed number of tokens in circulation.
*/
uint256 constant MAX_TOKEN_COUNT =
0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
/**
* Address of the owner of this smart contract.
*/
address private owner;
/**
... | /**
* Xels Token smart contract.
*/ | NatSpecMultiLine | totalSupply | function totalSupply () public view returns (uint256 supply) {
return tokenCount;
}
| /**
* Get total number of tokens in circulation.
*
* @return total number of tokens in circulation
*/ | NatSpecMultiLine | v0.4.20+commit.3155dd80 | None | bzzr://1d020d113b53fea9c655cd9d02e7146ad11042635e72ca51f31d140a09846c49 | {
"func_code_index": [
818,
912
]
} | 8,140 |
XelsToken | XelsToken.sol | 0xe748269494e76c1cec3f627bb1e561e607da9161 | Solidity | XelsToken | contract XelsToken is AbstractToken {
/**
* Maximum allowed number of tokens in circulation.
*/
uint256 constant MAX_TOKEN_COUNT =
0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
/**
* Address of the owner of this smart contract.
*/
address private owner;
/**
... | /**
* Xels Token smart contract.
*/ | NatSpecMultiLine | name | function name () public pure returns (string result) {
return "Xels Token";
}
| /**
* Get name of this token.
*
* @return name of this token
*/ | NatSpecMultiLine | v0.4.20+commit.3155dd80 | None | bzzr://1d020d113b53fea9c655cd9d02e7146ad11042635e72ca51f31d140a09846c49 | {
"func_code_index": [
998,
1086
]
} | 8,141 |
XelsToken | XelsToken.sol | 0xe748269494e76c1cec3f627bb1e561e607da9161 | Solidity | XelsToken | contract XelsToken is AbstractToken {
/**
* Maximum allowed number of tokens in circulation.
*/
uint256 constant MAX_TOKEN_COUNT =
0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
/**
* Address of the owner of this smart contract.
*/
address private owner;
/**
... | /**
* Xels Token smart contract.
*/ | NatSpecMultiLine | symbol | function symbol () public pure returns (string result) {
return "XELS";
}
| /**
* Get symbol of this token.
*
* @return symbol of this token
*/ | NatSpecMultiLine | v0.4.20+commit.3155dd80 | None | bzzr://1d020d113b53fea9c655cd9d02e7146ad11042635e72ca51f31d140a09846c49 | {
"func_code_index": [
1176,
1260
]
} | 8,142 |
XelsToken | XelsToken.sol | 0xe748269494e76c1cec3f627bb1e561e607da9161 | Solidity | XelsToken | contract XelsToken is AbstractToken {
/**
* Maximum allowed number of tokens in circulation.
*/
uint256 constant MAX_TOKEN_COUNT =
0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
/**
* Address of the owner of this smart contract.
*/
address private owner;
/**
... | /**
* Xels Token smart contract.
*/ | NatSpecMultiLine | decimals | function decimals () public pure returns (uint8 result) {
return 8;
}
| /**
* Get number of decimals for this token.
*
* @return number of decimals for this token
*/ | NatSpecMultiLine | v0.4.20+commit.3155dd80 | None | bzzr://1d020d113b53fea9c655cd9d02e7146ad11042635e72ca51f31d140a09846c49 | {
"func_code_index": [
1376,
1456
]
} | 8,143 |
XelsToken | XelsToken.sol | 0xe748269494e76c1cec3f627bb1e561e607da9161 | Solidity | XelsToken | contract XelsToken is AbstractToken {
/**
* Maximum allowed number of tokens in circulation.
*/
uint256 constant MAX_TOKEN_COUNT =
0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
/**
* Address of the owner of this smart contract.
*/
address private owner;
/**
... | /**
* Xels Token smart contract.
*/ | NatSpecMultiLine | transfer | function transfer (address _to, uint256 _value)
public returns (bool success) {
if (frozen) return false;
else return AbstractToken.transfer (_to, _value);
}
| /**
* Transfer given number of tokens from message sender to given recipient.
*
* @param _to address to transfer tokens to the owner of
* @param _value number of tokens to transfer to the owner of given address
* @return true if tokens were transferred successfully, false otherwise
*/ | NatSpecMultiLine | v0.4.20+commit.3155dd80 | None | bzzr://1d020d113b53fea9c655cd9d02e7146ad11042635e72ca51f31d140a09846c49 | {
"func_code_index": [
1772,
1950
]
} | 8,144 |
XelsToken | XelsToken.sol | 0xe748269494e76c1cec3f627bb1e561e607da9161 | Solidity | XelsToken | contract XelsToken is AbstractToken {
/**
* Maximum allowed number of tokens in circulation.
*/
uint256 constant MAX_TOKEN_COUNT =
0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
/**
* Address of the owner of this smart contract.
*/
address private owner;
/**
... | /**
* Xels Token smart contract.
*/ | NatSpecMultiLine | transferFrom | function transferFrom (address _from, address _to, uint256 _value)
public returns (bool success) {
if (frozen) return false;
else return AbstractToken.transferFrom (_from, _to, _value);
}
| /**
* Transfer given number of tokens from given owner to given recipient.
*
* @param _from address to transfer tokens from the owner of
* @param _to address to transfer tokens to the owner of
* @param _value number of tokens to transfer from given owner to given
* recipient
* @return true if token... | NatSpecMultiLine | v0.4.20+commit.3155dd80 | None | bzzr://1d020d113b53fea9c655cd9d02e7146ad11042635e72ca51f31d140a09846c49 | {
"func_code_index": [
2346,
2554
]
} | 8,145 |
XelsToken | XelsToken.sol | 0xe748269494e76c1cec3f627bb1e561e607da9161 | Solidity | XelsToken | contract XelsToken is AbstractToken {
/**
* Maximum allowed number of tokens in circulation.
*/
uint256 constant MAX_TOKEN_COUNT =
0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
/**
* Address of the owner of this smart contract.
*/
address private owner;
/**
... | /**
* Xels Token smart contract.
*/ | NatSpecMultiLine | approve | function approve (address _spender, uint256 _currentValue, uint256 _newValue)
public returns (bool success) {
if (allowance (msg.sender, _spender) == _currentValue)
return approve (_spender, _newValue);
else return false;
}
| /**
* Change how many tokens given spender is allowed to transfer from message
* spender. In order to prevent double spending of allowance, this method
* receives assumed current allowance value as an argument. If actual
* allowance differs from an assumed one, this method just returns false.
*
* @param _... | NatSpecMultiLine | v0.4.20+commit.3155dd80 | None | bzzr://1d020d113b53fea9c655cd9d02e7146ad11042635e72ca51f31d140a09846c49 | {
"func_code_index": [
3231,
3482
]
} | 8,146 |
XelsToken | XelsToken.sol | 0xe748269494e76c1cec3f627bb1e561e607da9161 | Solidity | XelsToken | contract XelsToken is AbstractToken {
/**
* Maximum allowed number of tokens in circulation.
*/
uint256 constant MAX_TOKEN_COUNT =
0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
/**
* Address of the owner of this smart contract.
*/
address private owner;
/**
... | /**
* Xels Token smart contract.
*/ | NatSpecMultiLine | burnTokens | function burnTokens (uint256 _value) public returns (bool success) {
if (_value > accounts [msg.sender]) return false;
else if (_value > 0) {
accounts [msg.sender] = safeSub (accounts [msg.sender], _value);
tokenCount = safeSub (tokenCount, _value);
Transfer (msg.sender, address (0), _value);
... | /**
* Burn given number of tokens belonging to message sender.
*
* @param _value number of tokens to burn
* @return true on success, false on error
*/ | NatSpecMultiLine | v0.4.20+commit.3155dd80 | None | bzzr://1d020d113b53fea9c655cd9d02e7146ad11042635e72ca51f31d140a09846c49 | {
"func_code_index": [
3659,
4038
]
} | 8,147 |
XelsToken | XelsToken.sol | 0xe748269494e76c1cec3f627bb1e561e607da9161 | Solidity | XelsToken | contract XelsToken is AbstractToken {
/**
* Maximum allowed number of tokens in circulation.
*/
uint256 constant MAX_TOKEN_COUNT =
0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
/**
* Address of the owner of this smart contract.
*/
address private owner;
/**
... | /**
* Xels Token smart contract.
*/ | NatSpecMultiLine | createTokens | function createTokens (uint256 _value)
public returns (bool success) {
require (msg.sender == owner);
if (_value > 0) {
if (_value > safeSub (MAX_TOKEN_COUNT, tokenCount)) return false;
accounts [msg.sender] = safeAdd (accounts [msg.sender], _value);
tokenCount = safeAdd (tokenCount, _value);
... | /**
* Create _value new tokens and give new created tokens to msg.sender.
* May only be called by smart contract owner.
*
* @param _value number of tokens to create
* @return true if tokens were created successfully, false otherwise
*/ | NatSpecMultiLine | v0.4.20+commit.3155dd80 | None | bzzr://1d020d113b53fea9c655cd9d02e7146ad11042635e72ca51f31d140a09846c49 | {
"func_code_index": [
4304,
4723
]
} | 8,148 |
XelsToken | XelsToken.sol | 0xe748269494e76c1cec3f627bb1e561e607da9161 | Solidity | XelsToken | contract XelsToken is AbstractToken {
/**
* Maximum allowed number of tokens in circulation.
*/
uint256 constant MAX_TOKEN_COUNT =
0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
/**
* Address of the owner of this smart contract.
*/
address private owner;
/**
... | /**
* Xels Token smart contract.
*/ | NatSpecMultiLine | setOwner | function setOwner (address _newOwner) public {
require (msg.sender == owner);
owner = _newOwner;
}
| /**
* Set new owner for the smart contract.
* May only be called by smart contract owner.
*
* @param _newOwner address of new owner of the smart contract
*/ | NatSpecMultiLine | v0.4.20+commit.3155dd80 | None | bzzr://1d020d113b53fea9c655cd9d02e7146ad11042635e72ca51f31d140a09846c49 | {
"func_code_index": [
4906,
5022
]
} | 8,149 |
XelsToken | XelsToken.sol | 0xe748269494e76c1cec3f627bb1e561e607da9161 | Solidity | XelsToken | contract XelsToken is AbstractToken {
/**
* Maximum allowed number of tokens in circulation.
*/
uint256 constant MAX_TOKEN_COUNT =
0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
/**
* Address of the owner of this smart contract.
*/
address private owner;
/**
... | /**
* Xels Token smart contract.
*/ | NatSpecMultiLine | freezeTransfers | function freezeTransfers () public {
require (msg.sender == owner);
if (!frozen) {
frozen = true;
Freeze ();
}
}
| /**
* Freeze token transfers.
* May only be called by smart contract owner.
*/ | NatSpecMultiLine | v0.4.20+commit.3155dd80 | None | bzzr://1d020d113b53fea9c655cd9d02e7146ad11042635e72ca51f31d140a09846c49 | {
"func_code_index": [
5119,
5268
]
} | 8,150 |
XelsToken | XelsToken.sol | 0xe748269494e76c1cec3f627bb1e561e607da9161 | Solidity | XelsToken | contract XelsToken is AbstractToken {
/**
* Maximum allowed number of tokens in circulation.
*/
uint256 constant MAX_TOKEN_COUNT =
0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
/**
* Address of the owner of this smart contract.
*/
address private owner;
/**
... | /**
* Xels Token smart contract.
*/ | NatSpecMultiLine | unfreezeTransfers | function unfreezeTransfers () public {
require (msg.sender == owner);
if (frozen) {
frozen = false;
Unfreeze ();
}
}
| /**
* Unfreeze token transfers.
* May only be called by smart contract owner.
*/ | NatSpecMultiLine | v0.4.20+commit.3155dd80 | None | bzzr://1d020d113b53fea9c655cd9d02e7146ad11042635e72ca51f31d140a09846c49 | {
"func_code_index": [
5367,
5520
]
} | 8,151 |
Superboys | contracts/Superboys.sol | 0xe7337a1df1e4c2952d76f73af9665024938094b6 | Solidity | Superboys | contract Superboys is ERC721Enumerable, Ownable {
using Strings for uint256;
string public baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
uint256 public cost = 0.08 ether;
uint256 public maxSupply = 5000;
uint256 public maxMintAmount = 20;
uint256 public n... | /// @title Superboys. 5,000 students from different Houses at Numinous Park work together to solve hard problems in a virtual universe
/// @author DOSWΞLL.ΞTH (David Oliver Doswell, II)
/// @notice Simple contract to mint NFTs to promote STEM in K-12. 30% of the contract's funds are donated to STEM-based organizations
... | NatSpecSingleLine | _baseURI | function _baseURI() internal view virtual override returns (string memory) {
return baseURI;
}
| /// @notice Function to return the baseURI
/// @dev Explicitly override function, as we inherit from Open Zeppelin. See docs (https://docs.soliditylang.org/en/v0.6.0/contracts.html#index-17)
/// @return notRevealedURI for early whitelisted minters | NatSpecSingleLine | v0.8.10+commit.fc410830 | {
"func_code_index": [
1089,
1199
]
} | 8,152 | ||
Superboys | contracts/Superboys.sol | 0xe7337a1df1e4c2952d76f73af9665024938094b6 | Solidity | Superboys | contract Superboys is ERC721Enumerable, Ownable {
using Strings for uint256;
string public baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
uint256 public cost = 0.08 ether;
uint256 public maxSupply = 5000;
uint256 public maxMintAmount = 20;
uint256 public n... | /// @title Superboys. 5,000 students from different Houses at Numinous Park work together to solve hard problems in a virtual universe
/// @author DOSWΞLL.ΞTH (David Oliver Doswell, II)
/// @notice Simple contract to mint NFTs to promote STEM in K-12. 30% of the contract's funds are donated to STEM-based organizations
... | NatSpecSingleLine | mint | function mint(uint256 _mintAmount) public payable {
require(!paused, "the contract is paused");
uint256 supply = totalSupply();
require(_mintAmount > 0, "need to mint at least 1 NFT");
require(
_mintAmount <= maxMintAmount,
"max mint amount per session exceeded"
);
require(supply... | /// @notice Function to mint non-fungible tokens, pause contract, check amount minted is > 0, and doesn't exceed the maxMintAmount or maxSupply
/// @param _mintAmount tracks number of NFTs minted | NatSpecSingleLine | v0.8.10+commit.fc410830 | {
"func_code_index": [
1405,
2678
]
} | 8,153 | ||
Superboys | contracts/Superboys.sol | 0xe7337a1df1e4c2952d76f73af9665024938094b6 | Solidity | Superboys | contract Superboys is ERC721Enumerable, Ownable {
using Strings for uint256;
string public baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
uint256 public cost = 0.08 ether;
uint256 public maxSupply = 5000;
uint256 public maxMintAmount = 20;
uint256 public n... | /// @title Superboys. 5,000 students from different Houses at Numinous Park work together to solve hard problems in a virtual universe
/// @author DOSWΞLL.ΞTH (David Oliver Doswell, II)
/// @notice Simple contract to mint NFTs to promote STEM in K-12. 30% of the contract's funds are donated to STEM-based organizations
... | NatSpecSingleLine | walletOfOwner | function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
uint256 ownerTokenCount = balanceOf(_owner);
uint256[] memory tokenIds = new uint256[](ownerTokenCount);
for (uint256 i; i < ownerTokenCount; i++) {
tokenIds[i] = tokenOfOwnerByIndex(_owner, i);
}
ret... | /// @notice we keep track of tokenIds owner possesses
/// @dev tokenIds are kept in memory for efficiency
/// @return tokenIds of wallet owner | NatSpecSingleLine | v0.8.10+commit.fc410830 | {
"func_code_index": [
3108,
3491
]
} | 8,154 | ||
Superboys | contracts/Superboys.sol | 0xe7337a1df1e4c2952d76f73af9665024938094b6 | Solidity | Superboys | contract Superboys is ERC721Enumerable, Ownable {
using Strings for uint256;
string public baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
uint256 public cost = 0.08 ether;
uint256 public maxSupply = 5000;
uint256 public maxMintAmount = 20;
uint256 public n... | /// @title Superboys. 5,000 students from different Houses at Numinous Park work together to solve hard problems in a virtual universe
/// @author DOSWΞLL.ΞTH (David Oliver Doswell, II)
/// @notice Simple contract to mint NFTs to promote STEM in K-12. 30% of the contract's funds are donated to STEM-based organizations
... | NatSpecSingleLine | tokenURI | function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
require(
_exists(tokenId),
"ERC721Metadata: URI query for nonexistent token"
);
if (revealed == false) {
return notRevealedUri;
}
string memory currentBaseURI = _ba... | /// @notice we require a token Id to exist
/// @dev if contract is not revealed, show temporary uniform resource identifier
/// @return current base uniform resource identifier, or return nothing | NatSpecSingleLine | v0.8.10+commit.fc410830 | {
"func_code_index": [
3701,
4403
]
} | 8,155 | ||
Superboys | contracts/Superboys.sol | 0xe7337a1df1e4c2952d76f73af9665024938094b6 | Solidity | Superboys | contract Superboys is ERC721Enumerable, Ownable {
using Strings for uint256;
string public baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
uint256 public cost = 0.08 ether;
uint256 public maxSupply = 5000;
uint256 public maxMintAmount = 20;
uint256 public n... | /// @title Superboys. 5,000 students from different Houses at Numinous Park work together to solve hard problems in a virtual universe
/// @author DOSWΞLL.ΞTH (David Oliver Doswell, II)
/// @notice Simple contract to mint NFTs to promote STEM in K-12. 30% of the contract's funds are donated to STEM-based organizations
... | NatSpecSingleLine | reveal | function reveal() public onlyOwner {
revealed = true;
}
| /// @notice functions permissible to call only by contract owner | NatSpecSingleLine | v0.8.10+commit.fc410830 | {
"func_code_index": [
4474,
4545
]
} | 8,156 | ||
Superboys | contracts/Superboys.sol | 0xe7337a1df1e4c2952d76f73af9665024938094b6 | Solidity | Superboys | contract Superboys is ERC721Enumerable, Ownable {
using Strings for uint256;
string public baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
uint256 public cost = 0.08 ether;
uint256 public maxSupply = 5000;
uint256 public maxMintAmount = 20;
uint256 public n... | /// @title Superboys. 5,000 students from different Houses at Numinous Park work together to solve hard problems in a virtual universe
/// @author DOSWΞLL.ΞTH (David Oliver Doswell, II)
/// @notice Simple contract to mint NFTs to promote STEM in K-12. 30% of the contract's funds are donated to STEM-based organizations
... | NatSpecSingleLine | setNftPerAddressLimit | function setNftPerAddressLimit(uint256 _limit) public onlyOwner {
nftPerAddressLimit = _limit;
}
| /// @notice only owner can set max number of Superkids per address | NatSpecSingleLine | v0.8.10+commit.fc410830 | {
"func_code_index": [
4618,
4730
]
} | 8,157 | ||
Superboys | contracts/Superboys.sol | 0xe7337a1df1e4c2952d76f73af9665024938094b6 | Solidity | Superboys | contract Superboys is ERC721Enumerable, Ownable {
using Strings for uint256;
string public baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
uint256 public cost = 0.08 ether;
uint256 public maxSupply = 5000;
uint256 public maxMintAmount = 20;
uint256 public n... | /// @title Superboys. 5,000 students from different Houses at Numinous Park work together to solve hard problems in a virtual universe
/// @author DOSWΞLL.ΞTH (David Oliver Doswell, II)
/// @notice Simple contract to mint NFTs to promote STEM in K-12. 30% of the contract's funds are donated to STEM-based organizations
... | NatSpecSingleLine | setCost | function setCost(uint256 _newCost) public onlyOwner {
cost = _newCost;
}
| /// @notice only owner can set new cost of Superkids | NatSpecSingleLine | v0.8.10+commit.fc410830 | {
"func_code_index": [
4789,
4877
]
} | 8,158 | ||
Superboys | contracts/Superboys.sol | 0xe7337a1df1e4c2952d76f73af9665024938094b6 | Solidity | Superboys | contract Superboys is ERC721Enumerable, Ownable {
using Strings for uint256;
string public baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
uint256 public cost = 0.08 ether;
uint256 public maxSupply = 5000;
uint256 public maxMintAmount = 20;
uint256 public n... | /// @title Superboys. 5,000 students from different Houses at Numinous Park work together to solve hard problems in a virtual universe
/// @author DOSWΞLL.ΞTH (David Oliver Doswell, II)
/// @notice Simple contract to mint NFTs to promote STEM in K-12. 30% of the contract's funds are donated to STEM-based organizations
... | NatSpecSingleLine | setmaxMintAmount | function setmaxMintAmount(uint256 _newmaxMintAmount) public onlyOwner {
maxMintAmount = _newmaxMintAmount;
}
| /// @notice only owner can set maximum amount wallet owner may mint | NatSpecSingleLine | v0.8.10+commit.fc410830 | {
"func_code_index": [
4951,
5075
]
} | 8,159 | ||
Superboys | contracts/Superboys.sol | 0xe7337a1df1e4c2952d76f73af9665024938094b6 | Solidity | Superboys | contract Superboys is ERC721Enumerable, Ownable {
using Strings for uint256;
string public baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
uint256 public cost = 0.08 ether;
uint256 public maxSupply = 5000;
uint256 public maxMintAmount = 20;
uint256 public n... | /// @title Superboys. 5,000 students from different Houses at Numinous Park work together to solve hard problems in a virtual universe
/// @author DOSWΞLL.ΞTH (David Oliver Doswell, II)
/// @notice Simple contract to mint NFTs to promote STEM in K-12. 30% of the contract's funds are donated to STEM-based organizations
... | NatSpecSingleLine | setBaseURI | function setBaseURI(string memory _newBaseURI) public onlyOwner {
baseURI = _newBaseURI;
}
| /// @notice only owner can set a new base uniform resource identifier | NatSpecSingleLine | v0.8.10+commit.fc410830 | {
"func_code_index": [
5151,
5257
]
} | 8,160 | ||
Superboys | contracts/Superboys.sol | 0xe7337a1df1e4c2952d76f73af9665024938094b6 | Solidity | Superboys | contract Superboys is ERC721Enumerable, Ownable {
using Strings for uint256;
string public baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
uint256 public cost = 0.08 ether;
uint256 public maxSupply = 5000;
uint256 public maxMintAmount = 20;
uint256 public n... | /// @title Superboys. 5,000 students from different Houses at Numinous Park work together to solve hard problems in a virtual universe
/// @author DOSWΞLL.ΞTH (David Oliver Doswell, II)
/// @notice Simple contract to mint NFTs to promote STEM in K-12. 30% of the contract's funds are donated to STEM-based organizations
... | NatSpecSingleLine | setBaseExtension | function setBaseExtension(string memory _newBaseExtension)
public
onlyOwner
{
baseExtension = _newBaseExtension;
}
| /// @notice only owner can set a new base extension for our metadata | NatSpecSingleLine | v0.8.10+commit.fc410830 | {
"func_code_index": [
5332,
5482
]
} | 8,161 | ||
Superboys | contracts/Superboys.sol | 0xe7337a1df1e4c2952d76f73af9665024938094b6 | Solidity | Superboys | contract Superboys is ERC721Enumerable, Ownable {
using Strings for uint256;
string public baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
uint256 public cost = 0.08 ether;
uint256 public maxSupply = 5000;
uint256 public maxMintAmount = 20;
uint256 public n... | /// @title Superboys. 5,000 students from different Houses at Numinous Park work together to solve hard problems in a virtual universe
/// @author DOSWΞLL.ΞTH (David Oliver Doswell, II)
/// @notice Simple contract to mint NFTs to promote STEM in K-12. 30% of the contract's funds are donated to STEM-based organizations
... | NatSpecSingleLine | setNotRevealedURI | function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
notRevealedUri = _notRevealedURI;
}
| /// @notice only owner can set a new temporary uniform resource identifier | NatSpecSingleLine | v0.8.10+commit.fc410830 | {
"func_code_index": [
5563,
5691
]
} | 8,162 | ||
Superboys | contracts/Superboys.sol | 0xe7337a1df1e4c2952d76f73af9665024938094b6 | Solidity | Superboys | contract Superboys is ERC721Enumerable, Ownable {
using Strings for uint256;
string public baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
uint256 public cost = 0.08 ether;
uint256 public maxSupply = 5000;
uint256 public maxMintAmount = 20;
uint256 public n... | /// @title Superboys. 5,000 students from different Houses at Numinous Park work together to solve hard problems in a virtual universe
/// @author DOSWΞLL.ΞTH (David Oliver Doswell, II)
/// @notice Simple contract to mint NFTs to promote STEM in K-12. 30% of the contract's funds are donated to STEM-based organizations
... | NatSpecSingleLine | pause | function pause(bool _state) public onlyOwner {
paused = _state;
}
| /// @notice only owner can pause our contract | NatSpecSingleLine | v0.8.10+commit.fc410830 | {
"func_code_index": [
5743,
5824
]
} | 8,163 | ||
Superboys | contracts/Superboys.sol | 0xe7337a1df1e4c2952d76f73af9665024938094b6 | Solidity | Superboys | contract Superboys is ERC721Enumerable, Ownable {
using Strings for uint256;
string public baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
uint256 public cost = 0.08 ether;
uint256 public maxSupply = 5000;
uint256 public maxMintAmount = 20;
uint256 public n... | /// @title Superboys. 5,000 students from different Houses at Numinous Park work together to solve hard problems in a virtual universe
/// @author DOSWΞLL.ΞTH (David Oliver Doswell, II)
/// @notice Simple contract to mint NFTs to promote STEM in K-12. 30% of the contract's funds are donated to STEM-based organizations
... | NatSpecSingleLine | setOnlyWhitelisted | function setOnlyWhitelisted(bool _state) public onlyOwner {
onlyWhitelisted = _state;
}
| /// @notice only owner can add whitelisted wallet addresses | NatSpecSingleLine | v0.8.10+commit.fc410830 | {
"func_code_index": [
5890,
5993
]
} | 8,164 | ||
Superboys | contracts/Superboys.sol | 0xe7337a1df1e4c2952d76f73af9665024938094b6 | Solidity | Superboys | contract Superboys is ERC721Enumerable, Ownable {
using Strings for uint256;
string public baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
uint256 public cost = 0.08 ether;
uint256 public maxSupply = 5000;
uint256 public maxMintAmount = 20;
uint256 public n... | /// @title Superboys. 5,000 students from different Houses at Numinous Park work together to solve hard problems in a virtual universe
/// @author DOSWΞLL.ΞTH (David Oliver Doswell, II)
/// @notice Simple contract to mint NFTs to promote STEM in K-12. 30% of the contract's funds are donated to STEM-based organizations
... | NatSpecSingleLine | whitelistUsers | function whitelistUsers(address[] calldata _users) public onlyOwner {
delete whitelistedAddresses;
whitelistedAddresses = _users;
}
| /// @notice only owner can remove whitelisted wallet addresses | NatSpecSingleLine | v0.8.10+commit.fc410830 | {
"func_code_index": [
6062,
6217
]
} | 8,165 | ||
Superboys | contracts/Superboys.sol | 0xe7337a1df1e4c2952d76f73af9665024938094b6 | Solidity | Superboys | contract Superboys is ERC721Enumerable, Ownable {
using Strings for uint256;
string public baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
uint256 public cost = 0.08 ether;
uint256 public maxSupply = 5000;
uint256 public maxMintAmount = 20;
uint256 public n... | /// @title Superboys. 5,000 students from different Houses at Numinous Park work together to solve hard problems in a virtual universe
/// @author DOSWΞLL.ΞTH (David Oliver Doswell, II)
/// @notice Simple contract to mint NFTs to promote STEM in K-12. 30% of the contract's funds are donated to STEM-based organizations
... | NatSpecSingleLine | withdraw | function withdraw() public payable onlyOwner {
/// @notice Donate 10% to Assemble Pittsburgh
(bool assemble, ) = payable(0xc1353fE8bd78aE6f5449da47203523D2edEaCc59)
.call{value: (address(this).balance * 10) / 100}("");
require(assemble);
/// @notice Donate 10% to Black Girls Code
(bool blac... | /// @notice only owner can withdraw ether from contract | NatSpecSingleLine | v0.8.10+commit.fc410830 | {
"func_code_index": [
6279,
7181
]
} | 8,166 | ||
E99 | E99.sol | 0xa133882a62c4a53389a5517470b7e3ed23006c5d | Solidity | E99 | contract E99 {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => u... | E99 | function E99 (
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
totalSupply = initialSupply * 10 ** uint256(decimals); // Update total supply with the decimal amount
balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens
name = to... | /**
* Constructor function
*
* Initializes contract with initial supply tokens to the creator of the contract
*/ | NatSpecMultiLine | v0.4.21+commit.dfe3193c | None | bzzr://ed35bc98e324be78b85595590c56d684278e428a587f592d520a5ea36f7f150f | {
"func_code_index": [
834,
1373
]
} | 8,167 | ||
E99 | E99.sol | 0xa133882a62c4a53389a5517470b7e3ed23006c5d | Solidity | E99 | contract E99 {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => u... | _transfer | function _transfer(address _from, address _to, uint _value) internal {
// Prevent transfer to 0x0 address. Use burn() instead
require(_to != 0x0);
// Check if the sender has enough
require(balanceOf[_from] >= _value);
// Check for overflows
require(balanceOf[_to] + _value >= balanceOf[_to]... | /**
* Internal transfer, only can be called by this contract
*/ | NatSpecMultiLine | v0.4.21+commit.dfe3193c | None | bzzr://ed35bc98e324be78b85595590c56d684278e428a587f592d520a5ea36f7f150f | {
"func_code_index": [
1457,
2305
]
} | 8,168 | ||
E99 | E99.sol | 0xa133882a62c4a53389a5517470b7e3ed23006c5d | Solidity | E99 | contract E99 {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => u... | transfer | function transfer(address _to, uint256 _value) public {
_transfer(msg.sender, _to, _value);
}
| /**
* Transfer tokens
*
* Send `_value` tokens to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/ | NatSpecMultiLine | v0.4.21+commit.dfe3193c | None | bzzr://ed35bc98e324be78b85595590c56d684278e428a587f592d520a5ea36f7f150f | {
"func_code_index": [
2511,
2623
]
} | 8,169 | ||
E99 | E99.sol | 0xa133882a62c4a53389a5517470b7e3ed23006c5d | Solidity | E99 | contract E99 {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => u... | transferFrom | function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]); // Check allowance
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
| /**
* Transfer tokens from other address
*
* Send `_value` tokens to `_to` on behalf of `_from`
*
* @param _from The address of the sender
* @param _to The address of the recipient
* @param _value the amount to send
*/ | NatSpecMultiLine | v0.4.21+commit.dfe3193c | None | bzzr://ed35bc98e324be78b85595590c56d684278e428a587f592d520a5ea36f7f150f | {
"func_code_index": [
2898,
3199
]
} | 8,170 | ||
E99 | E99.sol | 0xa133882a62c4a53389a5517470b7e3ed23006c5d | Solidity | E99 | contract E99 {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => u... | approve | function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
| /**
* Set allowance for other address
*
* Allows `_spender` to spend no more than `_value` tokens on your behalf
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
*/ | NatSpecMultiLine | v0.4.21+commit.dfe3193c | None | bzzr://ed35bc98e324be78b85595590c56d684278e428a587f592d520a5ea36f7f150f | {
"func_code_index": [
3463,
3639
]
} | 8,171 | ||
E99 | E99.sol | 0xa133882a62c4a53389a5517470b7e3ed23006c5d | Solidity | E99 | contract E99 {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => u... | approveAndCall | function approveAndCall(address _spender, uint256 _value, bytes _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
| /**
* Set allowance for other address and notify
*
* Allows `_spender` to spend no more than `_value` tokens on your behalf, and then ping the contract about it
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
* @param _extraData some extra information to s... | NatSpecMultiLine | v0.4.21+commit.dfe3193c | None | bzzr://ed35bc98e324be78b85595590c56d684278e428a587f592d520a5ea36f7f150f | {
"func_code_index": [
4033,
4385
]
} | 8,172 | ||
E99 | E99.sol | 0xa133882a62c4a53389a5517470b7e3ed23006c5d | Solidity | E99 | contract E99 {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => u... | burn | function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value); // Check if the sender has enough
balanceOf[msg.sender] -= _value; // Subtract from the sender
totalSupply -= _value; // Updates totalSupply
emit Burn(msg.sender,... | /**
* Destroy tokens
*
* Remove `_value` tokens from the system irreversibly
*
* @param _value the amount of money to burn
*/ | NatSpecMultiLine | v0.4.21+commit.dfe3193c | None | bzzr://ed35bc98e324be78b85595590c56d684278e428a587f592d520a5ea36f7f150f | {
"func_code_index": [
4555,
4934
]
} | 8,173 | ||
E99 | E99.sol | 0xa133882a62c4a53389a5517470b7e3ed23006c5d | Solidity | E99 | contract E99 {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => u... | burnFrom | function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value); // Check if the targeted balance is enough
require(_value <= allowance[_from][msg.sender]); // Check allowance
balanceOf[_from] -= _value; // Sub... | /**
* Destroy tokens from other account
*
* Remove `_value` tokens from the system irreversibly on behalf of `_from`.
*
* @param _from the address of the sender
* @param _value the amount of money to burn
*/ | NatSpecMultiLine | v0.4.21+commit.dfe3193c | None | bzzr://ed35bc98e324be78b85595590c56d684278e428a587f592d520a5ea36f7f150f | {
"func_code_index": [
5192,
5808
]
} | 8,174 | ||
SmartInvoiceWallet | SafeMath.sol | 0x9f7c7ec1d32262911c19b257841eda5d0ffaaf5a | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
... | /**
* @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 language... | 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.5.0+commit.1d4f565a | bzzr://7af97b9d816714361b682d9edb3ac49f66a5cf2353dd676f68b0e50721b0c411 | {
"func_code_index": [
241,
421
]
} | 8,175 | |
SmartInvoiceWallet | SafeMath.sol | 0x9f7c7ec1d32262911c19b257841eda5d0ffaaf5a | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
... | /**
* @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 language... | NatSpecMultiLine | sub | function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
| /**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
* - Subtraction cannot overflow.
*/ | NatSpecMultiLine | v0.5.0+commit.1d4f565a | bzzr://7af97b9d816714361b682d9edb3ac49f66a5cf2353dd676f68b0e50721b0c411 | {
"func_code_index": [
681,
864
]
} | 8,176 | |
SmartInvoiceWallet | SafeMath.sol | 0x9f7c7ec1d32262911c19b257841eda5d0ffaaf5a | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
... | /**
* @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 language... | 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;
}
... | /**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
* - Multiplication cannot overflow.
*/ | NatSpecMultiLine | v0.5.0+commit.1d4f565a | bzzr://7af97b9d816714361b682d9edb3ac49f66a5cf2353dd676f68b0e50721b0c411 | {
"func_code_index": [
1100,
1562
]
} | 8,177 | |
SmartInvoiceWallet | SafeMath.sol | 0x9f7c7ec1d32262911c19b257841eda5d0ffaaf5a | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
... | /**
* @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 language... | NatSpecMultiLine | div | function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath: division by zero");
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 on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (co... | NatSpecMultiLine | v0.5.0+commit.1d4f565a | bzzr://7af97b9d816714361b682d9edb3ac49f66a5cf2353dd676f68b0e50721b0c411 | {
"func_code_index": [
2013,
2343
]
} | 8,178 | |
SmartInvoiceWallet | SafeMath.sol | 0x9f7c7ec1d32262911c19b257841eda5d0ffaaf5a | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
... | /**
* @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 language... | NatSpecMultiLine | mod | function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
| /**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all... | NatSpecMultiLine | v0.5.0+commit.1d4f565a | bzzr://7af97b9d816714361b682d9edb3ac49f66a5cf2353dd676f68b0e50721b0c411 | {
"func_code_index": [
2783,
2936
]
} | 8,179 | |
BSDB | BSDB.sol | 0xd92eaf047744e65d0f40a3651f318d08f7eb835f | Solidity | BSDB | contract BSDB is MintableToken
{
string public name = "BsdbWealth";
string public symbol = "BSDB";
uint public decimals = 8;
uint private initialSupply = 81*10**(6+8); // 81 Millions
function BSDB()
{
owner = msg.sender;
totalSupply = initialSupply;
bala... | BSDB | function BSDB()
{
owner = msg.sender;
totalSupply = initialSupply;
balances[owner] = initialSupply;
}
| // 81 Millions | LineComment | v0.4.15+commit.bbb8e64f | bzzr://e2b27c9ce4608b2438fc1ca2c42e43140b8d1584bcb0882a1c327d871224f947 | {
"func_code_index": [
213,
356
]
} | 8,180 | |||
AugustusSwapper | contracts/AugustusSwapper.sol | 0x66152a2a538644ae125570de522adeac9e41d865 | Solidity | AugustusSwapper | contract AugustusSwapper is ReentrancyGuard, Ownable {
using SafeERC20 for IERC20;
using SafeMath for uint256;
using Address for address;
//Ether token address used when to or from in swap is Ether
address constant private ETH_ADDRESS = address(
0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeee... | /**
* @dev The contract will allow swap of one token for another across multiple exchanges in one atomic transaction
* Kyber, Uniswap and Bancor are supported in phase-01
*/ | NatSpecMultiLine | function() external payable whenNotPaused {
address account = msg.sender;
require(
account.isContract(),
"Sender is not a contract"
);
}
| /**
* @dev Fallback method to allow exchanges to transfer back ethers for a particular swap
* It will only allow contracts to send funds to it
*/ | NatSpecMultiLine | v0.5.10+commit.5a6ea5b1 | BSD-3-Clause | bzzr://a414e7ebbd4e22e20905576e075c51708f507cc3b4782f370cdcb29302473dd4 | {
"func_code_index": [
2640,
2839
]
} | 8,181 | |
AugustusSwapper | contracts/AugustusSwapper.sol | 0x66152a2a538644ae125570de522adeac9e41d865 | Solidity | AugustusSwapper | contract AugustusSwapper is ReentrancyGuard, Ownable {
using SafeERC20 for IERC20;
using SafeMath for uint256;
using Address for address;
//Ether token address used when to or from in swap is Ether
address constant private ETH_ADDRESS = address(
0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeee... | /**
* @dev The contract will allow swap of one token for another across multiple exchanges in one atomic transaction
* Kyber, Uniswap and Bancor are supported in phase-01
*/ | NatSpecMultiLine | getTokenTransferProxy | function getTokenTransferProxy() external view returns (address) {
return address(_tokenTransferProxy);
}
| /**
* @dev Returns address of TokenTransferProxy Contract
*/ | NatSpecMultiLine | v0.5.10+commit.5a6ea5b1 | BSD-3-Clause | bzzr://a414e7ebbd4e22e20905576e075c51708f507cc3b4782f370cdcb29302473dd4 | {
"func_code_index": [
2918,
3042
]
} | 8,182 |
AugustusSwapper | contracts/AugustusSwapper.sol | 0x66152a2a538644ae125570de522adeac9e41d865 | Solidity | AugustusSwapper | contract AugustusSwapper is ReentrancyGuard, Ownable {
using SafeERC20 for IERC20;
using SafeMath for uint256;
using Address for address;
//Ether token address used when to or from in swap is Ether
address constant private ETH_ADDRESS = address(
0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeee... | /**
* @dev The contract will allow swap of one token for another across multiple exchanges in one atomic transaction
* Kyber, Uniswap and Bancor are supported in phase-01
*/ | NatSpecMultiLine | paused | function paused() external view returns (bool) {
return _paused;
}
| /**
* @dev Returns true if the contract is paused, and false otherwise.
*/ | NatSpecMultiLine | v0.5.10+commit.5a6ea5b1 | BSD-3-Clause | bzzr://a414e7ebbd4e22e20905576e075c51708f507cc3b4782f370cdcb29302473dd4 | {
"func_code_index": [
3137,
3222
]
} | 8,183 |
AugustusSwapper | contracts/AugustusSwapper.sol | 0x66152a2a538644ae125570de522adeac9e41d865 | Solidity | AugustusSwapper | contract AugustusSwapper is ReentrancyGuard, Ownable {
using SafeERC20 for IERC20;
using SafeMath for uint256;
using Address for address;
//Ether token address used when to or from in swap is Ether
address constant private ETH_ADDRESS = address(
0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeee... | /**
* @dev The contract will allow swap of one token for another across multiple exchanges in one atomic transaction
* Kyber, Uniswap and Bancor are supported in phase-01
*/ | NatSpecMultiLine | pause | function pause() external onlyOwner whenNotPaused {
_paused = true;
emit Paused();
}
| /**
* @dev Called by a pauser to pause, triggers stopped state.
*/ | NatSpecMultiLine | v0.5.10+commit.5a6ea5b1 | BSD-3-Clause | bzzr://a414e7ebbd4e22e20905576e075c51708f507cc3b4782f370cdcb29302473dd4 | {
"func_code_index": [
3309,
3421
]
} | 8,184 |
AugustusSwapper | contracts/AugustusSwapper.sol | 0x66152a2a538644ae125570de522adeac9e41d865 | Solidity | AugustusSwapper | contract AugustusSwapper is ReentrancyGuard, Ownable {
using SafeERC20 for IERC20;
using SafeMath for uint256;
using Address for address;
//Ether token address used when to or from in swap is Ether
address constant private ETH_ADDRESS = address(
0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeee... | /**
* @dev The contract will allow swap of one token for another across multiple exchanges in one atomic transaction
* Kyber, Uniswap and Bancor are supported in phase-01
*/ | NatSpecMultiLine | unpause | function unpause() external onlyOwner whenPaused {
_paused = false;
emit Unpaused();
}
| /**
* @dev Called by a pauser to unpause, returns to normal state.
*/ | NatSpecMultiLine | v0.5.10+commit.5a6ea5b1 | BSD-3-Clause | bzzr://a414e7ebbd4e22e20905576e075c51708f507cc3b4782f370cdcb29302473dd4 | {
"func_code_index": [
3511,
3625
]
} | 8,185 |
AugustusSwapper | contracts/AugustusSwapper.sol | 0x66152a2a538644ae125570de522adeac9e41d865 | Solidity | AugustusSwapper | contract AugustusSwapper is ReentrancyGuard, Ownable {
using SafeERC20 for IERC20;
using SafeMath for uint256;
using Address for address;
//Ether token address used when to or from in swap is Ether
address constant private ETH_ADDRESS = address(
0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeee... | /**
* @dev The contract will allow swap of one token for another across multiple exchanges in one atomic transaction
* Kyber, Uniswap and Bancor are supported in phase-01
*/ | NatSpecMultiLine | changeFeeWallet | function changeFeeWallet(address payable feeWallet) external onlyOwner {
_feeWallet = feeWallet;
}
| /**
* @dev Allows owner to change fee wallet
* @param feeWallet Address of the new fee wallet
*/ | NatSpecMultiLine | v0.5.10+commit.5a6ea5b1 | BSD-3-Clause | bzzr://a414e7ebbd4e22e20905576e075c51708f507cc3b4782f370cdcb29302473dd4 | {
"func_code_index": [
3745,
3862
]
} | 8,186 |
AugustusSwapper | contracts/AugustusSwapper.sol | 0x66152a2a538644ae125570de522adeac9e41d865 | Solidity | AugustusSwapper | contract AugustusSwapper is ReentrancyGuard, Ownable {
using SafeERC20 for IERC20;
using SafeMath for uint256;
using Address for address;
//Ether token address used when to or from in swap is Ether
address constant private ETH_ADDRESS = address(
0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeee... | /**
* @dev The contract will allow swap of one token for another across multiple exchanges in one atomic transaction
* Kyber, Uniswap and Bancor are supported in phase-01
*/ | NatSpecMultiLine | getFeeWallet | function getFeeWallet() external view returns (address) {
return _feeWallet;
}
| /**
* @dev Returns the fee wallet address
*/ | NatSpecMultiLine | v0.5.10+commit.5a6ea5b1 | BSD-3-Clause | bzzr://a414e7ebbd4e22e20905576e075c51708f507cc3b4782f370cdcb29302473dd4 | {
"func_code_index": [
3925,
4022
]
} | 8,187 |
AugustusSwapper | contracts/AugustusSwapper.sol | 0x66152a2a538644ae125570de522adeac9e41d865 | Solidity | AugustusSwapper | contract AugustusSwapper is ReentrancyGuard, Ownable {
using SafeERC20 for IERC20;
using SafeMath for uint256;
using Address for address;
//Ether token address used when to or from in swap is Ether
address constant private ETH_ADDRESS = address(
0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeee... | /**
* @dev The contract will allow swap of one token for another across multiple exchanges in one atomic transaction
* Kyber, Uniswap and Bancor are supported in phase-01
*/ | NatSpecMultiLine | changeFee | function changeFee(uint256 fee) external onlyOwner {
_fee = fee;
}
| /**
* @dev Allows owner to change fee
* @param fee New fee percentage
*/ | NatSpecMultiLine | v0.5.10+commit.5a6ea5b1 | BSD-3-Clause | bzzr://a414e7ebbd4e22e20905576e075c51708f507cc3b4782f370cdcb29302473dd4 | {
"func_code_index": [
4118,
4203
]
} | 8,188 |
AugustusSwapper | contracts/AugustusSwapper.sol | 0x66152a2a538644ae125570de522adeac9e41d865 | Solidity | AugustusSwapper | contract AugustusSwapper is ReentrancyGuard, Ownable {
using SafeERC20 for IERC20;
using SafeMath for uint256;
using Address for address;
//Ether token address used when to or from in swap is Ether
address constant private ETH_ADDRESS = address(
0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeee... | /**
* @dev The contract will allow swap of one token for another across multiple exchanges in one atomic transaction
* Kyber, Uniswap and Bancor are supported in phase-01
*/ | NatSpecMultiLine | getFee | function getFee() external view returns (uint256) {
return _fee;
}
| /**
* @dev returns the current fee percentage
*/ | NatSpecMultiLine | v0.5.10+commit.5a6ea5b1 | BSD-3-Clause | bzzr://a414e7ebbd4e22e20905576e075c51708f507cc3b4782f370cdcb29302473dd4 | {
"func_code_index": [
4270,
4355
]
} | 8,189 |
AugustusSwapper | contracts/AugustusSwapper.sol | 0x66152a2a538644ae125570de522adeac9e41d865 | Solidity | AugustusSwapper | contract AugustusSwapper is ReentrancyGuard, Ownable {
using SafeERC20 for IERC20;
using SafeMath for uint256;
using Address for address;
//Ether token address used when to or from in swap is Ether
address constant private ETH_ADDRESS = address(
0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeee... | /**
* @dev The contract will allow swap of one token for another across multiple exchanges in one atomic transaction
* Kyber, Uniswap and Bancor are supported in phase-01
*/ | NatSpecMultiLine | addWhitelisted | function addWhitelisted(address account) external onlyOwner {
_whitelisteds[account] = true;
emit WhitelistAdded(account);
}
| /**
* @dev Allows owner of the contract to whitelist an address
* @param account Address of the account to be whitelisted
*/ | NatSpecMultiLine | v0.5.10+commit.5a6ea5b1 | BSD-3-Clause | bzzr://a414e7ebbd4e22e20905576e075c51708f507cc3b4782f370cdcb29302473dd4 | {
"func_code_index": [
4503,
4655
]
} | 8,190 |
AugustusSwapper | contracts/AugustusSwapper.sol | 0x66152a2a538644ae125570de522adeac9e41d865 | Solidity | AugustusSwapper | contract AugustusSwapper is ReentrancyGuard, Ownable {
using SafeERC20 for IERC20;
using SafeMath for uint256;
using Address for address;
//Ether token address used when to or from in swap is Ether
address constant private ETH_ADDRESS = address(
0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeee... | /**
* @dev The contract will allow swap of one token for another across multiple exchanges in one atomic transaction
* Kyber, Uniswap and Bancor are supported in phase-01
*/ | NatSpecMultiLine | removeWhitelistes | function removeWhitelistes(address account) external onlyOwner {
_whitelisteds[account] = false;
emit WhitelistRemoved(account);
}
| /**
* @dev Allows owner of the contract to remove address from a whitelist
* @param account Address of the account the be removed
*/ | NatSpecMultiLine | v0.5.10+commit.5a6ea5b1 | BSD-3-Clause | bzzr://a414e7ebbd4e22e20905576e075c51708f507cc3b4782f370cdcb29302473dd4 | {
"func_code_index": [
4811,
4969
]
} | 8,191 |
AugustusSwapper | contracts/AugustusSwapper.sol | 0x66152a2a538644ae125570de522adeac9e41d865 | Solidity | AugustusSwapper | contract AugustusSwapper is ReentrancyGuard, Ownable {
using SafeERC20 for IERC20;
using SafeMath for uint256;
using Address for address;
//Ether token address used when to or from in swap is Ether
address constant private ETH_ADDRESS = address(
0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeee... | /**
* @dev The contract will allow swap of one token for another across multiple exchanges in one atomic transaction
* Kyber, Uniswap and Bancor are supported in phase-01
*/ | NatSpecMultiLine | addWhitelistedBulk | function addWhitelistedBulk(
address[] calldata accounts
)
external
onlyOwner
{
for (uint256 i = 0; i < accounts.length; i++) {
_whitelisteds[accounts[i]] = true;
emit WhitelistAdded(accounts[i]);
}
}
| /**
* @dev Allows onwers of the contract to whitelist addresses in bulk
* @param accounts An array of addresses to be whitelisted
*/ | NatSpecMultiLine | v0.5.10+commit.5a6ea5b1 | BSD-3-Clause | bzzr://a414e7ebbd4e22e20905576e075c51708f507cc3b4782f370cdcb29302473dd4 | {
"func_code_index": [
5125,
5408
]
} | 8,192 |
AugustusSwapper | contracts/AugustusSwapper.sol | 0x66152a2a538644ae125570de522adeac9e41d865 | Solidity | AugustusSwapper | contract AugustusSwapper is ReentrancyGuard, Ownable {
using SafeERC20 for IERC20;
using SafeMath for uint256;
using Address for address;
//Ether token address used when to or from in swap is Ether
address constant private ETH_ADDRESS = address(
0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeee... | /**
* @dev The contract will allow swap of one token for another across multiple exchanges in one atomic transaction
* Kyber, Uniswap and Bancor are supported in phase-01
*/ | NatSpecMultiLine | approve | function approve(
address token,
address to,
uint256 amount
)
external
onlySelf
{
require(amount > 0, "Amount should be greater than 0!!");
//1. Check for valid whitelisted address
require(
isWhitelisted(to),
"AugustusSwapper: Not a whitelisted address!!"
);
... | /**
* @dev Allows this contract to make approve call for a token
* This method is expected to be called using externalCall method.
* @param token The address of the token
* @param to The address of the spender
* @param amount The amount to be approved
*/ | NatSpecMultiLine | v0.5.10+commit.5a6ea5b1 | BSD-3-Clause | bzzr://a414e7ebbd4e22e20905576e075c51708f507cc3b4782f370cdcb29302473dd4 | {
"func_code_index": [
5701,
6283
]
} | 8,193 |
AugustusSwapper | contracts/AugustusSwapper.sol | 0x66152a2a538644ae125570de522adeac9e41d865 | Solidity | AugustusSwapper | contract AugustusSwapper is ReentrancyGuard, Ownable {
using SafeERC20 for IERC20;
using SafeMath for uint256;
using Address for address;
//Ether token address used when to or from in swap is Ether
address constant private ETH_ADDRESS = address(
0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeee... | /**
* @dev The contract will allow swap of one token for another across multiple exchanges in one atomic transaction
* Kyber, Uniswap and Bancor are supported in phase-01
*/ | NatSpecMultiLine | ownerTransferTokens | function ownerTransferTokens(
address token,
address payable destination,
uint256 amount
)
external
onlyOwner
{
transferTokens(token, destination, amount);
}
| /**
* @dev Allows owner of the contract to transfer tokens any tokens which are assigned to the contract
* This method is for saftey if by any chance tokens or ETHs are assigned to the contract by mistake
* @dev token Address of the token to be transferred
* @dev destination Recepient of the token
* @dev amou... | NatSpecMultiLine | v0.5.10+commit.5a6ea5b1 | BSD-3-Clause | bzzr://a414e7ebbd4e22e20905576e075c51708f507cc3b4782f370cdcb29302473dd4 | {
"func_code_index": [
6672,
6895
]
} | 8,194 |
AugustusSwapper | contracts/AugustusSwapper.sol | 0x66152a2a538644ae125570de522adeac9e41d865 | Solidity | AugustusSwapper | contract AugustusSwapper is ReentrancyGuard, Ownable {
using SafeERC20 for IERC20;
using SafeMath for uint256;
using Address for address;
//Ether token address used when to or from in swap is Ether
address constant private ETH_ADDRESS = address(
0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeee... | /**
* @dev The contract will allow swap of one token for another across multiple exchanges in one atomic transaction
* Kyber, Uniswap and Bancor are supported in phase-01
*/ | NatSpecMultiLine | mintGasTokens | function mintGasTokens(uint256 amount) external onlyOwner {
_gasToken.mint(amount);
}
| /**
* @dev Allows owner of the contract to mint more gas tokens
* @param amount Amount of gas tokens to mint
*/ | NatSpecMultiLine | v0.5.10+commit.5a6ea5b1 | BSD-3-Clause | bzzr://a414e7ebbd4e22e20905576e075c51708f507cc3b4782f370cdcb29302473dd4 | {
"func_code_index": [
7030,
7134
]
} | 8,195 |
AugustusSwapper | contracts/AugustusSwapper.sol | 0x66152a2a538644ae125570de522adeac9e41d865 | Solidity | AugustusSwapper | contract AugustusSwapper is ReentrancyGuard, Ownable {
using SafeERC20 for IERC20;
using SafeMath for uint256;
using Address for address;
//Ether token address used when to or from in swap is Ether
address constant private ETH_ADDRESS = address(
0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeee... | /**
* @dev The contract will allow swap of one token for another across multiple exchanges in one atomic transaction
* Kyber, Uniswap and Bancor are supported in phase-01
*/ | NatSpecMultiLine | withdrawAllWETH | function withdrawAllWETH(IWETH token) external {
uint256 amount = token.balanceOf(address(this));
token.withdraw(amount);
}
| /**
* @dev This function sends the WETH returned during the exchange to the user.
* @param token: The WETH Address
*/ | NatSpecMultiLine | v0.5.10+commit.5a6ea5b1 | BSD-3-Clause | bzzr://a414e7ebbd4e22e20905576e075c51708f507cc3b4782f370cdcb29302473dd4 | {
"func_code_index": [
7272,
7423
]
} | 8,196 |
AugustusSwapper | contracts/AugustusSwapper.sol | 0x66152a2a538644ae125570de522adeac9e41d865 | Solidity | AugustusSwapper | contract AugustusSwapper is ReentrancyGuard, Ownable {
using SafeERC20 for IERC20;
using SafeMath for uint256;
using Address for address;
//Ether token address used when to or from in swap is Ether
address constant private ETH_ADDRESS = address(
0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeee... | /**
* @dev The contract will allow swap of one token for another across multiple exchanges in one atomic transaction
* Kyber, Uniswap and Bancor are supported in phase-01
*/ | NatSpecMultiLine | swap | function swap(
address sourceToken,
address destinationToken,
uint256 sourceAmount,
uint256 minDestinationAmount,
address[] memory callees,
bytes memory exchangeData,
uint256[] memory startIndexes,
uint256[] memory values,
string memory referrer,
uint256 mintPrice
)
p... | /**
* @dev The function which performs the actual swap.
* The call data to the actual exchanges must be built offchain
* and then sent to this method. It will be call those external exchanges using
* data passed through externalCall function
* It is a nonreentrant function
* @param sourceToken Address of th... | NatSpecMultiLine | v0.5.10+commit.5a6ea5b1 | BSD-3-Clause | bzzr://a414e7ebbd4e22e20905576e075c51708f507cc3b4782f370cdcb29302473dd4 | {
"func_code_index": [
9834,
10841
]
} | 8,197 |
AugustusSwapper | contracts/AugustusSwapper.sol | 0x66152a2a538644ae125570de522adeac9e41d865 | Solidity | AugustusSwapper | contract AugustusSwapper is ReentrancyGuard, Ownable {
using SafeERC20 for IERC20;
using SafeMath for uint256;
using Address for address;
//Ether token address used when to or from in swap is Ether
address constant private ETH_ADDRESS = address(
0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeee... | /**
* @dev The contract will allow swap of one token for another across multiple exchanges in one atomic transaction
* Kyber, Uniswap and Bancor are supported in phase-01
*/ | NatSpecMultiLine | isWhitelisted | function isWhitelisted(address account) public view returns (bool) {
return _whitelisteds[account];
}
| /**
* @dev Returns whether given addresses is whitelisted or not
* @param account The account to be checked
* @return bool
*/ | NatSpecMultiLine | v0.5.10+commit.5a6ea5b1 | BSD-3-Clause | bzzr://a414e7ebbd4e22e20905576e075c51708f507cc3b4782f370cdcb29302473dd4 | {
"func_code_index": [
13838,
13958
]
} | 8,198 |
AugustusSwapper | contracts/AugustusSwapper.sol | 0x66152a2a538644ae125570de522adeac9e41d865 | Solidity | AugustusSwapper | contract AugustusSwapper is ReentrancyGuard, Ownable {
using SafeERC20 for IERC20;
using SafeMath for uint256;
using Address for address;
//Ether token address used when to or from in swap is Ether
address constant private ETH_ADDRESS = address(
0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeee... | /**
* @dev The contract will allow swap of one token for another across multiple exchanges in one atomic transaction
* Kyber, Uniswap and Bancor are supported in phase-01
*/ | NatSpecMultiLine | refundGas | function refundGas(uint256 initialGas, uint256 mintPrice) private {
uint256 mintBase = 32254;
uint256 mintToken = 36543;
uint256 freeBase = 14154;
uint256 freeToken = 6870;
uint256 reimburse = 24000;
uint256 tokens = initialGas.sub(
gasleft()).add(freeBase).div(reimburse.mul(2... | /**
* @dev Helper method to refund gas using gas tokens
*/ | NatSpecMultiLine | v0.5.10+commit.5a6ea5b1 | BSD-3-Clause | bzzr://a414e7ebbd4e22e20905576e075c51708f507cc3b4782f370cdcb29302473dd4 | {
"func_code_index": [
14035,
14848
]
} | 8,199 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.