ERC-20 Tokeni Nasıl Oluşturulur ve Dağıtılır?

03 Ocak 2023 422 kez okundu Okuma süresi: 50dk, 10sn

ERC-20 Tokeni Nasıl Oluşturulur ve Dağıtılır?

Kripto para birimleri son zamanlarda popülerliğini yitirse de teknolojisi şirketlere, bireylere ve DAO’lara sonsuz olanaklar sunuyor. Bu işin teknolojisini öğrenmek, hatta 1 Saatte ERC20 Jetonu oluşturmayı ve dağıtmayı öğrenmek istiyorsanız , doğru yer orası.

Bu eğitimde, OpenZeppelin tarafından sağlanan Solidity ve ERC20 Token standardını kullanarak bir kripto para birimini nasıl oluşturacağınızı anlayacaksınız .

Öncelikle, Solidity ile Ethereum geliştirmesi için özel olarak yapılmış çevrimiçi bir IDE olan REMIX IDE‘yi kullanarak Akıllı Sözleşmeyi yazacağız. Ardından, Mumbai Polygon Testnet’te kendi kripto para biriminizi dağıtmak için Hardhat kullanarak yerel bir ortam kuracağız.

Bu eğitimin sonunda şunları öğreneceksiniz :

Remix IDE’yi kullanarak bir Ethereum Akıllı Sözleşmeleri geliştirin ve dağıtın.
Solidity ile bir ERC20 Simgesi nasıl oluşturulur ve dağıtılır.
Hardhat kullanarak yerel bir Ethereum geliştirme ortamı kurun.
Polygon Mumbai’de bir kripto para birimi dağıtın.
Kendi kripto para biriminizi MetaMask’ta görselleştirin.
Kendi kripto para biriminizi nasıl başlatabilirsiniz?

Bu eğitime başlamadan önce önceden programlama bilgisine sahip olunması önerilmesine rağmen, önceden herhangi bir Solidity bilgisi olduğu varsayılmaz. Nereden başlayacağınızı bilmiyorsanız, gidip Zero To Hero : Web3.0 ve Solidity Geliştirme Yol Haritasının tamamını kontrol etmenizi şiddetle tavsiye ederim.

Zero To Hero : Web3.0 ve Solidity Geliştirme Yol Haritası 2023

Bununla birlikte, doğrudan bir ERC20 jetonunun nasıl geliştirilip konuşlandırılacağına bakalım .

Bir ERC20 Jetonu Nasıl Oluşturulur: REMIX ile Ortamı Kurun

Kullanımı kolay, ücretsiz, harika bir Solidity uyumlu özelliği ve uygun derleme zamanı hataları olan IDE ile REMIX kullanarak bir ERC20 Token Akıllı Sözleşmesini nasıl oluşturacağımızı ve konuşlandıracağımızı öğreneceğiz .

remix.ethereum.org adresine gidin, kişiler klasörünü açın ve “Token.sol” adlı yeni bir dosya oluşturun :

Remix IDE, *ERC20 Simgesi Nasıl Oluşturulur ve Dağıtılır*

Yeni bir Solidity dosyası oluşturulduğunda, derleyicinin kodumuzu oluşturmak için kullanması gereken Solidity sürümünü belirtmek için Lisans tanımlayıcısını ve pragmayı eklemek zorunludur.

Token.sol dosyasına aşağıdaki kodu yazın:

// SPDX-License-Identifier: GPL-3.0

pragma solidity ^0.8.17;

Şimdi OpenZeppelin‘den ERC20 jeton sözleşmesini içe aktarmamız gerekiyor, ancak önce, kendi kripto para biriminizi oluşturmak isteyip istemediğinizi anlamak için önemli olan bir ERC20 Token’ın ne olduğuna kısaca değinmeme izin verin.

Bir ERC20 Simgesi Nasıl Oluşturulur ve Dağıtılır: ERC20 nedir?

Resmi OpenZeppelin belgelerine göre:

“ERC20 belirteç sözleşmesi, değiştirilebilir belirteçlerin kaydını tutar; herhangi bir belirteç, diğer herhangi bir belirteç ile tam olarak eşittir; hiçbir belirteç onlarla ilişkili özel haklara veya davranışlara sahip değildir. Bu, ERC20 belirteçlerini bir döviz kuru aracı, oylama hakları, staking ve daha fazlası gibi şeyler için kullanışlı hale getiriyor.”

Basitçe söylemek gerekirse, ERC20, yöntemleri ve üyeleriyle, diğer kullanım durumlarında da uygulamalar bulduğu için, daha geniş bir anlama sahip olsa da, yaygın olarak kripto para birimleri dediğimiz mantığı çalıştıran bir sınıftan başka bir şey değildir.

Öte yandan OpenZeppelin , ERC sözleşmeleri sınıflarını koruyan standart kütüphane olarak kabul edilir.

Artık OpenZeppelin kitaplığını neden içe aktardığımızı ve ERC20’nin ne anlama geldiğini kısa bir şekilde anladığımıza göre, bir ERC20 Simgesinin nasıl oluşturulacağını ve konuşlandırılacağını öğrenmeye devam edelim.

Bir ERC20 Simgesi Nasıl Oluşturulur ve Dağıtılır?

OpenZeppelin ERC20 sözleşmesini Token.sol dosyasına aktarın:

// SPDX-License-Identifier: GPL-3.0

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

Ve ERC20.sol sözleşmesinden devralan Token’ı başlatın:

// SPDX-License-Identifier: GPL-3.0

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";


contract DevToken is ERC20{
}

Burada , ERC20 OpenZeppelin’in sözleşmesinden “is” anahtar sözcüğünü kullanarak devralırken, Solidity anahtar sözcüğü sözleşmeyi kullanarak “DevToken” adlı yeni bir sözleşme ilan ediyoruz .

ERC20 sözleşmesinden devralmak, bize _mint() ve balanceOf() gibi yöntemlere erişim sağlayacaktır. Mevcut tüm yöntemlere göz atmak isterseniz, resmi ERC20 belgelerini kontrol edebilirsiniz.

Bir kripto para birimi oluşturmak için bir sonraki adım, sözleşmenin kurucusunu aramak ve Token’ın adını ve sembolünü sağlamaktır . Bunu yapmak için sözleşmenin içine aşağıdaki kodu yazın:

contract DevToken is ERC20{
    constructor() ERC20("DevToken", "DVT"){

    }
}

Bu noktada kodunuz şöyle görünmelidir:

// SPDX-License-Identifier: GPL-3.0

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract DevToken is ERC20{
    constructor() ERC20("DevToken", "DVT"){

    }
}

Harika! 🎉 Kendi Kripto Para Birimimizi test etmeden ve daha karmaşık konulara geçmeden önce son bir adım, şimdi ERC20 Token’ımızı etkin bir şekilde dağıtmamız gerekiyor.

Bir ERC20 Simgesi Nasıl Oluşturulur: Kripto Para Birimi Üretin

Daha önce de belirtildiği gibi , ERC20 sözleşmesinden devralmak, bize yeni belirteçler oluşturmak ve bunları belirli bir adrese göndermek için kullanılan _mint() yöntemine erişim sağlar, tam da şimdi ihtiyacımız olan şey.

Minting, bilgileri doğrulama , yeni bir blok oluşturma ve bu bilgileri blok zincirine kaydetme süreci olarak tanımlanır. Basitçe söylemek gerekirse, “mint” şu anlama gelir: bir dizi Jeton veya bir NFT gibi bir şey yaratmak ve bunu blok zincirine kaydetmek.

Diyelim ki 1000 jeton oluşturup cüzdanımıza göndermek istiyoruz, bunu başarmak için yapıcıya aşağıdaki kodu ekleyebiliriz:

contract DevToken is ERC20{
    constructor() ERC20("DevToken", "DVT"){
        _mint(msg.sender,1000*10**18);
    }
}

Bu kod parçası, Solidity dilinde bir Ethereum kontratı tanımlar. Bu kontrat, ERC20 standardını uygular ve DevToken isminde bir kontrat oluşturur. Bu kontratın yapılandırıcı fonksiyonu (constructor) çağrıldığında, “DevToken” isminde ve “DVT” sembolüyle bir ERC20 token oluşturulur. Ayrıca, yapılandırıcı fonksiyon içinde, _mint() adlı bir fonksiyon çağrılır ve bu fonksiyon, mesaj gönderen kullanıcıya (msg.sender) 1000 adet DevToken token verir. Bu tokenlerin birimi, 10^18’inci katıdır (bu, ERC20 standardında kullanılan birimdir). Bu kontrat, bu şekilde yapılandırıldıktan sonra, kullanıcılara DevToken token dağıtabilir ve DevToken tokenlerinin transferlerini takip edebilir.

