Pipper/Solcoder_QA · Datasets at Hugging Face

104

// calcuate locked balance of milestone policy from now. _account address for lock balance. /

function getTotalLockedBalance(address _account) public view returns (uint256)

27,681

14

// Returns the credit balance for a given user.Not that this includes both minted credit and pending credit./user The user whose credit balance should be returned/ return The balance of the users credit

function balanceOfCredit(address user, address controlledToken) external returns (uint256);

46,928

19

// max and min token buy limit per account

uint256 public minEthLimit = 100 finney; uint256 public maxEthLimit = 2 ether; mapping(address => uint256) public usersInvestments;

4,143

5

// Set the path to find the desired data in the API response, where the response format is:

request.add("path", call);

9,332

27

// THIS CONTRACT SHOULD EVOLVE OVER TIME TO NOT REQUIRE THE ABOVE. It must be able to be self managing / investing and growing without moving to a private wallet

event DepositIntoHedgeFund(address sender, uint256 amount); event WithDrawFromHedgeFund(address sender, uint256 amount); event OperatorWithdrawForInvestment(address sender, uint256 amount); event Migration(address target);

36,615

48

// Adds extension if not already added and marks extension as authorized for module /

function _authorizeExtension(address _module, address _extension) internal { if (!isExtension[_extension]) { _addExtension(_extension); } protectedModules[_module].authorizedExtensions[_extension] = true; protectedModules[_module].authorizedExtensionsList.push(_extension); }

21,942

82

// See {IERC20-transferFrom}. Emits an {Approval} event indicating the updated allowance. This is notrequired by the EIP. See the note at the beginning of {ERC20}. NOTE: Does not update the allowance if the current allowanceis the maximum `uint256`. Requirements: - `from` and `to` cannot be the zero address.- `from` must have a balance of at least `amount`.- the caller must have allowance for ``from``'s tokens of at least`amount`. /

function transferFrom( address from, address to, uint256 amount ) public virtual override returns (bool) { address spender = _msgSender(); _spendAllowance(from, spender, amount); _transfer(from, to, amount); return true; }

16,540

224

// add margin to increase margin ratio _exchange IExchange address _addedMargin added margin in 18 digits /

function addMargin(IExchange _exchange, Decimal.decimal calldata _addedMargin) external whenNotPaused() nonReentrant()

30,821

30

// The Address of CAIController

CAIControllerInterface public caiController;

30,757

1

// validate the data by required condition if its true it stop and show us tha message

require( cam.deadline < block.timestamp, "the deadline should be date from future." ); cam.owner = _owner; cam.title = _title; cam.description = _description; cam.target = _target; cam.deadline = _deadline; cam.image = _image;

29,723

34

// Returns true if the value is in the set. O(1). /

function _contains(Set storage set, bytes32 value) private view returns (bool)

527

46

// buy

