Pipper/Solcoder_QA · Datasets at Hugging Face

16

// During the deployment of the contract pass the ERC-20 contract address used for rewards.

constructor(address _rewardsToken) public { rewardsToken = IERC20(_rewardsToken); }

77,595

113

// Make sure tokens are currently locked before proceeding to unlock them

require(tokensLocked == true); tokensLocked = false;

42,320

11

// send fee tokens to fee collector

IERC20(_token).safeTransfer(feeCollector, liquidityFee); uint256 amountLocked = _amount.sub(liquidityFee); TokenLock memory token_lock; token_lock.lockDate = block.timestamp; token_lock.amount = amountLocked; token_lock.initialAmount = amountLocked; token_lock.unlockDate = _unlockDate; token_lock.lockID = tokenLocks[_token].length; token_lock.owner = _withdrawer;

39,690

65

// Redeems yield bearing tokens from this TempusPool/msg.sender will receive the YBT/NOTE 1 Before maturity, principalAmount must equal to yieldAmount./NOTE 2 This function can only be called by TempusController/from Address to redeem its Tempus Shares/principalAmount Amount of Tempus Principal Shares (TPS) to redeem for YBT in PrincipalShare decimal precision/yieldAmount Amount of Tempus Yield Shares (TYS) to redeem for YBT in YieldShare decimal precision/recipient Address to which redeemed YBT will be sent/ return redeemableYieldTokens Amount of Yield Bearing Tokens redeemed to `recipient`/ return fee The fee which was deducted (in terms of YBT)/ return rate The interest rate at the time of