Burada çok şey oluyor, anlamak için bir saniyenizi ayıralım:

Her şeyden önce, belirteçleri yayınlamaktan sorumlu olan ve iki parametre isteyen _mint() işlevini çağırıyoruz:

to: jetonları alacak cüzdanın/sözleşmenin adresi,
miktar: gönderilecek jeton miktarı.

“to (kime)” bağımsız değişkeni, değeri sözleşmeyi çağıran cüzdanın/sözleşmenin adresi olan özel bir değişken olan msg.sender‘dan alınır . Miktarın ise ondalıklarla ilgilenmesi gerekiyor ve bu yüzden bu kadar büyük bir sayıyı geçiyoruz, bir saniye üzerinden geçeyim.

Ondalık Sayılar Üzerine Bir Not

Kripto para birimleriyle uğraşırken, 0.004ETH gibi keyfi miktarlar gönderebilmek isteyebilirsiniz. Ne yazık ki, Solidity ve Ethereum Virtual Machine ondalık sayıları desteklemez : sadece tamsayı sayılar kullanılabilir. Bu, yalnızca tam sayıların (1, 4, 5) gönderilebileceği anlamına gelir ve bu, elbette bir sorun teşkil eder.

Peki geçici çözüm nedir?

Çok basit, bir belirteç sözleşmesi daha büyük tamsayı değerleri kullanabilir (EVM 256 bit tamsayıları destekler), böylece 1000000000000000000 bakiyesi 18 ondalık basamaklı 1 ETH’yi temsil eder, dolayısıyla 4000000000000000 transfer, gönderilen 0.004ETH’ye karşılık gelir.

Toplam arzımızı hesaplarken, sahip olmak istediğimiz ondalık basamaklar da dahil olmak üzere toplam token miktarını hesaba katmamız gerektiğini göz önünde bulunduruyoruz.

Ethereum ve diğer birçok kripto para biriminin sahip olduğu gibi 18 ondalık basamaklı toplam maksimum 1.000.000.000 jeton arzı istiyorsanız, 1000000000*10**18’i geçmek istersiniz (100000000000000000000000000).

Öte yandan, 2 belirteç gönderirken çağrılacak yöntem şu şekilde olacaktır:

transfer(recipient, 2 * 10**18);

Tamam, mint işlevinde neler olduğunu anladığımıza göre, ERC20 Token sözleşmemizi test edelim.

ERC20 Token Kripto Para Biriminizi Dağıtın

REMIX’te , ekranın sol tarafındaki Solidity simgesine tıklayın ve derlemeye tıklayın. REMIX’in kod değişikliklerini dinlemesine ve kodunuzu derlemesine izin vermek için otomatik derlemeyi de etkinleştirmek isteyebilirsiniz.

Bir ERC20 Simgesi Nasıl Oluşturulur ve Dağıtılır?

Bu, Token.sol kodunu derleyerek, yapay eserler klasörünü Token’in Sözleşme ABI‘si (uygulama ikili arayüzü) ve blok zincirinde dağıtmak için kullanılan ikili sürümüyle dolduracaktır.

Artık eserlerimizi aldığımıza göre, Solidity simgesinin altındaki Ethereum logosuna tıklayın, açılır menüden sözleşmenizi seçin ve konuşlandırmaya tıklayın:

Bir ERC20 Simgesi Nasıl Oluşturulur ve Dağıtılır?

Tebrikler ! 🎉 Her şey beklendiği gibi çalıştıysa, az önce bir ERC20 belirteci oluşturup dağıttınız!

İlk Kripto Para Biriminizle Etkileşime Geçin

Unutma? Dağıtıldığında, akıllı sözleşmemiz cüzdanımıza 1000 jeton vermiş olmalıdır! İzlerseniz, Dağıt düğmesinin hemen üzerinde “hesap” alanı bulunur:

Bir ERC20 Simgesi Nasıl Oluşturulur ve Dağıtılır? — *Bir ERC20 Simgesi Nasıl Oluşturulur ve Dağıtılır*?

Bu, ERC20 Token sözleşmemizi dağıtmak için kullandığımız cüzdanın adresidir, bazı Ethereum eksikleri olduğu için, sözleşmeyi Ethereum Sanal Makinesinde dağıtmak için ödediğimiz Gas ücretlerinin olduğunu söyleyebiliriz.

Her şey beklendiği gibi çalıştıysa, artık cüzdan adresimizin bakiyesinde verilen jeton miktarını görmeliyiz.

Bunu test etmek için, fark edebileceğiniz gibi, konuşlandırma düğmesinin ve “Dağıtılan Sözleşmeler“in hemen altında, dağıtılan ERC20 jetonunuz var. Açılır menüye tıklamak, sözleşmenizin miras aldığı veya uyguladığı tüm ERC20 yöntemlerine erişmenizi sağlayacaktır:

Bir ERC20 Simgesi Nasıl Oluşturulur ve Dağıtılır?

Düğmelerin rengi, temsil işlevinin blok zincirindeki herhangi bir değeri değiştirip değiştirmediğini, Gaza mal olup olmadığını (Turuncu) veya sadece okuyup bir değer döndürerek basit bir görüntüleme işlevi olup olmadığını gösterir.

Bu düğmelerin arasında “ balanceOf ” diyen bir tane var, giriş olarak bir adres gerektirir ve ilgili ERC20 Token miktarını alacaktır. Kullanalım:

Cüzdan adresinin yanındaki “kopyala” simgesine tıklayarak cüzdan adresini kopyalayın.
Belirteç yöntemlerinde aşağı kaydırın ve “balanceOf” ifadesini arayın.
Cüzdan adresini alana yapıştırın.
Mavi balanceOf düğmesine tıklayın.
Miktarı kontrol edin.

Bir ERC20 Simgesi Nasıl Oluşturulur ve Dağıtılır?

Bu bize toplam 1000000000000000000000 jeton geri vermeli, çünkü Token’a 18 ondalık basamak vermeyi seçtik. Miktarı dönüştürmek için sayıyı 10^18’e bölebilir ve 1000’i geri alabiliriz veya anında dönüştürmek için eth-converter.com’a gidebiliriz (çünkü Ethereum ile aynı miktarda ondalık sayı kullanıyoruz).

Tebrikler , az önce kendi kripto para biriminizi yarattınız! 🎉

Ne yazık ki, şu anda iki sorun var:

Token’ımıza henüz REMIX dışından erişilemiyor çünkü şu anda REMIX örneğiniz dışında hiçbir şey tarafından erişilemeyen bir blok zinciri görevi gören sanal bir makine olan Remix EVM’de kullanılıyor.
Şu anda yaptığımız gibi tüm belirteçleri konuşlandırırken yayınlamak yerine, belirteçleri bir eylemin sonucu olarak veya yalnızca küçük gruplar halinde bir ödül olarak vermek isteyebiliriz .

İlk olarak, token tedarikinin nasıl ele alınacağı konusuna değinelim .

Not : REMIX, bir test ağına benzetilebilen, ancak ortamın kendisi dışında halka açık olmayan, barındırılan bir sanal ethereum ortamı kullanır. Sözleşmeniz gerçek Ethereum ana ağında veya herkesin erişebileceği bir test ağında konuşlandırılmayacaktır.

Bir ERC20 Nasıl Geliştirilir: İşe Yarayan Bir Token Arzı Oluşturun

Kendi kripto para arzınızı oluşturmanız gerektiğinde, 3 ana seçeneğimiz var:

Sabit Tedarik
Sınırsız Tembel Tedarik
Kapaklı Tembel Tedarik

Bu noktada, jetonumuz dağıtımda yayınlanan Sabit bir tedarike sahiptir, bunun ne anlama geldiğini ve kripto para birimlerimizi geliştirirken sahip olduğumuz alternatifleri keşfedelim.

Sabit Tedarik

Jetonun toplam arzı, dağıtım sırasında verilir ve dağıtılan cüzdan adresine gönderilir.

Bu durumda, önceden bir toplam arz seçeriz ve sözleşmenin kurucusu çağrıldığında tüm tutarı cüzdanımıza veririz, bu da bize tokenleri farklı sahipler arasında dağıtma çabasını bırakır.

Tüm jetonları bir kerede çıkarmak istemiyorsak, tembel bir basım yaklaşımı seçmeliyiz.

Sınırsız Tembel Tedarik

