// SPDX-License-Identifier: MITpragmasolidity ^0.8.0;/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/abstractcontractContext{
function_msgSender() internalviewvirtualreturns (address) {
returnmsg.sender;
}
function_msgData() internalviewvirtualreturns (bytescalldata) {
returnmsg.data;
}
}
Contract Source Code
File 2 of 14: IERC165.sol
// SPDX-License-Identifier: MITpragmasolidity ^0.8.0;/**
* @dev Interface of the ERC165 standard, as defined in the
* https://eips.ethereum.org/EIPS/eip-165[EIP].
*
* Implementers can declare support of contract interfaces, which can then be
* queried by others ({ERC165Checker}).
*
* For an implementation, see {ERC165}.
*/interfaceIERC165{
/**
* @dev Returns true if this contract implements the interface defined by
* `interfaceId`. See the corresponding
* https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
* to learn more about how these ids are created.
*
* This function call must use less than 30 000 gas.
*/functionsupportsInterface(bytes4 interfaceId) externalviewreturns (bool);
}
Contract Source Code
File 3 of 14: IERC721.sol
// SPDX-License-Identifier: MITpragmasolidity ^0.8.0;import"../../utils/introspection/IERC165.sol";
/**
* @dev Required interface of an ERC721 compliant contract.
*/interfaceIERC721isIERC165{
/**
* @dev Emitted when `tokenId` token is transferred from `from` to `to`.
*/eventTransfer(addressindexedfrom, addressindexed to, uint256indexed tokenId);
/**
* @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
*/eventApproval(addressindexed owner, addressindexed approved, uint256indexed tokenId);
/**
* @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
*/eventApprovalForAll(addressindexed owner, addressindexed operator, bool approved);
/**
* @dev Returns the number of tokens in ``owner``'s account.
*/functionbalanceOf(address owner) externalviewreturns (uint256 balance);
/**
* @dev Returns the owner of the `tokenId` token.
*
* Requirements:
*
* - `tokenId` must exist.
*/functionownerOf(uint256 tokenId) externalviewreturns (address owner);
/**
* @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.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/functionsafeTransferFrom(addressfrom,
address to,
uint256 tokenId
) external;
/**
* @dev Transfers `tokenId` token from `from` to `to`.
*
* WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
* - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
*
* Emits a {Transfer} event.
*/functiontransferFrom(addressfrom,
address to,
uint256 tokenId
) external;
/**
* @dev Gives permission to `to` to transfer `tokenId` token to another account.
* The approval is cleared when the token is transferred.
*
* Only a single account can be approved at a time, so approving the zero address clears previous approvals.
*
* Requirements:
*
* - The caller must own the token or be an approved operator.
* - `tokenId` must exist.
*
* Emits an {Approval} event.
*/functionapprove(address to, uint256 tokenId) external;
/**
* @dev Returns the account approved for `tokenId` token.
*
* Requirements:
*
* - `tokenId` must exist.
*/functiongetApproved(uint256 tokenId) externalviewreturns (address operator);
/**
* @dev Approve or remove `operator` as an operator for the caller.
* Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
*
* Requirements:
*
* - The `operator` cannot be the caller.
*
* Emits an {ApprovalForAll} event.
*/functionsetApprovalForAll(address operator, bool _approved) external;
/**
* @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
*
* See {setApprovalForAll}
*/functionisApprovedForAll(address owner, address operator) externalviewreturns (bool);
/**
* @dev Safely transfers `tokenId` token from `from` to `to`.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/functionsafeTransferFrom(addressfrom,
address to,
uint256 tokenId,
bytescalldata data
) external;
}
Contract Source Code
File 4 of 14: IERC721Enumerable.sol
// SPDX-License-Identifier: MITpragmasolidity ^0.8.0;import"../IERC721.sol";
/**
* @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
* @dev See https://eips.ethereum.org/EIPS/eip-721
*/interfaceIERC721EnumerableisIERC721{
/**
* @dev Returns the total amount of tokens stored by the contract.
*/functiontotalSupply() externalviewreturns (uint256);
/**
* @dev Returns a token ID owned by `owner` at a given `index` of its token list.
* Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
*/functiontokenOfOwnerByIndex(address owner, uint256 index) externalviewreturns (uint256 tokenId);
/**
* @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
* Use along with {totalSupply} to enumerate all tokens.
*/functiontokenByIndex(uint256 index) externalviewreturns (uint256);
}
// SPDX-License-Identifier: MIT LICENSEpragmasolidity ^0.8.0;interfaceIWnDGame{
}
Contract Source Code
File 11 of 14: Ownable.sol
// SPDX-License-Identifier: MITpragmasolidity ^0.8.0;import"../utils/Context.sol";
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/abstractcontractOwnableisContext{
addressprivate _owner;
eventOwnershipTransferred(addressindexed previousOwner, addressindexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/constructor() {
_setOwner(_msgSender());
}
/**
* @dev Returns the address of the current owner.
*/functionowner() publicviewvirtualreturns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/modifieronlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/functionrenounceOwnership() publicvirtualonlyOwner{
_setOwner(address(0));
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/functiontransferOwnership(address newOwner) publicvirtualonlyOwner{
require(newOwner !=address(0), "Ownable: new owner is the zero address");
_setOwner(newOwner);
}
function_setOwner(address newOwner) private{
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
Contract Source Code
File 12 of 14: Pausable.sol
// SPDX-License-Identifier: MITpragmasolidity ^0.8.0;import"../utils/Context.sol";
/**
* @dev Contract module which allows children to implement an emergency stop
* mechanism that can be triggered by an authorized account.
*
* This module is used through inheritance. It will make available the
* modifiers `whenNotPaused` and `whenPaused`, which can be applied to
* the functions of your contract. Note that they will not be pausable by
* simply including this module, only once the modifiers are put in place.
*/abstractcontractPausableisContext{
/**
* @dev Emitted when the pause is triggered by `account`.
*/eventPaused(address account);
/**
* @dev Emitted when the pause is lifted by `account`.
*/eventUnpaused(address account);
boolprivate _paused;
/**
* @dev Initializes the contract in unpaused state.
*/constructor() {
_paused =false;
}
/**
* @dev Returns true if the contract is paused, and false otherwise.
*/functionpaused() publicviewvirtualreturns (bool) {
return _paused;
}
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*
* Requirements:
*
* - The contract must not be paused.
*/modifierwhenNotPaused() {
require(!paused(), "Pausable: paused");
_;
}
/**
* @dev Modifier to make a function callable only when the contract is paused.
*
* Requirements:
*
* - The contract must be paused.
*/modifierwhenPaused() {
require(paused(), "Pausable: not paused");
_;
}
/**
* @dev Triggers stopped state.
*
* Requirements:
*
* - The contract must not be paused.
*/function_pause() internalvirtualwhenNotPaused{
_paused =true;
emit Paused(_msgSender());
}
/**
* @dev Returns to normal state.
*
* Requirements:
*
* - The contract must be paused.
*/function_unpause() internalvirtualwhenPaused{
_paused =false;
emit Unpaused(_msgSender());
}
}
Contract Source Code
File 13 of 14: ReentrancyGuard.sol
// SPDX-License-Identifier: MITpragmasolidity ^0.8.0;/**
* @dev Contract module that helps prevent reentrant calls to a function.
*
* Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
* available, which can be applied to functions to make sure there are no nested
* (reentrant) calls to them.
*
* Note that because there is a single `nonReentrant` guard, functions marked as
* `nonReentrant` may not call one another. This can be worked around by making
* those functions `private`, and then adding `external` `nonReentrant` entry
* points to them.
*
* TIP: If you would like to learn more about reentrancy and alternative ways
* to protect against it, check out our blog post
* https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
*/abstractcontractReentrancyGuard{
// Booleans are more expensive than uint256 or any type that takes up a full// word because each write operation emits an extra SLOAD to first read the// slot's contents, replace the bits taken up by the boolean, and then write// back. This is the compiler's defense against contract upgrades and// pointer aliasing, and it cannot be disabled.// The values being non-zero value makes deployment a bit more expensive,// but in exchange the refund on every call to nonReentrant will be lower in// amount. Since refunds are capped to a percentage of the total// transaction's gas, it is best to keep them low in cases like this one, to// increase the likelihood of the full refund coming into effect.uint256privateconstant _NOT_ENTERED =1;
uint256privateconstant _ENTERED =2;
uint256private _status;
constructor() {
_status = _NOT_ENTERED;
}
/**
* @dev Prevents a contract from calling itself, directly or indirectly.
* Calling a `nonReentrant` function from another `nonReentrant`
* function is not supported. It is possible to prevent this from happening
* by making the `nonReentrant` function external, and make it call a
* `private` function that does the actual work.
*/modifiernonReentrant() {
// On the first call to nonReentrant, _notEntered will be truerequire(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
Contract Source Code
File 14 of 14: WnDGameTG.sol
// SPDX-License-Identifier: MIT LICENSEpragmasolidity ^0.8.0;import"@openzeppelin/contracts/access/Ownable.sol";
import"@openzeppelin/contracts/security/Pausable.sol";
import"@openzeppelin/contracts/security/ReentrancyGuard.sol";
import"./interfaces/IWnDGame.sol";
import"./interfaces/ITrainingGrounds.sol";
import"./interfaces/ITraits.sol";
import"./interfaces/IGP.sol";
import"./interfaces/IWnD.sol";
import"./interfaces/ISacrificialAlter.sol";
contractWnDGameTGisIWnDGame, Ownable, ReentrancyGuard, Pausable{
structMintCommit {
address recipient;
bool stake;
uint16 amount;
}
structTrainingCommit {
address tokenOwner;
uint16 tokenId;
bool isAdding; // If false, the commit is for claiming rewardsbool isUnstaking; // If !isAdding, this will determine if user is unstakingbool isTraining; // If !isAdding, this will define where the staked token is (only necessary for wizards)
}
uint256publicconstant TREASURE_CHEST =5;
// max $GP cost uint256private maxGpCost =72000ether;
/** =========== MINTING COMMIT AND REVEAL VARIABLES =========== */// commitId -> array of all pending commitsmapping(uint16=> MintCommit[]) private commitQueueMints;
// Track when a commitId started accepting commitsmapping(uint16=>uint256) private commitIdStartTimeMints;
mapping(address=>uint16) private pendingMintCommitsForAddr;
// Tracks the current commitId batch to put new commits intouint16private _commitIdCurMints =1;
// tracks the oldest commitId that has commits needing to be revealeduint16private _commitIdPendingMints =0;
/** =========== TRAINING COMMIT AND REVEAL VARIABLES =========== */// commitId -> array of all pending commitsmapping(uint16=> TrainingCommit[]) private commitQueueTraining;
// Track when a commitId started accepting commitsmapping(uint16=>uint256) private commitIdStartTimeTraining;
mapping(address=>uint16) private pendingTrainingCommitsForAddr;
mapping(uint256=>bool) private tokenHasPendingCommit;
// Tracks the current commitId batch to put new commits intouint16private _commitIdCurTraining =1;
// tracks the oldest commitId that has commits needing to be revealeduint16private _commitIdPendingTraining =0;
// Time from starting a commit batch to allow new commits to enteruint64private timePerCommitBatch =5minutes;
// Time from starting a commit batch to allow users to reveal these in exchange for $GPuint64private timeToAllowArb =30minutes;
uint16private pendingMintAmt;
boolpublic allowCommits =true;
uint256private revealRewardAmt =10000ether;
uint256private stakingCost =8000ether;
// reference to the TrainingGrounds
ITrainingGrounds public trainingGrounds;
// reference to $GP for burning on mint
IGP public gpToken;
// reference to Traits
ITraits public traits;
// reference to NFT collection
IWnD public wndNFT;
// reference to alter collection
ISacrificialAlter public alter;
constructor() {
_pause();
}
/** CRITICAL TO SETUP */modifierrequireContractsSet() {
require(address(gpToken) !=address(0) &&address(traits) !=address(0)
&&address(wndNFT) !=address(0) &&address(alter) !=address(0)
&&address(trainingGrounds) !=address(0)
, "Contracts not set");
_;
}
functionsetContracts(address _gp, address _traits, address _wnd, address _alter, address _trainingGrounds) externalonlyOwner{
gpToken = IGP(_gp);
traits = ITraits(_traits);
wndNFT = IWnD(_wnd);
alter = ISacrificialAlter(_alter);
trainingGrounds = ITrainingGrounds(_trainingGrounds);
}
/** EXTERNAL */functiongetPendingMintCommits(address addr) internalviewreturns (uint16) {
return pendingMintCommitsForAddr[addr];
}
functiongetPendingTrainingCommits(address addr) externalviewreturns (uint16) {
return pendingTrainingCommitsForAddr[addr];
}
functionisTokenPendingReveal(uint256 tokenId) externalviewreturns (bool) {
return tokenHasPendingCommit[tokenId];
}
functionhasStaleMintCommit() internalviewreturns (bool) {
uint16 pendingId = _commitIdPendingMints;
// Check if the revealable commitId has anything to commit and increment it until it does, or is the same as the current commitIdwhile(commitQueueMints[pendingId].length==0&& pendingId < _commitIdCurMints) {
// Only iterate if the commit pending is empty and behind the current id.// This is to prevent it from being in front of the current id and missing commits.
pendingId +=1;
}
return commitIdStartTimeMints[pendingId] <block.timestamp- timeToAllowArb && commitQueueMints[pendingId].length>0;
}
functionhasStaleTrainingCommit() externalviewreturns (bool) {
uint16 pendingId = _commitIdPendingTraining;
// Check if the revealable commitId has anything to commit and increment it until it does, or is the same as the current commitIdwhile(commitQueueTraining[pendingId].length==0&& pendingId < _commitIdCurTraining) {
// Only iterate if the commit pending is empty and behind the current id.// This is to prevent it from being in front of the current id and missing commits.
pendingId +=1;
}
return commitIdStartTimeTraining[pendingId] <block.timestamp- timeToAllowArb && commitQueueTraining[pendingId].length>0;
}
/** Allow users to reveal the oldest commit for GP. Mints commits must be stale to be able to be revealed this way */functionrevealOldestMint() internalwhenNotPaused{
require(tx.origin== _msgSender(), "Only EOA");
// Check if the revealable commitId has anything to commit and increment it until it does, or is the same as the current commitIdwhile(commitQueueMints[_commitIdPendingMints].length==0&& _commitIdPendingMints < _commitIdCurMints) {
// Only iterate if the commit pending is empty and behind the current id.// This is to prevent it from being in front of the current id and missing commits.
_commitIdPendingMints +=1;
}
// Check if there is a commit in a revealable batch and pop/reveal itrequire(commitIdStartTimeMints[_commitIdPendingMints] <block.timestamp- timeToAllowArb && commitQueueMints[_commitIdPendingMints].length>0, "No stale commits to reveal");
// If the pending batch is old enough to be revealed and has stuff in it, mine one.
MintCommit memory commit = commitQueueMints[_commitIdPendingMints][commitQueueMints[_commitIdPendingMints].length-1];
commitQueueMints[_commitIdPendingMints].pop();
revealMint(commit);
gpToken.mint(_msgSender(), revealRewardAmt * commit.amount);
}
/** Allow users to reveal the oldest commit for GP. Mints commits must be stale to be able to be revealed this way */functionskipOldestMint() internalonlyOwner{
// Check if the revealable commitId has anything to commit and increment it until it does, or is the same as the current commitIdwhile(commitQueueMints[_commitIdPendingMints].length==0&& _commitIdPendingMints < _commitIdCurMints) {
// Only iterate if the commit pending is empty and behind the current id.// This is to prevent it from being in front of the current id and missing commits.
_commitIdPendingMints +=1;
}
// Check if there is a commit in a revealable batch and pop/reveal itrequire(commitQueueMints[_commitIdPendingMints].length>0, "No stale commits to reveal");
// If the pending batch is old enough to be revealed and has stuff in it, mine one.
commitQueueMints[_commitIdPendingMints].pop();
// Do not reveal the commit, only pop it from the queue and move on.// revealMint(commit);
}
functionrevealOldestTraining() externalwhenNotPaused{
require(tx.origin== _msgSender(), "Only EOA");
// Check if the revealable commitId has anything to commit and increment it until it does, or is the same as the current commitIdwhile(commitQueueTraining[_commitIdPendingTraining].length==0&& _commitIdPendingTraining < _commitIdCurTraining) {
// Only iterate if the commit pending is empty and behind the current id.// This is to prevent it from being in front of the current id and missing commits.
_commitIdPendingTraining +=1;
}
// Check if there is a commit in a revealable batch and pop/reveal itrequire(commitIdStartTimeTraining[_commitIdPendingTraining] <block.timestamp- timeToAllowArb && commitQueueTraining[_commitIdPendingTraining].length>0, "No stale commits to reveal");
// If the pending batch is old enough to be revealed and has stuff in it, mine one.
TrainingCommit memory commit = commitQueueTraining[_commitIdPendingTraining][commitQueueTraining[_commitIdPendingTraining].length-1];
commitQueueTraining[_commitIdPendingTraining].pop();
revealTraining(commit);
gpToken.mint(_msgSender(), revealRewardAmt);
}
functionskipOldestTraining() externalonlyOwner{
// Check if the revealable commitId has anything to commit and increment it until it does, or is the same as the current commitIdwhile(commitQueueTraining[_commitIdPendingTraining].length==0&& _commitIdPendingTraining < _commitIdCurTraining) {
// Only iterate if the commit pending is empty and behind the current id.// This is to prevent it from being in front of the current id and missing commits.
_commitIdPendingTraining +=1;
}
// Check if there is a commit in a revealable batch and pop/reveal itrequire(commitQueueTraining[_commitIdPendingTraining].length>0, "No stale commits to reveal");
// If the pending batch is old enough to be revealed and has stuff in it, mine one.
TrainingCommit memory commit = commitQueueTraining[_commitIdPendingTraining][commitQueueTraining[_commitIdPendingTraining].length-1];
commitQueueTraining[_commitIdPendingTraining].pop();
// Do not reveal the commit, only pop it from the queue and move on.// revealTraining(commit);
tokenHasPendingCommit[commit.tokenId] =false;
}
/** Initiate the start of a mint. This action burns $GP, as the intent of committing is that you cannot back out once you've started.
* This will add users into the pending queue, to be revealed after a random seed is generated and assigned to the commit id this
* commit was added to. */functionmintCommit(uint256 amount, bool stake) internalwhenNotPausednonReentrant{
require(allowCommits, "adding commits disallowed");
require(tx.origin== _msgSender(), "Only EOA");
uint16 minted = wndNFT.minted();
uint256 maxTokens = wndNFT.getMaxTokens();
require(minted + pendingMintAmt + amount <= maxTokens, "All tokens minted");
require(amount >0&& amount <=10, "Invalid mint amount");
if(commitIdStartTimeMints[_commitIdCurMints] ==0) {
commitIdStartTimeMints[_commitIdCurMints] =block.timestamp;
}
// Check if current commit batch is past the threshold for time and increment commitId if soif(commitIdStartTimeMints[_commitIdCurMints] <block.timestamp- timePerCommitBatch) {
// increment commitId to start a new batch
_commitIdCurMints +=1;
commitIdStartTimeMints[_commitIdCurMints] =block.timestamp;
}
// Add this mint request to the commit queue for the current commitIduint256 totalGpCost =0;
// Loop through the amount of for (uint i =1; i <= amount; i++) {
// Add N number of commits to the queue. This is so people reveal the same number of commits as they added.
commitQueueMints[_commitIdCurMints].push(MintCommit(_msgSender(), stake, 1));
totalGpCost += mintCost(minted + pendingMintAmt + i, maxTokens);
}
if (totalGpCost >0) {
gpToken.burn(_msgSender(), totalGpCost);
gpToken.updateOriginAccess();
}
uint16 amt =uint16(amount);
pendingMintCommitsForAddr[_msgSender()] += amt;
pendingMintAmt += amt;
// Check if the revealable commitId has anything to commit and increment it until it does, or is the same as the current commitIdwhile(commitQueueMints[_commitIdPendingMints].length==0&& _commitIdPendingMints < _commitIdCurMints) {
// Only iterate if the commit pending is empty and behind the current id.// This is to prevent it from being in front of the current id and missing commits.
_commitIdPendingMints +=1;
}
// Check if there is a commit in a revealable batch and pop/reveal itif(commitIdStartTimeMints[_commitIdPendingMints] <block.timestamp- timePerCommitBatch && commitQueueMints[_commitIdPendingMints].length>0) {
// If the pending batch is old enough to be revealed and has stuff in it, mine the number that was added to the queue.for (uint256 i =0; i < amount; i++) {
// First iteration is guaranteed to have 1 commit to mine, so we can always retroactively check that we can continue to reveal after
MintCommit memory commit = commitQueueMints[_commitIdPendingMints][commitQueueMints[_commitIdPendingMints].length-1];
commitQueueMints[_commitIdPendingMints].pop();
revealMint(commit);
// Check to see if we are able to continue mining commitsif(commitQueueMints[_commitIdPendingMints].length==0&& _commitIdPendingMints < _commitIdCurMints) {
_commitIdPendingMints +=1;
if(commitIdStartTimeMints[_commitIdPendingMints] >block.timestamp- timePerCommitBatch
|| commitQueueMints[_commitIdPendingMints].length==0|| _commitIdPendingMints == _commitIdCurMints)
{
// If there are no more commits to reveal, exitbreak;
}
}
}
}
}
functionrevealMint(MintCommit memory commit) internal{
uint16 minted = wndNFT.minted();
pendingMintAmt -= commit.amount;
uint16[] memory tokenIds =newuint16[](commit.amount);
uint16[] memory tokenIdsToStake =newuint16[](commit.amount);
uint256 seed =uint256(keccak256(abi.encode(commit.recipient, minted, commitIdStartTimeMints[_commitIdPendingMints])));
for (uint k =0; k < commit.amount; k++) {
minted++;
// scramble the random so the steal / treasure mechanic are different per mint
seed =uint256(keccak256(abi.encode(seed, commit.recipient)));
address recipient = selectRecipient(seed, commit.recipient);
if(recipient != commit.recipient && alter.balanceOf(commit.recipient, TREASURE_CHEST) >0) {
// If the mint is going to be stolen, there's a 50% chance // a dragon will prefer a treasure chest over itif(seed &1==1) {
alter.safeTransferFrom(commit.recipient, recipient, TREASURE_CHEST, 1, "");
recipient = commit.recipient;
}
}
tokenIds[k] = minted;
if (!commit.stake || recipient != commit.recipient) {
wndNFT.mint(recipient, seed);
} else {
wndNFT.mint(address(trainingGrounds), seed);
tokenIdsToStake[k] = minted;
}
}
wndNFT.updateOriginAccess(tokenIds);
// mints are revealed 1 at a time. Because of this, we only need to check if the first tokenId is stolen// Don't call add many if there is no token to add.if(commit.stake && tokenIdsToStake[0] !=0) {
trainingGrounds.addManyToTowerAndFlight(commit.recipient, tokenIdsToStake);
}
pendingMintCommitsForAddr[commit.recipient] -= commit.amount;
}
functionaddToTower(uint16[] calldata tokenIds) externalwhenNotPaused{
require(_msgSender() ==tx.origin, "Only EOA");
for (uint256 i =0; i < tokenIds.length; i++) {
require(!tokenHasPendingCommit[tokenIds[i]], "token has pending commit");
}
trainingGrounds.addManyToTowerAndFlight(tx.origin, tokenIds);
}
functionaddToTrainingCommit(uint16[] calldata tokenIds) externalwhenNotPaused{
require(allowCommits, "adding commits disallowed");
require(tx.origin== _msgSender(), "Only EOA");
if(commitIdStartTimeTraining[_commitIdCurTraining] ==0) {
commitIdStartTimeTraining[_commitIdCurTraining] =block.timestamp;
}
// Check if current commit batch is past the threshold for time and increment commitId if soif(commitIdStartTimeTraining[_commitIdCurTraining] <block.timestamp- timePerCommitBatch) {
// increment commitId to start a new batch
_commitIdCurTraining +=1;
commitIdStartTimeTraining[_commitIdCurTraining] =block.timestamp;
}
// Loop through the amount of tokens being addeduint16 numDragons;
for (uint i =0; i < tokenIds.length; i++) {
require(address(trainingGrounds) != wndNFT.ownerOf(tokenIds[i]), "token already staked");
require(!tokenHasPendingCommit[tokenIds[i]], "token has pending commit");
require(_msgSender() == wndNFT.ownerOf(tokenIds[i]), "not owner of token");
if(!wndNFT.isWizard(tokenIds[i])) {
numDragons +=1;
}
tokenHasPendingCommit[tokenIds[i]] =true;
// Add N number of commits to the queue. This is so people reveal the same number of commits as they added.
commitQueueTraining[_commitIdCurTraining].push(TrainingCommit(_msgSender(), tokenIds[i], true, false, true));
}
gpToken.burn(_msgSender(), stakingCost * (tokenIds.length- numDragons)); // Dragons are free to stake
gpToken.updateOriginAccess();
pendingTrainingCommitsForAddr[_msgSender()] +=uint16(tokenIds.length);
tryRevealTraining(tokenIds.length);
}
functionclaimTrainingsCommit(uint16[] calldata tokenIds, bool isUnstaking, bool isTraining) externalwhenNotPaused{
require(allowCommits, "adding commits disallowed");
require(tx.origin== _msgSender(), "Only EOA");
if(commitIdStartTimeTraining[_commitIdCurTraining] ==0) {
commitIdStartTimeTraining[_commitIdCurTraining] =block.timestamp;
}
// Check if current commit batch is past the threshold for time and increment commitId if soif(commitIdStartTimeTraining[_commitIdCurTraining] <block.timestamp- timePerCommitBatch) {
// increment commitId to start a new batch
_commitIdCurTraining +=1;
commitIdStartTimeTraining[_commitIdCurTraining] =block.timestamp;
}
uint16 numDragons;
// Loop through the amount of tokens being addedfor (uint i =0; i < tokenIds.length; i++) {
require(!tokenHasPendingCommit[tokenIds[i]], "token has pending commit");
require(trainingGrounds.isTokenStaked(tokenIds[i], isTraining) && trainingGrounds.ownsToken(tokenIds[i])
, "Token not in staking pool");
if(isUnstaking) {
if(wndNFT.isWizard(tokenIds[i])) {
// Check to see if the wizard has earned enough to withdraw.// If emissions run out, allow them to attempt to withdraw anyways.if(isTraining) {
require(trainingGrounds.curWhipsEmitted() >=16000|| trainingGrounds.calculateErcEmissionRewards(tokenIds[i]) >0, "can't unstake wizard yet");
}
else {
require(trainingGrounds.totalGPEarned() >500000000ether-4000ether|| trainingGrounds.calculateGpRewards(tokenIds[i]) >=4000ether, "can't unstake wizard yet");
}
}
else {
numDragons +=1;
}
}
tokenHasPendingCommit[tokenIds[i]] =true;
// Add N number of commits to the queue. This is so people reveal the same number of commits as they added.
commitQueueTraining[_commitIdCurTraining].push(TrainingCommit(_msgSender(), tokenIds[i], false, isUnstaking, isTraining));
}
if(isUnstaking) {
gpToken.burn(_msgSender(), stakingCost * (tokenIds.length- numDragons)); // Dragons are free to stake
gpToken.updateOriginAccess();
}
pendingTrainingCommitsForAddr[_msgSender()] +=uint16(tokenIds.length);
tryRevealTraining(tokenIds.length);
}
functiontryRevealTraining(uint256 amount) internal{
// Check if the revealable commitId has anything to commit and increment it until it does, or is the same as the current commitIdwhile(commitQueueTraining[_commitIdPendingTraining].length==0&& _commitIdPendingTraining < _commitIdCurTraining) {
// Only iterate if the commit pending is empty and behind the current id.// This is to prevent it from being in front of the current id and missing commits.
_commitIdPendingTraining +=1;
}
// Check if there is a commit in a revealable batch and pop/reveal itif(commitIdStartTimeTraining[_commitIdPendingTraining] <block.timestamp- timePerCommitBatch && commitQueueTraining[_commitIdPendingTraining].length>0) {
// If the pending batch is old enough to be revealed and has stuff in it, mine the number that was added to the queue.for (uint256 i =0; i < amount; i++) {
// First iteration is guaranteed to have 1 commit to mine, so we can always retroactively check that we can continue to reveal after
TrainingCommit memory commit = commitQueueTraining[_commitIdPendingTraining][commitQueueTraining[_commitIdPendingTraining].length-1];
commitQueueTraining[_commitIdPendingTraining].pop();
revealTraining(commit);
// Check to see if we are able to continue mining commitsif(commitQueueTraining[_commitIdPendingTraining].length==0&& _commitIdPendingTraining < _commitIdCurTraining) {
_commitIdPendingTraining +=1;
if(commitIdStartTimeTraining[_commitIdPendingTraining] >block.timestamp- timePerCommitBatch
|| commitQueueTraining[_commitIdPendingTraining].length==0|| _commitIdPendingTraining == _commitIdCurTraining)
{
// If there are no more commits to reveal, exitbreak;
}
}
}
}
}
functionrevealTraining(TrainingCommit memory commit) internal{
uint16[] memory idSingle =newuint16[](1);
idSingle[0] = commit.tokenId;
tokenHasPendingCommit[commit.tokenId] =false;
if(commit.isAdding) {
if(wndNFT.ownerOf(commit.tokenId) != commit.tokenOwner) {
// The owner has transferred their token and can no longer be staked. We can simply skip this reveal.return;
}
if(wndNFT.isWizard(commit.tokenId)) {
// Add to training since tower staking doesn't need C+Ruint256 seed = random(commit.tokenId, commitIdStartTimeTraining[_commitIdPendingTraining], commit.tokenOwner);
trainingGrounds.addManyToTrainingAndFlight(seed, commit.tokenOwner, idSingle);
}
else {
// Dragons go to the tower but really they are in both pools. This just avoids the stealing logic.
trainingGrounds.addManyToTowerAndFlight(commit.tokenOwner, idSingle);
}
}
else {
if(!trainingGrounds.isTokenStaked(commit.tokenId, commit.isTraining)) {
// Skip reveals if the token has already been claimed since committing to this tx (like claiming multiple times unknowingly)return;
}
if(commit.isTraining) {
uint256 seed = random(commit.tokenId, commitIdStartTimeTraining[_commitIdPendingTraining], commit.tokenOwner);
trainingGrounds.claimManyFromTrainingAndFlight(seed, commit.tokenOwner, idSingle, commit.isUnstaking);
}
else {
trainingGrounds.claimManyFromTowerAndFlight(commit.tokenOwner, idSingle, commit.isUnstaking);
}
}
pendingTrainingCommitsForAddr[commit.tokenOwner] -=1;
}
/** Deterministically random. This assumes the call was a part of commit+reveal design
* that disallowed the benefactor of this outcome to make this call */functionrandom(uint16 tokenId, uint256 time, address owner) internalpurereturns (uint256) {
returnuint256(keccak256(abi.encodePacked(
owner,
tokenId,
time
)));
}
/**
* @param tokenId the ID to check the cost of to mint
* @return the cost of the given token ID
*/functionmintCost(uint256 tokenId, uint256 maxTokens) publicviewreturns (uint256) {
if (tokenId <= maxTokens *8/20) return24000ether;
if (tokenId <= maxTokens *11/20) return36000ether;
if (tokenId <= maxTokens *14/20) return48000ether;
if (tokenId <= maxTokens *17/20) return60000ether;
// if (tokenId > maxTokens * 17 / 20)return maxGpCost;
}
functionmakeTreasureChests(uint16 qty) externalwhenNotPaused{
require(tx.origin== _msgSender(), "Only EOA");
// $GP exchange amount handled within alter contract// Will fail if sender doesn't have enough $GP// Transfer does not need approved,// as there is established trust between this contract and the alter contract
alter.mint(TREASURE_CHEST, qty, _msgSender());
}
functionsellTreasureChests(uint16 qty) externalwhenNotPaused{
require(tx.origin== _msgSender(), "Only EOA");
// $GP exchange amount handled within alter contract
alter.burn(TREASURE_CHEST, qty, _msgSender());
}
/** INTERNAL *//**
* the first 25% (ETH purchases) go to the minter
* the remaining 80% have a 10% chance to be given to a random staked dragon
* @param seed a random value to select a recipient from
* @return the address of the recipient (either the minter or the Dragon thief's owner)
*/functionselectRecipient(uint256 seed, address committer) internalviewreturns (address) {
if (((seed >>245) %10) !=0) return committer; // top 10 bits haven't been usedaddress thief = trainingGrounds.randomDragonOwner(seed >>144); // 144 bits reserved for trait selectionif (thief ==address(0x0)) return committer;
return thief;
}
/** ADMIN *//**
* enables owner to pause / unpause contract
*/functionsetPaused(bool _paused) externalrequireContractsSetonlyOwner{
if (_paused) _pause();
else _unpause();
}
functionsetMaxGpCost(uint256 _amount) externalrequireContractsSetonlyOwner{
maxGpCost = _amount;
}
functionsetAllowCommits(bool allowed) externalonlyOwner{
allowCommits = allowed;
}
functionsetRevealRewardAmt(uint256 rewardAmt) externalonlyOwner{
revealRewardAmt = rewardAmt;
}
/** Allow the contract owner to set the pending mint amount.
* This allows any long-standing pending commits to be overwritten, say for instance if the max supply has been
* reached but there are many stale pending commits, it could be used to free up those spaces if needed/desired by the community.
* This function should not be called lightly, this will have negative consequences on the game. */functionsetPendingMintAmt(uint256 pendingAmt) externalonlyOwner{
pendingMintAmt =uint16(pendingAmt);
}
/**
* allows owner to withdraw funds from minting
*/functionwithdraw() externalonlyOwner{
payable(owner()).transfer(address(this).balance);
}
}