import NonFungibleToken from 0x1d7e57aa55817448 import ViewResolver from 0x1d7e57aa55817448 import MetadataViews from 0x1d7e57aa55817448 import FungibleToken from 0xf233dcee88fe0abe import USDCFlow from 0xf1ab99c82dee3526 access(all) contract NBAsageNFT: NonFungibleToken { /// Standard Paths access(all) let CollectionStoragePath: StoragePath access(all) let CollectionPublicPath: PublicPath access(all) let AdminStoragePath: StoragePath /// Nonce variable access(all) var lastNonce: Int64 /// Public key variable access(all) var publicKey: [UInt8] /// Event to emit purchase of NFT access(all) event NFTPurchased( NFTReceiver: Address, nftID: UInt64, name: String, questionID: String, side: String ) /// Treasury account receives the amount on PurchaseNFT access(all) var TreasuryAccount: Address /// To view current nonce access(all) view fun getNonce(): Int64 { return NBAsageNFT.lastNonce } /// To view treasury account access(all) view fun getTreasuryAccount(): Address { return NBAsageNFT.TreasuryAccount } /// To view public key in bytes access(all) view fun getPublicKey(): [UInt8] { return NBAsageNFT.publicKey } /// Function to view question profile access(all) view fun getQuestionView(QuestionID: String): &Question? { return &self.Questions[QuestionID] } /// Function to get instance of question profile access(contract) view fun getQuestion(QuestionID: String): &Question? { return &self.Questions[QuestionID] } /// Struct for question profile access(all) struct Question { access(self) var id: String access(self) var name: String access(self) var yesCount: UInt64 access(self) var noCount: UInt64 access(self) var startTime : String access(self) var endTime : String init(id: String, name: String, startTime : String, endTime : String) { self.id = id self.name = name self.yesCount = 0 self.noCount = 0 self.startTime = startTime self.endTime = endTime } access(contract) fun setYesCount () {self.yesCount = self.yesCount + 1} access(contract) fun setNoCount () {self.noCount = self.noCount + 1} access(contract) fun removeYesCount () {self.yesCount = self.yesCount - 1} access(contract) fun removeNoCount () {self.noCount = self.noCount - 1} access(contract) fun editDescription (name: String) {self.name = name} } /// Admin resource /// access(all) resource Admin { // Function to add a question to the dictionary access(all) fun addQuestion(id: String, name: String, startTime : String, endTime : String) { pre { NBAsageNFT.getQuestionView(QuestionID: id) == nil: "question exist" } NBAsageNFT.Questions[id] = Question(id: id, name: name, startTime: startTime, endTime: endTime) } // Update just the question description access(all) fun updateQuestionDescription(id: String, name: String) { if let QuestionProfile = NBAsageNFT.getQuestion(QuestionID: id) { QuestionProfile.editDescription(name: name) } } // Function to update Treasury account access(all) fun updateTreasury (TreasuryAccount: Address){ NBAsageNFT.TreasuryAccount = TreasuryAccount } // Function to update signer access(all) fun updateSigner (publicKey: String){ NBAsageNFT.publicKey = publicKey.decodeHex() } } /// Dictionary to hold question profile access(all) var Questions: {String : Question} /// We choose the name NFT here, but this type can have any name now /// because the interface does not require it to have a specific name any more access(all) resource NFT: NonFungibleToken.NFT { access(all) let id: UInt64 /// From the Display metadata view access(all) let name: String access(all) let description: String access(all) let thumbnail: String access(all) let side: String access(all) let questionID: String /// For the Royalties metadata view access(self) let royalties: [MetadataViews.Royalty] /// Generic dictionary of traits the NFT has access(self) let metadata: {String: AnyStruct} init( name: String, description: String, thumbnail: String, side: String, questionID: String, royalties: [MetadataViews.Royalty], metadata: {String: AnyStruct}, ) { self.id = self.uuid self.name = name self.description = description self.thumbnail = thumbnail self.side = side self.questionID = questionID self.royalties = royalties self.metadata = metadata } /// createEmptyCollection creates an empty Collection /// and returns it to the caller so that they can own NFTs /// @{NonFungibleToken.Collection} access(all) fun createEmptyCollection(): @{NonFungibleToken.Collection} { return <-NBAsageNFT.createEmptyCollection(nftType: Type<@NBAsageNFT.NFT>()) } access(all) view fun getViews(): [Type] { return [ Type(), Type(), Type(), Type(), Type(), Type(), Type(), Type(), Type() ] } access(all) fun resolveView(_ view: Type): AnyStruct? { switch view { case Type(): return MetadataViews.Display( name: self.name, description: self.description, thumbnail: MetadataViews.HTTPFile( url: self.thumbnail ) ) case Type(): // There is no max number of NFTs that can be minted from this contract // so the max edition field value is set to nil let editionInfo = MetadataViews.Edition(name: "Edition 1", number: self.id, max: nil) let editionList: [MetadataViews.Edition] = [editionInfo] return MetadataViews.Editions( editionList ) case Type(): return MetadataViews.Serial( self.id ) case Type(): return MetadataViews.Royalties( self.royalties ) case Type(): return MetadataViews.ExternalURL("N/A") case Type(): return NBAsageNFT.resolveContractView(resourceType: Type<@NBAsageNFT.NFT>(), viewType: Type()) case Type(): return NBAsageNFT.resolveContractView(resourceType: Type<@NBAsageNFT.NFT>(), viewType: Type()) case Type(): // exclude mintedTime and foo to show other uses of Traits let excludedTraits = ["mintedTime"] let traitsView = MetadataViews.dictToTraits(dict: self.metadata, excludedNames: excludedTraits) // mintedTime is a unix timestamp, we should mark it with a displayType so platforms know how to show it. let mintedTimeTrait = MetadataViews.Trait(name: "mintedTime", value: self.metadata["mintedTime"]!, displayType: "Date", rarity: nil) traitsView.addTrait(mintedTimeTrait) return traitsView case Type(): // Implementing this view gives the project control over how the bridged NFT is represented as an // ERC721 when bridged to EVM on Flow via the public infrastructure bridge. // Get the contract-level name and symbol values let contractLevel = NBAsageNFT.resolveContractView( resourceType: nil, viewType: Type() ) as! MetadataViews.EVMBridgedMetadata? ?? panic("Could not resolve contract-level EVMBridgedMetadata") // Compose the token-level URI based on a base URI and the token ID, pointing to a JSON file. This // would be a file you've uploaded and are hosting somewhere - in this case HTTP, but this could be // IPFS, S3, a data URL containing the JSON directly, etc. let baseURI = "https://example-nft.onflow.org/token-metadata/" let uriValue = self.id.toString().concat(".json") return MetadataViews.EVMBridgedMetadata( name: contractLevel.name, symbol: contractLevel.symbol, uri: MetadataViews.URI( baseURI: baseURI, // defining baseURI results in a concatenation of baseURI and value value: self.id.toString().concat(".json") ) ) } return nil } } // Deprecated: Only here for backward compatibility. access(all) resource interface NBAsageNFTCollectionPublic {} access(all) resource Collection: NonFungibleToken.Collection, NBAsageNFTCollectionPublic { access(all) var ownedNFTs: @{UInt64: {NonFungibleToken.NFT}} access(all) var nftProperties: @{UInt64: NBAsageNFT.NFT} init () { self.ownedNFTs <- {} self.nftProperties <- {} } access(contract) fun burnNFT(id: UInt64) { let _nft <- self.ownedNFTs.remove(key: id) ?? panic("This NFT does not exist in this Collection.") let nft <- _nft as! @NFT let questionID = nft.questionID let side = nft.side if let QuestionProfile = NBAsageNFT.getQuestion(QuestionID: questionID) { if side == "YES" { QuestionProfile.removeYesCount() } else { QuestionProfile.removeNoCount() } } destroy nft } access(all) fun batchBurn(ids: [UInt64]){ var id_length = ids.length while id_length !=0 { let single_id = ids.removeLast() self.burnNFT(id: single_id) id_length = id_length - 1 } } /// getSupportedNFTTypes returns a list of NFT types that this receiver accepts access(all) view fun getSupportedNFTTypes(): {Type: Bool} { let supportedTypes: {Type: Bool} = {} supportedTypes[Type<@NBAsageNFT.NFT>()] = true return supportedTypes } /// Returns whether or not the given type is accepted by the collection /// A collection that can accept any type should just return true by default access(all) view fun isSupportedNFTType(type: Type): Bool { return type == Type<@NBAsageNFT.NFT>() } /// withdraw removes an NFT from the collection and moves it to the caller access(NonFungibleToken.Withdraw) fun withdraw(withdrawID: UInt64): @{NonFungibleToken.NFT} { let token <- self.ownedNFTs.remove(key: withdrawID) ?? panic("Could not withdraw an NFT with the provided ID from the collection") return <-token } /// deposit takes a NFT and adds it to the collections dictionary /// and adds the ID to the id array access(all) fun deposit(token: @{NonFungibleToken.NFT}) { let token <- token as! @NBAsageNFT.NFT let id = token.id // add the new token to the dictionary which removes the old one let oldToken <- self.ownedNFTs[token.id] <- token destroy oldToken let authTokenRef = (&self.ownedNFTs[id] as auth(NonFungibleToken.Update) &{NonFungibleToken.NFT}?)! //authTokenRef.updateTransferDate(date: getCurrentBlock().timestamp) NBAsageNFT.emitNFTUpdated(authTokenRef) } /// getIDs returns an array of the IDs that are in the collection access(all) view fun getIDs(): [UInt64] { return self.ownedNFTs.keys } /// Gets the amount of NFTs stored in the collection access(all) view fun getLength(): Int { return self.ownedNFTs.length } access(all) view fun borrowNFT(_ id: UInt64): &{NonFungibleToken.NFT}? { return (&self.ownedNFTs[id] as &{NonFungibleToken.NFT}?) } /// Borrow the view resolver for the specified NFT ID access(all) view fun borrowViewResolver(id: UInt64): &{ViewResolver.Resolver}? { if let nft = &self.ownedNFTs[id] as &{NonFungibleToken.NFT}? { return nft as &{ViewResolver.Resolver} } return nil } /// createEmptyCollection creates an empty Collection of the same type /// and returns it to the caller /// @return A an empty collection of the same type access(all) fun createEmptyCollection(): @{NonFungibleToken.Collection} { return <-NBAsageNFT.createEmptyCollection(nftType: Type<@NBAsageNFT.NFT>()) } } /// createEmptyCollection creates an empty Collection for the specified NFT type /// and returns it to the caller so that they can own NFTs access(all) fun createEmptyCollection(nftType: Type): @{NonFungibleToken.Collection} { return <- create Collection() } /// Function that returns all the Metadata Views implemented by a Non Fungible Token /// /// @return An array of Types defining the implemented views. This value will be used by /// developers to know which parameter to pass to the resolveView() method. /// access(all) view fun getContractViews(resourceType: Type?): [Type] { return [ Type(), Type(), Type() ] } /// Function that resolves a metadata view for this contract. /// /// @param view: The Type of the desired view. /// @return A structure representing the requested view. /// access(all) fun resolveContractView(resourceType: Type?, viewType: Type): AnyStruct? { switch viewType { case Type(): let collectionData = MetadataViews.NFTCollectionData( storagePath: self.CollectionStoragePath, publicPath: self.CollectionPublicPath, publicCollection: Type<&NBAsageNFT.Collection>(), publicLinkedType: Type<&NBAsageNFT.Collection>(), createEmptyCollectionFunction: (fun(): @{NonFungibleToken.Collection} { return <-NBAsageNFT.createEmptyCollection(nftType: Type<@NBAsageNFT.NFT>()) }) ) return collectionData case Type(): let media = MetadataViews.Media( file: MetadataViews.HTTPFile( url: "https://www.arweave.net/uGxSlMRqsEEUPpJS2kRHGHOcjK4uLUxYB2xGrwllqtc" ), mediaType: "image/png" ) return MetadataViews.NFTCollectionDisplay( name: "NBAsage Opinions", description: "This collection will have YES and NO NFTs", externalURL: MetadataViews.ExternalURL("N/A"), squareImage: media, bannerImage: media, socials: { "twitter": MetadataViews.ExternalURL("https://x.com/Jumptradenft") } ) case Type(): // Implementing this view gives the project control over how the bridged NFT is represented as an ERC721 // when bridged to EVM on Flow via the public infrastructure bridge. // Compose the contract-level URI. In this case, the contract metadata is located on some HTTP host, // but it could be IPFS, S3, a data URL containing the JSON directly, etc. return MetadataViews.EVMBridgedMetadata( name: "NBAsage Opinions", symbol: "NBAS", uri: MetadataViews.URI( baseURI: nil, // setting baseURI as nil sets the given value as the uri field value value: "N/A" ) ) } return nil } access(all) fun signVerify( receiver: Address, nonce: Int64, questionID: String, side: Bool, salt: UInt64, sig: String ){ // Ensure that the nonce follows on from the previous meta // transaction. if nonce != (self.lastNonce + 1) { panic("Invalid meta transaction nonce") } let sideValue: UInt64 = side ? 1 : 0 // Construct the message to sign. var data: [UInt8] = receiver.toBytes() data = data.concat(nonce.toBigEndianBytes()) data = data.concat(questionID.utf8) data = data.concat(sideValue.toBigEndianBytes()) data = data.concat(salt.toBigEndianBytes()) // Verify the signature. let key = PublicKey( publicKey: self.publicKey, signatureAlgorithm: SignatureAlgorithm.ECDSA_P256 ) if !key.verify(signature: sig.decodeHex(), signedData: data, domainSeparationTag: "FLOW-V0.0-user", hashAlgorithm: HashAlgorithm.SHA3_256) { panic("Invalid meta transaction signature") } self.lastNonce = self.lastNonce + 1 } // TO DO: batch mint /// mintNFT mints a new NFT with a new ID /// and returns it to the calling context access(contract) fun mintNFT( name: String, description: String, thumbnail: String, royalties: [MetadataViews.Royalty], questionID: String, side: Bool, signature: String, salt: UInt64, ): @NBAsageNFT.NFT { let metadata: {String: AnyStruct} = {} let currentBlock = getCurrentBlock() var sideInput: String = "" if let QuestionProfile = NBAsageNFT.getQuestion(QuestionID: questionID) { if side == true { QuestionProfile.setYesCount() metadata["Side"] = "Yes" metadata["mintedBlock"] = currentBlock.height metadata["mintedTime"] = currentBlock.timestamp metadata["QuestionID"] = questionID sideInput = "YES" } else { QuestionProfile.setNoCount() metadata["Side"] = "No" metadata["mintedBlock"] = currentBlock.height metadata["mintedTime"] = currentBlock.timestamp metadata["QuestionID"] = questionID sideInput = "NO" } } else { panic("Invalid question ID") } // create a new NFT var newNFT <- create NFT( name: name, description: description, thumbnail: thumbnail, side: sideInput, questionID: questionID, royalties: royalties, metadata: metadata, ) return <-newNFT } access(all) fun purchaseNFT ( NFTReceiver: Address, paymentVault: @{FungibleToken.Vault}, amount: UFix64, name: String, description: String, thumbnail: String, royalties: [MetadataViews.Royalty], questionID: String, side: Bool, signature: String, salt: UInt64, nonce: Int64, count: UInt64 ) { NBAsageNFT.signVerify( receiver: NFTReceiver, nonce: nonce, questionID: questionID, side: side, salt: salt, sig: signature ) var nft_count = count // Deposit the FlowTokens into the assigned account let treasuryAccountVault = getAccount(NBAsageNFT.TreasuryAccount) .capabilities.get<&USDCFlow.Vault>(USDCFlow.VaultPublicPath) .borrow() ?? panic("Could not borrow receiver reference to the USDC vault") let Payment <- paymentVault.withdraw(amount: amount) treasuryAccountVault.deposit(from: <- Payment) destroy paymentVault // Borrow the caller's public NFT collection reference let callerCollectionRef = getAccount(NFTReceiver) .capabilities.get<&{NonFungibleToken.CollectionPublic}>(NBAsageNFT.CollectionPublicPath) .borrow() ?? panic("Could not get caller's NFT Collection reference") while nft_count !=0 { let newNFT <- NBAsageNFT.mintNFT ( name: name, description: description, thumbnail: thumbnail, royalties: royalties, questionID: questionID, side: side, signature: signature, salt: salt ) let sideInput = side ? "YES" : "NO" emit NFTPurchased( NFTReceiver: NFTReceiver, nftID: newNFT.uuid, name: name, questionID: questionID, side: sideInput ) // Deposit the minted NFT into the caller's collection callerCollectionRef.deposit(token: <-newNFT) nft_count = nft_count - 1 } } init(publicKey: String) { // Set the named paths self.CollectionStoragePath = /storage/NBAsageNFTCollection self.CollectionPublicPath = /public/NBAsageNFTCollection self.AdminStoragePath = /storage/NBAsageNFTAdmin // Create a Collection resource and save it to storage let collection <- create Collection() self.account.storage.save(<-collection, to: self.CollectionStoragePath) // create a public capability for the collection let collectionCap = self.account.capabilities.storage.issue<&NBAsageNFT.Collection>(self.CollectionStoragePath) self.account.capabilities.publish(collectionCap, at: self.CollectionPublicPath) self.Questions = {} self.TreasuryAccount = self.account.address self.lastNonce = -1 self.publicKey = publicKey.decodeHex() let admin <- create Admin() self.account.storage.save(<-admin, to: self.AdminStoragePath) } }