Belirteçler dağıtım sırasında benzersiz bir parti halinde basılmaz ve verilmez, ancak küçük miktarlarda ve belirtilen cüzdanlara , sonuç olarak bir veya daha fazla eyleme gönderilir.

Bu durumda, toplam maksimum arz, sabit kodlanmış bir değere göre değil, ekonomik odaklı ilkelere göre düzenlenir.

Bir işlemi onaylayan ve ödül olarak jetonları geri alan bir Madenciyi veya periyodik ödüller almak için jetonlarını istifleyen bir kullanıcıyı düşünün.

Bununla birlikte, sabit kodlanmış bir Max arzının olmaması, jetonunuzu şişirebilir, zaman içinde değer kaybına neden olabilir veya en kötüsü güvenliğini riske atabilir. Bu, bu eğitimin odak noktasının dışına çıksa bile, arzımızı sınırlandırabileceğimizi ve sınırlandırmamız gerektiğini anlamakta fayda var.

Kapaklı Tembel Tedarik

Sınırsız Tembel Tedarik mekanizmasında olduğu gibi, belirteçler küçük miktarlarda verilir, tek fark burada maksimum arzın önceden kararlaştırılması ve akıllı sözleşmede sabit kodlanması veya dağıtıma geçirilmesidir.

Bu eğitimde, Jetonlarımızın arzını oluşturmak için tüm yöntemleri geniş bir şekilde keşfedeceğiz.

ERC20 Token Temini – Sabit tedarik

Diyelim ki başlangıçta sözleşmeyi dağıtan cüzdana tahsis edilen sabit 1000 Dev Token arzına sahip bir jeton istiyoruz (kodumuzda yaptığımız gibi), bunu yapmak için Token Yapıcı içindeki _mint() özel işlevini çağırdık:

// SPDX-License-Identifier: GPL-3.0

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract DevToken is ERC20{
    constructor() ERC20("DevToken", "DVT"){
        _mint(msg.sender,1000*10**18);
    }
}

Bu kod parçası, Solidity dilinde bir Ethereum kontratı tanımlar. Bu kontrat, ERC20 standardını uygular ve DevToken isminde bir kontrat oluşturur. Kontratın ilk satırında, bir lisans tanımlayıcısı bulunur ve bu tanımlayıcı “GPL-3.0” lisansını belirtir.

Sonraki satırda, “pragma solidity” tanımlayıcısı ile kontratın Solidity sürümü belirtilir. Bu tanımlayıcı, kontratın Solidity sürümü 0.8.0 veya daha yeni bir sürümü ile yazıldığını belirtir.

Daha sonra, “@openzeppelin/contracts/token/ERC20/ERC20.sol” dosyası içeri aktarılır ve bu dosya, ERC20 standardını uygulayan bir kontratı içerir. Bu sayede, DevToken kontratı da ERC20 standardını uygular.

Son olarak, DevToken kontratının yapılandırıcı fonksiyonu (constructor) tanımlanır. Yapılandırıcı fonksiyon çağrıldığında, “DevToken” isminde ve “DVT” sembolüyle bir ERC20 token oluşturulur. Ayrıca, yapılandırıcı fonksiyon içinde, _mint() adlı bir fonksiyon çağrılır ve bu fonksiyon, mesaj gönderen kullanıcıya (msg.sender) 1000 adet DevToken token verir. Bu tokenlerin birimi, 10^18’inci katıdır (bu, ERC20 standardında kullanılan birimdir). Bu kontrat, bu şekilde yapılandırıldıktan sonra, kullanıcılara DevToken token dağıtabilir ve DevToken tokenlerinin transferlerini takip edebilir.

Özetle; Kurucunun dağıtım sırasında yalnızca bir kez çağrıldığını bilen bu akıllı sözleşme, cüzdanımıza yalnızca 1000 jeton (miktarda 18 ondalık basamak vardır: ondalık sayılar bölümüne bakın ) aktarmakla kalmadı, aynı zamanda herhangi bir yeni jeton basmayı imkansız hale getirdi.

Daha önce yaptığımız gibi balanceOf() metodunu çağırarak token dağıtan adresin token bakiyesini kontrol edebiliriz.

Peki, jetonları benzersiz bir partide değil, zaman içinde yayınlamak istiyorsak ne olur?

ERC20 Token Arzı – Sınırsız Tembel Arz

Bunu başarmak için, mint işlevini yapıcımızdan farklı koşullar altında çağrılabilecek yeni bir genel işleve taşıyabiliriz:

// SPDX-License-Identifier: GPL-3.0

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract DevToken is ERC20{
    constructor() ERC20("DevToken", "DVT"){}

    function issueToken() public{
        _mint(msg.sender, 1000*10**18);
    }
}

Son olarak, DevToken kontratının yapılandırıcı fonksiyonu (constructor) ve issueToken() adlı fonksiyon tanımlanır. Yapılandırıcı fonksiyon çağrıldığında, “DevToken” isminde ve “DVT” sembolüyle bir ERC20 token oluşturulur. Ancak yapılandırıcı fonksiyon içinde hiçbir işlem yapılmaz.

issueToken() fonksiyonu ise, kullanıcılara DevToken token dağıtmak için kullanılır. Bu fonksiyon, public erişim belirteciyle (public) tanımlanmıştır ve bu fonksiyon çağrıldığında, _mint() fonksiyonu çağrılır ve bu fonksiyon, mesaj gönderen kullanıcıya (msg.sender) 1000 adet DevToken token verir. Bu tokenlerin birimi, 10^18’inci katıdır (bu, ERC20 standardında kullanılan birimdir). Bu şekilde, issueToken() fonksiyonu çağrıldığında, kullanıcılara DevToken token dağıtabilir ve DevToken tokenlerinin transferlerini takip edebilir.

Özetle; Bu durumda, issueToken() her çağrıldığında, arayan kişi o miktarda jeton alır. Elbette, verilen jeton miktarını veya alıcıyı değiştirmek için argümanlar da iletebiliriz:

// SPDX-License-Identifier: GPL-3.0

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract DevToken is ERC20{
    constructor() ERC20("DevToken", "DVT"){}

    function issueToken(address receiver, uint256 amount) public{
        _mint(receiver, amount);
    }
}

issueToken() fonksiyonu ise, kullanıcılara DevToken token dağıtmak için kullanılır. Bu fonksiyon, public erişim belirteciyle (public) tanımlanmıştır ve iki parametre alır: address tipinde bir “receiver” adresi ve uint256 tipinde bir “amount” miktarı. Bu fonksiyon çağrıldığında, _mint() fonksiyonu çağrılır ve bu fonksiyon, belirtilen “receiver” adresine belirtilen “amount” miktarda DevToken token verir. Bu şekilde, issueToken() fonksiyonu çağrıldığında, istenen kullanıcıya istenen miktarda DevToken token dağıtabilir ve DevToken tokenlerinin transferlerini takip edebilir.

Özetle; Buradaki sorun, daha fazla kontrol olmaksızın, bir kullanıcının verebileceği belirteç sayısında bir sınır olmamasıdır. Geçici bir çözüm olarak, Token’ın toplam arzını sınırlandırabiliriz.

ERC20 Token Arzı – Sınırlandırılmış Modüler Tedarik

Token’ımıza maksimum tedarik eklemek için ERC20Capped OpenZeppelin kütüphanesini kullanabiliriz .

ERC20Capped , standart ERC20 sözleşmesinden miras kalan bir ERC20Mintable alt sınıfıdır . Bu, _mint() ve balanceOf() gibi yöntemleri korurken kodumuzdaki ERC20.sol kitaplığını ERC20Capped ile değiştirmemize olanak tanır.

Ayrıca Token yapıcımıza bir uint256 argümanı ileterek ve onu ERC20Capped yapıcısına besleyerek bir sınır değer belirlememiz gerekecek .

ERC20Capped kütüphanesini OpenZeppelin’den import edelim ve Token.sol sözleşmesine aşağıdaki kodu ekleyelim:

// SPDX-License-Identifier: GPL-3.0

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Capped.sol";

contract DevToken is ERC20Capped{
    constructor(uint256 cap) ERC20("DevToken", "DVT") ERC20Capped(cap){
}

    function issueToken() public{
        _mint(msg.sender, 1000*10**18);
    }
}

Bu kod parçası, Solidity dilinde bir Ethereum kontratı tanımlar. Bu kontrat, ERC20Capped adı verilen bir sınıfı uygular ve DevToken isminde bir kontrat oluşturur. ERC20Capped sınıfı, ERC20 standardını uygular ve ayrıca bir token’in toplam dağıtım miktarını sınırlandırır (capped). Kontratın ilk satırında, bir lisans tanımlayıcısı bulunur ve bu tanımlayıcı “GPL-3.0” lisansını belirtir.

