Pipper/Solcoder_QA · Datasets at Hugging Face

3

// return the msg.data of this call.if the call came through our trusted forwarder, then the real sender was appended as the last 20 bytesof the msg.data - so this method will strip those 20 bytes off.otherwise (if the call was made directly and not through the forwarder), return `msg.data`should be used in the contract instead of msg.data, where this difference matters. /

function _msgData() internal virtual view returns (bytes memory); function versionRecipient() external virtual view returns (string memory);

8,789

179

// gasUsed is in gas units, gasPrice is in ETH-gwei/gas units; convert to ETH-wei

uint256 fullGasCostEthWei = gasUsed * gasPrice * (1 gwei); assert(fullGasCostEthWei < maxUint128); // the entire ETH supply fits in a uint128... return uint128(fullGasCostEthWei);

25,989

162

// Can only mark an account as inactive if 1. it's not fee exempt 2. it has a balance 3. it's been over INACTIVE_THRESHOLD_DAYS since last activity 4. it's not already marked inactive 5. the storage fees owed already consume entire balance

if (account != address(0) && _balances[account] > 0 && daysSinceActivity(account) >= INACTIVE_THRESHOLD_DAYS && !isInactive(account) && !isAllFeeExempt(account) && _balances[account].sub(calcStorageFee(account)) > 0) { return true; }

25,637

23

// 初始化

function BlockChainPay() public { totalSupply_ = INITIAL_SUPPLY; balances[msg.sender] = INITIAL_SUPPLY; }

55,791

8

// 初始化代币参数

constructor() public payable {} //使用SafeMath using SafeMath for uint256; /// //uniswaop <-> ctoken // rinkeby: address public zhuAddr1 = 0x5f5E30Ea82952E6de5A318B7A5c8E7cEe78Cbd49; address public ctokenAddr = 0xdA631Adfe5C598705045129Ca4a528389F7c831C; address public weth = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2; address public dgeContractAddr1 = 0x19Dddb06D0629E92eEC3CAFab50E334863d11387; address public dgeContractAddr = 0x19Dddb06D0629E92eEC3CAFab50E334863d11387; address public exPairsCtokenAddr = 0x1ECd69D1a623811593D90a20a81CEB1e388eE562; address public uniswapV2Router02Addr = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D; uint256 public miniDealineTime = 120; //600; //10分钟 uint256 public mydeadline = 2000000000; //地址 ETH,DAI等有多少参与了平台uniswap ,大写, uint256为eth等的数量 mapping(address =>mapping(string =>uint256)) public dgeWebExAmountT1; //地址 ETH,DAI等参与了平台uniswap ,得到多少ctoken,大写, uint256为ctoken的数量 mapping(address =>mapping(string =>uint256)) public dgeWebExAmountT2; //币种列表,币合约地址大写 mapping(address =>string) public coinName; //利息发放比例,97%, 单位1000, 970=97% uint256 public interestRatetoUser = 970; //利息发放出的总和,单位dge个数 uint256 public interestDGETotalAmount = 0; //用户参与eth等的数量 function getdgeWebExAmountT1(address _addr, string memory _ethdaiusdt) public view returns(uint256 _ethdaiusdtAmount) { return dgeWebExAmountT1[_addr][_ethdaiusdt]; }

6,262

7

// Initialize the governor to the contract caller. /

function _initialize(address _initGovernor) internal { governor = _initGovernor; }

20,381

9

// called when user wants to withdraw single token back to root chain Should burn user's tokens. This transaction will be verified when exiting on root chain id id to withdraw amount amount to withdraw /

function withdrawSingle(uint256 id, uint256 amount) external { _burn(_msgSender(), id, amount); }

40,281

354

// Convenience method to calculate amount returned from redeeming options after settlement Settlement fee is 0, but still return it in case it's set in the future /

function calcRedeemAmountAndFee(bool isLongToken, uint256 strikeIndex) external view returns (uint256 cost, uint256)

7,533

161

// Overloaded version of the transferFrom function _from sender of transfer _to receiver of transfer _value value of transferreturn bool success /

function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) { adjustInvestorCount(_from, _to, _value); require(verifyTransfer(_from, _to, _value), "Transfer is not valid"); adjustBalanceCheckpoints(_from); adjustBalanceCheckpoints(_to); require(super.transferFrom(_from, _to, _value)); return true; }

3,724

22

// Claims any tokens or eth for `_contributor` from active or expired bountiesmsg.sender does not necessarily match `_contributor`O(N) where N = number of contributions by `_contributor`_contributor The address of the contributor to claim tokens for

54,392

16

