Nasıl Yapılır: PIRL Ağında Bir Token Oluşturma

Bu gönderiyi paylaş

#39;lerde paylaş
#39;lerde paylaş
#39;lerde paylaş
#39;lerde paylaş

Bozuk Para

Dijital bir jeton oluşturacağız. Pirl ekosistemindeki jetonlar herhangi bir mantarla satılabilir malları temsil edebilir: madeni paralar, sadakat puanları, altın sertifikalar, IOU'lar, oyun içi öğeler, vb. Tüm tokenler bazı temel özellikleri standart bir şekilde uyguladığı için, bu da simgenizin anında olacağı anlamına gelir. Pirl cüzdanı ve aynı standartları kullanan herhangi bir müşteri veya sözleşme ile uyumludur.

MİNİMUM VIABLE TOKEN

Standart token sözleşmesi oldukça karmaşık olabilir. Ancak özünde çok temel bir belirteç bununla ilgilidir:

contract MyToken {/ * Bu, tüm bakiyeleri * / mapping (address => uint256) genel bakiye ile bir dizi oluşturur; / * Sözleşmenin yaratıcısına ilk tedarik jetonları ile sözleşmeyi başlatır * / function MyToken (uint256 initialSupply) {balanceOf [msg.sender] = initialSupply; // Yaratıcıya tüm başlangıç simgelerini verin} / * Paraları gönderin * / işlev aktarımı (adres _to, uint256 _value) {requir (balanceOf [msg.sender]> = _value); // Gönderenin yeterli gereksinimi olup olmadığını kontrol edin (balanceOf [_to] + _value> = balanceOf [_to]); // taşmaları kontrol et balanceOf [msg.sender] - = _value; // Gönderen bakiyesinden çıkarOf [_to] + = _value; // Aynısını alıcıya ekle}}

KOD

Ancak, daha eksiksiz bir kodu kopyalamak istiyorsanız, bunu kullanın:

pragma sağlamlığı ^ 0.4.16;

arabirim tokenRecipient {function receApproval (adres _from, uint256 _value, adres _token, bayt _extraData) genel; }

sözleşme TokenERC20 {
   // Simgenin genel değişkenleri
   dize genel adı;
   dize halka açık simgesi;
   uint8 genel ondalıklar = 18;
   // 18 ondalık basamak şiddetle tavsiye edilen varsayılan değerdir, değiştirmekten kaçının
   uint256 genel toplamTedarik;

   // Bu, tüm bakiyelere sahip bir dizi oluşturur
   mapping (address => uint256) genel bakiyeOf;
   eşleme (adres => eşleme (adres => uint256)) kamu yardımı;

   // Bu, blockchain'de müşterileri bilgilendirecek herkese açık bir etkinlik oluşturur
   olay Transferi (adres endekslendi, adres endekslendi, uint256 değeri);

   // Bu, müşterilere yakılan miktar hakkında bilgi verir
   event Burn (adres indekslendi, uint256 değeri);

   /**
    * Oluşturucu işlevi
    *
    * Sözleşmenin yaratıcısına ilk tedarik jetonları ile sözleşmeyi başlatır
    */
   işlev TokenERC20 (
       uint256 initialSupply,
       string tokenName,
       string tokenSymbol
   ) halka açık {
       totalSupply = initialSupply * 10 ** uint256 (ondalıklar); // Toplam arzı ondalık miktarla güncelleyin
       balanceOf [msg.sender] = totalSupply; // Yaratıcıya tüm başlangıç jetonlarını verin
       name = tokenName; // Görüntüleme amaçları için adı ayarla
       sembol = tokenSymbol; // Sembolü görüntüleme amacıyla ayarlayın
   }

   /**
    * Dahili transfer, sadece bu sözleşme ile çağrılabilir
    */
   işlev _transfer (adres _from, adres _to, uint _value) dahili {
       // 0x0 adresine aktarmayı engelleyin. Bunun yerine burn () kullanın
       gerektirir (_to! = 0x0);
       // Gönderenin yeterli olup olmadığını kontrol edin
       gerektirir (balanceOf [_from]> = _değer);
       // Taşmaları kontrol et
       gerektirir (balanceOf [_to] + _value> balanceOf [_to]);
       // Bunu gelecekte bir iddia için kaydedin
       uint previousBalances = balanceOf [_from] + balanceOf [_to];
       // Gönderenden çıkarma
       balanceOf [_from] - = _değer;
       // Aynısını alıcıya ekle
       balanceOf [_to] + = _değer;
       Aktarım (_from, _to, _value);
       // Ekler, kodunuzdaki hataları bulmak için statik analiz kullanmak için kullanılır. Asla başarısız olmamalılar
       assert (balanceOf [_from] + balanceOf [_to] == previousBalances);
   }

   /**
    * Transfer jetonları
    *
    * Hesabınızdan `_to` ya` _value` belirteçleri gönderin
    *
    * @param _to Alıcının adresi
    * @param _ gönderilecek tutarı değerleyin
    */
   işlev aktarımı (adres _to, uint256 _value) genel {
       _transfer (msg.sender, _to, _value);
   }

   /**
    * Diğer adresten aktarım jetonları
    *
    * _From adına "_val`" _value belirteçleri gönderin
    *
    * @param _from Gönderenin adresi
    * @param _to Alıcının adresi
    * @param _ gönderilecek tutarı değerleyin
    */
   function transferFrom (adres _from, adres _to, uint256 _value) genel getiriler (bool başarılı) {
       gerektirir (_değer <= ödenek [_from] [msg.sender]); // Ödeneği kontrol et
       ödenek [_from] [msg.sender] - = _değer;
       _transfer (_from, _to, _value);
       geri dönüş;
   }

   /**
    * Diğer adres için ödenek ayarlama
    *
    * `_Spender`'ın sizin adınıza '_value` jetonundan fazlasını harcamasına izin vermez
    *
    * @param _spender Harcamaya yetkili adres
    * @param _değerleyebilecekleri maksimum tutar
    */
   işlev onayı (adres _spender, uint256 _value) genel
       döner (bool başarılı) {
       ödenek [msg.sender] [_ spender] = _değer;
       geri dönüş;
   }

   /**
    * Diğer adres için ödenek belirleyin ve bilgilendirin
    *
    * `_Spender`'ın sizin adınıza` `değer '' belirteçlerinden fazlasını harcamamasına ve ardından bununla ilgili sözleşmeye ping göndermesine izin verir
    *
    * @param _spender Harcamaya yetkili adres
    * @param _değerleyebilecekleri maksimum tutar
    * @param _extraVeri onaylanan sözleşmeye gönderilecek bazı ek bilgiler
    */
   function confirmveAndCall (adres _spender, uint256 _value, bayt _extraData)
       halka açık
       döner (bool başarılı) {
       tokenRecipient spender = tokenRecipient (_spender);
       if (onayla (_spender, _value)) {
           spender.receiveApproval (msg.sender, _value, this, _extraData);
           geri dönüş;
       }
   }

   /**
    * Jetonları yok et
    *
    * `_Value` belirteçlerini geri döndürülemez biçimde sistemden kaldırın
    *
    * @param _değer yakılacak para miktarı
    */
   function burn (uint256 _value) genel getirileri (bool başarılı) {
       gerektirir (balanceOf [msg.sender]> = _değer); // Gönderenin yeterli olup olmadığını kontrol edin
       balanceOf [msg.sender] - = _değer; // Gönderenden çıkarma
       totalSupply - = _değer; // Toplam güncelleme
       Burn (msg.sender, _value);
       geri dönüş;
   }

   /**
    * Diğer hesaptan jetonları yok et
    *
    * __Değeri adına geri dönüşü olmayan sistemden `_value` belirteçlerini kaldırın.
    *
    * @param _ gönderenin adresinden
    * @param _değer yakılacak para miktarı
    */
   function burnFrom (adres _from, uint256 _value) genel getiriler (bool başarılı) {
       gerektirir (balanceOf [_from]> = _değer); // Hedeflenen bakiyenin yeterli olup olmadığını kontrol edin
       gerektirir (_değer <= ödenek [_from] [msg.sender]); // Ödeneği kontrol et
       balanceOf [_from] - = _değer; // Hedeflenen bakiyeden çıkart
       ödenek [_from] [msg.sender] - = _değer; // Gönderenin ödeneğinden çıkar
       totalSupply - = _değer; // Toplamı güncelle
       Burn (_from, _value);
       geri dönüş;
   }
}

Kodu Anlama

Öyleyse temelden başlayalım. Cüzdan uygulamasını açın, Sözleşmeler sekmesine gidin ve ardından Yeni Sözleşme Dağıtın. Sağlamlık Sözleşmesi Kaynak kodu metin alanına aşağıdaki kodu yazın:

sözleşme MyToken {
       / * Bu, tüm dengeleri olan bir dizi oluşturur * /
       mapping (address => uint256) genel bakiyeOf;
   }

Eşleme, adresleri bakiyelerle ilişkilendirdiğiniz ilişkilendirilebilir bir dizi anlamına gelir. Adresler temel onaltılık Pirl biçimindeyken, bakiyeler 0 ila 115 quattuorvigintillion arasında bir tamsayıdır. Bir kuatuorvigintilyonun ne kadar olduğunu bilmiyorsanız, jetonlarınızı kullanmayı planladığınız her şeyden daha fazla vigintilyon daha fazladır. Public anahtar sözcüğü, bu değişkenin blockchain'deki herkes tarafından erişilebilir olacağı anlamına gelir, yani tüm bakiyeler herkese açıktır (istemcilerin gösterebilmesi için olması gerektiği gibi).

Sözleşmenizi hemen yayınladıysanız, işe yarayacaktı ama çok yararlı olmayacaktı: herhangi bir adres için madalyonunuzun bakiyesini sorgulayabilecek bir sözleşme olurdu - ama asla tek bir para oluşturmadığınız için, her biri return 0. Böylece başlangıçta birkaç jeton oluşturacağız. Bu kodu, eşleme .. satırının hemen altındaki son kapanış ayraçından önce ekleyin.

işlev MyToken () {
       balanceOf [msg.sender] = 21000000;
   }

MyToken işlevinin MyToken sözleşmesiyle aynı ada sahip olduğuna dikkat edin. Bu çok önemlidir ve birini yeniden adlandırırsanız, diğerini de yeniden adlandırmanız gerekir: bu, sözleşme ilk kez ağa yüklendiğinde yalnızca bir kez ve bir kez çalışan özel bir başlatma işlevidir. Bu işlev, sözleşmeyi uygulayan kullanıcı olan msg.sender'ın dengesini 21 milyonluk bir denge ile ayarlayacaktır.

21 milyon seçim oldukça keyfiydi ve bunu kodda istediğiniz herhangi bir şeyle değiştirebilirsiniz, ancak daha iyi bir yol var: bunun yerine, işlev için bir parametre olarak sağlayın:

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

Sözleşmenin yanındaki sağ sütuna bir göz atın ve açılan bir liste göreceksiniz, yazılı bir sözleşme seçin. “MyToken” sözleşmesini seçtiğinizde, artık Yapıcı parametreleri adlı bir bölüm gösterdiğini göreceksiniz. Bunlar jetonunuz için değiştirilebilir parametrelerdir, böylece aynı kodu tekrar kullanabilir ve yalnızca bu değişkenleri gelecekte değiştirebilirsiniz.

Şu anda, jetonların bakiyelerini oluşturan işlevsel bir sözleşmeniz var, ancak onu taşıyacak bir işlev olmadığından, tek yaptığı aynı hesapta kalmak. Şimdi bunu uygulayacağız. Son parantezden önce aşağıdaki kodu yazın.

/ * Paraları gönder * /
   işlev aktarımı (adres _to, uint256 _value) {
       / * Yeni bakiyeler ekleme ve çıkarma * /
       balanceOf [msg.sender] - = _değer;
       balanceOf [_to] + = _değer;
   }

Bu çok basit bir işlevdir: parametre olarak bir alıcıya ve bir değere sahiptir ve birisi onu çağırdığında, _değerini bakiyesinden çıkarır ve _to bakiyesine ekler. Hemen bariz bir sorun var: Kişi sahip olduğundan daha fazlasını göndermek isterse ne olur? Bu belirli sözleşmede borç işlemek istemediğimizden, hızlı bir kontrol yapacağız ve gönderenin yeterli parası yoksa sözleşme yürütmesi duracaktır. Ayrıca, tekrar sıfır olacak kadar büyük bir sayıya sahip olmaktan kaçınmak için taşmaları kontrol etmek.

Bir sözleşmenin yürütülmesini yürütmenin ortasında durdurmak için ya iade edebilir ya da fırlatabilirsiniz. İlki daha az gaza mal olacak, ancak sözleşmede şu ana kadar yaptığınız herhangi bir değişiklik korunacağından daha fazla baş ağrısı olabilir. Öte yandan, 'atma' tüm sözleşme uygulamalarını iptal eder, işlemde yapılabilecek değişiklikleri geri alır ve gönderici gaz için gönderdiği tüm Pirl'leri kaybeder. Ancak Cüzdan bir sözleşmenin imzalanacağını algılayabildiğinden, her zaman bir uyarı gösterir, bu nedenle herhangi bir Pirl'in harcanmasını önler.

işlev aktarımı (adres _to, uint256 _value) {
       / * Gönderenin dengesi olup olmadığını ve taşma olup olmadığını kontrol edin * /
       gerektirir (balanceOf [msg.sender]> = _değer && balanceOf [_to] + _value> = balanceOf [_to]);

       / * Yeni bakiyeler ekleme ve çıkarma * /
       balanceOf [msg.sender] - = _değer;
       balanceOf [_to] + = _değer;
   }

 

Şimdi eksik olan tek şey sözleşme hakkında bazı temel bilgilere sahip olmak. Yakın gelecekte bu bir jeton kaydı ile ele alınabilir, ancak şimdilik bunları doğrudan sözleşmeye ekleyeceğiz:

dize genel adı;
dize halka açık simgesi;
uint8 genel ondalık sayılar;

Ve şimdi tüm bu değişkenlerin başlangıçta ayarlanmasına izin vermek için yapıcı işlevini güncelliyoruz:

/ * Sözleşmenin yaratıcısına ilk tedarik jetonları ile sözleşmeyi başlatır * /
   işlevi MyToken (uint256 initialSupply, dize tokenName, dize tokenSymbol, uint8 decimalUnits) {
       balanceOf [msg.sender] = initialSupply; // Yaratıcıya tüm başlangıç jetonlarını verin
       name = tokenName; // Görüntüleme amaçları için adı ayarla
       sembol = tokenSymbol; // Sembolü görüntüleme amacıyla ayarlayın
       ondalıklar = ondalık birim; // Görüntüleme amaçlı ondalık miktar
   }

Son olarak, artık Etkinlikler adı verilen somPirling'e ihtiyacımız var. Bunlar, Pirl Cüzdan gibi müşterilerin sözleşmede gerçekleşen etkinlikleri takip etmelerine yardımcı olmak için aradığınız özel, boş işlevlerdir. Olaylar büyük harfle başlamalıdır. Etkinliği bildirmek için sözleşmenin başına bu satırı ekleyin:

olay Transferi (adres endekslendi, adres endekslendi, uint256 değeri);
 

Ve sonra sadece bu iki satırı “transfer” fonksiyonuna eklemeniz gerekir:

      / * Bu aktarımın gerçekleştiğini dinleyen herkese bildir * /
       Aktarım (msg.sender, _to, _value);

 

Ve şimdi jetonun hazır!

Yorumlar fark ettiniz mi?

@Notice ve @param yorumları nelerdir, sorabilirsiniz? Yani en Natspec cüzdanların kullanıcıya sözleşmenin ne yapmakla ilgili doğal bir dil açıklaması göstermesini sağlayan doğal bir dil spesifikasyonu için ortaya çıkan bir standart. Şu anda birçok cüzdan tarafından desteklenmese de, bu gelecekte değişecek, bu yüzden hazırlanmak güzel.

Nasıl Dağıtım Yapılır

Henüz orada değilseniz, Pirl Cüzdanını açın, sözleşmeler sekmesine gidin ve ardından “yeni sözleşme dağıt” ı tıklayın.

Şimdi jeton kaynağını yukarıdan alın ve “Sağlamlık kaynağı alanına” yapıştırın. Kod hatasız bir şekilde derleniyorsa, sağ tarafta bir "sözleşme seçin" açılır listesi görmelisiniz. Alın ve “MyToken” sözleşmesini seçin. Sağ sütunda, kendi simgenizi kişiselleştirmek için ihtiyacınız olan tüm parametreleri göreceksiniz. Onları istediğiniz gibi değiştirebilirsiniz.

Sayfanın sonuna gidin ve söz konusu sözleşmenin hesaplama maliyetinin bir tahminini görürsünüz ve bunun için ne kadar Pirl ödemek istediğinize ilişkin bir ücret seçebilirsiniz. Harcamadığınız fazla Pirl size iade edilir, böylece isterseniz varsayılan ayarları bırakabilirsiniz. "Dağıt" a basın, hesap şifrenizi yazın ve işleminizin tamamlanması için birkaç saniye bekleyin.

İşleminizin onay beklediğini görebileceğiniz ön sayfaya yönlendirileceksiniz. Hesabı tıklayın ve bir dakikadan fazla bir süre sonra hesabınızın az önce oluşturduğunuz paylaşımlardan 100%'e sahip olduğunu göstereceğini görmelisiniz. Birkaç arkadaşınıza göndermek için: "gönder" i seçin ve ardından göndermek istediğiniz para birimini seçin (Pirl veya yeni oluşturduğunuz paylaşım), arkadaşınızın adresini "kime" alanına yapıştırın ve "gönder" e basın.

Bir arkadaşınıza gönderirseniz, cüzdanlarında henüz bir şey görmezler. Bunun nedeni, cüzdanın yalnızca bildiği jetonları izlemesi ve bunları manuel olarak eklemeniz gerektiğidir. Şimdi "Sözleşmeler" sekmesine gidin; yeni oluşturulan sözleşmenizin bağlantısını görmelisiniz. Sayfasına gitmek için üzerine tıklayın. Bu çok basit bir sözleşme sayfası olduğundan, burada yapılacak çok şey yoktur, sadece "adresi kopyala" yı tıklayın ve sözleşme adresini bir metin düzenleyicisine yapıştırın, kısa bir süre sonra buna ihtiyacınız olacak.

İzlemek için bir jeton eklemek için sözleşmeler sayfasına gidin ve “İzle Simgesi” ni tıklayın. Bir açılır pencere görünür ve yalnızca sözleşme adresini yapıştırmanız gerekir. Belirteç adı, sembol ve ondalık sayı otomatik olarak doldurulmalıdır, ancak değilse istediğiniz herhangi bir şeyi koyabilirsiniz (sadece cüzdanınızda nasıl görüneceğini etkiler). Bunu yaptıktan sonra, otomatik olarak bu tokenle ilgili herhangi bir bakiyeniz gösterilir ve bunu başkalarına gönderebilirsiniz.

Ve şimdi kendi kripto jetonun var! Jetonlar, yerel topluluklarda değer değişimi, çalışma saatlerini takip etme yolları veya diğer sadakat programları olarak faydalı olabilir. Ancak, bir para biriminin yararlı olmasını sağlayarak gerçek bir değere sahip olmasını sağlayabilir miyiz?

Jetonunuzu Geliştirin

Tüm kripto jetonunuzu bir kod satırına dokunmadan dağıtabilirsiniz, ancak gerçek sihir onu özelleştirmeye başladığınızda gerçekleşir. Aşağıdaki bölümler, ihtiyaçlarınıza daha uygun hale getirmek için jetonunuza ekleyebileceğiniz işlevlerle ilgili öneriler olacaktır.

Daha Temel Fonksiyonlar

Temel token sözleşmenizde onaylama, sendFrom ve diğerleri gibi bazı işlevlerin olduğunu fark edeceksiniz. Bu işlevler, tokeninizin diğer sözleşmelerle etkileşime girmesi için hazırdır: İsterseniz, diyelim ki, merkezi olmayan bir borsaya jeton satmak, bunları bir adrese göndermek yeterli olmaz çünkü değişim yeni jetonların farkında olmayacak veya çünkü sözleşmeler yalnızca işlev çağrıları için Etkinliklere abone olamaz. Bu nedenle, sözleşmeler için önce hesabınızdan taşıyabilecekleri bir miktar jetonu onaylamanız ve ardından onaylamak ve iki işlemi tek bir seferde onaylamak ve onaylamak için onlara ping atmak zorundasınız.

Bu işlevlerin birçoğu, belirteçlerin aktarımını yeniden uygulamak zorunda kaldığından, bunları yalnızca sözleşmenin kendisi tarafından çağrılabilen dahili bir işleve değiştirmek mantıklıdır:

/ * Dahili transfer, sadece bu sözleşme ile çağrılabilir * /
   işlev _transfer (adres _from, adres _to, uint _value) dahili {
       gerektirir (_to! = 0x0); // 0x0 adresine aktarmayı engelleyin. Bunun yerine burn () kullanın
       gerektirir (balanceOf [_from]> = _değer); // Gönderenin yeterli olup olmadığını kontrol edin
       gerektirir (balanceOf [_to] + _value> balanceOf [_to]); // Taşmaları kontrol et
       gerektirir (frozenAccount [_from]!); // Gönderenin donup donmadığını kontrol edin
       (! FrozenAccount [_to]) gerektirir; // Alıcının donmuş olup olmadığını kontrol edin
       balanceOf [_from] - = _değer; // Gönderenden çıkarma
       balanceOf [_to] + = _değer; // Aynısını alıcıya ekle
       Aktarım (_from, _to, _value);
   }

Artık madeni para transferine neden olan tüm işlevleriniz kendi kontrollerini yapabilir ve daha sonra doğru parametrelerle transferi transfer edebilir. Bu işlevin, herhangi birinin herhangi bir hesaptan diğerine para taşıyacağına dikkat edin, kimsenin bunu yapmasına izin vermeden: bu nedenle, yalnızca sözleşme tarafından çağrılan dahili bir işlevdir: çağıran herhangi bir işlev eklerseniz, Arayanın bunları taşıma izni olmalıdır.

Merkezi Yönetici

Tüm dapps varsayılan olarak tamamen merkezi olmayan, ancak bu, isterseniz bir tür merkezi yöneticiye sahip olamayacakları anlamına gelmez. Belki daha fazla bozuk para nane yeteneğini istiyorsun, belki bazı insanların para birimini kullanmasını yasaklamak istiyorsun. Bu özelliklerden herhangi birini ekleyebilirsiniz, ancak yakalama, bunları yalnızca başlangıçta ekleyebilmenizdir, böylece tüm token sahipleri, kendilerine sahip olmaya karar vermeden önce oyunun kurallarını her zaman tam olarak bilecektir.

Bunun gerçekleşmesi için, merkezi bir para birimi denetleyicisine ihtiyacınız vardır. Bu basit bir hesap olabilir, ancak bir sözleşme de olabilir ve bu nedenle daha fazla jeton oluşturma kararı sözleşmeye bağlı olacaktır: eğer oy kullanmak mümkün olabilecek demokratik bir kuruluşsa veya belki de belirteç sahibinin gücü.

Bunu yapmak için çok kullanışlı bir sözleşme özelliği öğreneceğiz: kalıtım. Kalıtım, bir sözleşmenin tümünü yeniden tanımlamak zorunda kalmadan üst sözleşmenin mülklerini elde etmesine izin verir. Bu, kodu daha temiz ve yeniden kullanılmasını kolaylaştırır. Bu kodu MyToken ile sözleşme yapmadan önce kodunuzun ilk satırına ekleyin {.

sözleşmenin sahibi {
       kamu sahibine hitap etmek;

       sahip olunan işlev () {
           sahip = msg.sender;
       }

       only değiştiriciOwner {
           gerektirir (msg.sender == sahip);
           _;
       }

       function transferOwnership (yalnızca newOwner adresi )Owner {
           owner = newOwner;
       }
   }

Bu, “sahip olunabilen” bir sözleşme hakkında bazı genel işlevleri tanımlamak dışında hiçbir şey yapmayan çok temel bir sözleşme yaratır. Şimdi bir sonraki adım sadece metninizin sözleşmenize ait olduğunu eklemektir:

 sözleşme MyToken'e aittir {
       / * sözleşmenin geri kalanı her zamanki gibi * /

Bu, MyToken içindeki tüm işlevlerin artık değişken sahibine ve yalnızca değiştiriciye erişebileceği anlamına gelir. Sözleşme aynı zamanda mülkiyeti devretme işlevi de görür. Sözleşmenin sahibini başlangıçta ayarlamak ilginç olabileceğinden, bunu yapıcı işlevine de ekleyebilirsiniz:

MyToken işlevi (
       uint256 initialSupply,
       string tokenName,
       uint8 ondalık birim,
       string tokenSymbol,
       merkezi adres
       ) {
       eğer (centralMinter! = 0) sahip = centralMinter;
   }

Merkez Nane

Dolaşımdaki jeton miktarının değişmesini istediğinizi varsayalım. Jetonlarınız aslında bir off-blockchain varlığını (altın sertifikaları veya hükümet para birimleri gibi) temsil ettiğinde ve sanal envanterin gerçek olanı yansıtmasını istediğinizde durum budur. Bu durum, para sahiplerinin token fiyatının bir miktar kontrolünü beklemesi ve tokenleri dolaşımdan çıkarmak veya kaldırmak istediği durumlarda da olabilir.

İlk olarak, totalSupply öğesini depolamak ve yapıcı işlevimize atamak için bir değişken eklememiz gerekir.

sözleşme MyToken {
       uint256 genel toplamTedarik;

       fonksiyon MyToken (…) {
           totalSupply = initialSupply;
           …
       }
       …
   }

Şimdi nihayet sahibin yeni jeton oluşturmasını sağlayacak yeni bir işlev ekleyelim:

işlev mintToken (adres hedefi, uint256 mintedAmount) onlyOwner {
       balanceOf [hedef] + = mintedAmount;
       totalSupply + = mintedAmount;
       Transfer (0, sahip, mintedAmount);
       Aktarım (sahip, hedef, darbeyli);
   }

İşlev adının sonundaki onlyOwner değiştiricisine dikkat edin. Bu, kodu daha önce tanımladığımız onlyOwner'dan devralmak için bu işlevin derleme sırasında yeniden yazılacağı anlamına gelir. Bu işlevin kodu, değiştirici işlevinde bir alt çizginin bulunduğu yere eklenir; bu, bu özel işlevin yalnızca sahip olarak ayarlanmış hesap tarafından çağrılabileceği anlamına gelir. Bunu bir sahip değiştiricisiyle yapılan bir sözleşmeye ekleyin ve daha fazla para oluşturabilirsiniz.

Varlıkların Dondurulması

Kullanım durumunuza bağlı olarak, belirteçlerinizi kimlerin kullanabileceği ve kullanamayacağı konusunda bazı düzenleyici engellere sahip olmanız gerekebilir. Bunun olması için, sözleşme sahibinin varlıkları dondurmasına veya çözmesini sağlayan bir parametre ekleyebilirsiniz.

Bu değişkeni ekleyin ve sözleşmenin herhangi bir yerine işlev yapın. Bunları herhangi bir yere koyabilirsiniz, ancak iyi uygulama için eşlemeleri diğer eşlemelerle ve diğer etkinliklerle olayları yerleştirmenizi öneririz.

eşleme (adres => bool) genel dondurulmuş hesap;
   olay FrozenFunds (adres hedefi, bool dondurulmuş);

   function freezeAccount (adres hedefi, bool dondurması) YalnızcaOwner {
       frozenAccount [hedef] = donma;
       FrozenFunds (hedef, dondur);
   }

Bu kodla, tüm hesaplar varsayılan olarak donmaz, ancak sahibi Hesabı Dondur'u arayarak herhangi birini donma durumuna ayarlayabilir. Ne yazık ki, dondurmanın pratik bir etkisi yoktur, çünkü transfer fonksiyonuna hiçbir şey eklemedik. Bunu şimdi değiştiriyoruz:

işlev aktarımı (adres _to, uint256 _value) {
       gerektirir (frozenAccount [msg.sender]!);

Artık dondurulmuş herhangi bir hesabın fonları hala sağlam kalacak, ancak bunları taşıyamayacak. Siz dondurana kadar tüm hesaplar varsayılan olarak donmaz, ancak bu davranışı her hesabı el ile onaylamanız gereken bir beyaz listeye kolayca geri döndürebilirsiniz. FrozenAccount öğesini onaylıAccount olarak yeniden adlandırın ve son satırı şu şekilde değiştirin:

gerektirir (approvedAccount [msg.sender]);

Otomatik Satış ve Satın Alma

Şimdiye kadar, jetonunuza değer vermek için fayda ve güvene güvendiniz. Ancak isterseniz jetonun değerini, Pirl (veya diğer jetonlar) tarafından, piyasa değerinde otomatik olarak satan ve satın alan bir fon oluşturarak destekleyebilirsiniz.

İlk olarak, alış ve satış fiyatını belirleyelim:

uint256 halka açık fiyat
   uint256 kamu alım fiyatı

   işlev kümesiFiyatlar (uint256 newSellPrice, uint256 newBuyPrice) onlyOwner {
       sellPrice = newSellPrice;
       buyPrice = newBuyPrice;
   }

Her yeni fiyat değişikliği bir işlem gerçekleştirmenizi ve biraz Pirl harcamanızı gerektireceğinden, bu çok sık değişmeyen bir fiyat için kabul edilebilir. Sabit bir değişken fiyat istiyorsanız, standart veri feed'lerini araştırmanızı öneririz

Bir sonraki adım alış ve satış fonksiyonlarını yapmaktır:

function buy () ödenecek iadeler (uint miktarı) {
       miktar = msg.değer / satın almaFiyat; // tutarı hesaplar
       gerektirir (balanceOf [bu]> = miktar); // satmak için yeterli olup olmadığını kontrol eder
       balanceOf [msg.sender] + = tutar; // tutarı alıcının bakiyesine ekler
       balanceOf [this] - = miktar; // satıcının bakiyesinden tutarı çıkarır
       Aktarım (bu, msg.sender, miktar); // değişikliği yansıtan bir olay yürütme
       iade miktarı; // işlevi sonlandırır ve döndürür
   }

   function sell (uint miktar) iadeleri (uint gelir) {
       gerektirir (balanceOf [msg.sender]> = tutar); // gönderenin satmak için yeterli olup olmadığını kontrol eder
       balanceOf [this] + = tutar; // tutarı sahibinin bakiyesine ekler
       balanceOf [msg.sender] - = miktar; // tutarı satıcının bakiyesinden çıkarır
       gelir = tutar * satış fiyatı;
       msg.sender.transfer (gelir); // satıcıya Pirl gönderir: özyineleme saldırılarını önlemek için bunu en son yapmak önemlidir
       Aktar (msg.sender, bu, miktar); // değişikliği yansıtan bir olay yürütür
       getiri geliri; // işlevi sonlandırır ve döndürür
   }

Bunun yeni jetonlar oluşturmayacağına, ancak sözleşmenin sahip olduğu dengeyi değiştireceğine dikkat edin. Sözleşme hem kendi belirteçlerini hem de Pirl'i ve sözleşmenin sahibini tutarken, fiyatları ayarlayabilir veya bazı durumlarda (varsa) yeni belirteçler oluşturabilir, bankanın belirteçlerine veya Pirl'e dokunamaz. Bu sözleşmenin fonları taşıyabilmesinin tek yolu onları satıp satın almaktır.

Not Alış ve satış “fiyatlar” Pirl'de değil, sistemin minimum para birimidir (Euro ve Dolar cinsinden kuruşa veya Bitcoin'deki Satoshi'ye eşdeğer). Bir Pirl 1000000000000000000 wei'dir. Dolayısıyla, Pirl'deki jetonunuz için fiyat belirlerken, sonunda 18 sıfır ekleyin.

Sözleşmeyi oluştururken, piyasadaki tüm jetonları geri alabilmesi için yeterli Pirl gönderin, aksi takdirde sözleşmeniz iflas eder ve kullanıcılarınız jetonlarını satamaz.

Önceki örnekler, elbette, tek bir merkezi alıcı ve satıcı ile yapılan bir sözleşmeyi açıklar, çok daha ilginç bir sözleşme, herkesin farklı fiyatlar teklif edebileceği bir pazara izin verir veya belki de fiyatları doğrudan harici bir kaynaktan yükler.

Autorefill

Her zaman, Pirl'de bir işlem yaparsanız, akıllı sözleşmenizin sonucunu hesaplayacak olan blok madencisine bir ücret ödemeniz gerekir. Bu durum gelecekte değişebilse de, şu an için ücretler sadece Pirl'de ödenebilir ve bu nedenle jetonlarınızın tüm kullanıcılarının buna ihtiyacı vardır. Bakiyeden daha düşük bakiyeye sahip hesaplarda jetonlar, sahibi gerekli ücreti ödeyene kadar sıkışır. Ancak bazı kullanım durumlarında, kullanıcılarınızın Pirl, blockchain veya Pirl'i nasıl elde edeceklerini düşünmelerini istemeyebilirsiniz, bu nedenle olası bir yaklaşım, dengenin tehlikeli derecede düşük olduğunu tespit ettiğinde paranızın otomatik olarak kullanıcı dengesini doldurmasını sağlar.

Bunu yapmak için, önce eşik miktarını tutacak bir değişken ve bunu değiştirmek için bir işlev oluşturmanız gerekir.

uint minBalanceForAccounts;

   function setMinBalance (uint minimumBalanceInFinney) yalnızcaOwner {
        minBalanceForAccounts = minimumBalanceInFinney * 1 finney;
   }

 

Ardından, gönderenin geri ödenmesi için aktarma işlevine bu satırı ekleyin:

  / * Paraları gönder * /
   işlev aktarımı (adres _to, uint256 _value) {
       …
       eğer (msg.sender.balance <minBalanceForAccounts)
           sell ((minBalanceForAccounts - msg.sender.balance) / sellPrice);
   }

 

Bunun yerine ücreti, gönderen tarafından alıcıya ödenecek şekilde değiştirebilirsiniz:

  / * Paraları gönder * /
   işlev aktarımı (adres _to, uint256 _value) {
       …
       (_To.balance eğer            _to.send (sell ((minBalanceForAccounts - _to.balance) / sellPrice));
   }

Bu, jetonu alan hiçbir hesabın ücretleri ödemek için gerekli Pirl değerinden daha azına sahip olmamasını sağlayacaktır.

İşin kanıtı

Madeni para arzınızı matematiksel bir formüle bağlamak için bazı yollar vardır. En basit yollardan biri, onu Pirl ile “birleştirilmiş madencilik” haline getirmektir, yani Pirl'de bir blok bulan herkes, o blokta ödül işlevini çağırdığı için paranızdan bir ödül alacaktır. Bunu, bloğu bulan madenciye atıfta bulunan özel coinbase anahtar sözcüğünü kullanarak yapabilirsiniz.

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

Matematiksel bir formül eklemek de mümkündür, böylece matematik yapabilen herkes ödül kazanabilir. Bu sonraki örnekte, mevcut zorluğun kübik kökünü hesaplamak zorundasınız ve bir sonraki zorluğu ayarlama hakkı ve hakkı var:

uint currentChallenge = 1; // Bu sayının kübik kökünü bulabilir misiniz?

   function rewardMathGeniuses (uint answerToCurrentReward, uint nextChallenge) {
       gerektirir (answerToCurrentReward ** 3 == currentChallenge); // Cevap yanlışsa devam etmeyin
       balanceOf [msg.sender] + = 1; // Oyuncuyu ödüllendir
       currentChallenge = nextChallenge; // Sonraki zorluğu belirle
   }

Tabii ki, kübik kökleri hesaplamak, birinin kafasına yapması zor olsa da, bir hesap makinesi ile çok kolaydır, bu nedenle bu oyun bir bilgisayar tarafından kolayca kırılabilir. Ayrıca son kazanan bir sonraki mücadeleyi seçebildiğinden, bildikleri bir şeyi seçebilirler ve bu nedenle diğer oyuncular için çok adil bir oyun olmazlar. İnsanlar için kolay ancak bilgisayarlar için zor olan görevler vardır, ancak bunlar gibi basit komut dosyalarında kodlamak genellikle çok zordur. Bunun yerine, daha adil bir sistem bir bilgisayarın yapması çok zor, ancak bir bilgisayarın doğrulaması çok zor olmayan bir sistem olmalıdır. Harika bir aday, meydan okuyucunun belirli bir zorluktan daha düşük bir tane bulana kadar birden fazla sayıdan karma üretmesi gereken bir karma meydan okuma oluşturmak olacaktır.

Bu süreç ilk olarak Adam Back tarafından 1997 yılında Hashcash ve daha sonra 2008 yılında iş kanıtı olarak Satoshi Nakamoto tarafından Bitcoin'de uygulandı.

Hashing'i rastgele bir para verme biçimi olarak seviyorsanız, yine de iş verme kanıtı olan kendi Pirl tabanlı para biriminizi oluşturabilirsiniz:

kamuoyunda bytes32 // Bozuk para bir meydan okuma ile başlar
   uint kamu saatiOfLastProof; // Ödüllerin ne zaman verildiğini takip etmek için değişken
   uint kamu güçlüğü = 10 ** 32; // Zorluk oldukça düşük başlar

   işlev proofOfWork (uint nonce) {
       bytes8 n = bytes8 (sha3 (nonce, currentChallenge)); // Girdiye dayalı rasgele bir karma oluşturma
       gerektirir (n> = bytes8 (zorluk)); // Zorluk altında olup olmadığını kontrol et

       uint timeSinceLastProof = (şimdi - timeOfLastProof); // Son ödülün verilmesinden bu yana geçen süreyi hesapla
       gerektirir (timeSinceLastProof> = 5 saniye); // Ödüller çok hızlı verilemez
       balanceOf [msg.sender] + = timeSinceLastProof / 60 saniye; // Kazanan ödül dakikaya kadar artıyor

       zorluk = zorluk * 10 dakika / süreSinceLastProof + 1; // Zorluğu ayarlar

       timeOfLastProof = şimdi; // Sayacı sıfırla
       currentChallenge = sha3 (nonce, currentChallenge, block.blockhash (block.number - 1)); // Bir sonraki kanıt olarak kullanılacak bir karmayı kaydet
   }

Ayrıca bu satırı eklemek için Oluşturucu işlevini (sözleşme ile aynı ada sahip, ilk yüklemede çağrılan işlev) değiştirin, böylece zorluk ayarlaması çıldırmaz:

timeOfLastProof = şimdi;

Sözleşme çevrimiçi olduktan sonra, “İş kanıtı” fonksiyonunu seçin, nonce numaranızı favori olmayan alana ekleyin ve uygulamayı deneyin. Onay penceresi “Veriler yürütülemez” diyen kırmızı bir uyarı verirse, geri dönün ve işlemin ilerlemesine izin veren bir numara bulana kadar başka bir numara seçin: bu işlem rastgele. Bir tane bulursanız, son ödül verildiğinden bu yana geçen her dakika için 1 jeton kazanacaksınız ve daha sonra meydan okuma zorluğu, ödül başına ortalama 10 dakika hedefleyecek şekilde yukarı veya aşağı ayarlanacaktır.

Size ödül verecek sayıyı bulmaya çalışma süreci madencilik olarak adlandırılır: zorluk yükselirse şanslı bir sayı bulmak çok zor olabilir, ancak bir tane bulduğunuzu doğrulamak her zaman kolay olacaktır.

Geliştirilmiş Para

TAM PARA KODU
Tüm gelişmiş seçenekleri eklerseniz, son kod şöyle görünmelidir:

pragma sağlamlığı ^ 0.4.16;

sözleşmenin sahibi {
   kamu sahibine hitap etmek;

   işlevi sahip olunan () genel {
       sahip = msg.sender;
   }

   only değiştiriciOwner {
       gerektirir (msg.sender == sahip);
       _;
   }

   function transferOwnership (adres newOwner) yalnızcaOwner public {
       owner = newOwner;
   }
}


pragma sağlamlığı ^ 0.4.16;

sözleşmenin sahibi {
   kamu sahibine hitap etmek;

   işlevi sahip olunan () genel {
       sahip = msg.sender;
   }

   only değiştiriciOwner {
       gerektirir (msg.sender == sahip);
       _;
   }

   function transferOwnership (adres newOwner) yalnızcaOwner public {
       owner = newOwner;
   }
}

arabirim tokenRecipient {function receApproval (adres _from, uint256 _value, adres _token, bayt _extraData) genel; }

sözleşme TokenERC20 {
   // Simgenin genel değişkenleri
   dize genel adı;
   dize halka açık simgesi;
   uint8 genel ondalıklar = 18;
   // 18 ondalık basamak şiddetle tavsiye edilen varsayılan değerdir, değiştirmekten kaçının
   uint256 genel toplamTedarik;

   // Bu, tüm bakiyelere sahip bir dizi oluşturur
   mapping (address => uint256) genel bakiyeOf;
   eşleme (adres => eşleme (adres => uint256)) kamu yardımı;

   // Bu, blockchain'de müşterileri bilgilendirecek herkese açık bir etkinlik oluşturur
   olay Transferi (adres endekslendi, adres endekslendi, uint256 değeri);

   // Bu, müşterilere yakılan miktar hakkında bilgi verir
   event Burn (adres indekslendi, uint256 değeri);

   /**
    * Constrctor işlevi
    *
    * Sözleşmenin yaratıcısına ilk tedarik jetonları ile sözleşmeyi başlatır
    */
   işlev TokenERC20 (
       uint256 initialSupply,
       string tokenName,
       string tokenSymbol
   ) halka açık {
       totalSupply = initialSupply * 10 ** uint256 (ondalıklar); // Toplam arzı ondalık miktarla güncelleyin
       balanceOf [msg.sender] = totalSupply; // Yaratıcıya tüm başlangıç jetonlarını verin
       name = tokenName; // Görüntüleme amaçları için adı ayarla
       sembol = tokenSymbol; // Sembolü görüntüleme amacıyla ayarlayın
   }

   /**
    * Dahili transfer, sadece bu sözleşme ile çağrılabilir
    */
   işlev _transfer (adres _from, adres _to, uint _value) dahili {
       // 0x0 adresine aktarmayı engelleyin. Bunun yerine burn () kullanın
       gerektirir (_to! = 0x0);
       // Gönderenin yeterli olup olmadığını kontrol edin
       gerektirir (balanceOf [_from]> = _değer);
       // Taşmaları kontrol et
       gerektirir (balanceOf [_to] + _value> balanceOf [_to]);
       // Bunu gelecekte bir iddia için kaydedin
       uint previousBalances = balanceOf [_from] + balanceOf [_to];
       // Gönderenden çıkarma
       balanceOf [_from] - = _değer;
       // Aynısını alıcıya ekle
       balanceOf [_to] + = _değer;
       Aktarım (_from, _to, _value);
       // Ekler, kodunuzdaki hataları bulmak için statik analiz kullanmak için kullanılır. Asla başarısız olmamalılar
       assert (balanceOf [_from] + balanceOf [_to] == previousBalances);
   }

   /**
    * Transfer jetonları
    *
    * Hesabınızdan `_to` ya` _value` belirteçleri gönderin
    *
    * @param _to Alıcının adresi
    * @param _ gönderilecek tutarı değerleyin
    */
   işlev aktarımı (adres _to, uint256 _value) genel {
       _transfer (msg.sender, _to, _value);
   }

   /**
    * Diğer adresten aktarım jetonları
    *
    * _From adına "_değer" e "_değer" belirteçleri gönderin
    *
    * @param _from Gönderenin adresi
    * @param _to Alıcının adresi
    * @param _ gönderilecek tutarı değerleyin
    */
   function transferFrom (adres _from, adres _to, uint256 _value) genel getiriler (bool başarılı) {
       gerektirir (_değer <= ödenek [_from] [msg.sender]); // Ödeneği kontrol et
       ödenek [_from] [msg.sender] - = _değer;
       _transfer (_from, _to, _value);
       geri dönüş;
   }

   /**
    * Diğer adres için ödenek ayarlama
    *
    * `_Spender`'ın sizin adınıza` _value` jetonundan fazlasını harcamasına izin vermez
    *
    * @param _spender Harcamaya yetkili adres
    * @param _değerleyebilecekleri maksimum tutar
    */
   işlev onayı (adres _spender, uint256 _value) genel
       döner (bool başarılı) {
       ödenek [msg.sender] [_ spender] = _değer;
       geri dönüş;
   }

   /**
    * Diğer adres için ödenek belirleyin ve bilgilendirin
    *
    * `_Spender`'ın sizin adınıza` `değer '' belirteçlerinden fazlasını harcamamasına ve ardından bununla ilgili sözleşmeye ping göndermesine izin verir
    *
    * @param _spender Harcamaya yetkili adres
    * @param _değerleyebilecekleri maksimum tutar
    * @param _extraVeri onaylanan sözleşmeye gönderilecek bazı ek bilgiler
    */
   function confirmveAndCall (adres _spender, uint256 _value, bayt _extraData)
       halka açık
       döner (bool başarılı) {
       tokenRecipient spender = tokenRecipient (_spender);
       if (onayla (_spender, _value)) {
           spender.receiveApproval (msg.sender, _value, this, _extraData);
           geri dönüş;
       }
   }

   /**
    * Jetonları yok et
    *
    * `_Value` belirteçlerini geri döndürülemez biçimde sistemden kaldırın
    *
    * @param _değer yakılacak para miktarı
    */
   function burn (uint256 _value) genel getirileri (bool başarılı) {
       gerektirir (balanceOf [msg.sender]> = _değer); // Gönderenin yeterli olup olmadığını kontrol edin
       balanceOf [msg.sender] - = _değer; // Gönderenden çıkarma
       totalSupply - = _değer; // Toplam güncelleme
       Burn (msg.sender, _value);
       geri dönüş;
   }

   /**
    * Diğer hesaptan jetonları yok et
    *
    * __Değeri adına geri dönüşü olmayan sistemden `_value` belirteçlerini kaldırın.
    *
    * @param _ gönderenin adresinden
    * @param _değer yakılacak para miktarı
    */
   function burnFrom (adres _from, uint256 _value) genel getiriler (bool başarılı) {
       gerektirir (balanceOf [_from]> = _değer); // Hedeflenen bakiyenin yeterli olup olmadığını kontrol edin
       gerektirir (_değer <= ödenek [_from] [msg.sender]); // Ödeneği kontrol et
       balanceOf [_from] - = _değer; // Hedeflenen bakiyeden çıkart
       ödenek [_from] [msg.sender] - = _değer; // Gönderenin ödeneğinden çıkar
       totalSupply - = _değer; // Toplamı güncelle
       Burn (_from, _value);
       geri dönüş;
   }
}

/******************************************/
/ * İLERİ TOKEN BURADA BAŞLIYOR * /
/******************************************/

sözleşme MyAdvancedToken'e ait, TokenERC20 {

   uint256 halka açık fiyat
   uint256 kamu alım fiyatı

   eşleme (adres => bool) genel dondurulmuş hesap;

   / * Bu, blockchain'de müşterileri bilgilendirecek herkese açık bir etkinlik oluşturur * /
   olay FrozenFunds (adres hedefi, bool dondurulmuş);

   / * Sözleşmenin yaratıcısına ilk tedarik jetonları ile sözleşmeyi başlatır * /
   MyAdvancedToken işlevi (
       uint256 initialSupply,
       string tokenName,
       string tokenSymbol
   ) TokenERC20 (initialSupply, tokenName, tokenSymbol) genel {}

   / * Dahili transfer, sadece bu sözleşme ile çağrılabilir * /
   işlev _transfer (adres _from, adres _to, uint _value) dahili {
       gerektirir (_to! = 0x0); // 0x0 adresine aktarmayı engelleyin. Bunun yerine burn () kullanın
       gerektirir (balanceOf [_from]> = _değer); // Gönderenin yeterli olup olmadığını kontrol edin
       gerektirir (balanceOf [_to] + _value> balanceOf [_to]); // Taşmaları kontrol et
       gerektirir (frozenAccount [_from]!); // Gönderenin donup donmadığını kontrol edin
       (! FrozenAccount [_to]) gerektirir; // Alıcının donmuş olup olmadığını kontrol edin
       balanceOf [_from] - = _değer; // Gönderenden çıkarma
       balanceOf [_to] + = _değer; // Aynısını alıcıya ekle
       Aktarım (_from, _to, _value);
   }

   /// @notice`mintedAmount` belirteçleri oluşturun ve `target` a gönderin
   /// @param target Jetonları almak için adres
   /// @param mintedAçacak token miktarını karşılayın
   işlev mintToken (adres hedefi, uint256 mintedAmount) yalnızcaOwner public {
       balanceOf [hedef] + = mintedAmount;
       totalSupply + = mintedAmount;
       Transfer (0, bu, mintedAmount);
       Aktarım (bu, hedef, mintedAmount);
   }

   /// @ notice `donuyor mu? Önleme | Hedefin jeton göndermesine ve almasına izin ver
   /// @param target Dondurulacak adres
   /// @param dondurmak için dondurun ya da dondurmayın
   function freezeAccount (adres hedefi, bool dondurma) Yalnızca ortak {
       frozenAccount [hedef] = donma;
       FrozenFunds (hedef, dondur);
   }

   /// @not Kullanıcıların `newBuyPrice` Pirl için jeton satın almasına ve` newSellPrice` Pirl için jeton satmasına izin ver
   /// @param newSellPrice Kullanıcıların sözleşmeye satabilecekleri fiyat
   /// @param newBuyFiyat Fiyat kullanıcıları sözleşmeden satın alabilirsiniz
   işlev kümesiFiyatlar (uint256 newSellPrice, uint256 newBuyPrice)
       sellPrice = newSellPrice;
       buyPrice = newBuyPrice;
   }

   /// @notice Pirl göndererek sözleşmeden jeton satın alın
   function buy () ödenecek genel {
       uint miktarı = msg.değeri / satın almakFiyat; // tutarı hesaplar
       _transfer (bu, msg.sender, tutar); // transferleri yapar
   }

   /// @not Sözleşmeye `miktar` belirteçleri sat
   /// @param satılacak token miktarı
   function sell (uint256 tutarı) herkese açık {
       gerektirir (this.balance> = tutar * sellFiyat); // sözleşmede satın almak için yeterli Pirl olup olmadığını kontrol eder
       _transfer (msg.sender, bu, miktar); // transferleri yapar
       msg.sender.transfer (tutar * satış fiyatı); // Pirl'i satıcıya gönderir. Özyineleme saldırılarından kaçınmak için bunu en son yapmak önemlidir
   }
}

dağıtma

Aşağı kaydırın ve tahmini bir dağıtım maliyeti görürsünüz. İsterseniz daha küçük bir ücret ayarlamak için kaydırıcıyı değiştirebilirsiniz, ancak fiyat ortalama piyasa oranının çok altındaysa, işleminizin toplanması daha uzun sürebilir. Dağıt'ı tıklayın ve şifrenizi yazın. Birkaç saniye sonra kontrol paneline yönlendirileceksiniz ve Son işlemler altında “sözleşme oluşturma” yazan bir satır göreceksiniz. Birinin işleminizi seçmesi için birkaç saniye bekleyin ve ardından işleminizi kaç düğüm gördüğünü ve onayladığını gösteren yavaş mavi bir dikdörtgen görürsünüz. Ne kadar çok onayınız varsa, kodunuzun dağıtıldığından emin olursunuz.

Yönetici sayfasını yazan bağlantıyı tıklayın ve yeni oluşturulan para biriminizle istediğiniz her şeyi yapabileceğiniz dünyanın en basit merkez bankası gösterge tablosuna yönlendirileceksiniz.

Sol tarafta Sözleşmeden oku altında, sözleşmeden ücretsiz olarak bilgi okumak için kullanabileceğiniz tüm seçenek ve işlevlere sahipsiniz. Simgenizin bir sahibi varsa, adresini burada görüntüler. Bu adresi kopyalayın ve Bakiye'ye yapıştırın ve size herhangi bir hesabın bakiyesini gösterecektir (bakiye ayrıca belirteç içeren herhangi bir hesap sayfasında otomatik olarak gösterilir).

Sağ tarafta, Sözleşmeye Yaz altında, blok zincirini herhangi bir şekilde değiştirmek veya değiştirmek için kullanabileceğiniz tüm işlevleri göreceksiniz. Bunlar gaza mal olacak. Yeni paraları nane haline getirmenize izin veren bir sözleşme oluşturduysanız, “Mint Token” adlı bir fonksiyonunuz olmalıdır. Seçin.

Bu yeni para birimlerinin oluşturulacağı adresi ve ardından tutarı seçin (2 olarak ayarlanmış ondalık sayılarınız varsa, doğru miktarı oluşturmak için miktardan sonra 2 sıfır ekleyin). Yürütme sırasında, sahip olarak ayarlanan hesabı seçin, Pirl miktarını sıfırda bırakın ve ardından yürüt düğmesine basın.

Birkaç onaydan sonra, alıcı bakiyesi yeni tutarı yansıtacak şekilde güncellenecektir. Ancak alıcı cüzdanınız otomatik olarak göstermeyebilir: özel belirteçlerden haberdar olmak için cüzdan bunları bir izleme listesine manuel olarak eklemelidir. Jeton adresinizi kopyalayın (yönetici sayfasında, adresi kopyala'ya basın) ve alıcıya gönderin. Henüz yapmadılarsa, sözleşmeler sekmesine gitmelidirler, Jetonu İzle'ye basın ve adresi buraya ekleyin. Görüntülenen ad, semboller ve ondalık miktarlar, özellikle benzer (veya aynı) ada sahip başka simgeleri varsa, son kullanıcı tarafından özelleştirilebilir. Ana simge değiştirilemez ve kullanıcılar bazı taklitçi jetonuyla değil, gerçek anlaşma ile uğraştıklarından emin olmak için jeton gönderirken ve alırken onlara dikkat etmelidir.

Paranızı Kullanma

Jetonlarınızı dağıttıktan sonra, izlenen jetonlar listenize eklenir ve toplam bakiye hesabınızda gösterilir. Jeton göndermek için, Gönder sekmesine gidin ve jeton içeren bir hesap seçin. Hesabın sahip olduğu jetonlar Pirl'in hemen altında listelenecektir. Bunları seçin ve göndermek istediğiniz token miktarını yazın.

Başkasının jetonunu eklemek istiyorsanız, Sözleşmeler sekmesine gidin ve Simgesi izle'yi tıklayın. Örneğin, Pirl Vortex jetonunu izleme listenize eklemek için 0x0489A975393A1cD0330740040141D702C35180cb adresini eklemeniz yeterlidir.

Şimdi ne olacak?

Pirl'i bir jeton çıkarmak için nasıl kullanabileceğinizi öğrendiniz, bu da istediğiniz her şeyi temsil edebilir. Fakat jetonlarla ne yapabilirsiniz? Örneğin, bir şirketteki payı temsil etmek için jetonları kullanabilir veya enflasyonu kontrol etmek için yeni paraların ne zaman verileceğini oylamak için bir merkezi komite kullanabilirsiniz. Bunları bir kitle aracılığıyla bir amaç için para toplamak için de kullanabilirsiniz. Sonra ne inşa edeceksin?

Referans malzemesi: ethereum.org


Haber bültenimize abone ol

Güncellemeleri alın ve en iyilerden öğrenin

Daha Fazlasını Keşfedin

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