Daha sonra, “@openzeppelin/contracts/token/ERC20/extensions/ERC20Capped.sol” dosyası içeri aktarılır ve bu dosya, ERC20 standardını uygulayan ve ayrıca token dağıtımını sınırlandıran bir sınıf içerir. Bu sayede, DevToken kontratı da ERC20 standardını uygular ve ayrıca token dağıtımını sınırlandırır.

Son olarak, DevToken kontratının yapılandırıcı fonksiyonu (constructor) ve issueToken() adlı fonksiyon tanımlanır. Yapılandırıcı fonksiyon, uint256 tipinde bir “cap” parametresi alır ve bu “cap” parametresi, token’in toplam dağıtım miktarını belirtir. Yapılandırıcı fonksiyon çağrıldığında, “DevToken” isminde ve “DVT” sembolüyle bir ERC20 token oluşturulur ve bu token’in toplam dağıtım miktarı “cap” parametresi ile sınırlandırılır.

issueToken() fonksiyonu, kullanıcılara DevToken token dağıtmak için kullanılır. Bu fonksiyon, public erişim belirteciyle (public) tanımlanmıştır ve hiçbir parametre almaz. Bu fonksiyon çağrıldığında, _mint() fonksiyonu çağrılır ve bu fonksiyon, mesaj gönderen kullanıcıya (msg.sender) 1000 adet DevToken token verir. Bu tokenlerin birimi, 10^18’inci katıdır (bu, ERC20 standardında kullanılan birimdir). Bu şekilde, issueToken() fonksiyonu çağrıldığında, kullanıcılara DevToken token dağıtabilir ve DevToken tokenlerinin transferlerini takip edebilir. Ancak bu dağıtım işlemi, toplam dağıtım miktarını aşmayacak şekilde yapılır çünkü DevToken kontratı, ERC20Capped sınıfını uygular ve bu sınıf token dağıtımını sınırlandırır.

Şimdi, daha önce yaptığımız gibi, REMIX kullanarak Caped jetonumuzu test edebiliriz:

Solidity Simgesine tıklayın ve kodunuzu derleyin
Açılır menüden Token sözleşmenizi seçin
Sınır miktarını konuşlandırma alanına girin
Dağıt’a tıklayın
Sınır değerini almak için “sınır” düğmesi yöntemine tıklayın.

Bir ERC20 Simgesi Nasıl Oluşturulur ve Dağıtılır?

Örnekte görebileceğiniz gibi, 10000000000000000’lik bir üst değer ekledik, 18 ondalık basamak dikkate alındığında, maksimum 0,01 DVT kaynağına karşılık gelir. issueToken() yönteminin kullanılması artık “sınır aşıldı” hatası veren işlemi geri alacaktır:

Artık basılabilir bir Simgemiz olduğuna göre çözülmesi gereken bir sorun kaldı: herkes onu issueToken() işlevini çağırarak basabilir ve bu çok büyük bir güvenlik sorununa yol açar. Neyse ki buna bir çözüm var: Sahip olunan sözleşmeler…

ERC20 Simgesi Nasıl Oluşturulur – Güvenlik ve Erişim Kontrolü

Erişim kontrolü ile ilgili OpenZeppelin belgelerinin bize söylediklerini inceleyelim;

Akıllı sözleşmelerle uğraşırken erişim kontrolü veya “bunu kimin yapmasına izin verilir” inanılmaz derecede önemlidir. Sözleşmenizin erişim kontrolü, kimlerin jeton basabileceğini, tekliflere oy verebileceğini, transferleri dondurabileceğini ve diğer pek çok şeyi yönetebilir.

Bu nedenle, başka birinin tüm sisteminizi çalmaması için onu nasıl uyguladığınızı anlamak çok önemlidir .

En yaygın ve temel erişim denetimi biçimi, yalnızca bir hesabın bir sözleşmede (sahip) hassas görevleri gerçekleştirmesine izin verilen sahiplik kavramıdır. Bu yaklaşım, tek bir yönetici kullanıcıya sahip sözleşmeler için son derece uygundur.

OpenZeppelin, sözleşmelerde sahiplik uygulamak için Ownable sağlar.

Bunu kullanmak için, sözleşmeyi kodumuza içe aktarmamız, daha önce yaptığımız gibi onu Token sözleşmemizin bir üst sınıfı olarak eklememiz ve issueToken() işlevine bir işlev değiştirici eklememiz gerekecek.

// SPDX-License-Identifier: GPL-3.0

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract DevToken is ERC20, Ownable{
    constructor() ERC20("DevToken", "DVT"){}

    function issueToken() public onlyOwner{
        _mint(msg.sender, 1000*10**18);
    }
}

Bu kod parçası, Solidity dilinde bir Ethereum kontratı tanımlar. Bu kontrat, ERC20 ve Ownable adlı iki sınıfı uygular ve DevToken isminde bir kontrat oluşturur. ERC20 sınıfı, ERC20 standardını uygular ve Ownable sınıfı ise, bir kontratın sahiplenilebilir olmasını sağlar. Kontratın ilk satırında, bir lisans tanımlayıcısı bulunur ve bu tanımlayıcı “GPL-3.0” lisansını belirtir.

Daha sonra, “@openzeppelin/contracts/token/ERC20/ERC20.sol” ve “@openzeppelin/contracts/access/Ownable.sol” dosyaları içeri aktarılır. Bu dosyalar, ERC20 standardını uygulayan ve sahiplenilebilir kontratları tanımlayan sınıflar içerir. Bu sayede, DevToken kontratı da ERC20 standardını uygular ve ayrıca sahiplenilebilir hale gelir.

issueToken() fonksiyonu, kullanıcılara DevToken token dağıtmak için kullanılır. Bu fonksiyon, public erişim belirteciyle (public) ve onlyOwner özel yetki belirteciyle (onlyOwner) tanımlanmıştır. Bu özel yetki belirteci, fonksiyonu sadece kontrat sahibinin çağırabilmesine izin verir. Bu fonksiyon çağrıldığında, _mint() fonksiyonu çağrılır ve bu fonksiyon, mesaj gönderen kullanıcıya (msg.sender) 1000 adet DevToken token verir. Bu tokenlerin birimi, 10^18’inci katıdır (bu, ERC20 standardında kullanılan birimdir). Bu şekilde, issueToken() fonksiyonu çağrıldığında, kullanıcılara DevToken token dağıtabilir ve DevToken tokenlerinin transferlerini takip edebilir. Ancak bu dağıtım işlemi, sadece kontrat sahibi tarafından yapılabilir çünkü issueToken() fonksiyonu onlyOwner özel yetki belirteciyle tanımlanmıştır ve bu belirteç, fonksiyonu sadece kontrat sahibinin çağırabilmesine izin verir.

Fark edebileceğimiz gibi, Token sözleşmesi artık hem ERC20’den hem de Ownable sözleşmesinden devralıyor, bu bize issueToken() işlevine uygulanan onlyOwner işlev değiştiricisine erişim sağlıyor .

onlyOwner, issueToken() her çağrıldığında, arayanın sözleşmenin sahibi olup olmadığını doğrulayarak çalışır.

Varsayılan olarak, Sahip olunabilir bir sözleşmenin sahibi, onu dağıtan hesaptır ve bu genellikle tam olarak istediğiniz şeydir.

Artık belirteç tedarikimizi nasıl tasarlayacağımıza ve basım sürecini nasıl güvence altına alacağımıza dair makul bir anlayışa sahip olduğumuza göre, Hardhat kullanarak yerel bir geliştirme ortamı kurarak belirtecimizi gerçek ve erişilebilir bir blok zincirine nasıl dağıtacağımızı öğrenelim.

Yerel Blockchain Geliştirici Ortamınızı Kurun

Yeni oluşturulan Token’ı başka bir cüzdana aktarmak, bir borsada listelemek veya sadece gerçek dünyada kullanmak istiyorsak, REMIX yeterli olmayacaktır . Bir Ethereum akıllı sözleşmesini Polygon veya Ethereum gibi halka açık bir blok zincirine dağıtmak için Hardhat veya Truffle gibi bir Ethereum geliştirme ortamı kurmamız gerekecek .

Bu eğitimde, Hardhat kullanacağız ve VSCode‘un cihazınızda kurulu olduğunu varsayacağız.

