import ChainzNFT from 0xff342b6df9ef019d import DapperUtilityCoin from 0xead892083b3e2c6c import NonFungibleToken from 0x1d7e57aa55817448 import FungibleToken from 0xf233dcee88fe0abe import MetadataViews from 0x1d7e57aa55817448 import NFTStorefrontV2 from 0x4eb8a10cb9f87357 /// Transaction used to facilitate the creation of the listing under the signer's owned storefront resource. /// It accepts the certain details from the signer,i.e. - /// /// `saleItemID` - ID of the NFT that is put on sale by the seller. /// `saleItemPrice` - Amount of tokens (FT) buyer needs to pay for the purchase of listed NFT. /// `customID` - Optional string to represent identifier of the dapp. /// `expiry` - Unix timestamp at which created listing become expired. /// `marketPlaceSaleCutReceiver` - Marketplace sale cut receiver. /// `marketPlaceSaleCut` - Amount of the sale price received by the marketplace. /// If the given nft has a support of the RoyaltyView then royalties will added as the sale cut. transaction(saleItemID: UInt64, saleItemPrice: UFix64, customID: String?, expiry: UInt64, marketPlaceSaleCutReceiver: Address, marketPlaceSaleCut: UFix64) { let ducReceiver: Capability<&AnyResource{FungibleToken.Receiver}> let chainzNFTProvider: Capability<&AnyResource{NonFungibleToken.Provider, NonFungibleToken.CollectionPublic}> let storefront: &NFTStorefrontV2.Storefront var saleCuts: [NFTStorefrontV2.SaleCut] // var marketplacesCapability: Capability<&AnyResource{FungibleToken.Receiver}> prepare(acct: AuthAccount) { self.saleCuts = [] // self.marketplacesCapability = nil // We need a provider capability, but one is not provided by default so we create one if needed. let chainzNFTCollectionProviderPrivatePath = /private/chainzNFTCollectionProviderForNFTStorefront // Receiver for the sale cut. self.ducReceiver = acct.getCapability<&{FungibleToken.Receiver}>(/public/dapperUtilityCoinReceiver)! assert(self.ducReceiver.borrow() != nil, message: "Missing or mis-typed DapperUtilityCoin receiver") // let dapperVault = dapper.borrow<&DapperUtilityCoin.Vault>(from: /storage/dapperUtilityCoinVault)! // let payment <- dapperVault.withdraw(amount: packType.price) as! @DapperUtilityCoin.Vault // Check if the Provider capability exists or not if `no` then create a new link for the same. if !acct.getCapability<&{NonFungibleToken.Provider, NonFungibleToken.CollectionPublic}>(chainzNFTCollectionProviderPrivatePath)!.check() { acct.link<&{NonFungibleToken.Provider, NonFungibleToken.CollectionPublic}>(chainzNFTCollectionProviderPrivatePath, target: ChainzNFT.CollectionStoragePath) } self.chainzNFTProvider = acct.getCapability<&{NonFungibleToken.Provider, NonFungibleToken.CollectionPublic}>(chainzNFTCollectionProviderPrivatePath)! let collection = acct .getCapability(ChainzNFT.CollectionPublicPath) .borrow<&{ChainzNFT.CollectionPublic}>() ?? panic("Could not borrow a reference to the collection") var totalRoyaltyCut = 0.0 let nft = collection.borrowChainzNFT(id: saleItemID)! // Check whether the NFT implements the MetadataResolver or not. if nft.getViews().contains(Type()) { let royaltiesRef = nft.resolveView(Type())?? panic("Unable to retrieve the royalties") let royalties = (royaltiesRef as! MetadataViews.Royalties).getRoyalties() for royalty in royalties { // TODO - Verify the type of the vault and it should exists self.saleCuts.append(NFTStorefrontV2.SaleCut(receiver: royalty.receiver, amount: royalty.cut * saleItemPrice)) totalRoyaltyCut = totalRoyaltyCut + royalty.cut * saleItemPrice } } // Append the cut for the seller. self.saleCuts.append(NFTStorefrontV2.SaleCut( receiver: self.ducReceiver, // amount: saleItemPrice - totalRoyaltyCut - saleItemPrice * marketPlaceSaleCutPercentage amount: saleItemPrice )) assert(self.chainzNFTProvider.borrow() != nil, message: "Missing or mis-typed ChainzNFT.Collection provider") self.storefront = acct.borrow<&NFTStorefrontV2.Storefront>(from: NFTStorefrontV2.StorefrontStoragePath) ?? panic("Missing or mis-typed NFTStorefront Storefront") // Here we are making a fair assumption that all given addresses would have // the capability to receive the `DapperUtilityCoin` let marketPlaceCapability = getAccount(marketPlaceSaleCutReceiver).getCapability<&{FungibleToken.Receiver}>(/public/dapperUtilityCoinReceiver) // Append the cut for the marketplace. self.saleCuts.append(NFTStorefrontV2.SaleCut( receiver: marketPlaceCapability, amount: marketPlaceSaleCut )) } execute { // Create listing self.storefront.createListing( nftProviderCapability: self.chainzNFTProvider, nftType: Type<@ChainzNFT.NFT>(), nftID: saleItemID, salePaymentVaultType: Type<@DapperUtilityCoin.Vault>(), saleCuts: self.saleCuts, marketplacesCapability: nil, customID: customID, commissionAmount: 0.0, expiry: expiry ) } }