From f8f07aa1c8f34fbf97a1934320b9f07e638874cb Mon Sep 17 00:00:00 2001 From: Lea Lobanov Date: Tue, 10 Dec 2024 17:52:45 +0400 Subject: [PATCH] Linting tx --- cadence/contracts/ExampleNFT.cdc | 65 ++++--------------- cadence/transactions/create_nft_listing.cdc | 72 ++++++++++++--------- 2 files changed, 53 insertions(+), 84 deletions(-) diff --git a/cadence/contracts/ExampleNFT.cdc b/cadence/contracts/ExampleNFT.cdc index 8df0aec..49e614b 100644 --- a/cadence/contracts/ExampleNFT.cdc +++ b/cadence/contracts/ExampleNFT.cdc @@ -8,9 +8,7 @@ access(all) contract ExampleNFT { - // Declare Path constants so paths do not have to be hardcoded - // in transactions and scripts - + // Declare Path constants access(all) let CollectionStoragePath: StoragePath access(all) let CollectionPublicPath: PublicPath access(all) let MinterStoragePath: StoragePath @@ -18,12 +16,8 @@ access(all) contract ExampleNFT { // Tracks the unique IDs of the NFTs access(all) var idCount: UInt64 - // Declare the NFT resource type access(all) resource NFT { - // The unique ID that differentiates each NFT access(all) let id: UInt64 - - // Initialize both fields in the initializer init(initID: UInt64) { self.id = initID } @@ -31,72 +25,43 @@ access(all) contract ExampleNFT { access(all) entitlement Withdraw - // The definition of the Collection resource that - // holds the NFTs that a user owns - access(all) resource Collection { - // dictionary of NFT conforming tokens - // NFT is a resource type with an `UInt64` ID field + // Interface defining required methods for the Collection + access(all) resource interface CollectionInterface { + access(all) fun deposit(token: @NFT) + access(Withdraw) fun withdraw(withdrawID: UInt64): @NFT + access(all) view fun getIDs(): [UInt64] + } + + // Collection resource conforming to CollectionInterface + access(all) resource Collection: CollectionInterface { access(all) var ownedNFTs: @{UInt64: NFT} - // Initialize the NFTs field to an empty collection init () { self.ownedNFTs <- {} } - // withdraw - // - // Function that removes an NFT from the collection - // and moves it to the calling context access(Withdraw) fun withdraw(withdrawID: UInt64): @NFT { - // If the NFT isn't found, the transaction panics and reverts let token <- self.ownedNFTs.remove(key: withdrawID) - ?? panic("Could not withdraw an ExampleNFT.NFT with id=" - .concat(withdrawID.toString()) - .concat("Verify that the collection owns the NFT ") - .concat("with the specified ID first before withdrawing it.")) - + ?? panic("Could not withdraw NFT with id=".concat(withdrawID.toString())) return <-token } - // deposit - // - // Function that takes a NFT as an argument and - // adds it to the collections dictionary access(all) fun deposit(token: @NFT) { - // add the new token to the dictionary with a force assignment - // if there is already a value at that key, it will fail and revert self.ownedNFTs[token.id] <-! token } - // idExists checks to see if a NFT - // with the given ID exists in the collection - access(all) view fun idExists(id: UInt64): Bool { - return self.ownedNFTs[id] != nil - } - - // getIDs returns an array of the IDs that are in the collection access(all) view fun getIDs(): [UInt64] { return self.ownedNFTs.keys } } - // creates a new empty Collection resource and returns it access(all) fun createEmptyCollection(): @Collection { return <- create Collection() } - // mintNFT - // - // Function that mints a new NFT with a new ID - // and returns it to the caller access(all) fun mintNFT(): @NFT { - - // create a new NFT - var newNFT <- create NFT(initID: self.idCount) - - // change the id so that each ID is unique + let newNFT <- create NFT(initID: self.idCount) self.idCount = self.idCount + 1 - return <-newNFT } @@ -105,14 +70,10 @@ access(all) contract ExampleNFT { self.CollectionPublicPath = /public/nftTutorialCollection self.MinterStoragePath = /storage/nftTutorialMinter - // initialize the ID count to one self.idCount = 1 - // store an empty NFT Collection in account storage self.account.storage.save(<-self.createEmptyCollection(), to: self.CollectionStoragePath) - - // publish a capability to the Collection in storage let cap = self.account.capabilities.storage.issue<&Collection>(self.CollectionStoragePath) self.account.capabilities.publish(cap, at: self.CollectionPublicPath) } -} \ No newline at end of file +} diff --git a/cadence/transactions/create_nft_listing.cdc b/cadence/transactions/create_nft_listing.cdc index 90d25f8..bb35c2f 100644 --- a/cadence/transactions/create_nft_listing.cdc +++ b/cadence/transactions/create_nft_listing.cdc @@ -1,53 +1,61 @@ import "NFTStorefront" import "NonFungibleToken" -import "ExampleNFT" import "FungibleToken" +import "ExampleNFT" -transaction { - - // Reference to the NFTStorefront.Storefront resource. - let storefront: &NFTStorefront.Storefront - - // Capability for the ExampleNFT.Collection, allowing NFT interactions. - let exampleNFTProvider: Capability<&ExampleNFT.Collection> - // Capability for the FungibleToken.Vault, allowing token interactions. - let tokenReceiver: Capability<&FungibleToken.Vault> +transaction { + let storefront: auth(NFTStorefront.CreateListing) &NFTStorefront.Storefront + let exampleNFTProvider: Capability<&{ExampleNFT.CollectionInterface}> + let tokenReceiver: Capability<&{FungibleToken.Receiver}> prepare(signer: auth(Storage, Capabilities) &Account) { - // Borrow the storefront reference. - self.storefront = signer.storage.borrow<&NFTStorefront.Storefront>(at: NFTStorefront.StorefrontStoragePath) - ?? panic("Cannot borrow storefront") - - // Check and link the ExampleNFT.Collection capability if it doesn't exist. - if signer.capabilities.storage.get<&ExampleNFT.Collection>(at: ExampleNFT.CollectionPrivatePath).check() == false { - let cap = signer.capabilities.storage.issue<&ExampleNFT.Collection>(ExampleNFT.CollectionPrivatePath, target: ExampleNFT.CollectionStoragePath) - signer.capabilities.publish(cap, at: ExampleNFT.CollectionPublicPath) + // Retrieve the storefront capability + let storefrontCap = signer.capabilities.get<&NFTStorefront.Storefront>( + NFTStorefront.StorefrontStoragePath + ) + + // Borrow the resource from the capability + self.storefront = storefrontCap.borrow() + ?? panic("Cannot borrow storefront resource") + + // Ensure the ExampleNFT Collection capability is published + if signer.capabilities.get<&{ExampleNFT.CollectionInterface}>( + ExampleNFT.CollectionPublicPath + ) == nil { + let issuedCapability = signer.capabilities.storage.issue<&ExampleNFT.Collection>( + ExampleNFT.CollectionStoragePath + ) + signer.capabilities.publish(issuedCapability, at: ExampleNFT.CollectionPublicPath) } - // Retrieve the ExampleNFT.Collection capability. - self.exampleNFTProvider = signer.capabilities.storage.get<&ExampleNFT.Collection>(at: ExampleNFT.CollectionPrivatePath)! - assert(self.exampleNFTProvider.borrow() != nil, message: "Missing or mis-typed ExampleNFT.Collection provider") + // Retrieve and verify the ExampleNFT Collection capability + let nftProviderCap = signer.capabilities.get<&{ExampleNFT.CollectionInterface}>( + ExampleNFT.CollectionPublicPath + ) + self.exampleNFTProvider = nftProviderCap - // Retrieve the FungibleToken.Vault receiver capability. - self.tokenReceiver = signer.capabilities.get<&FungibleToken.Vault>(/public/MainReceiver)! - assert(self.tokenReceiver.borrow() != nil, message: "Missing or mis-typed FlowToken receiver") + // Retrieve and verify the FungibleToken receiver capability + let tokenReceiverCap = signer.capabilities.get<&{FungibleToken.Receiver}>( + /public/MainReceiver + ) + self.tokenReceiver = tokenReceiverCap - // Define a SaleCut with the token receiver and amount. + // Create a sale cut let saleCut = NFTStorefront.SaleCut( receiver: self.tokenReceiver, amount: 10.0 ) - // Create a new listing in the storefront. - self.storefront.createListing( - nftProviderCapability: self.exampleNFTProvider, - nftType: Type<@NonFungibleToken.NFT>(), - nftID: 0, - salePaymentVaultType: Type<@FungibleToken.Vault>(), + // Create the listing + let listingID = self.storefront.createListing( + nftProviderCapability: self.exampleNFTProvider, + nftType: Type<@ExampleNFT.NFT>(), + nftID: 1, + salePaymentVaultType: Type<@FungibleToken.Vault>(), saleCuts: [saleCut] ) - log("Storefront listing created") + log("Storefront listing created with ID: ".concat(listingID.toString())) } }