Yeni bir klasör oluşturarak başlayın:

mkdir myFirstToken

Bu kod satırı, “myFirstToken” isminde bir klasör oluşturur. Bu komut, sistemde mevcut olmayan bir klasör oluşturmak için kullanılır. Eğer sistemde bu isimde bir klasör zaten mevcutsa, bir hata mesajı görüntülenir ve klasör oluşturulmaz. Bu kod satırı, örneğin bir Ethereum token projesi için gerekli olan dosyaların tutulabileceği bir klasör oluşturmak için kullanılabilir.

Proje klasörüne gidin, Hardhat’i ve Token akıllı sözleşmemizi derlemek ve test etmek için gereken bağımlılıkları kurun:

yarn add hardhat @nomiclabs/hardhat-waffle @nomiclabs/hardhat-ethers ethers ethereum-waffle

Bu kod satırı, Yarn paket yöneticisini kullanarak bir projeye aşağıdaki paketlerin eklenmesini sağlar:

hardhat: Bu paket, Ethereum smart contractlerinin test edilmesi, derlenmesi ve dağıtılması için açık kaynaklı bir araçtır.
@nomiclabs/hardhat-waffle: Bu eklenti, Hardhat ile Waffle kütüphanesini kullanarak Ethereum smart contractlerinin test edilmesini sağlar.
@nomiclabs/hardhat-ethers: Bu eklenti, Hardhat ile Ethers.js kütüphanesini kullanarak Ethereum smart contractleriyle etkileşim kurmayı sağlar.
ethers: Bu paket, JavaScript diliyle Ethereum blockchain’iyle etkileşim kurmak için kullanılan bir kütüphanedir.
ethereum-waffle: Bu paket, Ethereum smart contractlerinin test edilmesi için kullanılan bir kütüphanedir.

Bu paketlerin eklenmesi, projenin Ethereum smart contractleriyle ilgili birçok işlem yapmasına olanak sağlar. Örneğin, test etmek, derlemek ve dağıtmak gibi işlemler yapılabilir. Ayrıca, bu paketler sayesinde Ethereum smart contractleriyle etkileşim kurmak ve test etmek için gerekli olan çeşitli araçlar da kullanılabilir.

Kurulduktan sonra , aşağıdakileri çalıştırarak Hardhat kurulum sihirbazını başlatın :

npx hardhat

Bu kod satırı, npm paket yöneticisi (npx) kullanarak Hardhat araç kitini çalıştırır. Hardhat, Ethereum smart contractlerinin test edilmesi, derlenmesi ve dağıtılması için açık kaynaklı bir araçtır. Bu kod satırı çalıştırıldığında, Hardhat’in konsol üzerinden kullanılabilir olan komutlarının bir listesi görüntülenir. Kullanıcı bu komutları kullanarak, Hardhat ile Ethereum smart contractleriyle ilgili işlemler yapabilir. Örneğin, test etmek, derlemek ve dağıtmak gibi işlemler yapılabilir. Ayrıca, Hardhat ile birlikte gelen eklentiler sayesinde Ethereum smart contractleriyle etkileşim kurmak ve test etmek için gerekli olan çeşitli araçlar da kullanılabilir.

Temel bir örnek proje oluşturun > varsayılan kökü bırakın > bir .gitignore ekleyin.

Bu, proje dizinimizi varsayılan Hardhat dosya ve klasörleriyle dolduracaktır.

Bir sonraki adım, çalışan blockchain örneklerine bağlanmak için yapılandırma ayarlarını içeren hardhat.config.js dosyasını değiştirmek olacaktır, ancak önce Düğüm Sağlayıcı Bitiş Noktası URL’mizi alalım .

Alchemy Kullanarak Mumbai Sağlayıcı Uç Noktanızı Alın

Blok zincirinde bir şey dağıtırken, akıllı sözleşmenizi yürütmekten sorumlu bir düğüme ihtiyacınız olacak, bunu yapmak için iki seçeneğiniz var:

Kendi Ethereum düğümünüzü döndürün .
Alchemy veya Infura gibi üçüncü taraf bir düğüm sağlayıcı kullanın.

Bakımı zor olduğundan, ölçeklenmesi zor olduğundan, yükseltilmesi gerektiğinden ve bazı ciddi sürekli mühendislik çabası gerektiren durum tutarlılığını sağlaması gerektiğinden, kendi düğümünüzü çalıştırmak genellikle önerilmez.

Bu durumda, tamamen ücretsiz, kurulumu kolay ve çarpıcı özelliklere sahip olduğu için Mumbai Bağlantı Noktası sağlayıcısı olarak Alchemy’yi kullanacağız.

alchemy.com ‘a gidin ve yeni bir hesap oluşturun:

**Alchemy** Giriş Ekranı – *Bir ERC20 Simgesi Nasıl Oluşturulur ve Dağıtılır*?

Giriş yaptıktan sonra, ” + UYGULAMA OLUŞTUR ” üzerine tıklayın :

Alchemy, Create App – *Bir ERC20 Simgesi Nasıl Oluşturulur ve Dağıtılır*?

Ve aşağıdaki örneğe göre ilgili alanları doldurun:

Name / Proje Adı: MyProject
Description / Proje Tanımı: My First Token
Environment / Ortam: Development
Chain / Zincir: Polygon
Network / Ağ : Polygon Mumbai

Ve UYGULAMA OLUŞTUR’a tıklayın .

Alchemy Apps altında yeni oluşturulan uygulamayı arayın ve üzerine tıklayın.

Uygulama sayfasındayken, ” ANAHTARI GÖRÜNTÜLE ” üzerine tıklayın ve HTTP Bitiş Noktasını kopyalayın:

Artık Polygon Mumbai uç noktasını kopyaladığımıza göre, hardhat.config.js dosyamızı değiştirelim .

Hardhat.config Dosyasını Değiştirin

Jetonumuzu Mumbai Polygon Testnet’e konuşlandıracağız , ancak aşağıdaki bölümde açıklananlar, Ethereum üzerine inşa edilmiş tüm Blockchain ağları için geçerlidir (istenen zincire uyum sağlamak için sadece hardhat.config.js ayarını değiştirin) ).

Hardhat.config.js dosyasını projenizin kök dizininde açın ve module.exports nesnesinin içine aşağıdaki kodu ekleyin :

module.exports = {
  solidity: "0.8.4",
  networks:{
    mumbai:{
      url: 'YOUR ALCHEMY POLYGON MUMBAI ENDPOINT',

    }
  }
};

Bu kod parçası, Hardhat araç kitinin özelleştirilmiş bir yapılandırma dosyasıdır. Bu dosya, Hardhat’in nasıl çalışacağını ve hangi ağlarla etkileşim kuracağını belirtir.

Bu yapılandırma dosyasında, ilk satırda “solidity” özelliği tanımlanır ve bu özellik, kullanılacak Solidity sürümünü belirtir. Bu örnekte, Solidity sürümü 0.8.4 olarak belirlenmiştir.

Daha sonra, “networks” özelliği tanımlanır ve bu özellik, Hardhat’in hangi ağlarla etkileşim kuracağını belirtir. Bu özellik içinde, “mumbai” adlı bir alt özellik tanımlanır ve bu alt özellik, Mumbai adlı bir ağ için özelleştirilmiş bir yapılandırma sağlar. Bu alt özellik içinde, “url” özelliği tanımlanır ve bu özellik, Mumbai ağına bağlanılması için gerekli olan bir endpoint’i belirtir. Bu endpoint’in değeri, “YOUR ALCHEMY POLYGON MUMBAI ENDPOINT” olarak tanımlanmıştır ve bu değer, kullanıcı tarafından değiştirilmesi gerekir.

Bu yapılandırma dosyası, Hardhat araç kitinin Mumbai ağına bağlanıp, 0.8.4 sürümünde yazılmış olan Solidity kodlarını derleyebileceğini belirtir. Örneğin, aşağıdaki komut çalıştırıldığında, Hardhat araç kiti Mumbai ağına bağlanarak, “contracts” klasörü içinde bulunan tüm Solidity dosyalarını derleyebilir:

hardhat compile

Bu yapılandırma dosyası, ayrıca Hardhat araç kitinin Mumbai ağında bir smart contract’ı dağıtabileceğini de belirtir. Örneğin, aşağıdaki komut çalıştırıldığında, Hardhat araç kiti Mumbai ağında bir smart contract’ı dağıtabilir:

hardhat deploy

