Buna ziua tuturor! În acest articol vă voi descrie cum în 5 minute și cîteva comenzi într-un terminal de a rula un smart contract de colectare a banilor pentru propriul ICO pe Ethereum. Acest eseu potențial vă salva mii de dolari, ca orice programator — și nu numai — va fi capabil să ruleze un contract inteligent pro-auditat și sigur (în loc să plătească 15.000 — 75.000 dolari pentru dezvoltare). Pe scurt, puteți să trimiteți bani la acest contract inteligent și să primiți jetoane ERC20 pentru asta.

În internet și așa e plin de articole despre contracte inteligente, dar de îndată ce începeți să scrieți unul nou, veți vedea că informațiile se repetă peste tot și tutorialele, cum să porniți propriul ERC20 pur și simplu nu este, sau că sunt depășite, încât nu puteți să le mai folosiți. Apropo, pentru ca acest articol să rămână relevant, voi încerca să indic potențialele locuri în care acesta ar putea deveni depășit (și cum se poate remedia). Să purcedem la lucru!

 

Solidity

Acesta este numele limbajului principal care a fost dezvoltat de o echipa ETH pentru a executa contracte inteligente. Dacă sunteți un programator, atunci doar uitați-vă la documentația limbii — este indecent de simplu. Apropo, a făcut-o simplă, așa că e greu să faci o greșeală în scris a unui contract inteligent. Deci, absolut orice programator, cel puțin nivelul de junior poate înțelege. Absolut nu are sens să plătești bani imenși dezvoltatorilor care știu solidity — va fi mai ieftin să antrenezi un dezvoltator existent.

crypto-job.com

 

Contracte inteligente

… și tot ce trebuie să știți despre ele. Săriți această secțiune dacă nu sunteți programator. Un contract inteligent este o bucată de cod. În principiu, aceasta este o clasă în solidity care are două tipuri de funcții: care schimbă starea și care nu o schimbă. Ei bine, pentru a rula funcții într-un contract inteligent pur și simplu prin trimiterea pe el de ETH, trebuie să marcați această funcție cu payable.

Starea (statul) – este un registru de date, blockchain, mai pe scurt. Contractele pot schimba blockchainul (starea, registrul) — dar pentru a schimba blockchainul , trebuie să plătești kefir (aici și mai departe se va subînțelege ETH- Ethereum) minerilor. Cum vor diviza chefirul nu vor fi discutate în cadrul acestui articol. Plata către mineri pentru executarea codului, schimbarea stării, se numește gaz (Gas). Dacă cineva din afară trimite chefir  la adresa unui contract inteligent, cu o chemare la o funcție marcată payable, dar care nu este etichetată ca Constant, View sau Pure, cantitatea necesară de kefir va fi dedusă din suma trimisă pentru a plăti minerii. În mod tipic, jetoanele ERC20 sunt funcții care fie dau expeditorului tokenuri în schimb la kefir, fie traduc jetoanele de la un utilizator la altul.

Și dacă marcați funcția din contract cu cuvintele Constant sau View (înseamnă același lucru, permiteți doar citirea stării) sau Pure (la fel, chiar și statul nu citește), atunci nu va trebui să cheltuiți kefirul pentru a îndeplini această funcție! Chiar și mai mult vă spun, aceste funcții nu trebuie să fie numite tranzacții — la urma urmei, orice client cu kefir, teoretic, va fi capabil să-l îndeplinească în sine — și nimeni altcineva nu trebuie să știe despre el (nimic nu este scris în blockchain).

Și există două lucruri importante în solidity: mai multe moșteniri și modificatori de funcții. De asemenea, trebuie să știți și despre ele.

Primul este că contractele pot fi moștenite simultan din mai multe clase, cum ar fi TimedCrowdsale, CappedCrowdsale, MintedCrowdsale, Ownable — în timp ce funcțiile constructorului încep, de asemenea una după alta — dar o voi explica cu un exemplul deja mai departe.

