Hoe kan ik: Een token maken op PIRL-netwerk

Deel dit bericht

Delen op facebook
Delen op linkedin
Delen op twitter
Delen op email

De munt

We gaan een digitaal token maken. Tokens in het Pirl-ecosysteem kunnen elk fungibel verhandelbaar goed vertegenwoordigen: munten, loyaliteitspunten, goudcertificaten, IOU's, in-game items, etc. Aangezien alle tokens een aantal basisfuncties op een standaard manier implementeren, betekent dit ook dat uw token onmiddellijk compatibel met de Pirl-portemonnee en elke andere klant of contract die dezelfde normen gebruikt.

MINIMAAL LEVENDIG TOKEN

Het standaard tokencontract kan behoorlijk complex zijn. Maar in wezen komt een heel eenvoudig token hierop neer:

contract MyToken {/ * Dit creëert een array met alle saldi * / mapping (adres => uint256) public balanceOf; / * Initialiseert contract met initiële leveringstokens voor de maker van het contract * / functie MyToken (uint256 initialSupply) {balanceOf [msg.sender] = initialSupply; // Geef de maker alle eerste tokens} / * Verzend munten * / functieoverdracht (adres _to, uint256 _value) {vereisen (balanceOf [msg.sender]> = _value); // Controleer of de afzender voldoende heeft vereist (balanceOf [_to] + _value> = balanceOf [_to]); // Controleer op overlopen balanceOf [msg.sender] - = _value; // Aftrekken van de afzenderbalans Van [_to] + = _waarde; // Voeg hetzelfde toe aan de ontvanger}}

DE CODE

Maar als je gewoon een meer complete code wilt kopiëren en plakken, gebruik dan dit:

pragma-stevigheid ^ 0.4.16;

interface tokenRecipient {function removeApproval (adres _from, uint256 _waarde, adres _token, bytes _extraData) openbaar; }

contract TokenERC20 {
   // Publieke variabelen van het token
   string openbare naam;
   string openbaar symbool;
   uint8 publieke decimalen = 18;
   // 18 decimalen is de sterk aanbevolen standaard, wijzig deze niet
   uint256 public totalSupply;

   // Hiermee maakt u een array met alle saldi
   mapping (adres => uint256) public balanceOf;
   toewijzing (adres => toewijzing (adres => uint256)) openbare vergoeding;

   // Dit genereert een openbaar evenement op de blockchain dat clients op de hoogte brengt
   event Transfer (adres geïndexeerd van, adres geïndexeerd naar, uint256 waarde);

   // Hiermee worden klanten op de hoogte gesteld van het verbrande bedrag
   gebeurtenis Burn (adres geïndexeerd van, uint256 waarde);

   /**
    * Constructor functie
    *
    * Initialiseert contract met initiële leveringstokens voor de maker van het contract
    */
   functie TokenERC20 (
       uint256 initialSupply,
       string tokenName,
       string tokenSymbool
   ) openbaar {
       totalSupply = initialSupply * 10 ** uint256 (decimalen); // Werk het totale aanbod bij met de decimale hoeveelheid
       balanceOf [msg.sender] = totalSupply; // Geef de maker alle eerste tokens
       name = tokenName; // Stel de naam in voor weergavedoeleinden
       symbool = tokenSymbool; // Stel het symbool in voor weergavedoeleinden
   }

   /**
    * Interne overdracht, kan alleen worden opgeroepen door dit contract
    */
   functie _transfer (adres _van, adres _to, uint _waarde) intern {
       // Voorkom overdracht naar 0x0-adres. Gebruik in plaats hiervan burn ()
       vereisen (_to! = 0x0);
       // Controleer of de afzender genoeg heeft
       vereisen (balanceOf [_from]> = _value);
       // Controleer op overlopen
       vereisen (balanceOf [_to] + _value> balanceOf [_to]);
       // Bewaar dit voor een bewering in de toekomst
       uint previousBalances = balanceOf [_from] + balanceOf [_to];
       // Aftrekken van de afzender
       balanceOf [_from] - = _value;
       // Voeg hetzelfde toe aan de ontvanger
       balanceOf [_to] + = _value;
       Transfer (_van, _ tot, _waarde);
       // Asserts worden gebruikt om statische analyse te gebruiken om bugs in uw code te vinden. Ze mogen nooit falen
       assert (balanceOf [_from] + balanceOf [_to] == previousBalances);
   }

   /**
    * Breng tokens over
    *
    * Stuur `_value` tokens naar` _to` vanuit uw account
    *
    * @param _to Het adres van de ontvanger
    * @param _waarde van het te verzenden bedrag
    */
   functieoverdracht (adres _to, uint256 _value) public {
       _transfer (msg.sender, _to, _value);
   }

   /**
    * Breng tokens over van een ander adres
    *
    * Stuur `_value` tokens naar` _to` namens `_from`
    *
    * @param _from Het adres van de afzender
    * @param _to Het adres van de ontvanger
    * @param _waarde van het te verzenden bedrag
    */
   function transferFrom (adres _van, adres _tot, uint256 _waarde) openbare retouren (succes bool) {
       vereisen (_waarde <= vergoeding [_vanaf] [msg.sender]); // Controleer vergoeding
       vergoeding [_vanaf] [msg.sender] - = _waarde;
       _transfer (_van, _ tot, _waarde);
       waar terugkomen;
   }

   /**
    * Stel vergoeding in voor ander adres
    *
    * Staat `_spender` toe om niet meer dan` _value` tokens namens u uit te geven
    *
    * @param _spender Het adres dat is geautoriseerd om te besteden
    * @param _waarde het maximale bedrag dat ze kunnen uitgeven
    */
   functie goedkeuren (adres _spender, uint256 _waarde) openbaar
       retourneert (bool succes) {
       vergoeding [msg.sender] [_ spender] = _waarde;
       waar terugkomen;
   }

   /**
    * Stel vergoeding in voor ander adres en meld het
    *
    * Staat `_spender` toe om niet meer dan` _value` tokens namens u uit te geven en vervolgens het contract hierover te pingen
    *
    * @param _spender Het adres dat is geautoriseerd om te besteden
    * @param _waarde het maximale bedrag dat ze kunnen uitgeven
    * @param _extraData wat extra informatie om naar het goedgekeurde contract te sturen
    */
   functie approveAndCall (adres _spender, uint256 _value, bytes _extraData)
       openbaar
       retourneert (bool succes) {
       tokenRecipient spender = tokenRecipient (_spender);
       if (goedkeuren (_spender, _waarde)) {
           spender.receiveApproval (msg.sender, _value, this, _extraData);
           waar terugkomen;
       }
   }

   /**
    * Vernietig tokens
    *
    * Verwijder `_value` tokens onomkeerbaar uit het systeem
    *
    * @param _waarde van de hoeveelheid te branden geld
    */
   function burn (uint256 _value) public returns (bool succes) {
       vereisen (balanceOf [msg.sender]> = _waarde); // Controleer of de afzender genoeg heeft
       balanceOf [msg.sender] - = _waarde; // Aftrekken van de afzender
       totalSupply - = _waarde; // Updates totalSupply
       Branden (msg.sender, _waarde);
       waar terugkomen;
   }

   /**
    * Vernietig tokens van een ander account
    *
    * Verwijder `_value` tokens onomkeerbaar uit het systeem namens` _from`.
    *
    * @param _van het adres van de afzender
    * @param _waarde van de hoeveelheid te branden geld
    */
   functie burnFrom (adres _from, uint256 _waarde) public returns (bool succes) {
       vereisen (balanceOf [_from]> = _value); // Controleer of het beoogde saldo voldoende is
       vereisen (_waarde <= vergoeding [_vanaf] [msg.sender]); // Controleer vergoeding
       balanceOf [_from] - = _value; // Aftrekken van het beoogde saldo
       vergoeding [_vanaf] [msg.sender] - = _waarde; // Aftrekken van de afzender & #8217; s vergoeding
       totalSupply - = _waarde; // Update totalSupply
       Branden (_van, _waarde);
       waar terugkomen;
   }
}

Inzicht in de code

Dus & #8217; s begint met de basis. Open de Wallet-app, ga naar het tabblad Contracten en implementeer vervolgens Nieuw contract. Typ de onderstaande code in het tekstveld Solidity Contract Source code:

contract MyToken {
       / * Hiermee maakt u een array met alle saldi * /
       mapping (adres => uint256) public balanceOf;
   }

Een toewijzing betekent een associatieve array, waar u adressen aan saldi koppelt. De adressen hebben het standaard hexadecimale Pirl-formaat, terwijl de saldi gehele getallen zijn, variërend van 0 tot 115 quattuorvigintillion. Als u niet weet hoeveel een quattuorvigintillion is, zijn er veel meer vigintillions dan alles waarvoor u uw tokens wilt gebruiken. Het openbare sleutelwoord betekent dat deze variabele voor iedereen op de blockchain toegankelijk is, wat betekent dat alle saldi openbaar zijn (zoals ze moeten zijn, zodat klanten ze kunnen weergeven).

Als u uw contract meteen publiceerde, zou het werken maar zou het niet erg handig zijn: het zou een contract zijn dat het saldo van uw munt voor elk adres zou kunnen opvragen - maar omdat u nooit een enkele munt hebt gemaakt, zou elk van hen retourneer 0. Dus we gaan een paar tokens maken bij het opstarten. Voeg deze code toe vóór de laatste afsluitende haak, net onder de toewijzingsregel.

functie MyToken () {
       balanceOf [msg.sender] = 21000000;
   }

Merk op dat de functie MyToken dezelfde naam heeft als het contract MyToken. Dit is erg belangrijk en als u de ene hernoemt, moet u ook de andere hernoemen: dit is een speciale opstartfunctie die slechts één keer en slechts één keer wordt uitgevoerd wanneer het contract voor het eerst wordt geüpload naar het netwerk. Met deze functie wordt het saldo van msg.sender, de gebruiker die het contract heeft geïmplementeerd, ingesteld op een saldo van 21 miljoen.

De keuze van 21 miljoen was tamelijk willekeurig, en je kunt het veranderen naar alles wat je in de code wilt, maar er is een betere manier: in plaats daarvan geef je het op als een parameter voor de functie, zoals deze:

functie MyToken (uint256 initialSupply) public {
       balanceOf [msg.sender] = initialSupply;
   }

Neem een kijkje in de rechterkolom naast het contract en u ziet een vervolgkeuzelijst, geschreven, kies een contract. Selecteer de & #8220; MyToken & #8221; contract en u & #8217; zie dat het nu een sectie met de naam Constructor-parameters toont. Dit zijn veranderlijke parameters voor uw token, zodat u dezelfde code opnieuw kunt gebruiken en deze variabelen alleen in de toekomst kunt wijzigen.

Op dit moment hebt u een functioneel contract dat saldi van tokens heeft gecreëerd, maar aangezien er geen functie is om het te verplaatsen, blijft het op dezelfde account. Dus dat gaan we nu implementeren. Schrijf de volgende code vóór de laatste haakje.

/ * Verzend munten * /
   functieoverdracht (adres _to, uint256 _value) {
       / * Nieuwe saldi toevoegen en aftrekken * /
       balanceOf [msg.sender] - = _waarde;
       balanceOf [_to] + = _value;
   }

Dit is een zeer eenvoudige functie: het heeft een ontvanger en een waarde als parameter en wanneer iemand het oproept, zal het de _waarde van zijn saldo aftrekken en toevoegen aan het saldo _to. Er is meteen een duidelijk probleem: wat gebeurt er als de persoon meer wil verzenden dan hij bezit? Omdat we in dit specifieke contract geen schulden willen afhandelen, gaan we gewoon een snelle controle uitvoeren en als de afzender niet voldoende geld heeft, stopt de uitvoering van het contract gewoon. It & #8217; s ook om te controleren op overlopen, om te voorkomen dat een getal zo groot wordt dat het weer nul wordt.

Om een uitvoering van een contract halverwege de uitvoering te stoppen, kunt u terugkeren of gooien. De eerste kost minder gas, maar het kan meer hoofdpijn veroorzaken omdat alle wijzigingen die u tot nu toe in het contract hebt aangebracht, behouden blijven. Aan de andere kant, & #8216; throw & #8217; zal alle contractuitvoering annuleren, eventuele wijzigingen terugdraaien die de transactie had kunnen maken en de afzender verliest alle Pirl die hij voor gas heeft gestuurd. Maar omdat de Wallet kan detecteren dat een contract wordt afgesloten, wordt er altijd een waarschuwing weergegeven, waardoor helemaal geen Pirl wordt uitgegeven.

functieoverdracht (adres _to, uint256 _value) {
       / * Controleer of de afzender balans heeft en op overlopen * /
       vereisen (balanceOf [msg.sender]> = _waarde && balanceOf [_to] + _value> = balanceOf [_to]);

       / * Nieuwe saldi toevoegen en aftrekken * /
       balanceOf [msg.sender] - = _waarde;
       balanceOf [_to] + = _value;
   }

 

Nu ontbreekt alleen nog wat basisinformatie over het contract. In de nabije toekomst kan dit worden afgehandeld door een tokenregister, maar voor nu voegen we ze & #8217; rechtstreeks toe aan het contract:

string openbare naam;
string openbaar symbool;
uint8 publieke decimalen;

En nu werken we de constructorfunctie bij zodat al die variabelen vanaf het begin kunnen worden ingesteld:

/ * Initialiseert contract met initiële leveringstokens voor de maker van het contract * /
   functie MyToken (uint256 initialSupply, string tokenName, string tokenSymbol, uint8 decimalUnits) {
       balanceOf [msg.sender] = initialSupply; // Geef de maker alle eerste tokens
       name = tokenName; // Stel de naam in voor weergavedoeleinden
       symbool = tokenSymbool; // Stel het symbool in voor weergavedoeleinden
       decimalen = decimalUnits; // Aantal decimalen voor weergavedoeleinden
   }

Eindelijk hebben we nu somPirling nodig genaamd Evenementen. Dit zijn speciale, lege functies die u gebruikt om klanten zoals de Pirl Wallet te helpen de activiteiten in het contract bij te houden. Evenementen moeten beginnen met een hoofdletter. Voeg deze regel toe aan het begin van het contract om het evenement aan te geven:

event Transfer (adres geïndexeerd van, adres geïndexeerd naar, uint256 waarde);
 

En dan hoeft u alleen maar deze twee regels toe te voegen in de & #8220; transfer & #8221; functie:

      / * Meld iemand die luistert dat deze overdracht heeft plaatsgevonden * /
       Transfer (msg.sender, _to, _value);

 

En nu is je token klaar!

De opmerkingen opgemerkt?

Wat zijn die opmerkingen @notice en @param, vraagt u zich misschien af? Dat & #8217; s Natspec een opkomende standaard voor een specificatie van de natuurlijke taal, waarmee portefeuilles de gebruiker een natuurlijke taalbeschrijving kunnen laten zien van wat het contract gaat doen. Hoewel dit momenteel niet door veel portefeuilles wordt ondersteund, zal dit in de toekomst veranderen, dus het is leuk om voorbereid te zijn.

Hoe te implementeren

Als u daar nog niet bent, open dan de Pirl Wallet, ga naar het tabblad contracten en klik vervolgens op & #8220; nieuw contract implementeren & #8221 ;.

Haal nu de tokenbron van boven en plak deze in het veld & #8220; Solidity source & #8221 ;. Als de code zonder fouten wordt gecompileerd, ziet u een & #8220; kies een contract & #8221; vervolgkeuzelijst aan de rechterkant. Pak het en selecteer de & #8220; MyToken & #8221; contract. In de rechterkolom ziet u & #8217; alle parameters die u nodig hebt om uw eigen token te personaliseren. Je kunt ze naar wens aanpassen.

Blader naar het einde van de pagina en u ziet een schatting van de berekeningskosten van dat contract en u kunt een vergoeding selecteren voor hoeveel Pirl u bereid bent te betalen. Eventueel teveel aan Pirl dat u niet uitgeeft, wordt aan u teruggegeven, zodat u de standaardinstellingen kunt laten als u dat wilt. Druk op & #8220; deploy & #8221 ;, typ uw accountwachtwoord en wacht een paar seconden tot uw transactie is opgepakt.

You & #8217; zal worden doorgestuurd naar de voorpagina waar u uw transactie kunt zien wachten op bevestiging. Klik op de account en na niet meer dan een minuut zou je moeten zien dat je account zal tonen dat je 100% van de aandelen hebt die je zojuist hebt aangemaakt. Om een paar vrienden te sturen: selecteer & #8220; stuur & #8221; en kies vervolgens de valuta die u wilt verzenden (Pirl of uw nieuw gemaakte share), plak het adres van uw vriend & #8217; op het & #8220; in & #8221; veld en druk op & #8220; stuur & #8221 ;.

Als je het naar een vriend stuurt, zien ze nog niets in hun portemonnee. Dit komt omdat de portemonnee alleen tokens bijhoudt waarvan hij weet en deze handmatig moet toevoegen. Ga nu naar de & #8220; Contracten & #8221; en u zou een link naar uw nieuw gecreëerde contract moeten zien. Klik erop om naar de pagina te gaan. Aangezien dit een zeer eenvoudige contractpagina is, is er hier niet veel te doen, klik gewoon op & #8220; kopieer adres & #8221; en plak het contractadres in een teksteditor, u & #8217; zult u binnenkort nodig hebben.

Als u een token wilt toevoegen om naar te kijken, gaat u naar de contractenpagina en klikt u op & #8220; Watch Token & #8221 ;. Er verschijnt een pop-up en u hoeft alleen het contractadres te plakken. De tokennaam, het symbool en het decimale nummer moeten automatisch worden ingevuld, maar als dit niet het geval is, kunt u alles plaatsen wat u wilt (dit heeft alleen invloed op de weergave ervan op uw portemonnee). Zodra u dit doet, wordt u & #8217; l automatisch het saldo weergegeven dat u van dat token hebt en kunt u het aan iemand anders verzenden.

En nu heb je je eigen crypto-token! Tokens kunnen op zichzelf nuttig zijn als waarde-uitwisseling op lokale gemeenschappen, manieren om gewerkte uren bij te houden of andere loyaliteitsprogramma's. Maar kunnen we ervoor zorgen dat een valuta een intrinsieke waarde heeft door deze nuttig te maken?

Verbeter uw token

Je kunt je hele crypto-token inzetten zonder ooit een coderegel aan te raken, maar de echte magie gebeurt wanneer je het gaat aanpassen. De volgende secties bevatten suggesties voor functies die u aan uw token kunt toevoegen om het meer aan uw behoeften te laten voldoen.

Meer basisfuncties

You & #8217; ll merken dat er meer functies in uw basistokencontract zijn, zoals goedkeuren, verzenden en meer. Deze functies zijn er voor uw token om te communiceren met andere contracten: als u bijvoorbeeld tokens wilt verkopen aan een gedecentraliseerde centrale, is het niet voldoende om ze naar een adres te sturen omdat de centrale niet op de hoogte is van de nieuwe tokens of wie heeft verzonden omdat contracten niet kunnen worden geabonneerd op evenementen, alleen voor functieaanroepen. Dus voor contracten moet u eerst een aantal tokens goedkeuren die ze van uw account kunnen verplaatsen en ze vervolgens pingen om ze te laten weten dat ze hun ding moeten doen & #8211; of voer de twee acties in één uit met approveAndCall.

Omdat veel van deze functies de overdracht van tokens moeten herimplementeren, is het logisch om ze te veranderen in een interne functie, die alleen door het contract zelf kan worden opgeroepen:

/ * Interne overdracht, kan alleen worden opgeroepen door dit contract * /
   functie _transfer (adres _van, adres _to, uint _waarde) intern {
       vereisen (_to! = 0x0); // Voorkom overdracht naar 0x0-adres. Gebruik in plaats hiervan burn ()
       vereisen (balanceOf [_from]> = _value); // Controleer of de afzender genoeg heeft
       vereisen (balanceOf [_to] + _value> balanceOf [_to]); // Controleer op overlopen
       vereisen (frozenAccount [_from]!); // Controleer of de afzender bevroren is
       vereisen (frozenAccount [_To]!); // Controleer of de ontvanger bevroren is
       balanceOf [_from] - = _value; // Aftrekken van de afzender
       balanceOf [_to] + = _value; // Voeg hetzelfde toe aan de ontvanger
       Transfer (_van, _ tot, _waarde);
   }

Nu kunnen al uw functies die resulteren in de overdracht van munten, hun eigen controles uitvoeren en vervolgens de overdracht met de juiste parameters oproepen. Merk op dat deze functie munten van elke account naar een andere account verplaatst, zonder dat iemand & #8217; s hiervoor toestemming nodig heeft: dat & #8217; s waarom het & #8217; s een interne functie is, alleen aangeroepen door het contract: als u een functie toevoegt die het aanroept, maak Zorg ervoor dat het goed controleert of de beller toestemming moet hebben om deze te verplaatsen.

Gecentraliseerde beheerder

Alle dapps zijn standaard volledig gedecentraliseerd, maar dat betekent niet dat ze een centrale manager kunnen hebben, als u dat wilt. Misschien wilt u de mogelijkheid om meer munten te slaan, misschien wilt u sommige mensen verbieden uw valuta te gebruiken. Je kunt elk van deze functies toevoegen, maar de vangst is dat je ze alleen aan het begin kunt toevoegen, zodat alle tokenhouders altijd precies de regels van het spel weten voordat ze besluiten er een te bezitten.

Daarvoor heeft u een centrale valuta-controller nodig. Dit kan een eenvoudig account zijn, maar ook een contract en daarom hangt de beslissing om meer tokens te maken af van het contract: als het & #8217; een democratische organisatie is die kan stemmen, of misschien is het gewoon een manier om te beperken de kracht van de tokeneigenaar.

Om dat te doen leren we een zeer nuttige eigenschap van contracten: overerving. Door overerving kan een contract eigenschappen van een oudercontract verwerven, zonder dat ze allemaal opnieuw moeten worden gedefinieerd. Dit maakt de code schoner en gemakkelijker opnieuw te gebruiken. Voeg deze code toe aan de eerste regel van uw code, vóór contract MyToken {.

contract eigendom {
       adres openbare eigenaar;

       functie eigendom () {
           eigenaar = msg.sender;
       }

       modifier onlyOwner {
           vereisen (msg.sender == eigenaar);
           _;
       }

       function transferOwnership (adres newOwner) alleenOwner {
           eigenaar = nieuwEigenaar;
       }
   }

Dit creëert een zeer basiscontract dat niets doet, behalve het definiëren van enkele generieke functies over een contract dat & #8220; eigendom is van & #8221 ;. Nu is de volgende stap alleen het toevoegen van de tekst die eigendom is van uw contract:

 contract MyToken is eigendom {
       / * de rest van het contract zoals gewoonlijk * /

Dit betekent dat alle functies in MyToken nu toegang hebben tot de variabele eigenaar en de modifier onlyOwner. Het contract krijgt ook een functie om eigendom over te dragen. Omdat het misschien interessant is om de eigenaar van het contract bij het opstarten in te stellen, kunt u dit ook toevoegen aan de constructorfunctie:

functie MyToken (
       uint256 initialSupply,
       string tokenName,
       uint8 decimalUnits,
       string tokenSymbool,
       adres centralMinter
       ) {
       if (centralMinter! = 0) eigenaar = centralMinter;
   }

Centrale munt

Stel dat u wilt dat het aantal munten in omloop verandert. Dit is het geval wanneer uw tokens feitelijk een off blockchain-activum vertegenwoordigen (zoals goudcertificaten of overheidsvaluta's) en u wilt dat de virtuele inventaris de echte weerspiegelt. Dit kan ook het geval zijn wanneer de valutahouders enige controle van de prijs van het token verwachten en tokens willen uitgeven of uit de circulatie willen halen.

Eerst moeten we een variabele toevoegen om de totalSupply op te slaan en toe te wijzen aan onze constructorfunctie.

contract MyToken {
       uint256 public totalSupply;

       functie MyToken (& #8230;) {
           totalSupply = initialSupply;
           …
       }
       …
   }

Laat nu & #8217; s eindelijk een nieuwe functie toevoegen waarmee de eigenaar nieuwe tokens kan maken:

function mintToken (address target, uint256 mintedAmount) onlyOwner {
       balanceOf [target] + = mintedAmount;
       totalSupply + = mintedAmount;
       Overboeking (0, eigenaar, geslagen bedrag);
       Overdracht (eigenaar, doel, geslagen bedrag);
   }

Let op de modifier onlyOwner aan het einde van de functienaam. Dit betekent dat deze functie bij het compileren wordt herschreven om de code over te nemen van de modifier onlyOwner die we eerder hadden gedefinieerd. De code van deze functie & #8217; s zal worden ingevoegd waar er een onderstreping is van de modificatiefunctie, wat betekent dat deze specifieke functie alleen kan worden aangeroepen door de account die is ingesteld als de eigenaar. Voeg dit gewoon toe aan een contract met een modifier voor de eigenaar en u kunt meer munten maken.

Bevriezing van activa

Afhankelijk van uw gebruik, is het mogelijk dat u een aantal regelgevingshindernissen moet hebben over wie uw tokens wel en niet mag gebruiken. Om dat te laten gebeuren, kunt u een parameter toevoegen waarmee de contracteigenaar activa kan bevriezen of bevriezen.

Voeg deze variabele toe en werk overal in het contract. Je kunt ze overal plaatsen, maar voor een goede oefening raden we je aan om de toewijzingen bij de andere toewijzingen en evenementen bij de andere evenementen te plaatsen.

mapping (adres => bool) public frozenAccount;
   gebeurtenis FrozenFunds (adresdoel, bool bevroren);

   functie freezeAccount (adresdoel, bool freeze) alleen Eigenaar {
       frozenAccount [target] = bevriezen;
       FrozenFunds (doel, bevriezen);
   }

Met deze code worden alle accounts standaard niet bevroren, maar de eigenaar kan elk van deze accounts in een freeze-status zetten door Freeze Account aan te roepen. Helaas heeft bevriezen geen praktisch effect omdat we niets hebben toegevoegd aan de overdrachtsfunctie. We veranderen dat nu:

functieoverdracht (adres _to, uint256 _value) {
       vereisen (frozenAccount [msg.sender]!);

Nu is voor elk account dat bevroren is, het geld nog steeds intact, maar kan het niet worden verplaatst & #8217; t. Alle accounts worden standaard bevroren totdat u ze bevriest, maar u kunt dat gedrag eenvoudig terugzetten op een witte lijst waar u elk account handmatig moet goedkeuren. Wijzig de naam bevrorenAccount in goedgekeurdeAccount en wijzig de laatste regel in:

vereisen (approvedAccount [msg.sender]);

Automatisch verkopen en kopen

Tot dusverre vertrouwde u & #8217; op nut en vertrouwen om uw token te waarderen. Maar als u wilt, kunt u de waarde van het token laten ondersteunen door Pirl (of andere tokens) door een fonds te maken dat ze automatisch verkoopt en koopt tegen marktwaarde.

Laat eerst & #8217; s de prijs instellen voor kopen en verkopen:

uint256 openbaar verkoopprijs;
   uint256 openbare aankoopprijs;

   function setPrices (uint256 newSellPrice, uint256 newBuyPrice) alleen Eigen {
       sellPrice = newSellPrice;
       buyPrice = newBuyPrice;
   }

Dit is acceptabel voor een prijs die niet vaak verandert, omdat elke nieuwe prijswijziging vereist dat u een transactie uitvoert en een beetje Pirl besteedt. Als u een constante variabele prijs wilt, raden we u aan om standaard datafeeds te onderzoeken

De volgende stap is het maken van de koop- en verkoopfuncties:

functie buy () betaalbaar rendement (uint-bedrag) {
       aantal = msg.waarde / koopprijs; // berekent het bedrag
       vereisen (balanceOf [this]> = bedrag); // controleert of het genoeg te verkopen heeft
       balanceOf [msg.sender] + = bedrag; // voegt het bedrag toe aan het saldo van koper & #8217;
       balanceOf [this] - = bedrag; // trekt bedrag af van het saldo van verkoper & #8217;
       Overboeking (dit, msg.sender, bedrag); // een gebeurtenis uitvoeren die de verandering weerspiegelt
       retourbedrag; // beëindigt functie en keert terug
   }

   functie sell (uint bedrag) retourneert (uint omzet) {
       vereisen (balanceOf [msg.sender]> = bedrag); // controleert of de afzender genoeg te verkopen heeft
       balanceOf [this] + = bedrag; // voegt het bedrag toe aan het saldo van eigenaar & #8217;
       balanceOf [msg.sender] - = bedrag; // trekt het bedrag af van het saldo van verkoper & #8217;
       omzet = bedrag * verkoopprijs;
       msg.sender.transfer (omzet); // stuurt Pirl naar de verkoper: it & #8217; s is belangrijk om dit als laatste te doen om recursie-aanvallen te voorkomen
       Overboeken (msg.sender, dit, bedrag); // voert een gebeurtenis uit die reflecteert op de wijziging
       opbrengst teruggeven; // beëindigt functie en keert terug
   }

Merk op dat hierdoor geen nieuwe tokens worden gecreëerd, maar het saldo van het contract wordt gewijzigd. Het contract kan zowel zijn eigen tokens als Pirl en de eigenaar van het contract bevatten, terwijl het prijzen kan instellen of in sommige gevallen nieuwe tokens kan creëren (indien van toepassing), het kan de bank & #8217; s tokens of Pirl niet raken. De enige manier waarop dit contract fondsen kan verplaatsen, is door ze te verkopen en te kopen.

Opmerking Kopen en verkopen & #8220; prijzen & #8221; zijn niet ingesteld in Pirl, maar in wei de minimale valuta van het systeem (gelijk aan de cent in de Euro en Dollar, of de Satoshi in Bitcoin). One Pirl is 1000000000000000000 wei. Dus als u prijzen instelt voor uw token in Pirl, voegt u aan het einde 18 nullen toe.

Stuur bij het maken van het contract voldoende Pirl naar het zodat het alle tokens op de markt kan terugkopen, anders zal uw contract insolvent zijn en zullen uw gebruikers hun tokens niet kunnen verkopen.

De voorgaande voorbeelden beschrijven natuurlijk een contract met één centrale koper en verkoper, een veel interessanter contract zou een markt mogelijk maken waar iedereen verschillende prijzen kan bieden, of misschien zou het de prijzen rechtstreeks van een externe bron laden.

Autorefill

Telkens wanneer u een transactie uitvoert op Pirl, moet u een vergoeding betalen aan de mijnwerker van het blok die het resultaat van uw slimme contract zal berekenen. Hoewel dit in de toekomst kan veranderen, kunnen kosten momenteel alleen in Pirl worden betaald en daarom hebben alle gebruikers van je tokens dit nodig. Tokens in accounts met een saldo dat kleiner is dan de vergoeding, blijven steken totdat de eigenaar de benodigde vergoeding kan betalen. Maar in sommige gevallen wilt u misschien niet dat uw gebruikers nadenken over Pirl, blockchain of hoe ze Pirl kunnen verkrijgen, dus een mogelijke aanpak zou zijn dat uw munt automatisch het gebruikerssaldo opnieuw vult zodra het detecteert dat het saldo gevaarlijk laag is.

Om dat te doen, moet u eerst een variabele maken die de drempelwaarde bevat en een functie om deze te wijzigen.

uint minBalanceForAccounts;

   function setMinBalance (uint minimumBalanceInFinney) alleen Eigen {
        minBalanceForAccounts = minimumBalanceInFinney * 1 finney;
   }

 

Voeg vervolgens deze regel toe aan de overdrachtsfunctie zodat de afzender wordt terugbetaald:

  / * Verzend munten * /
   functieoverdracht (adres _to, uint256 _value) {
       …
       if (msg.sender.balance <minBalanceForAccounts)
           sell ((minBalanceForAccounts & #8211; msg.sender.balance) / sellPrice);
   }

 

U kunt het in plaats daarvan ook wijzigen, zodat het tarief door de afzender aan de ontvanger wordt betaald:

  / * Verzend munten * /
   functieoverdracht (adres _to, uint256 _value) {
       …
       if (_to.balance            _to.send (sell ((minBalanceForAccounts & #8211; _to.balance) / sellPrice));
   }

Dit zorgt ervoor dat geen enkele rekening die het token ontvangt minder dan de benodigde Pirl heeft om de kosten te betalen.

Bewijs van werk

Er zijn enkele manieren om je muntenvoorraad aan een wiskundige formule te koppelen. Een van de eenvoudigste manieren is om er een & #8220; merged mining & #8221; van te maken. met Pirl, wat betekent dat iedereen die een blok op Pirl vindt, ook een beloning van je munt krijgt, aangezien iedereen de beloningsfunctie op dat blok aanroept. Je kunt het doen met behulp van het speciale sleutelwoord coinbase dat verwijst naar de mijnwerker die het blok vindt.

functie giveBlockReward () {
       balanceOf [block.coinbase] + = 1;
   }

Het is ook mogelijk om een wiskundige formule toe te voegen, zodat iedereen die wiskunde kan doen, een beloning kan winnen. In dit volgende voorbeeld moet je berekenen dat de kubieke wortel van de huidige uitdaging een punt krijgt en het recht om de volgende uitdaging in te stellen:

uint currentChallenge = 1; // Kun je de kubieke wortel van dit getal achterhalen?

   functie rewardMathGeniuses (uint answerToCurrentReward, uint nextChallenge) {
       vereisen (answerToCurrentReward ** 3 == currentChallenge); // Ga niet verder als het antwoord fout is
       balanceOf [msg.sender] + = 1; // Beloon de speler
       currentChallenge = nextChallenge; // Stel de volgende uitdaging in
   }

Hoewel het berekenen van kubieke wortels voor iemand moeilijk kan zijn om op zijn hoofd te doen, zijn ze natuurlijk heel eenvoudig met een rekenmachine, dus dit spel kan gemakkelijk worden gebroken door een computer. Omdat de laatste winnaar de volgende uitdaging kan kiezen, kunnen ze ook iets kiezen dat ze kennen en daarom zou het geen heel eerlijk spel zijn voor andere spelers. Er zijn taken die gemakkelijk zijn voor mensen, maar moeilijk voor computers, maar ze zijn meestal heel moeilijk te coderen in eenvoudige scripts zoals deze. In plaats daarvan zou een eerlijker systeem een systeem moeten zijn dat heel moeilijk is voor een computer, maar dat is niet erg moeilijk voor een computer om te verifiëren. Een goede kandidaat zou zijn om een hash-uitdaging te creëren waarbij de uitdager hashes van meerdere getallen moet genereren totdat hij er een vindt die lager is dan een bepaalde moeilijkheidsgraad.

Dit proces werd voor het eerst voorgesteld door Adam Back in 1997 als Hashcash en vervolgens werd geïmplementeerd in Bitcoin door Satoshi Nakamoto als bewijs van het werk in 2008.

Als je Hashing leuk vindt als een vorm van willekeurige uitgifte van munten, kun je nog steeds je eigen op Pirl gebaseerde valuta maken met een bewijs van werkuitgifte:

bytes32 publieke currentChallenge; // De munt begint met een uitdaging
   uint openbare tijdOfLastProof; // Variabel om bij te houden wanneer beloningen werden gegeven
   uint publieke moeilijkheid = 10 ** 32; // Moeilijkheidsgraad begint redelijk laag

   function proofOfWork (uint nonce) {
       bytes8 n = bytes8 (sha3 (nonce, currentChallenge)); // Genereer een willekeurige hash op basis van invoer
       vereisen (n> = bytes8 (moeilijkheidsgraad)); // Controleer of het & #8217; s onder de moeilijkheidsgraad is

       uint timeSinceLastProof = (nu & #8211; timeOfLastProof); // Bereken de tijd sinds de laatste beloning werd gegeven
       vereisen (timeSinceLastProof> = 5 seconden); // Beloningen kunnen niet te snel worden gegeven
       balanceOf [msg.sender] + = timeSinceLastProof / 60 seconden; // De beloning voor de winnaar groeit met de minuut

       moeilijkheid = moeilijkheid * 10 minuten / tijd SinceLastProof + 1; // Past de moeilijkheidsgraad aan

       timeOfLastProof = nu; // Reset de teller
       currentChallenge = sha3 (nonce, currentChallenge, block.blockhash (block.number & #8211; 1)); // Sla een hash op die zal worden gebruikt als het volgende bewijs
   }

Wijzig ook de Constructor-functie (die dezelfde naam heeft als het contract, die bij de eerste upload wordt genoemd) om deze regel toe te voegen, zodat de aanpassing van de moeilijkheidsgraad niet gek wordt:

timeOfLastProof = nu;

Zodra het contract online is, selecteert u de functie & #8220; Bewijs van werk & #8221 ;, voegt u uw favoriete nummer toe aan het nonce-veld en probeert u het uit te voeren. Als het bevestigingsvenster een rode waarschuwing geeft met de tekst & #8220; Gegevens kunnen & #8217; t worden uitgevoerd & #8221; ga terug en kies een ander nummer totdat u er een vindt waarmee de transactie kan worden voortgezet: dit proces is willekeurig. Als je er een vindt, krijg je 1 token voor elke minuut die is verstreken sinds de laatste beloning werd gegeven, en dan wordt de moeilijkheidsgraad van de uitdaging omhoog of omlaag aangepast om een gemiddelde van 10 minuten per beloning te bereiken.

Dit proces van proberen het nummer te vinden dat je een beloning zal geven, wordt mijnbouw genoemd: als de moeilijkheid oploopt, kan het heel moeilijk zijn om een geluksgetal te vinden, maar het zal altijd gemakkelijk zijn om te verifiëren dat je er een hebt gevonden.

Verbeterde munt

VOLLEDIGE COINCODE
Als u alle geavanceerde opties toevoegt, moet de uiteindelijke code er zo uitzien:

pragma-stevigheid ^ 0.4.16;

contract eigendom {
   adres openbare eigenaar;

   functie in eigendom () openbaar {
       eigenaar = msg.sender;
   }

   modifier onlyOwner {
       vereisen (msg.sender == eigenaar);
       _;
   }

   function transferOwnership (adres newOwner) alleenOwner public {
       eigenaar = nieuwEigenaar;
   }
}


pragma-stevigheid ^ 0.4.16;

contract eigendom {
   adres openbare eigenaar;

   functie in eigendom () openbaar {
       eigenaar = msg.sender;
   }

   modifier onlyOwner {
       vereisen (msg.sender == eigenaar);
       _;
   }

   function transferOwnership (adres newOwner) alleenOwner public {
       eigenaar = nieuwEigenaar;
   }
}

interface tokenRecipient {function removeApproval (adres _from, uint256 _waarde, adres _token, bytes _extraData) openbaar; }

contract TokenERC20 {
   // Publieke variabelen van het token
   string openbare naam;
   string openbaar symbool;
   uint8 publieke decimalen = 18;
   // 18 decimalen is de sterk aanbevolen standaard, wijzig deze niet
   uint256 public totalSupply;

   // Hiermee maakt u een array met alle saldi
   mapping (adres => uint256) public balanceOf;
   toewijzing (adres => toewijzing (adres => uint256)) openbare vergoeding;

   // Dit genereert een openbaar evenement op de blockchain dat clients op de hoogte brengt
   event Transfer (adres geïndexeerd van, adres geïndexeerd naar, uint256 waarde);

   // Hiermee worden klanten op de hoogte gesteld van het verbrande bedrag
   gebeurtenis Burn (adres geïndexeerd van, uint256 waarde);

   /**
    * Constrctor-functie
    *
    * Initialiseert contract met initiële leveringstokens voor de maker van het contract
    */
   functie TokenERC20 (
       uint256 initialSupply,
       string tokenName,
       string tokenSymbool
   ) openbaar {
       totalSupply = initialSupply * 10 ** uint256 (decimalen); // Werk het totale aanbod bij met de decimale hoeveelheid
       balanceOf [msg.sender] = totalSupply; // Geef de maker alle eerste tokens
       name = tokenName; // Stel de naam in voor weergavedoeleinden
       symbool = tokenSymbool; // Stel het symbool in voor weergavedoeleinden
   }

   /**
    * Interne overdracht, kan alleen worden opgeroepen door dit contract
    */
   functie _transfer (adres _van, adres _to, uint _waarde) intern {
       // Voorkom overdracht naar 0x0-adres. Gebruik in plaats hiervan burn ()
       vereisen (_to! = 0x0);
       // Controleer of de afzender genoeg heeft
       vereisen (balanceOf [_from]> = _value);
       // Controleer op overlopen
       vereisen (balanceOf [_to] + _value> balanceOf [_to]);
       // Bewaar dit voor een bewering in de toekomst
       uint previousBalances = balanceOf [_from] + balanceOf [_to];
       // Aftrekken van de afzender
       balanceOf [_from] - = _value;
       // Voeg hetzelfde toe aan de ontvanger
       balanceOf [_to] + = _value;
       Transfer (_van, _ tot, _waarde);
       // Asserts worden gebruikt om statische analyse te gebruiken om bugs in uw code te vinden. Ze mogen nooit falen
       assert (balanceOf [_from] + balanceOf [_to] == previousBalances);
   }

   /**
    * Breng tokens over
    *
    * Stuur `_value` tokens naar` _to` vanuit uw account
    *
    * @param _to Het adres van de ontvanger
    * @param _waarde van het te verzenden bedrag
    */
   functieoverdracht (adres _to, uint256 _value) public {
       _transfer (msg.sender, _to, _value);
   }

   /**
    * Breng tokens over van een ander adres
    *
    * Stuur `_value` tokens naar` _to` namens `_from`
    *
    * @param _from Het adres van de afzender
    * @param _to Het adres van de ontvanger
    * @param _waarde van het te verzenden bedrag
    */
   function transferFrom (adres _van, adres _tot, uint256 _waarde) openbare retouren (succes bool) {
       vereisen (_waarde <= vergoeding [_vanaf] [msg.sender]); // Controleer vergoeding
       vergoeding [_vanaf] [msg.sender] - = _waarde;
       _transfer (_van, _ tot, _waarde);
       waar terugkomen;
   }

   /**
    * Stel vergoeding in voor ander adres
    *
    * Staat toe dat `_spender` niet meer dan` _value` tokens voor u uitgeeft
    *
    * @param _spender Het adres dat is geautoriseerd om te besteden
    * @param _waarde het maximale bedrag dat ze kunnen uitgeven
    */
   functie goedkeuren (adres _spender, uint256 _waarde) openbaar
       retourneert (bool succes) {
       vergoeding [msg.sender] [_ spender] = _waarde;
       waar terugkomen;
   }

   /**
    * Stel vergoeding in voor ander adres en meld het
    *
    * Laat `_spender` niet meer dan` _value` tokens voor u uitgeven, en ping dan het contract erover
    *
    * @param _spender Het adres dat is geautoriseerd om te besteden
    * @param _waarde het maximale bedrag dat ze kunnen uitgeven
    * @param _extraData wat extra informatie om naar het goedgekeurde contract te sturen
    */
   functie approveAndCall (adres _spender, uint256 _value, bytes _extraData)
       openbaar
       retourneert (bool succes) {
       tokenRecipient spender = tokenRecipient (_spender);
       if (goedkeuren (_spender, _waarde)) {
           spender.receiveApproval (msg.sender, _value, this, _extraData);
           waar terugkomen;
       }
   }

   /**
    * Vernietig tokens
    *
    * Verwijder `_value` tokens onomkeerbaar uit het systeem
    *
    * @param _waarde van de hoeveelheid te branden geld
    */
   function burn (uint256 _value) public returns (bool succes) {
       vereisen (balanceOf [msg.sender]> = _waarde); // Controleer of de afzender genoeg heeft
       balanceOf [msg.sender] - = _waarde; // Aftrekken van de afzender
       totalSupply - = _waarde; // Updates totalSupply
       Branden (msg.sender, _waarde);
       waar terugkomen;
   }

   /**
    * Vernietig tokens van een ander account
    *
    * Verwijder `_value` tokens onomkeerbaar uit het systeem namens` _from`.
    *
    * @param _van het adres van de afzender
    * @param _waarde van de hoeveelheid te branden geld
    */
   functie burnFrom (adres _from, uint256 _waarde) public returns (bool succes) {
       vereisen (balanceOf [_from]> = _value); // Controleer of het beoogde saldo voldoende is
       vereisen (_waarde <= vergoeding [_vanaf] [msg.sender]); // Controleer vergoeding
       balanceOf [_from] - = _value; // Aftrekken van het beoogde saldo
       vergoeding [_vanaf] [msg.sender] - = _waarde; // Aftrekken van de afzender & #8217; s vergoeding
       totalSupply - = _waarde; // Update totalSupply
       Branden (_van, _waarde);
       waar terugkomen;
   }
}

/******************************************/
/ * GEAVANCEERDE TOKEN BEGINT HIER * /
/******************************************/

contract MyAdvancedToken is eigendom van, TokenERC20 {

   uint256 openbaar verkoopprijs;
   uint256 openbare aankoopprijs;

   mapping (adres => bool) public frozenAccount;

   / * Dit genereert een openbaar evenement op de blockchain dat klanten op de hoogte brengt * /
   gebeurtenis FrozenFunds (adresdoel, bool bevroren);

   / * Initialiseert contract met initiële leveringstokens voor de maker van het contract * /
   functie MyAdvancedToken (
       uint256 initialSupply,
       string tokenName,
       string tokenSymbool
   ) TokenERC20 (initialSupply, tokenName, tokenSymbol) public {}

   / * Interne overdracht, kan alleen door dit contract worden opgeroepen * /
   functie _transfer (adres _van, adres _to, uint _waarde) intern {
       vereisen (_to! = 0x0); // Voorkom overdracht naar 0x0-adres. Gebruik in plaats hiervan burn ()
       vereisen (balanceOf [_from]> = _value); // Controleer of de afzender genoeg heeft
       vereisen (balanceOf [_to] + _value> balanceOf [_to]); // Controleer op overlopen
       vereisen (frozenAccount [_from]!); // Controleer of de afzender bevroren is
       vereisen (frozenAccount [_To]!); // Controleer of de ontvanger bevroren is
       balanceOf [_from] - = _value; // Aftrekken van de afzender
       balanceOf [_to] + = _value; // Voeg hetzelfde toe aan de ontvanger
       Transfer (_van, _ tot, _waarde);
   }

   /// @notice Maak `mintedAmount` tokens en stuur het naar` target`
   /// @param target Adres om de tokens te ontvangen
   /// @param minted Bedrag het aantal tokens dat het zal ontvangen
   function mintToken (address target, uint256 mintedAmount) onlyOwner public {
       balanceOf [target] + = mintedAmount;
       totalSupply + = mintedAmount;
       Overboeking (0, dit, geslagen bedrag);
       Transfer (deze, target, geslagen bedrag);
   }

   /// @notice `bevriezen? Voorkomen | Toestaan dat 'doel' tokens verzendt en ontvangt
   /// @param target Adres dat moet worden bevroren
   /// @param bevriezen om het te bevriezen of niet
   function freezeAccount (adresdoel, bool freeze) alleen Eigen publiek {
       frozenAccount [target] = bevriezen;
       FrozenFunds (doel, bevriezen);
   }

   /// @notice Gebruikers toestaan tokens te kopen voor `newBuyPrice` Pirl en tokens te verkopen voor` newSellPrice` Pirl
   /// @param newSellPrice Prijs die de gebruikers aan het contract kunnen verkopen
   /// @param newBuyPrice Price gebruikers kunnen kopen van het contract
   function setPrices (uint256 newSellPrice, uint256 newBuyPrice) alleen Eigen publiek {
       sellPrice = newSellPrice;
       buyPrice = newBuyPrice;
   }

   /// @notice Koop tokens van het contract door Pirl te sturen
   functie buy () betaalbaar publiek {
       uint amount = msg.value / buyPrice; // berekent het bedrag
       _overdracht (dit, msg.sender, bedrag); // voert de overschrijvingen uit
   }

   /// @notice Verkoop `aantal` tokens om te contracteren
   /// @param aantal te verkopen tokens
   functie verkopen (bedrag uint256) openbaar {
       vereisen (this.balance> = bedrag * verkoopprijs); // controleert of het contract voldoende Pirl heeft om te kopen
       _transfer (msg.sender, this, amount); // voert de overschrijvingen uit
       msg.sender.transfer (bedrag * verkoopprijs); // stuurt Pirl naar de verkoper. Het is belangrijk om dit als laatste te doen om recursieaanvallen te voorkomen
   }
}

implementeren

Scroll naar beneden en u ziet & #8217; zie een geschatte kosten voor implementatie. Als u wilt, kunt u de schuifregelaar wijzigen om een lagere vergoeding in te stellen, maar als de prijs te lager is dan de gemiddelde marktkoers, kan het langer duren voordat uw transactie wordt opgehaald. Klik op Implementeren en typ uw wachtwoord. Na een paar seconden wordt u & #8217; u wordt doorgestuurd naar het dashboard en onder Laatste transacties ziet u & #8217; ziet u een regel met & #8220; contract maken & #8221 ;. Wacht een paar seconden totdat iemand je transactie heeft gekozen en dan zie je een trage blauwe rechthoek die aangeeft hoeveel andere knooppunten je transactie hebben gezien en bevestigd. Hoe meer bevestigingen u hebt, hoe meer zekerheid u hebt dat uw code is geïmplementeerd.

Klik op de link met de Admin-pagina en u wordt naar het eenvoudigste dashboard van de centrale bank ter wereld gebracht, waar u alles kunt doen wat u wilt met uw nieuwe valuta.

Aan de linkerkant onder Onder lezen van contract heb je alle opties en functies die je kunt gebruiken om informatie uit het contract gratis te lezen. Als uw token een eigenaar heeft, wordt het adres hier weergegeven. Kopieer dat adres en plak het in Saldo van en het toont het saldo van een account (het saldo wordt ook automatisch weergegeven op elke accountpagina met tokens).

Aan de rechterkant zie je onder Schrijven naar contract & #8217; alle functies die je kunt gebruiken om de blockchain op enigerlei wijze te wijzigen of wijzigen. Deze kosten gas. Als u een contract hebt gemaakt waarmee u nieuwe munten kunt slaan, moet u de functie & #8220; Mint Token & #8221; hebben. Selecteer het.

Selecteer het adres waar die nieuwe valuta's worden gemaakt en vervolgens het bedrag (als u decimalen hebt ingesteld op 2, voeg dan 2 nullen toe achter het bedrag om de juiste hoeveelheid te maken). Selecteer bij Uitvoeren van de account die als eigenaar is ingesteld, laat het Pirl-bedrag op nul staan en druk vervolgens op uitvoeren.

Na enkele bevestigingen wordt het saldo van de ontvanger bijgewerkt om het nieuwe bedrag weer te geven. Maar uw portemonnee voor ontvangers geeft deze mogelijk niet automatisch weer: om op de hoogte te zijn van aangepaste tokens, moet de portemonnee deze handmatig toevoegen aan een volglijst. Kopieer uw tokenadres (druk op de beheerpagina op kopieeradres) en verzend dit naar uw ontvanger. Als ze al & #8217; t al moeten gaan, moeten ze naar het tabblad Contracten gaan, op Watch Token drukken en daar het adres toevoegen. De weergegeven naam, symbolen en decimale bedragen kunnen door de eindgebruiker worden aangepast, vooral als ze andere tokens met een vergelijkbare (of dezelfde) naam hebben. Het hoofdpictogram kan niet worden gewijzigd en gebruikers moeten op hen letten bij het verzenden en ontvangen van tokens om ervoor te zorgen dat ze te maken hebben met de echte deal en niet met een copycat-token.

Uw munt gebruiken

Zodra u & #8217; uw tokens hebt geïmplementeerd, worden deze toegevoegd aan uw lijst met bewaakte tokens en wordt het totale saldo op uw account weergegeven. Om tokens te verzenden, ga je naar het tabblad Verzenden en selecteer je een account die tokens bevat. De tokens die het account heeft, worden net onder Pirl weergegeven. Selecteer ze en typ vervolgens het aantal tokens dat u wilt verzenden.

Als u iemand anders & #8217; s token wilt toevoegen, gaat u naar het tabblad Contracten en klikt u op Watch token. Als u bijvoorbeeld het Pirl Vortex-token aan uw volglijst wilt toevoegen, voegt u het adres 0x0489A975393A1cD0330740040141D702C35180cb toe

Wat nu?

Je hebt zojuist geleerd hoe je Pirl kunt gebruiken om een token uit te geven dat alles kan vertegenwoordigen wat je maar wilt. Maar wat kunt u doen met de tokens? U kunt bijvoorbeeld de tokens gebruiken om een aandeel in een bedrijf te vertegenwoordigen of u kunt een centraal comité gebruiken om te stemmen wanneer nieuwe munten worden uitgegeven om de inflatie te beheersen. Je kunt ze ook gebruiken om geld in te zamelen voor een doel, via een crowdsale. Wat ga je hierna bouwen?

Referentiemateriaal: ethereum.org


Abonneer op onze nieuwsbrief

Ontvang updates en leer van de beste

Meer te ontdekken

nl_NLNederlands
en_USEnglish fr_FRFrançais tr_TRTürkçe es_ESEspañol pt_PTPortuguês ru_RUРусский ko_KR한국어 zh_CN简体中文 hi_INहिन्दी nl_NLNederlands