Bu yapılandırma dosyası, ayrıca Hardhat araç kitinin Mumbai ağında bir smart contract’ı test edebileceğini de belirtir. Örneğin, aşağıdaki komut çalıştırıldığında, Hardhat araç kiti Mumbai ağında bir smart contract’ı test edebilir:

hardhat test

Bu yapılandırma dosyası, Hardhat araç kitinin Mumbai ağında bulunan bir smart contract’ın adresini alabilmesi için de kullanılabilir. Örneğin, aşağıdaki komut çalıştırıldığında, Hardhat araç kiti Mumbai ağında bulunan bir smart contract’ın adresini alabilir:

hardhat run print-contract-address --network mumbai

Bu yapılandırma dosyası, Hardhat araç kitinin Mumbai ağında bulunan bir smart contract’ın ABI’sini (Application Binary Interface) alabilmesi için de kullanılabilir. Örneğin, aşağıdaki komut çalıştırıldığında, Hardhat araç kiti Mumbai ağında bulunan bir smart contract’ın ABI’sini alabilir:

hardhat run print-contract-abi --network mumbai

Bu yapılandırma dosyası, Hardhat araç kitinin Mumbai ağında bulunan bir smart contract’ın bytecode’sini alabilmesi için de kullanılabilir. Örneğin, aşağıdaki komut çalıştırıldığında, Hardhat araç kiti Mumbai ağında bulunan bir smart contract’ın bytecode’sini alabilir:

hardhat run print-contract-bytecode --network mumbai

Bu kadar hardhat detayından sonra; bir sonraki adım, kullanmak istediğimiz cüzdanın özel anahtarını eklemek, Token’ı blok zincirinde dağıtmak, ancak önce, özel anahtarımızı güvende tutmak için dotenv kitaplığını kurmamız gerekiyor.

Dotenv’i yükleyerek başlayalım .

dotenv’i yükleyin

Terminalde, proje klasörünün içine şunu yazarak dotenv kitaplığını kurun:

yarn add dotenv

Bu kod satırı, npm paket yöneticisi (yarn) kullanarak dotenv adlı bir npm paketini projenize ekler. dotenv, uygulamanızda kullanılacak olan çeşitli ortam değişkenlerini (environment variables) yönetmenize yardımcı olan bir açık kaynaklı kütüphanedir. Örneğin, bir Ethereum blockchain’ine bağlanmak için kullanılacak olan private key gibi gizli verileri, uygulamanızın kodunda açıkça göstermek yerine, dotenv kütüphanesi sayesinde bir “.env” dosyasında saklayabilirsiniz. Böylece, bu gizli verilerin güvenliği sağlanmış olur ve bu verilerin uygulamanızın koduna dahil edilmesi de önlenebilir.

Bu kod satırı çalıştırıldığında, dotenv paketi projenizin “node_modules” klasörüne indirilir ve paketin kullanımı için gerekli olan tüm dosyalar da bu klasöre eklenir. Daha sonra, dotenv paketini kullanmak için gerekli olan require() fonksiyonu ile dotenv kütüphanesini projenizin kodunda kullanabilirsiniz. Örneğin:

const dotenv = require('dotenv');

dotenv.config();

const privateKey = process.env.PRIVATE_KEY;

console.log(privateKey);

Bu kod örneğinde, dotenv kütüphanesi sayesinde “.env” dosyasından PRIVATE_KEY değişkeni okunmuş ve değerini “privateKey” değişkenine atanmıştır. Daha sonra, “console.log” fonksiyonu ile “privateKey” değişkeninin değeri ekrana yazdırılmıştır.

Bu şekilde, dotenv kütüphanesi sayesinde uygulamanız için gerekli olan çeşitli ortam değişkenlerini yönetebilir ve bu değişkenlerin değerlerini uygulamanızın kodunda kullanabilirsiniz. Bu sayede, uygulamanızın farklı ortamlarda (örneğin test ortamı, production ortamı gibi) çalışırken değişkenlerin değerlerini kolayca değiştirebilir ve uygulamanızın çalışmasını etkileyecek olan bu değişkenleri güvenli bir şekilde saklayabilirsiniz.

Ve projenizin kök klasöründe yeni bir .env dosyası oluşturun .

Oluşturulduktan sonra .env dosyasını .gitignore dosyanıza ekleyin; bu, sırlarınızı GitHub’a veya kullanıyor olabileceğiniz diğer herhangi bir sürüm kontrol hizmetine iletmenizi engelleyecektir.

Not : Cüzdanınızın özel anahtarını GitHub’a göndermek, fonunuzun botlar tarafından çalınmasına neden olur. Sırlarınızı sakladığınızdan emin olun … :)

Şimdi özel anahtarımızı almamız gerekiyor, bunun için bir kripto cüzdanına ihtiyacınız olacak .

Cüzdanınızın Özel Anahtarını Alın

Bu eğitimde, en yaygın kullanılanlardan biri ve kurulumu kolay olduğu için MetaMask’ı kullanacağız. Halihazırda MetaMask kurulu değilse, MetaMask cüzdanınızı oluşturun.

Kurulduktan sonra MetaMask uzantınıza gidin ve:

Metamask cüzdana giriş yaptıktan sonra üç nokta menüsüne tıklayın,
“Hesap ayrıntıları”na tıklayın,
“Özel Anahtarı Dışa Aktar”a tıklayın,
Parolanızı girin,
ve özel anahtarınızı kopyalayın.

Özel Anahtarı .env dosyasına kaydedin

. env dosyasını proje klasörümüze ekleyin ve yeni bir değişken tanımlayın, “PRIVATE_VARIABLE” olarak adlandırın ve ona özel anahtarınızın değerini atayın:

PRIVATE_KEY="YOUR PRIVATE KEY"

hardhat.config.js dosyasını açın ve .env dosyasında bulunan ortam değişkenlerine erişim elde etmek için dotenv’i başlatın. Bunu yapmak için hardhat.config.js dosyanızın başında dotenv’i aşağıdaki gibi içe aktarın:

require('dotenv').config()

Bu kod satırı, projenizde kullanılan dotenv kütüphanesini yükler ve “.env” dosyasındaki ortam değişkenlerini yükler.

require(‘dotenv’) ifadesi, dotenv kütüphanesini projenizin koduna dahil eder. Bu sayede, dotenv kütüphanesi içinde bulunan fonksiyonları ve özellikleri kullanarak, “.env” dosyasındaki ortam değişkenlerini okuyabilirsiniz.

.config() ifadesi ise, dotenv kütüphanesi içinde bulunan bir fonksiyondur. Bu fonksiyon, projenizin çalıştığı dizinde bulunan “.env” dosyasını okur ve dosyadaki ortam değişkenlerini process.env nesnesine atar. Böylece, process.env nesnesi üzerinden ortam değişkenlerine ulaşılabilir ve değerleri kullanılabilir.

Örneğin, aşağıdaki kod örneğinde, “.env” dosyasındaki DB_HOST ortam değişkeninin değeri okunmuş ve “databaseHost” değişkenine atanmıştır:

const dotenv = require('dotenv');

dotenv.config();

const databaseHost = process.env.DB_HOST;

console.log(databaseHost);

Şimdi, module.exports nesnesinin içinde , ‘url’ özelliğinin hemen altında, Token Smart sözleşmemizi dağıtmak için kullanmak istediğimiz hesabı ekleyin:

module.exports = {
  solidity: "0.8.4",
  networks:{
    mumbai:{
      url: 'YOUR ALCHEMY POLYGON MUMBAI ENDPOINT',
      accounts: [`0x${process.env.PRIVATE_KEY}`]
    }
  }
};

Bu yapılandırma dosyası, Hardhat araç kitinin Mumbai ağında bulunan bir smart contract’ı derleme ve dağıtma işlemleri için kullanılacağını belirtir.

solidity: “0.8.4” ifadesi, Hardhat araç kitinin Mumbai ağında bulunan bir smart contract’ın Solidity dilinin 0.8.4 sürümünü kullanacağını belirtir. Bu sayede, derleyici Mumbai ağında bulunan smart contract’ı bu sürümde derleyebilir.

networks:{ … } bloğu, Mumbai ağı ile ilgili bilgileri içerir. Bu bloğun içinde, Mumbai ağına bağlanmak için gerekli olan url bilgisi ve bu ağda kullanılacak olan Ethereum hesaplarının private keyleri belirtilir.

url: ‘YOUR ALCHEMY POLYGON MUMBAI ENDPOINT’ ifadesi, Mumbai ağına bağlanmak için kullanılacak olan HTTP bağlantı noktasını belirtir. Bu bağlantı noktası, Mumbai ağının kurulu olduğu makine veya sunucunun IP adresini ve port numarasını içerir. Bu bilgi, Mumbai ağının kurulu olduğu makine veya sunucudan alınır ve bu ifadeye yazılır.

