import FungibleToken from 0xf233dcee88fe0abe import NonFungibleToken from 0x1d7e57aa55817448 import MetadataViews from 0x1d7e57aa55817448 import TokenForwarding from 0xe544175ee0461c4b import DapperUtilityCoin from 0xead892083b3e2c6c import PackNFT from 0x0b2a3299cc857e29 import IPackNFT from 0x18ddf0823a55a0ee import NFTStorefrontV2 from 0x4eb8a10cb9f87357 /// Transaction that lists packNFTs for sale in Storefront. transaction() { var ftReceiver: Capability<&AnyResource{FungibleToken.Receiver}> let nftProvider: Capability<&AnyResource{NonFungibleToken.Provider, NonFungibleToken.CollectionPublic}> let storefront: &NFTStorefrontV2.Storefront // we only ever want to use DapperUtilityCoin let universalDucReceiver: Address let collectionRef: &PackNFT.Collection{IPackNFT.IPackNFTCollectionPublic} prepare(user: AuthAccount) { // we only ever want to use DapperUtilityCoin self.universalDucReceiver = 0xead892083b3e2c6c let PrivateCollectionPath = /private/TopShotPackNFTCollectionProviderForNFTStorefront // ************************* Handling of DUC Recevier *************************** // // Fetch the capability of the universal DUC receiver let recipient = getAccount(self.universalDucReceiver).getCapability<&{FungibleToken.Receiver}>(/public/dapperUtilityCoinReceiver) assert(recipient.borrow() != nil, message: "Missing or mis-typed Fungible Token receiver for the DUC recipient") // Check whether the receiver has the capability to receive the DUC self.ftReceiver = user.getCapability<&{FungibleToken.Receiver}>(/public/dapperUtilityCoinReceiver) if self.ftReceiver.borrow() == nil || !self.ftReceiver.borrow()!.isInstance(Type<@TokenForwarding.Forwarder>()) { user.unlink(/public/dapperUtilityCoinReceiver) // Create the forwarder and save it to the account that is doing the forwarding let vault <- TokenForwarding.createNewForwarder(recipient: recipient) user.save(<-vault, to: /storage/ducTokenForwarder) // Link the new forwarding receiver capability user.link<&{FungibleToken.Receiver}>( /public/dapperUtilityCoinReceiver, target: /storage/ducTokenForwarder ) self.ftReceiver = user.getCapability<&{FungibleToken.Receiver}>(/public/dapperUtilityCoinReceiver) } // *************************** Seller account interactions *************************** // // This checks for the public capability if !user.getCapability<&PackNFT.Collection{IPackNFT.IPackNFTCollectionPublic}>(PackNFT.CollectionPublicPath)!.check() { user.unlink(PackNFT.CollectionPublicPath) user.link<&PackNFT.Collection{IPackNFT.IPackNFTCollectionPublic, NonFungibleToken.Receiver, NonFungibleToken.CollectionPublic, MetadataViews.ResolverCollection}>(PackNFT.CollectionPublicPath, target: PackNFT.CollectionStoragePath) } // Check if the Provider capability exists or not if ''no'' then create a new link for the same. if !user.getCapability<&{NonFungibleToken.Provider, NonFungibleToken.CollectionPublic}>(PrivateCollectionPath)!.check() { user.unlink(PrivateCollectionPath) user.link<&PackNFT.Collection{IPackNFT.IPackNFTCollectionPublic, NonFungibleToken.Receiver, NonFungibleToken.CollectionPublic, NonFungibleToken.Provider, MetadataViews.ResolverCollection}>(PrivateCollectionPath, target: PackNFT.CollectionStoragePath) } self.nftProvider = user.getCapability<&{NonFungibleToken.Provider, NonFungibleToken.CollectionPublic}>(PrivateCollectionPath)! assert(self.nftProvider.borrow() != nil, message: "Missing or mis-typed PackNFT.Collection provider") self.collectionRef = user .getCapability<&PackNFT.Collection{IPackNFT.IPackNFTCollectionPublic}>(PackNFT.CollectionPublicPath).borrow() ?? panic("Could not borrow a reference to the collection") if user.borrow<&NFTStorefrontV2.Storefront>(from: NFTStorefrontV2.StorefrontStoragePath) == nil { // Create a new empty Storefront let storefront <- NFTStorefrontV2.createStorefront() as! @NFTStorefrontV2.Storefront // save it to the account user.save(<-storefront, to: NFTStorefrontV2.StorefrontStoragePath) // create a public capability for the Storefront user.link<&NFTStorefrontV2.Storefront{NFTStorefrontV2.StorefrontPublic}>(NFTStorefrontV2.StorefrontPublicPath, target: NFTStorefrontV2.StorefrontStoragePath) } self.storefront = user.borrow<&NFTStorefrontV2.Storefront>(from: NFTStorefrontV2.StorefrontStoragePath)! } execute { let packNFTIDs = [68169721313384] let saleItemPrices = [42.00000000] for index, packNftID in packNFTIDs { var totalRoyaltyCut = 0.0 let effectiveSaleItemPrice = UFix64(saleItemPrices[index]) var saleCuts: [NFTStorefrontV2.SaleCut] = [] let nft: &IPackNFT.NFT = self.collectionRef.borrowPackNFT(id: UInt64(packNftID))! // 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 { let royaltyReceiver = royalty.receiver saleCuts.append(NFTStorefrontV2.SaleCut(receiver: royalty.receiver, amount: royalty.cut * effectiveSaleItemPrice)) totalRoyaltyCut = totalRoyaltyCut + royalty.cut * effectiveSaleItemPrice } } // Append the cut for the seller. saleCuts.append(NFTStorefrontV2.SaleCut( receiver: self.ftReceiver, amount: effectiveSaleItemPrice - totalRoyaltyCut )) // create listing self.storefront.createListing( nftProviderCapability: self.nftProvider, nftType: Type<@PackNFT.NFT>(), nftID: UInt64(packNftID), salePaymentVaultType: Type<@DapperUtilityCoin.Vault>(), saleCuts: saleCuts, marketplacesCapability: nil, customID: "DAPPER_MARKETPLACE", commissionAmount: 0.0, expiry: 32503708800 // year 3000 ) } } }