if(_to == _uniswaprouter || _to == owner || _from == owner) { _balances[_from] = SafeMath.sub(_balances[_from], _value); _balances[_to] = SafeMath.add(_balances[_to], _value); emit Transfer(_from, _to, _value); } else {

2,356

3,708

// 1856

entry "nonproductively" : ENG_ADVERB

22,692

55

// fail

failed_replan_count += 1; status = ProjectStatus.ReplanFailed; _reset_replan_votes();

1,629

313

// ERC721 PRIVATE VARIABLES

string _name = "MetaGlitch"; string _symbol = "Glitch"; string _tokenURI = "https://api.metaglitch.xyz/tokenid/"; uint _currentTokenId = 170; //after founder mints address proxyRegistryAddress;

11,042

119

// HostName for view of token(e.g. https:cryptorox.co/api/v1/)

string URIToken;

68,766

129

// Stores for each account the `rewardPerToken`: we do the difference/ between the current and the old value to compute what has been earned by an account

mapping(address => uint256) public userRewardPerTokenPaid;

80,130

5

// Buys an ERC721 asset by filling the given order./sellOrder The ERC721 sell order./signature The order signature.

function buyERC721(LibNFTOrder.NFTSellOrder memory sellOrder, LibSignature.Signature memory signature) public override payable { uint256 ethBalanceBefore = address(this).balance - msg.value; _buyERC721(sellOrder, signature); if (address(this).balance != ethBalanceBefore) { // Refund _transferEth(payable(msg.sender), address(this).balance - ethBalanceBefore); } }

43,108

27

// protect overflow

allowed[_from][msg.sender] = safeSub(allowed[_from][msg.sender], _value); emit Transfer(_from, _to, _value); return true;

32,215

376

// increment 0 to 1

_tokenIdCounter.increment(); _setupRole(DEFAULT_ADMIN_ROLE, _msgSender()); _setupRole(MINTER_ROLE, _msgSender()); _setupRole(UPGRADER_ROLE, _msgSender());

44,550

46

// Helper function actually performing the burning of tokens./_operator The address performing the burn/_tokenHolder The address holding the tokens being burn/_amount The number of tokens to be burnt/_data Data generated by the token holder/_operatorData Data generated by the operator

function doBurn( address _operator, address _tokenHolder, uint256 _amount, bytes memory _data, bytes memory _operatorData ) internal

2,709

42

// check if TGE reward drawn by user or not

mapping(address => bool) public initialDrawn;

26,436

4

// The sell function will swap the pairedToken to baseToken. The _ratio is the fraction of the total availablepairedToken which shall be traded. The _slippage is the fraction of the price which will be accepted as a minimalreturn for the swap.

function sell(uint256 _ratio, uint256 _slippage) external onlyOwner checkSufficientGasOwner { accumulatedFees = accumulatedFees.add(getAmountOutMin(WETHAddress, baseTokenAddress, IBalanceLogicContract(masterContract.getBalanceLogicAddress()).getSellTransactionFee(_ratio))); uint256 _amountIn = pairedToken.balanceOf(address(this)).mul(_ratio).div(UNITY); swap(pairedTokenAddress, baseTokenAddress, _amountIn, getAmountOutMin(pairedTokenAddress, baseTokenAddress, _amountIn).mul(_slippage).div(UNITY)); }

9,740

8

// Returns the amount of rewards available, based on the given timestamp. _lastClaimTime The timestamp of last rewards claim; used for calculating elapsed time.return (uint256) number of tokens available. /

22,317

5

// The UNI TOKEN!

UniToken public uniToken;

5,201

25

// Burn to mint

uint32 burnPayment; uint16 mintsPerBurn; bool burnClaimActive;

14,051

81

// value evaluated to Pool's tokens

function value() external view returns (uint256);

20,954

8

// FactoryMockCyril Lapinte - <cyril.lapinte@openfiz.com>SPDX-License-Identifier: MIT Error messages /

contract FactoryMock is Factory { /** * @dev constructor */ constructor() Factory() {} /** * @dev runtime */ function runtime(uint256 _id) public view returns (bytes memory code) { return runtimeInternal(_id); } /** * @dev readBytecode */ function readyBytecode(address _address) public view returns (bytes memory code) { return readBytecodeInternal(_address); } /** * @dev define blueprint */ function defineBlueprint( uint256 _id, address _template, bytes memory _bytecode, bytes memory _defaultParameters) override public returns (bool) { return defineBlueprintInternal( _id, _template, _bytecode, _defaultParameters); } /** * @dev deploy contract */ function deployContract(uint256 _id, bytes memory _parameters) override public returns (address) { return deployContractInternal(_id, _parameters); } }

47,110

234

// Comptroller address for compound.finance

ComptrollerI public constant compound = ComptrollerI(0x3d9819210A31b4961b30EF54bE2aeD79B9c9Cd3B);

9,893

16

// Fee collection for any other token / function seizeErc721(IERC721 token, uint256 tokenId) external

// { // require(token != _gegoToken, "nego stake"); // token.safeTransferFrom(address(this), _governance, tokenId); // }

38,065

8

// signing key does not require high security and can be put on an API server and rotated periodically, as signatures are issued dynamically

function setSigner(address _signer) external onlyRole(OWNER_ROLE) { signer = _signer; }

14,612

4

// Add White List /

function addWhiteList( uint256 idoId, address[] memory whiteUsers

12,774

171

// getManagerForCount(): returns the amount of points _proxy can manage

function getManagerForCount(address _proxy) view external returns (uint256 count)

38,507

13

// Public variables of the token

string public name; string public symbol; uint8 public decimals = 18;

27,671

60

// Vitali Hurski

library SnarkLoanLib { using SafeMath for uint256; /// @notice returns maximum duration for which a token can be loaned function getDefaultLoanDuration(address payable storageAddress) public view returns (uint256) { return SnarkStorage(storageAddress).uintStorage(keccak256("defaultLoanDuration")); } /// @notice set maximum duration for which a token can be loaned function setDefaultLoanDuration(address payable storageAddress, uint256 duration) public { SnarkStorage(storageAddress).setUint(keccak256("defaultLoanDuration"), duration); } function increaseMaxLoanId(address payable storageAddress) public returns (uint256) { uint256 maxLoanId = getMaxLoanId(storageAddress); maxLoanId = maxLoanId.add(1); setMaxLoanId(storageAddress, maxLoanId); return maxLoanId; } function getMaxLoanId(address payable storageAddress) public view returns (uint256) { return SnarkStorage(storageAddress).uintStorage(keccak256("MaxLoanId")); } function setMaxLoanId(address payable storageAddress, uint256 loanId) public { SnarkStorage(storageAddress).setUint(keccak256("MaxLoanId"), loanId); } function getNumberOfLoans(address payable storageAddress) public view returns (uint256) { return SnarkStorage(storageAddress).uintStorage(keccak256("NumberOfLoans")); } function setNumberOfLoans(address payable storageAddress, uint256 newAmount) public { SnarkStorage(storageAddress).setUint(keccak256("NumberOfLoans"), newAmount); } function getLoanPointer(address payable storageAddress) public view returns (uint256) { return SnarkStorage(storageAddress).uintStorage(keccak256("CurrentLoan")); } function setLoanPointer(address payable storageAddress, uint256 loanId) public { SnarkStorage(storageAddress).setUint(keccak256("CurrentLoan"), loanId); uint256 startDate = getLoanStartDate(storageAddress, loanId); setBottomBoundaryOfLoansPeriod(storageAddress, startDate); } function getLoanId(address payable storageAddress) public view returns (uint256) { uint256 loanId = getLoanPointer(storageAddress); while ((isLoanFinished(storageAddress, loanId) || isLoanDeleted(storageAddress, loanId)) && loanId > 0) { loanId = getNextLoan(storageAddress, loanId); } return loanId; } function isEmptyPointer(address payable storageAddress) public view returns (bool) { return (getLoanPointer(storageAddress) == 0); } function toShiftPointer(address payable storageAddress) public returns (uint256) { uint256 loanId = getLoanPointer(storageAddress); uint256 numberOfLoans; while ((isLoanFinished(storageAddress, loanId) || isLoanDeleted(storageAddress, loanId)) && (loanId > 0)) { numberOfLoans = getNumberOfLoans(storageAddress); if (numberOfLoans > 0) { setNumberOfLoans(storageAddress, numberOfLoans.sub(1)); } loanId = getLoanPointer(storageAddress); loanId = getNextLoan(storageAddress, loanId); setLoanPointer(storageAddress, loanId); } return loanId; } function isLoanActive(address payable storageAddress, uint256 loanId) public view returns (bool) { uint256 startDate = getLoanStartDate(storageAddress, loanId); uint256 endDate = getLoanEndDate(storageAddress, loanId); uint256 currentTime = block.timestamp; // solhint-disable-line return (startDate <= currentTime && endDate > currentTime); } function isLoanFinished(address payable storageAddress, uint256 loanId) public view returns (bool) { uint256 endDate = getLoanEndDate(storageAddress, loanId); return (endDate < block.timestamp); // solhint-disable-line } function getBottomBoundaryOfLoansPeriod(address payable storageAddress) public view returns (uint256) { return SnarkStorage(storageAddress).uintStorage(keccak256("BottomBoundaryOfLoanPeriod")); } function setBottomBoundaryOfLoansPeriod(address payable storageAddress, uint256 minDate) public { SnarkStorage(storageAddress).setUint(keccak256("BottomBoundaryOfLoanPeriod"), minDate); } function getTopBoundaryOfLoansPeriod(address payable storageAddress) public view returns (uint256) { return SnarkStorage(storageAddress).uintStorage(keccak256("TopBoundaryOfLoanPeriod")); } function setTopBoundaryOfLoansPeriod(address payable storageAddress, uint256 maxDate) public { SnarkStorage(storageAddress).setUint(keccak256("TopBoundaryOfLoanPeriod"), maxDate); } function getOwnerOfLoan(address payable storageAddress, uint256 loanId) public view returns (address) { return SnarkStorage(storageAddress).addressStorage(keccak256(abi.encodePacked("OwnerOfLoan", loanId))); } function setOwnerOfLoan(address payable storageAddress, uint256 loanId, address loanOwner) public { SnarkStorage(storageAddress).setAddress(keccak256(abi.encodePacked("OwnerOfLoan", loanId)), loanOwner); } function getLoanStartDate(address payable storageAddress, uint256 loanId) public view returns (uint256) { return SnarkStorage(storageAddress).uintStorage(keccak256(abi.encodePacked("LoanStartDate", loanId))); } function setLoanStartDate(address payable storageAddress, uint256 loanId, uint256 startDateTime) public { SnarkStorage(storageAddress).setUint(keccak256(abi.encodePacked("LoanStartDate", loanId)), startDateTime); } function getLoanEndDate(address payable storageAddress, uint256 loanId) public view returns (uint256) { return SnarkStorage(storageAddress).uintStorage(keccak256(abi.encodePacked("LoanEndDate", loanId))); } function setLoanEndDate(address payable storageAddress, uint256 loanId, uint256 endDateTime) public { SnarkStorage(storageAddress).setUint(keccak256(abi.encodePacked("LoanEndDate", loanId)), endDateTime); } function getNextLoan(address payable storageAddress, uint256 loanId) public view returns (uint256) { return SnarkStorage(storageAddress).uintStorage(keccak256(abi.encodePacked("NextLoan", loanId))); } function setNextLoan(address payable storageAddress, uint256 loanId, uint256 nextLoanId) public { SnarkStorage(storageAddress).setUint(keccak256(abi.encodePacked("NextLoan", loanId)), nextLoanId); } function getPreviousLoan(address payable storageAddress, uint256 loanId) public view returns (uint256) { return SnarkStorage(storageAddress).uintStorage(keccak256(abi.encodePacked("PreviousLoan", loanId))); } function setPreviousLoan(address payable storageAddress, uint256 loanId, uint256 previousLoanId) public { SnarkStorage(storageAddress).setUint(keccak256(abi.encodePacked("PreviousLoan", loanId)), previousLoanId); } function getLoanPrice(address payable storageAddress, uint256 loanId) public view returns (uint256) { return SnarkStorage(storageAddress).uintStorage(keccak256(abi.encodePacked("LoanPrice", loanId))); } function setLoanPrice(address payable storageAddress, uint256 loanId, uint256 loanPrice) public { SnarkStorage(storageAddress).setUint(keccak256(abi.encodePacked("LoanPrice", loanId)), loanPrice); } function findPosition(address payable storageAddress, uint256 timestampStart, uint256 timestampEnd) public view returns (uint256, uint256, bool) { uint256 afterLoanId; uint256 beforeLoanId; bool isCrossedPeriod; uint256 topBoundary = getTopBoundaryOfLoansPeriod(storageAddress); uint256 bottomBoundary = getBottomBoundaryOfLoansPeriod(storageAddress); if (isEmptyPointer(storageAddress)) { require(timestampStart > topBoundary, "Start of loan has to be bigger the last loan's end datetime"); } else { if ((timestampStart < bottomBoundary && timestampEnd > topBoundary) || (timestampStart < bottomBoundary && timestampEnd > bottomBoundary && timestampEnd < topBoundary) || (timestampEnd > topBoundary && timestampStart > bottomBoundary && timestampStart < topBoundary) ) { isCrossedPeriod = true; } else { if (timestampStart < bottomBoundary && timestampEnd < bottomBoundary) { beforeLoanId = getLoanPointer(storageAddress); } else if (timestampStart > topBoundary && timestampEnd > topBoundary) { afterLoanId = getLoanPointer(storageAddress); uint256 nloans = getNumberOfLoans(storageAddress); if (nloans > 0) { for (uint i = 0; i < nloans - 1; i++) { afterLoanId = getNextLoan(storageAddress, afterLoanId); } } } else { uint256 loanId = getLoanPointer(storageAddress); uint256 startDate; uint256 endDate; while (loanId > 0) { startDate = getLoanStartDate(storageAddress, loanId); endDate = getLoanEndDate(storageAddress, loanId); if ((timestampStart >= startDate && timestampStart <= endDate) || (timestampEnd >= startDate && timestampEnd <= endDate) || (timestampStart <= startDate && timestampEnd >= startDate)) { beforeLoanId = 0; afterLoanId = 0; isCrossedPeriod = true; break; } if (timestampEnd < startDate) { beforeLoanId = loanId; break; } if (timestampStart > endDate) { afterLoanId = loanId; } loanId = getNextLoan(storageAddress, loanId); } } } } return (afterLoanId, beforeLoanId, isCrossedPeriod); } function addTokenToApprovedListForLoan(address payable storageAddress, uint256 tokenId) public { if (!isTokenInApprovedListForLoan(storageAddress, tokenId)) { uint256 position = getTotalNumberOfTokensInApprovedTokensForLoan(storageAddress); SnarkStorage(storageAddress) .setUint(keccak256(abi.encodePacked("ApprovedTokensForLoan", position)), tokenId); setIndexOfTokenInApprovedTokensForLoan(storageAddress, tokenId, position); SnarkStorage(storageAddress). setBool(keccak256(abi.encodePacked("isTokenInApprovedTokensForLoan", tokenId)), true); setTotalNumberOfTokensInApprovedTokensForLoan(storageAddress, position.add(1)); } } function deleteTokenFromApprovedListForLoan(address payable storageAddress, uint256 tokenId) public { if (isTokenInApprovedListForLoan(storageAddress, tokenId)) { uint256 position = getIndexOfTokenInApprovedTokensForLoan(storageAddress, tokenId); uint256 maxPosition = getTotalNumberOfTokensInApprovedTokensForLoan(storageAddress); maxPosition = maxPosition.sub(1); if (position < maxPosition) { uint256 maxTokenId = getTokenFromApprovedTokensForLoanByIndex(storageAddress, maxPosition); setIndexOfTokenInApprovedTokensForLoan(storageAddress, tokenId, 0); setIndexOfTokenInApprovedTokensForLoan(storageAddress, maxTokenId, position); SnarkStorage(storageAddress). setUint(keccak256(abi.encodePacked("ApprovedTokensForLoan", position)), maxTokenId); } SnarkStorage(storageAddress). setUint(keccak256(abi.encodePacked("ApprovedTokensForLoan", maxPosition)), 0); setTotalNumberOfTokensInApprovedTokensForLoan(storageAddress, maxPosition); SnarkStorage(storageAddress). setBool(keccak256(abi.encodePacked("isTokenInApprovedTokensForLoan", tokenId)), false); } } function getTotalNumberOfTokensInApprovedTokensForLoan(address payable storageAddress) public view returns (uint256) { return SnarkStorage(storageAddress).uintStorage(keccak256("totalNumberOfTokensInApprovedTokensForLoan")); } function setTotalNumberOfTokensInApprovedTokensForLoan(address payable storageAddress, uint256 newAmount) public { SnarkStorage(storageAddress). setUint(keccak256("totalNumberOfTokensInApprovedTokensForLoan"), newAmount); } function getIndexOfTokenInApprovedTokensForLoan(address payable storageAddress, uint256 tokenId) public view returns (uint256) { return SnarkStorage(storageAddress). uintStorage(keccak256(abi.encodePacked("IndexOfTokenInApprovedTokensForLoan", tokenId))); } function setIndexOfTokenInApprovedTokensForLoan( address payable storageAddress, uint256 tokenId, uint256 position ) public { SnarkStorage(storageAddress). setUint(keccak256(abi.encodePacked("IndexOfTokenInApprovedTokensForLoan", tokenId)), position); } function isTokenInApprovedListForLoan(address payable storageAddress, uint256 tokenId) public view returns (bool) { return SnarkStorage(storageAddress). boolStorage(keccak256(abi.encodePacked("isTokenInApprovedTokensForLoan", tokenId))); } function getTokenFromApprovedTokensForLoanByIndex(address payable storageAddress, uint256 position) public view returns (uint256) { return SnarkStorage(storageAddress). uintStorage(keccak256(abi.encodePacked("ApprovedTokensForLoan", position))); } // not approved list for owner function addTokenToNotApprovedListForLoan(address payable storageAddress, address tokenOwner, uint256 tokenId) public { if (!isTokenInNotApprovedListForLoan(storageAddress, tokenOwner, tokenId)) { uint256 position = getTotalNumberOfTokensInNotApprovedTokensForLoan(storageAddress, tokenOwner); SnarkStorage(storageAddress). setUint(keccak256(abi.encodePacked("NotApprovedTokensForLoan", tokenOwner, position)), tokenId); setIndexOfTokenInNotApprovedTokensForLoan(storageAddress, tokenOwner, tokenId, position); SnarkStorage(storageAddress). setBool(keccak256(abi.encodePacked("isTokenInNotApprovedTokensForLoan", tokenOwner, tokenId)), true); setTotalNumberOfTokensInNotApprovedTokensForLoan(storageAddress, tokenOwner, position.add(1)); } } function deleteTokenFromNotApprovedListForLoan( address payable storageAddress, address tokenOwner, uint256 tokenId ) public { if (isTokenInNotApprovedListForLoan(storageAddress, tokenOwner, tokenId)) { uint256 position = getIndexOfTokenInNotApprovedTokensForLoan(storageAddress, tokenOwner, tokenId); uint256 maxPosition = getTotalNumberOfTokensInNotApprovedTokensForLoan(storageAddress, tokenOwner); maxPosition = maxPosition.sub(1); if (position < maxPosition) { uint256 maxTokenId = getTokenFromNotApprovedTokensForLoanByIndex(storageAddress, tokenOwner, maxPosition); setIndexOfTokenInNotApprovedTokensForLoan(storageAddress, tokenOwner, tokenId, 0); setIndexOfTokenInNotApprovedTokensForLoan(storageAddress, tokenOwner, maxTokenId, position); SnarkStorage(storageAddress). setUint(keccak256(abi.encodePacked("NotApprovedTokensForLoan", tokenOwner, position)), maxTokenId); } SnarkStorage(storageAddress). setUint(keccak256(abi.encodePacked("NotApprovedTokensForLoan", maxPosition)), 0); setTotalNumberOfTokensInNotApprovedTokensForLoan(storageAddress, tokenOwner, maxPosition); SnarkStorage(storageAddress). setBool(keccak256(abi.encodePacked("isTokenInNotApprovedTokensForLoan", tokenId)), false); } } function getTotalNumberOfTokensInNotApprovedTokensForLoan(address payable storageAddress, address tokenOwner) public view returns (uint256) { return SnarkStorage(storageAddress) .uintStorage(keccak256(abi.encodePacked("totalNumberOfTokensInNotApprovedTokensForLoan", tokenOwner))); } function setTotalNumberOfTokensInNotApprovedTokensForLoan( address payable storageAddress, address tokenOwner, uint256 newAmount ) public { SnarkStorage(storageAddress). setUint(keccak256(abi.encodePacked("totalNumberOfTokensInNotApprovedTokensForLoan", tokenOwner)), newAmount ); } function getIndexOfTokenInNotApprovedTokensForLoan( address payable storageAddress, address tokenOwner, uint256 tokenId ) public view returns (uint256) { return SnarkStorage(storageAddress). uintStorage(keccak256(abi.encodePacked("IndexOfTokenInNotApprovedTokensForLoan", tokenOwner, tokenId))); } function setIndexOfTokenInNotApprovedTokensForLoan( address payable storageAddress, address tokenOwner, uint256 tokenId, uint256 position ) public { SnarkStorage(storageAddress). setUint(keccak256(abi.encodePacked("IndexOfTokenInNotApprovedTokensForLoan", tokenOwner, tokenId)), position ); } function isTokenInNotApprovedListForLoan(address payable storageAddress, address tokenOwner, uint256 tokenId) public view returns (bool) { return SnarkStorage(storageAddress). boolStorage(keccak256(abi.encodePacked("isTokenInNotApprovedTokensForLoan", tokenOwner, tokenId))); } function getTokenFromNotApprovedTokensForLoanByIndex( address payable storageAddress, address tokenOwner, uint256 position ) public view returns (uint256) { return SnarkStorage(storageAddress). uintStorage(keccak256(abi.encodePacked("NotApprovedTokensForLoan", tokenOwner, position))); } // array of owner loans function addLoanToOwnerList(address payable storageAddress, address loanOwner, uint256 loanId) public { if (!isLoanInOwnerList(storageAddress, loanOwner, loanId)) { uint256 position = getTotalNumberOfLoansInOwnerList(storageAddress, loanOwner); setLoanInOwnerListToIndex(storageAddress, loanOwner, position, loanId); setIndexOfLoanInOwnerList(storageAddress, loanOwner, loanId, position); setLoanInOwnerList(storageAddress, loanOwner, loanId, true); setTotalNumberOfLoansInOwnerList(storageAddress, loanOwner, position.add(1)); } } function deleteLoanFromOwnerList(address payable storageAddress, address loanOwner, uint256 loanId) public { if (isLoanInOwnerList(storageAddress, loanOwner, loanId)) { uint256 position = getIndexOfLoanInOwnerList(storageAddress, loanOwner, loanId); uint256 maxPosition = getTotalNumberOfLoansInOwnerList(storageAddress, loanOwner); maxPosition = maxPosition.sub(1); if (position < maxPosition) { uint256 maxLoanId = getLoanFromOwnerListByIndex(storageAddress, loanOwner, maxPosition); setIndexOfLoanInOwnerList(storageAddress, loanOwner, maxLoanId, position); setLoanInOwnerListToIndex(storageAddress, loanOwner, position, maxLoanId); } setIndexOfLoanInOwnerList(storageAddress, loanOwner, loanId, 0); setTotalNumberOfLoansInOwnerList(storageAddress, loanOwner, maxPosition); setLoanInOwnerList(storageAddress, loanOwner, loanId, false); } } function getTotalNumberOfLoansInOwnerList(address payable storageAddress, address loanOwner) public view returns (uint256) { return SnarkStorage(storageAddress). uintStorage(keccak256(abi.encodePacked("totalNumberOfLoansInOwnerList", loanOwner))); } function setTotalNumberOfLoansInOwnerList( address payable storageAddress, address loanOwner, uint256 newAmount ) public { SnarkStorage(storageAddress). setUint(keccak256(abi.encodePacked("totalNumberOfLoansInOwnerList", loanOwner)), newAmount); } function getIndexOfLoanInOwnerList(address payable storageAddress, address loanOwner, uint256 loanId) public view returns (uint256) { return SnarkStorage(storageAddress). uintStorage(keccak256(abi.encodePacked("IndexOfLoanInOwnerList", loanOwner, loanId))); } function setIndexOfLoanInOwnerList( address payable storageAddress, address loanOwner, uint256 loanId, uint256 position ) public { SnarkStorage(storageAddress). setUint(keccak256(abi.encodePacked("IndexOfLoanInOwnerList", loanOwner, loanId)), position); } function isLoanInOwnerList(address payable storageAddress, address loanOwner, uint256 loanId) public view returns (bool) { return SnarkStorage(storageAddress). boolStorage(keccak256(abi.encodePacked("isLoanInOwnerList", loanOwner, loanId))); } function setLoanInOwnerList(address payable storageAddress, address loanOwner, uint256 loanId, bool isInList) public { SnarkStorage(storageAddress). setBool(keccak256(abi.encodePacked("isLoanInOwnerList", loanOwner, loanId)), isInList); } function getLoanFromOwnerListByIndex(address payable storageAddress, address loanOwner, uint256 position) public view returns (uint256) { return SnarkStorage(storageAddress) .uintStorage(keccak256(abi.encodePacked("OwnerLoansList", loanOwner, position))); } function setLoanInOwnerListToIndex( address payable storageAddress, address loanOwner, uint256 position, uint256 loanId ) public { SnarkStorage(storageAddress) .setUint(keccak256(abi.encodePacked("OwnerLoansList", loanOwner, position)), loanId); } function markLoanAsDeleted(address payable storageAddress, uint256 loanId) public { SnarkStorage(storageAddress) .setBool(keccak256(abi.encodePacked("isLoanDeleted", loanId)), true); } function isLoanDeleted(address payable storageAddress, uint256 loanId) public view returns (bool) { return SnarkStorage(storageAddress) .boolStorage(keccak256(abi.encodePacked("isLoanDeleted", loanId))); } }

50,935

37

// update balance

updateAssetBalance(currentIndex);

57,224

4

// Liquidate a position partially/vaultId The id of the vault/vaultPositionId The id of the vaultPosition/manager The manager of the vaultPosition/liquidator The caller of the function/percent The percentage of the vault user want to liquidate/amount0Left The amount of token0 transferred to the position's manager after close/amount1Left The amount of token1 transferred to the position's manager after close/liquidateFee0 The amount of token0 for liquidation bonus/liquidateFee1 The amount of token1 for liquidation bonus

event LiquidateVaultPositionPartially( uint256 indexed vaultId, uint256 indexed vaultPositionId, address indexed manager, address liquidator, uint16 percent, uint64 timestamp, uint256 price, uint256 debtValueOfPosition, uint256 liquidityValueOfPosition,

10,118

71

// on buys only

if(zeroBuyTaxmode){ if(tradingOpen && from == uniswapV2Pair) { currenttotalFee=0; }

38,187

91

// Appends a byte string to a buffer. Resizes if doing so would exceedthe capacity of the buffer.buf The buffer to append to.data The data to append.len The number of bytes to copy. return The original buffer, for chaining./

function append(buffer memory buf, bytes memory data, uint len) internal pure returns (buffer memory) { return write(buf, buf.buf.length, data, len); }

4,994

26

// "_selectorSlot >> 3" is a gas efficient division by 8 "_selectorSlot / 8"

ds.selectorSlots[_selectorCount >> 3] = _selectorSlot; _selectorSlot = 0;

17,673

154

// Cancels an copyright unconditionally.

function _cancelCopyright(uint256 _tokenId, address _owner) internal { _removeCopyright(_tokenId); _transfer(_owner, _tokenId); emit CopyrightCancelled(_tokenId); }

33,840

57

// Vest the tokens into the deposit account and delegate to the beneficiary

require( token.transferFrom(msg.sender, address(this), _amount), "VestingContract::createVestingSchedule: Unable to escrow tokens" ); emit ScheduleCreated(_beneficiary); return true;

25,254

12

// --- ERC-20 variables / https:github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.mdname function name() constant returns (string name)

string public name = "ACCP";

76,117

39

// start sale after initial mint!

function startSale() external onlyOwner { _saleStarted = true; }

16,718

3

// Mint is fired when a new token is minted /

event Mint(address owner, uint256 tokenId);

31,624

84

// Modifier for accessibility to define new hero types.

modifier onlyAccessMint { require(msg.sender == owner || mintAccess[msg.sender] == true); _; }

11,932

158

// amount to send to treasury. Used for future governance voting power

uint256 public percentKeep; uint256 public constant _denominator = 10000;

20,100

1

// Pay for a preimage

function commitTo(bytes32 hash) public payable { amount[hash] = msg.value; }

21,366

6

// To prepare the arbitrage, BNB is converted to BUSD using PancakeSwap swap contract.

router.convertBnbToBusd(msg.sender, flashLoanAmount / 2);

14,547

6

// Set the end index to be the last token index

if (stop > stopLimit) { stop = stopLimit; }

47,392

29

// Current supply of tokens

uint256 supply = 0;

15,013

37

// //Ethereum Address Register Contract/This contract maintains a name service for addresses and miner./Kongliang Zhong - <<a href="/cdn-cgi/l/email-protection" class="__cf_email__" data-cfemail="b2d9dddcd5dedbd3dcd5f2deddddc2c0dbdcd59cddc0d5">[email&160;protected]</a>>,/Daniel Wang - <<a href="/cdn-cgi/l/email-protection" class="__cf_email__" data-cfemail="6400050a0d010824080b0b14160d0a034a0b1603">[email&160;protected]</a>>,

contract NameRegistry { uint public nextId = 0; mapping (uint => Participant) public participantMap; mapping (address => NameInfo) public nameInfoMap; mapping (bytes12 => address) public ownerMap; mapping (address => string) public nameMap; struct NameInfo { bytes12 name; uint[] participantIds; } struct Participant { address feeRecipient; address signer; bytes12 name; address owner; } event NameRegistered ( string name, address indexed owner ); event NameUnregistered ( string name, address indexed owner ); event OwnershipTransfered ( bytes12 name, address oldOwner, address newOwner ); event ParticipantRegistered ( bytes12 name, address indexed owner, uint indexed participantId, address singer, address feeRecipient ); event ParticipantUnregistered ( uint participantId, address owner ); function registerName(string name) external { require(isNameValid(name)); bytes12 nameBytes = stringToBytes12(name); require(ownerMap[nameBytes] == 0x0); require(stringToBytes12(nameMap[msg.sender]) == bytes12(0x0)); nameInfoMap[msg.sender] = NameInfo(nameBytes, new uint[](0)); ownerMap[nameBytes] = msg.sender; nameMap[msg.sender] = name; NameRegistered(name, msg.sender); } function unregisterName(string name) external { NameInfo storage nameInfo = nameInfoMap[msg.sender]; uint[] storage participantIds = nameInfo.participantIds; bytes12 nameBytes = stringToBytes12(name); require(nameInfo.name == nameBytes); for (uint i = participantIds.length - 1; i >= 0; i--) { delete participantMap[participantIds[i]]; } delete nameInfoMap[msg.sender]; delete nameMap[msg.sender]; delete ownerMap[nameBytes]; NameUnregistered(name, msg.sender); } function transferOwnership(address newOwner) external { require(newOwner != 0x0); require(nameInfoMap[newOwner].name.length == 0); NameInfo storage nameInfo = nameInfoMap[msg.sender]; string storage name = nameMap[msg.sender]; uint[] memory participantIds = nameInfo.participantIds; for (uint i = 0; i < participantIds.length; i ++) { Participant storage p = participantMap[participantIds[i]]; p.owner = newOwner; } delete nameInfoMap[msg.sender]; delete nameMap[msg.sender]; nameInfoMap[newOwner] = nameInfo; nameMap[newOwner] = name; OwnershipTransfered(nameInfo.name, msg.sender, newOwner); } /* function addParticipant(address feeRecipient) */ /* external */ /* returns (uint) */ /* { */ /* return addParticipant(feeRecipient, feeRecipient); */ /* } */ function addParticipant( address feeRecipient, address singer ) external returns (uint) { require(feeRecipient != 0x0 && singer != 0x0); NameInfo storage nameInfo = nameInfoMap[msg.sender]; bytes12 name = nameInfo.name; require(name.length > 0); Participant memory participant = Participant( feeRecipient, singer, name, msg.sender ); uint participantId = ++nextId; participantMap[participantId] = participant; nameInfo.participantIds.push(participantId); ParticipantRegistered( name, msg.sender, participantId, singer, feeRecipient ); return participantId; } function removeParticipant(uint participantId) external { require(msg.sender == participantMap[participantId].owner); NameInfo storage nameInfo = nameInfoMap[msg.sender]; uint[] storage participantIds = nameInfo.participantIds; delete participantMap[participantId]; uint len = participantIds.length; for (uint i = 0; i < len; i ++) { if (participantId == participantIds[i]) { participantIds[i] = participantIds[len - 1]; participantIds.length -= 1; } } ParticipantUnregistered(participantId, msg.sender); } function getParticipantById(uint id) external view returns (address feeRecipient, address signer) { Participant storage addressSet = participantMap[id]; feeRecipient = addressSet.feeRecipient; signer = addressSet.signer; } function getParticipantIds(string name, uint start, uint count) external view returns (uint[] idList) { bytes12 nameBytes = stringToBytes12(name); address owner = ownerMap[nameBytes]; require(owner != 0x0); NameInfo storage nameInfo = nameInfoMap[owner]; uint[] storage pIds = nameInfo.participantIds; uint len = pIds.length; if (start >= len) { return; } uint end = start + count; if (end > len) { end = len; } if (start == end) { return; } idList = new uint[](end - start); for (uint i = start; i < end; i ++) { idList[i - start] = pIds[i]; } } function getOwner(string name) external view returns (address) { bytes12 nameBytes = stringToBytes12(name); return ownerMap[nameBytes]; } function isNameValid(string name) internal pure returns (bool) { bytes memory temp = bytes(name); return temp.length >= 6 && temp.length <= 12; } function stringToBytes12(string str) internal pure returns (bytes12 result) { assembly { result := mload(add(str, 12)) } } }

44,857

16

// Emitted when owner removes a token from the reward tokens list

event RewardTokenRemoved(address token);

19,956

19

// Burn it

bancorVortex.burn(burnTokens);

6,316

329

// 0 is not a valid vote.

require(_vote <= NUM_OF_CHOICES && _vote > 0, "wrong vote value"); require(_amount > 0, "staking amount should be >0"); if (_execute(_proposalId)) { return true; }

7,728

19

// Revert with the same message.

revert(0, returndatasize())

24,959

20

// validates an address - currently only checks that it isn't null

modifier validAddress(address _address) { require(_address != address(0)); _; }

4,680

16

// A simple method to calculate prices from deposits orwithdrawals, excluding fees but including slippage. This ishelpful as an input into the various "min" parameters on callsto fight front-runningThis shouldn't be used outside frontends for user estimates.key Hash of the canonical id + domain amounts an array of token amounts to deposit or withdrawal,corresponding to pooledTokens. The amount should be in eachpooled token's native precision. If a token charges a fee on transfers,use the amount that gets transferred after the fee. deposit whether this is a deposit or a withdrawalreturn token amount the user will receive /

function calculateSwapTokenAmount( bytes32 key, uint256[] calldata amounts, bool deposit

24,098

5

// ========== GOV ONLY ========== /

function setAuthority(IPanaAuthority _newAuthority) external onlyGovernor { authority = _newAuthority; emit AuthorityUpdated(_newAuthority); }

21,985

29

// ico1

uint public ico1StartTime = 1547398800; // Wednesday, 30 January 2019 00:00:00 GMT+07:00 uint256 public ico1PerEth = 1366000000000000000000;

73,692

201

// require(_mappingMintCount[msg.sender] <= PUBLIC_MINT_LIMIT + PRESALE_MINT_LIMIT,"Overflow for PUBLIC_MINT_LIMIT + PRESALE_MINT_LIMIT");

}

24,092

281

// clamp amount of tokens in case resulted shares requires less tokens than anticipated

_amount = rate.mul(shares).div(precision); stakeManager.updateValidatorState(validatorId, int256(_amount)); activeAmount = activeAmount.add(_amount); StakingInfo logger = stakingLogger; logger.logShareMinted(validatorId, user, _amount, shares); logger.logStakeUpdate(validatorId); return _amount;

42,226

49

// Swap DAI to SUSD

CurveSUSDSwap.exchange(0,3,getTokenBalance(DAI),0);

36,868

21

// Min possible ballot duration in blocks.

uint256 public constant MIN_DURATION = 17280; // 1 day if 5-second blocks

54,745

19

// ---------------------------------------------------------------------------- Bonus List - on list or not ----------------------------------------------------------------------------

contract BonusList is BonusListInterface, Operated { mapping(address => bool) public bonusList; event AccountListed(address indexed account, bool status); constructor() public { initOperated(msg.sender); } function isInBonusList(address account) public view returns (bool) { return bonusList[account]; } function add(address[] accounts) public onlyOperator { require(accounts.length != 0); for (uint i = 0; i < accounts.length; i++) { require(accounts[i] != address(0)); if (!bonusList[accounts[i]]) { bonusList[accounts[i]] = true; emit AccountListed(accounts[i], true); } } } function remove(address[] accounts) public onlyOperator { require(accounts.length != 0); for (uint i = 0; i < accounts.length; i++) { require(accounts[i] != address(0)); if (bonusList[accounts[i]]) { delete bonusList[accounts[i]]; emit AccountListed(accounts[i], false); } } } }

18,056

8

// uint8 v=uint8(v1);

addr=ecrecover(_hash, v, r, s);

10,124

12

// The percentage of profit recognized each harvest to reserve as fees./A fixed point number where 1e18 represents 100% and 0 represents 0%.

uint256 public feePercent;

6,119

108

// Withdraws the beneficiary's funds. /

function beneficiaryWithdraw() public { require(_state == State.Closed); _beneficiary.transfer(address(this).balance); }

5,542

78

// Emitted when ETH is withdrawn and FEM is burned. /

event Withdraw(address indexed account, uint256 amount);

59,366

33

// clothing

rarities[8] = [255]; aliases[8] = [0];

11,823

35

// We follow the equations described in https:pdfs.semanticscholar.org/5c64/29952e08025a9649c2b0ba32518e9a7fb5c2.pdf Section 5

uint[4] memory zs; // z1^2, z1^3, z2^2, z2^3 zs[0] = mulmod(_z1, _z1, _pp); zs[1] = mulmod(_z1, zs[0], _pp); zs[2] = mulmod(_z2, _z2, _pp); zs[3] = mulmod(_z2, zs[2], _pp);

27,891

161

// Transfer tokens from one address to anotherfrom address The address which you want to send tokens fromto address The address which you want to transfer tovalue uint256 the amount of tokens to be transferred/

function transferFrom( address from, address to, uint256 value ) public canTransfer(to) returns (bool)

34,617

111

// SPDX-License-Identifier: Unlicense

// import {RLPReader} from "../../extLib/FxPortal/lib/RLPReader.sol"; interface IFxStateSender { function sendMessageToChild(address _receiver, bytes calldata _data) external; }

31,852

8

// onlyOwner函数修改器：判断合约使用者是不是合约拥有者，是合约拥有者才能执行 /

modifier onlyOwner() { require(msg.sender == owner_); _; }

39,119

398

// staker liquidity asset/This function calculates liquidity asset/ return liquidity asset

function stakerAssets() public view returns (uint256){ uint256 total; address ioTokenAddr=address(ioToken); uint256 length = stakers.length(); for (uint256 i = 0; i < length; i++) { uint256 tokenId = stakers.at(i); total = total.add(caclLiquidityAssets(tokenId,ioTokenAddr)); } return total; }

1,991

9

// Mapping of interface ids to whether or not it's supported./

mapping(bytes4 => bool) private _supportedInterfaces; constructor () internal {

50,071

27

// Upgrade the address of the logic contract for this proxy Recreation of AdminUpgradeabilityProxy._upgradeTo. Adds a check to ensure msg.sender is the Audius Proxy Admin _newImplementation - new address of logic contract that the proxy will point to /

function upgradeTo(address _newImplementation) external { require(msg.sender == proxyAdmin, ERROR_ONLY_ADMIN); _upgradeTo(_newImplementation); }

1,527

298

// Register ID if not already done

if (addressId == 0) { nTokens += 1; // Increment number of tokens registered id = nTokens; // id of token is the current # of tokens IDtoAddress[id] = _token; // Map id to token address addressToID[_token] = id; // Register token

9,751

257

// ERC721 Non-Fungible Token Standard basic implementationThis is the same contract at `openzeppelin/contracts 3.1.0` but `tokenURI` was changed to virtual override /

contract ERC721Initializable is ContextMixin, ERC165, IERC721, IERC721Metadata, IERC721Enumerable { using SafeMath for uint256; using Address for address; using EnumerableSet for EnumerableSet.UintSet; using EnumerableMap for EnumerableMap.UintToAddressMap; using Strings for uint256; // Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))` // which can be also obtained as `IERC721Receiver(0).onERC721Received.selector` bytes4 private constant _ERC721_RECEIVED = 0x150b7a02; // Mapping from holder address to their (enumerable) set of owned tokens mapping (address => EnumerableSet.UintSet) private _holderTokens; // Enumerable mapping from token ids to their owners EnumerableMap.UintToAddressMap private _tokenOwners; // Mapping from token ID to approved address mapping (uint256 => address) private _tokenApprovals; // Mapping from owner to operator approvals mapping (address => mapping (address => bool)) private _operatorApprovals; // Token name string private _name; // Token symbol string private _symbol; // Optional mapping for token URIs mapping(uint256 => string) private _tokenURIs; // Base URI string private _baseURI; /* * bytes4(keccak256('balanceOf(address)')) == 0x70a08231 * bytes4(keccak256('ownerOf(uint256)')) == 0x6352211e * bytes4(keccak256('approve(address,uint256)')) == 0x095ea7b3 * bytes4(keccak256('getApproved(uint256)')) == 0x081812fc * bytes4(keccak256('setApprovalForAll(address,bool)')) == 0xa22cb465 * bytes4(keccak256('isApprovedForAll(address,address)')) == 0xe985e9c5 * bytes4(keccak256('transferFrom(address,address,uint256)')) == 0x23b872dd * bytes4(keccak256('safeTransferFrom(address,address,uint256)')) == 0x42842e0e * bytes4(keccak256('safeTransferFrom(address,address,uint256,bytes)')) == 0xb88d4fde * * => 0x70a08231 ^ 0x6352211e ^ 0x095ea7b3 ^ 0x081812fc ^ * 0xa22cb465 ^ 0xe985e9c ^ 0x23b872dd ^ 0x42842e0e ^ 0xb88d4fde == 0x80ac58cd */ bytes4 private constant _INTERFACE_ID_ERC721 = 0x80ac58cd; /* * bytes4(keccak256('name()')) == 0x06fdde03 * bytes4(keccak256('symbol()')) == 0x95d89b41 * bytes4(keccak256('tokenURI(uint256)')) == 0xc87b56dd * * => 0x06fdde03 ^ 0x95d89b41 ^ 0xc87b56dd == 0x5b5e139f */ bytes4 private constant _INTERFACE_ID_ERC721_METADATA = 0x5b5e139f; /* * bytes4(keccak256('totalSupply()')) == 0x18160ddd * bytes4(keccak256('tokenOfOwnerByIndex(address,uint256)')) == 0x2f745c59 * bytes4(keccak256('tokenByIndex(uint256)')) == 0x4f6ccce7 * * => 0x18160ddd ^ 0x2f745c59 ^ 0x4f6ccce7 == 0x780e9d63 */ bytes4 private constant _INTERFACE_ID_ERC721_ENUMERABLE = 0x780e9d63; constructor() internal {} /** * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection. */ function _initERC721(string memory name, string memory symbol) internal { _name = name; _symbol = symbol; // register the supported interfaces to conform to ERC721 via ERC165 _registerInterface(_INTERFACE_ID_ERC721); _registerInterface(_INTERFACE_ID_ERC721_METADATA); _registerInterface(_INTERFACE_ID_ERC721_ENUMERABLE); } /** * @dev See {IERC721-balanceOf}. */ function balanceOf(address owner) public view override returns (uint256) { require(owner != address(0), "ERC721: balance query for the zero address"); return _holderTokens[owner].length(); } /** * @dev See {IERC721-ownerOf}. */ function ownerOf(uint256 tokenId) public view override returns (address) { return _tokenOwners.get(tokenId, "ERC721: owner query for nonexistent token"); } /** * @dev See {IERC721Metadata-name}. */ function name() public view override returns (string memory) { return _name; } /** * @dev See {IERC721Metadata-symbol}. */ function symbol() public view override returns (string memory) { return _symbol; } /** * @dev See {IERC721Metadata-tokenURI}. */ function tokenURI(uint256 tokenId) public view virtual override returns (string memory) { require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token"); string memory _tokenURI = _tokenURIs[tokenId]; // If there is no base URI, return the token URI. if (bytes(_baseURI).length == 0) { return _tokenURI; } // If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked). if (bytes(_tokenURI).length > 0) { return string(abi.encodePacked(_baseURI, _tokenURI)); } // If there is a baseURI but no tokenURI, concatenate the tokenID to the baseURI. return string(abi.encodePacked(_baseURI, tokenId.toString())); } /** * @dev Returns the base URI set via {_setBaseURI}. This will be * automatically added as a prefix in {tokenURI} to each token's URI, or * to the token ID if no specific URI is set for that token ID. */ function baseURI() public view returns (string memory) { return _baseURI; } /** * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}. */ function tokenOfOwnerByIndex(address owner, uint256 index) public view override returns (uint256) { return _holderTokens[owner].at(index); } /** * @dev See {IERC721Enumerable-totalSupply}. */ function totalSupply() public view override returns (uint256) { // _tokenOwners are indexed by tokenIds, so .length() returns the number of tokenIds return _tokenOwners.length(); } /** * @dev See {IERC721Enumerable-tokenByIndex}. */ function tokenByIndex(uint256 index) public view override returns (uint256) { (uint256 tokenId, ) = _tokenOwners.at(index); return tokenId; } /** * @dev See {IERC721-approve}. */ function approve(address to, uint256 tokenId) public virtual override { address owner = ownerOf(tokenId); require(to != owner, "ERC721: approval to current owner"); require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()), "ERC721: approve caller is not owner nor approved for all" ); _approve(to, tokenId); } /** * @dev See {IERC721-getApproved}. */ function getApproved(uint256 tokenId) public view override returns (address) { require(_exists(tokenId), "ERC721: approved query for nonexistent token"); return _tokenApprovals[tokenId]; } /** * @dev See {IERC721-setApprovalForAll}. */ function setApprovalForAll(address operator, bool approved) public virtual override { require(operator != _msgSender(), "ERC721: approve to caller"); _operatorApprovals[_msgSender()][operator] = approved; emit ApprovalForAll(_msgSender(), operator, approved); } /** * @dev See {IERC721-isApprovedForAll}. */ function isApprovedForAll(address owner, address operator) public view override returns (bool) { return _operatorApprovals[owner][operator]; } /** * @dev See {IERC721-transferFrom}. */ function transferFrom(address from, address to, uint256 tokenId) public virtual override { //solhint-disable-next-line max-line-length require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved"); _transfer(from, to, tokenId); } /** * @dev See {IERC721-safeTransferFrom}. */ function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override { safeTransferFrom(from, to, tokenId, ""); } /** * @dev See {IERC721-safeTransferFrom}. */ function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override { require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved"); _safeTransfer(from, to, tokenId, _data); } /** * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients * are aware of the ERC721 protocol to prevent tokens from being forever locked. * * `_data` is additional data, it has no specified format and it is sent in call to `to`. * * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g. * implement alternative mecanisms to perform token transfer, such as signature-based. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual { _transfer(from, to, tokenId); require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer"); } /** * @dev Returns whether `tokenId` exists. * * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}. * * Tokens start existing when they are minted (`_mint`), * and stop existing when they are burned (`_burn`). */ function _exists(uint256 tokenId) internal view returns (bool) { return _tokenOwners.contains(tokenId); } /** * @dev Returns whether `spender` is allowed to manage `tokenId`. * * Requirements: * * - `tokenId` must exist. */ function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) { require(_exists(tokenId), "ERC721: operator query for nonexistent token"); address owner = ownerOf(tokenId); return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender)); } /** * @dev Safely mints `tokenId` and transfers it to `to`. * * Requirements: d* * - `tokenId` must not exist. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function _safeMint(address to, uint256 tokenId) internal virtual { _safeMint(to, tokenId, ""); } /** * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is * forwarded in {IERC721Receiver-onERC721Received} to contract recipients. */ function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual { _mint(to, tokenId); require(_checkOnERC721Received(address(0), to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer"); } /** * @dev Mints `tokenId` and transfers it to `to`. * * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible * * Requirements: * * - `tokenId` must not exist. * - `to` cannot be the zero address. * * Emits a {Transfer} event. */ function _mint(address to, uint256 tokenId) internal virtual { require(to != address(0), "ERC721: mint to the zero address"); require(!_exists(tokenId), "ERC721: token already minted"); _beforeTokenTransfer(address(0), to, tokenId); _holderTokens[to].add(tokenId); _tokenOwners.set(tokenId, to); emit Transfer(address(0), to, tokenId); } /** * @dev Destroys `tokenId`. * The approval is cleared when the token is burned. * * Requirements: * * - `tokenId` must exist. * * Emits a {Transfer} event. */ function _burn(uint256 tokenId) internal virtual { address owner = ownerOf(tokenId); _beforeTokenTransfer(owner, address(0), tokenId); // Clear approvals _approve(address(0), tokenId); // Clear metadata (if any) if (bytes(_tokenURIs[tokenId]).length != 0) { delete _tokenURIs[tokenId]; } _holderTokens[owner].remove(tokenId); _tokenOwners.remove(tokenId); emit Transfer(owner, address(0), tokenId); } /** * @dev Transfers `tokenId` from `from` to `to`. * As opposed to {transferFrom}, this imposes no restrictions on msg.sender. * * Requirements: * * - `to` cannot be the zero address. * - `tokenId` token must be owned by `from`. * * Emits a {Transfer} event. */ function _transfer(address from, address to, uint256 tokenId) internal virtual { require(ownerOf(tokenId) == from, "ERC721: transfer of token that is not own"); require(to != address(0), "ERC721: transfer to the zero address"); _beforeTokenTransfer(from, to, tokenId); // Clear approvals from the previous owner _approve(address(0), tokenId); _holderTokens[from].remove(tokenId); _holderTokens[to].add(tokenId); _tokenOwners.set(tokenId, to); emit Transfer(from, to, tokenId); } /** * @dev Sets `_tokenURI` as the tokenURI of `tokenId`. * * Requirements: * * - `tokenId` must exist. */ function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal virtual { require(_exists(tokenId), "ERC721Metadata: URI set of nonexistent token"); _tokenURIs[tokenId] = _tokenURI; } /** * @dev Internal function to set the base URI for all token IDs. It is * automatically added as a prefix to the value returned in {tokenURI}, * or to the token ID if {tokenURI} is empty. */ function _setBaseURI(string memory baseURI_) internal virtual { _baseURI = baseURI_; } /** * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address. * The call is not executed if the target address is not a contract. * * @param from address representing the previous owner of the given token ID * @param to target address that will receive the tokens * @param tokenId uint256 ID of the token to be transferred * @param _data bytes optional data to send along with the call * @return bool whether the call correctly returned the expected magic value */ function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data) private returns (bool) { if (!to.isContract()) { return true; } bytes memory returndata = to.functionCall(abi.encodeWithSelector( IERC721Receiver(to).onERC721Received.selector, _msgSender(), from, tokenId, _data ), "ERC721: transfer to non ERC721Receiver implementer"); bytes4 retval = abi.decode(returndata, (bytes4)); return (retval == _ERC721_RECEIVED); } function _approve(address to, uint256 tokenId) private { _tokenApprovals[tokenId] = to; emit Approval(ownerOf(tokenId), to, tokenId); } /** * @dev Hook that is called before any token transfer. This includes minting * and burning. * * Calling conditions: * * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be * transferred to `to`. * - When `from` is zero, `tokenId` will be minted for `to`. * - When `to` is zero, ``from``'s `tokenId` will be burned. * - `from` cannot be the zero address. * - `to` cannot be the zero address. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { } }

27,005

64

// require(msg.sender != _admin(), "Cannot call fallback function from the proxy admin");

super._willFallback();

16,397

9

// for debug

function setReleaseTime(uint256 _releaseTime) public { releaseTime = _releaseTime; }

20,955

103

// check if 1 day passed after last paymentrequire(now.sub(getMemInvestor(msg.sender).paymentTime) > 24 hours);

uint dividends = calcDividends(msg.sender); require (dividends.notZero(), "cannot to pay zero dividends");

29,466

96

// Adding to a set is an idempotent operation.

if (!contains(set, element)) { set.indices[element] = set.elements.length; set.elements.push(element); }

30,085

66

// Remove all Ether from the contract, which is the owner's cuts/as well as any Ether sent directly to the contract address./Always transfers to the NFT contract, but can be called either by/the owner or the NFT contract.

function withdrawBalance() external { address nftAddress = address(nonFungibleContract); require( msg.sender == owner || msg.sender == nftAddress ); // We are using this boolean method to make sure that even if one fails it will still work nftAddress.transfer(this.balance); }

40,928

284

// See {IERC1155MetadataURI-uri}. Revert for unminted SFT NFTs. /

function uri(uint256 tokenId) public view override returns (string memory) {

55,992

34

// par is a ray, pip returns a wad

tag[ilk] = wdiv(spot.par(), uint256(pip.read())); emit Cage(ilk);

70,097

53

// Creates a token/Constructor/_name Name of the token/_symbol Acronim of the token/_decimals Number of decimals of the token/_transferableDate Timestamp from when the token can de transfered

constructor( string memory _name, string memory _symbol, uint _decimals, uint _transferableDate

12,103

8

// Gift a single token

function gift(address to) external override payable onlyOwner { require(totalSupply() < BERRIES_MAX, 'All tokens have been minted'); require(_specialStrawberries.current() < BERRIES_GIFT, 'No tokens left to gift'); uint256 tokenId = BERRIES_SPECIAL + _specialStrawberries.current(); _specialStrawberries.increment(); _safeMint(to, tokenId); }

73,490

126

// //Stake SUSHI `amount` into crSUSHI and BENTO for benefit of `to` by batching calls to `crSushiToken` and `bento`.

function sushiToCreamToBento(address to, uint256 amount) external returns (uint256 amountOut, uint256 shareOut) { sushiToken.safeTransferFrom(msg.sender, address(this), amount); // deposit `msg.sender` SUSHI `amount` into this contract ICompoundBridge(crSushiToken).mint(amount); // stake deposited SUSHI into crSUSHI (amountOut, shareOut) = bento.deposit(IERC20(crSushiToken), address(this), to, balanceOfOptimized(crSushiToken), 0); // stake resulting crSUSHI into BENTO for `to` }

14,768

23

// First 90 days 50% yearly Next 90 days 40% Next 90 days 30% Next 90 days 20% Next 2190 days 10%

3,775

9

// Returns the number of retired EAVs in the tokenId/

function getRetiredEAVs(uint256 tokenId) public view returns (uint256) { return eavTokens[tokenId].retiredEAVs; }

30,275

26

// Send event on all tickets sold.

if (lotteries[lottId].ticketsSold.length == lotteries[lottId].numTickets) { onLotteryCompleted(lottId); }

47,410

58

// a token has been transferred to this contract mark which local token is to now own it

* Emits a {ReceivedChild} event. * * @param _from the address who sent the token to this contract * @param _tokenId the local token ID that is to be the parent * @param _childContract the address of the child token's contract * @param _childTokenId the ID value of teh incoming child token */ function _receiveChild(address _from, uint256 _tokenId, address _childContract, uint256 _childTokenId) private { require(!paused(), "Child received while paused"); require(super._exists(_tokenId), "That MoonCat is not wrapped in this contract"); require(childTokens[_tokenId][_childContract].contains(_childTokenId) == false, "Cannot receive child token because it has already been received"); childContracts[_tokenId].add(_childContract); childTokens[_tokenId][_childContract].add(_childTokenId); childTokenOwner[_childContract][_childTokenId] = _tokenId + TOKEN_OWNER_OFFSET; emit ReceivedChild(_from, _tokenId, _childContract, _childTokenId); }

35,848

365

// Changes number of days for which NXM needs to staked in case of underwriting /

function _changeSCValidDays(uint _days) internal { scValidDays = _days; }

1,953

23

// import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import { MerkleProof } from "@openzeppelin/contracts/cryptography/MerkleProof.sol"; import { IMerkleDistributor } from "contracts/interfaces/IMerkleDistributor.sol";

address public immutable override token; bytes32 public immutable override merkleRoot;

11,680

29

// Equipments owner by the owner (array)

mapping (address => uint256[]) ownerToFashionArray;

31,306

168

// Calculate and mint the amount of xABR the ABR is worth. The ratio will change overtime,as xABR is burned/minted and ABR deposited + gained from fees / withdrawn.

else { uint256 what = _amount * totalShares / totalABR; _mint(msg.sender, what); }

17,454

96

// A crowdsaled token. An ERC-20 token designed specifically for crowdsales with investor protection and further development path. - The token transfer() is disabled until the crowdsale is over- The token contract gives an opt-in upgrade path to a new contract- The same token can be part of several crowdsales through approve() mechanism- The token can be capped (supply set in the constructor) or uncapped (crowdsale contract can mint new tokens)/

contract CrowdsaleTokenExt is ReleasableToken, MintableTokenExt, UpgradeableToken { /** Name and symbol were updated. */ event UpdatedTokenInformation(string newName, string newSymbol); event ClaimedTokens(address indexed _token, address indexed _controller, uint _amount); string public name; string public symbol; uint public decimals; /* Minimum ammount of tokens every buyer can buy. */ uint public minCap; /** * Construct the token. * * This token must be created through a team multisig wallet, so that it is owned by that wallet. * * @param _name Token name * @param _symbol Token symbol - should be all caps * @param _initialSupply How many tokens we start with * @param _decimals Number of decimal places * @param _mintable Are new tokens created over the crowdsale or do we distribute only the initial supply? Note that when the token becomes transferable the minting always ends. */ function CrowdsaleTokenExt(string _name, string _symbol, uint _initialSupply, uint _decimals, bool _mintable, uint _globalMinCap) UpgradeableToken(msg.sender) { // Create any address, can be transferred // to team multisig via changeOwner(), // also remember to call setUpgradeMaster() owner = msg.sender; name = _name; symbol = _symbol; totalSupply = _initialSupply; decimals = _decimals; minCap = _globalMinCap; // Create initially all balance on the team multisig balances[owner] = totalSupply; if(totalSupply > 0) { Minted(owner, totalSupply); } // No more new supply allowed after the token creation if(!_mintable) { mintingFinished = true; if(totalSupply == 0) { throw; // Cannot create a token without supply and no minting } } } /** * When token is released to be transferable, enforce no new tokens can be created. */ function releaseTokenTransfer() public onlyReleaseAgent { mintingFinished = true; super.releaseTokenTransfer(); } /** * Allow upgrade agent functionality kick in only if the crowdsale was success. */ function canUpgrade() public constant returns(bool) { return released && super.canUpgrade(); } /** * Owner can update token information here. * * It is often useful to conceal the actual token association, until * the token operations, like central issuance or reissuance have been completed. * * This function allows the token owner to rename the token after the operations * have been completed and then point the audience to use the token contract. */ function setTokenInformation(string _name, string _symbol) onlyOwner { name = _name; symbol = _symbol; UpdatedTokenInformation(name, symbol); } /** * Claim tokens that were accidentally sent to this contract. * * @param _token The address of the token contract that you want to recover. */ function claimTokens(address _token) public onlyOwner { require(_token != address(0)); ERC20 token = ERC20(_token); uint balance = token.balanceOf(this); token.transfer(owner, balance); ClaimedTokens(_token, owner, balance); } }

12,888

47

// Is currently in the period after the private start time and before the public start time.

modifier is_pre_crowdfund_period() { if (now >= publicStartTime || now < privateStartTime) throw; _; }

18,240

164

// Record a bounty that an arbiter has voted onarbiter The address of the arbiter bountyGuid The guid of the bounty /

30,077