accounts: [0x${process.env.PRIVATE_KEY}] ifadesi ise, Mumbai ağında bulunan bir smart contract’ı derleme ve dağıtma işlemleri sırasında kullanılacak olan Ethereum hesaplarının private keylerini belirtir. Bu ifade, process.env nesnesi üzerinden PRIVATE_KEY ortam değişkeninin değerini okur ve bu değerin önüne “0x” ekleyerek döndürür. Böylece, Mumbai ağında bulunan bir smart contract’ı derleme ve dağıtma işlemleri sırasında kullanılacak olan Ethereum hesabının private keyi belirlenmiş olur.

Bu yapılandırma dosyası sayesinde, Hardhat araç kiti Mumbai ağında bulunan bir smart contract’ı derleyebilir ve bu smart contract’ı Mumbai ağına dağıtabilir. Ayrıca, Mumbai ağında bulunan bir smart contract’ın özelliklerini (örneğin balance, owner, symbol gibi) okuyabilir ve bu smart contract’a fon yatırılmasını sağlayabilir. Bu sayede, Mumbai ağında bulunan bir smart contract’ı test etmek ve geliştirme sürecine dahil etmek için gerekli olan tüm işlemleri yapabilirsiniz.

Fark edebileceğiniz gibi, JavaScript dize değişmezlerini kullanarak özel anahtarımıza ‘0x’ ekledik, çünkü Hardhat özel anahtar olarak 0x ile başlayan bir Hexadecimal dize beklerken, MetaMask ise verilen ön eki vererek onu kaldırır.

Ayrıca process.env.NAME_OF_VAR kullanarak PRIVATE_KEY değişkenimize erişiyoruz .

Bu noktada hardhat.config.js dosyamız şöyle görünmelidir:

require("@nomiclabs/hardhat-waffle");
require('dotenv').config()

task("accounts", "Prints the list of accounts", async (taskArgs, hre) => {
  const accounts = await hre.ethers.getSigners();

  for (const account of accounts) {
    console.log(account.address);
  }
});


module.exports = {
  solidity: "0.8.4",
  networks:{
    mumbai:{
      url: 'https://polygon-mumbai.g.alchemy.com/v2/jD_n5-Vt3zoIDgZX8ui1mtAueDGh4TQn',
      accounts: [`0x${process.env.PRIVATE_KEY}`]
    }
  }
};

Bu kod parçası, Hardhat araç kitinin Mumbai ağında bulunan hesapların listesini yazdırmak için bir task oluşturur. Bu task, konsol üzerinden “hardhat accounts” komutunu çalıştırdığınızda çalışır ve Mumbai ağında bulunan hesapların listesini yazdırır.

“accounts” taskı, “task” fonksiyonu ile tanımlanır ve bu fonksiyonun ilk argümanı task’ın adı, ikinci argümanı task’ın açıklaması ve üçüncü argümanı da task’ın nasıl çalıştırılacağını belirten bir fonksiyondur.

Bu task içinde, ilk olarak hre (Hardhat Runtime Environment) nesnesi üzerinden ethers modülü çağrılır ve getSigners() fonksiyonu çağrılır. Bu fonksiyon, Mumbai ağında bulunan tüm Ethereum hesaplarının listesini döndürür. Daha sonra, döndürülen hesaplar listesi döngü içinde dolaşılarak, her bir hesap için hesap adresi yazdırılır.

Harika! Hardhat.config.js dosyamız, sözleşmemizi Polygon üzerinde dağıtmaya hazır. Artık Token kodunu REMIX’ten yerel geliştirici ortamımıza taşımanın ve konuşlandırma betiğini değiştirmenin zamanı geldi.

Projemize OpenZeppelin’i kurarak başlayalım.

Token Akıllı Sözleşmeyi Projenize Ekleyin

Öncelikle projemize OpenZeppelin kurmamız gerekecek .

Terminalde, proje klasörünün içine şunu yazın:

yarn add @openzeppelin/contracts

Bu kod satırı, OpenZeppelin kütüphanesinin contractlarını projenize dahil etmek için kullanılır. OpenZeppelin, Ethereum blok zincirine yönelik smart contract geliştirme için kullanılabilecek bir kütüphanedir. Bu kütüphane, Ethereum blok zincirinde bulunan standart protokol ve kontratların temel yapılarını (örneğin ERC20, ERC721 gibi) kapsar ve bu yapıların kullanımını kolaylaştırır.

Kurulduktan sonra projemizin “contracts” klasörüne gidin ve Token.sol adlı yeni bir dosya oluşturun . REMIX’e geri dönün, birkaç paragraf önce yazdığımız Token.sol Contract kodunu kopyalayın ve yeni yerel Token.sol dosyasına yapıştırın .

Not : Token’ı eğitim amacıyla sabit bir tedarikle kullanacağız, aynısı tüm sözleşmeler için geçerli olacaktır.

Kod aşağıdaki gibi görünmelidir:

// SPDX-License-Identifier: GPL-3.0

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract DevToken is ERC20{
    constructor(uint256 totalSupply) ERC20("DevToken", "DVT"){
        _mint(msg.sender, totalSupply);
    }
}

Bu kod parçası, Ethereum blok zincirinde bir ERC20 standartına uygun token contract’ı oluşturmak için kullanılır. Bu contract, “DevToken” adında ve “DVT” sembolüyle bir token oluşturur ve tokenin toplam arzını (totalSupply) constructor fonksiyonuna gönderilen argüman olarak belirler.

Bu contract içinde, “_mint” adlı bir fonksiyon çağrılır ve bu fonksiyon, “msg.sender” adresine ve toplam arz değeri kadar token dağıtır. “msg.sender” adresi, contract’ı çağıran hesap adresidir. Bu sayede, contract’ı çağıran hesap adresine toplam arz kadar token dağıtılmış olur.

Bu contract, Solidity dilinin en son sürümü olan 0.8.0 sürümü ile derlenmelidir. Bu nedenle, “pragma solidity ^0.8.0;” ifadesi ile Solidity sürümü belirtilmiştir. Ayrıca, contract içinde OpenZeppelin kütüphanesinin ERC20 standartına uygun bir token contract’ı (“@openzeppelin/contracts/token/ERC20/ERC20.sol”) import edilmiştir. Bu import ifadesi sayesinde, ERC20 standartına uygun olarak yapılandırılmış bir token contract’ı oluşturulmuş olur.

Gelin şimdi dağıtım komut dosyasını değiştirmemiz gerekiyor.

Dağıtım Komut Dosyasını Değiştirin

Proje dizini içindeki “scripts” klasöründe sample-script.js’yi “deploy.js” olarak yeniden adlandırın ve açın.

Deployment.js içeriğini aşağıdaki kodla değiştirin:

const hre = require("hardhat");

async function main() {
  const DevToken = await hre.ethers.getContractFactory("DevToken");
  const devToken = await DevToken.deploy("1000000000000000000000000000");

  await devToken.deployed();

  console.log("Token deployed to:", devToken.address);
}

main()
  .then(() => process.exit(0))
  .catch((error) => {
    console.error(error);
    process.exit(1);
  });

Bu kod parçası, yazdığınız DevToken contract’ını Ethereum blok zincirine deploy etmek için kullanılır. Bu script içinde aşağıdaki adımlar gerçekleştirilir:

İlk olarak, Hardhat araç kitinin “hardhat” modülü çağrılır ve bir değişkene atanır. Bu sayede, daha sonra Hardhat araç kitinin fonksiyonlarını kullanabilmek için “hre” değişkenine ihtiyaç duyulur.
Daha sonra, “getContractFactory” fonksiyonu ile DevToken contract’ının bir factory nesnesi oluşturulur. Bu factory nesnesi, DevToken contract’ının deploy edileceği ağı ve contract’ın bytecode’unu (contract’ın Ethereum blok zincirine yüklenmesi için gerekli olan kod) içerir.
Factory nesnesi üzerinden “deploy” fonksiyonu çağrılarak, DevToken contract’ı deploy edilir ve contract’ın toplam arzı olarak “1000000000000000000000000000” değeri (1 milyar) gönderilir. Bu sayede, DevToken contract’ının toplam arzı 1 milyar olur.
“deployed” fonksiyonu ile contract’ın deploy işleminin tamamlandığı kontrol edilir. Bu fonksiyon, contract’ın deploy işleminin tamamlandığını gösteren bir Promise döndürür.
Eğer contract deploy işlemi başarılı bir şekilde tamamlanmışsa, contract’ın adresi yazdırılır ve script çalışması sonlandırılır. Eğer contract deploy işlemi sırasında bir hata oluşmuşsa, hata mesajı yazdırılır ve script çalışması sonlandırılır.

