function string | label int64 |
|---|---|
function transferOwnershipImmediately(Data storage self, address newOwner) public {
require(msg.sender == self.owner);
OwnershipTransferred(self.owner, newOwner);
self.owner = newOwner;
self.newOwner = address(0);
} | 0 |
constructor(address _teamAdvisorsReserveTokensAddress) public {
require(_teamAdvisorsReserveTokensAddress != address(0));
teamAdvisorsReserveTokensAddress = _teamAdvisorsReserveTokensAddress;
uint256 teamAdvisorsReserveTokens = 1564265000;
createTokens(teamAdvisorsReserveTokens, teamAdvisorsReserveTokensAddress);
... | 0 |
function changeOwner (address newOwner) public onlyOwner {
owner = newOwner;
} | 0 |
function endGameInternal() private {
gameOpponent = address(0);
gameTime = 0;
status = 0;
} | 0 |
function receiveApproval(address from, uint256 _amount, address _token, bytes _data) public;
}
contract ExtendedERC20 is StandardToken {
function increaseApproval(address _spender, uint256 _addedValue) onlyPayloadSize(2) public returns (bool) {
allowed[msg.sender][_spender] = safeAdd(allowed[msg.sender][_spender], _a... | 0 |
function setUpgradeAgent(address agent) external {
if(!canUpgrade()) {
throw;
}
if (agent == 0x0) throw;
if (msg.sender != upgradeMaster) throw;
if (getUpgradeState() == UpgradeState.Upgrading) throw;
upgradeAgent = UpgradeAgent(agent);
if(!upgradeAgent.isUpgradeAgent()) throw;
if (upgradeAgent.originalSupply(... | 0 |
function migrateFrom(address _from, uint256 _value);
}
contract ZeusShieldCoin is owned, ERC20Interface {
string public constant standard = 'ERC20';
string public constant name = 'Zeus Shield Coin';
string public constant symbol = 'ZSC';
uint8 public constant decimals = 18;
uint public registrationTime = 0;
bool ... | 0 |
function _prand(uint _modulo) private view returns (uint) {
require((1 < _modulo) && (_modulo <= 10000));
uint seed1 = uint(block.coinbase);
uint seed2 = now;
return uint(keccak256(seed1, seed2)) % _modulo;
} | 1 |
function upgradeMe(address newSC) only_editors() external {
editAllowed[msg.sender] = false;
editAllowed[newSC] = true;
emit SelfUpgrade(msg.sender, newSC);
} | 0 |
function _setAdmin(address a, bool _givePerms) internal {
admins[currAdminEpoch][a] = _givePerms;
if (_givePerms) {
emit AdminAdded(a);
adminLog.push(a);
} else {
emit AdminRemoved(a);
}
} | 0 |
modifier whenNotPaused() {
require(now > pauseEnd);
_;
} | 0 |
function getBonus() constant returns (uint) {
assert(now > start);
assert(now < end);
uint week = (now - start) / period;
uint8 foundBonus = bonuses[week];
if (foundBonus != 0) {
return foundBonus;
} else {
return 5;
}
} | 0 |
function transfer(address _to, uint _value) public returns (bool success) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
} | 0 |
function _getTokenAmount(uint256 _weiAmount) internal view returns (uint256) {
return _weiAmount.mul(tokenExchangeRate);
} | 0 |
function kill() isCreator public {
selfdestruct(owner);
} | 1 |
modifier onlySufficientAmount(string poolId, uint256 amount) {
require(amount <= pools[poolId].availableAmount);
_;
} | 0 |
function DXF_Tokens()
{
admin = msg.sender;
startingDateFunding=now;
multisigDXF=0x7a992f486fbc7C03a3f2f862Ad260f158C5c5486;
members.push(Member(0,0,0));
} | 0 |
constructor()
ERC20Burnable() ERC20Pausable() ERC20() Ownable() ERC20Detailed("Pokersoon JQK Token", "JQK", 18)
public {
_mint(msg.sender, 100000000000000000000000000);
nextminttime = now + 14 * 365 days;
} | 0 |
function makeRandomResult(uint256 guessType, uint256 period, uint256 seed, uint256 maxNumber) onlyMaster
public returns (bool) {
require(guessType > 0);
require(period > 0);
require(seed >= 0);
require(maxNumber > 0);
require(results[guessType][period] <= 0);
require(maxNumber <= 1000000);
uint256 random = uint... | 0 |
function purchase(address _sender, uint256 _value, uint256 _price) public returns (uint256);
function sell(address _from, uint256 _price, uint256 _amountBabz);
function powerBalanceOf(address _owner) constant returns (uint256);
function outstandingPower() constant returns (uint256);
function authorizedPower() const... | 0 |
function cancelAuction(uint _auctionId) external {
require(auctions[_auctionId].exists);
require(!auctions[_auctionId].executed);
require(msg.sender == auctions[_auctionId].owner);
require(now > auctions[_auctionId].executeTime);
require(ERC721Interface(auctions[_auctionId].token).transfer(auctions[_auctionId].own... | 0 |
function approve(address spender, uint value) public returns (bool ok);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract FractionalERC20 is ERC20 {
uint8 public decimals;
}
contract BasicToken is ERC20Basic {
using SafeMath for uint;
mapping(address => uint) balances;
function... | 0 |
function activateAccount(address addr) internal {
if (!accountActive[addr]) {
accountActive[addr] = true;
accountIndex.push(addr);
}
} | 0 |
function privateSaleIssue(address _to) onlyOwner public
{
require(tokenIssuedSale == 0);
uint tokens = privateSaleSupply;
balances[_to] = balances[_to].add(tokens);
totalTokenSupply = totalTokenSupply.add(tokens);
tokenIssuedSale = tokenIssuedSale.add(tokens);
emit SaleIssue(_to, tokens);
} | 0 |
function refund(address investor) {
require(state == State.Refunding);
uint256 depositedValue = deposited[investor];
deposited[investor] = 0;
investor.transfer(depositedValue);
Refunded(investor, depositedValue);
} | 0 |
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(address owner, address spender) public view returns (uint256)... | 0 |
function publish(bytes32 hashed_val) {
if (hash_db[hashed_val].publisher != address(0)) {
throw;
}
hash_db[hashed_val].publisher = msg.sender;
hash_db[hashed_val].stake = msg.sender.balance;
hash_db[hashed_val].burned = msg.value;
hash_db[hashed_val].timestamp = now;
} | 1 |
function sendVesting(uint _id) returns(bool) {
require(now >= (vestings[_id].schedule + vestings[_id].paymentInterval * (vestings[_id].sendings + 1)));
require(vestings[_id].ERC20.transfer(vestings[_id].receiver, vestings[_id].amount));
VestingSent(vestings[_id].receiver, vestings[_id].ERC20, vestings[_id].amount, _... | 0 |
function mintInternal(address receiver, uint amount) internal {
total_supply = total_supply.add(amount);
balances[receiver] = balances[receiver].add(amount);
Minted(receiver, amount);
Transfer(0, receiver, amount);
} | 0 |
function transfer(address _to, uint256 _value) returns (bool success);
function transfer(address _to, bytes32 _value) returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
function transferFrom(address _from, address _to, bytes32 _value) returns (bool succe... | 0 |
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner {
require(block.timestamp <= PRICE_CHANGE_ENDING_TIME);
sellPrice = newSellPrice;
buyPrice = newBuyPrice;
} | 0 |
function canWithdraw() public view returns (bool) {
return totalWeiReceived >= minCapWei || now > refundDeadlineTime;
} | 0 |
function inProgress() public view returns (bool);
function yes(address _address, uint _votes) public;
function no(address _address, uint _votes) public;
function vote(address _address) public view returns (int);
function votesTotal() public view returns (uint);
function isSubjectApproved() public view returns (boo... | 0 |
function endSale() onlyOwner public
{
require(saleTime == true);
require(maxSaleSupply == tokenIssuedSale);
saleTime = false;
uint nowTime = now;
endSaleTime = nowTime;
teamVestingTime = endSaleTime + teamVestingLockDate;
for(uint i = 0; i < rndVestingTime; i++)
{
rndVestingTimer[i] = endSaleTime + (month * i... | 0 |
function getLockedAmount_investors(address _investor)
public
constant
returns (uint256)
{
uint256 delieveryDate = investors_deliveryDate[_investor];
uint256 lockedAmt = investors_locked[_investor];
if (now <= delieveryDate) {return lockedAmt;}
if (now <= delieveryDate + 90 days) {return lockedAmt;}
return 0;
... | 0 |
function getMyEggs() public view returns(uint256){
return SafeMath.add(claimedEggs[msg.sender], getEggsSinceLastHatch(msg.sender));
} | 0 |
function tokensale(address recipient) public payable {
require(recipient != 0x0);
if (now < pre_endTime) {
ico_stage = STAGE_PRE_ICO;
} else {
ico_stage = STAGE_MAIN_ICO;
}
if ( fundRaised >= _presaleSupply ) {
ico_stage = STAGE_MAIN_ICO;
}
uint256 weiAmount = msg.value;
uint tokens = weiAmount.mul(getPrice(... | 1 |
function assignOwnership(address newOwner) external onlyOwner {
require(newOwner != 0x0, "Address can not be 0x0");
balances[newOwner] = (balances[newOwner]).add(balances[owner]);
balances[owner] = 0;
owner = newOwner;
emit Transfer(msg.sender, newOwner, balances[newOwner]);
} | 0 |
function upgradeFrom(address _from, uint _value) public;
}
contract UpgradeableToken is StandardToken {
address public upgradeMaster;
UpgradeAgent public upgradeAgent;
uint public totalUpgraded;
enum UpgradeState {Unknown, NotAllowed, WaitingForAgent, ReadyToUpgrade, Upgrading}
event Upgrade(address indexed _from,... | 0 |
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 indexed owner, address indexed spender, uint value);
}
contract BeefLedger is ERC20, S... | 0 |
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 |
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract Kryptos {
bool public transferactive;
bool public shareactive;
bool public coinsaleactive;
string public name;
string public symbol;
uint256 public buyPrice;
uint8 public decima... | 0 |
function refund(bytes32 _swapID) external onlyOpenSwaps(_swapID) onlyExpirableSwaps(_swapID) {
Swap memory swap = swaps[_swapID];
swapStates[_swapID] = States.EXPIRED;
swap.ethTrader.transfer(swap.value);
emit LogExpire(_swapID);
} | 0 |
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 signedApproveCheck(address tokenOwner, address spender, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result) {
return data.signedApproveCheck(address(this), tokenOwner, spender, tokens, fee, nonce, sig, feeAccount);
} | 0 |
function tokenPrice() returns (uint256);
}
contract DaoAccount
{
address public daoChallenge;
address public challengeOwner;
uint256 tokenBalance;
address owner;
modifier noEther() {if (msg.value > 0) throw; _}
modifier onlyOwner() {if (owner != msg.sender) throw; _}
modifier onlyDaoChallenge() {if (daoChallenge... | 0 |
function calculateExcessBalance() internal whenNotPaused returns(uint256) {
uint256 amountPaid = msg.value;
uint256 differenceWei = 0;
uint256 exceedingBalance = 0;
if(tokensRaised >= limitTier3) {
uint256 addedTokens = tokensRaised.add(amountPaid.mul(rateTier4));
if(addedTokens > maxTokensRaised) {
uint256 diff... | 0 |
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);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(addre... | 0 |
modifier whenSaleIsOpen() {
require(now >= startTimestamp && now < endTimestamp);
_;
} | 0 |
function random(uint256 upper) public returns (uint256 randomNumber) {
return maxRandom() % upper;
} | 0 |
function safeDiv(uint a, uint b) pure internal returns (uint) {
assert(b > 0);
uint c = a / b;
assert(a == b * c + a % b);
return c;
} | 0 |
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract LockableToken is ERC20 {
function addToTimeLockedList(address addr) external returns (bool);
}
contract VinToken is Contactable {
using SafeMath for uint;
... | 0 |
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 BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) public balances;
... | 0 |
function upgradeFrom(address _from, uint256 _value) public;
}
contract UpgradeableToken is StandardToken {
address public upgradeMaster;
UpgradeAgent public upgradeAgent;
uint256 public totalUpgraded;
enum UpgradeState {Unknown, NotAllowed, WaitingForAgent, ReadyToUpgrade, Upgrading}
event Upgrade(address indexed ... | 0 |
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);
}
contract TokenTimelock {
ERC20 public token;
address public beneficiary;
uin... | 0 |
function changeAirAmount(uint256 newAirAmount) public onlyOwner {
airAmount = newAirAmount;
} | 0 |
function min64(uint64 a, uint64 b) internal pure returns (uint64) {
return a < b ? a : b;
} | 0 |
function _transfer(address _to, uint256 _value, bytes _data, string _custom_fallback) private returns (bool success) {
if (isContract(_to)) {
if (balanceOf(msg.sender) < _value) revert("Insuficient funds");
balances[msg.sender] = balanceOf(msg.sender).sub(_value);
balances[_to] = balanceOf(_to).add(_value);
assert... | 0 |
function _processPurchase(address _beneficiary, uint256 _tokenAmount) internal {
_deliverTokens(_beneficiary, _tokenAmount);
} | 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 totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, ... | 0 |
function _holdAgeTimestamp(address owner) internal view returns (uint256 holdAgeTimestamp) {
require(_transferIns[owner].amountInVault > 0,
"You haven't sent any tokens to stake, so there is no stake age to return.");
uint256 _lengthOfHoldTimestamp = (block.timestamp - _transferIns[owner].tokenTimestamp);
holdAgeT... | 0 |
function transfer(address _to, uint256 _value) onlyPayloadSize(2 * 32) onlyIfTransfersAllowed {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
} | 0 |
function transfer(address to, uint tokencount) public returns (bool success);
function approve(address spender, uint tokencount) public returns (bool success);
function transferFrom(address from, address to, uint tokencount) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint... | 0 |
function setTreasuryBalance(uint256 amount) onlyOwnerUnlocked {
treasuryBalance = amount;
} | 0 |
function ShrimpFarmer() public{
ceoAddress=msg.sender;
} | 0 |
function Wolk()
{
if ( msg.sender != owner ) throw;
start_block = 3835853;
end_block = 3836353;
balances[owner] = wolkFund;
reservedTokens = 25 * 10**decimals;
allocations[0x564a3f7d98Eb5B1791132F8875fef582d528d5Cf] = 20;
allocations[0x7f512CCFEF05F651A70Fa322Ce27F4ad79b74ffe] = 1;
allocations[0x9D203A36cd61b2... | 0 |
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
assert(token.transfer(to, value));
} | 0 |
function unpause() public whenPaused onlyMaster {
paused = false;
} | 0 |
function revoke() public onlyOwner returns(bool) {
require(revocable);
require(!revoked);
uint256 balance = token.balanceOf(this);
uint256 unreleased = releasableAmount();
uint256 refund = balance.sub(unreleased);
revoked = true;
token.safeTransfer(owner, refund);
emit Revoked();
return true;
} | 0 |
function airdrop(address to, uint256 animalId) external contractIsActive {
require(now <= airdropEndTimestamp, "airdrop ended");
donateDna(to, animalId, AIRDROP_EFFECTIVENESS);
emit NewAirdrop(to, animalId);
} | 0 |
function approve(address spender, uint256 value) external returns (bool) {
_allowed[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
} | 0 |
function setApTime(uint _time) onlyOwner public
{
require(tokenLock == true);
require(saleTime == true);
apLock_1 = _time;
apLock_2 = _time.add(month);
apLock_3 = apLock_2.add(month);
} | 0 |
function setLockup_contributors(address _contributor, uint256 _value, uint256 _countdownDate)
public
onlyOwner
{
require(_contributor != address(0));
contributors_locked[_contributor] = _value;
contributors_countdownDate[_contributor] = _countdownDate;
UpdatedLockingState("contributor", _contributor, _value, _co... | 0 |
modifier noEther() {if (msg.value > 0) throw; _}
modifier onlyChallengeOwner() {if (challengeOwner != msg.sender) throw; _}
function DaoChallenge () {
challengeOwner = msg.sender;
} | 0 |
function timeUntilNextDividendFetching()
external
view
returns(uint256)
{
uint256 difference = now.sub(lastDividendsFetched);
return difference > DIVIDEND_FETCH_TIME ? 0 : DIVIDEND_FETCH_TIME.sub(difference);
} | 0 |
function setpricefactor(uint256 newPricefactor) external onlyOwner
{
priceFactor = newPricefactor;
} | 0 |
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a ... | 0 |
function getBackToken(uint256 _id) public returns (bool) {
require(started);
require(_id > 0 && _id <= cap);
require(!lottery.gameOver());
require(!lottery.gameOverByUser());
require(now > stopTime);
require(holderList[_id] == msg.sender);
holderList[_id] = 0x0;
priceList[_id] = 0;
assert(lottery.changeHolder(... | 0 |
function vestCmd1YearInstantInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, 0, lock365Days, lock365Days);
} | 0 |
function transfer(address _to, uint256 _value)
whenNotPaused limitForOwner public returns (bool success)
{
return super.transfer(_to, _value);
} | 0 |
function allowance(address owner, address spender) constant returns (uint256);
function transferFrom(address from, address to, uint256 value) returns (bool);
function approve(address spender, uint256 value) returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeM... | 0 |
function upgradeFrom(address _from, uint256 _value) public;
}
library SafeMathLib {
function times(uint a, uint b) returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
} | 0 |
function transferInvestorTokens(InvestorToken token, address to, uint256 amount) external onlyRole(ROLE_TRANSFER_INVESTOR_TOKENS) {
token.transferInvestorTokens(to, amount);
TransferredInvestorTokens(msg.sender, token, to, amount);
} | 0 |
function setMaxAuditDuration(uint _days) external onlyOwner {
maxAuditDuration = _days * 1 days;
} | 0 |
function getAuthorizedAddresses()
external
view
returns (address[] memory);
}
contract IAssetProxy is
IAuthorizable
{
function transferFrom(
bytes assetData,
address from,
address to,
uint256 amount
)
external;
function getProxyId()
external
pure
returns (bytes4);
}
contract IValidator {
function isVali... | 0 |
modifier spendControl(address currency, uint256 amount) {
assert(Oversight(oversightAddress).validate(currency, amount));
_
} | 0 |
function transferFrom(address _from, address _to, uint256 _value)
whenNotPaused limitForOwner public returns (bool success)
{
return super.transferFrom(_from, _to, _value);
} | 0 |
function viewRand() public view returns(uint256) {
return randToAddress[msg.sender];
} | 0 |
function getResult(uint256 guessType, uint256 period)
public view returns (uint256){
require(guessType > 0);
require(period > 0);
require(results[guessType][period] > 0);
return results[guessType][period];
} | 0 |
function transfer(address _to, uint _value) public returns (bool success);
function transferFrom(address _from, address _to, uint _value) public returns (bool success);
function approve(address _spender, uint _value) public returns (bool success);
}
contract StreamityEscrow is Ownable, ReentrancyGuard {
using SafeMa... | 0 |
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(address _owner, address _spender)
public view returns (ui... | 0 |
function getUpgradeState() public view returns(UpgradeState) {
if (!canUpgrade()) return UpgradeState.NotAllowed;
else if (address(upgradeAgent) == 0x00) return UpgradeState.WaitingForAgent;
else if (totalUpgraded == 0) return UpgradeState.ReadyToUpgrade;
else return UpgradeState.Upgrading;
} | 0 |
function mul(uint256 a, uint256 b) internal pure returns(uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
} | 0 |
function getRate() public view returns (uint256) {
if (now <= preICO.date)
return preICO.rate;
if (now < icoEndOfStageA.date)
return icoStarts.rate;
if (now < icoEndOfStageB.date)
return icoEndOfStageA.rate;
if (now < icoEnds.date)
return icoEndOfStageB.rate;
return icoEnds.rate;
} | 0 |
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
}
contract PhotochainVesting {
ERC20 public token;
address public beneficiary;
uint256 public releaseTime;
constructor(ERC20 _token, address _beneficiary, ui... | 0 |
function StreamityContract() public TokenERC20(130000000, "Streamity", "STM") {}
function () public payable
{
assert(msg.value >= 1 ether / 10);
require(now >= ICO.startDate);
if (now >= ICO.endDate) {
pauseInternal();
emit CrowdSaleFinished(crowdSaleStatus());
}
if (0 != startIcoDate) {
if (now < startIcoDat... | 0 |
function authorized_updateSaleInfo(uint256 _cardId, uint256 _sentValue) external requireAuthorizedLogicContract {
cardIdToSaleInfo[_cardId] = SaleInfo(uint128(now), uint128(_sentValue));
} | 0 |
modifier onlyOwner() {
require(msg.sender == owner);
_;
} | 0 |
function AlgoryToken() UpgradeableToken(msg.sender) {
owner = msg.sender;
totalSupply = INITIAL_SUPPLY;
balances[owner] = totalSupply;
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.