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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
VeraCoin | VeraCoin.sol | 0xf90f1648926005a8bb3ed8ec883164de7f768743 | Solidity | Haltable | contract Haltable is Ownable {
bool public halted;
modifier stopInEmergency {
require(!halted);
_;
}
modifier onlyInEmergency {
require(halted);
_;
}
// called by the owner on emergency, triggers stopped state
function halt() external onlyOwne... | /*
* Haltable
*
* Abstract contract that allows children to implement an
* emergency stop mechanism. Differs from Pausable by causing a throw when in halt mode.
*
*
* Originally envisioned in FirstBlood ICO contract.
*/ | Comment | unhalt | function unhalt() external onlyOwner onlyInEmergency {
halted = false;
}
| // called by the owner on end of emergency, returns to normal state | LineComment | v0.4.16+commit.d7661dd9 | bzzr://1f27e8465532873eb3888aa6ff655b1a02573d4be9906245de4351d19e9f1da1 | {
"func_code_index": [
431,
522
]
} | 59,461 | |
VeraCoin | VeraCoin.sol | 0xf90f1648926005a8bb3ed8ec883164de7f768743 | Solidity | BasicToken | contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping (address => uint256) balances;
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
function transfer(address _to, ui... | /**
* @title Basic token
* @dev Basic version of StandardToken, with no allowances.
*/ | NatSpecMultiLine | transfer | function transfer(address _to, uint256 _value) returns (bool) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
| /**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/ | NatSpecMultiLine | v0.4.16+commit.d7661dd9 | bzzr://1f27e8465532873eb3888aa6ff655b1a02573d4be9906245de4351d19e9f1da1 | {
"func_code_index": [
283,
542
]
} | 59,462 | |
VeraCoin | VeraCoin.sol | 0xf90f1648926005a8bb3ed8ec883164de7f768743 | Solidity | BasicToken | contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping (address => uint256) balances;
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
function transfer(address _to, ui... | /**
* @title Basic token
* @dev Basic version of StandardToken, with no allowances.
*/ | NatSpecMultiLine | balanceOf | function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
| /**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/ | NatSpecMultiLine | v0.4.16+commit.d7661dd9 | bzzr://1f27e8465532873eb3888aa6ff655b1a02573d4be9906245de4351d19e9f1da1 | {
"func_code_index": [
758,
875
]
} | 59,463 | |
VeraCoin | VeraCoin.sol | 0xf90f1648926005a8bb3ed8ec883164de7f768743 | Solidity | StandardToken | contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to trans... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | transferFrom | function transferFrom(address _from, address _to, uint256 _value) returns (bool) {
var _allowance = allowed[_from][msg.sender];
// Check is not needed because sub(_allowance, _value) will already throw if this condition is not met
// require (_value <= _allowance);
balances[_to] = balances[_to].... | /**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amout of tokens to be transfered
*/ | NatSpecMultiLine | v0.4.16+commit.d7661dd9 | bzzr://1f27e8465532873eb3888aa6ff655b1a02573d4be9906245de4351d19e9f1da1 | {
"func_code_index": [
404,
943
]
} | 59,464 | |
VeraCoin | VeraCoin.sol | 0xf90f1648926005a8bb3ed8ec883164de7f768743 | Solidity | StandardToken | contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to trans... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | approve | function approve(address _spender, uint256 _value) returns (bool) {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ether... | /**
* @dev Aprove the passed address to spend the specified amount of tokens on behalf of msg.sender.
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/ | NatSpecMultiLine | v0.4.16+commit.d7661dd9 | bzzr://1f27e8465532873eb3888aa6ff655b1a02573d4be9906245de4351d19e9f1da1 | {
"func_code_index": [
1188,
1772
]
} | 59,465 | |
VeraCoin | VeraCoin.sol | 0xf90f1648926005a8bb3ed8ec883164de7f768743 | Solidity | StandardToken | contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to trans... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | allowance | function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
| /**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifing the amount of tokens still avaible for the spender.
*/ | NatSpecMultiLine | v0.4.16+commit.d7661dd9 | bzzr://1f27e8465532873eb3888aa6ff655b1a02573d4be9906245de4351d19e9f1da1 | {
"func_code_index": [
2105,
2251
]
} | 59,466 | |
VeraCoin | VeraCoin.sol | 0xf90f1648926005a8bb3ed8ec883164de7f768743 | Solidity | VeraCoin | contract VeraCoin is StandardToken {
string public name = "VeraCoin";
string public symbol = "Vera";
uint256 public decimals = 18;
uint256 public INITIAL_SUPPLY = 15700000 * 1 ether;
/**
* @dev Contructor that gives msg.sender all of existing tokens.
*/
function VeraCoi... | /**
* @title VeraCoin
* @dev Very simple ERC20 Token example, where all tokens are pre-assigned to the creator.
* Note they can later distribute these tokens as they wish using `transfer` and other
* `StandardToken` functions.
*/ | NatSpecMultiLine | VeraCoin | function VeraCoin() {
totalSupply = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
}
| /**
* @dev Contructor that gives msg.sender all of existing tokens.
*/ | NatSpecMultiLine | v0.4.16+commit.d7661dd9 | bzzr://1f27e8465532873eb3888aa6ff655b1a02573d4be9906245de4351d19e9f1da1 | {
"func_code_index": [
300,
420
]
} | 59,467 | |
Packs | contracts/IPacks.sol | 0x1495ecbac40a69028b5d516597137de5e929b01b | Solidity | IPacks | interface IPacks is IERC721Enumerable {
/*
* cID refers to collection ID
* Should not have more than 1000 editions of the same collectible (gas limit recommended, technically can support ~4000 editions)
*/
/// @notice Transfers contract ownership to DAO / different address
/// @param _daoAddress The ne... | /// @title Creators can release NFTs with multiple collectibles, across multiple collections/drops, and buyers will receive a random tokenID
/// @notice This interface should be implemented by the Packs contract
/// @dev This interface should be implemented by the Packs contract | NatSpecSingleLine | transferDAOownership | function transferDAOownership(address payable _daoAddress) external;
| /// @notice Transfers contract ownership to DAO / different address
/// @param _daoAddress The new address | NatSpecSingleLine | v0.7.3+commit.9bfce1f6 | {
"func_code_index": [
330,
400
]
} | 59,468 | ||
Packs | contracts/IPacks.sol | 0x1495ecbac40a69028b5d516597137de5e929b01b | Solidity | IPacks | interface IPacks is IERC721Enumerable {
/*
* cID refers to collection ID
* Should not have more than 1000 editions of the same collectible (gas limit recommended, technically can support ~4000 editions)
*/
/// @notice Transfers contract ownership to DAO / different address
/// @param _daoAddress The ne... | /// @title Creators can release NFTs with multiple collectibles, across multiple collections/drops, and buyers will receive a random tokenID
/// @notice This interface should be implemented by the Packs contract
/// @dev This interface should be implemented by the Packs contract | NatSpecSingleLine | createNewCollection | function createNewCollection(string memory _baseURI, bool _editioned, uint256[] memory _initParams, string memory _licenseURI, address _mintPass, uint256 _mintPassDuration, bool[] memory _mintPassParams) external;
| /// @notice Creates a new collection / drop (first collection is created via constructor)
/// @param _baseURI Base URI (e.g. https://arweave.net/)
/// @param _editioned Toggle to show edition # in returned metadata
/// @param _initParams Initialization parameters in array [token price, bulk buy max quantity, start time... | NatSpecSingleLine | v0.7.3+commit.9bfce1f6 | {
"func_code_index": [
1109,
1324
]
} | 59,469 | ||
Packs | contracts/IPacks.sol | 0x1495ecbac40a69028b5d516597137de5e929b01b | Solidity | IPacks | interface IPacks is IERC721Enumerable {
/*
* cID refers to collection ID
* Should not have more than 1000 editions of the same collectible (gas limit recommended, technically can support ~4000 editions)
*/
/// @notice Transfers contract ownership to DAO / different address
/// @param _daoAddress The ne... | /// @title Creators can release NFTs with multiple collectibles, across multiple collections/drops, and buyers will receive a random tokenID
/// @notice This interface should be implemented by the Packs contract
/// @dev This interface should be implemented by the Packs contract | NatSpecSingleLine | addCollectible | function addCollectible(uint256 cID, string[] memory _coreData, string[] memory _assets, string[][] memory _metadataValues, string[][] memory _secondaryMetadata, LibPackStorage.Fee[] memory _fees) external;
| /// @notice Adds a collectible with multiple versions of artwork, metadata, and royalty declaration
/// @param cID Collection ID
/// @param _coreData Array of parameters [title, description, # of NFTs, current artwork version index starting 1]
/// @param _assets Array of artwork assets, starting index 0 indicative of v... | NatSpecSingleLine | v0.7.3+commit.9bfce1f6 | {
"func_code_index": [
1959,
2167
]
} | 59,470 | ||
Packs | contracts/IPacks.sol | 0x1495ecbac40a69028b5d516597137de5e929b01b | Solidity | IPacks | interface IPacks is IERC721Enumerable {
/*
* cID refers to collection ID
* Should not have more than 1000 editions of the same collectible (gas limit recommended, technically can support ~4000 editions)
*/
/// @notice Transfers contract ownership to DAO / different address
/// @param _daoAddress The ne... | /// @title Creators can release NFTs with multiple collectibles, across multiple collections/drops, and buyers will receive a random tokenID
/// @notice This interface should be implemented by the Packs contract
/// @dev This interface should be implemented by the Packs contract | NatSpecSingleLine | bulkAddCollectible | function bulkAddCollectible(uint256 cID, string[][] memory _coreData, string[][] memory _assets, string[][][] memory _metadataValues, string[][][] memory _secondaryMetadata, LibPackStorage.Fee[][] memory _fees) external;
| /// @notice Add multiple collectibles in one function call, same parameters as addCollectible but in array
/// @param cID Collection ID
/// @param _coreData Array of parameters [title, description, # of NFTs, current artwork version index starting 1]
/// @param _assets Array of artwork assets, starting index 0 indicati... | NatSpecSingleLine | v0.7.3+commit.9bfce1f6 | {
"func_code_index": [
2762,
2984
]
} | 59,471 | ||
Packs | contracts/IPacks.sol | 0x1495ecbac40a69028b5d516597137de5e929b01b | Solidity | IPacks | interface IPacks is IERC721Enumerable {
/*
* cID refers to collection ID
* Should not have more than 1000 editions of the same collectible (gas limit recommended, technically can support ~4000 editions)
*/
/// @notice Transfers contract ownership to DAO / different address
/// @param _daoAddress The ne... | /// @title Creators can release NFTs with multiple collectibles, across multiple collections/drops, and buyers will receive a random tokenID
/// @notice This interface should be implemented by the Packs contract
/// @dev This interface should be implemented by the Packs contract | NatSpecSingleLine | mintPack | function mintPack(uint256 cID) external payable;
| /// @notice Mints an NFT with random token ID
/// @param cID Collection ID | NatSpecSingleLine | v0.7.3+commit.9bfce1f6 | {
"func_code_index": [
3313,
3363
]
} | 59,472 | ||
Packs | contracts/IPacks.sol | 0x1495ecbac40a69028b5d516597137de5e929b01b | Solidity | IPacks | interface IPacks is IERC721Enumerable {
/*
* cID refers to collection ID
* Should not have more than 1000 editions of the same collectible (gas limit recommended, technically can support ~4000 editions)
*/
/// @notice Transfers contract ownership to DAO / different address
/// @param _daoAddress The ne... | /// @title Creators can release NFTs with multiple collectibles, across multiple collections/drops, and buyers will receive a random tokenID
/// @notice This interface should be implemented by the Packs contract
/// @dev This interface should be implemented by the Packs contract | NatSpecSingleLine | bulkMintPack | function bulkMintPack(uint256 cID, uint256 amount) external payable;
| /// @notice Mints multiple NFTs with random token IDs
/// @param cID Collection ID
/// @param amount # of NFTs to mint | NatSpecSingleLine | v0.7.3+commit.9bfce1f6 | {
"func_code_index": [
3490,
3560
]
} | 59,473 | ||
Packs | contracts/IPacks.sol | 0x1495ecbac40a69028b5d516597137de5e929b01b | Solidity | IPacks | interface IPacks is IERC721Enumerable {
/*
* cID refers to collection ID
* Should not have more than 1000 editions of the same collectible (gas limit recommended, technically can support ~4000 editions)
*/
/// @notice Transfers contract ownership to DAO / different address
/// @param _daoAddress The ne... | /// @title Creators can release NFTs with multiple collectibles, across multiple collections/drops, and buyers will receive a random tokenID
/// @notice This interface should be implemented by the Packs contract
/// @dev This interface should be implemented by the Packs contract | NatSpecSingleLine | mintPassClaimed | function mintPassClaimed(uint256 cID, uint256 tokenId) external view returns (bool);
| /// @notice Returns if an NFT was used as mint pass claim
/// @param cID Collection ID
/// @param tokenId NFT tokenID | NatSpecSingleLine | v0.7.3+commit.9bfce1f6 | {
"func_code_index": [
3686,
3772
]
} | 59,474 | ||
Packs | contracts/IPacks.sol | 0x1495ecbac40a69028b5d516597137de5e929b01b | Solidity | IPacks | interface IPacks is IERC721Enumerable {
/*
* cID refers to collection ID
* Should not have more than 1000 editions of the same collectible (gas limit recommended, technically can support ~4000 editions)
*/
/// @notice Transfers contract ownership to DAO / different address
/// @param _daoAddress The ne... | /// @title Creators can release NFTs with multiple collectibles, across multiple collections/drops, and buyers will receive a random tokenID
/// @notice This interface should be implemented by the Packs contract
/// @dev This interface should be implemented by the Packs contract | NatSpecSingleLine | tokensClaimable | function tokensClaimable(uint256 cID, address minter) external view returns (uint256[] memory);
| /// @notice Returns enumerable list of tokens that can be used to claim for mint pass
/// @param cID Collection ID
/// @param minter address of holder | NatSpecSingleLine | v0.7.3+commit.9bfce1f6 | {
"func_code_index": [
3931,
4028
]
} | 59,475 | ||
Packs | contracts/IPacks.sol | 0x1495ecbac40a69028b5d516597137de5e929b01b | Solidity | IPacks | interface IPacks is IERC721Enumerable {
/*
* cID refers to collection ID
* Should not have more than 1000 editions of the same collectible (gas limit recommended, technically can support ~4000 editions)
*/
/// @notice Transfers contract ownership to DAO / different address
/// @param _daoAddress The ne... | /// @title Creators can release NFTs with multiple collectibles, across multiple collections/drops, and buyers will receive a random tokenID
/// @notice This interface should be implemented by the Packs contract
/// @dev This interface should be implemented by the Packs contract | NatSpecSingleLine | remainingTokens | function remainingTokens(uint256 cID) external view returns (uint256);
| /// @notice Returns remaining NFTs available to purchase
/// @param cID Collection ID | NatSpecSingleLine | v0.7.3+commit.9bfce1f6 | {
"func_code_index": [
4120,
4192
]
} | 59,476 | ||
Packs | contracts/IPacks.sol | 0x1495ecbac40a69028b5d516597137de5e929b01b | Solidity | IPacks | interface IPacks is IERC721Enumerable {
/*
* cID refers to collection ID
* Should not have more than 1000 editions of the same collectible (gas limit recommended, technically can support ~4000 editions)
*/
/// @notice Transfers contract ownership to DAO / different address
/// @param _daoAddress The ne... | /// @title Creators can release NFTs with multiple collectibles, across multiple collections/drops, and buyers will receive a random tokenID
/// @notice This interface should be implemented by the Packs contract
/// @dev This interface should be implemented by the Packs contract | NatSpecSingleLine | updateMetadata | function updateMetadata(uint256 cID, uint256 collectibleId, uint256 propertyIndex, string memory value) external;
| /// @notice Updates metadata value given property is editable
/// @param cID Collection ID
/// @param collectibleId Collectible index (value 1 is index 0)
/// @param propertyIndex Index of property to update (value 0 is index 0)
/// @param value Value of property to update | NatSpecSingleLine | v0.7.3+commit.9bfce1f6 | {
"func_code_index": [
4478,
4593
]
} | 59,477 | ||
Packs | contracts/IPacks.sol | 0x1495ecbac40a69028b5d516597137de5e929b01b | Solidity | IPacks | interface IPacks is IERC721Enumerable {
/*
* cID refers to collection ID
* Should not have more than 1000 editions of the same collectible (gas limit recommended, technically can support ~4000 editions)
*/
/// @notice Transfers contract ownership to DAO / different address
/// @param _daoAddress The ne... | /// @title Creators can release NFTs with multiple collectibles, across multiple collections/drops, and buyers will receive a random tokenID
/// @notice This interface should be implemented by the Packs contract
/// @dev This interface should be implemented by the Packs contract | NatSpecSingleLine | addVersion | function addVersion(uint256 cID, uint256 collectibleId, string memory asset) external;
| /// @notice Adds new URI version with provided asset
/// @param cID Collection ID
/// @param collectibleId Collectible index (value 1 is index 0)
/// @param asset Asset hash without baseURI included | NatSpecSingleLine | v0.7.3+commit.9bfce1f6 | {
"func_code_index": [
4802,
4890
]
} | 59,478 | ||
Packs | contracts/IPacks.sol | 0x1495ecbac40a69028b5d516597137de5e929b01b | Solidity | IPacks | interface IPacks is IERC721Enumerable {
/*
* cID refers to collection ID
* Should not have more than 1000 editions of the same collectible (gas limit recommended, technically can support ~4000 editions)
*/
/// @notice Transfers contract ownership to DAO / different address
/// @param _daoAddress The ne... | /// @title Creators can release NFTs with multiple collectibles, across multiple collections/drops, and buyers will receive a random tokenID
/// @notice This interface should be implemented by the Packs contract
/// @dev This interface should be implemented by the Packs contract | NatSpecSingleLine | addNewLicense | function addNewLicense(uint256 cID, string memory _license) external;
| /// @notice Adds new license URL for collection, auto increments license version number
/// @param cID Collection ID
/// @param _license Full URL of license | NatSpecSingleLine | v0.7.3+commit.9bfce1f6 | {
"func_code_index": [
5389,
5460
]
} | 59,479 | ||
Packs | contracts/IPacks.sol | 0x1495ecbac40a69028b5d516597137de5e929b01b | Solidity | IPacks | interface IPacks is IERC721Enumerable {
/*
* cID refers to collection ID
* Should not have more than 1000 editions of the same collectible (gas limit recommended, technically can support ~4000 editions)
*/
/// @notice Transfers contract ownership to DAO / different address
/// @param _daoAddress The ne... | /// @title Creators can release NFTs with multiple collectibles, across multiple collections/drops, and buyers will receive a random tokenID
/// @notice This interface should be implemented by the Packs contract
/// @dev This interface should be implemented by the Packs contract | NatSpecSingleLine | getLicense | function getLicense(uint256 cID, uint256 versionNumber) external view returns (string memory);
| /// @notice Gets license given a license version
/// @param cID Collection ID
/// @param versionNumber Version number of license | NatSpecSingleLine | v0.7.3+commit.9bfce1f6 | {
"func_code_index": [
5597,
5693
]
} | 59,480 | ||
Packs | contracts/IPacks.sol | 0x1495ecbac40a69028b5d516597137de5e929b01b | Solidity | IPacks | interface IPacks is IERC721Enumerable {
/*
* cID refers to collection ID
* Should not have more than 1000 editions of the same collectible (gas limit recommended, technically can support ~4000 editions)
*/
/// @notice Transfers contract ownership to DAO / different address
/// @param _daoAddress The ne... | /// @title Creators can release NFTs with multiple collectibles, across multiple collections/drops, and buyers will receive a random tokenID
/// @notice This interface should be implemented by the Packs contract
/// @dev This interface should be implemented by the Packs contract | NatSpecSingleLine | getCollectionCount | function getCollectionCount() external view returns (uint256);
| /// @notice Returns number of collections | NatSpecSingleLine | v0.7.3+commit.9bfce1f6 | {
"func_code_index": [
5739,
5803
]
} | 59,481 | ||
Packs | contracts/IPacks.sol | 0x1495ecbac40a69028b5d516597137de5e929b01b | Solidity | IPacks | interface IPacks is IERC721Enumerable {
/*
* cID refers to collection ID
* Should not have more than 1000 editions of the same collectible (gas limit recommended, technically can support ~4000 editions)
*/
/// @notice Transfers contract ownership to DAO / different address
/// @param _daoAddress The ne... | /// @title Creators can release NFTs with multiple collectibles, across multiple collections/drops, and buyers will receive a random tokenID
/// @notice This interface should be implemented by the Packs contract
/// @dev This interface should be implemented by the Packs contract | NatSpecSingleLine | tokenURI | function tokenURI(uint256 tokenId) external view returns (string memory);
| /// @notice Dynamically generates tokenURI as base64 encoded JSON of on-chain metadata
/// @param tokenId NFT/Token ID number | NatSpecSingleLine | v0.7.3+commit.9bfce1f6 | {
"func_code_index": [
5935,
6010
]
} | 59,482 | ||
Packs | contracts/IPacks.sol | 0x1495ecbac40a69028b5d516597137de5e929b01b | Solidity | IPacks | interface IPacks is IERC721Enumerable {
/*
* cID refers to collection ID
* Should not have more than 1000 editions of the same collectible (gas limit recommended, technically can support ~4000 editions)
*/
/// @notice Transfers contract ownership to DAO / different address
/// @param _daoAddress The ne... | /// @title Creators can release NFTs with multiple collectibles, across multiple collections/drops, and buyers will receive a random tokenID
/// @notice This interface should be implemented by the Packs contract
/// @dev This interface should be implemented by the Packs contract | NatSpecSingleLine | getFeeRecipients | function getFeeRecipients(uint256 tokenId) external view returns (address payable[] memory);
| /// @notice Returns addresses of secondary sale fees (Rarible Royalties Standard)
/// @param tokenId NFT/Token ID number | NatSpecSingleLine | v0.7.3+commit.9bfce1f6 | {
"func_code_index": [
6137,
6231
]
} | 59,483 | ||
Packs | contracts/IPacks.sol | 0x1495ecbac40a69028b5d516597137de5e929b01b | Solidity | IPacks | interface IPacks is IERC721Enumerable {
/*
* cID refers to collection ID
* Should not have more than 1000 editions of the same collectible (gas limit recommended, technically can support ~4000 editions)
*/
/// @notice Transfers contract ownership to DAO / different address
/// @param _daoAddress The ne... | /// @title Creators can release NFTs with multiple collectibles, across multiple collections/drops, and buyers will receive a random tokenID
/// @notice This interface should be implemented by the Packs contract
/// @dev This interface should be implemented by the Packs contract | NatSpecSingleLine | getFeeBps | function getFeeBps(uint256 tokenId) external view returns (uint256[] memory);
| /// @notice Returns basis point values of secondary sale fees (Rarible Royalties Standard)
/// @param tokenId NFT/Token ID number | NatSpecSingleLine | v0.7.3+commit.9bfce1f6 | {
"func_code_index": [
6367,
6446
]
} | 59,484 | ||
Packs | contracts/IPacks.sol | 0x1495ecbac40a69028b5d516597137de5e929b01b | Solidity | IPacks | interface IPacks is IERC721Enumerable {
/*
* cID refers to collection ID
* Should not have more than 1000 editions of the same collectible (gas limit recommended, technically can support ~4000 editions)
*/
/// @notice Transfers contract ownership to DAO / different address
/// @param _daoAddress The ne... | /// @title Creators can release NFTs with multiple collectibles, across multiple collections/drops, and buyers will receive a random tokenID
/// @notice This interface should be implemented by the Packs contract
/// @dev This interface should be implemented by the Packs contract | NatSpecSingleLine | royaltyInfo | function royaltyInfo(uint256 tokenId, uint256 value) external view returns (address recipient, uint256 amount);
| /// @notice Returns address and value of secondary sale fee (EIP-2981 royalties standard)
/// @param tokenId NFT/Token ID number
/// @param value ETH/ERC20 value to calculate from | NatSpecSingleLine | v0.7.3+commit.9bfce1f6 | {
"func_code_index": [
6634,
6747
]
} | 59,485 | ||
RedditInu | RedditInu.sol | 0xf1fbfdf5b13aa626f7c9cc496eacfe1c92b55c9e | Solidity | RedditInu | contract RedditInu is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Reddit Inu";
string private constant _symbol = "RINU";
uint8 private constant _decimals = 9;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) priv... | setMinSwapTokensThreshold | function setMinSwapTokensThreshold(uint256 swapTokensAtAmount) public onlyOwner {
_swapTokensAtAmount = swapTokensAtAmount;
}
| //Set minimum tokens required to swap. | LineComment | v0.8.11+commit.d7f03943 | None | ipfs://09f4361e91067f23585e65b0686ef91b211e13cecdbecb1c8fd6ee9d3fd0f054 | {
"func_code_index": [
13546,
13690
]
} | 59,486 | ||
RedditInu | RedditInu.sol | 0xf1fbfdf5b13aa626f7c9cc496eacfe1c92b55c9e | Solidity | RedditInu | contract RedditInu is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Reddit Inu";
string private constant _symbol = "RINU";
uint8 private constant _decimals = 9;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) priv... | toggleSwap | function toggleSwap(bool _swapEnabled) public onlyOwner {
swapEnabled = _swapEnabled;
}
| //Set minimum tokens required to swap. | LineComment | v0.8.11+commit.d7f03943 | None | ipfs://09f4361e91067f23585e65b0686ef91b211e13cecdbecb1c8fd6ee9d3fd0f054 | {
"func_code_index": [
13741,
13847
]
} | 59,487 | ||
RedditInu | RedditInu.sol | 0xf1fbfdf5b13aa626f7c9cc496eacfe1c92b55c9e | Solidity | RedditInu | contract RedditInu is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Reddit Inu";
string private constant _symbol = "RINU";
uint8 private constant _decimals = 9;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) priv... | setMaxTxnAmount | function setMaxTxnAmount(uint256 maxTxAmount) public onlyOwner {
_maxTxAmount = maxTxAmount;
}
| //Set MAx transaction | LineComment | v0.8.11+commit.d7f03943 | None | ipfs://09f4361e91067f23585e65b0686ef91b211e13cecdbecb1c8fd6ee9d3fd0f054 | {
"func_code_index": [
13881,
13994
]
} | 59,488 | ||
ZenswapLiquidityToken | ZenswapLiquidityToken.sol | 0xf5d00367e6e0f2d3ac29997641b81c153a8f6444 | Solidity | ZenswapLiquidityToken | contract ZenswapLiquidityToken is Ownable {
// Public variables of the token
string public name = "Zenswap Liquidity Token";
string public symbol = "ZLT-U";
uint8 public decimals = 18;
uint256 public initialSupply = 120000000000000000000000000;
uint256 public totalSupply;
bool public ... | /**
* This ZLT-U token will be swapped to official ZLT token before Zenswap platform launch
*/ | NatSpecMultiLine | setSwapContract | function setSwapContract(address _swapAddress) public onlyOwner {
swapContract = swappingContract(_swapAddress);
swapAddress = _swapAddress;
canSwap = true;
}
| // This sets the swap contract address for swapping this token to the official ZLT token | LineComment | v0.4.24+commit.e67f0147 | bzzr://05e623100cb0b0b74cfc1ec8017ab306857b4be3378a895c6bd97fe272c96454 | {
"func_code_index": [
1332,
1527
]
} | 59,489 | |
ZenswapLiquidityToken | ZenswapLiquidityToken.sol | 0xf5d00367e6e0f2d3ac29997641b81c153a8f6444 | Solidity | ZenswapLiquidityToken | contract ZenswapLiquidityToken is Ownable {
// Public variables of the token
string public name = "Zenswap Liquidity Token";
string public symbol = "ZLT-U";
uint8 public decimals = 18;
uint256 public initialSupply = 120000000000000000000000000;
uint256 public totalSupply;
bool public ... | /**
* This ZLT-U token will be swapped to official ZLT token before Zenswap platform launch
*/ | NatSpecMultiLine | swapThisToken | function swapThisToken(address _from, uint256 _value) internal returns(bool success) {
bool isSuccessful;
// Note: Set the external contract to return bool in this function
isSuccessful = swapContract.swapAssets(_from, _value);
return isSuccessful;
}
| // Calls the external swap contract and trigger the swap of ZLT-U to official ZLT token | LineComment | v0.4.24+commit.e67f0147 | bzzr://05e623100cb0b0b74cfc1ec8017ab306857b4be3378a895c6bd97fe272c96454 | {
"func_code_index": [
1789,
2085
]
} | 59,490 | |
ZenswapLiquidityToken | ZenswapLiquidityToken.sol | 0xf5d00367e6e0f2d3ac29997641b81c153a8f6444 | Solidity | ZenswapLiquidityToken | contract ZenswapLiquidityToken is Ownable {
// Public variables of the token
string public name = "Zenswap Liquidity Token";
string public symbol = "ZLT-U";
uint8 public decimals = 18;
uint256 public initialSupply = 120000000000000000000000000;
uint256 public totalSupply;
bool public ... | /**
* This ZLT-U token will be swapped to official ZLT token before Zenswap platform launch
*/ | NatSpecMultiLine | _transfer | function _transfer(address _from, address _to, uint256 _value) internal {
bool swapSuccess = true;
// Prevent transfer to 0x0 address. Use burn() instead
require(_to != 0x0);
// Check if the sender has enough
require(balanceOf[_from] >= _value);
// Check for overflows
... | /**
* Internal transfer, only can be called by this contract
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://05e623100cb0b0b74cfc1ec8017ab306857b4be3378a895c6bd97fe272c96454 | {
"func_code_index": [
2171,
3297
]
} | 59,491 | |
ZenswapLiquidityToken | ZenswapLiquidityToken.sol | 0xf5d00367e6e0f2d3ac29997641b81c153a8f6444 | Solidity | ZenswapLiquidityToken | contract ZenswapLiquidityToken is Ownable {
// Public variables of the token
string public name = "Zenswap Liquidity Token";
string public symbol = "ZLT-U";
uint8 public decimals = 18;
uint256 public initialSupply = 120000000000000000000000000;
uint256 public totalSupply;
bool public ... | /**
* This ZLT-U token will be swapped to official ZLT token before Zenswap platform launch
*/ | NatSpecMultiLine | transfer | function transfer(address _to, uint256 _value) public {
_transfer(msg.sender, _to, _value);
}
| /**
* Transfer tokens
*
* Send `_value` tokens to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://05e623100cb0b0b74cfc1ec8017ab306857b4be3378a895c6bd97fe272c96454 | {
"func_code_index": [
3503,
3625
]
} | 59,492 | |
ZenswapLiquidityToken | ZenswapLiquidityToken.sol | 0xf5d00367e6e0f2d3ac29997641b81c153a8f6444 | Solidity | ZenswapLiquidityToken | contract ZenswapLiquidityToken is Ownable {
// Public variables of the token
string public name = "Zenswap Liquidity Token";
string public symbol = "ZLT-U";
uint8 public decimals = 18;
uint256 public initialSupply = 120000000000000000000000000;
uint256 public totalSupply;
bool public ... | /**
* This ZLT-U token will be swapped to official ZLT token before Zenswap platform launch
*/ | NatSpecMultiLine | transferFrom | function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]); // Check allowance
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
| /**
* Transfer tokens from other address
*
* Send `_value` tokens to `_to` in behalf of `_from`
*
* @param _from The address of the sender
* @param _to The address of the recipient
* @param _value the amount to send
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://05e623100cb0b0b74cfc1ec8017ab306857b4be3378a895c6bd97fe272c96454 | {
"func_code_index": [
3900,
4201
]
} | 59,493 | |
ZenswapLiquidityToken | ZenswapLiquidityToken.sol | 0xf5d00367e6e0f2d3ac29997641b81c153a8f6444 | Solidity | ZenswapLiquidityToken | contract ZenswapLiquidityToken is Ownable {
// Public variables of the token
string public name = "Zenswap Liquidity Token";
string public symbol = "ZLT-U";
uint8 public decimals = 18;
uint256 public initialSupply = 120000000000000000000000000;
uint256 public totalSupply;
bool public ... | /**
* This ZLT-U token will be swapped to official ZLT token before Zenswap platform launch
*/ | NatSpecMultiLine | approve | function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
| /**
* Set allowance for other address
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://05e623100cb0b0b74cfc1ec8017ab306857b4be3378a895c6bd97fe272c96454 | {
"func_code_index": [
4465,
4641
]
} | 59,494 | |
ZenswapLiquidityToken | ZenswapLiquidityToken.sol | 0xf5d00367e6e0f2d3ac29997641b81c153a8f6444 | Solidity | ZenswapLiquidityToken | contract ZenswapLiquidityToken is Ownable {
// Public variables of the token
string public name = "Zenswap Liquidity Token";
string public symbol = "ZLT-U";
uint8 public decimals = 18;
uint256 public initialSupply = 120000000000000000000000000;
uint256 public totalSupply;
bool public ... | /**
* This ZLT-U token will be swapped to official ZLT token before Zenswap platform launch
*/ | NatSpecMultiLine | approveAndCall | function approveAndCall(address _spender, uint256 _value, bytes _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
| /**
* Set allowance for other address and notify
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf, and then ping the contract about it
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
* @param _extraData some extra information to s... | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://05e623100cb0b0b74cfc1ec8017ab306857b4be3378a895c6bd97fe272c96454 | {
"func_code_index": [
5035,
5387
]
} | 59,495 | |
ZenswapLiquidityToken | ZenswapLiquidityToken.sol | 0xf5d00367e6e0f2d3ac29997641b81c153a8f6444 | Solidity | ZenswapLiquidityToken | contract ZenswapLiquidityToken is Ownable {
// Public variables of the token
string public name = "Zenswap Liquidity Token";
string public symbol = "ZLT-U";
uint8 public decimals = 18;
uint256 public initialSupply = 120000000000000000000000000;
uint256 public totalSupply;
bool public ... | /**
* This ZLT-U token will be swapped to official ZLT token before Zenswap platform launch
*/ | NatSpecMultiLine | burn | function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value); // Check if the sender has enough
balanceOf[msg.sender] -= _value; // Subtract from the sender
totalSupply -= _value; // Updates totalSupply
emit Burn(msg.sender,... | /**
* Destroy tokens
*
* Remove `_value` tokens from the system irreversibly
*
* @param _value the amount of money to burn
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://05e623100cb0b0b74cfc1ec8017ab306857b4be3378a895c6bd97fe272c96454 | {
"func_code_index": [
5557,
5936
]
} | 59,496 | |
ZenswapLiquidityToken | ZenswapLiquidityToken.sol | 0xf5d00367e6e0f2d3ac29997641b81c153a8f6444 | Solidity | ZenswapLiquidityToken | contract ZenswapLiquidityToken is Ownable {
// Public variables of the token
string public name = "Zenswap Liquidity Token";
string public symbol = "ZLT-U";
uint8 public decimals = 18;
uint256 public initialSupply = 120000000000000000000000000;
uint256 public totalSupply;
bool public ... | /**
* This ZLT-U token will be swapped to official ZLT token before Zenswap platform launch
*/ | NatSpecMultiLine | burnFrom | function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value); // Check if the targeted balance is enough
require(_value <= allowance[_from][msg.sender]); // Check allowance
balanceOf[_from] -= _value; // Sub... | /**
* Destroy tokens from other account
*
* Remove `_value` tokens from the system irreversibly on behalf of `_from`.
*
* @param _from the address of the sender
* @param _value the amount of money to burn
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://05e623100cb0b0b74cfc1ec8017ab306857b4be3378a895c6bd97fe272c96454 | {
"func_code_index": [
6194,
6810
]
} | 59,497 | |
NephilimToken | NephilimToken.sol | 0xc05a5115a7e40c3af2fed11e847d3a74a7c21c08 | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two unsigned integers, reverts on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
... | /**
* @title SafeMath
* @dev Unsigned math operations with safety checks that revert on error
*/ | NatSpecMultiLine | mul | function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
... | /**
* @dev Multiplies two unsigned integers, reverts on overflow.
*/ | NatSpecMultiLine | v0.5.16+commit.9c3226ce | None | bzzr://5838b2662d1912e6e51799f4139153ec7c0fd6d2ea662206d09588eb7f466c88 | {
"func_code_index": [
104,
542
]
} | 59,498 |
NephilimToken | NephilimToken.sol | 0xc05a5115a7e40c3af2fed11e847d3a74a7c21c08 | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two unsigned integers, reverts on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
... | /**
* @title SafeMath
* @dev Unsigned math operations with safety checks that revert on error
*/ | NatSpecMultiLine | div | function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
| /**
* @dev Integer division of two unsigned integers truncating the quotient, reverts on division by zero.
*/ | NatSpecMultiLine | v0.5.16+commit.9c3226ce | None | bzzr://5838b2662d1912e6e51799f4139153ec7c0fd6d2ea662206d09588eb7f466c88 | {
"func_code_index": [
670,
978
]
} | 59,499 |
NephilimToken | NephilimToken.sol | 0xc05a5115a7e40c3af2fed11e847d3a74a7c21c08 | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two unsigned integers, reverts on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
... | /**
* @title SafeMath
* @dev Unsigned math operations with safety checks that revert on error
*/ | NatSpecMultiLine | sub | function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
| /**
* @dev Subtracts two unsigned integers, reverts on overflow (i.e. if subtrahend is greater than minuend).
*/ | NatSpecMultiLine | v0.5.16+commit.9c3226ce | None | bzzr://5838b2662d1912e6e51799f4139153ec7c0fd6d2ea662206d09588eb7f466c88 | {
"func_code_index": [
1109,
1264
]
} | 59,500 |
NephilimToken | NephilimToken.sol | 0xc05a5115a7e40c3af2fed11e847d3a74a7c21c08 | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two unsigned integers, reverts on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
... | /**
* @title SafeMath
* @dev Unsigned math operations with safety checks that revert on error
*/ | NatSpecMultiLine | add | function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
| /**
* @dev Adds two unsigned integers, reverts on overflow.
*/ | NatSpecMultiLine | v0.5.16+commit.9c3226ce | None | bzzr://5838b2662d1912e6e51799f4139153ec7c0fd6d2ea662206d09588eb7f466c88 | {
"func_code_index": [
1345,
1500
]
} | 59,501 |
NephilimToken | NephilimToken.sol | 0xc05a5115a7e40c3af2fed11e847d3a74a7c21c08 | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two unsigned integers, reverts on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
... | /**
* @title SafeMath
* @dev Unsigned math operations with safety checks that revert on error
*/ | NatSpecMultiLine | mod | function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
| /**
* @dev Divides two unsigned integers and returns the remainder (unsigned integer modulo),
* reverts when dividing by zero.
*/ | NatSpecMultiLine | v0.5.16+commit.9c3226ce | None | bzzr://5838b2662d1912e6e51799f4139153ec7c0fd6d2ea662206d09588eb7f466c88 | {
"func_code_index": [
1653,
1782
]
} | 59,502 |
NephilimToken | NephilimToken.sol | 0xc05a5115a7e40c3af2fed11e847d3a74a7c21c08 | Solidity | ERC20 | contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
mapping(address => uint256) private _deposits;
uint256 private _totalSupply;
/**
* @dev Total number of ... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
* Originally based on code by FirstBlood:
* https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*
* This implementation em... | NatSpecMultiLine | totalSupply | function totalSupply() public view returns (uint256) {
return _totalSupply;
}
| /**
* @dev Total number of tokens in existence
*/ | NatSpecMultiLine | v0.5.16+commit.9c3226ce | None | bzzr://5838b2662d1912e6e51799f4139153ec7c0fd6d2ea662206d09588eb7f466c88 | {
"func_code_index": [
349,
445
]
} | 59,503 |
NephilimToken | NephilimToken.sol | 0xc05a5115a7e40c3af2fed11e847d3a74a7c21c08 | Solidity | ERC20 | contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
mapping(address => uint256) private _deposits;
uint256 private _totalSupply;
/**
* @dev Total number of ... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
* Originally based on code by FirstBlood:
* https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*
* This implementation em... | NatSpecMultiLine | balanceOf | function balanceOf(address owner) public view returns (uint256) {
return _balances[owner];
}
| /**
* @dev Gets the balance of the specified address.
* @param owner The address to query the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/ | NatSpecMultiLine | v0.5.16+commit.9c3226ce | None | bzzr://5838b2662d1912e6e51799f4139153ec7c0fd6d2ea662206d09588eb7f466c88 | {
"func_code_index": [
656,
767
]
} | 59,504 |
NephilimToken | NephilimToken.sol | 0xc05a5115a7e40c3af2fed11e847d3a74a7c21c08 | Solidity | ERC20 | contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
mapping(address => uint256) private _deposits;
uint256 private _totalSupply;
/**
* @dev Total number of ... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
* Originally based on code by FirstBlood:
* https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*
* This implementation em... | NatSpecMultiLine | allowance | function allowance(address owner, address spender) public view returns (uint256) {
return _allowed[owner][spender];
}
| /**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param owner address The address which owns the funds.
* @param spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/ | NatSpecMultiLine | v0.5.16+commit.9c3226ce | None | bzzr://5838b2662d1912e6e51799f4139153ec7c0fd6d2ea662206d09588eb7f466c88 | {
"func_code_index": [
1101,
1237
]
} | 59,505 |
NephilimToken | NephilimToken.sol | 0xc05a5115a7e40c3af2fed11e847d3a74a7c21c08 | Solidity | ERC20 | contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
mapping(address => uint256) private _deposits;
uint256 private _totalSupply;
/**
* @dev Total number of ... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
* Originally based on code by FirstBlood:
* https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*
* This implementation em... | NatSpecMultiLine | transfer | function transfer(address to, uint256 value) public returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
| /**
* @dev Transfer token for a specified address
* @param to The address to transfer to.
* @param value The amount to be transferred.
*/ | NatSpecMultiLine | v0.5.16+commit.9c3226ce | None | bzzr://5838b2662d1912e6e51799f4139153ec7c0fd6d2ea662206d09588eb7f466c88 | {
"func_code_index": [
1403,
1548
]
} | 59,506 |
NephilimToken | NephilimToken.sol | 0xc05a5115a7e40c3af2fed11e847d3a74a7c21c08 | Solidity | ERC20 | contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
mapping(address => uint256) private _deposits;
uint256 private _totalSupply;
/**
* @dev Total number of ... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
* Originally based on code by FirstBlood:
* https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*
* This implementation em... | NatSpecMultiLine | approve | function approve(address spender, uint256 value) public returns (bool) {
//require(spender != address(0));
_allowed[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
| /**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
* Beware that changing an allowance with this method brings the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
* race... | NatSpecMultiLine | v0.5.16+commit.9c3226ce | None | bzzr://5838b2662d1912e6e51799f4139153ec7c0fd6d2ea662206d09588eb7f466c88 | {
"func_code_index": [
2190,
2441
]
} | 59,507 |
NephilimToken | NephilimToken.sol | 0xc05a5115a7e40c3af2fed11e847d3a74a7c21c08 | Solidity | ERC20 | contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
mapping(address => uint256) private _deposits;
uint256 private _totalSupply;
/**
* @dev Total number of ... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
* Originally based on code by FirstBlood:
* https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*
* This implementation em... | NatSpecMultiLine | transferFrom | function transferFrom(address from, address to, uint256 value) public returns (bool) {
_allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value);
_transfer(from, to, value);
emit Approval(from, msg.sender, _allowed[from][msg.sender]);
return true;
}
| /**
* @dev Transfer tokens from one address to another.
* Note that while this function emits an Approval event, this is not required as per the specification,
* and other compliant implementations may not emit the event.
* @param from address The address which you want to send tokens from
* @param to address... | NatSpecMultiLine | v0.5.16+commit.9c3226ce | None | bzzr://5838b2662d1912e6e51799f4139153ec7c0fd6d2ea662206d09588eb7f466c88 | {
"func_code_index": [
2909,
3213
]
} | 59,508 |
NephilimToken | NephilimToken.sol | 0xc05a5115a7e40c3af2fed11e847d3a74a7c21c08 | Solidity | ERC20 | contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
mapping(address => uint256) private _deposits;
uint256 private _totalSupply;
/**
* @dev Total number of ... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
* Originally based on code by FirstBlood:
* https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*
* This implementation em... | NatSpecMultiLine | increaseAllowance | function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = _allowed[msg.sender][spender].add(addedValue);
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
| /**
* @dev Increase the amount of tokens that an owner allowed to a spender.
* approve should be called when allowed_[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* Emits an Approva... | NatSpecMultiLine | v0.5.16+commit.9c3226ce | None | bzzr://5838b2662d1912e6e51799f4139153ec7c0fd6d2ea662206d09588eb7f466c88 | {
"func_code_index": [
3723,
4051
]
} | 59,509 |
NephilimToken | NephilimToken.sol | 0xc05a5115a7e40c3af2fed11e847d3a74a7c21c08 | Solidity | ERC20 | contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
mapping(address => uint256) private _deposits;
uint256 private _totalSupply;
/**
* @dev Total number of ... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
* Originally based on code by FirstBlood:
* https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*
* This implementation em... | NatSpecMultiLine | decreaseAllowance | function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = _allowed[msg.sender][spender].sub(subtractedValue);
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
| /**
* @dev Decrease the amount of tokens that an owner allowed to a spender.
* approve should be called when allowed_[_spender] == 0. To decrement
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* Emits an Approva... | NatSpecMultiLine | v0.5.16+commit.9c3226ce | None | bzzr://5838b2662d1912e6e51799f4139153ec7c0fd6d2ea662206d09588eb7f466c88 | {
"func_code_index": [
4566,
4904
]
} | 59,510 |
NephilimToken | NephilimToken.sol | 0xc05a5115a7e40c3af2fed11e847d3a74a7c21c08 | Solidity | ERC20 | contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
mapping(address => uint256) private _deposits;
uint256 private _totalSupply;
/**
* @dev Total number of ... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
* Originally based on code by FirstBlood:
* https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*
* This implementation em... | NatSpecMultiLine | _transfer | function _transfer(address from, address to, uint256 value) internal {
require(to != address(0));
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
}
| /**
* @dev Transfer token for a specified addresses
* @param from The address to transfer from.
* @param to The address to transfer to.
* @param value The amount to be transferred.
*/ | NatSpecMultiLine | v0.5.16+commit.9c3226ce | None | bzzr://5838b2662d1912e6e51799f4139153ec7c0fd6d2ea662206d09588eb7f466c88 | {
"func_code_index": [
5121,
5388
]
} | 59,511 |
NephilimToken | NephilimToken.sol | 0xc05a5115a7e40c3af2fed11e847d3a74a7c21c08 | Solidity | ERC20 | contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
mapping(address => uint256) private _deposits;
uint256 private _totalSupply;
/**
* @dev Total number of ... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
* Originally based on code by FirstBlood:
* https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*
* This implementation em... | NatSpecMultiLine | _mint | function _mint(address account, uint256 value) internal {
require(account != address(0));
_totalSupply = _totalSupply.add(value);
_balances[account] = _balances[account].add(value);
emit Transfer(address(0), account, value);
}
| /**
* @dev Internal function that mints an amount of the token and assigns it to
* an account. This encapsulates the modification of balances such that the
* proper events are emitted.
* @param account The account that will receive the created tokens.
* @param value The amount that will be created.
*/ | NatSpecMultiLine | v0.5.16+commit.9c3226ce | None | bzzr://5838b2662d1912e6e51799f4139153ec7c0fd6d2ea662206d09588eb7f466c88 | {
"func_code_index": [
5735,
6009
]
} | 59,512 |
NephilimToken | NephilimToken.sol | 0xc05a5115a7e40c3af2fed11e847d3a74a7c21c08 | Solidity | ERC20 | contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
mapping(address => uint256) private _deposits;
uint256 private _totalSupply;
/**
* @dev Total number of ... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
* Originally based on code by FirstBlood:
* https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*
* This implementation em... | NatSpecMultiLine | _burn | function _burn(address account, uint256 value) internal {
require(account != address(0));
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
| /**
* @dev Internal function that burns an amount of the token of a given
* account.
* @param account The account whose tokens will be burnt.
* @param value The amount that will be burnt.
*/ | NatSpecMultiLine | v0.5.16+commit.9c3226ce | None | bzzr://5838b2662d1912e6e51799f4139153ec7c0fd6d2ea662206d09588eb7f466c88 | {
"func_code_index": [
6238,
6512
]
} | 59,513 |
NephilimToken | NephilimToken.sol | 0xc05a5115a7e40c3af2fed11e847d3a74a7c21c08 | Solidity | ERC20 | contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
mapping(address => uint256) private _deposits;
uint256 private _totalSupply;
/**
* @dev Total number of ... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
* Originally based on code by FirstBlood:
* https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*
* This implementation em... | NatSpecMultiLine | _burnFrom | function _burnFrom(address account, uint256 value) internal {
_allowed[account][msg.sender] = _allowed[account][msg.sender].sub(value);
_burn(account, value);
emit Approval(account, msg.sender, _allowed[account][msg.sender]);
}
| /**
* @dev Internal function that burns an amount of the token of a given
* account, deducting from the sender's allowance for said account. Uses the
* internal burn function.
* Emits an Approval event (reflecting the reduced allowance).
* @param account The account whose tokens will be burnt.
* @param valu... | NatSpecMultiLine | v0.5.16+commit.9c3226ce | None | bzzr://5838b2662d1912e6e51799f4139153ec7c0fd6d2ea662206d09588eb7f466c88 | {
"func_code_index": [
6906,
7170
]
} | 59,514 |
NephilimToken | NephilimToken.sol | 0xc05a5115a7e40c3af2fed11e847d3a74a7c21c08 | Solidity | ERC20Detailed | contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
/**
* @retu... | /**
* @title ERC20Detailed token
* @dev The decimals are only for visualization purposes.
* All the operations are done using the smallest and indivisible token unit,
* just as on Ethereum all the operations are done in wei.
*/ | NatSpecMultiLine | name | function name() public view returns (string memory) {
return _name;
}
| /**
* @return the name of the token.
*/ | NatSpecMultiLine | v0.5.16+commit.9c3226ce | None | bzzr://5838b2662d1912e6e51799f4139153ec7c0fd6d2ea662206d09588eb7f466c88 | {
"func_code_index": [
356,
444
]
} | 59,515 |
NephilimToken | NephilimToken.sol | 0xc05a5115a7e40c3af2fed11e847d3a74a7c21c08 | Solidity | ERC20Detailed | contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
/**
* @retu... | /**
* @title ERC20Detailed token
* @dev The decimals are only for visualization purposes.
* All the operations are done using the smallest and indivisible token unit,
* just as on Ethereum all the operations are done in wei.
*/ | NatSpecMultiLine | symbol | function symbol() public view returns (string memory) {
return _symbol;
}
| /**
* @return the symbol of the token.
*/ | NatSpecMultiLine | v0.5.16+commit.9c3226ce | None | bzzr://5838b2662d1912e6e51799f4139153ec7c0fd6d2ea662206d09588eb7f466c88 | {
"func_code_index": [
506,
598
]
} | 59,516 |
NephilimToken | NephilimToken.sol | 0xc05a5115a7e40c3af2fed11e847d3a74a7c21c08 | Solidity | ERC20Detailed | contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
/**
* @retu... | /**
* @title ERC20Detailed token
* @dev The decimals are only for visualization purposes.
* All the operations are done using the smallest and indivisible token unit,
* just as on Ethereum all the operations are done in wei.
*/ | NatSpecMultiLine | decimals | function decimals() public view returns (uint8) {
return _decimals;
}
| /**
* @return the number of decimals of the token.
*/ | NatSpecMultiLine | v0.5.16+commit.9c3226ce | None | bzzr://5838b2662d1912e6e51799f4139153ec7c0fd6d2ea662206d09588eb7f466c88 | {
"func_code_index": [
672,
760
]
} | 59,517 |
NephilimToken | NephilimToken.sol | 0xc05a5115a7e40c3af2fed11e847d3a74a7c21c08 | Solidity | Ownable | contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor () internal {
_owner = m... | /**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/ | NatSpecMultiLine | owner | function owner() public view returns (address) {
return _owner;
}
| /**
* @return the address of the owner.
*/ | NatSpecMultiLine | v0.5.16+commit.9c3226ce | None | bzzr://5838b2662d1912e6e51799f4139153ec7c0fd6d2ea662206d09588eb7f466c88 | {
"func_code_index": [
457,
541
]
} | 59,518 |
NephilimToken | NephilimToken.sol | 0xc05a5115a7e40c3af2fed11e847d3a74a7c21c08 | Solidity | Ownable | contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor () internal {
_owner = m... | /**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/ | NatSpecMultiLine | isOwner | function isOwner() public view returns (bool) {
return msg.sender == _owner;
}
| /**
* @return true if `msg.sender` is the owner of the contract.
*/ | NatSpecMultiLine | v0.5.16+commit.9c3226ce | None | bzzr://5838b2662d1912e6e51799f4139153ec7c0fd6d2ea662206d09588eb7f466c88 | {
"func_code_index": [
792,
889
]
} | 59,519 |
NephilimToken | NephilimToken.sol | 0xc05a5115a7e40c3af2fed11e847d3a74a7c21c08 | Solidity | Ownable | contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor () internal {
_owner = m... | /**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/ | NatSpecMultiLine | renounceOwnership | function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
| /**
* @dev Allows the current owner to relinquish control of the contract.
* @notice Renouncing to ownership will leave the contract without an owner.
* It will not be possible to call the functions with the `onlyOwner`
* modifier anymore.
*/ | NatSpecMultiLine | v0.5.16+commit.9c3226ce | None | bzzr://5838b2662d1912e6e51799f4139153ec7c0fd6d2ea662206d09588eb7f466c88 | {
"func_code_index": [
1170,
1315
]
} | 59,520 |
NephilimToken | NephilimToken.sol | 0xc05a5115a7e40c3af2fed11e847d3a74a7c21c08 | Solidity | Ownable | contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor () internal {
_owner = m... | /**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/ | NatSpecMultiLine | transferOwnership | function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
| /**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/ | NatSpecMultiLine | v0.5.16+commit.9c3226ce | None | bzzr://5838b2662d1912e6e51799f4139153ec7c0fd6d2ea662206d09588eb7f466c88 | {
"func_code_index": [
1487,
1601
]
} | 59,521 |
NephilimToken | NephilimToken.sol | 0xc05a5115a7e40c3af2fed11e847d3a74a7c21c08 | Solidity | Ownable | contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor () internal {
_owner = m... | /**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/ | NatSpecMultiLine | _transferOwnership | function _transferOwnership(address newOwner) internal {
require(newOwner != address(0));
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
| /**
* @dev Transfers control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/ | NatSpecMultiLine | v0.5.16+commit.9c3226ce | None | bzzr://5838b2662d1912e6e51799f4139153ec7c0fd6d2ea662206d09588eb7f466c88 | {
"func_code_index": [
1746,
1938
]
} | 59,522 |
DSDRouterV1 | DSDRouterV1.sol | 0xd2150f143939d233924e48b8c9516d9fd7841d27 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns ... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | add | function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
| /**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/ | NatSpecMultiLine | v0.7.6+commit.7338295f | None | ipfs://3b908ced1da876930f2e9db473d5baf57d758391eb0860135a5ef083c92f0e26 | {
"func_code_index": [
259,
445
]
} | 59,523 |
DSDRouterV1 | DSDRouterV1.sol | 0xd2150f143939d233924e48b8c9516d9fd7841d27 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns ... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | sub | function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
| /**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/ | NatSpecMultiLine | v0.7.6+commit.7338295f | None | ipfs://3b908ced1da876930f2e9db473d5baf57d758391eb0860135a5ef083c92f0e26 | {
"func_code_index": [
723,
864
]
} | 59,524 |
DSDRouterV1 | DSDRouterV1.sol | 0xd2150f143939d233924e48b8c9516d9fd7841d27 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns ... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | sub | function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
| /**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/ | NatSpecMultiLine | v0.7.6+commit.7338295f | None | ipfs://3b908ced1da876930f2e9db473d5baf57d758391eb0860135a5ef083c92f0e26 | {
"func_code_index": [
1162,
1359
]
} | 59,525 |
DSDRouterV1 | DSDRouterV1.sol | 0xd2150f143939d233924e48b8c9516d9fd7841d27 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns ... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | mul | function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
... | /**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/ | NatSpecMultiLine | v0.7.6+commit.7338295f | None | ipfs://3b908ced1da876930f2e9db473d5baf57d758391eb0860135a5ef083c92f0e26 | {
"func_code_index": [
1613,
2089
]
} | 59,526 |
DSDRouterV1 | DSDRouterV1.sol | 0xd2150f143939d233924e48b8c9516d9fd7841d27 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns ... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | div | function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
| /**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to reve... | NatSpecMultiLine | v0.7.6+commit.7338295f | None | ipfs://3b908ced1da876930f2e9db473d5baf57d758391eb0860135a5ef083c92f0e26 | {
"func_code_index": [
2560,
2697
]
} | 59,527 |
DSDRouterV1 | DSDRouterV1.sol | 0xd2150f143939d233924e48b8c9516d9fd7841d27 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns ... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | div | function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
| /**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an in... | NatSpecMultiLine | v0.7.6+commit.7338295f | None | ipfs://3b908ced1da876930f2e9db473d5baf57d758391eb0860135a5ef083c92f0e26 | {
"func_code_index": [
3188,
3471
]
} | 59,528 |
DSDRouterV1 | DSDRouterV1.sol | 0xd2150f143939d233924e48b8c9516d9fd7841d27 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns ... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | mod | function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
| /**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consumi... | NatSpecMultiLine | v0.7.6+commit.7338295f | None | ipfs://3b908ced1da876930f2e9db473d5baf57d758391eb0860135a5ef083c92f0e26 | {
"func_code_index": [
3931,
4066
]
} | 59,529 |
DSDRouterV1 | DSDRouterV1.sol | 0xd2150f143939d233924e48b8c9516d9fd7841d27 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns ... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | mod | function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
| /**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcod... | NatSpecMultiLine | v0.7.6+commit.7338295f | None | ipfs://3b908ced1da876930f2e9db473d5baf57d758391eb0860135a5ef083c92f0e26 | {
"func_code_index": [
4546,
4717
]
} | 59,530 |
DSDRouterV1 | DSDRouterV1.sol | 0xd2150f143939d233924e48b8c9516d9fd7841d27 | Solidity | UniswapV2Library | library UniswapV2Library {
using SafeMath for uint;
// returns sorted token addresses, used to handle return values from pairs sorted in this order
function sortTokens(address tokenA, address tokenB) internal pure returns (address token0, address token1) {
require(tokenA != tokenB, 'UniswapV2L... | sortTokens | function sortTokens(address tokenA, address tokenB) internal pure returns (address token0, address token1) {
require(tokenA != tokenB, 'UniswapV2Library: IDENTICAL_ADDRESSES');
(token0, token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
require(token0 != address(0), 'UniswapV2Library: ZERO_... | // returns sorted token addresses, used to handle return values from pairs sorted in this order | LineComment | v0.7.6+commit.7338295f | None | ipfs://3b908ced1da876930f2e9db473d5baf57d758391eb0860135a5ef083c92f0e26 | {
"func_code_index": [
161,
515
]
} | 59,531 | ||
DSDRouterV1 | DSDRouterV1.sol | 0xd2150f143939d233924e48b8c9516d9fd7841d27 | Solidity | UniswapV2Library | library UniswapV2Library {
using SafeMath for uint;
// returns sorted token addresses, used to handle return values from pairs sorted in this order
function sortTokens(address tokenA, address tokenB) internal pure returns (address token0, address token1) {
require(tokenA != tokenB, 'UniswapV2L... | pairFor | function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = sortTokens(tokenA, tokenB);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
factory,
keccak256(abi.encodePacked(token0, to... | // calculates the CREATE2 address for a pair without making any external calls | LineComment | v0.7.6+commit.7338295f | None | ipfs://3b908ced1da876930f2e9db473d5baf57d758391eb0860135a5ef083c92f0e26 | {
"func_code_index": [
602,
1085
]
} | 59,532 | ||
DSDRouterV1 | DSDRouterV1.sol | 0xd2150f143939d233924e48b8c9516d9fd7841d27 | Solidity | UniswapV2Library | library UniswapV2Library {
using SafeMath for uint;
// returns sorted token addresses, used to handle return values from pairs sorted in this order
function sortTokens(address tokenA, address tokenB) internal pure returns (address token0, address token1) {
require(tokenA != tokenB, 'UniswapV2L... | getReserves | function getReserves(address factory, address tokenA, address tokenB) internal view returns (uint reserveA, uint reserveB) {
(address token0,) = sortTokens(tokenA, tokenB);
(uint reserve0, uint reserve1,) = IUniswapV2Pair(pairFor(factory, tokenA, tokenB)).getReserves();
(reserveA, reserveB) = tokenA == t... | // fetches and sorts the reserves for a pair | LineComment | v0.7.6+commit.7338295f | None | ipfs://3b908ced1da876930f2e9db473d5baf57d758391eb0860135a5ef083c92f0e26 | {
"func_code_index": [
1138,
1534
]
} | 59,533 | ||
DSDRouterV1 | DSDRouterV1.sol | 0xd2150f143939d233924e48b8c9516d9fd7841d27 | Solidity | UniswapV2Library | library UniswapV2Library {
using SafeMath for uint;
// returns sorted token addresses, used to handle return values from pairs sorted in this order
function sortTokens(address tokenA, address tokenB) internal pure returns (address token0, address token1) {
require(tokenA != tokenB, 'UniswapV2L... | quote | function quote(uint amountA, uint reserveA, uint reserveB) internal pure returns (uint amountB) {
require(amountA > 0, 'UniswapV2Library: INSUFFICIENT_AMOUNT');
require(reserveA > 0 && reserveB > 0, 'UniswapV2Library: INSUFFICIENT_LIQUIDITY');
amountB = amountA.mul(reserveB) / reserveA;
}
| // given some amount of an asset and pair reserves, returns an equivalent amount of the other asset | LineComment | v0.7.6+commit.7338295f | None | ipfs://3b908ced1da876930f2e9db473d5baf57d758391eb0860135a5ef083c92f0e26 | {
"func_code_index": [
1642,
1968
]
} | 59,534 | ||
DSDRouterV1 | DSDRouterV1.sol | 0xd2150f143939d233924e48b8c9516d9fd7841d27 | Solidity | UniswapV2Library | library UniswapV2Library {
using SafeMath for uint;
// returns sorted token addresses, used to handle return values from pairs sorted in this order
function sortTokens(address tokenA, address tokenB) internal pure returns (address token0, address token1) {
require(tokenA != tokenB, 'UniswapV2L... | getAmountOut | function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) internal pure returns (uint amountOut) {
require(amountIn > 0, 'UniswapV2Library: INSUFFICIENT_INPUT_AMOUNT');
require(reserveIn > 0 && reserveOut > 0, 'UniswapV2Library: INSUFFICIENT_LIQUIDITY');
uint amountInWithFee = amountIn.mul(99... | // given an input amount of an asset and pair reserves, returns the maximum output amount of the other asset | LineComment | v0.7.6+commit.7338295f | None | ipfs://3b908ced1da876930f2e9db473d5baf57d758391eb0860135a5ef083c92f0e26 | {
"func_code_index": [
2085,
2607
]
} | 59,535 | ||
DSDRouterV1 | DSDRouterV1.sol | 0xd2150f143939d233924e48b8c9516d9fd7841d27 | Solidity | UniswapV2Library | library UniswapV2Library {
using SafeMath for uint;
// returns sorted token addresses, used to handle return values from pairs sorted in this order
function sortTokens(address tokenA, address tokenB) internal pure returns (address token0, address token1) {
require(tokenA != tokenB, 'UniswapV2L... | getAmountIn | function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) internal pure returns (uint amountIn) {
require(amountOut > 0, 'UniswapV2Library: INSUFFICIENT_OUTPUT_AMOUNT');
require(reserveIn > 0 && reserveOut > 0, 'UniswapV2Library: INSUFFICIENT_LIQUIDITY');
uint numerator = reserveIn.mul(amount... | // given an output amount of an asset and pair reserves, returns a required input amount of the other asset | LineComment | v0.7.6+commit.7338295f | None | ipfs://3b908ced1da876930f2e9db473d5baf57d758391eb0860135a5ef083c92f0e26 | {
"func_code_index": [
2723,
3200
]
} | 59,536 | ||
DSDRouterV1 | DSDRouterV1.sol | 0xd2150f143939d233924e48b8c9516d9fd7841d27 | Solidity | UniswapV2Library | library UniswapV2Library {
using SafeMath for uint;
// returns sorted token addresses, used to handle return values from pairs sorted in this order
function sortTokens(address tokenA, address tokenB) internal pure returns (address token0, address token1) {
require(tokenA != tokenB, 'UniswapV2L... | getAmountsOut | function getAmountsOut(address factory, uint amountIn, address[] memory path) internal view returns (uint[] memory amounts) {
require(path.length >= 2, 'UniswapV2Library: INVALID_PATH');
amounts = new uint[](path.length);
amounts[0] = amountIn;
for (uint i; i < path.length - 1; i++) {
(uint... | // performs chained getAmountOut calculations on any number of pairs | LineComment | v0.7.6+commit.7338295f | None | ipfs://3b908ced1da876930f2e9db473d5baf57d758391eb0860135a5ef083c92f0e26 | {
"func_code_index": [
3277,
3793
]
} | 59,537 | ||
DSDRouterV1 | DSDRouterV1.sol | 0xd2150f143939d233924e48b8c9516d9fd7841d27 | Solidity | UniswapV2Library | library UniswapV2Library {
using SafeMath for uint;
// returns sorted token addresses, used to handle return values from pairs sorted in this order
function sortTokens(address tokenA, address tokenB) internal pure returns (address token0, address token1) {
require(tokenA != tokenB, 'UniswapV2L... | getAmountsIn | function getAmountsIn(address factory, uint amountOut, address[] memory path) internal view returns (uint[] memory amounts) {
require(path.length >= 2, 'UniswapV2Library: INVALID_PATH');
amounts = new uint[](path.length);
amounts[amounts.length - 1] = amountOut;
for (uint i = path.length - 1; i > 0;... | // performs chained getAmountIn calculations on any number of pairs | LineComment | v0.7.6+commit.7338295f | None | ipfs://3b908ced1da876930f2e9db473d5baf57d758391eb0860135a5ef083c92f0e26 | {
"func_code_index": [
3869,
4406
]
} | 59,538 | ||
UniswapV3Pool | contracts/libraries/Position.sol | 0x5d752f322befb038991579972e912b02f61a3dda | Solidity | Position | library Position {
// info stored for each user's position
struct Info {
// the amount of liquidity owned by this position
uint128 liquidity;
// fee growth per unit of liquidity as of the last update to liquidity or fees owed
uint256 feeGrowthInside0LastX128;
uint256 feeG... | /// @title Position
/// @notice Positions represent an owner address' liquidity between a lower and upper tick boundary
/// @dev Positions store additional state for tracking fees owed to the position | NatSpecSingleLine | get | function get(
mapping(bytes32 => Info) storage self,
address owner,
int24 tickLower,
int24 tickUpper
) internal view returns (Position.Info storage position) {
position = self[keccak256(abi.encodePacked(owner, tickLower, tickUpper))];
}
| /// @notice Returns the Info struct of a position, given an owner and position boundaries
/// @param self The mapping containing all user positions
/// @param owner The address of the position owner
/// @param tickLower The lower tick boundary of the position
/// @param tickUpper The upper tick boundary of the position... | NatSpecSingleLine | v0.7.6+commit.7338295f | {
"func_code_index": [
892,
1180
]
} | 59,539 | ||
UniswapV3Pool | contracts/libraries/Position.sol | 0x5d752f322befb038991579972e912b02f61a3dda | Solidity | Position | library Position {
// info stored for each user's position
struct Info {
// the amount of liquidity owned by this position
uint128 liquidity;
// fee growth per unit of liquidity as of the last update to liquidity or fees owed
uint256 feeGrowthInside0LastX128;
uint256 feeG... | /// @title Position
/// @notice Positions represent an owner address' liquidity between a lower and upper tick boundary
/// @dev Positions store additional state for tracking fees owed to the position | NatSpecSingleLine | update | function update(
Info storage self,
int128 liquidityDelta,
uint256 feeGrowthInside0X128,
uint256 feeGrowthInside1X128
) internal {
Info memory _self = self;
uint128 liquidityNext;
if (liquidityDelta == 0) {
require(_self.liquidity > 0, 'NP'); // disallow pokes for 0 liquidity positi... | /// @notice Credits accumulated fees to a user's position
/// @param self The individual position to update
/// @param liquidityDelta The change in pool liquidity as a result of the position update
/// @param feeGrowthInside0X128 The all-time fee growth in token0, per unit of liquidity, inside the position's tick bound... | NatSpecSingleLine | v0.7.6+commit.7338295f | {
"func_code_index": [
1656,
3222
]
} | 59,540 | ||
POT | POT.sol | 0x6a01ee672da11086e8377d9e001efc7f61060703 | Solidity | Ownable | contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the
sender
* account.
*/
constructor() publ... | /**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization
control
* functions, this simplifies the implementation of "user permissions".
*/ | NatSpecMultiLine | transferOwnership | function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
| /**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/ | NatSpecMultiLine | v0.4.23+commit.124ca40d | None | bzzr://653cd540cc33493cd2b298b682a672508ef9408c5ad761b2f0a193064e73fafe | {
"func_code_index": [
633,
798
]
} | 59,541 |
POT | POT.sol | 0x6a01ee672da11086e8377d9e001efc7f61060703 | Solidity | Ownable | contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the
sender
* account.
*/
constructor() publ... | /**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization
control
* functions, this simplifies the implementation of "user permissions".
*/ | NatSpecMultiLine | renounceOwnership | function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
| /**
* @dev Allows the current owner to relinquish control of the contract.
*/ | NatSpecMultiLine | v0.4.23+commit.124ca40d | None | bzzr://653cd540cc33493cd2b298b682a672508ef9408c5ad761b2f0a193064e73fafe | {
"func_code_index": [
880,
985
]
} | 59,542 |
POT | POT.sol | 0x6a01ee672da11086e8377d9e001efc7f61060703 | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uin... | /**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/ | NatSpecMultiLine | mul | function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
| /**
* @dev Multiplies two numbers, throws on overflow.
*/ | NatSpecMultiLine | v0.4.23+commit.124ca40d | None | bzzr://653cd540cc33493cd2b298b682a672508ef9408c5ad761b2f0a193064e73fafe | {
"func_code_index": [
81,
228
]
} | 59,543 |
POT | POT.sol | 0x6a01ee672da11086e8377d9e001efc7f61060703 | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uin... | /**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/ | NatSpecMultiLine | div | function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
| /**
* @dev Integer division of two numbers, truncating the quotient.
*/ | NatSpecMultiLine | v0.4.23+commit.124ca40d | None | bzzr://653cd540cc33493cd2b298b682a672508ef9408c5ad761b2f0a193064e73fafe | {
"func_code_index": [
304,
564
]
} | 59,544 |
POT | POT.sol | 0x6a01ee672da11086e8377d9e001efc7f61060703 | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uin... | /**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/ | NatSpecMultiLine | sub | function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
| /**
* @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than
minuend).
*/ | NatSpecMultiLine | v0.4.23+commit.124ca40d | None | bzzr://653cd540cc33493cd2b298b682a672508ef9408c5ad761b2f0a193064e73fafe | {
"func_code_index": [
671,
775
]
} | 59,545 |
POT | POT.sol | 0x6a01ee672da11086e8377d9e001efc7f61060703 | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uin... | /**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/ | NatSpecMultiLine | add | function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
| /**
* @dev Adds two numbers, throws on overflow.
*/ | NatSpecMultiLine | v0.4.23+commit.124ca40d | None | bzzr://653cd540cc33493cd2b298b682a672508ef9408c5ad761b2f0a193064e73fafe | {
"func_code_index": [
831,
945
]
} | 59,546 |
POT | POT.sol | 0x6a01ee672da11086e8377d9e001efc7f61060703 | Solidity | BasicToken | contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
/**
* @dev total number of tokens in existence
*/
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
/**
* @dev transfer token for a specified address
* @par... | totalSupply | function totalSupply() public view returns (uint256) {
return totalSupply_;
}
| /**
* @dev total number of tokens in existence
*/ | NatSpecMultiLine | v0.4.23+commit.124ca40d | None | bzzr://653cd540cc33493cd2b298b682a672508ef9408c5ad761b2f0a193064e73fafe | {
"func_code_index": [
181,
261
]
} | 59,547 | ||
POT | POT.sol | 0x6a01ee672da11086e8377d9e001efc7f61060703 | Solidity | BasicToken | contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
/**
* @dev total number of tokens in existence
*/
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
/**
* @dev transfer token for a specified address
* @par... | transfer | function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
| /**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/ | NatSpecMultiLine | v0.4.23+commit.124ca40d | None | bzzr://653cd540cc33493cd2b298b682a672508ef9408c5ad761b2f0a193064e73fafe | {
"func_code_index": [
407,
709
]
} | 59,548 | ||
POT | POT.sol | 0x6a01ee672da11086e8377d9e001efc7f61060703 | Solidity | BasicToken | contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
/**
* @dev total number of tokens in existence
*/
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
/**
* @dev transfer token for a specified address
* @par... | balanceOf | function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
| /**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/ | NatSpecMultiLine | v0.4.23+commit.124ca40d | None | bzzr://653cd540cc33493cd2b298b682a672508ef9408c5ad761b2f0a193064e73fafe | {
"func_code_index": [
903,
999
]
} | 59,549 | ||
POT | POT.sol | 0x6a01ee672da11086e8377d9e001efc7f61060703 | Solidity | StandardToken | contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _va... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood:
https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | transferFrom | function transferFrom(address _from, address _to, uint256 _value) public returns
(bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sen... | /**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/ | NatSpecMultiLine | v0.4.23+commit.124ca40d | None | bzzr://653cd540cc33493cd2b298b682a672508ef9408c5ad761b2f0a193064e73fafe | {
"func_code_index": [
376,
796
]
} | 59,550 |
POT | POT.sol | 0x6a01ee672da11086e8377d9e001efc7f61060703 | Solidity | StandardToken | contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _va... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood:
https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | approve | function approve(address _spender, uint256 _value) public returns (bool) {
require((_value == 0 ) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
| /**
* @dev Approve the passed address to spend the specified amount of tokens on behalf
of msg.sender.
*
* Beware that changing an allowance with this method brings the risk that someone
may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution
to mitigate thi... | NatSpecMultiLine | v0.4.23+commit.124ca40d | None | bzzr://653cd540cc33493cd2b298b682a672508ef9408c5ad761b2f0a193064e73fafe | {
"func_code_index": [
1401,
1646
]
} | 59,551 |
POT | POT.sol | 0x6a01ee672da11086e8377d9e001efc7f61060703 | Solidity | StandardToken | contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _va... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood:
https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | allowance | function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
| /**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the
spender.
*/ | NatSpecMultiLine | v0.4.23+commit.124ca40d | None | bzzr://653cd540cc33493cd2b298b682a672508ef9408c5ad761b2f0a193064e73fafe | {
"func_code_index": [
1952,
2075
]
} | 59,552 |
POT | POT.sol | 0x6a01ee672da11086e8377d9e001efc7f61060703 | Solidity | StandardToken | contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _va... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood:
https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | increaseApproval | function increaseApproval(address _spender, uint _addedValue) public returns (bool)
{
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
| /**
* @dev Increase the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spend... | NatSpecMultiLine | v0.4.23+commit.124ca40d | None | bzzr://653cd540cc33493cd2b298b682a672508ef9408c5ad761b2f0a193064e73fafe | {
"func_code_index": [
2510,
2764
]
} | 59,553 |
POT | POT.sol | 0x6a01ee672da11086e8377d9e001efc7f61060703 | Solidity | StandardToken | contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _va... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood:
https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | decreaseApproval | function decreaseApproval(address _spender, uint _subtractedValue) public returns
(bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _sp... | /**
* @dev Decrease the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To decrement
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spend... | NatSpecMultiLine | v0.4.23+commit.124ca40d | None | bzzr://653cd540cc33493cd2b298b682a672508ef9408c5ad761b2f0a193064e73fafe | {
"func_code_index": [
3204,
3580
]
} | 59,554 |
POT | POT.sol | 0x6a01ee672da11086e8377d9e001efc7f61060703 | Solidity | POT | contract POT is StandardToken{
string public constant name = "POT"; // solium-disable-line uppercase
string public constant symbol = "POT"; // solium-disable-line uppercase
uint8 public constant decimals = 18; // solium-disable-line uppercase
uint256 public constant INITIAL_SUPPLY = 3000000000000000000000000000;
u... | function() payable public {
revert();
}
| /**
* The fallback function.
*/ | NatSpecMultiLine | v0.4.23+commit.124ca40d | None | bzzr://653cd540cc33493cd2b298b682a672508ef9408c5ad761b2f0a193064e73fafe | {
"func_code_index": [
671,
713
]
} | 59,555 | |||
BANANAS | BANANAS.sol | 0x939566b6c1fcd3bb1e7740f6399491ce84bdca60 | Solidity | BANANAS | contract BANANAS is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
... | setFeeRate | function setFeeRate(uint256 rate) external {
require(_msgSender() == _FeeAddress);
require(rate < 51, "Rate can't exceed 50%");
_feeRate = rate;
emit FeeRateUpdated(_feeRate);
}
| // fallback in case contract is not releasing tokens fast enough | LineComment | v0.8.4+commit.c7e474f2 | None | ipfs://f0faf4295a80b6dd1d2bfd44fcaf41a37667b31e460653fab39c56a5e0a3859f | {
"func_code_index": [
12659,
12882
]
} | 59,556 | ||
DexBrokerage | DexBrokerage.sol | 0x41a5b8aa081dcd69ace566061d5b6adcb92cae1c | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
/**
* @dev Integer division of two numb... | /**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/ | NatSpecMultiLine | mul | function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
| /**
* @dev Multiplies two numbers, throws on overflow.
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://08d43b7bceff4c3bda6099d6bfe95f6f51fadf64d77309ccc487dda94eb6b121 | {
"func_code_index": [
89,
273
]
} | 59,557 | |
DexBrokerage | DexBrokerage.sol | 0x41a5b8aa081dcd69ace566061d5b6adcb92cae1c | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
/**
* @dev Integer division of two numb... | /**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/ | NatSpecMultiLine | div | function div(uint256 a, uint256 b) internal pure returns (uint256) {
// require(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// require(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
| /**
* @dev Integer division of two numbers, truncating the quotient.
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://08d43b7bceff4c3bda6099d6bfe95f6f51fadf64d77309ccc487dda94eb6b121 | {
"func_code_index": [
357,
632
]
} | 59,558 | |
DexBrokerage | DexBrokerage.sol | 0x41a5b8aa081dcd69ace566061d5b6adcb92cae1c | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
/**
* @dev Integer division of two numb... | /**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/ | NatSpecMultiLine | sub | function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
return a - b;
}
| /**
* @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://08d43b7bceff4c3bda6099d6bfe95f6f51fadf64d77309ccc487dda94eb6b121 | {
"func_code_index": [
746,
863
]
} | 59,559 | |
DexBrokerage | DexBrokerage.sol | 0x41a5b8aa081dcd69ace566061d5b6adcb92cae1c | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
/**
* @dev Integer division of two numb... | /**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/ | NatSpecMultiLine | add | function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
| /**
* @dev Adds two numbers, throws on overflow.
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://08d43b7bceff4c3bda6099d6bfe95f6f51fadf64d77309ccc487dda94eb6b121 | {
"func_code_index": [
927,
1064
]
} | 59,560 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.