├── README.md └── SourceCode ├── 1World(1WO)_0xfdbc1adc26f0f8f8606a5d63b7d3a3cd21c22b23.sol ├── 300Token(300)_0xaec98a708810414878c3bcdf46aad31ded4a4557.sol ├── ACE(ACE)_0x06147110022b768ba8f99a8f385df11a151a9cc8.sol ├── AION(AION)_0x4CEdA7906a5Ed2179785Cd3A40A69ee8bc99C466.sol ├── ATLANT(ATL)_0x78b7fada55a64dd895d8c8c35779dd8b67fa8a05.sol ├── ATMChain(ATM)_0x9B11EFcAAA1890f6eE52C6bB7CF8153aC5d74139.sol ├── AVT(AVT)_0x0d88ed6e74bbfd96b831231638b66c05571e824f.sol ├── Accelerator(ACC)_0x13f1b7fdfbe1fc66676d56483e21b1ecb40b58e2.sol ├── AdBank(ADB)_0x2baac9330cf9ac479d819195794d79ad0c7616e3.sol ├── AdEx(ADX)_0x4470BB87d77b963A013DB939BE332f927f2b992e.sol ├── Adshares(ADST)_0x422866a8f0b032c5cf1dfbdef31a20f4509562b0.sol ├── Aeron(ARN)_0xBA5F11b16B155792Cf3B2E6880E8706859A8AEB6.sol ├── Aeternity(AE)_0x5ca9a71b1d01849c0a95490cc00559717fcf0d1d.sol ├── AidCoin(AID)_0x37e8789bb9996cac9156cd5f5fd32599e6b91289.sol ├── Aigang(AIX)_0x1063ce524265d5a3a624f4914acd573dd89ce988.sol ├── AirSwap(AST)_0x27054b13b1b798b345b591a4d22e6562d47ea75a.sol ├── AirToken(AIR)_0x27dce1ec4d3f72c3e457cc50354f1f975ddef488.sol ├── Alis(ALIS)_0xea610b1153477720748dc13ed378003941d84fab.sol ├── AllSportsCoin(SOC)_0x2d0e95bd4795d7ace0da3c0ff7b706a5970eb9d3.sol ├── Amber(AMB)_0x4dc3643dbc642b72c158e7f3d2ff232df61cb6ce.sol ├── AppCoins(APPC)_0x1a7a8bd9106f2b8d977e08582dc7d24c723ab0db.sol ├── Aragon(ANT)_0x960b236A07cf122663c4303350609A66A7B288C0.sol ├── ArbitrageCT(ARCT)_0x1245ef80f4d9e02ed9425375e8f649b9221b31d8.sol ├── ArcBlock(ABT)_0xb98d4c97425d9908e66e53a6fdf673acca0be986.sol ├── Arcade(ARC)_0xAc709FcB44a43c35F0DA4e3163b117A17F3770f5.sol ├── AstroTokens(ASTRO)_0x7b22938ca841aa392c93dbb7f4c42178e3d65e88.sol ├── Auctus(AUC)_0xc12d099be31567add4e4e4d0d45691c3f58f5663.sol ├── AuroraDAO(AURA)_0xcdcfc0f66c522fd086a1b725ea3c0eeb9f9e8814.sol ├── Authorship(ATS)_0x2dAEE1AA61D60A252DC80564499A69802853583A.sol ├── Autonio(NIO)_0x5554e04e76533e1d14c52f05beef6c9d329e1e30.sol ├── B2BX(B2BX)_0x5d51fcced3114a8bb5e90cdd0f9d682bcbcc5393.sol ├── BANCA(BANCA)_0x998b3b82bc9dba173990be7afb772788b5acb8bd.sol ├── BANKEX(BKX)_0x45245bc59219eeaaf6cd3f382e078a461ff9de7b.sol ├── BAT(BAT)_0x0d8775f648430679a709e98d2b0cb6250d2887ef.sol ├── BAX(BAX)_0x9a0242b7a33dacbe40edb927834f96eb39f8fbcb.sol ├── BBN(BBN)_0x35a69642857083ba2f30bfab735dacc7f0bac969.sol ├── BCAP(BCAP)_0xff3519eeeea3e76f1f699ccce5e23ee0bdda41ac.sol ├── BIXToken(BIX)_0xb3104b4b9da82025e8b9f8fb28b3553ce2f67069.sol ├── BLOCKMASONCREDITPROTOCOLTOKEN(BCPT)_0x1c4481750daa5ff521a2a7490d9981ed46465dbd.sol ├── BLOCKv(VEE)_0x340d2bde5eb28c1eed91b2f790723e3b160613b7.sol ├── BNB(BNB)_0xB8c77482e45F1F44dE1745F52C74426C631bDD52.sol ├── BRAT(BRAT)_0x9e77d5a1251b6f7d456722a6eac6d2d5980bd891.sol ├── Bancor(BNT)_0x1f573d6fb3f13d689ff844b4ce37794d79a7ff1c.sol ├── Bee(BEE)_0x4d8fc1453a0f359e99c9675954e656d80d996fbf.sol ├── Bezop(Bez)_0x3839d8ba312751aa0248fed6a8bacb84308e20ed.sol ├── BillionaireToken(XBL)_0x49aec0752e68d0282db544c677f6ba407ba17ed7.sol ├── BitAir(BTCA)_0x02725836ebf3ecdb1cdf1c7b02fcbbfaa2736af8.sol ├── BitAsean(BAS)_0x2a05d22db079bc40c2f77a1d1ff703a56e631cc1.sol ├── BitClave(CAT)_0x1234567461d3f8db7496581774bd869c83d51c93.sol ├── BitDegree(BDG)_0x1961b3331969ed52770751fc718ef530838b6dee.sol ├── BitDice(CSNO)_0x29d75277ac7f0335b2165d0895e8725cbf658d73.sol ├── BitcoinRed(BTCR)_0x6aac8cb9861e42bf8259f5abdc6ae3ae89909e11.sol ├── BlackmoonCryptoToken(BMC)_0xdf6ef343350780bf8c3410bf062e0c015b1dd671.sol ├── BlockArray(ARY)_0xa5f8fc0921880cb7342368bd128eb8050442b1a1.sol ├── BlockCAT(CAT)_0x56ba2ee7890461f463f7be02aac3099f6d5811a8.sol ├── Blockport(BPT)_0x327682779bab2bf4d1337e8974ab9de8275a7ca8.sol ├── Blocktix(TIX)_0xea1f346faf023f974eb5adaf088bbcdf02d761f4.sol ├── Bloom(BLT)_0x107c4504cd79c5d2696ea0030a8dd4e92601b82e.sol ├── Bluzelle(BLZ)_0x5732046a883704404f284ce41ffadd5b007fd668.sol ├── Boleno(BLN)_0xca29db4221c111888a7e80b12eac8a266da3ee0d.sol ├── Bonpay(BON)_0xcc34366e3842ca1bd36c1f324d15257960fcc801.sol ├── Bounty0x(BNTY)_0xd2d6158683aee4cc838067727209a0aaf4359de3.sol ├── Bread(BRD)_0x558ec3152e2eb2174905cd19aea4e34a23de9ad6.sol ├── Bytom(BTM)_0xcb97e65f07da24d46bcdd078ebebd7c6e6e3d750.sol ├── CCRB(CCRB)_0xe4c94d45f7aef7018a5d66f44af780ec6023378e.sol ├── COPYTRACK(CPY)_0xf44745fbd41f6a1ba151df190db0564c5fcc4410.sol ├── COSS(COSS)_0x9e96604445ec19ffed9a5e8dd7b50a29c899a10c.sol ├── CPAY(CPAY)_0x0Ebb614204E47c09B6C3FeB9AAeCad8EE060E23E.sol ├── CPChain(CPC)_0xfAE4Ee59CDd86e3Be9e8b90b53AA866327D7c090.sol ├── CREDITS(CS)_0x46b9ad944d1059450da1163511069c718f699d31.sol ├── CUBE(AUTO)_0x622dFfCc4e83C64ba959530A5a5580687a57581b.sol ├── CanYaCoin(CAN)_0x1d462414fe14cf489c7a21cac78509f4bf8cd7c0.sol ├── Cappasity(CAPP)_0x04f2e7221fdb1b52a68169b25793e51478ff0329.sol ├── CarTaxi(CTX)_0x662abcad0b7f345ab7ffb1b1fbb9df7894f18e66.sol ├── CargoX(CXO)_0xb6ee9668771a79be7967ee29a63d4184f8097143.sol ├── Cashaa(CAS)_0xe8780b48bdb05f928697a5e8155f672ed91462f7.sol ├── Ccore(CCO)_0x679badc551626e01b23ceecefbc9b877ea18fc46.sol ├── Centra(CTR)_0x96A65609a7B84E8842732DEB08f56C3E21aC6f8a.sol ├── CentralityToken(CENNZ)_0x1122b6a0e00dce0563082b6e2953f3a943855c1f.sol ├── ChainLinkToken(LINK)_0x514910771af9ca656af840dff83e8264ecf986ca.sol ├── ChangeBank(CAG)_0x7d4b8cce0591c9044a22ee543533b72e976e36c3.sol ├── Cindicator(CND)_0xd4c435f5b09f855c3317c8524cb1f586e42795fa.sol ├── Civic(CVC)_0x41e5560054824ea6b0732e656e3ad64e20e94e45.sol ├── ClearCoin(CLR)_0xac838aee2f650a6b970ecea56d4651653c1f84a1.sol ├── ClearPoll(POLL)_0x705EE96c1c160842C92c1aeCfCFfccc9C412e3D9.sol ├── Cobinhood(COB)_0xb2f7eb1f2c37645be61d73953035360e768d81e6.sol ├── Cofoundit(CFI)_0x12fef5e57bf45873cd9b62e9dbd7bfb99e32d73e.sol ├── CoinDash(CDT)_0x177d39ac676ed1c67a2b268ad7f1e58826e5b0af.sol ├── CoinFi(COFI)_0x3136ef851592acf49ca4c825131e364170fa32b3.sol ├── Coinlancer(CL)_0xe81d72d14b1516e68ac3190a46c93302cc8ed60f.sol ├── CommerceBlock(CBT)_0x076C97e1c869072eE22f8c91978C99B4bcB02591.sol ├── CortexCoin(CTXC)_0xea11755ae41d889ceec39a63e6ff75a02bc1c00d.sol ├── Covesting(COV)_0xe2fb6529ef566a080e6d23de0bd351311087d567.sol ├── CreditBIT(CRB)_0xAef38fBFBF932D1AeF3B808Bc8fBd8Cd8E1f8BC5.sol ├── CredoToken(CREDO)_0x4e0603e2a27a30480e5e3a4fe548e29ef12f64be.sol ├── Crypterium(CRPT)_0x80a7e048f37a50500351c204cb407766fa3bae7f.sol ├── Crypto20(C20)_0x26e75307fc0c021472feb8f727839531f112f317.sol ├── CrystalClearToken(CCT)_0x336f646f87d9f6bc6ed42dd46e8b3fd9dbd15c22.sol ├── CyberMiles(CMT)_0xf85feea2fdd81d51177f6b8f35f0e6734ce45f5f.sol ├── CyberVeinToken(CVT)_0xbe428c3867f05dea2a89fc76a102b544eac7f772.sol ├── DADI(DADI)_0xfb2f26f266fb2805a387230f2aa0a331b4d96fba.sol ├── DALECOIN(DALC)_0x07d9e49ea402194bf48a8276dafb16e4ed633317.sol ├── DATAcoin(DATA)_0x0cf0ee63788a0849fe5297f3407f701e122cc023.sol ├── DCORP(DRP)_0x621d78f2ef2fd937bfca696cabaf9a779f59b3ed.sol ├── DEBITUM(DEB)_0x151202c9c18e495656f372281f493eb7698961d5.sol ├── DENT(DENT)_0x3597bfd533a99c9aa083587b074434e61eb0a258.sol ├── DGD(DGD)_0xe0b7927c4af23765cb51314a0e0521a9645f0e2a.sol ├── DICE(ROL)_0x2e071D2966Aa7D8dECB1005885bA1977D6038A65.sol ├── DMarket(DMT)_0x2ccbff3a042c68716ed2a2cb0c544a9f1d1935e1.sol ├── DNA(DNA)_0x82b0e50478eeafde392d45d1259ed1071b6fda81.sol ├── DOVU(DOV)_0xac3211a5025414af2866ff09c23fc18bc97e79b1.sol ├── DRPUtility(DRPU)_0xe30e02f049957e2a5907589e06ba646fb2c321ba.sol ├── DaiStablecoinv1.0(DAI)_0x89d24a6b4ccb1b6faa2625fe562bdd9a23260359.sol ├── Daneel(DAN)_0x9b70740e708a083c6ff38df52297020f5dfaa5ee.sol ├── Dao.Casino(BET)_0x8aa33a7899fcc8ea5fbe6a608a109c3893a1b8b2.sol ├── DataWallet(DXT)_0x8db54ca569d3019a2ba126d03c37c44b5ef81ef6.sol ├── Datum(DAT)_0x81c9151de0c8bafcd325a57e3db5a5df1cebf79c.sol ├── Decent.Bet(DBET)_0x9b68bfae21df5a510931a262cecf63f41338f264.sol ├── Decentraland(MANA)_0x0f5d2fb29fb7d3cfee444a200298f468908cc942.sol ├── DecisionToken(HST)_0x554c20b7c486beee439277b4540a434566dc4c02.sol ├── Delta(DLT)_0x07e3c70653548b04f0a75970c1f81b4cbbfb606f.sol ├── Dentacoin(Dentacoin)_0x08d32b0da63e2C3bcF8019c9c5d849d7a9d791e6.sol ├── Dether(DTH)_0x5adc961d6ac3f7062d2ea45fefb8d8167d44b190.sol ├── Devery.io(EVE)_0x923108a439c4e8c2315c4f6521e5ce95b44e9b4c.sol ├── DigiPulse(DGPT)_0xf6cfe53d6febaeea051f400ff5fc14f0cbbdaca1.sol ├── DigitalDevelopersFundToken(DDF)_0xcc4ef9eeaf656ac1a2ab886743e98e97e090ed38.sol ├── DomRaiderToken(DRT)_0x9af4f26941677c706cfecf6d3379ff01bb85d5ab.sol ├── Dragon(DRGN)_0x419c4db4b9e25d6db2ad9691ccb832c8d9fda05e.sol ├── E4ROW(E4ROW)_0xce5c603c78d047ef43032e96b5b785324f753a4f.sol ├── EDUCare(EKT)_0xbab165df9455aa0f2aed1f2565520b91ddadb4c8.sol ├── ELF(ELF)_0xbf2179859fc6d5bee9bf9158632dc51678a4100e.sol ├── ELTCOIN(ELTCOIN)_0x44197a4c44d6a059297caf6be4f7e172bd56caaf.sol ├── EOS(EOS)_0x86fa049857e0209aa7d9e616f7eb3b3b78ecfdb0.sol ├── EQUAL(EQL)_0x47dd62d4d075dead71d0e00299fc56a2d747bebb.sol ├── EROSCOIN(ERO)_0x74ceda77281b339142a36817fa5f9e29412bab85.sol ├── ESZCoin(ESZ)_0xe8a1df958be379045e2b46a31a98b93a2ecdfded.sol ├── ETHGAS(eGAS)_0xb53a96bcbdd9cf78dff20bab6c2be7baec8f00f8.sol ├── EXRPNetwork(EXRN)_0xe469c4473af82217b30cf17b10bcdb6c8c796e75.sol ├── EZToken(EZT)_0x5e6016ae7d7c49d347dcf834860b9f3ee282812b.sol ├── Edgeless(EDG)_0x08711d3b02c8758f2fb3ab4e80228418a7f8e39c.sol ├── Education(LEDU)_0x5b26c5d0772e5bbac8b3182ae9a13f9bb2d03765.sol ├── Eidoo(EDO)_0xced4e93198734ddaff8492d525bd258d49eb388e.sol ├── ElectrifyAsia(ELEC)_0xd49ff13661451313ca1553fd6954bd1d9b6e02b9.sol ├── Embers(EMB)_0x386467f1f3ddbe832448650418311a479eecfc57.sol ├── EmphyCoin(EPY)_0x50ee674689d75c0f88e8f83cfe8c4b69e8fd590d.sol ├── Enigma(ENG)_0xf0ee6b27b759c9893ce4f094b49ad28fd15a23e4.sol ├── EnjinCoin(ENJ)_0xf629cbd94d3791c9250152bd8dfbdf380e2a3b9c.sol ├── Envion(EVN)_0xd780ae2bf04cd96e577d3d014762f831d97129d0.sol ├── EthBitsETBSToken(ETBS)_0x1b9743f556d65e757c4c650b4555baf354cb8bd3.sol ├── EthLend(LEND)_0x80fB784B7eD66730e8b1DBd9820aFD29931aab03.sol ├── EthereumBlue(BLUE)_0x539efe69bcdd21a83efd9122571a64cc25e0282b.sol ├── EthereumDark(ETHD)_0xdbfb423e9bbf16294388e07696a5120e4ceba0c5.sol ├── EthereumGold(ETG)_0x28c8d01ff633ea9cd8fc6a451d7457889e698de6.sol ├── Etheriya(RIYA)_0x0b1724cc9fda0186911ef6a75949e9c0d3f0f2f3.sol ├── Ethos(ETHOS)_0x5af2be193a6abca9c8817001f45744777db30756.sol ├── EventChain(EVC)_0xb62d18dea74045e822352ce4b3ee77319dc5ff2f.sol ├── Everex(EVX)_0xf3db5fa2c66b7af3eb0c0b782510816cbe4813b8.sol ├── Experty(EXY)_0x5c743a35E903F6c584514ec617ACEe0611Cf44f3.sol ├── FOTA(FOTA)_0x4270bb238f6dd8b1c3ca01f96ca65b2647c06d3c.sol ├── Feed(IFT)_0x7654915a1b82d6d2d0afc37c52af556ea8983c7e.sol ├── FinallyUsableCryptoKarma(FUCK)_0x65be44c747988fbf606207698c944df4442efe19.sol ├── FintruXNetwork(FTX)_0xd559f20296ff4895da39b5bd9add54b442596a61.sol ├── FirstBlood(ST)_0xaf30d2a7e90d7dc361c8c4585e9bb7d2f6f15bc7.sol ├── Flixx(FLIXX)_0xf04a8ac553fcedb5ba99a64799155826c136b0be.sol ├── FluzFluz(FLUZ)_0x954b5de09a55e59755acbda29e1eb74a45d30175.sol ├── Flyp.me(FYP)_0x8f0921f30555624143d427b340b1156914882c10.sol ├── FuelToken(FUEL)_0xea38eaa3c86c8f9b751533ba2e562deb9acded40.sol ├── Fujinto(NTO)_0x8a99ed8a1b204903ee46e733f2c1286f6d20b177.sol ├── FunFair(FUN)_0x419d0d8bdd9af5e606ae2232ed285aff190e711b.sol ├── FundYourselfNow(FYN)_0x88FCFBc22C6d3dBaa25aF478C578978339BDe77a.sol ├── Fusion(FSN)_0xd0352a019e9ab9d757776f532377aaebd36fd541.sol ├── GAT(GAT)_0x687174f8c49ceb7729d925c3a961507ea4ac7b28.sol ├── Game.comToken(GTC)_0xB70835D7822eBB9426B56543E391846C107bd32C.sol ├── GenaroX(GNX)_0x6ec8a24cabdc339a06a172f8223ea557055adaa5.sol ├── GenesisVision(GVT)_0x103c3A209da59d3E7C4A89307e66521e081CFDF0.sol ├── Gifto(GTO)_0xc5bbae50781be1669306b9e001eff57a2957b09d.sol ├── Gimli(GIM)_0xae4f56f072c34c0a65b3ae3e4db797d831439d93.sol ├── Gladius(GLA)_0x71d01db8d6a2fbea7f8d434599c237980c234e4c.sol ├── GlobalMessagingToken(GMT)_0xb3bd49e28f8f832b8d1e246106991e546c323502.sol ├── Gnosis(GNO)_0x6810e776880c02933d47db1b9fc05908e5386b96.sol ├── GoldmintMNTPrelaunchToken(MNTP)_0x83cee9e086a77e492ee0bb93c2b0437ad6fdeccc.sol ├── Golem(GNT)_0xa74476443119A942dE498590Fe1f2454d7D4aC0d.sol ├── Guppy(Guppy)_0xf7b098298f7c69fc14610bf71d5e02c60792894c.sol ├── HPBCoin(HPB)_0x38c6a68304cdefb9bec48bbfaaba5c5b47818bb2.sol ├── Hacken(HKN)_0x9e6b2b11542f2bc52f3029077ace37e8fd838d7f.sol ├── Havven(HAV)_0xf244176246168f24e3187f7288edbca29267739b.sol ├── Hedge(HDG)_0xffe8196bc259e8dedc544d935786aa4709ec3e64.sol ├── HelloGold(HGT)_0xba2184520a1cc49a6159c57e61e1844e085615b6.sol ├── Herocoin(PLAY)_0xe477292f1b3268687a29376116b0ed27a9c76170.sol ├── HiveProjectToken(HVN)_0xC0Eb85285d83217CD7c891702bcbC0FC401E2D9D.sol ├── Horse(HORSE)_0x5b0751713b2527d7f002c0c4e2a37e1219610a6b.sol ├── Hubiits(HBT)_0xdd6c68bb32462e01705011a4e2ad1a60740f217f.sol ├── Humaniq(HMQ)_0xcbcc0f036ed4788f63fc0fee32873d6a7487b908.sol ├── HydroProtocol(HOT)_0x9af839687f6c94542ac5ece2e317daae355493a1.sol ├── ICO(¢)_0xa33e729bf4fdeb868b534e1f20523463d9c46bee.sol ├── ICON(ICX)_0xb5a5f22694352c15b00323844ad545abb2b11028.sol ├── ICONOMI(ICN)_0x888666CA69E0f178DED6D75b5726Cee99A87D698.sol ├── IDEXMembership(IDXM)_0xcc13fc627effd6e35d2d2706ea3c4d7396c610ea.sol ├── IDICE(ICE)_0x5a84969bb663fb64f6d015dcf9f622aedc796750.sol ├── IHOUSETOKEN(IHT)_0xeda8b016efa8b1161208cf041cd86972eee0f31e.sol ├── INS(INS)_0x5b2e4a700dfbc560061e957edec8f6eeeb74a320.sol ├── IOSToken(IOST)_0xfa1a856cfa3409cfa145fa4e20eb270df3eb21ab.sol ├── IOTChain(ITC)_0x5e6b6d9abad9093fdc861ea1600eba1b355cd940.sol ├── IPSX(IPSX)_0x001f0aa5da15585e5b2305dbab2bac425ea71007.sol ├── IUNGO(ING)_0x24ddff6d8b8a42d835af3b440de91f3386554aa4.sol ├── Indorse(IND)_0xf8e386eda857484f5a12e4b5daa9984e06e73705.sol ├── InkProtocol(XNK)_0xbc86727e770de68b1060c91f6bb6945c73e10388.sol ├── InsightsNetwork(INSTAR)_0xc72fe8e3dd5bef0f9f31f259399f301272ef2a2d.sol ├── InsurePal(IPL)_0x64cdf819d3e75ac8ec217b3496d7ce167be42e80.sol ├── IntelligentTradingTechnologies(ITT)_0x0aef06dcccc531e581f0440059e6ffcc206039ee.sol ├── InternetNodeToken(INT)_0x0b76544f6c413a555f309bf76260d1e02377c02a.sol ├── Internxt(INXT)_0xa8006c4ca56f24d6836727d106349320db7fef82.sol ├── J8T(J8T)_0x0d262e5dc4a06a0f1c90ce79c7a60c09dfc884e4.sol ├── JesusCoin(JC)_0xe2d82dc7da0e6f882e96846451f4fabcc8f90528.sol ├── Jetcoin(JET)_0x8727c112c712c4a03371ac87a74dd6ab104af768.sol ├── JibrelNetworkToken(JNT)_0xa5fd1a791c4dfcaacc963d4f73c6ae5824149ea7.sol ├── KickCoin(KICK)_0x27695e09149adc738a978e9a678f99e4c39e9eb9.sol ├── Kin(KIN)_0x818fc6c2ec5986bc6e2cbf00939d90556ab12ce5.sol ├── KyberNetwork(KNC)_0xdd974d5c2e2928dea5f71b9825b8b646686bd200.sol ├── LALA(LALA)_0xfd107b473ab90e8fbd89872144a3dc92c40fa8c9.sol ├── LAtoken(LA)_0xe50365f5d679cb98a1dd62d6f6e58e59321bcddf.sol ├── LGO(LGO)_0x123ab195dd38b1b40510d467a6a359b201af056f.sol ├── LOCIcoin(LOCI)_0x9c23d67aea7b95d80942e3836bcdf7e708a747c2.sol ├── LamdenTau(TAU)_0xc27a2f05fa577a83ba0fdb4c38443c0718356501.sol ├── LancerToken(LNC)_0x63e634330a20150dbb61b15648bc73855d6ccf07.sol ├── LatiumX(LATX)_0x2f85e502a988af76f7ee6d83b7db8d6c0a823bf9.sol ├── Legends(LGD)_0x59061b6f26BB4A9cE5828A19d35CFD5A4B80F056.sol ├── LendConnect(LCT)_0x05c7065d644096a4e4c3fe24af86e36de021074b.sol ├── Leverj(LEV)_0x0f4ca92660efad97a9a70cb0fe969c755439772c.sol ├── LinkPlatform(LNK)_0xe2e6d4be086c6938b53b22144855eef674281639.sol ├── LockChain(LOC)_0x5e3346444010135322268a4630d2ed5f8d09446c.sol ├── Loom(LOOM)_0xa4e8c3ec456107ea67d3075bf9e3df3a75823db0.sol ├── Loopring(LRC)_0xef68e7c694f40c8202821edf525de3782458639f.sol ├── Lunyr(LUN)_0xfa05A73FfE78ef8f1a739473e462c54bae6567D9.sol ├── Lympo(LYM)_0x57ad67acf9bf015e4820fbd66ea1a21bed8852ec.sol ├── MCAP(MCAP)_0x93e682107d1e9defb0b5ee701c71707a4b2e46bc.sol ├── MOT(MOT)_0x263c618480dbe35c300d8d5ecda19bbb986acaed.sol ├── MaecenasARTToken(ART)_0xfec0cf7fe078a500abf15f1284958f22049c2c7e.sol ├── Maker(MKR)_0x9f8f72aa9304c8b593d555f12ef6589cc3a579a2.sol ├── Matryx(MTX)_0x0af44e2784637218dd1d32a322d44e603a8f0c6a.sol ├── MeasurableDataToken(MDT)_0x814e0908b12a99fecf5bc101bb5d0b8b5cdf7d26.sol ├── MedToken(MTN)_0x41dbecc1cdc5517c6f76f6a6e836adbee2754de3.sol ├── Melon(MLN)_0xBEB9eF514a379B997e0798FDcC901Ee474B6D9A1.sol ├── Metal(MTL)_0xF433089366899D83a9f26A773D59ec7eCF30355e.sol ├── MobileGo(MGO)_0x40395044Ac3c0C57051906dA938B54BD6557F212.sol ├── ModumToken(MOD)_0x957c30ab0426e0c93cd8241e2c60392d08c6ac8e.sol ├── MoedaLoyaltyPoints(MDA)_0x51db5ad35c671a87207d88fc11d593ac0c8415bd.sol ├── Monaco(MCO)_0xb63b606ac810a52cca15e44bb630fd42d8d1d83d.sol ├── Monetha(MTH)_0xaf4dce16da2877f8c9e00544c93b62ac40631f16.sol ├── Mothership(MSP)_0x68AA3F232dA9bdC2343465545794ef3eEa5209BD.sol ├── MyBitToken(MyB)_0x94298f1e0ab2dfad6eeffb1426846a3c29d98090.sol ├── MyWish(WISH)_0x1b22c32cd936cb97c28c5690a0695a82abf688e6.sol ├── Mysterium(MYST)_0xa645264C5603E96c3b0B078cdab68733794B0A71.sol ├── NAGACoin(NGC)_0x72dd4b6bd852a3aa172be4d6c5a6dbec588cf131.sol ├── NANJCOIN(NANJ)_0xffe02ee4c69edf1b340fcad64fbd6b37a7b9e265.sol ├── NEVERDIE(NDC)_0xa54ddc7b3cce7fc8b1e3fa0256d0db80d2c10970.sol ├── Nebulas(NAS)_0x5d65D971895Edc438f465c17DB6992698a52318D.sol ├── Nectar(NCT)_0x9e46a38f5daabe8683e10793b06749eef7d733d1.sol ├── Network(CDX)_0x6fff3806bbac52a20e0d79bc538d527f6a22c96b.sol ├── Network(NTWK)_0x2233799ee2683d75dfefacbcd2a26c78d34b470d.sol ├── Neumark(NEU)_0xa823e6722006afe99e91c30ff5295052fe6b8e32.sol ├── Newbium(NEWB)_0x814964b1bceAf24e26296D031EaDf134a2Ca4105.sol ├── Nexium(NxC)_0x45e42D659D9f9466cD5DF622506033145a9b89Bc.sol ├── Nexxus(NXX)_0x7627de4b93263a6a7570b8dafa64bae812e5c394.sol ├── NimiqNetwork(NET)_0xcfb98637bcae43C13323EAa1731cED2B716962fD.sol ├── NucleusVision(nCash)_0x809826cceab68c387726af962713b64cb5cb3cca.sol ├── Nuls(NULS)_0xb91318f35bdb262e9423bc7c7c2a3a93dd93c92c.sol ├── Numeraire(NMR)_0x1776e1f26f98b1a5df9cd347953a26dd3cb46671.sol ├── OCoin(OCN)_0x4092678e4e78230f46a1534c0fbc8fa39780892b.sol ├── ODEMToken(ODEM)_0xbf52f2ab39e26e0951d2a02b49b7702abe30406a.sol ├── OmiseGO(OMG)_0xd26114cd6EE289AccF82350c8d8487fedB8A0C07.sol ├── OneRootNetwork(RNT)_0xff603f43946a3a28df5e6a73172555d8c8b02386.sol ├── OpenANX(OAX)_0x701c244b988a513c945973defa05de933b23fe1d.sol ├── OpenTradingNetwork(OTN)_0x881ef48211982d01e2cb7092c915e647cd40d85c.sol ├── Opus(OPT)_0x4355fC160f74328f9b383dF2EC589bB3dFd82Ba0.sol ├── OysterPearl(PRL)_0x1844b21593262668b7248d0f57a220caaba46ab9.sol ├── PILLAR(PLR)_0xe3818504c1b32bf1557b16c238b2e01fd3149c17.sol ├── PIX(PIX)_0x8eFFd494eB698cc399AF6231fCcd39E08fd20B15.sol ├── PRG(PRG)_0x7728dFEF5aBd468669EB7f9b48A7f70a501eD29D.sol ├── ParetoNetworkToken(PARETO)_0xea5f88e54d982cbb0c441cde4e79bc305e5b43bc.sol ├── Patientory(PTOY)_0x8ae4bf2c33a8e667de34b54938b0ccd03eb8cc06.sol ├── PayFair(PFR)_0x2fa32a39fc1c399e0cc7b2935868f5165de7ce97.sol ├── PayPie(PPP)_0xc42209aCcC14029c1012fB5680D95fBd6036E2a0.sol ├── Pebbles(PBL)_0x55648de19836338549130b1af587f16bea46f66b.sol ├── Playkey(PKT)_0x2604fa406be957e542beb89e6754fcde6815e83f.sol ├── Pluton(PLU)_0xD8912C10681D8B21Fd3742244f44658dBA12264E.sol ├── Po.et(POE)_0x0e0989b1f9b8a38983c2ba8053269ca62ec9b195.sol ├── PoSToken(POS)_0xee609fe292128cad03b786dbb9bc2634ccdbe7fc.sol ├── PokerChips(CHP)_0xf3db7560e820834658b590c96234c333cd3d5e5e.sol ├── PolyAi(AI)_0x5121e348e897daef1eef23959ab290e5557cf274.sol ├── Polybius(PLBT)_0x0affa06e7fbe5bc9a764c979aa66e8256a631f02.sol ├── Polymath(POLY)_0x9992ec3cf6a55b00978cddf2b27bc6882d88d1ec.sol ├── Populous(PPT)_0xd4fa1460f537bb9085d22c7bccb5dd450ef28e3a.sol ├── PowerLedger(POWR)_0x595832f8fc6bf59c85c527fec3740a1b7a361269.sol ├── Presearch(PRE)_0x88a3e4f35d64aad41a6d4030ac9afe4356cb84fa.sol ├── Primas(PST)_0xe3fedaecd47aa8eab6b23227b0ee56f092c967a9.sol ├── Privatix(PRIX)_0x3adfc4999f77d04c8341bac5f3a76f58dff5b37a.sol ├── Pro(PRO)_0x9041fe5b3fdea0f5e4afdc17e75180738d877a01.sol ├── Propy(PRO)_0x226bb599a12c826476e3a771454697ea52e9e220.sol ├── Pylon(PYLNT)_0x7703c35cffdc5cda8d27aa3df2f9ba6964544b6e.sol ├── QASH(QASH)_0x618e75ac90b12c6049ba3b27f5d5f8651b0037f6.sol ├── QRL(QRL)_0x697beac28b09e122c4332d163985e8a73121b97f.sol ├── QVT(QVT)_0x1183f92a5624d68e85ffb9170f16bf0443b4c242.sol ├── Quantstamp(QSP)_0x99ea4db9ee77acd40b119bd1dc4e33e1c070b80d.sol ├── Quantum(QAU)_0x671abbe5ce652491985342e85428eb1b07bc6c64.sol ├── QunQunCommunities(QUN)_0x264dc2dedcdcbb897561a57cba5085ca416fb7b4.sol ├── REDMWAT(MWAT)_0x6425c6be902d692ae2db752b3c268afadb099d3b.sol ├── REMME(REM)_0x83984d6142934bb535793a82adb0a46ef0f66b6d.sol ├── REP(REP)_0xe94327d07fc17907b4db788e5adf2ed424addff6.sol ├── REX-RealEstatetokens(REX)_0xf05a9382A4C3F29E2784502754293D88b835109C.sol ├── RHOC(RHOC)_0x168296bb09e24a88805cb9c33356536b980d3fc5.sol ├── RLC(RLC)_0x607F4C5BB672230e8672085532f7e901544a7375.sol ├── RNTBToken(RNTB)_0x1fe70be734e473e5721ea57c8b5b01e6caa52686.sol ├── ROC(ROC)_0x1bcbc54166f6ba149934870b60506199b6c9db6d.sol ├── RUFF(RUFF)_0xf278c1ca969095ffddded020290cf8b5c424ace2.sol ├── Raiden(RDN)_0x255aa6df07540cb5d3d297f0d0d4d84cb52bc8e6.sol ├── RealEstateAssetLedger(REAL)_0x9214ec02cb71cba0ada6896b8da260736a67ab10.sol ├── Rebellious(REBL)_0x5f53f7a8075614b699baad0bc2c899f4bad8fbbf.sol ├── RefToken(REF)_0x89303500a7abfb178b274fd89f2469c264951e1f.sol ├── Refereum(RFR)_0xd0929d411954c47438dc1d871dd6081f5c5e149c.sol ├── RemiCoin(RMC)_0x7dc4f41294697a7903c4027f6ac528c5d14cd7eb.sol ├── Republic(REN)_0x408e41876cccdc0f92210600ef50372656052a38.sol ├── Request(REQ)_0x8f8221afbb33998d8584a2b05749ba73c37a938a.sol ├── Revain(R)_0x48f775efbe4f5ece6e0df2f7b5932df56823b990.sol ├── Rialto(XRL)_0xb24754be79281553dc1adc160ddf5cd9b74361a4.sol ├── RipioCreditNetwork(RCN)_0xf970b8e36e23f7fc3fd752eea86f8be8d83375a6.sol ├── Rock(RKT)_0x106aa49295b525fcf959aa75ec3f7dcbf5352f1c.sol ├── RouletteToken(RLT)_0xcced5b8288086be8c38e23567e684c3740be4d48.sol ├── RvT(RVT)_0x3d1ba9be9f66b8ee101911bc36d3fb562eac2244.sol ├── SAN(SAN)_0x7c5a0ce9267ed19b22f8cae653f198e3e8daf098.sol ├── SENTinel(SENT)_0xa44e5137293e855b1b7bc7e2c6f8cd796ffcb037.sol ├── SIRIN(SRN)_0x68d57c9a1c35f63e2c83ee8e49a64e9d70528d25.sol ├── SNGLS(SNGLS)_0xaec2e87e0a235266d9c5adc9deb4b2e29b54d009.sol ├── SOCIALL(SCL)_0xd7631787b4dcc87b1254cfd1e5ce48e96823dee8.sol ├── SPANK(SPANK)_0x42d6622dece394b54999fbd73d108123806f6a18.sol ├── SPF(SPF)_0x85089389c14bd9c77fc2b8f0c3d1dc3363bf06ef.sol ├── SPHTX(SPHTX)_0x3833dda0aeb6947b98ce454d89366cba8cc55528.sol ├── STK(STK)_0xae73b38d1c9a8b274127ec30160a4927c4d71824.sol ├── Salt(SALT)_0x4156D3342D5c385a87D264F90653733592000581.sol ├── SelfKey(KEY)_0x4cc19356f2d37338b9802aa8e8fc58b0373296e7.sol ├── Sense(SENSE)_0x6745fab6801e376cd24f03572b9c9b0d4edddccf.sol ├── SentinelChain(SENC)_0xa13f0743951b4f6e3e3aa039f682e17279f52bc3.sol ├── SharpePlatformToken(SHP)_0xef2463099360a085f1f10b076ed72ef625497a06.sol ├── ShipChainSHIP(SHIP)_0xe25b0bba01dc5630312b6a21927e578061a13f55.sol ├── Signals(SIG)_0x6888a16ea9792c15a4dcf2f6c623d055c8ede792.sol ├── SimpleToken(ST)_0x2c4e8f2d746113d0696ce89b35f0d8bf88e0aeca.sol ├── SingularityNET(AGI)_0x8eb24319393716668d768dcec29356ae9cffe285.sol ├── SkinCoin(SKIN)_0x2bdc0d42996017fce214b21607a515da41a9e0c5.sol ├── Snovio(SNOV)_0xbdc5bac39dbe132b1e030e898ae3830017d7d969.sol ├── Soarcoin(Soar)_0xD65960FAcb8E4a2dFcb2C2212cb2e44a02e2a57E.sol ├── Spectre.aiD-Token(SXDT)_0x12b306fa98f4cbb8d4457fdff3a0a0a56f07ccdf.sol ├── Spectre.aiU-Token(SXUT)_0x2c82c73d5b34aa015989462b2948cd616a37641f.sol ├── SpeedMiningService(SMS)_0x39013f961c378f02c2b82a6e1d31e9812786fd9d.sol ├── StarCredits(STRC)_0x46492473755e8df960f8034877f61732d718ce96.sol ├── StarterCoin(STAC)_0x9a005c9a89bd72a4bd27721e7a09a3c11d2b03c4.sol ├── StatusNetwork(SNT)_0x744d70fdbe2ba4cf95131626614a1763df805b9e.sol ├── Storiqa(STQ)_0x5c3a228510d246b78a3765c20221cbf3082b44a4.sol ├── Stox(STX)_0x006bea43baa3f7a6f765f14f10a1a1b08334ef45.sol ├── StudentCoin(STU)_0x0371a82e4a9d0a4312f3ee2ac9c6958512891372.sol ├── Substratum(SUB)_0x12480e24eb5bec1a9d4369cab6a80cad3c0a377a.sol ├── SugarExchange(SGR)_0xcb5a05bef3257613e984c17dbcf039952b6d883f.sol ├── SunContract(SNC)_0xF4134146AF2d511Dd5EA8cDB1C4AC88C57D60404.sol ├── Suretly(SUR)_0xe120c1ecbfdfea7f0a8f0ee30063491e8c26fedf.sol ├── SwarmCity(SWT)_0xb9e7f8568e08d5659f5d29c4997173d84cdf2607.sol ├── SwarmFund(SWM)_0x9e88613418cf03dca54d6a2cf6ad934a78c7a17a.sol ├── SwissBorg(CHSB)_0xba9d4199fab4f26efe3551d490e3821486f135ba.sol ├── TAAS(TAAS)_0xe7775a6e9bcf904eb39da2b68c5efb4f9360e08c.sol ├── TE-FOOD(TFD)_0xe5f166c0d8872b68790061317bb6cca04582c912.sol ├── TIME(TIME)_0x6531f133e6deebe7f2dce5a0441aa7ef330b4e53.sol ├── TKRToken(TKR)_0xb45a50545beeab73f38f31e5973768c421805e5e.sol ├── TargetCoin(TGT)_0xac3da587eac229c9896d919abc235ca4fd7f72c1.sol ├── Telcoin(TEL)_0x85e076361cc813a908ff672f9bad1541474402b2.sol ├── TenXPay(PAY)_0xB97048628DB6B661D4C2aA833e95Dbe1A905B280.sol ├── TieToken(TIE)_0x999967e2ec8a74b7c8e9db19e039d920b31d39d0.sol ├── TierionNetworkToken(TNT)_0x08f5a9235b08173b7569f83645d2c7fb55e8ccd8.sol ├── Tigereum(TIG)_0xeee2d00eb7deb8dd6924187f5aa3496b7d06e62a.sol ├── TokenCard(TKN)_0xaaaf91d9b90df800df4f55c205fd6989c977e73a.sol ├── Tokenbox(TBX)_0x3a92bd396aef82af98ebc0aa9030d25a23b11c6b.sol ├── Tokenomy(TEN)_0xdd16ec0f66e54d453e6756713e533355989040e4.sol ├── Tomocoin(TOMO)_0x8b353021189375591723e7384262f45709a3c3dc.sol ├── Trace(TRAC)_0xaa7a9ca87d3694b5755f213b5d04094b8d0f0a6f.sol ├── Tracto(TRCT)_0x30ceCB5461A449A90081F5a5F55db4e048397BAB.sol ├── Trade(TIO)_0x80bc5512561c7f85a3a9508c7df7901b370fa1df.sol ├── Tronix(TRX)_0xf230b790e05390fc8295f4d3f60332c93bed42e2.sol ├── TrueFlip(TFL)_0xa7f976c360ebbed4465c2855684d1aae5271efa9.sol ├── TrueUSD(TUSD)_0x8dd5fbce2f6a956c3022ba3663759011dd51e73e.sol ├── Trustcoin(TRST)_0xcb94be6f13a1182e4a4b6140cb7bf2025d28e41b.sol ├── UCASH(UCASH)_0x92e52a1a235d9a103d970901066ce910aacefd37.sol ├── UTN-P:UniversaToken(UTNP)_0x9e3319636e2126e3c0bc9e3134aec5e1508a46c7.sol ├── UTRUST(UTK)_0x70a72833d6bf7f508c8224ce59ea1ef3d0ea3a38.sol ├── UnikoinGold(UKG)_0x24692791bc444c5cd0b81e3cbcaba4b04acd1f3b.sol ├── UpToken(UP)_0x6ba460ab75cd2c56343b3517ffeba60748654d26.sol ├── Upfiring(UFR)_0xea097a2b1db00627b2fa17460ad260c016016977.sol ├── UquidCoin(UQC)_0xd01db73e047855efb414e6202098c4be4cd2423b.sol ├── UselessEthereumToken(UET)_0x27f706edde3aD952EF647Dd67E24e38CD0803DD6.sol ├── VIB(VIB)_0x2C974B2d0BA1716E644c1FC59982a89DDD2fF724.sol ├── VIU(VIU)_0x519475b31653e46d20cd09f9fdcf3b12bdacb4f5.sol ├── VOISE(VOISE)_0x83eEA00D838f92dEC4D1475697B9f4D3537b56E3.sol ├── VeChain(VEN)_0xd850942ef8811f2a866692a623011bde52a462c1.sol ├── Verify(CRED)_0x672a1ad4f667fb18a333af13667aa0af1f5b5bdd.sol ├── Veritaseum(VERI)_0x8f3470A7388c05eE4e7AF3d01D8C722b0FF52374.sol ├── Vezt(VZT)_0x9720b467a710382A232a32F540bDCed7d662a10B.sol ├── VibeCoin(VIBE)_0xe8ff5c9c75deb346acac493c463c8950be03dfba.sol ├── WAXToken(WAX)_0x39bb259f66e1c59d5abef88375979b4d20d98022.sol ├── WILDToken(WILD)_0xd3c00772b24d997a812249ca637a921e81357701.sol ├── WINGS(WINGS)_0x667088b212ce3d06a1b553a7221E1fD19000d9aF.sol ├── WTT(WTT)_0x84119cb33e8f590d75c2d6ea4e6b0741a7494eda.sol ├── WaBi(WaBi)_0x286BDA1413a2Df81731D4930ce2F862a35A609fE.sol ├── Walton(WTC)_0xb7cb1c96db6b22b0d3d9536e0108d062bd488f74.sol ├── WePower(WPR)_0x4CF488387F035FF08c371515562CBa712f9015d4.sol ├── Worldcore(WRC)_0x72adadb447784dd7ab1f472467750fc485e4cb2d.sol ├── XENON(XNN)_0xab95e915c123fded5bdfb6325e35ef5515f1ea69.sol ├── XPlay(XPA)_0x90528aeb3a2b736b780fd1b6c478bb7e1d643170.sol ├── Xaurum(Xaurum)_0x4DF812F6064def1e5e029f1ca858777CC98D2D81.sol ├── XinFinXDCE(XDCE)_0x41ab1b6fcbb2fa9dced81acbdec13ea6315f2bf2.sol ├── YOYOW(YOYOW)_0xcbeaec699431857fdb4d37addbbdc20e132d4903.sol ├── ZAPTOKEN(ZAP)_0x6781a0f84c7e9e846dcb84a9a5bd49333067b104.sol ├── ZRX(ZRX)_0xe41d2489571d322189246dafa5ebde1f4699f498.sol ├── ZeusShieldCoin(ZSC)_0x7A41e0517a5ecA4FdbC7FbebA4D4c47B9fF6DC63.sol ├── Zilla(ZLA)_0xfd8971d5e8e1740ce2d0a84095fca4de729d0c16.sol ├── Zilliqa(ZIL)_0x05f4a42e251f2d52b8ed15e9fedaacfcef1fad27.sol ├── aXpire(AXP)_0x9af2c6b1a28d3d6bc084bd267f70e90d49741d5b.sol ├── cVToken(cV)_0xda6cb58a0d0c01610a29c5a65c303e13e885887c.sol ├── district0x(DNT)_0x0abdace70d3790235af448c88547603b945604ea.sol ├── eBitcoin(EBTC)_0xeb7c20027172e5d143fb030d50f91cece2d1485d.sol ├── eBitcoinCash(eBCH)_0xafc39788c51f0c1ff7b55317f3e70299e521fff6.sol ├── iEthereum(iETH)_0x859a9c0b44cb7066d956a958b0b82e54c9e44b4b.sol ├── iXledger(IXT)_0xfca47962d45adfdfd1ab2d972315db4ce7ccf094.sol ├── indaHashCoin(IDH)_0x5136c98a80811c3f46bdda8b5c4555cfd9f812f0.sol ├── minereum(MNE)_0x1a95b271b0535d15fa49932daba31ba612b52946.sol └── vSlice(VSL)_0x5c543e7AE0A1104f78406C340E9C64FD9fCE5170.sol /README.md: -------------------------------------------------------------------------------- 1 | # 基于以太坊发行的ERC20代币源代码集合 2 | 3 | ## > 总收录ERC20代币：`431` 种 4 | 5 | ## 使用方式 6 | 7 | 通过查询代币简称/代币全称/代币合约地址等方式，从 `SourceCode` 文件夹中搜索即可。 8 | 9 | 10 | 11 | > 持续更新中，如果未收录您所关注的代币，可以通过issue提交您的代币合约地址 -------------------------------------------------------------------------------- /SourceCode/1World(1WO)_0xfdbc1adc26f0f8f8606a5d63b7d3a3cd21c22b23.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.16; 2 | 3 | /* 4 | * Abstract Token Smart Contract. Created in 2017 by ABDK Consulting. 5 | * Author: Mikhail Vladimirov < -------------------------------------------------------------------------------- /SourceCode/300Token(300)_0xaec98a708810414878c3bcdf46aad31ded4a4557.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.11; 2 | 3 | contract Token { 4 | string public symbol = ""; 5 | string public name = ""; 6 | uint8 public constant decimals = 18; 7 | uint256 _totalSupply = 0; 8 | address owner = 0; 9 | bool setupDone = false; 10 | 11 | event Transfer(address indexed _from, address indexed _to, uint256 _value); 12 | event Approval(address indexed _owner, address indexed _spender, uint256 _value); 13 | 14 | mapping(address => uint256) balances; 15 | 16 | mapping(address => mapping (address => uint256)) allowed; 17 | 18 | function Token(address adr) { 19 | owner = adr; 20 | } 21 | 22 | function SetupToken(string tokenName, string tokenSymbol, uint256 tokenSupply) 23 | { 24 | if (msg.sender == owner && setupDone == false) 25 | { 26 | symbol = tokenSymbol; 27 | name = tokenName; 28 | _totalSupply = tokenSupply * 1000000000000000000; 29 | balances[owner] = _totalSupply; 30 | setupDone = true; 31 | } 32 | } 33 | 34 | function totalSupply() constant returns (uint256 totalSupply) { 35 | return _totalSupply; 36 | } 37 | 38 | function balanceOf(address _owner) constant returns (uint256 balance) { 39 | return balances[_owner]; 40 | } 41 | 42 | function transfer(address _to, uint256 _amount) returns (bool success) { 43 | if (balances[msg.sender] >= _amount 44 | && _amount > 0 45 | && balances[_to] + _amount > balances[_to]) { 46 | balances[msg.sender] -= _amount; 47 | balances[_to] += _amount; 48 | Transfer(msg.sender, _to, _amount); 49 | return true; 50 | } else { 51 | return false; 52 | } 53 | } 54 | 55 | function transferFrom( 56 | address _from, 57 | address _to, 58 | uint256 _amount 59 | ) returns (bool success) { 60 | if (balances[_from] >= _amount 61 | && allowed[_from][msg.sender] >= _amount 62 | && _amount > 0 63 | && balances[_to] + _amount > balances[_to]) { 64 | balances[_from] -= _amount; 65 | allowed[_from][msg.sender] -= _amount; 66 | balances[_to] += _amount; 67 | Transfer(_from, _to, _amount); 68 | return true; 69 | } else { 70 | return false; 71 | } 72 | } 73 | 74 | function approve(address _spender, uint256 _amount) returns (bool success) { 75 | allowed[msg.sender][_spender] = _amount; 76 | Approval(msg.sender, _spender, _amount); 77 | return true; 78 | } 79 | 80 | function allowance(address _owner, address _spender) constant returns (uint256 remaining) { 81 | return allowed[_owner][_spender]; 82 | } 83 | } -------------------------------------------------------------------------------- /SourceCode/ATLANT(ATL)_0x78b7fada55a64dd895d8c8c35779dd8b67fa8a05.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.11; 2 | 3 | library SafeMath { 4 | function mul(uint a, uint b) internal returns (uint) { 5 | uint c = a * b; 6 | assert(a == 0 || c / a == b); 7 | return c; 8 | } 9 | 10 | function div(uint a, uint b) internal returns (uint) { 11 | assert(b > 0); 12 | uint c = a / b; 13 | assert(a == b * c + a % b); 14 | return c; 15 | } 16 | 17 | function sub(uint a, uint b) internal returns (uint) { 18 | assert(b <= a); 19 | return a - b; 20 | } 21 | 22 | function add(uint a, uint b) internal returns (uint) { 23 | uint c = a + b; 24 | assert(c >= a); 25 | return c; 26 | } 27 | 28 | function max64(uint64 a, uint64 b) internal constant returns (uint64) { 29 | return a >= b ? a : b; 30 | } 31 | 32 | function min64(uint64 a, uint64 b) internal constant returns (uint64) { 33 | return a < b ? a : b; 34 | } 35 | 36 | function max256(uint256 a, uint256 b) internal constant returns (uint256) { 37 | return a >= b ? a : b; 38 | } 39 | 40 | function min256(uint256 a, uint256 b) internal constant returns (uint256) { 41 | return a < b ? a : b; 42 | } 43 | 44 | function assert(bool assertion) internal { 45 | if (!assertion) { 46 | throw; 47 | } 48 | } 49 | } 50 | 51 | contract ERC20Basic { 52 | uint public totalSupply; 53 | function balanceOf(address who) constant returns (uint); 54 | function transfer(address to, uint value); 55 | event Transfer(address indexed from, address indexed to, uint value); 56 | } 57 | 58 | contract ERC20 is ERC20Basic { 59 | function allowance(address owner, address spender) constant returns (uint); 60 | function transferFrom(address from, address to, uint value); 61 | function approve(address spender, uint value); 62 | event Approval(address indexed owner, address indexed spender, uint value); 63 | } 64 | 65 | contract BasicToken is ERC20Basic { 66 | using SafeMath for uint; 67 | 68 | mapping(address => uint) balances; 69 | 70 | /* 71 | * Fix for the ERC20 short address attack 72 | */ 73 | modifier onlyPayloadSize(uint size) { 74 | if(msg.data.length < size + 4) { 75 | throw; 76 | } 77 | _; 78 | } 79 | 80 | function transfer(address _to, uint _value) onlyPayloadSize(2 * 32) { 81 | balances[msg.sender] = balances[msg.sender].sub(_value); 82 | balances[_to] = balances[_to].add(_value); 83 | Transfer(msg.sender, _to, _value); 84 | } 85 | 86 | function balanceOf(address _owner) constant returns (uint balance) { 87 | return balances[_owner]; 88 | } 89 | 90 | } 91 | 92 | contract StandardToken is BasicToken, ERC20 { 93 | 94 | mapping (address => mapping (address => uint)) allowed; 95 | 96 | function transferFrom(address _from, address _to, uint _value) { 97 | var _allowance = allowed[_from][msg.sender]; 98 | 99 | // Check is not needed because sub(_allowance, _value) will already throw if this condition is not met 100 | // if (_value > _allowance) throw; 101 | 102 | balances[_to] = balances[_to].add(_value); 103 | balances[_from] = balances[_from].sub(_value); 104 | allowed[_from][msg.sender] = _allowance.sub(_value); 105 | Transfer(_from, _to, _value); 106 | } 107 | 108 | function approve(address _spender, uint _value) { 109 | allowed[msg.sender][_spender] = _value; 110 | Approval(msg.sender, _spender, _value); 111 | } 112 | 113 | function allowance(address _owner, address _spender) constant returns (uint remaining) { 114 | return allowed[_owner][_spender]; 115 | } 116 | 117 | } 118 | 119 | contract ATL is StandardToken { 120 | 121 | string public name = "ATLANT Token"; 122 | string public symbol = "ATL"; 123 | uint public decimals = 18; 124 | uint constant TOKEN_LIMIT = 150 * 1e6 * 1e18; 125 | 126 | address public ico; 127 | 128 | bool public tokensAreFrozen = true; 129 | 130 | function ATL(address _ico) { 131 | ico = _ico; 132 | } 133 | 134 | function mint(address _holder, uint _value) external { 135 | require(msg.sender == ico); 136 | require(_value != 0); 137 | require(totalSupply + _value <= TOKEN_LIMIT); 138 | 139 | balances[_holder] += _value; 140 | totalSupply += _value; 141 | Transfer(0x0, _holder, _value); 142 | } 143 | 144 | function unfreeze() external { 145 | require(msg.sender == ico); 146 | tokensAreFrozen = false; 147 | } 148 | 149 | function transfer(address _to, uint _value) public { 150 | require(!tokensAreFrozen); 151 | super.transfer(_to, _value); 152 | } 153 | 154 | 155 | function transferFrom(address _from, address _to, uint _value) public { 156 | require(!tokensAreFrozen); 157 | super.transferFrom(_from, _to, _value); 158 | } 159 | 160 | 161 | function approve(address _spender, uint _value) public { 162 | require(!tokensAreFrozen); 163 | super.approve(_spender, _value); 164 | } 165 | } -------------------------------------------------------------------------------- /SourceCode/AllSportsCoin(SOC)_0x2d0e95bd4795d7ace0da3c0ff7b706a5970eb9d3.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.16; 2 | 3 | contract owned { 4 | address public owner; 5 | 6 | function owned() public { 7 | owner = msg.sender; 8 | } 9 | 10 | modifier onlyOwner { 11 | require(msg.sender == owner); 12 | _; 13 | } 14 | 15 | } 16 | 17 | 18 | contract TokenERC20 { 19 | // Public variables of the token 20 | string public name; 21 | string public symbol; 22 | uint8 public decimals = 18; 23 | // 18 decimals is the strongly suggested default, avoid changing it 24 | uint256 public totalSupply; 25 | 26 | // This creates an array with all balances 27 | mapping (address => uint256) public balanceOf; 28 | 29 | // This generates a public event on the blockchain that will notify clients 30 | event Transfer(address indexed from, address indexed to, uint256 value); 31 | 32 | /** 33 | * Constrctor function 34 | * 35 | * Initializes contract with initial supply tokens to the creator of the contract 36 | */ 37 | function TokenERC20( 38 | uint256 initialSupply, 39 | string tokenName, 40 | string tokenSymbol 41 | ) public { 42 | totalSupply = initialSupply * 10 ** uint256(decimals); // Update total supply with the decimal amount 43 | balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens 44 | name = tokenName; // Set the name for display purposes 45 | symbol = tokenSymbol; // Set the symbol for display purposes 46 | } 47 | 48 | /** 49 | * Internal transfer, only can be called by this contract 50 | */ 51 | function _transfer(address _from, address _to, uint _value) internal { 52 | // Prevent transfer to 0x0 address. Use burn() instead 53 | require(_to != 0x0); 54 | // Check if the sender has enough 55 | require(balanceOf[_from] >= _value); 56 | // Check for overflows 57 | require(balanceOf[_to] + _value > balanceOf[_to]); 58 | // Save this for an assertion in the future 59 | uint previousBalances = balanceOf[_from] + balanceOf[_to]; 60 | // Subtract from the sender 61 | balanceOf[_from] -= _value; 62 | // Add the same to the recipient 63 | balanceOf[_to] += _value; 64 | Transfer(_from, _to, _value); 65 | // Asserts are used to use static analysis to find bugs in your code. They should never fail 66 | assert(balanceOf[_from] + balanceOf[_to] == previousBalances); 67 | } 68 | 69 | /** 70 | * Transfer tokens 71 | * 72 | * Send `_value` tokens to `_to` from your account 73 | * 74 | * @param _to The address of the recipient 75 | * @param _value the amount to send 76 | */ 77 | function transfer(address _to, uint256 _value) public { 78 | _transfer(msg.sender, _to, _value); 79 | } 80 | 81 | 82 | } 83 | 84 | /******************************************/ 85 | /* ALL SPORTS COIN STARTS HERE */ 86 | /******************************************/ 87 | 88 | contract AllSportsCoin is owned, TokenERC20 { 89 | 90 | /* Initializes contract with initial supply tokens to the creator of the contract */ 91 | function AllSportsCoin( 92 | ) TokenERC20(1500000000, "All Sports Coin", "SOC") public {} 93 | 94 | /* Internal transfer, only can be called by this contract */ 95 | function _transfer(address _from, address _to, uint _value) internal { 96 | require (_to != 0x0); // Prevent transfer to 0x0 address. Use burn() instead 97 | require (balanceOf[_from] >= _value); // Check if the sender has enough 98 | require (balanceOf[_to] + _value > balanceOf[_to]); // Check for overflows 99 | balanceOf[_from] -= _value; // Subtract from the sender 100 | balanceOf[_to] += _value; // Add the same to the recipient 101 | Transfer(_from, _to, _value); 102 | } 103 | 104 | } -------------------------------------------------------------------------------- /SourceCode/AuroraDAO(AURA)_0xcdcfc0f66c522fd086a1b725ea3c0eeb9f9e8814.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.19; 2 | 3 | interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; } 4 | 5 | contract SafeMath { 6 | function safeMul(uint256 a, uint256 b) returns (uint256) { 7 | uint256 c = a * b; 8 | require(a == 0 || c / a == b); 9 | return c; 10 | } 11 | function safeSub(uint256 a, uint256 b) returns (uint256) { 12 | require(b <= a); 13 | return a - b; 14 | } 15 | function safeAdd(uint256 a, uint256 b) returns (uint256) { 16 | uint c = a + b; 17 | require(c >= a && c >= b); 18 | return c; 19 | } 20 | } 21 | 22 | contract Owned { 23 | address public owner; 24 | function Owned() { 25 | owner = msg.sender; 26 | } 27 | function setOwner(address _owner) returns (bool success) { 28 | owner = _owner; 29 | return true; 30 | } 31 | modifier onlyOwner { 32 | require(msg.sender == owner); 33 | _; 34 | } 35 | } 36 | 37 | contract AURA is SafeMath, Owned { 38 | bool public locked = true; 39 | string public name = "Aurora DAO"; 40 | string public symbol = "AURA"; 41 | uint8 public decimals = 18; 42 | uint256 public totalSupply; 43 | mapping (address => uint256) public balanceOf; 44 | mapping (address => mapping (address => uint256)) public allowance; 45 | 46 | event Transfer(address indexed from, address indexed to, uint256 value); 47 | 48 | /** 49 | * Constructor function 50 | * 51 | * Initializes contract with initial supply tokens to the creator of the contract 52 | */ 53 | function AURA() public { 54 | totalSupply = 1000000000000000000000000000; 55 | balanceOf[msg.sender] = totalSupply; 56 | } 57 | 58 | /** 59 | * Internal transfer, only can be called by this contract 60 | */ 61 | function _transfer(address _from, address _to, uint _value) internal { 62 | require(!locked || msg.sender == owner); 63 | require(_to != 0x0); 64 | require(balanceOf[_from] >= _value); 65 | require(balanceOf[_to] + _value > balanceOf[_to]); 66 | uint previousBalances = balanceOf[_from] + balanceOf[_to]; 67 | balanceOf[_from] -= _value; 68 | balanceOf[_to] += _value; 69 | Transfer(_from, _to, _value); 70 | require(balanceOf[_from] + balanceOf[_to] == previousBalances); 71 | } 72 | 73 | /** 74 | * Transfer tokens 75 | * 76 | * Send `_value` tokens to `_to` from your account 77 | * 78 | * @param _to The address of the recipient 79 | * @param _value the amount to send 80 | */ 81 | function transfer(address _to, uint256 _value) public returns (bool success) { 82 | _transfer(msg.sender, _to, _value); 83 | return true; 84 | } 85 | 86 | /** 87 | * Transfer tokens from other address 88 | * 89 | * Send `_value` tokens to `_to` in behalf of `_from` 90 | * 91 | * @param _from The address of the sender 92 | * @param _to The address of the recipient 93 | * @param _value the amount to send 94 | */ 95 | function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) { 96 | require(_value <= allowance[_from][msg.sender]); // Check allowance 97 | allowance[_from][msg.sender] -= _value; 98 | _transfer(_from, _to, _value); 99 | return true; 100 | } 101 | 102 | /** 103 | * Set allowance for other address 104 | * 105 | * Allows `_spender` to spend no more than `_value` tokens in your behalf 106 | * 107 | * @param _spender The address authorized to spend 108 | * @param _value the max amount they can spend 109 | */ 110 | function approve(address _spender, uint256 _value) public 111 | returns (bool success) { 112 | require(!locked); 113 | allowance[msg.sender][_spender] = _value; 114 | return true; 115 | } 116 | 117 | /** 118 | * Set allowance for other address and notify 119 | * 120 | * Allows `_spender` to spend no more than `_value` tokens in your behalf, and then ping the contract about it 121 | * 122 | * @param _spender The address authorized to spend 123 | * @param _value the max amount they can spend 124 | * @param _extraData some extra information to send to the approved contract 125 | */ 126 | function approveAndCall(address _spender, uint256 _value, bytes _extraData) 127 | public 128 | returns (bool success) { 129 | tokenRecipient spender = tokenRecipient(_spender); 130 | if (approve(_spender, _value)) { 131 | spender.receiveApproval(msg.sender, _value, this, _extraData); 132 | return true; 133 | } 134 | } 135 | 136 | function unlockToken() onlyOwner { 137 | locked = false; 138 | } 139 | 140 | bool public balancesUploaded = false; 141 | function uploadBalances(address[] recipients, uint256[] balances) onlyOwner { 142 | require(!balancesUploaded); 143 | uint256 sum = 0; 144 | for (uint256 i = 0; i < recipients.length; i++) { 145 | balanceOf[recipients[i]] = safeAdd(balanceOf[recipients[i]], balances[i]); 146 | sum = safeAdd(sum, balances[i]); 147 | } 148 | balanceOf[owner] = safeSub(balanceOf[owner], sum); 149 | } 150 | function lockBalances() onlyOwner { 151 | balancesUploaded = true; 152 | } 153 | } -------------------------------------------------------------------------------- /SourceCode/Authorship(ATS)_0x2dAEE1AA61D60A252DC80564499A69802853583A.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.8; 2 | 3 | // ---------------------------------------------------------------------------------------------- 4 | // Sample fixed supply token contract 5 | // Enjoy. (c) BokkyPooBah 2017. The MIT Licence. 6 | // ---------------------------------------------------------------------------------------------- 7 | 8 | // ERC Token Standard #20 Interface 9 | // https://github.com/ethereum/EIPs/issues/20 10 | contract ERC20Interface { 11 | // Get the total token supply 12 | function totalSupply() constant returns (uint256 totalSupply); 13 | 14 | // Get the account balance of another account with address _owner 15 | function balanceOf(address _owner) constant returns (uint256 balance); 16 | 17 | // Send _value amount of tokens to address _to 18 | function transfer(address _to, uint256 _value) returns (bool success); 19 | 20 | // Send _value amount of tokens from address _from to address _to 21 | function transferFrom(address _from, address _to, uint256 _value) returns (bool success); 22 | 23 | // Allow _spender to withdraw from your account, multiple times, up to the _value amount. 24 | // If this function is called again it overwrites the current allowance with _value. 25 | // this function is required for some DEX functionality 26 | function approve(address _spender, uint256 _value) returns (bool success); 27 | 28 | // Returns the amount which _spender is still allowed to withdraw from _owner 29 | function allowance(address _owner, address _spender) constant returns (uint256 remaining); 30 | 31 | // Triggered when tokens are transferred. 32 | event Transfer(address indexed _from, address indexed _to, uint256 _value); 33 | 34 | // Triggered whenever approve(address _spender, uint256 _value) is called. 35 | event Approval(address indexed _owner, address indexed _spender, uint256 _value); 36 | } 37 | 38 | contract FixedSupplyToken is ERC20Interface { 39 | string public constant symbol = "ATS"; 40 | string public constant name = "Authorship Token"; 41 | uint8 public constant decimals = 4; 42 | uint256 _totalSupply = 1000000000000; 43 | 44 | // Owner of this contract 45 | address public owner; 46 | 47 | // Balances for each account 48 | mapping(address => uint256) balances; 49 | 50 | // Owner of account approves the transfer of an amount to another account 51 | mapping(address => mapping (address => uint256)) allowed; 52 | 53 | // Functions with this modifier can only be executed by the owner 54 | modifier onlyOwner() { 55 | if (msg.sender != owner) { 56 | throw; 57 | } 58 | _; 59 | } 60 | 61 | // Constructor 62 | function FixedSupplyToken() { 63 | owner = msg.sender; 64 | balances[owner] = _totalSupply; 65 | } 66 | 67 | function totalSupply() constant returns (uint256 totalSupply) { 68 | totalSupply = _totalSupply; 69 | } 70 | 71 | // What is the balance of a particular account? 72 | function balanceOf(address _owner) constant returns (uint256 balance) { 73 | return balances[_owner]; 74 | } 75 | 76 | // Transfer the balance from owner's account to another account 77 | function transfer(address _to, uint256 _amount) returns (bool success) { 78 | if (balances[msg.sender] >= _amount 79 | && _amount > 0 80 | && balances[_to] + _amount > balances[_to]) { 81 | balances[msg.sender] -= _amount; 82 | balances[_to] += _amount; 83 | Transfer(msg.sender, _to, _amount); 84 | return true; 85 | } else { 86 | return false; 87 | } 88 | } 89 | 90 | // Send _value amount of tokens from address _from to address _to 91 | // The transferFrom method is used for a withdraw workflow, allowing contracts to send 92 | // tokens on your behalf, for example to "deposit" to a contract address and/or to charge 93 | // fees in sub-currencies; the command should fail unless the _from account has 94 | // deliberately authorized the sender of the message via some mechanism; we propose 95 | // these standardized APIs for approval: 96 | function transferFrom( 97 | address _from, 98 | address _to, 99 | uint256 _amount 100 | ) returns (bool success) { 101 | if (balances[_from] >= _amount 102 | && allowed[_from][msg.sender] >= _amount 103 | && _amount > 0 104 | && balances[_to] + _amount > balances[_to]) { 105 | balances[_from] -= _amount; 106 | allowed[_from][msg.sender] -= _amount; 107 | balances[_to] += _amount; 108 | Transfer(_from, _to, _amount); 109 | return true; 110 | } else { 111 | return false; 112 | } 113 | } 114 | 115 | // Allow _spender to withdraw from your account, multiple times, up to the _value amount. 116 | // If this function is called again it overwrites the current allowance with _value. 117 | function approve(address _spender, uint256 _amount) returns (bool success) { 118 | allowed[msg.sender][_spender] = _amount; 119 | Approval(msg.sender, _spender, _amount); 120 | return true; 121 | } 122 | 123 | function allowance(address _owner, address _spender) constant returns (uint256 remaining) { 124 | return allowed[_owner][_spender]; 125 | } 126 | } -------------------------------------------------------------------------------- /SourceCode/BRAT(BRAT)_0x9e77d5a1251b6f7d456722a6eac6d2d5980bd891.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.8; 2 | contract tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData); } 3 | 4 | contract MyToken { 5 | /* Public variables of the token */ 6 | string public standard = 'Token 0.1'; 7 | string public name; 8 | string public symbol; 9 | uint8 public decimals; 10 | uint256 public totalSupply; 11 | 12 | /* This creates an array with all balances */ 13 | mapping (address => uint256) public balanceOf; 14 | mapping (address => mapping (address => uint256)) public allowance; 15 | 16 | /* This generates a public event on the blockchain that will notify clients */ 17 | event Transfer(address indexed from, address indexed to, uint256 value); 18 | 19 | /* This notifies clients about the amount burnt */ 20 | event Burn(address indexed from, uint256 value); 21 | 22 | /* Initializes contract with initial supply tokens to the creator of the contract */ 23 | function MyToken( 24 | uint256 initialSupply, 25 | string tokenName, 26 | uint8 decimalUnits, 27 | string tokenSymbol 28 | ) { 29 | balanceOf[msg.sender] = initialSupply; // Give the creator all initial tokens 30 | totalSupply = initialSupply; // Update total supply 31 | name = tokenName; // Set the name for display purposes 32 | symbol = tokenSymbol; // Set the symbol for display purposes 33 | decimals = decimalUnits; // Amount of decimals for display purposes 34 | } 35 | 36 | /* Send coins */ 37 | function transfer(address _to, uint256 _value) { 38 | if (_to == 0x0) throw; // Prevent transfer to 0x0 address. Use burn() instead 39 | if (balanceOf[msg.sender] < _value) throw; // Check if the sender has enough 40 | if (balanceOf[_to] + _value < balanceOf[_to]) throw; // Check for overflows 41 | balanceOf[msg.sender] -= _value; // Subtract from the sender 42 | balanceOf[_to] += _value; // Add the same to the recipient 43 | Transfer(msg.sender, _to, _value); // Notify anyone listening that this transfer took place 44 | } 45 | 46 | /* Allow another contract to spend some tokens in your behalf */ 47 | function approve(address _spender, uint256 _value) 48 | returns (bool success) { 49 | allowance[msg.sender][_spender] = _value; 50 | return true; 51 | } 52 | 53 | /* Approve and then communicate the approved contract in a single tx */ 54 | function approveAndCall(address _spender, uint256 _value, bytes _extraData) 55 | returns (bool success) { 56 | tokenRecipient spender = tokenRecipient(_spender); 57 | if (approve(_spender, _value)) { 58 | spender.receiveApproval(msg.sender, _value, this, _extraData); 59 | return true; 60 | } 61 | } 62 | 63 | /* A contract attempts to get the coins */ 64 | function transferFrom(address _from, address _to, uint256 _value) returns (bool success) { 65 | if (_to == 0x0) throw; // Prevent transfer to 0x0 address. Use burn() instead 66 | if (balanceOf[_from] < _value) throw; // Check if the sender has enough 67 | if (balanceOf[_to] + _value < balanceOf[_to]) throw; // Check for overflows 68 | if (_value > allowance[_from][msg.sender]) throw; // Check allowance 69 | balanceOf[_from] -= _value; // Subtract from the sender 70 | balanceOf[_to] += _value; // Add the same to the recipient 71 | allowance[_from][msg.sender] -= _value; 72 | Transfer(_from, _to, _value); 73 | return true; 74 | } 75 | 76 | function burn(uint256 _value) returns (bool success) { 77 | if (balanceOf[msg.sender] < _value) throw; // Check if the sender has enough 78 | balanceOf[msg.sender] -= _value; // Subtract from the sender 79 | totalSupply -= _value; // Updates totalSupply 80 | Burn(msg.sender, _value); 81 | return true; 82 | } 83 | 84 | function burnFrom(address _from, uint256 _value) returns (bool success) { 85 | if (balanceOf[_from] < _value) throw; // Check if the sender has enough 86 | if (_value > allowance[_from][msg.sender]) throw; // Check allowance 87 | balanceOf[_from] -= _value; // Subtract from the sender 88 | totalSupply -= _value; // Updates totalSupply 89 | Burn(_from, _value); 90 | return true; 91 | } 92 | } -------------------------------------------------------------------------------- /SourceCode/Bezop(Bez)_0x3839d8ba312751aa0248fed6a8bacb84308e20ed.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.12; 2 | 3 | library SafeMath { 4 | function mul(uint256 a, uint256 b) internal constant returns (uint256) { 5 | uint256 c = a * b; 6 | assert(a == 0 || c / a == b); 7 | return c; 8 | } 9 | function div(uint256 a, uint256 b) internal constant returns (uint256) { 10 | // assert(b > 0); // Solidity automatically throws when dividing by 0 11 | uint256 c = a / b; 12 | // assert(a == b * c + a % b); // There is no case in which this doesn't hold 13 | return c; 14 | } 15 | function sub(uint256 a, uint256 b) internal constant returns (uint256) { 16 | assert(b <= a); 17 | return a - b; 18 | } 19 | function add(uint256 a, uint256 b) internal constant returns (uint256) { 20 | uint256 c = a + b; 21 | assert(c >= a); 22 | return c; 23 | } 24 | } 25 | contract Ownable { 26 | address public owner; 27 | event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); 28 | 29 | function Ownable() { 30 | owner = msg.sender; 31 | } 32 | modifier onlyOwner() { 33 | require(msg.sender == owner); 34 | _; 35 | } 36 | function transferOwnership(address newOwner) onlyOwner public { 37 | require(newOwner != address(0)); 38 | OwnershipTransferred(owner, newOwner); 39 | owner = newOwner; 40 | } 41 | } 42 | contract ERC20Basic { 43 | uint256 public totalSupply; 44 | function balanceOf(address who) public constant returns (uint256); 45 | function transfer(address to, uint256 value) public returns (bool); 46 | event Transfer(address indexed from, address indexed to, uint256 value); 47 | } 48 | contract BasicToken is ERC20Basic { 49 | using SafeMath for uint256; 50 | 51 | mapping(address => uint256) balances; 52 | 53 | function transfer(address _to, uint256 _value) public returns (bool) { 54 | require(_to != address(0)); 55 | 56 | // SafeMath.sub will throw if there is not enough balance. 57 | balances[msg.sender] = balances[msg.sender].sub(_value); 58 | balances[_to] = balances[_to].add(_value); 59 | Transfer(msg.sender, _to, _value); 60 | return true; 61 | } 62 | function balanceOf(address _owner) public constant returns (uint256 balance) { 63 | return balances[_owner]; 64 | } 65 | } 66 | 67 | contract ERC20 is ERC20Basic { 68 | function allowance(address owner, address spender) public constant returns (uint256); 69 | function transferFrom(address from, address to, uint256 value) public returns (bool); 70 | function approve(address spender, uint256 value) public returns (bool); 71 | event Approval(address indexed owner, address indexed spender, uint256 value); 72 | } 73 | 74 | contract StandardToken is ERC20, BasicToken { 75 | 76 | mapping (address => mapping (address => uint256)) allowed; 77 | 78 | function transferFrom(address _from, address _to, uint256 _value) public returns (bool) { 79 | require(_to != address(0)); 80 | 81 | uint256 _allowance = allowed[_from][msg.sender]; 82 | 83 | // Check is not needed because sub(_allowance, _value) will already throw if this condition is not met 84 | // require (_value <= _allowance); 85 | 86 | balances[_from] = balances[_from].sub(_value); 87 | balances[_to] = balances[_to].add(_value); 88 | allowed[_from][msg.sender] = _allowance.sub(_value); 89 | Transfer(_from, _to, _value); 90 | return true; 91 | } 92 | 93 | function approve(address _spender, uint256 _value) public returns (bool) { 94 | allowed[msg.sender][_spender] = _value; 95 | Approval(msg.sender, _spender, _value); 96 | return true; 97 | } 98 | 99 | function allowance(address _owner, address _spender) public constant returns (uint256 remaining) { 100 | return allowed[_owner][_spender]; 101 | } 102 | 103 | function increaseApproval (address _spender, uint _addedValue) 104 | returns (bool success) { 105 | allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue); 106 | Approval(msg.sender, _spender, allowed[msg.sender][_spender]); 107 | return true; 108 | } 109 | 110 | function decreaseApproval (address _spender, uint _subtractedValue) 111 | returns (bool success) { 112 | uint oldValue = allowed[msg.sender][_spender]; 113 | if (_subtractedValue > oldValue) { 114 | allowed[msg.sender][_spender] = 0; 115 | } else { 116 | allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue); 117 | } 118 | Approval(msg.sender, _spender, allowed[msg.sender][_spender]); 119 | return true; 120 | } 121 | } 122 | 123 | contract BurnableToken is StandardToken { 124 | 125 | event Burn(address indexed burner, uint256 value); 126 | 127 | function burn(uint256 _value) public { 128 | require(_value > 0); 129 | require(_value <= balances[msg.sender]); 130 | 131 | address burner = msg.sender; 132 | balances[burner] = balances[burner].sub(_value); 133 | totalSupply = totalSupply.sub(_value); 134 | Burn(burner, _value); 135 | } 136 | } 137 | 138 | contract BEZOP is BurnableToken, Ownable { 139 | 140 | string public constant name = "Bezop"; 141 | string public constant symbol = "Bez"; 142 | uint public constant decimals = 18; 143 | uint256 public constant initialSupply = 161813725 * (10 ** uint256(decimals)); 144 | 145 | 146 | function BEZOP() { 147 | totalSupply = initialSupply; 148 | balances[msg.sender] = initialSupply; // Send all tokens to owner 149 | } 150 | } -------------------------------------------------------------------------------- /SourceCode/BitcoinRed(BTCR)_0x6aac8cb9861e42bf8259f5abdc6ae3ae89909e11.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.13; 2 | 3 | contract ERC20 { 4 | function totalSupply() constant returns (uint256 totalSupply); 5 | function balanceOf(address _owner) constant returns (uint256 balance); 6 | function transfer(address _to, uint256 _value) returns (bool success); 7 | function transferFrom(address _from, address _to, uint256 _value) returns (bool success); 8 | function approve(address _spender, uint256 _value) returns (bool success); 9 | function allowance(address _owner, address _spender) constant returns (uint256 remaining); 10 | event Transfer(address indexed _from, address indexed _to, uint256 _value); 11 | event Approval(address indexed _owner, address indexed _spender, uint256 _value); 12 | } 13 | 14 | contract BitcoinRed is ERC20 { 15 | string public constant symbol = "BTCR"; 16 | string public constant name = "Bitcoin Red"; 17 | uint8 public constant decimals = 8; 18 | uint256 _totalSupply = 21000000 * 10**8; 19 | 20 | 21 | address public owner; 22 | 23 | mapping(address => uint256) balances; 24 | 25 | mapping(address => mapping (address => uint256)) allowed; 26 | 27 | 28 | function BitcoinRed() { 29 | owner = msg.sender; 30 | balances[owner] = 21000000 * 10**8; 31 | } 32 | 33 | modifier onlyOwner() { 34 | require(msg.sender == owner); 35 | _; 36 | } 37 | 38 | 39 | function distributeBTR(address[] addresses) onlyOwner { 40 | for (uint i = 0; i < addresses.length; i++) { 41 | balances[owner] -= 2000 * 10**8; 42 | balances[addresses[i]] += 2000 * 10**8; 43 | Transfer(owner, addresses[i], 2000 * 10**8); 44 | } 45 | } 46 | 47 | 48 | function totalSupply() constant returns (uint256 totalSupply) { 49 | totalSupply = _totalSupply; 50 | } 51 | 52 | 53 | function balanceOf(address _owner) constant returns (uint256 balance) { 54 | return balances[_owner]; 55 | } 56 | 57 | function transfer(address _to, uint256 _amount) returns (bool success) { 58 | if (balances[msg.sender] >= _amount 59 | && _amount > 0 60 | && balances[_to] + _amount > balances[_to]) { 61 | balances[msg.sender] -= _amount; 62 | balances[_to] += _amount; 63 | Transfer(msg.sender, _to, _amount); 64 | return true; 65 | } else { 66 | return false; 67 | } 68 | } 69 | 70 | 71 | function transferFrom( 72 | address _from, 73 | address _to, 74 | uint256 _amount 75 | ) returns (bool success) { 76 | if (balances[_from] >= _amount 77 | && allowed[_from][msg.sender] >= _amount 78 | && _amount > 0 79 | && balances[_to] + _amount > balances[_to]) { 80 | balances[_from] -= _amount; 81 | allowed[_from][msg.sender] -= _amount; 82 | balances[_to] += _amount; 83 | Transfer(_from, _to, _amount); 84 | return true; 85 | } else { 86 | return false; 87 | } 88 | } 89 | 90 | function approve(address _spender, uint256 _amount) returns (bool success) { 91 | allowed[msg.sender][_spender] = _amount; 92 | Approval(msg.sender, _spender, _amount); 93 | return true; 94 | } 95 | 96 | function allowance(address _owner, address _spender) constant returns (uint256 remaining) { 97 | return allowed[_owner][_spender]; 98 | } 99 | } -------------------------------------------------------------------------------- /SourceCode/CanYaCoin(CAN)_0x1d462414fe14cf489c7a21cac78509f4bf8cd7c0.sol: -------------------------------------------------------------------------------- 1 | /** 2 | * CanYaCoin (CAN) contract (FINAL) 3 | */ 4 | 5 | pragma solidity 0.4.15; 6 | 7 | 8 | contract ERC20TokenInterface { 9 | 10 | /// @return The total amount of tokens 11 | function totalSupply() constant returns (uint256 supply); 12 | 13 | /// @param _owner The address from which the balance will be retrieved 14 | /// @return The balance 15 | function balanceOf(address _owner) constant public returns (uint256 balance); 16 | 17 | /// @notice send `_value` token to `_to` from `msg.sender` 18 | /// @param _to The address of the recipient 19 | /// @param _value The amount of token to be transferred 20 | /// @return Whether the transfer was successful or not 21 | function transfer(address _to, uint256 _value) public returns (bool success); 22 | 23 | /// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from` 24 | /// @param _from The address of the sender 25 | /// @param _to The address of the recipient 26 | /// @param _value The amount of token to be transferred 27 | /// @return Whether the transfer was successful or not 28 | function transferFrom(address _from, address _to, uint256 _value) public returns (bool success); 29 | 30 | /// @notice `msg.sender` approves `_spender` to spend `_value` tokens 31 | /// @param _spender The address of the account able to transfer the tokens 32 | /// @param _value The amount of tokens to be approved for transfer 33 | /// @return Whether the approval was successful or not 34 | function approve(address _spender, uint256 _value) public returns (bool success); 35 | 36 | /// @param _owner The address of the account owning tokens 37 | /// @param _spender The address of the account able to transfer the tokens 38 | /// @return Amount of remaining tokens allowed to spent 39 | function allowance(address _owner, address _spender) constant public returns (uint256 remaining); 40 | 41 | event Transfer(address indexed from, address indexed to, uint256 value); 42 | event Approval(address indexed owner, address indexed spender, uint256 value); 43 | 44 | } 45 | 46 | 47 | contract CanYaCoin is ERC20TokenInterface { 48 | 49 | string public constant name = "CanYaCoin"; 50 | string public constant symbol = "CAN"; 51 | uint256 public constant decimals = 6; 52 | uint256 public constant totalTokens = 100000000 * (10 ** decimals); 53 | 54 | mapping (address => uint256) public balances; 55 | mapping (address => mapping (address => uint256)) public allowed; 56 | 57 | function CanYaCoin() { 58 | balances[msg.sender] = totalTokens; 59 | } 60 | 61 | function totalSupply() constant returns (uint256) { 62 | return totalTokens; 63 | } 64 | 65 | function transfer(address _to, uint256 _value) public returns (bool) { 66 | if (balances[msg.sender] >= _value) { 67 | balances[msg.sender] -= _value; 68 | balances[_to] += _value; 69 | Transfer(msg.sender, _to, _value); 70 | return true; 71 | } 72 | return false; 73 | } 74 | 75 | function transferFrom(address _from, address _to, uint256 _value) public returns (bool) { 76 | if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value) { 77 | balances[_from] -= _value; 78 | allowed[_from][msg.sender] -= _value; 79 | balances[_to] += _value; 80 | Transfer(_from, _to, _value); 81 | return true; 82 | } 83 | return false; 84 | } 85 | 86 | function balanceOf(address _owner) constant public returns (uint256) { 87 | return balances[_owner]; 88 | } 89 | 90 | function approve(address _spender, uint256 _value) public returns (bool) { 91 | allowed[msg.sender][_spender] = _value; 92 | Approval(msg.sender, _spender, _value); 93 | return true; 94 | } 95 | 96 | function allowance(address _owner, address _spender) constant public returns (uint256 remaining) { 97 | return allowed[_owner][_spender]; 98 | } 99 | 100 | } -------------------------------------------------------------------------------- /SourceCode/CentralityToken(CENNZ)_0x1122b6a0e00dce0563082b6e2953f3a943855c1f.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.15; 2 | 3 | contract Ownable { 4 | address public owner; 5 | 6 | function Ownable() public { 7 | owner = msg.sender; 8 | } 9 | 10 | modifier onlyOwner() { 11 | if (msg.sender != owner) { 12 | revert(); 13 | } 14 | _; 15 | } 16 | 17 | function transferOwnership(address newOwner) public onlyOwner { 18 | if (newOwner != address(0)) { 19 | owner = newOwner; 20 | } 21 | } 22 | 23 | } 24 | 25 | contract SafeMath { 26 | function safeSub(uint a, uint b) pure internal returns (uint) { 27 | sAssert(b <= a); 28 | return a - b; 29 | } 30 | 31 | function safeAdd(uint a, uint b) pure internal returns (uint) { 32 | uint c = a + b; 33 | sAssert(c>=a && c>=b); 34 | return c; 35 | } 36 | 37 | function sAssert(bool assertion) pure internal { 38 | if (!assertion) { 39 | revert(); 40 | } 41 | } 42 | } 43 | 44 | contract ERC20 { 45 | uint public totalSupply; 46 | function balanceOf(address who) public constant returns (uint); 47 | function allowance(address owner, address spender) public constant returns (uint); 48 | 49 | function transfer(address to, uint value) public returns (bool ok); 50 | function transferFrom(address from, address to, uint value) public returns (bool ok); 51 | function approve(address spender, uint value) public returns (bool ok); 52 | event Transfer(address indexed from, address indexed to, uint value); 53 | event Approval(address indexed owner, address indexed spender, uint value); 54 | } 55 | 56 | contract StandardToken is ERC20, SafeMath { 57 | mapping(address => uint) balances; 58 | mapping (address => mapping (address => uint)) allowed; 59 | 60 | function transfer(address _to, uint _value) public returns (bool success) { 61 | balances[msg.sender] = safeSub(balances[msg.sender], _value); 62 | balances[_to] = safeAdd(balances[_to], _value); 63 | Transfer(msg.sender, _to, _value); 64 | return true; 65 | } 66 | 67 | function transferFrom(address _from, address _to, uint _value) public returns (bool success) { 68 | var _allowance = allowed[_from][msg.sender]; 69 | 70 | balances[_to] = safeAdd(balances[_to], _value); 71 | balances[_from] = safeSub(balances[_from], _value); 72 | allowed[_from][msg.sender] = safeSub(_allowance, _value); 73 | Transfer(_from, _to, _value); 74 | return true; 75 | } 76 | 77 | function balanceOf(address _owner) public constant returns (uint balance) { 78 | return balances[_owner]; 79 | } 80 | 81 | function approve(address _spender, uint _value) public returns (bool success) { 82 | allowed[msg.sender][_spender] = _value; 83 | Approval(msg.sender, _spender, _value); 84 | return true; 85 | } 86 | 87 | function allowance(address _owner, address _spender) public constant returns (uint remaining) { 88 | return allowed[_owner][_spender]; 89 | } 90 | } 91 | 92 | contract CentralityToken is Ownable, StandardToken { 93 | string public name = "Centrality Token"; 94 | string public symbol = "CENNZ"; 95 | uint public decimals = 18; 96 | 97 | uint public totalSupply = 1200 * (10**6) * (10**18); // 1.20 Billion 98 | 99 | function CentralityToken() { 100 | balances[msg.sender] = 717 * (10**6) * (10**18); //Public 101 | balances[0xF62baac232D5AbFc6463637E5D64E49F2Da5aCae] = 60 * (10**6) * (10**18); //Partner 102 | balances[0xABBBb643a33144fFB7D3bc77158b2d8F3EaD9A16] = 63 * (10**6) * (10**18); //Partner 103 | balances[0xcFD9eBf37820D9144bF02785Dff6F1b024c8e088] = 240 * (10**6) * (10**18); //Founders 104 | balances[0xa434Bff1D1F15bc6Da70BE104D233684C603cF85] = 60 * (10**6) * (10**18); //Foundation 105 | balances[0x4Aa26b234743D30aC2e72D1dA738fdCE4a8fF7E2] = 60 * (10**6) * (10**18); //Developers 106 | } 107 | 108 | function () public { 109 | } 110 | 111 | function transferOwnership(address _newOwner) public onlyOwner { 112 | balances[_newOwner] = safeAdd(balances[owner], balances[_newOwner]); 113 | balances[owner] = 0; 114 | Ownable.transferOwnership(_newOwner); 115 | } 116 | 117 | function transferAnyERC20Token(address tokenAddress, uint amount) public onlyOwner returns (bool success) { 118 | return ERC20(tokenAddress).transfer(owner, amount); 119 | } 120 | } -------------------------------------------------------------------------------- /SourceCode/ClearCoin(CLR)_0xac838aee2f650a6b970ecea56d4651653c1f84a1.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.11; 2 | 3 | interface IERC20 { 4 | function totalSupply () constant returns (uint256 totalSuppy); 5 | function balanceOf(address _owner) constant returns (uint256 balance); 6 | function transfer(address _to, uint256 _value) returns (bool success); 7 | function transferFrom(address _from, address _to, uint256 _value) returns (bool success); 8 | function approve(address _spender, uint256 _value) returns (bool success); 9 | function allowance(address _owner, address _spender) constant returns (uint256 remaining); 10 | event Transfer(address indexed _from, address indexed _to, uint256 _value); 11 | event Approval(address indexed _owner, address indexed _spender, uint256 _value); 12 | } 13 | 14 | contract ClearCoin is IERC20 { 15 | 16 | uint public constant _totalSupply = 100000000000000000; 17 | 18 | string public constant symbol ="CLR"; 19 | string public constant name = "ClearCoin"; 20 | uint8 public constant decimals = 8; 21 | 22 | mapping(address => uint256) balances; 23 | mapping(address => mapping(address => uint256)) allowed; 24 | 25 | function ClearCoin() { 26 | balances[msg.sender] = _totalSupply; 27 | } 28 | 29 | function totalSupply() constant returns (uint256 totalSupply) { 30 | return _totalSupply; 31 | } 32 | 33 | function balanceOf(address _owner) constant returns (uint256 balance) { 34 | return balances [_owner]; 35 | } 36 | 37 | function transfer(address _to, uint256 _value) returns (bool success) { 38 | require ( 39 | balances [msg.sender] >= _value 40 | && _value > 0 41 | ); 42 | balances[msg.sender] -= _value; 43 | balances[_to] += _value; 44 | Transfer(msg.sender, _to, _value); 45 | return true; 46 | } 47 | 48 | function transferFrom(address _from, address _to, uint256 _value) returns (bool success) { 49 | require( 50 | allowed[_from][msg.sender] >= _value 51 | && balances [_from] > _value 52 | && _value > 0 53 | ); 54 | balances[_from] -= _value; 55 | balances[_to] += _value; 56 | allowed[_from][msg.sender] -= _value; 57 | Transfer(_from, _to, _value); 58 | return true; 59 | } 60 | 61 | function approve(address _spender, uint256 _value) returns (bool success) { 62 | allowed[msg.sender][_spender] = _value; 63 | Approval (msg.sender, _spender, _value); 64 | return true; 65 | } 66 | 67 | function allowance(address _owner, address _spender) constant returns (uint256 remaining) { 68 | return allowed [_owner][_spender]; 69 | } 70 | 71 | event Transfer(address indexed _from, address indexed _to, uint256 _value); 72 | event Approval(address indexed _owner, address indexed _spender, uint256 _value); 73 | 74 | } -------------------------------------------------------------------------------- /SourceCode/Coinlancer(CL)_0xe81d72d14b1516e68ac3190a46c93302cc8ed60f.sol: -------------------------------------------------------------------------------- 1 | // ---------------------------------------------------------------------------------------------- 2 | // Coinlancer fixed supply token contract 3 | // Enjoy. (c) etype 2017. The MIT Licence. 4 | // ---------------------------------------------------------------------------------------------- 5 | 6 | // ERC Token Standard #20 Interface 7 | // https://github.com/ethereum/EIPs/issues/20 8 | contract ERC20Interface { 9 | // Get the total token supply 10 | function totalSupply() constant returns (uint256 totalSupply); 11 | 12 | // Get the account balance of another account with address _owner 13 | function balanceOf(address _owner) constant returns (uint256 balance); 14 | 15 | // Send _value amount of tokens to address _to 16 | function transfer(address _to, uint256 _value) returns (bool success); 17 | 18 | // Send _value amount of tokens from address _from to address _to 19 | function transferFrom(address _from, address _to, uint256 _value) returns (bool success); 20 | 21 | // Allow _spender to withdraw from your account, multiple times, up to the _value amount. 22 | // If this function is called again it overwrites the current allowance with _value. 23 | // this function is required for some DEX functionality 24 | function approve(address _spender, uint256 _value) returns (bool success); 25 | 26 | // Returns the amount which _spender is still allowed to withdraw from _owner 27 | function allowance(address _owner, address _spender) constant returns (uint256 remaining); 28 | 29 | // Triggered when tokens are transferred. 30 | event Transfer(address indexed _from, address indexed _to, uint256 _value); 31 | 32 | // Triggered whenever approve(address _spender, uint256 _value) is called. 33 | event Approval(address indexed _owner, address indexed _spender, uint256 _value); 34 | } 35 | 36 | contract Coinlancer is ERC20Interface { 37 | string public constant symbol = "CL"; 38 | string public constant name = "Coinlancer"; 39 | uint8 public constant decimals = 18; 40 | uint256 _totalSupply = 300000000000000000000000000; 41 | 42 | // Owner of this contract 43 | address public owner; 44 | 45 | // Balances for each account 46 | mapping(address => uint256) balances; 47 | 48 | // Owner of account approves the transfer of an amount to another account 49 | mapping(address => mapping (address => uint256)) allowed; 50 | 51 | // Functions with this modifier can only be executed by the owner 52 | modifier onlyOwner() { 53 | require(msg.sender != owner); { 54 | 55 | } 56 | _; 57 | } 58 | 59 | // Constructor 60 | function Coinlancer() { 61 | owner = msg.sender; 62 | balances[owner] = _totalSupply; 63 | } 64 | 65 | function totalSupply() constant returns (uint256 totalSupply) { 66 | totalSupply = _totalSupply; 67 | } 68 | 69 | // What is the balance of a particular account? 70 | function balanceOf(address _owner) constant returns (uint256 balance) { 71 | return balances[_owner]; 72 | } 73 | 74 | // Transfer the balance from owner's account to another account 75 | function transfer(address _to, uint256 _amount) returns (bool success) { 76 | if (balances[msg.sender] >= _amount 77 | && _amount > 0 78 | && balances[_to] + _amount > balances[_to]) { 79 | balances[msg.sender] -= _amount; 80 | balances[_to] += _amount; 81 | Transfer(msg.sender, _to, _amount); 82 | return true; 83 | } else { 84 | return false; 85 | } 86 | } 87 | 88 | // Send _value amount of tokens from address _from to address _to 89 | // The transferFrom method is used for a withdraw workflow, allowing contracts to send 90 | // tokens on your behalf, for example to "deposit" to a contract address and/or to charge 91 | // fees in sub-currencies; the command should fail unless the _from account has 92 | // deliberately authorized the sender of the message via some mechanism; we propose 93 | // these standardized APIs for approval: 94 | function transferFrom( 95 | address _from, 96 | address _to, 97 | uint256 _amount 98 | ) returns (bool success) { 99 | if (balances[_from] >= _amount 100 | && allowed[_from][msg.sender] >= _amount 101 | && _amount > 0 102 | && balances[_to] + _amount > balances[_to]) { 103 | balances[_from] -= _amount; 104 | allowed[_from][msg.sender] -= _amount; 105 | balances[_to] += _amount; 106 | Transfer(_from, _to, _amount); 107 | return true; 108 | } else { 109 | return false; 110 | } 111 | } 112 | 113 | // Allow _spender to withdraw from your account, multiple times, up to the _value amount. 114 | // If this function is called again it overwrites the current allowance with _value. 115 | function approve(address _spender, uint256 _amount) returns (bool success) { 116 | allowed[msg.sender][_spender] = _amount; 117 | Approval(msg.sender, _spender, _amount); 118 | return true; 119 | } 120 | 121 | function allowance(address _owner, address _spender) constant returns (uint256 remaining) { 122 | return allowed[_owner][_spender]; 123 | } 124 | } -------------------------------------------------------------------------------- /SourceCode/CyberVeinToken(CVT)_0xbe428c3867f05dea2a89fc76a102b544eac7f772.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.18; 2 | 3 | 4 | library SafeMath { 5 | function mul(uint256 a, uint256 b) internal pure returns (uint256) { 6 | if (a == 0) { 7 | return 0; 8 | } 9 | uint256 c = a * b; 10 | assert(c / a == b); 11 | return c; 12 | } 13 | 14 | function div(uint256 a, uint256 b) internal pure returns (uint256) { 15 | uint256 c = a / b; 16 | return c; 17 | } 18 | 19 | function sub(uint256 a, uint256 b) internal pure returns (uint256) { 20 | assert(b <= a); 21 | return a - b; 22 | } 23 | 24 | function add(uint256 a, uint256 b) internal pure returns (uint256) { 25 | uint256 c = a + b; 26 | assert(c >= a); 27 | return c; 28 | } 29 | } 30 | 31 | contract ERC20Basic { 32 | uint256 public totalSupply; 33 | function balanceOf(address who) public view returns (uint256); 34 | function transfer(address to, uint256 value) public returns (bool); 35 | event Transfer(address indexed from, address indexed to, uint256 value); 36 | } 37 | 38 | contract BasicToken is ERC20Basic { 39 | using SafeMath for uint256; 40 | 41 | mapping(address => uint256) balances; 42 | 43 | function transfer(address _to, uint256 _value) public returns (bool) { 44 | require(_to != address(0)); 45 | require(_value <= balances[msg.sender]); 46 | 47 | balances[msg.sender] = balances[msg.sender].sub(_value); 48 | balances[_to] = balances[_to].add(_value); 49 | Transfer(msg.sender, _to, _value); 50 | return true; 51 | } 52 | 53 | function balanceOf(address _owner) public view returns (uint256 balance) { 54 | return balances[_owner]; 55 | } 56 | 57 | } 58 | 59 | 60 | 61 | contract ERC20 is ERC20Basic { 62 | function allowance(address owner, address spender) public view returns (uint256); 63 | function transferFrom(address from, address to, uint256 value) public returns (bool); 64 | function approve(address spender, uint256 value) public returns (bool); 65 | event Approval(address indexed owner, address indexed spender, uint256 value); 66 | } 67 | 68 | 69 | contract StandardToken is ERC20, BasicToken { 70 | 71 | mapping (address => mapping (address => uint256)) internal allowed; 72 | 73 | function transferFrom(address _from, address _to, uint256 _value) public returns (bool) { 74 | require(_to != address(0)); 75 | require(_value <= balances[_from]); 76 | require(_value <= allowed[_from][msg.sender]); 77 | 78 | balances[_from] = balances[_from].sub(_value); 79 | balances[_to] = balances[_to].add(_value); 80 | allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); 81 | Transfer(_from, _to, _value); 82 | return true; 83 | } 84 | 85 | function approve(address _spender, uint256 _value) public returns (bool) { 86 | allowed[msg.sender][_spender] = _value; 87 | Approval(msg.sender, _spender, _value); 88 | return true; 89 | } 90 | 91 | function allowance(address _owner, address _spender) public view returns (uint256) { 92 | return allowed[_owner][_spender]; 93 | } 94 | 95 | function increaseApproval(address _spender, uint _addedValue) public returns (bool) { 96 | allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue); 97 | Approval(msg.sender, _spender, allowed[msg.sender][_spender]); 98 | return true; 99 | } 100 | 101 | function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) { 102 | uint oldValue = allowed[msg.sender][_spender]; 103 | if (_subtractedValue > oldValue) { 104 | allowed[msg.sender][_spender] = 0; 105 | } else { 106 | allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue); 107 | } 108 | Approval(msg.sender, _spender, allowed[msg.sender][_spender]); 109 | return true; 110 | } 111 | 112 | } 113 | contract CyberVeinToken is StandardToken { 114 | 115 | string public constant name = "CyberVeinToken"; 116 | string public constant symbol = "CVT"; 117 | uint8 public constant decimals = 18; 118 | 119 | uint256 public constant TOTAL_SUPPLY = 2 ** 31 * (10 ** uint256(decimals)); 120 | uint256 public constant PRIVATESALE_SUPPLY = TOTAL_SUPPLY * 60 / 100; 121 | uint256 public constant PROJECTOPERATION_SUPPLY = TOTAL_SUPPLY * 25 / 100; 122 | uint256 public constant TEAM_AND_ANGEL_SUPPLY = TOTAL_SUPPLY * 15 / 100; 123 | 124 | // beneficiary of tokens after they are released 125 | address public privatesale_beneficiary; 126 | 127 | address public projectoperation_beneficiary; 128 | 129 | address public team_and_angel_beneficiary; 130 | // timestamp when token release is enabled 131 | uint256 public releaseTime; 132 | 133 | bool public released; 134 | 135 | function CyberVeinToken(address _privatesale_beneficiary, address _projectoperation_beneficiary, address _team_and_angel_beneficiary, uint256 _releaseTime) public { 136 | require(_releaseTime > now); 137 | totalSupply = TOTAL_SUPPLY; 138 | privatesale_beneficiary = _privatesale_beneficiary; 139 | projectoperation_beneficiary = _projectoperation_beneficiary; 140 | team_and_angel_beneficiary = _team_and_angel_beneficiary; 141 | releaseTime = _releaseTime; 142 | released = false; 143 | 144 | balances[privatesale_beneficiary] = PRIVATESALE_SUPPLY; 145 | balances[projectoperation_beneficiary] = PROJECTOPERATION_SUPPLY; 146 | } 147 | 148 | function release() public { 149 | require(released == false); 150 | require(now >= releaseTime); 151 | 152 | balances[team_and_angel_beneficiary] = TEAM_AND_ANGEL_SUPPLY; 153 | released = true; 154 | } 155 | 156 | } -------------------------------------------------------------------------------- /SourceCode/DNA(DNA)_0x82b0e50478eeafde392d45d1259ed1071b6fda81.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.11; 2 | 3 | /** 4 | * @title SafeMath 5 | * @dev Math operations with safety checks that throw on error 6 | */ 7 | library SafeMath { 8 | function mul(uint256 a, uint256 b) internal returns (uint256) { 9 | uint256 c = a * b; 10 | assert(a == 0 || c / a == b); 11 | return c; 12 | } 13 | 14 | function div(uint256 a, uint256 b) internal returns (uint256) { 15 | // assert(b > 0); // Solidity automatically throws when dividing by 0 16 | uint256 c = a / b; 17 | // assert(a == b * c + a % b); // There is no case in which this doesn't hold 18 | return c; 19 | } 20 | 21 | function sub(uint256 a, uint256 b) internal returns (uint256) { 22 | assert(b <= a); 23 | return a - b; 24 | } 25 | 26 | function add(uint256 a, uint256 b) internal returns (uint256) { 27 | uint256 c = a + b; 28 | assert(c >= a); 29 | return c; 30 | } 31 | } 32 | 33 | contract ERC20Basic { 34 | uint256 public totalSupply; 35 | function balanceOf(address who) constant returns (uint256); 36 | function transfer(address to, uint256 value); 37 | event Transfer(address indexed from, address indexed to, uint256 value); 38 | } 39 | 40 | contract ERC20 is ERC20Basic { 41 | function allowance(address owner, address spender) constant returns (uint256); 42 | function transferFrom(address from, address to, uint256 value); 43 | function approve(address spender, uint256 value); 44 | event Approval(address indexed owner, address indexed spender, uint256 value); 45 | } 46 | 47 | contract BasicToken is ERC20Basic { 48 | using SafeMath for uint256; 49 | 50 | mapping(address => uint256) balances; 51 | 52 | /** 53 | * @dev transfer token for a specified address 54 | * @param _to The address to transfer to. 55 | * @param _value The amount to be transferred. 56 | */ 57 | function transfer(address _to, uint256 _value) { 58 | balances[msg.sender] = balances[msg.sender].sub(_value); 59 | balances[_to] = balances[_to].add(_value); 60 | Transfer(msg.sender, _to, _value); 61 | } 62 | 63 | /** 64 | * @dev Gets the balance of the specified address. 65 | * @param _owner The address to query the the balance of. 66 | * @return An uint256 representing the amount owned by the passed address. 67 | */ 68 | function balanceOf(address _owner) constant returns (uint256 balance) { 69 | return balances[_owner]; 70 | } 71 | 72 | } 73 | 74 | contract StandardToken is ERC20, BasicToken { 75 | 76 | mapping (address => mapping (address => uint256)) allowed; 77 | 78 | 79 | /** 80 | * @dev Transfer tokens from one address to another 81 | * @param _from address The address which you want to send tokens from 82 | * @param _to address The address which you want to transfer to 83 | * @param _value uint256 the amout of tokens to be transfered 84 | */ 85 | function transferFrom(address _from, address _to, uint256 _value) { 86 | var _allowance = allowed[_from][msg.sender]; 87 | 88 | // Check is not needed because sub(_allowance, _value) will already throw if this condition is not met 89 | // if (_value > _allowance) throw; 90 | 91 | balances[_to] = balances[_to].add(_value); 92 | balances[_from] = balances[_from].sub(_value); 93 | allowed[_from][msg.sender] = _allowance.sub(_value); 94 | Transfer(_from, _to, _value); 95 | } 96 | 97 | /** 98 | * @dev Aprove the passed address to spend the specified amount of tokens on behalf of msg.sender. 99 | * @param _spender The address which will spend the funds. 100 | * @param _value The amount of tokens to be spent. 101 | */ 102 | function approve(address _spender, uint256 _value) { 103 | 104 | // To change the approve amount you first have to reduce the addresses` 105 | // allowance to zero by calling `approve(_spender, 0)` if it is not 106 | // already 0 to mitigate the race condition described here: 107 | // https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 108 | if ((_value != 0) && (allowed[msg.sender][_spender] != 0)) throw; 109 | 110 | allowed[msg.sender][_spender] = _value; 111 | Approval(msg.sender, _spender, _value); 112 | } 113 | 114 | /** 115 | * @dev Function to check the amount of tokens that an owner allowed to a spender. 116 | * @param _owner address The address which owns the funds. 117 | * @param _spender address The address which will spend the funds. 118 | * @return A uint256 specifing the amount of tokens still avaible for the spender. 119 | */ 120 | function allowance(address _owner, address _spender) constant returns (uint256 remaining) { 121 | return allowed[_owner][_spender]; 122 | } 123 | 124 | } 125 | 126 | 127 | contract DNAToken is StandardToken { 128 | 129 | string public name = "DNA Token"; 130 | string public symbol = "DNA"; 131 | uint256 public decimals = 18; 132 | uint256 public INITIAL_SUPPLY = 100000000 * 1 ether; 133 | 134 | /** 135 | * @dev Contructor that gives msg.sender all of existing tokens. 136 | */ 137 | function DNAToken() { 138 | totalSupply = INITIAL_SUPPLY; 139 | balances[msg.sender] = INITIAL_SUPPLY; 140 | } 141 | 142 | } -------------------------------------------------------------------------------- /SourceCode/Decent.Bet(DBET)_0x9b68bfae21df5a510931a262cecf63f41338f264.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.8; 2 | 3 | // accepted from zeppelin-solidity https://github.com/OpenZeppelin/zeppelin-solidity 4 | /* 5 | * ERC20 interface 6 | * see https://github.com/ethereum/EIPs/issues/20 7 | */ 8 | contract ERC20 { 9 | uint public totalSupply; 10 | function balanceOf(address who) constant returns (uint); 11 | function allowance(address owner, address spender) constant returns (uint); 12 | 13 | function transfer(address to, uint value) returns (bool ok); 14 | function transferFrom(address from, address to, uint value) returns (bool ok); 15 | function approve(address spender, uint value) returns (bool ok); 16 | event Transfer(address indexed from, address indexed to, uint value); 17 | event Approval(address indexed owner, address indexed spender, uint value); 18 | } 19 | 20 | // accepted from zeppelin-solidity https://github.com/OpenZeppelin/zeppelin-solidity 21 | 22 | /** 23 | * Math operations with safety checks 24 | */ 25 | contract SafeMath { 26 | function safeMul(uint a, uint b) internal returns (uint) { 27 | uint c = a * b; 28 | assert(a == 0 || c / a == b); 29 | return c; 30 | } 31 | 32 | function safeDiv(uint a, uint b) internal returns (uint) { 33 | assert(b > 0); 34 | uint c = a / b; 35 | assert(a == b * c + a % b); 36 | return c; 37 | } 38 | 39 | function safeSub(uint a, uint b) internal returns (uint) { 40 | assert(b <= a); 41 | return a - b; 42 | } 43 | 44 | function safeAdd(uint a, uint b) internal returns (uint) { 45 | uint c = a + b; 46 | assert(c >= a && c >= b); 47 | return c; 48 | } 49 | 50 | function max64(uint64 a, uint64 b) internal constant returns (uint64) { 51 | return a >= b ? a : b; 52 | } 53 | 54 | function min64(uint64 a, uint64 b) internal constant returns (uint64) { 55 | return a < b ? a : b; 56 | } 57 | 58 | function max256(uint256 a, uint256 b) internal constant returns (uint256) { 59 | return a >= b ? a : b; 60 | } 61 | 62 | function min256(uint256 a, uint256 b) internal constant returns (uint256) { 63 | return a < b ? a : b; 64 | } 65 | 66 | function assert(bool assertion) internal { 67 | if (!assertion) { 68 | throw; 69 | } 70 | } 71 | 72 | } 73 | 74 | /// @title Multisignature wallet - Allows multiple parties to agree on transactions before execution. 75 | /// @author Stefan George - < -------------------------------------------------------------------------------- /SourceCode/Delta(DLT)_0x07e3c70653548b04f0a75970c1f81b4cbbfb606f.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.8; 2 | 3 | contract Token { 4 | /// total amount of tokens 5 | uint256 public totalSupply; 6 | 7 | /// @param _owner The address from which the balance will be retrieved 8 | /// @return The balance 9 | function balanceOf(address _owner) constant returns (uint256 balance); 10 | 11 | /// @notice send `_value` token to `_to` from `msg.sender` 12 | /// @param _to The address of the recipient 13 | /// @param _value The amount of token to be transferred 14 | /// @return Whether the transfer was successful or not 15 | function transfer(address _to, uint256 _value) returns (bool success); 16 | 17 | /// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from` 18 | /// @param _from The address of the sender 19 | /// @param _to The address of the recipient 20 | /// @param _value The amount of token to be transferred 21 | /// @return Whether the transfer was successful or not 22 | function transferFrom(address _from, address _to, uint256 _value) returns (bool success); 23 | 24 | /// @notice `msg.sender` approves `_spender` to spend `_value` tokens 25 | /// @param _spender The address of the account able to transfer the tokens 26 | /// @param _value The amount of tokens to be approved for transfer 27 | /// @return Whether the approval was successful or not 28 | function approve(address _spender, uint256 _value) returns (bool success); 29 | 30 | /// @param _owner The address of the account owning tokens 31 | /// @param _spender The address of the account able to transfer the tokens 32 | /// @return Amount of remaining tokens allowed to spent 33 | function allowance(address _owner, address _spender) constant returns (uint256 remaining); 34 | 35 | event Transfer(address indexed _from, address indexed _to, uint256 _value); 36 | event Approval(address indexed _owner, address indexed _spender, uint256 _value); 37 | } 38 | 39 | contract StandardToken is Token { 40 | 41 | function transfer(address _to, uint256 _value) returns (bool success) { 42 | require(balances[msg.sender] >= _value); 43 | balances[msg.sender] -= _value; 44 | balances[_to] += _value; 45 | Transfer(msg.sender, _to, _value); 46 | return true; 47 | } 48 | 49 | function transferFrom(address _from, address _to, uint256 _value) returns (bool success) { 50 | require(balances[_from] >= _value && allowed[_from][msg.sender] >= _value); 51 | balances[_to] += _value; 52 | balances[_from] -= _value; 53 | allowed[_from][msg.sender] -= _value; 54 | Transfer(_from, _to, _value); 55 | return true; 56 | } 57 | 58 | function balanceOf(address _owner) constant returns (uint256 balance) { 59 | return balances[_owner]; 60 | } 61 | 62 | function approve(address _spender, uint256 _value) returns (bool success) { 63 | allowed[msg.sender][_spender] = _value; 64 | Approval(msg.sender, _spender, _value); 65 | return true; 66 | } 67 | 68 | function allowance(address _owner, address _spender) constant returns (uint256 remaining) { 69 | return allowed[_owner][_spender]; 70 | } 71 | 72 | mapping (address => uint256) balances; 73 | mapping (address => mapping (address => uint256)) allowed; 74 | } 75 | 76 | contract HumanStandardToken is StandardToken { 77 | 78 | /* Public variables of the token */ 79 | 80 | string public name; //fancy name: eg Simon Bucks 81 | uint8 public decimals; //How many decimals to show. ie. There could 1000 base units with 3 decimals. Meaning 0.980 SBX = 980 base units. It's like comparing 1 wei to 1 ether. 82 | string public symbol; //An identifier: eg SBX 83 | string public version = 'H0.1'; //human 0.1 standard. Just an arbitrary versioning scheme. 84 | 85 | function HumanStandardToken( 86 | uint256 _initialAmount, 87 | string _tokenName, 88 | uint8 _decimalUnits, 89 | string _tokenSymbol 90 | ) { 91 | balances[msg.sender] = _initialAmount; // Give the creator all initial tokens 92 | totalSupply = _initialAmount; // Update total supply 93 | name = _tokenName; // Set the name for display purposes 94 | decimals = _decimalUnits; // Amount of decimals for display purposes 95 | symbol = _tokenSymbol; // Set the symbol for display purposes 96 | } 97 | 98 | /* Approves and then calls the receiving contract */ 99 | function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) { 100 | allowed[msg.sender][_spender] = _value; 101 | Approval(msg.sender, _spender, _value); 102 | 103 | //call the receiveApproval function on the contract you want to be notified. This crafts the function signature manually so one doesn't have to include a contract in here just for this. 104 | //receiveApproval(address _from, uint256 _value, address _tokenContract, bytes _extraData) 105 | //it is assumed that when does this that the call *should* succeed, otherwise one would use vanilla approve instead. 106 | require(_spender.call(bytes4(bytes32(sha3("receiveApproval(address,uint256,address,bytes)"))), msg.sender, _value, this, _extraData)); 107 | return true; 108 | } 109 | } 110 | 111 | // Creates 130,271,020.035721000000000000 Agrello Delta Tokens 112 | contract Delta is HumanStandardToken(130271020035721000000000000, "Delta", 18, "DLT") {} -------------------------------------------------------------------------------- /SourceCode/EDUCare(EKT)_0xbab165df9455aa0f2aed1f2565520b91ddadb4c8.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.16; 2 | 3 | contract EKT { 4 | 5 | string public name = "EDUCare"; // token name 6 | string public symbol = "EKT"; // token symbol 7 | uint256 public decimals = 8; // token digit 8 | 9 | mapping (address => uint256) public balanceOf; 10 | mapping (address => mapping (address => uint256)) public allowance; 11 | 12 | uint256 public totalSupply = 0; 13 | 14 | address owner = 0x0; 15 | 16 | uint256 constant valueTotal = 10 * 10000 * 10000 * 100000000; //总量 10亿 17 | uint256 constant valueFounder = valueTotal / 100 * 50; // 基金会50% 18 | uint256 constant valueSale = valueTotal / 100 * 15; // ICO 15% 19 | uint256 constant valueVip = valueTotal / 100 * 20; // 私募 20% 20 | uint256 constant valueTeam = valueTotal / 100 * 15; // 团队与合作伙伴 15% 21 | 22 | modifier isOwner { 23 | assert(owner == msg.sender); 24 | _; 25 | } 26 | 27 | modifier validAddress(address _address) { 28 | assert(0x0 != _address); 29 | _; 30 | } 31 | 32 | 33 | function EKT(address _founder, address _sale, address _vip, address _team) 34 | public 35 | validAddress(_founder) 36 | validAddress(_sale) 37 | validAddress(_vip) 38 | validAddress(_team) 39 | { 40 | owner = msg.sender; 41 | totalSupply = valueTotal; 42 | 43 | // 基金会 44 | balanceOf[_founder] = valueFounder; 45 | Transfer(0x0, _founder, valueFounder); 46 | 47 | // ICO 48 | balanceOf[_sale] = valueSale; 49 | Transfer(0x0, _sale, valueSale); 50 | 51 | // 私募 52 | balanceOf[_vip] = valueVip; 53 | Transfer(0x0, _vip, valueVip); 54 | 55 | // 团队 56 | balanceOf[_team] = valueTeam; 57 | Transfer(0x0, _team, valueTeam); 58 | 59 | } 60 | 61 | function transfer(address _to, uint256 _value) 62 | public 63 | validAddress(_to) 64 | returns (bool success) 65 | { 66 | require(balanceOf[msg.sender] >= _value); 67 | require(balanceOf[_to] + _value >= balanceOf[_to]); 68 | balanceOf[msg.sender] -= _value; 69 | balanceOf[_to] += _value; 70 | Transfer(msg.sender, _to, _value); 71 | return true; 72 | } 73 | 74 | function transferFrom(address _from, address _to, uint256 _value) 75 | public 76 | validAddress(_from) 77 | validAddress(_to) 78 | returns (bool success) 79 | { 80 | require(balanceOf[_from] >= _value); 81 | require(balanceOf[_to] + _value >= balanceOf[_to]); 82 | require(allowance[_from][msg.sender] >= _value); 83 | balanceOf[_to] += _value; 84 | balanceOf[_from] -= _value; 85 | allowance[_from][msg.sender] -= _value; 86 | Transfer(_from, _to, _value); 87 | return true; 88 | } 89 | 90 | function approve(address _spender, uint256 _value) 91 | public 92 | validAddress(_spender) 93 | returns (bool success) 94 | { 95 | require(_value == 0 || allowance[msg.sender][_spender] == 0); 96 | allowance[msg.sender][_spender] = _value; 97 | Approval(msg.sender, _spender, _value); 98 | return true; 99 | } 100 | 101 | 102 | event Transfer(address indexed _from, address indexed _to, uint256 _value); 103 | event Approval(address indexed _owner, address indexed _spender, uint256 _value); 104 | } -------------------------------------------------------------------------------- /SourceCode/ETHGAS(eGAS)_0xb53a96bcbdd9cf78dff20bab6c2be7baec8f00f8.sol: -------------------------------------------------------------------------------- 1 | /** 2 | * @First Smart Airdrop eGAS Token 3 | * @First Smart Airdrop as Service SAaS Project 4 | * @http://ethgas.stream 5 | * @email: -------------------------------------------------------------------------------- /SourceCode/Edgeless(EDG)_0x08711d3b02c8758f2fb3ab4e80228418a7f8e39c.sol: -------------------------------------------------------------------------------- 1 | /** 2 | * The Edgeless token contract complies with the ERC20 standard (see https://github.com/ethereum/EIPs/issues/20). 3 | * Additionally tokens can be locked for a defined time interval by token holders. 4 | * The owner's share of tokens is locked for the first year and all tokens not 5 | * being sold during the crowdsale but 60.000.000 (owner's share + bounty program) are burned. 6 | * Author: Julia Altenried 7 | * */ 8 | 9 | pragma solidity ^0.4.6; 10 | 11 | contract SafeMath { 12 | //internals 13 | 14 | function safeMul(uint a, uint b) internal returns (uint) { 15 | uint c = a * b; 16 | assert(a == 0 || c / a == b); 17 | return c; 18 | } 19 | 20 | function safeSub(uint a, uint b) internal returns (uint) { 21 | assert(b <= a); 22 | return a - b; 23 | } 24 | 25 | function safeAdd(uint a, uint b) internal returns (uint) { 26 | uint c = a + b; 27 | assert(c>=a && c>=b); 28 | return c; 29 | } 30 | 31 | function assert(bool assertion) internal { 32 | if (!assertion) throw; 33 | } 34 | } 35 | 36 | contract EdgelessToken is SafeMath { 37 | /* Public variables of the token */ 38 | string public standard = 'ERC20'; 39 | string public name = 'Edgeless'; 40 | string public symbol = 'EDG'; 41 | uint8 public decimals = 0; 42 | uint256 public totalSupply; 43 | address public owner; 44 | /* from this time on tokens may be transfered (after ICO)*/ 45 | uint256 public startTime = 1490112000; 46 | /* tells if tokens have been burned already */ 47 | bool burned; 48 | 49 | /* This creates an array with all balances */ 50 | mapping (address => uint256) public balanceOf; 51 | mapping (address => mapping (address => uint256)) public allowance; 52 | 53 | 54 | /* This generates a public event on the blockchain that will notify clients */ 55 | event Transfer(address indexed from, address indexed to, uint256 value); 56 | event Approval(address indexed owner, address indexed spender, uint256 value); 57 | event Burned(uint amount); 58 | 59 | /* Initializes contract with initial supply tokens to the creator of the contract */ 60 | function EdgelessToken() { 61 | owner = 0x003230BBE64eccD66f62913679C8966Cf9F41166; 62 | balanceOf[owner] = 500000000; // Give the owner all initial tokens 63 | totalSupply = 500000000; // Update total supply 64 | } 65 | 66 | /* Send some of your tokens to a given address */ 67 | function transfer(address _to, uint256 _value) returns (bool success){ 68 | if (now < startTime) throw; //check if the crowdsale is already over 69 | if(msg.sender == owner && now < startTime + 1 years && safeSub(balanceOf[msg.sender],_value) < 50000000) throw; //prevent the owner of spending his share of tokens within the first year 70 | balanceOf[msg.sender] = safeSub(balanceOf[msg.sender],_value); // Subtract from the sender 71 | balanceOf[_to] = safeAdd(balanceOf[_to],_value); // Add the same to the recipient 72 | Transfer(msg.sender, _to, _value); // Notify anyone listening that this transfer took place 73 | return true; 74 | } 75 | 76 | /* Allow another contract or person to spend some tokens in your behalf */ 77 | function approve(address _spender, uint256 _value) returns (bool success) { 78 | allowance[msg.sender][_spender] = _value; 79 | Approval(msg.sender, _spender, _value); 80 | return true; 81 | } 82 | 83 | 84 | /* A contract or person attempts to get the tokens of somebody else. 85 | * This is only allowed if the token holder approved. */ 86 | function transferFrom(address _from, address _to, uint256 _value) returns (bool success) { 87 | if (now < startTime && _from!=owner) throw; //check if the crowdsale is already over 88 | if(_from == owner && now < startTime + 1 years && safeSub(balanceOf[_from],_value) < 50000000) throw; //prevent the owner of spending his share of tokens within the first year 89 | var _allowance = allowance[_from][msg.sender]; 90 | balanceOf[_from] = safeSub(balanceOf[_from],_value); // Subtract from the sender 91 | balanceOf[_to] = safeAdd(balanceOf[_to],_value); // Add the same to the recipient 92 | allowance[_from][msg.sender] = safeSub(_allowance,_value); 93 | Transfer(_from, _to, _value); 94 | return true; 95 | } 96 | 97 | 98 | /* to be called when ICO is closed, burns the remaining tokens but the owners share (50 000 000) and the ones reserved 99 | * for the bounty program (10 000 000). 100 | * anybody may burn the tokens after ICO ended, but only once (in case the owner holds more tokens in the future). 101 | * this ensures that the owner will not posses a majority of the tokens. */ 102 | function burn(){ 103 | //if tokens have not been burned already and the ICO ended 104 | if(!burned && now>startTime){ 105 | uint difference = safeSub(balanceOf[owner], 60000000);//checked for overflow above 106 | balanceOf[owner] = 60000000; 107 | totalSupply = safeSub(totalSupply, difference); 108 | burned = true; 109 | Burned(difference); 110 | } 111 | } 112 | 113 | } -------------------------------------------------------------------------------- /SourceCode/EthereumDark(ETHD)_0xdbfb423e9bbf16294388e07696a5120e4ceba0c5.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.11; 2 | 3 | contract Token { 4 | string public symbol = ""; 5 | string public name = ""; 6 | uint8 public constant decimals = 18; 7 | uint256 _totalSupply = 0; 8 | address owner = 0; 9 | bool setupDone = false; 10 | 11 | event Transfer(address indexed _from, address indexed _to, uint256 _value); 12 | event Approval(address indexed _owner, address indexed _spender, uint256 _value); 13 | 14 | mapping(address => uint256) balances; 15 | 16 | mapping(address => mapping (address => uint256)) allowed; 17 | 18 | function Token(address adr) { 19 | owner = adr; 20 | } 21 | 22 | function SetupToken(string tokenName, string tokenSymbol, uint256 tokenSupply) 23 | { 24 | if (msg.sender == owner && setupDone == false) 25 | { 26 | symbol = tokenSymbol; 27 | name = tokenName; 28 | _totalSupply = tokenSupply * 1000000000000000000; 29 | balances[owner] = _totalSupply; 30 | setupDone = true; 31 | } 32 | } 33 | 34 | function totalSupply() constant returns (uint256 totalSupply) { 35 | return _totalSupply; 36 | } 37 | 38 | function balanceOf(address _owner) constant returns (uint256 balance) { 39 | return balances[_owner]; 40 | } 41 | 42 | function transfer(address _to, uint256 _amount) returns (bool success) { 43 | if (balances[msg.sender] >= _amount 44 | && _amount > 0 45 | && balances[_to] + _amount > balances[_to]) { 46 | balances[msg.sender] -= _amount; 47 | balances[_to] += _amount; 48 | Transfer(msg.sender, _to, _amount); 49 | return true; 50 | } else { 51 | return false; 52 | } 53 | } 54 | 55 | function transferFrom( 56 | address _from, 57 | address _to, 58 | uint256 _amount 59 | ) returns (bool success) { 60 | if (balances[_from] >= _amount 61 | && allowed[_from][msg.sender] >= _amount 62 | && _amount > 0 63 | && balances[_to] + _amount > balances[_to]) { 64 | balances[_from] -= _amount; 65 | allowed[_from][msg.sender] -= _amount; 66 | balances[_to] += _amount; 67 | Transfer(_from, _to, _amount); 68 | return true; 69 | } else { 70 | return false; 71 | } 72 | } 73 | 74 | function approve(address _spender, uint256 _amount) returns (bool success) { 75 | allowed[msg.sender][_spender] = _amount; 76 | Approval(msg.sender, _spender, _amount); 77 | return true; 78 | } 79 | 80 | function allowance(address _owner, address _spender) constant returns (uint256 remaining) { 81 | return allowed[_owner][_spender]; 82 | } 83 | } -------------------------------------------------------------------------------- /SourceCode/EthereumGold(ETG)_0x28c8d01ff633ea9cd8fc6a451d7457889e698de6.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^ 0.4 .9; 2 | library SafeMath { 3 | function mul(uint256 a, uint256 b) internal constant returns(uint256) { 4 | uint256 c = a * b; 5 | assert(a == 0 || c / a == b); 6 | return c; 7 | } 8 | 9 | function div(uint256 a, uint256 b) internal constant returns(uint256) { 10 | uint256 c = a / b; 11 | return c; 12 | } 13 | 14 | function sub(uint256 a, uint256 b) internal constant returns(uint256) { 15 | assert(b <= a); 16 | return a - b; 17 | } 18 | 19 | function add(uint256 a, uint256 b) internal constant returns(uint256) { 20 | uint256 c = a + b; 21 | assert(c >= a); 22 | return c; 23 | } 24 | } 25 | contract EthereumGold { 26 | using SafeMath 27 | for uint256; 28 | mapping(address => mapping(address => uint256)) allowed; 29 | mapping(address => uint256) balances; 30 | uint256 public totalSupply; 31 | uint256 public decimals; 32 | address public owner; 33 | bytes32 public symbol; 34 | event Transfer(address indexed from, address indexed to, uint256 value); 35 | event Approval(address indexed _owner, address indexed spender, uint256 value); 36 | 37 | function EthereumGold() { 38 | totalSupply = 24000000; 39 | symbol = 'ETG'; 40 | owner = 0xe913aef983e84ed90f340ff533ce39668f45a0f6; 41 | balances[owner] = totalSupply; 42 | decimals = 0; 43 | } 44 | 45 | function balanceOf(address _owner) constant returns(uint256 balance) { 46 | return balances[_owner]; 47 | } 48 | 49 | function allowance(address _owner, address _spender) constant returns(uint256 remaining) { 50 | return allowed[_owner][_spender]; 51 | } 52 | 53 | function transfer(address _to, uint256 _value) returns(bool) { 54 | balances[msg.sender] = balances[msg.sender].sub(_value); 55 | balances[_to] = balances[_to].add(_value); 56 | Transfer(msg.sender, _to, _value); 57 | return true; 58 | } 59 | 60 | function transferFrom(address _from, address _to, uint256 _value) returns(bool) { 61 | var _allowance = allowed[_from][msg.sender]; 62 | balances[_to] = balances[_to].add(_value); 63 | balances[_from] = balances[_from].sub(_value); 64 | allowed[_from][msg.sender] = _allowance.sub(_value); 65 | Transfer(_from, _to, _value); 66 | return true; 67 | } 68 | 69 | function approve(address _spender, uint256 _value) returns(bool) { 70 | require((_value == 0) || (allowed[msg.sender][_spender] == 0)); 71 | allowed[msg.sender][_spender] = _value; 72 | Approval(msg.sender, _spender, _value); 73 | return true; 74 | } 75 | 76 | function() { 77 | revert(); 78 | } 79 | } -------------------------------------------------------------------------------- /SourceCode/FinallyUsableCryptoKarma(FUCK)_0x65be44c747988fbf606207698c944df4442efe19.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.16; 2 | contract tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData); } 3 | 4 | contract FuckToken { 5 | /* Public variables of the FUCK token */ 6 | string public standard = 'FUCK 1.1'; 7 | string public name = 'Finally Usable Crypto Karma'; 8 | string public symbol = 'FUCK'; 9 | uint8 public decimals = 4; 10 | uint256 public totalSupply = 708567744953; 11 | 12 | /* Creates an array with all balances */ 13 | mapping (address => uint256) public balanceOf; 14 | mapping (address => mapping (address => uint256)) public allowance; 15 | 16 | /* Generates a public event on the blockchain that will notify clients */ 17 | event Transfer(address indexed from, address indexed to, uint256 value); 18 | 19 | /* Notifies clients about the amount burnt */ 20 | event Burn(address indexed from, uint256 value); 21 | 22 | /* Initializes contract with initial supply tokens to me */ 23 | function FuckToken() { 24 | balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens 25 | } 26 | 27 | /* Send coins */ 28 | function transfer(address _to, uint256 _value) { 29 | if (_to == 0x0) revert(); // Prevent transfer to 0x0 address. Use burn() instead 30 | if (balanceOf[msg.sender] < _value) revert(); // Check if the sender has enough 31 | if (balanceOf[_to] + _value < balanceOf[_to]) revert(); // Check for overflows 32 | balanceOf[msg.sender] -= _value; // Subtract from the sender 33 | balanceOf[_to] += _value; // Add the same to the recipient 34 | Transfer(msg.sender, _to, _value); // Notify anyone listening that this transfer took place 35 | } 36 | 37 | /* Allow another contract to spend some tokens on my behalf */ 38 | function approve(address _spender, uint256 _value) 39 | returns (bool success) { 40 | if ((_value != 0) && (allowance[msg.sender][_spender] != 0)) revert(); 41 | allowance[msg.sender][_spender] = _value; 42 | return true; 43 | } 44 | 45 | /* Approve and then communicate the approved contract in a single tx */ 46 | function approveAndCall(address _spender, uint256 _value, bytes _extraData) 47 | returns (bool success) { 48 | tokenRecipient spender = tokenRecipient(_spender); 49 | if (approve(_spender, _value)) { 50 | spender.receiveApproval(msg.sender, _value, this, _extraData); 51 | return true; 52 | } 53 | } 54 | 55 | /* A contract attempts to get the coins */ 56 | function transferFrom(address _from, address _to, uint256 _value) returns (bool success) { 57 | if (_to == 0x0) revert(); // Prevent transfer to 0x0 address. Use burn() instead 58 | if (balanceOf[_from] < _value) revert(); // Check if the sender has enough 59 | if (balanceOf[_to] + _value < balanceOf[_to]) revert(); // Check for overflows 60 | if (_value > allowance[_from][msg.sender]) revert(); // Check allowance 61 | balanceOf[_from] -= _value; // Subtract from the sender 62 | balanceOf[_to] += _value; // Add the same to the recipient 63 | allowance[_from][msg.sender] -= _value; 64 | Transfer(_from, _to, _value); 65 | return true; 66 | } 67 | 68 | /* Burn FUCKs by User */ 69 | function burn(uint256 _value) returns (bool success) { 70 | if (balanceOf[msg.sender] < _value) revert(); // Check if the sender has enough 71 | balanceOf[msg.sender] -= _value; // Subtract from the sender 72 | totalSupply -= _value; // Updates totalSupply 73 | Burn(msg.sender, _value); 74 | return true; 75 | } 76 | 77 | /* Burn FUCKs from Users */ 78 | function burnFrom(address _from, uint256 _value) returns (bool success) { 79 | if (balanceOf[_from] < _value) revert(); // Check if the sender has enough 80 | if (_value > allowance[_from][msg.sender]) revert(); // Check allowance 81 | balanceOf[_from] -= _value; // Subtract from the sender 82 | totalSupply -= _value; // Updates totalSupply 83 | Burn(_from, _value); 84 | return true; 85 | } 86 | } -------------------------------------------------------------------------------- /SourceCode/Game.comToken(GTC)_0xB70835D7822eBB9426B56543E391846C107bd32C.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.8; 2 | 3 | // @address 0xb70835d7822ebb9426b56543e391846c107bd32c 4 | // @multisig 5 | // The implementation for the Game ICO smart contract was inspired by 6 | // the Ethereum token creation tutorial, the FirstBlood token, and the BAT token. 7 | // compiler: 0.4.17+commit.bdeb9e52 8 | 9 | /* 10 | 1. Contract Address: 0xb70835d7822ebb9426b56543e391846c107bd32c 11 | 12 | 2. Official Site URL:https://www.game.com/ 13 | 14 | 3. Link to download a 28x28png icon logo:https://ic.game.com/download/gameico_28.png 15 | 16 | 4. Official Contact Email Address: -------------------------------------------------------------------------------- /SourceCode/Gifto(GTO)_0xc5bbae50781be1669306b9e001eff57a2957b09d.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.18; 2 | 3 | // ---------------------------------------------------------------------------------------------- 4 | // Gifto Token by Gifto Limited. 5 | // An ERC20 standard 6 | // 7 | // author: Gifto Team 8 | // Contact: -------------------------------------------------------------------------------- /SourceCode/Gnosis(GNO)_0x6810e776880c02933d47db1b9fc05908e5386b96.sol: -------------------------------------------------------------------------------- 1 | pragma solidity 0.4.10; 2 | 3 | 4 | /// @title Abstract token contract - Functions to be implemented by token contracts. 5 | contract Token { 6 | function transfer(address to, uint256 value) returns (bool success); 7 | function transferFrom(address from, address to, uint256 value) returns (bool success); 8 | function approve(address spender, uint256 value) returns (bool success); 9 | 10 | // This is not an abstract function, because solc won't recognize generated getter functions for public variables as functions. 11 | function totalSupply() constant returns (uint256 supply) {} 12 | function balanceOf(address owner) constant returns (uint256 balance); 13 | function allowance(address owner, address spender) constant returns (uint256 remaining); 14 | 15 | event Transfer(address indexed from, address indexed to, uint256 value); 16 | event Approval(address indexed owner, address indexed spender, uint256 value); 17 | } 18 | 19 | 20 | /// @title Standard token contract - Standard token interface implementation. 21 | contract StandardToken is Token { 22 | 23 | /* 24 | * Data structures 25 | */ 26 | mapping (address => uint256) balances; 27 | mapping (address => mapping (address => uint256)) allowed; 28 | uint256 public totalSupply; 29 | 30 | /* 31 | * Public functions 32 | */ 33 | /// @dev Transfers sender's tokens to a given address. Returns success. 34 | /// @param _to Address of token receiver. 35 | /// @param _value Number of tokens to transfer. 36 | /// @return Returns success of function call. 37 | function transfer(address _to, uint256 _value) 38 | public 39 | returns (bool) 40 | { 41 | if (balances[msg.sender] < _value) { 42 | // Balance too low 43 | throw; 44 | } 45 | balances[msg.sender] -= _value; 46 | balances[_to] += _value; 47 | Transfer(msg.sender, _to, _value); 48 | return true; 49 | } 50 | 51 | /// @dev Allows allowed third party to transfer tokens from one address to another. Returns success. 52 | /// @param _from Address from where tokens are withdrawn. 53 | /// @param _to Address to where tokens are sent. 54 | /// @param _value Number of tokens to transfer. 55 | /// @return Returns success of function call. 56 | function transferFrom(address _from, address _to, uint256 _value) 57 | public 58 | returns (bool) 59 | { 60 | if (balances[_from] < _value || allowed[_from][msg.sender] < _value) { 61 | // Balance or allowance too low 62 | throw; 63 | } 64 | balances[_to] += _value; 65 | balances[_from] -= _value; 66 | allowed[_from][msg.sender] -= _value; 67 | Transfer(_from, _to, _value); 68 | return true; 69 | } 70 | 71 | /// @dev Sets approved amount of tokens for spender. Returns success. 72 | /// @param _spender Address of allowed account. 73 | /// @param _value Number of approved tokens. 74 | /// @return Returns success of function call. 75 | function approve(address _spender, uint256 _value) 76 | public 77 | returns (bool) 78 | { 79 | allowed[msg.sender][_spender] = _value; 80 | Approval(msg.sender, _spender, _value); 81 | return true; 82 | } 83 | 84 | /* 85 | * Read functions 86 | */ 87 | /// @dev Returns number of allowed tokens for given address. 88 | /// @param _owner Address of token owner. 89 | /// @param _spender Address of token spender. 90 | /// @return Returns remaining allowance for spender. 91 | function allowance(address _owner, address _spender) 92 | constant 93 | public 94 | returns (uint256) 95 | { 96 | return allowed[_owner][_spender]; 97 | } 98 | 99 | /// @dev Returns number of tokens owned by given address. 100 | /// @param _owner Address of token owner. 101 | /// @return Returns balance of owner. 102 | function balanceOf(address _owner) 103 | constant 104 | public 105 | returns (uint256) 106 | { 107 | return balances[_owner]; 108 | } 109 | } 110 | 111 | 112 | /// @title Gnosis token contract 113 | /// @author Stefan George - < -------------------------------------------------------------------------------- /SourceCode/Humaniq(HMQ)_0xcbcc0f036ed4788f63fc0fee32873d6a7487b908.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.6; 2 | 3 | 4 | /** 5 | * Math operations with safety checks 6 | */ 7 | contract SafeMath { 8 | function mul(uint a, uint b) internal returns (uint) { 9 | uint c = a * b; 10 | assert(a == 0 || c / a == b); 11 | return c; 12 | } 13 | 14 | function div(uint a, uint b) internal returns (uint) { 15 | assert(b > 0); 16 | uint c = a / b; 17 | assert(a == b * c + a % b); 18 | return c; 19 | } 20 | 21 | function sub(uint a, uint b) internal returns (uint) { 22 | assert(b <= a); 23 | return a - b; 24 | } 25 | 26 | function add(uint a, uint b) internal returns (uint) { 27 | uint c = a + b; 28 | assert(c >= a); 29 | return c; 30 | } 31 | 32 | function assert(bool assertion) internal { 33 | if (!assertion) { 34 | throw; 35 | } 36 | } 37 | } 38 | 39 | 40 | /// Implements ERC 20 Token standard: https://github.com/ethereum/EIPs/issues/20 41 | /// @title Abstract token contract - Functions to be implemented by token contracts. 42 | contract AbstractToken { 43 | // This is not an abstract function, because solc won't recognize generated getter functions for public variables as functions 44 | function totalSupply() constant returns (uint256 supply) {} 45 | function balanceOf(address owner) constant returns (uint256 balance); 46 | function transfer(address to, uint256 value) returns (bool success); 47 | function transferFrom(address from, address to, uint256 value) returns (bool success); 48 | function approve(address spender, uint256 value) returns (bool success); 49 | function allowance(address owner, address spender) constant returns (uint256 remaining); 50 | 51 | event Transfer(address indexed from, address indexed to, uint256 value); 52 | event Approval(address indexed owner, address indexed spender, uint256 value); 53 | event Issuance(address indexed to, uint256 value); 54 | } 55 | 56 | 57 | contract StandardToken is AbstractToken { 58 | 59 | /* 60 | * Data structures 61 | */ 62 | mapping (address => uint256) balances; 63 | mapping (address => mapping (address => uint256)) allowed; 64 | uint256 public totalSupply; 65 | 66 | /* 67 | * Read and write storage functions 68 | */ 69 | /// @dev Transfers sender's tokens to a given address. Returns success. 70 | /// @param _to Address of token receiver. 71 | /// @param _value Number of tokens to transfer. 72 | function transfer(address _to, uint256 _value) returns (bool success) { 73 | if (balances[msg.sender] >= _value && balances[_to] + _value > balances[_to]) { 74 | balances[msg.sender] -= _value; 75 | balances[_to] += _value; 76 | Transfer(msg.sender, _to, _value); 77 | return true; 78 | } 79 | else { 80 | return false; 81 | } 82 | } 83 | 84 | /// @dev Allows allowed third party to transfer tokens from one address to another. Returns success. 85 | /// @param _from Address from where tokens are withdrawn. 86 | /// @param _to Address to where tokens are sent. 87 | /// @param _value Number of tokens to transfer. 88 | function transferFrom(address _from, address _to, uint256 _value) returns (bool success) { 89 | if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && balances[_to] + _value > balances[_to]) { 90 | balances[_to] += _value; 91 | balances[_from] -= _value; 92 | allowed[_from][msg.sender] -= _value; 93 | Transfer(_from, _to, _value); 94 | return true; 95 | } 96 | else { 97 | return false; 98 | } 99 | } 100 | 101 | /// @dev Returns number of tokens owned by given address. 102 | /// @param _owner Address of token owner. 103 | function balanceOf(address _owner) constant returns (uint256 balance) { 104 | return balances[_owner]; 105 | } 106 | 107 | /// @dev Sets approved amount of tokens for spender. Returns success. 108 | /// @param _spender Address of allowed account. 109 | /// @param _value Number of approved tokens. 110 | function approve(address _spender, uint256 _value) returns (bool success) { 111 | allowed[msg.sender][_spender] = _value; 112 | Approval(msg.sender, _spender, _value); 113 | return true; 114 | } 115 | 116 | /* 117 | * Read storage functions 118 | */ 119 | /// @dev Returns number of allowed tokens for given address. 120 | /// @param _owner Address of token owner. 121 | /// @param _spender Address of token spender. 122 | function allowance(address _owner, address _spender) constant returns (uint256 remaining) { 123 | return allowed[_owner][_spender]; 124 | } 125 | 126 | } 127 | 128 | 129 | /// @title Token contract - Implements Standard Token Interface with HumaniQ features. 130 | /// @author Evgeny Yurtaev - < -------------------------------------------------------------------------------- /SourceCode/ICON(ICX)_0xb5a5f22694352c15b00323844ad545abb2b11028.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.11; 2 | 3 | contract Migrations { 4 | address public owner; 5 | uint public last_completed_migration; 6 | 7 | modifier restricted() { 8 | if (msg.sender == owner) _; 9 | } 10 | 11 | function Migrations() { 12 | owner = msg.sender; 13 | } 14 | 15 | function setCompleted(uint completed) restricted { 16 | last_completed_migration = completed; 17 | } 18 | 19 | function upgrade(address new_address) restricted { 20 | Migrations upgraded = Migrations(new_address); 21 | upgraded.setCompleted(last_completed_migration); 22 | } 23 | } 24 | 25 | contract ERC20 { 26 | function totalSupply() constant returns (uint supply); 27 | function balanceOf( address who ) constant returns (uint value); 28 | function allowance( address owner, address spender ) constant returns (uint _allowance); 29 | 30 | function transfer( address to, uint value) returns (bool ok); 31 | function transferFrom( address from, address to, uint value) returns (bool ok); 32 | function approve( address spender, uint value ) returns (bool ok); 33 | 34 | event Transfer( address indexed from, address indexed to, uint value); 35 | event Approval( address indexed owner, address indexed spender, uint value); 36 | } 37 | 38 | contract Lockable { 39 | uint public creationTime; 40 | bool public lock; 41 | bool public tokenTransfer; 42 | address public owner; 43 | mapping( address => bool ) public unlockaddress; 44 | mapping( address => bool ) public lockaddress; 45 | 46 | event Locked(address lockaddress,bool status); 47 | event Unlocked(address unlockedaddress, bool status); 48 | 49 | 50 | // if Token transfer 51 | modifier isTokenTransfer { 52 | // if token transfer is not allow 53 | if(!tokenTransfer) { 54 | require(unlockaddress[msg.sender]); 55 | } 56 | _; 57 | } 58 | 59 | // This modifier check whether the contract should be in a locked 60 | // or unlocked state, then acts and updates accordingly if 61 | // necessary 62 | modifier checkLock { 63 | if (lockaddress[msg.sender]) { 64 | throw; 65 | } 66 | _; 67 | } 68 | 69 | modifier isOwner { 70 | require(owner == msg.sender); 71 | _; 72 | } 73 | 74 | function Lockable() { 75 | creationTime = now; 76 | tokenTransfer = false; 77 | owner = msg.sender; 78 | } 79 | 80 | // Lock Address 81 | function lockAddress(address target, bool status) 82 | external 83 | isOwner 84 | { 85 | require(owner != target); 86 | lockaddress[target] = status; 87 | Locked(target, status); 88 | } 89 | 90 | // UnLock Address 91 | function unlockAddress(address target, bool status) 92 | external 93 | isOwner 94 | { 95 | unlockaddress[target] = status; 96 | Unlocked(target, status); 97 | } 98 | } 99 | 100 | library SafeMath { 101 | function mul(uint a, uint b) internal returns (uint) { 102 | uint c = a * b; 103 | assert(a == 0 || c / a == b); 104 | return c; 105 | } 106 | 107 | function div(uint a, uint b) internal returns (uint) { 108 | // assert(b > 0); // Solidity automatically throws when dividing by 0 109 | uint c = a / b; 110 | // assert(a == b * c + a % b); // There is no case in which this doesn't hold 111 | return c; 112 | } 113 | 114 | function sub(uint a, uint b) internal returns (uint) { 115 | assert(b <= a); 116 | return a - b; 117 | } 118 | 119 | function add(uint a, uint b) internal returns (uint) { 120 | uint c = a + b; 121 | assert(c >= a); 122 | return c; 123 | } 124 | 125 | function max64(uint64 a, uint64 b) internal constant returns (uint64) { 126 | return a >= b ? a : b; 127 | } 128 | 129 | function min64(uint64 a, uint64 b) internal constant returns (uint64) { 130 | return a < b ? a : b; 131 | } 132 | 133 | function max256(uint256 a, uint256 b) internal constant returns (uint256) { 134 | return a >= b ? a : b; 135 | } 136 | 137 | function min256(uint256 a, uint256 b) internal constant returns (uint256) { 138 | return a < b ? a : b; 139 | } 140 | 141 | function assert(bool assertion) internal { 142 | if (!assertion) { 143 | throw; 144 | } 145 | } 146 | } 147 | 148 | // ICON ICX Token 149 | /// @author DongOk Ryu - < -------------------------------------------------------------------------------- /SourceCode/ICONOMI(ICN)_0x888666CA69E0f178DED6D75b5726Cee99A87D698.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.0; 2 | 3 | contract tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData); } 4 | 5 | contract IconomiToken { 6 | 7 | event Transfer(address indexed _from, address indexed _to, uint256 _value); 8 | event Approval(address indexed _owner, address indexed _spender, uint256 _value); 9 | event BlockLockSet(uint256 _value); 10 | event NewOwner(address _newOwner); 11 | 12 | modifier onlyOwner { 13 | if (msg.sender == owner) { 14 | _; 15 | } 16 | } 17 | 18 | modifier blockLock(address _sender) { 19 | if (!isLocked() || _sender == owner) { 20 | _; 21 | } 22 | } 23 | 24 | modifier checkIfToContract(address _to) { 25 | if(_to != address(this)) { 26 | _; 27 | } 28 | } 29 | 30 | uint256 public totalSupply; 31 | string public name; 32 | uint8 public decimals; 33 | string public symbol; 34 | string public version = '0.0.1'; 35 | address public owner; 36 | uint256 public lockedUntilBlock; 37 | 38 | function IconomiToken( 39 | uint256 _initialAmount, 40 | string _tokenName, 41 | uint8 _decimalUnits, 42 | string _tokenSymbol, 43 | uint256 _lockedUntilBlock 44 | ) { 45 | 46 | balances[msg.sender] = _initialAmount; 47 | totalSupply = _initialAmount; 48 | name = _tokenName; 49 | decimals = _decimalUnits; 50 | symbol = _tokenSymbol; 51 | lockedUntilBlock = _lockedUntilBlock; 52 | owner = msg.sender; 53 | } 54 | 55 | function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) { 56 | tokenRecipient spender = tokenRecipient(_spender); 57 | if (approve(_spender, _value)) { 58 | spender.receiveApproval(msg.sender, _value, this, _extraData); 59 | return true; 60 | } 61 | } 62 | 63 | function transfer(address _to, uint256 _value) blockLock(msg.sender) checkIfToContract(_to) returns (bool success) { 64 | if (balances[msg.sender] >= _value && _value > 0) { 65 | balances[msg.sender] -= _value; 66 | balances[_to] += _value; 67 | Transfer(msg.sender, _to, _value); 68 | return true; 69 | } else { 70 | return false; 71 | } 72 | } 73 | 74 | function transferFrom(address _from, address _to, uint256 _value) blockLock(_from) checkIfToContract(_to) returns (bool success) { 75 | if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) { 76 | balances[_to] += _value; 77 | balances[_from] -= _value; 78 | allowed[_from][msg.sender] -= _value; 79 | Transfer(_from, _to, _value); 80 | return true; 81 | } else { 82 | return false; 83 | } 84 | } 85 | 86 | function balanceOf(address _owner) constant returns (uint256 balance) { 87 | return balances[_owner]; 88 | } 89 | 90 | function approve(address _spender, uint256 _value) returns (bool success) { 91 | allowed[msg.sender][_spender] = _value; 92 | Approval(msg.sender, _spender, _value); 93 | return true; 94 | } 95 | 96 | function allowance(address _owner, address _spender) constant returns (uint256 remaining) { 97 | return allowed[_owner][_spender]; 98 | } 99 | 100 | function setBlockLock(uint256 _lockedUntilBlock) onlyOwner returns (bool success) { 101 | lockedUntilBlock = _lockedUntilBlock; 102 | BlockLockSet(_lockedUntilBlock); 103 | return true; 104 | } 105 | 106 | function isLocked() constant returns (bool success) { 107 | return lockedUntilBlock > block.number; 108 | } 109 | 110 | function replaceOwner(address _newOwner) onlyOwner returns (bool success) { 111 | owner = _newOwner; 112 | NewOwner(_newOwner); 113 | return true; 114 | } 115 | 116 | mapping (address => uint256) balances; 117 | mapping (address => mapping (address => uint256)) allowed; 118 | } -------------------------------------------------------------------------------- /SourceCode/IDEXMembership(IDXM)_0xcc13fc627effd6e35d2d2706ea3c4d7396c610ea.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.19; 2 | 3 | /** 4 | * @title IDXM Contract. IDEX Membership Token contract. 5 | * 6 | * @author Ray Pulver, -------------------------------------------------------------------------------- /SourceCode/IDICE(ICE)_0x5a84969bb663fb64f6d015dcf9f622aedc796750.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.10; 2 | 3 | contract SafeMath { 4 | 5 | 6 | function safeAdd(uint256 x, uint256 y) internal returns(uint256) { 7 | uint256 z = x + y; 8 | assert((z >= x) && (z >= y)); 9 | return z; 10 | } 11 | 12 | function safeSubtract(uint256 x, uint256 y) internal returns(uint256) { 13 | assert(x >= y); 14 | uint256 z = x - y; 15 | return z; 16 | } 17 | 18 | function safeMult(uint256 x, uint256 y) internal returns(uint256) { 19 | uint256 z = x * y; 20 | assert((x == 0)||(z/x == y)); 21 | return z; 22 | } 23 | 24 | } 25 | 26 | contract Token { 27 | uint256 public totalSupply; 28 | function balanceOf(address _owner) constant returns (uint256 balance); 29 | function transfer(address _to, uint256 _value) returns (bool success); 30 | function transferFrom(address _from, address _to, uint256 _value) returns (bool success); 31 | function approve(address _spender, uint256 _value) returns (bool success); 32 | function allowance(address _owner, address _spender) constant returns (uint256 remaining); 33 | event Transfer(address indexed _from, address indexed _to, uint256 _value); 34 | event Approval(address indexed _owner, address indexed _spender, uint256 _value); 35 | } 36 | 37 | 38 | /* ERC 20 token */ 39 | contract StandardToken is Token { 40 | 41 | function transfer(address _to, uint256 _value) returns (bool success) { 42 | if (balances[msg.sender] >= _value && _value > 0) { 43 | balances[msg.sender] -= _value; 44 | balances[_to] += _value; 45 | Transfer(msg.sender, _to, _value); 46 | return true; 47 | } else { 48 | return false; 49 | } 50 | } 51 | 52 | function transferFrom(address _from, address _to, uint256 _value) returns (bool success) { 53 | if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) { 54 | balances[_to] += _value; 55 | balances[_from] -= _value; 56 | allowed[_from][msg.sender] -= _value; 57 | Transfer(_from, _to, _value); 58 | return true; 59 | } else { 60 | return false; 61 | } 62 | } 63 | 64 | function balanceOf(address _owner) constant returns (uint256 balance) { 65 | return balances[_owner]; 66 | } 67 | 68 | function approve(address _spender, uint256 _value) returns (bool success) { 69 | allowed[msg.sender][_spender] = _value; 70 | Approval(msg.sender, _spender, _value); 71 | return true; 72 | } 73 | 74 | function allowance(address _owner, address _spender) constant returns (uint256 remaining) { 75 | return allowed[_owner][_spender]; 76 | } 77 | 78 | mapping (address => uint256) balances; 79 | mapping (address => mapping (address => uint256)) allowed; 80 | } 81 | 82 | contract ICEToken is StandardToken, SafeMath { 83 | 84 | string public constant name = "IDICE"; 85 | string public constant symbol = "ICE"; 86 | uint256 public constant decimals = 18; 87 | string public version = "1.0"; 88 | 89 | address public ethFundDeposit; 90 | address public iceFundDeposit; 91 | 92 | bool public isFinalized; 93 | uint256 public fundingStartBlock; 94 | uint256 public fundingEndBlock; 95 | uint256 public constant iceFund = 500 * (10**3) * 10**decimals; 96 | 97 | function tokenRate() constant returns(uint) { 98 | if (block.number>=fundingStartBlock && block.number<fundingStartBlock+252) return 200; 99 | if (block.number>=fundingStartBlock && block.number<fundingStartBlock+36878) return 170; // first week 100 | return 130; 101 | } 102 | 103 | uint256 public constant tokenCreationCap = 5 * (10**6) * 10**decimals; /// 5M Tokens maximum 104 | 105 | 106 | // events 107 | event CreateICE(address indexed _to, uint256 _value); 108 | 109 | // constructor 110 | function ICEToken( 111 | address _ethFundDeposit, 112 | address _iceFundDeposit, 113 | uint256 _fundingStartBlock, 114 | uint256 _fundingEndBlock) 115 | { 116 | isFinalized = false; 117 | ethFundDeposit = _ethFundDeposit; 118 | iceFundDeposit = _iceFundDeposit; 119 | fundingStartBlock = _fundingStartBlock; 120 | fundingEndBlock = _fundingEndBlock; 121 | totalSupply = iceFund; 122 | balances[iceFundDeposit] = iceFund; 123 | CreateICE(iceFundDeposit, iceFund); 124 | } 125 | 126 | 127 | function makeTokens() payable { 128 | if (isFinalized) throw; 129 | if (block.number < fundingStartBlock) throw; 130 | if (block.number > fundingEndBlock) throw; 131 | if (msg.value == 0) throw; 132 | 133 | uint256 tokens = safeMult(msg.value, tokenRate()); 134 | 135 | uint256 checkedSupply = safeAdd(totalSupply, tokens); 136 | 137 | if (tokenCreationCap < checkedSupply) throw; 138 | 139 | totalSupply = checkedSupply; 140 | balances[msg.sender] += tokens; 141 | CreateICE(msg.sender, tokens); 142 | } 143 | 144 | function() payable { 145 | makeTokens(); 146 | } 147 | 148 | function finalize() external { 149 | if (isFinalized) throw; 150 | if (msg.sender != ethFundDeposit) throw; 151 | 152 | if(block.number <= fundingEndBlock && totalSupply != tokenCreationCap) throw; 153 | 154 | isFinalized = true; 155 | if(!ethFundDeposit.send(this.balance)) throw; 156 | } 157 | 158 | 159 | 160 | } -------------------------------------------------------------------------------- /SourceCode/INS(INS)_0x5b2e4a700dfbc560061e957edec8f6eeeb74a320.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.16; 2 | 3 | /* 4 | * Abstract Token Smart Contract. Copyright © 2017 by ABDK Consulting. 5 | * Author: Mikhail Vladimirov < -------------------------------------------------------------------------------- /SourceCode/JibrelNetworkToken(JNT)_0xa5fd1a791c4dfcaacc963d4f73c6ae5824149ea7.sol: -------------------------------------------------------------------------------- 1 | /* Author: Victor Mezrin -------------------------------------------------------------------------------- /SourceCode/LatiumX(LATX)_0x2f85e502a988af76f7ee6d83b7db8d6c0a823bf9.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.16; 2 | 3 | contract LatiumX { 4 | string public constant name = "LatiumX"; 5 | string public constant symbol = "LATX"; 6 | uint8 public constant decimals = 8; 7 | uint256 public constant totalSupply = 8 | 300000000 * 10 ** uint256(decimals); 9 | 10 | // owner of this contract 11 | address public owner; 12 | 13 | // balances for each account 14 | mapping (address => uint256) public balanceOf; 15 | 16 | // triggered when tokens are transferred 17 | event Transfer(address indexed _from, address indexed _to, uint _value); 18 | 19 | // constructor 20 | function LatiumX() { 21 | owner = msg.sender; 22 | balanceOf[owner] = totalSupply; 23 | } 24 | 25 | // transfer the balance from sender's account to another one 26 | function transfer(address _to, uint256 _value) { 27 | // prevent transfer to 0x0 address 28 | require(_to != 0x0); 29 | // sender and recipient should be different 30 | require(msg.sender != _to); 31 | // check if the sender has enough coins 32 | require(_value > 0 && balanceOf[msg.sender] >= _value); 33 | // check for overflows 34 | require(balanceOf[_to] + _value > balanceOf[_to]); 35 | // subtract coins from sender's account 36 | balanceOf[msg.sender] -= _value; 37 | // add coins to recipient's account 38 | balanceOf[_to] += _value; 39 | // notify listeners about this transfer 40 | Transfer(msg.sender, _to, _value); 41 | } 42 | } -------------------------------------------------------------------------------- /SourceCode/LinkPlatform(LNK)_0xe2e6d4be086c6938b53b22144855eef674281639.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.8; 2 | 3 | /// @title Link Token. This Token will remain the cornerstone of the entire organization. It will have an Ethereum address and from the moment that address is publish until the end, it will remain the same, and should. The Token should be as simple as it possibly can be and should not be able to terminate. It's state remains so that those who control their Tokens will continue to do so. 4 | /// @author Riaan F Venter~ RFVenter~ < -------------------------------------------------------------------------------- /SourceCode/Lunyr(LUN)_0xfa05A73FfE78ef8f1a739473e462c54bae6567D9.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.8; 2 | 3 | // accepted from zeppelin-solidity https://github.com/OpenZeppelin/zeppelin-solidity 4 | /* 5 | * ERC20 interface 6 | * see https://github.com/ethereum/EIPs/issues/20 7 | */ 8 | contract ERC20 { 9 | uint public totalSupply; 10 | function balanceOf(address who) constant returns (uint); 11 | function allowance(address owner, address spender) constant returns (uint); 12 | 13 | function transfer(address to, uint value) returns (bool ok); 14 | function transferFrom(address from, address to, uint value) returns (bool ok); 15 | function approve(address spender, uint value) returns (bool ok); 16 | event Transfer(address indexed from, address indexed to, uint value); 17 | event Approval(address indexed owner, address indexed spender, uint value); 18 | } 19 | 20 | 21 | // accepted from zeppelin-solidity https://github.com/OpenZeppelin/zeppelin-solidity 22 | 23 | /** 24 | * Math operations with safety checks 25 | */ 26 | contract SafeMath { 27 | function safeMul(uint a, uint b) internal returns (uint) { 28 | uint c = a * b; 29 | assert(a == 0 || c / a == b); 30 | return c; 31 | } 32 | 33 | function safeDiv(uint a, uint b) internal returns (uint) { 34 | assert(b > 0); 35 | uint c = a / b; 36 | assert(a == b * c + a % b); 37 | return c; 38 | } 39 | 40 | function safeSub(uint a, uint b) internal returns (uint) { 41 | assert(b <= a); 42 | return a - b; 43 | } 44 | 45 | function safeAdd(uint a, uint b) internal returns (uint) { 46 | uint c = a + b; 47 | assert(c>=a && c>=b); 48 | return c; 49 | } 50 | 51 | function max64(uint64 a, uint64 b) internal constant returns (uint64) { 52 | return a >= b ? a : b; 53 | } 54 | 55 | function min64(uint64 a, uint64 b) internal constant returns (uint64) { 56 | return a < b ? a : b; 57 | } 58 | 59 | function max256(uint256 a, uint256 b) internal constant returns (uint256) { 60 | return a >= b ? a : b; 61 | } 62 | 63 | function min256(uint256 a, uint256 b) internal constant returns (uint256) { 64 | return a < b ? a : b; 65 | } 66 | 67 | function assert(bool assertion) internal { 68 | if (!assertion) { 69 | throw; 70 | } 71 | } 72 | } 73 | 74 | /// @title Multisignature wallet - Allows multiple parties to agree on transactions before execution. 75 | /// @author Stefan George - < -------------------------------------------------------------------------------- /SourceCode/MCAP(MCAP)_0x93e682107d1e9defb0b5ee701c71707a4b2e46bc.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.6; 2 | 3 | 4 | contract tokenRecipient {function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData);} 5 | 6 | 7 | contract MCAP { 8 | /* Public variables of the token */ 9 | string public standard = 'MCAP 1.0'; 10 | 11 | string public name; 12 | 13 | string public symbol; 14 | 15 | uint8 public decimals; 16 | 17 | uint256 public totalSupply; 18 | 19 | address public owner; 20 | 21 | /* This creates an array with all balances */ 22 | mapping (address => uint256) public balanceOf; 23 | 24 | mapping (address => mapping (address => uint256)) public allowance; 25 | 26 | /* This generates a public event on the blockchain that will notify clients */ 27 | event Transfer(address indexed from, address indexed to, uint256 value); 28 | 29 | /* Initializes contract with initial supply tokens to the creator of the contract */ 30 | function MCAP( 31 | uint256 initialSupply, 32 | string tokenName, 33 | uint8 decimalUnits, 34 | string tokenSymbol 35 | ) { 36 | balanceOf[msg.sender] = initialSupply; 37 | // Give the creator all initial tokens 38 | totalSupply = initialSupply; 39 | // Update total supply 40 | name = tokenName; 41 | // Set the name for display purposes 42 | symbol = tokenSymbol; 43 | // Set the symbol for display purposes 44 | decimals = decimalUnits; 45 | // Amount of decimals for display purposes 46 | 47 | owner=msg.sender; 48 | } 49 | 50 | modifier onlyOwner { 51 | if (msg.sender != owner) throw; 52 | _; 53 | } 54 | /* Send coins */ 55 | function transfer(address _to, uint256 _value) { 56 | if (_to == 0x0) throw; 57 | // Prevent transfer to 0x0 address 58 | if (balanceOf[msg.sender] < _value) throw; 59 | // Check if the sender has enough 60 | if (balanceOf[_to] + _value < balanceOf[_to]) throw; 61 | // Check for overflows 62 | balanceOf[msg.sender] -= _value; 63 | // Subtract from the sender 64 | balanceOf[_to] += _value; 65 | // Add the same to the recipient 66 | Transfer(msg.sender, _to, _value); 67 | // Notify anyone listening that this transfer took place 68 | } 69 | 70 | /* Allow another contract to spend some tokens in your behalf */ 71 | function approve(address _spender, uint256 _value) 72 | returns (bool success) { 73 | allowance[msg.sender][_spender] = _value; 74 | return true; 75 | } 76 | 77 | /* Approve and then comunicate the approved contract in a single tx */ 78 | function approveAndCall(address _spender, uint256 _value, bytes _extraData) 79 | returns (bool success) { 80 | tokenRecipient spender = tokenRecipient(_spender); 81 | if (approve(_spender, _value)) { 82 | spender.receiveApproval(msg.sender, _value, this, _extraData); 83 | return true; 84 | } 85 | } 86 | 87 | /* A contract attempts to get the coins */ 88 | function transferFrom(address _from, address _to, uint256 _value) returns (bool success) { 89 | if (_to == 0x0) throw; 90 | // Prevent transfer to 0x0 address 91 | if (balanceOf[_from] < _value) throw; 92 | // Check if the sender has enough 93 | if (balanceOf[_to] + _value < balanceOf[_to]) throw; 94 | // Check for overflows 95 | if (_value > allowance[_from][msg.sender]) throw; 96 | // Check allowance 97 | balanceOf[_from] -= _value; 98 | // Subtract from the sender 99 | balanceOf[_to] += _value; 100 | // Add the same to the recipient 101 | allowance[_from][msg.sender] -= _value; 102 | Transfer(_from, _to, _value); 103 | return true; 104 | } 105 | 106 | } -------------------------------------------------------------------------------- /SourceCode/MOT(MOT)_0x263c618480dbe35c300d8d5ecda19bbb986acaed.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.19; 2 | 3 | contract Token { 4 | uint256 public totalSupply; 5 | function balanceOf(address _owner) constant returns (uint256 balance); 6 | function transfer(address _to, uint256 _value) returns (bool success); 7 | function transferFrom(address _from, address _to, uint256 _value) returns (bool success); 8 | function approve(address _spender, uint256 _value) returns (bool success); 9 | function allowance(address _owner, address _spender) constant returns (uint256 remaining); 10 | event Transfer(address indexed _from, address indexed _to, uint256 _value); 11 | event Approval(address indexed _owner, address indexed _spender, uint256 _value); 12 | function () public payable { 13 | revert(); 14 | } 15 | } 16 | 17 | 18 | /* ERC 20 token */ 19 | contract StandardToken is Token { 20 | 21 | function transfer(address _to, uint256 _value) returns (bool success) { 22 | if (balances[msg.sender] >= _value && _value > 0) { 23 | balances[msg.sender] -= _value; 24 | balances[_to] += _value; 25 | Transfer(msg.sender, _to, _value); 26 | return true; 27 | } else { 28 | return false; 29 | } 30 | } 31 | 32 | function transferFrom(address _from, address _to, uint256 _value) returns (bool success) { 33 | if (balances[_to] + _value < balances[_to]) revert(); // Check for overflows 34 | if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) { 35 | balances[_to] += _value; 36 | balances[_from] -= _value; 37 | allowed[_from][msg.sender] -= _value; 38 | Transfer(_from, _to, _value); 39 | return true; 40 | } else { 41 | return false; 42 | } 43 | } 44 | 45 | function balanceOf(address _owner) constant returns (uint256 balance) { 46 | return balances[_owner]; 47 | } 48 | 49 | function approve(address _spender, uint256 _value) returns (bool success) { 50 | allowed[msg.sender][_spender] = _value; 51 | Approval(msg.sender, _spender, _value); 52 | return true; 53 | } 54 | 55 | function allowance(address _owner, address _spender) constant returns (uint256 remaining) { 56 | return allowed[_owner][_spender]; 57 | } 58 | 59 | mapping (address => uint256) balances; 60 | mapping (address => mapping (address => uint256)) allowed; 61 | function () public payable { 62 | revert(); 63 | } 64 | } 65 | 66 | contract SafeMath { 67 | 68 | /* function assert(bool assertion) internal { */ 69 | /* if (!assertion) { */ 70 | /* throw; */ 71 | /* } */ 72 | /* } // assert no longer needed once solidity is on 0.4.10 */ 73 | 74 | function safeAdd(uint256 x, uint256 y) internal returns(uint256) { 75 | uint256 z = x + y; 76 | assert((z >= x) && (z >= y)); 77 | return z; 78 | } 79 | 80 | function safeSubtract(uint256 x, uint256 y) internal returns(uint256) { 81 | assert(x >= y); 82 | uint256 z = x - y; 83 | return z; 84 | } 85 | 86 | function safeMult(uint256 x, uint256 y) internal returns(uint256) { 87 | uint256 z = x * y; 88 | assert((x == 0)||(z/x == y)); 89 | return z; 90 | } 91 | 92 | function () public payable { 93 | revert(); 94 | } 95 | 96 | } 97 | contract Owner { 98 | 99 | /// @dev `owner` is the only address that can call a function with this 100 | /// modifier 101 | modifier onlyOwner() { 102 | require(msg.sender == owner); 103 | _; 104 | } 105 | 106 | address public owner; 107 | 108 | /// @notice The Constructor assigns the message sender to be `owner` 109 | function Owner() public { 110 | owner = msg.sender; 111 | } 112 | 113 | address public newOwner; 114 | 115 | /// @notice `owner` can step down and assign some other address to this role 116 | /// @param _newOwner The address of the new owner. 0x0 can be used to create 117 | /// an unowned neutral vault, however that cannot be undone 118 | function changeOwner(address _newOwner) public onlyOwner { 119 | newOwner = _newOwner; 120 | } 121 | 122 | 123 | function acceptOwnership() public { 124 | if (msg.sender == newOwner) { 125 | owner = newOwner; 126 | } 127 | } 128 | 129 | function () public payable { 130 | revert(); 131 | } 132 | 133 | } 134 | contract MOT is Owner, StandardToken, SafeMath { 135 | string public constant name = "MOT"; 136 | string public constant symbol = "MOT"; 137 | uint256 public constant decimals = 18; 138 | string public version = "1.0"; 139 | 140 | 141 | uint256 public constant total = 1 * (10**8) * 10**decimals; // 1*10^8 MOT total 142 | 143 | function MOT() { 144 | 145 | totalSupply = total; 146 | balances[msg.sender] = total; // Give the creator all initial tokens 147 | } 148 | function () public payable { 149 | revert(); 150 | } 151 | } -------------------------------------------------------------------------------- /SourceCode/Melon(MLN)_0xBEB9eF514a379B997e0798FDcC901Ee474B6D9A1.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.8; 2 | 3 | /// @title Assertive contract 4 | /// @author Melonport AG < -------------------------------------------------------------------------------- /SourceCode/MobileGo(MGO)_0x40395044Ac3c0C57051906dA938B54BD6557F212.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.11; 2 | 3 | /* 4 | -------------------------------------------------------------------------------- 5 | The MobileGo [MGO] Token Smart Contract 6 | 7 | Credit: 8 | Stefan Crnojević -------------------------------------------------------------------------------- /SourceCode/MoedaLoyaltyPoints(MDA)_0x51db5ad35c671a87207d88fc11d593ac0c8415bd.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.15; 2 | 3 | /** 4 | * @title SafeMath 5 | * @dev Math operations with safety checks that throw on error 6 | */ 7 | library SafeMath { 8 | function mul(uint256 a, uint256 b) internal constant returns (uint256) { 9 | uint256 c = a * b; 10 | assert(a == 0 || c / a == b); 11 | return c; 12 | } 13 | 14 | function div(uint256 a, uint256 b) internal constant returns (uint256) { 15 | // assert(b > 0); // Solidity automatically throws when dividing by 0 16 | uint256 c = a / b; 17 | // assert(a == b * c + a % b); // There is no case in which this doesn't hold 18 | return c; 19 | } 20 | 21 | function sub(uint256 a, uint256 b) internal constant returns (uint256) { 22 | assert(b <= a); 23 | return a - b; 24 | } 25 | 26 | function add(uint256 a, uint256 b) internal constant returns (uint256) { 27 | uint256 c = a + b; 28 | assert(c >= a); 29 | return c; 30 | } 31 | } 32 | 33 | /** 34 | * @title Ownable 35 | * @dev The Ownable contract has an owner address, and provides basic authorization control 36 | * functions, this simplifies the implementation of "user permissions". 37 | */ 38 | contract Ownable { 39 | address public owner; 40 | 41 | 42 | /** 43 | * @dev The Ownable constructor sets the original `owner` of the contract to the sender 44 | * account. 45 | */ 46 | function Ownable() { 47 | owner = msg.sender; 48 | } 49 | 50 | 51 | /** 52 | * @dev Throws if called by any account other than the owner. 53 | */ 54 | modifier onlyOwner() { 55 | require(msg.sender == owner); 56 | _; 57 | } 58 | 59 | 60 | /** 61 | * @dev Allows the current owner to transfer control of the contract to a newOwner. 62 | * @param newOwner The address to transfer ownership to. 63 | */ 64 | function transferOwnership(address newOwner) onlyOwner { 65 | if (newOwner != address(0)) { 66 | owner = newOwner; 67 | } 68 | } 69 | 70 | } 71 | 72 | /** 73 | * @title Contracts that should not own Tokens 74 | * @author Remco Bloemen < -------------------------------------------------------------------------------- /SourceCode/MyBitToken(MyB)_0x94298f1e0ab2dfad6eeffb1426846a3c29d98090.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.2; 2 | contract owned { 3 | address public owner; 4 | function owned() { 5 | owner = msg.sender; 6 | } 7 | function changeOwner(address newOwner) onlyowner { 8 | owner = newOwner; 9 | } 10 | modifier onlyowner() { 11 | if (msg.sender==owner) _; 12 | } 13 | } 14 | contract tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData); } 15 | contract CSToken is owned { 16 | /* Public variables of the token */ 17 | string public standard = 'Token 0.1'; 18 | string public name; 19 | string public symbol; 20 | uint8 public decimals; 21 | uint256 public totalSupply; 22 | /* This creates an array with all balances */ 23 | mapping (address => uint256) public balanceOf; 24 | mapping (address => mapping (address => uint256)) public allowance; 25 | /* This generates a public event on the blockchain that will notify clients */ 26 | event Transfer(address indexed from, address indexed to, uint256 value); 27 | /* Initializes contract with initial supply tokens to the creator of the contract */ 28 | function CSToken( 29 | uint256 initialSupply, 30 | string tokenName, 31 | uint8 decimalUnits, 32 | string tokenSymbol 33 | ) { 34 | owner = msg.sender; 35 | balanceOf[msg.sender] = initialSupply; // Give the creator all initial tokens 36 | totalSupply = initialSupply; // Update total supply 37 | name = tokenName; // Set the name for display purposes 38 | symbol = tokenSymbol; // Set the symbol for display purposes 39 | decimals = decimalUnits; // Amount of decimals for display purposes 40 | } 41 | /* Send coins */ 42 | function transfer(address _to, uint256 _value) { 43 | if (balanceOf[msg.sender] < _value) throw; // Check if the sender has enough 44 | if (balanceOf[_to] + _value < balanceOf[_to]) throw; // Check for overflows 45 | balanceOf[msg.sender] -= _value; // Subtract from the sender 46 | balanceOf[_to] += _value; // Add the same to the recipient 47 | Transfer(msg.sender, _to, _value); // Notify anyone listening that this transfer took place 48 | } 49 | function mintToken(address target, uint256 mintedAmount) onlyowner { 50 | balanceOf[target] += mintedAmount; 51 | totalSupply += mintedAmount; 52 | Transfer(0, owner, mintedAmount); 53 | Transfer(owner, target, mintedAmount); 54 | } 55 | /* Allow another contract to spend some tokens in your behalf */ 56 | function approve(address _spender, uint256 _value) 57 | returns (bool success) { 58 | allowance[msg.sender][_spender] = _value; 59 | return true; 60 | } 61 | /* Approve and then comunicate the approved contract in a single tx */ 62 | function approveAndCall(address _spender, uint256 _value, bytes _extraData) 63 | returns (bool success) { 64 | tokenRecipient spender = tokenRecipient(_spender); 65 | if (approve(_spender, _value)) { 66 | spender.receiveApproval(msg.sender, _value, this, _extraData); 67 | return true; 68 | } 69 | } 70 | /* A contract attempts to get the coins */ 71 | function transferFrom(address _from, address _to, uint256 _value) returns (bool success) { 72 | if (balanceOf[_from] < _value) throw; // Check if the sender has enough 73 | if (balanceOf[_to] + _value < balanceOf[_to]) throw; // Check for overflows 74 | if (_value > allowance[_from][msg.sender]) throw; // Check allowance 75 | balanceOf[_from] -= _value; // Subtract from the sender 76 | balanceOf[_to] += _value; // Add the same to the recipient 77 | allowance[_from][msg.sender] -= _value; 78 | Transfer(_from, _to, _value); 79 | return true; 80 | } 81 | /* This unnamed function is called whenever someone tries to send ether to it */ 82 | function () { 83 | throw; // Prevents accidental sending of ether 84 | } 85 | } -------------------------------------------------------------------------------- /SourceCode/Network(NTWK)_0x2233799ee2683d75dfefacbcd2a26c78d34b470d.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.11; 2 | 3 | contract Token { 4 | string public symbol = ""; 5 | string public name = ""; 6 | uint8 public constant decimals = 18; 7 | uint256 _totalSupply = 0; 8 | address owner = 0; 9 | bool setupDone = false; 10 | 11 | event Transfer(address indexed _from, address indexed _to, uint256 _value); 12 | event Approval(address indexed _owner, address indexed _spender, uint256 _value); 13 | 14 | mapping(address => uint256) balances; 15 | 16 | mapping(address => mapping (address => uint256)) allowed; 17 | 18 | function Token(address adr) { 19 | owner = adr; 20 | } 21 | 22 | function SetupToken(string tokenName, string tokenSymbol, uint256 tokenSupply) 23 | { 24 | if (msg.sender == owner && setupDone == false) 25 | { 26 | symbol = tokenSymbol; 27 | name = tokenName; 28 | _totalSupply = tokenSupply * 1000000000000000000; 29 | balances[owner] = _totalSupply; 30 | setupDone = true; 31 | } 32 | } 33 | 34 | function totalSupply() constant returns (uint256 totalSupply) { 35 | return _totalSupply; 36 | } 37 | 38 | function balanceOf(address _owner) constant returns (uint256 balance) { 39 | return balances[_owner]; 40 | } 41 | 42 | function transfer(address _to, uint256 _amount) returns (bool success) { 43 | if (balances[msg.sender] >= _amount 44 | && _amount > 0 45 | && balances[_to] + _amount > balances[_to]) { 46 | balances[msg.sender] -= _amount; 47 | balances[_to] += _amount; 48 | Transfer(msg.sender, _to, _amount); 49 | return true; 50 | } else { 51 | return false; 52 | } 53 | } 54 | 55 | function transferFrom( 56 | address _from, 57 | address _to, 58 | uint256 _amount 59 | ) returns (bool success) { 60 | if (balances[_from] >= _amount 61 | && allowed[_from][msg.sender] >= _amount 62 | && _amount > 0 63 | && balances[_to] + _amount > balances[_to]) { 64 | balances[_from] -= _amount; 65 | allowed[_from][msg.sender] -= _amount; 66 | balances[_to] += _amount; 67 | Transfer(_from, _to, _amount); 68 | return true; 69 | } else { 70 | return false; 71 | } 72 | } 73 | 74 | function approve(address _spender, uint256 _amount) returns (bool success) { 75 | allowed[msg.sender][_spender] = _amount; 76 | Approval(msg.sender, _spender, _amount); 77 | return true; 78 | } 79 | 80 | function allowance(address _owner, address _spender) constant returns (uint256 remaining) { 81 | return allowed[_owner][_spender]; 82 | } 83 | } -------------------------------------------------------------------------------- /SourceCode/Nexium(NxC)_0x45e42D659D9f9466cD5DF622506033145a9b89Bc.sol: -------------------------------------------------------------------------------- 1 | contract tokenSpender { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData); } 2 | 3 | contract Nexium { 4 | 5 | 6 | /* Public variables of the token */ 7 | string public name; 8 | string public symbol; 9 | uint8 public decimals; 10 | uint256 public initialSupply; 11 | address public burnAddress; 12 | 13 | /* This creates an array with all balances */ 14 | mapping (address => uint) public balanceOf; 15 | mapping (address => mapping (address => uint)) public allowance; 16 | 17 | /* This generates a public event on the blockchain that will notify clients */ 18 | event Transfer(address indexed from, address indexed to, uint value); 19 | event Approval(address indexed from, address indexed spender, uint value); 20 | 21 | 22 | 23 | /* Initializes contract with initial supply tokens to the creator of the contract */ 24 | function Nexium() { 25 | initialSupply = 100000000000; 26 | balanceOf[msg.sender] = initialSupply; // Give the creator all initial tokens 27 | name = 'Nexium'; // Set the name for display purposes 28 | symbol = 'NxC'; // Set the symbol for display purposes 29 | decimals = 3; // Amount of decimals for display purposes 30 | burnAddress = 0x1b32000000000000000000000000000000000000; 31 | } 32 | 33 | function totalSupply() returns(uint){ 34 | return initialSupply - balanceOf[burnAddress]; 35 | } 36 | 37 | /* Send coins */ 38 | function transfer(address _to, uint256 _value) 39 | returns (bool success) { 40 | if (balanceOf[msg.sender] >= _value && _value > 0) { 41 | balanceOf[msg.sender] -= _value; 42 | balanceOf[_to] += _value; 43 | Transfer(msg.sender, _to, _value); 44 | return true; 45 | } else return false; 46 | } 47 | 48 | /* Allow another contract to spend some tokens in your behalf */ 49 | 50 | 51 | 52 | function approveAndCall(address _spender, 53 | uint256 _value, 54 | bytes _extraData) 55 | returns (bool success) { 56 | allowance[msg.sender][_spender] = _value; 57 | tokenSpender spender = tokenSpender(_spender); 58 | spender.receiveApproval(msg.sender, _value, this, _extraData); 59 | Approval(msg.sender, _spender, _value); 60 | return true; 61 | } 62 | 63 | 64 | 65 | /*Allow another adress to use your money but doesn't notify it*/ 66 | function approve(address _spender, uint256 _value) returns (bool success) { 67 | allowance[msg.sender][_spender] = _value; 68 | Approval(msg.sender, _spender, _value); 69 | return true; 70 | } 71 | 72 | 73 | 74 | /* A contract attempts to get the coins */ 75 | function transferFrom(address _from, 76 | address _to, 77 | uint256 _value) 78 | returns (bool success) { 79 | if (balanceOf[_from] >= _value && allowance[_from][msg.sender] >= _value && _value > 0) { 80 | balanceOf[_to] += _value; 81 | Transfer(_from, _to, _value); 82 | balanceOf[_from] -= _value; 83 | allowance[_from][msg.sender] -= _value; 84 | return true; 85 | } else return false; 86 | } 87 | 88 | 89 | 90 | /* This unnamed function is called whenever someone tries to send ether to it */ 91 | function () { 92 | throw; // Prevents accidental sending of ether 93 | } 94 | } -------------------------------------------------------------------------------- /SourceCode/Nexxus(NXX)_0x7627de4b93263a6a7570b8dafa64bae812e5c394.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.11; 2 | 3 | contract Token { 4 | uint256 public totalSupply; 5 | function balanceOf(address _owner) constant returns (uint256 balance); 6 | function transfer(address _to, uint256 _value) returns (bool success); 7 | function transferFrom(address _from, address _to, uint256 _value) returns (bool success); 8 | function approve(address _spender, uint256 _value) returns (bool success); 9 | function allowance(address _owner, address _spender) constant returns (uint256 remaining); 10 | event Transfer(address indexed _from, address indexed _to, uint256 _value); 11 | event Approval(address indexed _owner, address indexed _spender, uint256 _value); 12 | } 13 | 14 | contract StandardToken is Token { 15 | bool public disabled = false; 16 | function transfer(address _to, uint256 _value) returns (bool success) { 17 | if (disabled != true && balances[msg.sender] >= _value && _value > 0) { 18 | balances[msg.sender] -= _value; 19 | balances[_to] += _value; 20 | Transfer(msg.sender, _to, _value); 21 | return true; 22 | } else { return false; } 23 | } 24 | function transferFrom(address _from, address _to, uint256 _value) returns (bool success) { 25 | if (disabled != true && balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) { 26 | balances[_to] += _value; 27 | balances[_from] -= _value; 28 | allowed[_from][msg.sender] -= _value; 29 | Transfer(_from, _to, _value); 30 | return true; 31 | } else { return false; } 32 | } 33 | function balanceOf(address _owner) constant returns (uint256 balance) { 34 | return balances[_owner]; 35 | } 36 | function approve(address _spender, uint256 _value) returns (bool success) { 37 | allowed[msg.sender][_spender] = _value; 38 | Approval(msg.sender, _spender, _value); 39 | return true; 40 | } 41 | function allowance(address _owner, address _spender) constant returns (uint256 remaining) { 42 | return allowed[_owner][_spender]; 43 | } 44 | mapping (address => uint256) balances; 45 | mapping (address => mapping (address => uint256)) allowed; 46 | } 47 | 48 | contract NexxusToken is StandardToken { 49 | 50 | function () {return;} 51 | 52 | string public name = "Nexxus"; 53 | uint8 public decimals = 8; 54 | string public symbol = "NXX"; 55 | address public owner; 56 | 57 | function NexxusToken() { 58 | totalSupply = 31800000000000000; 59 | owner = msg.sender; 60 | balances[owner] = totalSupply; 61 | } 62 | function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) { 63 | allowed[msg.sender][_spender] = _value; 64 | Approval(msg.sender, _spender, _value); 65 | if(!_spender.call(bytes4(bytes32(sha3("receiveApproval(address,uint256,address,bytes)"))), msg.sender, _value, this, _extraData)) { return; } 66 | return true; 67 | } 68 | function mintToken(uint256 _amount) { 69 | if (msg.sender == owner) { 70 | totalSupply += _amount; 71 | balances[owner] += _amount; 72 | Transfer(0, owner, _amount); 73 | } 74 | } 75 | function disableToken(bool _disable) { 76 | if (msg.sender == owner) 77 | disabled = _disable; 78 | } 79 | } -------------------------------------------------------------------------------- /SourceCode/Quantum(QAU)_0x671abbe5ce652491985342e85428eb1b07bc6c64.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.8; 2 | 3 | contract tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData); } 4 | 5 | contract QuantumToken { 6 | string public version = '0.1'; 7 | string public name; 8 | string public symbol; 9 | uint8 public decimals; 10 | address public owner; 11 | uint256 public _totalSupply; 12 | 13 | mapping (address => uint256) public balances; 14 | mapping (address => mapping (address => uint256)) public allowances; 15 | 16 | event Transfer(address indexed _from, address indexed _to, uint256 _value); 17 | event Burn(address indexed from, uint256 value); 18 | event Approval(address indexed _owner, address indexed _spender, uint256 _value); 19 | 20 | function QuantumToken() { 21 | balances[msg.sender] = 24736207038308271; 22 | _totalSupply = 24736207038308271; 23 | name = 'Quantum'; 24 | symbol = 'QAU'; 25 | decimals = 8; 26 | owner = msg.sender; 27 | } 28 | 29 | function balanceOf(address _owner) constant returns (uint256 balance) { 30 | return balances[_owner]; 31 | } 32 | 33 | function allowance(address _owner, address _spender) constant returns (uint256 remaining) { 34 | return allowances[_owner][_spender]; 35 | } 36 | 37 | function totalSupply() constant returns (uint256 totalSupply) { 38 | return _totalSupply; 39 | } 40 | 41 | function transfer(address _to, uint256 _value) returns (bool success) { 42 | if (_to == 0x0) return false; 43 | if (balances[msg.sender] < _value) return false; 44 | if (balances[_to] + _value < balances[_to]) return false; 45 | balances[msg.sender] -= _value; 46 | balances[_to] += _value; 47 | Transfer(msg.sender, _to, _value); 48 | return true; 49 | } 50 | 51 | function approve(address _spender, uint256 _value) returns (bool success) { 52 | allowances[msg.sender][_spender] = _value; 53 | Approval(msg.sender, _spender, _value); 54 | return true; 55 | } 56 | 57 | function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) { 58 | tokenRecipient spender = tokenRecipient(_spender); 59 | if (approve(_spender, _value)) { 60 | spender.receiveApproval(msg.sender, _value, this, _extraData); 61 | return true; 62 | } 63 | } 64 | 65 | function transferFrom(address _from, address _to, uint256 _value) returns (bool success) { 66 | if (_to == 0x0) return false; 67 | if (balances[_from] < _value) return false; 68 | if (balances[_to] + _value < balances[_to]) return false; 69 | if (_value > allowances[_from][msg.sender]) return false; 70 | balances[_from] -= _value; 71 | balances[_to] += _value; 72 | allowances[_from][msg.sender] -= _value; 73 | Transfer(_from, _to, _value); 74 | return true; 75 | } 76 | 77 | function burn(uint256 _value) returns (bool success) { 78 | if (balances[msg.sender] < _value) return false; 79 | balances[msg.sender] -= _value; 80 | _totalSupply -= _value; 81 | Burn(msg.sender, _value); 82 | return true; 83 | } 84 | 85 | function burnFrom(address _from, uint256 _value) returns (bool success) { 86 | if (balances[_from] < _value) return false; 87 | if (_value > allowances[_from][msg.sender]) return false; 88 | balances[_from] -= _value; 89 | _totalSupply -= _value; 90 | Burn(_from, _value); 91 | return true; 92 | } 93 | } -------------------------------------------------------------------------------- /SourceCode/RHOC(RHOC)_0x168296bb09e24a88805cb9c33356536b980d3fc5.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.7; 2 | 3 | contract SafeMath { 4 | function safeMul(uint a, uint b) internal returns (uint) { 5 | uint c = a * b; 6 | assert(a == 0 || c / a == b); 7 | return c; 8 | } 9 | 10 | function safeSub(uint a, uint b) internal returns (uint) { 11 | assert(b <= a); 12 | return a - b; 13 | } 14 | 15 | function safeAdd(uint a, uint b) internal returns (uint) { 16 | uint c = a + b; 17 | assert(c>=a && c>=b); 18 | return c; 19 | } 20 | 21 | function assert(bool assertion) internal { 22 | if (!assertion) throw; 23 | } 24 | } 25 | 26 | contract ERC20 { 27 | uint public totalSupply; 28 | function balanceOf(address who) constant returns (uint); 29 | function allowance(address owner, address spender) constant returns (uint); 30 | 31 | function transfer(address to, uint value) returns (bool ok); 32 | function transferFrom(address from, address to, uint value) returns (bool ok); 33 | function approve(address spender, uint value) returns (bool ok); 34 | event Transfer(address indexed from, address indexed to, uint value); 35 | event Approval(address indexed owner, address indexed spender, uint value); 36 | } 37 | 38 | contract StandardToken is ERC20, SafeMath { 39 | mapping (address => uint) balances; 40 | mapping (address => mapping (address => uint)) allowed; 41 | 42 | function transfer(address _to, uint _value) returns (bool success) { 43 | // This test is implied by safeSub() 44 | // if (balances[msg.sender] < _value) { throw; } 45 | balances[msg.sender] = safeSub(balances[msg.sender], _value); 46 | balances[_to] = safeAdd(balances[_to], _value); 47 | Transfer(msg.sender, _to, _value); 48 | return true; 49 | } 50 | 51 | function transferFrom(address _from, address _to, uint _value) returns (bool success) { 52 | var _allowance = allowed[_from][msg.sender]; 53 | 54 | // These tests are implied by safeSub() 55 | // if (balances[_from] < _value) { throw; } 56 | // if (_allowance < _value) { throw; } 57 | balances[_to] = safeAdd(balances[_to], _value); 58 | balances[_from] = safeSub(balances[_from], _value); 59 | allowed[_from][msg.sender] = safeSub(_allowance, _value); 60 | Transfer(_from, _to, _value); 61 | return true; 62 | } 63 | 64 | function balanceOf(address _owner) constant returns (uint balance) { 65 | return balances[_owner]; 66 | } 67 | 68 | function approve(address _spender, uint _value) returns (bool success) { 69 | allowed[msg.sender][_spender] = _value; 70 | Approval(msg.sender, _spender, _value); 71 | return true; 72 | } 73 | 74 | function allowance(address _owner, address _spender) constant returns (uint remaining) { 75 | return allowed[_owner][_spender]; 76 | } 77 | } 78 | 79 | contract RHOC is StandardToken { 80 | /* 81 | NOTE: 82 | The following variables are OPTIONAL vanities. One does not have to include them. 83 | They allow one to customise the token contract & in no way influences the core functionality. 84 | Some wallets/interfaces might not even bother to look at this information. 85 | */ 86 | string public name = "RHOC"; // Fancy name: eg: RHO Coin 87 | string public symbol = "RHOC"; // An identifier: eg RHOC 88 | uint public decimals = 8; // Unit precision 89 | 90 | function RHOC(uint supply, address mint) { 91 | totalSupply = supply; // Set the total supply (in base units) 92 | balances[mint] = supply; // Initially assign the entire supply to the specified account 93 | } 94 | 95 | // do not allow deposits 96 | function() { 97 | throw; 98 | } 99 | } -------------------------------------------------------------------------------- /SourceCode/RNTBToken(RNTB)_0x1fe70be734e473e5721ea57c8b5b01e6caa52686.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.15; 2 | 3 | /** 4 | * @title Ownable 5 | * @dev The Ownable contract has an owner address, and provides basic authorization control 6 | * functions, this simplifies the implementation of "user permissions". 7 | */ 8 | contract Ownable { 9 | address public owner; 10 | 11 | 12 | event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); 13 | 14 | 15 | /** 16 | * @dev The Ownable constructor sets the original `owner` of the contract to the sender 17 | * account. 18 | */ 19 | function Ownable() { 20 | owner = msg.sender; 21 | } 22 | 23 | 24 | /** 25 | * @dev Throws if called by any account other than the owner. 26 | */ 27 | modifier onlyOwner() { 28 | require(msg.sender == owner); 29 | _; 30 | } 31 | 32 | 33 | /** 34 | * @dev Allows the current owner to transfer control of the contract to a newOwner. 35 | * @param newOwner The address to transfer ownership to. 36 | */ 37 | function transferOwnership(address newOwner) onlyOwner public { 38 | require(newOwner != address(0)); 39 | OwnershipTransferred(owner, newOwner); 40 | owner = newOwner; 41 | } 42 | 43 | } 44 | 45 | /** 46 | * @title Contracts that should not own Ether 47 | * @author Remco Bloemen < -------------------------------------------------------------------------------- /SourceCode/SENTinel(SENT)_0xa44e5137293e855b1b7bc7e2c6f8cd796ffcb037.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.19; 2 | 3 | contract Owned { 4 | address public owner; 5 | 6 | function Owned( 7 | ) 8 | public { 9 | owner = msg.sender; 10 | } 11 | 12 | modifier onlyOwner { 13 | require(msg.sender == owner); 14 | _; 15 | } 16 | 17 | function transferOwnership( 18 | address _owner) 19 | onlyOwner public { 20 | require(_owner != 0x0); 21 | 22 | owner = _owner; 23 | } 24 | } 25 | 26 | interface tokenRecipient { 27 | function receiveApproval( 28 | address _from, 29 | uint256 _value, 30 | address _token, 31 | bytes _extraData) 32 | public; 33 | } 34 | 35 | contract ERC20Token { 36 | string public name; 37 | string public symbol; 38 | uint8 public decimals; 39 | uint256 public totalSupply; 40 | 41 | mapping (address => uint256) public balanceOf; 42 | mapping (address => mapping (address => uint256)) public allowance; 43 | 44 | event Transfer(address indexed from, address indexed to, uint256 value); 45 | 46 | event Burn(address indexed from, uint256 value); 47 | 48 | function ERC20Token( 49 | string _tokenName, 50 | string _tokenSymbol, 51 | uint8 _decimals, 52 | uint256 _totalSupply) 53 | public { 54 | name = _tokenName; 55 | symbol = _tokenSymbol; 56 | decimals = _decimals; 57 | totalSupply = _totalSupply * 10 ** uint256(decimals); 58 | balanceOf[msg.sender] = totalSupply; 59 | } 60 | 61 | function _transfer( 62 | address _from, 63 | address _to, 64 | uint256 _value) 65 | internal { 66 | require(_to != 0x0); 67 | require(_from != 0x0); 68 | require(_from != _to); 69 | require(balanceOf[_from] >= _value); 70 | require(balanceOf[_to] + _value > balanceOf[_to]); 71 | 72 | uint256 previousBalances = balanceOf[_from] + balanceOf[_to]; 73 | 74 | balanceOf[_from] -= _value; 75 | balanceOf[_to] += _value; 76 | 77 | Transfer(_from, _to, _value); 78 | 79 | assert(balanceOf[_from] + balanceOf[_to] == previousBalances); 80 | } 81 | 82 | function transfer( 83 | address _to, 84 | uint256 _value) 85 | public { 86 | _transfer(msg.sender, _to, _value); 87 | } 88 | 89 | function transferFrom( 90 | address _from, 91 | address _to, 92 | uint256 _value) 93 | public returns (bool success) { 94 | require(_value <= allowance[_from][msg.sender]); 95 | 96 | allowance[_from][msg.sender] -= _value; 97 | 98 | _transfer(_from, _to, _value); 99 | 100 | return true; 101 | } 102 | 103 | function approve( 104 | address _spender, 105 | uint256 _value) 106 | public returns (bool success) { 107 | allowance[msg.sender][_spender] = _value; 108 | 109 | return true; 110 | } 111 | 112 | function approveAndCall( 113 | address _spender, 114 | uint256 _value, 115 | bytes _extraData) 116 | public returns (bool success) { 117 | tokenRecipient spender = tokenRecipient(_spender); 118 | 119 | if (approve(_spender, _value)) { 120 | spender.receiveApproval(msg.sender, _value, this, _extraData); 121 | 122 | return true; 123 | } 124 | } 125 | 126 | function burn( 127 | uint256 _value) 128 | public returns (bool success) { 129 | require(balanceOf[msg.sender] >= _value); 130 | 131 | balanceOf[msg.sender] -= _value; 132 | totalSupply -= _value; 133 | 134 | Burn(msg.sender, _value); 135 | 136 | return true; 137 | } 138 | 139 | function burnFrom( 140 | address _from, 141 | uint256 _value) 142 | public returns (bool success) { 143 | require(balanceOf[_from] >= _value); 144 | require(_value <= allowance[_from][msg.sender]); 145 | 146 | balanceOf[_from] -= _value; 147 | allowance[_from][msg.sender] -= _value; 148 | totalSupply -= _value; 149 | 150 | Burn(_from, _value); 151 | 152 | return true; 153 | } 154 | } 155 | 156 | contract Sentinel is Owned, ERC20Token { 157 | mapping (bytes32 => address) public services; 158 | 159 | function Sentinel( 160 | string _tokenName, 161 | string _tokenSymbol, 162 | uint8 _decimals, 163 | uint256 _totalSupply) 164 | ERC20Token(_tokenName, _tokenSymbol, _decimals, _totalSupply) public { 165 | } 166 | 167 | function deployService( 168 | bytes32 _serviceName, 169 | address _serviceAddress) 170 | onlyOwner public { 171 | services[_serviceName] = _serviceAddress; 172 | } 173 | 174 | function payService( 175 | bytes32 _serviceName, 176 | address _from, 177 | address _to, 178 | uint256 _value) 179 | public { 180 | require(msg.sender != 0x0); 181 | require(services[_serviceName] != 0x0); 182 | require(msg.sender == services[_serviceName]); 183 | require(_from != 0x0); 184 | require(_to != 0x0); 185 | require(balanceOf[_from] >= _value); 186 | require(balanceOf[_to] + _value > balanceOf[_to]); 187 | 188 | uint256 previousBalances = balanceOf[_from] + balanceOf[_to]; 189 | 190 | balanceOf[_from] -= _value; 191 | balanceOf[_to] += _value; 192 | 193 | Transfer(_from, _to, _value); 194 | 195 | assert(balanceOf[_from] + balanceOf[_to] == previousBalances); 196 | } 197 | } -------------------------------------------------------------------------------- /SourceCode/SNGLS(SNGLS)_0xaec2e87e0a235266d9c5adc9deb4b2e29b54d009.sol: -------------------------------------------------------------------------------- 1 | /// Implements ERC 20 Token standard: https://github.com/ethereum/EIPs/issues/20 2 | 3 | /// @title Abstract token contract - Functions to be implemented by token contracts. 4 | /// @author Stefan George - < -------------------------------------------------------------------------------- /SourceCode/Salt(SALT)_0x4156D3342D5c385a87D264F90653733592000581.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.8; 2 | 3 | 4 | contract Token { 5 | uint256 public totalSupply; 6 | 7 | function balanceOf(address _owner) constant returns (uint256 balance); 8 | 9 | function transfer(address _to, uint256 _value) returns (bool success); 10 | 11 | function transferFrom(address _from, address _to, uint256 _value) returns (bool success); 12 | 13 | function approve(address _spender, uint256 _value) returns (bool success); 14 | 15 | function allowance(address _owner, address _spender) constant returns (uint256 remaining); 16 | 17 | event Transfer(address indexed _from, address indexed _to, uint256 _value); 18 | event Approval(address indexed _owner, address indexed _spender, uint256 _value); 19 | } 20 | 21 | 22 | contract StandardToken is Token { 23 | 24 | function transfer(address _to, uint256 _value) returns (bool success) { 25 | if (balances[msg.sender] >= _value && _value > 0) { 26 | balances[msg.sender] -= _value; 27 | balances[_to] += _value; 28 | Transfer(msg.sender, _to, _value); 29 | return true; 30 | } else { return false; } 31 | } 32 | 33 | function transferFrom(address _from, address _to, uint256 _value) returns (bool success) { 34 | if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) { 35 | balances[_to] += _value; 36 | balances[_from] -= _value; 37 | allowed[_from][msg.sender] -= _value; 38 | Transfer(_from, _to, _value); 39 | return true; 40 | } else { return false; } 41 | } 42 | 43 | function balanceOf(address _owner) constant returns (uint256 balance) { 44 | return balances[_owner]; 45 | } 46 | 47 | function approve(address _spender, uint256 _value) returns (bool success) { 48 | allowed[msg.sender][_spender] = _value; 49 | Approval(msg.sender, _spender, _value); 50 | return true; 51 | } 52 | 53 | function allowance(address _owner, address _spender) constant returns (uint256 remaining) { 54 | return allowed[_owner][_spender]; 55 | } 56 | 57 | mapping (address => uint256) balances; 58 | mapping (address => mapping (address => uint256)) allowed; 59 | } 60 | 61 | contract Salt is StandardToken { 62 | 63 | function () { 64 | throw; 65 | } 66 | 67 | string public name; 68 | uint8 public decimals; 69 | string public symbol; 70 | string public version = '1.0'; 71 | 72 | function Salt() { 73 | balances[msg.sender] = 12000000000000000; // Give the creator all initial tokens 74 | totalSupply = 12000000000000000; // Update total supply 75 | name = 'Salt'; // Set the name for display purposes 76 | decimals = 8; // Amount of decimals for display purposes 77 | symbol = 'SALT'; // Set the symbol for display purposes 78 | } 79 | } -------------------------------------------------------------------------------- /SourceCode/Soarcoin(Soar)_0xD65960FAcb8E4a2dFcb2C2212cb2e44a02e2a57E.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^ 0.4.8; 2 | 3 | contract ERC20 { 4 | 5 | uint public totalSupply; 6 | 7 | function totalSupply() constant returns(uint totalSupply); 8 | 9 | function balanceOf(address who) constant returns(uint256); 10 | 11 | function allowance(address owner, address spender) constant returns(uint); 12 | 13 | function transferFrom(address from, address to, uint value) returns(bool ok); 14 | 15 | function approve(address spender, uint value) returns(bool ok); 16 | 17 | function transfer(address to, uint value) returns(bool ok); 18 | 19 | event Transfer(address indexed from, address indexed to, uint value); 20 | 21 | event Approval(address indexed owner, address indexed spender, uint value); 22 | 23 | } 24 | 25 | contract SoarCoin is ERC20 26 | { 27 | 28 | // Name of the token 29 | string public constant name = "Soarcoin"; 30 | 31 | // Symbol of token 32 | string public constant symbol = "Soar"; 33 | 34 | uint public decimals = 6; 35 | uint public totalSupply = 5000000000000000 ; //5 billion includes 6 zero for decimal 36 | address central_account; 37 | address owner; 38 | mapping(address => uint) balances; 39 | 40 | mapping(address => mapping(address => uint)) allowed; 41 | 42 | // Functions with this modifier can only be executed by the owner 43 | modifier onlyOwner() { 44 | if (msg.sender != owner) { 45 | revert(); 46 | } 47 | _; 48 | } 49 | 50 | modifier onlycentralAccount { 51 | require(msg.sender == central_account); 52 | _; 53 | } 54 | 55 | function SoarCoin() 56 | { 57 | owner = msg.sender; 58 | balances[owner] = totalSupply; 59 | } 60 | 61 | 62 | // erc20 function to return total supply 63 | function totalSupply() constant returns(uint) { 64 | return totalSupply; 65 | } 66 | 67 | // erc20 function to return balance of give address 68 | function balanceOf(address sender) constant returns(uint256 balance) { 69 | return balances[sender]; 70 | } 71 | 72 | // Transfer the balance from one account to another account 73 | function transfer(address _to, uint256 _amount) returns(bool success) { 74 | 75 | if (balances[msg.sender] >= _amount && 76 | _amount > 0 && 77 | balances[_to] + _amount > balances[_to]) { 78 | balances[msg.sender] -= _amount; 79 | balances[_to] += _amount; 80 | Transfer(msg.sender, _to, _amount); 81 | return true; 82 | } else { 83 | return false; 84 | } 85 | } 86 | 87 | function set_centralAccount(address central_Acccount) onlyOwner 88 | { 89 | central_account = central_Acccount; 90 | } 91 | 92 | // Send _value amount of tokens from address _from to address _to 93 | // The transferFrom method is used for a withdraw workflow, allowing contracts to send 94 | // tokens on your behalf, for example to "deposit" to a contract address and/or to charge 95 | // fees in sub-currencies; the command should fail unless the _from account has 96 | // deliberately authorized the sender of the message via some mechanism; we propose 97 | // these standardized APIs for approval: 98 | 99 | function transferFrom( 100 | address _from, 101 | address _to, 102 | uint256 _amount 103 | ) returns(bool success) { 104 | if (balances[_from] >= _amount && 105 | allowed[_from][msg.sender] >= _amount && 106 | _amount > 0 && 107 | balances[_to] + _amount > balances[_to]) { 108 | balances[_from] -= _amount; 109 | allowed[_from][msg.sender] -= _amount; 110 | balances[_to] += _amount; 111 | Transfer(_from, _to, _amount); 112 | return true; 113 | } else { 114 | return false; 115 | } 116 | } 117 | 118 | // Allow _spender to withdraw from your account, multiple times, up to the _value amount. 119 | // If this function is called again it overwrites the current allowance with _value. 120 | function approve(address _spender, uint256 _amount) returns(bool success) { 121 | allowed[msg.sender][_spender] = _amount; 122 | Approval(msg.sender, _spender, _amount); 123 | return true; 124 | } 125 | 126 | function allowance(address _owner, address _spender) constant returns(uint256 remaining) { 127 | return allowed[_owner][_spender]; 128 | } 129 | 130 | // Failsafe drain only owner can call this function 131 | function drain() onlyOwner { 132 | if (!owner.send(this.balance)) revert(); 133 | } 134 | // function called by owner only 135 | function zero_fee_transaction( 136 | address _from, 137 | address _to, 138 | uint256 _amount 139 | ) onlycentralAccount returns(bool success) { 140 | if (balances[_from] >= _amount && 141 | _amount > 0 && 142 | balances[_to] + _amount > balances[_to]) { 143 | balances[_from] -= _amount; 144 | balances[_to] += _amount; 145 | Transfer(_from, _to, _amount); 146 | return true; 147 | } else { 148 | return false; 149 | } 150 | } 151 | 152 | } -------------------------------------------------------------------------------- /SourceCode/Suretly(SUR)_0xe120c1ecbfdfea7f0a8f0ee30063491e8c26fedf.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.11; 2 | 3 | contract tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData); } 4 | 5 | contract SuretlyToken { 6 | 7 | string public constant standard = 'Token 0.1'; 8 | string public constant name = "Suretly"; 9 | string public constant symbol = "SUR"; 10 | uint8 public constant decimals = 8; 11 | uint256 public totalSupply = 237614 * 100000000; 12 | 13 | address public owner; 14 | 15 | mapping (address => uint256) public balanceOf; 16 | mapping (address => mapping (address => uint256)) public allowance; 17 | 18 | event Transfer(address indexed _from, address indexed _to, uint256 _value); 19 | event NewOwner(address _newOwner); 20 | event Burn(address indexed _from, uint256 _value); 21 | 22 | function SuretlyToken() { 23 | owner = msg.sender; 24 | balanceOf[owner] = totalSupply; 25 | } 26 | 27 | function replaceOwner(address _newOwner) returns (bool success) { 28 | assert(msg.sender == owner); 29 | owner = _newOwner; 30 | NewOwner(_newOwner); 31 | return true; 32 | } 33 | 34 | function transfer(address _to, uint256 _value) { 35 | require(_to != 0x0); 36 | require(_to != address(this)); 37 | assert(!(balanceOf[msg.sender] < _value)); 38 | assert(!(balanceOf[_to] + _value < balanceOf[_to])); 39 | balanceOf[msg.sender] -= _value; 40 | balanceOf[_to] += _value; 41 | Transfer(msg.sender, _to, _value); 42 | } 43 | 44 | function transferFrom(address _from, address _to, uint256 _value) returns (bool success) { 45 | require(_to != 0x0); 46 | require(_to != address(this)); 47 | assert(!(balanceOf[_from] < _value)); 48 | assert(!(balanceOf[_to] + _value < balanceOf[_to])); 49 | assert(!(_value > allowance[_from][msg.sender])); 50 | balanceOf[_from] -= _value; 51 | balanceOf[_to] += _value; 52 | allowance[_from][msg.sender] -= _value; 53 | Transfer(_from, _to, _value); 54 | return true; 55 | } 56 | 57 | function approve(address _spender, uint256 _value) returns (bool success) { 58 | allowance[msg.sender][_spender] = _value; 59 | return true; 60 | } 61 | 62 | function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) { 63 | tokenRecipient spender = tokenRecipient(_spender); 64 | if (approve(_spender, _value)) { 65 | spender.receiveApproval(msg.sender, _value, this, _extraData); 66 | return true; 67 | } 68 | } 69 | 70 | function burn(uint256 _value) returns (bool success) { 71 | assert(!(balanceOf[msg.sender] < _value)); 72 | balanceOf[msg.sender] -= _value; 73 | totalSupply -= _value; 74 | Burn(msg.sender, _value); 75 | return true; 76 | } 77 | 78 | function burnFrom(address _from, uint256 _value) returns (bool success) { 79 | assert(!(balanceOf[_from] < _value)); 80 | assert(!(_value > allowance[_from][msg.sender])); 81 | balanceOf[_from] -= _value; 82 | totalSupply -= _value; 83 | Burn(_from, _value); 84 | return true; 85 | } 86 | } -------------------------------------------------------------------------------- /SourceCode/Telcoin(TEL)_0x85e076361cc813a908ff672f9bad1541474402b2.sol: -------------------------------------------------------------------------------- 1 | pragma solidity 0.4.18; 2 | 3 | 4 | /** 5 | * @title SafeMath 6 | * @dev Math operations with safety checks that throw on error 7 | */ 8 | library SafeMath { 9 | function mul(uint256 a, uint256 b) internal pure returns (uint256) { 10 | uint256 c = a * b; 11 | assert(a == 0 || c / a == b); 12 | return c; 13 | } 14 | 15 | function div(uint256 a, uint256 b) internal pure returns (uint256) { 16 | // assert(b > 0); // Solidity automatically throws when dividing by 0 17 | uint256 c = a / b; 18 | // assert(a == b * c + a % b); // There is no case in which this doesn't hold 19 | return c; 20 | } 21 | 22 | function sub(uint256 a, uint256 b) internal pure returns (uint256) { 23 | assert(b <= a); 24 | return a - b; 25 | } 26 | 27 | function add(uint256 a, uint256 b) internal pure returns (uint256) { 28 | uint256 c = a + b; 29 | assert(c >= a); 30 | return c; 31 | } 32 | } 33 | 34 | 35 | contract Telcoin { 36 | using SafeMath for uint256; 37 | 38 | event Transfer(address indexed _from, address indexed _to, uint _value); 39 | event Approval(address indexed _owner, address indexed _spender, uint _value); 40 | 41 | string public constant name = "Telcoin"; 42 | string public constant symbol = "TEL"; 43 | uint8 public constant decimals = 2; 44 | 45 | /// The ERC20 total fixed supply of tokens. 46 | uint256 public constant totalSupply = 100000000000 * (10 ** uint256(decimals)); 47 | 48 | /// Account balances. 49 | mapping(address => uint256) balances; 50 | 51 | /// The transfer allowances. 52 | mapping (address => mapping (address => uint256)) internal allowed; 53 | 54 | /// The initial distributor is responsible for allocating the supply 55 | /// into the various pools described in the whitepaper. This can be 56 | /// verified later from the event log. 57 | function Telcoin(address _distributor) public { 58 | balances[_distributor] = totalSupply; 59 | Transfer(0x0, _distributor, totalSupply); 60 | } 61 | 62 | /// ERC20 balanceOf(). 63 | function balanceOf(address _owner) public view returns (uint256) { 64 | return balances[_owner]; 65 | } 66 | 67 | /// ERC20 transfer(). 68 | function transfer(address _to, uint256 _value) public returns (bool) { 69 | require(_to != address(0)); 70 | require(_value <= balances[msg.sender]); 71 | 72 | // SafeMath.sub will throw if there is not enough balance. 73 | balances[msg.sender] = balances[msg.sender].sub(_value); 74 | balances[_to] = balances[_to].add(_value); 75 | Transfer(msg.sender, _to, _value); 76 | return true; 77 | } 78 | 79 | /// ERC20 transferFrom(). 80 | function transferFrom(address _from, address _to, uint256 _value) public returns (bool) { 81 | require(_to != address(0)); 82 | require(_value <= balances[_from]); 83 | require(_value <= allowed[_from][msg.sender]); 84 | 85 | balances[_from] = balances[_from].sub(_value); 86 | balances[_to] = balances[_to].add(_value); 87 | allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); 88 | Transfer(_from, _to, _value); 89 | return true; 90 | } 91 | 92 | /// ERC20 approve(). Comes with the standard caveat that an approval 93 | /// meant to limit spending may actually allow more to be spent due to 94 | /// unfortunate ordering of transactions. For safety, this method 95 | /// should only be called if the current allowance is 0. Alternatively, 96 | /// non-ERC20 increaseApproval() and decreaseApproval() can be used. 97 | function approve(address _spender, uint256 _value) public returns (bool) { 98 | allowed[msg.sender][_spender] = _value; 99 | Approval(msg.sender, _spender, _value); 100 | return true; 101 | } 102 | 103 | /// ERC20 allowance(). 104 | function allowance(address _owner, address _spender) public view returns (uint256) { 105 | return allowed[_owner][_spender]; 106 | } 107 | 108 | /// Not officially ERC20. Allows an allowance to be increased safely. 109 | function increaseApproval(address _spender, uint _addedValue) public returns (bool) { 110 | allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue); 111 | Approval(msg.sender, _spender, allowed[msg.sender][_spender]); 112 | return true; 113 | } 114 | 115 | /// Not officially ERC20. Allows an allowance to be decreased safely. 116 | function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) { 117 | uint oldValue = allowed[msg.sender][_spender]; 118 | if (_subtractedValue > oldValue) { 119 | allowed[msg.sender][_spender] = 0; 120 | } else { 121 | allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue); 122 | } 123 | Approval(msg.sender, _spender, allowed[msg.sender][_spender]); 124 | return true; 125 | } 126 | } -------------------------------------------------------------------------------- /SourceCode/TieToken(TIE)_0x999967e2ec8a74b7c8e9db19e039d920b31d39d0.sol: -------------------------------------------------------------------------------- 1 | /************************************************************************* 2 | * This contract has been merged with solidify 3 | * https://github.com/tiesnetwork/solidify 4 | *************************************************************************/ 5 | 6 | /* 7 | * Tie Token smart contract 8 | * 9 | * Supports ERC20, ERC223 stadards 10 | * 11 | * The TieToken is mintable during Token Sale. On Token Sale finalization it 12 | * will be minted up to the cap and minting will be finished forever 13 | * 14 | * @author Dmitry Kochin < -------------------------------------------------------------------------------- /SourceCode/Tokenomy(TEN)_0xdd16ec0f66e54d453e6756713e533355989040e4.sol: -------------------------------------------------------------------------------- 1 | contract ERC20Basic { 2 | uint256 public totalSupply; 3 | function balanceOf(address who) public view returns (uint256); 4 | function transfer(address to, uint256 value) public returns (bool); 5 | event Transfer(address indexed from, address indexed to, uint256 value); 6 | } 7 | 8 | library SafeMath { 9 | 10 | function mul(uint256 a, uint256 b) internal pure returns (uint256) { 11 | if (a == 0) { 12 | return 0; 13 | } 14 | uint256 c = a * b; 15 | assert(c / a == b); 16 | return c; 17 | } 18 | 19 | function div(uint256 a, uint256 b) internal pure returns (uint256) { 20 | uint256 c = a / b; 21 | return c; 22 | } 23 | 24 | function sub(uint256 a, uint256 b) internal pure returns (uint256) { 25 | assert(b <= a); 26 | return a - b; 27 | } 28 | 29 | function add(uint256 a, uint256 b) internal pure returns (uint256) { 30 | uint256 c = a + b; 31 | assert(c >= a); 32 | return c; 33 | } 34 | } 35 | 36 | 37 | contract BasicToken is ERC20Basic { 38 | using SafeMath for uint256; 39 | 40 | mapping(address => uint256) balances; 41 | 42 | function transfer(address _to, uint256 _value) public returns (bool) { 43 | require(_value > 0); 44 | require(_to != address(0)); 45 | require(_value <= balances[msg.sender]); 46 | 47 | balances[msg.sender] = balances[msg.sender].sub(_value); 48 | balances[_to] = balances[_to].add(_value); 49 | Transfer(msg.sender, _to, _value); 50 | return true; 51 | } 52 | 53 | function balanceOf(address _owner) public view returns (uint256 balance) { 54 | return balances[_owner]; 55 | } 56 | 57 | } 58 | 59 | contract ERC20 is ERC20Basic { 60 | function allowance(address owner, address spender) public view returns (uint256); 61 | function transferFrom(address from, address to, uint256 value) public returns (bool); 62 | function approve(address spender, uint256 value) public returns (bool); 63 | event Approval(address indexed owner, address indexed spender, uint256 value); 64 | } 65 | 66 | 67 | 68 | contract StandardToken is ERC20, BasicToken { 69 | 70 | mapping (address => mapping (address => uint256)) internal allowed; 71 | 72 | 73 | function transferFrom(address _from, address _to, uint256 _value) public returns (bool) { 74 | require(_value > 0); 75 | require(_to != address(0)); 76 | require(_value <= balances[_from]); 77 | require(_value <= allowed[_from][msg.sender]); 78 | 79 | balances[_from] = balances[_from].sub(_value); 80 | balances[_to] = balances[_to].add(_value); 81 | allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); 82 | Transfer(_from, _to, _value); 83 | return true; 84 | } 85 | 86 | function approve(address _spender, uint256 _value) public returns (bool) { 87 | require(_value > 0); 88 | allowed[msg.sender][_spender] = _value; 89 | Approval(msg.sender, _spender, _value); 90 | return true; 91 | } 92 | 93 | function allowance(address _owner, address _spender) public view returns (uint256) { 94 | return allowed[_owner][_spender]; 95 | } 96 | 97 | function increaseApproval(address _spender, uint _addedValue) public returns (bool) { 98 | require(_addedValue > 0); 99 | allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue); 100 | Approval(msg.sender, _spender, allowed[msg.sender][_spender]); 101 | return true; 102 | } 103 | 104 | function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) { 105 | require(_subtractedValue > 0); 106 | uint oldValue = allowed[msg.sender][_spender]; 107 | if (_subtractedValue > oldValue) { 108 | allowed[msg.sender][_spender] = 0; 109 | } else { 110 | allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue); 111 | } 112 | Approval(msg.sender, _spender, allowed[msg.sender][_spender]); 113 | return true; 114 | } 115 | 116 | } 117 | 118 | contract BurnableToken is BasicToken { 119 | 120 | event Burn(address indexed burner, uint256 value); 121 | 122 | function burn(uint256 _value) public { 123 | require(_value > 0); 124 | require(_value <= balances[msg.sender]); 125 | 126 | address burner = msg.sender; 127 | balances[burner] = balances[burner].sub(_value); 128 | totalSupply = totalSupply.sub(_value); 129 | Burn(burner, _value); 130 | } 131 | } 132 | 133 | 134 | contract TenToken is StandardToken, BurnableToken { 135 | 136 | string public constant name = "Tokenomy"; 137 | string public constant symbol = "TEN"; 138 | uint8 public constant decimals = 18; 139 | 140 | uint256 public constant INITIAL_SUPPLY = 200000000 * (10 ** uint256(decimals)); 141 | 142 | function TenToken() public { 143 | totalSupply = INITIAL_SUPPLY; 144 | balances[msg.sender] = INITIAL_SUPPLY; 145 | Transfer(0x0, msg.sender, INITIAL_SUPPLY); 146 | } 147 | 148 | } -------------------------------------------------------------------------------- /SourceCode/Tronix(TRX)_0xf230b790e05390fc8295f4d3f60332c93bed42e2.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.11; 2 | 3 | contract TronToken { 4 | 5 | string public name = "Tronix"; // token name 6 | string public symbol = "TRX"; // token symbol 7 | uint256 public decimals = 6; // token digit 8 | 9 | mapping (address => uint256) public balanceOf; 10 | mapping (address => mapping (address => uint256)) public allowance; 11 | 12 | uint256 public totalSupply = 0; 13 | bool public stopped = false; 14 | 15 | uint256 constant valueFounder = 100000000000000000; 16 | address owner = 0x0; 17 | 18 | modifier isOwner { 19 | assert(owner == msg.sender); 20 | _; 21 | } 22 | 23 | modifier isRunning { 24 | assert (!stopped); 25 | _; 26 | } 27 | 28 | modifier validAddress { 29 | assert(0x0 != msg.sender); 30 | _; 31 | } 32 | 33 | function TronToken(address _addressFounder) { 34 | owner = msg.sender; 35 | totalSupply = valueFounder; 36 | balanceOf[_addressFounder] = valueFounder; 37 | Transfer(0x0, _addressFounder, valueFounder); 38 | } 39 | 40 | function transfer(address _to, uint256 _value) isRunning validAddress returns (bool success) { 41 | require(balanceOf[msg.sender] >= _value); 42 | require(balanceOf[_to] + _value >= balanceOf[_to]); 43 | balanceOf[msg.sender] -= _value; 44 | balanceOf[_to] += _value; 45 | Transfer(msg.sender, _to, _value); 46 | return true; 47 | } 48 | 49 | function transferFrom(address _from, address _to, uint256 _value) isRunning validAddress returns (bool success) { 50 | require(balanceOf[_from] >= _value); 51 | require(balanceOf[_to] + _value >= balanceOf[_to]); 52 | require(allowance[_from][msg.sender] >= _value); 53 | balanceOf[_to] += _value; 54 | balanceOf[_from] -= _value; 55 | allowance[_from][msg.sender] -= _value; 56 | Transfer(_from, _to, _value); 57 | return true; 58 | } 59 | 60 | function approve(address _spender, uint256 _value) isRunning validAddress returns (bool success) { 61 | require(_value == 0 || allowance[msg.sender][_spender] == 0); 62 | allowance[msg.sender][_spender] = _value; 63 | Approval(msg.sender, _spender, _value); 64 | return true; 65 | } 66 | 67 | function stop() isOwner { 68 | stopped = true; 69 | } 70 | 71 | function start() isOwner { 72 | stopped = false; 73 | } 74 | 75 | function setName(string _name) isOwner { 76 | name = _name; 77 | } 78 | 79 | function burn(uint256 _value) { 80 | require(balanceOf[msg.sender] >= _value); 81 | balanceOf[msg.sender] -= _value; 82 | balanceOf[0x0] += _value; 83 | Transfer(msg.sender, 0x0, _value); 84 | } 85 | 86 | event Transfer(address indexed _from, address indexed _to, uint256 _value); 87 | event Approval(address indexed _owner, address indexed _spender, uint256 _value); 88 | } -------------------------------------------------------------------------------- /SourceCode/TrueFlip(TFL)_0xa7f976c360ebbed4465c2855684d1aae5271efa9.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.11; 2 | 3 | contract Owned { 4 | 5 | address public owner = msg.sender; 6 | address public potentialOwner; 7 | 8 | modifier onlyOwner { 9 | require(msg.sender == owner); 10 | _; 11 | } 12 | 13 | modifier onlyPotentialOwner { 14 | require(msg.sender == potentialOwner); 15 | _; 16 | } 17 | 18 | event NewOwner(address old, address current); 19 | event NewPotentialOwner(address old, address potential); 20 | 21 | function setOwner(address _new) 22 | onlyOwner 23 | { 24 | NewPotentialOwner(owner, _new); 25 | potentialOwner = _new; 26 | // owner = _new; 27 | } 28 | 29 | function confirmOwnership() 30 | onlyPotentialOwner 31 | { 32 | NewOwner(owner, potentialOwner); 33 | owner = potentialOwner; 34 | potentialOwner = 0; 35 | } 36 | } 37 | 38 | /** 39 | * Math operations with safety checks 40 | */ 41 | contract SafeMath { 42 | function mul(uint a, uint b) internal returns (uint) { 43 | uint c = a * b; 44 | assert(a == 0 || c / a == b); 45 | return c; 46 | } 47 | 48 | function div(uint a, uint b) internal returns (uint) { 49 | assert(b > 0); 50 | uint c = a / b; 51 | assert(a == b * c + a % b); 52 | return c; 53 | } 54 | 55 | function sub(uint a, uint b) internal returns (uint) { 56 | assert(b <= a); 57 | return a - b; 58 | } 59 | 60 | function add(uint a, uint b) internal returns (uint) { 61 | uint c = a + b; 62 | assert(c >= a); 63 | return c; 64 | } 65 | } 66 | 67 | contract AbstractToken { 68 | // This is not an abstract function, because solc won't recognize generated getter functions for public variables as functions 69 | function totalSupply() constant returns (uint256) {} 70 | function balanceOf(address owner) constant returns (uint256 balance); 71 | function transfer(address to, uint256 value) returns (bool success); 72 | function transferFrom(address from, address to, uint256 value) returns (bool success); 73 | function approve(address spender, uint256 value) returns (bool success); 74 | function allowance(address owner, address spender) constant returns (uint256 remaining); 75 | 76 | event Transfer(address indexed from, address indexed to, uint256 value); 77 | event Approval(address indexed owner, address indexed spender, uint256 value); 78 | event Issuance(address indexed to, uint256 value); 79 | } 80 | 81 | 82 | /// Implements ERC 20 Token standard: https://github.com/ethereum/EIPs/issues/20 83 | contract StandardToken is AbstractToken { 84 | 85 | /* 86 | * Data structures 87 | */ 88 | mapping (address => uint256) balances; 89 | mapping (address => mapping (address => uint256)) allowed; 90 | uint256 public totalSupply; 91 | 92 | /* 93 | * Read and write storage functions 94 | */ 95 | /// @dev Transfers sender's tokens to a given address. Returns success. 96 | /// @param _to Address of token receiver. 97 | /// @param _value Number of tokens to transfer. 98 | function transfer(address _to, uint256 _value) returns (bool success) { 99 | if (balances[msg.sender] >= _value && balances[_to] + _value > balances[_to]) { 100 | balances[msg.sender] -= _value; 101 | balances[_to] += _value; 102 | Transfer(msg.sender, _to, _value); 103 | return true; 104 | } 105 | else { 106 | return false; 107 | } 108 | } 109 | 110 | /// @dev Allows allowed third party to transfer tokens from one address to another. Returns success. 111 | /// @param _from Address from where tokens are withdrawn. 112 | /// @param _to Address to where tokens are sent. 113 | /// @param _value Number of tokens to transfer. 114 | function transferFrom(address _from, address _to, uint256 _value) returns (bool success) { 115 | if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && balances[_to] + _value > balances[_to]) { 116 | balances[_to] += _value; 117 | balances[_from] -= _value; 118 | allowed[_from][msg.sender] -= _value; 119 | Transfer(_from, _to, _value); 120 | return true; 121 | } 122 | else { 123 | return false; 124 | } 125 | } 126 | 127 | /// @dev Returns number of tokens owned by given address. 128 | /// @param _owner Address of token owner. 129 | function balanceOf(address _owner) constant returns (uint256 balance) { 130 | return balances[_owner]; 131 | } 132 | 133 | /// @dev Sets approved amount of tokens for spender. Returns success. 134 | /// @param _spender Address of allowed account. 135 | /// @param _value Number of approved tokens. 136 | function approve(address _spender, uint256 _value) returns (bool success) { 137 | allowed[msg.sender][_spender] = _value; 138 | Approval(msg.sender, _spender, _value); 139 | return true; 140 | } 141 | 142 | /* 143 | * Read storage functions 144 | */ 145 | /// @dev Returns number of allowed tokens for given address. 146 | /// @param _owner Address of token owner. 147 | /// @param _spender Address of token spender. 148 | function allowance(address _owner, address _spender) constant returns (uint256 remaining) { 149 | return allowed[_owner][_spender]; 150 | } 151 | } 152 | 153 | 154 | /// @title Token contract - Implements Standard Token Interface for TrueFlip. 155 | /// @author Zerion - < -------------------------------------------------------------------------------- /SourceCode/UCASH(UCASH)_0x92e52a1a235d9a103d970901066ce910aacefd37.sol: -------------------------------------------------------------------------------- 1 | /* 2 | This is the UCASH Ethereum smart contract 3 | 4 | UCASH Implements the EIP20 token standard: https://github.com/ethereum/EIPs/issues/20 5 | 6 | The smart contract code can be viewed here: https://github.com/UdotCASH/UCASH-ERC20.git 7 | 8 | For more info about UCASH and the U.CASH ecosystem, visit https://u.cash 9 | .*/ 10 | 11 | pragma solidity ^0.4.8; 12 | 13 | contract EIP20Interface { 14 | /* This is a slight change to the ERC20 base standard. 15 | function totalSupply() constant returns (uint256 supply); 16 | is replaced with: 17 | uint256 public totalSupply; 18 | This automatically creates a getter function for the totalSupply. 19 | This is moved to the base contract since public getter functions are not 20 | currently recognised as an implementation of the matching abstract 21 | function by the compiler. 22 | */ 23 | /// total amount of tokens 24 | uint256 public totalSupply; 25 | 26 | /// @param _owner The address from which the balance will be retrieved 27 | /// @return The balance 28 | function balanceOf(address _owner) public view returns (uint256 balance); 29 | 30 | /// @notice send `_value` token to `_to` from `msg.sender` 31 | /// @param _to The address of the recipient 32 | /// @param _value The amount of token to be transferred 33 | /// @return Whether the transfer was successful or not 34 | function transfer(address _to, uint256 _value) public returns (bool success); 35 | 36 | /// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from` 37 | /// @param _from The address of the sender 38 | /// @param _to The address of the recipient 39 | /// @param _value The amount of token to be transferred 40 | /// @return Whether the transfer was successful or not 41 | function transferFrom(address _from, address _to, uint256 _value) public returns (bool success); 42 | 43 | /// @notice `msg.sender` approves `_spender` to spend `_value` tokens 44 | /// @param _spender The address of the account able to transfer the tokens 45 | /// @param _value The amount of tokens to be approved for transfer 46 | /// @return Whether the approval was successful or not 47 | function approve(address _spender, uint256 _value) public returns (bool success); 48 | 49 | /// @param _owner The address of the account owning tokens 50 | /// @param _spender The address of the account able to transfer the tokens 51 | /// @return Amount of remaining tokens allowed to spent 52 | function allowance(address _owner, address _spender) public view returns (uint256 remaining); 53 | 54 | event Transfer(address indexed _from, address indexed _to, uint256 _value); 55 | event Approval(address indexed _owner, address indexed _spender, uint256 _value); 56 | } 57 | 58 | 59 | contract UCASH is EIP20Interface { 60 | 61 | uint256 constant MAX_UINT256 = 2**256 - 1; 62 | 63 | 64 | string public name; 65 | uint8 public decimals; 66 | string public symbol; 67 | 68 | function UCASH( 69 | 70 | ) public { 71 | totalSupply = 21*10**9*10**8; //UCASH totalSupply 72 | balances[msg.sender] = totalSupply; //Allocate UCASH to contract deployer 73 | name = "UCASH"; 74 | decimals = 8; //Amount of decimals for display purposes 75 | symbol = "UCASH"; 76 | } 77 | 78 | function transfer(address _to, uint256 _value) public returns (bool success) { 79 | require(balances[msg.sender] >= _value); 80 | balances[msg.sender] -= _value; 81 | balances[_to] += _value; 82 | Transfer(msg.sender, _to, _value); 83 | return true; 84 | } 85 | 86 | function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) { 87 | uint256 allowance = allowed[_from][msg.sender]; 88 | require(balances[_from] >= _value && allowance >= _value); 89 | balances[_to] += _value; 90 | balances[_from] -= _value; 91 | if (allowance < MAX_UINT256) { 92 | allowed[_from][msg.sender] -= _value; 93 | } 94 | Transfer(_from, _to, _value); 95 | return true; 96 | } 97 | 98 | function balanceOf(address _owner) view public returns (uint256 balance) { 99 | return balances[_owner]; 100 | } 101 | 102 | function approve(address _spender, uint256 _value) public returns (bool success) { 103 | allowed[msg.sender][_spender] = _value; 104 | Approval(msg.sender, _spender, _value); 105 | return true; 106 | } 107 | 108 | function allowance(address _owner, address _spender) 109 | view public returns (uint256 remaining) { 110 | return allowed[_owner][_spender]; 111 | } 112 | 113 | mapping (address => uint256) balances; 114 | mapping (address => mapping (address => uint256)) allowed; 115 | } -------------------------------------------------------------------------------- /SourceCode/VOISE(VOISE)_0x83eEA00D838f92dEC4D1475697B9f4D3537b56E3.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.6; 2 | 3 | contract SafeMath { 4 | //internals 5 | 6 | function safeMul(uint a, uint b) internal returns (uint) { 7 | uint c = a * b; 8 | assert(a == 0 || c / a == b); 9 | return c; 10 | } 11 | 12 | function safeSub(uint a, uint b) internal returns (uint) { 13 | assert(b <= a); 14 | return a - b; 15 | } 16 | 17 | function safeAdd(uint a, uint b) internal returns (uint) { 18 | uint c = a + b; 19 | assert(c>=a && c>=b); 20 | return c; 21 | } 22 | 23 | function assert(bool assertion) internal { 24 | if (!assertion) throw; 25 | } 26 | } 27 | 28 | contract VOISE is SafeMath { 29 | /* Public variables of the token */ 30 | string public standard = 'ERC20'; 31 | string public name = 'VOISE'; 32 | string public symbol = 'VOISE'; 33 | uint8 public decimals = 8; 34 | uint256 public totalSupply; 35 | address public owner; 36 | uint256 public startTime = 1492560000; 37 | /* tells if tokens have been burned already */ 38 | bool burned; 39 | 40 | /* This creates an array with all the balances */ 41 | mapping (address => uint256) public balanceOf; 42 | mapping (address => mapping (address => uint256)) public allowance; 43 | 44 | 45 | /* This generates a public event on the blockchain that will notify all clients */ 46 | event Transfer(address indexed from, address indexed to, uint256 value); 47 | event Approval(address indexed owner, address indexed spender, uint256 value); 48 | event Burned(uint amount); 49 | 50 | /* Initializes contract with initial supply tokens and gives them to the voise team adress */ 51 | function VOISE() { 52 | 53 | owner = msg.sender; 54 | 55 | balanceOf[owner] = 82557800000000000; // All of them are stored in the voise team adress until they are bought 56 | totalSupply = 82557800000000000; // total supply of tokens 57 | } 58 | 59 | /* Send some of your tokens to a given address (Press bounties) */ 60 | function transfer(address _to, uint256 _value) returns (bool success){ 61 | if (now < startTime) throw; //check if the crowdsale is already over 62 | balanceOf[msg.sender] = safeSub(balanceOf[msg.sender],_value); // Subtract from the sender 63 | balanceOf[_to] = safeAdd(balanceOf[_to],_value); // Add the same to the recipient 64 | Transfer(msg.sender, _to, _value); // Notify anyone listening that this transfer took place 65 | return true; 66 | } 67 | 68 | /* Allow another contract or person to spend some tokens in your behalf */ 69 | function approve(address _spender, uint256 _value) returns (bool success) { 70 | allowance[msg.sender][_spender] = _value; 71 | Approval(msg.sender, _spender, _value); 72 | return true; 73 | } 74 | 75 | 76 | /* A contract or person attempts to get the tokens of somebody else. */ 77 | function transferFrom(address _from, address _to, uint256 _value) returns (bool success) { 78 | if (now < startTime && _from!=owner) throw; //check if the crowdsale is already over 79 | var _allowance = allowance[_from][msg.sender]; 80 | balanceOf[_from] = safeSub(balanceOf[_from],_value); // Subtract from the sender 81 | balanceOf[_to] = safeAdd(balanceOf[_to],_value); // Add the same to the recipient 82 | allowance[_from][msg.sender] = safeSub(_allowance,_value); 83 | Transfer(_from, _to, _value); 84 | return true; 85 | } 86 | 87 | } -------------------------------------------------------------------------------- /SourceCode/Veritaseum(VERI)_0x8f3470A7388c05eE4e7AF3d01D8C722b0FF52374.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.8; 2 | 3 | 4 | contract Ownable { 5 | address public owner; 6 | 7 | function Ownable() { 8 | owner = msg.sender; 9 | } 10 | 11 | modifier onlyOwner() { 12 | if (msg.sender != owner) { 13 | throw; 14 | } 15 | _; 16 | } 17 | 18 | function transferOwnership(address newOwner) onlyOwner { 19 | if (newOwner != address(0)) { 20 | owner = newOwner; 21 | } 22 | } 23 | 24 | } 25 | 26 | contract SafeMath { 27 | function safeMul(uint a, uint b) internal returns (uint) { 28 | uint c = a * b; 29 | assert(a == 0 || c / a == b); 30 | return c; 31 | } 32 | 33 | function safeDiv(uint a, uint b) internal returns (uint) { 34 | assert(b > 0); 35 | uint c = a / b; 36 | assert(a == b * c + a % b); 37 | return c; 38 | } 39 | 40 | function safeSub(uint a, uint b) internal returns (uint) { 41 | assert(b <= a); 42 | return a - b; 43 | } 44 | 45 | function safeAdd(uint a, uint b) internal returns (uint) { 46 | uint c = a + b; 47 | assert(c>=a && c>=b); 48 | return c; 49 | } 50 | 51 | function max64(uint64 a, uint64 b) internal constant returns (uint64) { 52 | return a >= b ? a : b; 53 | } 54 | 55 | function min64(uint64 a, uint64 b) internal constant returns (uint64) { 56 | return a < b ? a : b; 57 | } 58 | 59 | function max256(uint256 a, uint256 b) internal constant returns (uint256) { 60 | return a >= b ? a : b; 61 | } 62 | 63 | function min256(uint256 a, uint256 b) internal constant returns (uint256) { 64 | return a < b ? a : b; 65 | } 66 | 67 | function assert(bool assertion) internal { 68 | if (!assertion) { 69 | throw; 70 | } 71 | } 72 | } 73 | 74 | contract ERC20 { 75 | uint public totalSupply; 76 | function balanceOf(address who) constant returns (uint); 77 | function allowance(address owner, address spender) constant returns (uint); 78 | 79 | function transfer(address to, uint value) returns (bool ok); 80 | function transferFrom(address from, address to, uint value) returns (bool ok); 81 | function approve(address spender, uint value) returns (bool ok); 82 | event Transfer(address indexed from, address indexed to, uint value); 83 | event Approval(address indexed owner, address indexed spender, uint value); 84 | } 85 | 86 | contract StandardToken is ERC20, SafeMath { 87 | 88 | mapping(address => uint) balances; 89 | mapping (address => mapping (address => uint)) allowed; 90 | 91 | function transfer(address _to, uint _value) returns (bool success) { 92 | balances[msg.sender] = safeSub(balances[msg.sender], _value); 93 | balances[_to] = safeAdd(balances[_to], _value); 94 | Transfer(msg.sender, _to, _value); 95 | return true; 96 | } 97 | 98 | function transferFrom(address _from, address _to, uint _value) returns (bool success) { 99 | var _allowance = allowed[_from][msg.sender]; 100 | 101 | // Check is not needed because safeSub(_allowance, _value) will already throw if this condition is not met 102 | // if (_value > _allowance) throw; 103 | 104 | balances[_to] = safeAdd(balances[_to], _value); 105 | balances[_from] = safeSub(balances[_from], _value); 106 | allowed[_from][msg.sender] = safeSub(_allowance, _value); 107 | Transfer(_from, _to, _value); 108 | return true; 109 | } 110 | 111 | function balanceOf(address _owner) constant returns (uint balance) { 112 | return balances[_owner]; 113 | } 114 | 115 | function approve(address _spender, uint _value) returns (bool success) { 116 | allowed[msg.sender][_spender] = _value; 117 | Approval(msg.sender, _spender, _value); 118 | return true; 119 | } 120 | 121 | function allowance(address _owner, address _spender) constant returns (uint remaining) { 122 | return allowed[_owner][_spender]; 123 | } 124 | 125 | } 126 | 127 | /// @title Veritaseum Token 128 | /// @author Riaan F Venter~ RFVenter~ < -------------------------------------------------------------------------------- /SourceCode/VibeCoin(VIBE)_0xe8ff5c9c75deb346acac493c463c8950be03dfba.sol: -------------------------------------------------------------------------------- 1 | contract SafeMath { 2 | 3 | function safeAdd(uint256 x, uint256 y) internal returns(uint256) { 4 | uint256 z = x + y; 5 | assert((z >= x) && (z >= y)); 6 | return z; 7 | } 8 | 9 | function safeSubtract(uint256 x, uint256 y) internal returns(uint256) { 10 | assert(x >= y); 11 | uint256 z = x - y; 12 | return z; 13 | } 14 | 15 | function safeMult(uint256 x, uint256 y) internal returns(uint256) { 16 | uint256 z = x * y; 17 | assert((x == 0)||(z/x == y)); 18 | return z; 19 | } 20 | } 21 | 22 | contract Token { 23 | uint256 public totalSupply; 24 | 25 | function balanceOf(address _owner) constant returns (uint256 balance); 26 | function transfer(address _to, uint256 _value) returns (bool success); 27 | function transferFrom(address _from, address _to, uint256 _value) returns (bool success); 28 | function approve(address _spender, uint256 _value) returns (bool success); 29 | function allowance(address _owner, address _spender) constant returns (uint256 remaining); 30 | 31 | event Transfer(address indexed _from, address indexed _to, uint256 _value); 32 | event Approval(address indexed _owner, address indexed _spender, uint256 _value); 33 | } 34 | 35 | /* ERC 20 token */ 36 | contract StandardToken is Token, SafeMath { 37 | 38 | mapping (address => uint256) balances; 39 | mapping (address => mapping (address => uint256)) allowed; 40 | 41 | modifier onlyPayloadSize(uint numwords) { 42 | assert(msg.data.length == numwords * 32 + 4); 43 | _; 44 | } 45 | 46 | function transfer(address _to, uint256 _value) 47 | returns (bool success) 48 | { 49 | if (balances[msg.sender] >= _value && _value > 0 && balances[_to] + _value > balances[_to]) { 50 | balances[msg.sender] = safeSubtract(balances[msg.sender], _value); 51 | balances[_to] = safeAdd(balances[_to], _value); 52 | Transfer(msg.sender, _to, _value); 53 | return true; 54 | } else { 55 | return false; 56 | } 57 | } 58 | 59 | function transferFrom(address _from, address _to, uint256 _value) 60 | returns (bool success) 61 | { 62 | if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0 && balances[_to] + _value > balances[_to]) { 63 | balances[_to] = safeAdd(balances[_to], _value); 64 | balances[_from] = safeSubtract(balances[_from], _value); 65 | allowed[_from][msg.sender] = safeSubtract(allowed[_from][msg.sender], _value); 66 | Transfer(_from, _to, _value); 67 | return true; 68 | } else { 69 | return false; 70 | } 71 | } 72 | 73 | function balanceOf(address _owner) constant returns (uint256 balance) { 74 | return balances[_owner]; 75 | } 76 | 77 | function approve(address _spender, uint256 _value) 78 | onlyPayloadSize(2) 79 | returns (bool success) 80 | { 81 | allowed[msg.sender][_spender] = _value; 82 | Approval(msg.sender, _spender, _value); 83 | return true; 84 | } 85 | 86 | function allowance(address _owner, address _spender) 87 | constant 88 | onlyPayloadSize(2) 89 | returns (uint256 remaining) 90 | { 91 | return allowed[_owner][_spender]; 92 | } 93 | } 94 | /** 95 | * @title VIBECoin 96 | * @dev ERC20 Token, where all tokens are pre-assigned to the creator. 97 | * Note they can later distribute these tokens as they wish using `transfer` and other 98 | * `StandardToken` functions. 99 | */ 100 | contract VibeCoin is StandardToken { 101 | 102 | string public name = "Vibe Coin"; 103 | string public symbol = "VIBE"; 104 | uint256 public decimals = 18; 105 | uint256 public INITIAL_SUPPLY = 267000000 * 1 ether; 106 | 107 | /** 108 | * @dev Contructor that gives msg.sender all of existing tokens. 109 | */ 110 | function VibeCoin() { 111 | totalSupply = INITIAL_SUPPLY; 112 | balances[msg.sender] = INITIAL_SUPPLY; 113 | } 114 | 115 | } -------------------------------------------------------------------------------- /SourceCode/WTT(WTT)_0x84119cb33e8f590d75c2d6ea4e6b0741a7494eda.sol: -------------------------------------------------------------------------------- 1 | /* 2 | * Giga Watt Token Smart Contract. Copyright © 2016 by ABDK Consulting. 3 | * Author: Mikhail Vladimirov < -------------------------------------------------------------------------------- /SourceCode/Walton(WTC)_0xb7cb1c96db6b22b0d3d9536e0108d062bd488f74.sol: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.4.11; 2 | 3 | contract Token { 4 | function transfer(address to, uint256 value) returns (bool success); 5 | function transferFrom(address from, address to, uint256 value) returns (bool success); 6 | function approve(address spender, uint256 value) returns (bool success); 7 | 8 | function totalSupply() constant returns (uint256 totalSupply) {} 9 | function balanceOf(address owner) constant returns (uint256 balance); 10 | function allowance(address owner, address spender) constant returns (uint256 remaining); 11 | 12 | event Transfer(address indexed from, address indexed to, uint256 value); 13 | event Approval(address indexed owner, address indexed spender, uint256 value); 14 | } 15 | 16 | contract StandardToken is Token { 17 | 18 | mapping (address => uint256) balances; 19 | mapping (address => mapping (address => uint256)) allowed; 20 | uint256 public totalSupply; 21 | 22 | function transfer(address _to, uint256 _value) 23 | public 24 | returns (bool) 25 | { 26 | if (balances[msg.sender] < _value) { 27 | throw; 28 | } 29 | balances[msg.sender] -= _value; 30 | balances[_to] += _value; 31 | Transfer(msg.sender, _to, _value); 32 | return true; 33 | } 34 | 35 | function transferFrom(address _from, address _to, uint256 _value) 36 | public 37 | returns (bool) 38 | { 39 | if (balances[_from] < _value || allowed[_from][msg.sender] < _value) { 40 | throw; 41 | } 42 | balances[_to] += _value; 43 | balances[_from] -= _value; 44 | allowed[_from][msg.sender] -= _value; 45 | Transfer(_from, _to, _value); 46 | return true; 47 | } 48 | 49 | function approve(address _spender, uint256 _value) 50 | public 51 | returns (bool) 52 | { 53 | allowed[msg.sender][_spender] = _value; 54 | Approval(msg.sender, _spender, _value); 55 | return true; 56 | } 57 | 58 | function allowance(address _owner, address _spender) 59 | constant 60 | public 61 | returns (uint256) 62 | { 63 | return allowed[_owner][_spender]; 64 | } 65 | 66 | function balanceOf(address _owner) 67 | constant 68 | public 69 | returns (uint256) 70 | { 71 | return balances[_owner]; 72 | } 73 | } 74 | 75 | contract WaltonToken is StandardToken { 76 | 77 | string constant public name = "Walton Token"; 78 | string constant public symbol = "WTC"; 79 | uint8 constant public decimals = 18; 80 | 81 | function WaltonToken() 82 | public 83 | { 84 | totalSupply = 70000000 * 10**18; // the left 30% for pow 85 | balances[msg.sender] = totalSupply; 86 | } 87 | } -------------------------------------------------------------------------------- /SourceCode/minereum(MNE)_0x1a95b271b0535d15fa49932daba31ba612b52946.sol: -------------------------------------------------------------------------------- 1 | contract minereum { 2 | 3 | string public name; 4 | string public symbol; 5 | uint8 public decimals; 6 | uint256 public initialSupplyPerAddress; 7 | uint256 public initialBlockCount; 8 | uint256 public rewardPerBlockPerAddress; 9 | uint256 public totalGenesisAddresses; 10 | address public genesisCallerAddress; 11 | uint256 private availableAmount; 12 | uint256 private availableBalance; 13 | uint256 private minedBlocks; 14 | uint256 private totalMaxAvailableAmount; 15 | uint256 private balanceOfAddress; 16 | 17 | mapping (address => uint256) public balanceOf; 18 | mapping (address => bool) public genesisAddress; 19 | 20 | event Transfer(address indexed from, address indexed to, uint256 value); 21 | 22 | function minereum() { 23 | 24 | name = "minereum"; 25 | symbol = "MNE"; 26 | decimals = 8; 27 | initialSupplyPerAddress = 3200000000000; 28 | initialBlockCount = 3516521; 29 | rewardPerBlockPerAddress = 32000; 30 | totalGenesisAddresses = 4268; 31 | 32 | genesisCallerAddress = 0x0000000000000000000000000000000000000000; 33 | } 34 | 35 | function currentEthBlock() constant returns (uint256 blockNumber) 36 | { 37 | return block.number; 38 | } 39 | 40 | function currentBlock() constant returns (uint256 blockNumber) 41 | { 42 | return block.number - initialBlockCount; 43 | } 44 | 45 | function setGenesisAddressArray(address[] _address) public returns (bool success) 46 | { 47 | if (block.number <= 3597381) 48 | { 49 | if (msg.sender == genesisCallerAddress) 50 | { 51 | for (uint i = 0; i < _address.length; i++) 52 | { 53 | balanceOf[_address[i]] = initialSupplyPerAddress; 54 | genesisAddress[_address[i]] = true; 55 | } 56 | return true; 57 | } 58 | } 59 | return false; 60 | } 61 | 62 | 63 | function availableBalanceOf(address _address) constant returns (uint256 Balance) 64 | { 65 | if (genesisAddress[_address]) 66 | { 67 | minedBlocks = block.number - initialBlockCount; 68 | 69 | if (minedBlocks >= 100000000) return balanceOf[_address]; 70 | 71 | availableAmount = rewardPerBlockPerAddress*minedBlocks; 72 | 73 | totalMaxAvailableAmount = initialSupplyPerAddress - availableAmount; 74 | 75 | availableBalance = balanceOf[_address] - totalMaxAvailableAmount; 76 | 77 | return availableBalance; 78 | } 79 | else 80 | return balanceOf[_address]; 81 | } 82 | 83 | function totalSupply() constant returns (uint256 totalSupply) 84 | { 85 | minedBlocks = block.number - initialBlockCount; 86 | availableAmount = rewardPerBlockPerAddress*minedBlocks; 87 | return availableAmount*totalGenesisAddresses; 88 | } 89 | 90 | function maxTotalSupply() constant returns (uint256 maxSupply) 91 | { 92 | return initialSupplyPerAddress*totalGenesisAddresses; 93 | } 94 | 95 | function transfer(address _to, uint256 _value) { 96 | 97 | if (genesisAddress[_to]) throw; 98 | 99 | if (balanceOf[msg.sender] < _value) throw; 100 | 101 | if (balanceOf[_to] + _value < balanceOf[_to]) throw; 102 | 103 | if (genesisAddress[msg.sender]) 104 | { 105 | minedBlocks = block.number - initialBlockCount; 106 | if (minedBlocks < 100000000) 107 | { 108 | availableAmount = rewardPerBlockPerAddress*minedBlocks; 109 | 110 | totalMaxAvailableAmount = initialSupplyPerAddress - availableAmount; 111 | 112 | availableBalance = balanceOf[msg.sender] - totalMaxAvailableAmount; 113 | 114 | if (_value > availableBalance) throw; 115 | } 116 | } 117 | 118 | balanceOf[msg.sender] -= _value; 119 | balanceOf[_to] += _value; 120 | Transfer(msg.sender, _to, _value); 121 | } 122 | 123 | function setGenesisCallerAddress(address _caller) public returns (bool success) 124 | { 125 | if (genesisCallerAddress != 0x0000000000000000000000000000000000000000) return false; 126 | 127 | genesisCallerAddress = _caller; 128 | 129 | return true; 130 | } 131 | } --------------------------------------------------------------------------------