Özetlersek;

Her şeyden önce, getContractFactory() gibi yardımcı programlara erişmemizi sağlayacak olan Hardhat kütüphanesini içe aktarıyoruz. Bir zaman uyumsuz işlev bildiririz ve belirteci, Token yapıcısında gereken totalSupply değerini bir argüman olarak iletiriz.

Fark edebileceğiniz gibi, totalSupply bir dize olarak iletilir (“1000000000000000000000000000”) çünkü değer JavaScript tarafından izin verilen maksimum int değerini aşıyor.

Son olarak, devToken’ın konuşlandırılmasını ve adresini yazdırmasını bekliyoruz.

Son birkaç satır sadece main() işlevini çağırıyor ve hata durumunda çıkıyor.

Artık kripto para birimimizi derlemek ve dağıtmak için her şey hazır.

Kendi Kripto Para Biriminizi Derleyin ve Polygon Mumbai’ye Dağıtın

Her şeyden önce, REMIX’te yaptığımız gibi, Eserleri almak için Token Sözleşmemizi derlememiz ve deploy.js’deki getContractFactory() işlevinin sözleşmemizi almasına izin vermemiz gerekecek.

Terminalde şunu çalıştırın:

npx hardhat compile

Bu komut, projenizdeki Solidity dosyalarını derlemek için kullanılır. Bu komut, projenizdeki tüm Solidity dosyalarını tarar ve bu dosyaları derler. Derleme işlemi sırasında, Solidity dosyalarındaki kod, Ethereum Virtual Machine (EVM) koduna çevrilir ve bu kod, Ethereum blok zincirine yüklenmek üzere hazır hale getirilir.

Derleme işlemi sırasında, her bir Solidity dosyası için bir .json dosyası oluşur. Bu .json dosyaları, derlenmiş Solidity kodunun bytecode’unu (EVM kodunu) ve ABI’sini (Application Binary Interface) içerir. Bytecode, Ethereum blok zincirine yüklenmek üzere oluşturulan contract’ın kodudur ve ABI ise, contract’ın fonksiyonlarının nasıl çağrılabileceğini ve bu fonksiyonların argümanlarının nasıl verileceğini belirtir. Bu .json dosyaları, contract’ın deploy edilebilmesi ve contract’ın fonksiyonlarının çağrılması için gereklidir.

Bu komut, projenizdeki Solidity dosyalarını derlemeniz için kullanılır. Bu komutu çalıştırdıktan sonra, projenizin “build” dizininde derlenmiş Solidity dosyalarının .json dosyaları bulunur.

Özetle; bu satır, proje kökünde eserler adı verilen yeni bir klasör oluşturur ve onu Token’ımızın derlenmiş sürümüyle doldurur.

Son olarak, sözleşmemizi devreye almamız gerekecek, ancak bunu yapmak için Gaz ücretlerini ödemek için biraz MATIC’e ihtiyacımız olacak. Endişelenmeyin, bir kuruş harcamayacağız, bu yüzden bir test ağında konuşlandırıyoruz.

Kripto para biriminizi dağıtmak için Test MATIC’i edinin

Biraz test MATIC almak çok basit:

faucet.polygon.technology adresine gidin .
Bombay ağını seçin.
Cüzdan adresinizi yapıştırın.
“Gönder”e tıklayın.
Test ağı için MATIC’lerin cüzdanınıza aktarıldığını görmek için bir dakika kadar bekleyin.

Polygon Faucet - Bir ERC20 Simgesi Nasıl Oluşturulur ve Dağıtılır? — Polygon Faucet – *Bir ERC20 Simgesi Nasıl Oluşturulur ve Dağıtılır*?

Artık Token Sözleşmemizi uygulamak için yeterli MATIC’e sahibiz.

Polygon Mumbai’de ERC20 Jetonu Nasıl Dağıtılır?

Proje klasörünüze geri dönün ve terminalde aşağıdaki betiği çalıştırın:

npx hardhat run ./scripts/deploy.js --network mumbai

Bu komut, projenizdeki deploy.js script’ini çalıştırmak için kullanılır. Bu script, DevToken contract’ını Ethereum blok zincirine deploy etmek için kullanılır. Bu script içinde, DevToken contract’ının bir factory nesnesi oluşturulur ve bu factory nesnesi üzerinden contract deploy edilir. Ayrıca, deploy işleminin tamamlandığı kontrol edilir ve contract’ın adresi yazdırılır.

Bu komut ile birlikte, “–network mumbai” argümanı da verilmiştir. Bu argüman, deploy edilecek ağın Mumbai ağı olduğunu belirtir. Bu sayede, DevToken contract’ı Mumbai ağına deploy edilir.

Bu komutu çalıştırdıktan sonra, DevToken contract’ı Mumbai ağına deploy edilir ve contract’ın adresi yazdırılır. Eğer deploy işlemi sırasında bir hata oluşmuşsa, hata mesajı yazdırılır.

Özetle; Burada Hardhat’a, ayarları hardhat.config.js dosyasında belirtilen Mumbai ağını kullanarak konuşlandırma betiğimizi çalıştırmasını söylüyoruz.

Birkaç saniye sonra Mumbai ağındaki Token Adresinin terminalde oturum açmış olduğunu görmelisiniz:

ERC Deploy – Polygon Faucet – Bir ERC20 Simgesi Nasıl Oluşturulur ve Dağıtılır?

Mükemmel ! Az önce ilk Kripto Paranızı Blockchain’e yerleştirdiniz!

Her şey beklendiği gibi çalıştıysa, artık MetaMask cüzdanınızda yeni oluşturulan kripto para biriminizi ve basılan jeton miktarını görmeli veya DApp’inizde onlarla etkileşime geçmelisiniz.

İlk olarak, MetaMask’a jetonumuzu nasıl bulacağını söylememiz gerekecek.

ERC20 Simgenizi MetaMask’a Ekleyin

Kendi ERC20 Toke’unuzu Metamask üzerinde görselleştirmek için iki adım vardır, bunu yapın:

Polygon Mumbai’yi MetaMask’a ekleyin.
Yeni Jetonu Metamask’a ekleyin.

Yeni bir Custom Token eklemek ise çok basit, bakalım nasıl olacak.

Jetonumuzu dağıttığımızda, zincir üzerindeki adresini terminalde kaydettik, kopyalayalım ve MetaMask’a geçelim:

Mumbai Testnet’te olduğunuzdan emin olun
MetaMask uzantısının en altına gidin
“Jetonları İçe Aktar”a tıklayın
Belirteç Adresinizi yapıştırın
“Özel Belirteç Ekle”ye tıklayın

Fark edebileceğiniz gibi, MetaMask Token Sembolünü ve ondalık sayıları otomatik olarak tanıyacaktır.

Yaptık! Az önce ilk kripto para biriminizi dağıttınız, tebrikler!

Sonuç Bağlamı : ERC-20 Tokeni Nasıl Oluşturulur ve Dağıtılır?

Umarım bir ERC20 belirtecini nasıl oluşturacağınızı ve konuşlandıracağınızı artık öğrenebilmişsinizdir. Eğer halen zorlanıyorsanız bu normaldir, adımları tekrar tekrar ilerleterek bu alanda ki yetinizi geliştirebilirisniz.

Ayrıca, kariyerinize başlamak için her gün en iyi Solidity Öğren kaynaklarını almak üzere e-bültenimize abone olmayı unutmayın .

Zero To Hero : Web3.0 ve Solidity Geliştirme Yol Haritası 2023

Akıllı sözleşme geliştirme yolculuğunuz hakkında daha iyi rehberlik almak için Solidity nedir? Ethereum Akıllı Sözleşmelerinin Dili Rehberi içeirğimize göz atın. Dilerseniz Yeni Başlayanlar için Solidity – Akıllı Sözleşme Geliştirme Hızlandırılmış Kursuna katılın.

Çalışmaya nereden başlayacğaım diyenler için Blockchain Developer Olmak İçin Yol Haritası içeriğine de muhakkak bakın.

Bu makaleyi okuduğunuz için teşekkürler! Bana destek olmak isterseniz;

Beni Twitter, Linkedin ve YouTube‘da takip edin.

Kısa bir yorum bırakmayı UNUTMAYIN!

Post Views: 422