import FungibleToken from 0x9a0766d93b6608b7 import DapperUtilityCoin from 0x82ec283f88a62e65 import FlowUtilityToken from 0x82ec283f88a62e65 import NonFungibleToken from 0x631e88ae7f1d7c20 import NFTStorefrontV2 from 0x2d55b98eb200daef import MetadataViews from 0x631e88ae7f1d7c20 import TuneGO from 0x5d45c655fcde5037 import TicalUniverse from 0x5d45c655fcde5037 import TuneGONFT from 0x723a1b50e1d67e8e import PackNFT from 0x4ed4b8e5cd0dd15e import DapperStorageRent from 0x43ee8c22fcf94ea3 import PrivateReceiverForwarder from 0x668b91e2995c2eba // Dapper App: TuneGO pub fun setupTuneGO(_ account: AuthAccount): &TuneGO.Collection { let capability = account.getCapability<&{NonFungibleToken.CollectionPublic, TuneGO.TuneGOCollectionPublic, MetadataViews.ResolverCollection}>(TuneGO.CollectionPublicPath) if account.getLinkTarget(TuneGO.CollectionPublicPath) != nil && capability.check() == false { account.unlink(TuneGO.CollectionPublicPath) } account.link<&{NonFungibleToken.CollectionPublic, TuneGO.TuneGOCollectionPublic, MetadataViews.ResolverCollection}>( TuneGO.CollectionPublicPath, target: TuneGO.CollectionStoragePath ) if let existingCollectionRef = account.borrow<&TuneGO.Collection>(from: TuneGO.CollectionStoragePath) { return existingCollectionRef } let collection <- TuneGO.createEmptyCollection() as! @TuneGO.Collection let collectionRef = &collection as &TuneGO.Collection account.save(<-collection, to: TuneGO.CollectionStoragePath) return collectionRef } pub fun setupTicalUniverse(_ account: AuthAccount): &TicalUniverse.Collection { let capability = account.getCapability<&{NonFungibleToken.CollectionPublic, TicalUniverse.TicalUniverseCollectionPublic, MetadataViews.ResolverCollection}>(TicalUniverse.CollectionPublicPath) if account.getLinkTarget(TicalUniverse.CollectionPublicPath) != nil && capability.check() == false { account.unlink(TicalUniverse.CollectionPublicPath) } account.link<&{NonFungibleToken.CollectionPublic, TicalUniverse.TicalUniverseCollectionPublic, MetadataViews.ResolverCollection}>( TicalUniverse.CollectionPublicPath, target: TicalUniverse.CollectionStoragePath ) if let existingCollectionRef = account.borrow<&TicalUniverse.Collection>(from: TicalUniverse.CollectionStoragePath) { return existingCollectionRef } let collection <- TicalUniverse.createEmptyCollection() as! @TicalUniverse.Collection let collectionRef = &collection as &TicalUniverse.Collection account.save(<-collection, to: TicalUniverse.CollectionStoragePath) return collectionRef } pub fun setupTuneGONFT(_ account: AuthAccount): &TuneGONFT.Collection { let capability = account.getCapability<&{NonFungibleToken.CollectionPublic, TuneGONFT.TuneGONFTCollectionPublic, MetadataViews.ResolverCollection}>(TuneGONFT.CollectionPublicPath) if account.getLinkTarget(TuneGONFT.CollectionPublicPath) != nil && capability.check() == false { account.unlink(TuneGONFT.CollectionPublicPath) } account.link<&{NonFungibleToken.CollectionPublic, TuneGONFT.TuneGONFTCollectionPublic, MetadataViews.ResolverCollection}>( TuneGONFT.CollectionPublicPath, target: TuneGONFT.CollectionStoragePath ) if let existingCollectionRef = account.borrow<&TuneGONFT.Collection>(from: TuneGONFT.CollectionStoragePath) { return existingCollectionRef } let collection <- TuneGONFT.createEmptyCollection() as! @TuneGONFT.Collection let collectionRef = &collection as &TuneGONFT.Collection account.save(<-collection, to: TuneGONFT.CollectionStoragePath) return collectionRef } pub fun setupPackCollection(_ signer: AuthAccount): &PackNFT.Collection { let type = signer.type(at: PackNFT.CollectionStoragePath) if type != nil && type != Type<@PackNFT.Collection>() { let objectAddress = type!.identifier.slice(from: 2, upTo: 18) let backupPath = StoragePath(identifier: "backupPackNFTCollection_".concat(objectAddress))! signer.save<@AnyResource>(<-signer.load<@AnyResource>(from: PackNFT.CollectionStoragePath)!, to: backupPath); } // if the account doesn't already have a collection if signer.borrow<&PackNFT.Collection>(from: PackNFT.CollectionStoragePath) == nil { // Create a collection to receive Pack NFTs let collection <- PackNFT.createEmptyCollection() signer.save(<-collection, to: PackNFT.CollectionStoragePath) } // remove old public capability for the collection if not compatibile let capability = signer.getCapability<&PackNFT.Collection{NonFungibleToken.CollectionPublic, MetadataViews.ResolverCollection, PackNFT.IPackNFTCollectionPublic}>(PackNFT.CollectionPublicPath); if signer.getLinkTarget(PackNFT.CollectionPublicPath) != nil && capability.check() == false { signer.unlink(PackNFT.CollectionPublicPath) } let capability2 = signer.getCapability<&PackNFT.Collection{NonFungibleToken.Provider, NonFungibleToken.CollectionPublic, PackNFT.IPackNFTCollectionPrivate}>(PackNFT.CollectionPrivatePath); if signer.getLinkTarget(PackNFT.CollectionPrivatePath) != nil && capability2.check() == false { signer.unlink(PackNFT.CollectionPrivatePath) } // create new public capability for the collection signer.link<&PackNFT.Collection{NonFungibleToken.CollectionPublic, MetadataViews.ResolverCollection, PackNFT.IPackNFTCollectionPublic}>(PackNFT.CollectionPublicPath, target: PackNFT.CollectionStoragePath) signer.link<&PackNFT.Collection{NonFungibleToken.Provider, NonFungibleToken.CollectionPublic, PackNFT.IPackNFTCollectionPrivate}>(PackNFT.CollectionPrivatePath, target: PackNFT.CollectionStoragePath) return signer.borrow<&PackNFT.Collection>(from: PackNFT.CollectionStoragePath)! } pub fun getOrCreateNFTCollectionRef(signer: AuthAccount, contractName: String): &{NonFungibleToken.Receiver} { switch contractName { case "TuneGONFT": return setupTuneGONFT(signer) case "TuneGO": return setupTuneGO(signer) case "TicalUniverse": return setupTicalUniverse(signer) case "PackNFT": return setupPackCollection(signer) } panic("Contract not supported") } pub fun refillStorage(_ address: Address, supplier: &FungibleToken.Vault?): Bool? { let acct = getAccount(address) var storageRemain = acct.storageCapacity - acct.storageUsed let refillThreshold = DapperStorageRent.getStorageRentRefillThreshold() if storageRemain > refillThreshold { return nil } if !acct.getCapability<&PrivateReceiverForwarder.Forwarder>(PrivateReceiverForwarder.PrivateReceiverPublicPath).check() { return false } if DapperStorageRent.checkEligibility(address) { DapperStorageRent.tryRefill(address) } storageRemain = acct.storageCapacity - acct.storageUsed if storageRemain > refillThreshold { return true } if supplier == nil { return false } if supplier!.owner == nil || supplier!.owner!.availableBalance < 0.01 { return false } let returned <- DapperStorageRent.fundedRefillV2(address: address, tokens: <-supplier!.withdraw(amount: 0.01)) supplier!.deposit(from:<-returned) storageRemain = acct.storageCapacity - acct.storageUsed return storageRemain > refillThreshold } pub fun getCurrency(paymentType: Type): String { if paymentType == Type<@DapperUtilityCoin.Vault>() { return "DUC" } if paymentType == Type<@FlowUtilityToken.Vault>() { return "FUT" } panic("Payment type not supported") } pub fun getPaymentVault( salePrice: UFix64, currency: String, ducVault: &DapperUtilityCoin.Vault, futVault: &FlowUtilityToken.Vault ): @FungibleToken.Vault { switch currency { case "DUC": return <- ducVault.withdraw(amount: salePrice) case "FUT": return <- futVault.withdraw(amount: salePrice) } panic("Currency not supported") } transaction( merchantAddress: Address, storefrontAddress: Address, nftContractName: String, listingResourceID: UInt64, expectedPrice: UFix64, expectedCurrency: String, signatureExpiration: UInt64, signature: String ) { let paymentVault: @FungibleToken.Vault let nftCollection: &{NonFungibleToken.Receiver} let storefront: &NFTStorefrontV2.Storefront{NFTStorefrontV2.StorefrontPublic} let listing: &NFTStorefrontV2.Listing{NFTStorefrontV2.ListingPublic} let salePrice: UFix64 let currency: String let ducBalanceBeforeTransfer: UFix64 let futBalanceBeforeTransfer: UFix64 let mainDapperUtilityCoinVault: &DapperUtilityCoin.Vault let mainFlowUtilityTokenVault: &FlowUtilityToken.Vault prepare(dapper: AuthAccount, buyer: AuthAccount) { assert(["DUC", "FUT"].contains(expectedCurrency), message: "Currency not supported") refillStorage(buyer.address, supplier: nil) if(nftContractName == "PackNFT") { setupTuneGONFT(buyer) }else{ setupPackCollection(buyer) } self.nftCollection = getOrCreateNFTCollectionRef(signer: buyer, contractName: nftContractName) self.storefront = getAccount(storefrontAddress) .getCapability<&NFTStorefrontV2.Storefront{NFTStorefrontV2.StorefrontPublic}>( NFTStorefrontV2.StorefrontPublicPath )! .borrow() ?? panic("Could not borrow Storefront") self.listing = self.storefront.borrowListing(listingResourceID: listingResourceID) ?? panic("No listing with that ID in Storefront") self.salePrice = self.listing.getDetails().salePrice self.currency = getCurrency(paymentType: self.listing.getDetails().salePaymentVaultType) self.mainDapperUtilityCoinVault = dapper.borrow<&DapperUtilityCoin.Vault>(from: /storage/dapperUtilityCoinVault) ?? panic("Cannot borrow DapperUtilityCoin vault from account storage") self.ducBalanceBeforeTransfer = self.mainDapperUtilityCoinVault.balance self.mainFlowUtilityTokenVault = dapper.borrow<&FlowUtilityToken.Vault>(from: /storage/flowUtilityTokenVault) ?? panic("Cannot borrow FlowUtilityToken vault from account storage") self.futBalanceBeforeTransfer = self.mainFlowUtilityTokenVault.balance self.paymentVault <- getPaymentVault( salePrice: self.salePrice, currency: self.currency, ducVault: self.mainDapperUtilityCoinVault, futVault: self.mainFlowUtilityTokenVault ) let publicKey = PublicKey( publicKey: "19e6fc6f9eab8113369d789b469da57a546fc7ccc3f9b7923f01778177477bf1b5c59bf2c1c76338cf339be1e98ba7c27bb804511d8515e986460e588d372b45".decodeHex(), signatureAlgorithm: SignatureAlgorithm.ECDSA_P256 ) let signedData = buyer.address.toString() .concat(":") .concat(storefrontAddress.toString()) .concat(":") .concat(listingResourceID.toString()) .concat(":") .concat(expectedPrice.toString()) .concat(":") .concat(expectedCurrency) .concat(":") .concat(signatureExpiration.toString()) let isValidSignature = publicKey.verify( signature: signature.decodeHex(), signedData: signedData.utf8, domainSeparationTag: "", hashAlgorithm: HashAlgorithm.SHA3_256 ) assert(isValidSignature, message: "Invalid signature for message: ".concat(signedData)) assert(UInt64(getCurrentBlock().timestamp) <= signatureExpiration, message: "Signature expired") } pre { self.salePrice == expectedPrice: "unexpected price" self.currency == expectedCurrency: "unexpected currency" } execute { let item <- self.listing.purchase(payment: <- self.paymentVault, commissionRecipient: nil) self.nftCollection.deposit(token: <-item) self.storefront.cleanupPurchasedListings(listingResourceID: listingResourceID) } post { self.mainDapperUtilityCoinVault.balance == self.ducBalanceBeforeTransfer: "DapperUtilityCoin leakage" self.mainFlowUtilityTokenVault.balance == self.futBalanceBeforeTransfer: "FlowUtilityToken leakage" } }

Transaction