A doua este capacitatea de a crea funcții care vor fi apoi introduse în alte funcții. Este ca o încapsulare simplă, doar un pic mai flexibil — este literalmente un șablon de funcții. Când creați un modificator, scrieți un caracter special _ acolo, unde înțelegeți codul funcției care utilizează acest modificator. Adică, modificatorii nu sunt doar o funcție încapsulată care returnează o valoare; acesta este un șablon de funcție, atunci când codul din modificator este literal introdus într-o funcție care utilizează acest modificator.

Să trecem acum la practică.

 

Pregătim mediul

Dacă sunteți pe Windows, pune-ți Terminal prin WLS. Dacă sunteți deja familiarizat cu Terminalul, vom continua. De asemenea, puneți-vă imediat Node.js — va fi necesar pentru pașii următori. Mai bine instalați LTS, dar de fapt, nu contează care dintre versiunile moderne ale nodului o să vă puneți.

Primul lucru pe care îl punem imediat și rulăm procesul de sincronizare a blocurilor este geth. Pe scurt, aceasta este o utilitate scrisă în Go, care ne va permite să rulăm nodul eteric pe computerul local și să vă conectați la rețeaua de testare și reală. Puteți instala prin instalatori, dar vă sfătuiesc să configurați geth imediat în Terminal, așa cum este descris aici. Pentru a verifica dacă ați instalat geth, puteți rula comanda:

geth version

în Terminal. Dacă vi sa digerat versiunea geth – totul este ok, continuați tutorialul. Dacă nu — rău, corect; este necesar se pare să vă mîngîia-ți cu Terminalul și sistemul tău de operare — dar nu este pentru prima dată, veți înțelege.

Cum se instalează geth, executați următoarea comandă în Terminal:

geth —testnet console

Acesta va începe procesul de sincronizare a nodului dvs. cu test server, ale cărui blocuri pot fi vizualizate aici. Verificați dacă sunteți sincronizat cu rețeaua din consola geth, tastând:

eth.blockNumber # dacă 0 nu este încă sincronizat

eth.syncing # va scuipa progresul sincronizării sau fals dacă nu se întâmplă nimic

Procesul de sincronizare mi-a luat de la 1 la 4 ore – când și cum. De asemenea, pe lângă blocarea sincronizării, va trebui de asemenea să așteptați sincronizarea stării — adesea aceasta este mai lungă decât sincronizarea blocurilor. De asemenea, puteți utiliza comenzile geth cu pictograma —light, apoi sincronizarea durează de la câteva secunde până la un minut și puteți încă să faceți deploit la contracte.

Bine, am pus prima utilitate – puneți acum următoarea. Trebuie să punem geth analogică, doar o simulare locală a blockchainu-lui — testrpc. Da, da avem 3 tipuri de blockchain.

  • testrpc — simulare locală a blockchainu-lui, rapidă dar nu reală și stocată numai în aparatul tău
  • geth —testnet — deja un blockchain real, dar o rețea de testare unde puteți obține kefir gratuit și testați tot felul de deznădejde, nu veți pierde banii
  • geth — mainnet, principalul blockchain real, sută la sută kefir pentru adulți, greșeli aici – pierderea reală a kefirului

În consecință, vom începe testul contractelor cu testrpc, apoi îl vom seta în geth —testnet, și apoi vom pune pe geth.

Am pus testrpc executând următoarea comandă:

npm install -g ethereumjs-testrpc

Ei bine, sau acum tot o să fie super tare, din moment ce testrpc stă sub aripa truffle și se numește ganache-cli. Deși dracu s-o știe, la mine totul a mers ca în vanilie cu testrpc. Și dacă funcționează, nu-l atinge, așa cum ma învățat în academia intergalactică. Puteți, de asemenea, să o rulați pentru a verifica instalarea prin scrierea truffle în consola, dar deja sincronizăm blockchainul test — nu vom interfera cu acesta.

Ei bine, te-ai lămurit cu blockchainurile? Nodurile sunt acum acolo și testul este chiar sincronizat? Am pus un utilitar la îndemână pentru a lucra cu smart-contractele pe kefirul — truffle, cu următoarea comandă:

npm install -g truffle

truffle version # verifica imediat, dacă a fost instalat, verificând versiunea

Truffle este un instrument care vă permite să păstrați contractele inteligente în fișiere diferite, să importați alte fișiere și, de asemenea, să vă compilați codul de smart contract într-un singur octet mare (necitit de o persoană), vă găsește automat geth lansată local (test și real ) sau testrpc, veți obține contractul dvs. inteligent în această rețea. De asemenea, verifică codul dvs. de contract inteligent pentru erori și, de asemenea, recent depanat ajută tranzacțiile complete. Must have mai pe scurt.

În această etapă ar trebui să aveți: testrpc, geth, truffle — dacă ceva lipsește sau versiunea nu se varsă în consola la cerere, apoi corectați-o; altfel nu veți obține nimic.

De asemenea, am pus un script simplu bash care va rezolva totul pentru tine. Acest lucru este aici i: source <(curl -s https://raw.githubusercontent.com/backmeupplz/eth-installer/master/install.sh) — dar nu am testat-o încă, deci nu sunt sigur de performanța sa. Cu toate acestea, voi fi bucuros să răspund listelor de apeluri.

 

Scriem contractul propriu zis

Pentru voi totul este deja gândit și scris — este bine. Un pic de cefalee oricum ve-ți avea nu conteaza — dar voi incerca sa-l minimizez. Vom folosi contractele ERC20 deja pregătite de la OpenZeppelin — acesta este acum standardul din industrie, au trecut auditul și, în general, se folosește tot codul. Mulțumesc foarte mult pentru contribuția lor în open source.

Faceți cd-ul într-un dosar sigur și scrie-ți

mkdir contract && cd contract

Vom lucra în acest dosar. Vom crea aici un stub pentru contractul nostru inteligent:

truffle init

Super tare. Acum avem două dosare foarte importante, în care vom marca: contracts și migrations. Primul este codul contractelor noastre, al doilea este codul pentru truffle pentru a ști ce să facem atunci când deploit sunt contractate în blockchain.

În continuare, trebuie să luăm codul actual al contractelor inteligente de la npm și, în mod corespunzător, să începem proiectul în sine:

npm init -y # creați un proiect fără întrebări (-y flag)
npm install -E openzeppelin-solidity # preluați contractele și reparați versiunea curentă (-E flag)

Excelent, codul pentru contractele inteligente de la OpenZeppelin este în buzunarul nostru în dosarul node_modules / openzeppelin-solidity / contracts. Acum mergeți în dosarul principal contracts, ștergeți toate fișierele acolo și adăugați fișierele MyToken.sol și MyCrowdsale.sol — firește, vă veți numi contractele în mod diferit. Primul va fi un contract pentru tokenul nostru ERC20, iar al doilea — contractul ICO-ului nostru, care va lua chefirul și va fi înmânat oamenilor din MyToken. Acest articol poate deveni depășit, dar puteți să vă uitați întotdeauna la modul în care OpenZeppelin sugerează că creați contracte cu aceștia în depozit. Așa va arăta

MyToken.sol:

pragma solidity ^0.4.23;

 

// Imports

import «../node_modules/openzeppelin-solidity/contracts/token/ERC20/MintableToken.sol»;

 

// Main token smart contract

contract MyToken is MintableToken {

string public constant name = «My Token»;

string public constant symbol = «MTKN»;

uint8 public constant decimals = 18;

}

 

Nice — aveți un smart contract pentru propriul token (doar modificați numele în constante)! Puteți să vă uitați la moștenirea de la MintableToken — dar totul este la fel de simplu. Acesta este un simbol care poate fi eliberat (din engleză «Mint» — Monetăria) și numai proprietarul are dreptul să îl elibereze, de vreme ce MintableToken moștenește de asemenea de la Ownable. La fel MintableToken moșteneste, de asemenea, din clasele ERC20, scrise de OpenZeppelin, în care este implementată interfața ERC20:

contract ERC20Basic {

function totalSupply() public view returns (uint256);

function balanceOf(address who) public view returns (uint256);

function transfer(address to, uint256 value) public returns (bool);

event Transfer(address indexed from, address indexed to, uint256 value);

}

Da, iată întreaga interfață ERC20. Este dificil? Nu cred. Oferă posibilitatea de a vedea câte jetoane au fost emise, verificați balanța de adrese și transferați jetoanele la o altă adresă, scuipând un eveniment de transfer pentru clienții ușori de kefir. Și toate aceste lucruri pe care le obțineți gratuit în MyToken.sol datorită activității OpenZeppelin — sunt bravo.

Și acum trecem la partea principală a ICO-lui nostru, trebuie să luăm kefir și să dezvălui MyToken! Așa va arata al vostru MyCrowdsale.sol:

pragma solidity ^0.4.23;

 

// Imports

import «../node_modules/openzeppelin-solidity/contracts/crowdsale/emission/MintedCrowdsale.sol»;

import «../node_modules/openzeppelin-solidity/contracts/crowdsale/distribution/RefundableCrowdsale.sol»;

import «../node_modules/openzeppelin-solidity/contracts/crowdsale/validation/CappedCrowdsale.sol»;

import «../node_modules/openzeppelin-solidity/contracts/token/ERC20/MintableToken.sol»;

 

contract MyCrowdsale is CappedCrowdsale, RefundableCrowdsale, MintedCrowdsale {

constructor(

uint256 _openingTime,

uint256 _closingTime,

uint256 _rate,

address _wallet,

uint256 _cap,

MintableToken _token,

uint256 _goal

)

public

Crowdsale(_rate, _wallet, _token)

CappedCrowdsale(_cap)

TimedCrowdsale(_openingTime, _closingTime)

RefundableCrowdsale(_goal)

{

//As goal needs to be met for a successful crowdsale

//the value needs to less or equal than a cap which is limit for accepted funds

require(_goal <= _cap);

}

}

Deci, deci, ce avem aici? Da băieți smart contracte? Vânzarea noastră de jetoane publică moșteneste cele trei proprietăți cele mai populare: are un hard-cap, mai mult de care nu va putea să colecteze; soft-cap, care nu a colectat etherii care vin înapoi; momentul începutului și sfârșitului vânzării jetoanelor. Strict vorbind, ce altceva este necesar pentru fericire?

Programatorii, notează modul în care constructorii mai multor clase de mosteniri sunt grupați și obțin argumente de la constructorul principal MyCrowdsale. De asemenea, verificăm că avem o unitate de disc deasupra softcap-ului — ales gut! De asemenea, nu fi alarmat de norul parametrilor din constructorul MyCrowdsale — îi vom transmite în stadiul ștergerii contractului în truffle.

Asta e tot — aveți contracte pregătite pentru propriul token ERC20 și chiar un contract inteligent ICO care este personalizat în funcție de preferințele dvs. și distribuie tokene pentru kefir. De asemenea, este susținută de toate portofelele ERC20 – plăcere supremă! Să trecem la testele manuale și deplou.

 

Migrările

După cum am spus mai devreme, vom testa secvențial trei rețele blockchain, dar procesul de testare manual va fi întotdeauna același. Să începem cu testrpc, apoi trecem la geth –testnet și la geth. Nu atît de departe am scris codul, să încercăm să-l compilam. În dosarul proiectului scrieți:

truffle compile

Dacă totul a fost compilat fără probleme, atunci va apărea un dosar build, care va conține un crack pentru truffle, astfel încât acesta să poată consolida codul octet al contractelor tale inteligente în blockchain. Înainte de a pune contracte inteligente în deplou, trebuie să-i spunem trufei ce să facă. Deploy (lansarea) contractelor smart în truffle se numește – migrare — bine, să urmăm această terminologie. Mergeți la migrations/1_initial_migration.js și modificați-l după cum urmează:

const token = artifacts.require(«../contracts/MyToken.sol»);

const crowdsale = artifacts.require(«../contracts/MyCrowdsale.sol»);

 

module.exports = function(deployer, network, accounts) {

const openingTime = 1514764800; // 15 iunie 2018

const closingTime = 1561939200; // 1 iulie 2019

const rate = new web3.BigNumber(1); // 1 FDU за 1 wei

const wallet = ‘0x281055afc982d96fab65b3a49cac8b878184cb16’; // Portofelul beneficiarului

const cap = 200 * 1000000; // Hard cap-ul

const goal = 100 * 1000000; // Soft cap-ul

 

return deployer

.then(() => {

return deployer.deploy(token);

})

.then(() => {

return deployer.deploy(

crowdsale,

openingTime,

closingTime,

rate,

wallet,

cap,

token.address,

goal

);

})

.then(() => {

// Crowdsale  trebuie să dețină tokenul

var tokenContract = web3.eth.contract(token.abi).at(token.address);

web3.eth.defaultAccount = web3.eth.accounts[0];

tokenContract.transferOwnership(crowdsale.address);

});

};

Acesta este același fișier care va fi folosit de truffle pentru deploy a contractelor. Ce magie am făcut aici? În primul rând, am cerut să compilam MyToken și MyCrowdsale. După aceea, am stabilit constantele cu toate argumentele ICO — setați ora de începere și de sfârșit; câte jetoane vor primi pentru 0.000000000000000001 kefir; portofelul unde vor veni kefirii din vânzare, hard cap și soft cap. Rețineți că timpul de deschidere openingTime trebuie să fie întotdeauna după ora blocului curent din blockchain — în caz contrar, contractul dvs. inteligent nu va fi asigurat din cauza verificării condiției în TimedCrowdsale. Am călcat eu pe aceste greble, iar tranzacțiile eșuate, în general, nu pot fi depanate. Modificați aceste constante după cum doriți.

Următorul pas este tocmai acel deploy al smart contractelor. Nu este nimic interesant aici: avem un obiect de deployer care șterge artefactele din contractele inteligente și trece argumentele acolo. Rețineți că mai întâi va fi creat MyToken și numai atunci MyCrowdsale — iar în al doilea rând, adresa primului este trecută de argument.

Apoi, cel mai interesant este ceea ce ei nu scriu despre nici în documentație, nici în cărți. Atunci când creați cu portofelul MyToken, acest portofel devine proprietarul MyToken de către Superclass Ownable — același lucru se întâmplă și cu MyCrowdsale. Dacă săpați adînc în MintableToken, puteți vedea că monedele sunt măcinate numai de proprietar! Și cine deține MyToken? Corect: adresa, pe care o și deployer. Și cine va trimite cereri de monedă? Corect: contractul inteligent MyCrowdsale. Permiteți-mi să vă reamintesc că adresa care a creat MyToken și adresa MyCrowdsale sunt două adrese diferite.

Prin urmare, adăugăm a treia etapă non-ortodoxă a deploy unde adresa, care a făcut deploy la contracte (web3.eth.accounts[0]) numește funcția transferOwnership pe contractul MyToken, astfel încât MyCrowdsale deține MyToken și poate să producă monede. Și MyCrowdsale este încă în posesia contului web3.eth. [0] — deci totul este un pachet.

Notă despre web3.eth.accounts [0]: când faceți deploy la contractul smart , asigurați-vă că geth sau testrpc au setat portofelul corect în web3.eth.accounts [0] — nu pierdeți cheia privată de la acesta, deși nu vă rănește deloc, dar dacă proprietarul vrea să facă ceva schimbări iar cheia este pierdută?

În testrpc, de regulă, conturile sunt create imediat la pornire și sunt imediat deblocate; dar pe blockchainul ether test și real merită să creezi un cont prin personal.newAccount () apoi suplinești această adresă prin intermediul Faucet pe test blockchain sau kefir real pe blockchain real. Nu pierdeți parola și cheile private.

De asemenea, puteți adăuga un portofel existent în conturi apelând web3.personal.importRawKey(‘pvt_key’, ‘password’), dar pentru aceasta trebuie să apelați geth cu parametrul suplimentar —rpcapi = «db, eth, net, web3, personal , web3 «. Cred că veți înțelege.

 

Testarea și implimentarea

Da, contractele sunt gata, migrațiile sunt scrise, rămâne doar pentru a confirma și a verifica. Atât geth (test și real), cât și testrpc sunt gestionate în același mod prin consola truffle console — așa că voi descrie metoda de testare pentru testrpc și vă voi spune cum să activați geth după. Deci, rulați test ethereum blockchainul  local:

testrpc

Um … asta e tot. Simți-ți cum lucrează simulatorul local pentru ether blockchain.

Și pentru a conecta deploy în test ether blockchain, , în locul acestei comenzi, faceți geth — testnet — rpc. Și pentru a vă conecta la ether blockchain real, scrieți doar geth —rpc. Steagul —rpc , este necesar pentru conectarea trufei. Următorii pași ai deployer și testului sunt mai mult sau mai puțin aceiași pentru toate cele trei tipuri de blockchain. Singurul lucru care — după ce executați un blockchain test sau real prin geth, acesta va începe să sincronizeze blocurile — și poate dura până la 4-5 ore pe o conexiune bună la internet. Remarcă despre acest lucru a fost la începutul articolului. Înainte de lansarea contractelor inteligente, vă recomand să așteptați sincronizarea completă. De asemenea, blockchain cântărește aproximativ 60-100 GB, deci pregătiți pentru acesta loc pe disc.

De asemenea, asigurați-vă că web3.eth.accounts[0] este deblocat. De obicei, puteți scrie în consolă testrpc, care se deschide imediat sau într-o fereastră separată Terminal din consola, care se deschide prin consola geth: eth.unlockAccount (eth.accounts [0], «Parola primită când contabilitatea a fost creată», 24 * 3600) acesta va debloca contul dvs., care ar trebui să creeze un contract inteligent

Acum deschidem o nouă fereastră a Terminalului (testrpc nu închidem — ar trebui să funcționeze) și se înregistrează în folderul proiectului:

truffle migrate –reset

Această comandă magică va compila un contract inteligent (adică nu este necesar să scrieți truffle compile de fiecare dată) și conectați-l la micro-serverul blockchain găsit localizat. Este demn de remarcat faptul că, dacă testrpc face acest lucru instantaneu, atunci blockchainul de test și real va include tranzacția în următoarele blocuri mult mai mult. După asta, ar trebui să scuipe consola ceva de genul acesta:

Using network ‘development’.

 

Running migration: 1_initial_migration.js

Running step…

Replacing MyToken…

… 0x86a7090b0a279f8befc95b38fa8bee6918df30928dda0a3c48416454e2082b65

MyToken: 0x2dc35f255e56f06bd2935f5a49a0033548d85477

Replacing MyCrowdsale…

… 0xf0aab5d550f363478ac426dc2aff570302a576282c6c2c4e91205a7a3dea5d72

MyCrowdsale: 0xaac611907f12d5ebe89648d6459c1c81eca78151

… 0x459303aa0b79be2dc2c8041dd48493f2d0e109fac19588f50c0ac664f34c7e30

Saving artifacts…

Cred că deja ați înțeles că consola vă oferă adrese de contracte inteligente MyToken și MyCrowdsale. Asta e tot! Contractul inteligent este executat deploy în acel blockchain, al cărui microserver este deschis pentru tine. Rămâne doar să se verifice faptul că jetoanele sunt într-adevăr distribuite utilizatorilor care trimit kefir la contractul inteligent MyCrowdsale. Înregistrați în Terminal următoarele pentru a intra în consola trufei:

truffle console

Precizați următoarele în trufa acum (fără comentarii vă rog):

// Salvați adresele de contact inteligente

t = «0x2dc35f255e56f06bd2935f5a49a0033548d85477» / / Înlocuiți-vă cu adresa dvs. de MyToken

c = «0xaac611907f12d5ebe89648d6459c1c81eca78151» / / Înlocuiți cu adresa MyCrowdsale

 

// Obțineți instanțe de contracte inteligente

token = MyToken.at (t)

crowdsale = MyCrowdsale.at (c)

 

// Salvați contul într-un nume mai scurt

cont = web3.eth.accounts [0]

 

// Verificați câte jetoane din contul nostru

token.balanceOf (cont) // trebuie să fie 0

 

/ / Am trimis chefir la contractul inteligent

web3.eth.sendTransaction ({de la: cont, la: c, valoare: web3.toWei (0,1, «eter»), gaz: 900000})

 

În cazul testrpc, puteți verifica imediat soldul portofelului vostru, dar în cazul încercării și al unui blockchain test sau adevărat, trebuie să așteptați ca tranzacția să fie inclusă în bloc — de obicei, atunci când acest lucru are loc, trufa vă va da numărul tranzacției. Ai așteptat? Verificăm din nou soldul nostru în MyToken:

// Verificați câte jetoane sunt în contul vostru

token.balanceOf (cont) // trebuie să fie mai mare decât zero

Asta e tot! Încercați mai întâi contractul pe testrpc, apoi pe geth — testnet, apoi pe geth. Deci ai lansat propriul ICO! Și nu a trebuit să cheltuiți zeci de kilodolari pe audit și lansare. Este foarte greu să dăm greș din cea ce ne-au dat băieții de la OpenZeppelin. Și când folosiți truffle — deci dezvoltarea pe solidity  în general, într-un basm se preface. Ei bine, cu excepția situațiilor în care tranzacțiile sunt inversate chiar și atunci când se execută pe un contract inteligent — pentru a le debuga e iadul real. Dar depanarea contractelor inteligente este într-adevăr demnă de un articol separat.

 

La încheiere

Vă mulțumesc foarte mult pentru citirea acestui articol! Dacă am reușit să vă economisesc timp sau bani sau dacă ați învățat ceva nou din acest articol, vă rugăm să vă abonați la canalul nostru de știri pe Telegram. Cea mai bună mulțumire pentru noi este să vă abonați la canal. Dar pentru întrebări și răspunsuri să intrați în chatul nostru.

 

Bonus

Și dacă doriți să schimbați logica, conform căreia este luat în considerare prețul jetoanelor de cumpărare? Desigur, poți schimba rate  sau folosești una dintre clasele de contracte din OpenZeppelin, dar dintr-o dată vrei ceva și mai pervertit? Într-un contract inteligent, puteți depăși funcția getTokenAmount după cum urmează:

function _getTokenAmount(uint256 _weiAmount)

internal view returns (uint256)

{

if (block.timestamp < 1533081600) { // August 1st, 2018

rate = rate * 4;

} else if (block.timestamp < 1546300800) { // January 1st, 2019

rate = rate * 2;

}

return _weiAmount.mul(rate);

}

În general, pentru a putea face prețul tokenului dependente de timp – cu cît mai departe în pădure, cu atât sunt mai scumpe tokenurile. Nu vă fie frică să experimentați și să rescrieți anumite funcții ale contractelor inteligente — este distractiv!

 

ЧЕРЕЗTelegraPH
Предыдущая статьяPornhub добавляет Tron, ZenCash в качестве способов оплаты
Следующая статьяFacebook reia reclamele crypto. Reclamele la ICO-uri rămân interzise în continuare
Отказаться от желаний. Это концепция происходит от одного из трёх путей мудрости: юмор, парадокс, изменение. Она дублирует понятие парадокса. Именно тогда, когда мы больше не желаем чего-то, это может произойти. Искусство отказа от желаний невозможно перехвалить. Не существует ничего, без чего нельзя обойтись. Никогда человек не становился счастливей, если вдруг получал работу, деньги, любовь, которых желал. Настоящее большое счастье связано с неожиданным событием, которое намного превосходит ожидание человека. Мы ведем себя как вечные Деды морозы. Те, кто просит игрушечную железную дорогу, получают ее. А те, кто не просят ничего, могут получить гораздо больше. Перестаньте просить, и только тогда вас можно будет удолетворить.

ОСТАВЬТЕ ОТВЕТ

Please enter your comment!
Please enter your name here