// SPDX-License-Identifier: Unlicense import FungibleToken from 0xf233dcee88fe0abe import NonFungibleToken from 0x1d7e57aa55817448 // NFTStorefront // // A general purpose sale support contract for Flow NonFungibleTokens. // // Each account that wants to list NFTs for sale installs a Storefront, // and lists individual sales within that Storefront as Listings. // There is one Storefront per account, it handles sales of all NFT types // for that account. // // Each Listing can have one or more "cut"s of the sale price that // goes to one or more addresses. Cuts can be used to pay listing fees // or other considerations. // Each NFT may be listed in one or more Listings, the validity of each // Listing can easily be checked. // // Purchasers can watch for Listing events and check the NFT type and // ID to see if they wish to buy the listed item. // Marketplaces and other aggregators can watch for Listing events // and list items of interest. // pub contract NFTStorefront { // NFTStorefrontInitialized // This contract has been deployed. // Event consumers can now expect events from this contract. // pub event NFTStorefrontInitialized() // StorefrontInitialized // A Storefront resource has been created. // Event consumers can now expect events from this Storefront. // Note that we do not specify an address: we cannot and should not. // Created resources do not have an owner address, and may be moved // after creation in ways we cannot check. // ListingAvailable events can be used to determine the address // of the owner of the Storefront (...its location) at the time of // the listing but only at that precise moment in that precise transaction. // If the seller moves the Storefront while the listing is valid, // that is on them. // pub event StorefrontInitialized(storefrontResourceID: UInt64) // StorefrontDestroyed // A Storefront has been destroyed. // Event consumers can now stop processing events from this Storefront. // Note that we do not specify an address. // pub event StorefrontDestroyed(storefrontResourceID: UInt64) // ListingAvailable // A listing has been created and added to a Storefront resource. // The Address values here are valid when the event is emitted, but // the state of the accounts they refer to may be changed outside of the // NFTStorefront workflow, so be careful to check when using them. // pub event ListingAvailable( storefrontAddress: Address, listingResourceID: UInt64, nftType: Type, nftID: [UInt64], ftVaultType: Type, price: UFix64, databaseID: String ) // ListingCompleted // The listing has been resolved. It has either been purchased, or removed and destroyed. // pub event ListingCompleted( listingResourceID: UInt64, storefrontResourceID: UInt64, purchased: Bool, nftType: Type ) /// Event used on Listing is purchased // TOKEN RUNNERS: New event to signal that listing was purchased, used when listing has more than 1 nftID pub event ListingPurchased(listingID: UInt64, databaseID: String, nftType: Type, nftID: UInt64, owner: Address) // StorefrontStoragePath // The location in storage that a Storefront resource should be located. pub let StorefrontStoragePath: StoragePath // StorefrontPublicPath // The public location for a Storefront link. pub let StorefrontPublicPath: PublicPath // SaleCut // A struct representing a recipient that must be sent a certain amount // of the payment when a token is sold. // pub struct SaleCut { // The receiver for the payment. // Note that we do not store an address to find the Vault that this represents, // as the link or resource that we fetch in this way may be manipulated, // so to find the address that a cut goes to you must get this struct and then // call receiver.borrow()!.owner.address on it. // This can be done efficiently in a script. pub let receiver: Capability<&{FungibleToken.Receiver}> // The amount of the payment FungibleToken that will be paid to the receiver. pub let amount: UFix64 // initializer // init(receiver: Capability<&{FungibleToken.Receiver}>, amount: UFix64) { self.receiver = receiver self.amount = amount } } // ListingDetails // A struct containing a Listing's data. // pub struct ListingDetails { // The Storefront that the Listing is stored in. // Note that this resource cannot be moved to a different Storefront, // so this is OK. If we ever make it so that it *can* be moved, // this should be revisited. pub var storefrontID: UInt64 // Whether this listing has been purchased or not. pub var purchased: Bool // The Type of the NonFungibleToken.NFT that is being listed. pub let nftType: Type // The ID of the NFT within that type. // TOKEN RUNNERS: Update this field from single UInt64 to Array of UInt64 access(contract) let nftID: [UInt64] // The Type of the FungibleToken that payments must be made in. pub let salePaymentVaultType: Type // The amount that must be paid in the specified FungibleToken. pub let salePrice: UFix64 // This specifies the division of payment between recipients. access(contract) let saleCuts: [SaleCut] // The time when this listing can be purchase // TOKEN RUNNERS: Add new field to check when the listing can be purchase pub let availableAtTimestamp: UFix64 // The max quantity can be sell // TOKEN RUNNERS: Add new field to check when the listing should be completed pub let maxQuantity: UInt64 // The quantity NFTs was sold in this listing // TOKEN RUNNERS: Add new field to count how many was sold in this listing pub var quantitySold: UInt64 // The field to check if is pre-sale // TOKEN RUNNERS: Add new field to pre sale listing pub var isPreSale: Bool // The field save buyer // TOKEN RUNNERS: Add new field to save the buyers address access(account) let buyers: {Address: UInt64} // The field with max limit per buyer // TOKEN RUNNERS: Add new field to save whitelist access(account) var preSaleBuyerMaxLimit: {Address: UInt64} // setToPurchased // Irreversibly set this listing as purchased. // TOKEN RUNNERS: Add new function to set listing as purchased // access(contract) fun setToPurchased() { self.purchased = true } // increaseQuantitySold // Increase the quantity sold // TOKEN RUNNERS: Add new function to increase quantity sold // access(contract) fun increaseQuantitySold() { self.quantitySold = self.quantitySold + UInt64(1) } // changePreSaleStatus // Change the pre sale status // TOKEN RUNNERS: Add new function to change pre sale status // pub fun changePreSaleStatus(isPreSale: Bool){ self.isPreSale = isPreSale } // updateWhitelist // Update whitelist // TOKEN RUNNERS: Add new function to update whitelist // pub fun updateWhitelist(whitelist: {Address: UInt64}) { self.preSaleBuyerMaxLimit = whitelist } pub fun getBuyer(address: Address): UInt64? { return self.buyers[address] } pub fun setBuyer(address: Address, buyer:UInt64) { self.buyers[address] = buyer } pub fun removeNftID(index:UInt64): UInt64 { return self.nftID.remove(at: index) } // initializer // init ( nftType: Type, nftID: [UInt64], salePaymentVaultType: Type, saleCuts: [SaleCut], storefrontID: UInt64, availableAtTimestamp: UFix64, maxQuantity: UInt64?, isPreSale: Bool, preSaleBuyerMaxLimit: {Address: UInt64} ) { self.storefrontID = storefrontID self.purchased = false self.nftType = nftType self.availableAtTimestamp = availableAtTimestamp self.nftID = nftID self.salePaymentVaultType = salePaymentVaultType self.quantitySold = 0 self.maxQuantity = maxQuantity ?? UInt64(nftID.length) self.isPreSale = isPreSale self.buyers = {} self.preSaleBuyerMaxLimit = preSaleBuyerMaxLimit // Store the cuts assert(saleCuts.length > 0, message: "Listing must have at least one payment cut recipient") self.saleCuts = saleCuts // Calculate the total price from the cuts var salePrice = 0.0 // Perform initial check on capabilities, and calculate sale price from cut amounts. for cut in self.saleCuts { // Make sure we can borrow the receiver. // We will check this again when the token is sold. cut.receiver.borrow() ?? panic("Cannot borrow receiver") // Add the cut amount to the total price salePrice = salePrice + cut.amount } assert(salePrice > 0.0, message: "Listing must have non-zero price") // Store the calculated sale price self.salePrice = salePrice } } // ListingPublic // An interface providing a useful public interface to a Listing. // pub resource interface ListingPublic { // borrowNFT // This will assert in the same way as the NFT standard borrowNFT() // if the NFT is absent, for example if it has been sold via another listing. // pub fun borrowNFT(nftID : UInt64): &NonFungibleToken.NFT // purchaseLiveSale // Purchase the listing, buying the token. // This pays the beneficiaries and returns the token to the buyer. // pub fun purchaseLiveSale(payment: @FungibleToken.Vault, databaseID: String, address: Address): @NonFungibleToken.NFT // purchasePreSale // Purchase the listing, buying the token. // This pays the beneficiaries and returns the token to the buyer. // pub fun purchasePreSale(payment: @FungibleToken.Vault, databaseID: String, address: Address): @NonFungibleToken.NFT // getDetails // pub fun getDetails(): ListingDetails } // Listing // A resource that allows an NFT to be sold for an amount of a given FungibleToken, // and for the proceeds of that sale to be split between several recipients. // pub resource Listing: ListingPublic { // The simple (non-Capability, non-complex) details of the sale access(self) let details: ListingDetails // A capability allowing this resource to withdraw the NFT with the given ID from its collection. // This capability allows the resource to withdraw *any* NFT, so you should be careful when giving // such a capability to a resource and always check its code to make sure it will use it in the // way that it claims. access(contract) let nftProviderCapability: Capability<&{NonFungibleToken.Provider, NonFungibleToken.CollectionPublic}> // borrowNFT // This will assert in the same way as the NFT standard borrowNFT() // if the NFT is absent, for example if it has been sold via another listing. // pub fun borrowNFT(nftID : UInt64): &NonFungibleToken.NFT { let ref = self.nftProviderCapability.borrow()!.borrowNFT(id: nftID) //- CANNOT DO THIS IN PRECONDITION: "member of restricted type is not accessible: isInstance" // result.isInstance(self.getDetails().nftType): "token has wrong type" assert(ref.isInstance(self.getDetails().nftType), message: "token has wrong type") assert(ref.id == nftID, message: "token has wrong ID") return ref as &NonFungibleToken.NFT } // getDetails // Get the details of the current state of the Listing as a struct. // This avoids having more public variables and getter methods for them, and plays // nicely with scripts (which cannot return resources). // pub fun getDetails(): ListingDetails { return self.details } // purchasePreSale // Purchase the listing, buying the token. // This pays the beneficiaries and returns the token to the buyer. // pub fun purchasePreSale(payment: @FungibleToken.Vault, databaseID: String, address: Address): @NonFungibleToken.NFT { pre { self.details.isPreSale : "sale is not available" self.details.preSaleBuyerMaxLimit.containsKey(address) : "sale available for users in whitelist" self.checkBuyerMaxLimit(address: address) : "pre-sale offer is not available for this wallet" } if self.details.getBuyer(address:address) == nil { self.details.setBuyer(address:address, buyer:0) } let buyer = self.details.getBuyer(address:address)! + UInt64(1) self.details.setBuyer(address:address, buyer:buyer) return <- self.purchase(payment: <- payment, databaseID: databaseID, address: address) } // purchaseLiveSale // Purchase the listing, buying the token. // This pays the beneficiaries and returns the token to the buyer. // pub fun purchaseLiveSale(payment: @FungibleToken.Vault, databaseID: String, address: Address): @NonFungibleToken.NFT { pre { !self.details.isPreSale : "sale is not available" } return <- self.purchase(payment: <- payment, databaseID: databaseID, address: address) } // purchase // Purchase the listing, buying the token. // This pays the beneficiaries and returns the token to the buyer. // access(contract) fun purchase(payment: @FungibleToken.Vault, databaseID: String, address: Address): @NonFungibleToken.NFT { pre { self.details.purchased == false: "listing has already been purchased" // TOKEN RUNNERS: availableAtTimestamp validation, can't be purchase before this time self.details.availableAtTimestamp < getCurrentBlock().timestamp: "listing is not available now" payment.isInstance(self.details.salePaymentVaultType): "payment vault is not requested fungible token" payment.balance == self.details.salePrice: "payment vault does not contain requested price" } self.details.increaseQuantitySold() if(self.details.nftID.length == 1 || self.details.quantitySold == self.details.maxQuantity) { // Make sure the listing cannot be purchased again. self.details.setToPurchased() emit ListingCompleted( listingResourceID: self.uuid, storefrontResourceID: self.details.storefrontID, purchased: self.details.purchased, nftType: self.details.nftType ) } let nftId = self.details.removeNftID(index: 0) // Fetch the token to return to the purchaser. let nft <-self.nftProviderCapability.borrow()!.withdraw(withdrawID: nftId) // Neither receivers nor providers are trustworthy, they must implement the correct // interface but beyond complying with its pre/post conditions they are not gauranteed // to implement the functionality behind the interface in any given way. // Therefore we cannot trust the Collection resource behind the interface, // and we must check the NFT resource it gives us to make sure that it is the correct one. assert(nft.isInstance(self.details.nftType), message: "withdrawn NFT is not of specified type") assert(nft.id == nftId, message: "withdrawn NFT does not have specified ID") // Rather than aborting the transaction if any receiver is absent when we try to pay it, // we send the cut to the first valid receiver. // The first receiver should therefore either be the seller, or an agreed recipient for // any unpaid cuts. var residualReceiver: &{FungibleToken.Receiver}? = nil // Pay each beneficiary their amount of the payment. for cut in self.details.saleCuts { if let receiver = cut.receiver.borrow() { let paymentCut <- payment.withdraw(amount: cut.amount) receiver.deposit(from: <-paymentCut) if (residualReceiver == nil) { residualReceiver = receiver } } } assert(residualReceiver != nil, message: "No valid payment receivers") // At this point, if all recievers were active and availabile, then the payment Vault will have // zero tokens left, and this will functionally be a no-op that consumes the empty vault residualReceiver!.deposit(from: <-payment) // If the listing is purchased, we regard it as completed here. // Otherwise we regard it as completed in the destructor. emit ListingPurchased(listingID: self.uuid, databaseID: databaseID, nftType: self.details.nftType, nftID: nft.id, owner: address) return <-nft } // checkBuyerMaxLimit function to check if wallet can buy on pre-sale access(self) fun checkBuyerMaxLimit(address: Address): Bool { if (self.details.preSaleBuyerMaxLimit.containsKey(address)) { var quantityBuyer: UInt64 = 0 if self.details.buyers.containsKey(address) { quantityBuyer = self.details.buyers[address]! } return self.details.preSaleBuyerMaxLimit[address]! >= quantityBuyer + UInt64(1) } return !self.details.buyers.containsKey(address) } // changePreSaleStatus // Change the pre sale status // pub fun changePreSaleStatus(isPreSale: Bool) { self.details.changePreSaleStatus(isPreSale: isPreSale) } // updateWhitelist // Change the whitelist // pub fun updateWhitelist(whitelist: {Address: UInt64}) { self.details.updateWhitelist(whitelist: whitelist) } // destructor // destroy () { // If the listing has not been purchased, we regard it as completed here. // Otherwise we regard it as completed in purchase(). // This is because we destroy the listing in Storefront.removeListing() // or Storefront.cleanup() . // If we change this destructor, revisit those functions. if !self.details.purchased { emit ListingCompleted( listingResourceID: self.uuid, storefrontResourceID: self.details.storefrontID, purchased: self.details.purchased, nftType: self.details.nftType ) } } // initializer // init ( nftProviderCapability: Capability<&{NonFungibleToken.Provider, NonFungibleToken.CollectionPublic}>, nftType: Type, nftID: [UInt64], salePaymentVaultType: Type, saleCuts: [SaleCut], storefrontID: UInt64, availableAtTimestamp: UFix64, maxQuantity: UInt64?, isPreSale: Bool, preSaleBuyerMaxLimit: {Address: UInt64} ) { // Store the sale information self.details = ListingDetails( nftType: nftType, nftID: nftID, salePaymentVaultType: salePaymentVaultType, saleCuts: saleCuts, storefrontID: storefrontID, availableAtTimestamp: availableAtTimestamp, maxQuantity: maxQuantity, isPreSale: isPreSale, preSaleBuyerMaxLimit: preSaleBuyerMaxLimit ) // Store the NFT provider self.nftProviderCapability = nftProviderCapability // Check that the provider contains the NFT. // We will check it again when the token is sold. // We cannot move this into a function because initializers cannot call member functions. let provider = self.nftProviderCapability.borrow() assert(provider != nil, message: "cannot borrow nftProviderCapability") // This will precondition assert if the token is not available. // let nft = provider!.borrowNFT(id: self.details.nftID[0]) // assert(nft.isInstance(self.details.nftType), message: "token is not of specified type") // assert(nft.id == self.details.nftID, message: "token does not have specified ID") } } // StorefrontManager // An interface for adding and removing Listings within a Storefront, // intended for use by the Storefront's own // pub resource interface StorefrontManager { // createListing // Allows the Storefront owner to create and insert Listings. // pub fun createListing( nftProviderCapability: Capability<&{NonFungibleToken.Provider, NonFungibleToken.CollectionPublic}>, nftType: Type, nftID: [UInt64], salePaymentVaultType: Type, saleCuts: [SaleCut], databaseID: String, availableAtTimestamp: UFix64, maxQuantity: UInt64?, isPreSale: Bool, preSaleBuyerMaxLimit: {Address: UInt64} ): UInt64 // removeListing // Allows the Storefront owner to remove any sale listing, acepted or not. // pub fun removeListing(listingResourceID: UInt64) pub fun changePreSaleStatus(listingResourceID: UInt64, isPreSale: Bool) pub fun updateWhitelist(listingResourceID: UInt64, whitelist: {Address: UInt64}) } // StorefrontPublic // An interface to allow listing and borrowing Listings, and purchasing items via Listings // in a Storefront. // pub resource interface StorefrontPublic { pub fun getListingIDs(): [UInt64] pub fun borrowListing(listingResourceID: UInt64): &Listing{ListingPublic}? pub fun cleanup(listingResourceID: UInt64) } // Storefront // A resource that allows its owner to manage a list of Listings, and anyone to interact with them // in order to query their details and purchase the NFTs that they represent. // pub resource Storefront : StorefrontManager, StorefrontPublic { // The dictionary of Listing uuids to Listing resources. access(self) var listings: @{UInt64: Listing} // insert // Create and publish a Listing for an NFT. // pub fun createListing( nftProviderCapability: Capability<&{NonFungibleToken.Provider, NonFungibleToken.CollectionPublic}>, nftType: Type, nftID: [UInt64], salePaymentVaultType: Type, saleCuts: [SaleCut], databaseID: String, availableAtTimestamp: UFix64, maxQuantity: UInt64?, isPreSale: Bool, preSaleBuyerMaxLimit: {Address: UInt64} ): UInt64 { let listing <- create Listing( nftProviderCapability: nftProviderCapability, nftType: nftType, nftID: nftID, salePaymentVaultType: salePaymentVaultType, saleCuts: saleCuts, storefrontID: self.uuid, availableAtTimestamp: availableAtTimestamp, maxQuantity: maxQuantity, isPreSale: isPreSale, preSaleBuyerMaxLimit: preSaleBuyerMaxLimit ) let listingResourceID = listing.uuid let listingPrice = listing.getDetails().salePrice // Add the new listing to the dictionary. let oldListing <- self.listings[listingResourceID] <- listing // Note that oldListing will always be nil, but we have to handle it. destroy oldListing emit ListingAvailable( storefrontAddress: self.owner?.address!, listingResourceID: listingResourceID, nftType: nftType, nftID: nftID, ftVaultType: salePaymentVaultType, price: listingPrice, databaseID: databaseID ) return listingResourceID } // removeListing // Remove a Listing that has not yet been purchased from the collection and destroy it. // pub fun removeListing(listingResourceID: UInt64) { let listing <- self.listings.remove(key: listingResourceID) ?? panic("missing Listing") // This will emit a ListingCompleted event. destroy listing } // getListingIDs // Returns an array of the Listing resource IDs that are in the collection // pub fun getListingIDs(): [UInt64] { return self.listings.keys } // borrowSaleItem // Returns a read-only view of the SaleItem for the given listingID if it is contained by this collection. // pub fun borrowListing(listingResourceID: UInt64): &Listing{ListingPublic}? { return &self.listings[listingResourceID] as! &Listing{ListingPublic}? } // cleanup // Remove an listing *if* it has been purchased. // Anyone can call, but at present it only benefits the account owner to do so. // Kind purchasers can however call it if they like. // pub fun cleanup(listingResourceID: UInt64) { pre { self.listings[listingResourceID] != nil: "could not find listing with given id" } let listing <- self.listings.remove(key: listingResourceID)! assert(listing.getDetails().purchased == true, message: "listing is not purchased, only admin can remove") destroy listing } // changePreSaleStatus // Change the pre sale status // pub fun changePreSaleStatus(listingResourceID: UInt64, isPreSale: Bool) { pre { self.listings[listingResourceID] != nil: "could not find listing with given id" } let listing = (&self.listings[listingResourceID] as! &Listing?)! listing.changePreSaleStatus(isPreSale: isPreSale) } // updateWhitelist // Update listing whitelist pub fun updateWhitelist(listingResourceID: UInt64, whitelist: {Address: UInt64}) { pre { self.listings[listingResourceID] != nil: "could not find listing with given id" } let listing = (&self.listings[listingResourceID] as! &Listing?)! listing.updateWhitelist(whitelist: whitelist) } // destructor // destroy () { destroy self.listings // Let event consumers know that this storefront will no longer exist emit StorefrontDestroyed(storefrontResourceID: self.uuid) } // constructor // init () { self.listings <- {} // self.account.b // self.account // Let event consumers know that this storefront exists emit StorefrontInitialized(storefrontResourceID: self.uuid) } } // createStorefront // Make creating a Storefront publicly accessible. // TOKEN RUNNERS: Only the super admin can create a new storefront marketplace // access(account) fun createStorefront(): @Storefront { return <-create Storefront() } init () { self.StorefrontStoragePath = /storage/NFTStorefront0xb681e84ceea6299e self.StorefrontPublicPath = /public/NFTStorefront0xb681e84ceea6299e emit NFTStorefrontInitialized() } }

Contract

Contract