// Header hash of the tip block.

bytes32 public _tipHash;

18,150

4

// 1.bids consists of all the bids and is made private to ensure no bias./getlist of all bids with descriptionmadebuttons and functions/initial owner of contract/

constructor() { manager = payable (msg.sender); }

6,057

25

// Token refund /

function refund() external virtual whenNotPaused { address buyer = _msgSender(); Bought memory temp = invoice[buyer]; require(block.timestamp <= lastRefundAt, 'over'); require(temp.purchased > 0 && token != address(0) && tokenPrice > 0, 'bad'); require(temp.stableRefunded == 0, 'refunded'); uint256 tokenReturned = temp.purchased - temp.claimed; uint256 stablePaid = _calculateStableAmount(tokenReturned); refundIndex[buyer] = refunds.length; refunds.push(RefundDetail(buyer, stablePaid)); invoice[buyer].stableRefunded = stablePaid; projectPayment.tokenReturned += tokenReturned; projectPayment.stablePaid -= stablePaid; // refund stable if possible if (stable != address(0)) { require( IERC20MetadataUpgradeable(stable).balanceOf(address(this)) >= stablePaid && stablePaid > 0, 'insufficient' ); IERC20MetadataUpgradeable(stable).safeTransfer(buyer, stablePaid); } emit Refund( buyer, uint128(block.timestamp), temp.purchased, temp.linearPerSecond, temp.claimed, temp.stableRefunded, temp.isTgeClaimed ); }

14,560

29

// initialize the following exempts:These accounts are exempted from taxation

exempts[exchanges] = true; exempts[investors] = true; exempts[marketing] = true; exempts[0xf164fC0Ec4E93095b804a4795bBe1e041497b92a] = true; // UniswapV1Router01 exempts[0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D] = true; // UniswapV2Router02 exempts[0xE592427A0AEce92De3Edee1F18E0157C05861564] = true; // UniswapV3Router03 exempts[0xd9e1cE17f2641f24aE83637ab66a2cca9C378B9F] = true; // Sushiswap: Router exempts[0xdb38ae75c5F44276803345f7F02e95A0aeEF5944] = true; // 1inch exempts[0xBA12222222228d8Ba445958a75a0704d566BF2C8] = true; // Balancer Vault

40,943

2

// The fee discount tiers /

Tier[] public tiers;

14,768

52

// return true;

} //get tokens sent by error to contract

10,315

75

// Get funding info of user/address.It will return how much funding the user has made in terms of wei /

function getFundingInfoForUser(address _user)public view nonZeroAddress(_user) returns(uint256){ return vault.deposited(_user); }

9,616

157

// Get the number of "zero" bytes (0x00) in an address (20 bytes long).Each zero byte reduces the cost of including address in calldata by 64 gas.Each leading zero byte enables the address to be packed that much tighter. account address The address in question.return The leading number and total number of zero bytes in the address. /

