import NonFungibleToken from 0x1d7e57aa55817448 import MetadataViews from 0x1d7e57aa55817448 import FungibleToken from 0xf233dcee88fe0abe import ViewResolver from 0x1d7e57aa55817448 access(all) contract KARATZ1S8SJESBT: NonFungibleToken { access(all) let CollectionStoragePath: StoragePath access(all) let CollectionPublicPath: PublicPath access(all) let AdminStoragePath: StoragePath access(all) var totalSupply: UInt64 access(all) event ContractInitialized() access(all) event Withdraw(id: UInt64, from: Address?) access(all) event Deposit(id: UInt64, to: Address?) access(all) event Minted(id: UInt64, metadata: Metadata) access(all) resource NFT: NonFungibleToken.NFT { access(all) let id: UInt64 access(all) let metadata: Metadata init(initID: UInt64, initMetadata: Metadata) { self.id = initID self.metadata = initMetadata } access(all) view fun getMetadata(): Metadata { return self.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 <-KARATZ1S8SJESBT.createEmptyCollection(nftType: Type<@KARATZ1S8SJESBT.NFT>()) } access(all) view fun getViews(): [Type] { return [ Type(), Type(), Type(), Type(), Type(), Type(), Type(), Type() ] } access(all) fun resolveView(_ view: Type): AnyStruct? { switch view { case Type(): return MetadataViews.Display( name: self.metadata.name, description: self.metadata.description, thumbnail: MetadataViews.HTTPFile( url: "https://market.24karat.io/api/items/KARATZ1S8SJESBT/".concat(self.id.toString()).concat("/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: "24Karat NFT Edition", 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( [MetadataViews.Royalty( receiver: getAccount(self.metadata.artistAddress).capabilities.get<&{FungibleToken.Receiver}>(MetadataViews.getRoyaltyReceiverPublicPath())!, cut: self.metadata.royalty, description: "The Royalty of 24Karat NFT" )] ) case Type(): return MetadataViews.ExternalURL("https://market.24karat.io/nfts/KARATZ1S8SJESBT/".concat(self.id.toString())) case Type(): return MetadataViews.NFTCollectionData( storagePath: KARATZ1S8SJESBT.CollectionStoragePath, publicPath: KARATZ1S8SJESBT.CollectionPublicPath, publicCollection: Type<&KARATZ1S8SJESBT.Collection>(), publicLinkedType: Type<&KARATZ1S8SJESBT.Collection>(), createEmptyCollectionFunction: (fun(): @{NonFungibleToken.Collection} { return <-KARATZ1S8SJESBT.createEmptyCollection(nftType: Type<@KARATZ1S8SJESBT.NFT>()) }) ) case Type(): let media = MetadataViews.Media( file: MetadataViews.HTTPFile( url: "https://static.wixstatic.com/media/568614_5676993b65c64da29cecf24d323fd664~mv2.png/v1/fill/w_140,h_160,al_c,q_85,usm_0.66_1.00_0.01,enc_auto/568614_5676993b65c64da29cecf24d323fd664~mv2.png" ), mediaType: "image/png" ) return MetadataViews.NFTCollectionDisplay( name: "The 24Karat Collection", description: "This collection is used for 24Karat market.", externalURL: MetadataViews.ExternalURL("https://market.24karat.io"), squareImage: media, bannerImage: media, socials: { "twitter": MetadataViews.ExternalURL("https://twitter.com/24karat_io") } ) case Type(): // traits is not yet ready let excludedTraits: [String] = [] let traitsView = MetadataViews.dictToTraits(dict: {}, excludedNames: excludedTraits) return traitsView } return nil } } access(all) struct Metadata { access(all) let name: String access(all) let artist: String access(all) let artistAddress: Address access(all) let description: String access(all) let type: String access(all) let serialId: UInt64 access(all) let royalty: UFix64 init( name: String, artist: String, artistAddress: Address, description: String, type: String, serialId: UInt64, royalty: UFix64 ) { self.name = name self.artist = artist self.artistAddress = artistAddress self.description = description self.type = type self.serialId = serialId self.royalty = royalty } } // Deprecated: Only here for backward compatibility. access(all) resource interface KARATZ1S8SJESBTCollectionPublic {} access(all) resource Collection: NonFungibleToken.Collection, KARATZ1S8SJESBTCollectionPublic { access(all) var ownedNFTs: @{UInt64: {NonFungibleToken.NFT}} init () { self.ownedNFTs <- {} } /// getSupportedNFTTypes returns a list of NFT types that this receiver accepts access(all) view fun getSupportedNFTTypes(): {Type: Bool} { let supportedTypes: {Type: Bool} = {} supportedTypes[Type<@KARATZ1S8SJESBT.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<@KARATZ1S8SJESBT.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 } access(all) fun deposit(token: @{NonFungibleToken.NFT}) { let id: UInt64 = token.id let oldToken <- self.ownedNFTs[id] <- token emit Deposit(id: id, to: self.owner?.address) destroy oldToken } 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.keys.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 <-KARATZ1S8SJESBT.createEmptyCollection(nftType: Type<@KARATZ1S8SJESBT.NFT>()) } } access(all) fun createEmptyCollection(nftType: Type): @{NonFungibleToken.Collection} { return <- create Collection() } access(all) view fun getContractViews(resourceType: Type?): [Type] { return [ 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<&KARATZ1S8SJESBT.Collection>(), publicLinkedType: Type<&KARATZ1S8SJESBT.Collection>(), createEmptyCollectionFunction: (fun(): @{NonFungibleToken.Collection} { return <-KARATZ1S8SJESBT.createEmptyCollection(nftType: Type<@KARATZ1S8SJESBT.NFT>()) }) ) return collectionData case Type(): let media = MetadataViews.Media( file: MetadataViews.HTTPFile( url: "https://static.wixstatic.com/media/568614_5676993b65c64da29cecf24d323fd664~mv2.png/v1/fill/w_140,h_160,al_c,q_85,usm_0.66_1.00_0.01,enc_auto/568614_5676993b65c64da29cecf24d323fd664~mv2.png" ), mediaType: "image/png" ) return MetadataViews.NFTCollectionDisplay( name: "24karat", description: "24karat", externalURL: MetadataViews.ExternalURL("https://market.24karat.io"), squareImage: media, bannerImage: media, socials: {} ) } return nil } access(all) resource NFTMinter { access(all) fun mintNFT(recipient: &{NonFungibleToken.Receiver}, metadata: KARATZ1S8SJESBT.Metadata) { pre { metadata.royalty <= 0.1: "royalty must lower than 0.1" } let tokenId = KARATZ1S8SJESBT.totalSupply + (1 as UInt64) var newNFT <- create NFT(initID: tokenId, initMetadata: metadata) recipient.deposit(token: <-newNFT) emit Minted(id: tokenId, metadata: metadata) KARATZ1S8SJESBT.totalSupply = tokenId } } init() { self.CollectionStoragePath = /storage/KARATZ1S8SJESBTCollection self.CollectionPublicPath = /public/KARATZ1S8SJESBTCollection self.AdminStoragePath = /storage/KARATZ1S8SJESBTAdmin self.totalSupply = 0 let minter: @KARATZ1S8SJESBT.NFTMinter <- create NFTMinter() self.account.storage.save(<-minter, to: self.AdminStoragePath) emit ContractInitialized() } }