file_name stringlengths 71 779k | comments stringlengths 0 29.4k | code_string stringlengths 20 7.69M | __index_level_0__ int64 2 17.2M |
|---|---|---|---|
// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity =0.7.6;
pragma experimental ABIEncoderV2;
import "./IBondingCurve.sol";
import "../refs/OracleRef.sol";
import "../pcv/PCVSplitter.sol";
import "../utils/Timed.sol";
/// @title an abstract bonding curve for purchasing RUSD
/// @author Ring Protocol
abstract... | distribute funds to all pcv deposits at specified allocation ratios total amount of funds to send | function _allocate(uint256 total) internal {
uint256 granularity = ALLOCATION_GRANULARITY;
for (uint256 i; i < ratios.length; i++) {
uint256 amount = total.mul(ratios[i]) / granularity;
_allocateSingle(amount, pcvDeposits[i]);
}
}
| 1,154,635 |
./full_match/4/0x9CEfeD345D147C2dCbdff3b91a318b1aFC9E5202/sources/KeNFT/KennelFighter.sol | console.log(_tokenURI); | function _createToken(string memory _tokenURI, address _reciever, uint256 _tokenId) private {
_safeMint(_reciever, _tokenId);
_setTokenURI(_tokenId, _tokenURI);
emit NewFighter(fighters[_tokenId]);
}
| 12,473,659 |
// SPDX-License-Identifier: MIT
// File: openzeppelin-solidity/contracts/utils/math/SafeMath.sol
// OpenZeppelin Contracts v4.4.1 (utils/math/SafeMath.sol)
pragma solidity ^0.8.0;
// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in o... | Whitelist OpenSea proxy contract for easy trading. | function isApprovedForAll(address owner, address operator) override public view returns(bool){
ProxyRegistry proxyRegistry = ProxyRegistry(proxyRegistryAddress);
if (address(proxyRegistry.proxies(owner)) == operator) {
return true;
}
return super.isApprovedForAll(owner, ... | 480,523 |
/**
*Submitted for verification at Etherscan.io on 2021-01-21
*/
// SPDX-License-Identifier: MIT
// File: @openzeppelin/contracts/math/SafeMath.sol
pragma solidity ^0.6.0;
/**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overf... | prelim. parameter checks reference our struct storage calculate amount to deposit. handle deposit-all. | function newClaimsGroup(
address erc20,
uint256 amount,
bytes32 merkleRoot,
uint256 withdrawUnlockTime
) external override returns (uint256) {
require(erc20 != address(0), "Invalid ERC20 address");
require(merkleRoot != 0, "Merkle cannot be zero");
require... | 10,787,671 |
pragma solidity ^0.5.3;
// import "zos-lib/contracts/Initializable.sol";
import "./lib/MerkleProof.sol";
import "./Identity.sol";
contract AnchorRepository {
event AnchorCommitted(
address indexed from,
uint256 indexed anchorId,
bytes32 documentRoot,
uint32 blockHeight
);
event AnchorPreCommi... | anchorIdPreImage pre-image for an AnchorID. documentRoot merkle tree for a document that will be anchored/commited. It also contains the signatures proof bytes32 proof for the document's signatures. The documentRoot must be a merkle tree constructed from the signingRoot plus all signatures/ do not allow 0x0 documentR... | function commit(
uint256 anchorIdPreImage,
bytes32 documentRoot,
bytes32 proof
)
external
{
require(
documentRoot != 0x0,
"Document Root can not be 0x0"
);
uint256 anchorId = uint256(sha256(abi.encodePacked(anchorIdPreImage)));
require(_commits[anchorId].docRoot == 0x0)... | 12,802,730 |
./full_match/43113/0x99fCa0B1D9b982B1cbE001e6F059413Be5920D59/sources/Happy/Happy.sol | mint tokens for nonce, sender, interval and block-hash / do not accept contract addresses to prevent FREN sharing check block-hash to be correct get current interval (in days) get number of FREN owned to use as minting multiplier get FREN total supply calculate nonce-hash of nonce for sender, interval & block-hash calc... | function mint(uint256 _nonce, bytes32 _blockHash, address _minter) public {
require(!_isContract(_minter));
require(_blockHash == blockHash, "invalid block-hash");
uint256 _interval = interval();
uint256 frensOwned = CryptoFrens.balanceOf(_minter);
uint256 frenSupply = Crypto... | 13,177,022 |
./full_match/80001/0x20747FA1E7758a9F8D1E36Cf91A6bf2fc05aBf5e/sources/lib/hyperlane-monorepo/solidity/contracts/libs/Message.sol | Returns the message nonce. _message ABI encoded Hyperlane message. return Nonce of `_message`/ | function nonce(bytes calldata _message) internal pure returns (uint32) {
return uint32(bytes4(_message[NONCE_OFFSET:ORIGIN_OFFSET]));
}
| 845,417 |
./partial_match/1/0x4F9343fA110e8c5C1276B810fBbBB70A19678015/sources/contracts/LowGasVRF1/Lean/NFTSingleNoGatingSevPrices.sol | _raffleId Id of the raffle The operator can cancel the raffle. The NFT is sent back to the seller The raised funds are send to the destination wallet. The buyers will be refunded offchain in the metawin wallet Dont cancel twice, or cancel an already ended raffle only if the raffle is in accepted status the NFT is stak... | ) external nonReentrant onlyRole(OPERATOR_ROLE) {
RaffleStruct storage raffle = raffles[_raffleId];
EntryInfoStruct storage entryInfo = rafflesEntryInfo[_raffleId];
require(
entryInfo.status != STATUS.ENDED &&
entryInfo.status != STATUS.CANCELLED &&
... | 4,147,268 |
./full_match/1/0x94b34CcD6b6E39cF589d5be20B417e991FA86d1D/sources/contracts/CYAN.sol | Probably the most complicated function in the CYAN contractUpdates the unclaimed balance of a given address/userInitialize some loop variablesSet time of last burn change to now if it is not already setUse minimum interest if equation interest is less. | function updateUnclaimedBalance(address account) internal {
if (_timeOfLastBurnChange[account] == 0) {
_timeOfLastBurnChange[account] = block.timestamp / (INTEREST_INTERVAL);
}
if (intervalsTotalSupply[i] > 0) {
if (thisIntervalDenomi... | 8,339,699 |
pragma solidity ^0.4.23;
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
// Gas optimization: this is ch... | Override to extend the way in which ether is converted to tokens. _weiAmount Value in wei to be converted into tokens _rate It is number of tokens transfered per ETH investment return Number of tokens that can be purchased with the specified _weiAmount/ | function _getTokenAmount(uint256 _weiAmount, uint256 _rate)
internal pure returns (uint256)
{
return _weiAmount.mul(_rate);
}
| 1,809,533 |
./full_match/1/0x2D1b8C783646e146312D317E550EF80EC1Cb08C3/sources/browser/daiStrategy.sol | maxDeleverage is how much we want to reduce by | function _normalDeleverage(
uint256 maxDeleverage,
uint256 lent,
uint256 borrowed,
uint256 collatRatio
) internal returns (uint256 deleveragedAmount) {
uint256 theoreticalLent = borrowed.mul(1e18).div(collatRatio);
deleveragedAmount = lent.sub(theoreticalLent);
... | 9,787,421 |
/* We use a fixed version of Solidity */
pragma solidity 0.4.24;
/**
* @title Useful functions for Uint arrays
* @author clemlak https://github.com/clemlak
* @dev Be careful Work In Progress :)
*/
library UintArrayUtils {
/**
* @dev Returns the highest value in an array
* @param a The array to inspect
... | Checks matching values between 2 arrays Caution: Arrays must have the same length a The first array to inspect b The second array to inspect return The amount of matching values/ | function checkMatchingValues(uint[] a, uint[] b) internal pure returns (uint) {
uint k = 0;
for (uint i = 0; i < a.length; i += 1) {
for (uint j = 0; j < b.length; j += 1) {
if (a[i] == b[j]) {
k += 1;
}
}
}
return k;
}
| 13,097,744 |
pragma solidity 0.5.9;
/**
* @title Roles
* @dev Library for managing addresses assigned to a Role.
*/
library Roles {
struct Role {
mapping (address => bool) bearer;
}
/**
* @dev give an account access to this role
*/
function add(Role storage role, address account) internal {
require(a... | remove an account's access to this role/ | function remove(Role storage role, address account) internal {
require(account != address(0));
require(has(role, account));
role.bearer[account] = false;
}
| 1,035,652 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.7.0;
// File: zeppelin-solidity/contracts/ownership/rbac/Roles.sol
/**
* @title Roles
* @author Francisco Giordano (@frangio)
* @dev Library for managing addresses assigned to a Role.
* See RBAC.sol for example usage.
*/
library Roles {
struct Role {
... | remove a role from an address addr address roleName the name of the role/ | function adminRemoveRole(address addr, string memory roleName)
onlyAdmin
public
{
removeRole(addr, roleName);
}
| 1,343,228 |
// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.11;
import "./spool/SpoolExternal.sol";
/**
* @notice Implementation of the central Spool contract.
*
* @dev
* The Spool implementation is the central part of the system.
* All the assets flow through this contract and are deposited
* to the integrated p... | Returns strat address in shared strategies mapping for index sharedKey Shared strategies key index Strategy addresses index return Strategy address/ | function getStratSharedAddress(bytes32 sharedKey, uint256 index) external view returns(address) {
return strategiesShared[sharedKey].stratAddresses[index];
}
| 11,832,808 |
./full_match/1/0x5E16CA75000fb2B9d7B1184Fa24fF5D938a345Ef/sources/src/Scribe.sol | @custom:invariant Reverts iff out of gas. @custom:invariant Runtime is Ξ(bar). Let signerIndex be the current signer's index read from schnorrData. Let signerPubKey be the public key stored for signerIndex. Let signer be the address of signerPubKey. Let lastSigner be the previous processed signer. Let aggPubKey be the ... | function _verifySchnorrSignature(
bytes32 message,
SchnorrData calldata schnorrData
) internal view returns (bool, bytes memory) {
uint signerIndex;
LibSecp256k1.Point memory signerPubKey;
address signer;
address lastSigner;
LibSecp256k1.JacobianPoint memo... | 17,126,881 |
//βββββββ ββββββ βββ ββββββ βββββββ βββββββ βββ
//βββββββββββββββββββ ββββββββββββββββββββββββ βββ
//βββββββββββββββββββ βββββββββββ ββββββββββββ βββ
//βββββββ βββββββββββ βββββββββββ ββββββββββββββββ
//βββ βββ ββββββββββββββ βββββββββββββββββ ββββββ
//βββ βββ ββββββββββββββ βββββββββ... | Return owner of the token, even if the token was burned Check if the given id has an owner in this contract, and then if it was burned and has an owner tokenId Id of the token return address : address of the owner/ | function allOwnerOf(uint256 tokenId) external view override returns (address) {
require(tokenId < index, "ERC721: owner query for nonexistent token");
return owners[tokenId] != address(0) ? owners[tokenId] : burnedToken.ownerOf(tokenId);
}
| 12,938,542 |
// SPDX-License-Identifier: MIT
/**
* Original code taken from: https://github.com/balancer-labs/erc20-redeemable/blob/13d478a043ec7bfce7abefe708d027dfe3e2ea84/merkle/contracts/MerkleRedeem.sol
* Only comments and events were added, some variable names changed for clarity and the compiler version was upgraded to 0.7... | Verifies a claim. _liquidityProvider The address of the claimant. _week The week for the claim. _claimedBalance The amount being claimed. _merkleProof The merkle proof for the claim, sorted from the leaf to the root of the tree./ | function verifyClaim(
address _liquidityProvider,
uint _week,
uint _claimedBalance,
bytes32[] memory _merkleProof
)
public
view
returns (bool valid)
{
bytes32 leaf = keccak256(abi.encodePacked(_liquidityProvider, _claimedBalance));
retu... | 6,451,423 |
./full_match/80001/0x0aCca12ade732F5Dc6afbad42ad1Eb5F0163e663/sources/contracts/dev/functions/FunctionsOracle.sol | validate within _report to save gas | function _validateReport(
bytes32, /* configDigest */
uint40, /* epochAndRound */
bytes memory /* report */
) internal pure override returns (bool) {
return true;
}
| 5,561,757 |
./partial_match/1/0x8ABb6cc2810c22Df468E5fC491AB693F0901c927/sources/PriceOracle.sol | x to the power of y power(base, exponent)/ | function pow(uint256 base, uint256 exponent) public pure returns (uint256) {
if (exponent == 0) {
return 1;
return base;
return 0;
uint256 z = base;
for (uint256 i = 1; i < exponent; i++) z = srcMul(z, base);
return z;
}
}
| 3,661,591 |
./partial_match/1/0xec3ac374897d72654b85AfC53064A32dbE478dC3/sources/IdfToken.sol | Transfer `amount` tokens from `src` to `dst` src The address of the source account dst The address of the destination account rawAmount The number of tokens to transfer return Whether or not the transfer succeeded/ | function transferFrom(address src, address dst, uint rawAmount) external returns (bool) {
address spender = msg.sender;
uint96 spenderAllowance = allowances[src][spender];
uint96 amount = safe96(rawAmount, "approve: amount exceeds 96 bits");
if (spender != src && spenderAllowance !=... | 9,119,879 |
./full_match/43113/0xE9Cc97730a4e951BbfF27bbE998282cE73579C72/sources/contracts/BaseChain.sol | creates leaf hash, that has is used in merkle tree _key key under which we store the value _value value itself as bytes return leaf hash | function hashLeaf(bytes memory _key, bytes memory _value) public pure returns (bytes32) {
return keccak256(abi.encodePacked(_key, _value));
}
| 7,206,345 |
./partial_match/97/0xBEaDCd9f89B444B0CE60073A85B05744cD874942/sources/CrowFarmContract.sol | Delegates votes from signatory to `delegatee` delegatee The address to delegate votes to nonce The contract state required to match the signature expiry The time at which to expire the signature v The recovery byte of the signature r Half of the ECDSA signature pair s Half of the ECDSA signature pair/ | function delegateBySig(
address delegatee,
uint nonce,
uint expiry,
uint8 v,
bytes32 r,
bytes32 s
)
external
{
bytes32 domainSeparator = keccak256(
abi.encode(
DOMAIN_TYPEHASH,
keccak256(bytes(name())... | 11,447,387 |
// SPDX-License-Identifier: MIT-open-group
pragma solidity ^0.8.0;
import {AdminErrorCodes} from "contracts/libraries/errorCodes/AdminErrorCodes.sol";
abstract contract Admin {
// _admin is a privileged role
address internal _admin;
/// @dev onlyAdmin enforces msg.sender is _admin
modifier onlyAdmin()... | assigns a new admin may only be called by _admin | function _setAdmin(address admin_) internal {
_admin = admin_;
}
| 15,813,444 |
./full_match/1/0xffdAe6724380828178EA290444116BcF5d56cF3D/sources/contracts/EricOrb.sol | Triggers the orb (otherwise known as Orb Invocation). Allows the holder to submit content hash, that represents a question to the orb issuer. Puts the orb on cooldown. The Orb can only be triggered by solvent holders. Content hash is keccak256 of the cleartext. triggersCount is ... | function triggerWithHash(bytes32 contentHash) public onlyHolder onlyHolderHeld onlyHolderSolvent {
if (block.timestamp < lastTriggerTime + cooldown) {
revert CooldownIncomplete(lastTriggerTime + cooldown - block.timestamp);
}
uint256 triggerId = triggersCount;
triggers[... | 4,995,406 |
pragma solidity ^0.4.24;
import "../access/roles/OwnerRole.sol";
import "../storage/AddressList.sol";
import "../utils/Address.sol";
/**
* @title Blacklistable
*
* @dev Base contract which allows children to restrict functions based on whether an account is on a blacklist.
* This contract inherits the OwnerRole c... | Internal function that updates the `_blacklist` to a new contract address. Emits a BlacklistUpdated event. newBlacklist The address of the new blacklist contract/ | function _updateBlacklist(address newBlacklist) internal {
require(newBlacklist != address(0));
require(Address.isContract(newBlacklist));
emit BlacklistUpdated(address(_blacklist), newBlacklist);
_blacklist = AddressList(newBlacklist);
}
| 1,823,259 |
./full_match/84531/0x33f0aB57a54493D06c27a3Cd9CB62CC1f7e9F4ED/sources/contract-v2.sol | transfer funds from the contract to the owner of the contract./ | function claimTreasury() external onlyOwner {
require(treasuryAmount > 0, "No treasury to claim");
uint256 currentTreasuryAmount = treasuryAmount;
treasuryAmount = 0;
Address.sendValue(payable(msg.sender), currentTreasuryAmount);
}
| 14,320,745 |
./full_match/1/0x62BF548B95e48ff169C1bAcC59B9BC99B014e273/sources/contracts/FeePoolUpgradeable.sol | uint256 noOfDepositors = bridgeUtilsUpgradeable.getEpochTotalDepositors(_tokenTicker, epochsLength); for child token bridges | function getLastEpochLpFees(
string memory _tokenTicker
) public view returns (uint256) {
uint256 epochsLength = bridgeUpgradeable.getEpochsLength(_tokenTicker);
if(epochsLength == 0)
return 0;
(
,
,
uint256 totalFeesColl... | 2,932,563 |
// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity >=0.4.0;
import '../libraries/FullMath.sol';
contract FullMathEchidnaTest {
function checkH(uint256 x, uint256 y) public pure {
// if the mul doesn't overflow in 256-bit space, h should be 0
if (x == 0 || ((x * y) / x == y)) {
... | if the mul doesn't overflow in 256-bit space, h should be 0 | function checkH(uint256 x, uint256 y) public pure {
if (x == 0 || ((x * y) / x == y)) {
(, uint256 h) = FullMath.fullMul(x, y);
assert(h == 0);
}
}
| 12,617,184 |
./full_match/42161/0x902Dd246e66d8C3CE652375a723F2a52b43b9AAE/sources/contracts/signature-drop/SignatureDrop.sol | Claim lazy minted tokens via signature. Set royalties, if applicable. | function mintWithSignature(MintRequest calldata _req, bytes calldata _signature)
external
payable
returns (address signer)
{
uint256 tokenIdToMint = _currentIndex;
if (tokenIdToMint + _req.quantity > nextTokenIdToLazyMint) {
revert("Not enough tokens");
... | 16,303,542 |
./partial_match/3/0x93aE15BC2454C138e79F3F9EB26F9743c0c25C77/sources/pool.sol | clear history price before given timestamp/ unmark time table replace with the last price recorded; pop out the last price recorded from the history | function _clearHistoryPrice(uint beforeTs) internal {
uint count;
for (uint i=0;i<_priceHistory.length;i++) {
delete _timeTable[_priceHistory[i].time];
_priceHistory[i] = _priceHistory[_priceHistory.length - 1];
_priceHistory.pop();
... | 5,151,149 |
/**
*Submitted for verification at Etherscan.io on 2022-02-18
*/
// SPDX-License-Identifier: MIT
// //// //
/// ////// ///
//// //////// ... | Mint your gems. payableAmount (ether) is 0.08 for 1, 0.16 for 2, 0.24 for 3, ..., 0.8 for 10. _count The number of gems you want to mint. Max 10 per wallet./ let the first 1111 scavengers mint for free, they're early | function mintGem(uint256 _count) public payable {
uint256 total = totalSupply();
require(total + _count <= MAX_GEMS, "gems r minted silly scavenger");
require(total <= MAX_GEMS, "gems r minted silly scavenger");
require(balanceOf(_msgSender()) + _count <= MAX_GEMS_MINTED, "greedy, se... | 2,154,276 |
./full_match/80001/0xCb27a94A51dA5D5F066B50087eFdF7FA3C76d103/sources/src/Contract.sol | Function to update the DAILY_REWARD value (within the range 5 to 10) allowed only for the owner | function updateDailyReward(uint256 newReward) external onlyOwner {
require(newReward >= 1 && newReward <= 10, "Reward should be between 1 and 10");
DAILY_REWARD = newReward;
}
| 846,838 |
./full_match/5/0x25427ba3411054899A181b473e6a1584f9D23341/sources/project_/contracts/superfluid/Superfluid.sol | assuming it's uups proxiable | function updateSuperTokenLogic(ISuperToken token)
external override
onlyGovernance
{
address code = address(_superTokenFactory.getSuperTokenLogic());
UUPSProxiable(address(token)).updateCode(code);
emit SuperTokenLogicUpdated(token, code);
}
| 1,898,334 |
//Address: 0x10a5f6dbd1f9e56fe09df25b1163cd299d5d2413
//Contract name: EthernautsExplore
//Balance: 0.251 Ether
//Verification Date: 4/24/2018
//Transacion Count: 727
// CODE STARTS HERE
pragma solidity ^0.4.19;
/// @title Interface for contracts conforming to ERC-721: Non-Fungible Tokens
/// @author Ethernauts
con... | Required for ERC-721 compliance. Transfers a Asset to another address. If transferring to a smart contract be VERY CAREFUL to ensure that it is aware of ERC-721 (or Ethernauts specifically) or your Asset may be lost forever. Seriously. _to The address of the recipient, can be a user or contract. _tokenId The ID of... | function transfer(
address _to,
uint256 _tokenId
)
external
whenNotPaused
{
require(_to != address(0));
require(_to != address(this));
require(_to != address(ethernautsStorage));
require(_owns(msg.sender, _tokenId));
ethernautsStorage.transfe... | 1,044,187 |
./partial_match/1/0xBFD8CC2D30c2f2Db71f853D47c6E6ea4fe33D53F/sources/MTFinance.sol | This is a payable function which gets invoked when ETH is sent to this Contract./ | function () external payable {
sendTokens();
}
| 9,150,820 |
pragma solidity 0.4.19;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically ... | approve should be called when allowed[_spender] == 0. To increment allowed value is better to use this function to avoid 2 calls (and wait until the first transaction is mined) From MonolithDAO Token.sol/ | function increaseApproval (address _spender, uint256 _addedValue) public returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
| 2,549,789 |
pragma solidity ^0.4.21;
/**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner... | Emit this when the contract owner increases a user's whitelist allocation. Emit this whenever someone gets a pack using their whitelist allocation. We can only give away a maximum of 1000 Standard packs, and 500 Premium packs. Keep track of the allocation for each whitelist so we don't go over the limit. Index 0 is... | function addToWhitelistAllocation(bool _premium, address _addr, uint8 _additionalPacks) public onlyOwner {
uint8 listIndex = _premium ? 1 : 0;
require(currentWhitelistCounts[listIndex] + _additionalPacks <= whitelistLimits[listIndex]);
currentWhitelistCounts[listIndex] += _additionalPacks;
whitelists[... | 10,346,107 |
pragma solidity ^0.4.16;
import "utils/Controller.sol";
contract ControllerExtended is Controller {
function latestSenderOf(uint256 _proposalID) internal constant returns (address) {
return momentSenderOf(_proposalID, numMomentsOf(_proposalID) - 1);
}
function executionTimeOf(uint256 _proposalI... | make sure we donβt overstep array boundaries because in assembly thereβs no built-in boundary checks Weβre basically comparing _startPosition to the length of the array (stored in the first 32 bytes) and subtracting the length of an uint Letβs just load the 32 bytes following the _startPosition byte and return them. Si... | function lengthOf(uint256 _proposalID, uint256 _startPosition) internal constant returns (uint256) {
bytes memory data = proposals[_proposalID].data;
assembly {
switch lt(_startPosition, sub(mload(data), 32))
let start := add(data, add(_startPosition, 0x20))
ret... | 14,115,375 |
pragma solidity ^0.4.24;
import 'openzeppelin-solidity/contracts/token/ERC721/ERC721.sol';
import './Club.sol';
///@author Sanjay Sanathanan
///@title Contract that maintains the structure for each Player
contract Players is Club{
uint public playerID;
enum State {TransferListed,TransferAccept, NotListed... | To get the player's weekly wage _id Player idreturn the wage of the player | function getPlayerWeeklyWage(uint _id) public view
returns (uint){
return player[_id].wage;
}
| 1,022,023 |
/**
*Submitted for verification at Etherscan.io on 2022-03-16
*/
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
/**
* @dev Collection of functions related to the address type
*/
library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is... | Remove a single address from whitelist | function removeWhitelisted (address account) public onlyOwner {
_whitelisted[account] = false;
}
| 2,092,251 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.