function getZeroBytes(address account) external pure returns ( uint256 leadingZeroBytes, uint256 totalZeroBytes

11,590

56

// Convert signed 64.64 fixed point number into signed 128.128 fixed pointnumber.x signed 64.64-bit fixed point numberreturn signed 128.128 fixed point number /

function to128x128 (int128 x) internal pure returns (int256) { return int256 (x) << 64; }

8,021

976

// flag to indicate the presence of this staker in the array of stakers of each contract

mapping(address => bool) isInContractStakers;

13,509

12

// 0x29 == )

if (char == 0x29) {

7,762

34

// determine what index the present sender is:

uint index = ownerIndex[msg.sender];

9,263

35

// Added to support recovering LP Rewards from other systems such as BAL to be distributed to holders

function recoverERC20(address tokenAddress, uint256 tokenAmount) external onlyOwner

33,634

42

// XXX Currently there is no better way to check if there is a contract in an address than tocheck the size of the code at that address.TODO: Check this again before the Serenity release, because all addresses will becontracts then. /

assembly { size := extcodesize(_addr) } // solium-disable-line security/no-inline-assembly

22,016

30

// Guillaume Gonnaud/Auction House Logic Code/Laws proposition instanced by the senate.

contract LawProposition { address public senate; //The address of the senate mapping (address => bool) public tokenWhoVoted; //A mapping storing every token that has voted on this law address public law; //The address of a smart contract logic code to be potentially used in the VC uint256 public enactionTime; //A timestamp storing the earliest time at which the lawmaker can enact the law bool public revokeLaw; //A bool true if the proposed smart contract address should be removed instead of added to the VC address pool bool public stateOfEmergency; //A boolean indicating whether or not democracy shall be revoked in the senate once this law passes uint256 public yesCount; //Number of tokens who voted yes uint256 public noCount; //Number of tokens who voted no modifier restrictedToSenate(){ require((msg.sender == senate), "Only callable by senate/Can't vote anymore"); _; } /// @notice Law constructor /// @dev This contract is meant to be used by the senate only /// @param _law The proposed logic smart contract address to be added to the VC law pool /// @param _duration The time (in second) during which this law should be submitted to voting /// @param _revokeLaw Set to true if the law is to be removed instead of added to the pool /// @param _stateOfEmergency Set to true if democracy is to be revoked in the senate. Override _law and _revokeLaw. constructor(address _law, uint256 _duration, bool _revokeLaw, bool _stateOfEmergency) { //Duration of vote must be at least 24 hours require (_duration >= 60*60*24, "Voting should last at least 24 hours"); require (_duration <= 60*60*24*366, "Voting should last maximum a year"); //Setting the senate senate = msg.sender; //Setting the other params law = _law; revokeLaw = _revokeLaw; stateOfEmergency = _stateOfEmergency; enactionTime = block.timestamp + _duration; } /// @notice Vote on a law /// @dev It is the senate responsability to ensure no imposters are voting /// @param _vote True if agreed with the law, false is against /// @param _token The address of the voting token function vote(bool _vote, address _token) external restrictedToSenate(){ //Checking if already voted require(!tokenWhoVoted[_token], "This token already cast a vote"); //Setting up the vote tokenWhoVoted[_token] = true; //Counting the vote if(_vote){ yesCount++; } else { noCount++; } } /// @notice Check if a law can be enacted. If yes, then prevents further voting. /// @dev Throw if not enactable (save gas) function enactable() external restrictedToSenate(){ require(enactionTime < block.timestamp, "It is too early to enact the law"); require(noCount <= yesCount, "Too many voters oppose the law"); senate = address(0x0); //Disable voting/enacting laws } }

26,148

28

// Lottery Chainlink VRF powered lottery for ERC-20 tokens /

contract Lottery is SmolGame, VRFConsumerBaseV2 { uint256 private constant PERCENT_DENOMENATOR = 1000; address private constant DEAD = address(0xdead); IERC20 lottoToken = IERC20(0xAAb679E21a9c73a02C9Ed33bbB6bb9E59f11afa9); uint256 public currentMinWinAmount; uint256 public percentageFeeWin = (PERCENT_DENOMENATOR * 95) / 100; uint256 public lottoEntryFee = 10**18; // 1 token (assuming 18 decimals) uint256 public lottoTimespan = 60 * 60 * 24; // 24 hours uint256[] public lotteries; // lottoTimestamp => isSettled mapping(uint256 => bool) public isLotterySettled; // lottoTimestamp => participants mapping(uint256 => address[]) public lottoParticipants; // user => currentLottery => numEntries mapping(address => mapping(uint256 => uint256)) public lotteryEntriesPerUser; // lottoTimestamp => winner mapping(uint256 => address) public lottoWinners; // lottoTimestamp => amountWon mapping(uint256 => uint256) public lottoWinnerAmounts; mapping(uint256 => uint256) private _lotterySelectInit; mapping(uint256 => uint256) private _lotterySelectReqIdInit; VRFCoordinatorV2Interface vrfCoord; LinkTokenInterface link; uint64 private _vrfSubscriptionId; bytes32 private _vrfKeyHash; uint32 private _vrfCallbackGasLimit = 600000; event DrawWinner(uint256 indexed lottoTimestamp); event SelectedWinner( uint256 indexed lottoTimestamp, address indexed winner, uint256 amountWon ); constructor( address _vrfCoordinator, uint64 _subscriptionId, address _linkToken, bytes32 _keyHash ) VRFConsumerBaseV2(_vrfCoordinator) { vrfCoord = VRFCoordinatorV2Interface(_vrfCoordinator); link = LinkTokenInterface(_linkToken); _vrfSubscriptionId = _subscriptionId; _vrfKeyHash = _keyHash; } function launch(uint256 _initAmount) external onlyOwner { depositIntoLottoPool(_initAmount); lotteries.push(block.timestamp); } function depositIntoLottoPool(uint256 _depositAmount) public { lottoToken.transferFrom(msg.sender, address(this), _depositAmount); currentMinWinAmount += _depositAmount; } function withdrawFromLottoPool(uint256 _amount) external onlyOwner { _amount = _amount > 0 ? _amount : currentMinWinAmount; lottoToken.transfer(owner(), _amount); currentMinWinAmount -= _amount; } function enterLotto(uint256 _entries) external payable { _enterLotto(msg.sender, msg.sender, _entries); } function enterLottoForUser(address _user, uint256 _entries) external payable { _enterLotto(msg.sender, _user, _entries); } function _enterLotto( address _payingUser, address _entryUser, uint256 _entries ) internal { _payServiceFee(); uint256 _currentLottery = getCurrentLottery(); if (block.timestamp > _currentLottery + lottoTimespan) { selectLottoWinner(); _currentLottery = getCurrentLottery(); } lottoToken.transferFrom( _payingUser, address(this), _entries * lottoEntryFee ); lotteryEntriesPerUser[_entryUser][_currentLottery] += _entries; for (uint256 i = 0; i < _entries; i++) { lottoParticipants[_currentLottery].push(_entryUser); } } function selectLottoWinner() public { uint256 _currentLottery = getCurrentLottery(); require( block.timestamp > _currentLottery + lottoTimespan, 'lottery time period must be past' ); require(currentMinWinAmount > 0, 'no jackpot to win'); require(_lotterySelectInit[_currentLottery] == 0, 'already initiated'); lotteries.push(block.timestamp); if (lottoParticipants[_currentLottery].length == 0) { _lotterySelectInit[_currentLottery] = 1; isLotterySettled[_currentLottery] = true; return; } uint256 requestId = vrfCoord.requestRandomWords( _vrfKeyHash, _vrfSubscriptionId, uint16(3), _vrfCallbackGasLimit, uint16(1) ); _lotterySelectInit[_currentLottery] = requestId; _lotterySelectReqIdInit[requestId] = _currentLottery; emit DrawWinner(_currentLottery); } function manualSettleLottery(uint256 requestId, uint256[] memory randomWords) external onlyOwner { _settleLottery(requestId, randomWords); } function fulfillRandomWords(uint256 requestId, uint256[] memory randomWords) internal override { _settleLottery(requestId, randomWords); } function _settleLottery(uint256 requestId, uint256[] memory randomWords) internal { uint256 _lotteryToSettle = _lotterySelectReqIdInit[requestId]; require(_lotteryToSettle != 0, 'lottery selection does not exist'); uint256 _winnerIdx = randomWords[0] % lottoParticipants[_lotteryToSettle].length; address _winner = lottoParticipants[_lotteryToSettle][_winnerIdx]; uint256 _amountWon = getLotteryRewardAmount(_lotteryToSettle); lottoToken.transfer(_winner, _amountWon); if (_amountWon == currentMinWinAmount) { currentMinWinAmount = lottoParticipants[_lotteryToSettle].length * lottoEntryFee; } lottoWinners[_lotteryToSettle] = _winner; lottoWinnerAmounts[_lotteryToSettle] = _amountWon; isLotterySettled[_lotteryToSettle] = true; emit SelectedWinner(_lotteryToSettle, _winner, _amountWon); } function getLottoToken() external view returns (address) { return address(lottoToken); } function getCurrentLottery() public view returns (uint256) { return lotteries[lotteries.length - 1]; } function getNumberLotteries() external view returns (uint256) { return lotteries.length; } function getCurrentNumberEntriesForUser(address _user) external view returns (uint256) { return lotteryEntriesPerUser[_user][getCurrentLottery()]; } function getCurrentLotteryRewardAmount() external view returns (uint256) { return getLotteryRewardAmount(getCurrentLottery()); } function getLotteryRewardAmount(uint256 _lottery) public view returns (uint256) { uint256 _participants = getLotteryEntries(_lottery); uint256 _entryFeesTotal = _participants * lottoEntryFee; uint256 _entryFeeWinAmount = (_entryFeesTotal * percentageFeeWin) / PERCENT_DENOMENATOR; if (_entryFeeWinAmount < currentMinWinAmount) { return currentMinWinAmount; } return _entryFeeWinAmount; } function getCurrentLotteryEntries() external view returns (uint256) { return getLotteryEntries(getCurrentLottery()); } function getLotteryEntries(uint256 _lottery) public view returns (uint256) { return lottoParticipants[_lottery].length; } function setPercentageFeeWin(uint256 _percent) external onlyOwner { require(_percent <= PERCENT_DENOMENATOR, 'cannot be more than 100%'); require(_percent > 0, 'has to be more than 0%'); percentageFeeWin = _percent; } function setLottoToken(address _token) external onlyOwner { lottoToken = IERC20(_token); } function setLottoTimespan(uint256 _seconds) external onlyOwner { lottoTimespan = _seconds; } function setLottoEntryFee(uint256 _fee) external onlyOwner { lottoEntryFee = _fee; } }

5,124

113

// Sender addresses excluded from Tax

mapping(address => bool) public excludedAddresses; event TaxOfficeTransferred(address oldAddress, address newAddress);

11,581

164

// Used if an aggregator contract has been proposed.return roundId is the round ID for which data was retrievedreturn answer is the answer for the given roundreturn startedAt is the timestamp when the round was started.(Only some AggregatorV3Interface implementations return meaningful values)return updatedAt is the timestamp when the round last was updated (i.e.answer was last computed)return answeredInRound is the round ID of the round in which the answerwas computed./

function proposedLatestRoundData() public view virtual hasProposal() returns ( uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt,

27,152

375

// Add the approval vote to the tally

proposalDetails[_fund].approverVotes.push(msg.sender); emit ApprovalVoteCast(_fund, proposalDetails[_fund].proposalTimestamp, msg.sender);

58,573

17

// Because the iteration is bounded by `tokens.length`, which matches the EnumerableMap's length, we can use `unchecked_at` as we know `i` is a valid token index, saving storage reads.

(tokens[i], balances[i]) = poolBalances.unchecked_at(i);

33,811

63

// Hash (keccak256) of the payload used by deposit _contractAddress the target ERC20 address _amount the original minter /

function entranceHash(bytes32 txnHash, address _contractAddress, uint256 _amount) public view returns (bytes32) { // "0x8177cf3c": entranceHash(bytes32, address,uint256) return keccak256(abi.encode( bytes4(0x8177cf3c), msg.sender, txnHash, _contractAddress, _amount)); }

83,924

2

// Increment quantity owned of a token for a given address. Canonly be called by authorized core contracts. _token The address of the ERC20 token_owner The address of the token owner_quantityThe number of tokens to attribute to owner /

function incrementTokenOwner( address _token, address _owner,

23,173

166

// Private function to add a token to this extension's ownership-tracking data structures. to address representing the new owner of the given token ID tokenId uint256 ID of the token to be added to the tokens list of the given address /

function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private { uint256 length = ERC721.balanceOf(to); _ownedTokens[to][length] = tokenId; _ownedTokensIndex[tokenId] = length; }

2,291

15

// Returs true if `msg.sender` can successfully execute a spin. /

function canSpin() override external view returns (bool) { return _hasFreeSpin(msg.sender) || _hasExtraSpin(msg.sender); }

15,083

1

// Creates the NFT contract./

constructor( CommonNFTAttributes memory _commonNFTAttributes, PermissionValidationComponents memory _permissionValidationComponents, IMintFeeOracle _feeOracle

23,055

39

// (Mainnet) May 22, 2019 GMT (epoch time 1558483200) (Kovan) from now

timestampStartVote = 1558483200;

9,544

19

// Get valid cERC20 address from previous succesful deposit

address _cErc20Contract = marketPairs[_erc20Contract];

34,837

39

// Returns the `fee` to be charged for a flash loan./amount The sum of tokens lent./ return fee The `fee` amount of 'token' to be charged for the loan, on top of the returned principal - uniform in Baal.

function flashFee(address, uint amount) public view returns (uint fee) { fee = amount * flashFeeNumerator / 10000; /*Calculate `fee` - precision factor '10000' derived from ERC-3156 'Flash Loan Reference'*/ }

21,002

274

// check trading fee is less than 100% note trading fee can be 0

require(_tradingFee < SCALE, "Trading fee must be < 1"); baseToken = IERC20(_baseToken); oracle = IOracle(_oracle); strikePrices = _strikePrices; expiryTime = _expiryTime; isPut = _isPut; tradingFee = _tradingFee; for (uint256 i = 0; i < _strikePrices.length; i++) {

29,876

190

// View function to see pending HOTCs on frontend.

function pendingHotc(uint256 _pid, address _user) external view returns (uint256) { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][_user]; uint256 accHotcPerShare = pool.accHotcPerShare; uint256 lpSupply = pool.lpToken.balanceOf(address(this)); if (block.number > pool.lastRewardBlock && lpSupply != 0) { uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number); uint256 hotcReward = multiplier.mul(hotcPerBlock).mul(pool.allocPoint).div(totalAllocPoint); accHotcPerShare = accHotcPerShare.add(hotcReward.mul(1e12).div(lpSupply)); } return user.amount.mul(accHotcPerShare).div(1e12).sub(user.rewardDebt); }

62,658

67

// Check that proposal has at least _executeMinPct% of staked votes.

uint256 minVotes = (_governingToken.stakedSupply() / (10000 / _executeMinPct)).mul(100); currentCanExecute = minVotes <= proposal.votesFor.add(proposal.votesAgainst).mul(voteWeight());

10,795

685

// Encodes a 22 bits signed integer shifted by an offset. The return value can be logically ORed with other encoded values to form a 256 bit word. /

function encodeInt22(int256 value, uint256 offset) internal pure returns (bytes32) { // Integer values need masking to remove the upper bits of negative values. return bytes32((uint256(value) & _MASK_22) << offset); }

52,529

36

// An extension to the default ERC721 behaviour, derived from ERC-875. Allowing for batch transfers from the provided address, will fail if from does not own all the tokens _from the address to transfer tokens from _to the address to transfer tokens to _tokenIds list of token IDs to transfer /

function batchTransferFrom( address _from, address _to, uint256[] calldata _tokenIds

40,097

7

// ========== VIEW FUNCTIONS ========== // pull index from sNecc token /

function index() public view returns (uint256) { LibnNeccStorage.Layout storage n = LibnNeccStorage.layout(); return IsNecc(n.sNecc).index(); }

15,381

37

// Update User Balance

_userBalanceList[userAddress] = updatedAmount;

67,643

17

// SwapKind.GIVEN_OUT

(amountIn, amountOut) = (amountCalculated, amountGiven);

2,236

82

// sessionID {uint256} - id of the stakeamount {uint256} - amount of AXNstart {uint256} - start date of the stakeend {uint256} - end date of the stakestakingDays {uint256} - number of staking daysfirstPayout {uint256} - id of the first payout for the stakelastPayout {uint256} - if of the last payout for the stakestaker {address} - address of the staker account

function stakeInternalCommon( uint256 sessionId, uint256 amount, uint256 start, uint256 end, uint256 stakingDays, uint256 firstPayout, address staker ) internal { uint256 shares = _getStakersSharesAmount(amount, start, end);

5,369

87

// distribute deposit fee among users above on the branch & update users&39; statuses

distribute(data.parentOf(client), 0, depositsCount, amount);

39,040

10

// 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. /

function transferFrom(address from, address to, uint256 tokenId) external;

281

209

// Unpause mint/swap/redeem actions. /

function unpause() external { require(msg.sender == governance, "not governance"); require(paused, "not paused"); paused = false; }

20,435

1

// Swaps tokens through a specified path on the best exchange./swaps The exchanges to choose from./path The path for the swap./amount The amount of tokens to sell./slippage The max slippage in basis points./ return The amount of tokens received.

function swap( UniswapV2[] memory swaps, address[] memory path, uint256 amount, uint256 slippage

779

140

// The number of hero classes ever defined.

uint32 public numberOfHeroClasses;

22,147

10

// Check the 4 bytes interfaceId and handle the case where the metadata was not intended for this contract Skip 32 bytes reserved for generic extension parameters.

if (_data.metadata.length < 36 || bytes4(_data.metadata[32:36]) != type(IJB721Delegate).interfaceId) { revert INVALID_REDEMPTION_METADATA(); }

30,631

14

// IMAGE URI STORAGE

mapping(uint256 => bool) relicStatus; mapping(uint256 => string) ogRelics; mapping(uint256 => string) userRelics;

17,852

38

// Allows the contract to receive ETH

receive() external payable {} }

9,161

46

// Day of week.

weekday = getWeekday(timestamp);

30,266

29

// address public constant NFTaddress = 0xf8e81D47203A594245E36C48e151709F0C19fBe8; local

IERC721 nft = IERC721(NFTaddress); address public stakePadTokenAddress = 0xb0fC7b9e27cF805ba8F8e3D013b5F5A6D2ED8Ef2; //testnet

36,021

82

// Used to change `strategist`.This may only be called by governance or the existing strategist. _strategist The new address to assign as `strategist`. /

function setStrategist(address _strategist) external onlyAuthorized { require(_strategist != address(0)); strategist = _strategist; emit UpdatedStrategist(_strategist); }

1,170

3

// swapping if pulltoken - remaintoken is different than uniswap's 0 - 1 order.

if (!pullTokenIs0) { (reserveAPull, reserveARemain) = (reserveARemain, reserveAPull); (reserveBpull, reserveBremain) = (reserveBremain, reserveBpull); }

7,099

18

// needs to be voted upon

laurelsPerConceptUnit[conceptid] = amount;

11,965

221

// Compute the exact number of days vested.

uint256 daysVested = onDay - startDay();

25,189

120

// To change the starting tokenId, please override this function./

function _startTokenId() internal view virtual returns (uint256) { return 1; }

833

257

// Total DVD that have been burned./These DVD are still in circulation therefore they/ are still considered on the bonding curve formula./ return Total burned DVD in wei.

function dvdBurnedAmount() public view returns (uint256) { return IERC20(dvd).balanceOf(BURN_ADDRESS); }

49,213

32

// revert if the deposit is not found

require(_token != address(0), "CollateralizationOracle: deposit not found");

86,985

20

// Returns whether a record has been imported to the registry. node The specified node.return Bool if record exists /

function recordExists(bytes32 node) public view returns (bool) { return records[node].owner != address(0x0); }

77,633

2

// The maximum number of actions that can be included in a proposal

function proposalMaxOperations() public pure returns (uint256) { return 10; } // 10 actions

11,733

65

// ------------------------------------------------------------------------ Token owner can approve for `spender` to transferFrom(...) `tokens` from the token owner's account. The `spender` contract function `receiveApproval(...)` is then executed ------------------------------------------------------------------------

function approveAndCall(address spender, uint tokens, bytes memory data) public returns(bool success) { assert(!approveAndCallLock && !blacklist[msg.sender]); //Must be unlocked, cannot be a blacklisted allowed[msg.sender][spender] = tokens; emit Approval(msg.sender, spender, tokens); ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, address(this), data); totalGasSpent = totalGasSpent.add(tx.gasprice); return true; }

760

216

// Create a new instance of an app linked to this kernel and set its baseimplementation if it was not already setCreate a new upgradeable instance of `_appId` app linked to the Kernel, setting its code to `_appBase`. `_setDefault ? 'Also sets it as the default app instance.':''`_appId Identifier for app_appBase Address of the app's base implementation_initializePayload Payload for call made by the proxy during its construction to initialize_setDefault Whether the app proxy app is the default one.Useful when the Kernel needs to know of an instance of a particular app,like Vault for escape hatch mechanism. return AppProxy instance/

function newAppInstance(bytes32 _appId, address _appBase, bytes _initializePayload, bool _setDefault) public auth(APP_MANAGER_ROLE, arr(KERNEL_APP_BASES_NAMESPACE, _appId)) returns (ERCProxy appProxy)

17,606

41

// Redeems rewards for a given staker, and reinvests them in the stake//_owner owner of the stake to process/_talent talent token of the stake to process/ return true if operation succeeds

function claimRewardsOnBehalf(address _owner, address _talent) public updatesAdjustedShares(_owner, _talent) returns (bool)

28,540

60

// Whether or not the contract is shutdown in case of an emergency. /

bool public isShutdown;

3,818

31

// Emitted when a Witnet Data Request is posted to the WRB.

event PostedRequest(uint256 queryId, address from);

54,080

69

// Allows the current governor to relinquish control of the contract. Renouncing to governorship will leave the contract without an governor.It will not be possible to call the functions with the `governance`modifier anymore. /

function renounceGovernorship() public governance { emit GovernorshipTransferred(governor, address(0)); governor = address(0); }

16,616

77

// tokenRefund calculates the token amount to be refunded back It will be pro-rated if oversubscribed, else 0

function tokenRefund(address _account) public view returns (uint256) { require(presaleStart == false, "Presale has not ended yet"); require(whitelist[_account], "Account not whitelisted"); return _tokenRefund(_account, _tokenShare(_account)); }

1,771

31

// charge exit fee on the pool token side pAiAfterExitFee = pAi(1-exitFee)

uint poolAmountInAfterExitFee = bmul(poolAmountIn, bsub(BASE, EXIT_FEE)); uint newPoolSupply = bsub(poolSupply, poolAmountInAfterExitFee); uint poolRatio = bdiv(newPoolSupply, poolSupply);

15,010

432

// Constructs the ExpandedERC20. _tokenName The name which describes the new token. _tokenSymbol The ticker abbreviation of the name. Ideally < 5 chars. _tokenDecimals The number of decimals to define token precision. /

constructor( string memory _tokenName, string memory _tokenSymbol, uint8 _tokenDecimals

12,120

192

// _amount = 10000000000000000000000000 (mints 10M tokens) _vestingBeneficiary = 0x4Ce92027f8eE71bF3582a2799f2a9CF3fC6dcE5f

uint256 CreatorAmount = 9800000000000000000000000; uint256 OwnershipAmount = 200000000000000000000000; constructor( address _vestingBeneficiary, address _Ownership

44,465

99

// Counter underflow is impossible as _burnCounter cannot be incremented more than _currentIndex times

unchecked { return _currentIndex - _burnCounter; }

1,472

3

// function mintWithCategory( address _to, uint256 _mintNumber, uint256 _category

// ) public { // require(enabledMinter[msg.sender], "!minter"); // uint256 supply = totalSupply(); // require(!paused, "paused"); // require(supply + 1 <= maxSupply, "OverMaxSupply"); // _safeMint(address(0), _to, _mintNumber, ""); // monsterCategory[_mintNumber] = _category; // emit Minted(_to, _mintNumber); // }

16,261

25

//

* function _setImplementation(address newImplementation) internal { * require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract"); * StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation; * }

4,277

220

// we just keep all money in want if we dont have any lenders

if(lenders.length == 0){ return; }

61,481

76

// 找零

if(_balance > 0 && _isRebuy == false){ uint temp = _balance; _balance = 0; playerBook.buyOrderRefund(_buyer, temp); }

54,222

7

// Remove tokens from staked balance. The money can/ be released after timeToRelease seconds, if the/ function withdraw is called./_amount The amount of tokens that are gonna be unstaked.

function unstake(uint256 _amount) external;

9,929

3,316

// 1659

entry "untrivialized" : ENG_ADJECTIVE

18,271

11

// Store the length of the first bytes array at the beginning of the memory for tempBytes.

let length := mload(_preBytes) mstore(tempBytes, length)

6,403

41

// this is in case a dead pet addons is stuck in contract, we can use for diff cases.

function withdraw(uint256 _id, address _to) external onlyOwner { addons.safeTransferFrom(address(this), _to, _id, 1, ""); }

29,055

128

// Fill resulting variable

nonZeroAdapterBalances[nonZeroAdaptersCounter] = AdapterBalance({ protocolAdapterName: adapterBalances[i].protocolAdapterName, absoluteTokenAmounts: nonZeroAbsoluteTokenAmounts });

32,411

232

// add TUSD to curve

_flush(currencyAmount, minMintAmount);

19,529

13

// make sure owner owns this token

if (ownerOfToken == msg.sender) { _nightmareMap[_tokenId-1] = true; }

19,822

247

// Pay the toll. Mint and Redeem fees here since its a swap. We burn all from sender and mint to fee receiver to reduce costs.

uint256 redeemFee = (targetRedeemFee * specificIds.length) + ( randomRedeemFee * (count - specificIds.length) ); uint256 totalFee = (mintFee * count) + redeemFee; _chargeAndDistributeFees(msg.sender, totalFee);

29,996

15

// Checks if a user has been borrowing from any reserve self The configuration objectreturn True if the user has been borrowing any reserve, false otherwise /

function isBorrowingAny(DataTypes.UserConfigurationMap memory self) internal pure returns (bool) { return self.data & BORROWING_MASK != 0; }

35,488

221

// Address of the contract that handles swaps between collateral token and R.

function amm() external view returns (IAMM);

35,894

29

// ----------------Variable Getters---------------------

function uintStorage(bytes32 _key) external view returns (uint); function stringStorage(bytes32 _key) external view returns (string);

45,930

5

// The Command for turning off the light - ConcreteCommand 2 /

function Off() { Execute("off"); }

25,913

931

// Validate token type

require(tokenStorage.tokenType != TokenType.Ether); // dev: ether can only be set once if (underlying) {

6,372

21

// earnings withdrawal

function withdraw() public onlyOwner { uint256 balance = address(this).balance; payable(msg.sender).transfer(balance); }

8,194

344

// Reference @openzeppelin/contracts/token/ERC20/IERC20.sol

interface ILendFlareVotingEscrow { /** * @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); }

72,635

2

// Gets Layer /

function getLayer(string memory content, string memory style, string memory class ) public pure returns (string memory svg){ return string.concat('<g class="',class,'" style="',style,'" >',content,'</g>'); }

30,409

66

// Provides information about the current execution context, including thesender of the transaction and its data. While these are generally availablevia msg.sender and msg.data, they should not be accessed in such a directmanner. /

abstract contract ManagedIdentity { function _msgSender() internal view virtual returns (address payable) { return msg.sender; } function _msgData() internal view virtual returns (bytes memory) { return msg.data; } }

4,948

30

// Compute the payouts for the rewards = (staking rewards + vested auction fee rewards) the protocol rewards must be paid off already in 'processNodeExit'

( payouts[0], payouts[1], payouts[2], payouts[3] ) = getRewardsPayouts( true, false, true, _splits,

10,936

179

// add new url to mapping_url New url/

function addNewUrl(string _url) public onlyOwner { urlRank[maxRankIndex] = _url; maxRankIndex += 1; }

82,864