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
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
LaunchpadCrowdsaleWithVesting | contracts/NoDeliveryCrowdsale.sol | 0x6557d383b209fc901c57da8dffd15e2689e789ed | Solidity | NoDeliveryCrowdsale | abstract contract NoDeliveryCrowdsale is Crowdsale {
/**
* @dev Overrides delivery by not delivering tokens upon purchase.
*/
function _deliverTokens(address, uint256) internal pure override {
return;
}
} | /**
* @title NoDeliveryCrowdsale
* @author Enjinstarter
* @dev Extension of Crowdsale contract where purchased tokens are not delivered.
*/ | NatSpecMultiLine | _deliverTokens | function _deliverTokens(address, uint256) internal pure override {
return;
}
| /**
* @dev Overrides delivery by not delivering tokens upon purchase.
*/ | NatSpecMultiLine | v0.7.6+commit.7338295f | {
"func_code_index": [
140,
232
]
} | 8,900 |
||
LaunchpadCrowdsaleWithVesting | contracts/LaunchpadWhitelistCrowdsaleHelper.sol | 0x6557d383b209fc901c57da8dffd15e2689e789ed | Solidity | LaunchpadWhitelistCrowdsaleHelper | contract LaunchpadWhitelistCrowdsaleHelper {
using SafeMath for uint256;
address public whitelistContract;
mapping(address => uint256) private _tokensPurchased;
/**
* @param whitelistContract_ whitelist contract address
*/
constructor(address whitelistContract_) {
require(
whitelistContract_ != address(0),
"LaunchpadWhitelistCrowdsaleHelper: zero whitelist address"
);
whitelistContract = whitelistContract_;
}
// TODO: Investigate why modifier and require() don't work consistently for beneficiaryCapNotExceeded()
/*
modifier beneficiaryCapNotExceeded(
address beneficiary,
uint256 tokenAmount
) {
require(
_tokensPurchased[beneficiary].add(tokenAmount) <=
ILaunchpadWhitelist(whitelistContract).whitelistedAmountFor(
beneficiary
),
"LaunchpadWhitelistCrowdsaleHelper: beneficiary cap exceeded"
);
_;
}
*/
modifier isWhitelisted(address account) {
require(
ILaunchpadWhitelist(whitelistContract).isWhitelisted(account),
"LaunchpadWhitelistCrowdsaleHelper: account not whitelisted"
);
_;
}
/**
* @return tokenCap Cap for beneficiary in wei
*/
function getBeneficiaryCap(address beneficiary)
public
view
returns (uint256 tokenCap)
{
require(
beneficiary != address(0),
"LaunchpadWhitelistCrowdsaleHelper: zero beneficiary address"
);
tokenCap = ILaunchpadWhitelist(whitelistContract).whitelistedAmountFor(
beneficiary
);
}
/**
* @dev Returns the amount of tokens purchased so far by specific beneficiary.
* @param beneficiary Address of contributor
* @return tokensPurchased Tokens purchased by beneficiary so far in wei
*/
function getTokensPurchasedBy(address beneficiary)
public
view
returns (uint256 tokensPurchased)
{
require(
beneficiary != address(0),
"LaunchpadWhitelistCrowdsaleHelper: zero beneficiary address"
);
tokensPurchased = _tokensPurchased[beneficiary];
}
function whitelisted(address account)
public
view
returns (bool whitelisted_)
{
require(
account != address(0),
"LaunchpadWhitelistCrowdsaleHelper: zero account"
);
whitelisted_ = ILaunchpadWhitelist(whitelistContract).isWhitelisted(
account
);
}
/**
* @param beneficiary Address of contributor
* @param tokenAmount Amount in wei of token being purchased
*/
function _updateBeneficiaryTokensPurchased(
address beneficiary,
uint256 tokenAmount
) internal {
_tokensPurchased[beneficiary] = _tokensPurchased[beneficiary].add(
tokenAmount
);
}
/**
* @return availableTokens Available number of tokens for purchase by beneficiary
*/
function _getAvailableTokensFor(address beneficiary)
internal
view
returns (uint256 availableTokens)
{
availableTokens = getBeneficiaryCap(beneficiary).sub(
getTokensPurchasedBy(beneficiary)
);
}
} | /**
* @title LaunchpadWhitelistCrowdsaleHelper
* @author Enjinstarter
* @dev Helper for crowdsale in which only whitelisted users can contribute.
*/ | NatSpecMultiLine | getBeneficiaryCap | function getBeneficiaryCap(address beneficiary)
public
view
returns (uint256 tokenCap)
{
require(
beneficiary != address(0),
"LaunchpadWhitelistCrowdsaleHelper: zero beneficiary address"
);
tokenCap = ILaunchpadWhitelist(whitelistContract).whitelistedAmountFor(
beneficiary
);
}
| /**
* @return tokenCap Cap for beneficiary in wei
*/ | NatSpecMultiLine | v0.7.6+commit.7338295f | {
"func_code_index": [
1344,
1727
]
} | 8,901 |
||
LaunchpadCrowdsaleWithVesting | contracts/LaunchpadWhitelistCrowdsaleHelper.sol | 0x6557d383b209fc901c57da8dffd15e2689e789ed | Solidity | LaunchpadWhitelistCrowdsaleHelper | contract LaunchpadWhitelistCrowdsaleHelper {
using SafeMath for uint256;
address public whitelistContract;
mapping(address => uint256) private _tokensPurchased;
/**
* @param whitelistContract_ whitelist contract address
*/
constructor(address whitelistContract_) {
require(
whitelistContract_ != address(0),
"LaunchpadWhitelistCrowdsaleHelper: zero whitelist address"
);
whitelistContract = whitelistContract_;
}
// TODO: Investigate why modifier and require() don't work consistently for beneficiaryCapNotExceeded()
/*
modifier beneficiaryCapNotExceeded(
address beneficiary,
uint256 tokenAmount
) {
require(
_tokensPurchased[beneficiary].add(tokenAmount) <=
ILaunchpadWhitelist(whitelistContract).whitelistedAmountFor(
beneficiary
),
"LaunchpadWhitelistCrowdsaleHelper: beneficiary cap exceeded"
);
_;
}
*/
modifier isWhitelisted(address account) {
require(
ILaunchpadWhitelist(whitelistContract).isWhitelisted(account),
"LaunchpadWhitelistCrowdsaleHelper: account not whitelisted"
);
_;
}
/**
* @return tokenCap Cap for beneficiary in wei
*/
function getBeneficiaryCap(address beneficiary)
public
view
returns (uint256 tokenCap)
{
require(
beneficiary != address(0),
"LaunchpadWhitelistCrowdsaleHelper: zero beneficiary address"
);
tokenCap = ILaunchpadWhitelist(whitelistContract).whitelistedAmountFor(
beneficiary
);
}
/**
* @dev Returns the amount of tokens purchased so far by specific beneficiary.
* @param beneficiary Address of contributor
* @return tokensPurchased Tokens purchased by beneficiary so far in wei
*/
function getTokensPurchasedBy(address beneficiary)
public
view
returns (uint256 tokensPurchased)
{
require(
beneficiary != address(0),
"LaunchpadWhitelistCrowdsaleHelper: zero beneficiary address"
);
tokensPurchased = _tokensPurchased[beneficiary];
}
function whitelisted(address account)
public
view
returns (bool whitelisted_)
{
require(
account != address(0),
"LaunchpadWhitelistCrowdsaleHelper: zero account"
);
whitelisted_ = ILaunchpadWhitelist(whitelistContract).isWhitelisted(
account
);
}
/**
* @param beneficiary Address of contributor
* @param tokenAmount Amount in wei of token being purchased
*/
function _updateBeneficiaryTokensPurchased(
address beneficiary,
uint256 tokenAmount
) internal {
_tokensPurchased[beneficiary] = _tokensPurchased[beneficiary].add(
tokenAmount
);
}
/**
* @return availableTokens Available number of tokens for purchase by beneficiary
*/
function _getAvailableTokensFor(address beneficiary)
internal
view
returns (uint256 availableTokens)
{
availableTokens = getBeneficiaryCap(beneficiary).sub(
getTokensPurchasedBy(beneficiary)
);
}
} | /**
* @title LaunchpadWhitelistCrowdsaleHelper
* @author Enjinstarter
* @dev Helper for crowdsale in which only whitelisted users can contribute.
*/ | NatSpecMultiLine | getTokensPurchasedBy | function getTokensPurchasedBy(address beneficiary)
public
view
returns (uint256 tokensPurchased)
{
require(
beneficiary != address(0),
"LaunchpadWhitelistCrowdsaleHelper: zero beneficiary address"
);
tokensPurchased = _tokensPurchased[beneficiary];
}
| /**
* @dev Returns the amount of tokens purchased so far by specific beneficiary.
* @param beneficiary Address of contributor
* @return tokensPurchased Tokens purchased by beneficiary so far in wei
*/ | NatSpecMultiLine | v0.7.6+commit.7338295f | {
"func_code_index": [
1954,
2289
]
} | 8,902 |
||
LaunchpadCrowdsaleWithVesting | contracts/LaunchpadWhitelistCrowdsaleHelper.sol | 0x6557d383b209fc901c57da8dffd15e2689e789ed | Solidity | LaunchpadWhitelistCrowdsaleHelper | contract LaunchpadWhitelistCrowdsaleHelper {
using SafeMath for uint256;
address public whitelistContract;
mapping(address => uint256) private _tokensPurchased;
/**
* @param whitelistContract_ whitelist contract address
*/
constructor(address whitelistContract_) {
require(
whitelistContract_ != address(0),
"LaunchpadWhitelistCrowdsaleHelper: zero whitelist address"
);
whitelistContract = whitelistContract_;
}
// TODO: Investigate why modifier and require() don't work consistently for beneficiaryCapNotExceeded()
/*
modifier beneficiaryCapNotExceeded(
address beneficiary,
uint256 tokenAmount
) {
require(
_tokensPurchased[beneficiary].add(tokenAmount) <=
ILaunchpadWhitelist(whitelistContract).whitelistedAmountFor(
beneficiary
),
"LaunchpadWhitelistCrowdsaleHelper: beneficiary cap exceeded"
);
_;
}
*/
modifier isWhitelisted(address account) {
require(
ILaunchpadWhitelist(whitelistContract).isWhitelisted(account),
"LaunchpadWhitelistCrowdsaleHelper: account not whitelisted"
);
_;
}
/**
* @return tokenCap Cap for beneficiary in wei
*/
function getBeneficiaryCap(address beneficiary)
public
view
returns (uint256 tokenCap)
{
require(
beneficiary != address(0),
"LaunchpadWhitelistCrowdsaleHelper: zero beneficiary address"
);
tokenCap = ILaunchpadWhitelist(whitelistContract).whitelistedAmountFor(
beneficiary
);
}
/**
* @dev Returns the amount of tokens purchased so far by specific beneficiary.
* @param beneficiary Address of contributor
* @return tokensPurchased Tokens purchased by beneficiary so far in wei
*/
function getTokensPurchasedBy(address beneficiary)
public
view
returns (uint256 tokensPurchased)
{
require(
beneficiary != address(0),
"LaunchpadWhitelistCrowdsaleHelper: zero beneficiary address"
);
tokensPurchased = _tokensPurchased[beneficiary];
}
function whitelisted(address account)
public
view
returns (bool whitelisted_)
{
require(
account != address(0),
"LaunchpadWhitelistCrowdsaleHelper: zero account"
);
whitelisted_ = ILaunchpadWhitelist(whitelistContract).isWhitelisted(
account
);
}
/**
* @param beneficiary Address of contributor
* @param tokenAmount Amount in wei of token being purchased
*/
function _updateBeneficiaryTokensPurchased(
address beneficiary,
uint256 tokenAmount
) internal {
_tokensPurchased[beneficiary] = _tokensPurchased[beneficiary].add(
tokenAmount
);
}
/**
* @return availableTokens Available number of tokens for purchase by beneficiary
*/
function _getAvailableTokensFor(address beneficiary)
internal
view
returns (uint256 availableTokens)
{
availableTokens = getBeneficiaryCap(beneficiary).sub(
getTokensPurchasedBy(beneficiary)
);
}
} | /**
* @title LaunchpadWhitelistCrowdsaleHelper
* @author Enjinstarter
* @dev Helper for crowdsale in which only whitelisted users can contribute.
*/ | NatSpecMultiLine | _updateBeneficiaryTokensPurchased | function _updateBeneficiaryTokensPurchased(
address beneficiary,
uint256 tokenAmount
) internal {
_tokensPurchased[beneficiary] = _tokensPurchased[beneficiary].add(
tokenAmount
);
}
| /**
* @param beneficiary Address of contributor
* @param tokenAmount Amount in wei of token being purchased
*/ | NatSpecMultiLine | v0.7.6+commit.7338295f | {
"func_code_index": [
2774,
3011
]
} | 8,903 |
||
LaunchpadCrowdsaleWithVesting | contracts/LaunchpadWhitelistCrowdsaleHelper.sol | 0x6557d383b209fc901c57da8dffd15e2689e789ed | Solidity | LaunchpadWhitelistCrowdsaleHelper | contract LaunchpadWhitelistCrowdsaleHelper {
using SafeMath for uint256;
address public whitelistContract;
mapping(address => uint256) private _tokensPurchased;
/**
* @param whitelistContract_ whitelist contract address
*/
constructor(address whitelistContract_) {
require(
whitelistContract_ != address(0),
"LaunchpadWhitelistCrowdsaleHelper: zero whitelist address"
);
whitelistContract = whitelistContract_;
}
// TODO: Investigate why modifier and require() don't work consistently for beneficiaryCapNotExceeded()
/*
modifier beneficiaryCapNotExceeded(
address beneficiary,
uint256 tokenAmount
) {
require(
_tokensPurchased[beneficiary].add(tokenAmount) <=
ILaunchpadWhitelist(whitelistContract).whitelistedAmountFor(
beneficiary
),
"LaunchpadWhitelistCrowdsaleHelper: beneficiary cap exceeded"
);
_;
}
*/
modifier isWhitelisted(address account) {
require(
ILaunchpadWhitelist(whitelistContract).isWhitelisted(account),
"LaunchpadWhitelistCrowdsaleHelper: account not whitelisted"
);
_;
}
/**
* @return tokenCap Cap for beneficiary in wei
*/
function getBeneficiaryCap(address beneficiary)
public
view
returns (uint256 tokenCap)
{
require(
beneficiary != address(0),
"LaunchpadWhitelistCrowdsaleHelper: zero beneficiary address"
);
tokenCap = ILaunchpadWhitelist(whitelistContract).whitelistedAmountFor(
beneficiary
);
}
/**
* @dev Returns the amount of tokens purchased so far by specific beneficiary.
* @param beneficiary Address of contributor
* @return tokensPurchased Tokens purchased by beneficiary so far in wei
*/
function getTokensPurchasedBy(address beneficiary)
public
view
returns (uint256 tokensPurchased)
{
require(
beneficiary != address(0),
"LaunchpadWhitelistCrowdsaleHelper: zero beneficiary address"
);
tokensPurchased = _tokensPurchased[beneficiary];
}
function whitelisted(address account)
public
view
returns (bool whitelisted_)
{
require(
account != address(0),
"LaunchpadWhitelistCrowdsaleHelper: zero account"
);
whitelisted_ = ILaunchpadWhitelist(whitelistContract).isWhitelisted(
account
);
}
/**
* @param beneficiary Address of contributor
* @param tokenAmount Amount in wei of token being purchased
*/
function _updateBeneficiaryTokensPurchased(
address beneficiary,
uint256 tokenAmount
) internal {
_tokensPurchased[beneficiary] = _tokensPurchased[beneficiary].add(
tokenAmount
);
}
/**
* @return availableTokens Available number of tokens for purchase by beneficiary
*/
function _getAvailableTokensFor(address beneficiary)
internal
view
returns (uint256 availableTokens)
{
availableTokens = getBeneficiaryCap(beneficiary).sub(
getTokensPurchasedBy(beneficiary)
);
}
} | /**
* @title LaunchpadWhitelistCrowdsaleHelper
* @author Enjinstarter
* @dev Helper for crowdsale in which only whitelisted users can contribute.
*/ | NatSpecMultiLine | _getAvailableTokensFor | function _getAvailableTokensFor(address beneficiary)
internal
view
returns (uint256 availableTokens)
{
availableTokens = getBeneficiaryCap(beneficiary).sub(
getTokensPurchasedBy(beneficiary)
);
}
| /**
* @return availableTokens Available number of tokens for purchase by beneficiary
*/ | NatSpecMultiLine | v0.7.6+commit.7338295f | {
"func_code_index": [
3115,
3374
]
} | 8,904 |
||
LaunchpadCrowdsaleWithVesting | contracts/VestedCrowdsale.sol | 0x6557d383b209fc901c57da8dffd15e2689e789ed | Solidity | VestedCrowdsale | abstract contract VestedCrowdsale is Crowdsale {
address public vestingContract;
constructor(address vestingContract_) {
require(
vestingContract_ != address(0),
"VestedCrowdsale: zero vesting address"
);
vestingContract = vestingContract_;
}
function _startDistribution(uint256 scheduleStartTimestamp) internal {
IVesting(vestingContract).setScheduleStartTimestamp(
scheduleStartTimestamp
);
}
/**
* @dev Overrides delivery by transferring tokens to vesting schedule upon purchase.
* @param beneficiary Token purchaser
* @param tokenAmount Number of tokens to be vested
*/
function _deliverTokens(address beneficiary, uint256 tokenAmount)
internal
override
{
IVesting(vestingContract).addVestingGrant(
beneficiary,
tokenAmount,
false
);
}
} | /**
* @title VestedCrowdsale
* @author Enjinstarter
* @dev Extension of Crowdsale contract where purchased tokens are transferred to a vesting schedule.
*/ | NatSpecMultiLine | _deliverTokens | function _deliverTokens(address beneficiary, uint256 tokenAmount)
internal
override
{
IVesting(vestingContract).addVestingGrant(
beneficiary,
tokenAmount,
false
);
}
| /**
* @dev Overrides delivery by transferring tokens to vesting schedule upon purchase.
* @param beneficiary Token purchaser
* @param tokenAmount Number of tokens to be vested
*/ | NatSpecMultiLine | v0.7.6+commit.7338295f | {
"func_code_index": [
698,
943
]
} | 8,905 |
||
LaunchpadCrowdsaleWithVesting | contracts/TimedCrowdsaleHelper.sol | 0x6557d383b209fc901c57da8dffd15e2689e789ed | Solidity | TimedCrowdsaleHelper | contract TimedCrowdsaleHelper {
using SafeMath for uint256;
struct Timeframe {
uint256 openingTime;
uint256 closingTime;
}
Timeframe private _timeframe;
/**
* Event for crowdsale extending
* @param prevClosingTime old closing time
* @param newClosingTime new closing time
*/
event TimedCrowdsaleExtended(
uint256 prevClosingTime,
uint256 newClosingTime
);
/**
* @dev Reverts if not in crowdsale time range.
*/
modifier onlyWhileOpen() {
require(isOpen(), "TimedCrowdsaleHelper: not open");
_;
}
/**
* @dev Constructor, takes crowdsale opening and closing times.
* @param timeframe Crowdsale opening and closing times
*/
constructor(Timeframe memory timeframe) {
require(
timeframe.openingTime >= block.timestamp,
"TimedCrowdsaleHelper: opening time is before current time"
);
require(
timeframe.closingTime > timeframe.openingTime,
"TimedCrowdsaleHelper: closing time is before opening time"
);
_timeframe.openingTime = timeframe.openingTime;
_timeframe.closingTime = timeframe.closingTime;
}
/**
* @return the crowdsale opening time.
*/
function openingTime() external view returns (uint256) {
return _timeframe.openingTime;
}
/**
* @return the crowdsale closing time.
*/
function closingTime() public view returns (uint256) {
return _timeframe.closingTime;
}
/**
* @return true if the crowdsale is open, false otherwise.
*/
function isOpen() public view returns (bool) {
return
block.timestamp >= _timeframe.openingTime &&
block.timestamp <= _timeframe.closingTime;
}
/**
* @dev Checks whether the period in which the crowdsale is open has already elapsed.
* @return Whether crowdsale period has elapsed
*/
function hasClosed() public view returns (bool) {
return block.timestamp > _timeframe.closingTime;
}
/**
* @dev Extend crowdsale.
* @param newClosingTime Crowdsale closing time
*/
// https://github.com/crytic/slither/wiki/Detector-Documentation#dead-code
// slither-disable-next-line dead-code
function _extendTime(uint256 newClosingTime) internal {
require(!hasClosed(), "TimedCrowdsaleHelper: already closed");
uint256 oldClosingTime = _timeframe.closingTime;
require(
newClosingTime > oldClosingTime,
"TimedCrowdsaleHelper: before current closing time"
);
_timeframe.closingTime = newClosingTime;
emit TimedCrowdsaleExtended(oldClosingTime, newClosingTime);
}
} | /**
* @title TimedCrowdsaleHelper
* @author Enjinstarter
* @dev Helper for crowdsale accepting contributions only within a time frame.
*/ | NatSpecMultiLine | openingTime | function openingTime() external view returns (uint256) {
return _timeframe.openingTime;
}
| /**
* @return the crowdsale opening time.
*/ | NatSpecMultiLine | v0.7.6+commit.7338295f | {
"func_code_index": [
1300,
1405
]
} | 8,906 |
||
LaunchpadCrowdsaleWithVesting | contracts/TimedCrowdsaleHelper.sol | 0x6557d383b209fc901c57da8dffd15e2689e789ed | Solidity | TimedCrowdsaleHelper | contract TimedCrowdsaleHelper {
using SafeMath for uint256;
struct Timeframe {
uint256 openingTime;
uint256 closingTime;
}
Timeframe private _timeframe;
/**
* Event for crowdsale extending
* @param prevClosingTime old closing time
* @param newClosingTime new closing time
*/
event TimedCrowdsaleExtended(
uint256 prevClosingTime,
uint256 newClosingTime
);
/**
* @dev Reverts if not in crowdsale time range.
*/
modifier onlyWhileOpen() {
require(isOpen(), "TimedCrowdsaleHelper: not open");
_;
}
/**
* @dev Constructor, takes crowdsale opening and closing times.
* @param timeframe Crowdsale opening and closing times
*/
constructor(Timeframe memory timeframe) {
require(
timeframe.openingTime >= block.timestamp,
"TimedCrowdsaleHelper: opening time is before current time"
);
require(
timeframe.closingTime > timeframe.openingTime,
"TimedCrowdsaleHelper: closing time is before opening time"
);
_timeframe.openingTime = timeframe.openingTime;
_timeframe.closingTime = timeframe.closingTime;
}
/**
* @return the crowdsale opening time.
*/
function openingTime() external view returns (uint256) {
return _timeframe.openingTime;
}
/**
* @return the crowdsale closing time.
*/
function closingTime() public view returns (uint256) {
return _timeframe.closingTime;
}
/**
* @return true if the crowdsale is open, false otherwise.
*/
function isOpen() public view returns (bool) {
return
block.timestamp >= _timeframe.openingTime &&
block.timestamp <= _timeframe.closingTime;
}
/**
* @dev Checks whether the period in which the crowdsale is open has already elapsed.
* @return Whether crowdsale period has elapsed
*/
function hasClosed() public view returns (bool) {
return block.timestamp > _timeframe.closingTime;
}
/**
* @dev Extend crowdsale.
* @param newClosingTime Crowdsale closing time
*/
// https://github.com/crytic/slither/wiki/Detector-Documentation#dead-code
// slither-disable-next-line dead-code
function _extendTime(uint256 newClosingTime) internal {
require(!hasClosed(), "TimedCrowdsaleHelper: already closed");
uint256 oldClosingTime = _timeframe.closingTime;
require(
newClosingTime > oldClosingTime,
"TimedCrowdsaleHelper: before current closing time"
);
_timeframe.closingTime = newClosingTime;
emit TimedCrowdsaleExtended(oldClosingTime, newClosingTime);
}
} | /**
* @title TimedCrowdsaleHelper
* @author Enjinstarter
* @dev Helper for crowdsale accepting contributions only within a time frame.
*/ | NatSpecMultiLine | closingTime | function closingTime() public view returns (uint256) {
return _timeframe.closingTime;
}
| /**
* @return the crowdsale closing time.
*/ | NatSpecMultiLine | v0.7.6+commit.7338295f | {
"func_code_index": [
1466,
1569
]
} | 8,907 |
||
LaunchpadCrowdsaleWithVesting | contracts/TimedCrowdsaleHelper.sol | 0x6557d383b209fc901c57da8dffd15e2689e789ed | Solidity | TimedCrowdsaleHelper | contract TimedCrowdsaleHelper {
using SafeMath for uint256;
struct Timeframe {
uint256 openingTime;
uint256 closingTime;
}
Timeframe private _timeframe;
/**
* Event for crowdsale extending
* @param prevClosingTime old closing time
* @param newClosingTime new closing time
*/
event TimedCrowdsaleExtended(
uint256 prevClosingTime,
uint256 newClosingTime
);
/**
* @dev Reverts if not in crowdsale time range.
*/
modifier onlyWhileOpen() {
require(isOpen(), "TimedCrowdsaleHelper: not open");
_;
}
/**
* @dev Constructor, takes crowdsale opening and closing times.
* @param timeframe Crowdsale opening and closing times
*/
constructor(Timeframe memory timeframe) {
require(
timeframe.openingTime >= block.timestamp,
"TimedCrowdsaleHelper: opening time is before current time"
);
require(
timeframe.closingTime > timeframe.openingTime,
"TimedCrowdsaleHelper: closing time is before opening time"
);
_timeframe.openingTime = timeframe.openingTime;
_timeframe.closingTime = timeframe.closingTime;
}
/**
* @return the crowdsale opening time.
*/
function openingTime() external view returns (uint256) {
return _timeframe.openingTime;
}
/**
* @return the crowdsale closing time.
*/
function closingTime() public view returns (uint256) {
return _timeframe.closingTime;
}
/**
* @return true if the crowdsale is open, false otherwise.
*/
function isOpen() public view returns (bool) {
return
block.timestamp >= _timeframe.openingTime &&
block.timestamp <= _timeframe.closingTime;
}
/**
* @dev Checks whether the period in which the crowdsale is open has already elapsed.
* @return Whether crowdsale period has elapsed
*/
function hasClosed() public view returns (bool) {
return block.timestamp > _timeframe.closingTime;
}
/**
* @dev Extend crowdsale.
* @param newClosingTime Crowdsale closing time
*/
// https://github.com/crytic/slither/wiki/Detector-Documentation#dead-code
// slither-disable-next-line dead-code
function _extendTime(uint256 newClosingTime) internal {
require(!hasClosed(), "TimedCrowdsaleHelper: already closed");
uint256 oldClosingTime = _timeframe.closingTime;
require(
newClosingTime > oldClosingTime,
"TimedCrowdsaleHelper: before current closing time"
);
_timeframe.closingTime = newClosingTime;
emit TimedCrowdsaleExtended(oldClosingTime, newClosingTime);
}
} | /**
* @title TimedCrowdsaleHelper
* @author Enjinstarter
* @dev Helper for crowdsale accepting contributions only within a time frame.
*/ | NatSpecMultiLine | isOpen | function isOpen() public view returns (bool) {
return
block.timestamp >= _timeframe.openingTime &&
block.timestamp <= _timeframe.closingTime;
}
| /**
* @return true if the crowdsale is open, false otherwise.
*/ | NatSpecMultiLine | v0.7.6+commit.7338295f | {
"func_code_index": [
1650,
1833
]
} | 8,908 |
||
LaunchpadCrowdsaleWithVesting | contracts/TimedCrowdsaleHelper.sol | 0x6557d383b209fc901c57da8dffd15e2689e789ed | Solidity | TimedCrowdsaleHelper | contract TimedCrowdsaleHelper {
using SafeMath for uint256;
struct Timeframe {
uint256 openingTime;
uint256 closingTime;
}
Timeframe private _timeframe;
/**
* Event for crowdsale extending
* @param prevClosingTime old closing time
* @param newClosingTime new closing time
*/
event TimedCrowdsaleExtended(
uint256 prevClosingTime,
uint256 newClosingTime
);
/**
* @dev Reverts if not in crowdsale time range.
*/
modifier onlyWhileOpen() {
require(isOpen(), "TimedCrowdsaleHelper: not open");
_;
}
/**
* @dev Constructor, takes crowdsale opening and closing times.
* @param timeframe Crowdsale opening and closing times
*/
constructor(Timeframe memory timeframe) {
require(
timeframe.openingTime >= block.timestamp,
"TimedCrowdsaleHelper: opening time is before current time"
);
require(
timeframe.closingTime > timeframe.openingTime,
"TimedCrowdsaleHelper: closing time is before opening time"
);
_timeframe.openingTime = timeframe.openingTime;
_timeframe.closingTime = timeframe.closingTime;
}
/**
* @return the crowdsale opening time.
*/
function openingTime() external view returns (uint256) {
return _timeframe.openingTime;
}
/**
* @return the crowdsale closing time.
*/
function closingTime() public view returns (uint256) {
return _timeframe.closingTime;
}
/**
* @return true if the crowdsale is open, false otherwise.
*/
function isOpen() public view returns (bool) {
return
block.timestamp >= _timeframe.openingTime &&
block.timestamp <= _timeframe.closingTime;
}
/**
* @dev Checks whether the period in which the crowdsale is open has already elapsed.
* @return Whether crowdsale period has elapsed
*/
function hasClosed() public view returns (bool) {
return block.timestamp > _timeframe.closingTime;
}
/**
* @dev Extend crowdsale.
* @param newClosingTime Crowdsale closing time
*/
// https://github.com/crytic/slither/wiki/Detector-Documentation#dead-code
// slither-disable-next-line dead-code
function _extendTime(uint256 newClosingTime) internal {
require(!hasClosed(), "TimedCrowdsaleHelper: already closed");
uint256 oldClosingTime = _timeframe.closingTime;
require(
newClosingTime > oldClosingTime,
"TimedCrowdsaleHelper: before current closing time"
);
_timeframe.closingTime = newClosingTime;
emit TimedCrowdsaleExtended(oldClosingTime, newClosingTime);
}
} | /**
* @title TimedCrowdsaleHelper
* @author Enjinstarter
* @dev Helper for crowdsale accepting contributions only within a time frame.
*/ | NatSpecMultiLine | hasClosed | function hasClosed() public view returns (bool) {
return block.timestamp > _timeframe.closingTime;
}
| /**
* @dev Checks whether the period in which the crowdsale is open has already elapsed.
* @return Whether crowdsale period has elapsed
*/ | NatSpecMultiLine | v0.7.6+commit.7338295f | {
"func_code_index": [
1993,
2109
]
} | 8,909 |
||
LaunchpadCrowdsaleWithVesting | contracts/TimedCrowdsaleHelper.sol | 0x6557d383b209fc901c57da8dffd15e2689e789ed | Solidity | TimedCrowdsaleHelper | contract TimedCrowdsaleHelper {
using SafeMath for uint256;
struct Timeframe {
uint256 openingTime;
uint256 closingTime;
}
Timeframe private _timeframe;
/**
* Event for crowdsale extending
* @param prevClosingTime old closing time
* @param newClosingTime new closing time
*/
event TimedCrowdsaleExtended(
uint256 prevClosingTime,
uint256 newClosingTime
);
/**
* @dev Reverts if not in crowdsale time range.
*/
modifier onlyWhileOpen() {
require(isOpen(), "TimedCrowdsaleHelper: not open");
_;
}
/**
* @dev Constructor, takes crowdsale opening and closing times.
* @param timeframe Crowdsale opening and closing times
*/
constructor(Timeframe memory timeframe) {
require(
timeframe.openingTime >= block.timestamp,
"TimedCrowdsaleHelper: opening time is before current time"
);
require(
timeframe.closingTime > timeframe.openingTime,
"TimedCrowdsaleHelper: closing time is before opening time"
);
_timeframe.openingTime = timeframe.openingTime;
_timeframe.closingTime = timeframe.closingTime;
}
/**
* @return the crowdsale opening time.
*/
function openingTime() external view returns (uint256) {
return _timeframe.openingTime;
}
/**
* @return the crowdsale closing time.
*/
function closingTime() public view returns (uint256) {
return _timeframe.closingTime;
}
/**
* @return true if the crowdsale is open, false otherwise.
*/
function isOpen() public view returns (bool) {
return
block.timestamp >= _timeframe.openingTime &&
block.timestamp <= _timeframe.closingTime;
}
/**
* @dev Checks whether the period in which the crowdsale is open has already elapsed.
* @return Whether crowdsale period has elapsed
*/
function hasClosed() public view returns (bool) {
return block.timestamp > _timeframe.closingTime;
}
/**
* @dev Extend crowdsale.
* @param newClosingTime Crowdsale closing time
*/
// https://github.com/crytic/slither/wiki/Detector-Documentation#dead-code
// slither-disable-next-line dead-code
function _extendTime(uint256 newClosingTime) internal {
require(!hasClosed(), "TimedCrowdsaleHelper: already closed");
uint256 oldClosingTime = _timeframe.closingTime;
require(
newClosingTime > oldClosingTime,
"TimedCrowdsaleHelper: before current closing time"
);
_timeframe.closingTime = newClosingTime;
emit TimedCrowdsaleExtended(oldClosingTime, newClosingTime);
}
} | /**
* @title TimedCrowdsaleHelper
* @author Enjinstarter
* @dev Helper for crowdsale accepting contributions only within a time frame.
*/ | NatSpecMultiLine | _extendTime | function _extendTime(uint256 newClosingTime) internal {
require(!hasClosed(), "TimedCrowdsaleHelper: already closed");
uint256 oldClosingTime = _timeframe.closingTime;
require(
newClosingTime > oldClosingTime,
"TimedCrowdsaleHelper: before current closing time"
);
_timeframe.closingTime = newClosingTime;
emit TimedCrowdsaleExtended(oldClosingTime, newClosingTime);
}
| // https://github.com/crytic/slither/wiki/Detector-Documentation#dead-code
// slither-disable-next-line dead-code | LineComment | v0.7.6+commit.7338295f | {
"func_code_index": [
2331,
2781
]
} | 8,910 |
||
LaunchpadCrowdsaleWithVesting | contracts/LaunchpadCrowdsaleWithVesting.sol | 0x6557d383b209fc901c57da8dffd15e2689e789ed | Solidity | LaunchpadCrowdsaleWithVesting | contract LaunchpadCrowdsaleWithVesting is
VestedCrowdsale,
CappedTokenSoldCrowdsaleHelper,
HoldErc20TokenCrowdsaleHelper,
TimedCrowdsaleHelper,
LaunchpadWhitelistCrowdsaleHelper,
Pausable,
ILaunchpadCrowdsaleWithVesting
{
using SafeMath for uint256;
struct LaunchpadCrowdsaleInfo {
uint256 tokenCap;
address vestingContract;
address whitelistContract;
address tokenHold;
uint256 minTokenHoldAmount;
}
address public governanceAccount;
address public crowdsaleAdmin;
// max 1 lot
constructor(
address wallet_,
address tokenSelling_,
LaunchpadCrowdsaleInfo memory crowdsaleInfo,
LotsInfo memory lotsInfo,
Timeframe memory timeframe,
PaymentTokenInfo[] memory paymentTokensInfo
)
Crowdsale(wallet_, tokenSelling_, lotsInfo, paymentTokensInfo)
VestedCrowdsale(crowdsaleInfo.vestingContract)
CappedTokenSoldCrowdsaleHelper(crowdsaleInfo.tokenCap)
HoldErc20TokenCrowdsaleHelper(
crowdsaleInfo.tokenHold,
crowdsaleInfo.minTokenHoldAmount
)
TimedCrowdsaleHelper(timeframe)
LaunchpadWhitelistCrowdsaleHelper(crowdsaleInfo.whitelistContract)
{
governanceAccount = msg.sender;
crowdsaleAdmin = msg.sender;
}
modifier onlyBy(address account) {
require(
msg.sender == account,
"LaunchpadCrowdsaleWithVesting: sender unauthorized"
);
_;
}
/**
* @return availableLots Available number of lots for beneficiary
*/
function getAvailableLotsFor(address beneficiary)
external
view
override
returns (uint256 availableLots)
{
if (!whitelisted(beneficiary)) {
return 0;
}
availableLots = _getAvailableTokensFor(beneficiary).div(
getBeneficiaryCap(beneficiary)
);
}
/**
* @return remainingTokens Remaining number of tokens for crowdsale
*/
function getRemainingTokens()
external
view
override
returns (uint256 remainingTokens)
{
remainingTokens = tokenCap().sub(tokensSold);
}
function pause() external override onlyBy(crowdsaleAdmin) {
_pause();
}
function unpause() external override onlyBy(crowdsaleAdmin) {
_unpause();
}
function extendTime(uint256 newClosingTime)
external
override
onlyBy(crowdsaleAdmin)
{
_extendTime(newClosingTime);
}
function startDistribution(uint256 scheduleStartTimestamp)
external
override
onlyBy(crowdsaleAdmin)
{
require(
scheduleStartTimestamp > closingTime(),
"LaunchpadCrowdsaleWithVesting: must be after closing time"
);
_startDistribution(scheduleStartTimestamp);
}
function setGovernanceAccount(address account)
external
override
onlyBy(governanceAccount)
{
require(
account != address(0),
"LaunchpadCrowdsaleWithVesting: zero account"
);
governanceAccount = account;
}
function setCrowdsaleAdmin(address account)
external
override
onlyBy(governanceAccount)
{
require(
account != address(0),
"LaunchpadCrowdsaleWithVesting: zero account"
);
crowdsaleAdmin = account;
}
/**
* @param beneficiary Address receiving the tokens
* @return lotSize_ lot size of token being sold
*/
function _lotSize(address beneficiary)
internal
view
override
returns (uint256 lotSize_)
{
lotSize_ = getBeneficiaryCap(beneficiary);
}
/**
* @dev Override to extend the way in which payment token is converted to tokens.
* @param lots Number of lots of token being sold
* @param beneficiary Address receiving the tokens
* @return tokenAmount Number of tokens that will be purchased
*/
function _getTokenAmount(uint256 lots, address beneficiary)
internal
view
override
returns (uint256 tokenAmount)
{
tokenAmount = lots.mul(_lotSize(beneficiary));
}
/**
* @param beneficiary Token beneficiary
* @param paymentToken ERC20 payment token address
* @param weiAmount Amount of wei contributed
* @param tokenAmount Number of tokens to be purchased
*/
function _preValidatePurchase(
address beneficiary,
address paymentToken,
uint256 weiAmount,
uint256 tokenAmount
)
internal
view
override
whenNotPaused
onlyWhileOpen
tokenCapNotExceeded(tokensSold, tokenAmount)
holdsSufficientTokens(beneficiary)
isWhitelisted(beneficiary)
{
// TODO: Investigate why modifier and require() don't work consistently for beneficiaryCapNotExceeded()
if (
getTokensPurchasedBy(beneficiary).add(tokenAmount) >
getBeneficiaryCap(beneficiary)
) {
revert("LaunchpadCrowdsaleWithVesting: beneficiary cap exceeded");
}
super._preValidatePurchase(
beneficiary,
paymentToken,
weiAmount,
tokenAmount
);
}
/**
* @dev Extend parent behavior to update purchased amount of tokens by beneficiary.
* @param beneficiary Token purchaser
* @param paymentToken ERC20 payment token address
* @param weiAmount Amount in wei of ERC20 payment token
* @param tokenAmount Number of tokens to be purchased
*/
function _updatePurchasingState(
address beneficiary,
address paymentToken,
uint256 weiAmount,
uint256 tokenAmount
) internal override {
super._updatePurchasingState(
beneficiary,
paymentToken,
weiAmount,
tokenAmount
);
_updateBeneficiaryTokensPurchased(beneficiary, tokenAmount);
}
} | /**
* @title LaunchpadCrowdsaleWithVesting
* @author Enjinstarter
* @dev Launchpad crowdsale where there is no delivery of tokens in each purchase.
*/ | NatSpecMultiLine | getAvailableLotsFor | function getAvailableLotsFor(address beneficiary)
external
view
override
returns (uint256 availableLots)
{
if (!whitelisted(beneficiary)) {
return 0;
}
availableLots = _getAvailableTokensFor(beneficiary).div(
getBeneficiaryCap(beneficiary)
);
}
| /**
* @return availableLots Available number of lots for beneficiary
*/ | NatSpecMultiLine | v0.7.6+commit.7338295f | {
"func_code_index": [
1624,
1969
]
} | 8,911 |
||
LaunchpadCrowdsaleWithVesting | contracts/LaunchpadCrowdsaleWithVesting.sol | 0x6557d383b209fc901c57da8dffd15e2689e789ed | Solidity | LaunchpadCrowdsaleWithVesting | contract LaunchpadCrowdsaleWithVesting is
VestedCrowdsale,
CappedTokenSoldCrowdsaleHelper,
HoldErc20TokenCrowdsaleHelper,
TimedCrowdsaleHelper,
LaunchpadWhitelistCrowdsaleHelper,
Pausable,
ILaunchpadCrowdsaleWithVesting
{
using SafeMath for uint256;
struct LaunchpadCrowdsaleInfo {
uint256 tokenCap;
address vestingContract;
address whitelistContract;
address tokenHold;
uint256 minTokenHoldAmount;
}
address public governanceAccount;
address public crowdsaleAdmin;
// max 1 lot
constructor(
address wallet_,
address tokenSelling_,
LaunchpadCrowdsaleInfo memory crowdsaleInfo,
LotsInfo memory lotsInfo,
Timeframe memory timeframe,
PaymentTokenInfo[] memory paymentTokensInfo
)
Crowdsale(wallet_, tokenSelling_, lotsInfo, paymentTokensInfo)
VestedCrowdsale(crowdsaleInfo.vestingContract)
CappedTokenSoldCrowdsaleHelper(crowdsaleInfo.tokenCap)
HoldErc20TokenCrowdsaleHelper(
crowdsaleInfo.tokenHold,
crowdsaleInfo.minTokenHoldAmount
)
TimedCrowdsaleHelper(timeframe)
LaunchpadWhitelistCrowdsaleHelper(crowdsaleInfo.whitelistContract)
{
governanceAccount = msg.sender;
crowdsaleAdmin = msg.sender;
}
modifier onlyBy(address account) {
require(
msg.sender == account,
"LaunchpadCrowdsaleWithVesting: sender unauthorized"
);
_;
}
/**
* @return availableLots Available number of lots for beneficiary
*/
function getAvailableLotsFor(address beneficiary)
external
view
override
returns (uint256 availableLots)
{
if (!whitelisted(beneficiary)) {
return 0;
}
availableLots = _getAvailableTokensFor(beneficiary).div(
getBeneficiaryCap(beneficiary)
);
}
/**
* @return remainingTokens Remaining number of tokens for crowdsale
*/
function getRemainingTokens()
external
view
override
returns (uint256 remainingTokens)
{
remainingTokens = tokenCap().sub(tokensSold);
}
function pause() external override onlyBy(crowdsaleAdmin) {
_pause();
}
function unpause() external override onlyBy(crowdsaleAdmin) {
_unpause();
}
function extendTime(uint256 newClosingTime)
external
override
onlyBy(crowdsaleAdmin)
{
_extendTime(newClosingTime);
}
function startDistribution(uint256 scheduleStartTimestamp)
external
override
onlyBy(crowdsaleAdmin)
{
require(
scheduleStartTimestamp > closingTime(),
"LaunchpadCrowdsaleWithVesting: must be after closing time"
);
_startDistribution(scheduleStartTimestamp);
}
function setGovernanceAccount(address account)
external
override
onlyBy(governanceAccount)
{
require(
account != address(0),
"LaunchpadCrowdsaleWithVesting: zero account"
);
governanceAccount = account;
}
function setCrowdsaleAdmin(address account)
external
override
onlyBy(governanceAccount)
{
require(
account != address(0),
"LaunchpadCrowdsaleWithVesting: zero account"
);
crowdsaleAdmin = account;
}
/**
* @param beneficiary Address receiving the tokens
* @return lotSize_ lot size of token being sold
*/
function _lotSize(address beneficiary)
internal
view
override
returns (uint256 lotSize_)
{
lotSize_ = getBeneficiaryCap(beneficiary);
}
/**
* @dev Override to extend the way in which payment token is converted to tokens.
* @param lots Number of lots of token being sold
* @param beneficiary Address receiving the tokens
* @return tokenAmount Number of tokens that will be purchased
*/
function _getTokenAmount(uint256 lots, address beneficiary)
internal
view
override
returns (uint256 tokenAmount)
{
tokenAmount = lots.mul(_lotSize(beneficiary));
}
/**
* @param beneficiary Token beneficiary
* @param paymentToken ERC20 payment token address
* @param weiAmount Amount of wei contributed
* @param tokenAmount Number of tokens to be purchased
*/
function _preValidatePurchase(
address beneficiary,
address paymentToken,
uint256 weiAmount,
uint256 tokenAmount
)
internal
view
override
whenNotPaused
onlyWhileOpen
tokenCapNotExceeded(tokensSold, tokenAmount)
holdsSufficientTokens(beneficiary)
isWhitelisted(beneficiary)
{
// TODO: Investigate why modifier and require() don't work consistently for beneficiaryCapNotExceeded()
if (
getTokensPurchasedBy(beneficiary).add(tokenAmount) >
getBeneficiaryCap(beneficiary)
) {
revert("LaunchpadCrowdsaleWithVesting: beneficiary cap exceeded");
}
super._preValidatePurchase(
beneficiary,
paymentToken,
weiAmount,
tokenAmount
);
}
/**
* @dev Extend parent behavior to update purchased amount of tokens by beneficiary.
* @param beneficiary Token purchaser
* @param paymentToken ERC20 payment token address
* @param weiAmount Amount in wei of ERC20 payment token
* @param tokenAmount Number of tokens to be purchased
*/
function _updatePurchasingState(
address beneficiary,
address paymentToken,
uint256 weiAmount,
uint256 tokenAmount
) internal override {
super._updatePurchasingState(
beneficiary,
paymentToken,
weiAmount,
tokenAmount
);
_updateBeneficiaryTokensPurchased(beneficiary, tokenAmount);
}
} | /**
* @title LaunchpadCrowdsaleWithVesting
* @author Enjinstarter
* @dev Launchpad crowdsale where there is no delivery of tokens in each purchase.
*/ | NatSpecMultiLine | getRemainingTokens | function getRemainingTokens()
external
view
override
returns (uint256 remainingTokens)
{
remainingTokens = tokenCap().sub(tokensSold);
}
| /**
* @return remainingTokens Remaining number of tokens for crowdsale
*/ | NatSpecMultiLine | v0.7.6+commit.7338295f | {
"func_code_index": [
2059,
2247
]
} | 8,912 |
||
LaunchpadCrowdsaleWithVesting | contracts/LaunchpadCrowdsaleWithVesting.sol | 0x6557d383b209fc901c57da8dffd15e2689e789ed | Solidity | LaunchpadCrowdsaleWithVesting | contract LaunchpadCrowdsaleWithVesting is
VestedCrowdsale,
CappedTokenSoldCrowdsaleHelper,
HoldErc20TokenCrowdsaleHelper,
TimedCrowdsaleHelper,
LaunchpadWhitelistCrowdsaleHelper,
Pausable,
ILaunchpadCrowdsaleWithVesting
{
using SafeMath for uint256;
struct LaunchpadCrowdsaleInfo {
uint256 tokenCap;
address vestingContract;
address whitelistContract;
address tokenHold;
uint256 minTokenHoldAmount;
}
address public governanceAccount;
address public crowdsaleAdmin;
// max 1 lot
constructor(
address wallet_,
address tokenSelling_,
LaunchpadCrowdsaleInfo memory crowdsaleInfo,
LotsInfo memory lotsInfo,
Timeframe memory timeframe,
PaymentTokenInfo[] memory paymentTokensInfo
)
Crowdsale(wallet_, tokenSelling_, lotsInfo, paymentTokensInfo)
VestedCrowdsale(crowdsaleInfo.vestingContract)
CappedTokenSoldCrowdsaleHelper(crowdsaleInfo.tokenCap)
HoldErc20TokenCrowdsaleHelper(
crowdsaleInfo.tokenHold,
crowdsaleInfo.minTokenHoldAmount
)
TimedCrowdsaleHelper(timeframe)
LaunchpadWhitelistCrowdsaleHelper(crowdsaleInfo.whitelistContract)
{
governanceAccount = msg.sender;
crowdsaleAdmin = msg.sender;
}
modifier onlyBy(address account) {
require(
msg.sender == account,
"LaunchpadCrowdsaleWithVesting: sender unauthorized"
);
_;
}
/**
* @return availableLots Available number of lots for beneficiary
*/
function getAvailableLotsFor(address beneficiary)
external
view
override
returns (uint256 availableLots)
{
if (!whitelisted(beneficiary)) {
return 0;
}
availableLots = _getAvailableTokensFor(beneficiary).div(
getBeneficiaryCap(beneficiary)
);
}
/**
* @return remainingTokens Remaining number of tokens for crowdsale
*/
function getRemainingTokens()
external
view
override
returns (uint256 remainingTokens)
{
remainingTokens = tokenCap().sub(tokensSold);
}
function pause() external override onlyBy(crowdsaleAdmin) {
_pause();
}
function unpause() external override onlyBy(crowdsaleAdmin) {
_unpause();
}
function extendTime(uint256 newClosingTime)
external
override
onlyBy(crowdsaleAdmin)
{
_extendTime(newClosingTime);
}
function startDistribution(uint256 scheduleStartTimestamp)
external
override
onlyBy(crowdsaleAdmin)
{
require(
scheduleStartTimestamp > closingTime(),
"LaunchpadCrowdsaleWithVesting: must be after closing time"
);
_startDistribution(scheduleStartTimestamp);
}
function setGovernanceAccount(address account)
external
override
onlyBy(governanceAccount)
{
require(
account != address(0),
"LaunchpadCrowdsaleWithVesting: zero account"
);
governanceAccount = account;
}
function setCrowdsaleAdmin(address account)
external
override
onlyBy(governanceAccount)
{
require(
account != address(0),
"LaunchpadCrowdsaleWithVesting: zero account"
);
crowdsaleAdmin = account;
}
/**
* @param beneficiary Address receiving the tokens
* @return lotSize_ lot size of token being sold
*/
function _lotSize(address beneficiary)
internal
view
override
returns (uint256 lotSize_)
{
lotSize_ = getBeneficiaryCap(beneficiary);
}
/**
* @dev Override to extend the way in which payment token is converted to tokens.
* @param lots Number of lots of token being sold
* @param beneficiary Address receiving the tokens
* @return tokenAmount Number of tokens that will be purchased
*/
function _getTokenAmount(uint256 lots, address beneficiary)
internal
view
override
returns (uint256 tokenAmount)
{
tokenAmount = lots.mul(_lotSize(beneficiary));
}
/**
* @param beneficiary Token beneficiary
* @param paymentToken ERC20 payment token address
* @param weiAmount Amount of wei contributed
* @param tokenAmount Number of tokens to be purchased
*/
function _preValidatePurchase(
address beneficiary,
address paymentToken,
uint256 weiAmount,
uint256 tokenAmount
)
internal
view
override
whenNotPaused
onlyWhileOpen
tokenCapNotExceeded(tokensSold, tokenAmount)
holdsSufficientTokens(beneficiary)
isWhitelisted(beneficiary)
{
// TODO: Investigate why modifier and require() don't work consistently for beneficiaryCapNotExceeded()
if (
getTokensPurchasedBy(beneficiary).add(tokenAmount) >
getBeneficiaryCap(beneficiary)
) {
revert("LaunchpadCrowdsaleWithVesting: beneficiary cap exceeded");
}
super._preValidatePurchase(
beneficiary,
paymentToken,
weiAmount,
tokenAmount
);
}
/**
* @dev Extend parent behavior to update purchased amount of tokens by beneficiary.
* @param beneficiary Token purchaser
* @param paymentToken ERC20 payment token address
* @param weiAmount Amount in wei of ERC20 payment token
* @param tokenAmount Number of tokens to be purchased
*/
function _updatePurchasingState(
address beneficiary,
address paymentToken,
uint256 weiAmount,
uint256 tokenAmount
) internal override {
super._updatePurchasingState(
beneficiary,
paymentToken,
weiAmount,
tokenAmount
);
_updateBeneficiaryTokensPurchased(beneficiary, tokenAmount);
}
} | /**
* @title LaunchpadCrowdsaleWithVesting
* @author Enjinstarter
* @dev Launchpad crowdsale where there is no delivery of tokens in each purchase.
*/ | NatSpecMultiLine | _lotSize | function _lotSize(address beneficiary)
internal
view
override
returns (uint256 lotSize_)
{
lotSize_ = getBeneficiaryCap(beneficiary);
}
| /**
* @param beneficiary Address receiving the tokens
* @return lotSize_ lot size of token being sold
*/ | NatSpecMultiLine | v0.7.6+commit.7338295f | {
"func_code_index": [
3639,
3826
]
} | 8,913 |
||
LaunchpadCrowdsaleWithVesting | contracts/LaunchpadCrowdsaleWithVesting.sol | 0x6557d383b209fc901c57da8dffd15e2689e789ed | Solidity | LaunchpadCrowdsaleWithVesting | contract LaunchpadCrowdsaleWithVesting is
VestedCrowdsale,
CappedTokenSoldCrowdsaleHelper,
HoldErc20TokenCrowdsaleHelper,
TimedCrowdsaleHelper,
LaunchpadWhitelistCrowdsaleHelper,
Pausable,
ILaunchpadCrowdsaleWithVesting
{
using SafeMath for uint256;
struct LaunchpadCrowdsaleInfo {
uint256 tokenCap;
address vestingContract;
address whitelistContract;
address tokenHold;
uint256 minTokenHoldAmount;
}
address public governanceAccount;
address public crowdsaleAdmin;
// max 1 lot
constructor(
address wallet_,
address tokenSelling_,
LaunchpadCrowdsaleInfo memory crowdsaleInfo,
LotsInfo memory lotsInfo,
Timeframe memory timeframe,
PaymentTokenInfo[] memory paymentTokensInfo
)
Crowdsale(wallet_, tokenSelling_, lotsInfo, paymentTokensInfo)
VestedCrowdsale(crowdsaleInfo.vestingContract)
CappedTokenSoldCrowdsaleHelper(crowdsaleInfo.tokenCap)
HoldErc20TokenCrowdsaleHelper(
crowdsaleInfo.tokenHold,
crowdsaleInfo.minTokenHoldAmount
)
TimedCrowdsaleHelper(timeframe)
LaunchpadWhitelistCrowdsaleHelper(crowdsaleInfo.whitelistContract)
{
governanceAccount = msg.sender;
crowdsaleAdmin = msg.sender;
}
modifier onlyBy(address account) {
require(
msg.sender == account,
"LaunchpadCrowdsaleWithVesting: sender unauthorized"
);
_;
}
/**
* @return availableLots Available number of lots for beneficiary
*/
function getAvailableLotsFor(address beneficiary)
external
view
override
returns (uint256 availableLots)
{
if (!whitelisted(beneficiary)) {
return 0;
}
availableLots = _getAvailableTokensFor(beneficiary).div(
getBeneficiaryCap(beneficiary)
);
}
/**
* @return remainingTokens Remaining number of tokens for crowdsale
*/
function getRemainingTokens()
external
view
override
returns (uint256 remainingTokens)
{
remainingTokens = tokenCap().sub(tokensSold);
}
function pause() external override onlyBy(crowdsaleAdmin) {
_pause();
}
function unpause() external override onlyBy(crowdsaleAdmin) {
_unpause();
}
function extendTime(uint256 newClosingTime)
external
override
onlyBy(crowdsaleAdmin)
{
_extendTime(newClosingTime);
}
function startDistribution(uint256 scheduleStartTimestamp)
external
override
onlyBy(crowdsaleAdmin)
{
require(
scheduleStartTimestamp > closingTime(),
"LaunchpadCrowdsaleWithVesting: must be after closing time"
);
_startDistribution(scheduleStartTimestamp);
}
function setGovernanceAccount(address account)
external
override
onlyBy(governanceAccount)
{
require(
account != address(0),
"LaunchpadCrowdsaleWithVesting: zero account"
);
governanceAccount = account;
}
function setCrowdsaleAdmin(address account)
external
override
onlyBy(governanceAccount)
{
require(
account != address(0),
"LaunchpadCrowdsaleWithVesting: zero account"
);
crowdsaleAdmin = account;
}
/**
* @param beneficiary Address receiving the tokens
* @return lotSize_ lot size of token being sold
*/
function _lotSize(address beneficiary)
internal
view
override
returns (uint256 lotSize_)
{
lotSize_ = getBeneficiaryCap(beneficiary);
}
/**
* @dev Override to extend the way in which payment token is converted to tokens.
* @param lots Number of lots of token being sold
* @param beneficiary Address receiving the tokens
* @return tokenAmount Number of tokens that will be purchased
*/
function _getTokenAmount(uint256 lots, address beneficiary)
internal
view
override
returns (uint256 tokenAmount)
{
tokenAmount = lots.mul(_lotSize(beneficiary));
}
/**
* @param beneficiary Token beneficiary
* @param paymentToken ERC20 payment token address
* @param weiAmount Amount of wei contributed
* @param tokenAmount Number of tokens to be purchased
*/
function _preValidatePurchase(
address beneficiary,
address paymentToken,
uint256 weiAmount,
uint256 tokenAmount
)
internal
view
override
whenNotPaused
onlyWhileOpen
tokenCapNotExceeded(tokensSold, tokenAmount)
holdsSufficientTokens(beneficiary)
isWhitelisted(beneficiary)
{
// TODO: Investigate why modifier and require() don't work consistently for beneficiaryCapNotExceeded()
if (
getTokensPurchasedBy(beneficiary).add(tokenAmount) >
getBeneficiaryCap(beneficiary)
) {
revert("LaunchpadCrowdsaleWithVesting: beneficiary cap exceeded");
}
super._preValidatePurchase(
beneficiary,
paymentToken,
weiAmount,
tokenAmount
);
}
/**
* @dev Extend parent behavior to update purchased amount of tokens by beneficiary.
* @param beneficiary Token purchaser
* @param paymentToken ERC20 payment token address
* @param weiAmount Amount in wei of ERC20 payment token
* @param tokenAmount Number of tokens to be purchased
*/
function _updatePurchasingState(
address beneficiary,
address paymentToken,
uint256 weiAmount,
uint256 tokenAmount
) internal override {
super._updatePurchasingState(
beneficiary,
paymentToken,
weiAmount,
tokenAmount
);
_updateBeneficiaryTokensPurchased(beneficiary, tokenAmount);
}
} | /**
* @title LaunchpadCrowdsaleWithVesting
* @author Enjinstarter
* @dev Launchpad crowdsale where there is no delivery of tokens in each purchase.
*/ | NatSpecMultiLine | _getTokenAmount | function _getTokenAmount(uint256 lots, address beneficiary)
internal
view
override
returns (uint256 tokenAmount)
{
tokenAmount = lots.mul(_lotSize(beneficiary));
}
| /**
* @dev Override to extend the way in which payment token is converted to tokens.
* @param lots Number of lots of token being sold
* @param beneficiary Address receiving the tokens
* @return tokenAmount Number of tokens that will be purchased
*/ | NatSpecMultiLine | v0.7.6+commit.7338295f | {
"func_code_index": [
4106,
4321
]
} | 8,914 |
||
LaunchpadCrowdsaleWithVesting | contracts/LaunchpadCrowdsaleWithVesting.sol | 0x6557d383b209fc901c57da8dffd15e2689e789ed | Solidity | LaunchpadCrowdsaleWithVesting | contract LaunchpadCrowdsaleWithVesting is
VestedCrowdsale,
CappedTokenSoldCrowdsaleHelper,
HoldErc20TokenCrowdsaleHelper,
TimedCrowdsaleHelper,
LaunchpadWhitelistCrowdsaleHelper,
Pausable,
ILaunchpadCrowdsaleWithVesting
{
using SafeMath for uint256;
struct LaunchpadCrowdsaleInfo {
uint256 tokenCap;
address vestingContract;
address whitelistContract;
address tokenHold;
uint256 minTokenHoldAmount;
}
address public governanceAccount;
address public crowdsaleAdmin;
// max 1 lot
constructor(
address wallet_,
address tokenSelling_,
LaunchpadCrowdsaleInfo memory crowdsaleInfo,
LotsInfo memory lotsInfo,
Timeframe memory timeframe,
PaymentTokenInfo[] memory paymentTokensInfo
)
Crowdsale(wallet_, tokenSelling_, lotsInfo, paymentTokensInfo)
VestedCrowdsale(crowdsaleInfo.vestingContract)
CappedTokenSoldCrowdsaleHelper(crowdsaleInfo.tokenCap)
HoldErc20TokenCrowdsaleHelper(
crowdsaleInfo.tokenHold,
crowdsaleInfo.minTokenHoldAmount
)
TimedCrowdsaleHelper(timeframe)
LaunchpadWhitelistCrowdsaleHelper(crowdsaleInfo.whitelistContract)
{
governanceAccount = msg.sender;
crowdsaleAdmin = msg.sender;
}
modifier onlyBy(address account) {
require(
msg.sender == account,
"LaunchpadCrowdsaleWithVesting: sender unauthorized"
);
_;
}
/**
* @return availableLots Available number of lots for beneficiary
*/
function getAvailableLotsFor(address beneficiary)
external
view
override
returns (uint256 availableLots)
{
if (!whitelisted(beneficiary)) {
return 0;
}
availableLots = _getAvailableTokensFor(beneficiary).div(
getBeneficiaryCap(beneficiary)
);
}
/**
* @return remainingTokens Remaining number of tokens for crowdsale
*/
function getRemainingTokens()
external
view
override
returns (uint256 remainingTokens)
{
remainingTokens = tokenCap().sub(tokensSold);
}
function pause() external override onlyBy(crowdsaleAdmin) {
_pause();
}
function unpause() external override onlyBy(crowdsaleAdmin) {
_unpause();
}
function extendTime(uint256 newClosingTime)
external
override
onlyBy(crowdsaleAdmin)
{
_extendTime(newClosingTime);
}
function startDistribution(uint256 scheduleStartTimestamp)
external
override
onlyBy(crowdsaleAdmin)
{
require(
scheduleStartTimestamp > closingTime(),
"LaunchpadCrowdsaleWithVesting: must be after closing time"
);
_startDistribution(scheduleStartTimestamp);
}
function setGovernanceAccount(address account)
external
override
onlyBy(governanceAccount)
{
require(
account != address(0),
"LaunchpadCrowdsaleWithVesting: zero account"
);
governanceAccount = account;
}
function setCrowdsaleAdmin(address account)
external
override
onlyBy(governanceAccount)
{
require(
account != address(0),
"LaunchpadCrowdsaleWithVesting: zero account"
);
crowdsaleAdmin = account;
}
/**
* @param beneficiary Address receiving the tokens
* @return lotSize_ lot size of token being sold
*/
function _lotSize(address beneficiary)
internal
view
override
returns (uint256 lotSize_)
{
lotSize_ = getBeneficiaryCap(beneficiary);
}
/**
* @dev Override to extend the way in which payment token is converted to tokens.
* @param lots Number of lots of token being sold
* @param beneficiary Address receiving the tokens
* @return tokenAmount Number of tokens that will be purchased
*/
function _getTokenAmount(uint256 lots, address beneficiary)
internal
view
override
returns (uint256 tokenAmount)
{
tokenAmount = lots.mul(_lotSize(beneficiary));
}
/**
* @param beneficiary Token beneficiary
* @param paymentToken ERC20 payment token address
* @param weiAmount Amount of wei contributed
* @param tokenAmount Number of tokens to be purchased
*/
function _preValidatePurchase(
address beneficiary,
address paymentToken,
uint256 weiAmount,
uint256 tokenAmount
)
internal
view
override
whenNotPaused
onlyWhileOpen
tokenCapNotExceeded(tokensSold, tokenAmount)
holdsSufficientTokens(beneficiary)
isWhitelisted(beneficiary)
{
// TODO: Investigate why modifier and require() don't work consistently for beneficiaryCapNotExceeded()
if (
getTokensPurchasedBy(beneficiary).add(tokenAmount) >
getBeneficiaryCap(beneficiary)
) {
revert("LaunchpadCrowdsaleWithVesting: beneficiary cap exceeded");
}
super._preValidatePurchase(
beneficiary,
paymentToken,
weiAmount,
tokenAmount
);
}
/**
* @dev Extend parent behavior to update purchased amount of tokens by beneficiary.
* @param beneficiary Token purchaser
* @param paymentToken ERC20 payment token address
* @param weiAmount Amount in wei of ERC20 payment token
* @param tokenAmount Number of tokens to be purchased
*/
function _updatePurchasingState(
address beneficiary,
address paymentToken,
uint256 weiAmount,
uint256 tokenAmount
) internal override {
super._updatePurchasingState(
beneficiary,
paymentToken,
weiAmount,
tokenAmount
);
_updateBeneficiaryTokensPurchased(beneficiary, tokenAmount);
}
} | /**
* @title LaunchpadCrowdsaleWithVesting
* @author Enjinstarter
* @dev Launchpad crowdsale where there is no delivery of tokens in each purchase.
*/ | NatSpecMultiLine | _preValidatePurchase | function _preValidatePurchase(
address beneficiary,
address paymentToken,
uint256 weiAmount,
uint256 tokenAmount
)
internal
view
override
whenNotPaused
onlyWhileOpen
tokenCapNotExceeded(tokensSold, tokenAmount)
holdsSufficientTokens(beneficiary)
isWhitelisted(beneficiary)
{
// TODO: Investigate why modifier and require() don't work consistently for beneficiaryCapNotExceeded()
if (
getTokensPurchasedBy(beneficiary).add(tokenAmount) >
getBeneficiaryCap(beneficiary)
) {
revert("LaunchpadCrowdsaleWithVesting: beneficiary cap exceeded");
}
super._preValidatePurchase(
beneficiary,
paymentToken,
weiAmount,
tokenAmount
);
}
| /**
* @param beneficiary Token beneficiary
* @param paymentToken ERC20 payment token address
* @param weiAmount Amount of wei contributed
* @param tokenAmount Number of tokens to be purchased
*/ | NatSpecMultiLine | v0.7.6+commit.7338295f | {
"func_code_index": [
4547,
5415
]
} | 8,915 |
||
LaunchpadCrowdsaleWithVesting | contracts/LaunchpadCrowdsaleWithVesting.sol | 0x6557d383b209fc901c57da8dffd15e2689e789ed | Solidity | LaunchpadCrowdsaleWithVesting | contract LaunchpadCrowdsaleWithVesting is
VestedCrowdsale,
CappedTokenSoldCrowdsaleHelper,
HoldErc20TokenCrowdsaleHelper,
TimedCrowdsaleHelper,
LaunchpadWhitelistCrowdsaleHelper,
Pausable,
ILaunchpadCrowdsaleWithVesting
{
using SafeMath for uint256;
struct LaunchpadCrowdsaleInfo {
uint256 tokenCap;
address vestingContract;
address whitelistContract;
address tokenHold;
uint256 minTokenHoldAmount;
}
address public governanceAccount;
address public crowdsaleAdmin;
// max 1 lot
constructor(
address wallet_,
address tokenSelling_,
LaunchpadCrowdsaleInfo memory crowdsaleInfo,
LotsInfo memory lotsInfo,
Timeframe memory timeframe,
PaymentTokenInfo[] memory paymentTokensInfo
)
Crowdsale(wallet_, tokenSelling_, lotsInfo, paymentTokensInfo)
VestedCrowdsale(crowdsaleInfo.vestingContract)
CappedTokenSoldCrowdsaleHelper(crowdsaleInfo.tokenCap)
HoldErc20TokenCrowdsaleHelper(
crowdsaleInfo.tokenHold,
crowdsaleInfo.minTokenHoldAmount
)
TimedCrowdsaleHelper(timeframe)
LaunchpadWhitelistCrowdsaleHelper(crowdsaleInfo.whitelistContract)
{
governanceAccount = msg.sender;
crowdsaleAdmin = msg.sender;
}
modifier onlyBy(address account) {
require(
msg.sender == account,
"LaunchpadCrowdsaleWithVesting: sender unauthorized"
);
_;
}
/**
* @return availableLots Available number of lots for beneficiary
*/
function getAvailableLotsFor(address beneficiary)
external
view
override
returns (uint256 availableLots)
{
if (!whitelisted(beneficiary)) {
return 0;
}
availableLots = _getAvailableTokensFor(beneficiary).div(
getBeneficiaryCap(beneficiary)
);
}
/**
* @return remainingTokens Remaining number of tokens for crowdsale
*/
function getRemainingTokens()
external
view
override
returns (uint256 remainingTokens)
{
remainingTokens = tokenCap().sub(tokensSold);
}
function pause() external override onlyBy(crowdsaleAdmin) {
_pause();
}
function unpause() external override onlyBy(crowdsaleAdmin) {
_unpause();
}
function extendTime(uint256 newClosingTime)
external
override
onlyBy(crowdsaleAdmin)
{
_extendTime(newClosingTime);
}
function startDistribution(uint256 scheduleStartTimestamp)
external
override
onlyBy(crowdsaleAdmin)
{
require(
scheduleStartTimestamp > closingTime(),
"LaunchpadCrowdsaleWithVesting: must be after closing time"
);
_startDistribution(scheduleStartTimestamp);
}
function setGovernanceAccount(address account)
external
override
onlyBy(governanceAccount)
{
require(
account != address(0),
"LaunchpadCrowdsaleWithVesting: zero account"
);
governanceAccount = account;
}
function setCrowdsaleAdmin(address account)
external
override
onlyBy(governanceAccount)
{
require(
account != address(0),
"LaunchpadCrowdsaleWithVesting: zero account"
);
crowdsaleAdmin = account;
}
/**
* @param beneficiary Address receiving the tokens
* @return lotSize_ lot size of token being sold
*/
function _lotSize(address beneficiary)
internal
view
override
returns (uint256 lotSize_)
{
lotSize_ = getBeneficiaryCap(beneficiary);
}
/**
* @dev Override to extend the way in which payment token is converted to tokens.
* @param lots Number of lots of token being sold
* @param beneficiary Address receiving the tokens
* @return tokenAmount Number of tokens that will be purchased
*/
function _getTokenAmount(uint256 lots, address beneficiary)
internal
view
override
returns (uint256 tokenAmount)
{
tokenAmount = lots.mul(_lotSize(beneficiary));
}
/**
* @param beneficiary Token beneficiary
* @param paymentToken ERC20 payment token address
* @param weiAmount Amount of wei contributed
* @param tokenAmount Number of tokens to be purchased
*/
function _preValidatePurchase(
address beneficiary,
address paymentToken,
uint256 weiAmount,
uint256 tokenAmount
)
internal
view
override
whenNotPaused
onlyWhileOpen
tokenCapNotExceeded(tokensSold, tokenAmount)
holdsSufficientTokens(beneficiary)
isWhitelisted(beneficiary)
{
// TODO: Investigate why modifier and require() don't work consistently for beneficiaryCapNotExceeded()
if (
getTokensPurchasedBy(beneficiary).add(tokenAmount) >
getBeneficiaryCap(beneficiary)
) {
revert("LaunchpadCrowdsaleWithVesting: beneficiary cap exceeded");
}
super._preValidatePurchase(
beneficiary,
paymentToken,
weiAmount,
tokenAmount
);
}
/**
* @dev Extend parent behavior to update purchased amount of tokens by beneficiary.
* @param beneficiary Token purchaser
* @param paymentToken ERC20 payment token address
* @param weiAmount Amount in wei of ERC20 payment token
* @param tokenAmount Number of tokens to be purchased
*/
function _updatePurchasingState(
address beneficiary,
address paymentToken,
uint256 weiAmount,
uint256 tokenAmount
) internal override {
super._updatePurchasingState(
beneficiary,
paymentToken,
weiAmount,
tokenAmount
);
_updateBeneficiaryTokensPurchased(beneficiary, tokenAmount);
}
} | /**
* @title LaunchpadCrowdsaleWithVesting
* @author Enjinstarter
* @dev Launchpad crowdsale where there is no delivery of tokens in each purchase.
*/ | NatSpecMultiLine | _updatePurchasingState | function _updatePurchasingState(
address beneficiary,
address paymentToken,
uint256 weiAmount,
uint256 tokenAmount
) internal override {
super._updatePurchasingState(
beneficiary,
paymentToken,
weiAmount,
tokenAmount
);
_updateBeneficiaryTokensPurchased(beneficiary, tokenAmount);
}
| /**
* @dev Extend parent behavior to update purchased amount of tokens by beneficiary.
* @param beneficiary Token purchaser
* @param paymentToken ERC20 payment token address
* @param weiAmount Amount in wei of ERC20 payment token
* @param tokenAmount Number of tokens to be purchased
*/ | NatSpecMultiLine | v0.7.6+commit.7338295f | {
"func_code_index": [
5738,
6137
]
} | 8,916 |
||
HonestCoinToken | HonestCoinToken.sol | 0x1bb8daa79accb27a22b2a3384273bcc53c9a4161 | Solidity | Context | contract Context {
constructor () internal { }
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
} | _msgSender | function _msgSender() internal view returns (address payable) {
return msg.sender;
}
| // solhint-disable-previous-line no-empty-blocks | LineComment | v0.5.12+commit.7709ece9 | MIT | bzzr://b126a478439fdfa7ea8ec601385dfa8d8781044c7ec00f416a2b7f2b179ba8ff | {
"func_code_index": [
109,
212
]
} | 8,917 |
||
HonestCoinToken | HonestCoinToken.sol | 0x1bb8daa79accb27a22b2a3384273bcc53c9a4161 | Solidity | ERC20Burnable | contract ERC20Burnable is ERC20 {
/**
* @dev Destroys `amount` tokens from msg.sender's balance.
*/
function burn(uint256 amount) public {
_burn(msg.sender, amount);
}
/**
* @dev Destroys `amount` tokens from `account`.`amount` is then deducted
* from the caller's allowance.
*/
function burnFrom(address account, uint256 amount) public {
_burnFrom(account, amount);
}
} | /**
* @dev Extension of `ERC20` that allows token holders to destroy both their own
* tokens and those that they have an allowance for, in a way that can be
* recognized off-chain (via event analysis).
*/ | NatSpecMultiLine | burn | function burn(uint256 amount) public {
_burn(msg.sender, amount);
}
| /**
* @dev Destroys `amount` tokens from msg.sender's balance.
*/ | NatSpecMultiLine | v0.5.12+commit.7709ece9 | MIT | bzzr://b126a478439fdfa7ea8ec601385dfa8d8781044c7ec00f416a2b7f2b179ba8ff | {
"func_code_index": [
118,
204
]
} | 8,918 |
HonestCoinToken | HonestCoinToken.sol | 0x1bb8daa79accb27a22b2a3384273bcc53c9a4161 | Solidity | ERC20Burnable | contract ERC20Burnable is ERC20 {
/**
* @dev Destroys `amount` tokens from msg.sender's balance.
*/
function burn(uint256 amount) public {
_burn(msg.sender, amount);
}
/**
* @dev Destroys `amount` tokens from `account`.`amount` is then deducted
* from the caller's allowance.
*/
function burnFrom(address account, uint256 amount) public {
_burnFrom(account, amount);
}
} | /**
* @dev Extension of `ERC20` that allows token holders to destroy both their own
* tokens and those that they have an allowance for, in a way that can be
* recognized off-chain (via event analysis).
*/ | NatSpecMultiLine | burnFrom | function burnFrom(address account, uint256 amount) public {
_burnFrom(account, amount);
}
| /**
* @dev Destroys `amount` tokens from `account`.`amount` is then deducted
* from the caller's allowance.
*/ | NatSpecMultiLine | v0.5.12+commit.7709ece9 | MIT | bzzr://b126a478439fdfa7ea8ec601385dfa8d8781044c7ec00f416a2b7f2b179ba8ff | {
"func_code_index": [
341,
449
]
} | 8,919 |
HonestCoinToken | HonestCoinToken.sol | 0x1bb8daa79accb27a22b2a3384273bcc53c9a4161 | Solidity | ERC20Mintable | contract ERC20Mintable is ERC20Burnable, MinterRole {
// if additional minting of tokens is impossible
bool public mintingFinished;
// prevent minting of tokens when it is finished.
// prevent total supply to exceed the limit of emission.
modifier canMint(uint256 amount) {
require(amount > 0, "Minting zero amount");
require(!mintingFinished, "Minting is finished");
_;
}
/**
* @dev Stop any additional minting of tokens forever.
* Available only to the owner.
*/
function finishMinting() external onlyOwner {
mintingFinished = true;
}
/**
* @dev Minting of new tokens.
* @param to The address to mint to.
* @param value The amount to be minted.
*/
function mint(address to, uint256 value) public onlyMinter canMint(value) returns (bool) {
_mint(to, value);
return true;
}
} | /**
* @dev Extension of {ERC20} that adds a set of accounts with the {MinterRole},
* which have permission to mint (create) new tokens as they see fit.
*/ | NatSpecMultiLine | finishMinting | function finishMinting() external onlyOwner {
mintingFinished = true;
}
| /**
* @dev Stop any additional minting of tokens forever.
* Available only to the owner.
*/ | NatSpecMultiLine | v0.5.12+commit.7709ece9 | MIT | bzzr://b126a478439fdfa7ea8ec601385dfa8d8781044c7ec00f416a2b7f2b179ba8ff | {
"func_code_index": [
552,
642
]
} | 8,920 |
HonestCoinToken | HonestCoinToken.sol | 0x1bb8daa79accb27a22b2a3384273bcc53c9a4161 | Solidity | ERC20Mintable | contract ERC20Mintable is ERC20Burnable, MinterRole {
// if additional minting of tokens is impossible
bool public mintingFinished;
// prevent minting of tokens when it is finished.
// prevent total supply to exceed the limit of emission.
modifier canMint(uint256 amount) {
require(amount > 0, "Minting zero amount");
require(!mintingFinished, "Minting is finished");
_;
}
/**
* @dev Stop any additional minting of tokens forever.
* Available only to the owner.
*/
function finishMinting() external onlyOwner {
mintingFinished = true;
}
/**
* @dev Minting of new tokens.
* @param to The address to mint to.
* @param value The amount to be minted.
*/
function mint(address to, uint256 value) public onlyMinter canMint(value) returns (bool) {
_mint(to, value);
return true;
}
} | /**
* @dev Extension of {ERC20} that adds a set of accounts with the {MinterRole},
* which have permission to mint (create) new tokens as they see fit.
*/ | NatSpecMultiLine | mint | function mint(address to, uint256 value) public onlyMinter canMint(value) returns (bool) {
_mint(to, value);
return true;
}
| /**
* @dev Minting of new tokens.
* @param to The address to mint to.
* @param value The amount to be minted.
*/ | NatSpecMultiLine | v0.5.12+commit.7709ece9 | MIT | bzzr://b126a478439fdfa7ea8ec601385dfa8d8781044c7ec00f416a2b7f2b179ba8ff | {
"func_code_index": [
787,
938
]
} | 8,921 |
HonestCoinToken | HonestCoinToken.sol | 0x1bb8daa79accb27a22b2a3384273bcc53c9a4161 | Solidity | HonestCoinToken | contract HonestCoinToken is ERC20Mintable, ERC20Detailed {
using SafeERC20 for IERC20;
using SafeMath for uint256;
// registered contracts (to prevent loss of token via transfer function)
mapping (address => bool) private _contracts;
constructor(address initialOwner, address recipient) public ERC20Detailed("HonestCoin", "USDH", 6) Ownable(initialOwner) {
// creating of inital supply
uint256 INITIAL_SUPPLY = 88888888e6;
_mint(recipient, INITIAL_SUPPLY);
}
/**
* @dev modified transfer function that allows to safely send tokens to smart-contract.
* @param to The address to transfer to.
* @param value The amount to be transferred.
*/
function transfer(address to, uint256 value) public returns (bool) {
if (_contracts[to]) {
approveAndCall(to, value, new bytes(0));
} else {
super.transfer(to, value);
}
return true;
}
/**
* @dev Allows to send tokens (via Approve and TransferFrom) to other smart-contract.
* @param spender Address of smart contracts to work with.
* @param amount Amount of tokens to send.
* @param extraData Any extra data.
*/
function approveAndCall(address spender, uint256 amount, bytes memory extraData) public returns (bool) {
require(approve(spender, amount));
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, amount, address(this), extraData);
return true;
}
/**
* @dev Allows to register other smart-contracts (to prevent loss of tokens via transfer function).
* @param account Address of smart contracts to work with.
*/
function registerContract(address account) external onlyOwner {
require(_isContract(account), "Token: account is not a smart-contract");
_contracts[account] = true;
}
/**
* @dev Allows to unregister registered smart-contracts.
* @param account Address of smart contracts to work with.
*/
function unregisterContract(address account) external onlyOwner {
require(isRegistered(account), "Token: account is not registered yet");
_contracts[account] = false;
}
/**
* @dev Allows to any owner of the contract withdraw needed ERC20 token from this contract (for example promo or bounties).
* @param ERC20Token Address of ERC20 token.
* @param recipient Account to receive tokens.
*/
function withdrawERC20(address ERC20Token, address recipient) external onlyOwner {
uint256 amount = IERC20(ERC20Token).balanceOf(address(this));
IERC20(ERC20Token).safeTransfer(recipient, amount);
}
/**
* @return true if the address is registered as contract
* @param account Address to be checked.
*/
function isRegistered(address account) public view returns (bool) {
return _contracts[account];
}
/**
* @return true if `account` is a contract.
* @param account Address to be checked.
*/
function _isContract(address account) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(account) }
return size > 0;
}
} | /**
* @title The main project contract.
*/ | NatSpecMultiLine | transfer | function transfer(address to, uint256 value) public returns (bool) {
if (_contracts[to]) {
approveAndCall(to, value, new bytes(0));
} else {
super.transfer(to, value);
}
return true;
}
| /**
* @dev modified transfer function that allows to safely send tokens to smart-contract.
* @param to The address to transfer to.
* @param value The amount to be transferred.
*/ | NatSpecMultiLine | v0.5.12+commit.7709ece9 | MIT | bzzr://b126a478439fdfa7ea8ec601385dfa8d8781044c7ec00f416a2b7f2b179ba8ff | {
"func_code_index": [
731,
993
]
} | 8,922 |
HonestCoinToken | HonestCoinToken.sol | 0x1bb8daa79accb27a22b2a3384273bcc53c9a4161 | Solidity | HonestCoinToken | contract HonestCoinToken is ERC20Mintable, ERC20Detailed {
using SafeERC20 for IERC20;
using SafeMath for uint256;
// registered contracts (to prevent loss of token via transfer function)
mapping (address => bool) private _contracts;
constructor(address initialOwner, address recipient) public ERC20Detailed("HonestCoin", "USDH", 6) Ownable(initialOwner) {
// creating of inital supply
uint256 INITIAL_SUPPLY = 88888888e6;
_mint(recipient, INITIAL_SUPPLY);
}
/**
* @dev modified transfer function that allows to safely send tokens to smart-contract.
* @param to The address to transfer to.
* @param value The amount to be transferred.
*/
function transfer(address to, uint256 value) public returns (bool) {
if (_contracts[to]) {
approveAndCall(to, value, new bytes(0));
} else {
super.transfer(to, value);
}
return true;
}
/**
* @dev Allows to send tokens (via Approve and TransferFrom) to other smart-contract.
* @param spender Address of smart contracts to work with.
* @param amount Amount of tokens to send.
* @param extraData Any extra data.
*/
function approveAndCall(address spender, uint256 amount, bytes memory extraData) public returns (bool) {
require(approve(spender, amount));
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, amount, address(this), extraData);
return true;
}
/**
* @dev Allows to register other smart-contracts (to prevent loss of tokens via transfer function).
* @param account Address of smart contracts to work with.
*/
function registerContract(address account) external onlyOwner {
require(_isContract(account), "Token: account is not a smart-contract");
_contracts[account] = true;
}
/**
* @dev Allows to unregister registered smart-contracts.
* @param account Address of smart contracts to work with.
*/
function unregisterContract(address account) external onlyOwner {
require(isRegistered(account), "Token: account is not registered yet");
_contracts[account] = false;
}
/**
* @dev Allows to any owner of the contract withdraw needed ERC20 token from this contract (for example promo or bounties).
* @param ERC20Token Address of ERC20 token.
* @param recipient Account to receive tokens.
*/
function withdrawERC20(address ERC20Token, address recipient) external onlyOwner {
uint256 amount = IERC20(ERC20Token).balanceOf(address(this));
IERC20(ERC20Token).safeTransfer(recipient, amount);
}
/**
* @return true if the address is registered as contract
* @param account Address to be checked.
*/
function isRegistered(address account) public view returns (bool) {
return _contracts[account];
}
/**
* @return true if `account` is a contract.
* @param account Address to be checked.
*/
function _isContract(address account) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(account) }
return size > 0;
}
} | /**
* @title The main project contract.
*/ | NatSpecMultiLine | approveAndCall | function approveAndCall(address spender, uint256 amount, bytes memory extraData) public returns (bool) {
require(approve(spender, amount));
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, amount, address(this), extraData);
return true;
}
| /**
* @dev Allows to send tokens (via Approve and TransferFrom) to other smart-contract.
* @param spender Address of smart contracts to work with.
* @param amount Amount of tokens to send.
* @param extraData Any extra data.
*/ | NatSpecMultiLine | v0.5.12+commit.7709ece9 | MIT | bzzr://b126a478439fdfa7ea8ec601385dfa8d8781044c7ec00f416a2b7f2b179ba8ff | {
"func_code_index": [
1253,
1543
]
} | 8,923 |
HonestCoinToken | HonestCoinToken.sol | 0x1bb8daa79accb27a22b2a3384273bcc53c9a4161 | Solidity | HonestCoinToken | contract HonestCoinToken is ERC20Mintable, ERC20Detailed {
using SafeERC20 for IERC20;
using SafeMath for uint256;
// registered contracts (to prevent loss of token via transfer function)
mapping (address => bool) private _contracts;
constructor(address initialOwner, address recipient) public ERC20Detailed("HonestCoin", "USDH", 6) Ownable(initialOwner) {
// creating of inital supply
uint256 INITIAL_SUPPLY = 88888888e6;
_mint(recipient, INITIAL_SUPPLY);
}
/**
* @dev modified transfer function that allows to safely send tokens to smart-contract.
* @param to The address to transfer to.
* @param value The amount to be transferred.
*/
function transfer(address to, uint256 value) public returns (bool) {
if (_contracts[to]) {
approveAndCall(to, value, new bytes(0));
} else {
super.transfer(to, value);
}
return true;
}
/**
* @dev Allows to send tokens (via Approve and TransferFrom) to other smart-contract.
* @param spender Address of smart contracts to work with.
* @param amount Amount of tokens to send.
* @param extraData Any extra data.
*/
function approveAndCall(address spender, uint256 amount, bytes memory extraData) public returns (bool) {
require(approve(spender, amount));
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, amount, address(this), extraData);
return true;
}
/**
* @dev Allows to register other smart-contracts (to prevent loss of tokens via transfer function).
* @param account Address of smart contracts to work with.
*/
function registerContract(address account) external onlyOwner {
require(_isContract(account), "Token: account is not a smart-contract");
_contracts[account] = true;
}
/**
* @dev Allows to unregister registered smart-contracts.
* @param account Address of smart contracts to work with.
*/
function unregisterContract(address account) external onlyOwner {
require(isRegistered(account), "Token: account is not registered yet");
_contracts[account] = false;
}
/**
* @dev Allows to any owner of the contract withdraw needed ERC20 token from this contract (for example promo or bounties).
* @param ERC20Token Address of ERC20 token.
* @param recipient Account to receive tokens.
*/
function withdrawERC20(address ERC20Token, address recipient) external onlyOwner {
uint256 amount = IERC20(ERC20Token).balanceOf(address(this));
IERC20(ERC20Token).safeTransfer(recipient, amount);
}
/**
* @return true if the address is registered as contract
* @param account Address to be checked.
*/
function isRegistered(address account) public view returns (bool) {
return _contracts[account];
}
/**
* @return true if `account` is a contract.
* @param account Address to be checked.
*/
function _isContract(address account) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(account) }
return size > 0;
}
} | /**
* @title The main project contract.
*/ | NatSpecMultiLine | registerContract | function registerContract(address account) external onlyOwner {
require(_isContract(account), "Token: account is not a smart-contract");
_contracts[account] = true;
}
| /**
* @dev Allows to register other smart-contracts (to prevent loss of tokens via transfer function).
* @param account Address of smart contracts to work with.
*/ | NatSpecMultiLine | v0.5.12+commit.7709ece9 | MIT | bzzr://b126a478439fdfa7ea8ec601385dfa8d8781044c7ec00f416a2b7f2b179ba8ff | {
"func_code_index": [
1733,
1927
]
} | 8,924 |
HonestCoinToken | HonestCoinToken.sol | 0x1bb8daa79accb27a22b2a3384273bcc53c9a4161 | Solidity | HonestCoinToken | contract HonestCoinToken is ERC20Mintable, ERC20Detailed {
using SafeERC20 for IERC20;
using SafeMath for uint256;
// registered contracts (to prevent loss of token via transfer function)
mapping (address => bool) private _contracts;
constructor(address initialOwner, address recipient) public ERC20Detailed("HonestCoin", "USDH", 6) Ownable(initialOwner) {
// creating of inital supply
uint256 INITIAL_SUPPLY = 88888888e6;
_mint(recipient, INITIAL_SUPPLY);
}
/**
* @dev modified transfer function that allows to safely send tokens to smart-contract.
* @param to The address to transfer to.
* @param value The amount to be transferred.
*/
function transfer(address to, uint256 value) public returns (bool) {
if (_contracts[to]) {
approveAndCall(to, value, new bytes(0));
} else {
super.transfer(to, value);
}
return true;
}
/**
* @dev Allows to send tokens (via Approve and TransferFrom) to other smart-contract.
* @param spender Address of smart contracts to work with.
* @param amount Amount of tokens to send.
* @param extraData Any extra data.
*/
function approveAndCall(address spender, uint256 amount, bytes memory extraData) public returns (bool) {
require(approve(spender, amount));
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, amount, address(this), extraData);
return true;
}
/**
* @dev Allows to register other smart-contracts (to prevent loss of tokens via transfer function).
* @param account Address of smart contracts to work with.
*/
function registerContract(address account) external onlyOwner {
require(_isContract(account), "Token: account is not a smart-contract");
_contracts[account] = true;
}
/**
* @dev Allows to unregister registered smart-contracts.
* @param account Address of smart contracts to work with.
*/
function unregisterContract(address account) external onlyOwner {
require(isRegistered(account), "Token: account is not registered yet");
_contracts[account] = false;
}
/**
* @dev Allows to any owner of the contract withdraw needed ERC20 token from this contract (for example promo or bounties).
* @param ERC20Token Address of ERC20 token.
* @param recipient Account to receive tokens.
*/
function withdrawERC20(address ERC20Token, address recipient) external onlyOwner {
uint256 amount = IERC20(ERC20Token).balanceOf(address(this));
IERC20(ERC20Token).safeTransfer(recipient, amount);
}
/**
* @return true if the address is registered as contract
* @param account Address to be checked.
*/
function isRegistered(address account) public view returns (bool) {
return _contracts[account];
}
/**
* @return true if `account` is a contract.
* @param account Address to be checked.
*/
function _isContract(address account) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(account) }
return size > 0;
}
} | /**
* @title The main project contract.
*/ | NatSpecMultiLine | unregisterContract | function unregisterContract(address account) external onlyOwner {
require(isRegistered(account), "Token: account is not registered yet");
_contracts[account] = false;
}
| /**
* @dev Allows to unregister registered smart-contracts.
* @param account Address of smart contracts to work with.
*/ | NatSpecMultiLine | v0.5.12+commit.7709ece9 | MIT | bzzr://b126a478439fdfa7ea8ec601385dfa8d8781044c7ec00f416a2b7f2b179ba8ff | {
"func_code_index": [
2074,
2270
]
} | 8,925 |
HonestCoinToken | HonestCoinToken.sol | 0x1bb8daa79accb27a22b2a3384273bcc53c9a4161 | Solidity | HonestCoinToken | contract HonestCoinToken is ERC20Mintable, ERC20Detailed {
using SafeERC20 for IERC20;
using SafeMath for uint256;
// registered contracts (to prevent loss of token via transfer function)
mapping (address => bool) private _contracts;
constructor(address initialOwner, address recipient) public ERC20Detailed("HonestCoin", "USDH", 6) Ownable(initialOwner) {
// creating of inital supply
uint256 INITIAL_SUPPLY = 88888888e6;
_mint(recipient, INITIAL_SUPPLY);
}
/**
* @dev modified transfer function that allows to safely send tokens to smart-contract.
* @param to The address to transfer to.
* @param value The amount to be transferred.
*/
function transfer(address to, uint256 value) public returns (bool) {
if (_contracts[to]) {
approveAndCall(to, value, new bytes(0));
} else {
super.transfer(to, value);
}
return true;
}
/**
* @dev Allows to send tokens (via Approve and TransferFrom) to other smart-contract.
* @param spender Address of smart contracts to work with.
* @param amount Amount of tokens to send.
* @param extraData Any extra data.
*/
function approveAndCall(address spender, uint256 amount, bytes memory extraData) public returns (bool) {
require(approve(spender, amount));
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, amount, address(this), extraData);
return true;
}
/**
* @dev Allows to register other smart-contracts (to prevent loss of tokens via transfer function).
* @param account Address of smart contracts to work with.
*/
function registerContract(address account) external onlyOwner {
require(_isContract(account), "Token: account is not a smart-contract");
_contracts[account] = true;
}
/**
* @dev Allows to unregister registered smart-contracts.
* @param account Address of smart contracts to work with.
*/
function unregisterContract(address account) external onlyOwner {
require(isRegistered(account), "Token: account is not registered yet");
_contracts[account] = false;
}
/**
* @dev Allows to any owner of the contract withdraw needed ERC20 token from this contract (for example promo or bounties).
* @param ERC20Token Address of ERC20 token.
* @param recipient Account to receive tokens.
*/
function withdrawERC20(address ERC20Token, address recipient) external onlyOwner {
uint256 amount = IERC20(ERC20Token).balanceOf(address(this));
IERC20(ERC20Token).safeTransfer(recipient, amount);
}
/**
* @return true if the address is registered as contract
* @param account Address to be checked.
*/
function isRegistered(address account) public view returns (bool) {
return _contracts[account];
}
/**
* @return true if `account` is a contract.
* @param account Address to be checked.
*/
function _isContract(address account) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(account) }
return size > 0;
}
} | /**
* @title The main project contract.
*/ | NatSpecMultiLine | withdrawERC20 | function withdrawERC20(address ERC20Token, address recipient) external onlyOwner {
uint256 amount = IERC20(ERC20Token).balanceOf(address(this));
IERC20(ERC20Token).safeTransfer(recipient, amount);
}
| /**
* @dev Allows to any owner of the contract withdraw needed ERC20 token from this contract (for example promo or bounties).
* @param ERC20Token Address of ERC20 token.
* @param recipient Account to receive tokens.
*/ | NatSpecMultiLine | v0.5.12+commit.7709ece9 | MIT | bzzr://b126a478439fdfa7ea8ec601385dfa8d8781044c7ec00f416a2b7f2b179ba8ff | {
"func_code_index": [
2518,
2748
]
} | 8,926 |
HonestCoinToken | HonestCoinToken.sol | 0x1bb8daa79accb27a22b2a3384273bcc53c9a4161 | Solidity | HonestCoinToken | contract HonestCoinToken is ERC20Mintable, ERC20Detailed {
using SafeERC20 for IERC20;
using SafeMath for uint256;
// registered contracts (to prevent loss of token via transfer function)
mapping (address => bool) private _contracts;
constructor(address initialOwner, address recipient) public ERC20Detailed("HonestCoin", "USDH", 6) Ownable(initialOwner) {
// creating of inital supply
uint256 INITIAL_SUPPLY = 88888888e6;
_mint(recipient, INITIAL_SUPPLY);
}
/**
* @dev modified transfer function that allows to safely send tokens to smart-contract.
* @param to The address to transfer to.
* @param value The amount to be transferred.
*/
function transfer(address to, uint256 value) public returns (bool) {
if (_contracts[to]) {
approveAndCall(to, value, new bytes(0));
} else {
super.transfer(to, value);
}
return true;
}
/**
* @dev Allows to send tokens (via Approve and TransferFrom) to other smart-contract.
* @param spender Address of smart contracts to work with.
* @param amount Amount of tokens to send.
* @param extraData Any extra data.
*/
function approveAndCall(address spender, uint256 amount, bytes memory extraData) public returns (bool) {
require(approve(spender, amount));
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, amount, address(this), extraData);
return true;
}
/**
* @dev Allows to register other smart-contracts (to prevent loss of tokens via transfer function).
* @param account Address of smart contracts to work with.
*/
function registerContract(address account) external onlyOwner {
require(_isContract(account), "Token: account is not a smart-contract");
_contracts[account] = true;
}
/**
* @dev Allows to unregister registered smart-contracts.
* @param account Address of smart contracts to work with.
*/
function unregisterContract(address account) external onlyOwner {
require(isRegistered(account), "Token: account is not registered yet");
_contracts[account] = false;
}
/**
* @dev Allows to any owner of the contract withdraw needed ERC20 token from this contract (for example promo or bounties).
* @param ERC20Token Address of ERC20 token.
* @param recipient Account to receive tokens.
*/
function withdrawERC20(address ERC20Token, address recipient) external onlyOwner {
uint256 amount = IERC20(ERC20Token).balanceOf(address(this));
IERC20(ERC20Token).safeTransfer(recipient, amount);
}
/**
* @return true if the address is registered as contract
* @param account Address to be checked.
*/
function isRegistered(address account) public view returns (bool) {
return _contracts[account];
}
/**
* @return true if `account` is a contract.
* @param account Address to be checked.
*/
function _isContract(address account) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(account) }
return size > 0;
}
} | /**
* @title The main project contract.
*/ | NatSpecMultiLine | isRegistered | function isRegistered(address account) public view returns (bool) {
return _contracts[account];
}
| /**
* @return true if the address is registered as contract
* @param account Address to be checked.
*/ | NatSpecMultiLine | v0.5.12+commit.7709ece9 | MIT | bzzr://b126a478439fdfa7ea8ec601385dfa8d8781044c7ec00f416a2b7f2b179ba8ff | {
"func_code_index": [
2877,
2993
]
} | 8,927 |
HonestCoinToken | HonestCoinToken.sol | 0x1bb8daa79accb27a22b2a3384273bcc53c9a4161 | Solidity | HonestCoinToken | contract HonestCoinToken is ERC20Mintable, ERC20Detailed {
using SafeERC20 for IERC20;
using SafeMath for uint256;
// registered contracts (to prevent loss of token via transfer function)
mapping (address => bool) private _contracts;
constructor(address initialOwner, address recipient) public ERC20Detailed("HonestCoin", "USDH", 6) Ownable(initialOwner) {
// creating of inital supply
uint256 INITIAL_SUPPLY = 88888888e6;
_mint(recipient, INITIAL_SUPPLY);
}
/**
* @dev modified transfer function that allows to safely send tokens to smart-contract.
* @param to The address to transfer to.
* @param value The amount to be transferred.
*/
function transfer(address to, uint256 value) public returns (bool) {
if (_contracts[to]) {
approveAndCall(to, value, new bytes(0));
} else {
super.transfer(to, value);
}
return true;
}
/**
* @dev Allows to send tokens (via Approve and TransferFrom) to other smart-contract.
* @param spender Address of smart contracts to work with.
* @param amount Amount of tokens to send.
* @param extraData Any extra data.
*/
function approveAndCall(address spender, uint256 amount, bytes memory extraData) public returns (bool) {
require(approve(spender, amount));
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, amount, address(this), extraData);
return true;
}
/**
* @dev Allows to register other smart-contracts (to prevent loss of tokens via transfer function).
* @param account Address of smart contracts to work with.
*/
function registerContract(address account) external onlyOwner {
require(_isContract(account), "Token: account is not a smart-contract");
_contracts[account] = true;
}
/**
* @dev Allows to unregister registered smart-contracts.
* @param account Address of smart contracts to work with.
*/
function unregisterContract(address account) external onlyOwner {
require(isRegistered(account), "Token: account is not registered yet");
_contracts[account] = false;
}
/**
* @dev Allows to any owner of the contract withdraw needed ERC20 token from this contract (for example promo or bounties).
* @param ERC20Token Address of ERC20 token.
* @param recipient Account to receive tokens.
*/
function withdrawERC20(address ERC20Token, address recipient) external onlyOwner {
uint256 amount = IERC20(ERC20Token).balanceOf(address(this));
IERC20(ERC20Token).safeTransfer(recipient, amount);
}
/**
* @return true if the address is registered as contract
* @param account Address to be checked.
*/
function isRegistered(address account) public view returns (bool) {
return _contracts[account];
}
/**
* @return true if `account` is a contract.
* @param account Address to be checked.
*/
function _isContract(address account) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(account) }
return size > 0;
}
} | /**
* @title The main project contract.
*/ | NatSpecMultiLine | _isContract | function _isContract(address account) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(account) }
return size > 0;
}
| /**
* @return true if `account` is a contract.
* @param account Address to be checked.
*/ | NatSpecMultiLine | v0.5.12+commit.7709ece9 | MIT | bzzr://b126a478439fdfa7ea8ec601385dfa8d8781044c7ec00f416a2b7f2b179ba8ff | {
"func_code_index": [
3109,
3289
]
} | 8,928 |
MarsLocker | contracts/Mars.sol | 0x64200351e787b33cd7c518a93fc24d780092f727 | Solidity | Mars | contract Mars is Ownable, ERC721Enumerable, PaymentSplitter {
using SafeMath for uint256;
uint256 public constant MAX_SUPPLY = 16200;
uint256 public constant RESERVED_SUPPLY = 1305 + 500;
bytes32 private _provenanceHash;
uint256 private _nameChangePrice;
uint256 private _saleStartTimestamp;
uint256 private _revealTimestamp;
uint256 private _startingIndexBlock;
uint256 internal _startingIndex;
uint256 private _numSoldTokens;
uint256 private _numMintedReservedTokens;
mapping (uint256 => string) private _tokenNames;
mapping (string => bool) private _reservedNames;
mapping (uint256 => bool) private _mintedBeforeReveal;
Mars26 private _m26;
MarsStorage private _storage;
event NameChange (uint256 indexed maskIndex, string newName);
/**
* @dev Sets immutable values of contract.
*/
constructor (
bytes32 provenanceHash_,
address m26Address_,
uint256 nameChangePrice_,
uint256 saleStartTimestamp_,
uint256 revealTimestamp_,
address[] memory payees,
uint256[] memory shares_
) ERC721("Mars", "MARS") PaymentSplitter(payees, shares_) {
_provenanceHash = provenanceHash_;
_m26 = Mars26(m26Address_);
_nameChangePrice = nameChangePrice_;
_saleStartTimestamp = saleStartTimestamp_;
_revealTimestamp = revealTimestamp_;
_storage = new MarsStorage(MAX_SUPPLY);
}
/**
* @dev Returns provenance hash digest set during initialization of contract.
*
* The provenance hash is derived by concatenating all existing IPFS CIDs (v0)
* of the Mars NFTs and hashing the concatenated string using SHA2-256.
* Note that the CIDs were concatenated and hashed in their base58 representation.
*/
function provenanceHash() public view returns (bytes32) {
return _provenanceHash;
}
/**
* @dev Returns address of Mars26 ERC-20 token contract.
*/
function m26Address() public view returns (address) {
return address(_m26);
}
/**
* @dev Returns address of connected storage contract.
*/
function storageAddress() public view returns (address) {
return address(_storage);
}
/**
* @dev Returns the number of sold NFTs.
*/
function numSoldTokens() public view returns (uint256) {
return _numSoldTokens;
}
/**
* @dev Returns the MNCT price for changing the name of a token.
*/
function nameChangePrice() public view returns (uint256) {
return _nameChangePrice;
}
/**
* @dev Returns the start timestamp of the initial sale.
*/
function saleStartTimestamp() public view returns (uint256) {
return _saleStartTimestamp;
}
/**
* @dev Returns the reveal timestamp after which the token ids will be assigned.
*/
function revealTimestamp() public view returns (uint256) {
return _revealTimestamp;
}
/**
* @dev Returns the randomized starting index to assign and reveal token ids to
* intial sequence of NFTs.
*/
function startingIndex() public view returns (uint256) {
return _startingIndex;
}
/**
* @dev Returns the randomized starting index block which is used to derive
* {_startingIndex} from.
*/
function startingIndexBlock() public view returns (uint256) {
return _startingIndexBlock;
}
/**
* @dev See {MarsStorage.initialSequenceTokenCID}
*/
function initialSequenceTokenCID(uint256 initialSequenceIndex) public view returns (string memory) {
return _storage.initialSequenceTokenCID(initialSequenceIndex);
}
/**
* @dev Returns if {nameString} has been reserved.
*/
function isNameReserved(string memory nameString) public view returns (bool) {
return _reservedNames[_toLower(nameString)];
}
/**
* @dev Returns reverved name for given token id.
*/
function tokenNames(uint256 tokenId) public view returns (string memory) {
return _tokenNames[tokenId];
}
/**
* @dev Returns the set token URI, i.e. IPFS v0 CID, of {tokenId}.
* Prefixed with ipfs://
*/
function tokenURI(uint256 tokenId) public view override returns (string memory) {
require(_exists(tokenId), "ERC721URIStorage: URI query for nonexistent token");
require(_startingIndex > 0, "Tokens have not been assigned yet");
uint256 initialSequenceIndex = _toInitialSequenceIndex(tokenId);
return tokenURIOfInitialSequenceIndex(initialSequenceIndex);
}
/**
* @dev Returns the set token URI, i.e. IPFS v0 CID, of {initialSequenceIndex}.
* Prefixed with ipfs://
*/
function tokenURIOfInitialSequenceIndex(uint256 initialSequenceIndex) public view returns (string memory) {
require(_startingIndex > 0, "Tokens have not been assigned yet");
string memory tokenCID = initialSequenceTokenCID(initialSequenceIndex);
string memory base = _baseURI();
// If there is no base URI, return the token URI.
if (bytes(base).length == 0) {
return tokenCID;
}
// If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked).
if (bytes(tokenCID).length > 0) {
return string(abi.encodePacked(base, tokenCID));
}
return base;
}
/**
* @dev Returns if the NFT has been minted before reveal phase.
*/
function isMintedBeforeReveal(uint256 index) public view returns (bool) {
return _mintedBeforeReveal[index];
}
/**
* @dev Gets current NFT price based on already sold tokens.
*/
function getNFTPrice() public view returns (uint256) {
if (_numSoldTokens < 800) {
return 0.01 ether;
} else if (_numSoldTokens < 4400) {
return 0.02 ether;
} else if (_numSoldTokens < 8800) {
return 0.03 ether;
} else if (_numSoldTokens < 12600) {
return 0.05 ether;
} else if (_numSoldTokens < 14040) {
return 0.1 ether;
} else if (_numSoldTokens < 14392) {
return 0.3 ether;
} else {
return 1 ether;
}
}
/**
* @dev Mints Mars NFTs
*/
function mint(uint256 numberOfNfts) public payable {
require(block.timestamp >= _saleStartTimestamp, "Sale has not started");
require(totalSupply() < MAX_SUPPLY, "Sale has already ended");
require(numberOfNfts > 0, "Cannot buy 0 NFTs");
require(numberOfNfts <= 20, "You may not buy more than 20 NFTs at once");
require(_numSoldTokens.add(numberOfNfts) <= MAX_SUPPLY.sub(RESERVED_SUPPLY), "Exceeds max number of sellable NFTs");
require(getNFTPrice().mul(numberOfNfts) == msg.value, "Ether value sent is not correct");
for (uint i = 0; i < numberOfNfts; i++) {
uint mintIndex = totalSupply();
_numSoldTokens++;
require(mintIndex < MAX_SUPPLY, "Exceeds max number of NFTs in existence");
if (block.timestamp < _revealTimestamp) {
_mintedBeforeReveal[mintIndex] = true;
}
_safeMint(msg.sender, mintIndex);
}
// Source of randomness. Theoretical miner withhold manipulation possible but should be sufficient in a pragmatic sense
if (_startingIndexBlock == 0 && (_numSoldTokens >= MAX_SUPPLY.sub(RESERVED_SUPPLY) || block.timestamp >= _revealTimestamp)) {
_startingIndexBlock = block.number;
}
}
/**
* @dev Used to migrate already minted NFTs of old contract.
*/
function mintReserved(address to, uint256 numOfNFTs) public onlyOwner {
require(totalSupply().add(numOfNFTs) <= MAX_SUPPLY, "Exceeds max supply of NFTs");
require(_numMintedReservedTokens.add(numOfNFTs) <= RESERVED_SUPPLY, "Exceeds max num of reserved NFTs");
for (uint j = 0; j < numOfNFTs; j++) {
uint tokenId = totalSupply();
if (block.timestamp < _revealTimestamp) {
_mintedBeforeReveal[tokenId] = true;
}
_numMintedReservedTokens++;
_safeMint(to, tokenId);
}
}
/**
* @dev Finalize starting index
*/
function finalizeStartingIndex() public {
require(_startingIndex == 0, "Starting index is already set");
require(_startingIndexBlock != 0, "Starting index block must be set");
_startingIndex = uint(blockhash(_startingIndexBlock)) % MAX_SUPPLY;
// Just a sanity case in the worst case if this function is called late (EVM only stores last 256 block hashes)
if (block.number.sub(_startingIndexBlock) > 255) {
_startingIndex = uint(blockhash(block.number - 1)) % MAX_SUPPLY;
}
// Prevent default sequence
if (_startingIndex == 0) {
_startingIndex = _startingIndex.add(1);
}
}
/**
* @dev Changes the name for Mars tile tokenId
*/
function changeName(uint256 tokenId, string memory newName) public {
address owner = ownerOf(tokenId);
require(_msgSender() == owner, "ERC721: caller is not the owner");
require(_validateName(newName) == true, "Not a valid new name");
require(sha256(bytes(newName)) != sha256(bytes(_tokenNames[tokenId])), "New name is same as the current one");
require(isNameReserved(newName) == false, "Name already reserved");
_m26.transferFrom(msg.sender, address(this), _nameChangePrice);
// If already named, dereserve old name
if (bytes(_tokenNames[tokenId]).length > 0) {
_toggleReserveName(_tokenNames[tokenId], false);
}
_toggleReserveName(newName, true);
_tokenNames[tokenId] = newName;
_m26.burn(_nameChangePrice);
emit NameChange(tokenId, newName);
}
/**
* @dev See {MarsStorage.setInitialSequenceTokenHashes}
*/
function setInitialSequenceTokenHashes(bytes32[] memory tokenHashes) onlyOwner public {
_storage.setInitialSequenceTokenHashes(tokenHashes);
}
/**
* @dev See {MarsStorage.setInitialSequenceTokenHashesAtIndex}
*/
function setInitialSequenceTokenHashesAtIndex(
uint256 startIndex,
bytes32[] memory tokenHashes
) public onlyOwner {
_storage.setInitialSequenceTokenHashesAtIndex(startIndex, tokenHashes);
}
/**
* @dev Check if the name string is valid (Alphanumeric and spaces without leading or trailing space)
*/
function _validateName(string memory str) private pure returns (bool){
bytes memory b = bytes(str);
if (b.length < 1) return false;
if (b.length > 50) return false; // Cannot be longer than 25 characters
if (b[0] == 0x20) return false; // Leading space
if (b[b.length - 1] == 0x20) return false; // Trailing space
bytes1 lastChar = b[0];
for (uint i; i < b.length; i++) {
bytes1 char = b[i];
if (char == 0x20 && lastChar == 0x20) return false; // Cannot contain continous spaces
if (
!(char >= 0x30 && char <= 0x39) && //9-0
!(char >= 0x41 && char <= 0x5A) && //A-Z
!(char >= 0x61 && char <= 0x7A) && //a-z
!(char == 0x20) //space
)
return false;
lastChar = char;
}
return true;
}
/**
* @dev Converts the string to lowercase
*/
function _toLower(string memory str) private pure returns (string memory){
bytes memory bStr = bytes(str);
bytes memory bLower = new bytes(bStr.length);
for (uint i = 0; i < bStr.length; i++) {
// Uppercase character
if ((uint8(bStr[i]) >= 65) && (uint8(bStr[i]) <= 90)) {
bLower[i] = bytes1(uint8(bStr[i]) + 32);
} else {
bLower[i] = bStr[i];
}
}
return string(bLower);
}
/**
* @dev Reserves the name if isReserve is set to true, de-reserves if set to false
*/
function _toggleReserveName(string memory str, bool isReserve) internal {
_reservedNames[_toLower(str)] = isReserve;
}
function _baseURI() internal pure override returns (string memory) {
return "ipfs://";
}
function _toInitialSequenceIndex(uint256 tokenId) internal view returns (uint256) {
return (tokenId + _startingIndex) % MAX_SUPPLY;
}
} | /**
* @title Mars contract
* @dev Extends ERC721 Non-Fungible Token Standard basic implementation
*/ | NatSpecMultiLine | provenanceHash | function provenanceHash() public view returns (bytes32) {
return _provenanceHash;
}
| /**
* @dev Returns provenance hash digest set during initialization of contract.
*
* The provenance hash is derived by concatenating all existing IPFS CIDs (v0)
* of the Mars NFTs and hashing the concatenated string using SHA2-256.
* Note that the CIDs were concatenated and hashed in their base58 representation.
*/ | NatSpecMultiLine | v0.8.3+commit.8d00100c | {
"func_code_index": [
1846,
1945
]
} | 8,929 |
||
MarsLocker | contracts/Mars.sol | 0x64200351e787b33cd7c518a93fc24d780092f727 | Solidity | Mars | contract Mars is Ownable, ERC721Enumerable, PaymentSplitter {
using SafeMath for uint256;
uint256 public constant MAX_SUPPLY = 16200;
uint256 public constant RESERVED_SUPPLY = 1305 + 500;
bytes32 private _provenanceHash;
uint256 private _nameChangePrice;
uint256 private _saleStartTimestamp;
uint256 private _revealTimestamp;
uint256 private _startingIndexBlock;
uint256 internal _startingIndex;
uint256 private _numSoldTokens;
uint256 private _numMintedReservedTokens;
mapping (uint256 => string) private _tokenNames;
mapping (string => bool) private _reservedNames;
mapping (uint256 => bool) private _mintedBeforeReveal;
Mars26 private _m26;
MarsStorage private _storage;
event NameChange (uint256 indexed maskIndex, string newName);
/**
* @dev Sets immutable values of contract.
*/
constructor (
bytes32 provenanceHash_,
address m26Address_,
uint256 nameChangePrice_,
uint256 saleStartTimestamp_,
uint256 revealTimestamp_,
address[] memory payees,
uint256[] memory shares_
) ERC721("Mars", "MARS") PaymentSplitter(payees, shares_) {
_provenanceHash = provenanceHash_;
_m26 = Mars26(m26Address_);
_nameChangePrice = nameChangePrice_;
_saleStartTimestamp = saleStartTimestamp_;
_revealTimestamp = revealTimestamp_;
_storage = new MarsStorage(MAX_SUPPLY);
}
/**
* @dev Returns provenance hash digest set during initialization of contract.
*
* The provenance hash is derived by concatenating all existing IPFS CIDs (v0)
* of the Mars NFTs and hashing the concatenated string using SHA2-256.
* Note that the CIDs were concatenated and hashed in their base58 representation.
*/
function provenanceHash() public view returns (bytes32) {
return _provenanceHash;
}
/**
* @dev Returns address of Mars26 ERC-20 token contract.
*/
function m26Address() public view returns (address) {
return address(_m26);
}
/**
* @dev Returns address of connected storage contract.
*/
function storageAddress() public view returns (address) {
return address(_storage);
}
/**
* @dev Returns the number of sold NFTs.
*/
function numSoldTokens() public view returns (uint256) {
return _numSoldTokens;
}
/**
* @dev Returns the MNCT price for changing the name of a token.
*/
function nameChangePrice() public view returns (uint256) {
return _nameChangePrice;
}
/**
* @dev Returns the start timestamp of the initial sale.
*/
function saleStartTimestamp() public view returns (uint256) {
return _saleStartTimestamp;
}
/**
* @dev Returns the reveal timestamp after which the token ids will be assigned.
*/
function revealTimestamp() public view returns (uint256) {
return _revealTimestamp;
}
/**
* @dev Returns the randomized starting index to assign and reveal token ids to
* intial sequence of NFTs.
*/
function startingIndex() public view returns (uint256) {
return _startingIndex;
}
/**
* @dev Returns the randomized starting index block which is used to derive
* {_startingIndex} from.
*/
function startingIndexBlock() public view returns (uint256) {
return _startingIndexBlock;
}
/**
* @dev See {MarsStorage.initialSequenceTokenCID}
*/
function initialSequenceTokenCID(uint256 initialSequenceIndex) public view returns (string memory) {
return _storage.initialSequenceTokenCID(initialSequenceIndex);
}
/**
* @dev Returns if {nameString} has been reserved.
*/
function isNameReserved(string memory nameString) public view returns (bool) {
return _reservedNames[_toLower(nameString)];
}
/**
* @dev Returns reverved name for given token id.
*/
function tokenNames(uint256 tokenId) public view returns (string memory) {
return _tokenNames[tokenId];
}
/**
* @dev Returns the set token URI, i.e. IPFS v0 CID, of {tokenId}.
* Prefixed with ipfs://
*/
function tokenURI(uint256 tokenId) public view override returns (string memory) {
require(_exists(tokenId), "ERC721URIStorage: URI query for nonexistent token");
require(_startingIndex > 0, "Tokens have not been assigned yet");
uint256 initialSequenceIndex = _toInitialSequenceIndex(tokenId);
return tokenURIOfInitialSequenceIndex(initialSequenceIndex);
}
/**
* @dev Returns the set token URI, i.e. IPFS v0 CID, of {initialSequenceIndex}.
* Prefixed with ipfs://
*/
function tokenURIOfInitialSequenceIndex(uint256 initialSequenceIndex) public view returns (string memory) {
require(_startingIndex > 0, "Tokens have not been assigned yet");
string memory tokenCID = initialSequenceTokenCID(initialSequenceIndex);
string memory base = _baseURI();
// If there is no base URI, return the token URI.
if (bytes(base).length == 0) {
return tokenCID;
}
// If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked).
if (bytes(tokenCID).length > 0) {
return string(abi.encodePacked(base, tokenCID));
}
return base;
}
/**
* @dev Returns if the NFT has been minted before reveal phase.
*/
function isMintedBeforeReveal(uint256 index) public view returns (bool) {
return _mintedBeforeReveal[index];
}
/**
* @dev Gets current NFT price based on already sold tokens.
*/
function getNFTPrice() public view returns (uint256) {
if (_numSoldTokens < 800) {
return 0.01 ether;
} else if (_numSoldTokens < 4400) {
return 0.02 ether;
} else if (_numSoldTokens < 8800) {
return 0.03 ether;
} else if (_numSoldTokens < 12600) {
return 0.05 ether;
} else if (_numSoldTokens < 14040) {
return 0.1 ether;
} else if (_numSoldTokens < 14392) {
return 0.3 ether;
} else {
return 1 ether;
}
}
/**
* @dev Mints Mars NFTs
*/
function mint(uint256 numberOfNfts) public payable {
require(block.timestamp >= _saleStartTimestamp, "Sale has not started");
require(totalSupply() < MAX_SUPPLY, "Sale has already ended");
require(numberOfNfts > 0, "Cannot buy 0 NFTs");
require(numberOfNfts <= 20, "You may not buy more than 20 NFTs at once");
require(_numSoldTokens.add(numberOfNfts) <= MAX_SUPPLY.sub(RESERVED_SUPPLY), "Exceeds max number of sellable NFTs");
require(getNFTPrice().mul(numberOfNfts) == msg.value, "Ether value sent is not correct");
for (uint i = 0; i < numberOfNfts; i++) {
uint mintIndex = totalSupply();
_numSoldTokens++;
require(mintIndex < MAX_SUPPLY, "Exceeds max number of NFTs in existence");
if (block.timestamp < _revealTimestamp) {
_mintedBeforeReveal[mintIndex] = true;
}
_safeMint(msg.sender, mintIndex);
}
// Source of randomness. Theoretical miner withhold manipulation possible but should be sufficient in a pragmatic sense
if (_startingIndexBlock == 0 && (_numSoldTokens >= MAX_SUPPLY.sub(RESERVED_SUPPLY) || block.timestamp >= _revealTimestamp)) {
_startingIndexBlock = block.number;
}
}
/**
* @dev Used to migrate already minted NFTs of old contract.
*/
function mintReserved(address to, uint256 numOfNFTs) public onlyOwner {
require(totalSupply().add(numOfNFTs) <= MAX_SUPPLY, "Exceeds max supply of NFTs");
require(_numMintedReservedTokens.add(numOfNFTs) <= RESERVED_SUPPLY, "Exceeds max num of reserved NFTs");
for (uint j = 0; j < numOfNFTs; j++) {
uint tokenId = totalSupply();
if (block.timestamp < _revealTimestamp) {
_mintedBeforeReveal[tokenId] = true;
}
_numMintedReservedTokens++;
_safeMint(to, tokenId);
}
}
/**
* @dev Finalize starting index
*/
function finalizeStartingIndex() public {
require(_startingIndex == 0, "Starting index is already set");
require(_startingIndexBlock != 0, "Starting index block must be set");
_startingIndex = uint(blockhash(_startingIndexBlock)) % MAX_SUPPLY;
// Just a sanity case in the worst case if this function is called late (EVM only stores last 256 block hashes)
if (block.number.sub(_startingIndexBlock) > 255) {
_startingIndex = uint(blockhash(block.number - 1)) % MAX_SUPPLY;
}
// Prevent default sequence
if (_startingIndex == 0) {
_startingIndex = _startingIndex.add(1);
}
}
/**
* @dev Changes the name for Mars tile tokenId
*/
function changeName(uint256 tokenId, string memory newName) public {
address owner = ownerOf(tokenId);
require(_msgSender() == owner, "ERC721: caller is not the owner");
require(_validateName(newName) == true, "Not a valid new name");
require(sha256(bytes(newName)) != sha256(bytes(_tokenNames[tokenId])), "New name is same as the current one");
require(isNameReserved(newName) == false, "Name already reserved");
_m26.transferFrom(msg.sender, address(this), _nameChangePrice);
// If already named, dereserve old name
if (bytes(_tokenNames[tokenId]).length > 0) {
_toggleReserveName(_tokenNames[tokenId], false);
}
_toggleReserveName(newName, true);
_tokenNames[tokenId] = newName;
_m26.burn(_nameChangePrice);
emit NameChange(tokenId, newName);
}
/**
* @dev See {MarsStorage.setInitialSequenceTokenHashes}
*/
function setInitialSequenceTokenHashes(bytes32[] memory tokenHashes) onlyOwner public {
_storage.setInitialSequenceTokenHashes(tokenHashes);
}
/**
* @dev See {MarsStorage.setInitialSequenceTokenHashesAtIndex}
*/
function setInitialSequenceTokenHashesAtIndex(
uint256 startIndex,
bytes32[] memory tokenHashes
) public onlyOwner {
_storage.setInitialSequenceTokenHashesAtIndex(startIndex, tokenHashes);
}
/**
* @dev Check if the name string is valid (Alphanumeric and spaces without leading or trailing space)
*/
function _validateName(string memory str) private pure returns (bool){
bytes memory b = bytes(str);
if (b.length < 1) return false;
if (b.length > 50) return false; // Cannot be longer than 25 characters
if (b[0] == 0x20) return false; // Leading space
if (b[b.length - 1] == 0x20) return false; // Trailing space
bytes1 lastChar = b[0];
for (uint i; i < b.length; i++) {
bytes1 char = b[i];
if (char == 0x20 && lastChar == 0x20) return false; // Cannot contain continous spaces
if (
!(char >= 0x30 && char <= 0x39) && //9-0
!(char >= 0x41 && char <= 0x5A) && //A-Z
!(char >= 0x61 && char <= 0x7A) && //a-z
!(char == 0x20) //space
)
return false;
lastChar = char;
}
return true;
}
/**
* @dev Converts the string to lowercase
*/
function _toLower(string memory str) private pure returns (string memory){
bytes memory bStr = bytes(str);
bytes memory bLower = new bytes(bStr.length);
for (uint i = 0; i < bStr.length; i++) {
// Uppercase character
if ((uint8(bStr[i]) >= 65) && (uint8(bStr[i]) <= 90)) {
bLower[i] = bytes1(uint8(bStr[i]) + 32);
} else {
bLower[i] = bStr[i];
}
}
return string(bLower);
}
/**
* @dev Reserves the name if isReserve is set to true, de-reserves if set to false
*/
function _toggleReserveName(string memory str, bool isReserve) internal {
_reservedNames[_toLower(str)] = isReserve;
}
function _baseURI() internal pure override returns (string memory) {
return "ipfs://";
}
function _toInitialSequenceIndex(uint256 tokenId) internal view returns (uint256) {
return (tokenId + _startingIndex) % MAX_SUPPLY;
}
} | /**
* @title Mars contract
* @dev Extends ERC721 Non-Fungible Token Standard basic implementation
*/ | NatSpecMultiLine | m26Address | function m26Address() public view returns (address) {
return address(_m26);
}
| /**
* @dev Returns address of Mars26 ERC-20 token contract.
*/ | NatSpecMultiLine | v0.8.3+commit.8d00100c | {
"func_code_index": [
2024,
2117
]
} | 8,930 |
||
MarsLocker | contracts/Mars.sol | 0x64200351e787b33cd7c518a93fc24d780092f727 | Solidity | Mars | contract Mars is Ownable, ERC721Enumerable, PaymentSplitter {
using SafeMath for uint256;
uint256 public constant MAX_SUPPLY = 16200;
uint256 public constant RESERVED_SUPPLY = 1305 + 500;
bytes32 private _provenanceHash;
uint256 private _nameChangePrice;
uint256 private _saleStartTimestamp;
uint256 private _revealTimestamp;
uint256 private _startingIndexBlock;
uint256 internal _startingIndex;
uint256 private _numSoldTokens;
uint256 private _numMintedReservedTokens;
mapping (uint256 => string) private _tokenNames;
mapping (string => bool) private _reservedNames;
mapping (uint256 => bool) private _mintedBeforeReveal;
Mars26 private _m26;
MarsStorage private _storage;
event NameChange (uint256 indexed maskIndex, string newName);
/**
* @dev Sets immutable values of contract.
*/
constructor (
bytes32 provenanceHash_,
address m26Address_,
uint256 nameChangePrice_,
uint256 saleStartTimestamp_,
uint256 revealTimestamp_,
address[] memory payees,
uint256[] memory shares_
) ERC721("Mars", "MARS") PaymentSplitter(payees, shares_) {
_provenanceHash = provenanceHash_;
_m26 = Mars26(m26Address_);
_nameChangePrice = nameChangePrice_;
_saleStartTimestamp = saleStartTimestamp_;
_revealTimestamp = revealTimestamp_;
_storage = new MarsStorage(MAX_SUPPLY);
}
/**
* @dev Returns provenance hash digest set during initialization of contract.
*
* The provenance hash is derived by concatenating all existing IPFS CIDs (v0)
* of the Mars NFTs and hashing the concatenated string using SHA2-256.
* Note that the CIDs were concatenated and hashed in their base58 representation.
*/
function provenanceHash() public view returns (bytes32) {
return _provenanceHash;
}
/**
* @dev Returns address of Mars26 ERC-20 token contract.
*/
function m26Address() public view returns (address) {
return address(_m26);
}
/**
* @dev Returns address of connected storage contract.
*/
function storageAddress() public view returns (address) {
return address(_storage);
}
/**
* @dev Returns the number of sold NFTs.
*/
function numSoldTokens() public view returns (uint256) {
return _numSoldTokens;
}
/**
* @dev Returns the MNCT price for changing the name of a token.
*/
function nameChangePrice() public view returns (uint256) {
return _nameChangePrice;
}
/**
* @dev Returns the start timestamp of the initial sale.
*/
function saleStartTimestamp() public view returns (uint256) {
return _saleStartTimestamp;
}
/**
* @dev Returns the reveal timestamp after which the token ids will be assigned.
*/
function revealTimestamp() public view returns (uint256) {
return _revealTimestamp;
}
/**
* @dev Returns the randomized starting index to assign and reveal token ids to
* intial sequence of NFTs.
*/
function startingIndex() public view returns (uint256) {
return _startingIndex;
}
/**
* @dev Returns the randomized starting index block which is used to derive
* {_startingIndex} from.
*/
function startingIndexBlock() public view returns (uint256) {
return _startingIndexBlock;
}
/**
* @dev See {MarsStorage.initialSequenceTokenCID}
*/
function initialSequenceTokenCID(uint256 initialSequenceIndex) public view returns (string memory) {
return _storage.initialSequenceTokenCID(initialSequenceIndex);
}
/**
* @dev Returns if {nameString} has been reserved.
*/
function isNameReserved(string memory nameString) public view returns (bool) {
return _reservedNames[_toLower(nameString)];
}
/**
* @dev Returns reverved name for given token id.
*/
function tokenNames(uint256 tokenId) public view returns (string memory) {
return _tokenNames[tokenId];
}
/**
* @dev Returns the set token URI, i.e. IPFS v0 CID, of {tokenId}.
* Prefixed with ipfs://
*/
function tokenURI(uint256 tokenId) public view override returns (string memory) {
require(_exists(tokenId), "ERC721URIStorage: URI query for nonexistent token");
require(_startingIndex > 0, "Tokens have not been assigned yet");
uint256 initialSequenceIndex = _toInitialSequenceIndex(tokenId);
return tokenURIOfInitialSequenceIndex(initialSequenceIndex);
}
/**
* @dev Returns the set token URI, i.e. IPFS v0 CID, of {initialSequenceIndex}.
* Prefixed with ipfs://
*/
function tokenURIOfInitialSequenceIndex(uint256 initialSequenceIndex) public view returns (string memory) {
require(_startingIndex > 0, "Tokens have not been assigned yet");
string memory tokenCID = initialSequenceTokenCID(initialSequenceIndex);
string memory base = _baseURI();
// If there is no base URI, return the token URI.
if (bytes(base).length == 0) {
return tokenCID;
}
// If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked).
if (bytes(tokenCID).length > 0) {
return string(abi.encodePacked(base, tokenCID));
}
return base;
}
/**
* @dev Returns if the NFT has been minted before reveal phase.
*/
function isMintedBeforeReveal(uint256 index) public view returns (bool) {
return _mintedBeforeReveal[index];
}
/**
* @dev Gets current NFT price based on already sold tokens.
*/
function getNFTPrice() public view returns (uint256) {
if (_numSoldTokens < 800) {
return 0.01 ether;
} else if (_numSoldTokens < 4400) {
return 0.02 ether;
} else if (_numSoldTokens < 8800) {
return 0.03 ether;
} else if (_numSoldTokens < 12600) {
return 0.05 ether;
} else if (_numSoldTokens < 14040) {
return 0.1 ether;
} else if (_numSoldTokens < 14392) {
return 0.3 ether;
} else {
return 1 ether;
}
}
/**
* @dev Mints Mars NFTs
*/
function mint(uint256 numberOfNfts) public payable {
require(block.timestamp >= _saleStartTimestamp, "Sale has not started");
require(totalSupply() < MAX_SUPPLY, "Sale has already ended");
require(numberOfNfts > 0, "Cannot buy 0 NFTs");
require(numberOfNfts <= 20, "You may not buy more than 20 NFTs at once");
require(_numSoldTokens.add(numberOfNfts) <= MAX_SUPPLY.sub(RESERVED_SUPPLY), "Exceeds max number of sellable NFTs");
require(getNFTPrice().mul(numberOfNfts) == msg.value, "Ether value sent is not correct");
for (uint i = 0; i < numberOfNfts; i++) {
uint mintIndex = totalSupply();
_numSoldTokens++;
require(mintIndex < MAX_SUPPLY, "Exceeds max number of NFTs in existence");
if (block.timestamp < _revealTimestamp) {
_mintedBeforeReveal[mintIndex] = true;
}
_safeMint(msg.sender, mintIndex);
}
// Source of randomness. Theoretical miner withhold manipulation possible but should be sufficient in a pragmatic sense
if (_startingIndexBlock == 0 && (_numSoldTokens >= MAX_SUPPLY.sub(RESERVED_SUPPLY) || block.timestamp >= _revealTimestamp)) {
_startingIndexBlock = block.number;
}
}
/**
* @dev Used to migrate already minted NFTs of old contract.
*/
function mintReserved(address to, uint256 numOfNFTs) public onlyOwner {
require(totalSupply().add(numOfNFTs) <= MAX_SUPPLY, "Exceeds max supply of NFTs");
require(_numMintedReservedTokens.add(numOfNFTs) <= RESERVED_SUPPLY, "Exceeds max num of reserved NFTs");
for (uint j = 0; j < numOfNFTs; j++) {
uint tokenId = totalSupply();
if (block.timestamp < _revealTimestamp) {
_mintedBeforeReveal[tokenId] = true;
}
_numMintedReservedTokens++;
_safeMint(to, tokenId);
}
}
/**
* @dev Finalize starting index
*/
function finalizeStartingIndex() public {
require(_startingIndex == 0, "Starting index is already set");
require(_startingIndexBlock != 0, "Starting index block must be set");
_startingIndex = uint(blockhash(_startingIndexBlock)) % MAX_SUPPLY;
// Just a sanity case in the worst case if this function is called late (EVM only stores last 256 block hashes)
if (block.number.sub(_startingIndexBlock) > 255) {
_startingIndex = uint(blockhash(block.number - 1)) % MAX_SUPPLY;
}
// Prevent default sequence
if (_startingIndex == 0) {
_startingIndex = _startingIndex.add(1);
}
}
/**
* @dev Changes the name for Mars tile tokenId
*/
function changeName(uint256 tokenId, string memory newName) public {
address owner = ownerOf(tokenId);
require(_msgSender() == owner, "ERC721: caller is not the owner");
require(_validateName(newName) == true, "Not a valid new name");
require(sha256(bytes(newName)) != sha256(bytes(_tokenNames[tokenId])), "New name is same as the current one");
require(isNameReserved(newName) == false, "Name already reserved");
_m26.transferFrom(msg.sender, address(this), _nameChangePrice);
// If already named, dereserve old name
if (bytes(_tokenNames[tokenId]).length > 0) {
_toggleReserveName(_tokenNames[tokenId], false);
}
_toggleReserveName(newName, true);
_tokenNames[tokenId] = newName;
_m26.burn(_nameChangePrice);
emit NameChange(tokenId, newName);
}
/**
* @dev See {MarsStorage.setInitialSequenceTokenHashes}
*/
function setInitialSequenceTokenHashes(bytes32[] memory tokenHashes) onlyOwner public {
_storage.setInitialSequenceTokenHashes(tokenHashes);
}
/**
* @dev See {MarsStorage.setInitialSequenceTokenHashesAtIndex}
*/
function setInitialSequenceTokenHashesAtIndex(
uint256 startIndex,
bytes32[] memory tokenHashes
) public onlyOwner {
_storage.setInitialSequenceTokenHashesAtIndex(startIndex, tokenHashes);
}
/**
* @dev Check if the name string is valid (Alphanumeric and spaces without leading or trailing space)
*/
function _validateName(string memory str) private pure returns (bool){
bytes memory b = bytes(str);
if (b.length < 1) return false;
if (b.length > 50) return false; // Cannot be longer than 25 characters
if (b[0] == 0x20) return false; // Leading space
if (b[b.length - 1] == 0x20) return false; // Trailing space
bytes1 lastChar = b[0];
for (uint i; i < b.length; i++) {
bytes1 char = b[i];
if (char == 0x20 && lastChar == 0x20) return false; // Cannot contain continous spaces
if (
!(char >= 0x30 && char <= 0x39) && //9-0
!(char >= 0x41 && char <= 0x5A) && //A-Z
!(char >= 0x61 && char <= 0x7A) && //a-z
!(char == 0x20) //space
)
return false;
lastChar = char;
}
return true;
}
/**
* @dev Converts the string to lowercase
*/
function _toLower(string memory str) private pure returns (string memory){
bytes memory bStr = bytes(str);
bytes memory bLower = new bytes(bStr.length);
for (uint i = 0; i < bStr.length; i++) {
// Uppercase character
if ((uint8(bStr[i]) >= 65) && (uint8(bStr[i]) <= 90)) {
bLower[i] = bytes1(uint8(bStr[i]) + 32);
} else {
bLower[i] = bStr[i];
}
}
return string(bLower);
}
/**
* @dev Reserves the name if isReserve is set to true, de-reserves if set to false
*/
function _toggleReserveName(string memory str, bool isReserve) internal {
_reservedNames[_toLower(str)] = isReserve;
}
function _baseURI() internal pure override returns (string memory) {
return "ipfs://";
}
function _toInitialSequenceIndex(uint256 tokenId) internal view returns (uint256) {
return (tokenId + _startingIndex) % MAX_SUPPLY;
}
} | /**
* @title Mars contract
* @dev Extends ERC721 Non-Fungible Token Standard basic implementation
*/ | NatSpecMultiLine | storageAddress | function storageAddress() public view returns (address) {
return address(_storage);
}
| /**
* @dev Returns address of connected storage contract.
*/ | NatSpecMultiLine | v0.8.3+commit.8d00100c | {
"func_code_index": [
2194,
2295
]
} | 8,931 |
||
MarsLocker | contracts/Mars.sol | 0x64200351e787b33cd7c518a93fc24d780092f727 | Solidity | Mars | contract Mars is Ownable, ERC721Enumerable, PaymentSplitter {
using SafeMath for uint256;
uint256 public constant MAX_SUPPLY = 16200;
uint256 public constant RESERVED_SUPPLY = 1305 + 500;
bytes32 private _provenanceHash;
uint256 private _nameChangePrice;
uint256 private _saleStartTimestamp;
uint256 private _revealTimestamp;
uint256 private _startingIndexBlock;
uint256 internal _startingIndex;
uint256 private _numSoldTokens;
uint256 private _numMintedReservedTokens;
mapping (uint256 => string) private _tokenNames;
mapping (string => bool) private _reservedNames;
mapping (uint256 => bool) private _mintedBeforeReveal;
Mars26 private _m26;
MarsStorage private _storage;
event NameChange (uint256 indexed maskIndex, string newName);
/**
* @dev Sets immutable values of contract.
*/
constructor (
bytes32 provenanceHash_,
address m26Address_,
uint256 nameChangePrice_,
uint256 saleStartTimestamp_,
uint256 revealTimestamp_,
address[] memory payees,
uint256[] memory shares_
) ERC721("Mars", "MARS") PaymentSplitter(payees, shares_) {
_provenanceHash = provenanceHash_;
_m26 = Mars26(m26Address_);
_nameChangePrice = nameChangePrice_;
_saleStartTimestamp = saleStartTimestamp_;
_revealTimestamp = revealTimestamp_;
_storage = new MarsStorage(MAX_SUPPLY);
}
/**
* @dev Returns provenance hash digest set during initialization of contract.
*
* The provenance hash is derived by concatenating all existing IPFS CIDs (v0)
* of the Mars NFTs and hashing the concatenated string using SHA2-256.
* Note that the CIDs were concatenated and hashed in their base58 representation.
*/
function provenanceHash() public view returns (bytes32) {
return _provenanceHash;
}
/**
* @dev Returns address of Mars26 ERC-20 token contract.
*/
function m26Address() public view returns (address) {
return address(_m26);
}
/**
* @dev Returns address of connected storage contract.
*/
function storageAddress() public view returns (address) {
return address(_storage);
}
/**
* @dev Returns the number of sold NFTs.
*/
function numSoldTokens() public view returns (uint256) {
return _numSoldTokens;
}
/**
* @dev Returns the MNCT price for changing the name of a token.
*/
function nameChangePrice() public view returns (uint256) {
return _nameChangePrice;
}
/**
* @dev Returns the start timestamp of the initial sale.
*/
function saleStartTimestamp() public view returns (uint256) {
return _saleStartTimestamp;
}
/**
* @dev Returns the reveal timestamp after which the token ids will be assigned.
*/
function revealTimestamp() public view returns (uint256) {
return _revealTimestamp;
}
/**
* @dev Returns the randomized starting index to assign and reveal token ids to
* intial sequence of NFTs.
*/
function startingIndex() public view returns (uint256) {
return _startingIndex;
}
/**
* @dev Returns the randomized starting index block which is used to derive
* {_startingIndex} from.
*/
function startingIndexBlock() public view returns (uint256) {
return _startingIndexBlock;
}
/**
* @dev See {MarsStorage.initialSequenceTokenCID}
*/
function initialSequenceTokenCID(uint256 initialSequenceIndex) public view returns (string memory) {
return _storage.initialSequenceTokenCID(initialSequenceIndex);
}
/**
* @dev Returns if {nameString} has been reserved.
*/
function isNameReserved(string memory nameString) public view returns (bool) {
return _reservedNames[_toLower(nameString)];
}
/**
* @dev Returns reverved name for given token id.
*/
function tokenNames(uint256 tokenId) public view returns (string memory) {
return _tokenNames[tokenId];
}
/**
* @dev Returns the set token URI, i.e. IPFS v0 CID, of {tokenId}.
* Prefixed with ipfs://
*/
function tokenURI(uint256 tokenId) public view override returns (string memory) {
require(_exists(tokenId), "ERC721URIStorage: URI query for nonexistent token");
require(_startingIndex > 0, "Tokens have not been assigned yet");
uint256 initialSequenceIndex = _toInitialSequenceIndex(tokenId);
return tokenURIOfInitialSequenceIndex(initialSequenceIndex);
}
/**
* @dev Returns the set token URI, i.e. IPFS v0 CID, of {initialSequenceIndex}.
* Prefixed with ipfs://
*/
function tokenURIOfInitialSequenceIndex(uint256 initialSequenceIndex) public view returns (string memory) {
require(_startingIndex > 0, "Tokens have not been assigned yet");
string memory tokenCID = initialSequenceTokenCID(initialSequenceIndex);
string memory base = _baseURI();
// If there is no base URI, return the token URI.
if (bytes(base).length == 0) {
return tokenCID;
}
// If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked).
if (bytes(tokenCID).length > 0) {
return string(abi.encodePacked(base, tokenCID));
}
return base;
}
/**
* @dev Returns if the NFT has been minted before reveal phase.
*/
function isMintedBeforeReveal(uint256 index) public view returns (bool) {
return _mintedBeforeReveal[index];
}
/**
* @dev Gets current NFT price based on already sold tokens.
*/
function getNFTPrice() public view returns (uint256) {
if (_numSoldTokens < 800) {
return 0.01 ether;
} else if (_numSoldTokens < 4400) {
return 0.02 ether;
} else if (_numSoldTokens < 8800) {
return 0.03 ether;
} else if (_numSoldTokens < 12600) {
return 0.05 ether;
} else if (_numSoldTokens < 14040) {
return 0.1 ether;
} else if (_numSoldTokens < 14392) {
return 0.3 ether;
} else {
return 1 ether;
}
}
/**
* @dev Mints Mars NFTs
*/
function mint(uint256 numberOfNfts) public payable {
require(block.timestamp >= _saleStartTimestamp, "Sale has not started");
require(totalSupply() < MAX_SUPPLY, "Sale has already ended");
require(numberOfNfts > 0, "Cannot buy 0 NFTs");
require(numberOfNfts <= 20, "You may not buy more than 20 NFTs at once");
require(_numSoldTokens.add(numberOfNfts) <= MAX_SUPPLY.sub(RESERVED_SUPPLY), "Exceeds max number of sellable NFTs");
require(getNFTPrice().mul(numberOfNfts) == msg.value, "Ether value sent is not correct");
for (uint i = 0; i < numberOfNfts; i++) {
uint mintIndex = totalSupply();
_numSoldTokens++;
require(mintIndex < MAX_SUPPLY, "Exceeds max number of NFTs in existence");
if (block.timestamp < _revealTimestamp) {
_mintedBeforeReveal[mintIndex] = true;
}
_safeMint(msg.sender, mintIndex);
}
// Source of randomness. Theoretical miner withhold manipulation possible but should be sufficient in a pragmatic sense
if (_startingIndexBlock == 0 && (_numSoldTokens >= MAX_SUPPLY.sub(RESERVED_SUPPLY) || block.timestamp >= _revealTimestamp)) {
_startingIndexBlock = block.number;
}
}
/**
* @dev Used to migrate already minted NFTs of old contract.
*/
function mintReserved(address to, uint256 numOfNFTs) public onlyOwner {
require(totalSupply().add(numOfNFTs) <= MAX_SUPPLY, "Exceeds max supply of NFTs");
require(_numMintedReservedTokens.add(numOfNFTs) <= RESERVED_SUPPLY, "Exceeds max num of reserved NFTs");
for (uint j = 0; j < numOfNFTs; j++) {
uint tokenId = totalSupply();
if (block.timestamp < _revealTimestamp) {
_mintedBeforeReveal[tokenId] = true;
}
_numMintedReservedTokens++;
_safeMint(to, tokenId);
}
}
/**
* @dev Finalize starting index
*/
function finalizeStartingIndex() public {
require(_startingIndex == 0, "Starting index is already set");
require(_startingIndexBlock != 0, "Starting index block must be set");
_startingIndex = uint(blockhash(_startingIndexBlock)) % MAX_SUPPLY;
// Just a sanity case in the worst case if this function is called late (EVM only stores last 256 block hashes)
if (block.number.sub(_startingIndexBlock) > 255) {
_startingIndex = uint(blockhash(block.number - 1)) % MAX_SUPPLY;
}
// Prevent default sequence
if (_startingIndex == 0) {
_startingIndex = _startingIndex.add(1);
}
}
/**
* @dev Changes the name for Mars tile tokenId
*/
function changeName(uint256 tokenId, string memory newName) public {
address owner = ownerOf(tokenId);
require(_msgSender() == owner, "ERC721: caller is not the owner");
require(_validateName(newName) == true, "Not a valid new name");
require(sha256(bytes(newName)) != sha256(bytes(_tokenNames[tokenId])), "New name is same as the current one");
require(isNameReserved(newName) == false, "Name already reserved");
_m26.transferFrom(msg.sender, address(this), _nameChangePrice);
// If already named, dereserve old name
if (bytes(_tokenNames[tokenId]).length > 0) {
_toggleReserveName(_tokenNames[tokenId], false);
}
_toggleReserveName(newName, true);
_tokenNames[tokenId] = newName;
_m26.burn(_nameChangePrice);
emit NameChange(tokenId, newName);
}
/**
* @dev See {MarsStorage.setInitialSequenceTokenHashes}
*/
function setInitialSequenceTokenHashes(bytes32[] memory tokenHashes) onlyOwner public {
_storage.setInitialSequenceTokenHashes(tokenHashes);
}
/**
* @dev See {MarsStorage.setInitialSequenceTokenHashesAtIndex}
*/
function setInitialSequenceTokenHashesAtIndex(
uint256 startIndex,
bytes32[] memory tokenHashes
) public onlyOwner {
_storage.setInitialSequenceTokenHashesAtIndex(startIndex, tokenHashes);
}
/**
* @dev Check if the name string is valid (Alphanumeric and spaces without leading or trailing space)
*/
function _validateName(string memory str) private pure returns (bool){
bytes memory b = bytes(str);
if (b.length < 1) return false;
if (b.length > 50) return false; // Cannot be longer than 25 characters
if (b[0] == 0x20) return false; // Leading space
if (b[b.length - 1] == 0x20) return false; // Trailing space
bytes1 lastChar = b[0];
for (uint i; i < b.length; i++) {
bytes1 char = b[i];
if (char == 0x20 && lastChar == 0x20) return false; // Cannot contain continous spaces
if (
!(char >= 0x30 && char <= 0x39) && //9-0
!(char >= 0x41 && char <= 0x5A) && //A-Z
!(char >= 0x61 && char <= 0x7A) && //a-z
!(char == 0x20) //space
)
return false;
lastChar = char;
}
return true;
}
/**
* @dev Converts the string to lowercase
*/
function _toLower(string memory str) private pure returns (string memory){
bytes memory bStr = bytes(str);
bytes memory bLower = new bytes(bStr.length);
for (uint i = 0; i < bStr.length; i++) {
// Uppercase character
if ((uint8(bStr[i]) >= 65) && (uint8(bStr[i]) <= 90)) {
bLower[i] = bytes1(uint8(bStr[i]) + 32);
} else {
bLower[i] = bStr[i];
}
}
return string(bLower);
}
/**
* @dev Reserves the name if isReserve is set to true, de-reserves if set to false
*/
function _toggleReserveName(string memory str, bool isReserve) internal {
_reservedNames[_toLower(str)] = isReserve;
}
function _baseURI() internal pure override returns (string memory) {
return "ipfs://";
}
function _toInitialSequenceIndex(uint256 tokenId) internal view returns (uint256) {
return (tokenId + _startingIndex) % MAX_SUPPLY;
}
} | /**
* @title Mars contract
* @dev Extends ERC721 Non-Fungible Token Standard basic implementation
*/ | NatSpecMultiLine | numSoldTokens | function numSoldTokens() public view returns (uint256) {
return _numSoldTokens;
}
| /**
* @dev Returns the number of sold NFTs.
*/ | NatSpecMultiLine | v0.8.3+commit.8d00100c | {
"func_code_index": [
2359,
2456
]
} | 8,932 |
||
MarsLocker | contracts/Mars.sol | 0x64200351e787b33cd7c518a93fc24d780092f727 | Solidity | Mars | contract Mars is Ownable, ERC721Enumerable, PaymentSplitter {
using SafeMath for uint256;
uint256 public constant MAX_SUPPLY = 16200;
uint256 public constant RESERVED_SUPPLY = 1305 + 500;
bytes32 private _provenanceHash;
uint256 private _nameChangePrice;
uint256 private _saleStartTimestamp;
uint256 private _revealTimestamp;
uint256 private _startingIndexBlock;
uint256 internal _startingIndex;
uint256 private _numSoldTokens;
uint256 private _numMintedReservedTokens;
mapping (uint256 => string) private _tokenNames;
mapping (string => bool) private _reservedNames;
mapping (uint256 => bool) private _mintedBeforeReveal;
Mars26 private _m26;
MarsStorage private _storage;
event NameChange (uint256 indexed maskIndex, string newName);
/**
* @dev Sets immutable values of contract.
*/
constructor (
bytes32 provenanceHash_,
address m26Address_,
uint256 nameChangePrice_,
uint256 saleStartTimestamp_,
uint256 revealTimestamp_,
address[] memory payees,
uint256[] memory shares_
) ERC721("Mars", "MARS") PaymentSplitter(payees, shares_) {
_provenanceHash = provenanceHash_;
_m26 = Mars26(m26Address_);
_nameChangePrice = nameChangePrice_;
_saleStartTimestamp = saleStartTimestamp_;
_revealTimestamp = revealTimestamp_;
_storage = new MarsStorage(MAX_SUPPLY);
}
/**
* @dev Returns provenance hash digest set during initialization of contract.
*
* The provenance hash is derived by concatenating all existing IPFS CIDs (v0)
* of the Mars NFTs and hashing the concatenated string using SHA2-256.
* Note that the CIDs were concatenated and hashed in their base58 representation.
*/
function provenanceHash() public view returns (bytes32) {
return _provenanceHash;
}
/**
* @dev Returns address of Mars26 ERC-20 token contract.
*/
function m26Address() public view returns (address) {
return address(_m26);
}
/**
* @dev Returns address of connected storage contract.
*/
function storageAddress() public view returns (address) {
return address(_storage);
}
/**
* @dev Returns the number of sold NFTs.
*/
function numSoldTokens() public view returns (uint256) {
return _numSoldTokens;
}
/**
* @dev Returns the MNCT price for changing the name of a token.
*/
function nameChangePrice() public view returns (uint256) {
return _nameChangePrice;
}
/**
* @dev Returns the start timestamp of the initial sale.
*/
function saleStartTimestamp() public view returns (uint256) {
return _saleStartTimestamp;
}
/**
* @dev Returns the reveal timestamp after which the token ids will be assigned.
*/
function revealTimestamp() public view returns (uint256) {
return _revealTimestamp;
}
/**
* @dev Returns the randomized starting index to assign and reveal token ids to
* intial sequence of NFTs.
*/
function startingIndex() public view returns (uint256) {
return _startingIndex;
}
/**
* @dev Returns the randomized starting index block which is used to derive
* {_startingIndex} from.
*/
function startingIndexBlock() public view returns (uint256) {
return _startingIndexBlock;
}
/**
* @dev See {MarsStorage.initialSequenceTokenCID}
*/
function initialSequenceTokenCID(uint256 initialSequenceIndex) public view returns (string memory) {
return _storage.initialSequenceTokenCID(initialSequenceIndex);
}
/**
* @dev Returns if {nameString} has been reserved.
*/
function isNameReserved(string memory nameString) public view returns (bool) {
return _reservedNames[_toLower(nameString)];
}
/**
* @dev Returns reverved name for given token id.
*/
function tokenNames(uint256 tokenId) public view returns (string memory) {
return _tokenNames[tokenId];
}
/**
* @dev Returns the set token URI, i.e. IPFS v0 CID, of {tokenId}.
* Prefixed with ipfs://
*/
function tokenURI(uint256 tokenId) public view override returns (string memory) {
require(_exists(tokenId), "ERC721URIStorage: URI query for nonexistent token");
require(_startingIndex > 0, "Tokens have not been assigned yet");
uint256 initialSequenceIndex = _toInitialSequenceIndex(tokenId);
return tokenURIOfInitialSequenceIndex(initialSequenceIndex);
}
/**
* @dev Returns the set token URI, i.e. IPFS v0 CID, of {initialSequenceIndex}.
* Prefixed with ipfs://
*/
function tokenURIOfInitialSequenceIndex(uint256 initialSequenceIndex) public view returns (string memory) {
require(_startingIndex > 0, "Tokens have not been assigned yet");
string memory tokenCID = initialSequenceTokenCID(initialSequenceIndex);
string memory base = _baseURI();
// If there is no base URI, return the token URI.
if (bytes(base).length == 0) {
return tokenCID;
}
// If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked).
if (bytes(tokenCID).length > 0) {
return string(abi.encodePacked(base, tokenCID));
}
return base;
}
/**
* @dev Returns if the NFT has been minted before reveal phase.
*/
function isMintedBeforeReveal(uint256 index) public view returns (bool) {
return _mintedBeforeReveal[index];
}
/**
* @dev Gets current NFT price based on already sold tokens.
*/
function getNFTPrice() public view returns (uint256) {
if (_numSoldTokens < 800) {
return 0.01 ether;
} else if (_numSoldTokens < 4400) {
return 0.02 ether;
} else if (_numSoldTokens < 8800) {
return 0.03 ether;
} else if (_numSoldTokens < 12600) {
return 0.05 ether;
} else if (_numSoldTokens < 14040) {
return 0.1 ether;
} else if (_numSoldTokens < 14392) {
return 0.3 ether;
} else {
return 1 ether;
}
}
/**
* @dev Mints Mars NFTs
*/
function mint(uint256 numberOfNfts) public payable {
require(block.timestamp >= _saleStartTimestamp, "Sale has not started");
require(totalSupply() < MAX_SUPPLY, "Sale has already ended");
require(numberOfNfts > 0, "Cannot buy 0 NFTs");
require(numberOfNfts <= 20, "You may not buy more than 20 NFTs at once");
require(_numSoldTokens.add(numberOfNfts) <= MAX_SUPPLY.sub(RESERVED_SUPPLY), "Exceeds max number of sellable NFTs");
require(getNFTPrice().mul(numberOfNfts) == msg.value, "Ether value sent is not correct");
for (uint i = 0; i < numberOfNfts; i++) {
uint mintIndex = totalSupply();
_numSoldTokens++;
require(mintIndex < MAX_SUPPLY, "Exceeds max number of NFTs in existence");
if (block.timestamp < _revealTimestamp) {
_mintedBeforeReveal[mintIndex] = true;
}
_safeMint(msg.sender, mintIndex);
}
// Source of randomness. Theoretical miner withhold manipulation possible but should be sufficient in a pragmatic sense
if (_startingIndexBlock == 0 && (_numSoldTokens >= MAX_SUPPLY.sub(RESERVED_SUPPLY) || block.timestamp >= _revealTimestamp)) {
_startingIndexBlock = block.number;
}
}
/**
* @dev Used to migrate already minted NFTs of old contract.
*/
function mintReserved(address to, uint256 numOfNFTs) public onlyOwner {
require(totalSupply().add(numOfNFTs) <= MAX_SUPPLY, "Exceeds max supply of NFTs");
require(_numMintedReservedTokens.add(numOfNFTs) <= RESERVED_SUPPLY, "Exceeds max num of reserved NFTs");
for (uint j = 0; j < numOfNFTs; j++) {
uint tokenId = totalSupply();
if (block.timestamp < _revealTimestamp) {
_mintedBeforeReveal[tokenId] = true;
}
_numMintedReservedTokens++;
_safeMint(to, tokenId);
}
}
/**
* @dev Finalize starting index
*/
function finalizeStartingIndex() public {
require(_startingIndex == 0, "Starting index is already set");
require(_startingIndexBlock != 0, "Starting index block must be set");
_startingIndex = uint(blockhash(_startingIndexBlock)) % MAX_SUPPLY;
// Just a sanity case in the worst case if this function is called late (EVM only stores last 256 block hashes)
if (block.number.sub(_startingIndexBlock) > 255) {
_startingIndex = uint(blockhash(block.number - 1)) % MAX_SUPPLY;
}
// Prevent default sequence
if (_startingIndex == 0) {
_startingIndex = _startingIndex.add(1);
}
}
/**
* @dev Changes the name for Mars tile tokenId
*/
function changeName(uint256 tokenId, string memory newName) public {
address owner = ownerOf(tokenId);
require(_msgSender() == owner, "ERC721: caller is not the owner");
require(_validateName(newName) == true, "Not a valid new name");
require(sha256(bytes(newName)) != sha256(bytes(_tokenNames[tokenId])), "New name is same as the current one");
require(isNameReserved(newName) == false, "Name already reserved");
_m26.transferFrom(msg.sender, address(this), _nameChangePrice);
// If already named, dereserve old name
if (bytes(_tokenNames[tokenId]).length > 0) {
_toggleReserveName(_tokenNames[tokenId], false);
}
_toggleReserveName(newName, true);
_tokenNames[tokenId] = newName;
_m26.burn(_nameChangePrice);
emit NameChange(tokenId, newName);
}
/**
* @dev See {MarsStorage.setInitialSequenceTokenHashes}
*/
function setInitialSequenceTokenHashes(bytes32[] memory tokenHashes) onlyOwner public {
_storage.setInitialSequenceTokenHashes(tokenHashes);
}
/**
* @dev See {MarsStorage.setInitialSequenceTokenHashesAtIndex}
*/
function setInitialSequenceTokenHashesAtIndex(
uint256 startIndex,
bytes32[] memory tokenHashes
) public onlyOwner {
_storage.setInitialSequenceTokenHashesAtIndex(startIndex, tokenHashes);
}
/**
* @dev Check if the name string is valid (Alphanumeric and spaces without leading or trailing space)
*/
function _validateName(string memory str) private pure returns (bool){
bytes memory b = bytes(str);
if (b.length < 1) return false;
if (b.length > 50) return false; // Cannot be longer than 25 characters
if (b[0] == 0x20) return false; // Leading space
if (b[b.length - 1] == 0x20) return false; // Trailing space
bytes1 lastChar = b[0];
for (uint i; i < b.length; i++) {
bytes1 char = b[i];
if (char == 0x20 && lastChar == 0x20) return false; // Cannot contain continous spaces
if (
!(char >= 0x30 && char <= 0x39) && //9-0
!(char >= 0x41 && char <= 0x5A) && //A-Z
!(char >= 0x61 && char <= 0x7A) && //a-z
!(char == 0x20) //space
)
return false;
lastChar = char;
}
return true;
}
/**
* @dev Converts the string to lowercase
*/
function _toLower(string memory str) private pure returns (string memory){
bytes memory bStr = bytes(str);
bytes memory bLower = new bytes(bStr.length);
for (uint i = 0; i < bStr.length; i++) {
// Uppercase character
if ((uint8(bStr[i]) >= 65) && (uint8(bStr[i]) <= 90)) {
bLower[i] = bytes1(uint8(bStr[i]) + 32);
} else {
bLower[i] = bStr[i];
}
}
return string(bLower);
}
/**
* @dev Reserves the name if isReserve is set to true, de-reserves if set to false
*/
function _toggleReserveName(string memory str, bool isReserve) internal {
_reservedNames[_toLower(str)] = isReserve;
}
function _baseURI() internal pure override returns (string memory) {
return "ipfs://";
}
function _toInitialSequenceIndex(uint256 tokenId) internal view returns (uint256) {
return (tokenId + _startingIndex) % MAX_SUPPLY;
}
} | /**
* @title Mars contract
* @dev Extends ERC721 Non-Fungible Token Standard basic implementation
*/ | NatSpecMultiLine | nameChangePrice | function nameChangePrice() public view returns (uint256) {
return _nameChangePrice;
}
| /**
* @dev Returns the MNCT price for changing the name of a token.
*/ | NatSpecMultiLine | v0.8.3+commit.8d00100c | {
"func_code_index": [
2543,
2644
]
} | 8,933 |
||
MarsLocker | contracts/Mars.sol | 0x64200351e787b33cd7c518a93fc24d780092f727 | Solidity | Mars | contract Mars is Ownable, ERC721Enumerable, PaymentSplitter {
using SafeMath for uint256;
uint256 public constant MAX_SUPPLY = 16200;
uint256 public constant RESERVED_SUPPLY = 1305 + 500;
bytes32 private _provenanceHash;
uint256 private _nameChangePrice;
uint256 private _saleStartTimestamp;
uint256 private _revealTimestamp;
uint256 private _startingIndexBlock;
uint256 internal _startingIndex;
uint256 private _numSoldTokens;
uint256 private _numMintedReservedTokens;
mapping (uint256 => string) private _tokenNames;
mapping (string => bool) private _reservedNames;
mapping (uint256 => bool) private _mintedBeforeReveal;
Mars26 private _m26;
MarsStorage private _storage;
event NameChange (uint256 indexed maskIndex, string newName);
/**
* @dev Sets immutable values of contract.
*/
constructor (
bytes32 provenanceHash_,
address m26Address_,
uint256 nameChangePrice_,
uint256 saleStartTimestamp_,
uint256 revealTimestamp_,
address[] memory payees,
uint256[] memory shares_
) ERC721("Mars", "MARS") PaymentSplitter(payees, shares_) {
_provenanceHash = provenanceHash_;
_m26 = Mars26(m26Address_);
_nameChangePrice = nameChangePrice_;
_saleStartTimestamp = saleStartTimestamp_;
_revealTimestamp = revealTimestamp_;
_storage = new MarsStorage(MAX_SUPPLY);
}
/**
* @dev Returns provenance hash digest set during initialization of contract.
*
* The provenance hash is derived by concatenating all existing IPFS CIDs (v0)
* of the Mars NFTs and hashing the concatenated string using SHA2-256.
* Note that the CIDs were concatenated and hashed in their base58 representation.
*/
function provenanceHash() public view returns (bytes32) {
return _provenanceHash;
}
/**
* @dev Returns address of Mars26 ERC-20 token contract.
*/
function m26Address() public view returns (address) {
return address(_m26);
}
/**
* @dev Returns address of connected storage contract.
*/
function storageAddress() public view returns (address) {
return address(_storage);
}
/**
* @dev Returns the number of sold NFTs.
*/
function numSoldTokens() public view returns (uint256) {
return _numSoldTokens;
}
/**
* @dev Returns the MNCT price for changing the name of a token.
*/
function nameChangePrice() public view returns (uint256) {
return _nameChangePrice;
}
/**
* @dev Returns the start timestamp of the initial sale.
*/
function saleStartTimestamp() public view returns (uint256) {
return _saleStartTimestamp;
}
/**
* @dev Returns the reveal timestamp after which the token ids will be assigned.
*/
function revealTimestamp() public view returns (uint256) {
return _revealTimestamp;
}
/**
* @dev Returns the randomized starting index to assign and reveal token ids to
* intial sequence of NFTs.
*/
function startingIndex() public view returns (uint256) {
return _startingIndex;
}
/**
* @dev Returns the randomized starting index block which is used to derive
* {_startingIndex} from.
*/
function startingIndexBlock() public view returns (uint256) {
return _startingIndexBlock;
}
/**
* @dev See {MarsStorage.initialSequenceTokenCID}
*/
function initialSequenceTokenCID(uint256 initialSequenceIndex) public view returns (string memory) {
return _storage.initialSequenceTokenCID(initialSequenceIndex);
}
/**
* @dev Returns if {nameString} has been reserved.
*/
function isNameReserved(string memory nameString) public view returns (bool) {
return _reservedNames[_toLower(nameString)];
}
/**
* @dev Returns reverved name for given token id.
*/
function tokenNames(uint256 tokenId) public view returns (string memory) {
return _tokenNames[tokenId];
}
/**
* @dev Returns the set token URI, i.e. IPFS v0 CID, of {tokenId}.
* Prefixed with ipfs://
*/
function tokenURI(uint256 tokenId) public view override returns (string memory) {
require(_exists(tokenId), "ERC721URIStorage: URI query for nonexistent token");
require(_startingIndex > 0, "Tokens have not been assigned yet");
uint256 initialSequenceIndex = _toInitialSequenceIndex(tokenId);
return tokenURIOfInitialSequenceIndex(initialSequenceIndex);
}
/**
* @dev Returns the set token URI, i.e. IPFS v0 CID, of {initialSequenceIndex}.
* Prefixed with ipfs://
*/
function tokenURIOfInitialSequenceIndex(uint256 initialSequenceIndex) public view returns (string memory) {
require(_startingIndex > 0, "Tokens have not been assigned yet");
string memory tokenCID = initialSequenceTokenCID(initialSequenceIndex);
string memory base = _baseURI();
// If there is no base URI, return the token URI.
if (bytes(base).length == 0) {
return tokenCID;
}
// If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked).
if (bytes(tokenCID).length > 0) {
return string(abi.encodePacked(base, tokenCID));
}
return base;
}
/**
* @dev Returns if the NFT has been minted before reveal phase.
*/
function isMintedBeforeReveal(uint256 index) public view returns (bool) {
return _mintedBeforeReveal[index];
}
/**
* @dev Gets current NFT price based on already sold tokens.
*/
function getNFTPrice() public view returns (uint256) {
if (_numSoldTokens < 800) {
return 0.01 ether;
} else if (_numSoldTokens < 4400) {
return 0.02 ether;
} else if (_numSoldTokens < 8800) {
return 0.03 ether;
} else if (_numSoldTokens < 12600) {
return 0.05 ether;
} else if (_numSoldTokens < 14040) {
return 0.1 ether;
} else if (_numSoldTokens < 14392) {
return 0.3 ether;
} else {
return 1 ether;
}
}
/**
* @dev Mints Mars NFTs
*/
function mint(uint256 numberOfNfts) public payable {
require(block.timestamp >= _saleStartTimestamp, "Sale has not started");
require(totalSupply() < MAX_SUPPLY, "Sale has already ended");
require(numberOfNfts > 0, "Cannot buy 0 NFTs");
require(numberOfNfts <= 20, "You may not buy more than 20 NFTs at once");
require(_numSoldTokens.add(numberOfNfts) <= MAX_SUPPLY.sub(RESERVED_SUPPLY), "Exceeds max number of sellable NFTs");
require(getNFTPrice().mul(numberOfNfts) == msg.value, "Ether value sent is not correct");
for (uint i = 0; i < numberOfNfts; i++) {
uint mintIndex = totalSupply();
_numSoldTokens++;
require(mintIndex < MAX_SUPPLY, "Exceeds max number of NFTs in existence");
if (block.timestamp < _revealTimestamp) {
_mintedBeforeReveal[mintIndex] = true;
}
_safeMint(msg.sender, mintIndex);
}
// Source of randomness. Theoretical miner withhold manipulation possible but should be sufficient in a pragmatic sense
if (_startingIndexBlock == 0 && (_numSoldTokens >= MAX_SUPPLY.sub(RESERVED_SUPPLY) || block.timestamp >= _revealTimestamp)) {
_startingIndexBlock = block.number;
}
}
/**
* @dev Used to migrate already minted NFTs of old contract.
*/
function mintReserved(address to, uint256 numOfNFTs) public onlyOwner {
require(totalSupply().add(numOfNFTs) <= MAX_SUPPLY, "Exceeds max supply of NFTs");
require(_numMintedReservedTokens.add(numOfNFTs) <= RESERVED_SUPPLY, "Exceeds max num of reserved NFTs");
for (uint j = 0; j < numOfNFTs; j++) {
uint tokenId = totalSupply();
if (block.timestamp < _revealTimestamp) {
_mintedBeforeReveal[tokenId] = true;
}
_numMintedReservedTokens++;
_safeMint(to, tokenId);
}
}
/**
* @dev Finalize starting index
*/
function finalizeStartingIndex() public {
require(_startingIndex == 0, "Starting index is already set");
require(_startingIndexBlock != 0, "Starting index block must be set");
_startingIndex = uint(blockhash(_startingIndexBlock)) % MAX_SUPPLY;
// Just a sanity case in the worst case if this function is called late (EVM only stores last 256 block hashes)
if (block.number.sub(_startingIndexBlock) > 255) {
_startingIndex = uint(blockhash(block.number - 1)) % MAX_SUPPLY;
}
// Prevent default sequence
if (_startingIndex == 0) {
_startingIndex = _startingIndex.add(1);
}
}
/**
* @dev Changes the name for Mars tile tokenId
*/
function changeName(uint256 tokenId, string memory newName) public {
address owner = ownerOf(tokenId);
require(_msgSender() == owner, "ERC721: caller is not the owner");
require(_validateName(newName) == true, "Not a valid new name");
require(sha256(bytes(newName)) != sha256(bytes(_tokenNames[tokenId])), "New name is same as the current one");
require(isNameReserved(newName) == false, "Name already reserved");
_m26.transferFrom(msg.sender, address(this), _nameChangePrice);
// If already named, dereserve old name
if (bytes(_tokenNames[tokenId]).length > 0) {
_toggleReserveName(_tokenNames[tokenId], false);
}
_toggleReserveName(newName, true);
_tokenNames[tokenId] = newName;
_m26.burn(_nameChangePrice);
emit NameChange(tokenId, newName);
}
/**
* @dev See {MarsStorage.setInitialSequenceTokenHashes}
*/
function setInitialSequenceTokenHashes(bytes32[] memory tokenHashes) onlyOwner public {
_storage.setInitialSequenceTokenHashes(tokenHashes);
}
/**
* @dev See {MarsStorage.setInitialSequenceTokenHashesAtIndex}
*/
function setInitialSequenceTokenHashesAtIndex(
uint256 startIndex,
bytes32[] memory tokenHashes
) public onlyOwner {
_storage.setInitialSequenceTokenHashesAtIndex(startIndex, tokenHashes);
}
/**
* @dev Check if the name string is valid (Alphanumeric and spaces without leading or trailing space)
*/
function _validateName(string memory str) private pure returns (bool){
bytes memory b = bytes(str);
if (b.length < 1) return false;
if (b.length > 50) return false; // Cannot be longer than 25 characters
if (b[0] == 0x20) return false; // Leading space
if (b[b.length - 1] == 0x20) return false; // Trailing space
bytes1 lastChar = b[0];
for (uint i; i < b.length; i++) {
bytes1 char = b[i];
if (char == 0x20 && lastChar == 0x20) return false; // Cannot contain continous spaces
if (
!(char >= 0x30 && char <= 0x39) && //9-0
!(char >= 0x41 && char <= 0x5A) && //A-Z
!(char >= 0x61 && char <= 0x7A) && //a-z
!(char == 0x20) //space
)
return false;
lastChar = char;
}
return true;
}
/**
* @dev Converts the string to lowercase
*/
function _toLower(string memory str) private pure returns (string memory){
bytes memory bStr = bytes(str);
bytes memory bLower = new bytes(bStr.length);
for (uint i = 0; i < bStr.length; i++) {
// Uppercase character
if ((uint8(bStr[i]) >= 65) && (uint8(bStr[i]) <= 90)) {
bLower[i] = bytes1(uint8(bStr[i]) + 32);
} else {
bLower[i] = bStr[i];
}
}
return string(bLower);
}
/**
* @dev Reserves the name if isReserve is set to true, de-reserves if set to false
*/
function _toggleReserveName(string memory str, bool isReserve) internal {
_reservedNames[_toLower(str)] = isReserve;
}
function _baseURI() internal pure override returns (string memory) {
return "ipfs://";
}
function _toInitialSequenceIndex(uint256 tokenId) internal view returns (uint256) {
return (tokenId + _startingIndex) % MAX_SUPPLY;
}
} | /**
* @title Mars contract
* @dev Extends ERC721 Non-Fungible Token Standard basic implementation
*/ | NatSpecMultiLine | saleStartTimestamp | function saleStartTimestamp() public view returns (uint256) {
return _saleStartTimestamp;
}
| /**
* @dev Returns the start timestamp of the initial sale.
*/ | NatSpecMultiLine | v0.8.3+commit.8d00100c | {
"func_code_index": [
2723,
2830
]
} | 8,934 |
||
MarsLocker | contracts/Mars.sol | 0x64200351e787b33cd7c518a93fc24d780092f727 | Solidity | Mars | contract Mars is Ownable, ERC721Enumerable, PaymentSplitter {
using SafeMath for uint256;
uint256 public constant MAX_SUPPLY = 16200;
uint256 public constant RESERVED_SUPPLY = 1305 + 500;
bytes32 private _provenanceHash;
uint256 private _nameChangePrice;
uint256 private _saleStartTimestamp;
uint256 private _revealTimestamp;
uint256 private _startingIndexBlock;
uint256 internal _startingIndex;
uint256 private _numSoldTokens;
uint256 private _numMintedReservedTokens;
mapping (uint256 => string) private _tokenNames;
mapping (string => bool) private _reservedNames;
mapping (uint256 => bool) private _mintedBeforeReveal;
Mars26 private _m26;
MarsStorage private _storage;
event NameChange (uint256 indexed maskIndex, string newName);
/**
* @dev Sets immutable values of contract.
*/
constructor (
bytes32 provenanceHash_,
address m26Address_,
uint256 nameChangePrice_,
uint256 saleStartTimestamp_,
uint256 revealTimestamp_,
address[] memory payees,
uint256[] memory shares_
) ERC721("Mars", "MARS") PaymentSplitter(payees, shares_) {
_provenanceHash = provenanceHash_;
_m26 = Mars26(m26Address_);
_nameChangePrice = nameChangePrice_;
_saleStartTimestamp = saleStartTimestamp_;
_revealTimestamp = revealTimestamp_;
_storage = new MarsStorage(MAX_SUPPLY);
}
/**
* @dev Returns provenance hash digest set during initialization of contract.
*
* The provenance hash is derived by concatenating all existing IPFS CIDs (v0)
* of the Mars NFTs and hashing the concatenated string using SHA2-256.
* Note that the CIDs were concatenated and hashed in their base58 representation.
*/
function provenanceHash() public view returns (bytes32) {
return _provenanceHash;
}
/**
* @dev Returns address of Mars26 ERC-20 token contract.
*/
function m26Address() public view returns (address) {
return address(_m26);
}
/**
* @dev Returns address of connected storage contract.
*/
function storageAddress() public view returns (address) {
return address(_storage);
}
/**
* @dev Returns the number of sold NFTs.
*/
function numSoldTokens() public view returns (uint256) {
return _numSoldTokens;
}
/**
* @dev Returns the MNCT price for changing the name of a token.
*/
function nameChangePrice() public view returns (uint256) {
return _nameChangePrice;
}
/**
* @dev Returns the start timestamp of the initial sale.
*/
function saleStartTimestamp() public view returns (uint256) {
return _saleStartTimestamp;
}
/**
* @dev Returns the reveal timestamp after which the token ids will be assigned.
*/
function revealTimestamp() public view returns (uint256) {
return _revealTimestamp;
}
/**
* @dev Returns the randomized starting index to assign and reveal token ids to
* intial sequence of NFTs.
*/
function startingIndex() public view returns (uint256) {
return _startingIndex;
}
/**
* @dev Returns the randomized starting index block which is used to derive
* {_startingIndex} from.
*/
function startingIndexBlock() public view returns (uint256) {
return _startingIndexBlock;
}
/**
* @dev See {MarsStorage.initialSequenceTokenCID}
*/
function initialSequenceTokenCID(uint256 initialSequenceIndex) public view returns (string memory) {
return _storage.initialSequenceTokenCID(initialSequenceIndex);
}
/**
* @dev Returns if {nameString} has been reserved.
*/
function isNameReserved(string memory nameString) public view returns (bool) {
return _reservedNames[_toLower(nameString)];
}
/**
* @dev Returns reverved name for given token id.
*/
function tokenNames(uint256 tokenId) public view returns (string memory) {
return _tokenNames[tokenId];
}
/**
* @dev Returns the set token URI, i.e. IPFS v0 CID, of {tokenId}.
* Prefixed with ipfs://
*/
function tokenURI(uint256 tokenId) public view override returns (string memory) {
require(_exists(tokenId), "ERC721URIStorage: URI query for nonexistent token");
require(_startingIndex > 0, "Tokens have not been assigned yet");
uint256 initialSequenceIndex = _toInitialSequenceIndex(tokenId);
return tokenURIOfInitialSequenceIndex(initialSequenceIndex);
}
/**
* @dev Returns the set token URI, i.e. IPFS v0 CID, of {initialSequenceIndex}.
* Prefixed with ipfs://
*/
function tokenURIOfInitialSequenceIndex(uint256 initialSequenceIndex) public view returns (string memory) {
require(_startingIndex > 0, "Tokens have not been assigned yet");
string memory tokenCID = initialSequenceTokenCID(initialSequenceIndex);
string memory base = _baseURI();
// If there is no base URI, return the token URI.
if (bytes(base).length == 0) {
return tokenCID;
}
// If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked).
if (bytes(tokenCID).length > 0) {
return string(abi.encodePacked(base, tokenCID));
}
return base;
}
/**
* @dev Returns if the NFT has been minted before reveal phase.
*/
function isMintedBeforeReveal(uint256 index) public view returns (bool) {
return _mintedBeforeReveal[index];
}
/**
* @dev Gets current NFT price based on already sold tokens.
*/
function getNFTPrice() public view returns (uint256) {
if (_numSoldTokens < 800) {
return 0.01 ether;
} else if (_numSoldTokens < 4400) {
return 0.02 ether;
} else if (_numSoldTokens < 8800) {
return 0.03 ether;
} else if (_numSoldTokens < 12600) {
return 0.05 ether;
} else if (_numSoldTokens < 14040) {
return 0.1 ether;
} else if (_numSoldTokens < 14392) {
return 0.3 ether;
} else {
return 1 ether;
}
}
/**
* @dev Mints Mars NFTs
*/
function mint(uint256 numberOfNfts) public payable {
require(block.timestamp >= _saleStartTimestamp, "Sale has not started");
require(totalSupply() < MAX_SUPPLY, "Sale has already ended");
require(numberOfNfts > 0, "Cannot buy 0 NFTs");
require(numberOfNfts <= 20, "You may not buy more than 20 NFTs at once");
require(_numSoldTokens.add(numberOfNfts) <= MAX_SUPPLY.sub(RESERVED_SUPPLY), "Exceeds max number of sellable NFTs");
require(getNFTPrice().mul(numberOfNfts) == msg.value, "Ether value sent is not correct");
for (uint i = 0; i < numberOfNfts; i++) {
uint mintIndex = totalSupply();
_numSoldTokens++;
require(mintIndex < MAX_SUPPLY, "Exceeds max number of NFTs in existence");
if (block.timestamp < _revealTimestamp) {
_mintedBeforeReveal[mintIndex] = true;
}
_safeMint(msg.sender, mintIndex);
}
// Source of randomness. Theoretical miner withhold manipulation possible but should be sufficient in a pragmatic sense
if (_startingIndexBlock == 0 && (_numSoldTokens >= MAX_SUPPLY.sub(RESERVED_SUPPLY) || block.timestamp >= _revealTimestamp)) {
_startingIndexBlock = block.number;
}
}
/**
* @dev Used to migrate already minted NFTs of old contract.
*/
function mintReserved(address to, uint256 numOfNFTs) public onlyOwner {
require(totalSupply().add(numOfNFTs) <= MAX_SUPPLY, "Exceeds max supply of NFTs");
require(_numMintedReservedTokens.add(numOfNFTs) <= RESERVED_SUPPLY, "Exceeds max num of reserved NFTs");
for (uint j = 0; j < numOfNFTs; j++) {
uint tokenId = totalSupply();
if (block.timestamp < _revealTimestamp) {
_mintedBeforeReveal[tokenId] = true;
}
_numMintedReservedTokens++;
_safeMint(to, tokenId);
}
}
/**
* @dev Finalize starting index
*/
function finalizeStartingIndex() public {
require(_startingIndex == 0, "Starting index is already set");
require(_startingIndexBlock != 0, "Starting index block must be set");
_startingIndex = uint(blockhash(_startingIndexBlock)) % MAX_SUPPLY;
// Just a sanity case in the worst case if this function is called late (EVM only stores last 256 block hashes)
if (block.number.sub(_startingIndexBlock) > 255) {
_startingIndex = uint(blockhash(block.number - 1)) % MAX_SUPPLY;
}
// Prevent default sequence
if (_startingIndex == 0) {
_startingIndex = _startingIndex.add(1);
}
}
/**
* @dev Changes the name for Mars tile tokenId
*/
function changeName(uint256 tokenId, string memory newName) public {
address owner = ownerOf(tokenId);
require(_msgSender() == owner, "ERC721: caller is not the owner");
require(_validateName(newName) == true, "Not a valid new name");
require(sha256(bytes(newName)) != sha256(bytes(_tokenNames[tokenId])), "New name is same as the current one");
require(isNameReserved(newName) == false, "Name already reserved");
_m26.transferFrom(msg.sender, address(this), _nameChangePrice);
// If already named, dereserve old name
if (bytes(_tokenNames[tokenId]).length > 0) {
_toggleReserveName(_tokenNames[tokenId], false);
}
_toggleReserveName(newName, true);
_tokenNames[tokenId] = newName;
_m26.burn(_nameChangePrice);
emit NameChange(tokenId, newName);
}
/**
* @dev See {MarsStorage.setInitialSequenceTokenHashes}
*/
function setInitialSequenceTokenHashes(bytes32[] memory tokenHashes) onlyOwner public {
_storage.setInitialSequenceTokenHashes(tokenHashes);
}
/**
* @dev See {MarsStorage.setInitialSequenceTokenHashesAtIndex}
*/
function setInitialSequenceTokenHashesAtIndex(
uint256 startIndex,
bytes32[] memory tokenHashes
) public onlyOwner {
_storage.setInitialSequenceTokenHashesAtIndex(startIndex, tokenHashes);
}
/**
* @dev Check if the name string is valid (Alphanumeric and spaces without leading or trailing space)
*/
function _validateName(string memory str) private pure returns (bool){
bytes memory b = bytes(str);
if (b.length < 1) return false;
if (b.length > 50) return false; // Cannot be longer than 25 characters
if (b[0] == 0x20) return false; // Leading space
if (b[b.length - 1] == 0x20) return false; // Trailing space
bytes1 lastChar = b[0];
for (uint i; i < b.length; i++) {
bytes1 char = b[i];
if (char == 0x20 && lastChar == 0x20) return false; // Cannot contain continous spaces
if (
!(char >= 0x30 && char <= 0x39) && //9-0
!(char >= 0x41 && char <= 0x5A) && //A-Z
!(char >= 0x61 && char <= 0x7A) && //a-z
!(char == 0x20) //space
)
return false;
lastChar = char;
}
return true;
}
/**
* @dev Converts the string to lowercase
*/
function _toLower(string memory str) private pure returns (string memory){
bytes memory bStr = bytes(str);
bytes memory bLower = new bytes(bStr.length);
for (uint i = 0; i < bStr.length; i++) {
// Uppercase character
if ((uint8(bStr[i]) >= 65) && (uint8(bStr[i]) <= 90)) {
bLower[i] = bytes1(uint8(bStr[i]) + 32);
} else {
bLower[i] = bStr[i];
}
}
return string(bLower);
}
/**
* @dev Reserves the name if isReserve is set to true, de-reserves if set to false
*/
function _toggleReserveName(string memory str, bool isReserve) internal {
_reservedNames[_toLower(str)] = isReserve;
}
function _baseURI() internal pure override returns (string memory) {
return "ipfs://";
}
function _toInitialSequenceIndex(uint256 tokenId) internal view returns (uint256) {
return (tokenId + _startingIndex) % MAX_SUPPLY;
}
} | /**
* @title Mars contract
* @dev Extends ERC721 Non-Fungible Token Standard basic implementation
*/ | NatSpecMultiLine | revealTimestamp | function revealTimestamp() public view returns (uint256) {
return _revealTimestamp;
}
| /**
* @dev Returns the reveal timestamp after which the token ids will be assigned.
*/ | NatSpecMultiLine | v0.8.3+commit.8d00100c | {
"func_code_index": [
2933,
3034
]
} | 8,935 |
||
MarsLocker | contracts/Mars.sol | 0x64200351e787b33cd7c518a93fc24d780092f727 | Solidity | Mars | contract Mars is Ownable, ERC721Enumerable, PaymentSplitter {
using SafeMath for uint256;
uint256 public constant MAX_SUPPLY = 16200;
uint256 public constant RESERVED_SUPPLY = 1305 + 500;
bytes32 private _provenanceHash;
uint256 private _nameChangePrice;
uint256 private _saleStartTimestamp;
uint256 private _revealTimestamp;
uint256 private _startingIndexBlock;
uint256 internal _startingIndex;
uint256 private _numSoldTokens;
uint256 private _numMintedReservedTokens;
mapping (uint256 => string) private _tokenNames;
mapping (string => bool) private _reservedNames;
mapping (uint256 => bool) private _mintedBeforeReveal;
Mars26 private _m26;
MarsStorage private _storage;
event NameChange (uint256 indexed maskIndex, string newName);
/**
* @dev Sets immutable values of contract.
*/
constructor (
bytes32 provenanceHash_,
address m26Address_,
uint256 nameChangePrice_,
uint256 saleStartTimestamp_,
uint256 revealTimestamp_,
address[] memory payees,
uint256[] memory shares_
) ERC721("Mars", "MARS") PaymentSplitter(payees, shares_) {
_provenanceHash = provenanceHash_;
_m26 = Mars26(m26Address_);
_nameChangePrice = nameChangePrice_;
_saleStartTimestamp = saleStartTimestamp_;
_revealTimestamp = revealTimestamp_;
_storage = new MarsStorage(MAX_SUPPLY);
}
/**
* @dev Returns provenance hash digest set during initialization of contract.
*
* The provenance hash is derived by concatenating all existing IPFS CIDs (v0)
* of the Mars NFTs and hashing the concatenated string using SHA2-256.
* Note that the CIDs were concatenated and hashed in their base58 representation.
*/
function provenanceHash() public view returns (bytes32) {
return _provenanceHash;
}
/**
* @dev Returns address of Mars26 ERC-20 token contract.
*/
function m26Address() public view returns (address) {
return address(_m26);
}
/**
* @dev Returns address of connected storage contract.
*/
function storageAddress() public view returns (address) {
return address(_storage);
}
/**
* @dev Returns the number of sold NFTs.
*/
function numSoldTokens() public view returns (uint256) {
return _numSoldTokens;
}
/**
* @dev Returns the MNCT price for changing the name of a token.
*/
function nameChangePrice() public view returns (uint256) {
return _nameChangePrice;
}
/**
* @dev Returns the start timestamp of the initial sale.
*/
function saleStartTimestamp() public view returns (uint256) {
return _saleStartTimestamp;
}
/**
* @dev Returns the reveal timestamp after which the token ids will be assigned.
*/
function revealTimestamp() public view returns (uint256) {
return _revealTimestamp;
}
/**
* @dev Returns the randomized starting index to assign and reveal token ids to
* intial sequence of NFTs.
*/
function startingIndex() public view returns (uint256) {
return _startingIndex;
}
/**
* @dev Returns the randomized starting index block which is used to derive
* {_startingIndex} from.
*/
function startingIndexBlock() public view returns (uint256) {
return _startingIndexBlock;
}
/**
* @dev See {MarsStorage.initialSequenceTokenCID}
*/
function initialSequenceTokenCID(uint256 initialSequenceIndex) public view returns (string memory) {
return _storage.initialSequenceTokenCID(initialSequenceIndex);
}
/**
* @dev Returns if {nameString} has been reserved.
*/
function isNameReserved(string memory nameString) public view returns (bool) {
return _reservedNames[_toLower(nameString)];
}
/**
* @dev Returns reverved name for given token id.
*/
function tokenNames(uint256 tokenId) public view returns (string memory) {
return _tokenNames[tokenId];
}
/**
* @dev Returns the set token URI, i.e. IPFS v0 CID, of {tokenId}.
* Prefixed with ipfs://
*/
function tokenURI(uint256 tokenId) public view override returns (string memory) {
require(_exists(tokenId), "ERC721URIStorage: URI query for nonexistent token");
require(_startingIndex > 0, "Tokens have not been assigned yet");
uint256 initialSequenceIndex = _toInitialSequenceIndex(tokenId);
return tokenURIOfInitialSequenceIndex(initialSequenceIndex);
}
/**
* @dev Returns the set token URI, i.e. IPFS v0 CID, of {initialSequenceIndex}.
* Prefixed with ipfs://
*/
function tokenURIOfInitialSequenceIndex(uint256 initialSequenceIndex) public view returns (string memory) {
require(_startingIndex > 0, "Tokens have not been assigned yet");
string memory tokenCID = initialSequenceTokenCID(initialSequenceIndex);
string memory base = _baseURI();
// If there is no base URI, return the token URI.
if (bytes(base).length == 0) {
return tokenCID;
}
// If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked).
if (bytes(tokenCID).length > 0) {
return string(abi.encodePacked(base, tokenCID));
}
return base;
}
/**
* @dev Returns if the NFT has been minted before reveal phase.
*/
function isMintedBeforeReveal(uint256 index) public view returns (bool) {
return _mintedBeforeReveal[index];
}
/**
* @dev Gets current NFT price based on already sold tokens.
*/
function getNFTPrice() public view returns (uint256) {
if (_numSoldTokens < 800) {
return 0.01 ether;
} else if (_numSoldTokens < 4400) {
return 0.02 ether;
} else if (_numSoldTokens < 8800) {
return 0.03 ether;
} else if (_numSoldTokens < 12600) {
return 0.05 ether;
} else if (_numSoldTokens < 14040) {
return 0.1 ether;
} else if (_numSoldTokens < 14392) {
return 0.3 ether;
} else {
return 1 ether;
}
}
/**
* @dev Mints Mars NFTs
*/
function mint(uint256 numberOfNfts) public payable {
require(block.timestamp >= _saleStartTimestamp, "Sale has not started");
require(totalSupply() < MAX_SUPPLY, "Sale has already ended");
require(numberOfNfts > 0, "Cannot buy 0 NFTs");
require(numberOfNfts <= 20, "You may not buy more than 20 NFTs at once");
require(_numSoldTokens.add(numberOfNfts) <= MAX_SUPPLY.sub(RESERVED_SUPPLY), "Exceeds max number of sellable NFTs");
require(getNFTPrice().mul(numberOfNfts) == msg.value, "Ether value sent is not correct");
for (uint i = 0; i < numberOfNfts; i++) {
uint mintIndex = totalSupply();
_numSoldTokens++;
require(mintIndex < MAX_SUPPLY, "Exceeds max number of NFTs in existence");
if (block.timestamp < _revealTimestamp) {
_mintedBeforeReveal[mintIndex] = true;
}
_safeMint(msg.sender, mintIndex);
}
// Source of randomness. Theoretical miner withhold manipulation possible but should be sufficient in a pragmatic sense
if (_startingIndexBlock == 0 && (_numSoldTokens >= MAX_SUPPLY.sub(RESERVED_SUPPLY) || block.timestamp >= _revealTimestamp)) {
_startingIndexBlock = block.number;
}
}
/**
* @dev Used to migrate already minted NFTs of old contract.
*/
function mintReserved(address to, uint256 numOfNFTs) public onlyOwner {
require(totalSupply().add(numOfNFTs) <= MAX_SUPPLY, "Exceeds max supply of NFTs");
require(_numMintedReservedTokens.add(numOfNFTs) <= RESERVED_SUPPLY, "Exceeds max num of reserved NFTs");
for (uint j = 0; j < numOfNFTs; j++) {
uint tokenId = totalSupply();
if (block.timestamp < _revealTimestamp) {
_mintedBeforeReveal[tokenId] = true;
}
_numMintedReservedTokens++;
_safeMint(to, tokenId);
}
}
/**
* @dev Finalize starting index
*/
function finalizeStartingIndex() public {
require(_startingIndex == 0, "Starting index is already set");
require(_startingIndexBlock != 0, "Starting index block must be set");
_startingIndex = uint(blockhash(_startingIndexBlock)) % MAX_SUPPLY;
// Just a sanity case in the worst case if this function is called late (EVM only stores last 256 block hashes)
if (block.number.sub(_startingIndexBlock) > 255) {
_startingIndex = uint(blockhash(block.number - 1)) % MAX_SUPPLY;
}
// Prevent default sequence
if (_startingIndex == 0) {
_startingIndex = _startingIndex.add(1);
}
}
/**
* @dev Changes the name for Mars tile tokenId
*/
function changeName(uint256 tokenId, string memory newName) public {
address owner = ownerOf(tokenId);
require(_msgSender() == owner, "ERC721: caller is not the owner");
require(_validateName(newName) == true, "Not a valid new name");
require(sha256(bytes(newName)) != sha256(bytes(_tokenNames[tokenId])), "New name is same as the current one");
require(isNameReserved(newName) == false, "Name already reserved");
_m26.transferFrom(msg.sender, address(this), _nameChangePrice);
// If already named, dereserve old name
if (bytes(_tokenNames[tokenId]).length > 0) {
_toggleReserveName(_tokenNames[tokenId], false);
}
_toggleReserveName(newName, true);
_tokenNames[tokenId] = newName;
_m26.burn(_nameChangePrice);
emit NameChange(tokenId, newName);
}
/**
* @dev See {MarsStorage.setInitialSequenceTokenHashes}
*/
function setInitialSequenceTokenHashes(bytes32[] memory tokenHashes) onlyOwner public {
_storage.setInitialSequenceTokenHashes(tokenHashes);
}
/**
* @dev See {MarsStorage.setInitialSequenceTokenHashesAtIndex}
*/
function setInitialSequenceTokenHashesAtIndex(
uint256 startIndex,
bytes32[] memory tokenHashes
) public onlyOwner {
_storage.setInitialSequenceTokenHashesAtIndex(startIndex, tokenHashes);
}
/**
* @dev Check if the name string is valid (Alphanumeric and spaces without leading or trailing space)
*/
function _validateName(string memory str) private pure returns (bool){
bytes memory b = bytes(str);
if (b.length < 1) return false;
if (b.length > 50) return false; // Cannot be longer than 25 characters
if (b[0] == 0x20) return false; // Leading space
if (b[b.length - 1] == 0x20) return false; // Trailing space
bytes1 lastChar = b[0];
for (uint i; i < b.length; i++) {
bytes1 char = b[i];
if (char == 0x20 && lastChar == 0x20) return false; // Cannot contain continous spaces
if (
!(char >= 0x30 && char <= 0x39) && //9-0
!(char >= 0x41 && char <= 0x5A) && //A-Z
!(char >= 0x61 && char <= 0x7A) && //a-z
!(char == 0x20) //space
)
return false;
lastChar = char;
}
return true;
}
/**
* @dev Converts the string to lowercase
*/
function _toLower(string memory str) private pure returns (string memory){
bytes memory bStr = bytes(str);
bytes memory bLower = new bytes(bStr.length);
for (uint i = 0; i < bStr.length; i++) {
// Uppercase character
if ((uint8(bStr[i]) >= 65) && (uint8(bStr[i]) <= 90)) {
bLower[i] = bytes1(uint8(bStr[i]) + 32);
} else {
bLower[i] = bStr[i];
}
}
return string(bLower);
}
/**
* @dev Reserves the name if isReserve is set to true, de-reserves if set to false
*/
function _toggleReserveName(string memory str, bool isReserve) internal {
_reservedNames[_toLower(str)] = isReserve;
}
function _baseURI() internal pure override returns (string memory) {
return "ipfs://";
}
function _toInitialSequenceIndex(uint256 tokenId) internal view returns (uint256) {
return (tokenId + _startingIndex) % MAX_SUPPLY;
}
} | /**
* @title Mars contract
* @dev Extends ERC721 Non-Fungible Token Standard basic implementation
*/ | NatSpecMultiLine | startingIndex | function startingIndex() public view returns (uint256) {
return _startingIndex;
}
| /**
* @dev Returns the randomized starting index to assign and reveal token ids to
* intial sequence of NFTs.
*/ | NatSpecMultiLine | v0.8.3+commit.8d00100c | {
"func_code_index": [
3168,
3265
]
} | 8,936 |
||
MarsLocker | contracts/Mars.sol | 0x64200351e787b33cd7c518a93fc24d780092f727 | Solidity | Mars | contract Mars is Ownable, ERC721Enumerable, PaymentSplitter {
using SafeMath for uint256;
uint256 public constant MAX_SUPPLY = 16200;
uint256 public constant RESERVED_SUPPLY = 1305 + 500;
bytes32 private _provenanceHash;
uint256 private _nameChangePrice;
uint256 private _saleStartTimestamp;
uint256 private _revealTimestamp;
uint256 private _startingIndexBlock;
uint256 internal _startingIndex;
uint256 private _numSoldTokens;
uint256 private _numMintedReservedTokens;
mapping (uint256 => string) private _tokenNames;
mapping (string => bool) private _reservedNames;
mapping (uint256 => bool) private _mintedBeforeReveal;
Mars26 private _m26;
MarsStorage private _storage;
event NameChange (uint256 indexed maskIndex, string newName);
/**
* @dev Sets immutable values of contract.
*/
constructor (
bytes32 provenanceHash_,
address m26Address_,
uint256 nameChangePrice_,
uint256 saleStartTimestamp_,
uint256 revealTimestamp_,
address[] memory payees,
uint256[] memory shares_
) ERC721("Mars", "MARS") PaymentSplitter(payees, shares_) {
_provenanceHash = provenanceHash_;
_m26 = Mars26(m26Address_);
_nameChangePrice = nameChangePrice_;
_saleStartTimestamp = saleStartTimestamp_;
_revealTimestamp = revealTimestamp_;
_storage = new MarsStorage(MAX_SUPPLY);
}
/**
* @dev Returns provenance hash digest set during initialization of contract.
*
* The provenance hash is derived by concatenating all existing IPFS CIDs (v0)
* of the Mars NFTs and hashing the concatenated string using SHA2-256.
* Note that the CIDs were concatenated and hashed in their base58 representation.
*/
function provenanceHash() public view returns (bytes32) {
return _provenanceHash;
}
/**
* @dev Returns address of Mars26 ERC-20 token contract.
*/
function m26Address() public view returns (address) {
return address(_m26);
}
/**
* @dev Returns address of connected storage contract.
*/
function storageAddress() public view returns (address) {
return address(_storage);
}
/**
* @dev Returns the number of sold NFTs.
*/
function numSoldTokens() public view returns (uint256) {
return _numSoldTokens;
}
/**
* @dev Returns the MNCT price for changing the name of a token.
*/
function nameChangePrice() public view returns (uint256) {
return _nameChangePrice;
}
/**
* @dev Returns the start timestamp of the initial sale.
*/
function saleStartTimestamp() public view returns (uint256) {
return _saleStartTimestamp;
}
/**
* @dev Returns the reveal timestamp after which the token ids will be assigned.
*/
function revealTimestamp() public view returns (uint256) {
return _revealTimestamp;
}
/**
* @dev Returns the randomized starting index to assign and reveal token ids to
* intial sequence of NFTs.
*/
function startingIndex() public view returns (uint256) {
return _startingIndex;
}
/**
* @dev Returns the randomized starting index block which is used to derive
* {_startingIndex} from.
*/
function startingIndexBlock() public view returns (uint256) {
return _startingIndexBlock;
}
/**
* @dev See {MarsStorage.initialSequenceTokenCID}
*/
function initialSequenceTokenCID(uint256 initialSequenceIndex) public view returns (string memory) {
return _storage.initialSequenceTokenCID(initialSequenceIndex);
}
/**
* @dev Returns if {nameString} has been reserved.
*/
function isNameReserved(string memory nameString) public view returns (bool) {
return _reservedNames[_toLower(nameString)];
}
/**
* @dev Returns reverved name for given token id.
*/
function tokenNames(uint256 tokenId) public view returns (string memory) {
return _tokenNames[tokenId];
}
/**
* @dev Returns the set token URI, i.e. IPFS v0 CID, of {tokenId}.
* Prefixed with ipfs://
*/
function tokenURI(uint256 tokenId) public view override returns (string memory) {
require(_exists(tokenId), "ERC721URIStorage: URI query for nonexistent token");
require(_startingIndex > 0, "Tokens have not been assigned yet");
uint256 initialSequenceIndex = _toInitialSequenceIndex(tokenId);
return tokenURIOfInitialSequenceIndex(initialSequenceIndex);
}
/**
* @dev Returns the set token URI, i.e. IPFS v0 CID, of {initialSequenceIndex}.
* Prefixed with ipfs://
*/
function tokenURIOfInitialSequenceIndex(uint256 initialSequenceIndex) public view returns (string memory) {
require(_startingIndex > 0, "Tokens have not been assigned yet");
string memory tokenCID = initialSequenceTokenCID(initialSequenceIndex);
string memory base = _baseURI();
// If there is no base URI, return the token URI.
if (bytes(base).length == 0) {
return tokenCID;
}
// If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked).
if (bytes(tokenCID).length > 0) {
return string(abi.encodePacked(base, tokenCID));
}
return base;
}
/**
* @dev Returns if the NFT has been minted before reveal phase.
*/
function isMintedBeforeReveal(uint256 index) public view returns (bool) {
return _mintedBeforeReveal[index];
}
/**
* @dev Gets current NFT price based on already sold tokens.
*/
function getNFTPrice() public view returns (uint256) {
if (_numSoldTokens < 800) {
return 0.01 ether;
} else if (_numSoldTokens < 4400) {
return 0.02 ether;
} else if (_numSoldTokens < 8800) {
return 0.03 ether;
} else if (_numSoldTokens < 12600) {
return 0.05 ether;
} else if (_numSoldTokens < 14040) {
return 0.1 ether;
} else if (_numSoldTokens < 14392) {
return 0.3 ether;
} else {
return 1 ether;
}
}
/**
* @dev Mints Mars NFTs
*/
function mint(uint256 numberOfNfts) public payable {
require(block.timestamp >= _saleStartTimestamp, "Sale has not started");
require(totalSupply() < MAX_SUPPLY, "Sale has already ended");
require(numberOfNfts > 0, "Cannot buy 0 NFTs");
require(numberOfNfts <= 20, "You may not buy more than 20 NFTs at once");
require(_numSoldTokens.add(numberOfNfts) <= MAX_SUPPLY.sub(RESERVED_SUPPLY), "Exceeds max number of sellable NFTs");
require(getNFTPrice().mul(numberOfNfts) == msg.value, "Ether value sent is not correct");
for (uint i = 0; i < numberOfNfts; i++) {
uint mintIndex = totalSupply();
_numSoldTokens++;
require(mintIndex < MAX_SUPPLY, "Exceeds max number of NFTs in existence");
if (block.timestamp < _revealTimestamp) {
_mintedBeforeReveal[mintIndex] = true;
}
_safeMint(msg.sender, mintIndex);
}
// Source of randomness. Theoretical miner withhold manipulation possible but should be sufficient in a pragmatic sense
if (_startingIndexBlock == 0 && (_numSoldTokens >= MAX_SUPPLY.sub(RESERVED_SUPPLY) || block.timestamp >= _revealTimestamp)) {
_startingIndexBlock = block.number;
}
}
/**
* @dev Used to migrate already minted NFTs of old contract.
*/
function mintReserved(address to, uint256 numOfNFTs) public onlyOwner {
require(totalSupply().add(numOfNFTs) <= MAX_SUPPLY, "Exceeds max supply of NFTs");
require(_numMintedReservedTokens.add(numOfNFTs) <= RESERVED_SUPPLY, "Exceeds max num of reserved NFTs");
for (uint j = 0; j < numOfNFTs; j++) {
uint tokenId = totalSupply();
if (block.timestamp < _revealTimestamp) {
_mintedBeforeReveal[tokenId] = true;
}
_numMintedReservedTokens++;
_safeMint(to, tokenId);
}
}
/**
* @dev Finalize starting index
*/
function finalizeStartingIndex() public {
require(_startingIndex == 0, "Starting index is already set");
require(_startingIndexBlock != 0, "Starting index block must be set");
_startingIndex = uint(blockhash(_startingIndexBlock)) % MAX_SUPPLY;
// Just a sanity case in the worst case if this function is called late (EVM only stores last 256 block hashes)
if (block.number.sub(_startingIndexBlock) > 255) {
_startingIndex = uint(blockhash(block.number - 1)) % MAX_SUPPLY;
}
// Prevent default sequence
if (_startingIndex == 0) {
_startingIndex = _startingIndex.add(1);
}
}
/**
* @dev Changes the name for Mars tile tokenId
*/
function changeName(uint256 tokenId, string memory newName) public {
address owner = ownerOf(tokenId);
require(_msgSender() == owner, "ERC721: caller is not the owner");
require(_validateName(newName) == true, "Not a valid new name");
require(sha256(bytes(newName)) != sha256(bytes(_tokenNames[tokenId])), "New name is same as the current one");
require(isNameReserved(newName) == false, "Name already reserved");
_m26.transferFrom(msg.sender, address(this), _nameChangePrice);
// If already named, dereserve old name
if (bytes(_tokenNames[tokenId]).length > 0) {
_toggleReserveName(_tokenNames[tokenId], false);
}
_toggleReserveName(newName, true);
_tokenNames[tokenId] = newName;
_m26.burn(_nameChangePrice);
emit NameChange(tokenId, newName);
}
/**
* @dev See {MarsStorage.setInitialSequenceTokenHashes}
*/
function setInitialSequenceTokenHashes(bytes32[] memory tokenHashes) onlyOwner public {
_storage.setInitialSequenceTokenHashes(tokenHashes);
}
/**
* @dev See {MarsStorage.setInitialSequenceTokenHashesAtIndex}
*/
function setInitialSequenceTokenHashesAtIndex(
uint256 startIndex,
bytes32[] memory tokenHashes
) public onlyOwner {
_storage.setInitialSequenceTokenHashesAtIndex(startIndex, tokenHashes);
}
/**
* @dev Check if the name string is valid (Alphanumeric and spaces without leading or trailing space)
*/
function _validateName(string memory str) private pure returns (bool){
bytes memory b = bytes(str);
if (b.length < 1) return false;
if (b.length > 50) return false; // Cannot be longer than 25 characters
if (b[0] == 0x20) return false; // Leading space
if (b[b.length - 1] == 0x20) return false; // Trailing space
bytes1 lastChar = b[0];
for (uint i; i < b.length; i++) {
bytes1 char = b[i];
if (char == 0x20 && lastChar == 0x20) return false; // Cannot contain continous spaces
if (
!(char >= 0x30 && char <= 0x39) && //9-0
!(char >= 0x41 && char <= 0x5A) && //A-Z
!(char >= 0x61 && char <= 0x7A) && //a-z
!(char == 0x20) //space
)
return false;
lastChar = char;
}
return true;
}
/**
* @dev Converts the string to lowercase
*/
function _toLower(string memory str) private pure returns (string memory){
bytes memory bStr = bytes(str);
bytes memory bLower = new bytes(bStr.length);
for (uint i = 0; i < bStr.length; i++) {
// Uppercase character
if ((uint8(bStr[i]) >= 65) && (uint8(bStr[i]) <= 90)) {
bLower[i] = bytes1(uint8(bStr[i]) + 32);
} else {
bLower[i] = bStr[i];
}
}
return string(bLower);
}
/**
* @dev Reserves the name if isReserve is set to true, de-reserves if set to false
*/
function _toggleReserveName(string memory str, bool isReserve) internal {
_reservedNames[_toLower(str)] = isReserve;
}
function _baseURI() internal pure override returns (string memory) {
return "ipfs://";
}
function _toInitialSequenceIndex(uint256 tokenId) internal view returns (uint256) {
return (tokenId + _startingIndex) % MAX_SUPPLY;
}
} | /**
* @title Mars contract
* @dev Extends ERC721 Non-Fungible Token Standard basic implementation
*/ | NatSpecMultiLine | startingIndexBlock | function startingIndexBlock() public view returns (uint256) {
return _startingIndexBlock;
}
| /**
* @dev Returns the randomized starting index block which is used to derive
* {_startingIndex} from.
*/ | NatSpecMultiLine | v0.8.3+commit.8d00100c | {
"func_code_index": [
3393,
3500
]
} | 8,937 |
||
MarsLocker | contracts/Mars.sol | 0x64200351e787b33cd7c518a93fc24d780092f727 | Solidity | Mars | contract Mars is Ownable, ERC721Enumerable, PaymentSplitter {
using SafeMath for uint256;
uint256 public constant MAX_SUPPLY = 16200;
uint256 public constant RESERVED_SUPPLY = 1305 + 500;
bytes32 private _provenanceHash;
uint256 private _nameChangePrice;
uint256 private _saleStartTimestamp;
uint256 private _revealTimestamp;
uint256 private _startingIndexBlock;
uint256 internal _startingIndex;
uint256 private _numSoldTokens;
uint256 private _numMintedReservedTokens;
mapping (uint256 => string) private _tokenNames;
mapping (string => bool) private _reservedNames;
mapping (uint256 => bool) private _mintedBeforeReveal;
Mars26 private _m26;
MarsStorage private _storage;
event NameChange (uint256 indexed maskIndex, string newName);
/**
* @dev Sets immutable values of contract.
*/
constructor (
bytes32 provenanceHash_,
address m26Address_,
uint256 nameChangePrice_,
uint256 saleStartTimestamp_,
uint256 revealTimestamp_,
address[] memory payees,
uint256[] memory shares_
) ERC721("Mars", "MARS") PaymentSplitter(payees, shares_) {
_provenanceHash = provenanceHash_;
_m26 = Mars26(m26Address_);
_nameChangePrice = nameChangePrice_;
_saleStartTimestamp = saleStartTimestamp_;
_revealTimestamp = revealTimestamp_;
_storage = new MarsStorage(MAX_SUPPLY);
}
/**
* @dev Returns provenance hash digest set during initialization of contract.
*
* The provenance hash is derived by concatenating all existing IPFS CIDs (v0)
* of the Mars NFTs and hashing the concatenated string using SHA2-256.
* Note that the CIDs were concatenated and hashed in their base58 representation.
*/
function provenanceHash() public view returns (bytes32) {
return _provenanceHash;
}
/**
* @dev Returns address of Mars26 ERC-20 token contract.
*/
function m26Address() public view returns (address) {
return address(_m26);
}
/**
* @dev Returns address of connected storage contract.
*/
function storageAddress() public view returns (address) {
return address(_storage);
}
/**
* @dev Returns the number of sold NFTs.
*/
function numSoldTokens() public view returns (uint256) {
return _numSoldTokens;
}
/**
* @dev Returns the MNCT price for changing the name of a token.
*/
function nameChangePrice() public view returns (uint256) {
return _nameChangePrice;
}
/**
* @dev Returns the start timestamp of the initial sale.
*/
function saleStartTimestamp() public view returns (uint256) {
return _saleStartTimestamp;
}
/**
* @dev Returns the reveal timestamp after which the token ids will be assigned.
*/
function revealTimestamp() public view returns (uint256) {
return _revealTimestamp;
}
/**
* @dev Returns the randomized starting index to assign and reveal token ids to
* intial sequence of NFTs.
*/
function startingIndex() public view returns (uint256) {
return _startingIndex;
}
/**
* @dev Returns the randomized starting index block which is used to derive
* {_startingIndex} from.
*/
function startingIndexBlock() public view returns (uint256) {
return _startingIndexBlock;
}
/**
* @dev See {MarsStorage.initialSequenceTokenCID}
*/
function initialSequenceTokenCID(uint256 initialSequenceIndex) public view returns (string memory) {
return _storage.initialSequenceTokenCID(initialSequenceIndex);
}
/**
* @dev Returns if {nameString} has been reserved.
*/
function isNameReserved(string memory nameString) public view returns (bool) {
return _reservedNames[_toLower(nameString)];
}
/**
* @dev Returns reverved name for given token id.
*/
function tokenNames(uint256 tokenId) public view returns (string memory) {
return _tokenNames[tokenId];
}
/**
* @dev Returns the set token URI, i.e. IPFS v0 CID, of {tokenId}.
* Prefixed with ipfs://
*/
function tokenURI(uint256 tokenId) public view override returns (string memory) {
require(_exists(tokenId), "ERC721URIStorage: URI query for nonexistent token");
require(_startingIndex > 0, "Tokens have not been assigned yet");
uint256 initialSequenceIndex = _toInitialSequenceIndex(tokenId);
return tokenURIOfInitialSequenceIndex(initialSequenceIndex);
}
/**
* @dev Returns the set token URI, i.e. IPFS v0 CID, of {initialSequenceIndex}.
* Prefixed with ipfs://
*/
function tokenURIOfInitialSequenceIndex(uint256 initialSequenceIndex) public view returns (string memory) {
require(_startingIndex > 0, "Tokens have not been assigned yet");
string memory tokenCID = initialSequenceTokenCID(initialSequenceIndex);
string memory base = _baseURI();
// If there is no base URI, return the token URI.
if (bytes(base).length == 0) {
return tokenCID;
}
// If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked).
if (bytes(tokenCID).length > 0) {
return string(abi.encodePacked(base, tokenCID));
}
return base;
}
/**
* @dev Returns if the NFT has been minted before reveal phase.
*/
function isMintedBeforeReveal(uint256 index) public view returns (bool) {
return _mintedBeforeReveal[index];
}
/**
* @dev Gets current NFT price based on already sold tokens.
*/
function getNFTPrice() public view returns (uint256) {
if (_numSoldTokens < 800) {
return 0.01 ether;
} else if (_numSoldTokens < 4400) {
return 0.02 ether;
} else if (_numSoldTokens < 8800) {
return 0.03 ether;
} else if (_numSoldTokens < 12600) {
return 0.05 ether;
} else if (_numSoldTokens < 14040) {
return 0.1 ether;
} else if (_numSoldTokens < 14392) {
return 0.3 ether;
} else {
return 1 ether;
}
}
/**
* @dev Mints Mars NFTs
*/
function mint(uint256 numberOfNfts) public payable {
require(block.timestamp >= _saleStartTimestamp, "Sale has not started");
require(totalSupply() < MAX_SUPPLY, "Sale has already ended");
require(numberOfNfts > 0, "Cannot buy 0 NFTs");
require(numberOfNfts <= 20, "You may not buy more than 20 NFTs at once");
require(_numSoldTokens.add(numberOfNfts) <= MAX_SUPPLY.sub(RESERVED_SUPPLY), "Exceeds max number of sellable NFTs");
require(getNFTPrice().mul(numberOfNfts) == msg.value, "Ether value sent is not correct");
for (uint i = 0; i < numberOfNfts; i++) {
uint mintIndex = totalSupply();
_numSoldTokens++;
require(mintIndex < MAX_SUPPLY, "Exceeds max number of NFTs in existence");
if (block.timestamp < _revealTimestamp) {
_mintedBeforeReveal[mintIndex] = true;
}
_safeMint(msg.sender, mintIndex);
}
// Source of randomness. Theoretical miner withhold manipulation possible but should be sufficient in a pragmatic sense
if (_startingIndexBlock == 0 && (_numSoldTokens >= MAX_SUPPLY.sub(RESERVED_SUPPLY) || block.timestamp >= _revealTimestamp)) {
_startingIndexBlock = block.number;
}
}
/**
* @dev Used to migrate already minted NFTs of old contract.
*/
function mintReserved(address to, uint256 numOfNFTs) public onlyOwner {
require(totalSupply().add(numOfNFTs) <= MAX_SUPPLY, "Exceeds max supply of NFTs");
require(_numMintedReservedTokens.add(numOfNFTs) <= RESERVED_SUPPLY, "Exceeds max num of reserved NFTs");
for (uint j = 0; j < numOfNFTs; j++) {
uint tokenId = totalSupply();
if (block.timestamp < _revealTimestamp) {
_mintedBeforeReveal[tokenId] = true;
}
_numMintedReservedTokens++;
_safeMint(to, tokenId);
}
}
/**
* @dev Finalize starting index
*/
function finalizeStartingIndex() public {
require(_startingIndex == 0, "Starting index is already set");
require(_startingIndexBlock != 0, "Starting index block must be set");
_startingIndex = uint(blockhash(_startingIndexBlock)) % MAX_SUPPLY;
// Just a sanity case in the worst case if this function is called late (EVM only stores last 256 block hashes)
if (block.number.sub(_startingIndexBlock) > 255) {
_startingIndex = uint(blockhash(block.number - 1)) % MAX_SUPPLY;
}
// Prevent default sequence
if (_startingIndex == 0) {
_startingIndex = _startingIndex.add(1);
}
}
/**
* @dev Changes the name for Mars tile tokenId
*/
function changeName(uint256 tokenId, string memory newName) public {
address owner = ownerOf(tokenId);
require(_msgSender() == owner, "ERC721: caller is not the owner");
require(_validateName(newName) == true, "Not a valid new name");
require(sha256(bytes(newName)) != sha256(bytes(_tokenNames[tokenId])), "New name is same as the current one");
require(isNameReserved(newName) == false, "Name already reserved");
_m26.transferFrom(msg.sender, address(this), _nameChangePrice);
// If already named, dereserve old name
if (bytes(_tokenNames[tokenId]).length > 0) {
_toggleReserveName(_tokenNames[tokenId], false);
}
_toggleReserveName(newName, true);
_tokenNames[tokenId] = newName;
_m26.burn(_nameChangePrice);
emit NameChange(tokenId, newName);
}
/**
* @dev See {MarsStorage.setInitialSequenceTokenHashes}
*/
function setInitialSequenceTokenHashes(bytes32[] memory tokenHashes) onlyOwner public {
_storage.setInitialSequenceTokenHashes(tokenHashes);
}
/**
* @dev See {MarsStorage.setInitialSequenceTokenHashesAtIndex}
*/
function setInitialSequenceTokenHashesAtIndex(
uint256 startIndex,
bytes32[] memory tokenHashes
) public onlyOwner {
_storage.setInitialSequenceTokenHashesAtIndex(startIndex, tokenHashes);
}
/**
* @dev Check if the name string is valid (Alphanumeric and spaces without leading or trailing space)
*/
function _validateName(string memory str) private pure returns (bool){
bytes memory b = bytes(str);
if (b.length < 1) return false;
if (b.length > 50) return false; // Cannot be longer than 25 characters
if (b[0] == 0x20) return false; // Leading space
if (b[b.length - 1] == 0x20) return false; // Trailing space
bytes1 lastChar = b[0];
for (uint i; i < b.length; i++) {
bytes1 char = b[i];
if (char == 0x20 && lastChar == 0x20) return false; // Cannot contain continous spaces
if (
!(char >= 0x30 && char <= 0x39) && //9-0
!(char >= 0x41 && char <= 0x5A) && //A-Z
!(char >= 0x61 && char <= 0x7A) && //a-z
!(char == 0x20) //space
)
return false;
lastChar = char;
}
return true;
}
/**
* @dev Converts the string to lowercase
*/
function _toLower(string memory str) private pure returns (string memory){
bytes memory bStr = bytes(str);
bytes memory bLower = new bytes(bStr.length);
for (uint i = 0; i < bStr.length; i++) {
// Uppercase character
if ((uint8(bStr[i]) >= 65) && (uint8(bStr[i]) <= 90)) {
bLower[i] = bytes1(uint8(bStr[i]) + 32);
} else {
bLower[i] = bStr[i];
}
}
return string(bLower);
}
/**
* @dev Reserves the name if isReserve is set to true, de-reserves if set to false
*/
function _toggleReserveName(string memory str, bool isReserve) internal {
_reservedNames[_toLower(str)] = isReserve;
}
function _baseURI() internal pure override returns (string memory) {
return "ipfs://";
}
function _toInitialSequenceIndex(uint256 tokenId) internal view returns (uint256) {
return (tokenId + _startingIndex) % MAX_SUPPLY;
}
} | /**
* @title Mars contract
* @dev Extends ERC721 Non-Fungible Token Standard basic implementation
*/ | NatSpecMultiLine | initialSequenceTokenCID | function initialSequenceTokenCID(uint256 initialSequenceIndex) public view returns (string memory) {
return _storage.initialSequenceTokenCID(initialSequenceIndex);
}
| /**
* @dev See {MarsStorage.initialSequenceTokenCID}
*/ | NatSpecMultiLine | v0.8.3+commit.8d00100c | {
"func_code_index": [
3572,
3753
]
} | 8,938 |
||
MarsLocker | contracts/Mars.sol | 0x64200351e787b33cd7c518a93fc24d780092f727 | Solidity | Mars | contract Mars is Ownable, ERC721Enumerable, PaymentSplitter {
using SafeMath for uint256;
uint256 public constant MAX_SUPPLY = 16200;
uint256 public constant RESERVED_SUPPLY = 1305 + 500;
bytes32 private _provenanceHash;
uint256 private _nameChangePrice;
uint256 private _saleStartTimestamp;
uint256 private _revealTimestamp;
uint256 private _startingIndexBlock;
uint256 internal _startingIndex;
uint256 private _numSoldTokens;
uint256 private _numMintedReservedTokens;
mapping (uint256 => string) private _tokenNames;
mapping (string => bool) private _reservedNames;
mapping (uint256 => bool) private _mintedBeforeReveal;
Mars26 private _m26;
MarsStorage private _storage;
event NameChange (uint256 indexed maskIndex, string newName);
/**
* @dev Sets immutable values of contract.
*/
constructor (
bytes32 provenanceHash_,
address m26Address_,
uint256 nameChangePrice_,
uint256 saleStartTimestamp_,
uint256 revealTimestamp_,
address[] memory payees,
uint256[] memory shares_
) ERC721("Mars", "MARS") PaymentSplitter(payees, shares_) {
_provenanceHash = provenanceHash_;
_m26 = Mars26(m26Address_);
_nameChangePrice = nameChangePrice_;
_saleStartTimestamp = saleStartTimestamp_;
_revealTimestamp = revealTimestamp_;
_storage = new MarsStorage(MAX_SUPPLY);
}
/**
* @dev Returns provenance hash digest set during initialization of contract.
*
* The provenance hash is derived by concatenating all existing IPFS CIDs (v0)
* of the Mars NFTs and hashing the concatenated string using SHA2-256.
* Note that the CIDs were concatenated and hashed in their base58 representation.
*/
function provenanceHash() public view returns (bytes32) {
return _provenanceHash;
}
/**
* @dev Returns address of Mars26 ERC-20 token contract.
*/
function m26Address() public view returns (address) {
return address(_m26);
}
/**
* @dev Returns address of connected storage contract.
*/
function storageAddress() public view returns (address) {
return address(_storage);
}
/**
* @dev Returns the number of sold NFTs.
*/
function numSoldTokens() public view returns (uint256) {
return _numSoldTokens;
}
/**
* @dev Returns the MNCT price for changing the name of a token.
*/
function nameChangePrice() public view returns (uint256) {
return _nameChangePrice;
}
/**
* @dev Returns the start timestamp of the initial sale.
*/
function saleStartTimestamp() public view returns (uint256) {
return _saleStartTimestamp;
}
/**
* @dev Returns the reveal timestamp after which the token ids will be assigned.
*/
function revealTimestamp() public view returns (uint256) {
return _revealTimestamp;
}
/**
* @dev Returns the randomized starting index to assign and reveal token ids to
* intial sequence of NFTs.
*/
function startingIndex() public view returns (uint256) {
return _startingIndex;
}
/**
* @dev Returns the randomized starting index block which is used to derive
* {_startingIndex} from.
*/
function startingIndexBlock() public view returns (uint256) {
return _startingIndexBlock;
}
/**
* @dev See {MarsStorage.initialSequenceTokenCID}
*/
function initialSequenceTokenCID(uint256 initialSequenceIndex) public view returns (string memory) {
return _storage.initialSequenceTokenCID(initialSequenceIndex);
}
/**
* @dev Returns if {nameString} has been reserved.
*/
function isNameReserved(string memory nameString) public view returns (bool) {
return _reservedNames[_toLower(nameString)];
}
/**
* @dev Returns reverved name for given token id.
*/
function tokenNames(uint256 tokenId) public view returns (string memory) {
return _tokenNames[tokenId];
}
/**
* @dev Returns the set token URI, i.e. IPFS v0 CID, of {tokenId}.
* Prefixed with ipfs://
*/
function tokenURI(uint256 tokenId) public view override returns (string memory) {
require(_exists(tokenId), "ERC721URIStorage: URI query for nonexistent token");
require(_startingIndex > 0, "Tokens have not been assigned yet");
uint256 initialSequenceIndex = _toInitialSequenceIndex(tokenId);
return tokenURIOfInitialSequenceIndex(initialSequenceIndex);
}
/**
* @dev Returns the set token URI, i.e. IPFS v0 CID, of {initialSequenceIndex}.
* Prefixed with ipfs://
*/
function tokenURIOfInitialSequenceIndex(uint256 initialSequenceIndex) public view returns (string memory) {
require(_startingIndex > 0, "Tokens have not been assigned yet");
string memory tokenCID = initialSequenceTokenCID(initialSequenceIndex);
string memory base = _baseURI();
// If there is no base URI, return the token URI.
if (bytes(base).length == 0) {
return tokenCID;
}
// If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked).
if (bytes(tokenCID).length > 0) {
return string(abi.encodePacked(base, tokenCID));
}
return base;
}
/**
* @dev Returns if the NFT has been minted before reveal phase.
*/
function isMintedBeforeReveal(uint256 index) public view returns (bool) {
return _mintedBeforeReveal[index];
}
/**
* @dev Gets current NFT price based on already sold tokens.
*/
function getNFTPrice() public view returns (uint256) {
if (_numSoldTokens < 800) {
return 0.01 ether;
} else if (_numSoldTokens < 4400) {
return 0.02 ether;
} else if (_numSoldTokens < 8800) {
return 0.03 ether;
} else if (_numSoldTokens < 12600) {
return 0.05 ether;
} else if (_numSoldTokens < 14040) {
return 0.1 ether;
} else if (_numSoldTokens < 14392) {
return 0.3 ether;
} else {
return 1 ether;
}
}
/**
* @dev Mints Mars NFTs
*/
function mint(uint256 numberOfNfts) public payable {
require(block.timestamp >= _saleStartTimestamp, "Sale has not started");
require(totalSupply() < MAX_SUPPLY, "Sale has already ended");
require(numberOfNfts > 0, "Cannot buy 0 NFTs");
require(numberOfNfts <= 20, "You may not buy more than 20 NFTs at once");
require(_numSoldTokens.add(numberOfNfts) <= MAX_SUPPLY.sub(RESERVED_SUPPLY), "Exceeds max number of sellable NFTs");
require(getNFTPrice().mul(numberOfNfts) == msg.value, "Ether value sent is not correct");
for (uint i = 0; i < numberOfNfts; i++) {
uint mintIndex = totalSupply();
_numSoldTokens++;
require(mintIndex < MAX_SUPPLY, "Exceeds max number of NFTs in existence");
if (block.timestamp < _revealTimestamp) {
_mintedBeforeReveal[mintIndex] = true;
}
_safeMint(msg.sender, mintIndex);
}
// Source of randomness. Theoretical miner withhold manipulation possible but should be sufficient in a pragmatic sense
if (_startingIndexBlock == 0 && (_numSoldTokens >= MAX_SUPPLY.sub(RESERVED_SUPPLY) || block.timestamp >= _revealTimestamp)) {
_startingIndexBlock = block.number;
}
}
/**
* @dev Used to migrate already minted NFTs of old contract.
*/
function mintReserved(address to, uint256 numOfNFTs) public onlyOwner {
require(totalSupply().add(numOfNFTs) <= MAX_SUPPLY, "Exceeds max supply of NFTs");
require(_numMintedReservedTokens.add(numOfNFTs) <= RESERVED_SUPPLY, "Exceeds max num of reserved NFTs");
for (uint j = 0; j < numOfNFTs; j++) {
uint tokenId = totalSupply();
if (block.timestamp < _revealTimestamp) {
_mintedBeforeReveal[tokenId] = true;
}
_numMintedReservedTokens++;
_safeMint(to, tokenId);
}
}
/**
* @dev Finalize starting index
*/
function finalizeStartingIndex() public {
require(_startingIndex == 0, "Starting index is already set");
require(_startingIndexBlock != 0, "Starting index block must be set");
_startingIndex = uint(blockhash(_startingIndexBlock)) % MAX_SUPPLY;
// Just a sanity case in the worst case if this function is called late (EVM only stores last 256 block hashes)
if (block.number.sub(_startingIndexBlock) > 255) {
_startingIndex = uint(blockhash(block.number - 1)) % MAX_SUPPLY;
}
// Prevent default sequence
if (_startingIndex == 0) {
_startingIndex = _startingIndex.add(1);
}
}
/**
* @dev Changes the name for Mars tile tokenId
*/
function changeName(uint256 tokenId, string memory newName) public {
address owner = ownerOf(tokenId);
require(_msgSender() == owner, "ERC721: caller is not the owner");
require(_validateName(newName) == true, "Not a valid new name");
require(sha256(bytes(newName)) != sha256(bytes(_tokenNames[tokenId])), "New name is same as the current one");
require(isNameReserved(newName) == false, "Name already reserved");
_m26.transferFrom(msg.sender, address(this), _nameChangePrice);
// If already named, dereserve old name
if (bytes(_tokenNames[tokenId]).length > 0) {
_toggleReserveName(_tokenNames[tokenId], false);
}
_toggleReserveName(newName, true);
_tokenNames[tokenId] = newName;
_m26.burn(_nameChangePrice);
emit NameChange(tokenId, newName);
}
/**
* @dev See {MarsStorage.setInitialSequenceTokenHashes}
*/
function setInitialSequenceTokenHashes(bytes32[] memory tokenHashes) onlyOwner public {
_storage.setInitialSequenceTokenHashes(tokenHashes);
}
/**
* @dev See {MarsStorage.setInitialSequenceTokenHashesAtIndex}
*/
function setInitialSequenceTokenHashesAtIndex(
uint256 startIndex,
bytes32[] memory tokenHashes
) public onlyOwner {
_storage.setInitialSequenceTokenHashesAtIndex(startIndex, tokenHashes);
}
/**
* @dev Check if the name string is valid (Alphanumeric and spaces without leading or trailing space)
*/
function _validateName(string memory str) private pure returns (bool){
bytes memory b = bytes(str);
if (b.length < 1) return false;
if (b.length > 50) return false; // Cannot be longer than 25 characters
if (b[0] == 0x20) return false; // Leading space
if (b[b.length - 1] == 0x20) return false; // Trailing space
bytes1 lastChar = b[0];
for (uint i; i < b.length; i++) {
bytes1 char = b[i];
if (char == 0x20 && lastChar == 0x20) return false; // Cannot contain continous spaces
if (
!(char >= 0x30 && char <= 0x39) && //9-0
!(char >= 0x41 && char <= 0x5A) && //A-Z
!(char >= 0x61 && char <= 0x7A) && //a-z
!(char == 0x20) //space
)
return false;
lastChar = char;
}
return true;
}
/**
* @dev Converts the string to lowercase
*/
function _toLower(string memory str) private pure returns (string memory){
bytes memory bStr = bytes(str);
bytes memory bLower = new bytes(bStr.length);
for (uint i = 0; i < bStr.length; i++) {
// Uppercase character
if ((uint8(bStr[i]) >= 65) && (uint8(bStr[i]) <= 90)) {
bLower[i] = bytes1(uint8(bStr[i]) + 32);
} else {
bLower[i] = bStr[i];
}
}
return string(bLower);
}
/**
* @dev Reserves the name if isReserve is set to true, de-reserves if set to false
*/
function _toggleReserveName(string memory str, bool isReserve) internal {
_reservedNames[_toLower(str)] = isReserve;
}
function _baseURI() internal pure override returns (string memory) {
return "ipfs://";
}
function _toInitialSequenceIndex(uint256 tokenId) internal view returns (uint256) {
return (tokenId + _startingIndex) % MAX_SUPPLY;
}
} | /**
* @title Mars contract
* @dev Extends ERC721 Non-Fungible Token Standard basic implementation
*/ | NatSpecMultiLine | isNameReserved | function isNameReserved(string memory nameString) public view returns (bool) {
return _reservedNames[_toLower(nameString)];
}
| /**
* @dev Returns if {nameString} has been reserved.
*/ | NatSpecMultiLine | v0.8.3+commit.8d00100c | {
"func_code_index": [
3826,
3967
]
} | 8,939 |
||
MarsLocker | contracts/Mars.sol | 0x64200351e787b33cd7c518a93fc24d780092f727 | Solidity | Mars | contract Mars is Ownable, ERC721Enumerable, PaymentSplitter {
using SafeMath for uint256;
uint256 public constant MAX_SUPPLY = 16200;
uint256 public constant RESERVED_SUPPLY = 1305 + 500;
bytes32 private _provenanceHash;
uint256 private _nameChangePrice;
uint256 private _saleStartTimestamp;
uint256 private _revealTimestamp;
uint256 private _startingIndexBlock;
uint256 internal _startingIndex;
uint256 private _numSoldTokens;
uint256 private _numMintedReservedTokens;
mapping (uint256 => string) private _tokenNames;
mapping (string => bool) private _reservedNames;
mapping (uint256 => bool) private _mintedBeforeReveal;
Mars26 private _m26;
MarsStorage private _storage;
event NameChange (uint256 indexed maskIndex, string newName);
/**
* @dev Sets immutable values of contract.
*/
constructor (
bytes32 provenanceHash_,
address m26Address_,
uint256 nameChangePrice_,
uint256 saleStartTimestamp_,
uint256 revealTimestamp_,
address[] memory payees,
uint256[] memory shares_
) ERC721("Mars", "MARS") PaymentSplitter(payees, shares_) {
_provenanceHash = provenanceHash_;
_m26 = Mars26(m26Address_);
_nameChangePrice = nameChangePrice_;
_saleStartTimestamp = saleStartTimestamp_;
_revealTimestamp = revealTimestamp_;
_storage = new MarsStorage(MAX_SUPPLY);
}
/**
* @dev Returns provenance hash digest set during initialization of contract.
*
* The provenance hash is derived by concatenating all existing IPFS CIDs (v0)
* of the Mars NFTs and hashing the concatenated string using SHA2-256.
* Note that the CIDs were concatenated and hashed in their base58 representation.
*/
function provenanceHash() public view returns (bytes32) {
return _provenanceHash;
}
/**
* @dev Returns address of Mars26 ERC-20 token contract.
*/
function m26Address() public view returns (address) {
return address(_m26);
}
/**
* @dev Returns address of connected storage contract.
*/
function storageAddress() public view returns (address) {
return address(_storage);
}
/**
* @dev Returns the number of sold NFTs.
*/
function numSoldTokens() public view returns (uint256) {
return _numSoldTokens;
}
/**
* @dev Returns the MNCT price for changing the name of a token.
*/
function nameChangePrice() public view returns (uint256) {
return _nameChangePrice;
}
/**
* @dev Returns the start timestamp of the initial sale.
*/
function saleStartTimestamp() public view returns (uint256) {
return _saleStartTimestamp;
}
/**
* @dev Returns the reveal timestamp after which the token ids will be assigned.
*/
function revealTimestamp() public view returns (uint256) {
return _revealTimestamp;
}
/**
* @dev Returns the randomized starting index to assign and reveal token ids to
* intial sequence of NFTs.
*/
function startingIndex() public view returns (uint256) {
return _startingIndex;
}
/**
* @dev Returns the randomized starting index block which is used to derive
* {_startingIndex} from.
*/
function startingIndexBlock() public view returns (uint256) {
return _startingIndexBlock;
}
/**
* @dev See {MarsStorage.initialSequenceTokenCID}
*/
function initialSequenceTokenCID(uint256 initialSequenceIndex) public view returns (string memory) {
return _storage.initialSequenceTokenCID(initialSequenceIndex);
}
/**
* @dev Returns if {nameString} has been reserved.
*/
function isNameReserved(string memory nameString) public view returns (bool) {
return _reservedNames[_toLower(nameString)];
}
/**
* @dev Returns reverved name for given token id.
*/
function tokenNames(uint256 tokenId) public view returns (string memory) {
return _tokenNames[tokenId];
}
/**
* @dev Returns the set token URI, i.e. IPFS v0 CID, of {tokenId}.
* Prefixed with ipfs://
*/
function tokenURI(uint256 tokenId) public view override returns (string memory) {
require(_exists(tokenId), "ERC721URIStorage: URI query for nonexistent token");
require(_startingIndex > 0, "Tokens have not been assigned yet");
uint256 initialSequenceIndex = _toInitialSequenceIndex(tokenId);
return tokenURIOfInitialSequenceIndex(initialSequenceIndex);
}
/**
* @dev Returns the set token URI, i.e. IPFS v0 CID, of {initialSequenceIndex}.
* Prefixed with ipfs://
*/
function tokenURIOfInitialSequenceIndex(uint256 initialSequenceIndex) public view returns (string memory) {
require(_startingIndex > 0, "Tokens have not been assigned yet");
string memory tokenCID = initialSequenceTokenCID(initialSequenceIndex);
string memory base = _baseURI();
// If there is no base URI, return the token URI.
if (bytes(base).length == 0) {
return tokenCID;
}
// If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked).
if (bytes(tokenCID).length > 0) {
return string(abi.encodePacked(base, tokenCID));
}
return base;
}
/**
* @dev Returns if the NFT has been minted before reveal phase.
*/
function isMintedBeforeReveal(uint256 index) public view returns (bool) {
return _mintedBeforeReveal[index];
}
/**
* @dev Gets current NFT price based on already sold tokens.
*/
function getNFTPrice() public view returns (uint256) {
if (_numSoldTokens < 800) {
return 0.01 ether;
} else if (_numSoldTokens < 4400) {
return 0.02 ether;
} else if (_numSoldTokens < 8800) {
return 0.03 ether;
} else if (_numSoldTokens < 12600) {
return 0.05 ether;
} else if (_numSoldTokens < 14040) {
return 0.1 ether;
} else if (_numSoldTokens < 14392) {
return 0.3 ether;
} else {
return 1 ether;
}
}
/**
* @dev Mints Mars NFTs
*/
function mint(uint256 numberOfNfts) public payable {
require(block.timestamp >= _saleStartTimestamp, "Sale has not started");
require(totalSupply() < MAX_SUPPLY, "Sale has already ended");
require(numberOfNfts > 0, "Cannot buy 0 NFTs");
require(numberOfNfts <= 20, "You may not buy more than 20 NFTs at once");
require(_numSoldTokens.add(numberOfNfts) <= MAX_SUPPLY.sub(RESERVED_SUPPLY), "Exceeds max number of sellable NFTs");
require(getNFTPrice().mul(numberOfNfts) == msg.value, "Ether value sent is not correct");
for (uint i = 0; i < numberOfNfts; i++) {
uint mintIndex = totalSupply();
_numSoldTokens++;
require(mintIndex < MAX_SUPPLY, "Exceeds max number of NFTs in existence");
if (block.timestamp < _revealTimestamp) {
_mintedBeforeReveal[mintIndex] = true;
}
_safeMint(msg.sender, mintIndex);
}
// Source of randomness. Theoretical miner withhold manipulation possible but should be sufficient in a pragmatic sense
if (_startingIndexBlock == 0 && (_numSoldTokens >= MAX_SUPPLY.sub(RESERVED_SUPPLY) || block.timestamp >= _revealTimestamp)) {
_startingIndexBlock = block.number;
}
}
/**
* @dev Used to migrate already minted NFTs of old contract.
*/
function mintReserved(address to, uint256 numOfNFTs) public onlyOwner {
require(totalSupply().add(numOfNFTs) <= MAX_SUPPLY, "Exceeds max supply of NFTs");
require(_numMintedReservedTokens.add(numOfNFTs) <= RESERVED_SUPPLY, "Exceeds max num of reserved NFTs");
for (uint j = 0; j < numOfNFTs; j++) {
uint tokenId = totalSupply();
if (block.timestamp < _revealTimestamp) {
_mintedBeforeReveal[tokenId] = true;
}
_numMintedReservedTokens++;
_safeMint(to, tokenId);
}
}
/**
* @dev Finalize starting index
*/
function finalizeStartingIndex() public {
require(_startingIndex == 0, "Starting index is already set");
require(_startingIndexBlock != 0, "Starting index block must be set");
_startingIndex = uint(blockhash(_startingIndexBlock)) % MAX_SUPPLY;
// Just a sanity case in the worst case if this function is called late (EVM only stores last 256 block hashes)
if (block.number.sub(_startingIndexBlock) > 255) {
_startingIndex = uint(blockhash(block.number - 1)) % MAX_SUPPLY;
}
// Prevent default sequence
if (_startingIndex == 0) {
_startingIndex = _startingIndex.add(1);
}
}
/**
* @dev Changes the name for Mars tile tokenId
*/
function changeName(uint256 tokenId, string memory newName) public {
address owner = ownerOf(tokenId);
require(_msgSender() == owner, "ERC721: caller is not the owner");
require(_validateName(newName) == true, "Not a valid new name");
require(sha256(bytes(newName)) != sha256(bytes(_tokenNames[tokenId])), "New name is same as the current one");
require(isNameReserved(newName) == false, "Name already reserved");
_m26.transferFrom(msg.sender, address(this), _nameChangePrice);
// If already named, dereserve old name
if (bytes(_tokenNames[tokenId]).length > 0) {
_toggleReserveName(_tokenNames[tokenId], false);
}
_toggleReserveName(newName, true);
_tokenNames[tokenId] = newName;
_m26.burn(_nameChangePrice);
emit NameChange(tokenId, newName);
}
/**
* @dev See {MarsStorage.setInitialSequenceTokenHashes}
*/
function setInitialSequenceTokenHashes(bytes32[] memory tokenHashes) onlyOwner public {
_storage.setInitialSequenceTokenHashes(tokenHashes);
}
/**
* @dev See {MarsStorage.setInitialSequenceTokenHashesAtIndex}
*/
function setInitialSequenceTokenHashesAtIndex(
uint256 startIndex,
bytes32[] memory tokenHashes
) public onlyOwner {
_storage.setInitialSequenceTokenHashesAtIndex(startIndex, tokenHashes);
}
/**
* @dev Check if the name string is valid (Alphanumeric and spaces without leading or trailing space)
*/
function _validateName(string memory str) private pure returns (bool){
bytes memory b = bytes(str);
if (b.length < 1) return false;
if (b.length > 50) return false; // Cannot be longer than 25 characters
if (b[0] == 0x20) return false; // Leading space
if (b[b.length - 1] == 0x20) return false; // Trailing space
bytes1 lastChar = b[0];
for (uint i; i < b.length; i++) {
bytes1 char = b[i];
if (char == 0x20 && lastChar == 0x20) return false; // Cannot contain continous spaces
if (
!(char >= 0x30 && char <= 0x39) && //9-0
!(char >= 0x41 && char <= 0x5A) && //A-Z
!(char >= 0x61 && char <= 0x7A) && //a-z
!(char == 0x20) //space
)
return false;
lastChar = char;
}
return true;
}
/**
* @dev Converts the string to lowercase
*/
function _toLower(string memory str) private pure returns (string memory){
bytes memory bStr = bytes(str);
bytes memory bLower = new bytes(bStr.length);
for (uint i = 0; i < bStr.length; i++) {
// Uppercase character
if ((uint8(bStr[i]) >= 65) && (uint8(bStr[i]) <= 90)) {
bLower[i] = bytes1(uint8(bStr[i]) + 32);
} else {
bLower[i] = bStr[i];
}
}
return string(bLower);
}
/**
* @dev Reserves the name if isReserve is set to true, de-reserves if set to false
*/
function _toggleReserveName(string memory str, bool isReserve) internal {
_reservedNames[_toLower(str)] = isReserve;
}
function _baseURI() internal pure override returns (string memory) {
return "ipfs://";
}
function _toInitialSequenceIndex(uint256 tokenId) internal view returns (uint256) {
return (tokenId + _startingIndex) % MAX_SUPPLY;
}
} | /**
* @title Mars contract
* @dev Extends ERC721 Non-Fungible Token Standard basic implementation
*/ | NatSpecMultiLine | tokenNames | function tokenNames(uint256 tokenId) public view returns (string memory) {
return _tokenNames[tokenId];
}
| /**
* @dev Returns reverved name for given token id.
*/ | NatSpecMultiLine | v0.8.3+commit.8d00100c | {
"func_code_index": [
4039,
4163
]
} | 8,940 |
||
MarsLocker | contracts/Mars.sol | 0x64200351e787b33cd7c518a93fc24d780092f727 | Solidity | Mars | contract Mars is Ownable, ERC721Enumerable, PaymentSplitter {
using SafeMath for uint256;
uint256 public constant MAX_SUPPLY = 16200;
uint256 public constant RESERVED_SUPPLY = 1305 + 500;
bytes32 private _provenanceHash;
uint256 private _nameChangePrice;
uint256 private _saleStartTimestamp;
uint256 private _revealTimestamp;
uint256 private _startingIndexBlock;
uint256 internal _startingIndex;
uint256 private _numSoldTokens;
uint256 private _numMintedReservedTokens;
mapping (uint256 => string) private _tokenNames;
mapping (string => bool) private _reservedNames;
mapping (uint256 => bool) private _mintedBeforeReveal;
Mars26 private _m26;
MarsStorage private _storage;
event NameChange (uint256 indexed maskIndex, string newName);
/**
* @dev Sets immutable values of contract.
*/
constructor (
bytes32 provenanceHash_,
address m26Address_,
uint256 nameChangePrice_,
uint256 saleStartTimestamp_,
uint256 revealTimestamp_,
address[] memory payees,
uint256[] memory shares_
) ERC721("Mars", "MARS") PaymentSplitter(payees, shares_) {
_provenanceHash = provenanceHash_;
_m26 = Mars26(m26Address_);
_nameChangePrice = nameChangePrice_;
_saleStartTimestamp = saleStartTimestamp_;
_revealTimestamp = revealTimestamp_;
_storage = new MarsStorage(MAX_SUPPLY);
}
/**
* @dev Returns provenance hash digest set during initialization of contract.
*
* The provenance hash is derived by concatenating all existing IPFS CIDs (v0)
* of the Mars NFTs and hashing the concatenated string using SHA2-256.
* Note that the CIDs were concatenated and hashed in their base58 representation.
*/
function provenanceHash() public view returns (bytes32) {
return _provenanceHash;
}
/**
* @dev Returns address of Mars26 ERC-20 token contract.
*/
function m26Address() public view returns (address) {
return address(_m26);
}
/**
* @dev Returns address of connected storage contract.
*/
function storageAddress() public view returns (address) {
return address(_storage);
}
/**
* @dev Returns the number of sold NFTs.
*/
function numSoldTokens() public view returns (uint256) {
return _numSoldTokens;
}
/**
* @dev Returns the MNCT price for changing the name of a token.
*/
function nameChangePrice() public view returns (uint256) {
return _nameChangePrice;
}
/**
* @dev Returns the start timestamp of the initial sale.
*/
function saleStartTimestamp() public view returns (uint256) {
return _saleStartTimestamp;
}
/**
* @dev Returns the reveal timestamp after which the token ids will be assigned.
*/
function revealTimestamp() public view returns (uint256) {
return _revealTimestamp;
}
/**
* @dev Returns the randomized starting index to assign and reveal token ids to
* intial sequence of NFTs.
*/
function startingIndex() public view returns (uint256) {
return _startingIndex;
}
/**
* @dev Returns the randomized starting index block which is used to derive
* {_startingIndex} from.
*/
function startingIndexBlock() public view returns (uint256) {
return _startingIndexBlock;
}
/**
* @dev See {MarsStorage.initialSequenceTokenCID}
*/
function initialSequenceTokenCID(uint256 initialSequenceIndex) public view returns (string memory) {
return _storage.initialSequenceTokenCID(initialSequenceIndex);
}
/**
* @dev Returns if {nameString} has been reserved.
*/
function isNameReserved(string memory nameString) public view returns (bool) {
return _reservedNames[_toLower(nameString)];
}
/**
* @dev Returns reverved name for given token id.
*/
function tokenNames(uint256 tokenId) public view returns (string memory) {
return _tokenNames[tokenId];
}
/**
* @dev Returns the set token URI, i.e. IPFS v0 CID, of {tokenId}.
* Prefixed with ipfs://
*/
function tokenURI(uint256 tokenId) public view override returns (string memory) {
require(_exists(tokenId), "ERC721URIStorage: URI query for nonexistent token");
require(_startingIndex > 0, "Tokens have not been assigned yet");
uint256 initialSequenceIndex = _toInitialSequenceIndex(tokenId);
return tokenURIOfInitialSequenceIndex(initialSequenceIndex);
}
/**
* @dev Returns the set token URI, i.e. IPFS v0 CID, of {initialSequenceIndex}.
* Prefixed with ipfs://
*/
function tokenURIOfInitialSequenceIndex(uint256 initialSequenceIndex) public view returns (string memory) {
require(_startingIndex > 0, "Tokens have not been assigned yet");
string memory tokenCID = initialSequenceTokenCID(initialSequenceIndex);
string memory base = _baseURI();
// If there is no base URI, return the token URI.
if (bytes(base).length == 0) {
return tokenCID;
}
// If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked).
if (bytes(tokenCID).length > 0) {
return string(abi.encodePacked(base, tokenCID));
}
return base;
}
/**
* @dev Returns if the NFT has been minted before reveal phase.
*/
function isMintedBeforeReveal(uint256 index) public view returns (bool) {
return _mintedBeforeReveal[index];
}
/**
* @dev Gets current NFT price based on already sold tokens.
*/
function getNFTPrice() public view returns (uint256) {
if (_numSoldTokens < 800) {
return 0.01 ether;
} else if (_numSoldTokens < 4400) {
return 0.02 ether;
} else if (_numSoldTokens < 8800) {
return 0.03 ether;
} else if (_numSoldTokens < 12600) {
return 0.05 ether;
} else if (_numSoldTokens < 14040) {
return 0.1 ether;
} else if (_numSoldTokens < 14392) {
return 0.3 ether;
} else {
return 1 ether;
}
}
/**
* @dev Mints Mars NFTs
*/
function mint(uint256 numberOfNfts) public payable {
require(block.timestamp >= _saleStartTimestamp, "Sale has not started");
require(totalSupply() < MAX_SUPPLY, "Sale has already ended");
require(numberOfNfts > 0, "Cannot buy 0 NFTs");
require(numberOfNfts <= 20, "You may not buy more than 20 NFTs at once");
require(_numSoldTokens.add(numberOfNfts) <= MAX_SUPPLY.sub(RESERVED_SUPPLY), "Exceeds max number of sellable NFTs");
require(getNFTPrice().mul(numberOfNfts) == msg.value, "Ether value sent is not correct");
for (uint i = 0; i < numberOfNfts; i++) {
uint mintIndex = totalSupply();
_numSoldTokens++;
require(mintIndex < MAX_SUPPLY, "Exceeds max number of NFTs in existence");
if (block.timestamp < _revealTimestamp) {
_mintedBeforeReveal[mintIndex] = true;
}
_safeMint(msg.sender, mintIndex);
}
// Source of randomness. Theoretical miner withhold manipulation possible but should be sufficient in a pragmatic sense
if (_startingIndexBlock == 0 && (_numSoldTokens >= MAX_SUPPLY.sub(RESERVED_SUPPLY) || block.timestamp >= _revealTimestamp)) {
_startingIndexBlock = block.number;
}
}
/**
* @dev Used to migrate already minted NFTs of old contract.
*/
function mintReserved(address to, uint256 numOfNFTs) public onlyOwner {
require(totalSupply().add(numOfNFTs) <= MAX_SUPPLY, "Exceeds max supply of NFTs");
require(_numMintedReservedTokens.add(numOfNFTs) <= RESERVED_SUPPLY, "Exceeds max num of reserved NFTs");
for (uint j = 0; j < numOfNFTs; j++) {
uint tokenId = totalSupply();
if (block.timestamp < _revealTimestamp) {
_mintedBeforeReveal[tokenId] = true;
}
_numMintedReservedTokens++;
_safeMint(to, tokenId);
}
}
/**
* @dev Finalize starting index
*/
function finalizeStartingIndex() public {
require(_startingIndex == 0, "Starting index is already set");
require(_startingIndexBlock != 0, "Starting index block must be set");
_startingIndex = uint(blockhash(_startingIndexBlock)) % MAX_SUPPLY;
// Just a sanity case in the worst case if this function is called late (EVM only stores last 256 block hashes)
if (block.number.sub(_startingIndexBlock) > 255) {
_startingIndex = uint(blockhash(block.number - 1)) % MAX_SUPPLY;
}
// Prevent default sequence
if (_startingIndex == 0) {
_startingIndex = _startingIndex.add(1);
}
}
/**
* @dev Changes the name for Mars tile tokenId
*/
function changeName(uint256 tokenId, string memory newName) public {
address owner = ownerOf(tokenId);
require(_msgSender() == owner, "ERC721: caller is not the owner");
require(_validateName(newName) == true, "Not a valid new name");
require(sha256(bytes(newName)) != sha256(bytes(_tokenNames[tokenId])), "New name is same as the current one");
require(isNameReserved(newName) == false, "Name already reserved");
_m26.transferFrom(msg.sender, address(this), _nameChangePrice);
// If already named, dereserve old name
if (bytes(_tokenNames[tokenId]).length > 0) {
_toggleReserveName(_tokenNames[tokenId], false);
}
_toggleReserveName(newName, true);
_tokenNames[tokenId] = newName;
_m26.burn(_nameChangePrice);
emit NameChange(tokenId, newName);
}
/**
* @dev See {MarsStorage.setInitialSequenceTokenHashes}
*/
function setInitialSequenceTokenHashes(bytes32[] memory tokenHashes) onlyOwner public {
_storage.setInitialSequenceTokenHashes(tokenHashes);
}
/**
* @dev See {MarsStorage.setInitialSequenceTokenHashesAtIndex}
*/
function setInitialSequenceTokenHashesAtIndex(
uint256 startIndex,
bytes32[] memory tokenHashes
) public onlyOwner {
_storage.setInitialSequenceTokenHashesAtIndex(startIndex, tokenHashes);
}
/**
* @dev Check if the name string is valid (Alphanumeric and spaces without leading or trailing space)
*/
function _validateName(string memory str) private pure returns (bool){
bytes memory b = bytes(str);
if (b.length < 1) return false;
if (b.length > 50) return false; // Cannot be longer than 25 characters
if (b[0] == 0x20) return false; // Leading space
if (b[b.length - 1] == 0x20) return false; // Trailing space
bytes1 lastChar = b[0];
for (uint i; i < b.length; i++) {
bytes1 char = b[i];
if (char == 0x20 && lastChar == 0x20) return false; // Cannot contain continous spaces
if (
!(char >= 0x30 && char <= 0x39) && //9-0
!(char >= 0x41 && char <= 0x5A) && //A-Z
!(char >= 0x61 && char <= 0x7A) && //a-z
!(char == 0x20) //space
)
return false;
lastChar = char;
}
return true;
}
/**
* @dev Converts the string to lowercase
*/
function _toLower(string memory str) private pure returns (string memory){
bytes memory bStr = bytes(str);
bytes memory bLower = new bytes(bStr.length);
for (uint i = 0; i < bStr.length; i++) {
// Uppercase character
if ((uint8(bStr[i]) >= 65) && (uint8(bStr[i]) <= 90)) {
bLower[i] = bytes1(uint8(bStr[i]) + 32);
} else {
bLower[i] = bStr[i];
}
}
return string(bLower);
}
/**
* @dev Reserves the name if isReserve is set to true, de-reserves if set to false
*/
function _toggleReserveName(string memory str, bool isReserve) internal {
_reservedNames[_toLower(str)] = isReserve;
}
function _baseURI() internal pure override returns (string memory) {
return "ipfs://";
}
function _toInitialSequenceIndex(uint256 tokenId) internal view returns (uint256) {
return (tokenId + _startingIndex) % MAX_SUPPLY;
}
} | /**
* @title Mars contract
* @dev Extends ERC721 Non-Fungible Token Standard basic implementation
*/ | NatSpecMultiLine | tokenURI | function tokenURI(uint256 tokenId) public view override returns (string memory) {
require(_exists(tokenId), "ERC721URIStorage: URI query for nonexistent token");
require(_startingIndex > 0, "Tokens have not been assigned yet");
uint256 initialSequenceIndex = _toInitialSequenceIndex(tokenId);
return tokenURIOfInitialSequenceIndex(initialSequenceIndex);
}
| /**
* @dev Returns the set token URI, i.e. IPFS v0 CID, of {tokenId}.
* Prefixed with ipfs://
*/ | NatSpecMultiLine | v0.8.3+commit.8d00100c | {
"func_code_index": [
4281,
4677
]
} | 8,941 |
||
MarsLocker | contracts/Mars.sol | 0x64200351e787b33cd7c518a93fc24d780092f727 | Solidity | Mars | contract Mars is Ownable, ERC721Enumerable, PaymentSplitter {
using SafeMath for uint256;
uint256 public constant MAX_SUPPLY = 16200;
uint256 public constant RESERVED_SUPPLY = 1305 + 500;
bytes32 private _provenanceHash;
uint256 private _nameChangePrice;
uint256 private _saleStartTimestamp;
uint256 private _revealTimestamp;
uint256 private _startingIndexBlock;
uint256 internal _startingIndex;
uint256 private _numSoldTokens;
uint256 private _numMintedReservedTokens;
mapping (uint256 => string) private _tokenNames;
mapping (string => bool) private _reservedNames;
mapping (uint256 => bool) private _mintedBeforeReveal;
Mars26 private _m26;
MarsStorage private _storage;
event NameChange (uint256 indexed maskIndex, string newName);
/**
* @dev Sets immutable values of contract.
*/
constructor (
bytes32 provenanceHash_,
address m26Address_,
uint256 nameChangePrice_,
uint256 saleStartTimestamp_,
uint256 revealTimestamp_,
address[] memory payees,
uint256[] memory shares_
) ERC721("Mars", "MARS") PaymentSplitter(payees, shares_) {
_provenanceHash = provenanceHash_;
_m26 = Mars26(m26Address_);
_nameChangePrice = nameChangePrice_;
_saleStartTimestamp = saleStartTimestamp_;
_revealTimestamp = revealTimestamp_;
_storage = new MarsStorage(MAX_SUPPLY);
}
/**
* @dev Returns provenance hash digest set during initialization of contract.
*
* The provenance hash is derived by concatenating all existing IPFS CIDs (v0)
* of the Mars NFTs and hashing the concatenated string using SHA2-256.
* Note that the CIDs were concatenated and hashed in their base58 representation.
*/
function provenanceHash() public view returns (bytes32) {
return _provenanceHash;
}
/**
* @dev Returns address of Mars26 ERC-20 token contract.
*/
function m26Address() public view returns (address) {
return address(_m26);
}
/**
* @dev Returns address of connected storage contract.
*/
function storageAddress() public view returns (address) {
return address(_storage);
}
/**
* @dev Returns the number of sold NFTs.
*/
function numSoldTokens() public view returns (uint256) {
return _numSoldTokens;
}
/**
* @dev Returns the MNCT price for changing the name of a token.
*/
function nameChangePrice() public view returns (uint256) {
return _nameChangePrice;
}
/**
* @dev Returns the start timestamp of the initial sale.
*/
function saleStartTimestamp() public view returns (uint256) {
return _saleStartTimestamp;
}
/**
* @dev Returns the reveal timestamp after which the token ids will be assigned.
*/
function revealTimestamp() public view returns (uint256) {
return _revealTimestamp;
}
/**
* @dev Returns the randomized starting index to assign and reveal token ids to
* intial sequence of NFTs.
*/
function startingIndex() public view returns (uint256) {
return _startingIndex;
}
/**
* @dev Returns the randomized starting index block which is used to derive
* {_startingIndex} from.
*/
function startingIndexBlock() public view returns (uint256) {
return _startingIndexBlock;
}
/**
* @dev See {MarsStorage.initialSequenceTokenCID}
*/
function initialSequenceTokenCID(uint256 initialSequenceIndex) public view returns (string memory) {
return _storage.initialSequenceTokenCID(initialSequenceIndex);
}
/**
* @dev Returns if {nameString} has been reserved.
*/
function isNameReserved(string memory nameString) public view returns (bool) {
return _reservedNames[_toLower(nameString)];
}
/**
* @dev Returns reverved name for given token id.
*/
function tokenNames(uint256 tokenId) public view returns (string memory) {
return _tokenNames[tokenId];
}
/**
* @dev Returns the set token URI, i.e. IPFS v0 CID, of {tokenId}.
* Prefixed with ipfs://
*/
function tokenURI(uint256 tokenId) public view override returns (string memory) {
require(_exists(tokenId), "ERC721URIStorage: URI query for nonexistent token");
require(_startingIndex > 0, "Tokens have not been assigned yet");
uint256 initialSequenceIndex = _toInitialSequenceIndex(tokenId);
return tokenURIOfInitialSequenceIndex(initialSequenceIndex);
}
/**
* @dev Returns the set token URI, i.e. IPFS v0 CID, of {initialSequenceIndex}.
* Prefixed with ipfs://
*/
function tokenURIOfInitialSequenceIndex(uint256 initialSequenceIndex) public view returns (string memory) {
require(_startingIndex > 0, "Tokens have not been assigned yet");
string memory tokenCID = initialSequenceTokenCID(initialSequenceIndex);
string memory base = _baseURI();
// If there is no base URI, return the token URI.
if (bytes(base).length == 0) {
return tokenCID;
}
// If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked).
if (bytes(tokenCID).length > 0) {
return string(abi.encodePacked(base, tokenCID));
}
return base;
}
/**
* @dev Returns if the NFT has been minted before reveal phase.
*/
function isMintedBeforeReveal(uint256 index) public view returns (bool) {
return _mintedBeforeReveal[index];
}
/**
* @dev Gets current NFT price based on already sold tokens.
*/
function getNFTPrice() public view returns (uint256) {
if (_numSoldTokens < 800) {
return 0.01 ether;
} else if (_numSoldTokens < 4400) {
return 0.02 ether;
} else if (_numSoldTokens < 8800) {
return 0.03 ether;
} else if (_numSoldTokens < 12600) {
return 0.05 ether;
} else if (_numSoldTokens < 14040) {
return 0.1 ether;
} else if (_numSoldTokens < 14392) {
return 0.3 ether;
} else {
return 1 ether;
}
}
/**
* @dev Mints Mars NFTs
*/
function mint(uint256 numberOfNfts) public payable {
require(block.timestamp >= _saleStartTimestamp, "Sale has not started");
require(totalSupply() < MAX_SUPPLY, "Sale has already ended");
require(numberOfNfts > 0, "Cannot buy 0 NFTs");
require(numberOfNfts <= 20, "You may not buy more than 20 NFTs at once");
require(_numSoldTokens.add(numberOfNfts) <= MAX_SUPPLY.sub(RESERVED_SUPPLY), "Exceeds max number of sellable NFTs");
require(getNFTPrice().mul(numberOfNfts) == msg.value, "Ether value sent is not correct");
for (uint i = 0; i < numberOfNfts; i++) {
uint mintIndex = totalSupply();
_numSoldTokens++;
require(mintIndex < MAX_SUPPLY, "Exceeds max number of NFTs in existence");
if (block.timestamp < _revealTimestamp) {
_mintedBeforeReveal[mintIndex] = true;
}
_safeMint(msg.sender, mintIndex);
}
// Source of randomness. Theoretical miner withhold manipulation possible but should be sufficient in a pragmatic sense
if (_startingIndexBlock == 0 && (_numSoldTokens >= MAX_SUPPLY.sub(RESERVED_SUPPLY) || block.timestamp >= _revealTimestamp)) {
_startingIndexBlock = block.number;
}
}
/**
* @dev Used to migrate already minted NFTs of old contract.
*/
function mintReserved(address to, uint256 numOfNFTs) public onlyOwner {
require(totalSupply().add(numOfNFTs) <= MAX_SUPPLY, "Exceeds max supply of NFTs");
require(_numMintedReservedTokens.add(numOfNFTs) <= RESERVED_SUPPLY, "Exceeds max num of reserved NFTs");
for (uint j = 0; j < numOfNFTs; j++) {
uint tokenId = totalSupply();
if (block.timestamp < _revealTimestamp) {
_mintedBeforeReveal[tokenId] = true;
}
_numMintedReservedTokens++;
_safeMint(to, tokenId);
}
}
/**
* @dev Finalize starting index
*/
function finalizeStartingIndex() public {
require(_startingIndex == 0, "Starting index is already set");
require(_startingIndexBlock != 0, "Starting index block must be set");
_startingIndex = uint(blockhash(_startingIndexBlock)) % MAX_SUPPLY;
// Just a sanity case in the worst case if this function is called late (EVM only stores last 256 block hashes)
if (block.number.sub(_startingIndexBlock) > 255) {
_startingIndex = uint(blockhash(block.number - 1)) % MAX_SUPPLY;
}
// Prevent default sequence
if (_startingIndex == 0) {
_startingIndex = _startingIndex.add(1);
}
}
/**
* @dev Changes the name for Mars tile tokenId
*/
function changeName(uint256 tokenId, string memory newName) public {
address owner = ownerOf(tokenId);
require(_msgSender() == owner, "ERC721: caller is not the owner");
require(_validateName(newName) == true, "Not a valid new name");
require(sha256(bytes(newName)) != sha256(bytes(_tokenNames[tokenId])), "New name is same as the current one");
require(isNameReserved(newName) == false, "Name already reserved");
_m26.transferFrom(msg.sender, address(this), _nameChangePrice);
// If already named, dereserve old name
if (bytes(_tokenNames[tokenId]).length > 0) {
_toggleReserveName(_tokenNames[tokenId], false);
}
_toggleReserveName(newName, true);
_tokenNames[tokenId] = newName;
_m26.burn(_nameChangePrice);
emit NameChange(tokenId, newName);
}
/**
* @dev See {MarsStorage.setInitialSequenceTokenHashes}
*/
function setInitialSequenceTokenHashes(bytes32[] memory tokenHashes) onlyOwner public {
_storage.setInitialSequenceTokenHashes(tokenHashes);
}
/**
* @dev See {MarsStorage.setInitialSequenceTokenHashesAtIndex}
*/
function setInitialSequenceTokenHashesAtIndex(
uint256 startIndex,
bytes32[] memory tokenHashes
) public onlyOwner {
_storage.setInitialSequenceTokenHashesAtIndex(startIndex, tokenHashes);
}
/**
* @dev Check if the name string is valid (Alphanumeric and spaces without leading or trailing space)
*/
function _validateName(string memory str) private pure returns (bool){
bytes memory b = bytes(str);
if (b.length < 1) return false;
if (b.length > 50) return false; // Cannot be longer than 25 characters
if (b[0] == 0x20) return false; // Leading space
if (b[b.length - 1] == 0x20) return false; // Trailing space
bytes1 lastChar = b[0];
for (uint i; i < b.length; i++) {
bytes1 char = b[i];
if (char == 0x20 && lastChar == 0x20) return false; // Cannot contain continous spaces
if (
!(char >= 0x30 && char <= 0x39) && //9-0
!(char >= 0x41 && char <= 0x5A) && //A-Z
!(char >= 0x61 && char <= 0x7A) && //a-z
!(char == 0x20) //space
)
return false;
lastChar = char;
}
return true;
}
/**
* @dev Converts the string to lowercase
*/
function _toLower(string memory str) private pure returns (string memory){
bytes memory bStr = bytes(str);
bytes memory bLower = new bytes(bStr.length);
for (uint i = 0; i < bStr.length; i++) {
// Uppercase character
if ((uint8(bStr[i]) >= 65) && (uint8(bStr[i]) <= 90)) {
bLower[i] = bytes1(uint8(bStr[i]) + 32);
} else {
bLower[i] = bStr[i];
}
}
return string(bLower);
}
/**
* @dev Reserves the name if isReserve is set to true, de-reserves if set to false
*/
function _toggleReserveName(string memory str, bool isReserve) internal {
_reservedNames[_toLower(str)] = isReserve;
}
function _baseURI() internal pure override returns (string memory) {
return "ipfs://";
}
function _toInitialSequenceIndex(uint256 tokenId) internal view returns (uint256) {
return (tokenId + _startingIndex) % MAX_SUPPLY;
}
} | /**
* @title Mars contract
* @dev Extends ERC721 Non-Fungible Token Standard basic implementation
*/ | NatSpecMultiLine | tokenURIOfInitialSequenceIndex | function tokenURIOfInitialSequenceIndex(uint256 initialSequenceIndex) public view returns (string memory) {
require(_startingIndex > 0, "Tokens have not been assigned yet");
string memory tokenCID = initialSequenceTokenCID(initialSequenceIndex);
string memory base = _baseURI();
// If there is no base URI, return the token URI.
if (bytes(base).length == 0) {
return tokenCID;
}
// If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked).
if (bytes(tokenCID).length > 0) {
return string(abi.encodePacked(base, tokenCID));
}
return base;
}
| /**
* @dev Returns the set token URI, i.e. IPFS v0 CID, of {initialSequenceIndex}.
* Prefixed with ipfs://
*/ | NatSpecMultiLine | v0.8.3+commit.8d00100c | {
"func_code_index": [
4808,
5482
]
} | 8,942 |
||
MarsLocker | contracts/Mars.sol | 0x64200351e787b33cd7c518a93fc24d780092f727 | Solidity | Mars | contract Mars is Ownable, ERC721Enumerable, PaymentSplitter {
using SafeMath for uint256;
uint256 public constant MAX_SUPPLY = 16200;
uint256 public constant RESERVED_SUPPLY = 1305 + 500;
bytes32 private _provenanceHash;
uint256 private _nameChangePrice;
uint256 private _saleStartTimestamp;
uint256 private _revealTimestamp;
uint256 private _startingIndexBlock;
uint256 internal _startingIndex;
uint256 private _numSoldTokens;
uint256 private _numMintedReservedTokens;
mapping (uint256 => string) private _tokenNames;
mapping (string => bool) private _reservedNames;
mapping (uint256 => bool) private _mintedBeforeReveal;
Mars26 private _m26;
MarsStorage private _storage;
event NameChange (uint256 indexed maskIndex, string newName);
/**
* @dev Sets immutable values of contract.
*/
constructor (
bytes32 provenanceHash_,
address m26Address_,
uint256 nameChangePrice_,
uint256 saleStartTimestamp_,
uint256 revealTimestamp_,
address[] memory payees,
uint256[] memory shares_
) ERC721("Mars", "MARS") PaymentSplitter(payees, shares_) {
_provenanceHash = provenanceHash_;
_m26 = Mars26(m26Address_);
_nameChangePrice = nameChangePrice_;
_saleStartTimestamp = saleStartTimestamp_;
_revealTimestamp = revealTimestamp_;
_storage = new MarsStorage(MAX_SUPPLY);
}
/**
* @dev Returns provenance hash digest set during initialization of contract.
*
* The provenance hash is derived by concatenating all existing IPFS CIDs (v0)
* of the Mars NFTs and hashing the concatenated string using SHA2-256.
* Note that the CIDs were concatenated and hashed in their base58 representation.
*/
function provenanceHash() public view returns (bytes32) {
return _provenanceHash;
}
/**
* @dev Returns address of Mars26 ERC-20 token contract.
*/
function m26Address() public view returns (address) {
return address(_m26);
}
/**
* @dev Returns address of connected storage contract.
*/
function storageAddress() public view returns (address) {
return address(_storage);
}
/**
* @dev Returns the number of sold NFTs.
*/
function numSoldTokens() public view returns (uint256) {
return _numSoldTokens;
}
/**
* @dev Returns the MNCT price for changing the name of a token.
*/
function nameChangePrice() public view returns (uint256) {
return _nameChangePrice;
}
/**
* @dev Returns the start timestamp of the initial sale.
*/
function saleStartTimestamp() public view returns (uint256) {
return _saleStartTimestamp;
}
/**
* @dev Returns the reveal timestamp after which the token ids will be assigned.
*/
function revealTimestamp() public view returns (uint256) {
return _revealTimestamp;
}
/**
* @dev Returns the randomized starting index to assign and reveal token ids to
* intial sequence of NFTs.
*/
function startingIndex() public view returns (uint256) {
return _startingIndex;
}
/**
* @dev Returns the randomized starting index block which is used to derive
* {_startingIndex} from.
*/
function startingIndexBlock() public view returns (uint256) {
return _startingIndexBlock;
}
/**
* @dev See {MarsStorage.initialSequenceTokenCID}
*/
function initialSequenceTokenCID(uint256 initialSequenceIndex) public view returns (string memory) {
return _storage.initialSequenceTokenCID(initialSequenceIndex);
}
/**
* @dev Returns if {nameString} has been reserved.
*/
function isNameReserved(string memory nameString) public view returns (bool) {
return _reservedNames[_toLower(nameString)];
}
/**
* @dev Returns reverved name for given token id.
*/
function tokenNames(uint256 tokenId) public view returns (string memory) {
return _tokenNames[tokenId];
}
/**
* @dev Returns the set token URI, i.e. IPFS v0 CID, of {tokenId}.
* Prefixed with ipfs://
*/
function tokenURI(uint256 tokenId) public view override returns (string memory) {
require(_exists(tokenId), "ERC721URIStorage: URI query for nonexistent token");
require(_startingIndex > 0, "Tokens have not been assigned yet");
uint256 initialSequenceIndex = _toInitialSequenceIndex(tokenId);
return tokenURIOfInitialSequenceIndex(initialSequenceIndex);
}
/**
* @dev Returns the set token URI, i.e. IPFS v0 CID, of {initialSequenceIndex}.
* Prefixed with ipfs://
*/
function tokenURIOfInitialSequenceIndex(uint256 initialSequenceIndex) public view returns (string memory) {
require(_startingIndex > 0, "Tokens have not been assigned yet");
string memory tokenCID = initialSequenceTokenCID(initialSequenceIndex);
string memory base = _baseURI();
// If there is no base URI, return the token URI.
if (bytes(base).length == 0) {
return tokenCID;
}
// If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked).
if (bytes(tokenCID).length > 0) {
return string(abi.encodePacked(base, tokenCID));
}
return base;
}
/**
* @dev Returns if the NFT has been minted before reveal phase.
*/
function isMintedBeforeReveal(uint256 index) public view returns (bool) {
return _mintedBeforeReveal[index];
}
/**
* @dev Gets current NFT price based on already sold tokens.
*/
function getNFTPrice() public view returns (uint256) {
if (_numSoldTokens < 800) {
return 0.01 ether;
} else if (_numSoldTokens < 4400) {
return 0.02 ether;
} else if (_numSoldTokens < 8800) {
return 0.03 ether;
} else if (_numSoldTokens < 12600) {
return 0.05 ether;
} else if (_numSoldTokens < 14040) {
return 0.1 ether;
} else if (_numSoldTokens < 14392) {
return 0.3 ether;
} else {
return 1 ether;
}
}
/**
* @dev Mints Mars NFTs
*/
function mint(uint256 numberOfNfts) public payable {
require(block.timestamp >= _saleStartTimestamp, "Sale has not started");
require(totalSupply() < MAX_SUPPLY, "Sale has already ended");
require(numberOfNfts > 0, "Cannot buy 0 NFTs");
require(numberOfNfts <= 20, "You may not buy more than 20 NFTs at once");
require(_numSoldTokens.add(numberOfNfts) <= MAX_SUPPLY.sub(RESERVED_SUPPLY), "Exceeds max number of sellable NFTs");
require(getNFTPrice().mul(numberOfNfts) == msg.value, "Ether value sent is not correct");
for (uint i = 0; i < numberOfNfts; i++) {
uint mintIndex = totalSupply();
_numSoldTokens++;
require(mintIndex < MAX_SUPPLY, "Exceeds max number of NFTs in existence");
if (block.timestamp < _revealTimestamp) {
_mintedBeforeReveal[mintIndex] = true;
}
_safeMint(msg.sender, mintIndex);
}
// Source of randomness. Theoretical miner withhold manipulation possible but should be sufficient in a pragmatic sense
if (_startingIndexBlock == 0 && (_numSoldTokens >= MAX_SUPPLY.sub(RESERVED_SUPPLY) || block.timestamp >= _revealTimestamp)) {
_startingIndexBlock = block.number;
}
}
/**
* @dev Used to migrate already minted NFTs of old contract.
*/
function mintReserved(address to, uint256 numOfNFTs) public onlyOwner {
require(totalSupply().add(numOfNFTs) <= MAX_SUPPLY, "Exceeds max supply of NFTs");
require(_numMintedReservedTokens.add(numOfNFTs) <= RESERVED_SUPPLY, "Exceeds max num of reserved NFTs");
for (uint j = 0; j < numOfNFTs; j++) {
uint tokenId = totalSupply();
if (block.timestamp < _revealTimestamp) {
_mintedBeforeReveal[tokenId] = true;
}
_numMintedReservedTokens++;
_safeMint(to, tokenId);
}
}
/**
* @dev Finalize starting index
*/
function finalizeStartingIndex() public {
require(_startingIndex == 0, "Starting index is already set");
require(_startingIndexBlock != 0, "Starting index block must be set");
_startingIndex = uint(blockhash(_startingIndexBlock)) % MAX_SUPPLY;
// Just a sanity case in the worst case if this function is called late (EVM only stores last 256 block hashes)
if (block.number.sub(_startingIndexBlock) > 255) {
_startingIndex = uint(blockhash(block.number - 1)) % MAX_SUPPLY;
}
// Prevent default sequence
if (_startingIndex == 0) {
_startingIndex = _startingIndex.add(1);
}
}
/**
* @dev Changes the name for Mars tile tokenId
*/
function changeName(uint256 tokenId, string memory newName) public {
address owner = ownerOf(tokenId);
require(_msgSender() == owner, "ERC721: caller is not the owner");
require(_validateName(newName) == true, "Not a valid new name");
require(sha256(bytes(newName)) != sha256(bytes(_tokenNames[tokenId])), "New name is same as the current one");
require(isNameReserved(newName) == false, "Name already reserved");
_m26.transferFrom(msg.sender, address(this), _nameChangePrice);
// If already named, dereserve old name
if (bytes(_tokenNames[tokenId]).length > 0) {
_toggleReserveName(_tokenNames[tokenId], false);
}
_toggleReserveName(newName, true);
_tokenNames[tokenId] = newName;
_m26.burn(_nameChangePrice);
emit NameChange(tokenId, newName);
}
/**
* @dev See {MarsStorage.setInitialSequenceTokenHashes}
*/
function setInitialSequenceTokenHashes(bytes32[] memory tokenHashes) onlyOwner public {
_storage.setInitialSequenceTokenHashes(tokenHashes);
}
/**
* @dev See {MarsStorage.setInitialSequenceTokenHashesAtIndex}
*/
function setInitialSequenceTokenHashesAtIndex(
uint256 startIndex,
bytes32[] memory tokenHashes
) public onlyOwner {
_storage.setInitialSequenceTokenHashesAtIndex(startIndex, tokenHashes);
}
/**
* @dev Check if the name string is valid (Alphanumeric and spaces without leading or trailing space)
*/
function _validateName(string memory str) private pure returns (bool){
bytes memory b = bytes(str);
if (b.length < 1) return false;
if (b.length > 50) return false; // Cannot be longer than 25 characters
if (b[0] == 0x20) return false; // Leading space
if (b[b.length - 1] == 0x20) return false; // Trailing space
bytes1 lastChar = b[0];
for (uint i; i < b.length; i++) {
bytes1 char = b[i];
if (char == 0x20 && lastChar == 0x20) return false; // Cannot contain continous spaces
if (
!(char >= 0x30 && char <= 0x39) && //9-0
!(char >= 0x41 && char <= 0x5A) && //A-Z
!(char >= 0x61 && char <= 0x7A) && //a-z
!(char == 0x20) //space
)
return false;
lastChar = char;
}
return true;
}
/**
* @dev Converts the string to lowercase
*/
function _toLower(string memory str) private pure returns (string memory){
bytes memory bStr = bytes(str);
bytes memory bLower = new bytes(bStr.length);
for (uint i = 0; i < bStr.length; i++) {
// Uppercase character
if ((uint8(bStr[i]) >= 65) && (uint8(bStr[i]) <= 90)) {
bLower[i] = bytes1(uint8(bStr[i]) + 32);
} else {
bLower[i] = bStr[i];
}
}
return string(bLower);
}
/**
* @dev Reserves the name if isReserve is set to true, de-reserves if set to false
*/
function _toggleReserveName(string memory str, bool isReserve) internal {
_reservedNames[_toLower(str)] = isReserve;
}
function _baseURI() internal pure override returns (string memory) {
return "ipfs://";
}
function _toInitialSequenceIndex(uint256 tokenId) internal view returns (uint256) {
return (tokenId + _startingIndex) % MAX_SUPPLY;
}
} | /**
* @title Mars contract
* @dev Extends ERC721 Non-Fungible Token Standard basic implementation
*/ | NatSpecMultiLine | isMintedBeforeReveal | function isMintedBeforeReveal(uint256 index) public view returns (bool) {
return _mintedBeforeReveal[index];
}
| /**
* @dev Returns if the NFT has been minted before reveal phase.
*/ | NatSpecMultiLine | v0.8.3+commit.8d00100c | {
"func_code_index": [
5568,
5694
]
} | 8,943 |
||
MarsLocker | contracts/Mars.sol | 0x64200351e787b33cd7c518a93fc24d780092f727 | Solidity | Mars | contract Mars is Ownable, ERC721Enumerable, PaymentSplitter {
using SafeMath for uint256;
uint256 public constant MAX_SUPPLY = 16200;
uint256 public constant RESERVED_SUPPLY = 1305 + 500;
bytes32 private _provenanceHash;
uint256 private _nameChangePrice;
uint256 private _saleStartTimestamp;
uint256 private _revealTimestamp;
uint256 private _startingIndexBlock;
uint256 internal _startingIndex;
uint256 private _numSoldTokens;
uint256 private _numMintedReservedTokens;
mapping (uint256 => string) private _tokenNames;
mapping (string => bool) private _reservedNames;
mapping (uint256 => bool) private _mintedBeforeReveal;
Mars26 private _m26;
MarsStorage private _storage;
event NameChange (uint256 indexed maskIndex, string newName);
/**
* @dev Sets immutable values of contract.
*/
constructor (
bytes32 provenanceHash_,
address m26Address_,
uint256 nameChangePrice_,
uint256 saleStartTimestamp_,
uint256 revealTimestamp_,
address[] memory payees,
uint256[] memory shares_
) ERC721("Mars", "MARS") PaymentSplitter(payees, shares_) {
_provenanceHash = provenanceHash_;
_m26 = Mars26(m26Address_);
_nameChangePrice = nameChangePrice_;
_saleStartTimestamp = saleStartTimestamp_;
_revealTimestamp = revealTimestamp_;
_storage = new MarsStorage(MAX_SUPPLY);
}
/**
* @dev Returns provenance hash digest set during initialization of contract.
*
* The provenance hash is derived by concatenating all existing IPFS CIDs (v0)
* of the Mars NFTs and hashing the concatenated string using SHA2-256.
* Note that the CIDs were concatenated and hashed in their base58 representation.
*/
function provenanceHash() public view returns (bytes32) {
return _provenanceHash;
}
/**
* @dev Returns address of Mars26 ERC-20 token contract.
*/
function m26Address() public view returns (address) {
return address(_m26);
}
/**
* @dev Returns address of connected storage contract.
*/
function storageAddress() public view returns (address) {
return address(_storage);
}
/**
* @dev Returns the number of sold NFTs.
*/
function numSoldTokens() public view returns (uint256) {
return _numSoldTokens;
}
/**
* @dev Returns the MNCT price for changing the name of a token.
*/
function nameChangePrice() public view returns (uint256) {
return _nameChangePrice;
}
/**
* @dev Returns the start timestamp of the initial sale.
*/
function saleStartTimestamp() public view returns (uint256) {
return _saleStartTimestamp;
}
/**
* @dev Returns the reveal timestamp after which the token ids will be assigned.
*/
function revealTimestamp() public view returns (uint256) {
return _revealTimestamp;
}
/**
* @dev Returns the randomized starting index to assign and reveal token ids to
* intial sequence of NFTs.
*/
function startingIndex() public view returns (uint256) {
return _startingIndex;
}
/**
* @dev Returns the randomized starting index block which is used to derive
* {_startingIndex} from.
*/
function startingIndexBlock() public view returns (uint256) {
return _startingIndexBlock;
}
/**
* @dev See {MarsStorage.initialSequenceTokenCID}
*/
function initialSequenceTokenCID(uint256 initialSequenceIndex) public view returns (string memory) {
return _storage.initialSequenceTokenCID(initialSequenceIndex);
}
/**
* @dev Returns if {nameString} has been reserved.
*/
function isNameReserved(string memory nameString) public view returns (bool) {
return _reservedNames[_toLower(nameString)];
}
/**
* @dev Returns reverved name for given token id.
*/
function tokenNames(uint256 tokenId) public view returns (string memory) {
return _tokenNames[tokenId];
}
/**
* @dev Returns the set token URI, i.e. IPFS v0 CID, of {tokenId}.
* Prefixed with ipfs://
*/
function tokenURI(uint256 tokenId) public view override returns (string memory) {
require(_exists(tokenId), "ERC721URIStorage: URI query for nonexistent token");
require(_startingIndex > 0, "Tokens have not been assigned yet");
uint256 initialSequenceIndex = _toInitialSequenceIndex(tokenId);
return tokenURIOfInitialSequenceIndex(initialSequenceIndex);
}
/**
* @dev Returns the set token URI, i.e. IPFS v0 CID, of {initialSequenceIndex}.
* Prefixed with ipfs://
*/
function tokenURIOfInitialSequenceIndex(uint256 initialSequenceIndex) public view returns (string memory) {
require(_startingIndex > 0, "Tokens have not been assigned yet");
string memory tokenCID = initialSequenceTokenCID(initialSequenceIndex);
string memory base = _baseURI();
// If there is no base URI, return the token URI.
if (bytes(base).length == 0) {
return tokenCID;
}
// If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked).
if (bytes(tokenCID).length > 0) {
return string(abi.encodePacked(base, tokenCID));
}
return base;
}
/**
* @dev Returns if the NFT has been minted before reveal phase.
*/
function isMintedBeforeReveal(uint256 index) public view returns (bool) {
return _mintedBeforeReveal[index];
}
/**
* @dev Gets current NFT price based on already sold tokens.
*/
function getNFTPrice() public view returns (uint256) {
if (_numSoldTokens < 800) {
return 0.01 ether;
} else if (_numSoldTokens < 4400) {
return 0.02 ether;
} else if (_numSoldTokens < 8800) {
return 0.03 ether;
} else if (_numSoldTokens < 12600) {
return 0.05 ether;
} else if (_numSoldTokens < 14040) {
return 0.1 ether;
} else if (_numSoldTokens < 14392) {
return 0.3 ether;
} else {
return 1 ether;
}
}
/**
* @dev Mints Mars NFTs
*/
function mint(uint256 numberOfNfts) public payable {
require(block.timestamp >= _saleStartTimestamp, "Sale has not started");
require(totalSupply() < MAX_SUPPLY, "Sale has already ended");
require(numberOfNfts > 0, "Cannot buy 0 NFTs");
require(numberOfNfts <= 20, "You may not buy more than 20 NFTs at once");
require(_numSoldTokens.add(numberOfNfts) <= MAX_SUPPLY.sub(RESERVED_SUPPLY), "Exceeds max number of sellable NFTs");
require(getNFTPrice().mul(numberOfNfts) == msg.value, "Ether value sent is not correct");
for (uint i = 0; i < numberOfNfts; i++) {
uint mintIndex = totalSupply();
_numSoldTokens++;
require(mintIndex < MAX_SUPPLY, "Exceeds max number of NFTs in existence");
if (block.timestamp < _revealTimestamp) {
_mintedBeforeReveal[mintIndex] = true;
}
_safeMint(msg.sender, mintIndex);
}
// Source of randomness. Theoretical miner withhold manipulation possible but should be sufficient in a pragmatic sense
if (_startingIndexBlock == 0 && (_numSoldTokens >= MAX_SUPPLY.sub(RESERVED_SUPPLY) || block.timestamp >= _revealTimestamp)) {
_startingIndexBlock = block.number;
}
}
/**
* @dev Used to migrate already minted NFTs of old contract.
*/
function mintReserved(address to, uint256 numOfNFTs) public onlyOwner {
require(totalSupply().add(numOfNFTs) <= MAX_SUPPLY, "Exceeds max supply of NFTs");
require(_numMintedReservedTokens.add(numOfNFTs) <= RESERVED_SUPPLY, "Exceeds max num of reserved NFTs");
for (uint j = 0; j < numOfNFTs; j++) {
uint tokenId = totalSupply();
if (block.timestamp < _revealTimestamp) {
_mintedBeforeReveal[tokenId] = true;
}
_numMintedReservedTokens++;
_safeMint(to, tokenId);
}
}
/**
* @dev Finalize starting index
*/
function finalizeStartingIndex() public {
require(_startingIndex == 0, "Starting index is already set");
require(_startingIndexBlock != 0, "Starting index block must be set");
_startingIndex = uint(blockhash(_startingIndexBlock)) % MAX_SUPPLY;
// Just a sanity case in the worst case if this function is called late (EVM only stores last 256 block hashes)
if (block.number.sub(_startingIndexBlock) > 255) {
_startingIndex = uint(blockhash(block.number - 1)) % MAX_SUPPLY;
}
// Prevent default sequence
if (_startingIndex == 0) {
_startingIndex = _startingIndex.add(1);
}
}
/**
* @dev Changes the name for Mars tile tokenId
*/
function changeName(uint256 tokenId, string memory newName) public {
address owner = ownerOf(tokenId);
require(_msgSender() == owner, "ERC721: caller is not the owner");
require(_validateName(newName) == true, "Not a valid new name");
require(sha256(bytes(newName)) != sha256(bytes(_tokenNames[tokenId])), "New name is same as the current one");
require(isNameReserved(newName) == false, "Name already reserved");
_m26.transferFrom(msg.sender, address(this), _nameChangePrice);
// If already named, dereserve old name
if (bytes(_tokenNames[tokenId]).length > 0) {
_toggleReserveName(_tokenNames[tokenId], false);
}
_toggleReserveName(newName, true);
_tokenNames[tokenId] = newName;
_m26.burn(_nameChangePrice);
emit NameChange(tokenId, newName);
}
/**
* @dev See {MarsStorage.setInitialSequenceTokenHashes}
*/
function setInitialSequenceTokenHashes(bytes32[] memory tokenHashes) onlyOwner public {
_storage.setInitialSequenceTokenHashes(tokenHashes);
}
/**
* @dev See {MarsStorage.setInitialSequenceTokenHashesAtIndex}
*/
function setInitialSequenceTokenHashesAtIndex(
uint256 startIndex,
bytes32[] memory tokenHashes
) public onlyOwner {
_storage.setInitialSequenceTokenHashesAtIndex(startIndex, tokenHashes);
}
/**
* @dev Check if the name string is valid (Alphanumeric and spaces without leading or trailing space)
*/
function _validateName(string memory str) private pure returns (bool){
bytes memory b = bytes(str);
if (b.length < 1) return false;
if (b.length > 50) return false; // Cannot be longer than 25 characters
if (b[0] == 0x20) return false; // Leading space
if (b[b.length - 1] == 0x20) return false; // Trailing space
bytes1 lastChar = b[0];
for (uint i; i < b.length; i++) {
bytes1 char = b[i];
if (char == 0x20 && lastChar == 0x20) return false; // Cannot contain continous spaces
if (
!(char >= 0x30 && char <= 0x39) && //9-0
!(char >= 0x41 && char <= 0x5A) && //A-Z
!(char >= 0x61 && char <= 0x7A) && //a-z
!(char == 0x20) //space
)
return false;
lastChar = char;
}
return true;
}
/**
* @dev Converts the string to lowercase
*/
function _toLower(string memory str) private pure returns (string memory){
bytes memory bStr = bytes(str);
bytes memory bLower = new bytes(bStr.length);
for (uint i = 0; i < bStr.length; i++) {
// Uppercase character
if ((uint8(bStr[i]) >= 65) && (uint8(bStr[i]) <= 90)) {
bLower[i] = bytes1(uint8(bStr[i]) + 32);
} else {
bLower[i] = bStr[i];
}
}
return string(bLower);
}
/**
* @dev Reserves the name if isReserve is set to true, de-reserves if set to false
*/
function _toggleReserveName(string memory str, bool isReserve) internal {
_reservedNames[_toLower(str)] = isReserve;
}
function _baseURI() internal pure override returns (string memory) {
return "ipfs://";
}
function _toInitialSequenceIndex(uint256 tokenId) internal view returns (uint256) {
return (tokenId + _startingIndex) % MAX_SUPPLY;
}
} | /**
* @title Mars contract
* @dev Extends ERC721 Non-Fungible Token Standard basic implementation
*/ | NatSpecMultiLine | getNFTPrice | function getNFTPrice() public view returns (uint256) {
if (_numSoldTokens < 800) {
return 0.01 ether;
} else if (_numSoldTokens < 4400) {
return 0.02 ether;
} else if (_numSoldTokens < 8800) {
return 0.03 ether;
} else if (_numSoldTokens < 12600) {
return 0.05 ether;
} else if (_numSoldTokens < 14040) {
return 0.1 ether;
} else if (_numSoldTokens < 14392) {
return 0.3 ether;
} else {
return 1 ether;
}
}
| /**
* @dev Gets current NFT price based on already sold tokens.
*/ | NatSpecMultiLine | v0.8.3+commit.8d00100c | {
"func_code_index": [
5777,
6343
]
} | 8,944 |
||
MarsLocker | contracts/Mars.sol | 0x64200351e787b33cd7c518a93fc24d780092f727 | Solidity | Mars | contract Mars is Ownable, ERC721Enumerable, PaymentSplitter {
using SafeMath for uint256;
uint256 public constant MAX_SUPPLY = 16200;
uint256 public constant RESERVED_SUPPLY = 1305 + 500;
bytes32 private _provenanceHash;
uint256 private _nameChangePrice;
uint256 private _saleStartTimestamp;
uint256 private _revealTimestamp;
uint256 private _startingIndexBlock;
uint256 internal _startingIndex;
uint256 private _numSoldTokens;
uint256 private _numMintedReservedTokens;
mapping (uint256 => string) private _tokenNames;
mapping (string => bool) private _reservedNames;
mapping (uint256 => bool) private _mintedBeforeReveal;
Mars26 private _m26;
MarsStorage private _storage;
event NameChange (uint256 indexed maskIndex, string newName);
/**
* @dev Sets immutable values of contract.
*/
constructor (
bytes32 provenanceHash_,
address m26Address_,
uint256 nameChangePrice_,
uint256 saleStartTimestamp_,
uint256 revealTimestamp_,
address[] memory payees,
uint256[] memory shares_
) ERC721("Mars", "MARS") PaymentSplitter(payees, shares_) {
_provenanceHash = provenanceHash_;
_m26 = Mars26(m26Address_);
_nameChangePrice = nameChangePrice_;
_saleStartTimestamp = saleStartTimestamp_;
_revealTimestamp = revealTimestamp_;
_storage = new MarsStorage(MAX_SUPPLY);
}
/**
* @dev Returns provenance hash digest set during initialization of contract.
*
* The provenance hash is derived by concatenating all existing IPFS CIDs (v0)
* of the Mars NFTs and hashing the concatenated string using SHA2-256.
* Note that the CIDs were concatenated and hashed in their base58 representation.
*/
function provenanceHash() public view returns (bytes32) {
return _provenanceHash;
}
/**
* @dev Returns address of Mars26 ERC-20 token contract.
*/
function m26Address() public view returns (address) {
return address(_m26);
}
/**
* @dev Returns address of connected storage contract.
*/
function storageAddress() public view returns (address) {
return address(_storage);
}
/**
* @dev Returns the number of sold NFTs.
*/
function numSoldTokens() public view returns (uint256) {
return _numSoldTokens;
}
/**
* @dev Returns the MNCT price for changing the name of a token.
*/
function nameChangePrice() public view returns (uint256) {
return _nameChangePrice;
}
/**
* @dev Returns the start timestamp of the initial sale.
*/
function saleStartTimestamp() public view returns (uint256) {
return _saleStartTimestamp;
}
/**
* @dev Returns the reveal timestamp after which the token ids will be assigned.
*/
function revealTimestamp() public view returns (uint256) {
return _revealTimestamp;
}
/**
* @dev Returns the randomized starting index to assign and reveal token ids to
* intial sequence of NFTs.
*/
function startingIndex() public view returns (uint256) {
return _startingIndex;
}
/**
* @dev Returns the randomized starting index block which is used to derive
* {_startingIndex} from.
*/
function startingIndexBlock() public view returns (uint256) {
return _startingIndexBlock;
}
/**
* @dev See {MarsStorage.initialSequenceTokenCID}
*/
function initialSequenceTokenCID(uint256 initialSequenceIndex) public view returns (string memory) {
return _storage.initialSequenceTokenCID(initialSequenceIndex);
}
/**
* @dev Returns if {nameString} has been reserved.
*/
function isNameReserved(string memory nameString) public view returns (bool) {
return _reservedNames[_toLower(nameString)];
}
/**
* @dev Returns reverved name for given token id.
*/
function tokenNames(uint256 tokenId) public view returns (string memory) {
return _tokenNames[tokenId];
}
/**
* @dev Returns the set token URI, i.e. IPFS v0 CID, of {tokenId}.
* Prefixed with ipfs://
*/
function tokenURI(uint256 tokenId) public view override returns (string memory) {
require(_exists(tokenId), "ERC721URIStorage: URI query for nonexistent token");
require(_startingIndex > 0, "Tokens have not been assigned yet");
uint256 initialSequenceIndex = _toInitialSequenceIndex(tokenId);
return tokenURIOfInitialSequenceIndex(initialSequenceIndex);
}
/**
* @dev Returns the set token URI, i.e. IPFS v0 CID, of {initialSequenceIndex}.
* Prefixed with ipfs://
*/
function tokenURIOfInitialSequenceIndex(uint256 initialSequenceIndex) public view returns (string memory) {
require(_startingIndex > 0, "Tokens have not been assigned yet");
string memory tokenCID = initialSequenceTokenCID(initialSequenceIndex);
string memory base = _baseURI();
// If there is no base URI, return the token URI.
if (bytes(base).length == 0) {
return tokenCID;
}
// If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked).
if (bytes(tokenCID).length > 0) {
return string(abi.encodePacked(base, tokenCID));
}
return base;
}
/**
* @dev Returns if the NFT has been minted before reveal phase.
*/
function isMintedBeforeReveal(uint256 index) public view returns (bool) {
return _mintedBeforeReveal[index];
}
/**
* @dev Gets current NFT price based on already sold tokens.
*/
function getNFTPrice() public view returns (uint256) {
if (_numSoldTokens < 800) {
return 0.01 ether;
} else if (_numSoldTokens < 4400) {
return 0.02 ether;
} else if (_numSoldTokens < 8800) {
return 0.03 ether;
} else if (_numSoldTokens < 12600) {
return 0.05 ether;
} else if (_numSoldTokens < 14040) {
return 0.1 ether;
} else if (_numSoldTokens < 14392) {
return 0.3 ether;
} else {
return 1 ether;
}
}
/**
* @dev Mints Mars NFTs
*/
function mint(uint256 numberOfNfts) public payable {
require(block.timestamp >= _saleStartTimestamp, "Sale has not started");
require(totalSupply() < MAX_SUPPLY, "Sale has already ended");
require(numberOfNfts > 0, "Cannot buy 0 NFTs");
require(numberOfNfts <= 20, "You may not buy more than 20 NFTs at once");
require(_numSoldTokens.add(numberOfNfts) <= MAX_SUPPLY.sub(RESERVED_SUPPLY), "Exceeds max number of sellable NFTs");
require(getNFTPrice().mul(numberOfNfts) == msg.value, "Ether value sent is not correct");
for (uint i = 0; i < numberOfNfts; i++) {
uint mintIndex = totalSupply();
_numSoldTokens++;
require(mintIndex < MAX_SUPPLY, "Exceeds max number of NFTs in existence");
if (block.timestamp < _revealTimestamp) {
_mintedBeforeReveal[mintIndex] = true;
}
_safeMint(msg.sender, mintIndex);
}
// Source of randomness. Theoretical miner withhold manipulation possible but should be sufficient in a pragmatic sense
if (_startingIndexBlock == 0 && (_numSoldTokens >= MAX_SUPPLY.sub(RESERVED_SUPPLY) || block.timestamp >= _revealTimestamp)) {
_startingIndexBlock = block.number;
}
}
/**
* @dev Used to migrate already minted NFTs of old contract.
*/
function mintReserved(address to, uint256 numOfNFTs) public onlyOwner {
require(totalSupply().add(numOfNFTs) <= MAX_SUPPLY, "Exceeds max supply of NFTs");
require(_numMintedReservedTokens.add(numOfNFTs) <= RESERVED_SUPPLY, "Exceeds max num of reserved NFTs");
for (uint j = 0; j < numOfNFTs; j++) {
uint tokenId = totalSupply();
if (block.timestamp < _revealTimestamp) {
_mintedBeforeReveal[tokenId] = true;
}
_numMintedReservedTokens++;
_safeMint(to, tokenId);
}
}
/**
* @dev Finalize starting index
*/
function finalizeStartingIndex() public {
require(_startingIndex == 0, "Starting index is already set");
require(_startingIndexBlock != 0, "Starting index block must be set");
_startingIndex = uint(blockhash(_startingIndexBlock)) % MAX_SUPPLY;
// Just a sanity case in the worst case if this function is called late (EVM only stores last 256 block hashes)
if (block.number.sub(_startingIndexBlock) > 255) {
_startingIndex = uint(blockhash(block.number - 1)) % MAX_SUPPLY;
}
// Prevent default sequence
if (_startingIndex == 0) {
_startingIndex = _startingIndex.add(1);
}
}
/**
* @dev Changes the name for Mars tile tokenId
*/
function changeName(uint256 tokenId, string memory newName) public {
address owner = ownerOf(tokenId);
require(_msgSender() == owner, "ERC721: caller is not the owner");
require(_validateName(newName) == true, "Not a valid new name");
require(sha256(bytes(newName)) != sha256(bytes(_tokenNames[tokenId])), "New name is same as the current one");
require(isNameReserved(newName) == false, "Name already reserved");
_m26.transferFrom(msg.sender, address(this), _nameChangePrice);
// If already named, dereserve old name
if (bytes(_tokenNames[tokenId]).length > 0) {
_toggleReserveName(_tokenNames[tokenId], false);
}
_toggleReserveName(newName, true);
_tokenNames[tokenId] = newName;
_m26.burn(_nameChangePrice);
emit NameChange(tokenId, newName);
}
/**
* @dev See {MarsStorage.setInitialSequenceTokenHashes}
*/
function setInitialSequenceTokenHashes(bytes32[] memory tokenHashes) onlyOwner public {
_storage.setInitialSequenceTokenHashes(tokenHashes);
}
/**
* @dev See {MarsStorage.setInitialSequenceTokenHashesAtIndex}
*/
function setInitialSequenceTokenHashesAtIndex(
uint256 startIndex,
bytes32[] memory tokenHashes
) public onlyOwner {
_storage.setInitialSequenceTokenHashesAtIndex(startIndex, tokenHashes);
}
/**
* @dev Check if the name string is valid (Alphanumeric and spaces without leading or trailing space)
*/
function _validateName(string memory str) private pure returns (bool){
bytes memory b = bytes(str);
if (b.length < 1) return false;
if (b.length > 50) return false; // Cannot be longer than 25 characters
if (b[0] == 0x20) return false; // Leading space
if (b[b.length - 1] == 0x20) return false; // Trailing space
bytes1 lastChar = b[0];
for (uint i; i < b.length; i++) {
bytes1 char = b[i];
if (char == 0x20 && lastChar == 0x20) return false; // Cannot contain continous spaces
if (
!(char >= 0x30 && char <= 0x39) && //9-0
!(char >= 0x41 && char <= 0x5A) && //A-Z
!(char >= 0x61 && char <= 0x7A) && //a-z
!(char == 0x20) //space
)
return false;
lastChar = char;
}
return true;
}
/**
* @dev Converts the string to lowercase
*/
function _toLower(string memory str) private pure returns (string memory){
bytes memory bStr = bytes(str);
bytes memory bLower = new bytes(bStr.length);
for (uint i = 0; i < bStr.length; i++) {
// Uppercase character
if ((uint8(bStr[i]) >= 65) && (uint8(bStr[i]) <= 90)) {
bLower[i] = bytes1(uint8(bStr[i]) + 32);
} else {
bLower[i] = bStr[i];
}
}
return string(bLower);
}
/**
* @dev Reserves the name if isReserve is set to true, de-reserves if set to false
*/
function _toggleReserveName(string memory str, bool isReserve) internal {
_reservedNames[_toLower(str)] = isReserve;
}
function _baseURI() internal pure override returns (string memory) {
return "ipfs://";
}
function _toInitialSequenceIndex(uint256 tokenId) internal view returns (uint256) {
return (tokenId + _startingIndex) % MAX_SUPPLY;
}
} | /**
* @title Mars contract
* @dev Extends ERC721 Non-Fungible Token Standard basic implementation
*/ | NatSpecMultiLine | mint | function mint(uint256 numberOfNfts) public payable {
require(block.timestamp >= _saleStartTimestamp, "Sale has not started");
require(totalSupply() < MAX_SUPPLY, "Sale has already ended");
require(numberOfNfts > 0, "Cannot buy 0 NFTs");
require(numberOfNfts <= 20, "You may not buy more than 20 NFTs at once");
require(_numSoldTokens.add(numberOfNfts) <= MAX_SUPPLY.sub(RESERVED_SUPPLY), "Exceeds max number of sellable NFTs");
require(getNFTPrice().mul(numberOfNfts) == msg.value, "Ether value sent is not correct");
for (uint i = 0; i < numberOfNfts; i++) {
uint mintIndex = totalSupply();
_numSoldTokens++;
require(mintIndex < MAX_SUPPLY, "Exceeds max number of NFTs in existence");
if (block.timestamp < _revealTimestamp) {
_mintedBeforeReveal[mintIndex] = true;
}
_safeMint(msg.sender, mintIndex);
}
// Source of randomness. Theoretical miner withhold manipulation possible but should be sufficient in a pragmatic sense
if (_startingIndexBlock == 0 && (_numSoldTokens >= MAX_SUPPLY.sub(RESERVED_SUPPLY) || block.timestamp >= _revealTimestamp)) {
_startingIndexBlock = block.number;
}
}
| /**
* @dev Mints Mars NFTs
*/ | NatSpecMultiLine | v0.8.3+commit.8d00100c | {
"func_code_index": [
6389,
7680
]
} | 8,945 |
||
MarsLocker | contracts/Mars.sol | 0x64200351e787b33cd7c518a93fc24d780092f727 | Solidity | Mars | contract Mars is Ownable, ERC721Enumerable, PaymentSplitter {
using SafeMath for uint256;
uint256 public constant MAX_SUPPLY = 16200;
uint256 public constant RESERVED_SUPPLY = 1305 + 500;
bytes32 private _provenanceHash;
uint256 private _nameChangePrice;
uint256 private _saleStartTimestamp;
uint256 private _revealTimestamp;
uint256 private _startingIndexBlock;
uint256 internal _startingIndex;
uint256 private _numSoldTokens;
uint256 private _numMintedReservedTokens;
mapping (uint256 => string) private _tokenNames;
mapping (string => bool) private _reservedNames;
mapping (uint256 => bool) private _mintedBeforeReveal;
Mars26 private _m26;
MarsStorage private _storage;
event NameChange (uint256 indexed maskIndex, string newName);
/**
* @dev Sets immutable values of contract.
*/
constructor (
bytes32 provenanceHash_,
address m26Address_,
uint256 nameChangePrice_,
uint256 saleStartTimestamp_,
uint256 revealTimestamp_,
address[] memory payees,
uint256[] memory shares_
) ERC721("Mars", "MARS") PaymentSplitter(payees, shares_) {
_provenanceHash = provenanceHash_;
_m26 = Mars26(m26Address_);
_nameChangePrice = nameChangePrice_;
_saleStartTimestamp = saleStartTimestamp_;
_revealTimestamp = revealTimestamp_;
_storage = new MarsStorage(MAX_SUPPLY);
}
/**
* @dev Returns provenance hash digest set during initialization of contract.
*
* The provenance hash is derived by concatenating all existing IPFS CIDs (v0)
* of the Mars NFTs and hashing the concatenated string using SHA2-256.
* Note that the CIDs were concatenated and hashed in their base58 representation.
*/
function provenanceHash() public view returns (bytes32) {
return _provenanceHash;
}
/**
* @dev Returns address of Mars26 ERC-20 token contract.
*/
function m26Address() public view returns (address) {
return address(_m26);
}
/**
* @dev Returns address of connected storage contract.
*/
function storageAddress() public view returns (address) {
return address(_storage);
}
/**
* @dev Returns the number of sold NFTs.
*/
function numSoldTokens() public view returns (uint256) {
return _numSoldTokens;
}
/**
* @dev Returns the MNCT price for changing the name of a token.
*/
function nameChangePrice() public view returns (uint256) {
return _nameChangePrice;
}
/**
* @dev Returns the start timestamp of the initial sale.
*/
function saleStartTimestamp() public view returns (uint256) {
return _saleStartTimestamp;
}
/**
* @dev Returns the reveal timestamp after which the token ids will be assigned.
*/
function revealTimestamp() public view returns (uint256) {
return _revealTimestamp;
}
/**
* @dev Returns the randomized starting index to assign and reveal token ids to
* intial sequence of NFTs.
*/
function startingIndex() public view returns (uint256) {
return _startingIndex;
}
/**
* @dev Returns the randomized starting index block which is used to derive
* {_startingIndex} from.
*/
function startingIndexBlock() public view returns (uint256) {
return _startingIndexBlock;
}
/**
* @dev See {MarsStorage.initialSequenceTokenCID}
*/
function initialSequenceTokenCID(uint256 initialSequenceIndex) public view returns (string memory) {
return _storage.initialSequenceTokenCID(initialSequenceIndex);
}
/**
* @dev Returns if {nameString} has been reserved.
*/
function isNameReserved(string memory nameString) public view returns (bool) {
return _reservedNames[_toLower(nameString)];
}
/**
* @dev Returns reverved name for given token id.
*/
function tokenNames(uint256 tokenId) public view returns (string memory) {
return _tokenNames[tokenId];
}
/**
* @dev Returns the set token URI, i.e. IPFS v0 CID, of {tokenId}.
* Prefixed with ipfs://
*/
function tokenURI(uint256 tokenId) public view override returns (string memory) {
require(_exists(tokenId), "ERC721URIStorage: URI query for nonexistent token");
require(_startingIndex > 0, "Tokens have not been assigned yet");
uint256 initialSequenceIndex = _toInitialSequenceIndex(tokenId);
return tokenURIOfInitialSequenceIndex(initialSequenceIndex);
}
/**
* @dev Returns the set token URI, i.e. IPFS v0 CID, of {initialSequenceIndex}.
* Prefixed with ipfs://
*/
function tokenURIOfInitialSequenceIndex(uint256 initialSequenceIndex) public view returns (string memory) {
require(_startingIndex > 0, "Tokens have not been assigned yet");
string memory tokenCID = initialSequenceTokenCID(initialSequenceIndex);
string memory base = _baseURI();
// If there is no base URI, return the token URI.
if (bytes(base).length == 0) {
return tokenCID;
}
// If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked).
if (bytes(tokenCID).length > 0) {
return string(abi.encodePacked(base, tokenCID));
}
return base;
}
/**
* @dev Returns if the NFT has been minted before reveal phase.
*/
function isMintedBeforeReveal(uint256 index) public view returns (bool) {
return _mintedBeforeReveal[index];
}
/**
* @dev Gets current NFT price based on already sold tokens.
*/
function getNFTPrice() public view returns (uint256) {
if (_numSoldTokens < 800) {
return 0.01 ether;
} else if (_numSoldTokens < 4400) {
return 0.02 ether;
} else if (_numSoldTokens < 8800) {
return 0.03 ether;
} else if (_numSoldTokens < 12600) {
return 0.05 ether;
} else if (_numSoldTokens < 14040) {
return 0.1 ether;
} else if (_numSoldTokens < 14392) {
return 0.3 ether;
} else {
return 1 ether;
}
}
/**
* @dev Mints Mars NFTs
*/
function mint(uint256 numberOfNfts) public payable {
require(block.timestamp >= _saleStartTimestamp, "Sale has not started");
require(totalSupply() < MAX_SUPPLY, "Sale has already ended");
require(numberOfNfts > 0, "Cannot buy 0 NFTs");
require(numberOfNfts <= 20, "You may not buy more than 20 NFTs at once");
require(_numSoldTokens.add(numberOfNfts) <= MAX_SUPPLY.sub(RESERVED_SUPPLY), "Exceeds max number of sellable NFTs");
require(getNFTPrice().mul(numberOfNfts) == msg.value, "Ether value sent is not correct");
for (uint i = 0; i < numberOfNfts; i++) {
uint mintIndex = totalSupply();
_numSoldTokens++;
require(mintIndex < MAX_SUPPLY, "Exceeds max number of NFTs in existence");
if (block.timestamp < _revealTimestamp) {
_mintedBeforeReveal[mintIndex] = true;
}
_safeMint(msg.sender, mintIndex);
}
// Source of randomness. Theoretical miner withhold manipulation possible but should be sufficient in a pragmatic sense
if (_startingIndexBlock == 0 && (_numSoldTokens >= MAX_SUPPLY.sub(RESERVED_SUPPLY) || block.timestamp >= _revealTimestamp)) {
_startingIndexBlock = block.number;
}
}
/**
* @dev Used to migrate already minted NFTs of old contract.
*/
function mintReserved(address to, uint256 numOfNFTs) public onlyOwner {
require(totalSupply().add(numOfNFTs) <= MAX_SUPPLY, "Exceeds max supply of NFTs");
require(_numMintedReservedTokens.add(numOfNFTs) <= RESERVED_SUPPLY, "Exceeds max num of reserved NFTs");
for (uint j = 0; j < numOfNFTs; j++) {
uint tokenId = totalSupply();
if (block.timestamp < _revealTimestamp) {
_mintedBeforeReveal[tokenId] = true;
}
_numMintedReservedTokens++;
_safeMint(to, tokenId);
}
}
/**
* @dev Finalize starting index
*/
function finalizeStartingIndex() public {
require(_startingIndex == 0, "Starting index is already set");
require(_startingIndexBlock != 0, "Starting index block must be set");
_startingIndex = uint(blockhash(_startingIndexBlock)) % MAX_SUPPLY;
// Just a sanity case in the worst case if this function is called late (EVM only stores last 256 block hashes)
if (block.number.sub(_startingIndexBlock) > 255) {
_startingIndex = uint(blockhash(block.number - 1)) % MAX_SUPPLY;
}
// Prevent default sequence
if (_startingIndex == 0) {
_startingIndex = _startingIndex.add(1);
}
}
/**
* @dev Changes the name for Mars tile tokenId
*/
function changeName(uint256 tokenId, string memory newName) public {
address owner = ownerOf(tokenId);
require(_msgSender() == owner, "ERC721: caller is not the owner");
require(_validateName(newName) == true, "Not a valid new name");
require(sha256(bytes(newName)) != sha256(bytes(_tokenNames[tokenId])), "New name is same as the current one");
require(isNameReserved(newName) == false, "Name already reserved");
_m26.transferFrom(msg.sender, address(this), _nameChangePrice);
// If already named, dereserve old name
if (bytes(_tokenNames[tokenId]).length > 0) {
_toggleReserveName(_tokenNames[tokenId], false);
}
_toggleReserveName(newName, true);
_tokenNames[tokenId] = newName;
_m26.burn(_nameChangePrice);
emit NameChange(tokenId, newName);
}
/**
* @dev See {MarsStorage.setInitialSequenceTokenHashes}
*/
function setInitialSequenceTokenHashes(bytes32[] memory tokenHashes) onlyOwner public {
_storage.setInitialSequenceTokenHashes(tokenHashes);
}
/**
* @dev See {MarsStorage.setInitialSequenceTokenHashesAtIndex}
*/
function setInitialSequenceTokenHashesAtIndex(
uint256 startIndex,
bytes32[] memory tokenHashes
) public onlyOwner {
_storage.setInitialSequenceTokenHashesAtIndex(startIndex, tokenHashes);
}
/**
* @dev Check if the name string is valid (Alphanumeric and spaces without leading or trailing space)
*/
function _validateName(string memory str) private pure returns (bool){
bytes memory b = bytes(str);
if (b.length < 1) return false;
if (b.length > 50) return false; // Cannot be longer than 25 characters
if (b[0] == 0x20) return false; // Leading space
if (b[b.length - 1] == 0x20) return false; // Trailing space
bytes1 lastChar = b[0];
for (uint i; i < b.length; i++) {
bytes1 char = b[i];
if (char == 0x20 && lastChar == 0x20) return false; // Cannot contain continous spaces
if (
!(char >= 0x30 && char <= 0x39) && //9-0
!(char >= 0x41 && char <= 0x5A) && //A-Z
!(char >= 0x61 && char <= 0x7A) && //a-z
!(char == 0x20) //space
)
return false;
lastChar = char;
}
return true;
}
/**
* @dev Converts the string to lowercase
*/
function _toLower(string memory str) private pure returns (string memory){
bytes memory bStr = bytes(str);
bytes memory bLower = new bytes(bStr.length);
for (uint i = 0; i < bStr.length; i++) {
// Uppercase character
if ((uint8(bStr[i]) >= 65) && (uint8(bStr[i]) <= 90)) {
bLower[i] = bytes1(uint8(bStr[i]) + 32);
} else {
bLower[i] = bStr[i];
}
}
return string(bLower);
}
/**
* @dev Reserves the name if isReserve is set to true, de-reserves if set to false
*/
function _toggleReserveName(string memory str, bool isReserve) internal {
_reservedNames[_toLower(str)] = isReserve;
}
function _baseURI() internal pure override returns (string memory) {
return "ipfs://";
}
function _toInitialSequenceIndex(uint256 tokenId) internal view returns (uint256) {
return (tokenId + _startingIndex) % MAX_SUPPLY;
}
} | /**
* @title Mars contract
* @dev Extends ERC721 Non-Fungible Token Standard basic implementation
*/ | NatSpecMultiLine | mintReserved | function mintReserved(address to, uint256 numOfNFTs) public onlyOwner {
require(totalSupply().add(numOfNFTs) <= MAX_SUPPLY, "Exceeds max supply of NFTs");
require(_numMintedReservedTokens.add(numOfNFTs) <= RESERVED_SUPPLY, "Exceeds max num of reserved NFTs");
for (uint j = 0; j < numOfNFTs; j++) {
uint tokenId = totalSupply();
if (block.timestamp < _revealTimestamp) {
_mintedBeforeReveal[tokenId] = true;
}
_numMintedReservedTokens++;
_safeMint(to, tokenId);
}
}
| /**
* @dev Used to migrate already minted NFTs of old contract.
*/ | NatSpecMultiLine | v0.8.3+commit.8d00100c | {
"func_code_index": [
7763,
8346
]
} | 8,946 |
||
MarsLocker | contracts/Mars.sol | 0x64200351e787b33cd7c518a93fc24d780092f727 | Solidity | Mars | contract Mars is Ownable, ERC721Enumerable, PaymentSplitter {
using SafeMath for uint256;
uint256 public constant MAX_SUPPLY = 16200;
uint256 public constant RESERVED_SUPPLY = 1305 + 500;
bytes32 private _provenanceHash;
uint256 private _nameChangePrice;
uint256 private _saleStartTimestamp;
uint256 private _revealTimestamp;
uint256 private _startingIndexBlock;
uint256 internal _startingIndex;
uint256 private _numSoldTokens;
uint256 private _numMintedReservedTokens;
mapping (uint256 => string) private _tokenNames;
mapping (string => bool) private _reservedNames;
mapping (uint256 => bool) private _mintedBeforeReveal;
Mars26 private _m26;
MarsStorage private _storage;
event NameChange (uint256 indexed maskIndex, string newName);
/**
* @dev Sets immutable values of contract.
*/
constructor (
bytes32 provenanceHash_,
address m26Address_,
uint256 nameChangePrice_,
uint256 saleStartTimestamp_,
uint256 revealTimestamp_,
address[] memory payees,
uint256[] memory shares_
) ERC721("Mars", "MARS") PaymentSplitter(payees, shares_) {
_provenanceHash = provenanceHash_;
_m26 = Mars26(m26Address_);
_nameChangePrice = nameChangePrice_;
_saleStartTimestamp = saleStartTimestamp_;
_revealTimestamp = revealTimestamp_;
_storage = new MarsStorage(MAX_SUPPLY);
}
/**
* @dev Returns provenance hash digest set during initialization of contract.
*
* The provenance hash is derived by concatenating all existing IPFS CIDs (v0)
* of the Mars NFTs and hashing the concatenated string using SHA2-256.
* Note that the CIDs were concatenated and hashed in their base58 representation.
*/
function provenanceHash() public view returns (bytes32) {
return _provenanceHash;
}
/**
* @dev Returns address of Mars26 ERC-20 token contract.
*/
function m26Address() public view returns (address) {
return address(_m26);
}
/**
* @dev Returns address of connected storage contract.
*/
function storageAddress() public view returns (address) {
return address(_storage);
}
/**
* @dev Returns the number of sold NFTs.
*/
function numSoldTokens() public view returns (uint256) {
return _numSoldTokens;
}
/**
* @dev Returns the MNCT price for changing the name of a token.
*/
function nameChangePrice() public view returns (uint256) {
return _nameChangePrice;
}
/**
* @dev Returns the start timestamp of the initial sale.
*/
function saleStartTimestamp() public view returns (uint256) {
return _saleStartTimestamp;
}
/**
* @dev Returns the reveal timestamp after which the token ids will be assigned.
*/
function revealTimestamp() public view returns (uint256) {
return _revealTimestamp;
}
/**
* @dev Returns the randomized starting index to assign and reveal token ids to
* intial sequence of NFTs.
*/
function startingIndex() public view returns (uint256) {
return _startingIndex;
}
/**
* @dev Returns the randomized starting index block which is used to derive
* {_startingIndex} from.
*/
function startingIndexBlock() public view returns (uint256) {
return _startingIndexBlock;
}
/**
* @dev See {MarsStorage.initialSequenceTokenCID}
*/
function initialSequenceTokenCID(uint256 initialSequenceIndex) public view returns (string memory) {
return _storage.initialSequenceTokenCID(initialSequenceIndex);
}
/**
* @dev Returns if {nameString} has been reserved.
*/
function isNameReserved(string memory nameString) public view returns (bool) {
return _reservedNames[_toLower(nameString)];
}
/**
* @dev Returns reverved name for given token id.
*/
function tokenNames(uint256 tokenId) public view returns (string memory) {
return _tokenNames[tokenId];
}
/**
* @dev Returns the set token URI, i.e. IPFS v0 CID, of {tokenId}.
* Prefixed with ipfs://
*/
function tokenURI(uint256 tokenId) public view override returns (string memory) {
require(_exists(tokenId), "ERC721URIStorage: URI query for nonexistent token");
require(_startingIndex > 0, "Tokens have not been assigned yet");
uint256 initialSequenceIndex = _toInitialSequenceIndex(tokenId);
return tokenURIOfInitialSequenceIndex(initialSequenceIndex);
}
/**
* @dev Returns the set token URI, i.e. IPFS v0 CID, of {initialSequenceIndex}.
* Prefixed with ipfs://
*/
function tokenURIOfInitialSequenceIndex(uint256 initialSequenceIndex) public view returns (string memory) {
require(_startingIndex > 0, "Tokens have not been assigned yet");
string memory tokenCID = initialSequenceTokenCID(initialSequenceIndex);
string memory base = _baseURI();
// If there is no base URI, return the token URI.
if (bytes(base).length == 0) {
return tokenCID;
}
// If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked).
if (bytes(tokenCID).length > 0) {
return string(abi.encodePacked(base, tokenCID));
}
return base;
}
/**
* @dev Returns if the NFT has been minted before reveal phase.
*/
function isMintedBeforeReveal(uint256 index) public view returns (bool) {
return _mintedBeforeReveal[index];
}
/**
* @dev Gets current NFT price based on already sold tokens.
*/
function getNFTPrice() public view returns (uint256) {
if (_numSoldTokens < 800) {
return 0.01 ether;
} else if (_numSoldTokens < 4400) {
return 0.02 ether;
} else if (_numSoldTokens < 8800) {
return 0.03 ether;
} else if (_numSoldTokens < 12600) {
return 0.05 ether;
} else if (_numSoldTokens < 14040) {
return 0.1 ether;
} else if (_numSoldTokens < 14392) {
return 0.3 ether;
} else {
return 1 ether;
}
}
/**
* @dev Mints Mars NFTs
*/
function mint(uint256 numberOfNfts) public payable {
require(block.timestamp >= _saleStartTimestamp, "Sale has not started");
require(totalSupply() < MAX_SUPPLY, "Sale has already ended");
require(numberOfNfts > 0, "Cannot buy 0 NFTs");
require(numberOfNfts <= 20, "You may not buy more than 20 NFTs at once");
require(_numSoldTokens.add(numberOfNfts) <= MAX_SUPPLY.sub(RESERVED_SUPPLY), "Exceeds max number of sellable NFTs");
require(getNFTPrice().mul(numberOfNfts) == msg.value, "Ether value sent is not correct");
for (uint i = 0; i < numberOfNfts; i++) {
uint mintIndex = totalSupply();
_numSoldTokens++;
require(mintIndex < MAX_SUPPLY, "Exceeds max number of NFTs in existence");
if (block.timestamp < _revealTimestamp) {
_mintedBeforeReveal[mintIndex] = true;
}
_safeMint(msg.sender, mintIndex);
}
// Source of randomness. Theoretical miner withhold manipulation possible but should be sufficient in a pragmatic sense
if (_startingIndexBlock == 0 && (_numSoldTokens >= MAX_SUPPLY.sub(RESERVED_SUPPLY) || block.timestamp >= _revealTimestamp)) {
_startingIndexBlock = block.number;
}
}
/**
* @dev Used to migrate already minted NFTs of old contract.
*/
function mintReserved(address to, uint256 numOfNFTs) public onlyOwner {
require(totalSupply().add(numOfNFTs) <= MAX_SUPPLY, "Exceeds max supply of NFTs");
require(_numMintedReservedTokens.add(numOfNFTs) <= RESERVED_SUPPLY, "Exceeds max num of reserved NFTs");
for (uint j = 0; j < numOfNFTs; j++) {
uint tokenId = totalSupply();
if (block.timestamp < _revealTimestamp) {
_mintedBeforeReveal[tokenId] = true;
}
_numMintedReservedTokens++;
_safeMint(to, tokenId);
}
}
/**
* @dev Finalize starting index
*/
function finalizeStartingIndex() public {
require(_startingIndex == 0, "Starting index is already set");
require(_startingIndexBlock != 0, "Starting index block must be set");
_startingIndex = uint(blockhash(_startingIndexBlock)) % MAX_SUPPLY;
// Just a sanity case in the worst case if this function is called late (EVM only stores last 256 block hashes)
if (block.number.sub(_startingIndexBlock) > 255) {
_startingIndex = uint(blockhash(block.number - 1)) % MAX_SUPPLY;
}
// Prevent default sequence
if (_startingIndex == 0) {
_startingIndex = _startingIndex.add(1);
}
}
/**
* @dev Changes the name for Mars tile tokenId
*/
function changeName(uint256 tokenId, string memory newName) public {
address owner = ownerOf(tokenId);
require(_msgSender() == owner, "ERC721: caller is not the owner");
require(_validateName(newName) == true, "Not a valid new name");
require(sha256(bytes(newName)) != sha256(bytes(_tokenNames[tokenId])), "New name is same as the current one");
require(isNameReserved(newName) == false, "Name already reserved");
_m26.transferFrom(msg.sender, address(this), _nameChangePrice);
// If already named, dereserve old name
if (bytes(_tokenNames[tokenId]).length > 0) {
_toggleReserveName(_tokenNames[tokenId], false);
}
_toggleReserveName(newName, true);
_tokenNames[tokenId] = newName;
_m26.burn(_nameChangePrice);
emit NameChange(tokenId, newName);
}
/**
* @dev See {MarsStorage.setInitialSequenceTokenHashes}
*/
function setInitialSequenceTokenHashes(bytes32[] memory tokenHashes) onlyOwner public {
_storage.setInitialSequenceTokenHashes(tokenHashes);
}
/**
* @dev See {MarsStorage.setInitialSequenceTokenHashesAtIndex}
*/
function setInitialSequenceTokenHashesAtIndex(
uint256 startIndex,
bytes32[] memory tokenHashes
) public onlyOwner {
_storage.setInitialSequenceTokenHashesAtIndex(startIndex, tokenHashes);
}
/**
* @dev Check if the name string is valid (Alphanumeric and spaces without leading or trailing space)
*/
function _validateName(string memory str) private pure returns (bool){
bytes memory b = bytes(str);
if (b.length < 1) return false;
if (b.length > 50) return false; // Cannot be longer than 25 characters
if (b[0] == 0x20) return false; // Leading space
if (b[b.length - 1] == 0x20) return false; // Trailing space
bytes1 lastChar = b[0];
for (uint i; i < b.length; i++) {
bytes1 char = b[i];
if (char == 0x20 && lastChar == 0x20) return false; // Cannot contain continous spaces
if (
!(char >= 0x30 && char <= 0x39) && //9-0
!(char >= 0x41 && char <= 0x5A) && //A-Z
!(char >= 0x61 && char <= 0x7A) && //a-z
!(char == 0x20) //space
)
return false;
lastChar = char;
}
return true;
}
/**
* @dev Converts the string to lowercase
*/
function _toLower(string memory str) private pure returns (string memory){
bytes memory bStr = bytes(str);
bytes memory bLower = new bytes(bStr.length);
for (uint i = 0; i < bStr.length; i++) {
// Uppercase character
if ((uint8(bStr[i]) >= 65) && (uint8(bStr[i]) <= 90)) {
bLower[i] = bytes1(uint8(bStr[i]) + 32);
} else {
bLower[i] = bStr[i];
}
}
return string(bLower);
}
/**
* @dev Reserves the name if isReserve is set to true, de-reserves if set to false
*/
function _toggleReserveName(string memory str, bool isReserve) internal {
_reservedNames[_toLower(str)] = isReserve;
}
function _baseURI() internal pure override returns (string memory) {
return "ipfs://";
}
function _toInitialSequenceIndex(uint256 tokenId) internal view returns (uint256) {
return (tokenId + _startingIndex) % MAX_SUPPLY;
}
} | /**
* @title Mars contract
* @dev Extends ERC721 Non-Fungible Token Standard basic implementation
*/ | NatSpecMultiLine | finalizeStartingIndex | function finalizeStartingIndex() public {
require(_startingIndex == 0, "Starting index is already set");
require(_startingIndexBlock != 0, "Starting index block must be set");
_startingIndex = uint(blockhash(_startingIndexBlock)) % MAX_SUPPLY;
// Just a sanity case in the worst case if this function is called late (EVM only stores last 256 block hashes)
if (block.number.sub(_startingIndexBlock) > 255) {
_startingIndex = uint(blockhash(block.number - 1)) % MAX_SUPPLY;
}
// Prevent default sequence
if (_startingIndex == 0) {
_startingIndex = _startingIndex.add(1);
}
}
| /**
* @dev Finalize starting index
*/ | NatSpecMultiLine | v0.8.3+commit.8d00100c | {
"func_code_index": [
8400,
9085
]
} | 8,947 |
||
MarsLocker | contracts/Mars.sol | 0x64200351e787b33cd7c518a93fc24d780092f727 | Solidity | Mars | contract Mars is Ownable, ERC721Enumerable, PaymentSplitter {
using SafeMath for uint256;
uint256 public constant MAX_SUPPLY = 16200;
uint256 public constant RESERVED_SUPPLY = 1305 + 500;
bytes32 private _provenanceHash;
uint256 private _nameChangePrice;
uint256 private _saleStartTimestamp;
uint256 private _revealTimestamp;
uint256 private _startingIndexBlock;
uint256 internal _startingIndex;
uint256 private _numSoldTokens;
uint256 private _numMintedReservedTokens;
mapping (uint256 => string) private _tokenNames;
mapping (string => bool) private _reservedNames;
mapping (uint256 => bool) private _mintedBeforeReveal;
Mars26 private _m26;
MarsStorage private _storage;
event NameChange (uint256 indexed maskIndex, string newName);
/**
* @dev Sets immutable values of contract.
*/
constructor (
bytes32 provenanceHash_,
address m26Address_,
uint256 nameChangePrice_,
uint256 saleStartTimestamp_,
uint256 revealTimestamp_,
address[] memory payees,
uint256[] memory shares_
) ERC721("Mars", "MARS") PaymentSplitter(payees, shares_) {
_provenanceHash = provenanceHash_;
_m26 = Mars26(m26Address_);
_nameChangePrice = nameChangePrice_;
_saleStartTimestamp = saleStartTimestamp_;
_revealTimestamp = revealTimestamp_;
_storage = new MarsStorage(MAX_SUPPLY);
}
/**
* @dev Returns provenance hash digest set during initialization of contract.
*
* The provenance hash is derived by concatenating all existing IPFS CIDs (v0)
* of the Mars NFTs and hashing the concatenated string using SHA2-256.
* Note that the CIDs were concatenated and hashed in their base58 representation.
*/
function provenanceHash() public view returns (bytes32) {
return _provenanceHash;
}
/**
* @dev Returns address of Mars26 ERC-20 token contract.
*/
function m26Address() public view returns (address) {
return address(_m26);
}
/**
* @dev Returns address of connected storage contract.
*/
function storageAddress() public view returns (address) {
return address(_storage);
}
/**
* @dev Returns the number of sold NFTs.
*/
function numSoldTokens() public view returns (uint256) {
return _numSoldTokens;
}
/**
* @dev Returns the MNCT price for changing the name of a token.
*/
function nameChangePrice() public view returns (uint256) {
return _nameChangePrice;
}
/**
* @dev Returns the start timestamp of the initial sale.
*/
function saleStartTimestamp() public view returns (uint256) {
return _saleStartTimestamp;
}
/**
* @dev Returns the reveal timestamp after which the token ids will be assigned.
*/
function revealTimestamp() public view returns (uint256) {
return _revealTimestamp;
}
/**
* @dev Returns the randomized starting index to assign and reveal token ids to
* intial sequence of NFTs.
*/
function startingIndex() public view returns (uint256) {
return _startingIndex;
}
/**
* @dev Returns the randomized starting index block which is used to derive
* {_startingIndex} from.
*/
function startingIndexBlock() public view returns (uint256) {
return _startingIndexBlock;
}
/**
* @dev See {MarsStorage.initialSequenceTokenCID}
*/
function initialSequenceTokenCID(uint256 initialSequenceIndex) public view returns (string memory) {
return _storage.initialSequenceTokenCID(initialSequenceIndex);
}
/**
* @dev Returns if {nameString} has been reserved.
*/
function isNameReserved(string memory nameString) public view returns (bool) {
return _reservedNames[_toLower(nameString)];
}
/**
* @dev Returns reverved name for given token id.
*/
function tokenNames(uint256 tokenId) public view returns (string memory) {
return _tokenNames[tokenId];
}
/**
* @dev Returns the set token URI, i.e. IPFS v0 CID, of {tokenId}.
* Prefixed with ipfs://
*/
function tokenURI(uint256 tokenId) public view override returns (string memory) {
require(_exists(tokenId), "ERC721URIStorage: URI query for nonexistent token");
require(_startingIndex > 0, "Tokens have not been assigned yet");
uint256 initialSequenceIndex = _toInitialSequenceIndex(tokenId);
return tokenURIOfInitialSequenceIndex(initialSequenceIndex);
}
/**
* @dev Returns the set token URI, i.e. IPFS v0 CID, of {initialSequenceIndex}.
* Prefixed with ipfs://
*/
function tokenURIOfInitialSequenceIndex(uint256 initialSequenceIndex) public view returns (string memory) {
require(_startingIndex > 0, "Tokens have not been assigned yet");
string memory tokenCID = initialSequenceTokenCID(initialSequenceIndex);
string memory base = _baseURI();
// If there is no base URI, return the token URI.
if (bytes(base).length == 0) {
return tokenCID;
}
// If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked).
if (bytes(tokenCID).length > 0) {
return string(abi.encodePacked(base, tokenCID));
}
return base;
}
/**
* @dev Returns if the NFT has been minted before reveal phase.
*/
function isMintedBeforeReveal(uint256 index) public view returns (bool) {
return _mintedBeforeReveal[index];
}
/**
* @dev Gets current NFT price based on already sold tokens.
*/
function getNFTPrice() public view returns (uint256) {
if (_numSoldTokens < 800) {
return 0.01 ether;
} else if (_numSoldTokens < 4400) {
return 0.02 ether;
} else if (_numSoldTokens < 8800) {
return 0.03 ether;
} else if (_numSoldTokens < 12600) {
return 0.05 ether;
} else if (_numSoldTokens < 14040) {
return 0.1 ether;
} else if (_numSoldTokens < 14392) {
return 0.3 ether;
} else {
return 1 ether;
}
}
/**
* @dev Mints Mars NFTs
*/
function mint(uint256 numberOfNfts) public payable {
require(block.timestamp >= _saleStartTimestamp, "Sale has not started");
require(totalSupply() < MAX_SUPPLY, "Sale has already ended");
require(numberOfNfts > 0, "Cannot buy 0 NFTs");
require(numberOfNfts <= 20, "You may not buy more than 20 NFTs at once");
require(_numSoldTokens.add(numberOfNfts) <= MAX_SUPPLY.sub(RESERVED_SUPPLY), "Exceeds max number of sellable NFTs");
require(getNFTPrice().mul(numberOfNfts) == msg.value, "Ether value sent is not correct");
for (uint i = 0; i < numberOfNfts; i++) {
uint mintIndex = totalSupply();
_numSoldTokens++;
require(mintIndex < MAX_SUPPLY, "Exceeds max number of NFTs in existence");
if (block.timestamp < _revealTimestamp) {
_mintedBeforeReveal[mintIndex] = true;
}
_safeMint(msg.sender, mintIndex);
}
// Source of randomness. Theoretical miner withhold manipulation possible but should be sufficient in a pragmatic sense
if (_startingIndexBlock == 0 && (_numSoldTokens >= MAX_SUPPLY.sub(RESERVED_SUPPLY) || block.timestamp >= _revealTimestamp)) {
_startingIndexBlock = block.number;
}
}
/**
* @dev Used to migrate already minted NFTs of old contract.
*/
function mintReserved(address to, uint256 numOfNFTs) public onlyOwner {
require(totalSupply().add(numOfNFTs) <= MAX_SUPPLY, "Exceeds max supply of NFTs");
require(_numMintedReservedTokens.add(numOfNFTs) <= RESERVED_SUPPLY, "Exceeds max num of reserved NFTs");
for (uint j = 0; j < numOfNFTs; j++) {
uint tokenId = totalSupply();
if (block.timestamp < _revealTimestamp) {
_mintedBeforeReveal[tokenId] = true;
}
_numMintedReservedTokens++;
_safeMint(to, tokenId);
}
}
/**
* @dev Finalize starting index
*/
function finalizeStartingIndex() public {
require(_startingIndex == 0, "Starting index is already set");
require(_startingIndexBlock != 0, "Starting index block must be set");
_startingIndex = uint(blockhash(_startingIndexBlock)) % MAX_SUPPLY;
// Just a sanity case in the worst case if this function is called late (EVM only stores last 256 block hashes)
if (block.number.sub(_startingIndexBlock) > 255) {
_startingIndex = uint(blockhash(block.number - 1)) % MAX_SUPPLY;
}
// Prevent default sequence
if (_startingIndex == 0) {
_startingIndex = _startingIndex.add(1);
}
}
/**
* @dev Changes the name for Mars tile tokenId
*/
function changeName(uint256 tokenId, string memory newName) public {
address owner = ownerOf(tokenId);
require(_msgSender() == owner, "ERC721: caller is not the owner");
require(_validateName(newName) == true, "Not a valid new name");
require(sha256(bytes(newName)) != sha256(bytes(_tokenNames[tokenId])), "New name is same as the current one");
require(isNameReserved(newName) == false, "Name already reserved");
_m26.transferFrom(msg.sender, address(this), _nameChangePrice);
// If already named, dereserve old name
if (bytes(_tokenNames[tokenId]).length > 0) {
_toggleReserveName(_tokenNames[tokenId], false);
}
_toggleReserveName(newName, true);
_tokenNames[tokenId] = newName;
_m26.burn(_nameChangePrice);
emit NameChange(tokenId, newName);
}
/**
* @dev See {MarsStorage.setInitialSequenceTokenHashes}
*/
function setInitialSequenceTokenHashes(bytes32[] memory tokenHashes) onlyOwner public {
_storage.setInitialSequenceTokenHashes(tokenHashes);
}
/**
* @dev See {MarsStorage.setInitialSequenceTokenHashesAtIndex}
*/
function setInitialSequenceTokenHashesAtIndex(
uint256 startIndex,
bytes32[] memory tokenHashes
) public onlyOwner {
_storage.setInitialSequenceTokenHashesAtIndex(startIndex, tokenHashes);
}
/**
* @dev Check if the name string is valid (Alphanumeric and spaces without leading or trailing space)
*/
function _validateName(string memory str) private pure returns (bool){
bytes memory b = bytes(str);
if (b.length < 1) return false;
if (b.length > 50) return false; // Cannot be longer than 25 characters
if (b[0] == 0x20) return false; // Leading space
if (b[b.length - 1] == 0x20) return false; // Trailing space
bytes1 lastChar = b[0];
for (uint i; i < b.length; i++) {
bytes1 char = b[i];
if (char == 0x20 && lastChar == 0x20) return false; // Cannot contain continous spaces
if (
!(char >= 0x30 && char <= 0x39) && //9-0
!(char >= 0x41 && char <= 0x5A) && //A-Z
!(char >= 0x61 && char <= 0x7A) && //a-z
!(char == 0x20) //space
)
return false;
lastChar = char;
}
return true;
}
/**
* @dev Converts the string to lowercase
*/
function _toLower(string memory str) private pure returns (string memory){
bytes memory bStr = bytes(str);
bytes memory bLower = new bytes(bStr.length);
for (uint i = 0; i < bStr.length; i++) {
// Uppercase character
if ((uint8(bStr[i]) >= 65) && (uint8(bStr[i]) <= 90)) {
bLower[i] = bytes1(uint8(bStr[i]) + 32);
} else {
bLower[i] = bStr[i];
}
}
return string(bLower);
}
/**
* @dev Reserves the name if isReserve is set to true, de-reserves if set to false
*/
function _toggleReserveName(string memory str, bool isReserve) internal {
_reservedNames[_toLower(str)] = isReserve;
}
function _baseURI() internal pure override returns (string memory) {
return "ipfs://";
}
function _toInitialSequenceIndex(uint256 tokenId) internal view returns (uint256) {
return (tokenId + _startingIndex) % MAX_SUPPLY;
}
} | /**
* @title Mars contract
* @dev Extends ERC721 Non-Fungible Token Standard basic implementation
*/ | NatSpecMultiLine | changeName | function changeName(uint256 tokenId, string memory newName) public {
address owner = ownerOf(tokenId);
require(_msgSender() == owner, "ERC721: caller is not the owner");
require(_validateName(newName) == true, "Not a valid new name");
require(sha256(bytes(newName)) != sha256(bytes(_tokenNames[tokenId])), "New name is same as the current one");
require(isNameReserved(newName) == false, "Name already reserved");
_m26.transferFrom(msg.sender, address(this), _nameChangePrice);
// If already named, dereserve old name
if (bytes(_tokenNames[tokenId]).length > 0) {
_toggleReserveName(_tokenNames[tokenId], false);
}
_toggleReserveName(newName, true);
_tokenNames[tokenId] = newName;
_m26.burn(_nameChangePrice);
emit NameChange(tokenId, newName);
}
| /**
* @dev Changes the name for Mars tile tokenId
*/ | NatSpecMultiLine | v0.8.3+commit.8d00100c | {
"func_code_index": [
9154,
10027
]
} | 8,948 |
||
MarsLocker | contracts/Mars.sol | 0x64200351e787b33cd7c518a93fc24d780092f727 | Solidity | Mars | contract Mars is Ownable, ERC721Enumerable, PaymentSplitter {
using SafeMath for uint256;
uint256 public constant MAX_SUPPLY = 16200;
uint256 public constant RESERVED_SUPPLY = 1305 + 500;
bytes32 private _provenanceHash;
uint256 private _nameChangePrice;
uint256 private _saleStartTimestamp;
uint256 private _revealTimestamp;
uint256 private _startingIndexBlock;
uint256 internal _startingIndex;
uint256 private _numSoldTokens;
uint256 private _numMintedReservedTokens;
mapping (uint256 => string) private _tokenNames;
mapping (string => bool) private _reservedNames;
mapping (uint256 => bool) private _mintedBeforeReveal;
Mars26 private _m26;
MarsStorage private _storage;
event NameChange (uint256 indexed maskIndex, string newName);
/**
* @dev Sets immutable values of contract.
*/
constructor (
bytes32 provenanceHash_,
address m26Address_,
uint256 nameChangePrice_,
uint256 saleStartTimestamp_,
uint256 revealTimestamp_,
address[] memory payees,
uint256[] memory shares_
) ERC721("Mars", "MARS") PaymentSplitter(payees, shares_) {
_provenanceHash = provenanceHash_;
_m26 = Mars26(m26Address_);
_nameChangePrice = nameChangePrice_;
_saleStartTimestamp = saleStartTimestamp_;
_revealTimestamp = revealTimestamp_;
_storage = new MarsStorage(MAX_SUPPLY);
}
/**
* @dev Returns provenance hash digest set during initialization of contract.
*
* The provenance hash is derived by concatenating all existing IPFS CIDs (v0)
* of the Mars NFTs and hashing the concatenated string using SHA2-256.
* Note that the CIDs were concatenated and hashed in their base58 representation.
*/
function provenanceHash() public view returns (bytes32) {
return _provenanceHash;
}
/**
* @dev Returns address of Mars26 ERC-20 token contract.
*/
function m26Address() public view returns (address) {
return address(_m26);
}
/**
* @dev Returns address of connected storage contract.
*/
function storageAddress() public view returns (address) {
return address(_storage);
}
/**
* @dev Returns the number of sold NFTs.
*/
function numSoldTokens() public view returns (uint256) {
return _numSoldTokens;
}
/**
* @dev Returns the MNCT price for changing the name of a token.
*/
function nameChangePrice() public view returns (uint256) {
return _nameChangePrice;
}
/**
* @dev Returns the start timestamp of the initial sale.
*/
function saleStartTimestamp() public view returns (uint256) {
return _saleStartTimestamp;
}
/**
* @dev Returns the reveal timestamp after which the token ids will be assigned.
*/
function revealTimestamp() public view returns (uint256) {
return _revealTimestamp;
}
/**
* @dev Returns the randomized starting index to assign and reveal token ids to
* intial sequence of NFTs.
*/
function startingIndex() public view returns (uint256) {
return _startingIndex;
}
/**
* @dev Returns the randomized starting index block which is used to derive
* {_startingIndex} from.
*/
function startingIndexBlock() public view returns (uint256) {
return _startingIndexBlock;
}
/**
* @dev See {MarsStorage.initialSequenceTokenCID}
*/
function initialSequenceTokenCID(uint256 initialSequenceIndex) public view returns (string memory) {
return _storage.initialSequenceTokenCID(initialSequenceIndex);
}
/**
* @dev Returns if {nameString} has been reserved.
*/
function isNameReserved(string memory nameString) public view returns (bool) {
return _reservedNames[_toLower(nameString)];
}
/**
* @dev Returns reverved name for given token id.
*/
function tokenNames(uint256 tokenId) public view returns (string memory) {
return _tokenNames[tokenId];
}
/**
* @dev Returns the set token URI, i.e. IPFS v0 CID, of {tokenId}.
* Prefixed with ipfs://
*/
function tokenURI(uint256 tokenId) public view override returns (string memory) {
require(_exists(tokenId), "ERC721URIStorage: URI query for nonexistent token");
require(_startingIndex > 0, "Tokens have not been assigned yet");
uint256 initialSequenceIndex = _toInitialSequenceIndex(tokenId);
return tokenURIOfInitialSequenceIndex(initialSequenceIndex);
}
/**
* @dev Returns the set token URI, i.e. IPFS v0 CID, of {initialSequenceIndex}.
* Prefixed with ipfs://
*/
function tokenURIOfInitialSequenceIndex(uint256 initialSequenceIndex) public view returns (string memory) {
require(_startingIndex > 0, "Tokens have not been assigned yet");
string memory tokenCID = initialSequenceTokenCID(initialSequenceIndex);
string memory base = _baseURI();
// If there is no base URI, return the token URI.
if (bytes(base).length == 0) {
return tokenCID;
}
// If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked).
if (bytes(tokenCID).length > 0) {
return string(abi.encodePacked(base, tokenCID));
}
return base;
}
/**
* @dev Returns if the NFT has been minted before reveal phase.
*/
function isMintedBeforeReveal(uint256 index) public view returns (bool) {
return _mintedBeforeReveal[index];
}
/**
* @dev Gets current NFT price based on already sold tokens.
*/
function getNFTPrice() public view returns (uint256) {
if (_numSoldTokens < 800) {
return 0.01 ether;
} else if (_numSoldTokens < 4400) {
return 0.02 ether;
} else if (_numSoldTokens < 8800) {
return 0.03 ether;
} else if (_numSoldTokens < 12600) {
return 0.05 ether;
} else if (_numSoldTokens < 14040) {
return 0.1 ether;
} else if (_numSoldTokens < 14392) {
return 0.3 ether;
} else {
return 1 ether;
}
}
/**
* @dev Mints Mars NFTs
*/
function mint(uint256 numberOfNfts) public payable {
require(block.timestamp >= _saleStartTimestamp, "Sale has not started");
require(totalSupply() < MAX_SUPPLY, "Sale has already ended");
require(numberOfNfts > 0, "Cannot buy 0 NFTs");
require(numberOfNfts <= 20, "You may not buy more than 20 NFTs at once");
require(_numSoldTokens.add(numberOfNfts) <= MAX_SUPPLY.sub(RESERVED_SUPPLY), "Exceeds max number of sellable NFTs");
require(getNFTPrice().mul(numberOfNfts) == msg.value, "Ether value sent is not correct");
for (uint i = 0; i < numberOfNfts; i++) {
uint mintIndex = totalSupply();
_numSoldTokens++;
require(mintIndex < MAX_SUPPLY, "Exceeds max number of NFTs in existence");
if (block.timestamp < _revealTimestamp) {
_mintedBeforeReveal[mintIndex] = true;
}
_safeMint(msg.sender, mintIndex);
}
// Source of randomness. Theoretical miner withhold manipulation possible but should be sufficient in a pragmatic sense
if (_startingIndexBlock == 0 && (_numSoldTokens >= MAX_SUPPLY.sub(RESERVED_SUPPLY) || block.timestamp >= _revealTimestamp)) {
_startingIndexBlock = block.number;
}
}
/**
* @dev Used to migrate already minted NFTs of old contract.
*/
function mintReserved(address to, uint256 numOfNFTs) public onlyOwner {
require(totalSupply().add(numOfNFTs) <= MAX_SUPPLY, "Exceeds max supply of NFTs");
require(_numMintedReservedTokens.add(numOfNFTs) <= RESERVED_SUPPLY, "Exceeds max num of reserved NFTs");
for (uint j = 0; j < numOfNFTs; j++) {
uint tokenId = totalSupply();
if (block.timestamp < _revealTimestamp) {
_mintedBeforeReveal[tokenId] = true;
}
_numMintedReservedTokens++;
_safeMint(to, tokenId);
}
}
/**
* @dev Finalize starting index
*/
function finalizeStartingIndex() public {
require(_startingIndex == 0, "Starting index is already set");
require(_startingIndexBlock != 0, "Starting index block must be set");
_startingIndex = uint(blockhash(_startingIndexBlock)) % MAX_SUPPLY;
// Just a sanity case in the worst case if this function is called late (EVM only stores last 256 block hashes)
if (block.number.sub(_startingIndexBlock) > 255) {
_startingIndex = uint(blockhash(block.number - 1)) % MAX_SUPPLY;
}
// Prevent default sequence
if (_startingIndex == 0) {
_startingIndex = _startingIndex.add(1);
}
}
/**
* @dev Changes the name for Mars tile tokenId
*/
function changeName(uint256 tokenId, string memory newName) public {
address owner = ownerOf(tokenId);
require(_msgSender() == owner, "ERC721: caller is not the owner");
require(_validateName(newName) == true, "Not a valid new name");
require(sha256(bytes(newName)) != sha256(bytes(_tokenNames[tokenId])), "New name is same as the current one");
require(isNameReserved(newName) == false, "Name already reserved");
_m26.transferFrom(msg.sender, address(this), _nameChangePrice);
// If already named, dereserve old name
if (bytes(_tokenNames[tokenId]).length > 0) {
_toggleReserveName(_tokenNames[tokenId], false);
}
_toggleReserveName(newName, true);
_tokenNames[tokenId] = newName;
_m26.burn(_nameChangePrice);
emit NameChange(tokenId, newName);
}
/**
* @dev See {MarsStorage.setInitialSequenceTokenHashes}
*/
function setInitialSequenceTokenHashes(bytes32[] memory tokenHashes) onlyOwner public {
_storage.setInitialSequenceTokenHashes(tokenHashes);
}
/**
* @dev See {MarsStorage.setInitialSequenceTokenHashesAtIndex}
*/
function setInitialSequenceTokenHashesAtIndex(
uint256 startIndex,
bytes32[] memory tokenHashes
) public onlyOwner {
_storage.setInitialSequenceTokenHashesAtIndex(startIndex, tokenHashes);
}
/**
* @dev Check if the name string is valid (Alphanumeric and spaces without leading or trailing space)
*/
function _validateName(string memory str) private pure returns (bool){
bytes memory b = bytes(str);
if (b.length < 1) return false;
if (b.length > 50) return false; // Cannot be longer than 25 characters
if (b[0] == 0x20) return false; // Leading space
if (b[b.length - 1] == 0x20) return false; // Trailing space
bytes1 lastChar = b[0];
for (uint i; i < b.length; i++) {
bytes1 char = b[i];
if (char == 0x20 && lastChar == 0x20) return false; // Cannot contain continous spaces
if (
!(char >= 0x30 && char <= 0x39) && //9-0
!(char >= 0x41 && char <= 0x5A) && //A-Z
!(char >= 0x61 && char <= 0x7A) && //a-z
!(char == 0x20) //space
)
return false;
lastChar = char;
}
return true;
}
/**
* @dev Converts the string to lowercase
*/
function _toLower(string memory str) private pure returns (string memory){
bytes memory bStr = bytes(str);
bytes memory bLower = new bytes(bStr.length);
for (uint i = 0; i < bStr.length; i++) {
// Uppercase character
if ((uint8(bStr[i]) >= 65) && (uint8(bStr[i]) <= 90)) {
bLower[i] = bytes1(uint8(bStr[i]) + 32);
} else {
bLower[i] = bStr[i];
}
}
return string(bLower);
}
/**
* @dev Reserves the name if isReserve is set to true, de-reserves if set to false
*/
function _toggleReserveName(string memory str, bool isReserve) internal {
_reservedNames[_toLower(str)] = isReserve;
}
function _baseURI() internal pure override returns (string memory) {
return "ipfs://";
}
function _toInitialSequenceIndex(uint256 tokenId) internal view returns (uint256) {
return (tokenId + _startingIndex) % MAX_SUPPLY;
}
} | /**
* @title Mars contract
* @dev Extends ERC721 Non-Fungible Token Standard basic implementation
*/ | NatSpecMultiLine | setInitialSequenceTokenHashes | function setInitialSequenceTokenHashes(bytes32[] memory tokenHashes) onlyOwner public {
_storage.setInitialSequenceTokenHashes(tokenHashes);
}
| /**
* @dev See {MarsStorage.setInitialSequenceTokenHashes}
*/ | NatSpecMultiLine | v0.8.3+commit.8d00100c | {
"func_code_index": [
10105,
10263
]
} | 8,949 |
||
MarsLocker | contracts/Mars.sol | 0x64200351e787b33cd7c518a93fc24d780092f727 | Solidity | Mars | contract Mars is Ownable, ERC721Enumerable, PaymentSplitter {
using SafeMath for uint256;
uint256 public constant MAX_SUPPLY = 16200;
uint256 public constant RESERVED_SUPPLY = 1305 + 500;
bytes32 private _provenanceHash;
uint256 private _nameChangePrice;
uint256 private _saleStartTimestamp;
uint256 private _revealTimestamp;
uint256 private _startingIndexBlock;
uint256 internal _startingIndex;
uint256 private _numSoldTokens;
uint256 private _numMintedReservedTokens;
mapping (uint256 => string) private _tokenNames;
mapping (string => bool) private _reservedNames;
mapping (uint256 => bool) private _mintedBeforeReveal;
Mars26 private _m26;
MarsStorage private _storage;
event NameChange (uint256 indexed maskIndex, string newName);
/**
* @dev Sets immutable values of contract.
*/
constructor (
bytes32 provenanceHash_,
address m26Address_,
uint256 nameChangePrice_,
uint256 saleStartTimestamp_,
uint256 revealTimestamp_,
address[] memory payees,
uint256[] memory shares_
) ERC721("Mars", "MARS") PaymentSplitter(payees, shares_) {
_provenanceHash = provenanceHash_;
_m26 = Mars26(m26Address_);
_nameChangePrice = nameChangePrice_;
_saleStartTimestamp = saleStartTimestamp_;
_revealTimestamp = revealTimestamp_;
_storage = new MarsStorage(MAX_SUPPLY);
}
/**
* @dev Returns provenance hash digest set during initialization of contract.
*
* The provenance hash is derived by concatenating all existing IPFS CIDs (v0)
* of the Mars NFTs and hashing the concatenated string using SHA2-256.
* Note that the CIDs were concatenated and hashed in their base58 representation.
*/
function provenanceHash() public view returns (bytes32) {
return _provenanceHash;
}
/**
* @dev Returns address of Mars26 ERC-20 token contract.
*/
function m26Address() public view returns (address) {
return address(_m26);
}
/**
* @dev Returns address of connected storage contract.
*/
function storageAddress() public view returns (address) {
return address(_storage);
}
/**
* @dev Returns the number of sold NFTs.
*/
function numSoldTokens() public view returns (uint256) {
return _numSoldTokens;
}
/**
* @dev Returns the MNCT price for changing the name of a token.
*/
function nameChangePrice() public view returns (uint256) {
return _nameChangePrice;
}
/**
* @dev Returns the start timestamp of the initial sale.
*/
function saleStartTimestamp() public view returns (uint256) {
return _saleStartTimestamp;
}
/**
* @dev Returns the reveal timestamp after which the token ids will be assigned.
*/
function revealTimestamp() public view returns (uint256) {
return _revealTimestamp;
}
/**
* @dev Returns the randomized starting index to assign and reveal token ids to
* intial sequence of NFTs.
*/
function startingIndex() public view returns (uint256) {
return _startingIndex;
}
/**
* @dev Returns the randomized starting index block which is used to derive
* {_startingIndex} from.
*/
function startingIndexBlock() public view returns (uint256) {
return _startingIndexBlock;
}
/**
* @dev See {MarsStorage.initialSequenceTokenCID}
*/
function initialSequenceTokenCID(uint256 initialSequenceIndex) public view returns (string memory) {
return _storage.initialSequenceTokenCID(initialSequenceIndex);
}
/**
* @dev Returns if {nameString} has been reserved.
*/
function isNameReserved(string memory nameString) public view returns (bool) {
return _reservedNames[_toLower(nameString)];
}
/**
* @dev Returns reverved name for given token id.
*/
function tokenNames(uint256 tokenId) public view returns (string memory) {
return _tokenNames[tokenId];
}
/**
* @dev Returns the set token URI, i.e. IPFS v0 CID, of {tokenId}.
* Prefixed with ipfs://
*/
function tokenURI(uint256 tokenId) public view override returns (string memory) {
require(_exists(tokenId), "ERC721URIStorage: URI query for nonexistent token");
require(_startingIndex > 0, "Tokens have not been assigned yet");
uint256 initialSequenceIndex = _toInitialSequenceIndex(tokenId);
return tokenURIOfInitialSequenceIndex(initialSequenceIndex);
}
/**
* @dev Returns the set token URI, i.e. IPFS v0 CID, of {initialSequenceIndex}.
* Prefixed with ipfs://
*/
function tokenURIOfInitialSequenceIndex(uint256 initialSequenceIndex) public view returns (string memory) {
require(_startingIndex > 0, "Tokens have not been assigned yet");
string memory tokenCID = initialSequenceTokenCID(initialSequenceIndex);
string memory base = _baseURI();
// If there is no base URI, return the token URI.
if (bytes(base).length == 0) {
return tokenCID;
}
// If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked).
if (bytes(tokenCID).length > 0) {
return string(abi.encodePacked(base, tokenCID));
}
return base;
}
/**
* @dev Returns if the NFT has been minted before reveal phase.
*/
function isMintedBeforeReveal(uint256 index) public view returns (bool) {
return _mintedBeforeReveal[index];
}
/**
* @dev Gets current NFT price based on already sold tokens.
*/
function getNFTPrice() public view returns (uint256) {
if (_numSoldTokens < 800) {
return 0.01 ether;
} else if (_numSoldTokens < 4400) {
return 0.02 ether;
} else if (_numSoldTokens < 8800) {
return 0.03 ether;
} else if (_numSoldTokens < 12600) {
return 0.05 ether;
} else if (_numSoldTokens < 14040) {
return 0.1 ether;
} else if (_numSoldTokens < 14392) {
return 0.3 ether;
} else {
return 1 ether;
}
}
/**
* @dev Mints Mars NFTs
*/
function mint(uint256 numberOfNfts) public payable {
require(block.timestamp >= _saleStartTimestamp, "Sale has not started");
require(totalSupply() < MAX_SUPPLY, "Sale has already ended");
require(numberOfNfts > 0, "Cannot buy 0 NFTs");
require(numberOfNfts <= 20, "You may not buy more than 20 NFTs at once");
require(_numSoldTokens.add(numberOfNfts) <= MAX_SUPPLY.sub(RESERVED_SUPPLY), "Exceeds max number of sellable NFTs");
require(getNFTPrice().mul(numberOfNfts) == msg.value, "Ether value sent is not correct");
for (uint i = 0; i < numberOfNfts; i++) {
uint mintIndex = totalSupply();
_numSoldTokens++;
require(mintIndex < MAX_SUPPLY, "Exceeds max number of NFTs in existence");
if (block.timestamp < _revealTimestamp) {
_mintedBeforeReveal[mintIndex] = true;
}
_safeMint(msg.sender, mintIndex);
}
// Source of randomness. Theoretical miner withhold manipulation possible but should be sufficient in a pragmatic sense
if (_startingIndexBlock == 0 && (_numSoldTokens >= MAX_SUPPLY.sub(RESERVED_SUPPLY) || block.timestamp >= _revealTimestamp)) {
_startingIndexBlock = block.number;
}
}
/**
* @dev Used to migrate already minted NFTs of old contract.
*/
function mintReserved(address to, uint256 numOfNFTs) public onlyOwner {
require(totalSupply().add(numOfNFTs) <= MAX_SUPPLY, "Exceeds max supply of NFTs");
require(_numMintedReservedTokens.add(numOfNFTs) <= RESERVED_SUPPLY, "Exceeds max num of reserved NFTs");
for (uint j = 0; j < numOfNFTs; j++) {
uint tokenId = totalSupply();
if (block.timestamp < _revealTimestamp) {
_mintedBeforeReveal[tokenId] = true;
}
_numMintedReservedTokens++;
_safeMint(to, tokenId);
}
}
/**
* @dev Finalize starting index
*/
function finalizeStartingIndex() public {
require(_startingIndex == 0, "Starting index is already set");
require(_startingIndexBlock != 0, "Starting index block must be set");
_startingIndex = uint(blockhash(_startingIndexBlock)) % MAX_SUPPLY;
// Just a sanity case in the worst case if this function is called late (EVM only stores last 256 block hashes)
if (block.number.sub(_startingIndexBlock) > 255) {
_startingIndex = uint(blockhash(block.number - 1)) % MAX_SUPPLY;
}
// Prevent default sequence
if (_startingIndex == 0) {
_startingIndex = _startingIndex.add(1);
}
}
/**
* @dev Changes the name for Mars tile tokenId
*/
function changeName(uint256 tokenId, string memory newName) public {
address owner = ownerOf(tokenId);
require(_msgSender() == owner, "ERC721: caller is not the owner");
require(_validateName(newName) == true, "Not a valid new name");
require(sha256(bytes(newName)) != sha256(bytes(_tokenNames[tokenId])), "New name is same as the current one");
require(isNameReserved(newName) == false, "Name already reserved");
_m26.transferFrom(msg.sender, address(this), _nameChangePrice);
// If already named, dereserve old name
if (bytes(_tokenNames[tokenId]).length > 0) {
_toggleReserveName(_tokenNames[tokenId], false);
}
_toggleReserveName(newName, true);
_tokenNames[tokenId] = newName;
_m26.burn(_nameChangePrice);
emit NameChange(tokenId, newName);
}
/**
* @dev See {MarsStorage.setInitialSequenceTokenHashes}
*/
function setInitialSequenceTokenHashes(bytes32[] memory tokenHashes) onlyOwner public {
_storage.setInitialSequenceTokenHashes(tokenHashes);
}
/**
* @dev See {MarsStorage.setInitialSequenceTokenHashesAtIndex}
*/
function setInitialSequenceTokenHashesAtIndex(
uint256 startIndex,
bytes32[] memory tokenHashes
) public onlyOwner {
_storage.setInitialSequenceTokenHashesAtIndex(startIndex, tokenHashes);
}
/**
* @dev Check if the name string is valid (Alphanumeric and spaces without leading or trailing space)
*/
function _validateName(string memory str) private pure returns (bool){
bytes memory b = bytes(str);
if (b.length < 1) return false;
if (b.length > 50) return false; // Cannot be longer than 25 characters
if (b[0] == 0x20) return false; // Leading space
if (b[b.length - 1] == 0x20) return false; // Trailing space
bytes1 lastChar = b[0];
for (uint i; i < b.length; i++) {
bytes1 char = b[i];
if (char == 0x20 && lastChar == 0x20) return false; // Cannot contain continous spaces
if (
!(char >= 0x30 && char <= 0x39) && //9-0
!(char >= 0x41 && char <= 0x5A) && //A-Z
!(char >= 0x61 && char <= 0x7A) && //a-z
!(char == 0x20) //space
)
return false;
lastChar = char;
}
return true;
}
/**
* @dev Converts the string to lowercase
*/
function _toLower(string memory str) private pure returns (string memory){
bytes memory bStr = bytes(str);
bytes memory bLower = new bytes(bStr.length);
for (uint i = 0; i < bStr.length; i++) {
// Uppercase character
if ((uint8(bStr[i]) >= 65) && (uint8(bStr[i]) <= 90)) {
bLower[i] = bytes1(uint8(bStr[i]) + 32);
} else {
bLower[i] = bStr[i];
}
}
return string(bLower);
}
/**
* @dev Reserves the name if isReserve is set to true, de-reserves if set to false
*/
function _toggleReserveName(string memory str, bool isReserve) internal {
_reservedNames[_toLower(str)] = isReserve;
}
function _baseURI() internal pure override returns (string memory) {
return "ipfs://";
}
function _toInitialSequenceIndex(uint256 tokenId) internal view returns (uint256) {
return (tokenId + _startingIndex) % MAX_SUPPLY;
}
} | /**
* @title Mars contract
* @dev Extends ERC721 Non-Fungible Token Standard basic implementation
*/ | NatSpecMultiLine | setInitialSequenceTokenHashesAtIndex | function setInitialSequenceTokenHashesAtIndex(
uint256 startIndex,
bytes32[] memory tokenHashes
) public onlyOwner {
_storage.setInitialSequenceTokenHashesAtIndex(startIndex, tokenHashes);
}
| /**
* @dev See {MarsStorage.setInitialSequenceTokenHashesAtIndex}
*/ | NatSpecMultiLine | v0.8.3+commit.8d00100c | {
"func_code_index": [
10348,
10574
]
} | 8,950 |
||
MarsLocker | contracts/Mars.sol | 0x64200351e787b33cd7c518a93fc24d780092f727 | Solidity | Mars | contract Mars is Ownable, ERC721Enumerable, PaymentSplitter {
using SafeMath for uint256;
uint256 public constant MAX_SUPPLY = 16200;
uint256 public constant RESERVED_SUPPLY = 1305 + 500;
bytes32 private _provenanceHash;
uint256 private _nameChangePrice;
uint256 private _saleStartTimestamp;
uint256 private _revealTimestamp;
uint256 private _startingIndexBlock;
uint256 internal _startingIndex;
uint256 private _numSoldTokens;
uint256 private _numMintedReservedTokens;
mapping (uint256 => string) private _tokenNames;
mapping (string => bool) private _reservedNames;
mapping (uint256 => bool) private _mintedBeforeReveal;
Mars26 private _m26;
MarsStorage private _storage;
event NameChange (uint256 indexed maskIndex, string newName);
/**
* @dev Sets immutable values of contract.
*/
constructor (
bytes32 provenanceHash_,
address m26Address_,
uint256 nameChangePrice_,
uint256 saleStartTimestamp_,
uint256 revealTimestamp_,
address[] memory payees,
uint256[] memory shares_
) ERC721("Mars", "MARS") PaymentSplitter(payees, shares_) {
_provenanceHash = provenanceHash_;
_m26 = Mars26(m26Address_);
_nameChangePrice = nameChangePrice_;
_saleStartTimestamp = saleStartTimestamp_;
_revealTimestamp = revealTimestamp_;
_storage = new MarsStorage(MAX_SUPPLY);
}
/**
* @dev Returns provenance hash digest set during initialization of contract.
*
* The provenance hash is derived by concatenating all existing IPFS CIDs (v0)
* of the Mars NFTs and hashing the concatenated string using SHA2-256.
* Note that the CIDs were concatenated and hashed in their base58 representation.
*/
function provenanceHash() public view returns (bytes32) {
return _provenanceHash;
}
/**
* @dev Returns address of Mars26 ERC-20 token contract.
*/
function m26Address() public view returns (address) {
return address(_m26);
}
/**
* @dev Returns address of connected storage contract.
*/
function storageAddress() public view returns (address) {
return address(_storage);
}
/**
* @dev Returns the number of sold NFTs.
*/
function numSoldTokens() public view returns (uint256) {
return _numSoldTokens;
}
/**
* @dev Returns the MNCT price for changing the name of a token.
*/
function nameChangePrice() public view returns (uint256) {
return _nameChangePrice;
}
/**
* @dev Returns the start timestamp of the initial sale.
*/
function saleStartTimestamp() public view returns (uint256) {
return _saleStartTimestamp;
}
/**
* @dev Returns the reveal timestamp after which the token ids will be assigned.
*/
function revealTimestamp() public view returns (uint256) {
return _revealTimestamp;
}
/**
* @dev Returns the randomized starting index to assign and reveal token ids to
* intial sequence of NFTs.
*/
function startingIndex() public view returns (uint256) {
return _startingIndex;
}
/**
* @dev Returns the randomized starting index block which is used to derive
* {_startingIndex} from.
*/
function startingIndexBlock() public view returns (uint256) {
return _startingIndexBlock;
}
/**
* @dev See {MarsStorage.initialSequenceTokenCID}
*/
function initialSequenceTokenCID(uint256 initialSequenceIndex) public view returns (string memory) {
return _storage.initialSequenceTokenCID(initialSequenceIndex);
}
/**
* @dev Returns if {nameString} has been reserved.
*/
function isNameReserved(string memory nameString) public view returns (bool) {
return _reservedNames[_toLower(nameString)];
}
/**
* @dev Returns reverved name for given token id.
*/
function tokenNames(uint256 tokenId) public view returns (string memory) {
return _tokenNames[tokenId];
}
/**
* @dev Returns the set token URI, i.e. IPFS v0 CID, of {tokenId}.
* Prefixed with ipfs://
*/
function tokenURI(uint256 tokenId) public view override returns (string memory) {
require(_exists(tokenId), "ERC721URIStorage: URI query for nonexistent token");
require(_startingIndex > 0, "Tokens have not been assigned yet");
uint256 initialSequenceIndex = _toInitialSequenceIndex(tokenId);
return tokenURIOfInitialSequenceIndex(initialSequenceIndex);
}
/**
* @dev Returns the set token URI, i.e. IPFS v0 CID, of {initialSequenceIndex}.
* Prefixed with ipfs://
*/
function tokenURIOfInitialSequenceIndex(uint256 initialSequenceIndex) public view returns (string memory) {
require(_startingIndex > 0, "Tokens have not been assigned yet");
string memory tokenCID = initialSequenceTokenCID(initialSequenceIndex);
string memory base = _baseURI();
// If there is no base URI, return the token URI.
if (bytes(base).length == 0) {
return tokenCID;
}
// If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked).
if (bytes(tokenCID).length > 0) {
return string(abi.encodePacked(base, tokenCID));
}
return base;
}
/**
* @dev Returns if the NFT has been minted before reveal phase.
*/
function isMintedBeforeReveal(uint256 index) public view returns (bool) {
return _mintedBeforeReveal[index];
}
/**
* @dev Gets current NFT price based on already sold tokens.
*/
function getNFTPrice() public view returns (uint256) {
if (_numSoldTokens < 800) {
return 0.01 ether;
} else if (_numSoldTokens < 4400) {
return 0.02 ether;
} else if (_numSoldTokens < 8800) {
return 0.03 ether;
} else if (_numSoldTokens < 12600) {
return 0.05 ether;
} else if (_numSoldTokens < 14040) {
return 0.1 ether;
} else if (_numSoldTokens < 14392) {
return 0.3 ether;
} else {
return 1 ether;
}
}
/**
* @dev Mints Mars NFTs
*/
function mint(uint256 numberOfNfts) public payable {
require(block.timestamp >= _saleStartTimestamp, "Sale has not started");
require(totalSupply() < MAX_SUPPLY, "Sale has already ended");
require(numberOfNfts > 0, "Cannot buy 0 NFTs");
require(numberOfNfts <= 20, "You may not buy more than 20 NFTs at once");
require(_numSoldTokens.add(numberOfNfts) <= MAX_SUPPLY.sub(RESERVED_SUPPLY), "Exceeds max number of sellable NFTs");
require(getNFTPrice().mul(numberOfNfts) == msg.value, "Ether value sent is not correct");
for (uint i = 0; i < numberOfNfts; i++) {
uint mintIndex = totalSupply();
_numSoldTokens++;
require(mintIndex < MAX_SUPPLY, "Exceeds max number of NFTs in existence");
if (block.timestamp < _revealTimestamp) {
_mintedBeforeReveal[mintIndex] = true;
}
_safeMint(msg.sender, mintIndex);
}
// Source of randomness. Theoretical miner withhold manipulation possible but should be sufficient in a pragmatic sense
if (_startingIndexBlock == 0 && (_numSoldTokens >= MAX_SUPPLY.sub(RESERVED_SUPPLY) || block.timestamp >= _revealTimestamp)) {
_startingIndexBlock = block.number;
}
}
/**
* @dev Used to migrate already minted NFTs of old contract.
*/
function mintReserved(address to, uint256 numOfNFTs) public onlyOwner {
require(totalSupply().add(numOfNFTs) <= MAX_SUPPLY, "Exceeds max supply of NFTs");
require(_numMintedReservedTokens.add(numOfNFTs) <= RESERVED_SUPPLY, "Exceeds max num of reserved NFTs");
for (uint j = 0; j < numOfNFTs; j++) {
uint tokenId = totalSupply();
if (block.timestamp < _revealTimestamp) {
_mintedBeforeReveal[tokenId] = true;
}
_numMintedReservedTokens++;
_safeMint(to, tokenId);
}
}
/**
* @dev Finalize starting index
*/
function finalizeStartingIndex() public {
require(_startingIndex == 0, "Starting index is already set");
require(_startingIndexBlock != 0, "Starting index block must be set");
_startingIndex = uint(blockhash(_startingIndexBlock)) % MAX_SUPPLY;
// Just a sanity case in the worst case if this function is called late (EVM only stores last 256 block hashes)
if (block.number.sub(_startingIndexBlock) > 255) {
_startingIndex = uint(blockhash(block.number - 1)) % MAX_SUPPLY;
}
// Prevent default sequence
if (_startingIndex == 0) {
_startingIndex = _startingIndex.add(1);
}
}
/**
* @dev Changes the name for Mars tile tokenId
*/
function changeName(uint256 tokenId, string memory newName) public {
address owner = ownerOf(tokenId);
require(_msgSender() == owner, "ERC721: caller is not the owner");
require(_validateName(newName) == true, "Not a valid new name");
require(sha256(bytes(newName)) != sha256(bytes(_tokenNames[tokenId])), "New name is same as the current one");
require(isNameReserved(newName) == false, "Name already reserved");
_m26.transferFrom(msg.sender, address(this), _nameChangePrice);
// If already named, dereserve old name
if (bytes(_tokenNames[tokenId]).length > 0) {
_toggleReserveName(_tokenNames[tokenId], false);
}
_toggleReserveName(newName, true);
_tokenNames[tokenId] = newName;
_m26.burn(_nameChangePrice);
emit NameChange(tokenId, newName);
}
/**
* @dev See {MarsStorage.setInitialSequenceTokenHashes}
*/
function setInitialSequenceTokenHashes(bytes32[] memory tokenHashes) onlyOwner public {
_storage.setInitialSequenceTokenHashes(tokenHashes);
}
/**
* @dev See {MarsStorage.setInitialSequenceTokenHashesAtIndex}
*/
function setInitialSequenceTokenHashesAtIndex(
uint256 startIndex,
bytes32[] memory tokenHashes
) public onlyOwner {
_storage.setInitialSequenceTokenHashesAtIndex(startIndex, tokenHashes);
}
/**
* @dev Check if the name string is valid (Alphanumeric and spaces without leading or trailing space)
*/
function _validateName(string memory str) private pure returns (bool){
bytes memory b = bytes(str);
if (b.length < 1) return false;
if (b.length > 50) return false; // Cannot be longer than 25 characters
if (b[0] == 0x20) return false; // Leading space
if (b[b.length - 1] == 0x20) return false; // Trailing space
bytes1 lastChar = b[0];
for (uint i; i < b.length; i++) {
bytes1 char = b[i];
if (char == 0x20 && lastChar == 0x20) return false; // Cannot contain continous spaces
if (
!(char >= 0x30 && char <= 0x39) && //9-0
!(char >= 0x41 && char <= 0x5A) && //A-Z
!(char >= 0x61 && char <= 0x7A) && //a-z
!(char == 0x20) //space
)
return false;
lastChar = char;
}
return true;
}
/**
* @dev Converts the string to lowercase
*/
function _toLower(string memory str) private pure returns (string memory){
bytes memory bStr = bytes(str);
bytes memory bLower = new bytes(bStr.length);
for (uint i = 0; i < bStr.length; i++) {
// Uppercase character
if ((uint8(bStr[i]) >= 65) && (uint8(bStr[i]) <= 90)) {
bLower[i] = bytes1(uint8(bStr[i]) + 32);
} else {
bLower[i] = bStr[i];
}
}
return string(bLower);
}
/**
* @dev Reserves the name if isReserve is set to true, de-reserves if set to false
*/
function _toggleReserveName(string memory str, bool isReserve) internal {
_reservedNames[_toLower(str)] = isReserve;
}
function _baseURI() internal pure override returns (string memory) {
return "ipfs://";
}
function _toInitialSequenceIndex(uint256 tokenId) internal view returns (uint256) {
return (tokenId + _startingIndex) % MAX_SUPPLY;
}
} | /**
* @title Mars contract
* @dev Extends ERC721 Non-Fungible Token Standard basic implementation
*/ | NatSpecMultiLine | _validateName | function _validateName(string memory str) private pure returns (bool){
bytes memory b = bytes(str);
if (b.length < 1) return false;
if (b.length > 50) return false; // Cannot be longer than 25 characters
if (b[0] == 0x20) return false; // Leading space
if (b[b.length - 1] == 0x20) return false; // Trailing space
bytes1 lastChar = b[0];
for (uint i; i < b.length; i++) {
bytes1 char = b[i];
if (char == 0x20 && lastChar == 0x20) return false; // Cannot contain continous spaces
if (
!(char >= 0x30 && char <= 0x39) && //9-0
!(char >= 0x41 && char <= 0x5A) && //A-Z
!(char >= 0x61 && char <= 0x7A) && //a-z
!(char == 0x20) //space
)
return false;
lastChar = char;
}
return true;
}
| /**
* @dev Check if the name string is valid (Alphanumeric and spaces without leading or trailing space)
*/ | NatSpecMultiLine | v0.8.3+commit.8d00100c | {
"func_code_index": [
10698,
11604
]
} | 8,951 |
||
MarsLocker | contracts/Mars.sol | 0x64200351e787b33cd7c518a93fc24d780092f727 | Solidity | Mars | contract Mars is Ownable, ERC721Enumerable, PaymentSplitter {
using SafeMath for uint256;
uint256 public constant MAX_SUPPLY = 16200;
uint256 public constant RESERVED_SUPPLY = 1305 + 500;
bytes32 private _provenanceHash;
uint256 private _nameChangePrice;
uint256 private _saleStartTimestamp;
uint256 private _revealTimestamp;
uint256 private _startingIndexBlock;
uint256 internal _startingIndex;
uint256 private _numSoldTokens;
uint256 private _numMintedReservedTokens;
mapping (uint256 => string) private _tokenNames;
mapping (string => bool) private _reservedNames;
mapping (uint256 => bool) private _mintedBeforeReveal;
Mars26 private _m26;
MarsStorage private _storage;
event NameChange (uint256 indexed maskIndex, string newName);
/**
* @dev Sets immutable values of contract.
*/
constructor (
bytes32 provenanceHash_,
address m26Address_,
uint256 nameChangePrice_,
uint256 saleStartTimestamp_,
uint256 revealTimestamp_,
address[] memory payees,
uint256[] memory shares_
) ERC721("Mars", "MARS") PaymentSplitter(payees, shares_) {
_provenanceHash = provenanceHash_;
_m26 = Mars26(m26Address_);
_nameChangePrice = nameChangePrice_;
_saleStartTimestamp = saleStartTimestamp_;
_revealTimestamp = revealTimestamp_;
_storage = new MarsStorage(MAX_SUPPLY);
}
/**
* @dev Returns provenance hash digest set during initialization of contract.
*
* The provenance hash is derived by concatenating all existing IPFS CIDs (v0)
* of the Mars NFTs and hashing the concatenated string using SHA2-256.
* Note that the CIDs were concatenated and hashed in their base58 representation.
*/
function provenanceHash() public view returns (bytes32) {
return _provenanceHash;
}
/**
* @dev Returns address of Mars26 ERC-20 token contract.
*/
function m26Address() public view returns (address) {
return address(_m26);
}
/**
* @dev Returns address of connected storage contract.
*/
function storageAddress() public view returns (address) {
return address(_storage);
}
/**
* @dev Returns the number of sold NFTs.
*/
function numSoldTokens() public view returns (uint256) {
return _numSoldTokens;
}
/**
* @dev Returns the MNCT price for changing the name of a token.
*/
function nameChangePrice() public view returns (uint256) {
return _nameChangePrice;
}
/**
* @dev Returns the start timestamp of the initial sale.
*/
function saleStartTimestamp() public view returns (uint256) {
return _saleStartTimestamp;
}
/**
* @dev Returns the reveal timestamp after which the token ids will be assigned.
*/
function revealTimestamp() public view returns (uint256) {
return _revealTimestamp;
}
/**
* @dev Returns the randomized starting index to assign and reveal token ids to
* intial sequence of NFTs.
*/
function startingIndex() public view returns (uint256) {
return _startingIndex;
}
/**
* @dev Returns the randomized starting index block which is used to derive
* {_startingIndex} from.
*/
function startingIndexBlock() public view returns (uint256) {
return _startingIndexBlock;
}
/**
* @dev See {MarsStorage.initialSequenceTokenCID}
*/
function initialSequenceTokenCID(uint256 initialSequenceIndex) public view returns (string memory) {
return _storage.initialSequenceTokenCID(initialSequenceIndex);
}
/**
* @dev Returns if {nameString} has been reserved.
*/
function isNameReserved(string memory nameString) public view returns (bool) {
return _reservedNames[_toLower(nameString)];
}
/**
* @dev Returns reverved name for given token id.
*/
function tokenNames(uint256 tokenId) public view returns (string memory) {
return _tokenNames[tokenId];
}
/**
* @dev Returns the set token URI, i.e. IPFS v0 CID, of {tokenId}.
* Prefixed with ipfs://
*/
function tokenURI(uint256 tokenId) public view override returns (string memory) {
require(_exists(tokenId), "ERC721URIStorage: URI query for nonexistent token");
require(_startingIndex > 0, "Tokens have not been assigned yet");
uint256 initialSequenceIndex = _toInitialSequenceIndex(tokenId);
return tokenURIOfInitialSequenceIndex(initialSequenceIndex);
}
/**
* @dev Returns the set token URI, i.e. IPFS v0 CID, of {initialSequenceIndex}.
* Prefixed with ipfs://
*/
function tokenURIOfInitialSequenceIndex(uint256 initialSequenceIndex) public view returns (string memory) {
require(_startingIndex > 0, "Tokens have not been assigned yet");
string memory tokenCID = initialSequenceTokenCID(initialSequenceIndex);
string memory base = _baseURI();
// If there is no base URI, return the token URI.
if (bytes(base).length == 0) {
return tokenCID;
}
// If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked).
if (bytes(tokenCID).length > 0) {
return string(abi.encodePacked(base, tokenCID));
}
return base;
}
/**
* @dev Returns if the NFT has been minted before reveal phase.
*/
function isMintedBeforeReveal(uint256 index) public view returns (bool) {
return _mintedBeforeReveal[index];
}
/**
* @dev Gets current NFT price based on already sold tokens.
*/
function getNFTPrice() public view returns (uint256) {
if (_numSoldTokens < 800) {
return 0.01 ether;
} else if (_numSoldTokens < 4400) {
return 0.02 ether;
} else if (_numSoldTokens < 8800) {
return 0.03 ether;
} else if (_numSoldTokens < 12600) {
return 0.05 ether;
} else if (_numSoldTokens < 14040) {
return 0.1 ether;
} else if (_numSoldTokens < 14392) {
return 0.3 ether;
} else {
return 1 ether;
}
}
/**
* @dev Mints Mars NFTs
*/
function mint(uint256 numberOfNfts) public payable {
require(block.timestamp >= _saleStartTimestamp, "Sale has not started");
require(totalSupply() < MAX_SUPPLY, "Sale has already ended");
require(numberOfNfts > 0, "Cannot buy 0 NFTs");
require(numberOfNfts <= 20, "You may not buy more than 20 NFTs at once");
require(_numSoldTokens.add(numberOfNfts) <= MAX_SUPPLY.sub(RESERVED_SUPPLY), "Exceeds max number of sellable NFTs");
require(getNFTPrice().mul(numberOfNfts) == msg.value, "Ether value sent is not correct");
for (uint i = 0; i < numberOfNfts; i++) {
uint mintIndex = totalSupply();
_numSoldTokens++;
require(mintIndex < MAX_SUPPLY, "Exceeds max number of NFTs in existence");
if (block.timestamp < _revealTimestamp) {
_mintedBeforeReveal[mintIndex] = true;
}
_safeMint(msg.sender, mintIndex);
}
// Source of randomness. Theoretical miner withhold manipulation possible but should be sufficient in a pragmatic sense
if (_startingIndexBlock == 0 && (_numSoldTokens >= MAX_SUPPLY.sub(RESERVED_SUPPLY) || block.timestamp >= _revealTimestamp)) {
_startingIndexBlock = block.number;
}
}
/**
* @dev Used to migrate already minted NFTs of old contract.
*/
function mintReserved(address to, uint256 numOfNFTs) public onlyOwner {
require(totalSupply().add(numOfNFTs) <= MAX_SUPPLY, "Exceeds max supply of NFTs");
require(_numMintedReservedTokens.add(numOfNFTs) <= RESERVED_SUPPLY, "Exceeds max num of reserved NFTs");
for (uint j = 0; j < numOfNFTs; j++) {
uint tokenId = totalSupply();
if (block.timestamp < _revealTimestamp) {
_mintedBeforeReveal[tokenId] = true;
}
_numMintedReservedTokens++;
_safeMint(to, tokenId);
}
}
/**
* @dev Finalize starting index
*/
function finalizeStartingIndex() public {
require(_startingIndex == 0, "Starting index is already set");
require(_startingIndexBlock != 0, "Starting index block must be set");
_startingIndex = uint(blockhash(_startingIndexBlock)) % MAX_SUPPLY;
// Just a sanity case in the worst case if this function is called late (EVM only stores last 256 block hashes)
if (block.number.sub(_startingIndexBlock) > 255) {
_startingIndex = uint(blockhash(block.number - 1)) % MAX_SUPPLY;
}
// Prevent default sequence
if (_startingIndex == 0) {
_startingIndex = _startingIndex.add(1);
}
}
/**
* @dev Changes the name for Mars tile tokenId
*/
function changeName(uint256 tokenId, string memory newName) public {
address owner = ownerOf(tokenId);
require(_msgSender() == owner, "ERC721: caller is not the owner");
require(_validateName(newName) == true, "Not a valid new name");
require(sha256(bytes(newName)) != sha256(bytes(_tokenNames[tokenId])), "New name is same as the current one");
require(isNameReserved(newName) == false, "Name already reserved");
_m26.transferFrom(msg.sender, address(this), _nameChangePrice);
// If already named, dereserve old name
if (bytes(_tokenNames[tokenId]).length > 0) {
_toggleReserveName(_tokenNames[tokenId], false);
}
_toggleReserveName(newName, true);
_tokenNames[tokenId] = newName;
_m26.burn(_nameChangePrice);
emit NameChange(tokenId, newName);
}
/**
* @dev See {MarsStorage.setInitialSequenceTokenHashes}
*/
function setInitialSequenceTokenHashes(bytes32[] memory tokenHashes) onlyOwner public {
_storage.setInitialSequenceTokenHashes(tokenHashes);
}
/**
* @dev See {MarsStorage.setInitialSequenceTokenHashesAtIndex}
*/
function setInitialSequenceTokenHashesAtIndex(
uint256 startIndex,
bytes32[] memory tokenHashes
) public onlyOwner {
_storage.setInitialSequenceTokenHashesAtIndex(startIndex, tokenHashes);
}
/**
* @dev Check if the name string is valid (Alphanumeric and spaces without leading or trailing space)
*/
function _validateName(string memory str) private pure returns (bool){
bytes memory b = bytes(str);
if (b.length < 1) return false;
if (b.length > 50) return false; // Cannot be longer than 25 characters
if (b[0] == 0x20) return false; // Leading space
if (b[b.length - 1] == 0x20) return false; // Trailing space
bytes1 lastChar = b[0];
for (uint i; i < b.length; i++) {
bytes1 char = b[i];
if (char == 0x20 && lastChar == 0x20) return false; // Cannot contain continous spaces
if (
!(char >= 0x30 && char <= 0x39) && //9-0
!(char >= 0x41 && char <= 0x5A) && //A-Z
!(char >= 0x61 && char <= 0x7A) && //a-z
!(char == 0x20) //space
)
return false;
lastChar = char;
}
return true;
}
/**
* @dev Converts the string to lowercase
*/
function _toLower(string memory str) private pure returns (string memory){
bytes memory bStr = bytes(str);
bytes memory bLower = new bytes(bStr.length);
for (uint i = 0; i < bStr.length; i++) {
// Uppercase character
if ((uint8(bStr[i]) >= 65) && (uint8(bStr[i]) <= 90)) {
bLower[i] = bytes1(uint8(bStr[i]) + 32);
} else {
bLower[i] = bStr[i];
}
}
return string(bLower);
}
/**
* @dev Reserves the name if isReserve is set to true, de-reserves if set to false
*/
function _toggleReserveName(string memory str, bool isReserve) internal {
_reservedNames[_toLower(str)] = isReserve;
}
function _baseURI() internal pure override returns (string memory) {
return "ipfs://";
}
function _toInitialSequenceIndex(uint256 tokenId) internal view returns (uint256) {
return (tokenId + _startingIndex) % MAX_SUPPLY;
}
} | /**
* @title Mars contract
* @dev Extends ERC721 Non-Fungible Token Standard basic implementation
*/ | NatSpecMultiLine | _toLower | function _toLower(string memory str) private pure returns (string memory){
bytes memory bStr = bytes(str);
bytes memory bLower = new bytes(bStr.length);
for (uint i = 0; i < bStr.length; i++) {
// Uppercase character
if ((uint8(bStr[i]) >= 65) && (uint8(bStr[i]) <= 90)) {
bLower[i] = bytes1(uint8(bStr[i]) + 32);
} else {
bLower[i] = bStr[i];
}
}
return string(bLower);
}
| /**
* @dev Converts the string to lowercase
*/ | NatSpecMultiLine | v0.8.3+commit.8d00100c | {
"func_code_index": [
11667,
12167
]
} | 8,952 |
||
MarsLocker | contracts/Mars.sol | 0x64200351e787b33cd7c518a93fc24d780092f727 | Solidity | Mars | contract Mars is Ownable, ERC721Enumerable, PaymentSplitter {
using SafeMath for uint256;
uint256 public constant MAX_SUPPLY = 16200;
uint256 public constant RESERVED_SUPPLY = 1305 + 500;
bytes32 private _provenanceHash;
uint256 private _nameChangePrice;
uint256 private _saleStartTimestamp;
uint256 private _revealTimestamp;
uint256 private _startingIndexBlock;
uint256 internal _startingIndex;
uint256 private _numSoldTokens;
uint256 private _numMintedReservedTokens;
mapping (uint256 => string) private _tokenNames;
mapping (string => bool) private _reservedNames;
mapping (uint256 => bool) private _mintedBeforeReveal;
Mars26 private _m26;
MarsStorage private _storage;
event NameChange (uint256 indexed maskIndex, string newName);
/**
* @dev Sets immutable values of contract.
*/
constructor (
bytes32 provenanceHash_,
address m26Address_,
uint256 nameChangePrice_,
uint256 saleStartTimestamp_,
uint256 revealTimestamp_,
address[] memory payees,
uint256[] memory shares_
) ERC721("Mars", "MARS") PaymentSplitter(payees, shares_) {
_provenanceHash = provenanceHash_;
_m26 = Mars26(m26Address_);
_nameChangePrice = nameChangePrice_;
_saleStartTimestamp = saleStartTimestamp_;
_revealTimestamp = revealTimestamp_;
_storage = new MarsStorage(MAX_SUPPLY);
}
/**
* @dev Returns provenance hash digest set during initialization of contract.
*
* The provenance hash is derived by concatenating all existing IPFS CIDs (v0)
* of the Mars NFTs and hashing the concatenated string using SHA2-256.
* Note that the CIDs were concatenated and hashed in their base58 representation.
*/
function provenanceHash() public view returns (bytes32) {
return _provenanceHash;
}
/**
* @dev Returns address of Mars26 ERC-20 token contract.
*/
function m26Address() public view returns (address) {
return address(_m26);
}
/**
* @dev Returns address of connected storage contract.
*/
function storageAddress() public view returns (address) {
return address(_storage);
}
/**
* @dev Returns the number of sold NFTs.
*/
function numSoldTokens() public view returns (uint256) {
return _numSoldTokens;
}
/**
* @dev Returns the MNCT price for changing the name of a token.
*/
function nameChangePrice() public view returns (uint256) {
return _nameChangePrice;
}
/**
* @dev Returns the start timestamp of the initial sale.
*/
function saleStartTimestamp() public view returns (uint256) {
return _saleStartTimestamp;
}
/**
* @dev Returns the reveal timestamp after which the token ids will be assigned.
*/
function revealTimestamp() public view returns (uint256) {
return _revealTimestamp;
}
/**
* @dev Returns the randomized starting index to assign and reveal token ids to
* intial sequence of NFTs.
*/
function startingIndex() public view returns (uint256) {
return _startingIndex;
}
/**
* @dev Returns the randomized starting index block which is used to derive
* {_startingIndex} from.
*/
function startingIndexBlock() public view returns (uint256) {
return _startingIndexBlock;
}
/**
* @dev See {MarsStorage.initialSequenceTokenCID}
*/
function initialSequenceTokenCID(uint256 initialSequenceIndex) public view returns (string memory) {
return _storage.initialSequenceTokenCID(initialSequenceIndex);
}
/**
* @dev Returns if {nameString} has been reserved.
*/
function isNameReserved(string memory nameString) public view returns (bool) {
return _reservedNames[_toLower(nameString)];
}
/**
* @dev Returns reverved name for given token id.
*/
function tokenNames(uint256 tokenId) public view returns (string memory) {
return _tokenNames[tokenId];
}
/**
* @dev Returns the set token URI, i.e. IPFS v0 CID, of {tokenId}.
* Prefixed with ipfs://
*/
function tokenURI(uint256 tokenId) public view override returns (string memory) {
require(_exists(tokenId), "ERC721URIStorage: URI query for nonexistent token");
require(_startingIndex > 0, "Tokens have not been assigned yet");
uint256 initialSequenceIndex = _toInitialSequenceIndex(tokenId);
return tokenURIOfInitialSequenceIndex(initialSequenceIndex);
}
/**
* @dev Returns the set token URI, i.e. IPFS v0 CID, of {initialSequenceIndex}.
* Prefixed with ipfs://
*/
function tokenURIOfInitialSequenceIndex(uint256 initialSequenceIndex) public view returns (string memory) {
require(_startingIndex > 0, "Tokens have not been assigned yet");
string memory tokenCID = initialSequenceTokenCID(initialSequenceIndex);
string memory base = _baseURI();
// If there is no base URI, return the token URI.
if (bytes(base).length == 0) {
return tokenCID;
}
// If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked).
if (bytes(tokenCID).length > 0) {
return string(abi.encodePacked(base, tokenCID));
}
return base;
}
/**
* @dev Returns if the NFT has been minted before reveal phase.
*/
function isMintedBeforeReveal(uint256 index) public view returns (bool) {
return _mintedBeforeReveal[index];
}
/**
* @dev Gets current NFT price based on already sold tokens.
*/
function getNFTPrice() public view returns (uint256) {
if (_numSoldTokens < 800) {
return 0.01 ether;
} else if (_numSoldTokens < 4400) {
return 0.02 ether;
} else if (_numSoldTokens < 8800) {
return 0.03 ether;
} else if (_numSoldTokens < 12600) {
return 0.05 ether;
} else if (_numSoldTokens < 14040) {
return 0.1 ether;
} else if (_numSoldTokens < 14392) {
return 0.3 ether;
} else {
return 1 ether;
}
}
/**
* @dev Mints Mars NFTs
*/
function mint(uint256 numberOfNfts) public payable {
require(block.timestamp >= _saleStartTimestamp, "Sale has not started");
require(totalSupply() < MAX_SUPPLY, "Sale has already ended");
require(numberOfNfts > 0, "Cannot buy 0 NFTs");
require(numberOfNfts <= 20, "You may not buy more than 20 NFTs at once");
require(_numSoldTokens.add(numberOfNfts) <= MAX_SUPPLY.sub(RESERVED_SUPPLY), "Exceeds max number of sellable NFTs");
require(getNFTPrice().mul(numberOfNfts) == msg.value, "Ether value sent is not correct");
for (uint i = 0; i < numberOfNfts; i++) {
uint mintIndex = totalSupply();
_numSoldTokens++;
require(mintIndex < MAX_SUPPLY, "Exceeds max number of NFTs in existence");
if (block.timestamp < _revealTimestamp) {
_mintedBeforeReveal[mintIndex] = true;
}
_safeMint(msg.sender, mintIndex);
}
// Source of randomness. Theoretical miner withhold manipulation possible but should be sufficient in a pragmatic sense
if (_startingIndexBlock == 0 && (_numSoldTokens >= MAX_SUPPLY.sub(RESERVED_SUPPLY) || block.timestamp >= _revealTimestamp)) {
_startingIndexBlock = block.number;
}
}
/**
* @dev Used to migrate already minted NFTs of old contract.
*/
function mintReserved(address to, uint256 numOfNFTs) public onlyOwner {
require(totalSupply().add(numOfNFTs) <= MAX_SUPPLY, "Exceeds max supply of NFTs");
require(_numMintedReservedTokens.add(numOfNFTs) <= RESERVED_SUPPLY, "Exceeds max num of reserved NFTs");
for (uint j = 0; j < numOfNFTs; j++) {
uint tokenId = totalSupply();
if (block.timestamp < _revealTimestamp) {
_mintedBeforeReveal[tokenId] = true;
}
_numMintedReservedTokens++;
_safeMint(to, tokenId);
}
}
/**
* @dev Finalize starting index
*/
function finalizeStartingIndex() public {
require(_startingIndex == 0, "Starting index is already set");
require(_startingIndexBlock != 0, "Starting index block must be set");
_startingIndex = uint(blockhash(_startingIndexBlock)) % MAX_SUPPLY;
// Just a sanity case in the worst case if this function is called late (EVM only stores last 256 block hashes)
if (block.number.sub(_startingIndexBlock) > 255) {
_startingIndex = uint(blockhash(block.number - 1)) % MAX_SUPPLY;
}
// Prevent default sequence
if (_startingIndex == 0) {
_startingIndex = _startingIndex.add(1);
}
}
/**
* @dev Changes the name for Mars tile tokenId
*/
function changeName(uint256 tokenId, string memory newName) public {
address owner = ownerOf(tokenId);
require(_msgSender() == owner, "ERC721: caller is not the owner");
require(_validateName(newName) == true, "Not a valid new name");
require(sha256(bytes(newName)) != sha256(bytes(_tokenNames[tokenId])), "New name is same as the current one");
require(isNameReserved(newName) == false, "Name already reserved");
_m26.transferFrom(msg.sender, address(this), _nameChangePrice);
// If already named, dereserve old name
if (bytes(_tokenNames[tokenId]).length > 0) {
_toggleReserveName(_tokenNames[tokenId], false);
}
_toggleReserveName(newName, true);
_tokenNames[tokenId] = newName;
_m26.burn(_nameChangePrice);
emit NameChange(tokenId, newName);
}
/**
* @dev See {MarsStorage.setInitialSequenceTokenHashes}
*/
function setInitialSequenceTokenHashes(bytes32[] memory tokenHashes) onlyOwner public {
_storage.setInitialSequenceTokenHashes(tokenHashes);
}
/**
* @dev See {MarsStorage.setInitialSequenceTokenHashesAtIndex}
*/
function setInitialSequenceTokenHashesAtIndex(
uint256 startIndex,
bytes32[] memory tokenHashes
) public onlyOwner {
_storage.setInitialSequenceTokenHashesAtIndex(startIndex, tokenHashes);
}
/**
* @dev Check if the name string is valid (Alphanumeric and spaces without leading or trailing space)
*/
function _validateName(string memory str) private pure returns (bool){
bytes memory b = bytes(str);
if (b.length < 1) return false;
if (b.length > 50) return false; // Cannot be longer than 25 characters
if (b[0] == 0x20) return false; // Leading space
if (b[b.length - 1] == 0x20) return false; // Trailing space
bytes1 lastChar = b[0];
for (uint i; i < b.length; i++) {
bytes1 char = b[i];
if (char == 0x20 && lastChar == 0x20) return false; // Cannot contain continous spaces
if (
!(char >= 0x30 && char <= 0x39) && //9-0
!(char >= 0x41 && char <= 0x5A) && //A-Z
!(char >= 0x61 && char <= 0x7A) && //a-z
!(char == 0x20) //space
)
return false;
lastChar = char;
}
return true;
}
/**
* @dev Converts the string to lowercase
*/
function _toLower(string memory str) private pure returns (string memory){
bytes memory bStr = bytes(str);
bytes memory bLower = new bytes(bStr.length);
for (uint i = 0; i < bStr.length; i++) {
// Uppercase character
if ((uint8(bStr[i]) >= 65) && (uint8(bStr[i]) <= 90)) {
bLower[i] = bytes1(uint8(bStr[i]) + 32);
} else {
bLower[i] = bStr[i];
}
}
return string(bLower);
}
/**
* @dev Reserves the name if isReserve is set to true, de-reserves if set to false
*/
function _toggleReserveName(string memory str, bool isReserve) internal {
_reservedNames[_toLower(str)] = isReserve;
}
function _baseURI() internal pure override returns (string memory) {
return "ipfs://";
}
function _toInitialSequenceIndex(uint256 tokenId) internal view returns (uint256) {
return (tokenId + _startingIndex) % MAX_SUPPLY;
}
} | /**
* @title Mars contract
* @dev Extends ERC721 Non-Fungible Token Standard basic implementation
*/ | NatSpecMultiLine | _toggleReserveName | function _toggleReserveName(string memory str, bool isReserve) internal {
_reservedNames[_toLower(str)] = isReserve;
}
| /**
* @dev Reserves the name if isReserve is set to true, de-reserves if set to false
*/ | NatSpecMultiLine | v0.8.3+commit.8d00100c | {
"func_code_index": [
12272,
12406
]
} | 8,953 |
||
MOLStaker | MOLStaker.sol | 0x04337132ec0c62cbca8640444d23496130e7ba16 | Solidity | MOLStaker | contract MOLStaker is Ownable {
using SafeMath for uint256;
MOLContract private _molContract; // mol token contract
RewardContract private _rewardContract; // reward contract
mapping (address => StakerInfo) private _stakeMap; // map for stakers
address private _devWallet; // dev wallet address
uint256 private _devLastClaimTimestamp; // dev wallet address
address[] private _stakers; // staker's array
uint256 private _totalStakedAmount = 0; // total staked amount
uint256 private _minStakeAmount = 1e18; // min stakable amount
uint256 private _rewardPortion = 10; // reward portion 10%
uint256 private _rewardFee = 98; // reward fee 98%, rest for dev 2%
uint256 private _taxFee = 3; // tax fee for transaction
struct StakerInfo {
uint256 stakedAmount;
uint256 lastClaimTimestamp;
uint256 rewardAmount;
}
// Events
event Staked(address indexed staker, uint256 amount);
event Unstaked(address indexed staker, uint256 amount);
event Claim(address indexed staker, uint256 amount);
constructor (MOLContract molContract, address devWallet) public {
_molContract = molContract;
_devWallet = devWallet;
}
function stake(uint256 amount) public {
require(
amount >= _minStakeAmount,
"MOLStaker: stake amount is less than min stake amount."
);
require(
_molContract.transferFrom(
_msgSender(),
address(this),
amount
),
"MOLStaker: stake failed."
);
uint256 taxAmount = amount.mul(_taxFee).div(100);
uint256 realStakedAmount = amount.sub(taxAmount);
uint256 currentTimestamp = uint256(now);
if(_stakers.length == 0)
_devLastClaimTimestamp = currentTimestamp;
if(_stakeMap[_msgSender()].stakedAmount == 0) {
_stakers.push(_msgSender());
_stakeMap[_msgSender()].lastClaimTimestamp = currentTimestamp;
} else {
_stakeMap[_msgSender()].rewardAmount = _stakeMap[_msgSender()].rewardAmount.add(calcReward(_msgSender(), currentTimestamp));
_stakeMap[_msgSender()].lastClaimTimestamp = currentTimestamp;
}
_stakeMap[_msgSender()].stakedAmount = _stakeMap[_msgSender()].stakedAmount.add(realStakedAmount);
_totalStakedAmount = _totalStakedAmount.add(realStakedAmount);
emit Staked(_msgSender(), realStakedAmount);
}
function unstake(uint256 amount) public {
require(
_stakeMap[_msgSender()].stakedAmount >= amount,
"MOLStaker: unstake amount exceededs the staked amount."
);
uint256 currentTimestamp = uint256(now);
_stakeMap[_msgSender()].rewardAmount = _stakeMap[_msgSender()].rewardAmount.add(calcReward(_msgSender(), currentTimestamp));
_stakeMap[_msgSender()].lastClaimTimestamp = currentTimestamp;
_stakeMap[_msgSender()].stakedAmount = _stakeMap[_msgSender()].stakedAmount.sub(amount);
_totalStakedAmount = _totalStakedAmount.sub(amount);
require(
_molContract.transfer(
_msgSender(),
amount
),
"MOLStaker: unstake failed."
);
if(_stakeMap[_msgSender()].stakedAmount == 0) {
_stakeMap[_msgSender()].lastClaimTimestamp = 0;
for(uint i=0; i<_stakers.length; i++) {
if(_stakers[i] == _msgSender()) {
_stakers[i] = _stakers[_stakers.length-1];
_stakers.pop();
break;
}
}
}
emit Unstaked(_msgSender(), amount);
}
function claim() public {
uint256 currentTimestamp = uint256(now);
uint256 rewardAmount = _stakeMap[_msgSender()].rewardAmount.add(calcReward(_msgSender(), currentTimestamp));
_stakeMap[_msgSender()].lastClaimTimestamp = currentTimestamp;
require(
_rewardContract.giveLavaReward(_msgSender(), rewardAmount),
"MOLStaker: claim failed."
);
_stakeMap[_msgSender()].rewardAmount = 0;
emit Claim(_msgSender(), rewardAmount);
if(currentTimestamp.sub(_devLastClaimTimestamp) >= 86400) {
rewardAmount = calcDevReward(currentTimestamp);
_devLastClaimTimestamp = currentTimestamp;
require(
_rewardContract.giveLavaReward(_devWallet, rewardAmount),
"MOLStaker: dev reward claim failed."
);
emit Claim(_devWallet, rewardAmount);
}
}
function endStake() external {
unstake(_stakeMap[_msgSender()].stakedAmount);
claim();
}
function calcReward(address staker, uint256 currentTimestamp) private view returns (uint256) {
if(_totalStakedAmount == 0)
return 0;
uint256 rewardPoolBalance = _rewardContract.getLavaBalance();
uint256 passTime = currentTimestamp.sub(_stakeMap[staker].lastClaimTimestamp);
uint256 rewardAmountForStakers = rewardPoolBalance.mul(_rewardPortion).div(100).mul(_rewardFee).div(100);
uint256 rewardAmount = rewardAmountForStakers.mul(passTime).div(86400).mul(_stakeMap[staker].stakedAmount).div(_totalStakedAmount);
return rewardAmount;
}
function calcDevReward(uint256 currentTimestamp) private view returns (uint256) {
uint256 rewardPoolBalance = _rewardContract.getLavaBalance();
uint256 passTime = currentTimestamp.sub(_devLastClaimTimestamp);
uint256 rewardAmount = rewardPoolBalance.mul(_rewardPortion).div(100).mul(uint256(100).sub(_rewardFee)).div(100).mul(passTime).div(86400);
return rewardAmount;
}
/**
* Get store wallet
*/
function getRewardContract() external view returns (address) {
return address(_rewardContract);
}
/**
* Get total staked amount
*/
function getTotalStakedAmount() external view returns (uint256) {
return _totalStakedAmount;
}
/**
* Get reward amount of staker
*/
function getReward(address staker) external view returns (uint256) {
return _stakeMap[staker].rewardAmount.add(calcReward(staker, now));
}
/**
* Get reward pool balance (LAVA)
*/
function getRewardPoolBalance() external view returns (uint256) {
return _rewardContract.getLavaBalance();
}
/**
* Get last claim timestamp
*/
function getLastClaimTimestamp(address staker) external view returns (uint256) {
return _stakeMap[staker].lastClaimTimestamp;
}
/**
* Get staked amount of staker
*/
function getStakedAmount(address staker) external view returns (uint256) {
return _stakeMap[staker].stakedAmount;
}
/**
* Get min stake amount
*/
function getMinStakeAmount() external view returns (uint256) {
return _minStakeAmount;
}
/**
* Get rewards portion
*/
function getRewardPortion() external view returns (uint256) {
return _rewardPortion;
}
/**
* Get staker count
*/
function getStakerCount() external view returns (uint256) {
return _stakers.length;
}
/**
* Get rewards fee
*/
function getRewardFee() external view returns (uint256) {
return _rewardFee;
}
/**
* Get staked rank
*/
function getStakedRank(address staker) external view returns (uint256) {
uint256 rank = 1;
uint256 senderStakedAmount = _stakeMap[staker].stakedAmount;
for(uint i=0; i<_stakers.length; i++) {
if(_stakers[i] != staker && senderStakedAmount < _stakeMap[_stakers[i]].stakedAmount)
rank = rank.add(1);
}
return rank;
}
/**
* Set store wallet contract address
*/
function setRewardContract(RewardContract rewardContract) external onlyOwner returns (bool) {
require(address(rewardContract) != address(0), 'MOLStaker: reward contract address should not be zero address.');
_rewardContract = rewardContract;
return true;
}
/**
* Set rewards portion in store balance.
* ex: 10 => 10%
*/
function setRewardPortion(uint256 rewardPortion) external onlyOwner returns (bool) {
require(rewardPortion >= 10 && rewardPortion <= 100, 'MOLStaker: reward portion should be in 10 ~ 100.');
_rewardPortion = rewardPortion;
return true;
}
/**
* Set rewards portion for stakers in rewards amount.
* ex: 98 => 98% (2% for dev)
*/
function setRewardFee(uint256 rewardFee) external onlyOwner returns (bool) {
require(rewardFee >= 96 && rewardFee <= 100, 'MOLStaker: reward fee should be in 96 ~ 100.' );
_rewardFee = rewardFee;
return true;
}
} | getRewardContract | function getRewardContract() external view returns (address) {
return address(_rewardContract);
}
| /**
* Get store wallet
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://368314f4777f190274441dfdebb1eaf8c259afa185c786922a40e946fdd52269 | {
"func_code_index": [
6336,
6452
]
} | 8,954 |
||
MOLStaker | MOLStaker.sol | 0x04337132ec0c62cbca8640444d23496130e7ba16 | Solidity | MOLStaker | contract MOLStaker is Ownable {
using SafeMath for uint256;
MOLContract private _molContract; // mol token contract
RewardContract private _rewardContract; // reward contract
mapping (address => StakerInfo) private _stakeMap; // map for stakers
address private _devWallet; // dev wallet address
uint256 private _devLastClaimTimestamp; // dev wallet address
address[] private _stakers; // staker's array
uint256 private _totalStakedAmount = 0; // total staked amount
uint256 private _minStakeAmount = 1e18; // min stakable amount
uint256 private _rewardPortion = 10; // reward portion 10%
uint256 private _rewardFee = 98; // reward fee 98%, rest for dev 2%
uint256 private _taxFee = 3; // tax fee for transaction
struct StakerInfo {
uint256 stakedAmount;
uint256 lastClaimTimestamp;
uint256 rewardAmount;
}
// Events
event Staked(address indexed staker, uint256 amount);
event Unstaked(address indexed staker, uint256 amount);
event Claim(address indexed staker, uint256 amount);
constructor (MOLContract molContract, address devWallet) public {
_molContract = molContract;
_devWallet = devWallet;
}
function stake(uint256 amount) public {
require(
amount >= _minStakeAmount,
"MOLStaker: stake amount is less than min stake amount."
);
require(
_molContract.transferFrom(
_msgSender(),
address(this),
amount
),
"MOLStaker: stake failed."
);
uint256 taxAmount = amount.mul(_taxFee).div(100);
uint256 realStakedAmount = amount.sub(taxAmount);
uint256 currentTimestamp = uint256(now);
if(_stakers.length == 0)
_devLastClaimTimestamp = currentTimestamp;
if(_stakeMap[_msgSender()].stakedAmount == 0) {
_stakers.push(_msgSender());
_stakeMap[_msgSender()].lastClaimTimestamp = currentTimestamp;
} else {
_stakeMap[_msgSender()].rewardAmount = _stakeMap[_msgSender()].rewardAmount.add(calcReward(_msgSender(), currentTimestamp));
_stakeMap[_msgSender()].lastClaimTimestamp = currentTimestamp;
}
_stakeMap[_msgSender()].stakedAmount = _stakeMap[_msgSender()].stakedAmount.add(realStakedAmount);
_totalStakedAmount = _totalStakedAmount.add(realStakedAmount);
emit Staked(_msgSender(), realStakedAmount);
}
function unstake(uint256 amount) public {
require(
_stakeMap[_msgSender()].stakedAmount >= amount,
"MOLStaker: unstake amount exceededs the staked amount."
);
uint256 currentTimestamp = uint256(now);
_stakeMap[_msgSender()].rewardAmount = _stakeMap[_msgSender()].rewardAmount.add(calcReward(_msgSender(), currentTimestamp));
_stakeMap[_msgSender()].lastClaimTimestamp = currentTimestamp;
_stakeMap[_msgSender()].stakedAmount = _stakeMap[_msgSender()].stakedAmount.sub(amount);
_totalStakedAmount = _totalStakedAmount.sub(amount);
require(
_molContract.transfer(
_msgSender(),
amount
),
"MOLStaker: unstake failed."
);
if(_stakeMap[_msgSender()].stakedAmount == 0) {
_stakeMap[_msgSender()].lastClaimTimestamp = 0;
for(uint i=0; i<_stakers.length; i++) {
if(_stakers[i] == _msgSender()) {
_stakers[i] = _stakers[_stakers.length-1];
_stakers.pop();
break;
}
}
}
emit Unstaked(_msgSender(), amount);
}
function claim() public {
uint256 currentTimestamp = uint256(now);
uint256 rewardAmount = _stakeMap[_msgSender()].rewardAmount.add(calcReward(_msgSender(), currentTimestamp));
_stakeMap[_msgSender()].lastClaimTimestamp = currentTimestamp;
require(
_rewardContract.giveLavaReward(_msgSender(), rewardAmount),
"MOLStaker: claim failed."
);
_stakeMap[_msgSender()].rewardAmount = 0;
emit Claim(_msgSender(), rewardAmount);
if(currentTimestamp.sub(_devLastClaimTimestamp) >= 86400) {
rewardAmount = calcDevReward(currentTimestamp);
_devLastClaimTimestamp = currentTimestamp;
require(
_rewardContract.giveLavaReward(_devWallet, rewardAmount),
"MOLStaker: dev reward claim failed."
);
emit Claim(_devWallet, rewardAmount);
}
}
function endStake() external {
unstake(_stakeMap[_msgSender()].stakedAmount);
claim();
}
function calcReward(address staker, uint256 currentTimestamp) private view returns (uint256) {
if(_totalStakedAmount == 0)
return 0;
uint256 rewardPoolBalance = _rewardContract.getLavaBalance();
uint256 passTime = currentTimestamp.sub(_stakeMap[staker].lastClaimTimestamp);
uint256 rewardAmountForStakers = rewardPoolBalance.mul(_rewardPortion).div(100).mul(_rewardFee).div(100);
uint256 rewardAmount = rewardAmountForStakers.mul(passTime).div(86400).mul(_stakeMap[staker].stakedAmount).div(_totalStakedAmount);
return rewardAmount;
}
function calcDevReward(uint256 currentTimestamp) private view returns (uint256) {
uint256 rewardPoolBalance = _rewardContract.getLavaBalance();
uint256 passTime = currentTimestamp.sub(_devLastClaimTimestamp);
uint256 rewardAmount = rewardPoolBalance.mul(_rewardPortion).div(100).mul(uint256(100).sub(_rewardFee)).div(100).mul(passTime).div(86400);
return rewardAmount;
}
/**
* Get store wallet
*/
function getRewardContract() external view returns (address) {
return address(_rewardContract);
}
/**
* Get total staked amount
*/
function getTotalStakedAmount() external view returns (uint256) {
return _totalStakedAmount;
}
/**
* Get reward amount of staker
*/
function getReward(address staker) external view returns (uint256) {
return _stakeMap[staker].rewardAmount.add(calcReward(staker, now));
}
/**
* Get reward pool balance (LAVA)
*/
function getRewardPoolBalance() external view returns (uint256) {
return _rewardContract.getLavaBalance();
}
/**
* Get last claim timestamp
*/
function getLastClaimTimestamp(address staker) external view returns (uint256) {
return _stakeMap[staker].lastClaimTimestamp;
}
/**
* Get staked amount of staker
*/
function getStakedAmount(address staker) external view returns (uint256) {
return _stakeMap[staker].stakedAmount;
}
/**
* Get min stake amount
*/
function getMinStakeAmount() external view returns (uint256) {
return _minStakeAmount;
}
/**
* Get rewards portion
*/
function getRewardPortion() external view returns (uint256) {
return _rewardPortion;
}
/**
* Get staker count
*/
function getStakerCount() external view returns (uint256) {
return _stakers.length;
}
/**
* Get rewards fee
*/
function getRewardFee() external view returns (uint256) {
return _rewardFee;
}
/**
* Get staked rank
*/
function getStakedRank(address staker) external view returns (uint256) {
uint256 rank = 1;
uint256 senderStakedAmount = _stakeMap[staker].stakedAmount;
for(uint i=0; i<_stakers.length; i++) {
if(_stakers[i] != staker && senderStakedAmount < _stakeMap[_stakers[i]].stakedAmount)
rank = rank.add(1);
}
return rank;
}
/**
* Set store wallet contract address
*/
function setRewardContract(RewardContract rewardContract) external onlyOwner returns (bool) {
require(address(rewardContract) != address(0), 'MOLStaker: reward contract address should not be zero address.');
_rewardContract = rewardContract;
return true;
}
/**
* Set rewards portion in store balance.
* ex: 10 => 10%
*/
function setRewardPortion(uint256 rewardPortion) external onlyOwner returns (bool) {
require(rewardPortion >= 10 && rewardPortion <= 100, 'MOLStaker: reward portion should be in 10 ~ 100.');
_rewardPortion = rewardPortion;
return true;
}
/**
* Set rewards portion for stakers in rewards amount.
* ex: 98 => 98% (2% for dev)
*/
function setRewardFee(uint256 rewardFee) external onlyOwner returns (bool) {
require(rewardFee >= 96 && rewardFee <= 100, 'MOLStaker: reward fee should be in 96 ~ 100.' );
_rewardFee = rewardFee;
return true;
}
} | getTotalStakedAmount | function getTotalStakedAmount() external view returns (uint256) {
return _totalStakedAmount;
}
| /**
* Get total staked amount
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://368314f4777f190274441dfdebb1eaf8c259afa185c786922a40e946fdd52269 | {
"func_code_index": [
6510,
6623
]
} | 8,955 |
||
MOLStaker | MOLStaker.sol | 0x04337132ec0c62cbca8640444d23496130e7ba16 | Solidity | MOLStaker | contract MOLStaker is Ownable {
using SafeMath for uint256;
MOLContract private _molContract; // mol token contract
RewardContract private _rewardContract; // reward contract
mapping (address => StakerInfo) private _stakeMap; // map for stakers
address private _devWallet; // dev wallet address
uint256 private _devLastClaimTimestamp; // dev wallet address
address[] private _stakers; // staker's array
uint256 private _totalStakedAmount = 0; // total staked amount
uint256 private _minStakeAmount = 1e18; // min stakable amount
uint256 private _rewardPortion = 10; // reward portion 10%
uint256 private _rewardFee = 98; // reward fee 98%, rest for dev 2%
uint256 private _taxFee = 3; // tax fee for transaction
struct StakerInfo {
uint256 stakedAmount;
uint256 lastClaimTimestamp;
uint256 rewardAmount;
}
// Events
event Staked(address indexed staker, uint256 amount);
event Unstaked(address indexed staker, uint256 amount);
event Claim(address indexed staker, uint256 amount);
constructor (MOLContract molContract, address devWallet) public {
_molContract = molContract;
_devWallet = devWallet;
}
function stake(uint256 amount) public {
require(
amount >= _minStakeAmount,
"MOLStaker: stake amount is less than min stake amount."
);
require(
_molContract.transferFrom(
_msgSender(),
address(this),
amount
),
"MOLStaker: stake failed."
);
uint256 taxAmount = amount.mul(_taxFee).div(100);
uint256 realStakedAmount = amount.sub(taxAmount);
uint256 currentTimestamp = uint256(now);
if(_stakers.length == 0)
_devLastClaimTimestamp = currentTimestamp;
if(_stakeMap[_msgSender()].stakedAmount == 0) {
_stakers.push(_msgSender());
_stakeMap[_msgSender()].lastClaimTimestamp = currentTimestamp;
} else {
_stakeMap[_msgSender()].rewardAmount = _stakeMap[_msgSender()].rewardAmount.add(calcReward(_msgSender(), currentTimestamp));
_stakeMap[_msgSender()].lastClaimTimestamp = currentTimestamp;
}
_stakeMap[_msgSender()].stakedAmount = _stakeMap[_msgSender()].stakedAmount.add(realStakedAmount);
_totalStakedAmount = _totalStakedAmount.add(realStakedAmount);
emit Staked(_msgSender(), realStakedAmount);
}
function unstake(uint256 amount) public {
require(
_stakeMap[_msgSender()].stakedAmount >= amount,
"MOLStaker: unstake amount exceededs the staked amount."
);
uint256 currentTimestamp = uint256(now);
_stakeMap[_msgSender()].rewardAmount = _stakeMap[_msgSender()].rewardAmount.add(calcReward(_msgSender(), currentTimestamp));
_stakeMap[_msgSender()].lastClaimTimestamp = currentTimestamp;
_stakeMap[_msgSender()].stakedAmount = _stakeMap[_msgSender()].stakedAmount.sub(amount);
_totalStakedAmount = _totalStakedAmount.sub(amount);
require(
_molContract.transfer(
_msgSender(),
amount
),
"MOLStaker: unstake failed."
);
if(_stakeMap[_msgSender()].stakedAmount == 0) {
_stakeMap[_msgSender()].lastClaimTimestamp = 0;
for(uint i=0; i<_stakers.length; i++) {
if(_stakers[i] == _msgSender()) {
_stakers[i] = _stakers[_stakers.length-1];
_stakers.pop();
break;
}
}
}
emit Unstaked(_msgSender(), amount);
}
function claim() public {
uint256 currentTimestamp = uint256(now);
uint256 rewardAmount = _stakeMap[_msgSender()].rewardAmount.add(calcReward(_msgSender(), currentTimestamp));
_stakeMap[_msgSender()].lastClaimTimestamp = currentTimestamp;
require(
_rewardContract.giveLavaReward(_msgSender(), rewardAmount),
"MOLStaker: claim failed."
);
_stakeMap[_msgSender()].rewardAmount = 0;
emit Claim(_msgSender(), rewardAmount);
if(currentTimestamp.sub(_devLastClaimTimestamp) >= 86400) {
rewardAmount = calcDevReward(currentTimestamp);
_devLastClaimTimestamp = currentTimestamp;
require(
_rewardContract.giveLavaReward(_devWallet, rewardAmount),
"MOLStaker: dev reward claim failed."
);
emit Claim(_devWallet, rewardAmount);
}
}
function endStake() external {
unstake(_stakeMap[_msgSender()].stakedAmount);
claim();
}
function calcReward(address staker, uint256 currentTimestamp) private view returns (uint256) {
if(_totalStakedAmount == 0)
return 0;
uint256 rewardPoolBalance = _rewardContract.getLavaBalance();
uint256 passTime = currentTimestamp.sub(_stakeMap[staker].lastClaimTimestamp);
uint256 rewardAmountForStakers = rewardPoolBalance.mul(_rewardPortion).div(100).mul(_rewardFee).div(100);
uint256 rewardAmount = rewardAmountForStakers.mul(passTime).div(86400).mul(_stakeMap[staker].stakedAmount).div(_totalStakedAmount);
return rewardAmount;
}
function calcDevReward(uint256 currentTimestamp) private view returns (uint256) {
uint256 rewardPoolBalance = _rewardContract.getLavaBalance();
uint256 passTime = currentTimestamp.sub(_devLastClaimTimestamp);
uint256 rewardAmount = rewardPoolBalance.mul(_rewardPortion).div(100).mul(uint256(100).sub(_rewardFee)).div(100).mul(passTime).div(86400);
return rewardAmount;
}
/**
* Get store wallet
*/
function getRewardContract() external view returns (address) {
return address(_rewardContract);
}
/**
* Get total staked amount
*/
function getTotalStakedAmount() external view returns (uint256) {
return _totalStakedAmount;
}
/**
* Get reward amount of staker
*/
function getReward(address staker) external view returns (uint256) {
return _stakeMap[staker].rewardAmount.add(calcReward(staker, now));
}
/**
* Get reward pool balance (LAVA)
*/
function getRewardPoolBalance() external view returns (uint256) {
return _rewardContract.getLavaBalance();
}
/**
* Get last claim timestamp
*/
function getLastClaimTimestamp(address staker) external view returns (uint256) {
return _stakeMap[staker].lastClaimTimestamp;
}
/**
* Get staked amount of staker
*/
function getStakedAmount(address staker) external view returns (uint256) {
return _stakeMap[staker].stakedAmount;
}
/**
* Get min stake amount
*/
function getMinStakeAmount() external view returns (uint256) {
return _minStakeAmount;
}
/**
* Get rewards portion
*/
function getRewardPortion() external view returns (uint256) {
return _rewardPortion;
}
/**
* Get staker count
*/
function getStakerCount() external view returns (uint256) {
return _stakers.length;
}
/**
* Get rewards fee
*/
function getRewardFee() external view returns (uint256) {
return _rewardFee;
}
/**
* Get staked rank
*/
function getStakedRank(address staker) external view returns (uint256) {
uint256 rank = 1;
uint256 senderStakedAmount = _stakeMap[staker].stakedAmount;
for(uint i=0; i<_stakers.length; i++) {
if(_stakers[i] != staker && senderStakedAmount < _stakeMap[_stakers[i]].stakedAmount)
rank = rank.add(1);
}
return rank;
}
/**
* Set store wallet contract address
*/
function setRewardContract(RewardContract rewardContract) external onlyOwner returns (bool) {
require(address(rewardContract) != address(0), 'MOLStaker: reward contract address should not be zero address.');
_rewardContract = rewardContract;
return true;
}
/**
* Set rewards portion in store balance.
* ex: 10 => 10%
*/
function setRewardPortion(uint256 rewardPortion) external onlyOwner returns (bool) {
require(rewardPortion >= 10 && rewardPortion <= 100, 'MOLStaker: reward portion should be in 10 ~ 100.');
_rewardPortion = rewardPortion;
return true;
}
/**
* Set rewards portion for stakers in rewards amount.
* ex: 98 => 98% (2% for dev)
*/
function setRewardFee(uint256 rewardFee) external onlyOwner returns (bool) {
require(rewardFee >= 96 && rewardFee <= 100, 'MOLStaker: reward fee should be in 96 ~ 100.' );
_rewardFee = rewardFee;
return true;
}
} | getReward | function getReward(address staker) external view returns (uint256) {
return _stakeMap[staker].rewardAmount.add(calcReward(staker, now));
}
| /**
* Get reward amount of staker
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://368314f4777f190274441dfdebb1eaf8c259afa185c786922a40e946fdd52269 | {
"func_code_index": [
6684,
6841
]
} | 8,956 |
||
MOLStaker | MOLStaker.sol | 0x04337132ec0c62cbca8640444d23496130e7ba16 | Solidity | MOLStaker | contract MOLStaker is Ownable {
using SafeMath for uint256;
MOLContract private _molContract; // mol token contract
RewardContract private _rewardContract; // reward contract
mapping (address => StakerInfo) private _stakeMap; // map for stakers
address private _devWallet; // dev wallet address
uint256 private _devLastClaimTimestamp; // dev wallet address
address[] private _stakers; // staker's array
uint256 private _totalStakedAmount = 0; // total staked amount
uint256 private _minStakeAmount = 1e18; // min stakable amount
uint256 private _rewardPortion = 10; // reward portion 10%
uint256 private _rewardFee = 98; // reward fee 98%, rest for dev 2%
uint256 private _taxFee = 3; // tax fee for transaction
struct StakerInfo {
uint256 stakedAmount;
uint256 lastClaimTimestamp;
uint256 rewardAmount;
}
// Events
event Staked(address indexed staker, uint256 amount);
event Unstaked(address indexed staker, uint256 amount);
event Claim(address indexed staker, uint256 amount);
constructor (MOLContract molContract, address devWallet) public {
_molContract = molContract;
_devWallet = devWallet;
}
function stake(uint256 amount) public {
require(
amount >= _minStakeAmount,
"MOLStaker: stake amount is less than min stake amount."
);
require(
_molContract.transferFrom(
_msgSender(),
address(this),
amount
),
"MOLStaker: stake failed."
);
uint256 taxAmount = amount.mul(_taxFee).div(100);
uint256 realStakedAmount = amount.sub(taxAmount);
uint256 currentTimestamp = uint256(now);
if(_stakers.length == 0)
_devLastClaimTimestamp = currentTimestamp;
if(_stakeMap[_msgSender()].stakedAmount == 0) {
_stakers.push(_msgSender());
_stakeMap[_msgSender()].lastClaimTimestamp = currentTimestamp;
} else {
_stakeMap[_msgSender()].rewardAmount = _stakeMap[_msgSender()].rewardAmount.add(calcReward(_msgSender(), currentTimestamp));
_stakeMap[_msgSender()].lastClaimTimestamp = currentTimestamp;
}
_stakeMap[_msgSender()].stakedAmount = _stakeMap[_msgSender()].stakedAmount.add(realStakedAmount);
_totalStakedAmount = _totalStakedAmount.add(realStakedAmount);
emit Staked(_msgSender(), realStakedAmount);
}
function unstake(uint256 amount) public {
require(
_stakeMap[_msgSender()].stakedAmount >= amount,
"MOLStaker: unstake amount exceededs the staked amount."
);
uint256 currentTimestamp = uint256(now);
_stakeMap[_msgSender()].rewardAmount = _stakeMap[_msgSender()].rewardAmount.add(calcReward(_msgSender(), currentTimestamp));
_stakeMap[_msgSender()].lastClaimTimestamp = currentTimestamp;
_stakeMap[_msgSender()].stakedAmount = _stakeMap[_msgSender()].stakedAmount.sub(amount);
_totalStakedAmount = _totalStakedAmount.sub(amount);
require(
_molContract.transfer(
_msgSender(),
amount
),
"MOLStaker: unstake failed."
);
if(_stakeMap[_msgSender()].stakedAmount == 0) {
_stakeMap[_msgSender()].lastClaimTimestamp = 0;
for(uint i=0; i<_stakers.length; i++) {
if(_stakers[i] == _msgSender()) {
_stakers[i] = _stakers[_stakers.length-1];
_stakers.pop();
break;
}
}
}
emit Unstaked(_msgSender(), amount);
}
function claim() public {
uint256 currentTimestamp = uint256(now);
uint256 rewardAmount = _stakeMap[_msgSender()].rewardAmount.add(calcReward(_msgSender(), currentTimestamp));
_stakeMap[_msgSender()].lastClaimTimestamp = currentTimestamp;
require(
_rewardContract.giveLavaReward(_msgSender(), rewardAmount),
"MOLStaker: claim failed."
);
_stakeMap[_msgSender()].rewardAmount = 0;
emit Claim(_msgSender(), rewardAmount);
if(currentTimestamp.sub(_devLastClaimTimestamp) >= 86400) {
rewardAmount = calcDevReward(currentTimestamp);
_devLastClaimTimestamp = currentTimestamp;
require(
_rewardContract.giveLavaReward(_devWallet, rewardAmount),
"MOLStaker: dev reward claim failed."
);
emit Claim(_devWallet, rewardAmount);
}
}
function endStake() external {
unstake(_stakeMap[_msgSender()].stakedAmount);
claim();
}
function calcReward(address staker, uint256 currentTimestamp) private view returns (uint256) {
if(_totalStakedAmount == 0)
return 0;
uint256 rewardPoolBalance = _rewardContract.getLavaBalance();
uint256 passTime = currentTimestamp.sub(_stakeMap[staker].lastClaimTimestamp);
uint256 rewardAmountForStakers = rewardPoolBalance.mul(_rewardPortion).div(100).mul(_rewardFee).div(100);
uint256 rewardAmount = rewardAmountForStakers.mul(passTime).div(86400).mul(_stakeMap[staker].stakedAmount).div(_totalStakedAmount);
return rewardAmount;
}
function calcDevReward(uint256 currentTimestamp) private view returns (uint256) {
uint256 rewardPoolBalance = _rewardContract.getLavaBalance();
uint256 passTime = currentTimestamp.sub(_devLastClaimTimestamp);
uint256 rewardAmount = rewardPoolBalance.mul(_rewardPortion).div(100).mul(uint256(100).sub(_rewardFee)).div(100).mul(passTime).div(86400);
return rewardAmount;
}
/**
* Get store wallet
*/
function getRewardContract() external view returns (address) {
return address(_rewardContract);
}
/**
* Get total staked amount
*/
function getTotalStakedAmount() external view returns (uint256) {
return _totalStakedAmount;
}
/**
* Get reward amount of staker
*/
function getReward(address staker) external view returns (uint256) {
return _stakeMap[staker].rewardAmount.add(calcReward(staker, now));
}
/**
* Get reward pool balance (LAVA)
*/
function getRewardPoolBalance() external view returns (uint256) {
return _rewardContract.getLavaBalance();
}
/**
* Get last claim timestamp
*/
function getLastClaimTimestamp(address staker) external view returns (uint256) {
return _stakeMap[staker].lastClaimTimestamp;
}
/**
* Get staked amount of staker
*/
function getStakedAmount(address staker) external view returns (uint256) {
return _stakeMap[staker].stakedAmount;
}
/**
* Get min stake amount
*/
function getMinStakeAmount() external view returns (uint256) {
return _minStakeAmount;
}
/**
* Get rewards portion
*/
function getRewardPortion() external view returns (uint256) {
return _rewardPortion;
}
/**
* Get staker count
*/
function getStakerCount() external view returns (uint256) {
return _stakers.length;
}
/**
* Get rewards fee
*/
function getRewardFee() external view returns (uint256) {
return _rewardFee;
}
/**
* Get staked rank
*/
function getStakedRank(address staker) external view returns (uint256) {
uint256 rank = 1;
uint256 senderStakedAmount = _stakeMap[staker].stakedAmount;
for(uint i=0; i<_stakers.length; i++) {
if(_stakers[i] != staker && senderStakedAmount < _stakeMap[_stakers[i]].stakedAmount)
rank = rank.add(1);
}
return rank;
}
/**
* Set store wallet contract address
*/
function setRewardContract(RewardContract rewardContract) external onlyOwner returns (bool) {
require(address(rewardContract) != address(0), 'MOLStaker: reward contract address should not be zero address.');
_rewardContract = rewardContract;
return true;
}
/**
* Set rewards portion in store balance.
* ex: 10 => 10%
*/
function setRewardPortion(uint256 rewardPortion) external onlyOwner returns (bool) {
require(rewardPortion >= 10 && rewardPortion <= 100, 'MOLStaker: reward portion should be in 10 ~ 100.');
_rewardPortion = rewardPortion;
return true;
}
/**
* Set rewards portion for stakers in rewards amount.
* ex: 98 => 98% (2% for dev)
*/
function setRewardFee(uint256 rewardFee) external onlyOwner returns (bool) {
require(rewardFee >= 96 && rewardFee <= 100, 'MOLStaker: reward fee should be in 96 ~ 100.' );
_rewardFee = rewardFee;
return true;
}
} | getRewardPoolBalance | function getRewardPoolBalance() external view returns (uint256) {
return _rewardContract.getLavaBalance();
}
| /**
* Get reward pool balance (LAVA)
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://368314f4777f190274441dfdebb1eaf8c259afa185c786922a40e946fdd52269 | {
"func_code_index": [
6905,
7032
]
} | 8,957 |
||
MOLStaker | MOLStaker.sol | 0x04337132ec0c62cbca8640444d23496130e7ba16 | Solidity | MOLStaker | contract MOLStaker is Ownable {
using SafeMath for uint256;
MOLContract private _molContract; // mol token contract
RewardContract private _rewardContract; // reward contract
mapping (address => StakerInfo) private _stakeMap; // map for stakers
address private _devWallet; // dev wallet address
uint256 private _devLastClaimTimestamp; // dev wallet address
address[] private _stakers; // staker's array
uint256 private _totalStakedAmount = 0; // total staked amount
uint256 private _minStakeAmount = 1e18; // min stakable amount
uint256 private _rewardPortion = 10; // reward portion 10%
uint256 private _rewardFee = 98; // reward fee 98%, rest for dev 2%
uint256 private _taxFee = 3; // tax fee for transaction
struct StakerInfo {
uint256 stakedAmount;
uint256 lastClaimTimestamp;
uint256 rewardAmount;
}
// Events
event Staked(address indexed staker, uint256 amount);
event Unstaked(address indexed staker, uint256 amount);
event Claim(address indexed staker, uint256 amount);
constructor (MOLContract molContract, address devWallet) public {
_molContract = molContract;
_devWallet = devWallet;
}
function stake(uint256 amount) public {
require(
amount >= _minStakeAmount,
"MOLStaker: stake amount is less than min stake amount."
);
require(
_molContract.transferFrom(
_msgSender(),
address(this),
amount
),
"MOLStaker: stake failed."
);
uint256 taxAmount = amount.mul(_taxFee).div(100);
uint256 realStakedAmount = amount.sub(taxAmount);
uint256 currentTimestamp = uint256(now);
if(_stakers.length == 0)
_devLastClaimTimestamp = currentTimestamp;
if(_stakeMap[_msgSender()].stakedAmount == 0) {
_stakers.push(_msgSender());
_stakeMap[_msgSender()].lastClaimTimestamp = currentTimestamp;
} else {
_stakeMap[_msgSender()].rewardAmount = _stakeMap[_msgSender()].rewardAmount.add(calcReward(_msgSender(), currentTimestamp));
_stakeMap[_msgSender()].lastClaimTimestamp = currentTimestamp;
}
_stakeMap[_msgSender()].stakedAmount = _stakeMap[_msgSender()].stakedAmount.add(realStakedAmount);
_totalStakedAmount = _totalStakedAmount.add(realStakedAmount);
emit Staked(_msgSender(), realStakedAmount);
}
function unstake(uint256 amount) public {
require(
_stakeMap[_msgSender()].stakedAmount >= amount,
"MOLStaker: unstake amount exceededs the staked amount."
);
uint256 currentTimestamp = uint256(now);
_stakeMap[_msgSender()].rewardAmount = _stakeMap[_msgSender()].rewardAmount.add(calcReward(_msgSender(), currentTimestamp));
_stakeMap[_msgSender()].lastClaimTimestamp = currentTimestamp;
_stakeMap[_msgSender()].stakedAmount = _stakeMap[_msgSender()].stakedAmount.sub(amount);
_totalStakedAmount = _totalStakedAmount.sub(amount);
require(
_molContract.transfer(
_msgSender(),
amount
),
"MOLStaker: unstake failed."
);
if(_stakeMap[_msgSender()].stakedAmount == 0) {
_stakeMap[_msgSender()].lastClaimTimestamp = 0;
for(uint i=0; i<_stakers.length; i++) {
if(_stakers[i] == _msgSender()) {
_stakers[i] = _stakers[_stakers.length-1];
_stakers.pop();
break;
}
}
}
emit Unstaked(_msgSender(), amount);
}
function claim() public {
uint256 currentTimestamp = uint256(now);
uint256 rewardAmount = _stakeMap[_msgSender()].rewardAmount.add(calcReward(_msgSender(), currentTimestamp));
_stakeMap[_msgSender()].lastClaimTimestamp = currentTimestamp;
require(
_rewardContract.giveLavaReward(_msgSender(), rewardAmount),
"MOLStaker: claim failed."
);
_stakeMap[_msgSender()].rewardAmount = 0;
emit Claim(_msgSender(), rewardAmount);
if(currentTimestamp.sub(_devLastClaimTimestamp) >= 86400) {
rewardAmount = calcDevReward(currentTimestamp);
_devLastClaimTimestamp = currentTimestamp;
require(
_rewardContract.giveLavaReward(_devWallet, rewardAmount),
"MOLStaker: dev reward claim failed."
);
emit Claim(_devWallet, rewardAmount);
}
}
function endStake() external {
unstake(_stakeMap[_msgSender()].stakedAmount);
claim();
}
function calcReward(address staker, uint256 currentTimestamp) private view returns (uint256) {
if(_totalStakedAmount == 0)
return 0;
uint256 rewardPoolBalance = _rewardContract.getLavaBalance();
uint256 passTime = currentTimestamp.sub(_stakeMap[staker].lastClaimTimestamp);
uint256 rewardAmountForStakers = rewardPoolBalance.mul(_rewardPortion).div(100).mul(_rewardFee).div(100);
uint256 rewardAmount = rewardAmountForStakers.mul(passTime).div(86400).mul(_stakeMap[staker].stakedAmount).div(_totalStakedAmount);
return rewardAmount;
}
function calcDevReward(uint256 currentTimestamp) private view returns (uint256) {
uint256 rewardPoolBalance = _rewardContract.getLavaBalance();
uint256 passTime = currentTimestamp.sub(_devLastClaimTimestamp);
uint256 rewardAmount = rewardPoolBalance.mul(_rewardPortion).div(100).mul(uint256(100).sub(_rewardFee)).div(100).mul(passTime).div(86400);
return rewardAmount;
}
/**
* Get store wallet
*/
function getRewardContract() external view returns (address) {
return address(_rewardContract);
}
/**
* Get total staked amount
*/
function getTotalStakedAmount() external view returns (uint256) {
return _totalStakedAmount;
}
/**
* Get reward amount of staker
*/
function getReward(address staker) external view returns (uint256) {
return _stakeMap[staker].rewardAmount.add(calcReward(staker, now));
}
/**
* Get reward pool balance (LAVA)
*/
function getRewardPoolBalance() external view returns (uint256) {
return _rewardContract.getLavaBalance();
}
/**
* Get last claim timestamp
*/
function getLastClaimTimestamp(address staker) external view returns (uint256) {
return _stakeMap[staker].lastClaimTimestamp;
}
/**
* Get staked amount of staker
*/
function getStakedAmount(address staker) external view returns (uint256) {
return _stakeMap[staker].stakedAmount;
}
/**
* Get min stake amount
*/
function getMinStakeAmount() external view returns (uint256) {
return _minStakeAmount;
}
/**
* Get rewards portion
*/
function getRewardPortion() external view returns (uint256) {
return _rewardPortion;
}
/**
* Get staker count
*/
function getStakerCount() external view returns (uint256) {
return _stakers.length;
}
/**
* Get rewards fee
*/
function getRewardFee() external view returns (uint256) {
return _rewardFee;
}
/**
* Get staked rank
*/
function getStakedRank(address staker) external view returns (uint256) {
uint256 rank = 1;
uint256 senderStakedAmount = _stakeMap[staker].stakedAmount;
for(uint i=0; i<_stakers.length; i++) {
if(_stakers[i] != staker && senderStakedAmount < _stakeMap[_stakers[i]].stakedAmount)
rank = rank.add(1);
}
return rank;
}
/**
* Set store wallet contract address
*/
function setRewardContract(RewardContract rewardContract) external onlyOwner returns (bool) {
require(address(rewardContract) != address(0), 'MOLStaker: reward contract address should not be zero address.');
_rewardContract = rewardContract;
return true;
}
/**
* Set rewards portion in store balance.
* ex: 10 => 10%
*/
function setRewardPortion(uint256 rewardPortion) external onlyOwner returns (bool) {
require(rewardPortion >= 10 && rewardPortion <= 100, 'MOLStaker: reward portion should be in 10 ~ 100.');
_rewardPortion = rewardPortion;
return true;
}
/**
* Set rewards portion for stakers in rewards amount.
* ex: 98 => 98% (2% for dev)
*/
function setRewardFee(uint256 rewardFee) external onlyOwner returns (bool) {
require(rewardFee >= 96 && rewardFee <= 100, 'MOLStaker: reward fee should be in 96 ~ 100.' );
_rewardFee = rewardFee;
return true;
}
} | getLastClaimTimestamp | function getLastClaimTimestamp(address staker) external view returns (uint256) {
return _stakeMap[staker].lastClaimTimestamp;
}
| /**
* Get last claim timestamp
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://368314f4777f190274441dfdebb1eaf8c259afa185c786922a40e946fdd52269 | {
"func_code_index": [
7090,
7236
]
} | 8,958 |
||
MOLStaker | MOLStaker.sol | 0x04337132ec0c62cbca8640444d23496130e7ba16 | Solidity | MOLStaker | contract MOLStaker is Ownable {
using SafeMath for uint256;
MOLContract private _molContract; // mol token contract
RewardContract private _rewardContract; // reward contract
mapping (address => StakerInfo) private _stakeMap; // map for stakers
address private _devWallet; // dev wallet address
uint256 private _devLastClaimTimestamp; // dev wallet address
address[] private _stakers; // staker's array
uint256 private _totalStakedAmount = 0; // total staked amount
uint256 private _minStakeAmount = 1e18; // min stakable amount
uint256 private _rewardPortion = 10; // reward portion 10%
uint256 private _rewardFee = 98; // reward fee 98%, rest for dev 2%
uint256 private _taxFee = 3; // tax fee for transaction
struct StakerInfo {
uint256 stakedAmount;
uint256 lastClaimTimestamp;
uint256 rewardAmount;
}
// Events
event Staked(address indexed staker, uint256 amount);
event Unstaked(address indexed staker, uint256 amount);
event Claim(address indexed staker, uint256 amount);
constructor (MOLContract molContract, address devWallet) public {
_molContract = molContract;
_devWallet = devWallet;
}
function stake(uint256 amount) public {
require(
amount >= _minStakeAmount,
"MOLStaker: stake amount is less than min stake amount."
);
require(
_molContract.transferFrom(
_msgSender(),
address(this),
amount
),
"MOLStaker: stake failed."
);
uint256 taxAmount = amount.mul(_taxFee).div(100);
uint256 realStakedAmount = amount.sub(taxAmount);
uint256 currentTimestamp = uint256(now);
if(_stakers.length == 0)
_devLastClaimTimestamp = currentTimestamp;
if(_stakeMap[_msgSender()].stakedAmount == 0) {
_stakers.push(_msgSender());
_stakeMap[_msgSender()].lastClaimTimestamp = currentTimestamp;
} else {
_stakeMap[_msgSender()].rewardAmount = _stakeMap[_msgSender()].rewardAmount.add(calcReward(_msgSender(), currentTimestamp));
_stakeMap[_msgSender()].lastClaimTimestamp = currentTimestamp;
}
_stakeMap[_msgSender()].stakedAmount = _stakeMap[_msgSender()].stakedAmount.add(realStakedAmount);
_totalStakedAmount = _totalStakedAmount.add(realStakedAmount);
emit Staked(_msgSender(), realStakedAmount);
}
function unstake(uint256 amount) public {
require(
_stakeMap[_msgSender()].stakedAmount >= amount,
"MOLStaker: unstake amount exceededs the staked amount."
);
uint256 currentTimestamp = uint256(now);
_stakeMap[_msgSender()].rewardAmount = _stakeMap[_msgSender()].rewardAmount.add(calcReward(_msgSender(), currentTimestamp));
_stakeMap[_msgSender()].lastClaimTimestamp = currentTimestamp;
_stakeMap[_msgSender()].stakedAmount = _stakeMap[_msgSender()].stakedAmount.sub(amount);
_totalStakedAmount = _totalStakedAmount.sub(amount);
require(
_molContract.transfer(
_msgSender(),
amount
),
"MOLStaker: unstake failed."
);
if(_stakeMap[_msgSender()].stakedAmount == 0) {
_stakeMap[_msgSender()].lastClaimTimestamp = 0;
for(uint i=0; i<_stakers.length; i++) {
if(_stakers[i] == _msgSender()) {
_stakers[i] = _stakers[_stakers.length-1];
_stakers.pop();
break;
}
}
}
emit Unstaked(_msgSender(), amount);
}
function claim() public {
uint256 currentTimestamp = uint256(now);
uint256 rewardAmount = _stakeMap[_msgSender()].rewardAmount.add(calcReward(_msgSender(), currentTimestamp));
_stakeMap[_msgSender()].lastClaimTimestamp = currentTimestamp;
require(
_rewardContract.giveLavaReward(_msgSender(), rewardAmount),
"MOLStaker: claim failed."
);
_stakeMap[_msgSender()].rewardAmount = 0;
emit Claim(_msgSender(), rewardAmount);
if(currentTimestamp.sub(_devLastClaimTimestamp) >= 86400) {
rewardAmount = calcDevReward(currentTimestamp);
_devLastClaimTimestamp = currentTimestamp;
require(
_rewardContract.giveLavaReward(_devWallet, rewardAmount),
"MOLStaker: dev reward claim failed."
);
emit Claim(_devWallet, rewardAmount);
}
}
function endStake() external {
unstake(_stakeMap[_msgSender()].stakedAmount);
claim();
}
function calcReward(address staker, uint256 currentTimestamp) private view returns (uint256) {
if(_totalStakedAmount == 0)
return 0;
uint256 rewardPoolBalance = _rewardContract.getLavaBalance();
uint256 passTime = currentTimestamp.sub(_stakeMap[staker].lastClaimTimestamp);
uint256 rewardAmountForStakers = rewardPoolBalance.mul(_rewardPortion).div(100).mul(_rewardFee).div(100);
uint256 rewardAmount = rewardAmountForStakers.mul(passTime).div(86400).mul(_stakeMap[staker].stakedAmount).div(_totalStakedAmount);
return rewardAmount;
}
function calcDevReward(uint256 currentTimestamp) private view returns (uint256) {
uint256 rewardPoolBalance = _rewardContract.getLavaBalance();
uint256 passTime = currentTimestamp.sub(_devLastClaimTimestamp);
uint256 rewardAmount = rewardPoolBalance.mul(_rewardPortion).div(100).mul(uint256(100).sub(_rewardFee)).div(100).mul(passTime).div(86400);
return rewardAmount;
}
/**
* Get store wallet
*/
function getRewardContract() external view returns (address) {
return address(_rewardContract);
}
/**
* Get total staked amount
*/
function getTotalStakedAmount() external view returns (uint256) {
return _totalStakedAmount;
}
/**
* Get reward amount of staker
*/
function getReward(address staker) external view returns (uint256) {
return _stakeMap[staker].rewardAmount.add(calcReward(staker, now));
}
/**
* Get reward pool balance (LAVA)
*/
function getRewardPoolBalance() external view returns (uint256) {
return _rewardContract.getLavaBalance();
}
/**
* Get last claim timestamp
*/
function getLastClaimTimestamp(address staker) external view returns (uint256) {
return _stakeMap[staker].lastClaimTimestamp;
}
/**
* Get staked amount of staker
*/
function getStakedAmount(address staker) external view returns (uint256) {
return _stakeMap[staker].stakedAmount;
}
/**
* Get min stake amount
*/
function getMinStakeAmount() external view returns (uint256) {
return _minStakeAmount;
}
/**
* Get rewards portion
*/
function getRewardPortion() external view returns (uint256) {
return _rewardPortion;
}
/**
* Get staker count
*/
function getStakerCount() external view returns (uint256) {
return _stakers.length;
}
/**
* Get rewards fee
*/
function getRewardFee() external view returns (uint256) {
return _rewardFee;
}
/**
* Get staked rank
*/
function getStakedRank(address staker) external view returns (uint256) {
uint256 rank = 1;
uint256 senderStakedAmount = _stakeMap[staker].stakedAmount;
for(uint i=0; i<_stakers.length; i++) {
if(_stakers[i] != staker && senderStakedAmount < _stakeMap[_stakers[i]].stakedAmount)
rank = rank.add(1);
}
return rank;
}
/**
* Set store wallet contract address
*/
function setRewardContract(RewardContract rewardContract) external onlyOwner returns (bool) {
require(address(rewardContract) != address(0), 'MOLStaker: reward contract address should not be zero address.');
_rewardContract = rewardContract;
return true;
}
/**
* Set rewards portion in store balance.
* ex: 10 => 10%
*/
function setRewardPortion(uint256 rewardPortion) external onlyOwner returns (bool) {
require(rewardPortion >= 10 && rewardPortion <= 100, 'MOLStaker: reward portion should be in 10 ~ 100.');
_rewardPortion = rewardPortion;
return true;
}
/**
* Set rewards portion for stakers in rewards amount.
* ex: 98 => 98% (2% for dev)
*/
function setRewardFee(uint256 rewardFee) external onlyOwner returns (bool) {
require(rewardFee >= 96 && rewardFee <= 100, 'MOLStaker: reward fee should be in 96 ~ 100.' );
_rewardFee = rewardFee;
return true;
}
} | getStakedAmount | function getStakedAmount(address staker) external view returns (uint256) {
return _stakeMap[staker].stakedAmount;
}
| /**
* Get staked amount of staker
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://368314f4777f190274441dfdebb1eaf8c259afa185c786922a40e946fdd52269 | {
"func_code_index": [
7297,
7431
]
} | 8,959 |
||
MOLStaker | MOLStaker.sol | 0x04337132ec0c62cbca8640444d23496130e7ba16 | Solidity | MOLStaker | contract MOLStaker is Ownable {
using SafeMath for uint256;
MOLContract private _molContract; // mol token contract
RewardContract private _rewardContract; // reward contract
mapping (address => StakerInfo) private _stakeMap; // map for stakers
address private _devWallet; // dev wallet address
uint256 private _devLastClaimTimestamp; // dev wallet address
address[] private _stakers; // staker's array
uint256 private _totalStakedAmount = 0; // total staked amount
uint256 private _minStakeAmount = 1e18; // min stakable amount
uint256 private _rewardPortion = 10; // reward portion 10%
uint256 private _rewardFee = 98; // reward fee 98%, rest for dev 2%
uint256 private _taxFee = 3; // tax fee for transaction
struct StakerInfo {
uint256 stakedAmount;
uint256 lastClaimTimestamp;
uint256 rewardAmount;
}
// Events
event Staked(address indexed staker, uint256 amount);
event Unstaked(address indexed staker, uint256 amount);
event Claim(address indexed staker, uint256 amount);
constructor (MOLContract molContract, address devWallet) public {
_molContract = molContract;
_devWallet = devWallet;
}
function stake(uint256 amount) public {
require(
amount >= _minStakeAmount,
"MOLStaker: stake amount is less than min stake amount."
);
require(
_molContract.transferFrom(
_msgSender(),
address(this),
amount
),
"MOLStaker: stake failed."
);
uint256 taxAmount = amount.mul(_taxFee).div(100);
uint256 realStakedAmount = amount.sub(taxAmount);
uint256 currentTimestamp = uint256(now);
if(_stakers.length == 0)
_devLastClaimTimestamp = currentTimestamp;
if(_stakeMap[_msgSender()].stakedAmount == 0) {
_stakers.push(_msgSender());
_stakeMap[_msgSender()].lastClaimTimestamp = currentTimestamp;
} else {
_stakeMap[_msgSender()].rewardAmount = _stakeMap[_msgSender()].rewardAmount.add(calcReward(_msgSender(), currentTimestamp));
_stakeMap[_msgSender()].lastClaimTimestamp = currentTimestamp;
}
_stakeMap[_msgSender()].stakedAmount = _stakeMap[_msgSender()].stakedAmount.add(realStakedAmount);
_totalStakedAmount = _totalStakedAmount.add(realStakedAmount);
emit Staked(_msgSender(), realStakedAmount);
}
function unstake(uint256 amount) public {
require(
_stakeMap[_msgSender()].stakedAmount >= amount,
"MOLStaker: unstake amount exceededs the staked amount."
);
uint256 currentTimestamp = uint256(now);
_stakeMap[_msgSender()].rewardAmount = _stakeMap[_msgSender()].rewardAmount.add(calcReward(_msgSender(), currentTimestamp));
_stakeMap[_msgSender()].lastClaimTimestamp = currentTimestamp;
_stakeMap[_msgSender()].stakedAmount = _stakeMap[_msgSender()].stakedAmount.sub(amount);
_totalStakedAmount = _totalStakedAmount.sub(amount);
require(
_molContract.transfer(
_msgSender(),
amount
),
"MOLStaker: unstake failed."
);
if(_stakeMap[_msgSender()].stakedAmount == 0) {
_stakeMap[_msgSender()].lastClaimTimestamp = 0;
for(uint i=0; i<_stakers.length; i++) {
if(_stakers[i] == _msgSender()) {
_stakers[i] = _stakers[_stakers.length-1];
_stakers.pop();
break;
}
}
}
emit Unstaked(_msgSender(), amount);
}
function claim() public {
uint256 currentTimestamp = uint256(now);
uint256 rewardAmount = _stakeMap[_msgSender()].rewardAmount.add(calcReward(_msgSender(), currentTimestamp));
_stakeMap[_msgSender()].lastClaimTimestamp = currentTimestamp;
require(
_rewardContract.giveLavaReward(_msgSender(), rewardAmount),
"MOLStaker: claim failed."
);
_stakeMap[_msgSender()].rewardAmount = 0;
emit Claim(_msgSender(), rewardAmount);
if(currentTimestamp.sub(_devLastClaimTimestamp) >= 86400) {
rewardAmount = calcDevReward(currentTimestamp);
_devLastClaimTimestamp = currentTimestamp;
require(
_rewardContract.giveLavaReward(_devWallet, rewardAmount),
"MOLStaker: dev reward claim failed."
);
emit Claim(_devWallet, rewardAmount);
}
}
function endStake() external {
unstake(_stakeMap[_msgSender()].stakedAmount);
claim();
}
function calcReward(address staker, uint256 currentTimestamp) private view returns (uint256) {
if(_totalStakedAmount == 0)
return 0;
uint256 rewardPoolBalance = _rewardContract.getLavaBalance();
uint256 passTime = currentTimestamp.sub(_stakeMap[staker].lastClaimTimestamp);
uint256 rewardAmountForStakers = rewardPoolBalance.mul(_rewardPortion).div(100).mul(_rewardFee).div(100);
uint256 rewardAmount = rewardAmountForStakers.mul(passTime).div(86400).mul(_stakeMap[staker].stakedAmount).div(_totalStakedAmount);
return rewardAmount;
}
function calcDevReward(uint256 currentTimestamp) private view returns (uint256) {
uint256 rewardPoolBalance = _rewardContract.getLavaBalance();
uint256 passTime = currentTimestamp.sub(_devLastClaimTimestamp);
uint256 rewardAmount = rewardPoolBalance.mul(_rewardPortion).div(100).mul(uint256(100).sub(_rewardFee)).div(100).mul(passTime).div(86400);
return rewardAmount;
}
/**
* Get store wallet
*/
function getRewardContract() external view returns (address) {
return address(_rewardContract);
}
/**
* Get total staked amount
*/
function getTotalStakedAmount() external view returns (uint256) {
return _totalStakedAmount;
}
/**
* Get reward amount of staker
*/
function getReward(address staker) external view returns (uint256) {
return _stakeMap[staker].rewardAmount.add(calcReward(staker, now));
}
/**
* Get reward pool balance (LAVA)
*/
function getRewardPoolBalance() external view returns (uint256) {
return _rewardContract.getLavaBalance();
}
/**
* Get last claim timestamp
*/
function getLastClaimTimestamp(address staker) external view returns (uint256) {
return _stakeMap[staker].lastClaimTimestamp;
}
/**
* Get staked amount of staker
*/
function getStakedAmount(address staker) external view returns (uint256) {
return _stakeMap[staker].stakedAmount;
}
/**
* Get min stake amount
*/
function getMinStakeAmount() external view returns (uint256) {
return _minStakeAmount;
}
/**
* Get rewards portion
*/
function getRewardPortion() external view returns (uint256) {
return _rewardPortion;
}
/**
* Get staker count
*/
function getStakerCount() external view returns (uint256) {
return _stakers.length;
}
/**
* Get rewards fee
*/
function getRewardFee() external view returns (uint256) {
return _rewardFee;
}
/**
* Get staked rank
*/
function getStakedRank(address staker) external view returns (uint256) {
uint256 rank = 1;
uint256 senderStakedAmount = _stakeMap[staker].stakedAmount;
for(uint i=0; i<_stakers.length; i++) {
if(_stakers[i] != staker && senderStakedAmount < _stakeMap[_stakers[i]].stakedAmount)
rank = rank.add(1);
}
return rank;
}
/**
* Set store wallet contract address
*/
function setRewardContract(RewardContract rewardContract) external onlyOwner returns (bool) {
require(address(rewardContract) != address(0), 'MOLStaker: reward contract address should not be zero address.');
_rewardContract = rewardContract;
return true;
}
/**
* Set rewards portion in store balance.
* ex: 10 => 10%
*/
function setRewardPortion(uint256 rewardPortion) external onlyOwner returns (bool) {
require(rewardPortion >= 10 && rewardPortion <= 100, 'MOLStaker: reward portion should be in 10 ~ 100.');
_rewardPortion = rewardPortion;
return true;
}
/**
* Set rewards portion for stakers in rewards amount.
* ex: 98 => 98% (2% for dev)
*/
function setRewardFee(uint256 rewardFee) external onlyOwner returns (bool) {
require(rewardFee >= 96 && rewardFee <= 100, 'MOLStaker: reward fee should be in 96 ~ 100.' );
_rewardFee = rewardFee;
return true;
}
} | getMinStakeAmount | function getMinStakeAmount() external view returns (uint256) {
return _minStakeAmount;
}
| /**
* Get min stake amount
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://368314f4777f190274441dfdebb1eaf8c259afa185c786922a40e946fdd52269 | {
"func_code_index": [
7485,
7592
]
} | 8,960 |
||
MOLStaker | MOLStaker.sol | 0x04337132ec0c62cbca8640444d23496130e7ba16 | Solidity | MOLStaker | contract MOLStaker is Ownable {
using SafeMath for uint256;
MOLContract private _molContract; // mol token contract
RewardContract private _rewardContract; // reward contract
mapping (address => StakerInfo) private _stakeMap; // map for stakers
address private _devWallet; // dev wallet address
uint256 private _devLastClaimTimestamp; // dev wallet address
address[] private _stakers; // staker's array
uint256 private _totalStakedAmount = 0; // total staked amount
uint256 private _minStakeAmount = 1e18; // min stakable amount
uint256 private _rewardPortion = 10; // reward portion 10%
uint256 private _rewardFee = 98; // reward fee 98%, rest for dev 2%
uint256 private _taxFee = 3; // tax fee for transaction
struct StakerInfo {
uint256 stakedAmount;
uint256 lastClaimTimestamp;
uint256 rewardAmount;
}
// Events
event Staked(address indexed staker, uint256 amount);
event Unstaked(address indexed staker, uint256 amount);
event Claim(address indexed staker, uint256 amount);
constructor (MOLContract molContract, address devWallet) public {
_molContract = molContract;
_devWallet = devWallet;
}
function stake(uint256 amount) public {
require(
amount >= _minStakeAmount,
"MOLStaker: stake amount is less than min stake amount."
);
require(
_molContract.transferFrom(
_msgSender(),
address(this),
amount
),
"MOLStaker: stake failed."
);
uint256 taxAmount = amount.mul(_taxFee).div(100);
uint256 realStakedAmount = amount.sub(taxAmount);
uint256 currentTimestamp = uint256(now);
if(_stakers.length == 0)
_devLastClaimTimestamp = currentTimestamp;
if(_stakeMap[_msgSender()].stakedAmount == 0) {
_stakers.push(_msgSender());
_stakeMap[_msgSender()].lastClaimTimestamp = currentTimestamp;
} else {
_stakeMap[_msgSender()].rewardAmount = _stakeMap[_msgSender()].rewardAmount.add(calcReward(_msgSender(), currentTimestamp));
_stakeMap[_msgSender()].lastClaimTimestamp = currentTimestamp;
}
_stakeMap[_msgSender()].stakedAmount = _stakeMap[_msgSender()].stakedAmount.add(realStakedAmount);
_totalStakedAmount = _totalStakedAmount.add(realStakedAmount);
emit Staked(_msgSender(), realStakedAmount);
}
function unstake(uint256 amount) public {
require(
_stakeMap[_msgSender()].stakedAmount >= amount,
"MOLStaker: unstake amount exceededs the staked amount."
);
uint256 currentTimestamp = uint256(now);
_stakeMap[_msgSender()].rewardAmount = _stakeMap[_msgSender()].rewardAmount.add(calcReward(_msgSender(), currentTimestamp));
_stakeMap[_msgSender()].lastClaimTimestamp = currentTimestamp;
_stakeMap[_msgSender()].stakedAmount = _stakeMap[_msgSender()].stakedAmount.sub(amount);
_totalStakedAmount = _totalStakedAmount.sub(amount);
require(
_molContract.transfer(
_msgSender(),
amount
),
"MOLStaker: unstake failed."
);
if(_stakeMap[_msgSender()].stakedAmount == 0) {
_stakeMap[_msgSender()].lastClaimTimestamp = 0;
for(uint i=0; i<_stakers.length; i++) {
if(_stakers[i] == _msgSender()) {
_stakers[i] = _stakers[_stakers.length-1];
_stakers.pop();
break;
}
}
}
emit Unstaked(_msgSender(), amount);
}
function claim() public {
uint256 currentTimestamp = uint256(now);
uint256 rewardAmount = _stakeMap[_msgSender()].rewardAmount.add(calcReward(_msgSender(), currentTimestamp));
_stakeMap[_msgSender()].lastClaimTimestamp = currentTimestamp;
require(
_rewardContract.giveLavaReward(_msgSender(), rewardAmount),
"MOLStaker: claim failed."
);
_stakeMap[_msgSender()].rewardAmount = 0;
emit Claim(_msgSender(), rewardAmount);
if(currentTimestamp.sub(_devLastClaimTimestamp) >= 86400) {
rewardAmount = calcDevReward(currentTimestamp);
_devLastClaimTimestamp = currentTimestamp;
require(
_rewardContract.giveLavaReward(_devWallet, rewardAmount),
"MOLStaker: dev reward claim failed."
);
emit Claim(_devWallet, rewardAmount);
}
}
function endStake() external {
unstake(_stakeMap[_msgSender()].stakedAmount);
claim();
}
function calcReward(address staker, uint256 currentTimestamp) private view returns (uint256) {
if(_totalStakedAmount == 0)
return 0;
uint256 rewardPoolBalance = _rewardContract.getLavaBalance();
uint256 passTime = currentTimestamp.sub(_stakeMap[staker].lastClaimTimestamp);
uint256 rewardAmountForStakers = rewardPoolBalance.mul(_rewardPortion).div(100).mul(_rewardFee).div(100);
uint256 rewardAmount = rewardAmountForStakers.mul(passTime).div(86400).mul(_stakeMap[staker].stakedAmount).div(_totalStakedAmount);
return rewardAmount;
}
function calcDevReward(uint256 currentTimestamp) private view returns (uint256) {
uint256 rewardPoolBalance = _rewardContract.getLavaBalance();
uint256 passTime = currentTimestamp.sub(_devLastClaimTimestamp);
uint256 rewardAmount = rewardPoolBalance.mul(_rewardPortion).div(100).mul(uint256(100).sub(_rewardFee)).div(100).mul(passTime).div(86400);
return rewardAmount;
}
/**
* Get store wallet
*/
function getRewardContract() external view returns (address) {
return address(_rewardContract);
}
/**
* Get total staked amount
*/
function getTotalStakedAmount() external view returns (uint256) {
return _totalStakedAmount;
}
/**
* Get reward amount of staker
*/
function getReward(address staker) external view returns (uint256) {
return _stakeMap[staker].rewardAmount.add(calcReward(staker, now));
}
/**
* Get reward pool balance (LAVA)
*/
function getRewardPoolBalance() external view returns (uint256) {
return _rewardContract.getLavaBalance();
}
/**
* Get last claim timestamp
*/
function getLastClaimTimestamp(address staker) external view returns (uint256) {
return _stakeMap[staker].lastClaimTimestamp;
}
/**
* Get staked amount of staker
*/
function getStakedAmount(address staker) external view returns (uint256) {
return _stakeMap[staker].stakedAmount;
}
/**
* Get min stake amount
*/
function getMinStakeAmount() external view returns (uint256) {
return _minStakeAmount;
}
/**
* Get rewards portion
*/
function getRewardPortion() external view returns (uint256) {
return _rewardPortion;
}
/**
* Get staker count
*/
function getStakerCount() external view returns (uint256) {
return _stakers.length;
}
/**
* Get rewards fee
*/
function getRewardFee() external view returns (uint256) {
return _rewardFee;
}
/**
* Get staked rank
*/
function getStakedRank(address staker) external view returns (uint256) {
uint256 rank = 1;
uint256 senderStakedAmount = _stakeMap[staker].stakedAmount;
for(uint i=0; i<_stakers.length; i++) {
if(_stakers[i] != staker && senderStakedAmount < _stakeMap[_stakers[i]].stakedAmount)
rank = rank.add(1);
}
return rank;
}
/**
* Set store wallet contract address
*/
function setRewardContract(RewardContract rewardContract) external onlyOwner returns (bool) {
require(address(rewardContract) != address(0), 'MOLStaker: reward contract address should not be zero address.');
_rewardContract = rewardContract;
return true;
}
/**
* Set rewards portion in store balance.
* ex: 10 => 10%
*/
function setRewardPortion(uint256 rewardPortion) external onlyOwner returns (bool) {
require(rewardPortion >= 10 && rewardPortion <= 100, 'MOLStaker: reward portion should be in 10 ~ 100.');
_rewardPortion = rewardPortion;
return true;
}
/**
* Set rewards portion for stakers in rewards amount.
* ex: 98 => 98% (2% for dev)
*/
function setRewardFee(uint256 rewardFee) external onlyOwner returns (bool) {
require(rewardFee >= 96 && rewardFee <= 100, 'MOLStaker: reward fee should be in 96 ~ 100.' );
_rewardFee = rewardFee;
return true;
}
} | getRewardPortion | function getRewardPortion() external view returns (uint256) {
return _rewardPortion;
}
| /**
* Get rewards portion
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://368314f4777f190274441dfdebb1eaf8c259afa185c786922a40e946fdd52269 | {
"func_code_index": [
7645,
7750
]
} | 8,961 |
||
MOLStaker | MOLStaker.sol | 0x04337132ec0c62cbca8640444d23496130e7ba16 | Solidity | MOLStaker | contract MOLStaker is Ownable {
using SafeMath for uint256;
MOLContract private _molContract; // mol token contract
RewardContract private _rewardContract; // reward contract
mapping (address => StakerInfo) private _stakeMap; // map for stakers
address private _devWallet; // dev wallet address
uint256 private _devLastClaimTimestamp; // dev wallet address
address[] private _stakers; // staker's array
uint256 private _totalStakedAmount = 0; // total staked amount
uint256 private _minStakeAmount = 1e18; // min stakable amount
uint256 private _rewardPortion = 10; // reward portion 10%
uint256 private _rewardFee = 98; // reward fee 98%, rest for dev 2%
uint256 private _taxFee = 3; // tax fee for transaction
struct StakerInfo {
uint256 stakedAmount;
uint256 lastClaimTimestamp;
uint256 rewardAmount;
}
// Events
event Staked(address indexed staker, uint256 amount);
event Unstaked(address indexed staker, uint256 amount);
event Claim(address indexed staker, uint256 amount);
constructor (MOLContract molContract, address devWallet) public {
_molContract = molContract;
_devWallet = devWallet;
}
function stake(uint256 amount) public {
require(
amount >= _minStakeAmount,
"MOLStaker: stake amount is less than min stake amount."
);
require(
_molContract.transferFrom(
_msgSender(),
address(this),
amount
),
"MOLStaker: stake failed."
);
uint256 taxAmount = amount.mul(_taxFee).div(100);
uint256 realStakedAmount = amount.sub(taxAmount);
uint256 currentTimestamp = uint256(now);
if(_stakers.length == 0)
_devLastClaimTimestamp = currentTimestamp;
if(_stakeMap[_msgSender()].stakedAmount == 0) {
_stakers.push(_msgSender());
_stakeMap[_msgSender()].lastClaimTimestamp = currentTimestamp;
} else {
_stakeMap[_msgSender()].rewardAmount = _stakeMap[_msgSender()].rewardAmount.add(calcReward(_msgSender(), currentTimestamp));
_stakeMap[_msgSender()].lastClaimTimestamp = currentTimestamp;
}
_stakeMap[_msgSender()].stakedAmount = _stakeMap[_msgSender()].stakedAmount.add(realStakedAmount);
_totalStakedAmount = _totalStakedAmount.add(realStakedAmount);
emit Staked(_msgSender(), realStakedAmount);
}
function unstake(uint256 amount) public {
require(
_stakeMap[_msgSender()].stakedAmount >= amount,
"MOLStaker: unstake amount exceededs the staked amount."
);
uint256 currentTimestamp = uint256(now);
_stakeMap[_msgSender()].rewardAmount = _stakeMap[_msgSender()].rewardAmount.add(calcReward(_msgSender(), currentTimestamp));
_stakeMap[_msgSender()].lastClaimTimestamp = currentTimestamp;
_stakeMap[_msgSender()].stakedAmount = _stakeMap[_msgSender()].stakedAmount.sub(amount);
_totalStakedAmount = _totalStakedAmount.sub(amount);
require(
_molContract.transfer(
_msgSender(),
amount
),
"MOLStaker: unstake failed."
);
if(_stakeMap[_msgSender()].stakedAmount == 0) {
_stakeMap[_msgSender()].lastClaimTimestamp = 0;
for(uint i=0; i<_stakers.length; i++) {
if(_stakers[i] == _msgSender()) {
_stakers[i] = _stakers[_stakers.length-1];
_stakers.pop();
break;
}
}
}
emit Unstaked(_msgSender(), amount);
}
function claim() public {
uint256 currentTimestamp = uint256(now);
uint256 rewardAmount = _stakeMap[_msgSender()].rewardAmount.add(calcReward(_msgSender(), currentTimestamp));
_stakeMap[_msgSender()].lastClaimTimestamp = currentTimestamp;
require(
_rewardContract.giveLavaReward(_msgSender(), rewardAmount),
"MOLStaker: claim failed."
);
_stakeMap[_msgSender()].rewardAmount = 0;
emit Claim(_msgSender(), rewardAmount);
if(currentTimestamp.sub(_devLastClaimTimestamp) >= 86400) {
rewardAmount = calcDevReward(currentTimestamp);
_devLastClaimTimestamp = currentTimestamp;
require(
_rewardContract.giveLavaReward(_devWallet, rewardAmount),
"MOLStaker: dev reward claim failed."
);
emit Claim(_devWallet, rewardAmount);
}
}
function endStake() external {
unstake(_stakeMap[_msgSender()].stakedAmount);
claim();
}
function calcReward(address staker, uint256 currentTimestamp) private view returns (uint256) {
if(_totalStakedAmount == 0)
return 0;
uint256 rewardPoolBalance = _rewardContract.getLavaBalance();
uint256 passTime = currentTimestamp.sub(_stakeMap[staker].lastClaimTimestamp);
uint256 rewardAmountForStakers = rewardPoolBalance.mul(_rewardPortion).div(100).mul(_rewardFee).div(100);
uint256 rewardAmount = rewardAmountForStakers.mul(passTime).div(86400).mul(_stakeMap[staker].stakedAmount).div(_totalStakedAmount);
return rewardAmount;
}
function calcDevReward(uint256 currentTimestamp) private view returns (uint256) {
uint256 rewardPoolBalance = _rewardContract.getLavaBalance();
uint256 passTime = currentTimestamp.sub(_devLastClaimTimestamp);
uint256 rewardAmount = rewardPoolBalance.mul(_rewardPortion).div(100).mul(uint256(100).sub(_rewardFee)).div(100).mul(passTime).div(86400);
return rewardAmount;
}
/**
* Get store wallet
*/
function getRewardContract() external view returns (address) {
return address(_rewardContract);
}
/**
* Get total staked amount
*/
function getTotalStakedAmount() external view returns (uint256) {
return _totalStakedAmount;
}
/**
* Get reward amount of staker
*/
function getReward(address staker) external view returns (uint256) {
return _stakeMap[staker].rewardAmount.add(calcReward(staker, now));
}
/**
* Get reward pool balance (LAVA)
*/
function getRewardPoolBalance() external view returns (uint256) {
return _rewardContract.getLavaBalance();
}
/**
* Get last claim timestamp
*/
function getLastClaimTimestamp(address staker) external view returns (uint256) {
return _stakeMap[staker].lastClaimTimestamp;
}
/**
* Get staked amount of staker
*/
function getStakedAmount(address staker) external view returns (uint256) {
return _stakeMap[staker].stakedAmount;
}
/**
* Get min stake amount
*/
function getMinStakeAmount() external view returns (uint256) {
return _minStakeAmount;
}
/**
* Get rewards portion
*/
function getRewardPortion() external view returns (uint256) {
return _rewardPortion;
}
/**
* Get staker count
*/
function getStakerCount() external view returns (uint256) {
return _stakers.length;
}
/**
* Get rewards fee
*/
function getRewardFee() external view returns (uint256) {
return _rewardFee;
}
/**
* Get staked rank
*/
function getStakedRank(address staker) external view returns (uint256) {
uint256 rank = 1;
uint256 senderStakedAmount = _stakeMap[staker].stakedAmount;
for(uint i=0; i<_stakers.length; i++) {
if(_stakers[i] != staker && senderStakedAmount < _stakeMap[_stakers[i]].stakedAmount)
rank = rank.add(1);
}
return rank;
}
/**
* Set store wallet contract address
*/
function setRewardContract(RewardContract rewardContract) external onlyOwner returns (bool) {
require(address(rewardContract) != address(0), 'MOLStaker: reward contract address should not be zero address.');
_rewardContract = rewardContract;
return true;
}
/**
* Set rewards portion in store balance.
* ex: 10 => 10%
*/
function setRewardPortion(uint256 rewardPortion) external onlyOwner returns (bool) {
require(rewardPortion >= 10 && rewardPortion <= 100, 'MOLStaker: reward portion should be in 10 ~ 100.');
_rewardPortion = rewardPortion;
return true;
}
/**
* Set rewards portion for stakers in rewards amount.
* ex: 98 => 98% (2% for dev)
*/
function setRewardFee(uint256 rewardFee) external onlyOwner returns (bool) {
require(rewardFee >= 96 && rewardFee <= 100, 'MOLStaker: reward fee should be in 96 ~ 100.' );
_rewardFee = rewardFee;
return true;
}
} | getStakerCount | function getStakerCount() external view returns (uint256) {
return _stakers.length;
}
| /**
* Get staker count
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://368314f4777f190274441dfdebb1eaf8c259afa185c786922a40e946fdd52269 | {
"func_code_index": [
7800,
7904
]
} | 8,962 |
||
MOLStaker | MOLStaker.sol | 0x04337132ec0c62cbca8640444d23496130e7ba16 | Solidity | MOLStaker | contract MOLStaker is Ownable {
using SafeMath for uint256;
MOLContract private _molContract; // mol token contract
RewardContract private _rewardContract; // reward contract
mapping (address => StakerInfo) private _stakeMap; // map for stakers
address private _devWallet; // dev wallet address
uint256 private _devLastClaimTimestamp; // dev wallet address
address[] private _stakers; // staker's array
uint256 private _totalStakedAmount = 0; // total staked amount
uint256 private _minStakeAmount = 1e18; // min stakable amount
uint256 private _rewardPortion = 10; // reward portion 10%
uint256 private _rewardFee = 98; // reward fee 98%, rest for dev 2%
uint256 private _taxFee = 3; // tax fee for transaction
struct StakerInfo {
uint256 stakedAmount;
uint256 lastClaimTimestamp;
uint256 rewardAmount;
}
// Events
event Staked(address indexed staker, uint256 amount);
event Unstaked(address indexed staker, uint256 amount);
event Claim(address indexed staker, uint256 amount);
constructor (MOLContract molContract, address devWallet) public {
_molContract = molContract;
_devWallet = devWallet;
}
function stake(uint256 amount) public {
require(
amount >= _minStakeAmount,
"MOLStaker: stake amount is less than min stake amount."
);
require(
_molContract.transferFrom(
_msgSender(),
address(this),
amount
),
"MOLStaker: stake failed."
);
uint256 taxAmount = amount.mul(_taxFee).div(100);
uint256 realStakedAmount = amount.sub(taxAmount);
uint256 currentTimestamp = uint256(now);
if(_stakers.length == 0)
_devLastClaimTimestamp = currentTimestamp;
if(_stakeMap[_msgSender()].stakedAmount == 0) {
_stakers.push(_msgSender());
_stakeMap[_msgSender()].lastClaimTimestamp = currentTimestamp;
} else {
_stakeMap[_msgSender()].rewardAmount = _stakeMap[_msgSender()].rewardAmount.add(calcReward(_msgSender(), currentTimestamp));
_stakeMap[_msgSender()].lastClaimTimestamp = currentTimestamp;
}
_stakeMap[_msgSender()].stakedAmount = _stakeMap[_msgSender()].stakedAmount.add(realStakedAmount);
_totalStakedAmount = _totalStakedAmount.add(realStakedAmount);
emit Staked(_msgSender(), realStakedAmount);
}
function unstake(uint256 amount) public {
require(
_stakeMap[_msgSender()].stakedAmount >= amount,
"MOLStaker: unstake amount exceededs the staked amount."
);
uint256 currentTimestamp = uint256(now);
_stakeMap[_msgSender()].rewardAmount = _stakeMap[_msgSender()].rewardAmount.add(calcReward(_msgSender(), currentTimestamp));
_stakeMap[_msgSender()].lastClaimTimestamp = currentTimestamp;
_stakeMap[_msgSender()].stakedAmount = _stakeMap[_msgSender()].stakedAmount.sub(amount);
_totalStakedAmount = _totalStakedAmount.sub(amount);
require(
_molContract.transfer(
_msgSender(),
amount
),
"MOLStaker: unstake failed."
);
if(_stakeMap[_msgSender()].stakedAmount == 0) {
_stakeMap[_msgSender()].lastClaimTimestamp = 0;
for(uint i=0; i<_stakers.length; i++) {
if(_stakers[i] == _msgSender()) {
_stakers[i] = _stakers[_stakers.length-1];
_stakers.pop();
break;
}
}
}
emit Unstaked(_msgSender(), amount);
}
function claim() public {
uint256 currentTimestamp = uint256(now);
uint256 rewardAmount = _stakeMap[_msgSender()].rewardAmount.add(calcReward(_msgSender(), currentTimestamp));
_stakeMap[_msgSender()].lastClaimTimestamp = currentTimestamp;
require(
_rewardContract.giveLavaReward(_msgSender(), rewardAmount),
"MOLStaker: claim failed."
);
_stakeMap[_msgSender()].rewardAmount = 0;
emit Claim(_msgSender(), rewardAmount);
if(currentTimestamp.sub(_devLastClaimTimestamp) >= 86400) {
rewardAmount = calcDevReward(currentTimestamp);
_devLastClaimTimestamp = currentTimestamp;
require(
_rewardContract.giveLavaReward(_devWallet, rewardAmount),
"MOLStaker: dev reward claim failed."
);
emit Claim(_devWallet, rewardAmount);
}
}
function endStake() external {
unstake(_stakeMap[_msgSender()].stakedAmount);
claim();
}
function calcReward(address staker, uint256 currentTimestamp) private view returns (uint256) {
if(_totalStakedAmount == 0)
return 0;
uint256 rewardPoolBalance = _rewardContract.getLavaBalance();
uint256 passTime = currentTimestamp.sub(_stakeMap[staker].lastClaimTimestamp);
uint256 rewardAmountForStakers = rewardPoolBalance.mul(_rewardPortion).div(100).mul(_rewardFee).div(100);
uint256 rewardAmount = rewardAmountForStakers.mul(passTime).div(86400).mul(_stakeMap[staker].stakedAmount).div(_totalStakedAmount);
return rewardAmount;
}
function calcDevReward(uint256 currentTimestamp) private view returns (uint256) {
uint256 rewardPoolBalance = _rewardContract.getLavaBalance();
uint256 passTime = currentTimestamp.sub(_devLastClaimTimestamp);
uint256 rewardAmount = rewardPoolBalance.mul(_rewardPortion).div(100).mul(uint256(100).sub(_rewardFee)).div(100).mul(passTime).div(86400);
return rewardAmount;
}
/**
* Get store wallet
*/
function getRewardContract() external view returns (address) {
return address(_rewardContract);
}
/**
* Get total staked amount
*/
function getTotalStakedAmount() external view returns (uint256) {
return _totalStakedAmount;
}
/**
* Get reward amount of staker
*/
function getReward(address staker) external view returns (uint256) {
return _stakeMap[staker].rewardAmount.add(calcReward(staker, now));
}
/**
* Get reward pool balance (LAVA)
*/
function getRewardPoolBalance() external view returns (uint256) {
return _rewardContract.getLavaBalance();
}
/**
* Get last claim timestamp
*/
function getLastClaimTimestamp(address staker) external view returns (uint256) {
return _stakeMap[staker].lastClaimTimestamp;
}
/**
* Get staked amount of staker
*/
function getStakedAmount(address staker) external view returns (uint256) {
return _stakeMap[staker].stakedAmount;
}
/**
* Get min stake amount
*/
function getMinStakeAmount() external view returns (uint256) {
return _minStakeAmount;
}
/**
* Get rewards portion
*/
function getRewardPortion() external view returns (uint256) {
return _rewardPortion;
}
/**
* Get staker count
*/
function getStakerCount() external view returns (uint256) {
return _stakers.length;
}
/**
* Get rewards fee
*/
function getRewardFee() external view returns (uint256) {
return _rewardFee;
}
/**
* Get staked rank
*/
function getStakedRank(address staker) external view returns (uint256) {
uint256 rank = 1;
uint256 senderStakedAmount = _stakeMap[staker].stakedAmount;
for(uint i=0; i<_stakers.length; i++) {
if(_stakers[i] != staker && senderStakedAmount < _stakeMap[_stakers[i]].stakedAmount)
rank = rank.add(1);
}
return rank;
}
/**
* Set store wallet contract address
*/
function setRewardContract(RewardContract rewardContract) external onlyOwner returns (bool) {
require(address(rewardContract) != address(0), 'MOLStaker: reward contract address should not be zero address.');
_rewardContract = rewardContract;
return true;
}
/**
* Set rewards portion in store balance.
* ex: 10 => 10%
*/
function setRewardPortion(uint256 rewardPortion) external onlyOwner returns (bool) {
require(rewardPortion >= 10 && rewardPortion <= 100, 'MOLStaker: reward portion should be in 10 ~ 100.');
_rewardPortion = rewardPortion;
return true;
}
/**
* Set rewards portion for stakers in rewards amount.
* ex: 98 => 98% (2% for dev)
*/
function setRewardFee(uint256 rewardFee) external onlyOwner returns (bool) {
require(rewardFee >= 96 && rewardFee <= 100, 'MOLStaker: reward fee should be in 96 ~ 100.' );
_rewardFee = rewardFee;
return true;
}
} | getRewardFee | function getRewardFee() external view returns (uint256) {
return _rewardFee;
}
| /**
* Get rewards fee
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://368314f4777f190274441dfdebb1eaf8c259afa185c786922a40e946fdd52269 | {
"func_code_index": [
7954,
8051
]
} | 8,963 |
||
MOLStaker | MOLStaker.sol | 0x04337132ec0c62cbca8640444d23496130e7ba16 | Solidity | MOLStaker | contract MOLStaker is Ownable {
using SafeMath for uint256;
MOLContract private _molContract; // mol token contract
RewardContract private _rewardContract; // reward contract
mapping (address => StakerInfo) private _stakeMap; // map for stakers
address private _devWallet; // dev wallet address
uint256 private _devLastClaimTimestamp; // dev wallet address
address[] private _stakers; // staker's array
uint256 private _totalStakedAmount = 0; // total staked amount
uint256 private _minStakeAmount = 1e18; // min stakable amount
uint256 private _rewardPortion = 10; // reward portion 10%
uint256 private _rewardFee = 98; // reward fee 98%, rest for dev 2%
uint256 private _taxFee = 3; // tax fee for transaction
struct StakerInfo {
uint256 stakedAmount;
uint256 lastClaimTimestamp;
uint256 rewardAmount;
}
// Events
event Staked(address indexed staker, uint256 amount);
event Unstaked(address indexed staker, uint256 amount);
event Claim(address indexed staker, uint256 amount);
constructor (MOLContract molContract, address devWallet) public {
_molContract = molContract;
_devWallet = devWallet;
}
function stake(uint256 amount) public {
require(
amount >= _minStakeAmount,
"MOLStaker: stake amount is less than min stake amount."
);
require(
_molContract.transferFrom(
_msgSender(),
address(this),
amount
),
"MOLStaker: stake failed."
);
uint256 taxAmount = amount.mul(_taxFee).div(100);
uint256 realStakedAmount = amount.sub(taxAmount);
uint256 currentTimestamp = uint256(now);
if(_stakers.length == 0)
_devLastClaimTimestamp = currentTimestamp;
if(_stakeMap[_msgSender()].stakedAmount == 0) {
_stakers.push(_msgSender());
_stakeMap[_msgSender()].lastClaimTimestamp = currentTimestamp;
} else {
_stakeMap[_msgSender()].rewardAmount = _stakeMap[_msgSender()].rewardAmount.add(calcReward(_msgSender(), currentTimestamp));
_stakeMap[_msgSender()].lastClaimTimestamp = currentTimestamp;
}
_stakeMap[_msgSender()].stakedAmount = _stakeMap[_msgSender()].stakedAmount.add(realStakedAmount);
_totalStakedAmount = _totalStakedAmount.add(realStakedAmount);
emit Staked(_msgSender(), realStakedAmount);
}
function unstake(uint256 amount) public {
require(
_stakeMap[_msgSender()].stakedAmount >= amount,
"MOLStaker: unstake amount exceededs the staked amount."
);
uint256 currentTimestamp = uint256(now);
_stakeMap[_msgSender()].rewardAmount = _stakeMap[_msgSender()].rewardAmount.add(calcReward(_msgSender(), currentTimestamp));
_stakeMap[_msgSender()].lastClaimTimestamp = currentTimestamp;
_stakeMap[_msgSender()].stakedAmount = _stakeMap[_msgSender()].stakedAmount.sub(amount);
_totalStakedAmount = _totalStakedAmount.sub(amount);
require(
_molContract.transfer(
_msgSender(),
amount
),
"MOLStaker: unstake failed."
);
if(_stakeMap[_msgSender()].stakedAmount == 0) {
_stakeMap[_msgSender()].lastClaimTimestamp = 0;
for(uint i=0; i<_stakers.length; i++) {
if(_stakers[i] == _msgSender()) {
_stakers[i] = _stakers[_stakers.length-1];
_stakers.pop();
break;
}
}
}
emit Unstaked(_msgSender(), amount);
}
function claim() public {
uint256 currentTimestamp = uint256(now);
uint256 rewardAmount = _stakeMap[_msgSender()].rewardAmount.add(calcReward(_msgSender(), currentTimestamp));
_stakeMap[_msgSender()].lastClaimTimestamp = currentTimestamp;
require(
_rewardContract.giveLavaReward(_msgSender(), rewardAmount),
"MOLStaker: claim failed."
);
_stakeMap[_msgSender()].rewardAmount = 0;
emit Claim(_msgSender(), rewardAmount);
if(currentTimestamp.sub(_devLastClaimTimestamp) >= 86400) {
rewardAmount = calcDevReward(currentTimestamp);
_devLastClaimTimestamp = currentTimestamp;
require(
_rewardContract.giveLavaReward(_devWallet, rewardAmount),
"MOLStaker: dev reward claim failed."
);
emit Claim(_devWallet, rewardAmount);
}
}
function endStake() external {
unstake(_stakeMap[_msgSender()].stakedAmount);
claim();
}
function calcReward(address staker, uint256 currentTimestamp) private view returns (uint256) {
if(_totalStakedAmount == 0)
return 0;
uint256 rewardPoolBalance = _rewardContract.getLavaBalance();
uint256 passTime = currentTimestamp.sub(_stakeMap[staker].lastClaimTimestamp);
uint256 rewardAmountForStakers = rewardPoolBalance.mul(_rewardPortion).div(100).mul(_rewardFee).div(100);
uint256 rewardAmount = rewardAmountForStakers.mul(passTime).div(86400).mul(_stakeMap[staker].stakedAmount).div(_totalStakedAmount);
return rewardAmount;
}
function calcDevReward(uint256 currentTimestamp) private view returns (uint256) {
uint256 rewardPoolBalance = _rewardContract.getLavaBalance();
uint256 passTime = currentTimestamp.sub(_devLastClaimTimestamp);
uint256 rewardAmount = rewardPoolBalance.mul(_rewardPortion).div(100).mul(uint256(100).sub(_rewardFee)).div(100).mul(passTime).div(86400);
return rewardAmount;
}
/**
* Get store wallet
*/
function getRewardContract() external view returns (address) {
return address(_rewardContract);
}
/**
* Get total staked amount
*/
function getTotalStakedAmount() external view returns (uint256) {
return _totalStakedAmount;
}
/**
* Get reward amount of staker
*/
function getReward(address staker) external view returns (uint256) {
return _stakeMap[staker].rewardAmount.add(calcReward(staker, now));
}
/**
* Get reward pool balance (LAVA)
*/
function getRewardPoolBalance() external view returns (uint256) {
return _rewardContract.getLavaBalance();
}
/**
* Get last claim timestamp
*/
function getLastClaimTimestamp(address staker) external view returns (uint256) {
return _stakeMap[staker].lastClaimTimestamp;
}
/**
* Get staked amount of staker
*/
function getStakedAmount(address staker) external view returns (uint256) {
return _stakeMap[staker].stakedAmount;
}
/**
* Get min stake amount
*/
function getMinStakeAmount() external view returns (uint256) {
return _minStakeAmount;
}
/**
* Get rewards portion
*/
function getRewardPortion() external view returns (uint256) {
return _rewardPortion;
}
/**
* Get staker count
*/
function getStakerCount() external view returns (uint256) {
return _stakers.length;
}
/**
* Get rewards fee
*/
function getRewardFee() external view returns (uint256) {
return _rewardFee;
}
/**
* Get staked rank
*/
function getStakedRank(address staker) external view returns (uint256) {
uint256 rank = 1;
uint256 senderStakedAmount = _stakeMap[staker].stakedAmount;
for(uint i=0; i<_stakers.length; i++) {
if(_stakers[i] != staker && senderStakedAmount < _stakeMap[_stakers[i]].stakedAmount)
rank = rank.add(1);
}
return rank;
}
/**
* Set store wallet contract address
*/
function setRewardContract(RewardContract rewardContract) external onlyOwner returns (bool) {
require(address(rewardContract) != address(0), 'MOLStaker: reward contract address should not be zero address.');
_rewardContract = rewardContract;
return true;
}
/**
* Set rewards portion in store balance.
* ex: 10 => 10%
*/
function setRewardPortion(uint256 rewardPortion) external onlyOwner returns (bool) {
require(rewardPortion >= 10 && rewardPortion <= 100, 'MOLStaker: reward portion should be in 10 ~ 100.');
_rewardPortion = rewardPortion;
return true;
}
/**
* Set rewards portion for stakers in rewards amount.
* ex: 98 => 98% (2% for dev)
*/
function setRewardFee(uint256 rewardFee) external onlyOwner returns (bool) {
require(rewardFee >= 96 && rewardFee <= 100, 'MOLStaker: reward fee should be in 96 ~ 100.' );
_rewardFee = rewardFee;
return true;
}
} | getStakedRank | function getStakedRank(address staker) external view returns (uint256) {
uint256 rank = 1;
uint256 senderStakedAmount = _stakeMap[staker].stakedAmount;
for(uint i=0; i<_stakers.length; i++) {
if(_stakers[i] != staker && senderStakedAmount < _stakeMap[_stakers[i]].stakedAmount)
rank = rank.add(1);
}
return rank;
}
| /**
* Get staked rank
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://368314f4777f190274441dfdebb1eaf8c259afa185c786922a40e946fdd52269 | {
"func_code_index": [
8100,
8509
]
} | 8,964 |
||
MOLStaker | MOLStaker.sol | 0x04337132ec0c62cbca8640444d23496130e7ba16 | Solidity | MOLStaker | contract MOLStaker is Ownable {
using SafeMath for uint256;
MOLContract private _molContract; // mol token contract
RewardContract private _rewardContract; // reward contract
mapping (address => StakerInfo) private _stakeMap; // map for stakers
address private _devWallet; // dev wallet address
uint256 private _devLastClaimTimestamp; // dev wallet address
address[] private _stakers; // staker's array
uint256 private _totalStakedAmount = 0; // total staked amount
uint256 private _minStakeAmount = 1e18; // min stakable amount
uint256 private _rewardPortion = 10; // reward portion 10%
uint256 private _rewardFee = 98; // reward fee 98%, rest for dev 2%
uint256 private _taxFee = 3; // tax fee for transaction
struct StakerInfo {
uint256 stakedAmount;
uint256 lastClaimTimestamp;
uint256 rewardAmount;
}
// Events
event Staked(address indexed staker, uint256 amount);
event Unstaked(address indexed staker, uint256 amount);
event Claim(address indexed staker, uint256 amount);
constructor (MOLContract molContract, address devWallet) public {
_molContract = molContract;
_devWallet = devWallet;
}
function stake(uint256 amount) public {
require(
amount >= _minStakeAmount,
"MOLStaker: stake amount is less than min stake amount."
);
require(
_molContract.transferFrom(
_msgSender(),
address(this),
amount
),
"MOLStaker: stake failed."
);
uint256 taxAmount = amount.mul(_taxFee).div(100);
uint256 realStakedAmount = amount.sub(taxAmount);
uint256 currentTimestamp = uint256(now);
if(_stakers.length == 0)
_devLastClaimTimestamp = currentTimestamp;
if(_stakeMap[_msgSender()].stakedAmount == 0) {
_stakers.push(_msgSender());
_stakeMap[_msgSender()].lastClaimTimestamp = currentTimestamp;
} else {
_stakeMap[_msgSender()].rewardAmount = _stakeMap[_msgSender()].rewardAmount.add(calcReward(_msgSender(), currentTimestamp));
_stakeMap[_msgSender()].lastClaimTimestamp = currentTimestamp;
}
_stakeMap[_msgSender()].stakedAmount = _stakeMap[_msgSender()].stakedAmount.add(realStakedAmount);
_totalStakedAmount = _totalStakedAmount.add(realStakedAmount);
emit Staked(_msgSender(), realStakedAmount);
}
function unstake(uint256 amount) public {
require(
_stakeMap[_msgSender()].stakedAmount >= amount,
"MOLStaker: unstake amount exceededs the staked amount."
);
uint256 currentTimestamp = uint256(now);
_stakeMap[_msgSender()].rewardAmount = _stakeMap[_msgSender()].rewardAmount.add(calcReward(_msgSender(), currentTimestamp));
_stakeMap[_msgSender()].lastClaimTimestamp = currentTimestamp;
_stakeMap[_msgSender()].stakedAmount = _stakeMap[_msgSender()].stakedAmount.sub(amount);
_totalStakedAmount = _totalStakedAmount.sub(amount);
require(
_molContract.transfer(
_msgSender(),
amount
),
"MOLStaker: unstake failed."
);
if(_stakeMap[_msgSender()].stakedAmount == 0) {
_stakeMap[_msgSender()].lastClaimTimestamp = 0;
for(uint i=0; i<_stakers.length; i++) {
if(_stakers[i] == _msgSender()) {
_stakers[i] = _stakers[_stakers.length-1];
_stakers.pop();
break;
}
}
}
emit Unstaked(_msgSender(), amount);
}
function claim() public {
uint256 currentTimestamp = uint256(now);
uint256 rewardAmount = _stakeMap[_msgSender()].rewardAmount.add(calcReward(_msgSender(), currentTimestamp));
_stakeMap[_msgSender()].lastClaimTimestamp = currentTimestamp;
require(
_rewardContract.giveLavaReward(_msgSender(), rewardAmount),
"MOLStaker: claim failed."
);
_stakeMap[_msgSender()].rewardAmount = 0;
emit Claim(_msgSender(), rewardAmount);
if(currentTimestamp.sub(_devLastClaimTimestamp) >= 86400) {
rewardAmount = calcDevReward(currentTimestamp);
_devLastClaimTimestamp = currentTimestamp;
require(
_rewardContract.giveLavaReward(_devWallet, rewardAmount),
"MOLStaker: dev reward claim failed."
);
emit Claim(_devWallet, rewardAmount);
}
}
function endStake() external {
unstake(_stakeMap[_msgSender()].stakedAmount);
claim();
}
function calcReward(address staker, uint256 currentTimestamp) private view returns (uint256) {
if(_totalStakedAmount == 0)
return 0;
uint256 rewardPoolBalance = _rewardContract.getLavaBalance();
uint256 passTime = currentTimestamp.sub(_stakeMap[staker].lastClaimTimestamp);
uint256 rewardAmountForStakers = rewardPoolBalance.mul(_rewardPortion).div(100).mul(_rewardFee).div(100);
uint256 rewardAmount = rewardAmountForStakers.mul(passTime).div(86400).mul(_stakeMap[staker].stakedAmount).div(_totalStakedAmount);
return rewardAmount;
}
function calcDevReward(uint256 currentTimestamp) private view returns (uint256) {
uint256 rewardPoolBalance = _rewardContract.getLavaBalance();
uint256 passTime = currentTimestamp.sub(_devLastClaimTimestamp);
uint256 rewardAmount = rewardPoolBalance.mul(_rewardPortion).div(100).mul(uint256(100).sub(_rewardFee)).div(100).mul(passTime).div(86400);
return rewardAmount;
}
/**
* Get store wallet
*/
function getRewardContract() external view returns (address) {
return address(_rewardContract);
}
/**
* Get total staked amount
*/
function getTotalStakedAmount() external view returns (uint256) {
return _totalStakedAmount;
}
/**
* Get reward amount of staker
*/
function getReward(address staker) external view returns (uint256) {
return _stakeMap[staker].rewardAmount.add(calcReward(staker, now));
}
/**
* Get reward pool balance (LAVA)
*/
function getRewardPoolBalance() external view returns (uint256) {
return _rewardContract.getLavaBalance();
}
/**
* Get last claim timestamp
*/
function getLastClaimTimestamp(address staker) external view returns (uint256) {
return _stakeMap[staker].lastClaimTimestamp;
}
/**
* Get staked amount of staker
*/
function getStakedAmount(address staker) external view returns (uint256) {
return _stakeMap[staker].stakedAmount;
}
/**
* Get min stake amount
*/
function getMinStakeAmount() external view returns (uint256) {
return _minStakeAmount;
}
/**
* Get rewards portion
*/
function getRewardPortion() external view returns (uint256) {
return _rewardPortion;
}
/**
* Get staker count
*/
function getStakerCount() external view returns (uint256) {
return _stakers.length;
}
/**
* Get rewards fee
*/
function getRewardFee() external view returns (uint256) {
return _rewardFee;
}
/**
* Get staked rank
*/
function getStakedRank(address staker) external view returns (uint256) {
uint256 rank = 1;
uint256 senderStakedAmount = _stakeMap[staker].stakedAmount;
for(uint i=0; i<_stakers.length; i++) {
if(_stakers[i] != staker && senderStakedAmount < _stakeMap[_stakers[i]].stakedAmount)
rank = rank.add(1);
}
return rank;
}
/**
* Set store wallet contract address
*/
function setRewardContract(RewardContract rewardContract) external onlyOwner returns (bool) {
require(address(rewardContract) != address(0), 'MOLStaker: reward contract address should not be zero address.');
_rewardContract = rewardContract;
return true;
}
/**
* Set rewards portion in store balance.
* ex: 10 => 10%
*/
function setRewardPortion(uint256 rewardPortion) external onlyOwner returns (bool) {
require(rewardPortion >= 10 && rewardPortion <= 100, 'MOLStaker: reward portion should be in 10 ~ 100.');
_rewardPortion = rewardPortion;
return true;
}
/**
* Set rewards portion for stakers in rewards amount.
* ex: 98 => 98% (2% for dev)
*/
function setRewardFee(uint256 rewardFee) external onlyOwner returns (bool) {
require(rewardFee >= 96 && rewardFee <= 100, 'MOLStaker: reward fee should be in 96 ~ 100.' );
_rewardFee = rewardFee;
return true;
}
} | setRewardContract | function setRewardContract(RewardContract rewardContract) external onlyOwner returns (bool) {
require(address(rewardContract) != address(0), 'MOLStaker: reward contract address should not be zero address.');
_rewardContract = rewardContract;
return true;
}
| /**
* Set store wallet contract address
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://368314f4777f190274441dfdebb1eaf8c259afa185c786922a40e946fdd52269 | {
"func_code_index": [
8576,
8871
]
} | 8,965 |
||
MOLStaker | MOLStaker.sol | 0x04337132ec0c62cbca8640444d23496130e7ba16 | Solidity | MOLStaker | contract MOLStaker is Ownable {
using SafeMath for uint256;
MOLContract private _molContract; // mol token contract
RewardContract private _rewardContract; // reward contract
mapping (address => StakerInfo) private _stakeMap; // map for stakers
address private _devWallet; // dev wallet address
uint256 private _devLastClaimTimestamp; // dev wallet address
address[] private _stakers; // staker's array
uint256 private _totalStakedAmount = 0; // total staked amount
uint256 private _minStakeAmount = 1e18; // min stakable amount
uint256 private _rewardPortion = 10; // reward portion 10%
uint256 private _rewardFee = 98; // reward fee 98%, rest for dev 2%
uint256 private _taxFee = 3; // tax fee for transaction
struct StakerInfo {
uint256 stakedAmount;
uint256 lastClaimTimestamp;
uint256 rewardAmount;
}
// Events
event Staked(address indexed staker, uint256 amount);
event Unstaked(address indexed staker, uint256 amount);
event Claim(address indexed staker, uint256 amount);
constructor (MOLContract molContract, address devWallet) public {
_molContract = molContract;
_devWallet = devWallet;
}
function stake(uint256 amount) public {
require(
amount >= _minStakeAmount,
"MOLStaker: stake amount is less than min stake amount."
);
require(
_molContract.transferFrom(
_msgSender(),
address(this),
amount
),
"MOLStaker: stake failed."
);
uint256 taxAmount = amount.mul(_taxFee).div(100);
uint256 realStakedAmount = amount.sub(taxAmount);
uint256 currentTimestamp = uint256(now);
if(_stakers.length == 0)
_devLastClaimTimestamp = currentTimestamp;
if(_stakeMap[_msgSender()].stakedAmount == 0) {
_stakers.push(_msgSender());
_stakeMap[_msgSender()].lastClaimTimestamp = currentTimestamp;
} else {
_stakeMap[_msgSender()].rewardAmount = _stakeMap[_msgSender()].rewardAmount.add(calcReward(_msgSender(), currentTimestamp));
_stakeMap[_msgSender()].lastClaimTimestamp = currentTimestamp;
}
_stakeMap[_msgSender()].stakedAmount = _stakeMap[_msgSender()].stakedAmount.add(realStakedAmount);
_totalStakedAmount = _totalStakedAmount.add(realStakedAmount);
emit Staked(_msgSender(), realStakedAmount);
}
function unstake(uint256 amount) public {
require(
_stakeMap[_msgSender()].stakedAmount >= amount,
"MOLStaker: unstake amount exceededs the staked amount."
);
uint256 currentTimestamp = uint256(now);
_stakeMap[_msgSender()].rewardAmount = _stakeMap[_msgSender()].rewardAmount.add(calcReward(_msgSender(), currentTimestamp));
_stakeMap[_msgSender()].lastClaimTimestamp = currentTimestamp;
_stakeMap[_msgSender()].stakedAmount = _stakeMap[_msgSender()].stakedAmount.sub(amount);
_totalStakedAmount = _totalStakedAmount.sub(amount);
require(
_molContract.transfer(
_msgSender(),
amount
),
"MOLStaker: unstake failed."
);
if(_stakeMap[_msgSender()].stakedAmount == 0) {
_stakeMap[_msgSender()].lastClaimTimestamp = 0;
for(uint i=0; i<_stakers.length; i++) {
if(_stakers[i] == _msgSender()) {
_stakers[i] = _stakers[_stakers.length-1];
_stakers.pop();
break;
}
}
}
emit Unstaked(_msgSender(), amount);
}
function claim() public {
uint256 currentTimestamp = uint256(now);
uint256 rewardAmount = _stakeMap[_msgSender()].rewardAmount.add(calcReward(_msgSender(), currentTimestamp));
_stakeMap[_msgSender()].lastClaimTimestamp = currentTimestamp;
require(
_rewardContract.giveLavaReward(_msgSender(), rewardAmount),
"MOLStaker: claim failed."
);
_stakeMap[_msgSender()].rewardAmount = 0;
emit Claim(_msgSender(), rewardAmount);
if(currentTimestamp.sub(_devLastClaimTimestamp) >= 86400) {
rewardAmount = calcDevReward(currentTimestamp);
_devLastClaimTimestamp = currentTimestamp;
require(
_rewardContract.giveLavaReward(_devWallet, rewardAmount),
"MOLStaker: dev reward claim failed."
);
emit Claim(_devWallet, rewardAmount);
}
}
function endStake() external {
unstake(_stakeMap[_msgSender()].stakedAmount);
claim();
}
function calcReward(address staker, uint256 currentTimestamp) private view returns (uint256) {
if(_totalStakedAmount == 0)
return 0;
uint256 rewardPoolBalance = _rewardContract.getLavaBalance();
uint256 passTime = currentTimestamp.sub(_stakeMap[staker].lastClaimTimestamp);
uint256 rewardAmountForStakers = rewardPoolBalance.mul(_rewardPortion).div(100).mul(_rewardFee).div(100);
uint256 rewardAmount = rewardAmountForStakers.mul(passTime).div(86400).mul(_stakeMap[staker].stakedAmount).div(_totalStakedAmount);
return rewardAmount;
}
function calcDevReward(uint256 currentTimestamp) private view returns (uint256) {
uint256 rewardPoolBalance = _rewardContract.getLavaBalance();
uint256 passTime = currentTimestamp.sub(_devLastClaimTimestamp);
uint256 rewardAmount = rewardPoolBalance.mul(_rewardPortion).div(100).mul(uint256(100).sub(_rewardFee)).div(100).mul(passTime).div(86400);
return rewardAmount;
}
/**
* Get store wallet
*/
function getRewardContract() external view returns (address) {
return address(_rewardContract);
}
/**
* Get total staked amount
*/
function getTotalStakedAmount() external view returns (uint256) {
return _totalStakedAmount;
}
/**
* Get reward amount of staker
*/
function getReward(address staker) external view returns (uint256) {
return _stakeMap[staker].rewardAmount.add(calcReward(staker, now));
}
/**
* Get reward pool balance (LAVA)
*/
function getRewardPoolBalance() external view returns (uint256) {
return _rewardContract.getLavaBalance();
}
/**
* Get last claim timestamp
*/
function getLastClaimTimestamp(address staker) external view returns (uint256) {
return _stakeMap[staker].lastClaimTimestamp;
}
/**
* Get staked amount of staker
*/
function getStakedAmount(address staker) external view returns (uint256) {
return _stakeMap[staker].stakedAmount;
}
/**
* Get min stake amount
*/
function getMinStakeAmount() external view returns (uint256) {
return _minStakeAmount;
}
/**
* Get rewards portion
*/
function getRewardPortion() external view returns (uint256) {
return _rewardPortion;
}
/**
* Get staker count
*/
function getStakerCount() external view returns (uint256) {
return _stakers.length;
}
/**
* Get rewards fee
*/
function getRewardFee() external view returns (uint256) {
return _rewardFee;
}
/**
* Get staked rank
*/
function getStakedRank(address staker) external view returns (uint256) {
uint256 rank = 1;
uint256 senderStakedAmount = _stakeMap[staker].stakedAmount;
for(uint i=0; i<_stakers.length; i++) {
if(_stakers[i] != staker && senderStakedAmount < _stakeMap[_stakers[i]].stakedAmount)
rank = rank.add(1);
}
return rank;
}
/**
* Set store wallet contract address
*/
function setRewardContract(RewardContract rewardContract) external onlyOwner returns (bool) {
require(address(rewardContract) != address(0), 'MOLStaker: reward contract address should not be zero address.');
_rewardContract = rewardContract;
return true;
}
/**
* Set rewards portion in store balance.
* ex: 10 => 10%
*/
function setRewardPortion(uint256 rewardPortion) external onlyOwner returns (bool) {
require(rewardPortion >= 10 && rewardPortion <= 100, 'MOLStaker: reward portion should be in 10 ~ 100.');
_rewardPortion = rewardPortion;
return true;
}
/**
* Set rewards portion for stakers in rewards amount.
* ex: 98 => 98% (2% for dev)
*/
function setRewardFee(uint256 rewardFee) external onlyOwner returns (bool) {
require(rewardFee >= 96 && rewardFee <= 100, 'MOLStaker: reward fee should be in 96 ~ 100.' );
_rewardFee = rewardFee;
return true;
}
} | setRewardPortion | function setRewardPortion(uint256 rewardPortion) external onlyOwner returns (bool) {
require(rewardPortion >= 10 && rewardPortion <= 100, 'MOLStaker: reward portion should be in 10 ~ 100.');
_rewardPortion = rewardPortion;
return true;
}
| /**
* Set rewards portion in store balance.
* ex: 10 => 10%
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://368314f4777f190274441dfdebb1eaf8c259afa185c786922a40e946fdd52269 | {
"func_code_index": [
8961,
9237
]
} | 8,966 |
||
MOLStaker | MOLStaker.sol | 0x04337132ec0c62cbca8640444d23496130e7ba16 | Solidity | MOLStaker | contract MOLStaker is Ownable {
using SafeMath for uint256;
MOLContract private _molContract; // mol token contract
RewardContract private _rewardContract; // reward contract
mapping (address => StakerInfo) private _stakeMap; // map for stakers
address private _devWallet; // dev wallet address
uint256 private _devLastClaimTimestamp; // dev wallet address
address[] private _stakers; // staker's array
uint256 private _totalStakedAmount = 0; // total staked amount
uint256 private _minStakeAmount = 1e18; // min stakable amount
uint256 private _rewardPortion = 10; // reward portion 10%
uint256 private _rewardFee = 98; // reward fee 98%, rest for dev 2%
uint256 private _taxFee = 3; // tax fee for transaction
struct StakerInfo {
uint256 stakedAmount;
uint256 lastClaimTimestamp;
uint256 rewardAmount;
}
// Events
event Staked(address indexed staker, uint256 amount);
event Unstaked(address indexed staker, uint256 amount);
event Claim(address indexed staker, uint256 amount);
constructor (MOLContract molContract, address devWallet) public {
_molContract = molContract;
_devWallet = devWallet;
}
function stake(uint256 amount) public {
require(
amount >= _minStakeAmount,
"MOLStaker: stake amount is less than min stake amount."
);
require(
_molContract.transferFrom(
_msgSender(),
address(this),
amount
),
"MOLStaker: stake failed."
);
uint256 taxAmount = amount.mul(_taxFee).div(100);
uint256 realStakedAmount = amount.sub(taxAmount);
uint256 currentTimestamp = uint256(now);
if(_stakers.length == 0)
_devLastClaimTimestamp = currentTimestamp;
if(_stakeMap[_msgSender()].stakedAmount == 0) {
_stakers.push(_msgSender());
_stakeMap[_msgSender()].lastClaimTimestamp = currentTimestamp;
} else {
_stakeMap[_msgSender()].rewardAmount = _stakeMap[_msgSender()].rewardAmount.add(calcReward(_msgSender(), currentTimestamp));
_stakeMap[_msgSender()].lastClaimTimestamp = currentTimestamp;
}
_stakeMap[_msgSender()].stakedAmount = _stakeMap[_msgSender()].stakedAmount.add(realStakedAmount);
_totalStakedAmount = _totalStakedAmount.add(realStakedAmount);
emit Staked(_msgSender(), realStakedAmount);
}
function unstake(uint256 amount) public {
require(
_stakeMap[_msgSender()].stakedAmount >= amount,
"MOLStaker: unstake amount exceededs the staked amount."
);
uint256 currentTimestamp = uint256(now);
_stakeMap[_msgSender()].rewardAmount = _stakeMap[_msgSender()].rewardAmount.add(calcReward(_msgSender(), currentTimestamp));
_stakeMap[_msgSender()].lastClaimTimestamp = currentTimestamp;
_stakeMap[_msgSender()].stakedAmount = _stakeMap[_msgSender()].stakedAmount.sub(amount);
_totalStakedAmount = _totalStakedAmount.sub(amount);
require(
_molContract.transfer(
_msgSender(),
amount
),
"MOLStaker: unstake failed."
);
if(_stakeMap[_msgSender()].stakedAmount == 0) {
_stakeMap[_msgSender()].lastClaimTimestamp = 0;
for(uint i=0; i<_stakers.length; i++) {
if(_stakers[i] == _msgSender()) {
_stakers[i] = _stakers[_stakers.length-1];
_stakers.pop();
break;
}
}
}
emit Unstaked(_msgSender(), amount);
}
function claim() public {
uint256 currentTimestamp = uint256(now);
uint256 rewardAmount = _stakeMap[_msgSender()].rewardAmount.add(calcReward(_msgSender(), currentTimestamp));
_stakeMap[_msgSender()].lastClaimTimestamp = currentTimestamp;
require(
_rewardContract.giveLavaReward(_msgSender(), rewardAmount),
"MOLStaker: claim failed."
);
_stakeMap[_msgSender()].rewardAmount = 0;
emit Claim(_msgSender(), rewardAmount);
if(currentTimestamp.sub(_devLastClaimTimestamp) >= 86400) {
rewardAmount = calcDevReward(currentTimestamp);
_devLastClaimTimestamp = currentTimestamp;
require(
_rewardContract.giveLavaReward(_devWallet, rewardAmount),
"MOLStaker: dev reward claim failed."
);
emit Claim(_devWallet, rewardAmount);
}
}
function endStake() external {
unstake(_stakeMap[_msgSender()].stakedAmount);
claim();
}
function calcReward(address staker, uint256 currentTimestamp) private view returns (uint256) {
if(_totalStakedAmount == 0)
return 0;
uint256 rewardPoolBalance = _rewardContract.getLavaBalance();
uint256 passTime = currentTimestamp.sub(_stakeMap[staker].lastClaimTimestamp);
uint256 rewardAmountForStakers = rewardPoolBalance.mul(_rewardPortion).div(100).mul(_rewardFee).div(100);
uint256 rewardAmount = rewardAmountForStakers.mul(passTime).div(86400).mul(_stakeMap[staker].stakedAmount).div(_totalStakedAmount);
return rewardAmount;
}
function calcDevReward(uint256 currentTimestamp) private view returns (uint256) {
uint256 rewardPoolBalance = _rewardContract.getLavaBalance();
uint256 passTime = currentTimestamp.sub(_devLastClaimTimestamp);
uint256 rewardAmount = rewardPoolBalance.mul(_rewardPortion).div(100).mul(uint256(100).sub(_rewardFee)).div(100).mul(passTime).div(86400);
return rewardAmount;
}
/**
* Get store wallet
*/
function getRewardContract() external view returns (address) {
return address(_rewardContract);
}
/**
* Get total staked amount
*/
function getTotalStakedAmount() external view returns (uint256) {
return _totalStakedAmount;
}
/**
* Get reward amount of staker
*/
function getReward(address staker) external view returns (uint256) {
return _stakeMap[staker].rewardAmount.add(calcReward(staker, now));
}
/**
* Get reward pool balance (LAVA)
*/
function getRewardPoolBalance() external view returns (uint256) {
return _rewardContract.getLavaBalance();
}
/**
* Get last claim timestamp
*/
function getLastClaimTimestamp(address staker) external view returns (uint256) {
return _stakeMap[staker].lastClaimTimestamp;
}
/**
* Get staked amount of staker
*/
function getStakedAmount(address staker) external view returns (uint256) {
return _stakeMap[staker].stakedAmount;
}
/**
* Get min stake amount
*/
function getMinStakeAmount() external view returns (uint256) {
return _minStakeAmount;
}
/**
* Get rewards portion
*/
function getRewardPortion() external view returns (uint256) {
return _rewardPortion;
}
/**
* Get staker count
*/
function getStakerCount() external view returns (uint256) {
return _stakers.length;
}
/**
* Get rewards fee
*/
function getRewardFee() external view returns (uint256) {
return _rewardFee;
}
/**
* Get staked rank
*/
function getStakedRank(address staker) external view returns (uint256) {
uint256 rank = 1;
uint256 senderStakedAmount = _stakeMap[staker].stakedAmount;
for(uint i=0; i<_stakers.length; i++) {
if(_stakers[i] != staker && senderStakedAmount < _stakeMap[_stakers[i]].stakedAmount)
rank = rank.add(1);
}
return rank;
}
/**
* Set store wallet contract address
*/
function setRewardContract(RewardContract rewardContract) external onlyOwner returns (bool) {
require(address(rewardContract) != address(0), 'MOLStaker: reward contract address should not be zero address.');
_rewardContract = rewardContract;
return true;
}
/**
* Set rewards portion in store balance.
* ex: 10 => 10%
*/
function setRewardPortion(uint256 rewardPortion) external onlyOwner returns (bool) {
require(rewardPortion >= 10 && rewardPortion <= 100, 'MOLStaker: reward portion should be in 10 ~ 100.');
_rewardPortion = rewardPortion;
return true;
}
/**
* Set rewards portion for stakers in rewards amount.
* ex: 98 => 98% (2% for dev)
*/
function setRewardFee(uint256 rewardFee) external onlyOwner returns (bool) {
require(rewardFee >= 96 && rewardFee <= 100, 'MOLStaker: reward fee should be in 96 ~ 100.' );
_rewardFee = rewardFee;
return true;
}
} | setRewardFee | function setRewardFee(uint256 rewardFee) external onlyOwner returns (bool) {
require(rewardFee >= 96 && rewardFee <= 100, 'MOLStaker: reward fee should be in 96 ~ 100.' );
_rewardFee = rewardFee;
return true;
}
| /**
* Set rewards portion for stakers in rewards amount.
* ex: 98 => 98% (2% for dev)
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://368314f4777f190274441dfdebb1eaf8c259afa185c786922a40e946fdd52269 | {
"func_code_index": [
9357,
9606
]
} | 8,967 |
||
EFI | EFI.sol | 0x0fd46ba88a9439d5b421f18732a2e196c02f0989 | Solidity | Context | contract Context {
constructor () internal { }
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
} | _msgSender | function _msgSender() internal view returns (address payable) {
return msg.sender;
}
| // solhint-disable-previous-line no-empty-blocks | LineComment | v0.5.16+commit.9c3226ce | None | bzzr://2e9f41e7c5f117a52aebaa3e049b0195eb2ede796de85963a9a9460db6c0bb6c | {
"func_code_index": [
109,
212
]
} | 8,968 |
||
Resonance | Recommend.sol | 0xd87c7ef38c3eaa2a196db19a5f1338eec123bec9 | Solidity | Recommend | contract Recommend {
// -------------------- mapping ------------------------ //
mapping(address => RecommendRecord) internal recommendRecord; // record straight reward information
// -------------------- struct ------------------------ //
struct RecommendRecord {
uint256[] straightTime; // this record start time, 3 days timeout
address[] refeAddress; // referral address
uint256[] ethAmount; // this record buy eth amount
bool[] supported; // false means unsupported
}
// -------------------- variate ------------------------ //
address public resonanceAddress;
address public owner;
constructor()
public{
owner = msg.sender;
}
// -------------------- modifier ------------------------ //
modifier onlyOwner(){
require(msg.sender == owner);
_;
}
modifier onlyResonance (){
require(msg.sender == resonanceAddress);
_;
}
// -------------------- owner api ------------------------ //
function allowResonance(address _addr) public onlyOwner() {
resonanceAddress = _addr;
}
// -------------------- Resonance api ----------------//
function getRecommendByIndex(uint256 index, address userAddress)
public
view
// onlyResonance() TODO
returns (
uint256 straightTime,
address refeAddress,
uint256 ethAmount,
bool supported
)
{
straightTime = recommendRecord[userAddress].straightTime[index];
refeAddress = recommendRecord[userAddress].refeAddress[index];
ethAmount = recommendRecord[userAddress].ethAmount[index];
supported = recommendRecord[userAddress].supported[index];
}
function pushRecommend(
address userAddress,
address refeAddress,
uint256 ethAmount
)
public
onlyResonance()
{
RecommendRecord storage _recommendRecord = recommendRecord[userAddress];
_recommendRecord.straightTime.push(block.timestamp);
_recommendRecord.refeAddress.push(refeAddress);
_recommendRecord.ethAmount.push(ethAmount);
_recommendRecord.supported.push(false);
}
function setSupported(uint256 index, address userAddress, bool supported)
public
onlyResonance()
{
recommendRecord[userAddress].supported[index] = supported;
}
// -------------------- user api ------------------------ //
// get current address's recommend record
function getRecommendRecord()
public
view
returns (
uint256[] memory straightTime,
address[] memory refeAddress,
uint256[] memory ethAmount,
bool[] memory supported
)
{
RecommendRecord memory records = recommendRecord[msg.sender];
straightTime = records.straightTime;
refeAddress = records.refeAddress;
ethAmount = records.ethAmount;
supported = records.supported;
}
} | allowResonance | function allowResonance(address _addr) public onlyOwner() {
resonanceAddress = _addr;
}
| // -------------------- owner api ------------------------ // | LineComment | v0.5.1+commit.c8a2cb62 | MIT | bzzr://a1533a2259fca30289db2437294a7f22dad9225667799e7f0acc8ada85f96280 | {
"func_code_index": [
1067,
1173
]
} | 8,969 |
||
Resonance | Recommend.sol | 0xd87c7ef38c3eaa2a196db19a5f1338eec123bec9 | Solidity | Recommend | contract Recommend {
// -------------------- mapping ------------------------ //
mapping(address => RecommendRecord) internal recommendRecord; // record straight reward information
// -------------------- struct ------------------------ //
struct RecommendRecord {
uint256[] straightTime; // this record start time, 3 days timeout
address[] refeAddress; // referral address
uint256[] ethAmount; // this record buy eth amount
bool[] supported; // false means unsupported
}
// -------------------- variate ------------------------ //
address public resonanceAddress;
address public owner;
constructor()
public{
owner = msg.sender;
}
// -------------------- modifier ------------------------ //
modifier onlyOwner(){
require(msg.sender == owner);
_;
}
modifier onlyResonance (){
require(msg.sender == resonanceAddress);
_;
}
// -------------------- owner api ------------------------ //
function allowResonance(address _addr) public onlyOwner() {
resonanceAddress = _addr;
}
// -------------------- Resonance api ----------------//
function getRecommendByIndex(uint256 index, address userAddress)
public
view
// onlyResonance() TODO
returns (
uint256 straightTime,
address refeAddress,
uint256 ethAmount,
bool supported
)
{
straightTime = recommendRecord[userAddress].straightTime[index];
refeAddress = recommendRecord[userAddress].refeAddress[index];
ethAmount = recommendRecord[userAddress].ethAmount[index];
supported = recommendRecord[userAddress].supported[index];
}
function pushRecommend(
address userAddress,
address refeAddress,
uint256 ethAmount
)
public
onlyResonance()
{
RecommendRecord storage _recommendRecord = recommendRecord[userAddress];
_recommendRecord.straightTime.push(block.timestamp);
_recommendRecord.refeAddress.push(refeAddress);
_recommendRecord.ethAmount.push(ethAmount);
_recommendRecord.supported.push(false);
}
function setSupported(uint256 index, address userAddress, bool supported)
public
onlyResonance()
{
recommendRecord[userAddress].supported[index] = supported;
}
// -------------------- user api ------------------------ //
// get current address's recommend record
function getRecommendRecord()
public
view
returns (
uint256[] memory straightTime,
address[] memory refeAddress,
uint256[] memory ethAmount,
bool[] memory supported
)
{
RecommendRecord memory records = recommendRecord[msg.sender];
straightTime = records.straightTime;
refeAddress = records.refeAddress;
ethAmount = records.ethAmount;
supported = records.supported;
}
} | getRecommendByIndex | function getRecommendByIndex(uint256 index, address userAddress)
public
view
onlyResonance() TODO
returns (
uint256 straightTime,
address refeAddress,
uint256 ethAmount,
bool supported
)
{
straightTime = recommendRecord[userAddress].straightTime[index];
refeAddress = recommendRecord[userAddress].refeAddress[index];
ethAmount = recommendRecord[userAddress].ethAmount[index];
supported = recommendRecord[userAddress].supported[index];
}
| // -------------------- Resonance api ----------------// | LineComment | v0.5.1+commit.c8a2cb62 | MIT | bzzr://a1533a2259fca30289db2437294a7f22dad9225667799e7f0acc8ada85f96280 | {
"func_code_index": [
1238,
1788
]
} | 8,970 |
||
Resonance | Recommend.sol | 0xd87c7ef38c3eaa2a196db19a5f1338eec123bec9 | Solidity | Recommend | contract Recommend {
// -------------------- mapping ------------------------ //
mapping(address => RecommendRecord) internal recommendRecord; // record straight reward information
// -------------------- struct ------------------------ //
struct RecommendRecord {
uint256[] straightTime; // this record start time, 3 days timeout
address[] refeAddress; // referral address
uint256[] ethAmount; // this record buy eth amount
bool[] supported; // false means unsupported
}
// -------------------- variate ------------------------ //
address public resonanceAddress;
address public owner;
constructor()
public{
owner = msg.sender;
}
// -------------------- modifier ------------------------ //
modifier onlyOwner(){
require(msg.sender == owner);
_;
}
modifier onlyResonance (){
require(msg.sender == resonanceAddress);
_;
}
// -------------------- owner api ------------------------ //
function allowResonance(address _addr) public onlyOwner() {
resonanceAddress = _addr;
}
// -------------------- Resonance api ----------------//
function getRecommendByIndex(uint256 index, address userAddress)
public
view
// onlyResonance() TODO
returns (
uint256 straightTime,
address refeAddress,
uint256 ethAmount,
bool supported
)
{
straightTime = recommendRecord[userAddress].straightTime[index];
refeAddress = recommendRecord[userAddress].refeAddress[index];
ethAmount = recommendRecord[userAddress].ethAmount[index];
supported = recommendRecord[userAddress].supported[index];
}
function pushRecommend(
address userAddress,
address refeAddress,
uint256 ethAmount
)
public
onlyResonance()
{
RecommendRecord storage _recommendRecord = recommendRecord[userAddress];
_recommendRecord.straightTime.push(block.timestamp);
_recommendRecord.refeAddress.push(refeAddress);
_recommendRecord.ethAmount.push(ethAmount);
_recommendRecord.supported.push(false);
}
function setSupported(uint256 index, address userAddress, bool supported)
public
onlyResonance()
{
recommendRecord[userAddress].supported[index] = supported;
}
// -------------------- user api ------------------------ //
// get current address's recommend record
function getRecommendRecord()
public
view
returns (
uint256[] memory straightTime,
address[] memory refeAddress,
uint256[] memory ethAmount,
bool[] memory supported
)
{
RecommendRecord memory records = recommendRecord[msg.sender];
straightTime = records.straightTime;
refeAddress = records.refeAddress;
ethAmount = records.ethAmount;
supported = records.supported;
}
} | getRecommendRecord | function getRecommendRecord()
public
view
returns (
uint256[] memory straightTime,
address[] memory refeAddress,
uint256[] memory ethAmount,
bool[] memory supported
)
{
RecommendRecord memory records = recommendRecord[msg.sender];
straightTime = records.straightTime;
refeAddress = records.refeAddress;
ethAmount = records.ethAmount;
supported = records.supported;
}
| // -------------------- user api ------------------------ //
// get current address's recommend record | LineComment | v0.5.1+commit.c8a2cb62 | MIT | bzzr://a1533a2259fca30289db2437294a7f22dad9225667799e7f0acc8ada85f96280 | {
"func_code_index": [
2575,
3060
]
} | 8,971 |
||
MetaScyra | contracts/Blimpie/ERC721B.sol | 0xd7c57fc28f72cc8ffbd635155d924f0ac3f03f8e | Solidity | ERC721B | abstract contract ERC721B is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to owner address
address[] internal _owners;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
super.supportsInterface(interfaceId);
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: balance query for the zero address");
uint count = 0;
uint length = _owners.length;
for( uint i = 0; i < length; ++i ){
if( owner == _owners[i] ){
++count;
}
}
delete length;
return count;
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _owners[tokenId];
require(owner != address(0), "ERC721: owner query for nonexistent token");
return owner;
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
return _name;
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual override {
address owner = ERC721B.ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(
_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not owner nor approved for all"
);
_approve(to, tokenId);
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view virtual override returns (address) {
require(_exists(tokenId), "ERC721: approved query for nonexistent token");
return _tokenApprovals[tokenId];
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
require(operator != _msgSender(), "ERC721: approve to caller");
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_msgSender(), operator, approved);
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
//solhint-disable-next-line max-line-length
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_transfer(from, to, tokenId);
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_safeTransfer(from, to, tokenId, _data);
}
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* `_data` is additional data, it has no specified format and it is sent in call to `to`.
*
* This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
* implement alternative mechanisms to perform token transfer, such as signature-based.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
* and stop existing when they are burned (`_burn`).
*/
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return tokenId < _owners.length && _owners[tokenId] != address(0);
}
/**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
require(_exists(tokenId), "ERC721: operator query for nonexistent token");
address owner = ERC721B.ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
}
/**
* @dev Safely mints `tokenId` and transfers it to `to`.
*
* Requirements:
*
* - `tokenId` must not exist.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
/**
* @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
* forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
*/
function _safeMint(
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_mint(to, tokenId);
require(
_checkOnERC721Received(address(0), to, tokenId, _data),
"ERC721: transfer to non ERC721Receiver implementer"
);
}
/**
* @dev Mints `tokenId` and transfers it to `to`.
*
* WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
*
* Requirements:
*
* - `tokenId` must not exist.
* - `to` cannot be the zero address.
*
* Emits a {Transfer} event.
*/
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId);
_owners.push(to);
emit Transfer(address(0), to, tokenId);
}
/**
* @dev Destroys `tokenId`.
* The approval is cleared when the token is burned.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits a {Transfer} event.
*/
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721B.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId);
// Clear approvals
_approve(address(0), tokenId);
_owners[tokenId] = address(0);
emit Transfer(owner, address(0), tokenId);
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
require(ERC721B.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId);
// Clear approvals from the previous owner
_approve(address(0), tokenId);
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721B.ownerOf(tokenId), to, tokenId);
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
if (to.isContract()) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
return retval == IERC721Receiver.onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
/**
* @dev Hook that is called before any token transfer. This includes minting
* and burning.
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
* - When `to` is zero, ``from``'s `tokenId` will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual {}
} | /********************
* @author: Squeebo *
********************/ | NatSpecMultiLine | supportsInterface | function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
super.supportsInterface(interfaceId);
}
| /**
* @dev See {IERC165-supportsInterface}.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | MIT | ipfs://672fc76424cd92c353e6de815b9bcc53701f37d5371e3774b462983f8ad2f3fe | {
"func_code_index": [
833,
1143
]
} | 8,972 |
MetaScyra | contracts/Blimpie/ERC721B.sol | 0xd7c57fc28f72cc8ffbd635155d924f0ac3f03f8e | Solidity | ERC721B | abstract contract ERC721B is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to owner address
address[] internal _owners;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
super.supportsInterface(interfaceId);
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: balance query for the zero address");
uint count = 0;
uint length = _owners.length;
for( uint i = 0; i < length; ++i ){
if( owner == _owners[i] ){
++count;
}
}
delete length;
return count;
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _owners[tokenId];
require(owner != address(0), "ERC721: owner query for nonexistent token");
return owner;
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
return _name;
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual override {
address owner = ERC721B.ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(
_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not owner nor approved for all"
);
_approve(to, tokenId);
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view virtual override returns (address) {
require(_exists(tokenId), "ERC721: approved query for nonexistent token");
return _tokenApprovals[tokenId];
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
require(operator != _msgSender(), "ERC721: approve to caller");
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_msgSender(), operator, approved);
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
//solhint-disable-next-line max-line-length
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_transfer(from, to, tokenId);
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_safeTransfer(from, to, tokenId, _data);
}
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* `_data` is additional data, it has no specified format and it is sent in call to `to`.
*
* This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
* implement alternative mechanisms to perform token transfer, such as signature-based.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
* and stop existing when they are burned (`_burn`).
*/
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return tokenId < _owners.length && _owners[tokenId] != address(0);
}
/**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
require(_exists(tokenId), "ERC721: operator query for nonexistent token");
address owner = ERC721B.ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
}
/**
* @dev Safely mints `tokenId` and transfers it to `to`.
*
* Requirements:
*
* - `tokenId` must not exist.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
/**
* @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
* forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
*/
function _safeMint(
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_mint(to, tokenId);
require(
_checkOnERC721Received(address(0), to, tokenId, _data),
"ERC721: transfer to non ERC721Receiver implementer"
);
}
/**
* @dev Mints `tokenId` and transfers it to `to`.
*
* WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
*
* Requirements:
*
* - `tokenId` must not exist.
* - `to` cannot be the zero address.
*
* Emits a {Transfer} event.
*/
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId);
_owners.push(to);
emit Transfer(address(0), to, tokenId);
}
/**
* @dev Destroys `tokenId`.
* The approval is cleared when the token is burned.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits a {Transfer} event.
*/
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721B.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId);
// Clear approvals
_approve(address(0), tokenId);
_owners[tokenId] = address(0);
emit Transfer(owner, address(0), tokenId);
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
require(ERC721B.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId);
// Clear approvals from the previous owner
_approve(address(0), tokenId);
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721B.ownerOf(tokenId), to, tokenId);
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
if (to.isContract()) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
return retval == IERC721Receiver.onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
/**
* @dev Hook that is called before any token transfer. This includes minting
* and burning.
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
* - When `to` is zero, ``from``'s `tokenId` will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual {}
} | /********************
* @author: Squeebo *
********************/ | NatSpecMultiLine | balanceOf | function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: balance query for the zero address");
uint count = 0;
uint length = _owners.length;
for( uint i = 0; i < length; ++i ){
if( owner == _owners[i] ){
++count;
}
}
delete length;
return count;
}
| /**
* @dev See {IERC721-balanceOf}.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | MIT | ipfs://672fc76424cd92c353e6de815b9bcc53701f37d5371e3774b462983f8ad2f3fe | {
"func_code_index": [
1202,
1625
]
} | 8,973 |
MetaScyra | contracts/Blimpie/ERC721B.sol | 0xd7c57fc28f72cc8ffbd635155d924f0ac3f03f8e | Solidity | ERC721B | abstract contract ERC721B is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to owner address
address[] internal _owners;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
super.supportsInterface(interfaceId);
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: balance query for the zero address");
uint count = 0;
uint length = _owners.length;
for( uint i = 0; i < length; ++i ){
if( owner == _owners[i] ){
++count;
}
}
delete length;
return count;
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _owners[tokenId];
require(owner != address(0), "ERC721: owner query for nonexistent token");
return owner;
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
return _name;
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual override {
address owner = ERC721B.ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(
_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not owner nor approved for all"
);
_approve(to, tokenId);
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view virtual override returns (address) {
require(_exists(tokenId), "ERC721: approved query for nonexistent token");
return _tokenApprovals[tokenId];
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
require(operator != _msgSender(), "ERC721: approve to caller");
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_msgSender(), operator, approved);
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
//solhint-disable-next-line max-line-length
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_transfer(from, to, tokenId);
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_safeTransfer(from, to, tokenId, _data);
}
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* `_data` is additional data, it has no specified format and it is sent in call to `to`.
*
* This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
* implement alternative mechanisms to perform token transfer, such as signature-based.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
* and stop existing when they are burned (`_burn`).
*/
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return tokenId < _owners.length && _owners[tokenId] != address(0);
}
/**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
require(_exists(tokenId), "ERC721: operator query for nonexistent token");
address owner = ERC721B.ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
}
/**
* @dev Safely mints `tokenId` and transfers it to `to`.
*
* Requirements:
*
* - `tokenId` must not exist.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
/**
* @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
* forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
*/
function _safeMint(
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_mint(to, tokenId);
require(
_checkOnERC721Received(address(0), to, tokenId, _data),
"ERC721: transfer to non ERC721Receiver implementer"
);
}
/**
* @dev Mints `tokenId` and transfers it to `to`.
*
* WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
*
* Requirements:
*
* - `tokenId` must not exist.
* - `to` cannot be the zero address.
*
* Emits a {Transfer} event.
*/
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId);
_owners.push(to);
emit Transfer(address(0), to, tokenId);
}
/**
* @dev Destroys `tokenId`.
* The approval is cleared when the token is burned.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits a {Transfer} event.
*/
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721B.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId);
// Clear approvals
_approve(address(0), tokenId);
_owners[tokenId] = address(0);
emit Transfer(owner, address(0), tokenId);
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
require(ERC721B.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId);
// Clear approvals from the previous owner
_approve(address(0), tokenId);
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721B.ownerOf(tokenId), to, tokenId);
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
if (to.isContract()) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
return retval == IERC721Receiver.onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
/**
* @dev Hook that is called before any token transfer. This includes minting
* and burning.
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
* - When `to` is zero, ``from``'s `tokenId` will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual {}
} | /********************
* @author: Squeebo *
********************/ | NatSpecMultiLine | ownerOf | function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _owners[tokenId];
require(owner != address(0), "ERC721: owner query for nonexistent token");
return owner;
}
| /**
* @dev See {IERC721-ownerOf}.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | MIT | ipfs://672fc76424cd92c353e6de815b9bcc53701f37d5371e3774b462983f8ad2f3fe | {
"func_code_index": [
1682,
1926
]
} | 8,974 |
MetaScyra | contracts/Blimpie/ERC721B.sol | 0xd7c57fc28f72cc8ffbd635155d924f0ac3f03f8e | Solidity | ERC721B | abstract contract ERC721B is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to owner address
address[] internal _owners;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
super.supportsInterface(interfaceId);
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: balance query for the zero address");
uint count = 0;
uint length = _owners.length;
for( uint i = 0; i < length; ++i ){
if( owner == _owners[i] ){
++count;
}
}
delete length;
return count;
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _owners[tokenId];
require(owner != address(0), "ERC721: owner query for nonexistent token");
return owner;
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
return _name;
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual override {
address owner = ERC721B.ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(
_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not owner nor approved for all"
);
_approve(to, tokenId);
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view virtual override returns (address) {
require(_exists(tokenId), "ERC721: approved query for nonexistent token");
return _tokenApprovals[tokenId];
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
require(operator != _msgSender(), "ERC721: approve to caller");
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_msgSender(), operator, approved);
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
//solhint-disable-next-line max-line-length
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_transfer(from, to, tokenId);
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_safeTransfer(from, to, tokenId, _data);
}
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* `_data` is additional data, it has no specified format and it is sent in call to `to`.
*
* This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
* implement alternative mechanisms to perform token transfer, such as signature-based.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
* and stop existing when they are burned (`_burn`).
*/
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return tokenId < _owners.length && _owners[tokenId] != address(0);
}
/**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
require(_exists(tokenId), "ERC721: operator query for nonexistent token");
address owner = ERC721B.ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
}
/**
* @dev Safely mints `tokenId` and transfers it to `to`.
*
* Requirements:
*
* - `tokenId` must not exist.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
/**
* @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
* forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
*/
function _safeMint(
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_mint(to, tokenId);
require(
_checkOnERC721Received(address(0), to, tokenId, _data),
"ERC721: transfer to non ERC721Receiver implementer"
);
}
/**
* @dev Mints `tokenId` and transfers it to `to`.
*
* WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
*
* Requirements:
*
* - `tokenId` must not exist.
* - `to` cannot be the zero address.
*
* Emits a {Transfer} event.
*/
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId);
_owners.push(to);
emit Transfer(address(0), to, tokenId);
}
/**
* @dev Destroys `tokenId`.
* The approval is cleared when the token is burned.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits a {Transfer} event.
*/
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721B.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId);
// Clear approvals
_approve(address(0), tokenId);
_owners[tokenId] = address(0);
emit Transfer(owner, address(0), tokenId);
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
require(ERC721B.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId);
// Clear approvals from the previous owner
_approve(address(0), tokenId);
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721B.ownerOf(tokenId), to, tokenId);
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
if (to.isContract()) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
return retval == IERC721Receiver.onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
/**
* @dev Hook that is called before any token transfer. This includes minting
* and burning.
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
* - When `to` is zero, ``from``'s `tokenId` will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual {}
} | /********************
* @author: Squeebo *
********************/ | NatSpecMultiLine | name | function name() public view virtual override returns (string memory) {
return _name;
}
| /**
* @dev See {IERC721Metadata-name}.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | MIT | ipfs://672fc76424cd92c353e6de815b9bcc53701f37d5371e3774b462983f8ad2f3fe | {
"func_code_index": [
1988,
2093
]
} | 8,975 |
MetaScyra | contracts/Blimpie/ERC721B.sol | 0xd7c57fc28f72cc8ffbd635155d924f0ac3f03f8e | Solidity | ERC721B | abstract contract ERC721B is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to owner address
address[] internal _owners;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
super.supportsInterface(interfaceId);
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: balance query for the zero address");
uint count = 0;
uint length = _owners.length;
for( uint i = 0; i < length; ++i ){
if( owner == _owners[i] ){
++count;
}
}
delete length;
return count;
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _owners[tokenId];
require(owner != address(0), "ERC721: owner query for nonexistent token");
return owner;
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
return _name;
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual override {
address owner = ERC721B.ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(
_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not owner nor approved for all"
);
_approve(to, tokenId);
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view virtual override returns (address) {
require(_exists(tokenId), "ERC721: approved query for nonexistent token");
return _tokenApprovals[tokenId];
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
require(operator != _msgSender(), "ERC721: approve to caller");
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_msgSender(), operator, approved);
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
//solhint-disable-next-line max-line-length
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_transfer(from, to, tokenId);
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_safeTransfer(from, to, tokenId, _data);
}
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* `_data` is additional data, it has no specified format and it is sent in call to `to`.
*
* This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
* implement alternative mechanisms to perform token transfer, such as signature-based.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
* and stop existing when they are burned (`_burn`).
*/
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return tokenId < _owners.length && _owners[tokenId] != address(0);
}
/**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
require(_exists(tokenId), "ERC721: operator query for nonexistent token");
address owner = ERC721B.ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
}
/**
* @dev Safely mints `tokenId` and transfers it to `to`.
*
* Requirements:
*
* - `tokenId` must not exist.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
/**
* @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
* forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
*/
function _safeMint(
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_mint(to, tokenId);
require(
_checkOnERC721Received(address(0), to, tokenId, _data),
"ERC721: transfer to non ERC721Receiver implementer"
);
}
/**
* @dev Mints `tokenId` and transfers it to `to`.
*
* WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
*
* Requirements:
*
* - `tokenId` must not exist.
* - `to` cannot be the zero address.
*
* Emits a {Transfer} event.
*/
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId);
_owners.push(to);
emit Transfer(address(0), to, tokenId);
}
/**
* @dev Destroys `tokenId`.
* The approval is cleared when the token is burned.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits a {Transfer} event.
*/
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721B.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId);
// Clear approvals
_approve(address(0), tokenId);
_owners[tokenId] = address(0);
emit Transfer(owner, address(0), tokenId);
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
require(ERC721B.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId);
// Clear approvals from the previous owner
_approve(address(0), tokenId);
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721B.ownerOf(tokenId), to, tokenId);
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
if (to.isContract()) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
return retval == IERC721Receiver.onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
/**
* @dev Hook that is called before any token transfer. This includes minting
* and burning.
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
* - When `to` is zero, ``from``'s `tokenId` will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual {}
} | /********************
* @author: Squeebo *
********************/ | NatSpecMultiLine | symbol | function symbol() public view virtual override returns (string memory) {
return _symbol;
}
| /**
* @dev See {IERC721Metadata-symbol}.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | MIT | ipfs://672fc76424cd92c353e6de815b9bcc53701f37d5371e3774b462983f8ad2f3fe | {
"func_code_index": [
2157,
2266
]
} | 8,976 |
MetaScyra | contracts/Blimpie/ERC721B.sol | 0xd7c57fc28f72cc8ffbd635155d924f0ac3f03f8e | Solidity | ERC721B | abstract contract ERC721B is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to owner address
address[] internal _owners;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
super.supportsInterface(interfaceId);
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: balance query for the zero address");
uint count = 0;
uint length = _owners.length;
for( uint i = 0; i < length; ++i ){
if( owner == _owners[i] ){
++count;
}
}
delete length;
return count;
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _owners[tokenId];
require(owner != address(0), "ERC721: owner query for nonexistent token");
return owner;
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
return _name;
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual override {
address owner = ERC721B.ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(
_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not owner nor approved for all"
);
_approve(to, tokenId);
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view virtual override returns (address) {
require(_exists(tokenId), "ERC721: approved query for nonexistent token");
return _tokenApprovals[tokenId];
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
require(operator != _msgSender(), "ERC721: approve to caller");
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_msgSender(), operator, approved);
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
//solhint-disable-next-line max-line-length
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_transfer(from, to, tokenId);
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_safeTransfer(from, to, tokenId, _data);
}
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* `_data` is additional data, it has no specified format and it is sent in call to `to`.
*
* This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
* implement alternative mechanisms to perform token transfer, such as signature-based.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
* and stop existing when they are burned (`_burn`).
*/
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return tokenId < _owners.length && _owners[tokenId] != address(0);
}
/**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
require(_exists(tokenId), "ERC721: operator query for nonexistent token");
address owner = ERC721B.ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
}
/**
* @dev Safely mints `tokenId` and transfers it to `to`.
*
* Requirements:
*
* - `tokenId` must not exist.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
/**
* @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
* forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
*/
function _safeMint(
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_mint(to, tokenId);
require(
_checkOnERC721Received(address(0), to, tokenId, _data),
"ERC721: transfer to non ERC721Receiver implementer"
);
}
/**
* @dev Mints `tokenId` and transfers it to `to`.
*
* WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
*
* Requirements:
*
* - `tokenId` must not exist.
* - `to` cannot be the zero address.
*
* Emits a {Transfer} event.
*/
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId);
_owners.push(to);
emit Transfer(address(0), to, tokenId);
}
/**
* @dev Destroys `tokenId`.
* The approval is cleared when the token is burned.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits a {Transfer} event.
*/
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721B.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId);
// Clear approvals
_approve(address(0), tokenId);
_owners[tokenId] = address(0);
emit Transfer(owner, address(0), tokenId);
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
require(ERC721B.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId);
// Clear approvals from the previous owner
_approve(address(0), tokenId);
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721B.ownerOf(tokenId), to, tokenId);
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
if (to.isContract()) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
return retval == IERC721Receiver.onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
/**
* @dev Hook that is called before any token transfer. This includes minting
* and burning.
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
* - When `to` is zero, ``from``'s `tokenId` will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual {}
} | /********************
* @author: Squeebo *
********************/ | NatSpecMultiLine | approve | function approve(address to, uint256 tokenId) public virtual override {
address owner = ERC721B.ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(
_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not owner nor approved for all"
);
_approve(to, tokenId);
}
| /**
* @dev See {IERC721-approve}.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | MIT | ipfs://672fc76424cd92c353e6de815b9bcc53701f37d5371e3774b462983f8ad2f3fe | {
"func_code_index": [
2323,
2740
]
} | 8,977 |
MetaScyra | contracts/Blimpie/ERC721B.sol | 0xd7c57fc28f72cc8ffbd635155d924f0ac3f03f8e | Solidity | ERC721B | abstract contract ERC721B is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to owner address
address[] internal _owners;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
super.supportsInterface(interfaceId);
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: balance query for the zero address");
uint count = 0;
uint length = _owners.length;
for( uint i = 0; i < length; ++i ){
if( owner == _owners[i] ){
++count;
}
}
delete length;
return count;
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _owners[tokenId];
require(owner != address(0), "ERC721: owner query for nonexistent token");
return owner;
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
return _name;
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual override {
address owner = ERC721B.ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(
_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not owner nor approved for all"
);
_approve(to, tokenId);
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view virtual override returns (address) {
require(_exists(tokenId), "ERC721: approved query for nonexistent token");
return _tokenApprovals[tokenId];
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
require(operator != _msgSender(), "ERC721: approve to caller");
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_msgSender(), operator, approved);
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
//solhint-disable-next-line max-line-length
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_transfer(from, to, tokenId);
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_safeTransfer(from, to, tokenId, _data);
}
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* `_data` is additional data, it has no specified format and it is sent in call to `to`.
*
* This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
* implement alternative mechanisms to perform token transfer, such as signature-based.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
* and stop existing when they are burned (`_burn`).
*/
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return tokenId < _owners.length && _owners[tokenId] != address(0);
}
/**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
require(_exists(tokenId), "ERC721: operator query for nonexistent token");
address owner = ERC721B.ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
}
/**
* @dev Safely mints `tokenId` and transfers it to `to`.
*
* Requirements:
*
* - `tokenId` must not exist.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
/**
* @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
* forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
*/
function _safeMint(
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_mint(to, tokenId);
require(
_checkOnERC721Received(address(0), to, tokenId, _data),
"ERC721: transfer to non ERC721Receiver implementer"
);
}
/**
* @dev Mints `tokenId` and transfers it to `to`.
*
* WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
*
* Requirements:
*
* - `tokenId` must not exist.
* - `to` cannot be the zero address.
*
* Emits a {Transfer} event.
*/
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId);
_owners.push(to);
emit Transfer(address(0), to, tokenId);
}
/**
* @dev Destroys `tokenId`.
* The approval is cleared when the token is burned.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits a {Transfer} event.
*/
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721B.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId);
// Clear approvals
_approve(address(0), tokenId);
_owners[tokenId] = address(0);
emit Transfer(owner, address(0), tokenId);
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
require(ERC721B.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId);
// Clear approvals from the previous owner
_approve(address(0), tokenId);
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721B.ownerOf(tokenId), to, tokenId);
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
if (to.isContract()) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
return retval == IERC721Receiver.onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
/**
* @dev Hook that is called before any token transfer. This includes minting
* and burning.
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
* - When `to` is zero, ``from``'s `tokenId` will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual {}
} | /********************
* @author: Squeebo *
********************/ | NatSpecMultiLine | getApproved | function getApproved(uint256 tokenId) public view virtual override returns (address) {
require(_exists(tokenId), "ERC721: approved query for nonexistent token");
return _tokenApprovals[tokenId];
}
| /**
* @dev See {IERC721-getApproved}.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | MIT | ipfs://672fc76424cd92c353e6de815b9bcc53701f37d5371e3774b462983f8ad2f3fe | {
"func_code_index": [
2801,
3027
]
} | 8,978 |
MetaScyra | contracts/Blimpie/ERC721B.sol | 0xd7c57fc28f72cc8ffbd635155d924f0ac3f03f8e | Solidity | ERC721B | abstract contract ERC721B is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to owner address
address[] internal _owners;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
super.supportsInterface(interfaceId);
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: balance query for the zero address");
uint count = 0;
uint length = _owners.length;
for( uint i = 0; i < length; ++i ){
if( owner == _owners[i] ){
++count;
}
}
delete length;
return count;
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _owners[tokenId];
require(owner != address(0), "ERC721: owner query for nonexistent token");
return owner;
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
return _name;
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual override {
address owner = ERC721B.ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(
_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not owner nor approved for all"
);
_approve(to, tokenId);
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view virtual override returns (address) {
require(_exists(tokenId), "ERC721: approved query for nonexistent token");
return _tokenApprovals[tokenId];
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
require(operator != _msgSender(), "ERC721: approve to caller");
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_msgSender(), operator, approved);
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
//solhint-disable-next-line max-line-length
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_transfer(from, to, tokenId);
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_safeTransfer(from, to, tokenId, _data);
}
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* `_data` is additional data, it has no specified format and it is sent in call to `to`.
*
* This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
* implement alternative mechanisms to perform token transfer, such as signature-based.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
* and stop existing when they are burned (`_burn`).
*/
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return tokenId < _owners.length && _owners[tokenId] != address(0);
}
/**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
require(_exists(tokenId), "ERC721: operator query for nonexistent token");
address owner = ERC721B.ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
}
/**
* @dev Safely mints `tokenId` and transfers it to `to`.
*
* Requirements:
*
* - `tokenId` must not exist.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
/**
* @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
* forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
*/
function _safeMint(
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_mint(to, tokenId);
require(
_checkOnERC721Received(address(0), to, tokenId, _data),
"ERC721: transfer to non ERC721Receiver implementer"
);
}
/**
* @dev Mints `tokenId` and transfers it to `to`.
*
* WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
*
* Requirements:
*
* - `tokenId` must not exist.
* - `to` cannot be the zero address.
*
* Emits a {Transfer} event.
*/
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId);
_owners.push(to);
emit Transfer(address(0), to, tokenId);
}
/**
* @dev Destroys `tokenId`.
* The approval is cleared when the token is burned.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits a {Transfer} event.
*/
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721B.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId);
// Clear approvals
_approve(address(0), tokenId);
_owners[tokenId] = address(0);
emit Transfer(owner, address(0), tokenId);
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
require(ERC721B.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId);
// Clear approvals from the previous owner
_approve(address(0), tokenId);
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721B.ownerOf(tokenId), to, tokenId);
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
if (to.isContract()) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
return retval == IERC721Receiver.onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
/**
* @dev Hook that is called before any token transfer. This includes minting
* and burning.
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
* - When `to` is zero, ``from``'s `tokenId` will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual {}
} | /********************
* @author: Squeebo *
********************/ | NatSpecMultiLine | setApprovalForAll | function setApprovalForAll(address operator, bool approved) public virtual override {
require(operator != _msgSender(), "ERC721: approve to caller");
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_msgSender(), operator, approved);
}
| /**
* @dev See {IERC721-setApprovalForAll}.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | MIT | ipfs://672fc76424cd92c353e6de815b9bcc53701f37d5371e3774b462983f8ad2f3fe | {
"func_code_index": [
3094,
3394
]
} | 8,979 |
MetaScyra | contracts/Blimpie/ERC721B.sol | 0xd7c57fc28f72cc8ffbd635155d924f0ac3f03f8e | Solidity | ERC721B | abstract contract ERC721B is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to owner address
address[] internal _owners;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
super.supportsInterface(interfaceId);
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: balance query for the zero address");
uint count = 0;
uint length = _owners.length;
for( uint i = 0; i < length; ++i ){
if( owner == _owners[i] ){
++count;
}
}
delete length;
return count;
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _owners[tokenId];
require(owner != address(0), "ERC721: owner query for nonexistent token");
return owner;
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
return _name;
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual override {
address owner = ERC721B.ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(
_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not owner nor approved for all"
);
_approve(to, tokenId);
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view virtual override returns (address) {
require(_exists(tokenId), "ERC721: approved query for nonexistent token");
return _tokenApprovals[tokenId];
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
require(operator != _msgSender(), "ERC721: approve to caller");
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_msgSender(), operator, approved);
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
//solhint-disable-next-line max-line-length
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_transfer(from, to, tokenId);
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_safeTransfer(from, to, tokenId, _data);
}
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* `_data` is additional data, it has no specified format and it is sent in call to `to`.
*
* This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
* implement alternative mechanisms to perform token transfer, such as signature-based.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
* and stop existing when they are burned (`_burn`).
*/
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return tokenId < _owners.length && _owners[tokenId] != address(0);
}
/**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
require(_exists(tokenId), "ERC721: operator query for nonexistent token");
address owner = ERC721B.ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
}
/**
* @dev Safely mints `tokenId` and transfers it to `to`.
*
* Requirements:
*
* - `tokenId` must not exist.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
/**
* @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
* forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
*/
function _safeMint(
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_mint(to, tokenId);
require(
_checkOnERC721Received(address(0), to, tokenId, _data),
"ERC721: transfer to non ERC721Receiver implementer"
);
}
/**
* @dev Mints `tokenId` and transfers it to `to`.
*
* WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
*
* Requirements:
*
* - `tokenId` must not exist.
* - `to` cannot be the zero address.
*
* Emits a {Transfer} event.
*/
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId);
_owners.push(to);
emit Transfer(address(0), to, tokenId);
}
/**
* @dev Destroys `tokenId`.
* The approval is cleared when the token is burned.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits a {Transfer} event.
*/
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721B.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId);
// Clear approvals
_approve(address(0), tokenId);
_owners[tokenId] = address(0);
emit Transfer(owner, address(0), tokenId);
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
require(ERC721B.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId);
// Clear approvals from the previous owner
_approve(address(0), tokenId);
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721B.ownerOf(tokenId), to, tokenId);
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
if (to.isContract()) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
return retval == IERC721Receiver.onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
/**
* @dev Hook that is called before any token transfer. This includes minting
* and burning.
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
* - When `to` is zero, ``from``'s `tokenId` will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual {}
} | /********************
* @author: Squeebo *
********************/ | NatSpecMultiLine | isApprovedForAll | function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
| /**
* @dev See {IERC721-isApprovedForAll}.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | MIT | ipfs://672fc76424cd92c353e6de815b9bcc53701f37d5371e3774b462983f8ad2f3fe | {
"func_code_index": [
3460,
3629
]
} | 8,980 |
MetaScyra | contracts/Blimpie/ERC721B.sol | 0xd7c57fc28f72cc8ffbd635155d924f0ac3f03f8e | Solidity | ERC721B | abstract contract ERC721B is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to owner address
address[] internal _owners;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
super.supportsInterface(interfaceId);
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: balance query for the zero address");
uint count = 0;
uint length = _owners.length;
for( uint i = 0; i < length; ++i ){
if( owner == _owners[i] ){
++count;
}
}
delete length;
return count;
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _owners[tokenId];
require(owner != address(0), "ERC721: owner query for nonexistent token");
return owner;
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
return _name;
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual override {
address owner = ERC721B.ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(
_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not owner nor approved for all"
);
_approve(to, tokenId);
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view virtual override returns (address) {
require(_exists(tokenId), "ERC721: approved query for nonexistent token");
return _tokenApprovals[tokenId];
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
require(operator != _msgSender(), "ERC721: approve to caller");
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_msgSender(), operator, approved);
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
//solhint-disable-next-line max-line-length
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_transfer(from, to, tokenId);
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_safeTransfer(from, to, tokenId, _data);
}
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* `_data` is additional data, it has no specified format and it is sent in call to `to`.
*
* This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
* implement alternative mechanisms to perform token transfer, such as signature-based.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
* and stop existing when they are burned (`_burn`).
*/
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return tokenId < _owners.length && _owners[tokenId] != address(0);
}
/**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
require(_exists(tokenId), "ERC721: operator query for nonexistent token");
address owner = ERC721B.ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
}
/**
* @dev Safely mints `tokenId` and transfers it to `to`.
*
* Requirements:
*
* - `tokenId` must not exist.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
/**
* @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
* forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
*/
function _safeMint(
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_mint(to, tokenId);
require(
_checkOnERC721Received(address(0), to, tokenId, _data),
"ERC721: transfer to non ERC721Receiver implementer"
);
}
/**
* @dev Mints `tokenId` and transfers it to `to`.
*
* WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
*
* Requirements:
*
* - `tokenId` must not exist.
* - `to` cannot be the zero address.
*
* Emits a {Transfer} event.
*/
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId);
_owners.push(to);
emit Transfer(address(0), to, tokenId);
}
/**
* @dev Destroys `tokenId`.
* The approval is cleared when the token is burned.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits a {Transfer} event.
*/
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721B.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId);
// Clear approvals
_approve(address(0), tokenId);
_owners[tokenId] = address(0);
emit Transfer(owner, address(0), tokenId);
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
require(ERC721B.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId);
// Clear approvals from the previous owner
_approve(address(0), tokenId);
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721B.ownerOf(tokenId), to, tokenId);
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
if (to.isContract()) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
return retval == IERC721Receiver.onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
/**
* @dev Hook that is called before any token transfer. This includes minting
* and burning.
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
* - When `to` is zero, ``from``'s `tokenId` will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual {}
} | /********************
* @author: Squeebo *
********************/ | NatSpecMultiLine | transferFrom | function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
//solhint-disable-next-line max-line-length
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_transfer(from, to, tokenId);
}
| /**
* @dev See {IERC721-transferFrom}.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | MIT | ipfs://672fc76424cd92c353e6de815b9bcc53701f37d5371e3774b462983f8ad2f3fe | {
"func_code_index": [
3693,
4037
]
} | 8,981 |
MetaScyra | contracts/Blimpie/ERC721B.sol | 0xd7c57fc28f72cc8ffbd635155d924f0ac3f03f8e | Solidity | ERC721B | abstract contract ERC721B is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to owner address
address[] internal _owners;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
super.supportsInterface(interfaceId);
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: balance query for the zero address");
uint count = 0;
uint length = _owners.length;
for( uint i = 0; i < length; ++i ){
if( owner == _owners[i] ){
++count;
}
}
delete length;
return count;
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _owners[tokenId];
require(owner != address(0), "ERC721: owner query for nonexistent token");
return owner;
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
return _name;
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual override {
address owner = ERC721B.ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(
_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not owner nor approved for all"
);
_approve(to, tokenId);
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view virtual override returns (address) {
require(_exists(tokenId), "ERC721: approved query for nonexistent token");
return _tokenApprovals[tokenId];
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
require(operator != _msgSender(), "ERC721: approve to caller");
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_msgSender(), operator, approved);
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
//solhint-disable-next-line max-line-length
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_transfer(from, to, tokenId);
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_safeTransfer(from, to, tokenId, _data);
}
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* `_data` is additional data, it has no specified format and it is sent in call to `to`.
*
* This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
* implement alternative mechanisms to perform token transfer, such as signature-based.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
* and stop existing when they are burned (`_burn`).
*/
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return tokenId < _owners.length && _owners[tokenId] != address(0);
}
/**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
require(_exists(tokenId), "ERC721: operator query for nonexistent token");
address owner = ERC721B.ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
}
/**
* @dev Safely mints `tokenId` and transfers it to `to`.
*
* Requirements:
*
* - `tokenId` must not exist.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
/**
* @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
* forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
*/
function _safeMint(
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_mint(to, tokenId);
require(
_checkOnERC721Received(address(0), to, tokenId, _data),
"ERC721: transfer to non ERC721Receiver implementer"
);
}
/**
* @dev Mints `tokenId` and transfers it to `to`.
*
* WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
*
* Requirements:
*
* - `tokenId` must not exist.
* - `to` cannot be the zero address.
*
* Emits a {Transfer} event.
*/
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId);
_owners.push(to);
emit Transfer(address(0), to, tokenId);
}
/**
* @dev Destroys `tokenId`.
* The approval is cleared when the token is burned.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits a {Transfer} event.
*/
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721B.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId);
// Clear approvals
_approve(address(0), tokenId);
_owners[tokenId] = address(0);
emit Transfer(owner, address(0), tokenId);
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
require(ERC721B.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId);
// Clear approvals from the previous owner
_approve(address(0), tokenId);
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721B.ownerOf(tokenId), to, tokenId);
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
if (to.isContract()) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
return retval == IERC721Receiver.onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
/**
* @dev Hook that is called before any token transfer. This includes minting
* and burning.
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
* - When `to` is zero, ``from``'s `tokenId` will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual {}
} | /********************
* @author: Squeebo *
********************/ | NatSpecMultiLine | safeTransferFrom | function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
| /**
* @dev See {IERC721-safeTransferFrom}.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | MIT | ipfs://672fc76424cd92c353e6de815b9bcc53701f37d5371e3774b462983f8ad2f3fe | {
"func_code_index": [
4103,
4293
]
} | 8,982 |
MetaScyra | contracts/Blimpie/ERC721B.sol | 0xd7c57fc28f72cc8ffbd635155d924f0ac3f03f8e | Solidity | ERC721B | abstract contract ERC721B is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to owner address
address[] internal _owners;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
super.supportsInterface(interfaceId);
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: balance query for the zero address");
uint count = 0;
uint length = _owners.length;
for( uint i = 0; i < length; ++i ){
if( owner == _owners[i] ){
++count;
}
}
delete length;
return count;
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _owners[tokenId];
require(owner != address(0), "ERC721: owner query for nonexistent token");
return owner;
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
return _name;
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual override {
address owner = ERC721B.ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(
_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not owner nor approved for all"
);
_approve(to, tokenId);
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view virtual override returns (address) {
require(_exists(tokenId), "ERC721: approved query for nonexistent token");
return _tokenApprovals[tokenId];
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
require(operator != _msgSender(), "ERC721: approve to caller");
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_msgSender(), operator, approved);
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
//solhint-disable-next-line max-line-length
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_transfer(from, to, tokenId);
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_safeTransfer(from, to, tokenId, _data);
}
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* `_data` is additional data, it has no specified format and it is sent in call to `to`.
*
* This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
* implement alternative mechanisms to perform token transfer, such as signature-based.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
* and stop existing when they are burned (`_burn`).
*/
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return tokenId < _owners.length && _owners[tokenId] != address(0);
}
/**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
require(_exists(tokenId), "ERC721: operator query for nonexistent token");
address owner = ERC721B.ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
}
/**
* @dev Safely mints `tokenId` and transfers it to `to`.
*
* Requirements:
*
* - `tokenId` must not exist.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
/**
* @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
* forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
*/
function _safeMint(
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_mint(to, tokenId);
require(
_checkOnERC721Received(address(0), to, tokenId, _data),
"ERC721: transfer to non ERC721Receiver implementer"
);
}
/**
* @dev Mints `tokenId` and transfers it to `to`.
*
* WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
*
* Requirements:
*
* - `tokenId` must not exist.
* - `to` cannot be the zero address.
*
* Emits a {Transfer} event.
*/
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId);
_owners.push(to);
emit Transfer(address(0), to, tokenId);
}
/**
* @dev Destroys `tokenId`.
* The approval is cleared when the token is burned.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits a {Transfer} event.
*/
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721B.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId);
// Clear approvals
_approve(address(0), tokenId);
_owners[tokenId] = address(0);
emit Transfer(owner, address(0), tokenId);
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
require(ERC721B.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId);
// Clear approvals from the previous owner
_approve(address(0), tokenId);
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721B.ownerOf(tokenId), to, tokenId);
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
if (to.isContract()) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
return retval == IERC721Receiver.onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
/**
* @dev Hook that is called before any token transfer. This includes minting
* and burning.
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
* - When `to` is zero, ``from``'s `tokenId` will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual {}
} | /********************
* @author: Squeebo *
********************/ | NatSpecMultiLine | safeTransferFrom | function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_safeTransfer(from, to, tokenId, _data);
}
| /**
* @dev See {IERC721-safeTransferFrom}.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | MIT | ipfs://672fc76424cd92c353e6de815b9bcc53701f37d5371e3774b462983f8ad2f3fe | {
"func_code_index": [
4359,
4692
]
} | 8,983 |
MetaScyra | contracts/Blimpie/ERC721B.sol | 0xd7c57fc28f72cc8ffbd635155d924f0ac3f03f8e | Solidity | ERC721B | abstract contract ERC721B is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to owner address
address[] internal _owners;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
super.supportsInterface(interfaceId);
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: balance query for the zero address");
uint count = 0;
uint length = _owners.length;
for( uint i = 0; i < length; ++i ){
if( owner == _owners[i] ){
++count;
}
}
delete length;
return count;
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _owners[tokenId];
require(owner != address(0), "ERC721: owner query for nonexistent token");
return owner;
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
return _name;
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual override {
address owner = ERC721B.ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(
_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not owner nor approved for all"
);
_approve(to, tokenId);
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view virtual override returns (address) {
require(_exists(tokenId), "ERC721: approved query for nonexistent token");
return _tokenApprovals[tokenId];
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
require(operator != _msgSender(), "ERC721: approve to caller");
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_msgSender(), operator, approved);
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
//solhint-disable-next-line max-line-length
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_transfer(from, to, tokenId);
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_safeTransfer(from, to, tokenId, _data);
}
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* `_data` is additional data, it has no specified format and it is sent in call to `to`.
*
* This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
* implement alternative mechanisms to perform token transfer, such as signature-based.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
* and stop existing when they are burned (`_burn`).
*/
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return tokenId < _owners.length && _owners[tokenId] != address(0);
}
/**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
require(_exists(tokenId), "ERC721: operator query for nonexistent token");
address owner = ERC721B.ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
}
/**
* @dev Safely mints `tokenId` and transfers it to `to`.
*
* Requirements:
*
* - `tokenId` must not exist.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
/**
* @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
* forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
*/
function _safeMint(
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_mint(to, tokenId);
require(
_checkOnERC721Received(address(0), to, tokenId, _data),
"ERC721: transfer to non ERC721Receiver implementer"
);
}
/**
* @dev Mints `tokenId` and transfers it to `to`.
*
* WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
*
* Requirements:
*
* - `tokenId` must not exist.
* - `to` cannot be the zero address.
*
* Emits a {Transfer} event.
*/
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId);
_owners.push(to);
emit Transfer(address(0), to, tokenId);
}
/**
* @dev Destroys `tokenId`.
* The approval is cleared when the token is burned.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits a {Transfer} event.
*/
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721B.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId);
// Clear approvals
_approve(address(0), tokenId);
_owners[tokenId] = address(0);
emit Transfer(owner, address(0), tokenId);
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
require(ERC721B.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId);
// Clear approvals from the previous owner
_approve(address(0), tokenId);
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721B.ownerOf(tokenId), to, tokenId);
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
if (to.isContract()) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
return retval == IERC721Receiver.onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
/**
* @dev Hook that is called before any token transfer. This includes minting
* and burning.
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
* - When `to` is zero, ``from``'s `tokenId` will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual {}
} | /********************
* @author: Squeebo *
********************/ | NatSpecMultiLine | _safeTransfer | function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
| /**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* `_data` is additional data, it has no specified format and it is sent in call to `to`.
*
* This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
* implement alternative mechanisms to perform token transfer, such as signature-based.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | MIT | ipfs://672fc76424cd92c353e6de815b9bcc53701f37d5371e3774b462983f8ad2f3fe | {
"func_code_index": [
5569,
5889
]
} | 8,984 |
MetaScyra | contracts/Blimpie/ERC721B.sol | 0xd7c57fc28f72cc8ffbd635155d924f0ac3f03f8e | Solidity | ERC721B | abstract contract ERC721B is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to owner address
address[] internal _owners;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
super.supportsInterface(interfaceId);
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: balance query for the zero address");
uint count = 0;
uint length = _owners.length;
for( uint i = 0; i < length; ++i ){
if( owner == _owners[i] ){
++count;
}
}
delete length;
return count;
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _owners[tokenId];
require(owner != address(0), "ERC721: owner query for nonexistent token");
return owner;
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
return _name;
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual override {
address owner = ERC721B.ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(
_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not owner nor approved for all"
);
_approve(to, tokenId);
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view virtual override returns (address) {
require(_exists(tokenId), "ERC721: approved query for nonexistent token");
return _tokenApprovals[tokenId];
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
require(operator != _msgSender(), "ERC721: approve to caller");
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_msgSender(), operator, approved);
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
//solhint-disable-next-line max-line-length
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_transfer(from, to, tokenId);
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_safeTransfer(from, to, tokenId, _data);
}
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* `_data` is additional data, it has no specified format and it is sent in call to `to`.
*
* This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
* implement alternative mechanisms to perform token transfer, such as signature-based.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
* and stop existing when they are burned (`_burn`).
*/
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return tokenId < _owners.length && _owners[tokenId] != address(0);
}
/**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
require(_exists(tokenId), "ERC721: operator query for nonexistent token");
address owner = ERC721B.ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
}
/**
* @dev Safely mints `tokenId` and transfers it to `to`.
*
* Requirements:
*
* - `tokenId` must not exist.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
/**
* @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
* forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
*/
function _safeMint(
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_mint(to, tokenId);
require(
_checkOnERC721Received(address(0), to, tokenId, _data),
"ERC721: transfer to non ERC721Receiver implementer"
);
}
/**
* @dev Mints `tokenId` and transfers it to `to`.
*
* WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
*
* Requirements:
*
* - `tokenId` must not exist.
* - `to` cannot be the zero address.
*
* Emits a {Transfer} event.
*/
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId);
_owners.push(to);
emit Transfer(address(0), to, tokenId);
}
/**
* @dev Destroys `tokenId`.
* The approval is cleared when the token is burned.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits a {Transfer} event.
*/
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721B.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId);
// Clear approvals
_approve(address(0), tokenId);
_owners[tokenId] = address(0);
emit Transfer(owner, address(0), tokenId);
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
require(ERC721B.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId);
// Clear approvals from the previous owner
_approve(address(0), tokenId);
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721B.ownerOf(tokenId), to, tokenId);
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
if (to.isContract()) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
return retval == IERC721Receiver.onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
/**
* @dev Hook that is called before any token transfer. This includes minting
* and burning.
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
* - When `to` is zero, ``from``'s `tokenId` will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual {}
} | /********************
* @author: Squeebo *
********************/ | NatSpecMultiLine | _exists | function _exists(uint256 tokenId) internal view virtual returns (bool) {
return tokenId < _owners.length && _owners[tokenId] != address(0);
}
| /**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
* and stop existing when they are burned (`_burn`).
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | MIT | ipfs://672fc76424cd92c353e6de815b9bcc53701f37d5371e3774b462983f8ad2f3fe | {
"func_code_index": [
6197,
6357
]
} | 8,985 |
MetaScyra | contracts/Blimpie/ERC721B.sol | 0xd7c57fc28f72cc8ffbd635155d924f0ac3f03f8e | Solidity | ERC721B | abstract contract ERC721B is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to owner address
address[] internal _owners;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
super.supportsInterface(interfaceId);
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: balance query for the zero address");
uint count = 0;
uint length = _owners.length;
for( uint i = 0; i < length; ++i ){
if( owner == _owners[i] ){
++count;
}
}
delete length;
return count;
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _owners[tokenId];
require(owner != address(0), "ERC721: owner query for nonexistent token");
return owner;
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
return _name;
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual override {
address owner = ERC721B.ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(
_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not owner nor approved for all"
);
_approve(to, tokenId);
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view virtual override returns (address) {
require(_exists(tokenId), "ERC721: approved query for nonexistent token");
return _tokenApprovals[tokenId];
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
require(operator != _msgSender(), "ERC721: approve to caller");
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_msgSender(), operator, approved);
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
//solhint-disable-next-line max-line-length
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_transfer(from, to, tokenId);
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_safeTransfer(from, to, tokenId, _data);
}
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* `_data` is additional data, it has no specified format and it is sent in call to `to`.
*
* This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
* implement alternative mechanisms to perform token transfer, such as signature-based.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
* and stop existing when they are burned (`_burn`).
*/
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return tokenId < _owners.length && _owners[tokenId] != address(0);
}
/**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
require(_exists(tokenId), "ERC721: operator query for nonexistent token");
address owner = ERC721B.ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
}
/**
* @dev Safely mints `tokenId` and transfers it to `to`.
*
* Requirements:
*
* - `tokenId` must not exist.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
/**
* @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
* forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
*/
function _safeMint(
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_mint(to, tokenId);
require(
_checkOnERC721Received(address(0), to, tokenId, _data),
"ERC721: transfer to non ERC721Receiver implementer"
);
}
/**
* @dev Mints `tokenId` and transfers it to `to`.
*
* WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
*
* Requirements:
*
* - `tokenId` must not exist.
* - `to` cannot be the zero address.
*
* Emits a {Transfer} event.
*/
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId);
_owners.push(to);
emit Transfer(address(0), to, tokenId);
}
/**
* @dev Destroys `tokenId`.
* The approval is cleared when the token is burned.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits a {Transfer} event.
*/
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721B.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId);
// Clear approvals
_approve(address(0), tokenId);
_owners[tokenId] = address(0);
emit Transfer(owner, address(0), tokenId);
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
require(ERC721B.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId);
// Clear approvals from the previous owner
_approve(address(0), tokenId);
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721B.ownerOf(tokenId), to, tokenId);
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
if (to.isContract()) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
return retval == IERC721Receiver.onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
/**
* @dev Hook that is called before any token transfer. This includes minting
* and burning.
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
* - When `to` is zero, ``from``'s `tokenId` will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual {}
} | /********************
* @author: Squeebo *
********************/ | NatSpecMultiLine | _isApprovedOrOwner | function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
require(_exists(tokenId), "ERC721: operator query for nonexistent token");
address owner = ERC721B.ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
}
| /**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | MIT | ipfs://672fc76424cd92c353e6de815b9bcc53701f37d5371e3774b462983f8ad2f3fe | {
"func_code_index": [
6519,
6873
]
} | 8,986 |
MetaScyra | contracts/Blimpie/ERC721B.sol | 0xd7c57fc28f72cc8ffbd635155d924f0ac3f03f8e | Solidity | ERC721B | abstract contract ERC721B is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to owner address
address[] internal _owners;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
super.supportsInterface(interfaceId);
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: balance query for the zero address");
uint count = 0;
uint length = _owners.length;
for( uint i = 0; i < length; ++i ){
if( owner == _owners[i] ){
++count;
}
}
delete length;
return count;
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _owners[tokenId];
require(owner != address(0), "ERC721: owner query for nonexistent token");
return owner;
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
return _name;
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual override {
address owner = ERC721B.ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(
_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not owner nor approved for all"
);
_approve(to, tokenId);
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view virtual override returns (address) {
require(_exists(tokenId), "ERC721: approved query for nonexistent token");
return _tokenApprovals[tokenId];
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
require(operator != _msgSender(), "ERC721: approve to caller");
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_msgSender(), operator, approved);
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
//solhint-disable-next-line max-line-length
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_transfer(from, to, tokenId);
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_safeTransfer(from, to, tokenId, _data);
}
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* `_data` is additional data, it has no specified format and it is sent in call to `to`.
*
* This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
* implement alternative mechanisms to perform token transfer, such as signature-based.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
* and stop existing when they are burned (`_burn`).
*/
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return tokenId < _owners.length && _owners[tokenId] != address(0);
}
/**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
require(_exists(tokenId), "ERC721: operator query for nonexistent token");
address owner = ERC721B.ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
}
/**
* @dev Safely mints `tokenId` and transfers it to `to`.
*
* Requirements:
*
* - `tokenId` must not exist.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
/**
* @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
* forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
*/
function _safeMint(
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_mint(to, tokenId);
require(
_checkOnERC721Received(address(0), to, tokenId, _data),
"ERC721: transfer to non ERC721Receiver implementer"
);
}
/**
* @dev Mints `tokenId` and transfers it to `to`.
*
* WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
*
* Requirements:
*
* - `tokenId` must not exist.
* - `to` cannot be the zero address.
*
* Emits a {Transfer} event.
*/
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId);
_owners.push(to);
emit Transfer(address(0), to, tokenId);
}
/**
* @dev Destroys `tokenId`.
* The approval is cleared when the token is burned.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits a {Transfer} event.
*/
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721B.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId);
// Clear approvals
_approve(address(0), tokenId);
_owners[tokenId] = address(0);
emit Transfer(owner, address(0), tokenId);
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
require(ERC721B.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId);
// Clear approvals from the previous owner
_approve(address(0), tokenId);
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721B.ownerOf(tokenId), to, tokenId);
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
if (to.isContract()) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
return retval == IERC721Receiver.onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
/**
* @dev Hook that is called before any token transfer. This includes minting
* and burning.
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
* - When `to` is zero, ``from``'s `tokenId` will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual {}
} | /********************
* @author: Squeebo *
********************/ | NatSpecMultiLine | _safeMint | function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
| /**
* @dev Safely mints `tokenId` and transfers it to `to`.
*
* Requirements:
*
* - `tokenId` must not exist.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | MIT | ipfs://672fc76424cd92c353e6de815b9bcc53701f37d5371e3774b462983f8ad2f3fe | {
"func_code_index": [
7210,
7325
]
} | 8,987 |
MetaScyra | contracts/Blimpie/ERC721B.sol | 0xd7c57fc28f72cc8ffbd635155d924f0ac3f03f8e | Solidity | ERC721B | abstract contract ERC721B is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to owner address
address[] internal _owners;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
super.supportsInterface(interfaceId);
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: balance query for the zero address");
uint count = 0;
uint length = _owners.length;
for( uint i = 0; i < length; ++i ){
if( owner == _owners[i] ){
++count;
}
}
delete length;
return count;
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _owners[tokenId];
require(owner != address(0), "ERC721: owner query for nonexistent token");
return owner;
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
return _name;
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual override {
address owner = ERC721B.ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(
_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not owner nor approved for all"
);
_approve(to, tokenId);
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view virtual override returns (address) {
require(_exists(tokenId), "ERC721: approved query for nonexistent token");
return _tokenApprovals[tokenId];
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
require(operator != _msgSender(), "ERC721: approve to caller");
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_msgSender(), operator, approved);
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
//solhint-disable-next-line max-line-length
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_transfer(from, to, tokenId);
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_safeTransfer(from, to, tokenId, _data);
}
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* `_data` is additional data, it has no specified format and it is sent in call to `to`.
*
* This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
* implement alternative mechanisms to perform token transfer, such as signature-based.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
* and stop existing when they are burned (`_burn`).
*/
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return tokenId < _owners.length && _owners[tokenId] != address(0);
}
/**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
require(_exists(tokenId), "ERC721: operator query for nonexistent token");
address owner = ERC721B.ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
}
/**
* @dev Safely mints `tokenId` and transfers it to `to`.
*
* Requirements:
*
* - `tokenId` must not exist.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
/**
* @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
* forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
*/
function _safeMint(
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_mint(to, tokenId);
require(
_checkOnERC721Received(address(0), to, tokenId, _data),
"ERC721: transfer to non ERC721Receiver implementer"
);
}
/**
* @dev Mints `tokenId` and transfers it to `to`.
*
* WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
*
* Requirements:
*
* - `tokenId` must not exist.
* - `to` cannot be the zero address.
*
* Emits a {Transfer} event.
*/
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId);
_owners.push(to);
emit Transfer(address(0), to, tokenId);
}
/**
* @dev Destroys `tokenId`.
* The approval is cleared when the token is burned.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits a {Transfer} event.
*/
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721B.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId);
// Clear approvals
_approve(address(0), tokenId);
_owners[tokenId] = address(0);
emit Transfer(owner, address(0), tokenId);
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
require(ERC721B.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId);
// Clear approvals from the previous owner
_approve(address(0), tokenId);
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721B.ownerOf(tokenId), to, tokenId);
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
if (to.isContract()) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
return retval == IERC721Receiver.onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
/**
* @dev Hook that is called before any token transfer. This includes minting
* and burning.
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
* - When `to` is zero, ``from``'s `tokenId` will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual {}
} | /********************
* @author: Squeebo *
********************/ | NatSpecMultiLine | _safeMint | function _safeMint(
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_mint(to, tokenId);
require(
_checkOnERC721Received(address(0), to, tokenId, _data),
"ERC721: transfer to non ERC721Receiver implementer"
);
}
| /**
* @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
* forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | MIT | ipfs://672fc76424cd92c353e6de815b9bcc53701f37d5371e3774b462983f8ad2f3fe | {
"func_code_index": [
7549,
7875
]
} | 8,988 |
MetaScyra | contracts/Blimpie/ERC721B.sol | 0xd7c57fc28f72cc8ffbd635155d924f0ac3f03f8e | Solidity | ERC721B | abstract contract ERC721B is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to owner address
address[] internal _owners;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
super.supportsInterface(interfaceId);
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: balance query for the zero address");
uint count = 0;
uint length = _owners.length;
for( uint i = 0; i < length; ++i ){
if( owner == _owners[i] ){
++count;
}
}
delete length;
return count;
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _owners[tokenId];
require(owner != address(0), "ERC721: owner query for nonexistent token");
return owner;
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
return _name;
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual override {
address owner = ERC721B.ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(
_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not owner nor approved for all"
);
_approve(to, tokenId);
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view virtual override returns (address) {
require(_exists(tokenId), "ERC721: approved query for nonexistent token");
return _tokenApprovals[tokenId];
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
require(operator != _msgSender(), "ERC721: approve to caller");
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_msgSender(), operator, approved);
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
//solhint-disable-next-line max-line-length
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_transfer(from, to, tokenId);
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_safeTransfer(from, to, tokenId, _data);
}
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* `_data` is additional data, it has no specified format and it is sent in call to `to`.
*
* This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
* implement alternative mechanisms to perform token transfer, such as signature-based.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
* and stop existing when they are burned (`_burn`).
*/
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return tokenId < _owners.length && _owners[tokenId] != address(0);
}
/**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
require(_exists(tokenId), "ERC721: operator query for nonexistent token");
address owner = ERC721B.ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
}
/**
* @dev Safely mints `tokenId` and transfers it to `to`.
*
* Requirements:
*
* - `tokenId` must not exist.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
/**
* @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
* forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
*/
function _safeMint(
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_mint(to, tokenId);
require(
_checkOnERC721Received(address(0), to, tokenId, _data),
"ERC721: transfer to non ERC721Receiver implementer"
);
}
/**
* @dev Mints `tokenId` and transfers it to `to`.
*
* WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
*
* Requirements:
*
* - `tokenId` must not exist.
* - `to` cannot be the zero address.
*
* Emits a {Transfer} event.
*/
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId);
_owners.push(to);
emit Transfer(address(0), to, tokenId);
}
/**
* @dev Destroys `tokenId`.
* The approval is cleared when the token is burned.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits a {Transfer} event.
*/
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721B.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId);
// Clear approvals
_approve(address(0), tokenId);
_owners[tokenId] = address(0);
emit Transfer(owner, address(0), tokenId);
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
require(ERC721B.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId);
// Clear approvals from the previous owner
_approve(address(0), tokenId);
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721B.ownerOf(tokenId), to, tokenId);
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
if (to.isContract()) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
return retval == IERC721Receiver.onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
/**
* @dev Hook that is called before any token transfer. This includes minting
* and burning.
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
* - When `to` is zero, ``from``'s `tokenId` will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual {}
} | /********************
* @author: Squeebo *
********************/ | NatSpecMultiLine | _mint | function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId);
_owners.push(to);
emit Transfer(address(0), to, tokenId);
}
| /**
* @dev Mints `tokenId` and transfers it to `to`.
*
* WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
*
* Requirements:
*
* - `tokenId` must not exist.
* - `to` cannot be the zero address.
*
* Emits a {Transfer} event.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | MIT | ipfs://672fc76424cd92c353e6de815b9bcc53701f37d5371e3774b462983f8ad2f3fe | {
"func_code_index": [
8206,
8557
]
} | 8,989 |
MetaScyra | contracts/Blimpie/ERC721B.sol | 0xd7c57fc28f72cc8ffbd635155d924f0ac3f03f8e | Solidity | ERC721B | abstract contract ERC721B is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to owner address
address[] internal _owners;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
super.supportsInterface(interfaceId);
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: balance query for the zero address");
uint count = 0;
uint length = _owners.length;
for( uint i = 0; i < length; ++i ){
if( owner == _owners[i] ){
++count;
}
}
delete length;
return count;
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _owners[tokenId];
require(owner != address(0), "ERC721: owner query for nonexistent token");
return owner;
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
return _name;
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual override {
address owner = ERC721B.ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(
_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not owner nor approved for all"
);
_approve(to, tokenId);
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view virtual override returns (address) {
require(_exists(tokenId), "ERC721: approved query for nonexistent token");
return _tokenApprovals[tokenId];
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
require(operator != _msgSender(), "ERC721: approve to caller");
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_msgSender(), operator, approved);
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
//solhint-disable-next-line max-line-length
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_transfer(from, to, tokenId);
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_safeTransfer(from, to, tokenId, _data);
}
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* `_data` is additional data, it has no specified format and it is sent in call to `to`.
*
* This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
* implement alternative mechanisms to perform token transfer, such as signature-based.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
* and stop existing when they are burned (`_burn`).
*/
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return tokenId < _owners.length && _owners[tokenId] != address(0);
}
/**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
require(_exists(tokenId), "ERC721: operator query for nonexistent token");
address owner = ERC721B.ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
}
/**
* @dev Safely mints `tokenId` and transfers it to `to`.
*
* Requirements:
*
* - `tokenId` must not exist.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
/**
* @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
* forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
*/
function _safeMint(
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_mint(to, tokenId);
require(
_checkOnERC721Received(address(0), to, tokenId, _data),
"ERC721: transfer to non ERC721Receiver implementer"
);
}
/**
* @dev Mints `tokenId` and transfers it to `to`.
*
* WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
*
* Requirements:
*
* - `tokenId` must not exist.
* - `to` cannot be the zero address.
*
* Emits a {Transfer} event.
*/
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId);
_owners.push(to);
emit Transfer(address(0), to, tokenId);
}
/**
* @dev Destroys `tokenId`.
* The approval is cleared when the token is burned.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits a {Transfer} event.
*/
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721B.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId);
// Clear approvals
_approve(address(0), tokenId);
_owners[tokenId] = address(0);
emit Transfer(owner, address(0), tokenId);
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
require(ERC721B.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId);
// Clear approvals from the previous owner
_approve(address(0), tokenId);
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721B.ownerOf(tokenId), to, tokenId);
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
if (to.isContract()) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
return retval == IERC721Receiver.onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
/**
* @dev Hook that is called before any token transfer. This includes minting
* and burning.
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
* - When `to` is zero, ``from``'s `tokenId` will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual {}
} | /********************
* @author: Squeebo *
********************/ | NatSpecMultiLine | _burn | function _burn(uint256 tokenId) internal virtual {
address owner = ERC721B.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId);
// Clear approvals
_approve(address(0), tokenId);
_owners[tokenId] = address(0);
emit Transfer(owner, address(0), tokenId);
}
| /**
* @dev Destroys `tokenId`.
* The approval is cleared when the token is burned.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits a {Transfer} event.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | MIT | ipfs://672fc76424cd92c353e6de815b9bcc53701f37d5371e3774b462983f8ad2f3fe | {
"func_code_index": [
8781,
9119
]
} | 8,990 |
MetaScyra | contracts/Blimpie/ERC721B.sol | 0xd7c57fc28f72cc8ffbd635155d924f0ac3f03f8e | Solidity | ERC721B | abstract contract ERC721B is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to owner address
address[] internal _owners;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
super.supportsInterface(interfaceId);
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: balance query for the zero address");
uint count = 0;
uint length = _owners.length;
for( uint i = 0; i < length; ++i ){
if( owner == _owners[i] ){
++count;
}
}
delete length;
return count;
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _owners[tokenId];
require(owner != address(0), "ERC721: owner query for nonexistent token");
return owner;
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
return _name;
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual override {
address owner = ERC721B.ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(
_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not owner nor approved for all"
);
_approve(to, tokenId);
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view virtual override returns (address) {
require(_exists(tokenId), "ERC721: approved query for nonexistent token");
return _tokenApprovals[tokenId];
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
require(operator != _msgSender(), "ERC721: approve to caller");
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_msgSender(), operator, approved);
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
//solhint-disable-next-line max-line-length
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_transfer(from, to, tokenId);
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_safeTransfer(from, to, tokenId, _data);
}
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* `_data` is additional data, it has no specified format and it is sent in call to `to`.
*
* This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
* implement alternative mechanisms to perform token transfer, such as signature-based.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
* and stop existing when they are burned (`_burn`).
*/
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return tokenId < _owners.length && _owners[tokenId] != address(0);
}
/**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
require(_exists(tokenId), "ERC721: operator query for nonexistent token");
address owner = ERC721B.ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
}
/**
* @dev Safely mints `tokenId` and transfers it to `to`.
*
* Requirements:
*
* - `tokenId` must not exist.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
/**
* @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
* forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
*/
function _safeMint(
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_mint(to, tokenId);
require(
_checkOnERC721Received(address(0), to, tokenId, _data),
"ERC721: transfer to non ERC721Receiver implementer"
);
}
/**
* @dev Mints `tokenId` and transfers it to `to`.
*
* WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
*
* Requirements:
*
* - `tokenId` must not exist.
* - `to` cannot be the zero address.
*
* Emits a {Transfer} event.
*/
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId);
_owners.push(to);
emit Transfer(address(0), to, tokenId);
}
/**
* @dev Destroys `tokenId`.
* The approval is cleared when the token is burned.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits a {Transfer} event.
*/
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721B.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId);
// Clear approvals
_approve(address(0), tokenId);
_owners[tokenId] = address(0);
emit Transfer(owner, address(0), tokenId);
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
require(ERC721B.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId);
// Clear approvals from the previous owner
_approve(address(0), tokenId);
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721B.ownerOf(tokenId), to, tokenId);
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
if (to.isContract()) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
return retval == IERC721Receiver.onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
/**
* @dev Hook that is called before any token transfer. This includes minting
* and burning.
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
* - When `to` is zero, ``from``'s `tokenId` will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual {}
} | /********************
* @author: Squeebo *
********************/ | NatSpecMultiLine | _transfer | function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
require(ERC721B.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId);
// Clear approvals from the previous owner
_approve(address(0), tokenId);
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
}
| /**
* @dev Transfers `tokenId` from `from` to `to`.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | MIT | ipfs://672fc76424cd92c353e6de815b9bcc53701f37d5371e3774b462983f8ad2f3fe | {
"func_code_index": [
9451,
9973
]
} | 8,991 |
MetaScyra | contracts/Blimpie/ERC721B.sol | 0xd7c57fc28f72cc8ffbd635155d924f0ac3f03f8e | Solidity | ERC721B | abstract contract ERC721B is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to owner address
address[] internal _owners;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
super.supportsInterface(interfaceId);
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: balance query for the zero address");
uint count = 0;
uint length = _owners.length;
for( uint i = 0; i < length; ++i ){
if( owner == _owners[i] ){
++count;
}
}
delete length;
return count;
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _owners[tokenId];
require(owner != address(0), "ERC721: owner query for nonexistent token");
return owner;
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
return _name;
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual override {
address owner = ERC721B.ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(
_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not owner nor approved for all"
);
_approve(to, tokenId);
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view virtual override returns (address) {
require(_exists(tokenId), "ERC721: approved query for nonexistent token");
return _tokenApprovals[tokenId];
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
require(operator != _msgSender(), "ERC721: approve to caller");
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_msgSender(), operator, approved);
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
//solhint-disable-next-line max-line-length
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_transfer(from, to, tokenId);
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_safeTransfer(from, to, tokenId, _data);
}
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* `_data` is additional data, it has no specified format and it is sent in call to `to`.
*
* This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
* implement alternative mechanisms to perform token transfer, such as signature-based.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
* and stop existing when they are burned (`_burn`).
*/
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return tokenId < _owners.length && _owners[tokenId] != address(0);
}
/**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
require(_exists(tokenId), "ERC721: operator query for nonexistent token");
address owner = ERC721B.ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
}
/**
* @dev Safely mints `tokenId` and transfers it to `to`.
*
* Requirements:
*
* - `tokenId` must not exist.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
/**
* @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
* forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
*/
function _safeMint(
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_mint(to, tokenId);
require(
_checkOnERC721Received(address(0), to, tokenId, _data),
"ERC721: transfer to non ERC721Receiver implementer"
);
}
/**
* @dev Mints `tokenId` and transfers it to `to`.
*
* WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
*
* Requirements:
*
* - `tokenId` must not exist.
* - `to` cannot be the zero address.
*
* Emits a {Transfer} event.
*/
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId);
_owners.push(to);
emit Transfer(address(0), to, tokenId);
}
/**
* @dev Destroys `tokenId`.
* The approval is cleared when the token is burned.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits a {Transfer} event.
*/
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721B.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId);
// Clear approvals
_approve(address(0), tokenId);
_owners[tokenId] = address(0);
emit Transfer(owner, address(0), tokenId);
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
require(ERC721B.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId);
// Clear approvals from the previous owner
_approve(address(0), tokenId);
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721B.ownerOf(tokenId), to, tokenId);
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
if (to.isContract()) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
return retval == IERC721Receiver.onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
/**
* @dev Hook that is called before any token transfer. This includes minting
* and burning.
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
* - When `to` is zero, ``from``'s `tokenId` will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual {}
} | /********************
* @author: Squeebo *
********************/ | NatSpecMultiLine | _approve | function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721B.ownerOf(tokenId), to, tokenId);
}
| /**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | MIT | ipfs://672fc76424cd92c353e6de815b9bcc53701f37d5371e3774b462983f8ad2f3fe | {
"func_code_index": [
10086,
10266
]
} | 8,992 |
MetaScyra | contracts/Blimpie/ERC721B.sol | 0xd7c57fc28f72cc8ffbd635155d924f0ac3f03f8e | Solidity | ERC721B | abstract contract ERC721B is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to owner address
address[] internal _owners;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
super.supportsInterface(interfaceId);
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: balance query for the zero address");
uint count = 0;
uint length = _owners.length;
for( uint i = 0; i < length; ++i ){
if( owner == _owners[i] ){
++count;
}
}
delete length;
return count;
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _owners[tokenId];
require(owner != address(0), "ERC721: owner query for nonexistent token");
return owner;
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
return _name;
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual override {
address owner = ERC721B.ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(
_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not owner nor approved for all"
);
_approve(to, tokenId);
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view virtual override returns (address) {
require(_exists(tokenId), "ERC721: approved query for nonexistent token");
return _tokenApprovals[tokenId];
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
require(operator != _msgSender(), "ERC721: approve to caller");
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_msgSender(), operator, approved);
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
//solhint-disable-next-line max-line-length
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_transfer(from, to, tokenId);
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_safeTransfer(from, to, tokenId, _data);
}
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* `_data` is additional data, it has no specified format and it is sent in call to `to`.
*
* This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
* implement alternative mechanisms to perform token transfer, such as signature-based.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
* and stop existing when they are burned (`_burn`).
*/
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return tokenId < _owners.length && _owners[tokenId] != address(0);
}
/**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
require(_exists(tokenId), "ERC721: operator query for nonexistent token");
address owner = ERC721B.ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
}
/**
* @dev Safely mints `tokenId` and transfers it to `to`.
*
* Requirements:
*
* - `tokenId` must not exist.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
/**
* @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
* forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
*/
function _safeMint(
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_mint(to, tokenId);
require(
_checkOnERC721Received(address(0), to, tokenId, _data),
"ERC721: transfer to non ERC721Receiver implementer"
);
}
/**
* @dev Mints `tokenId` and transfers it to `to`.
*
* WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
*
* Requirements:
*
* - `tokenId` must not exist.
* - `to` cannot be the zero address.
*
* Emits a {Transfer} event.
*/
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId);
_owners.push(to);
emit Transfer(address(0), to, tokenId);
}
/**
* @dev Destroys `tokenId`.
* The approval is cleared when the token is burned.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits a {Transfer} event.
*/
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721B.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId);
// Clear approvals
_approve(address(0), tokenId);
_owners[tokenId] = address(0);
emit Transfer(owner, address(0), tokenId);
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
require(ERC721B.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId);
// Clear approvals from the previous owner
_approve(address(0), tokenId);
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721B.ownerOf(tokenId), to, tokenId);
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
if (to.isContract()) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
return retval == IERC721Receiver.onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
/**
* @dev Hook that is called before any token transfer. This includes minting
* and burning.
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
* - When `to` is zero, ``from``'s `tokenId` will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual {}
} | /********************
* @author: Squeebo *
********************/ | NatSpecMultiLine | _checkOnERC721Received | function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
if (to.isContract()) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
return retval == IERC721Receiver.onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
| /**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | MIT | ipfs://672fc76424cd92c353e6de815b9bcc53701f37d5371e3774b462983f8ad2f3fe | {
"func_code_index": [
10828,
11632
]
} | 8,993 |
MetaScyra | contracts/Blimpie/ERC721B.sol | 0xd7c57fc28f72cc8ffbd635155d924f0ac3f03f8e | Solidity | ERC721B | abstract contract ERC721B is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to owner address
address[] internal _owners;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
super.supportsInterface(interfaceId);
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: balance query for the zero address");
uint count = 0;
uint length = _owners.length;
for( uint i = 0; i < length; ++i ){
if( owner == _owners[i] ){
++count;
}
}
delete length;
return count;
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _owners[tokenId];
require(owner != address(0), "ERC721: owner query for nonexistent token");
return owner;
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
return _name;
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual override {
address owner = ERC721B.ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(
_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not owner nor approved for all"
);
_approve(to, tokenId);
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view virtual override returns (address) {
require(_exists(tokenId), "ERC721: approved query for nonexistent token");
return _tokenApprovals[tokenId];
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
require(operator != _msgSender(), "ERC721: approve to caller");
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_msgSender(), operator, approved);
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
//solhint-disable-next-line max-line-length
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_transfer(from, to, tokenId);
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_safeTransfer(from, to, tokenId, _data);
}
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* `_data` is additional data, it has no specified format and it is sent in call to `to`.
*
* This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
* implement alternative mechanisms to perform token transfer, such as signature-based.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
* and stop existing when they are burned (`_burn`).
*/
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return tokenId < _owners.length && _owners[tokenId] != address(0);
}
/**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
require(_exists(tokenId), "ERC721: operator query for nonexistent token");
address owner = ERC721B.ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
}
/**
* @dev Safely mints `tokenId` and transfers it to `to`.
*
* Requirements:
*
* - `tokenId` must not exist.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
/**
* @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
* forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
*/
function _safeMint(
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_mint(to, tokenId);
require(
_checkOnERC721Received(address(0), to, tokenId, _data),
"ERC721: transfer to non ERC721Receiver implementer"
);
}
/**
* @dev Mints `tokenId` and transfers it to `to`.
*
* WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
*
* Requirements:
*
* - `tokenId` must not exist.
* - `to` cannot be the zero address.
*
* Emits a {Transfer} event.
*/
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId);
_owners.push(to);
emit Transfer(address(0), to, tokenId);
}
/**
* @dev Destroys `tokenId`.
* The approval is cleared when the token is burned.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits a {Transfer} event.
*/
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721B.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId);
// Clear approvals
_approve(address(0), tokenId);
_owners[tokenId] = address(0);
emit Transfer(owner, address(0), tokenId);
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
require(ERC721B.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId);
// Clear approvals from the previous owner
_approve(address(0), tokenId);
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721B.ownerOf(tokenId), to, tokenId);
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
if (to.isContract()) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
return retval == IERC721Receiver.onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
/**
* @dev Hook that is called before any token transfer. This includes minting
* and burning.
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
* - When `to` is zero, ``from``'s `tokenId` will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual {}
} | /********************
* @author: Squeebo *
********************/ | NatSpecMultiLine | _beforeTokenTransfer | function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual {}
| /**
* @dev Hook that is called before any token transfer. This includes minting
* and burning.
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
* - When `to` is zero, ``from``'s `tokenId` will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | MIT | ipfs://672fc76424cd92c353e6de815b9bcc53701f37d5371e3774b462983f8ad2f3fe | {
"func_code_index": [
12199,
12330
]
} | 8,994 |
MetaScyra | contracts/Blimpie/ERC721B.sol | 0xd7c57fc28f72cc8ffbd635155d924f0ac3f03f8e | Solidity | ERC721EnumerableB | abstract contract ERC721EnumerableB is ERC721B, IERC721Enumerable {
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(IERC165, ERC721B)
returns (bool)
{
return
interfaceId == type(IERC721Enumerable).interfaceId ||
super.supportsInterface(interfaceId);
}
/**
* @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
*/
function tokenOfOwnerByIndex(address owner, uint256 index)
public
view
virtual
override
returns (uint256 tokenId)
{
require(
index < this.balanceOf(owner),
"ERC721Enumerable: owner index out of bounds"
);
uint256 count;
uint256 length = _owners.length;
for (uint256 i; i < length; ++i) {
if (owner == _owners[i]) {
if (count == index) {
delete count;
delete length;
return i;
} else ++count;
}
}
delete count;
delete length;
require(false, "ERC721Enumerable: owner index out of bounds");
}
/**
* @dev See {IERC721Enumerable-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
return _owners.length;
}
/**
* @dev See {IERC721Enumerable-tokenByIndex}.
*/
function tokenByIndex(uint256 index)
public
view
virtual
override
returns (uint256)
{
require(
index < _owners.length,
"ERC721Enumerable: global index out of bounds"
);
return index;
}
} | /**
* @dev This implements an optional extension of {ERC721} defined in the EIP that adds
* enumerability of all the token ids in the contract as well as all token ids owned by each
* account.
*/ | NatSpecMultiLine | supportsInterface | function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(IERC165, ERC721B)
returns (bool)
{
return
interfaceId == type(IERC721Enumerable).interfaceId ||
super.supportsInterface(interfaceId);
}
| /**
* @dev See {IERC165-supportsInterface}.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | MIT | ipfs://672fc76424cd92c353e6de815b9bcc53701f37d5371e3774b462983f8ad2f3fe | {
"func_code_index": [
137,
443
]
} | 8,995 |
MetaScyra | contracts/Blimpie/ERC721B.sol | 0xd7c57fc28f72cc8ffbd635155d924f0ac3f03f8e | Solidity | ERC721EnumerableB | abstract contract ERC721EnumerableB is ERC721B, IERC721Enumerable {
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(IERC165, ERC721B)
returns (bool)
{
return
interfaceId == type(IERC721Enumerable).interfaceId ||
super.supportsInterface(interfaceId);
}
/**
* @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
*/
function tokenOfOwnerByIndex(address owner, uint256 index)
public
view
virtual
override
returns (uint256 tokenId)
{
require(
index < this.balanceOf(owner),
"ERC721Enumerable: owner index out of bounds"
);
uint256 count;
uint256 length = _owners.length;
for (uint256 i; i < length; ++i) {
if (owner == _owners[i]) {
if (count == index) {
delete count;
delete length;
return i;
} else ++count;
}
}
delete count;
delete length;
require(false, "ERC721Enumerable: owner index out of bounds");
}
/**
* @dev See {IERC721Enumerable-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
return _owners.length;
}
/**
* @dev See {IERC721Enumerable-tokenByIndex}.
*/
function tokenByIndex(uint256 index)
public
view
virtual
override
returns (uint256)
{
require(
index < _owners.length,
"ERC721Enumerable: global index out of bounds"
);
return index;
}
} | /**
* @dev This implements an optional extension of {ERC721} defined in the EIP that adds
* enumerability of all the token ids in the contract as well as all token ids owned by each
* account.
*/ | NatSpecMultiLine | tokenOfOwnerByIndex | function tokenOfOwnerByIndex(address owner, uint256 index)
public
view
virtual
override
returns (uint256 tokenId)
{
require(
index < this.balanceOf(owner),
"ERC721Enumerable: owner index out of bounds"
);
uint256 count;
uint256 length = _owners.length;
for (uint256 i; i < length; ++i) {
if (owner == _owners[i]) {
if (count == index) {
delete count;
delete length;
return i;
} else ++count;
}
}
delete count;
delete length;
require(false, "ERC721Enumerable: owner index out of bounds");
}
| /**
* @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | MIT | ipfs://672fc76424cd92c353e6de815b9bcc53701f37d5371e3774b462983f8ad2f3fe | {
"func_code_index": [
522,
1305
]
} | 8,996 |
MetaScyra | contracts/Blimpie/ERC721B.sol | 0xd7c57fc28f72cc8ffbd635155d924f0ac3f03f8e | Solidity | ERC721EnumerableB | abstract contract ERC721EnumerableB is ERC721B, IERC721Enumerable {
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(IERC165, ERC721B)
returns (bool)
{
return
interfaceId == type(IERC721Enumerable).interfaceId ||
super.supportsInterface(interfaceId);
}
/**
* @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
*/
function tokenOfOwnerByIndex(address owner, uint256 index)
public
view
virtual
override
returns (uint256 tokenId)
{
require(
index < this.balanceOf(owner),
"ERC721Enumerable: owner index out of bounds"
);
uint256 count;
uint256 length = _owners.length;
for (uint256 i; i < length; ++i) {
if (owner == _owners[i]) {
if (count == index) {
delete count;
delete length;
return i;
} else ++count;
}
}
delete count;
delete length;
require(false, "ERC721Enumerable: owner index out of bounds");
}
/**
* @dev See {IERC721Enumerable-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
return _owners.length;
}
/**
* @dev See {IERC721Enumerable-tokenByIndex}.
*/
function tokenByIndex(uint256 index)
public
view
virtual
override
returns (uint256)
{
require(
index < _owners.length,
"ERC721Enumerable: global index out of bounds"
);
return index;
}
} | /**
* @dev This implements an optional extension of {ERC721} defined in the EIP that adds
* enumerability of all the token ids in the contract as well as all token ids owned by each
* account.
*/ | NatSpecMultiLine | totalSupply | function totalSupply() public view virtual override returns (uint256) {
return _owners.length;
}
| /**
* @dev See {IERC721Enumerable-totalSupply}.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | MIT | ipfs://672fc76424cd92c353e6de815b9bcc53701f37d5371e3774b462983f8ad2f3fe | {
"func_code_index": [
1376,
1491
]
} | 8,997 |
MetaScyra | contracts/Blimpie/ERC721B.sol | 0xd7c57fc28f72cc8ffbd635155d924f0ac3f03f8e | Solidity | ERC721EnumerableB | abstract contract ERC721EnumerableB is ERC721B, IERC721Enumerable {
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(IERC165, ERC721B)
returns (bool)
{
return
interfaceId == type(IERC721Enumerable).interfaceId ||
super.supportsInterface(interfaceId);
}
/**
* @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
*/
function tokenOfOwnerByIndex(address owner, uint256 index)
public
view
virtual
override
returns (uint256 tokenId)
{
require(
index < this.balanceOf(owner),
"ERC721Enumerable: owner index out of bounds"
);
uint256 count;
uint256 length = _owners.length;
for (uint256 i; i < length; ++i) {
if (owner == _owners[i]) {
if (count == index) {
delete count;
delete length;
return i;
} else ++count;
}
}
delete count;
delete length;
require(false, "ERC721Enumerable: owner index out of bounds");
}
/**
* @dev See {IERC721Enumerable-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
return _owners.length;
}
/**
* @dev See {IERC721Enumerable-tokenByIndex}.
*/
function tokenByIndex(uint256 index)
public
view
virtual
override
returns (uint256)
{
require(
index < _owners.length,
"ERC721Enumerable: global index out of bounds"
);
return index;
}
} | /**
* @dev This implements an optional extension of {ERC721} defined in the EIP that adds
* enumerability of all the token ids in the contract as well as all token ids owned by each
* account.
*/ | NatSpecMultiLine | tokenByIndex | function tokenByIndex(uint256 index)
public
view
virtual
override
returns (uint256)
{
require(
index < _owners.length,
"ERC721Enumerable: global index out of bounds"
);
return index;
}
| /**
* @dev See {IERC721Enumerable-tokenByIndex}.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | MIT | ipfs://672fc76424cd92c353e6de815b9bcc53701f37d5371e3774b462983f8ad2f3fe | {
"func_code_index": [
1563,
1860
]
} | 8,998 |
NipponInu | NipponInu.sol | 0xc4ae41030535080907e5fbf1ad8f11fcbbc86199 | Solidity | IERC20 | interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
} | totalSupply | function totalSupply() external view returns (uint256);
| /**
* @dev Returns the amount of tokens in existence.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://8911bc60efd34d07cefe7032fb8eb60586a10ae7ab658ba04757b83418508612 | {
"func_code_index": [
94,
154
]
} | 8,999 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.