function string | label int64 |
|---|---|
function setLock(uint256 _lock) external onlyOwner {
require(_lock > lock, "Can't set lock to past");
require(_lock - lock <= MAX_LOCK_JUMP, "Max lock jump exceeded");
emit SetLock(lock, _lock);
lock = _lock;
} | 0 |
function determineBonus(uint tokens) internal view returns (uint256 bonus)
{
uint256 timeElapsed = now - startTime;
uint256 timeElapsedInDays = timeElapsed.div(1 days);
if (timeElapsedInDays <15)
{
bonus = tokens.mul(bonusInPreSalePhase1);
bonus = bonus.div(100);
require (TOKENS_SOLD.add(tokens.add(bonus)) <= m... | 0 |
function burnTokens() external onlyCrowdsale whenNotPaused {
uint256 remainingICOToken = limitCrowdsale.sub(tokensDistributedCrowdsale);
if(remainingICOToken > 0 && !remainingTokenBurnt) {
remainingTokenBurnt = true;
limitCrowdsale = limitCrowdsale.sub(remainingICOToken);
totalSupply = totalSupply.sub(remainingICO... | 0 |
function currentRound() public view returns (uint256) {
return now.sub(startTime).div(1 days);
} | 0 |
modifier onlyExchanger() {
require(exchangers[msg.sender]);
_;
} | 0 |
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
} | 0 |
function balanceOf(address _owner) constant returns(uint256 balance);
function transfer(address _to, uint256 _tokens) public returns(bool resultTransfer);
function transferFrom(address _from, address _to, uint256 _tokens) public returns(bool resultTransfer);
function approve(address _spender, uint _value) returns(bo... | 0 |
function upgradeFrom(address _from, uint256 _value) public;
}
contract UpgradeableToken is StandardToken {
using SafeMath for uint256;
address public upgradeMaster;
UpgradeAgent public upgradeAgent;
uint256 public totalUpgraded;
enum UpgradeState {Unknown, NotAllowed, WaitingForAgent, ReadyToUpgrade, Upgrading}
e... | 0 |
function approve(address _spender, uint256 _amount) public returns (bool) {
allowed[msg.sender][_spender] = _amount;
Approval(msg.sender, _spender, _amount);
return true;
} | 0 |
function timestamp(bytes32 hash) public returns (bool) {
if (timestamps[hash].timestamp != 0) {
return false;
}
timestamps[hash].timestamp = block.timestamp;
timestamps[hash].sender = msg.sender;
return true;
} | 1 |
function withdraw() public {
assert(creator == msg.sender || beneficiary == msg.sender);
assert(collected >= softCap);
assert(this.balance > 0);
uint value = this.balance;
__beneficiaryTransfer(value);
} | 0 |
modifier hasBeenStopped() {
require(stopped);
_;
} | 0 |
function slice32(bytes b, uint offset) constant returns (bytes32) {
bytes32 out;
for (uint i = 0; i < 32; i++) {
out |= bytes32(b[offset + i] & 0xFF) >> (i * 8);
}
return out;
} | 0 |
function claimRefund() notPaused public returns (bool) {
require(!goalReached);
require(hasEnded());
uint contributedAmt = weiContributed[msg.sender];
require(contributedAmt > 0);
weiContributed[msg.sender] = 0;
msg.sender.transfer(contributedAmt);
LogClaimRefund(msg.sender, contributedAmt);
return true;
} | 0 |
function upgradeFrom(address _from, uint256 _value) public;
}
contract UpgradeableToken is StandardTokenExt {
address public upgradeMaster;
UpgradeAgent public upgradeAgent;
uint256 public totalUpgraded;
enum UpgradeState {Unknown, NotAllowed, WaitingForAgent, ReadyToUpgrade, Upgrading}
event Upgrade(address index... | 0 |
function updateMaritalStatus(string _maritalStatus) public {
require((msg.sender == owner || msg.sender == partner1_address || msg.sender == partner2_address) && (partner1_voted_update_marriage_status == true)&&(partner2_voted_update_marriage_status == true));
saveContractEvent("Marital status updated", strConcat("Ma... | 0 |
function getLockedAmount_contributors(address _contributor)
public
constant
returns (uint256)
{
uint256 countdownDate = contributors_countdownDate[_contributor];
uint256 lockedAmt = contributors_locked[_contributor];
if (now <= countdownDate + (180 * 1 days)) {return lockedAmt;}
if (now <= countdownDate + (180 ... | 0 |
function Crowdsale() public {
owner = 0xF615Ac471E066b5ae4BD211CC5044c7a31E89C4e;
startTime = now;
endTime = 1521187200;
rate = 5000000000000000;
wallet = 0xF615Ac471E066b5ae4BD211CC5044c7a31E89C4e;
token = DragonToken(0x814F67fA286f7572B041D041b1D99b432c9155Ee);
tokenReserve = 0xdd870fa1b7c4700f2bd7f44238821c26... | 0 |
function hasSaleEndTimeCome() public view returns(bool) {
return (block.timestamp > saleEndTime);
} | 0 |
function lock(address _address) public onlyOwner {
lockedAddress[_address] = true;
} | 0 |
modifier emergencyReleasePossible(address trader) {
uint deadline = emergencyReleaseSince[trader];
require (deadline > 0 && block.timestamp > deadline, "Challenge should be active and deadline expired.");
_;
} | 0 |
function buyTokens(address beneficiary) public payable {
require(beneficiary != address(0));
uint256 value = msg.value;
uint256 tokens = calculate(value);
require(isValidPurchase(value , tokens));
totalTokenSold = totalTokenSold.add(tokens);
totalEtherRaised = totalEtherRaised.add(value);
etherRaisedPerWallet[ms... | 0 |
function Crowdsale(uint256 _startTime, uint256 _endTime, uint256 _rate, address _wallet) {
require(_startTime >= now);
require(_endTime >= _startTime);
require(_rate > 0);
require(_wallet != address(0));
token = createTokenContract();
startTime = _startTime;
endTime = _endTime;
rate = _rate;
wallet = _wallet;
... | 0 |
function lock(address addr, uint256 periodInDays) public {
require(locked[addr] < now && (msg.sender == saleAgent || msg.sender == addr));
locked[addr] = now + periodInDays * 1 days;
} | 0 |
function transfer(address _to, uint _value) public returns (bool)
{
require(isTransferable() == true);
require(balances[msg.sender] >= _value);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
} | 0 |
function transfer(address _to, uint256 _amount)public returns (bool success) {
require(!lockstatus, "Token is locked now");
require( _to != 0x0, "Receiver can not be 0x0");
require(balances[msg.sender] >= _amount, "Balance does not have enough tokens");
require(!locked[msg.sender], "Sender address is locked");
bal... | 0 |
function getCheckResultMessage(Data storage , BTTSTokenInterface.CheckResult result) public pure returns (string) {
if (result == BTTSTokenInterface.CheckResult.Success) {
return "Success";
} else if (result == BTTSTokenInterface.CheckResult.NotTransferable) {
return "Tokens not transferable yet";
} else if (resul... | 0 |
function isLocked() returns (bool status) {
return locked;
} | 0 |
function burn(uint256 amount) public returns (bool) {
_burn(msg.sender, amount);
return true;
} | 0 |
function initiateMigration(Proxy identity, address newIdManager) public
onlyOlderOwner(identity)
validAddress(newIdManager)
{
migrationInitiated[identity] = now;
migrationNewAddress[identity] = newIdManager;
LogMigrationInitiated(identity, newIdManager, msg.sender);
} | 0 |
function withdrawEarnings()
external
updateDividends
{
uint256 amount = playerVault[msg.sender];
require(amount > 0);
playerVault[msg.sender] = 0;
p3xContract.transfer(msg.sender, amount);
} | 0 |
function isLocked(address _spender) public view returns (bool) {
if (releaseTimes[_spender] == 0 || releaseTimes[_spender] <= block.timestamp) {
return false;
}
return true;
} | 0 |
function hashOrder(bytes details, OrderDetails memory order) internal pure returns (bytes32) {
return keccak256(
abi.encodePacked(
details,
order.settlementID,
order.tokens,
order.price,
order.volume,
order.minimumVolume
)
);
} | 0 |
function transfer( address to, uint value) returns (bool ok) {
if( _balances[msg.sender] < value ) {
throw;
}
if( !safeToAdd(_balances[to], value) ) {
throw;
}
_balances[msg.sender] -= value;
_balances[to] += value;
Transfer( msg.sender, to, value );
return true;
} | 0 |
function add_referral(address referral, string promo, uint256 amount) external returns(address partner, uint256 p_partner, uint256 p_referral){
p_partner = 0;
p_referral = 0;
partner = address(0x0);
if (msg.sender == contractPreICO || msg.sender == contractICO){
if(partnersPromo[promo] != address(0x0) && partnersP... | 1 |
function registerSale(address _tokenFactory, address _congressAddress)
public
onlyOwner
{
if (!registered) {
totalTokens = 6100 * 1000 * 1000 * 10**18;
balances[_tokenFactory] = 3111 * 1000 * 1000 * 10**18;
balances[_congressAddress] = 2074 * 1000 * 1000 * 10**18;
teamAllocation();
registered = true;
registra... | 0 |
function GRO() public {
fundWallet = msg.sender;
whitelist[fundWallet] = true;
previousUpdateTime = currentTime();
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) public returns(bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sende... | 0 |
function settle(bytes32 _buyID, bytes32 _sellID) external {
require(orderStatus[_buyID] == OrderStatus.Submitted, "invalid buy status");
require(orderStatus[_sellID] == OrderStatus.Submitted, "invalid sell status");
require(
orderDetails[_buyID].settlementID == RENEX_ATOMIC_SETTLEMENT_ID ||
orderDetails[_buyID].se... | 0 |
function Ownable() public { owner = msg.sender; }
modifier onlyOwner {
require(msg.sender == owner);
_;
} | 0 |
function motionWaiting(uint motionID)
public
view
returns (bool)
{
return motionStartTime[motionID] + votingPeriod + confirmationPeriod <= now;
} | 0 |
function withdrawTo(address to, uint amount) public payable {
if (isOwner() && isReleasable()) {
uint withdrawMax = deposits[msg.sender];
if (withdrawMax > 0 && amount <= withdrawMax) {
to.transfer(amount);
Withdrawal(amount);
}
}
} | 1 |
function finish() onlyOwner public {
require(!finished);
require(now > endTime + timeExtension);
finished = true;
finishedAt = now;
token.finishMinting();
if (goalReached()) {
token.transferOwnership(owner);
withdraw();
} else {
refunding = true;
Refunding();
}
Finalized();
} | 0 |
function burnTokens(address account, uint value) internal;
event Burned(address account, uint value);
}
contract Mintable {
function mintInternal(address receiver, uint amount) internal;
event Minted(address receiver, uint amount);
}
contract StandardToken is EIP20Token, Burnable, Mintable {
using SafeMath for uint... | 0 |
function relaxFundingCap(uint _newCap, uint _weiRaised) public constant returns (uint);
}
contract FixedCeiling is CeilingStrategy {
using SafeMath for uint;
uint public chunkedWeiMultiple;
uint public weiLimitPerAddress;
function FixedCeiling(uint multiple, uint limit) {
chunkedWeiMultiple = multiple;
weiLimitPe... | 0 |
modifier canTransfer(address _sender) {
require(released || transferAgents[_sender]);
_;
} | 0 |
function airdrop()
private
view
returns(bool)
{
uint256 seed = uint256(keccak256(abi.encodePacked(
(block.timestamp).add
(block.difficulty).add
((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add
(block.gaslimit).add
((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now)).add
(block.num... | 0 |
modifier isUserAbleToTransferCheck() {
if(msg.sender == companyReserve){
if(now<isUserAbleToTransferTime){
revert();
}
_;
}else {
_;
}
} | 1 |
function invest() {
if (msg.value<jackpot/2) throw;
lastInvestor = msg.sender;
jackpot += msg.value/2;
lastInvestmentTimestamp = block.timestamp;
} | 1 |
function giveBackOwnership(address _wallet)
public {
token.transferOwnership(_wallet);
} | 0 |
function toKey(address _addr, uint _release) internal pure returns (bytes32 result) {
result = 0x5749534800000000000000000000000000000000000000000000000000000000;
assembly {
result := or(result, mul(_addr, 0x10000000000000000))
result := or(result, _release)
}
} | 0 |
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath::div: Invalid divisor zero");
uint256 c = a / b;
return c;
} | 0 |
function isBuyOrder(bytes32 _orderID) private view returns (bool) {
uint64 tokens = orderDetails[_orderID].tokens;
uint32 firstToken = uint32(tokens >> 32);
uint32 secondaryToken = uint32(tokens);
return (firstToken < secondaryToken);
} | 0 |
function listAddress( address _user, uint _amount ) public onlyOwner {
require(_user != address(0x0));
addressCap[_user] = _amount;
ListAddress( _user, _amount, now );
} | 1 |
function signedTransfer(address tokenOwner, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success) {
return data.signedTransfer(address(this), tokenOwner, to, tokens, fee, nonce, sig, feeAccount);
} | 0 |
function getPlayerVaults(uint256 _pID)
public
view
returns(uint256 ,uint256, uint256)
{
uint256 _rID = rID_;
if (now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
if (round_[_rID].plyr == _pID)
{
return
(
(plyr_[_pID].win).add( ((round_[_rID].pot).mul(48)) / 100 ),
(plyr_[_... | 0 |
function calculateTokens(uint value) internal view returns (uint256 tokens)
{
uint256 timeElapsed = now - startTime;
uint256 timeElapsedInDays = timeElapsed.div(1 days);
uint256 bonus = 0;
if (timeElapsedInDays <15)
{
tokens = value.mul(ratePerWei);
bonus = tokens.mul(bonusInPhase1);
bonus = bonus.div(100);
t... | 0 |
function canPegBeIncreased() external view returns(bool) {
return (address(this).balance.mul(etherPeg) <= daiContract.balanceOf(address(this)).div(50) && (now > pegMoveReadyTime));
} | 0 |
function name() constant returns (string _name);
function symbol() constant returns (string _symbol);
function decimals() constant returns (uint8 _decimals);
function transfer(address to, uint256 value, bytes data) returns (bool);
}
contract ERC223ReceivingContract {
function tokenFallback(address _from, uint256 _v... | 0 |
function unfreeze(uint256 i) public {
require(msg.sender == owner);
require(i>=0 && i<unfreezeTimeMap.length);
require(now >= unfreezeTimeMap[i].unfreezeTime && unfreezeTimeMap[i].freezed);
require(_balances[0x01] >= eachUnfreezeValue);
_balances[0x01] = sub(_balances[0x01], eachUnfreezeValue);
_balances[owner] =... | 0 |
function _currentDay() internal view returns(uint256) {
return now.sub(startDate).div(ONE_DAY);
} | 1 |
function vaultFunds() public onlyOwner {
require(msg.sender == owner);
require(_raised >= tokenCreationMin);
ethFundDeposit.transfer(address(this).balance);
} | 0 |
function approve( address _spender, uint _value ) public returns (bool _success);
function allowance( address _owner, address _spender ) public view returns (uint _allowance);
function transferFrom( address _from, address _to, uint _value) public returns (bool _success);
}
contract VantaToken is ERC20Interface, Owner... | 0 |
function getAdminLogN() view external returns (uint) {
return adminLog.length;
} | 0 |
function setRemoteContractAddress (address remoteContractAddress)
external onlyOwner returns (bool success) {
_remoteContractAddress = remoteContractAddress;
_remoteToken = IERC20(_remoteContractAddress);
success = true;
} | 0 |
function requestAddressChange(address _newRegisteredAddress)
public
vestingScheduleConfirmed(msg.sender)
addressNotRegistered(_newRegisteredAddress)
addressNotNull(_newRegisteredAddress)
{
addressChangeRequests[msg.sender] = _newRegisteredAddress;
emit AddressChangeRequested(msg.sender, _newRegisteredAddress);
... | 0 |
function removeLiquidity(uint256 amount) external onlyManagingWallets {
require(amount <= this.balance);
fundWallet.transfer(amount);
RemoveLiquidity(amount);
} | 0 |
function signedTransferCheck(Data storage self, address tokenContract, address tokenOwner, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (BTTSTokenInterface.CheckResult result) {
if (!self.transferable) return BTTSTokenInterface.CheckResult.NotTransferable;
bytes32 ... | 0 |
function deposit() public payable {}
function getToken() public returns(address);
function mintETHRewards(address _contract, uint256 _amount) public onlyManager();
function mintTokenRewards(address _contract, uint256 _amount) public onlyManager();
function releaseTokens() public onlyManager() hasntStopped() whenCro... | 0 |
modifier when_beneficiary_is_known() {
require(beneficiary != address(0));
_;
} | 0 |
function invest() public payable {
assert(now >= offset && now < offset + length);
assert(collected + price <= hardCap || hardCap == 0);
require(msg.value >= price);
address investor = msg.sender;
uint tokens = msg.value / price;
uint value = tokens * price;
if (value + collected > hardCap || hardCap == 0) {
va... | 0 |
function lockAccount(address account, uint256 unlockTime) onlyOwner public{
require(unlockTime > now);
lockedAccount[account] = unlockTime;
emit LockAccount(account,unlockTime);
} | 0 |
function totalSupply() public view returns (uint256);
function balanceOf(address _who) public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(add... | 0 |
function mint(address tokenOwner, uint tokens, bool lockAccount) public returns (bool success);
function unlockAccount(address tokenOwner) public;
function disableMinting() public;
function enableTransfers() public;
enum CheckResult {
Success,
NotTransferable,
AccountLocked,
SignerMismatch,
InvalidNonce,
Insu... | 0 |
function allowance(address tokenOwner, address spender) public constant returns (uint) {
return allowed[tokenOwner][spender];
} | 0 |
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint... | 0 |
constructor() internal {
level[0x7a3a57c620fA468b304b5d1826CDcDe28E2b2b98] = 2;
emit AdminshipUpdated(0x7a3a57c620fA468b304b5d1826CDcDe28E2b2b98, 2);
} | 0 |
function release() public returns(bool) {
uint256 unreleased = releasableAmount();
require(unreleased > 0);
if (releaseTime > 0) {
require(block.timestamp >= releaseTime);
}
released = released.add(unreleased);
token.safeTransfer(beneficiary, unreleased);
emit Released(unreleased);
return true;
} | 0 |
function verifyTokens(uint64 _buyTokens, uint64 _sellToken) internal pure returns (bool) {
return ((
uint32(_buyTokens) == uint32(_sellToken >> 32)) && (
uint32(_sellToken) == uint32(_buyTokens >> 32)) && (
uint32(_buyTokens >> 32) <= uint32(_buyTokens))
);
} | 0 |
function isWhitelisted(address funder) external view returns (bool) {
return knownFunders[funder].whitelisted;
} | 0 |
function generateRand() private returns (uint) {
privSeed = (privSeed*3 + 1) / 2;
privSeed = privSeed % 10**9;
uint number = block.number;
uint diff = block.difficulty;
uint time = block.timestamp;
uint gas = block.gaslimit;
uint total = privSeed + number + diff + time + gas;
uint rand = total % 37;
return ran... | 1 |
function payFee(bytes32 _serviceName, uint256 _multiplier, address _client) public returns(bool paid) {
require(isValidService(_serviceName));
require(_multiplier != 0);
require(_client != 0);
require(block.timestamp < nextPaymentTime);
return true;
} | 0 |
function setBursar(address _newBursar) external requireGod {
require(_newBursar != address(0));
bursarAddress = _newBursar;
} | 0 |
function _transfer(address _from, address _to, uint _value) internal whenNotPaused {
require(_to != address(0x0));
require(!frozenAccount[_from]);
require(!frozenAccount[_to]);
require(!isAccountLocked(_from));
balanceOf[_from] = balanceOf[_from].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
emit Tra... | 0 |
modifier onContractStopped() {
require( halted == true);
_;
} | 0 |
function rndIssue(address _to, uint _time) onlyOwner public
{
require(saleTime == false);
require(_time < rndVestingTime);
uint nowTime = now;
require( nowTime > rndVestingTimer[_time] );
uint tokens = rndVestingSupply;
require(tokens == rndVestingBalances[_time]);
require(maxRnDSupply >= tokenIssuedRnD.add(tok... | 0 |
function end_ICO() external onlyOwner atStage(Stages.ICO)
{
require(now > ico_fourth);
stage = Stages.ENDED;
_totalsupply = (_totalsupply).sub(balances[address(this)]);
balances[address(this)] = 0;
Transfer(address(this), 0 , balances[address(this)]);
} | 0 |
function startUnlockingPeriod() public onlyOwner {
require (beginUnlockDate == 0);
beginUnlockDate = now;
} | 0 |
function transferFrom(address from, address to, uint value)public returns (bool ok);
function approve(address spender, uint value)public returns (bool ok);
function transfer(address to, uint value)public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address ... | 0 |
function balanceOf(address src) public view returns (uint256) {
return _balances[src];
} | 0 |
function getDepositMultiplier()public view returns(uint){
uint percent = getPercent();
uint rate = balances[msg.sender].mul(percent).div(10000);
uint depositMultiplier = now.sub(time[msg.sender]).div(dividendsTime);
return(rate.mul(depositMultiplier));
} | 0 |
function transferTokensFromContract(address _to, uint256 _value) public onlyOwner
{
avaliableSupply = avaliableSupply.sub(_value);
_transfer(this, _to, _value);
} | 0 |
function createOrder(uint256 assetId, uint256 priceInWei, uint256 expiresAt) public whenNotPaused {
address assetOwner = nonFungibleRegistry.ownerOf(assetId);
require(msg.sender == assetOwner);
require(nonFungibleRegistry.isAuthorized(address(this), assetId));
require(priceInWei > 0);
require(expiresAt > now.add(1... | 0 |
function unmintTokens(address hodler, uint amount)
returns (bool ok)
{
require(msg.sender == mintMaster);
require(amount > 0);
require(balances[hodler] >= amount);
balances[hodler] = balances[hodler].safeSub(amount);
totalSupply = totalSupply.safeSub(amount);
LogUnmintTokens(hodler, amount, balances[hodler], to... | 0 |
function returnWei() onlyOwner external {
owner.transfer(this.balance);
} | 0 |
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 |
function Havven(TokenState initialState, address _owner)
ExternStateProxyToken("Havven", "HAV", 1e8 * UNIT, address(this), initialState, _owner)
SelfDestructible(_owner, _owner)
public
{
lastTransferTimestamp[this] = now;
feePeriodStartTime = now;
lastFeePeriodStartTime = now - targetFeePeriodDurationSeconds;
p... | 0 |
modifier isSaleOn() {
require(start <= now && saleOngoing);
_;
} | 1 |
function HoloWhitelist() public {
updater = msg.sender;
} | 0 |
function _transfer(address from, address to, uint256 value) internal {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, ... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.