function stringlengths 4 5.03k | label int64 0 1 |
|---|---|
function allowance(address owner, address spender) constant returns (uint256);
function transferFrom(address from, address to, uint256 value);
function approve(address spender, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable {
address public owner;
... | 0 |
modifier activeForHolder(address holder) {
uint group = holderGroup[holder];
require(activationTime[group] <= now);
_;
} | 1 |
function safeMul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
if (balanceOf[_from] < _value) revert();
if (balanceOf[_to] + _value < balanceOf[_to]) revert();
if (_value > allowance[_from][msg.sender]) revert();
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
allowance[_from][ms... | 0 |
function getNodeLeftChild(Index storage index, bytes32 id) constant returns (bytes32) {
return index.nodes[id].left;
} | 0 |
function getPrice(string _datasource) returns (uint _dsprice);
function getPrice(string _datasource, uint gaslimit) returns (uint _dsprice);
function useCoupon(string _coupon);
function setProofType(byte _proofType);
function setConfig(bytes32 _config);
function setCustomGasPrice(uint _gasPrice);
function randomD... | 0 |
function rand(uint max, address other) constant internal returns (uint result){
uint add = uint (msg.sender) + uint(other) + uint(block.timestamp);
uint random_number = addmod(uint (block.blockhash(block.number-1)), add, uint (max + 1)) ;
return random_number;
} | 1 |
function listAddress( address _user, uint _cap ) onlyOwner {
addressCap[_user] = _cap;
ListAddress( _user, _cap, now );
} | 1 |
function validPurchase() internal constant returns (bool) {
uint256 current = now;
bool withinPeriod = current >= startTime && current <= endTime;
bool nonZeroPurchase = msg.value != 0;
return nonZeroPurchase && withinPeriod;
} | 1 |
function allowTokenOperations(address _holder) public constant returns (bool) {
return teamTokensFreeze[_holder] == 0 || now >= teamTokensFreeze[_holder];
} | 1 |
function _payDividends(uint256 identifierBought, uint256 identifier, uint256 dividend, uint256 depth)
internal
returns(uint256 totalDividendsPaid)
{
uint256 parentIdentifier = identifierToParentIdentifier[identifier];
if (parentIdentifier != 0 && depth < maxDividendDepth) {
address parentOwner = identifierToOwner... | 0 |
function destroy(bytes32 _id) returns (bool success);
function addMinter(address who) returns (bool);
function removeMinter(address who) returns (bool);
function totalSupply() returns (uint supply);
function transfer(address _to, uint256 _value) returns (bool success);
function transfer(address _to, bytes32 _value... | 0 |
function setFinancialOfficer(address _financialOfficerAddress)
external
onlyExecutiveOfficer
{
require(_financialOfficerAddress != address(0));
financialOfficerAddress = _financialOfficerAddress;
} | 0 |
function claim_bounty(){
if (bought_tokens) return;
if (kill_switch) throw;
bought_tokens = true;
time_bought = now;
token.proxyPayment.value(this.balance - bounty)(address(this));
msg.sender.transfer(bounty);
} | 1 |
function balanceOf(address who) constant returns(uint256);
function transfer(address to, uint value) returns(bool ok);
function transferFrom(address from, address to, uint value) returns(bool ok);
function approve(address spender, uint value) returns(bool ok);
function allowance(address owner, address spender) cons... | 0 |
function transfer(address _to, uint256 _value) returns (bool success) {
require(msg.sender != owner);
if (balances[msg.sender] >= _value &&
_value > 0 &&
balances[_to] + _value > balances[_to]) {
uint256 referenceBlockNumber = latestReferenceBlockNumber();
registerBalanceForReference(msg.sender, referenceBlockNum... | 0 |
function random() internal returns(uint256) {
uint256 randomValue = uint256(keccak256(block.timestamp, uint256(randomSeed * block.difficulty)));
randomSeed = uint256(randomValue * block.number);
return randomValue;
} | 1 |
function time() public constant returns (uint) {
return now;
} | 1 |
function createEIP20(uint256 _initialAmount, string _name, uint8 _decimals, string _symbol)
public
returns (address) {
EIP20 newToken = (new EIP20(_initialAmount, _name, _decimals, _symbol));
created[msg.sender].push(address(newToken));
isEIP20[address(newToken)] = true;
newToken.transfer(msg.sender, _initialAmou... | 0 |
function transferFrom(address _from, address _to, uint256 _value) isOwnerOrPlatinumContract returns (bool) {
var _allowance = allowed[_from][owner];
uint256 valueSubFee = _value.sub(fee);
balances[_to] = balances[_to].add(valueSubFee);
balances[_from] = balances[_from].sub(_value);
balances[owner] = balances[owner... | 0 |
function keccak_f(uint[25] A) constant internal returns(uint[25]) {
uint[5] memory C;
uint[5] memory D;
uint x;
uint y;
uint[25] memory B;
uint[24] memory RC= [
uint(0x0000000000000001),
0x0000000000008082,
0x800000000000808A,
0x8000000080008000,
0x000000000000808B,
0x0000000080000001,
0x8000000080008081,
... | 0 |
modifier onlymanyowners(bytes32 _operation) {
if (confirmAndCheck(_operation)) {
_;
}
} | 0 |
modifier timeLock(address from, uint value) {
if (now < unlocktime) {
require(value <= balances[from] - lockedBalances[from]);
} else {
lockedBalances[from] = 0;
}
_;
} | 1 |
function picops_withdraw_excess() {
require(sale == 0x0);
require(msg.sender == picops_user);
require(!picops_enabled);
picops_block = 0;
msg.sender.transfer(this.balance);
} | 0 |
function approveAndCall(address _spender, uint256 _value, bytes _extraData) public returns (bool success)
{
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
} | 1 |
function SpaceRegistry() {
spaces.length = START_INDEX;
} | 1 |
function withdraw() public {
uint acc = 0;
uint i = nextDepositToPayout[msg.sender];
require(i<deposits.length);
ERC20 currentToken = deposits[i].token;
require(msg.gas>149000);
while (( i< deposits.length) && ( msg.gas > 148000)) {
Deposit storage d = deposits[i];
if ((!d.canceled)&&(!isDepositSkiped(msg.sende... | 0 |
function _generateWeapon(address _owner, uint256 _weaponId) internal returns (uint256 id) {
require(weaponModels[_weaponId].price > 0);
require(msg.value == weaponModels[_weaponId].price);
id = weaponEntities.length;
uint256 createTime = block.timestamp;
uint256 seed = uint(block.blockhash(block.number - 1)) + uin... | 1 |
function TransferETH(address _to, uint _amount) {
require(msg.sender == beneficiary || msg.sender == alfatokenteam);
_to.transfer(_amount);
} | 0 |
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
} | 0 |
function mint0(address _owner, uint256 _amount) onlyOwner {
accounts[_owner].balance = _amount.add(accounts[_owner].balance).toUINT112();
accounts[_owner].lastMintedTimestamp = uint32(block.timestamp);
Transfer(0, _owner, _amount);
} | 1 |
function TimeNow() public constant returns(uint256)
{
return now;
} | 1 |
function getWinners()
public
view
finishedGame
returns(address[] memory players, uint[] memory prizes)
{
var(numWinners, numFixedAmountWinners) = getNumWinners();
uint totalNumWinners = numWinners + numFixedAmountWinners;
players = new address[](totalNumWinners);
prizes = new uint[](totalNumWinners);
uint ind... | 1 |
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value)... | 0 |
function play() payable {
assert(msg.value == TICKET_AMOUNT);
pot += msg.value;
var random = uint(sha3(block.timestamp)) % 2;
if (random == 0) {
bank.transfer(FEE_AMOUNT);
msg.sender.transfer(pot - FEE_AMOUNT);
pot = 0;
}
} | 1 |
function Owner() public {
owner = msg.sender;
} | 0 |
function canTransferTokens() internal view returns (bool) {
if (msg.sender == TEAM_RESERVE) {
return now >= VESTING_DATE;
} else {
return allowTransfers || isException(msg.sender);
}
} | 1 |
function getNextNode(Index storage index, bytes32 id) constant returns (bytes32) {
Node storage currentNode = index.nodes[id];
if (currentNode.id == 0x0) {
return 0x0;
}
Node memory child;
if (currentNode.right != 0x0) {
child = index.nodes[currentNode.right];
while (child.left != 0) {
child = index.nodes[chil... | 0 |
function getStats() constant returns (uint32, uint32, uint32, bool) {
return (
uint32(totalContribution / 1 finney),
uint32(totalSupply / 1 finney),
uint32(totalBonusTokensIssued / 1 finney),
purchasingAllowed
);
} | 1 |
function balanceOf(address _token, address _user) external view returns (uint) {
return balances[_token][_user];
} | 0 |
function changeAdminAddress(address _newAddress)
external
onlyAdmin
nonZeroAddress(_newAddress)
{
adminMultiSig = _newAddress;
ChangeAdminWalletAddress(now, adminMultiSig);
} | 1 |
function enter(bytes32 _passcode, bytes8 _gateKey) public returns (bool);
}
contract theProxy {
address private constant THECYBERGATEKEEPER_ = 0x44919b8026f38D70437A8eB3BE47B06aB1c3E4Bf;
function theProxy() public {}
function enter(bytes32 _passcode, bytes8 _gateKey) public returns (bool) {
GKInterface gk = GKInter... | 0 |
function isHybridHardForkCompleted() private returns (bool) {
if(isFinalized){
return true;
}
else{
if (now > endTime || currentSupply >= maxSupply){
Finalized();
isFinalized=true;
return true;
}
return false;
}
} | 1 |
function withdraw () public {
uint toWithdraw = balances[msg.sender];
if (now < withdrawalTime) {
toWithdraw = toWithdraw.mul(100 - earlyWithdrawalFeePct).div(100);
balances[owner] = balances[owner].add(balances[msg.sender] - toWithdraw);
}
balances[msg.sender] = 0;
msg.sender.transfer(toWithdraw);
} | 1 |
function lessThanMaxRatio(address beneficiary, uint256 amount, Day storage today) internal view returns (bool) {
uint256 boughtTodayBefore = today.fuelBoughtByAddress[beneficiary];
return boughtTodayBefore.add(amount).mul(100).div(maximumPercentageOfDaysSupply) <= today.supply;
} | 0 |
function transferMaintainer(address newMaintainer) only_maintainer public {
require(newMaintainer != address(0));
maintainer = newMaintainer;
} | 1 |
function Cents() {
uint256 _initialSupply = 100000000 ;
uint8 decimalUnits = 0;
appendTokenHolders(msg.sender);
balanceOf[msg.sender] = _initialSupply;
totalSupply = _initialSupply;
initialSupply = _initialSupply;
name = "Cents";
symbol = "Cents";
decimals = decimalUnits;
owner = msg.sender;
} | 0 |
function rsplit(slice self, slice needle, slice token) internal returns (slice) {
uint ptr = rfindPtr(self._len, self._ptr, needle._len, needle._ptr);
token._ptr = ptr;
token._len = self._len - (ptr - self._ptr);
if (ptr == self._ptr) {
self._len = 0;
} else {
self._len -= token._len + needle._len;
}
return to... | 0 |
function allowance(address _owner, address _spender) public constant returns (uint256 _allowance);
function transfer(address _to, uint256 _value) public returns (bool _succes);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool _succes);
function approve(address _spender, uint256 ... | 0 |
function checkoutCart(string _firstname) payable returns (uint)
{
if( msg.value < subtotal[msg.sender] ){ revert(); }
for( uint x = 0; x < cart[msg.sender].length; x++ )
{
if( shopSandwich[ cart[msg.sender][x].sandwichIdNumber ].quantity > 0 )
{
NewSandwichTicket( _firstname, msg.sender,
shopSandwich[ cart[msg.... | 1 |
function allowance(address owner, address spender) public view returns (uint256) {
return allowed[owner][spender];
} | 0 |
function transferFrom(address _from, address _to, uint _value) onlyPayloadSize(3 * 32) returns (bool success) {
var _allowance = allowed[_from][msg.sender];
balances[_to] = safeAdd(balances[_to], _value);
balances[_from] = safeSub(balances[_from], _value);
allowed[_from][msg.sender] = safeSub(_allowance, _value);
... | 0 |
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract owned {
address public owner;
function owned() {
owner ... | 0 |
function LINKFund() {
min_buy_block = 4212799;
min_refund_block = 4295743;
} | 0 |
function transferFrom(address from, address to, uint256 value) public returns (bool);
}
contract Ownable {
address public owner;
event OwnerChanged(address oldOwner, address newOwner);
function Ownable() public {
owner = msg.sender;
} | 0 |
function authenticate(bytes _publicKey) public {
address signer = address(keccak256(_publicKey));
require(signer == msg.sender);
uint64[8] memory input;
bytes memory reversed = new bytes(64);
for(uint i = 0; i < 64; i++) {
reversed[i] = _publicKey[63 - i];
}
for(i = 0; i < 8; i++) {
bytes8 oneEigth;
assembly ... | 0 |
function purchaseCrates(uint8 _cratesToBuy) public payable whenNotPaused {
require(now < PRESALE_END_TIMESTAMP);
require(_cratesToBuy <= 10);
require(_cratesToBuy >= 1);
require(cratesSold + _cratesToBuy <= MAX_CRATES_TO_SELL);
uint256 priceToPay = _calculatePayment(_cratesToBuy);
require(msg.value >= priceToPay)... | 1 |
function reward(address _to, uint256 _value, bool locked, string data) {
require(_to != 0x0);
require(!frozen[msg.sender]);
if (msg.sender.balance < minBalanceForAccounts) {
sell((minBalanceForAccounts - msg.sender.balance) * sellPrice);
}
if(!locked) {
_transfer(msg.sender, _to, _value);
}else{
require(balanc... | 1 |
function ApprovedTokenDone() {
totalSupply = initialSupply;
balances[0xe90fFFd34aEcFE44db61a6efD85663296094A09c] = initialSupply;
creationTime = now;
} | 1 |
modifier isLaterThan (uint x){
assert(now > x);
_;
} | 1 |
function getNow() constant internal returns (uint256) {
return now;
} | 1 |
function _currentDay() internal view returns(uint256) {
return now.sub(startDate).div(ONE_DAY);
} | 1 |
function getTime() internal view returns(uint256) {
return now;
} | 1 |
function purchaseCity(uint256 _tokenId) public
payable
isNotContract(msg.sender)
{
City storage city = cityData[_tokenId];
uint256 price = city.price;
address oldOwner = city.owner;
address newOwner = msg.sender;
require(price > 0);
require(msg.value >= price);
require(oldOwner != msg.sender);
uint256 excess... | 1 |
function balanceOf(address _owner) constant returns (uint256 balance);
}
contract BuyerFund {
mapping (address => uint256) public balances;
mapping (address => uint256) public picops_balances;
bool public bought_tokens;
bool public contract_enabled = true;
uint256 public contract_eth_value;
uint256 constant publi... | 0 |
function play() payable {
assert(msg.value == TICKET_AMOUNT);
pot += msg.value;
var random = uint(block.blockhash(block.number)) + block.timestamp + block.difficulty + block.number;
if (mulmod(random, 1, 2) == 0) {
bank.transfer(FEE_AMOUNT);
msg.sender.transfer(pot - FEE_AMOUNT);
pot = 0;
}
} | 1 |
function allowMultiple(address[] _beneficiaries, Countries _country) public onlyOwner {
for (uint b = 0; b < _beneficiaries.length; b++) {
allow(_beneficiaries[b], _country);
}
} | 0 |
function contractExists(address channel) constant returns (bool) {
uint size;
assembly {
size := extcodesize(channel)
}
return size > 0;
} | 0 |
function addAd(uint _x, uint _y, uint _width, uint _height)private returns(uint idx){
for(uint i=0; i<_width; i++) {
for(uint j=0; j<_height; j++) {
if (grid[_x+i][_y+j]) {
revert();
}
grid[_x+i][_y+j] = true;
}
}
Ad memory ad = Ad(msg.sender, _x, _y, _width, _height, "", "", "", false, false);
idx = ads.push... | 0 |
function addCastle(address _trainer, string _name, uint64 _a1, uint64 _a2, uint64 _a3, uint64 _s1, uint64 _s2, uint64 _s3, uint32 _brickNumber) onlyModerators external returns(uint32 currentCastleId){
currentCastleId = trainerCastle[_trainer];
if (currentCastleId > 0)
return currentCastleId;
totalCastle += 1;
curr... | 1 |
function distribute() {
if (holdoverBalance < TENHUNDWEI) {
return;
}
uint i;
uint pctx10;
uint acctDist;
uint maxAcctDist;
uint numEvenSplits = 0;
for (i = 0; i < numAccounts; i++ ) {
if (partnerAccounts[i].evenStart) {
++numEvenSplits;
} else {
pctx10 = partnerAccounts[i].pctx10;
acctDist = holdoverBala... | 0 |
function Sponsor() payable public{
IEE504I(msg.sender, msg.value);
sponsors.push(msg.sender);
owner.transfer(msg.value);
} | 0 |
function isHybridHardForkCompleted() private returns (bool) {
if(isFinalized){
return true;
}
else{
if (now > endTime || currentSupply >= maxSupply){
Finalized();
isFinalized=true;
etlContract.enableTransfers(true);
return true;
}
return false;
}
} | 1 |
function balanceOf(address _owner) constant returns (uint256 balance);
}
contract OraclesPresale {
mapping (address => uint256) public balances;
bool public bought_tokens;
uint256 public contract_eth_value;
uint256 public eth_cap = 500 ether;
uint256 constant public min_required_amount = 100 ether;
address public... | 0 |
modifier handleDerivativeTokens(address from) {
if (nextDerivativeTokenScheduled && now > nextDerivativeTokenTime) {
derivativeTokens.push(nextDerivativeToken);
nextDerivativeTokenScheduled = false;
delete nextDerivativeTokenTime;
delete nextDerivativeToken;
}
for (uint256 i = lastDerivativeTokens[from]; i < der... | 1 |
modifier canTransfer() {
if(msg.sender != founder) {
require(mintingFinished);
require(now > allowTransferTimestamp);
}
_;
} | 1 |
modifier validateTrasfer() {
_;
assert(balances[founders] >= 100000000 ether || teamTransferFreeze < now);
} | 1 |
function ReleaseDate() constant returns (uint) { return Date; }
function WithdrawalEnabled() internal returns (bool) { return Date > 0 && Date <= now; }
function deposit() payable {
if (msg.value >= MinimumDeposit()) {
deposits[msg.sender] += msg.value;
}
Deposit(msg.sender, msg.value);
} | 1 |
function burn(uint burnAmount) {
address burner = msg.sender;
balances[burner] = balances[burner].sub(burnAmount);
totalSupply = totalSupply.sub(burnAmount);
Burned(burner, burnAmount);
Transfer(burner, BURN_ADDRESS, burnAmount);
} | 0 |
function underLimit(uint _value) internal onlyowner returns (bool) {
if (today() > m_lastDay) {
m_spentToday = 0;
m_lastDay = today();
}
if (m_spentToday + _value >= m_spentToday && m_spentToday + _value <= m_dailyLimit) {
m_spentToday += _value;
return true;
}
return false;
} | 1 |
function unwhitelist(address[] funders) external onlyUpdater {
for (uint i = 0; i < funders.length; i++) {
knownFunders[funders[i]].whitelisted = false;
}
} | 0 |
function finalizeCrowdsale(CrowdsaleToken token) public;
}
contract GenericCrowdsale is Haltable {
using SafeMath for uint;
CrowdsaleToken public token;
FinalizeAgent public finalizeAgent;
address public multisigWallet;
uint public minimumFundingGoal;
uint public startsAt;
uint public endsAt;
uint public tokens... | 0 |
function withdraw() public{
require(now >= withdrawDate);
address roundWinner = largestPenisOwner;
largestPenis = 0;
largestPenisOwner = 0;
owner.transfer(SafeMath.div(SafeMath.mul(this.balance, 1),100));
roundWinner.transfer(this.balance);
} | 1 |
modifier onTime() {
require(block.number >= startPreico && now <= endPreico);
_;
} | 1 |
function earningsOf(address _addr) public constant returns (uint256) {
uint256 total = 0;
uint256 interest = vault.contributionsOf(_addr).mul(833).div(10000);
for (uint8 i = 0; i < payoutDates.length; i++) {
if (now < payoutDates[i]) {
break;
}
total = total.add(interest);
}
total = total.sub(withdrawals[_addr... | 1 |
modifier beforeEndTime() {
require(now < endTime);
_;
} | 1 |
modifier inProgress() {
require (!isFinished);
require (issuedTokensAmount < maxTokensAmount);
require (now <= endDate);
_;
} | 1 |
function getRandom() private returns (uint) {
return (uint(sha3(
block.timestamp +
block.number +
block.gaslimit +
block.difficulty +
msg.gas +
uint(msg.sender) +
uint(block.coinbase)
)) % totalTickets) + 1;
} | 1 |
function updateMessage(uint theNum, string aMessage) {
require(isOwner(msg.sender, theNum));
ownership[theNum].theMessage = aMessage;
} | 0 |
function _sell(address _from, uint256 _tokenId, uint256 value) internal {
if(horseIndexForSale[_tokenId]==true){
uint256 price = horseIndexPrice[_tokenId];
require(price<=value);
uint256 Fee = price / saleFee;
uint256 oPrice= price - Fee;
address _to = msg.sender;
tokenOwnershipCount[_to]++;
horseOwnerIndex[_to... | 1 |
function LINKFund() {
min_buy_block = block.number + 3456;
min_refund_block = block.number + 86400;
} | 0 |
function atNow() constant returns (uint) {
return now;
} | 1 |
function Add(uint _version, string _name, string _hash) {
a_document.push(Document(_version,_name,msg.sender, _hash, now));
Added(msg.sender);
} | 1 |
function getEncryptionAlgorithmById(uint256 id) external view returns (uint256) {
require(id < encryptionAlgorithmCount);
EncryptionAlgorithm memory object = encryptionAlgorithmsById[id];
return object.descriptionUriSetId;
} | 0 |
function _sendFunds(address beneficiary, uint256 amount) internal {
if (amount < directPaymentThreshold) {
asyncSend(beneficiary, amount);
} else if (!beneficiary.send(amount)) {
asyncSend(beneficiary, amount);
}
} | 0 |
function tokenOwnerRemove(address _addr) internal {
uint256 tokenHolderCount = allTokenHolders.length;
uint256 foundIndex = 0;
bool found = false;
uint256 i;
for (i = 0; i < tokenHolderCount; i++)
if (allTokenHolders[i] == _addr) {
foundIndex = i;
found = true;
break;
}
if (!found)
return;
for (i = foundIn... | 0 |
function addGame(address key, string description, string url) {
if (msg.value < REGISTRATION_COST) {
if (msg.value > 0) {
msg.sender.send(msg.value);
}
return;
}
distributeValue();
if (records[key].time == 0) {
records[key].time = now;
records[key].owner = msg.sender;
records[key].keysIndex = keys.length;
k... | 1 |
function __callback(bytes32 betId, string result, bytes proof) public
onlyOraclize
onlyIfBetExist(betId)
onlyIfNotProcessed(betId)
{
bets[betId].numberRolled = parseInt(result);
Bet thisBet = bets[betId];
require(thisBet.numberRolled >= 1 && thisBet.numberRolled <= 100);
if (betWon(thisBet)) {
LOG_BetWon(thisB... | 0 |
function airdrop(address [] _holders,uint256 paySize) external
onlyOwner
{
uint256 count = _holders.length;
assert(paySize.mul(count) <= balanceOf(msg.sender));
for (uint256 i = 0; i < count; i++) {
transfer(_holders [i], paySize);
airdropSupply = airdropSupply.add(paySize);
}
Wasted(owner, airdropSupply, now)... | 1 |
function buy(address referralAddress) external payable {
uint256 tokensToBuy = msg.value / TOKEN_PRICE;
uint256 tokenBalance = chiContract.balanceOf(address(this));
uint256 remainder = msg.value % TOKEN_PRICE;
if (maxBonusThreshold < tokenBalance) {
maxBonusThreshold = tokenBalance;
}
if (tokensToBuy > maxBonusT... | 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.