Akış ve Ritim Kullanarak Dijital Koleksiyon Portalı Nasıl Oluşturulur (Bölüm 1)

Bu eğitimde, blockchain Flow'da dijital koleksiyon öğeleri (veya NFT'ler) toplamak için bir web sitesinin nasıl oluşturulacağını öğreneceğiz. Tüm bunları gerçekleştirmek için akıllı sözleşme dili Cadence'i React ile birlikte kullanacağız. Ayrıca Flow'u, avantajlarını ve kullanabileceğimiz eğlenceli araçları da öğreneceğiz.

Bu makalenin sonunda, Flow blockchain üzerinde kendi merkezi olmayan uygulamanızı oluşturmak için ihtiyaç duyduğunuz araç ve bilgilere sahip olacaksınız.

Haydi hemen dalalım!

Ne İnşa Ediyoruz?

Dijital koleksiyonlara yönelik bir uygulama geliştiriyoruz. Her koleksiyon parçası bir Değiştirilemez Tokendır (NFT). (Yeniyseniz ve NFT'yi anlamıyorsanız buraya bir göz atın.) Uygulamamız NFT'leri toplamanıza olanak tanıyacak ve her öğe diğerlerinden benzersiz olacaktır.

Tüm bunların işe yaraması için, bu özel dijital öğeleri (Ethereum'daki ERC-721'e benzer) yönetmemize yardımcı olan bir dizi kural olan Flow'un NonFungibleToken Standardını kullanacağız.

Önkoşullar

Başlamadan önce sisteminize Flow CLI'yi yüklediğinizden emin olun. Henüz yapmadıysanız bu kurulum talimatlarını izleyin.

Kurulum

Projenizi başlatmaya hazırsanız öncelikle komut akışı kurulumunu yazın.

Bu komut, projenizin temelini oluşturmak için perde arkasında bazı sihirler yapar. Bir klasör sistemi oluşturur ve projenizi yapılandırmak için flow.json adlı bir dosya kurar, her şeyin düzenli ve kullanıma hazır olmasını sağlar!

Proje Yapısı

Proje bir cadence klasörü ve flow.json dosyası içerecektir. (Flow.json dosyası, projeniz için otomatik olarak tutulan bir yapılandırma dosyasıdır.)

Cadence klasörü aşağıdakileri içerir:

• /sözleşmeler: Tüm Cadence sözleşmelerini içerir.
• /scripts: Tüm Cadence komut dosyalarını tutar.
• /transactions: Tüm Cadence işlemlerini saklar.

Flow NFT Standardını kullanmak için aşağıdaki adımları izleyin.

Adım 1: Bir Dosya Oluşturun.

Öncelikle flow-collectibles-portal klasörüne gidin ve cadence klasörünü bulun. Daha sonra contracts klasörünü açın. Yeni bir dosya oluşturun ve onu NonFungibleToken.cdc olarak adlandırın.

Adım 2: Kopyala ve Yapıştır.

Şimdi NFT standardını içeren NonFungibleToken adlı bağlantıyı açın. Bu dosyadaki tüm içeriği kopyalayın ve az önce oluşturduğunuz yeni dosyaya ("NonFungibleToken.cdc") yapıştırın.

Bu kadar! Projeniz için standartları başarıyla oluşturdunuz.

Şimdi biraz kod yazalım!

Ancak kodlamaya dalmadan önce geliştiricilerin kodlarını nasıl yapılandıracaklarına dair zihinsel bir model oluşturmaları önemlidir.

En üst düzeyde kod tabanımız üç ana bileşenden oluşur:

1. NFT: Her koleksiyon parçası bir NFT olarak temsil edilir.

   
   

2. Koleksiyon: Koleksiyon, belirli bir kullanıcının sahip olduğu bir grup NFT'yi ifade eder.

   
   

3. Global Fonksiyonlar ve Değişkenler: Akıllı sözleşme için global düzeyde tanımlanan ve herhangi bir kaynakla ilişkili olmayan fonksiyon ve değişkenlerdir.

Akıllı Sözleşme Yapısı

Akıllı Sözleşme Temel Yapısı

cadence/contracts içinde Collectibles.cdc adında yeni bir dosya oluşturun. Kodu yazacağımız yer burasıdır.

Sözleşme Yapısı

 import NonFungibleToken from "./NonFungibleToken.cdc" pub contract Collectibles: NonFungibleToken{ pub var totalSupply: UInt64 // other code will come here init(){ self.totalSupply = 0 } }

Kodu satır satır inceleyelim:

1. İlk olarak, "NonFungibleToken" adı verilen öğeyi dahil ederek bir NFT oluşturduğumuzu standartlaştırmamız gerekecek. Bu, Flow tarafından oluşturulan ve her NFT akıllı sözleşmesine dahil edilmesi gereken aşağıdaki işlevsellik kümesini tanımlayan bir NFT standardıdır.

   
   

2. Import ettikten sonra sözleşmemizi oluşturalım. Bunu yapmak için pub contract [contract name] kullanırız. Her yeni sözleşme oluşturduğunuzda aynı sözdizimini kullanın. contract name sözleşmenizi adlandırmak istediğiniz şeyle doldurabilirsiniz. Bizim durumumuzda buna Collectibles diyelim.

   
   

3. Daha sonra, sözleşmemizin NonFungibleToken'in belirli işlevsellik ve kurallarına uygun olduğundan emin olmak istiyoruz. Bunu yapmak için `:` yardımıyla NonFungibleToken arayüzünü ekliyoruz.
   Bunun gibi ( `pub contract Collectibles: NonFungibleToken{}` )

   
   

4. Her sözleşmenin init() fonksiyonuna sahip olması ZORUNLUDUR . Sözleşme ilk kez dağıtıldığında çağrılır. Bu, Solidity'nin Yapıcı dediği şeye benzer.

   
   

5. Şimdi totalSupply adında UInt64 veri tipinde global bir değişken oluşturalım. Bu değişken toplam Koleksiyon Öğelerinizi takip edecektir.

   
   

6. Şimdi totalSupply değerini 0 değeriyle başlatın.

Bu kadar! Collectibles sözleşmemizin temelini oluşturduk. Artık oyunu daha da heyecanlı hale getirmek için daha fazla özellik ve işlevsellik eklemeye başlayabiliriz.

İlerlemeden önce lütfen Cadence'de değişkenleri nasıl tanımladığımızı anlamak için kod pasajına göz atın:

Kaynak NFT'si

Akıllı sözleşmenize aşağıdaki kodu ekleyin:

 import NonFungibleToken from "./NonFungibleToken.cdc" pub contract Collectibles: NonFungibleToken{ // above code… pub resource NFT: NonFungibleToken.INFT{ pub let id: UInt64 pub var name: String pub var image: String init(_id:UInt64, _name:String, _image:String){ self.id = _id self.name = _name self.image = _image } } // init()... }

Daha önce gördüğünüz gibi sözleşme, pub contract Collectibles: NonFungibleToken tarafından temsil edilen NFT standart arayüzünü uyguluyor. Benzer şekilde kaynaklar da çeşitli kaynak arayüzlerini uygulayabilir.

Öyleyse, NFT Kaynağına, kaynak içinde id adı verilen ortak bir özelliğin varlığını zorunlu kılan NonFungibleToken.INFT arayüzünü ekleyelim.

NFT kaynağında kullanacağımız değişkenler şunlardır:

• id: NFT'nin kimliğini korur
• name: NFT'nin adı.
• image: NFT'nin resim URL'si.

Değişkeni tanımladıktan sonra değişkeni init() işlevinde başlattığınızdan emin olun.

Şimdi ilerleyelim ve Collection Resource adında başka bir kaynak oluşturalım.

Koleksiyon Kaynağı

Öncelikle Collection Resources nasıl çalıştığını anlamanız gerekir.

Dizüstü bilgisayarınızda bir müzik dosyası ve birkaç fotoğraf saklamanız gerekiyorsa ne yapardınız?

Tipik olarak, yerel bir sürücüye (diyelim ki D-Drive'ınıza) gider ve bir music klasörü ve photos klasörü oluşturursunuz. Daha sonra müzik ve fotoğraf dosyalarını kopyalayıp hedef klasörlerinize yapıştırırsınız.

Benzer şekilde, Flow'daki dijital koleksiyonlarınız da bu şekilde çalışır.

Dizüstü bilgisayarınızı bir Flow Blockchain Account , D-Drive'ınızı Account Storage Alanı ve Klasörü bir Collection olarak hayal edin.

Dolayısıyla, NFT satın almak için herhangi bir projeyle etkileşime geçtiğinizde proje, D-Drive'ınızda bir klasör oluşturmaya benzer şekilde kendi collection account storage alanınızda oluşturur. 10 farklı NFT projesiyle etkileşime girdiğinizde hesabınızda 10 farklı koleksiyon elde edeceksiniz.

Eşsiz dijital hazinelerinizi saklayıp organize edebileceğiniz kişisel bir alana sahip olmak gibidir!

 import NonFungibleToken from "./NonFungibleToken.cdc" pub contract Collectibles: NonFungibleToken{ //Above code NFT Resource… // Collection Resource pub resource Collection{ } // Below code… }

Her collection NFT Resources tutacak bir ownedNFTs değişkeni vardır.

 pub resource Collection { pub var ownedNFTs: @{UInt64: NonFungibleToken.NFT} init(){ self.ownedNFTs <- {} } }

Kaynak Arayüzleri

Flow'daki resource arayüzü diğer programlama dillerindeki arayüzlere benzer. Bir kaynağın üzerinde yer alır ve onu uygulayan kaynağın, arayüz tarafından tanımlandığı şekilde gerekli işlevselliğe sahip olmasını sağlar.

Ayrıca kaynağın tamamına erişimi kısıtlamak için de kullanılabilir ve erişim değiştiricileri açısından kaynağın kendisinden daha kısıtlayıcı olabilir.

NonFungibleToken standardında INFT , Provider , Receiver ve CollectionPublic gibi çeşitli kaynak arayüzleri vardır.

Bu arayüzlerin her birinin, onları kullanan kaynak tarafından uygulanması gereken belirli işlevleri ve alanları vardır.

Bu sözleşmede NonFungibleToken: Provider , Receiver ve CollectionPublic . Bu arayüzler deposit , withdraw , borrowNFT ve getIDs gibi işlevleri tanımlar. İlerledikçe bunların her birini ayrıntılı olarak açıklayacağız.

Ayrıca bu işlevlerden çıkaracağımız bazı olayları ekleyeceğiz ve öğreticinin ilerleyen kısımlarında kullanacağımız bazı değişkenleri de bildireceğiz.

 pub contract Collectibles:NonFungibleToken{ // rest of the code… pub event ContractInitialized() pub event Withdraw(id: UInt64, from: Address?) pub event Deposit(id: UInt64, to: Address?) pub let CollectionStoragePath: StoragePath pub let CollectionPublicPath: PublicPath pub resource interface CollectionPublic{ pub fun deposit(token: @NonFungibleToken.NFT) pub fun getIDs(): [UInt64] pub fun borrowNFT(id: UInt64): &NonFungibleToken.NFT } pub resource Collection: CollectionPublic, NonFungibleToken.Provider, NonFungibleToken.Receiver, NonFungibleToken.CollectionPublic{ pub var ownedNFTs: @{UInt64: NonFungibleToken.NFT} init(){ self.ownedNFTs <- {} } } }

Geri çekilmek

Şimdi arayüzün gerektirdiği withdraw() fonksiyonunu oluşturalım.

 pub resource Collection: CollectionPublic, NonFungibleToken.Provider, NonFungibleToken.Receiver, NonFungibleToken.CollectionPublic{ // other code pub fun withdraw(withdrawID: UInt64): @NonFungibleToken.NFT { let token <- self.ownedNFTs.remove(key: withdrawID) ?? panic("missing NFT") emit Withdraw(id: token.id, from: self.owner?.address) return <- token } init()... }

Bu fonksiyonun yardımıyla NFT kaynağını koleksiyonun dışına taşıyabilirsiniz. Eğer o:

• Başarısız : Panik yapar ve hata verir.

• Başarılı : Bir çekilme olayı yayar ve kaynağı arayana geri döndürür.

Arayan kişi daha sonra bu kaynağı kullanabilir ve kendi hesap deposuna kaydedebilir.

Depozito

Şimdi NonFungibleToken.Receiver gerektirdiği deposit() fonksiyonunun zamanı geldi.

 pub resource Collection: CollectionPublic, NonFungibleToken.Provider, NonFungibleToken.Receiver, NonFungibleToken.CollectionPublic{ // other code pub fun withdraw(withdrawID: UInt64): @NonFungibleToken.NFT { let token <- self.ownedNFTs.remove(key: withdrawID) ?? panic("missing NFT") emit Withdraw(id: token.id, from: self.owner?.address) return <- token } pub fun deposit(token: @NonFungibleToken.NFT) { let id = token.id let oldToken <- self.ownedNFTs[id] <-token destroy oldToken emit Deposit(id: id, to: self.owner?.address) } init()... }

Ödünç al ve GetID

Şimdi NonFungibleToken.CollectionPublic: borrowNFT() ve getID() .

 pub resource Collection: CollectionPublic, NonFungibleToken.Provider, NonFungibleToken.Receiver, NonFungibleToken.CollectionPublic{ // other code pub fun withdraw(withdrawID: UInt64): @NonFungibleToken.NFT { let token <- self.ownedNFTs.remove(key: withdrawID) ?? panic("missing NFT") emit Withdraw(id: token.id, from: self.owner?.address) return <- token } pub fun deposit(token: @NonFungibleToken.NFT) { let id = token.id let oldToken <- self.ownedNFTs[id] <-token destroy oldToken emit Deposit(id: id, to: self.owner?.address) } pub fun borrowNFT(id: UInt64): &NonFungibleToken.NFT { if self.ownedNFTs[id] != nil { return (&self.ownedNFTs[id] as &NonFungibleToken.NFT?)! } panic("NFT not found in collection.") } pub fun getIDs(): [UInt64]{ return self.ownedNFTs.keys } init()... }

Yıkıcı

Koleksiyon Kaynağı için ihtiyacımız olan son şey bir yıkıcıdır.

 destroy (){ destroy self.ownedNFTs }

Koleksiyon kaynağı başka kaynaklar (NFT kaynakları) içerdiğinden bir yıkıcı belirtmemiz gerekir. Nesne yok edildiğinde bir yıkıcı çalışır. Bu, ana kaynakları yok edildiğinde kaynakların "evsiz" kalmamasını sağlar. NFT kaynağı başka bir kaynak içermediğinden dolayı bir yıkıcıya ihtiyacımız yok.

Koleksiyon kaynağı kaynak kodunun tamamına bakalım:

 import NonFungibleToken from "./NonFungibleToken.cdc" pub contract Collectibles: NonFungibleToken{ pub var totalSupply: UInt64 pub resource NFT: NonFungibleToken.INFT{ pub let id: UInt64 pub var name: String pub var image: String init(_id:UInt64, _name:String, _image:String){ self.id = _id self.name = _name self.image = _image } } pub resource interface CollectionPublic{ pub fun deposit(token: @NonFungibleToken.NFT) pub fun getIDs(): [UInt64] pub fun borrowNFT(id: UInt64): &NonFungibleToken.NFT } pub event ContractInitialized() pub event Withdraw(id: UInt64, from: Address?) pub event Deposit(id: UInt64, to: Address?) pub let CollectionStoragePath: StoragePath pub let CollectionPublicPath: PublicPath pub resource Collection: CollectionPublic, NonFungibleToken.Provider, NonFungibleToken.Receiver, NonFungibleToken.CollectionPublic{ pub var ownedNFTs: @{UInt64: NonFungibleToken.NFT} init(){ self.ownedNFTs <- {} } destroy (){ destroy self.ownedNFTs } pub fun withdraw(withdrawID: UInt64): @NonFungibleToken.NFT { let token <- self.ownedNFTs.remove(key: withdrawID) ?? panic("missing NFT") emit Withdraw(id: token.id, from: self.owner?.address) return <- token } pub fun deposit(token: @NonFungibleToken.NFT) { let id = token.id let oldToken <- self.ownedNFTs[id] <-token destroy oldToken emit Deposit(id: id, to: self.owner?.address) } pub fun borrowNFT(id: UInt64): &NonFungibleToken.NFT { if self.ownedNFTs[id] != nil { return (&self.ownedNFTs[id] as &NonFungibleToken.NFT?)! } panic("NFT not found in collection.") } pub fun getIDs(): [UInt64]{ return self.ownedNFTs.keys } } init(){ self.CollectionPublicPath = /public/NFTCollection self.CollectionStoragePath = /storage/NFTCollection self.totalSupply = 0 emit ContractInitialized() } }

Artık tüm kaynakları bitirdik. Daha sonra global fonksiyona bakacağız.

Küresel İşlev

Küresel İşlevler, akıllı sözleşmenin küresel düzeyinde tanımlanan işlevlerdir; yani herhangi bir kaynağın parçası değildirler. Bunlara halk tarafından erişilebiliyor ve çağrılabiliyor ve akıllı sözleşmenin temel işlevlerini halka açık hale getiriyor.

1. createEmptyCollection : Bu işlev, arayan hesabı deposunda boş bir Collectibles.Collection başlatır.

   
   

2. checkCollection : Bu kullanışlı işlev, hesabınızda halihazırda bir collection kaynağının olup olmadığını keşfetmenize yardımcı olur.

   
   

3. mintNFT : Bu işlev çok harika çünkü herkesin NFT oluşturmasına olanak tanıyor.

 // pub resource Collection… pub fun createEmptyCollection(): @Collection{ return <- create Collection() } pub fun checkCollection(_addr: Address): Bool{ return getAccount(_addr) .capabilities.get<&{Collectibles.CollectionPublic}> (Collectibles.CollectionPublicPath)! .check() } pub fun mintNFT(name:String, image:String): @NFT{ Collectibles.totalSupply = Collectibles.totalSupply + 1 let nftId = Collectibles.totalSupply var newNFT <- create NFT(_id:nftId, _name:name, _image:image) return <- newNFT } init()...

Akıllı Sözleşmeyi Tamamlamak

Ve şimdi, SONUNDA her şey yerli yerinde olduğundan akıllı sözleşmemizi yazmayı bitirdik. Buradaki son koda bir göz atın.

Şimdi bir kullanıcının Flow blockchain üzerinde konuşlandırılan akıllı sözleşmelerle nasıl etkileşime girdiğine bakalım.

Flow blockchain ile etkileşime geçmek için iki adım vardır:

1. İşlemleri çalıştırarak durumu değiştirin.
2. Bir komut dosyası çalıştırarak blockchain'i sorgulayın.

İşlemleri Çalıştırarak Durumu Değiştirin

İşlemler, Akış durumunu güncellemek için akıllı sözleşmeyle etkileşime giren bir dizi talimat içeren kriptografik olarak imzalanmış verilerdir. Basit bir ifadeyle bu, blok zincirindeki verileri değiştiren bir işlev çağrısına benzer. İşlemler genellikle, bulunduğunuz blok zincirine bağlı olarak değişebilen bir miktar maliyet içerir.

Bir işlem birden fazla isteğe bağlı aşamayı içerir: prepare , pre , execute ve post aşama.

Bu konuda daha fazla bilgiyi işlemlere ilişkin Cadence referans belgesinde okuyabilirsiniz . Her aşamanın bir amacı vardır; En önemli iki aşama prepare ve execute .

Prepare Phase : Bu aşama, imzalayanın hesabındaki verilere ve bilgilere erişmek için kullanılır (AuthAccount türü tarafından izin verilir).

Execute Phase : Bu aşama eylemleri yürütmek için kullanılır.

Şimdi projemiz için bir transaction oluşturalım.

Proje klasörünüzde bir işlem oluşturmak için aşağıdaki adımları izleyin.

Adım 1: Bir Dosya Oluşturun.

Öncelikle proje klasörüne gidin ve cadence klasörünü açın. İçinde transaction klasörünü açın ve Create_Collection.cdc ve mint_nft.cdc adında yeni bir dosya oluşturun.

Adım 2: Tahsilat İşlem Kodu Oluştur'u ekleyin.

 import Collectibles from "../contracts/Collectibles.cdc" transaction { prepare(signer: AuthAccount) { if signer.borrow<&Collectibles.Collection>(from: Collectibles.CollectionStoragePath) == nil { let collection <- Collectibles.createEmptyCollection() signer.save(<-collection, to: Collectibles.CollectionStoragePath) let cap = signer.capabilities.storage.issue<&{Collectibles.CollectionPublic}>(Collectibles.CollectionStoragePath) signer.capabilities.publish( cap, at: Collectibles.CollectionPublicPath) } } }

Bu kodu satır satır inceleyelim:

1. Bu işlem, Koleksiyon akıllı sözleşmesiyle etkileşime girer. Ardından, Collectibles.CollectionStoragePath belirtilen depolama yolundan Koleksiyon kaynağına bir referans ödünç alarak gönderenin (imzalayanın) hesabında depolanan bir Koleksiyon kaynağı olup olmadığını kontrol eder. Referans sıfırsa imzalayanın henüz bir koleksiyonu olmadığı anlamına gelir.

   
   

2. İmzalayanın bir koleksiyonu yoksa createEmptyCollection() işlevini çağırarak boş bir koleksiyon oluşturur.

   
   

3. Boş koleksiyonu oluşturduktan sonra, bunu Collectibles.CollectionStoragePath belirtilen depolama yolu altındaki imzalayanın hesabına yerleştirin.

Bu, imzalayanın hesabı ile link() kullanılarak yeni oluşturulan koleksiyon arasında bir bağlantı kurar.

Adım 3: Mint NFT İşlem Kodunu ekleyin.

 import NonFungibleToken from "../contracts/NonFungibleToken.cdc" import Collectibles from "../contracts/Collectibles.cdc" transaction(name:String, image:String){ let receiverCollectionRef: &{NonFungibleToken.CollectionPublic} prepare(signer:AuthAccount){ self.receiverCollectionRef = signer.borrow<&Collectibles.Collection>(from: Collectibles.CollectionStoragePath) ?? panic("could not borrow Collection reference") } execute{ let nft <- Collectibles.mintNFT(name:name, image:image) self.receiverCollectionRef.deposit(token: <-nft) } }

Bu kodu satır satır inceleyelim:

1. Öncelikle NonFungibleToken ve Collectibles contract içe aktarıyoruz.

   
   

2. transaction(name: String, image: String) Bu satır yeni bir işlemi tanımlar. Her ikisi de String türünden iki bağımsız değişken, ad ve görüntü alır. Bu bağımsız değişkenler, basılan NFT'nin adını ve görüntüsünü iletmek için kullanılır.

   
   

3. let receiverCollectionRef: &{NonFungibleToken.CollectionPublic} Bu satır yeni bir receiverCollectionRef. NonFungibleToken.CollectionPublic türündeki genel NFT koleksiyonuna bir referanstır. Bu referans, yeni basılan NFT'yi depolayacağımız koleksiyonla etkileşimde bulunmak için kullanılacaktır.

   
   

4. prepare(signer: AuthAccount) Bu satır, işlemden önce yürütülen hazırlama bloğunu başlatır. AuthAccount türünde bir bağımsız değişken imzalayanı alır. AuthAccount işlemi imzalayanın hesabını temsil eder.

   
   

5. İmzalayanın hazırlama bloğu içindeki deposundan Collectibles.Collection bir referans ödünç alır. Koleksiyonun referansına erişmek ve bunu receiverCollectionRef değişkeninde saklamak için ödünç alma işlevini kullanır.

   
   

   Referans bulunamazsa (örneğin koleksiyon imzalayanın deposunda mevcut değilse), "Koleksiyon referansı ödünç alınamadı" hata mesajını verir.

   
   

6. execute bloğu, işlemin ana yürütme mantığını içerir. Bu bloğun içindeki kod, prepare bloğu başarıyla tamamlandıktan sonra yürütülecektir.

   
   

7. nft <- Collectibles.mintNFT(_name: name, image: image) execute bloğunun içinde bu satır, sağlanan ad ve görüntü argümanlarıyla Collectibles sözleşmesinden mintNFT işlevini çağırır. Bu işlevin verilen ad ve görüntüyle yeni bir NFT oluşturması bekleniyor. <- sembolü, NFT'nin taşınabilecek bir nesne (bir kaynak) olarak alındığını gösterir.

   
   

8. self.receiverCollectionRef.deposit(token: <-nft) Bu satır, yeni basılan NFT'yi belirtilen koleksiyona depolar. NFT'nin sahipliğini işlemin yürütme hesabından koleksiyona aktarmak için receiverCollectionRef üzerindeki para yatırma işlevini kullanır. Buradaki <- sembolü aynı zamanda NFT'nin deposit işlemi sırasında kaynak olarak taşındığını da gösterir.

Bir Komut Dosyasını Çalıştırarak Blockchain'i Sorgulayın

Blockchain'deki verileri görüntülemek veya okumak için bir komut dosyası kullanırız. Komut dosyaları ücretsizdir ve imzalanması gerekmez.

Proje klasörünüzde bir komut dosyası oluşturmak için aşağıdaki adımları izleyin.

Adım 1: Bir Dosya Oluşturun.

Öncelikle proje klasörüne gidin ve cadence klasörünü açın. İçinde script klasörünü açın ve view_nft.cdc adında yeni bir dosya oluşturun.

2. Adım: NFT Komut Dosyasını Görüntüleyin

 import NonFungibleToken from "../contracts/NonFungibleToken.cdc" import Collectibles from "../contracts/Collectibles.cdc" pub fun main(user: Address, id: UInt64): &NonFungibleToken.NFT? { let collectionCap= getAccount(user).capabilities .get<&{Collectibles.CollectionPublic}>(/public/NFTCollection) ?? panic("This public capability does not exist.") let collectionRef = collectionCap.borrow()! return collectionRef.borrowNFT(id: id) }

Bu kodu satır satır inceleyelim:

1. Öncelikle NonFungibleToken ve Collectibles sözleşmesini içe aktarıyoruz.

   
   

2. pub fun main(acctAddress: Address, id: UInt64): &NonFungibleToken.NFT? Bu satır, main adında ortak bir işlev olan betiğin giriş noktasını tanımlar. Fonksiyon iki parametre alır:

   
   

• acctAddress : Flow blok zincirindeki bir hesabın adresini temsil eden Address türü parametresi.

  
  

• id : Koleksiyon içindeki NFT'nin benzersiz tanımlayıcısını temsil eden UInt64 tipi bir parametre.

  
  

3. Daha sonra belirtilen acctAddress için Collectibles.Collection yeteneğini getirmek üzere getCapability kullanırız. Yetenek, işlevlerine ve verilerine erişime izin veren bir kaynağa yapılan referanstır. Bu durumda, Collectibles.Collection kaynak türüne yönelik yetenek getiriliyor.

   
   

4. Daha sonra, borrowNFT işlevini kullanarak collectionRef bir NFT ödünç alıyoruz. borrowNFT işlevi, koleksiyon içindeki NFT'nin benzersiz tanımlayıcısı olan id parametresini alır. Bir yetenekteki borrow işlevi, kaynak verilerinin okunmasına olanak tanır.

   
   

5. Son olarak fonksiyondan NFT’yi döndürüyoruz.

Adım 3: Test Ağı Dağıtımı

Artık akıllı sözleşmemizi Flow test ağına dağıtmanın zamanı geldi.

1. Bir Flow hesabı oluşturun.

Flow hesabı oluşturmak için terminalde aşağıdaki komutu çalıştırın:

 flow keys generate

Genel anahtarınızı ve özel anahtarınızı yazdığınızdan emin olun.

Daha sonra şuraya gideceğiz: Akış Musluğu , anahtarlarımıza göre yeni bir adres oluşturun ve hesabımızı bazı test jetonlarıyla finanse edin. Hesabınızı oluşturmak için aşağıdaki adımları tamamlayın:

1. Genel anahtarınızı belirtilen giriş alanına yapıştırın.

   
   

2. İmza ve Karma Algoritmalarını varsayılan olarak ayarlayın.

   
   

3. Captcha'yı tamamlayın.

   
   

4. Hesap Oluştur'a tıklayın.

Hesap oluşturduktan sonra, 1.000 test Flow tokenı içeren yeni Flow adresimizle bir diyalog alıyoruz. İleride kullanabilmemiz için adresi kopyalayın .

2. Projeyi yapılandırın.

Şimdi projemizi yapılandıralım. Başlangıçta projeyi kurduğumuzda bir flow.json dosyası oluşturdu.

Bu, Flow CLI'nin yapılandırma dosyasıdır ve Flow CLI'nin sizin için gerçekleştirebileceği eylemlere ilişkin yapılandırmayı tanımlar. Bunu kabaca Ethereum'daki hardhat.config.js eşdeğer olarak düşünün.

Şimdi kod düzenleyicinizi açın ve aşağıdaki kodu kopyalayıp flow.json dosyanıza yapıştırın.

 { "contracts": { "Collectibles": "./cadence/contracts/Collectibles.cdc", "NonFungibleToken": { "source": "./cadence/contracts/NonFungibleToken.cdc", "aliases": { "testnet": "0x631e88ae7f1d7c20" } } }, "networks": { "testnet": "access.devnet.nodes.onflow.org:9000" }, "accounts": { "testnet-account": { "address": "ENTER YOUR ADDRESS FROM FAUCET HERE", "key": "ENTER YOUR GENERATED PRIVATE KEY HERE" } }, "deployments": { "testnet": { "testnet-account": [ "Collectibles" ] } } }

3. Kopyala ve yapıştır.

Oluşturduğunuz özel anahtarınızı koddaki yere (anahtar: “OLUŞTURULAN ÖZEL ANAHTARINIZI BURAYA GİRİN”) yapıştırın.

4. Uygulamak.

Şimdi kodu test ağında yürütün. Terminale gidin ve aşağıdaki kodu çalıştırın:

 flow project deploy --network testnet

5. Onaylamayı bekleyin.

İşlemi gönderdikten sonra bir işlem kimliği alacaksınız. Akıllı sözleşmenin başarıyla dağıtıldığını belirten işlemin test ağında onaylanmasını bekleyin.

Dağıtılan sözleşmenizi buradan kontrol edin.

GitHub'daki kodun tamamını kontrol edin.

Son Düşünceler ve Tebrikler!

Tebrikler! Artık Flow blok zincirinde bir koleksiyon portalı oluşturdunuz ve bunu test ağına dağıttınız. Sıradaki ne? Artık bu serinin 2. bölümünde ele alacağımız ön yüzü oluşturmaya çalışabilirsiniz.

Gerçekten harika bir gün geçirin!

Burada da yayınlandı