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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Kannabiz | Kannabiz.sol | 0xd9506121d67fb918ac47af0b883730694be9377c | Solidity | Kannabiz | contract Kannabiz is ERC20Interface, Owned
{
using SafeMath for uint;
using ExtendedMath for uint;
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
uint public latestDifficultyPeriodStarted;
uint public epochCount; //number of 'blocks' mine... | // ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and an
// initial fixed supply
// ---------------------------------------------------------------------------- | LineComment | totalSupply | function totalSupply() public constant returns (uint)
{
return _totalSupply - balances[address(0)];
}
| // ------------------------------------------------------------------------
// Total supply
// ------------------------------------------------------------------------ | LineComment | v0.4.18+commit.9cf6e910 | MIT | bzzr://36f2cb1a1a9ef7dc23ca6748643c1e70e2de61a55de2af8061617bc05ba7c865 | {
"func_code_index": [
9229,
9357
]
} | 12,200 |
Kannabiz | Kannabiz.sol | 0xd9506121d67fb918ac47af0b883730694be9377c | Solidity | Kannabiz | contract Kannabiz is ERC20Interface, Owned
{
using SafeMath for uint;
using ExtendedMath for uint;
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
uint public latestDifficultyPeriodStarted;
uint public epochCount; //number of 'blocks' mine... | // ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and an
// initial fixed supply
// ---------------------------------------------------------------------------- | LineComment | balanceOf | function balanceOf(address tokenOwner) public constant returns (uint balance)
{
return balances[tokenOwner];
}
| // ------------------------------------------------------------------------
// Get the token balance for account `tokenOwner`
// ------------------------------------------------------------------------ | LineComment | v0.4.18+commit.9cf6e910 | MIT | bzzr://36f2cb1a1a9ef7dc23ca6748643c1e70e2de61a55de2af8061617bc05ba7c865 | {
"func_code_index": [
9580,
9716
]
} | 12,201 |
Kannabiz | Kannabiz.sol | 0xd9506121d67fb918ac47af0b883730694be9377c | Solidity | Kannabiz | contract Kannabiz is ERC20Interface, Owned
{
using SafeMath for uint;
using ExtendedMath for uint;
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
uint public latestDifficultyPeriodStarted;
uint public epochCount; //number of 'blocks' mine... | // ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and an
// initial fixed supply
// ---------------------------------------------------------------------------- | LineComment | transfer | function transfer(address to, uint tokens) public returns (bool success)
{
// Checks if sender has enough balance, checks for overflows, and checks if the sender or to accounts are frozen
if ((balances[msg.sender] < tokens) || (balances[to] + tokens < balances[to]) || (frozenAccount[msg.sender]) || (frozen... | // ------------------------------------------------------------------------
// Transfer the balance from token owner's account to `to` account
// - Owner's account must have sufficient balance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------ | LineComment | v0.4.18+commit.9cf6e910 | MIT | bzzr://36f2cb1a1a9ef7dc23ca6748643c1e70e2de61a55de2af8061617bc05ba7c865 | {
"func_code_index": [
10061,
10686
]
} | 12,202 |
Kannabiz | Kannabiz.sol | 0xd9506121d67fb918ac47af0b883730694be9377c | Solidity | Kannabiz | contract Kannabiz is ERC20Interface, Owned
{
using SafeMath for uint;
using ExtendedMath for uint;
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
uint public latestDifficultyPeriodStarted;
uint public epochCount; //number of 'blocks' mine... | // ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and an
// initial fixed supply
// ---------------------------------------------------------------------------- | LineComment | approve | function approve(address spender, uint tokens) public returns (bool success)
{
if ((frozenAccount[msg.sender]) || (frozenAccount[spender]))
{
return false;
}
else
{
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
return true... | // ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account
//
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// recommends that there are no checks for the approval do... | LineComment | v0.4.18+commit.9cf6e910 | MIT | bzzr://36f2cb1a1a9ef7dc23ca6748643c1e70e2de61a55de2af8061617bc05ba7c865 | {
"func_code_index": [
11191,
11567
]
} | 12,203 |
Kannabiz | Kannabiz.sol | 0xd9506121d67fb918ac47af0b883730694be9377c | Solidity | Kannabiz | contract Kannabiz is ERC20Interface, Owned
{
using SafeMath for uint;
using ExtendedMath for uint;
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
uint public latestDifficultyPeriodStarted;
uint public epochCount; //number of 'blocks' mine... | // ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and an
// initial fixed supply
// ---------------------------------------------------------------------------- | LineComment | transferFrom | function transferFrom(address from, address to, uint tokens) public returns (bool success)
{
if ((frozenAccount[msg.sender]) || (frozenAccount[from]) || (frozenAccount[to]))
{
return false;
}
else
{
balances[from] = balances[from].sub(tokens);
allowed[from][msg... | // ------------------------------------------------------------------------
// Transfer `tokens` from the `from` account to the `to` account
//
// The calling account must already have sufficient tokens approve(...)-d
// for spending from the `from` account and
// - From account must have sufficient balance to transfer... | LineComment | v0.4.18+commit.9cf6e910 | MIT | bzzr://36f2cb1a1a9ef7dc23ca6748643c1e70e2de61a55de2af8061617bc05ba7c865 | {
"func_code_index": [
12100,
12633
]
} | 12,204 |
Kannabiz | Kannabiz.sol | 0xd9506121d67fb918ac47af0b883730694be9377c | Solidity | Kannabiz | contract Kannabiz is ERC20Interface, Owned
{
using SafeMath for uint;
using ExtendedMath for uint;
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
uint public latestDifficultyPeriodStarted;
uint public epochCount; //number of 'blocks' mine... | // ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and an
// initial fixed supply
// ---------------------------------------------------------------------------- | LineComment | allowance | function allowance(address tokenOwner, address spender) public constant returns (uint remaining)
{
return allowed[tokenOwner][spender];
}
| // ------------------------------------------------------------------------
// Returns the amount of tokens approved by the owner that can be
// transferred to the spender's account
// ------------------------------------------------------------------------ | LineComment | v0.4.18+commit.9cf6e910 | MIT | bzzr://36f2cb1a1a9ef7dc23ca6748643c1e70e2de61a55de2af8061617bc05ba7c865 | {
"func_code_index": [
12916,
13079
]
} | 12,205 |
Kannabiz | Kannabiz.sol | 0xd9506121d67fb918ac47af0b883730694be9377c | Solidity | Kannabiz | contract Kannabiz is ERC20Interface, Owned
{
using SafeMath for uint;
using ExtendedMath for uint;
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
uint public latestDifficultyPeriodStarted;
uint public epochCount; //number of 'blocks' mine... | // ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and an
// initial fixed supply
// ---------------------------------------------------------------------------- | LineComment | approveAndCall | function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success)
{
if ((frozenAccount[msg.sender]) || (frozenAccount[spender]))
{
return false;
}
else
{
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);... | // ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account. The `spender` contract function
// `receiveApproval(...)` is then executed
// ------------------------------------------------------------... | LineComment | v0.4.18+commit.9cf6e910 | MIT | bzzr://36f2cb1a1a9ef7dc23ca6748643c1e70e2de61a55de2af8061617bc05ba7c865 | {
"func_code_index": [
13441,
13927
]
} | 12,206 |
Kannabiz | Kannabiz.sol | 0xd9506121d67fb918ac47af0b883730694be9377c | Solidity | Kannabiz | contract Kannabiz is ERC20Interface, Owned
{
using SafeMath for uint;
using ExtendedMath for uint;
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
uint public latestDifficultyPeriodStarted;
uint public epochCount; //number of 'blocks' mine... | // ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and an
// initial fixed supply
// ---------------------------------------------------------------------------- | LineComment | function () public payable
{
revert();
}
| // ------------------------------------------------------------------------
// Don't accept ETH
// ------------------------------------------------------------------------ | LineComment | v0.4.18+commit.9cf6e910 | MIT | bzzr://36f2cb1a1a9ef7dc23ca6748643c1e70e2de61a55de2af8061617bc05ba7c865 | {
"func_code_index": [
14494,
14560
]
} | 12,207 | |
Kannabiz | Kannabiz.sol | 0xd9506121d67fb918ac47af0b883730694be9377c | Solidity | Kannabiz | contract Kannabiz is ERC20Interface, Owned
{
using SafeMath for uint;
using ExtendedMath for uint;
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
uint public latestDifficultyPeriodStarted;
uint public epochCount; //number of 'blocks' mine... | // ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and an
// initial fixed supply
// ---------------------------------------------------------------------------- | LineComment | transferAnyERC20Token | function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success)
{
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
| // ------------------------------------------------------------------------
// Owner can transfer out any accidentally sent ERC20 tokens
// ------------------------------------------------------------------------ | LineComment | v0.4.18+commit.9cf6e910 | MIT | bzzr://36f2cb1a1a9ef7dc23ca6748643c1e70e2de61a55de2af8061617bc05ba7c865 | {
"func_code_index": [
14794,
14990
]
} | 12,208 |
Wrapped_JAXNET_Token_ERC20 | contracts/Wrapped_JAXNET_Token.sol | 0xca1262e77fb25c0a4112cfc9bad3ff54f617f2e6 | Solidity | Wrapped_JAXNET_Token_ERC20 | contract Wrapped_JAXNET_Token_ERC20 is Ownable, ERC20, Pausable {
constructor(address owner) ERC20("Wrapped JAXNET", "WJXN") {
_mint(owner, 40002164);
_pause();
transferOwnership(owner);
}
function decimals() public pure override returns (uint8) {
return 0;
}
/... | /* This contract created to support token distribution in JaxNet project
* By default, all transfers are paused. Except function, transferFromOwner, which allows
* to distribute tokens.
* Supply is limited to 40002164
* Owner of contract may burn coins from his account
*/ | Comment | pause | function pause() public onlyOwner {
_pause();
}
| /**
* @dev Pauses all token transfers.
*
* See {ERC20Pausable} and {Pausable-_pause}.
*
* Requirements:
*
* - the caller must be contract owner
*/ | NatSpecMultiLine | v0.8.4+commit.c7e474f2 | {
"func_code_index": [
506,
569
]
} | 12,209 | ||
Wrapped_JAXNET_Token_ERC20 | contracts/Wrapped_JAXNET_Token.sol | 0xca1262e77fb25c0a4112cfc9bad3ff54f617f2e6 | Solidity | Wrapped_JAXNET_Token_ERC20 | contract Wrapped_JAXNET_Token_ERC20 is Ownable, ERC20, Pausable {
constructor(address owner) ERC20("Wrapped JAXNET", "WJXN") {
_mint(owner, 40002164);
_pause();
transferOwnership(owner);
}
function decimals() public pure override returns (uint8) {
return 0;
}
/... | /* This contract created to support token distribution in JaxNet project
* By default, all transfers are paused. Except function, transferFromOwner, which allows
* to distribute tokens.
* Supply is limited to 40002164
* Owner of contract may burn coins from his account
*/ | Comment | unpause | function unpause() public onlyOwner {
_unpause();
}
| /**
* @dev Unpauses all token transfers.
*
* See {ERC20Pausable} and {Pausable-_unpause}.
*
* Requirements:
*
* - the caller must be contract owner.
*/ | NatSpecMultiLine | v0.8.4+commit.c7e474f2 | {
"func_code_index": [
767,
834
]
} | 12,210 | ||
Wrapped_JAXNET_Token_ERC20 | contracts/Wrapped_JAXNET_Token.sol | 0xca1262e77fb25c0a4112cfc9bad3ff54f617f2e6 | Solidity | Wrapped_JAXNET_Token_ERC20 | contract Wrapped_JAXNET_Token_ERC20 is Ownable, ERC20, Pausable {
constructor(address owner) ERC20("Wrapped JAXNET", "WJXN") {
_mint(owner, 40002164);
_pause();
transferOwnership(owner);
}
function decimals() public pure override returns (uint8) {
return 0;
}
/... | /* This contract created to support token distribution in JaxNet project
* By default, all transfers are paused. Except function, transferFromOwner, which allows
* to distribute tokens.
* Supply is limited to 40002164
* Owner of contract may burn coins from his account
*/ | Comment | _beforeTokenTransfer | function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal override {
super._beforeTokenTransfer(from, to, amount);
require(!paused(), "ERC20Pausable: token transfer while paused");
}
| /**
* @dev Check if system is not paused.
*/ | NatSpecMultiLine | v0.8.4+commit.c7e474f2 | {
"func_code_index": [
896,
1156
]
} | 12,211 | ||
Wrapped_JAXNET_Token_ERC20 | contracts/Wrapped_JAXNET_Token.sol | 0xca1262e77fb25c0a4112cfc9bad3ff54f617f2e6 | Solidity | Wrapped_JAXNET_Token_ERC20 | contract Wrapped_JAXNET_Token_ERC20 is Ownable, ERC20, Pausable {
constructor(address owner) ERC20("Wrapped JAXNET", "WJXN") {
_mint(owner, 40002164);
_pause();
transferOwnership(owner);
}
function decimals() public pure override returns (uint8) {
return 0;
}
/... | /* This contract created to support token distribution in JaxNet project
* By default, all transfers are paused. Except function, transferFromOwner, which allows
* to distribute tokens.
* Supply is limited to 40002164
* Owner of contract may burn coins from his account
*/ | Comment | burn | function burn(uint256 amount) public onlyOwner {
_burn(_msgSender(), amount);
}
| /**
* @dev Destroys `amount` tokens from the caller.
*/ | NatSpecMultiLine | v0.8.4+commit.c7e474f2 | {
"func_code_index": [
1228,
1323
]
} | 12,212 | ||
EsportsPro | @openzeppelin\contracts\token\ERC20\ERC20Capped.sol | 0x29c56e7cb9c840d2b2371b17e28bab44ad3c3ead | Solidity | ERC20Capped | abstract contract ERC20Capped is ERC20 {
using SafeMath for uint256;
uint256 private _cap;
/**
* @dev Sets the value of the `cap`. This value is immutable, it can only be
* set once during construction.
*/
constructor (uint256 cap_) internal {
require(cap_ > 0, "ERC20C... | /**
* @dev Extension of {ERC20} that adds a cap to the supply of tokens.
*/ | NatSpecMultiLine | cap | function cap() public view virtual returns (uint256) {
return _cap;
}
| /**
* @dev Returns the cap on the token's total supply.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://e48c8eeefff0faddbad81c0ec41116429af4e84586d2d4749ad34c84e493fa75 | {
"func_code_index": [
447,
535
]
} | 12,213 |
EsportsPro | @openzeppelin\contracts\token\ERC20\ERC20Capped.sol | 0x29c56e7cb9c840d2b2371b17e28bab44ad3c3ead | Solidity | ERC20Capped | abstract contract ERC20Capped is ERC20 {
using SafeMath for uint256;
uint256 private _cap;
/**
* @dev Sets the value of the `cap`. This value is immutable, it can only be
* set once during construction.
*/
constructor (uint256 cap_) internal {
require(cap_ > 0, "ERC20C... | /**
* @dev Extension of {ERC20} that adds a cap to the supply of tokens.
*/ | NatSpecMultiLine | _beforeTokenTransfer | function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual override {
super._beforeTokenTransfer(from, to, amount);
if (from == address(0)) { // When minting tokens
require(totalSupply().add(amount) <= cap(), "ERC20Capped: cap exceeded");
}
}
| /**
* @dev See {ERC20-_beforeTokenTransfer}.
*
* Requirements:
*
* - minted tokens must not cause the total supply to go over the cap.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://e48c8eeefff0faddbad81c0ec41116429af4e84586d2d4749ad34c84e493fa75 | {
"func_code_index": [
717,
1041
]
} | 12,214 |
SpiderFarm | SpiderFarm.sol | 0x25e1779f5f2fbdd378ced1a338f6c26aeb3d6ad0 | Solidity | SpiderFarm | contract SpiderFarm{
//uint256 EGGS_PER_SHRIMP_PER_SECOND=1;
uint256 public EGGS_TO_HATCH_1SHRIMP=86400;//for final version should be seconds in a day
uint256 public STARTING_SHRIMP=50;
uint256 PSN=10000;
uint256 PSNH=5000;
uint256 startTime;
bool public initialized=false;
addres... | // similar to shrimp/snail
// you lose one third of your spiders on sell anti-inflation + longevity
// freebies on a set price of 0.001 and only 50 anti-bot
// ... | LineComment | calculateTrade | function calculateTrade(uint256 rt,uint256 rs, uint256 bs) public view returns(uint256){
//(PSN*bs)/(PSNH+((PSN*rs+PSNH*rt)/rt));
return SafeMath.div(SafeMath.mul(PSN,bs),SafeMath.add(PSNH,SafeMath.div(SafeMath.add(SafeMath.mul(PSN,rs),SafeMath.mul(PSNH,rt)),rt)));
}
| //magic trade balancing algorithm | LineComment | v0.4.24+commit.e67f0147 | bzzr://08973e877a676516cd38692b1311ee013ce7d4b71d521f8ac4771785966ea2ac | {
"func_code_index": [
3298,
3593
]
} | 12,215 | |
SpiderFarm | SpiderFarm.sol | 0x25e1779f5f2fbdd378ced1a338f6c26aeb3d6ad0 | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
/**
* @dev Integer division of two numbe... | mul | function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
| /**
* @dev Multiplies two numbers, throws on overflow.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://08973e877a676516cd38692b1311ee013ce7d4b71d521f8ac4771785966ea2ac | {
"func_code_index": [
89,
272
]
} | 12,216 | |||
SpiderFarm | SpiderFarm.sol | 0x25e1779f5f2fbdd378ced1a338f6c26aeb3d6ad0 | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
/**
* @dev Integer division of two numbe... | div | function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
| /**
* @dev Integer division of two numbers, truncating the quotient.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://08973e877a676516cd38692b1311ee013ce7d4b71d521f8ac4771785966ea2ac | {
"func_code_index": [
356,
629
]
} | 12,217 | |||
SpiderFarm | SpiderFarm.sol | 0x25e1779f5f2fbdd378ced1a338f6c26aeb3d6ad0 | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
/**
* @dev Integer division of two numbe... | sub | function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
| /**
* @dev Substracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://08973e877a676516cd38692b1311ee013ce7d4b71d521f8ac4771785966ea2ac | {
"func_code_index": [
744,
860
]
} | 12,218 | |||
SpiderFarm | SpiderFarm.sol | 0x25e1779f5f2fbdd378ced1a338f6c26aeb3d6ad0 | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
/**
* @dev Integer division of two numbe... | add | function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
| /**
* @dev Adds two numbers, throws on overflow.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://08973e877a676516cd38692b1311ee013ce7d4b71d521f8ac4771785966ea2ac | {
"func_code_index": [
924,
1060
]
} | 12,219 | |||
BabyAXIE | @openzeppelin/contracts/token/ERC20/IERC20.sol | 0x39db8e213ebf84d713383bf51c621d210bc1fa17 | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values fo... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our... | NatSpecMultiLine | name | function name() public view virtual override returns (string memory) {
return _name;
}
| /**
* @dev Returns the name of the token.
*/ | NatSpecMultiLine | v0.8.4+commit.c7e474f2 | MIT | ipfs://a9bfcd486b1700b948ab2234b7cda1203427abeeef98f725108722ab9937fa21 | {
"func_code_index": [
779,
884
]
} | 12,220 |
BabyAXIE | @openzeppelin/contracts/token/ERC20/IERC20.sol | 0x39db8e213ebf84d713383bf51c621d210bc1fa17 | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values fo... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our... | NatSpecMultiLine | symbol | function symbol() public view virtual override returns (string memory) {
return _symbol;
}
| /**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/ | NatSpecMultiLine | v0.8.4+commit.c7e474f2 | MIT | ipfs://a9bfcd486b1700b948ab2234b7cda1203427abeeef98f725108722ab9937fa21 | {
"func_code_index": [
998,
1107
]
} | 12,221 |
BabyAXIE | @openzeppelin/contracts/token/ERC20/IERC20.sol | 0x39db8e213ebf84d713383bf51c621d210bc1fa17 | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values fo... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our... | NatSpecMultiLine | decimals | function decimals() public view virtual override returns (uint8) {
return 18;
}
| /**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is... | NatSpecMultiLine | v0.8.4+commit.c7e474f2 | MIT | ipfs://a9bfcd486b1700b948ab2234b7cda1203427abeeef98f725108722ab9937fa21 | {
"func_code_index": [
1741,
1839
]
} | 12,222 |
BabyAXIE | @openzeppelin/contracts/token/ERC20/IERC20.sol | 0x39db8e213ebf84d713383bf51c621d210bc1fa17 | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values fo... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our... | NatSpecMultiLine | totalSupply | function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
| /**
* @dev See {IERC20-totalSupply}.
*/ | NatSpecMultiLine | v0.8.4+commit.c7e474f2 | MIT | ipfs://a9bfcd486b1700b948ab2234b7cda1203427abeeef98f725108722ab9937fa21 | {
"func_code_index": [
1899,
2012
]
} | 12,223 |
BabyAXIE | @openzeppelin/contracts/token/ERC20/IERC20.sol | 0x39db8e213ebf84d713383bf51c621d210bc1fa17 | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values fo... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our... | NatSpecMultiLine | balanceOf | function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
| /**
* @dev See {IERC20-balanceOf}.
*/ | NatSpecMultiLine | v0.8.4+commit.c7e474f2 | MIT | ipfs://a9bfcd486b1700b948ab2234b7cda1203427abeeef98f725108722ab9937fa21 | {
"func_code_index": [
2070,
2202
]
} | 12,224 |
BabyAXIE | @openzeppelin/contracts/token/ERC20/IERC20.sol | 0x39db8e213ebf84d713383bf51c621d210bc1fa17 | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values fo... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our... | NatSpecMultiLine | transfer | function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
| /**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/ | NatSpecMultiLine | v0.8.4+commit.c7e474f2 | MIT | ipfs://a9bfcd486b1700b948ab2234b7cda1203427abeeef98f725108722ab9937fa21 | {
"func_code_index": [
2410,
2590
]
} | 12,225 |
BabyAXIE | @openzeppelin/contracts/token/ERC20/IERC20.sol | 0x39db8e213ebf84d713383bf51c621d210bc1fa17 | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values fo... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our... | NatSpecMultiLine | allowance | function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
| /**
* @dev See {IERC20-allowance}.
*/ | NatSpecMultiLine | v0.8.4+commit.c7e474f2 | MIT | ipfs://a9bfcd486b1700b948ab2234b7cda1203427abeeef98f725108722ab9937fa21 | {
"func_code_index": [
2648,
2804
]
} | 12,226 |
BabyAXIE | @openzeppelin/contracts/token/ERC20/IERC20.sol | 0x39db8e213ebf84d713383bf51c621d210bc1fa17 | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values fo... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our... | NatSpecMultiLine | approve | function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
| /**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/ | NatSpecMultiLine | v0.8.4+commit.c7e474f2 | MIT | ipfs://a9bfcd486b1700b948ab2234b7cda1203427abeeef98f725108722ab9937fa21 | {
"func_code_index": [
2946,
3120
]
} | 12,227 |
BabyAXIE | @openzeppelin/contracts/token/ERC20/IERC20.sol | 0x39db8e213ebf84d713383bf51c621d210bc1fa17 | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values fo... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our... | NatSpecMultiLine | transferFrom | function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
_ap... | /**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* Requirements:
*
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `... | NatSpecMultiLine | v0.8.4+commit.c7e474f2 | MIT | ipfs://a9bfcd486b1700b948ab2234b7cda1203427abeeef98f725108722ab9937fa21 | {
"func_code_index": [
3597,
4024
]
} | 12,228 |
BabyAXIE | @openzeppelin/contracts/token/ERC20/IERC20.sol | 0x39db8e213ebf84d713383bf51c621d210bc1fa17 | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values fo... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our... | NatSpecMultiLine | increaseAllowance | function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + 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.8.4+commit.c7e474f2 | MIT | ipfs://a9bfcd486b1700b948ab2234b7cda1203427abeeef98f725108722ab9937fa21 | {
"func_code_index": [
4428,
4648
]
} | 12,229 |
BabyAXIE | @openzeppelin/contracts/token/ERC20/IERC20.sol | 0x39db8e213ebf84d713383bf51c621d210bc1fa17 | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values fo... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our... | NatSpecMultiLine | decreaseAllowance | function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
uint256 currentAllowance = _allowances[_msgSender()][spender];
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
_approve(_msgSender(), spender, currentAllowance - sub... | /**
* @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.8.4+commit.c7e474f2 | MIT | ipfs://a9bfcd486b1700b948ab2234b7cda1203427abeeef98f725108722ab9937fa21 | {
"func_code_index": [
5146,
5528
]
} | 12,230 |
BabyAXIE | @openzeppelin/contracts/token/ERC20/IERC20.sol | 0x39db8e213ebf84d713383bf51c621d210bc1fa17 | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values fo... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our... | NatSpecMultiLine | _transfer | function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
uint256 sende... | /**
* @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.8.4+commit.c7e474f2 | MIT | ipfs://a9bfcd486b1700b948ab2234b7cda1203427abeeef98f725108722ab9937fa21 | {
"func_code_index": [
6013,
6622
]
} | 12,231 |
BabyAXIE | @openzeppelin/contracts/token/ERC20/IERC20.sol | 0x39db8e213ebf84d713383bf51c621d210bc1fa17 | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values fo... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our... | NatSpecMultiLine | _mint | function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
_balances[account] += amount;
emit Transfer(address(0), account, amount);
}
| /** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements:
*
* - `to` cannot be the zero address.
*/ | NatSpecMultiLine | v0.8.4+commit.c7e474f2 | MIT | ipfs://a9bfcd486b1700b948ab2234b7cda1203427abeeef98f725108722ab9937fa21 | {
"func_code_index": [
6899,
7242
]
} | 12,232 |
BabyAXIE | @openzeppelin/contracts/token/ERC20/IERC20.sol | 0x39db8e213ebf84d713383bf51c621d210bc1fa17 | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values fo... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our... | NatSpecMultiLine | _burn | function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds ba... | /**
* @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.8.4+commit.c7e474f2 | MIT | ipfs://a9bfcd486b1700b948ab2234b7cda1203427abeeef98f725108722ab9937fa21 | {
"func_code_index": [
7570,
8069
]
} | 12,233 |
BabyAXIE | @openzeppelin/contracts/token/ERC20/IERC20.sol | 0x39db8e213ebf84d713383bf51c621d210bc1fa17 | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values fo... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our... | NatSpecMultiLine | _approve | function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amoun... | /**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero a... | NatSpecMultiLine | v0.8.4+commit.c7e474f2 | MIT | ipfs://a9bfcd486b1700b948ab2234b7cda1203427abeeef98f725108722ab9937fa21 | {
"func_code_index": [
8502,
8853
]
} | 12,234 |
BabyAXIE | @openzeppelin/contracts/token/ERC20/IERC20.sol | 0x39db8e213ebf84d713383bf51c621d210bc1fa17 | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values fo... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our... | NatSpecMultiLine | _beforeTokenTransfer | function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
| /**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be to transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* -... | NatSpecMultiLine | v0.8.4+commit.c7e474f2 | MIT | ipfs://a9bfcd486b1700b948ab2234b7cda1203427abeeef98f725108722ab9937fa21 | {
"func_code_index": [
9451,
9548
]
} | 12,235 |
BabyAXIE | @openzeppelin/contracts/token/ERC20/IERC20.sol | 0x39db8e213ebf84d713383bf51c621d210bc1fa17 | Solidity | BabyAXIE | contract BabyAXIE is ERC20, Owned {
uint256 public minSupply;
address public beneficiary;
bool public feesEnabled;
mapping(address => bool) public isExcludedFromFee;
event MinSupplyUpdated(uint256 oldAmount, uint256 newAmount);
event BeneficiaryUpdated(address oldBeneficiary, address ne... | _transfer | function _transfer(
address sender,
address recipient,
uint256 amount
) internal override {
require(
recipient != address(this),
"Cannot send tokens to token contract"
);
if (
!feesEnabled ||
isExcludedFromFee[sender] ||
isExcludedFromFee[recip... | /**
* @dev if fees are enabled, subtract 2.25% fee and send it to beneficiary
* @dev after a certain threshold, try to swap collected fees automatically
* @dev if automatic swap fails (or beneficiary does not implement swapTokens function) transfer should still succeed
*/ | NatSpecMultiLine | v0.8.4+commit.c7e474f2 | MIT | ipfs://a9bfcd486b1700b948ab2234b7cda1203427abeeef98f725108722ab9937fa21 | {
"func_code_index": [
1139,
2083
]
} | 12,236 | ||
BabyAXIE | @openzeppelin/contracts/token/ERC20/IERC20.sol | 0x39db8e213ebf84d713383bf51c621d210bc1fa17 | Solidity | BabyAXIE | contract BabyAXIE is ERC20, Owned {
uint256 public minSupply;
address public beneficiary;
bool public feesEnabled;
mapping(address => bool) public isExcludedFromFee;
event MinSupplyUpdated(uint256 oldAmount, uint256 newAmount);
event BeneficiaryUpdated(address oldBeneficiary, address ne... | burn | function burn(uint256 value) public {
_burn(_msgSender(), value);
require(totalSupply() >= minSupply, "total supply exceeds min supply");
}
| /**
* @notice allows to burn tokens from own balance
* @dev only allows burning tokens until minimum supply is reached
* @param value amount of tokens to burn
*/ | NatSpecMultiLine | v0.8.4+commit.c7e474f2 | MIT | ipfs://a9bfcd486b1700b948ab2234b7cda1203427abeeef98f725108722ab9937fa21 | {
"func_code_index": [
2450,
2617
]
} | 12,237 | ||
BabyAXIE | @openzeppelin/contracts/token/ERC20/IERC20.sol | 0x39db8e213ebf84d713383bf51c621d210bc1fa17 | Solidity | BabyAXIE | contract BabyAXIE is ERC20, Owned {
uint256 public minSupply;
address public beneficiary;
bool public feesEnabled;
mapping(address => bool) public isExcludedFromFee;
event MinSupplyUpdated(uint256 oldAmount, uint256 newAmount);
event BeneficiaryUpdated(address oldBeneficiary, address ne... | setMinSupply | function setMinSupply(uint256 _newMinSupply) public onlyOwner {
emit MinSupplyUpdated(minSupply, _newMinSupply);
minSupply = _newMinSupply;
}
| /**
* @notice sets minimum supply of the token
* @dev only callable by owner
* @param _newMinSupply new minimum supply
*/ | NatSpecMultiLine | v0.8.4+commit.c7e474f2 | MIT | ipfs://a9bfcd486b1700b948ab2234b7cda1203427abeeef98f725108722ab9937fa21 | {
"func_code_index": [
2771,
2940
]
} | 12,238 | ||
BabyAXIE | @openzeppelin/contracts/token/ERC20/IERC20.sol | 0x39db8e213ebf84d713383bf51c621d210bc1fa17 | Solidity | BabyAXIE | contract BabyAXIE is ERC20, Owned {
uint256 public minSupply;
address public beneficiary;
bool public feesEnabled;
mapping(address => bool) public isExcludedFromFee;
event MinSupplyUpdated(uint256 oldAmount, uint256 newAmount);
event BeneficiaryUpdated(address oldBeneficiary, address ne... | setBeneficiary | function setBeneficiary(address _newBeneficiary) public onlyOwner {
setExcludeFromFee(_newBeneficiary, true);
emit BeneficiaryUpdated(beneficiary, _newBeneficiary);
beneficiary = _newBeneficiary;
}
| /**
* @notice sets recipient of transfer fee
* @dev only callable by owner
* @param _newBeneficiary new beneficiary
*/ | NatSpecMultiLine | v0.8.4+commit.c7e474f2 | MIT | ipfs://a9bfcd486b1700b948ab2234b7cda1203427abeeef98f725108722ab9937fa21 | {
"func_code_index": [
3096,
3330
]
} | 12,239 | ||
BabyAXIE | @openzeppelin/contracts/token/ERC20/IERC20.sol | 0x39db8e213ebf84d713383bf51c621d210bc1fa17 | Solidity | BabyAXIE | contract BabyAXIE is ERC20, Owned {
uint256 public minSupply;
address public beneficiary;
bool public feesEnabled;
mapping(address => bool) public isExcludedFromFee;
event MinSupplyUpdated(uint256 oldAmount, uint256 newAmount);
event BeneficiaryUpdated(address oldBeneficiary, address ne... | setFeesEnabled | function setFeesEnabled(bool _enabled) public onlyOwner {
emit FeesEnabledUpdated(_enabled);
feesEnabled = _enabled;
}
| /**
* @notice sets whether account collects fees on token transfer
* @dev only callable by owner
* @param _enabled bool whether fees are enabled
*/ | NatSpecMultiLine | v0.8.4+commit.c7e474f2 | MIT | ipfs://a9bfcd486b1700b948ab2234b7cda1203427abeeef98f725108722ab9937fa21 | {
"func_code_index": [
3510,
3656
]
} | 12,240 | ||
BabyAXIE | @openzeppelin/contracts/token/ERC20/IERC20.sol | 0x39db8e213ebf84d713383bf51c621d210bc1fa17 | Solidity | BabyAXIE | contract BabyAXIE is ERC20, Owned {
uint256 public minSupply;
address public beneficiary;
bool public feesEnabled;
mapping(address => bool) public isExcludedFromFee;
event MinSupplyUpdated(uint256 oldAmount, uint256 newAmount);
event BeneficiaryUpdated(address oldBeneficiary, address ne... | setExcludeFromFee | function setExcludeFromFee(address _account, bool _excluded)
public
onlyOwner
{
isExcludedFromFee[_account] = _excluded;
emit ExcludedFromFeeUpdated(_account, _excluded);
}
| /**
* @notice adds or removes an account that is exempt from fee collection
* @dev only callable by owner
* @param _account account to modify
* @param _excluded new value
*/ | NatSpecMultiLine | v0.8.4+commit.c7e474f2 | MIT | ipfs://a9bfcd486b1700b948ab2234b7cda1203427abeeef98f725108722ab9937fa21 | {
"func_code_index": [
3868,
4091
]
} | 12,241 | ||
Synthetix | Synthetix.sol | 0x7cb89c509001d25da9938999abfea6740212e5f0 | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, reverts on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/Ope... | /**
* @title SafeMath
* @dev Math operations with safety checks that revert on error
*/ | NatSpecMultiLine | mul | function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a *... | /**
* @dev Multiplies two numbers, reverts on overflow.
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://7e5de7b2c8454afb4fecf2a46fa9ccc0e392fe2b302da0369358c02ba4f12d11 | {
"func_code_index": [
85,
468
]
} | 12,242 | |
Synthetix | Synthetix.sol | 0x7cb89c509001d25da9938999abfea6740212e5f0 | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, reverts on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/Ope... | /**
* @title SafeMath
* @dev Math operations with safety checks that revert on error
*/ | NatSpecMultiLine | div | function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0); // Solidity only automatically asserts when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
| /**
* @dev Integer division of two numbers truncating the quotient, reverts on division by zero.
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://7e5de7b2c8454afb4fecf2a46fa9ccc0e392fe2b302da0369358c02ba4f12d11 | {
"func_code_index": [
576,
848
]
} | 12,243 | |
Synthetix | Synthetix.sol | 0x7cb89c509001d25da9938999abfea6740212e5f0 | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, reverts on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/Ope... | /**
* @title SafeMath
* @dev Math operations with safety checks that revert on error
*/ | NatSpecMultiLine | sub | function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
| /**
* @dev Subtracts two numbers, reverts on overflow (i.e. if subtrahend is greater than minuend).
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://7e5de7b2c8454afb4fecf2a46fa9ccc0e392fe2b302da0369358c02ba4f12d11 | {
"func_code_index": [
959,
1092
]
} | 12,244 | |
Synthetix | Synthetix.sol | 0x7cb89c509001d25da9938999abfea6740212e5f0 | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, reverts on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/Ope... | /**
* @title SafeMath
* @dev Math operations with safety checks that revert on error
*/ | NatSpecMultiLine | add | function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
| /**
* @dev Adds two numbers, reverts on overflow.
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://7e5de7b2c8454afb4fecf2a46fa9ccc0e392fe2b302da0369358c02ba4f12d11 | {
"func_code_index": [
1153,
1286
]
} | 12,245 | |
Synthetix | Synthetix.sol | 0x7cb89c509001d25da9938999abfea6740212e5f0 | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, reverts on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/Ope... | /**
* @title SafeMath
* @dev Math operations with safety checks that revert on error
*/ | NatSpecMultiLine | mod | function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
| /**
* @dev Divides two numbers and returns the remainder (unsigned integer modulo),
* reverts when dividing by zero.
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://7e5de7b2c8454afb4fecf2a46fa9ccc0e392fe2b302da0369358c02ba4f12d11 | {
"func_code_index": [
1416,
1529
]
} | 12,246 | |
Synthetix | Synthetix.sol | 0x7cb89c509001d25da9938999abfea6740212e5f0 | Solidity | SafeDecimalMath | library SafeDecimalMath {
using SafeMath for uint;
/* Number of decimal places in the representations. */
uint8 public constant decimals = 18;
uint8 public constant highPrecisionDecimals = 27;
/* The number representing 1.0. */
uint public constant UNIT = 10 ** uint(decimals);
/* The num... | /**
* @title Safely manipulate unsigned fixed-point decimals at a given precision level.
* @dev Functions accepting uints in this contract and derived contracts
* are taken to be such fixed point decimals of a specified precision (either standard
* or high).
*/ | NatSpecMultiLine | unit | function unit()
external
pure
returns (uint)
{
return UNIT;
}
| /**
* @return Provides an interface to UNIT.
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://7e5de7b2c8454afb4fecf2a46fa9ccc0e392fe2b302da0369358c02ba4f12d11 | {
"func_code_index": [
627,
732
]
} | 12,247 | |
Synthetix | Synthetix.sol | 0x7cb89c509001d25da9938999abfea6740212e5f0 | Solidity | SafeDecimalMath | library SafeDecimalMath {
using SafeMath for uint;
/* Number of decimal places in the representations. */
uint8 public constant decimals = 18;
uint8 public constant highPrecisionDecimals = 27;
/* The number representing 1.0. */
uint public constant UNIT = 10 ** uint(decimals);
/* The num... | /**
* @title Safely manipulate unsigned fixed-point decimals at a given precision level.
* @dev Functions accepting uints in this contract and derived contracts
* are taken to be such fixed point decimals of a specified precision (either standard
* or high).
*/ | NatSpecMultiLine | preciseUnit | function preciseUnit()
external
pure
returns (uint)
{
return PRECISE_UNIT;
}
| /**
* @return Provides an interface to PRECISE_UNIT.
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://7e5de7b2c8454afb4fecf2a46fa9ccc0e392fe2b302da0369358c02ba4f12d11 | {
"func_code_index": [
805,
926
]
} | 12,248 | |
Synthetix | Synthetix.sol | 0x7cb89c509001d25da9938999abfea6740212e5f0 | Solidity | SafeDecimalMath | library SafeDecimalMath {
using SafeMath for uint;
/* Number of decimal places in the representations. */
uint8 public constant decimals = 18;
uint8 public constant highPrecisionDecimals = 27;
/* The number representing 1.0. */
uint public constant UNIT = 10 ** uint(decimals);
/* The num... | /**
* @title Safely manipulate unsigned fixed-point decimals at a given precision level.
* @dev Functions accepting uints in this contract and derived contracts
* are taken to be such fixed point decimals of a specified precision (either standard
* or high).
*/ | NatSpecMultiLine | multiplyDecimal | function multiplyDecimal(uint x, uint y)
internal
pure
returns (uint)
{
/* Divide by UNIT to remove the extra factor introduced by the product. */
return x.mul(y) / UNIT;
}
| /**
* @return The result of multiplying x and y, interpreting the operands as fixed-point
* decimals.
*
* @dev A unit factor is divided out after the product of x and y is evaluated,
* so that product must be less than 2**256. As this is an integer division,
* the internal division always rounds down. This helps ... | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://7e5de7b2c8454afb4fecf2a46fa9ccc0e392fe2b302da0369358c02ba4f12d11 | {
"func_code_index": [
1340,
1564
]
} | 12,249 | |
Synthetix | Synthetix.sol | 0x7cb89c509001d25da9938999abfea6740212e5f0 | Solidity | SafeDecimalMath | library SafeDecimalMath {
using SafeMath for uint;
/* Number of decimal places in the representations. */
uint8 public constant decimals = 18;
uint8 public constant highPrecisionDecimals = 27;
/* The number representing 1.0. */
uint public constant UNIT = 10 ** uint(decimals);
/* The num... | /**
* @title Safely manipulate unsigned fixed-point decimals at a given precision level.
* @dev Functions accepting uints in this contract and derived contracts
* are taken to be such fixed point decimals of a specified precision (either standard
* or high).
*/ | NatSpecMultiLine | _multiplyDecimalRound | function _multiplyDecimalRound(uint x, uint y, uint precisionUnit)
private
pure
returns (uint)
{
/* Divide by UNIT to remove the extra factor introduced by the product. */
uint quotientTimesTen = x.mul(y) / (precisionUnit / 10);
if (quotientTimesTen % 10 >= 5) {
quotientTimesTen += 10;
... | /**
* @return The result of safely multiplying x and y, interpreting the operands
* as fixed-point decimals of the specified precision unit.
*
* @dev The operands should be in the form of a the specified unit factor which will be
* divided out after the product of x and y is evaluated, so that product must be
* l... | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://7e5de7b2c8454afb4fecf2a46fa9ccc0e392fe2b302da0369358c02ba4f12d11 | {
"func_code_index": [
2165,
2575
]
} | 12,250 | |
Synthetix | Synthetix.sol | 0x7cb89c509001d25da9938999abfea6740212e5f0 | Solidity | SafeDecimalMath | library SafeDecimalMath {
using SafeMath for uint;
/* Number of decimal places in the representations. */
uint8 public constant decimals = 18;
uint8 public constant highPrecisionDecimals = 27;
/* The number representing 1.0. */
uint public constant UNIT = 10 ** uint(decimals);
/* The num... | /**
* @title Safely manipulate unsigned fixed-point decimals at a given precision level.
* @dev Functions accepting uints in this contract and derived contracts
* are taken to be such fixed point decimals of a specified precision (either standard
* or high).
*/ | NatSpecMultiLine | multiplyDecimalRoundPrecise | function multiplyDecimalRoundPrecise(uint x, uint y)
internal
pure
returns (uint)
{
return _multiplyDecimalRound(x, y, PRECISE_UNIT);
}
| /**
* @return The result of safely multiplying x and y, interpreting the operands
* as fixed-point decimals of a precise unit.
*
* @dev The operands should be in the precise unit factor which will be
* divided out after the product of x and y is evaluated, so that product must be
* less than 2**256.
*
* Unlike ... | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://7e5de7b2c8454afb4fecf2a46fa9ccc0e392fe2b302da0369358c02ba4f12d11 | {
"func_code_index": [
3146,
3325
]
} | 12,251 | |
Synthetix | Synthetix.sol | 0x7cb89c509001d25da9938999abfea6740212e5f0 | Solidity | SafeDecimalMath | library SafeDecimalMath {
using SafeMath for uint;
/* Number of decimal places in the representations. */
uint8 public constant decimals = 18;
uint8 public constant highPrecisionDecimals = 27;
/* The number representing 1.0. */
uint public constant UNIT = 10 ** uint(decimals);
/* The num... | /**
* @title Safely manipulate unsigned fixed-point decimals at a given precision level.
* @dev Functions accepting uints in this contract and derived contracts
* are taken to be such fixed point decimals of a specified precision (either standard
* or high).
*/ | NatSpecMultiLine | multiplyDecimalRound | function multiplyDecimalRound(uint x, uint y)
internal
pure
returns (uint)
{
return _multiplyDecimalRound(x, y, UNIT);
}
| /**
* @return The result of safely multiplying x and y, interpreting the operands
* as fixed-point decimals of a standard unit.
*
* @dev The operands should be in the standard unit factor which will be
* divided out after the product of x and y is evaluated, so that product must be
* less than 2**256.
*
* Unlik... | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://7e5de7b2c8454afb4fecf2a46fa9ccc0e392fe2b302da0369358c02ba4f12d11 | {
"func_code_index": [
3898,
4062
]
} | 12,252 | |
Synthetix | Synthetix.sol | 0x7cb89c509001d25da9938999abfea6740212e5f0 | Solidity | SafeDecimalMath | library SafeDecimalMath {
using SafeMath for uint;
/* Number of decimal places in the representations. */
uint8 public constant decimals = 18;
uint8 public constant highPrecisionDecimals = 27;
/* The number representing 1.0. */
uint public constant UNIT = 10 ** uint(decimals);
/* The num... | /**
* @title Safely manipulate unsigned fixed-point decimals at a given precision level.
* @dev Functions accepting uints in this contract and derived contracts
* are taken to be such fixed point decimals of a specified precision (either standard
* or high).
*/ | NatSpecMultiLine | divideDecimal | function divideDecimal(uint x, uint y)
internal
pure
returns (uint)
{
/* Reintroduce the UNIT factor that will be divided out by y. */
return x.mul(UNIT).div(y);
}
| /**
* @return The result of safely dividing x and y. The return value is a high
* precision decimal.
*
* @dev y is divided after the product of x and the standard precision unit
* is evaluated, so the product of x and UNIT must be less than 2**256. As
* this is an integer division, the result is always rounded do... | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://7e5de7b2c8454afb4fecf2a46fa9ccc0e392fe2b302da0369358c02ba4f12d11 | {
"func_code_index": [
4491,
4706
]
} | 12,253 | |
Synthetix | Synthetix.sol | 0x7cb89c509001d25da9938999abfea6740212e5f0 | Solidity | SafeDecimalMath | library SafeDecimalMath {
using SafeMath for uint;
/* Number of decimal places in the representations. */
uint8 public constant decimals = 18;
uint8 public constant highPrecisionDecimals = 27;
/* The number representing 1.0. */
uint public constant UNIT = 10 ** uint(decimals);
/* The num... | /**
* @title Safely manipulate unsigned fixed-point decimals at a given precision level.
* @dev Functions accepting uints in this contract and derived contracts
* are taken to be such fixed point decimals of a specified precision (either standard
* or high).
*/ | NatSpecMultiLine | _divideDecimalRound | function _divideDecimalRound(uint x, uint y, uint precisionUnit)
private
pure
returns (uint)
{
uint resultTimesTen = x.mul(precisionUnit * 10).div(y);
if (resultTimesTen % 10 >= 5) {
resultTimesTen += 10;
}
return resultTimesTen / 10;
}
| /**
* @return The result of safely dividing x and y. The return value is as a rounded
* decimal in the precision unit specified in the parameter.
*
* @dev y is divided after the product of x and the specified precision unit
* is evaluated, so the product of x and the specified precision unit must
* be less than 2... | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://7e5de7b2c8454afb4fecf2a46fa9ccc0e392fe2b302da0369358c02ba4f12d11 | {
"func_code_index": [
5119,
5437
]
} | 12,254 | |
Synthetix | Synthetix.sol | 0x7cb89c509001d25da9938999abfea6740212e5f0 | Solidity | SafeDecimalMath | library SafeDecimalMath {
using SafeMath for uint;
/* Number of decimal places in the representations. */
uint8 public constant decimals = 18;
uint8 public constant highPrecisionDecimals = 27;
/* The number representing 1.0. */
uint public constant UNIT = 10 ** uint(decimals);
/* The num... | /**
* @title Safely manipulate unsigned fixed-point decimals at a given precision level.
* @dev Functions accepting uints in this contract and derived contracts
* are taken to be such fixed point decimals of a specified precision (either standard
* or high).
*/ | NatSpecMultiLine | divideDecimalRound | function divideDecimalRound(uint x, uint y)
internal
pure
returns (uint)
{
return _divideDecimalRound(x, y, UNIT);
}
| /**
* @return The result of safely dividing x and y. The return value is as a rounded
* standard precision decimal.
*
* @dev y is divided after the product of x and the standard precision unit
* is evaluated, so the product of x and the standard precision unit must
* be less than 2**256. The result is rounded to ... | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://7e5de7b2c8454afb4fecf2a46fa9ccc0e392fe2b302da0369358c02ba4f12d11 | {
"func_code_index": [
5818,
5978
]
} | 12,255 | |
Synthetix | Synthetix.sol | 0x7cb89c509001d25da9938999abfea6740212e5f0 | Solidity | SafeDecimalMath | library SafeDecimalMath {
using SafeMath for uint;
/* Number of decimal places in the representations. */
uint8 public constant decimals = 18;
uint8 public constant highPrecisionDecimals = 27;
/* The number representing 1.0. */
uint public constant UNIT = 10 ** uint(decimals);
/* The num... | /**
* @title Safely manipulate unsigned fixed-point decimals at a given precision level.
* @dev Functions accepting uints in this contract and derived contracts
* are taken to be such fixed point decimals of a specified precision (either standard
* or high).
*/ | NatSpecMultiLine | divideDecimalRoundPrecise | function divideDecimalRoundPrecise(uint x, uint y)
internal
pure
returns (uint)
{
return _divideDecimalRound(x, y, PRECISE_UNIT);
}
| /**
* @return The result of safely dividing x and y. The return value is as a rounded
* high precision decimal.
*
* @dev y is divided after the product of x and the high precision unit
* is evaluated, so the product of x and the high precision unit must
* be less than 2**256. The result is rounded to the nearest ... | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://7e5de7b2c8454afb4fecf2a46fa9ccc0e392fe2b302da0369358c02ba4f12d11 | {
"func_code_index": [
6347,
6522
]
} | 12,256 | |
Synthetix | Synthetix.sol | 0x7cb89c509001d25da9938999abfea6740212e5f0 | Solidity | SafeDecimalMath | library SafeDecimalMath {
using SafeMath for uint;
/* Number of decimal places in the representations. */
uint8 public constant decimals = 18;
uint8 public constant highPrecisionDecimals = 27;
/* The number representing 1.0. */
uint public constant UNIT = 10 ** uint(decimals);
/* The num... | /**
* @title Safely manipulate unsigned fixed-point decimals at a given precision level.
* @dev Functions accepting uints in this contract and derived contracts
* are taken to be such fixed point decimals of a specified precision (either standard
* or high).
*/ | NatSpecMultiLine | decimalToPreciseDecimal | function decimalToPreciseDecimal(uint i)
internal
pure
returns (uint)
{
return i.mul(UNIT_TO_HIGH_PRECISION_CONVERSION_FACTOR);
}
| /**
* @dev Convert a standard decimal representation to a high precision one.
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://7e5de7b2c8454afb4fecf2a46fa9ccc0e392fe2b302da0369358c02ba4f12d11 | {
"func_code_index": [
6619,
6792
]
} | 12,257 | |
Synthetix | Synthetix.sol | 0x7cb89c509001d25da9938999abfea6740212e5f0 | Solidity | SafeDecimalMath | library SafeDecimalMath {
using SafeMath for uint;
/* Number of decimal places in the representations. */
uint8 public constant decimals = 18;
uint8 public constant highPrecisionDecimals = 27;
/* The number representing 1.0. */
uint public constant UNIT = 10 ** uint(decimals);
/* The num... | /**
* @title Safely manipulate unsigned fixed-point decimals at a given precision level.
* @dev Functions accepting uints in this contract and derived contracts
* are taken to be such fixed point decimals of a specified precision (either standard
* or high).
*/ | NatSpecMultiLine | preciseDecimalToDecimal | function preciseDecimalToDecimal(uint i)
internal
pure
returns (uint)
{
uint quotientTimesTen = i / (UNIT_TO_HIGH_PRECISION_CONVERSION_FACTOR / 10);
if (quotientTimesTen % 10 >= 5) {
quotientTimesTen += 10;
}
return quotientTimesTen / 10;
}
| /**
* @dev Convert a high precision decimal to a standard decimal representation.
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://7e5de7b2c8454afb4fecf2a46fa9ccc0e392fe2b302da0369358c02ba4f12d11 | {
"func_code_index": [
6893,
7215
]
} | 12,258 | |
Synthetix | Synthetix.sol | 0x7cb89c509001d25da9938999abfea6740212e5f0 | Solidity | Owned | contract Owned {
address public owner;
address public nominatedOwner;
/**
* @dev Owned Constructor
*/
constructor(address _owner)
public
{
require(_owner != address(0), "Owner address cannot be 0");
owner = _owner;
emit OwnerChanged(address(0), _owner);
... | /**
* @title A contract with an owner.
* @notice Contract ownership can be transferred by first nominating the new owner,
* who must then accept the ownership, which prevents accidental incorrect ownership transfers.
*/ | NatSpecMultiLine | nominateNewOwner | function nominateNewOwner(address _owner)
external
onlyOwner
{
nominatedOwner = _owner;
emit OwnerNominated(_owner);
}
| /**
* @notice Nominate a new owner of this contract.
* @dev Only the current owner may nominate a new owner.
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://7e5de7b2c8454afb4fecf2a46fa9ccc0e392fe2b302da0369358c02ba4f12d11 | {
"func_code_index": [
455,
617
]
} | 12,259 | |
Synthetix | Synthetix.sol | 0x7cb89c509001d25da9938999abfea6740212e5f0 | Solidity | Owned | contract Owned {
address public owner;
address public nominatedOwner;
/**
* @dev Owned Constructor
*/
constructor(address _owner)
public
{
require(_owner != address(0), "Owner address cannot be 0");
owner = _owner;
emit OwnerChanged(address(0), _owner);
... | /**
* @title A contract with an owner.
* @notice Contract ownership can be transferred by first nominating the new owner,
* who must then accept the ownership, which prevents accidental incorrect ownership transfers.
*/ | NatSpecMultiLine | acceptOwnership | function acceptOwnership()
external
{
require(msg.sender == nominatedOwner, "You must be nominated before you can accept ownership");
emit OwnerChanged(owner, nominatedOwner);
owner = nominatedOwner;
nominatedOwner = address(0);
}
| /**
* @notice Accept the nomination to be owner.
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://7e5de7b2c8454afb4fecf2a46fa9ccc0e392fe2b302da0369358c02ba4f12d11 | {
"func_code_index": [
685,
967
]
} | 12,260 | |
Synthetix | Synthetix.sol | 0x7cb89c509001d25da9938999abfea6740212e5f0 | Solidity | SelfDestructible | contract SelfDestructible is Owned {
uint public initiationTime;
bool public selfDestructInitiated;
address public selfDestructBeneficiary;
uint public constant SELFDESTRUCT_DELAY = 4 weeks;
/**
* @dev Constructor
* @param _owner The account which controls this contract.
*/
... | /**
* @title A contract that can be destroyed by its owner after a delay elapses.
*/ | NatSpecMultiLine | setSelfDestructBeneficiary | function setSelfDestructBeneficiary(address _beneficiary)
external
onlyOwner
{
require(_beneficiary != address(0), "Beneficiary must not be zero");
selfDestructBeneficiary = _beneficiary;
emit SelfDestructBeneficiaryUpdated(_beneficiary);
}
| /**
* @notice Set the beneficiary address of this contract.
* @dev Only the contract owner may call this. The provided beneficiary must be non-null.
* @param _beneficiary The address to pay any eth contained in this contract to upon self-destruction.
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://7e5de7b2c8454afb4fecf2a46fa9ccc0e392fe2b302da0369358c02ba4f12d11 | {
"func_code_index": [
836,
1128
]
} | 12,261 | |
Synthetix | Synthetix.sol | 0x7cb89c509001d25da9938999abfea6740212e5f0 | Solidity | SelfDestructible | contract SelfDestructible is Owned {
uint public initiationTime;
bool public selfDestructInitiated;
address public selfDestructBeneficiary;
uint public constant SELFDESTRUCT_DELAY = 4 weeks;
/**
* @dev Constructor
* @param _owner The account which controls this contract.
*/
... | /**
* @title A contract that can be destroyed by its owner after a delay elapses.
*/ | NatSpecMultiLine | initiateSelfDestruct | function initiateSelfDestruct()
external
onlyOwner
{
initiationTime = now;
selfDestructInitiated = true;
emit SelfDestructInitiated(SELFDESTRUCT_DELAY);
}
| /**
* @notice Begin the self-destruction counter of this contract.
* Once the delay has elapsed, the contract may be self-destructed.
* @dev Only the contract owner may call this.
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://7e5de7b2c8454afb4fecf2a46fa9ccc0e392fe2b302da0369358c02ba4f12d11 | {
"func_code_index": [
1337,
1543
]
} | 12,262 | |
Synthetix | Synthetix.sol | 0x7cb89c509001d25da9938999abfea6740212e5f0 | Solidity | SelfDestructible | contract SelfDestructible is Owned {
uint public initiationTime;
bool public selfDestructInitiated;
address public selfDestructBeneficiary;
uint public constant SELFDESTRUCT_DELAY = 4 weeks;
/**
* @dev Constructor
* @param _owner The account which controls this contract.
*/
... | /**
* @title A contract that can be destroyed by its owner after a delay elapses.
*/ | NatSpecMultiLine | terminateSelfDestruct | function terminateSelfDestruct()
external
onlyOwner
{
initiationTime = 0;
selfDestructInitiated = false;
emit SelfDestructTerminated();
}
| /**
* @notice Terminate and reset the self-destruction timer.
* @dev Only the contract owner may call this.
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://7e5de7b2c8454afb4fecf2a46fa9ccc0e392fe2b302da0369358c02ba4f12d11 | {
"func_code_index": [
1675,
1864
]
} | 12,263 | |
Synthetix | Synthetix.sol | 0x7cb89c509001d25da9938999abfea6740212e5f0 | Solidity | SelfDestructible | contract SelfDestructible is Owned {
uint public initiationTime;
bool public selfDestructInitiated;
address public selfDestructBeneficiary;
uint public constant SELFDESTRUCT_DELAY = 4 weeks;
/**
* @dev Constructor
* @param _owner The account which controls this contract.
*/
... | /**
* @title A contract that can be destroyed by its owner after a delay elapses.
*/ | NatSpecMultiLine | selfDestruct | function selfDestruct()
external
onlyOwner
{
require(selfDestructInitiated, "Self Destruct not yet initiated");
require(initiationTime + SELFDESTRUCT_DELAY < now, "Self destruct delay not met");
address beneficiary = selfDestructBeneficiary;
emit SelfDestructed(beneficiary);
selfdestruct(ben... | /**
* @notice If the self-destruction delay has elapsed, destroy this contract and
* remit any ether it owns to the beneficiary address.
* @dev Only the contract owner may call this.
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://7e5de7b2c8454afb4fecf2a46fa9ccc0e392fe2b302da0369358c02ba4f12d11 | {
"func_code_index": [
2076,
2448
]
} | 12,264 | |
Synthetix | Synthetix.sol | 0x7cb89c509001d25da9938999abfea6740212e5f0 | Solidity | State | contract State is Owned {
// the address of the contract that can modify variables
// this can only be changed by the owner of this contract
address public associatedContract;
constructor(address _owner, address _associatedContract)
Owned(_owner)
public
{
associatedContract... | /*
-----------------------------------------------------------------
FILE INFORMATION
-----------------------------------------------------------------
file: State.sol
version: 1.1
author: Dominic Romanowski
Anton Jurisevic
date: 2018-05-15
---------------------------------------------... | Comment | setAssociatedContract | function setAssociatedContract(address _associatedContract)
external
onlyOwner
{
associatedContract = _associatedContract;
emit AssociatedContractUpdated(_associatedContract);
}
| // Change the associated contract to a new address | LineComment | v0.4.25+commit.59dbf8f1 | bzzr://7e5de7b2c8454afb4fecf2a46fa9ccc0e392fe2b302da0369358c02ba4f12d11 | {
"func_code_index": [
508,
729
]
} | 12,265 | |
Synthetix | Synthetix.sol | 0x7cb89c509001d25da9938999abfea6740212e5f0 | Solidity | TokenState | contract TokenState is State {
/* ERC20 fields. */
mapping(address => uint) public balanceOf;
mapping(address => mapping(address => uint)) public allowance;
/**
* @dev Constructor
* @param _owner The address which controls this contract.
* @param _associatedContract The ERC20 contract w... | /**
* @title ERC20 Token State
* @notice Stores balance information of an ERC20 token contract.
*/ | NatSpecMultiLine | setAllowance | function setAllowance(address tokenOwner, address spender, uint value)
external
onlyAssociatedContract
{
allowance[tokenOwner][spender] = value;
}
| /**
* @notice Set ERC20 allowance.
* @dev Only the associated contract may call this.
* @param tokenOwner The authorising party.
* @param spender The authorised party.
* @param value The total value the authorised party may spend on the
* authorising party's behalf.
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://7e5de7b2c8454afb4fecf2a46fa9ccc0e392fe2b302da0369358c02ba4f12d11 | {
"func_code_index": [
831,
1013
]
} | 12,266 | |
Synthetix | Synthetix.sol | 0x7cb89c509001d25da9938999abfea6740212e5f0 | Solidity | TokenState | contract TokenState is State {
/* ERC20 fields. */
mapping(address => uint) public balanceOf;
mapping(address => mapping(address => uint)) public allowance;
/**
* @dev Constructor
* @param _owner The address which controls this contract.
* @param _associatedContract The ERC20 contract w... | /**
* @title ERC20 Token State
* @notice Stores balance information of an ERC20 token contract.
*/ | NatSpecMultiLine | setBalanceOf | function setBalanceOf(address account, uint value)
external
onlyAssociatedContract
{
balanceOf[account] = value;
}
| /**
* @notice Set the balance in a given account
* @dev Only the associated contract may call this.
* @param account The account whose value to set.
* @param value The new balance of the given account.
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://7e5de7b2c8454afb4fecf2a46fa9ccc0e392fe2b302da0369358c02ba4f12d11 | {
"func_code_index": [
1249,
1399
]
} | 12,267 | |
Synthetix | Synthetix.sol | 0x7cb89c509001d25da9938999abfea6740212e5f0 | Solidity | ExternStateToken | contract ExternStateToken is SelfDestructible, Proxyable {
using SafeMath for uint;
using SafeDecimalMath for uint;
/* ========== STATE VARIABLES ========== */
/* Stores balances and allowances. */
TokenState public tokenState;
/* Other ERC20 fields. */
string public name;
string pub... | /**
* @title ERC20 Token contract, with detached state and designed to operate behind a proxy.
*/ | NatSpecMultiLine | allowance | function allowance(address owner, address spender)
public
view
returns (uint)
{
return tokenState.allowance(owner, spender);
}
| /**
* @notice Returns the ERC20 allowance of one party to spend on behalf of another.
* @param owner The party authorising spending of their funds.
* @param spender The party spending tokenOwner's funds.
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://7e5de7b2c8454afb4fecf2a46fa9ccc0e392fe2b302da0369358c02ba4f12d11 | {
"func_code_index": [
1426,
1596
]
} | 12,268 | |
Synthetix | Synthetix.sol | 0x7cb89c509001d25da9938999abfea6740212e5f0 | Solidity | ExternStateToken | contract ExternStateToken is SelfDestructible, Proxyable {
using SafeMath for uint;
using SafeDecimalMath for uint;
/* ========== STATE VARIABLES ========== */
/* Stores balances and allowances. */
TokenState public tokenState;
/* Other ERC20 fields. */
string public name;
string pub... | /**
* @title ERC20 Token contract, with detached state and designed to operate behind a proxy.
*/ | NatSpecMultiLine | balanceOf | function balanceOf(address account)
public
view
returns (uint)
{
return tokenState.balanceOf(account);
}
| /**
* @notice Returns the ERC20 token balance of a given account.
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://7e5de7b2c8454afb4fecf2a46fa9ccc0e392fe2b302da0369358c02ba4f12d11 | {
"func_code_index": [
1681,
1829
]
} | 12,269 | |
Synthetix | Synthetix.sol | 0x7cb89c509001d25da9938999abfea6740212e5f0 | Solidity | ExternStateToken | contract ExternStateToken is SelfDestructible, Proxyable {
using SafeMath for uint;
using SafeDecimalMath for uint;
/* ========== STATE VARIABLES ========== */
/* Stores balances and allowances. */
TokenState public tokenState;
/* Other ERC20 fields. */
string public name;
string pub... | /**
* @title ERC20 Token contract, with detached state and designed to operate behind a proxy.
*/ | NatSpecMultiLine | setTokenState | function setTokenState(TokenState _tokenState)
external
optionalProxy_onlyOwner
{
tokenState = _tokenState;
emitTokenStateUpdated(_tokenState);
}
| /**
* @notice Set the address of the TokenState contract.
* @dev This can be used to "pause" transfer functionality, by pointing the tokenState at 0x000..
* as balances would be unreachable.
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://7e5de7b2c8454afb4fecf2a46fa9ccc0e392fe2b302da0369358c02ba4f12d11 | {
"func_code_index": [
2101,
2290
]
} | 12,270 | |
Synthetix | Synthetix.sol | 0x7cb89c509001d25da9938999abfea6740212e5f0 | Solidity | ExternStateToken | contract ExternStateToken is SelfDestructible, Proxyable {
using SafeMath for uint;
using SafeDecimalMath for uint;
/* ========== STATE VARIABLES ========== */
/* Stores balances and allowances. */
TokenState public tokenState;
/* Other ERC20 fields. */
string public name;
string pub... | /**
* @title ERC20 Token contract, with detached state and designed to operate behind a proxy.
*/ | NatSpecMultiLine | _transfer_byProxy | function _transfer_byProxy(address from, address to, uint value)
internal
returns (bool)
{
return _internalTransfer(from, to, value);
}
| /**
* @dev Perform an ERC20 token transfer. Designed to be called by transfer functions possessing
* the onlyProxy or optionalProxy modifiers.
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://7e5de7b2c8454afb4fecf2a46fa9ccc0e392fe2b302da0369358c02ba4f12d11 | {
"func_code_index": [
3101,
3272
]
} | 12,271 | |
Synthetix | Synthetix.sol | 0x7cb89c509001d25da9938999abfea6740212e5f0 | Solidity | ExternStateToken | contract ExternStateToken is SelfDestructible, Proxyable {
using SafeMath for uint;
using SafeDecimalMath for uint;
/* ========== STATE VARIABLES ========== */
/* Stores balances and allowances. */
TokenState public tokenState;
/* Other ERC20 fields. */
string public name;
string pub... | /**
* @title ERC20 Token contract, with detached state and designed to operate behind a proxy.
*/ | NatSpecMultiLine | _transferFrom_byProxy | function _transferFrom_byProxy(address sender, address from, address to, uint value)
internal
returns (bool)
{
/* Insufficient allowance will be handled by the safe subtraction. */
tokenState.setAllowance(from, sender, tokenState.allowance(from, sender).sub(value));
return _internalTransfer(from, to... | /**
* @dev Perform an ERC20 token transferFrom. Designed to be called by transferFrom functions
* possessing the optionalProxy or optionalProxy modifiers.
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://7e5de7b2c8454afb4fecf2a46fa9ccc0e392fe2b302da0369358c02ba4f12d11 | {
"func_code_index": [
3451,
3814
]
} | 12,272 | |
Synthetix | Synthetix.sol | 0x7cb89c509001d25da9938999abfea6740212e5f0 | Solidity | ExternStateToken | contract ExternStateToken is SelfDestructible, Proxyable {
using SafeMath for uint;
using SafeDecimalMath for uint;
/* ========== STATE VARIABLES ========== */
/* Stores balances and allowances. */
TokenState public tokenState;
/* Other ERC20 fields. */
string public name;
string pub... | /**
* @title ERC20 Token contract, with detached state and designed to operate behind a proxy.
*/ | NatSpecMultiLine | approve | function approve(address spender, uint value)
public
optionalProxy
returns (bool)
{
address sender = messageSender;
tokenState.setAllowance(sender, spender, value);
emitApproval(sender, spender, value);
return true;
}
| /**
* @notice Approves spender to transfer on the message sender's behalf.
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://7e5de7b2c8454afb4fecf2a46fa9ccc0e392fe2b302da0369358c02ba4f12d11 | {
"func_code_index": [
3908,
4194
]
} | 12,273 | |
Synthetix | Synthetix.sol | 0x7cb89c509001d25da9938999abfea6740212e5f0 | Solidity | Math | library Math {
using SafeMath for uint;
using SafeDecimalMath for uint;
/**
* @dev Uses "exponentiation by squaring" algorithm where cost is 0(logN)
* vs 0(N) for naive repeated multiplication.
* Calculates x^n with x as fixed-point and n as regular unsigned int.
* Calculates to 18 digits... | powDecimal | function powDecimal(uint x, uint n)
internal
pure
returns (uint)
{
// https://mpark.github.io/programming/2014/08/18/exponentiation-by-squaring/
uint result = SafeDecimalMath.unit();
while (n > 0) {
if (n % 2 != 0) {
result = result.multiplyDecimal(x);
}
x = ... | /**
* @dev Uses "exponentiation by squaring" algorithm where cost is 0(logN)
* vs 0(N) for naive repeated multiplication.
* Calculates x^n with x as fixed-point and n as regular unsigned int.
* Calculates to 18 digits of precision with SafeDecimalMath.unit()
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://7e5de7b2c8454afb4fecf2a46fa9ccc0e392fe2b302da0369358c02ba4f12d11 | {
"func_code_index": [
369,
817
]
} | 12,274 | |||
Synthetix | Synthetix.sol | 0x7cb89c509001d25da9938999abfea6740212e5f0 | Solidity | Synth | contract Synth is ExternStateToken {
/* ========== STATE VARIABLES ========== */
// Address of the FeePoolProxy
address public feePoolProxy;
// Address of the SynthetixProxy
address public synthetixProxy;
// Currency key which identifies this Synth to the Synthetix system
bytes32 public c... | /*
-----------------------------------------------------------------
MODULE DESCRIPTION
-----------------------------------------------------------------
Synthetix-backed stablecoin contract.
This contract issues synths, which are tokens that mirror various
flavours of fiat currency.
Synths are issuable by... | Comment | setSynthetixProxy | function setSynthetixProxy(ISynthetix _synthetixProxy)
external
optionalProxy_onlyOwner
{
synthetixProxy = _synthetixProxy;
emitSynthetixUpdated(_synthetixProxy);
}
| /**
* @notice Set the SynthetixProxy should it ever change.
* The Synth requires Synthetix address as it has the authority
* to mint and burn synths
* */ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://7e5de7b2c8454afb4fecf2a46fa9ccc0e392fe2b302da0369358c02ba4f12d11 | {
"func_code_index": [
1475,
1683
]
} | 12,275 | |
Synthetix | Synthetix.sol | 0x7cb89c509001d25da9938999abfea6740212e5f0 | Solidity | Synth | contract Synth is ExternStateToken {
/* ========== STATE VARIABLES ========== */
// Address of the FeePoolProxy
address public feePoolProxy;
// Address of the SynthetixProxy
address public synthetixProxy;
// Currency key which identifies this Synth to the Synthetix system
bytes32 public c... | /*
-----------------------------------------------------------------
MODULE DESCRIPTION
-----------------------------------------------------------------
Synthetix-backed stablecoin contract.
This contract issues synths, which are tokens that mirror various
flavours of fiat currency.
Synths are issuable by... | Comment | setFeePoolProxy | function setFeePoolProxy(address _feePoolProxy)
external
optionalProxy_onlyOwner
{
feePoolProxy = _feePoolProxy;
emitFeePoolUpdated(_feePoolProxy);
}
| /**
* @notice Set the FeePoolProxy should it ever change.
* The Synth requires FeePool address as it has the authority
* to mint and burn for FeePool.claimFees()
* */ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://7e5de7b2c8454afb4fecf2a46fa9ccc0e392fe2b302da0369358c02ba4f12d11 | {
"func_code_index": [
1876,
2069
]
} | 12,276 | |
Synthetix | Synthetix.sol | 0x7cb89c509001d25da9938999abfea6740212e5f0 | Solidity | Synth | contract Synth is ExternStateToken {
/* ========== STATE VARIABLES ========== */
// Address of the FeePoolProxy
address public feePoolProxy;
// Address of the SynthetixProxy
address public synthetixProxy;
// Currency key which identifies this Synth to the Synthetix system
bytes32 public c... | /*
-----------------------------------------------------------------
MODULE DESCRIPTION
-----------------------------------------------------------------
Synthetix-backed stablecoin contract.
This contract issues synths, which are tokens that mirror various
flavours of fiat currency.
Synths are issuable by... | Comment | transfer | function transfer(address to, uint value)
public
optionalProxy
returns (bool)
{
return super._internalTransfer(messageSender, to, value);
}
| /**
* @notice ERC20 transfer function
* forward call on to _internalTransfer */ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://7e5de7b2c8454afb4fecf2a46fa9ccc0e392fe2b302da0369358c02ba4f12d11 | {
"func_code_index": [
2217,
2408
]
} | 12,277 | |
Synthetix | Synthetix.sol | 0x7cb89c509001d25da9938999abfea6740212e5f0 | Solidity | Synth | contract Synth is ExternStateToken {
/* ========== STATE VARIABLES ========== */
// Address of the FeePoolProxy
address public feePoolProxy;
// Address of the SynthetixProxy
address public synthetixProxy;
// Currency key which identifies this Synth to the Synthetix system
bytes32 public c... | /*
-----------------------------------------------------------------
MODULE DESCRIPTION
-----------------------------------------------------------------
Synthetix-backed stablecoin contract.
This contract issues synths, which are tokens that mirror various
flavours of fiat currency.
Synths are issuable by... | Comment | transferFrom | function transferFrom(address from, address to, uint value)
public
optionalProxy
returns (bool)
{
// Skip allowance update in case of infinite allowance
if (tokenState.allowance(from, messageSender) != uint(-1)) {
// Reduce the allowance by the amount we're transferring.
// T... | /**
* @notice ERC20 transferFrom function
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://7e5de7b2c8454afb4fecf2a46fa9ccc0e392fe2b302da0369358c02ba4f12d11 | {
"func_code_index": [
2469,
3073
]
} | 12,278 | |
Synthetix | Synthetix.sol | 0x7cb89c509001d25da9938999abfea6740212e5f0 | Solidity | Synth | contract Synth is ExternStateToken {
/* ========== STATE VARIABLES ========== */
// Address of the FeePoolProxy
address public feePoolProxy;
// Address of the SynthetixProxy
address public synthetixProxy;
// Currency key which identifies this Synth to the Synthetix system
bytes32 public c... | /*
-----------------------------------------------------------------
MODULE DESCRIPTION
-----------------------------------------------------------------
Synthetix-backed stablecoin contract.
This contract issues synths, which are tokens that mirror various
flavours of fiat currency.
Synths are issuable by... | Comment | issue | function issue(address account, uint amount)
external
onlySynthetixOrFeePool
{
tokenState.setBalanceOf(account, tokenState.balanceOf(account).add(amount));
totalSupply = totalSupply.add(amount);
emitTransfer(address(0), account, amount);
emitIssued(account, amount);
}
| // Allow synthetix to issue a certain number of synths from an account. | LineComment | v0.4.25+commit.59dbf8f1 | bzzr://7e5de7b2c8454afb4fecf2a46fa9ccc0e392fe2b302da0369358c02ba4f12d11 | {
"func_code_index": [
3151,
3479
]
} | 12,279 | |
Synthetix | Synthetix.sol | 0x7cb89c509001d25da9938999abfea6740212e5f0 | Solidity | Synth | contract Synth is ExternStateToken {
/* ========== STATE VARIABLES ========== */
// Address of the FeePoolProxy
address public feePoolProxy;
// Address of the SynthetixProxy
address public synthetixProxy;
// Currency key which identifies this Synth to the Synthetix system
bytes32 public c... | /*
-----------------------------------------------------------------
MODULE DESCRIPTION
-----------------------------------------------------------------
Synthetix-backed stablecoin contract.
This contract issues synths, which are tokens that mirror various
flavours of fiat currency.
Synths are issuable by... | Comment | burn | function burn(address account, uint amount)
external
onlySynthetixOrFeePool
{
tokenState.setBalanceOf(account, tokenState.balanceOf(account).sub(amount));
totalSupply = totalSupply.sub(amount);
emitTransfer(account, address(0), amount);
emitBurned(account, amount);
}
| // Allow synthetix or another synth contract to burn a certain number of synths from an account. | LineComment | v0.4.25+commit.59dbf8f1 | bzzr://7e5de7b2c8454afb4fecf2a46fa9ccc0e392fe2b302da0369358c02ba4f12d11 | {
"func_code_index": [
3582,
3909
]
} | 12,280 | |
Synthetix | Synthetix.sol | 0x7cb89c509001d25da9938999abfea6740212e5f0 | Solidity | Synth | contract Synth is ExternStateToken {
/* ========== STATE VARIABLES ========== */
// Address of the FeePoolProxy
address public feePoolProxy;
// Address of the SynthetixProxy
address public synthetixProxy;
// Currency key which identifies this Synth to the Synthetix system
bytes32 public c... | /*
-----------------------------------------------------------------
MODULE DESCRIPTION
-----------------------------------------------------------------
Synthetix-backed stablecoin contract.
This contract issues synths, which are tokens that mirror various
flavours of fiat currency.
Synths are issuable by... | Comment | setTotalSupply | function setTotalSupply(uint amount)
external
optionalProxy_onlyOwner
{
totalSupply = amount;
}
| // Allow owner to set the total supply on import. | LineComment | v0.4.25+commit.59dbf8f1 | bzzr://7e5de7b2c8454afb4fecf2a46fa9ccc0e392fe2b302da0369358c02ba4f12d11 | {
"func_code_index": [
3965,
4096
]
} | 12,281 | |
Synthetix | Synthetix.sol | 0x7cb89c509001d25da9938999abfea6740212e5f0 | Solidity | ISynthetix | contract ISynthetix {
// ========== PUBLIC STATE VARIABLES ==========
IFeePool public feePool;
ISynthetixEscrow public escrow;
ISynthetixEscrow public rewardEscrow;
ISynthetixState public synthetixState;
IExchangeRates public exchangeRates;
uint public totalSupply;
mapping(by... | /**
* @title Synthetix interface contract
* @notice Abstract contract to hold public getters
* @dev pseudo interface, actually declared as contract to hold the public getters
*/ | NatSpecMultiLine | balanceOf | function balanceOf(address account) public view returns (uint);
| // ========== PUBLIC FUNCTIONS ========== | LineComment | v0.4.25+commit.59dbf8f1 | bzzr://7e5de7b2c8454afb4fecf2a46fa9ccc0e392fe2b302da0369358c02ba4f12d11 | {
"func_code_index": [
399,
466
]
} | 12,282 | |
Synthetix | Synthetix.sol | 0x7cb89c509001d25da9938999abfea6740212e5f0 | Solidity | SupplySchedule | contract SupplySchedule is Owned {
using SafeMath for uint;
using SafeDecimalMath for uint;
using Math for uint;
// Time of the last inflation supply mint event
uint public lastMintEvent;
// Counter for number of weeks since the start of supply inflation
uint public weekCounter;
// Th... | /**
* @title SupplySchedule contract
*/ | NatSpecMultiLine | mintableSupply | function mintableSupply()
external
view
returns (uint)
{
uint totalAmount;
if (!isMintable()) {
return totalAmount;
}
uint remainingWeeksToMint = weeksSinceLastIssuance();
uint currentWeek = weekCounter;
// Calculate total mintable supply from ex... | /**
* @return The amount of SNX mintable for the inflationary supply
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://7e5de7b2c8454afb4fecf2a46fa9ccc0e392fe2b302da0369358c02ba4f12d11 | {
"func_code_index": [
2030,
3897
]
} | 12,283 | |
Synthetix | Synthetix.sol | 0x7cb89c509001d25da9938999abfea6740212e5f0 | Solidity | SupplySchedule | contract SupplySchedule is Owned {
using SafeMath for uint;
using SafeDecimalMath for uint;
using Math for uint;
// Time of the last inflation supply mint event
uint public lastMintEvent;
// Counter for number of weeks since the start of supply inflation
uint public weekCounter;
// Th... | /**
* @title SupplySchedule contract
*/ | NatSpecMultiLine | tokenDecaySupplyForWeek | function tokenDecaySupplyForWeek(uint counter)
public
pure
returns (uint)
{
// Apply exponential decay function to number of weeks since
// start of inflation smoothing to calculate diminishing supply for the week.
uint effectiveDecay = (SafeDecimalMath.unit().sub(DECAY_RATE)).powDecimal(cou... | /**
* @return A unit amount of decaying inflationary supply from the INITIAL_WEEKLY_SUPPLY
* @dev New token supply reduces by the decay rate each week calculated as supply = INITIAL_WEEKLY_SUPPLY * ()
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://7e5de7b2c8454afb4fecf2a46fa9ccc0e392fe2b302da0369358c02ba4f12d11 | {
"func_code_index": [
4120,
4603
]
} | 12,284 | |
Synthetix | Synthetix.sol | 0x7cb89c509001d25da9938999abfea6740212e5f0 | Solidity | SupplySchedule | contract SupplySchedule is Owned {
using SafeMath for uint;
using SafeDecimalMath for uint;
using Math for uint;
// Time of the last inflation supply mint event
uint public lastMintEvent;
// Counter for number of weeks since the start of supply inflation
uint public weekCounter;
// Th... | /**
* @title SupplySchedule contract
*/ | NatSpecMultiLine | terminalInflationSupply | function terminalInflationSupply(uint totalSupply, uint numOfWeeks)
public
pure
returns (uint)
{
// rate = (1 + weekly rate) ^ num of weeks
uint effectiveCompoundRate = SafeDecimalMath.unit().add(TERMINAL_SUPPLY_RATE_ANNUAL.div(52)).powDecimal(numOfWeeks);
// return Supply * (effectiveRate -... | /**
* @return A unit amount of terminal inflation supply
* @dev Weekly compound rate based on number of weeks
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://7e5de7b2c8454afb4fecf2a46fa9ccc0e392fe2b302da0369358c02ba4f12d11 | {
"func_code_index": [
4743,
5250
]
} | 12,285 | |
Synthetix | Synthetix.sol | 0x7cb89c509001d25da9938999abfea6740212e5f0 | Solidity | SupplySchedule | contract SupplySchedule is Owned {
using SafeMath for uint;
using SafeDecimalMath for uint;
using Math for uint;
// Time of the last inflation supply mint event
uint public lastMintEvent;
// Counter for number of weeks since the start of supply inflation
uint public weekCounter;
// Th... | /**
* @title SupplySchedule contract
*/ | NatSpecMultiLine | weeksSinceLastIssuance | function weeksSinceLastIssuance()
public
view
returns (uint)
{
// Get weeks since lastMintEvent
// If lastMintEvent not set or 0, then start from inflation start date.
uint timeDiff = lastMintEvent > 0 ? now.sub(lastMintEvent) : now.sub(INFLATION_START_DATE);
return timeDiff.div(MINT_PERIOD_... | /**
* @dev Take timeDiff in seconds (Dividend) and MINT_PERIOD_DURATION as (Divisor)
* @return Calculate the numberOfWeeks since last mint rounded down to 1 week
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://7e5de7b2c8454afb4fecf2a46fa9ccc0e392fe2b302da0369358c02ba4f12d11 | {
"func_code_index": [
5437,
5809
]
} | 12,286 | |
Synthetix | Synthetix.sol | 0x7cb89c509001d25da9938999abfea6740212e5f0 | Solidity | SupplySchedule | contract SupplySchedule is Owned {
using SafeMath for uint;
using SafeDecimalMath for uint;
using Math for uint;
// Time of the last inflation supply mint event
uint public lastMintEvent;
// Counter for number of weeks since the start of supply inflation
uint public weekCounter;
// Th... | /**
* @title SupplySchedule contract
*/ | NatSpecMultiLine | isMintable | function isMintable()
public
view
returns (bool)
{
if (now - lastMintEvent > MINT_PERIOD_DURATION)
{
return true;
}
return false;
}
| /**
* @return boolean whether the MINT_PERIOD_DURATION (7 days)
* has passed since the lastMintEvent.
* */ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://7e5de7b2c8454afb4fecf2a46fa9ccc0e392fe2b302da0369358c02ba4f12d11 | {
"func_code_index": [
5937,
6148
]
} | 12,287 | |
Synthetix | Synthetix.sol | 0x7cb89c509001d25da9938999abfea6740212e5f0 | Solidity | SupplySchedule | contract SupplySchedule is Owned {
using SafeMath for uint;
using SafeDecimalMath for uint;
using Math for uint;
// Time of the last inflation supply mint event
uint public lastMintEvent;
// Counter for number of weeks since the start of supply inflation
uint public weekCounter;
// Th... | /**
* @title SupplySchedule contract
*/ | NatSpecMultiLine | recordMintEvent | function recordMintEvent(uint supplyMinted)
external
onlySynthetix
returns (bool)
{
uint numberOfWeeksIssued = weeksSinceLastIssuance();
// add number of weeks minted to weekCounter
weekCounter = weekCounter.add(numberOfWeeksIssued);
// Update mint event to latest week issued (start date +... | /**
* @notice Record the mint event from Synthetix by incrementing the inflation
* week counter for the number of weeks minted (probabaly always 1)
* and store the time of the event.
* @param supplyMinted the amount of SNX the total supply was inflated by.
* */ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://7e5de7b2c8454afb4fecf2a46fa9ccc0e392fe2b302da0369358c02ba4f12d11 | {
"func_code_index": [
6491,
7190
]
} | 12,288 | |
Synthetix | Synthetix.sol | 0x7cb89c509001d25da9938999abfea6740212e5f0 | Solidity | SupplySchedule | contract SupplySchedule is Owned {
using SafeMath for uint;
using SafeDecimalMath for uint;
using Math for uint;
// Time of the last inflation supply mint event
uint public lastMintEvent;
// Counter for number of weeks since the start of supply inflation
uint public weekCounter;
// Th... | /**
* @title SupplySchedule contract
*/ | NatSpecMultiLine | setMinterReward | function setMinterReward(uint amount)
external
onlyOwner
{
require(amount <= MAX_MINTER_REWARD, "Reward cannot exceed max minter reward");
minterReward = amount;
emit MinterRewardUpdated(minterReward);
}
| /**
* @notice Sets the reward amount of SNX for the caller of the public
* function Synthetix.mint().
* This incentivises anyone to mint the inflationary supply and the mintr
* Reward will be deducted from the inflationary supply and sent to the caller.
* @param amount the amount of SNX to reward the minter.
* */ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://7e5de7b2c8454afb4fecf2a46fa9ccc0e392fe2b302da0369358c02ba4f12d11 | {
"func_code_index": [
7544,
7799
]
} | 12,289 | |
Synthetix | Synthetix.sol | 0x7cb89c509001d25da9938999abfea6740212e5f0 | Solidity | SupplySchedule | contract SupplySchedule is Owned {
using SafeMath for uint;
using SafeDecimalMath for uint;
using Math for uint;
// Time of the last inflation supply mint event
uint public lastMintEvent;
// Counter for number of weeks since the start of supply inflation
uint public weekCounter;
// Th... | /**
* @title SupplySchedule contract
*/ | NatSpecMultiLine | setSynthetixProxy | function setSynthetixProxy(ISynthetix _synthetixProxy)
external
onlyOwner
{
require(_synthetixProxy != address(0), "Address cannot be 0");
synthetixProxy = _synthetixProxy;
emit SynthetixProxyUpdated(synthetixProxy);
}
| /**
* @notice Set the SynthetixProxy should it ever change.
* SupplySchedule requires Synthetix address as it has the authority
* to record mint event.
* */ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://7e5de7b2c8454afb4fecf2a46fa9ccc0e392fe2b302da0369358c02ba4f12d11 | {
"func_code_index": [
8023,
8293
]
} | 12,290 | |
Synthetix | Synthetix.sol | 0x7cb89c509001d25da9938999abfea6740212e5f0 | Solidity | ExchangeRates | contract ExchangeRates is SelfDestructible {
using SafeMath for uint;
using SafeDecimalMath for uint;
struct RateAndUpdatedTime {
uint216 rate;
uint40 time;
}
// Exchange rates and update times stored by currency code, e.g. 'SNX', or 'sUSD'
mapping(bytes32 => RateAndUpdatedTi... | /**
* @title The repository for exchange rates
*/ | NatSpecMultiLine | rates | function rates(bytes32 code) public view returns(uint256) {
return getRateAndUpdatedTime(code).rate;
}
| /**
* @notice Retrieves the exchange rate (sUSD per unit) for a given currency key
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://7e5de7b2c8454afb4fecf2a46fa9ccc0e392fe2b302da0369358c02ba4f12d11 | {
"func_code_index": [
5024,
5142
]
} | 12,291 | |
Synthetix | Synthetix.sol | 0x7cb89c509001d25da9938999abfea6740212e5f0 | Solidity | ExchangeRates | contract ExchangeRates is SelfDestructible {
using SafeMath for uint;
using SafeDecimalMath for uint;
struct RateAndUpdatedTime {
uint216 rate;
uint40 time;
}
// Exchange rates and update times stored by currency code, e.g. 'SNX', or 'sUSD'
mapping(bytes32 => RateAndUpdatedTi... | /**
* @title The repository for exchange rates
*/ | NatSpecMultiLine | lastRateUpdateTimes | function lastRateUpdateTimes(bytes32 code) public view returns(uint256) {
return getRateAndUpdatedTime(code).time;
}
| /**
* @notice Retrieves the timestamp the given rate was last updated.
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://7e5de7b2c8454afb4fecf2a46fa9ccc0e392fe2b302da0369358c02ba4f12d11 | {
"func_code_index": [
5232,
5364
]
} | 12,292 | |
Synthetix | Synthetix.sol | 0x7cb89c509001d25da9938999abfea6740212e5f0 | Solidity | ExchangeRates | contract ExchangeRates is SelfDestructible {
using SafeMath for uint;
using SafeDecimalMath for uint;
struct RateAndUpdatedTime {
uint216 rate;
uint40 time;
}
// Exchange rates and update times stored by currency code, e.g. 'SNX', or 'sUSD'
mapping(bytes32 => RateAndUpdatedTi... | /**
* @title The repository for exchange rates
*/ | NatSpecMultiLine | lastRateUpdateTimesForCurrencies | function lastRateUpdateTimesForCurrencies(bytes32[] currencyKeys)
public
view
returns (uint[])
{
uint[] memory lastUpdateTimes = new uint[](currencyKeys.length);
for (uint i = 0; i < currencyKeys.length; i++) {
lastUpdateTimes[i] = lastRateUpdateTimes(currencyKeys[i]);
}
return las... | /**
* @notice Retrieve the last update time for a list of currencies
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://7e5de7b2c8454afb4fecf2a46fa9ccc0e392fe2b302da0369358c02ba4f12d11 | {
"func_code_index": [
5452,
5831
]
} | 12,293 | |
Synthetix | Synthetix.sol | 0x7cb89c509001d25da9938999abfea6740212e5f0 | Solidity | ExchangeRates | contract ExchangeRates is SelfDestructible {
using SafeMath for uint;
using SafeDecimalMath for uint;
struct RateAndUpdatedTime {
uint216 rate;
uint40 time;
}
// Exchange rates and update times stored by currency code, e.g. 'SNX', or 'sUSD'
mapping(bytes32 => RateAndUpdatedTi... | /**
* @title The repository for exchange rates
*/ | NatSpecMultiLine | updateRates | function updateRates(bytes32[] currencyKeys, uint[] newRates, uint timeSent)
external
onlyOracle
returns(bool)
{
return internalUpdateRates(currencyKeys, newRates, timeSent);
}
| /**
* @notice Set the rates stored in this contract
* @param currencyKeys The currency keys you wish to update the rates for (in order)
* @param newRates The rates for each currency (in order)
* @param timeSent The timestamp of when the update was sent, specified in seconds since epoch (e.g. the same as the now key... | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://7e5de7b2c8454afb4fecf2a46fa9ccc0e392fe2b302da0369358c02ba4f12d11 | {
"func_code_index": [
6686,
6906
]
} | 12,294 | |
Synthetix | Synthetix.sol | 0x7cb89c509001d25da9938999abfea6740212e5f0 | Solidity | ExchangeRates | contract ExchangeRates is SelfDestructible {
using SafeMath for uint;
using SafeDecimalMath for uint;
struct RateAndUpdatedTime {
uint216 rate;
uint40 time;
}
// Exchange rates and update times stored by currency code, e.g. 'SNX', or 'sUSD'
mapping(bytes32 => RateAndUpdatedTi... | /**
* @title The repository for exchange rates
*/ | NatSpecMultiLine | internalUpdateRates | function internalUpdateRates(bytes32[] currencyKeys, uint[] newRates, uint timeSent)
internal
returns(bool)
{
require(currencyKeys.length == newRates.length, "Currency key array length must match rates array length.");
require(timeSent < (now + ORACLE_FUTURE_LIMIT), "Time is too far into the future");
... | /**
* @notice Internal function which sets the rates stored in this contract
* @param currencyKeys The currency keys you wish to update the rates for (in order)
* @param newRates The rates for each currency (in order)
* @param timeSent The timestamp of when the update was sent, specified in seconds since epoch (e.g... | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://7e5de7b2c8454afb4fecf2a46fa9ccc0e392fe2b302da0369358c02ba4f12d11 | {
"func_code_index": [
7543,
8933
]
} | 12,295 | |
Synthetix | Synthetix.sol | 0x7cb89c509001d25da9938999abfea6740212e5f0 | Solidity | ExchangeRates | contract ExchangeRates is SelfDestructible {
using SafeMath for uint;
using SafeDecimalMath for uint;
struct RateAndUpdatedTime {
uint216 rate;
uint40 time;
}
// Exchange rates and update times stored by currency code, e.g. 'SNX', or 'sUSD'
mapping(bytes32 => RateAndUpdatedTi... | /**
* @title The repository for exchange rates
*/ | NatSpecMultiLine | rateOrInverted | function rateOrInverted(bytes32 currencyKey, uint rate) internal returns (uint) {
// if an inverse mapping exists, adjust the price accordingly
InversePricing storage inverse = inversePricing[currencyKey];
if (inverse.entryPoint <= 0) {
return rate;
}
// set the rate to the current rate ini... | /**
* @notice Internal function to get the inverted rate, if any, and mark an inverted
* key as frozen if either limits are reached.
*
* Inverted rates are ones that take a regular rate, perform a simple calculation (double entryPrice and
* subtract the rate) on them and if the result of the calculation is over o... | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://7e5de7b2c8454afb4fecf2a46fa9ccc0e392fe2b302da0369358c02ba4f12d11 | {
"func_code_index": [
10221,
11784
]
} | 12,296 | |
Synthetix | Synthetix.sol | 0x7cb89c509001d25da9938999abfea6740212e5f0 | Solidity | ExchangeRates | contract ExchangeRates is SelfDestructible {
using SafeMath for uint;
using SafeDecimalMath for uint;
struct RateAndUpdatedTime {
uint216 rate;
uint40 time;
}
// Exchange rates and update times stored by currency code, e.g. 'SNX', or 'sUSD'
mapping(bytes32 => RateAndUpdatedTi... | /**
* @title The repository for exchange rates
*/ | NatSpecMultiLine | deleteRate | function deleteRate(bytes32 currencyKey)
external
onlyOracle
{
require(rates(currencyKey) > 0, "Rate is zero");
delete _rates[currencyKey];
emit RateDeleted(currencyKey);
}
| /**
* @notice Delete a rate stored in the contract
* @param currencyKey The currency key you wish to delete the rate for
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://7e5de7b2c8454afb4fecf2a46fa9ccc0e392fe2b302da0369358c02ba4f12d11 | {
"func_code_index": [
11929,
12155
]
} | 12,297 | |
Synthetix | Synthetix.sol | 0x7cb89c509001d25da9938999abfea6740212e5f0 | Solidity | ExchangeRates | contract ExchangeRates is SelfDestructible {
using SafeMath for uint;
using SafeDecimalMath for uint;
struct RateAndUpdatedTime {
uint216 rate;
uint40 time;
}
// Exchange rates and update times stored by currency code, e.g. 'SNX', or 'sUSD'
mapping(bytes32 => RateAndUpdatedTi... | /**
* @title The repository for exchange rates
*/ | NatSpecMultiLine | setOracle | function setOracle(address _oracle)
external
onlyOwner
{
oracle = _oracle;
emit OracleUpdated(oracle);
}
| /**
* @notice Set the Oracle that pushes the rate information to this contract
* @param _oracle The new oracle address
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://7e5de7b2c8454afb4fecf2a46fa9ccc0e392fe2b302da0369358c02ba4f12d11 | {
"func_code_index": [
12298,
12446
]
} | 12,298 | |
Synthetix | Synthetix.sol | 0x7cb89c509001d25da9938999abfea6740212e5f0 | Solidity | ExchangeRates | contract ExchangeRates is SelfDestructible {
using SafeMath for uint;
using SafeDecimalMath for uint;
struct RateAndUpdatedTime {
uint216 rate;
uint40 time;
}
// Exchange rates and update times stored by currency code, e.g. 'SNX', or 'sUSD'
mapping(bytes32 => RateAndUpdatedTi... | /**
* @title The repository for exchange rates
*/ | NatSpecMultiLine | setRateStalePeriod | function setRateStalePeriod(uint _time)
external
onlyOwner
{
rateStalePeriod = _time;
emit RateStalePeriodUpdated(rateStalePeriod);
}
| /**
* @notice Set the stale period on the updated rate variables
* @param _time The new rateStalePeriod
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://7e5de7b2c8454afb4fecf2a46fa9ccc0e392fe2b302da0369358c02ba4f12d11 | {
"func_code_index": [
12574,
12751
]
} | 12,299 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.