function redeem( address from, uint256 principalAmount, uint256 yieldAmount, address recipient ) external returns ( uint256 redeemableYieldTokens, uint256 fee,

53,411

20

// Initializes the contract with immutable variables /

constructor(address _share) { if (_share == address(0)) revert BadAddress(); share = IVaultShare(_share); }

15,323

89

// Set next loan allocation from vault in USD

allocationState.loanAllocation = (uint256(_allocationState.loanAllocationPCT) * lockedBalance) / TOTAL_PCT;

8,339

0

// ratio for token transfers. 1000 -> 1:1 transfer

uint256 public constant TOKEN_RATIO = 1000; uint256 private nonce; string private constant ACTIVE_TOKEN_NAME = "IOU-"; string private constant PASSIVE_TOKEN_NAME = "R-";

27,222

114

// Redeem invested underlying tokens from defi protocol and exchange into DAI _amount tokens to be redeemedreturn amount of token swapped to dai, amount of reward token swapped to dai, total dai /

function redeemUnderlyingToDAI(uint256 _amount, address _recipient)

38,711

24

// Forward authorized contract calls to protocol contracts Fallback function can be called by the beneficiary only if function call is allowed / solhint-disable-next-line no-complex-fallback

fallback() external payable { // Only beneficiary can forward calls require(msg.sender == beneficiary, "Unauthorized caller"); require(msg.value == 0, "ETH transfers not supported"); // Function call validation address _target = manager.getAuthFunctionCallTarget(msg.sig); require(_target != address(0), "Unauthorized function"); uint256 oldBalance = currentBalance(); // Call function with data Address.functionCall(_target, msg.data); // Tracked used tokens in the protocol // We do this check after balances were updated by the forwarded call // Check is only enforced for revocable contracts to save some gas if (revocable == Revocability.Enabled) { // Track contract balance change uint256 newBalance = currentBalance(); if (newBalance < oldBalance) { // Outflow uint256 diff = oldBalance.sub(newBalance); usedAmount = usedAmount.add(diff); } else { // Inflow: We can receive profits from the protocol, that could make usedAmount to // underflow. We set it to zero in that case. uint256 diff = newBalance.sub(oldBalance); usedAmount = (diff >= usedAmount) ? 0 : usedAmount.sub(diff); } require(usedAmount <= vestedAmount(), "Cannot use more tokens than vested amount"); } }

21,308

296

// lib/yamV3/contracts/tests/vesting_pool/VestingPool.sol/ pragma solidity 0.5.15; // import "../../lib/SafeERC20.sol"; /

/* import {YAMDelegate3} from "../../token/YAMDelegate3.sol"; */ contract VestingPool { using SafeMath_2 for uint256; using SafeMath_2 for uint128; struct Stream { address recipient; uint128 startTime; uint128 length; uint256 totalAmount; uint256 amountPaidOut; } /** * @notice Governor for this contract */ address public gov; /** * @notice Pending governance for this contract */ address public pendingGov; /// @notice Mapping containing valid stream managers mapping(address => bool) public isSubGov; /// @notice Amount of tokens allocated to streams that hasn't yet been claimed uint256 public totalUnclaimedInStreams; /// @notice The number of streams created so far uint256 public streamCount; /// @notice All streams mapping(uint256 => Stream) public streams; /// @notice YAM token YAMDelegate3 public yam; /** * @notice Event emitted when a sub gov is enabled/disabled */ event SubGovModified( address account, bool isSubGov ); /** * @notice Event emitted when stream is opened */ event StreamOpened( address indexed account, uint256 indexed streamId, uint256 length, uint256 totalAmount ); /** * @notice Event emitted when stream is closed */ event StreamClosed(uint256 indexed streamId); /** * @notice Event emitted on payout */ event Payout( uint256 indexed streamId, address indexed recipient, uint256 amount ); /** * @notice Event emitted when pendingGov is changed */ event NewPendingGov( address oldPendingGov, address newPendingGov ); /** * @notice Event emitted when gov is changed */ event NewGov( address oldGov, address newGov ); constructor(YAMDelegate3 _yam) public { gov = msg.sender; yam = _yam; } modifier onlyGov() { require(msg.sender == gov, "VestingPool::onlyGov: account is not gov"); _; } modifier canManageStreams() { require( isSubGov[msg.sender] || (msg.sender == gov), "VestingPool::canManageStreams: account cannot manage streams" ); _; } /** * @dev Set whether an account can open/close streams. Only callable by the current gov contract * @param account The account to set permissions for. * @param _isSubGov Whether or not this account can manage streams */ function setSubGov(address account, bool _isSubGov) public onlyGov { isSubGov[account] = _isSubGov; emit SubGovModified(account, _isSubGov); } /** @notice sets the pendingGov * @param pendingGov_ The address of the contract to use for authentication. */ function _setPendingGov(address pendingGov_) external onlyGov { address oldPendingGov = pendingGov; pendingGov = pendingGov_; emit NewPendingGov(oldPendingGov, pendingGov_); } /** @notice accepts governance over this contract * */ function _acceptGov() external { require(msg.sender == pendingGov, "!pending"); address oldGov = gov; gov = pendingGov; pendingGov = address(0); emit NewGov(oldGov, gov); } /** * @dev Opens a new stream that continuously pays out. * @param recipient Account that will receive the funds. * @param length The amount of time in seconds that the stream lasts * @param totalAmount The total amount to payout in the stream */ function openStream( address recipient, uint128 length, uint256 totalAmount ) public canManageStreams returns (uint256 streamIndex) { streamIndex = streamCount++; streams[streamIndex] = Stream({ recipient: recipient, length: length, startTime: uint128(block.timestamp), totalAmount: totalAmount, amountPaidOut: 0 }); totalUnclaimedInStreams = totalUnclaimedInStreams.add(totalAmount); require( totalUnclaimedInStreams <= yam.balanceOfUnderlying(address(this)), "VestingPool::payout: Total streaming is greater than pool's YAM balance" ); emit StreamOpened(recipient, streamIndex, length, totalAmount); } /** * @dev Closes the specified stream. Pays out pending amounts, clears out the stream, and emits a StreamClosed event. * @param streamId The id of the stream to close. */ function closeStream(uint256 streamId) public canManageStreams { payout(streamId); streams[streamId] = Stream( address(0x0000000000000000000000000000000000000000), 0, 0, 0, 0 ); emit StreamClosed(streamId); } /** * @dev Pays out pending amount in a stream * @param streamId The id of the stream to payout. * @return The amount paid out in underlying */ function payout(uint256 streamId) public returns (uint256 paidOut) { uint128 currentTime = uint128(block.timestamp); Stream memory stream = streams[streamId]; require( stream.startTime <= currentTime, "VestingPool::payout: Stream hasn't started yet" ); uint256 claimableUnderlying = _claimable(stream); streams[streamId].amountPaidOut = stream.amountPaidOut.add( claimableUnderlying ); totalUnclaimedInStreams = totalUnclaimedInStreams.sub( claimableUnderlying ); yam.transferUnderlying(stream.recipient, claimableUnderlying); emit Payout(streamId, stream.recipient, claimableUnderlying); return claimableUnderlying; } /** * @dev The amount that is claimable for a stream * @param streamId The stream to get the claimabout amount for. * @return The amount that is claimable for this stream */ function claimable(uint256 streamId) external view returns (uint256 claimableUnderlying) { Stream memory stream = streams[streamId]; return _claimable(stream); } function _claimable(Stream memory stream) internal view returns (uint256 claimableUnderlying) { uint128 currentTime = uint128(block.timestamp); uint128 elapsedTime = currentTime - stream.startTime; if (currentTime >= stream.startTime + stream.length) { claimableUnderlying = stream.totalAmount - stream.amountPaidOut; } else { claimableUnderlying = elapsedTime .mul(stream.totalAmount) .div(stream.length) .sub(stream.amountPaidOut); } } }

36,803

28

// Deletes the provided root from the collection ofwithdrawal authorization merkle tree roots, invalidating thewithdrawals contained in the tree assocated with this root. root The root hash to delete. /

function deleteWithdrawalRoot(bytes32 root) private { uint256 nonce = _withdrawalRootToNonce[root]; require( nonce > 0, "Root hash not set" ); delete _withdrawalRootToNonce[root]; emit WithdrawalRootHashRemoval(root, nonce); }

26,532

1

// Subtract a number from another number, checking for underflowsa first number b second numberreturna - b /

function sub(uint256 a, uint256 b) internal constant returns (uint256) { assert(b <= a); return a - b; }

40,744

6

// Track amount of seed money put into jackpot.

uint256 public seedAmount;

11,574

290

// Allow Original Crypterior Holders to mint an another one if goal is reached. /

function increaseMaxMintPerOriginalCrypterior() public { require(totalSupply() > WHEN_INCREASE_MAX_MINTS_PER_ORIGINAL_CRYPTERIOR, "Goal has to be reached"); MAX_MINTS_PER_ORIGINAL_CRYPTERIOR = 2; }

52,005

97

// event of when a swap has been cancelled

event SwapCancelled(uint256 indexed id);

15,465

240

// StakeRewarder This contract distributes rewards to depositors of supported tokens.It's based on Sushi's MasterChef v1, but notably only serves what's alreadyavailable: no new tokens can be created. It's just a restaurant, not a farm. /

contract StakeRewarder is Ownable { using SafeMath for uint256; using SafeERC20 for IERC20; struct UserInfo { uint256 amount; // Quantity of tokens the user has staked. uint256 rewardDebt; // Reward debt. See explanation below. // We do some fancy math here. Basically, any point in time, the // amount of rewards entitled to a user but is pending to be distributed is: // // pendingReward = (stakedAmount * pool.accPerShare) - user.rewardDebt // // Whenever a user deposits or withdraws tokens in a pool: // 1. The pool's `accPerShare` (and `lastRewardBlock`) gets updated. // 2. User's pending rewards are issued (greatly simplifies accounting). // 3. User's `amount` gets updated. // 4. User's `rewardDebt` gets updated. } struct PoolInfo { IERC20 token; // Address of the token contract. uint256 weight; // Weight points assigned to this pool. uint256 power; // The multiplier for determining "staking power". uint256 total; // Total number of tokens staked. uint256 accPerShare; // Accumulated rewards per share (times 1e12). uint256 lastRewardBlock; // Last block where rewards were calculated. } // Distribution vault. VestingMultiVault public immutable vault; // Reward configuration. IERC20 public immutable rewardToken; uint256 public rewardPerBlock; uint256 public vestingCliff; uint256 public vestingDuration; // Housekeeping for each pool. PoolInfo[] public poolInfo; // Info of each user that stakes tokens. mapping(uint256 => mapping(address => UserInfo)) public userInfo; // Underpaid rewards owed to a user. mapping(address => uint256) public underpayment; // The sum of weights across all staking tokens. uint256 public totalWeight = 0; // The block number when staking starts. uint256 public startBlock; event TokenAdded(address indexed token, uint256 weight, uint256 totalWeight); event Deposit(address indexed user, uint256 indexed pid, uint256 amount); event Withdraw(address indexed user, uint256 indexed pid, uint256 amount); event Claim(address indexed user, uint256 amount); event EmergencyReclaim(address indexed user, address token, uint256 amount); event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 amount); /** * @dev Create a staking contract that rewards depositors using its own token balance * and optionally vests rewards over time. * @param _rewardToken The token to be distributed as rewards. * @param _rewardPerBlock The quantity of reward tokens accrued per block. * @param _startBlock The first block at which staking is allowed. * @param _vestingCliff The number of seconds until issued rewards begin vesting. * @param _vestingDuration The number of seconds after issuance until vesting is completed. * @param _vault The VestingMultiVault that is ultimately responsible for reward distribution. */ constructor( IERC20 _rewardToken, uint256 _rewardPerBlock, uint256 _startBlock, uint256 _vestingCliff, uint256 _vestingDuration, VestingMultiVault _vault ) { // Set the initial reward config rewardPerBlock = _rewardPerBlock; startBlock = _startBlock; vestingCliff = _vestingCliff; vestingDuration = _vestingDuration; // Set the vault and reward token (immutable after creation) vault = _vault; rewardToken = _rewardToken; // Approve the vault to pull reward tokens _rewardToken.approve(address(_vault), 2**256 - 1); } /** * @dev Adds a new staking pool to the stack. Can only be called by the owner. * @param _token The token to be staked. * @param _weight The weight of this pool (used to determine proportion of rewards relative to the total weight). * @param _power The power factor of this pool (used as a multiple of tokens staked, e.g. for determining voting power). * @param _shouldUpdate Whether to update all pools first. */ function createPool( IERC20 _token, uint256 _weight, uint256 _power, bool _shouldUpdate ) public onlyOwner { if (_shouldUpdate) { pokePools(); } uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock; totalWeight = totalWeight.add(_weight); poolInfo.push( PoolInfo({ token: _token, weight: _weight, power: _power, total: 0, accPerShare: 0, lastRewardBlock: lastRewardBlock }) ); } /** * @dev Update the given staking pool's weight and power. Can only be called by the owner. * @param _pid The pool identifier. * @param _weight The weight of this pool (used to determine proportion of rewards relative to the total weight). * @param _power The power of this pool's token (used as a multiplier of tokens staked, e.g. for voting). * @param _shouldUpdate Whether to update all pools first. */ function updatePool( uint256 _pid, uint256 _weight, uint256 _power, bool _shouldUpdate ) public onlyOwner { if (_shouldUpdate) { pokePools(); } totalWeight = totalWeight.sub(poolInfo[_pid].weight).add( _weight ); poolInfo[_pid].weight = _weight; poolInfo[_pid].power = _power; } /** * @dev Update the reward per block. Can only be called by the owner. * @param _rewardPerBlock The total quantity to distribute per block. */ function setRewardPerBlock( uint256 _rewardPerBlock ) public onlyOwner { rewardPerBlock = _rewardPerBlock; } /** * @dev Update the vesting rules for rewards. Can only be called by the owner. * @param _duration the number of seconds over which vesting occurs (see VestingMultiVault) * @param _cliff the number of seconds before any release occurs (see VestingMultiVault) */ function setVestingRules( uint256 _duration, uint256 _cliff ) public onlyOwner { vestingDuration = _duration; vestingCliff = _cliff; } /** * @dev Calculate elapsed blocks between `_from` and `_to`. * @param _from The starting block. * @param _to The ending block. */ function duration( uint256 _from, uint256 _to ) public pure returns (uint256) { return _to.sub(_from); } function totalPendingRewards( address _beneficiary ) public view returns (uint256 total) { for (uint256 pid = 0; pid < poolInfo.length; pid++) { total = total.add(pendingRewards(pid, _beneficiary)); } return total; } /** * @dev View function to see pending rewards for an address. Likely gas intensive. * @param _pid The pool identifier. * @param _beneficiary The address to check. */ function pendingRewards( uint256 _pid, address _beneficiary ) public view returns (uint256 amount) { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][_beneficiary]; uint256 accPerShare = pool.accPerShare; uint256 tokenSupply = pool.total; if (block.number > pool.lastRewardBlock && tokenSupply != 0) { uint256 reward = duration(pool.lastRewardBlock, block.number) .mul(rewardPerBlock) .mul(pool.weight) .div(totalWeight); accPerShare = accPerShare.add( reward.mul(1e12).div(tokenSupply) ); } return user.amount.mul(accPerShare).div(1e12).sub(user.rewardDebt); } /** * @dev Gets the sum of power for every pool. Likely gas intensive. * @param _beneficiary The address to check. */ function totalPower( address _beneficiary ) public view returns (uint256 total) { for (uint256 pid = 0; pid < poolInfo.length; pid++) { total = total.add(power(pid, _beneficiary)); } return total; } /** * @dev Gets power for a single pool. * @param _pid The pool identifier. * @param _beneficiary The address to check. */ function power( uint256 _pid, address _beneficiary ) public view returns (uint256 amount) { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][_beneficiary]; return pool.power.mul(user.amount); } /** * @dev Update all pools. Callable by anyone. Could be gas intensive. */ function pokePools() public { uint256 length = poolInfo.length; for (uint256 pid = 0; pid < length; ++pid) { pokePool(pid); } } /** * @dev Update rewards of the given pool to be up-to-date. Callable by anyone. * @param _pid The pool identifier. */ function pokePool( uint256 _pid ) public { PoolInfo storage pool = poolInfo[_pid]; if (block.number <= pool.lastRewardBlock) { return; } uint256 tokenSupply = pool.total; if (tokenSupply == 0) { pool.lastRewardBlock = block.number; return; } uint256 reward = duration(pool.lastRewardBlock, block.number) .mul(rewardPerBlock) .mul(pool.weight) .div(totalWeight); pool.accPerShare = pool.accPerShare.add( reward.mul(1e12).div(tokenSupply) ); pool.lastRewardBlock = block.number; } /** * @dev Claim rewards not yet distributed for an address. Callable by anyone. * @param _pid The pool identifier. * @param _beneficiary The address to claim for. */ function claim( uint256 _pid, address _beneficiary ) public { // make sure the pool is up-to-date pokePool(_pid); PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][_beneficiary]; _claim(pool, user, _beneficiary); } /** * @dev Claim rewards from multiple pools. Callable by anyone. * @param _pids An array of pool identifiers. * @param _beneficiary The address to claim for. */ function claimMultiple( uint256[] calldata _pids, address _beneficiary ) external { for (uint256 i = 0; i < _pids.length; i++) { claim(_pids[i], _beneficiary); } } /** * @dev Stake tokens to earn a share of rewards. * @param _pid The pool identifier. * @param _amount The number of tokens to deposit. */ function deposit( uint256 _pid, uint256 _amount ) public { require(_amount > 0, "deposit: only non-zero amounts allowed"); // make sure the pool is up-to-date pokePool(_pid); PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; // deliver any pending rewards _claim(pool, user, msg.sender); // pull in user's staked assets pool.token.safeTransferFrom( address(msg.sender), address(this), _amount ); // update the pool's total deposit pool.total = pool.total.add(_amount); // update user's deposit and reward info user.amount = user.amount.add(_amount); user.rewardDebt = user.amount.mul(pool.accPerShare).div(1e12); emit Deposit(msg.sender, _pid, _amount); } /** * @dev Withdraw staked tokens and any pending rewards. */ function withdraw( uint256 _pid, uint256 _amount ) public { require(_amount > 0, "withdraw: only non-zero amounts allowed"); // make sure the pool is up-to-date pokePool(_pid); PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; require(user.amount >= _amount, "withdraw: amount too large"); // deliver any pending rewards _claim(pool, user, msg.sender); // update the pool's total deposit pool.total = pool.total.sub(_amount); // update the user's deposit and reward info user.amount = user.amount.sub(_amount); user.rewardDebt = user.amount.mul(pool.accPerShare).div(1e12); // send back the staked assets pool.token.safeTransfer(address(msg.sender), _amount); emit Withdraw(msg.sender, _pid, _amount); } /** * @dev Withdraw staked tokens and forego any unclaimed rewards. This is a fail-safe. */ function emergencyWithdraw( uint256 _pid ) public { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; uint256 amount = user.amount; // reset everything to zero user.amount = 0; user.rewardDebt = 0; underpayment[msg.sender] = 0; // update the pool's total deposit pool.total = pool.total.sub(amount); // send back the staked assets pool.token.safeTransfer(address(msg.sender), amount); emit EmergencyWithdraw(msg.sender, _pid, amount); } /** * @dev Reclaim stuck tokens (e.g. unexpected external rewards). This is a fail-safe. */ function emergencyReclaim( IERC20 _token, uint256 _amount ) public onlyOwner { if (_amount == 0) { _amount = _token.balanceOf(address(this)); } _token.transfer(msg.sender, _amount); emit EmergencyReclaim(msg.sender, address(_token), _amount); } /** * @dev Gets the length of the pools array. */ function poolLength() external view returns (uint256 length) { return poolInfo.length; } /** * @dev Claim rewards not yet distributed for an address. * @param pool The staking pool issuing rewards. * @param user The staker who earned them. * @param to The address to pay. */ function _claim( PoolInfo storage pool, UserInfo storage user, address to ) internal { if (user.amount > 0) { // calculate the pending reward uint256 pending = user.amount .mul(pool.accPerShare) .div(1e12) .sub(user.rewardDebt) .add(underpayment[to]); // send the rewards out uint256 payout = _safelyDistribute(to, pending); if (payout < pending) { underpayment[to] = pending.sub(payout); } else { underpayment[to] = 0; } emit Claim(to, payout); } } /** * @dev Safely distribute at most the amount of tokens in holding. */ function _safelyDistribute( address _to, uint256 _amount ) internal returns (uint256 amount) { uint256 available = rewardToken.balanceOf(address(this)); amount = _amount > available ? available : _amount; vault.issue( _to, // address _beneficiary, _amount, // uint256 _amount, block.timestamp, // uint256 _startAt, vestingCliff, // uint256 _cliff, vestingDuration, // uint256 _duration, 0 // uint256 _initialPct ); return amount; } }

31,477

1,430

// Load the corresponding market into memory

nToken.cashGroup.loadMarket(market, i + 1, true, blockTime); PortfolioAsset memory liquidityToken = nToken.portfolioState.storedAssets[i]; uint256 maturity = liquidityToken.maturity;

4,280

0

// ISideToken sideTokenBtc;sideEthereumBTC

address internal constant NULL_ADDRESS = address(0); uint256 public fee; mapping(address => uint256) public balance;

11,779

103

// Pool Delegate Utility Functions // /

function poolSanityChecks( IMapleGlobals globals, address liquidityAsset, address stakeAsset, uint256 stakingFee, uint256 delegateFee

59,702

6

// Empty internal constructor, to prevent people from mistakenly deployingan instance of this contract, which should be used via inheritance.

constructor () internal { }

8,951

121

// Returns number of valid coins staked by `account` /

function activeStakeOf(address account) public view returns (uint256) { return _stakeOf(account, _nextCheckpoint()); }

34,692

1

// Store accounts that have made a transaction

mapping(address => bool) public senders;

2,844

5

// Chainlink Setup:

bytes32 internal keyHash; uint256 public fee; uint256 internal randomResult; uint256 internal randomNumber; address public linkToken; uint256 public vrfcooldown; CountersUpgradeable.Counter public vrfReqd;

7,092

683

// Address of the position's heldToken. Cached for convenience and lower-cost withdrawals

address public heldToken;

67,421

0

// ERC20 A standard interface for tokens. /

contract ERC20 { /// @dev Returns the total token supply function totalSupply() public view returns (uint256 supply); /// @dev Returns the account balance of the account with address _owner function balanceOf(address _owner) public view returns (uint256 balance); /// @dev Transfers _value number of tokens to address _to function transfer(address _to, uint256 _value) public returns (bool success); /// @dev Transfers _value number of tokens from address _from to address _to function transferFrom(address _from, address _to, uint256 _value) public returns (bool success); /// @dev Allows _spender to withdraw from the msg.sender's account up to the _value amount function approve(address _spender, uint256 _value) public returns (bool success); /// @dev Returns the amount which _spender is still allowed to withdraw from _owner function allowance(address _owner, address _spender) public view returns (uint256 remaining); event Transfer(address indexed _from, address indexed _to, uint256 _value); event Approval(address indexed _owner, address indexed _spender, uint256 _value); }

52,012

147

// Get the total denormalized weight of the pool. /

function getTotalDenormalizedWeight() external view override _viewlock_ returns (uint256)

12,416

9

// Events /

event Stake(uint256 amount, uint256 campaignId, uint256 poolId); event SwitchPool(uint256 campaignId, uint256 fromPoolId, uint256 toPoolId); event Unstake(uint256 campaignId, uint256 poolId); event Claim(uint256 campaignId, address userAddress, uint256 amount);

4,724

516

// Make sure the FPI oracle price hasn't moved away too much from the target peg price

require(price_diff_abs <= peg_band_twamm, "Peg band [TWAMM]");

47,960

1

// NoDeliveryCrowdsale Enjinstarter Extension of Crowdsale contract where purchased tokens are not delivered. /

abstract contract NoDeliveryCrowdsale is Crowdsale { /** * @dev Overrides delivery by not delivering tokens upon purchase. */ function _deliverTokens(address, uint256) internal pure override { return; } }

31,642

61

// increment buyer

tokenSaleInfo.counter++;

73,770

21

// Sanity check: constants are reasonable.

require(_processGas >= 850_000, "!process gas"); require(_reserveGas >= 15_000, "!reserve gas"); PROCESS_GAS = _processGas; RESERVE_GAS = _reserveGas; require(_merkle != address(0), "!zero merkle"); MERKLE = MerkleTreeManager(_merkle); delayBlocks = _delayBlocks;

11,464

12

// list of tokens

address[] public tokens; mapping(address => tokenData) public tokenInfo; mapping(address => bool) public keepers; distributionSplit public tokenDistribution;

48,547

106

// Shortcut to check if a farm is active /

function _checkActive(Farm storage farm) internal { farm.active = !(farm.paused || farm.farmEndedAtBlock > 0); }

49,721

11

// Compute the look up table for the simultaneous multiplication (P, 3P,..,Q,3Q,..)./_iP the look up table were values will be stored/_points the points P and Q to be multiplied/_aa constant of the curve/_beta constant of the curve (endomorphism)/_pp the modulus

function _lookupSimMul( uint256[3][4][4] memory _iP, uint256[4] memory _points, uint256 _aa, uint256 _beta, uint256 _pp) private pure

50,062

140

// CURVE

int128 fromIndex = int128(curveIndex[fromAddress]); int128 toIndex = int128(curveIndex[toAddress]); if (fromIndex > 0 && toIndex > 0) { reserveA = curve.balances(uint256(getCurveIndex(fromAddress))); reserveB = curve.balances(uint256(getCurveIndex(toAddress))); }

36,802

28

// {ERC721} token, including:This contract uses {AccessControl} to lock permissioned functions using the/ Grants `DEFAULT_ADMIN_ROLE`, `MINTER_ROLE` to theaccount that deploys the contract. Token URIs will be autogenerated based on `baseURI` and their token IDs.See {ERC721-tokenURI}. /

constructor(string memory name, string memory symbol, string memory baseTokenURI, uint32 maxTokenSupply, address _proxyRegistryAddress) ERC721(name, symbol) { proxyRegistryAddress = _proxyRegistryAddress; _initializeEIP712(name); _baseTokenURI = baseTokenURI; _maxSupply = maxTokenSupply; _setupRole(DEFAULT_ADMIN_ROLE, _msgSender()); _setupRole(MINTER_ROLE, _msgSender()); }

40,239

170

// `(quantity == 1) << _BITPOS_NEXT_INITIALIZED`.

result := shl(_BITPOS_NEXT_INITIALIZED, eq(quantity, 1))

8,215

18

// Gets the maximum input for a valid swap pair _mAsset mAsset address (e.g. mUSD) _input Asset to input only bAssets accepted _output Either a bAsset or the mAssetreturn validreturn validity reasonreturn max input units (in native decimals)return how much output this input would produce (in native decimals, after any fee) /

function getMaxSwap(

29,865

34

// Utility function to switch sides/ _side Side /return Opposite Side

function switchTeam(Sides _side) internal pure returns (Sides) { if (_side == Sides.Black) { return Sides.White; } else { return Sides.Black; } }

10,949

68

// Solidity does not require us to clean the trailing bytes. We do it anyway

result := and(result, 0xFFFFFFFF00000000000000000000000000000000000000000000000000000000)

5,769

54

// if we are selling token to token

else { amounts = router.swapExactTokensForTokens(_srcAmount, 1, path, msg.sender, block.timestamp + 1); }

38,373

1

// Query the TokenId(ERAC) list for the specified account./

function getTokenIds(address owner) external view returns (uint256[] memory);

55,395

32

// Don't allow for funding if the amount of Ether sent is less than 1 szabo.

reffUp(_reff); if (msg.value > 0.000001 ether) { investSum = add(investSum,msg.value); buy(bondType/*,edgePigmentR(),edgePigmentG(),edgePigmentB()*/); lastGateway = msg.sender; } else {

14,446

6

// ======== STATE VARIABLS ======== // ======== EVENTS ======== // ======== POLICY FUNCTIONS ======== // /

function pushBond(address _principalToken, address _customTreasury, address _customBond, address _initialOwner, uint[] calldata _tierCeilings, uint[] calldata _fees) external returns(address _treasury, address _bond) { require(olympusProFactory == msg.sender, "Not Olympus Pro Factory"); indexOfBond[_customBond] = bondDetails.length; bondDetails.push( BondDetails({ _principalToken: _principalToken, _treasuryAddress: _customTreasury, _bondAddress: _customBond, _initialOwner: _initialOwner, _tierCeilings: _tierCeilings, _fees: _fees })); emit BondCreation(_customTreasury, _customBond, _initialOwner); return( _customTreasury, _customBond ); }

11,977

26

// Has the farm started earning yet?

if ( block.number <= farm.lastRewardBlock) { return; }

34,905

8

// Swap old and new receivers' vesting schedule, using address(0) as a scratch space. This is done to not overwrite an active vesting schedule.

vestingScheduleOf[address(0)] = vestingScheduleOf[oldReceiver_]; vestingScheduleOf[oldReceiver_] = vestingScheduleOf[newReceiver_]; vestingScheduleOf[newReceiver_] = vestingScheduleOf[address(0)]; delete vestingScheduleOf[address(0)]; emit ReceiverChanged(oldReceiver_, newReceiver_);

57,994

82

// Given an addr input, injects return/sub values if specified/_param The original input value/_mapType Indicated the type of the input in paramMapping/_subData Array of subscription data we can replace the input value with/_returnValues Array of subscription data we can replace the input value with

function _parseParamAddr( address _param, uint8 _mapType, bytes[] memory _subData, bytes32[] memory _returnValues

2,656

92

// Update totals

weiRaised = weiRaised.plus(weiAmount); tokensSold = tokensSold.plus(tokenAmount);

66

12

// Note: the cost of playing is set by the contract creator, but it may be left to the player to decide.

function RockPaperScissors(uint _gameCreationCost) public

13,339

153

// Set address to receive fees./ This may be called only by `governance`/_rewards Rewards receiver in Everscale network

function setRewards( EverscaleAddress memory _rewards

42,018

84

// _releaseTime["C"] = _lockStart.add(231104000000);

_issueByPartition("C",msg.sender,msg.sender,87358000 * 10 ** uint256(_decimals),"");

3,232

30

// Get size of "_to" address, if 0 it's a wallet

uint32 size; assembly { size := extcodesize(_to) }

4,917

425

// URI

string internal hiddenURI; string internal _baseTokenURI; string public _baseExtension = ".json";

38,789

137

// ERC721 Delete asset

_destroy(mortgageId);

50,093

42

// Update the swap fee to be applied on swaps newSwapFee new swap fee to be applied on future transactions /

function setSwapFee(uint256 newSwapFee) external payable onlyOwner { swapStorage.setSwapFee(newSwapFee); }

6,489

113

// Returns total USD holdings in strategy.return amount is lpBalance x lpPrice + cvx x cvxPrice + _config.crvcrvPrice.return Returns total USD holdings in strategy /

function totalHoldings() public view virtual returns (uint256) { uint256 crvLpHoldings = (cvxRewards.balanceOf(address(this)) * getCurvePoolPrice()) / CURVE_PRICE_DENOMINATOR; uint256 crvEarned = cvxRewards.earned(address(this)); uint256 cvxTotalCliffs = _config.cvx.totalCliffs(); uint256 cvxRemainCliffs = cvxTotalCliffs - _config.cvx.totalSupply() / _config.cvx.reductionPerCliff(); uint256 amountIn = (crvEarned * cvxRemainCliffs) / cvxTotalCliffs + _config.cvx.balanceOf(address(this)); uint256 cvxEarningsUSDT = priceTokenByExchange(amountIn, _config.cvxToUsdtPath); amountIn = crvEarned + _config.crv.balanceOf(address(this)); uint256 crvEarningsUSDT = priceTokenByExchange(amountIn, _config.crvToUsdtPath); uint256 tokensHoldings = 0; for (uint256 i = 0; i < 3; i++) { tokensHoldings += _config.tokens[i].balanceOf(address(this)) * decimalsMultipliers[i]; } return tokensHoldings + crvLpHoldings + (cvxEarningsUSDT + crvEarningsUSDT) * decimalsMultipliers[ZUNAMI_USDT_TOKEN_ID]; }

9,887

42

// calcOutGivenIn aO = tokenAmountOutbO = tokenBalanceOut bI = tokenBalanceIn//bI \(wI / wO) \ aI = tokenAmountInaO = bO|1 - | --------------------------| ^|wI = tokenWeightIn \\ ( bI + ( aI( 1 - sF )) // wO = tokenWeightOutsF = swapFee/

) public pure returns (uint256 tokenAmountOut) { uint256 weightRatio; if (tokenWeightIn == tokenWeightOut) { weightRatio = 1 * BONE; } else if (tokenWeightIn >> 1 == tokenWeightOut) { weightRatio = 2 * BONE; } else { weightRatio = tokenWeightIn.bdiv(tokenWeightOut); } uint256 adjustedIn = BONE.bsub(swapFee); adjustedIn = tokenAmountIn.bmul(adjustedIn); uint256 y = tokenBalanceIn.bdiv(tokenBalanceIn.badd(adjustedIn)); uint256 foo; if (tokenWeightIn == tokenWeightOut) { foo = y; } else if (tokenWeightIn >> 1 == tokenWeightOut) { foo = y.bmul(y); } else { foo = y.bpow(weightRatio); } uint256 bar = BONE.bsub(foo); tokenAmountOut = tokenBalanceOut.bmul(bar); return tokenAmountOut; }

1,576

226

// check if the base fee gas price is higher than we allow. if it is, block harvests.

if (!isBaseFeeAcceptable()) return false;

21,643

20

// See {ERC20-_burn}.votes will be updated after burn() whoever the delegator is. /

function burn(uint256 rawAmount) external returns (bool) { uint128 amount = safe128(rawAmount, "_burn: amount exceeds 128 bits"); require(_burn(msg.sender, amount), "burn: fail to burn"); return true; }

34,763

7

// Emitted when a submission for a bounty is rejected/bountyID The ID of the bounty for which the submission is rejected/submitter The address of the submitter/stake The stake of the rejected submission/payload The payload of the rejected submission/queueIndex The queue index of the submission/queueLength The queue length of the bounty the submission was made to

event RejectSubmission ( uint256 indexed bountyID, address indexed submitter, uint256 stake, bytes32 payload, uint32 queueIndex, uint32 queueLength );

27,987

157

// control

uint256 public period = 0; uint256 public periodFinish = 0; uint256 public startTime = 0;

72,749

1,351

// See {ERC20-_mint}. Requirements: - the caller must have the `MINTER_ROLE`. /

function mint(address to, uint256 amount) external virtual { require( hasRole(MINTER_ROLE, _msgSender()), "ERC20SupplyControlled/MinterRole" ); _mint(to, amount); }

3,686

28

// Contract address on Optimism

opWorldIDAddress, message, opGasLimitSendRootOptimism );

26,813

61

// Getter for the address of the payee number `index`. /

function payee(uint256 index) public view returns (address) { return _payees[index]; }

24,368

86

// Calculates the current borrow interest rate per blockcash The total amount of cash the market hasborrows The total amount of borrows the market has outstandingreserves The total amnount of reserves the market has return The borrow rate per block (as a percentage, and scaled by 1e18)/

function getBorrowRate(uint cash, uint borrows, uint reserves) external view returns (uint);

12,697

174

// I needed a time calaculator somewhere, so I added it in here. _months: The number of months to be converted into unix time. return uint256: The time stamp of the months in unix time./

function getMonthsFutureTimestamp( uint256 _months ) public view returns(uint256)

2,152

128

// Optional metadata extension for ERC-721 non-fungible token standard. /

interface ERC721Metadata { /** * @dev Returns a descriptive name for a collection of NFTs in this contract. */ function name() external view returns (string _name); /** * @dev Returns a abbreviated name for a collection of NFTs in this contract. */ function symbol() external view returns (string _symbol); /** * @dev Returns a distinct Uniform Resource Identifier (URI) for a given asset. It Throws if * `_tokenId` is not a valid NFT. URIs are defined in RFC3986. The URI may point to a JSON file * that conforms to the "ERC721 Metadata JSON Schema". */ function tokenURI(uint256 _tokenId) external view returns (string); }

22,052

9

// Initial exchange rate used when minting the first PTokens (used when totalSupply = 0) /

uint256 internal initialExchangeRateMantissa;

48,636

3

// Owner of account approves the transfer of an amount to another account

mapping(address => mapping (address => uint256)) allowed;

9,290

24

// The tradeable status of asset Leave (together with assetPrice) for auto buy and sell functionality (with Ether).

bool public isTradable;

21,182

273

// Gas price for oraclize callback transaction

uint256 public oracleGasPrice = 7000000000;

1,645

23

// _transfer tokens

try ERC20(paymentToken).transferFrom( subscriber, creator, paymentValue.mul(creatorCut).div(100) )

46,782

12

// Constructor _registry The address of the registry /

constructor(address _registry) { registry = _registry; }

27,476

58

// User redeems pTokens in exchange for the underlying asset Assumes interest has already been accrued up to the current block redeemer The address of the account which is redeeming the tokens redeemTokensIn The number of pTokens to redeem into underlying (only one of redeemTokensIn or redeemAmountIn may be non-zero) redeemAmountIn The number of underlying tokens to receive from redeeming pTokens (only one of redeemTokensIn or redeemAmountIn may be non-zero)return uint 0=success, otherwise a failure (see ErrorReporter.sol for details) /

3,680

3

// Derivative Configuration

uint256 public royaltyBps; uint256 public mintFee; address public creatorProceedRecipient; address public derivativeFeeRecipient; function initialize(address _creator, string memory _name, string memory _symbol, string memory _uri, address _creatorProceedRecipient,

22,999

57

// compute buy/sell taxes and subtract them from the total

uint256 feeValue = 0; if (!inSwap && currentState != State.AIRDROP) {

27,851

91

// If not a gen0 auction, exit

if (seller == address(nonFungibleContract)) {

18,752

7

// Match DAI DSR's maths. See DsrManager: 0x373238337Bfe1146fb49989fc222523f83081dDb And Pot: 0x197E90f9FAD81970bA7976f33CbD77088E5D7cf7 /

function _rmul(uint256 x, uint256 y) internal pure returns (uint256 z) { // always rounds down z = x * y / RAY; }

39,619

71

// External purchase function (payable in eth)/quantity to purchase/ return first minted token ID

function purchase(uint256 quantity) external payable returns (uint256);

26,245

40

// only allow one reward for each challenge

bytes32 solution = solutionForChallenge[challengeNumber]; solutionForChallenge[challengeNumber] = digest; if(solution != 0x0) revert(); //prevent the same answer from awarding twice if(tokensMinted > 1890000 * 10**uint(decimals)){ if(tokensMinted >= 6300000 * 10**uint(decimals)) {

33,459

43

// Unregisters Silo version/Callable only by owner./_siloVersion Silo version to be unregistered

function unregisterSiloVersion(uint128 _siloVersion) external;

24,732

297

// The managed root node

bytes32 public immutable rootNode;

27,547

15

// Lets an account with `MINTER_ROLE` mint tokens of ID from `nextTokenIdToMint`

* to `nextTokenIdToMint + _amount - 1`. The URIs for these tokenIds is baseURI + `${tokenId}`. * * @param _amount The amount of tokens (each with a unique tokenId) to lazy mint. */ function lazyMint(uint256 _amount, string calldata _baseURIForTokens) external; /** * @notice Lets an account claim a given quantity of tokens. * * @param _quantity The quantity of tokens to claim. * @param _proofs The proof required to prove the account's inclusion in the merkle root whitelist * of the mint conditions that apply. */ function claim(uint256 _quantity, bytes32[] calldata _proofs) external payable; /** * @notice Lets a module admin (account with `DEFAULT_ADMIN_ROLE`) set claim conditions. * * @param _conditions Mint conditions in ascending order by `startTimestamp`. */ function setClaimConditions(ClaimCondition[] calldata _conditions) external; }

53,645

2

// Number of pools

uint8 public constant numberPools = 2;

24,452

289

// 9 total active currencies possible (2 bytes each)

bytes18 activeCurrencies;

2,232

7

// get the WETH address

function WETH() external pure returns (address);

21,859

12

// Construct calldata for finalizeDeposit call

bytes memory message = abi.encodeWithSelector( IL2ERC20Bridge.finalizeDeposit.selector, address(0), Lib_PredeployAddresses.OVM_ETH, _from, _to, _amount, _data );

5,856

6

// Deposit `_value` additional tokens for `msg.sender` without modifying the unlock time _value Amount of tokens to deposit and add to the lock /

function increase_amount(uint256 _value) external;

58,034

160

// this will only be called by the clone function above

function initialize( address _vault, address _strategist, address _rewards, address _keeper, address _farmingContract, address _emissionToken, address _staking, string memory _name

14,999

52

// Emits a {Transfer} event with `to` set to the zero address. Requirements: - `account` cannot be the zero address.- `account` must have at least `amount` tokens./

function _transferWithBurn(address sender, address recipient, uint256 amount, uint256 amountToBurn) internal virtual { require(sender != address(0), "ERC20: transfer from the zero address"); require(recipient != address(0), "ERC20: transfer to the zero address"); _beforeTokenTransfer(sender, recipient, amount); uint256 senderBalance = _balances[sender]; require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");

27,521

14

// No wash trading.

require(sender != makerOrdersByID[makerOrderID].user, "07");

5,777

1

// Transfer the fees to the marketing wallet

super._transfer(sender, _marketingWallet, feeAmount);

29,585

1

// returns project detailsreturn owner of Project. return name of Project. return imageHash of Project. return description of Project. return rate of Project. return ownerWallet of Project. return cap of Project. return weiRaised of Project. return capReached of Project. /

{ owner = this.owner(); name = this.name(); imageHash = this.imageHash(); description = this.description(); rate = this.rate(); ownerWallet = this.wallet(); cap = this.cap(); weiRaised = this.weiRaised(); capReached = this.capReached(); return ( owner, name, imageHash, description, rate, ownerWallet, cap, weiRaised, capReached); }

50,058

27

// amtBaskets: the BU change to be recorded by this issuance D18{BU} = D18{BU}{qRTok} / {qRTok} Downcast is safe because an actual quantity of qBUs fits in uint192

uint192 amtBaskets = uint192( totalSupply() > 0 ? mulDiv256(basketsNeeded, amtRToken, totalSupply()) : amtRToken ); (address[] memory erc20s, uint256[] memory deposits) = basketHandler.quote( amtBaskets, CEIL );

31,518

183

// create dynamic array with 3 elements

address[] memory path = new address[](3); path[0] = _from; path[1] = WETH; path[2] = _to; Uniswap(UNISWAP).swapExactTokensForTokens( _amount, 1, path, address(this),

6,728

19

// Safe unsigned integer average Guard against (a+b) overflow by dividing each operand separatelya - first operand b - second operandreturn - the average of the two values /

function baverage(uint a, uint b) internal pure returns (uint) { // (a + b) / 2 can overflow, so we distribute return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2); }

137

46

// we log the new balance

emit LogBalance(address(this).balance, accounts["joint"], accounts["savings"]);

20,893

192

// return the _tokenId type' balance of _address _address Address to query balance of _tokenId type to query balance ofreturn Amount of objects of a given type ID /

function balanceOf(address _address, uint256 _tokenId) public view returns (uint256) { (uint256 bin, uint256 index) = _tokenId.getTokenBinIndex(); return packedTokenBalance[_address][bin].getValueInBin(index); }

82,940

1

// @inheritdoc IOniiChainDescriptor

function tokenURI(IOniiChain oniiChain, uint256 tokenId) external view override returns (string memory) { NFTDescriptor.SVGParams memory params = getSVGParams(oniiChain, tokenId); params.background = getBackgroundId(params); string memory image = Base64.encode(bytes(NFTDescriptor.generateSVGImage(params))); string memory name = NFTDescriptor.generateName(params, tokenId); string memory description = NFTDescriptor.generateDescription(params); string memory attributes = NFTDescriptor.generateAttributes(params); return string( abi.encodePacked( "data:application/json;base64,", Base64.encode( bytes( abi.encodePacked( '{"name":"', name, '", "description":"', description, '", "attributes":', attributes, ', "image": "', "data:image/svg+xml;base64,", image, '"}' ) ) ) ) ); }

33,828

330

// Note: Will only enter market if cToken is not enabled as a borrow asset as well

if (!borrowCTokenEnabled[_setToken][cToken]) { _setToken.invokeEnterMarkets(cToken, comptroller); }

29,289