@flowtyio/flow-contracts 0.0.18 → 0.1.0-beta.2

package/contracts/MetadataViews.cdc

@@ -1,5 +1,6 @@
 import "FungibleToken"
 import "NonFungibleToken"
+import "ViewResolver"
 
 /// This contract implements the metadata standard proposed
 /// in FLIP-0636.
@@ -11,113 +12,38 @@ import "NonFungibleToken"
 /// a different kind of metadata, such as a creator biography
 /// or a JPEG image file.
 ///
-pub contract MetadataViews {
-
-    /// Provides access to a set of metadata views. A struct or
-    /// resource (e.g. an NFT) can implement this interface to provide access to
-    /// the views that it supports.
-    ///
-    pub resource interface Resolver {
-        pub fun getViews(): [Type]
-        pub fun resolveView(_ view: Type): AnyStruct?
-    }
-
-    /// A group of view resolvers indexed by ID.
-    ///
-    pub resource interface ResolverCollection {
-        pub fun borrowViewResolver(id: UInt64): &{Resolver}
-        pub fun getIDs(): [UInt64]
-    }
-
-    /// NFTView wraps all Core views along `id` and `uuid` fields, and is used
-    /// to give a complete picture of an NFT. Most NFTs should implement this
-    /// view.
-    ///
-    pub struct NFTView {
-        pub let id: UInt64
-        pub let uuid: UInt64
-        pub let display: Display?
-        pub let externalURL: ExternalURL?
-        pub let collectionData: NFTCollectionData?
-        pub let collectionDisplay: NFTCollectionDisplay?
-        pub let royalties: Royalties?
-        pub let traits: Traits?
-
-        init(
-            id : UInt64,
-            uuid : UInt64,
-            display : Display?,
-            externalURL : ExternalURL?,
-            collectionData : NFTCollectionData?,
-            collectionDisplay : NFTCollectionDisplay?,
-            royalties : Royalties?,
-            traits: Traits?
-        ) {
-            self.id = id
-            self.uuid = uuid
-            self.display = display
-            self.externalURL = externalURL
-            self.collectionData = collectionData
-            self.collectionDisplay = collectionDisplay
-            self.royalties = royalties
-            self.traits = traits
-        }
-    }
-
-    /// Helper to get an NFT view
-    ///
-    /// @param id: The NFT id
-    /// @param viewResolver: A reference to the resolver resource
-    /// @return A NFTView struct
-    ///
-    pub fun getNFTView(id: UInt64, viewResolver: &{Resolver}) : NFTView {
-        let nftView = viewResolver.resolveView(Type<NFTView>())
-        if nftView != nil {
-            return nftView! as! NFTView
-        }
-
-        return NFTView(
-            id : id,
-            uuid: viewResolver.uuid,
-            display: self.getDisplay(viewResolver),
-            externalURL : self.getExternalURL(viewResolver),
-            collectionData : self.getNFTCollectionData(viewResolver),
-            collectionDisplay : self.getNFTCollectionDisplay(viewResolver),
-            royalties : self.getRoyalties(viewResolver),
-            traits : self.getTraits(viewResolver)
-        )
-    }
+access(all) contract MetadataViews {
 
     /// Display is a basic view that includes the name, description and
     /// thumbnail for an object. Most objects should implement this view.
     ///
-    pub struct Display {
+    access(all) struct Display {
 
         /// The name of the object.
         ///
         /// This field will be displayed in lists and therefore should
         /// be short an concise.
         ///
-        pub let name: String
+        access(all) let name: String
 
         /// A written description of the object.
         ///
         /// This field will be displayed in a detailed view of the object,
         /// so can be more verbose (e.g. a paragraph instead of a single line).
         ///
-        pub let description: String
+        access(all) let description: String
 
         /// A small thumbnail representation of the object.
         ///
         /// This field should be a web-friendly file (i.e JPEG, PNG)
         /// that can be displayed in lists, link previews, etc.
         ///
-        pub let thumbnail: AnyStruct{File}
+        access(all) let thumbnail: {File}
 
-        init(
+        view init(
             name: String,
             description: String,
-            thumbnail: AnyStruct{File}
+            thumbnail: {File}
         ) {
             self.name = name
             self.description = description
@@ -130,7 +56,7 @@ pub contract MetadataViews {
     /// @param viewResolver: A reference to the resolver resource
     /// @return An optional Display struct
     ///
-    pub fun getDisplay(_ viewResolver: &{Resolver}) : Display? {
+    access(all) fun getDisplay(_ viewResolver: &{ViewResolver.Resolver}) : Display? {
         if let view = viewResolver.resolveView(Type<Display>()) {
             if let v = view as? Display {
                 return v
@@ -142,20 +68,20 @@ pub contract MetadataViews {
     /// Generic interface that represents a file stored on or off chain. Files
     /// can be used to references images, videos and other media.
     ///
-    pub struct interface File {
-        pub fun uri(): String
+    access(all) struct interface File {
+        access(all) view fun uri(): String
     }
 
     /// View to expose a file that is accessible at an HTTP (or HTTPS) URL.
     ///
-    pub struct HTTPFile: File {
-        pub let url: String
+    access(all) struct HTTPFile: File {
+        access(all) let url: String
 
-        init(url: String) {
+        view init(url: String) {
             self.url = url
         }
 
-        pub fun uri(): String {
+        access(all) view fun uri(): String {
             return self.url
         }
     }
@@ -165,13 +91,13 @@ pub contract MetadataViews {
     /// rather than a direct URI. A client application can use this CID
     /// to find and load the image via an IPFS gateway.
     ///
-    pub struct IPFSFile: File {
+    access(all) struct IPFSFile: File {
 
         /// CID is the content identifier for this IPFS file.
         ///
         /// Ref: https://docs.ipfs.io/concepts/content-addressing/
         ///
-        pub let cid: String
+        access(all) let cid: String
 
         /// Path is an optional path to the file resource in an IPFS directory.
         ///
@@ -179,9 +105,9 @@ pub contract MetadataViews {
         ///
         /// Ref: https://docs.ipfs.io/concepts/file-systems/
         ///
-        pub let path: String?
+        access(all) let path: String?
 
-        init(cid: String, path: String?) {
+        view init(cid: String, path: String?) {
             self.cid = cid
             self.path = path
         }
@@ -191,7 +117,7 @@ pub contract MetadataViews {
         ///
         /// @return The string containing the file uri
         ///
-        pub fun uri(): String {
+        access(all) view fun uri(): String {
             if let path = self.path {
                 return "ipfs://".concat(self.cid).concat("/").concat(path)
             }
@@ -200,89 +126,97 @@ pub contract MetadataViews {
         }
     }
 
-    /// Optional view for collections that issue multiple objects
-    /// with the same or similar metadata, for example an X of 100 set. This
-    /// information is useful for wallets and marketplaces.
-    /// An NFT might be part of multiple editions, which is why the edition
-    /// information is returned as an arbitrary sized array
+    /// View to represent a file with an correspoiding mediaType.
     ///
-    pub struct Edition {
+    access(all) struct Media {
 
-        /// The name of the edition
-        /// For example, this could be Set, Play, Series,
-        /// or any other way a project could classify its editions
-        pub let name: String?
-
-        /// The edition number of the object.
-        /// For an "24 of 100 (#24/100)" item, the number is 24.
-        pub let number: UInt64
+        /// File for the media
+        ///
+        access(all) let file: {File}
 
-        /// The max edition number of this type of objects.
-        /// This field should only be provided for limited-editioned objects.
-        /// For an "24 of 100 (#24/100)" item, max is 100.
-        /// For an item with unlimited edition, max should be set to nil.
+        /// media-type comes on the form of type/subtype as described here
+        /// https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types
         ///
-        pub let max: UInt64?
+        access(all) let mediaType: String
 
-        init(name: String?, number: UInt64, max: UInt64?) {
-            if max != nil {
-                assert(number <= max!, message: "The number cannot be greater than the max number!")
-            }
-            self.name = name
-            self.number = number
-            self.max = max
+        view init(file: {File}, mediaType: String) {
+          self.file=file
+          self.mediaType=mediaType
         }
     }
 
-    /// Wrapper view for multiple Edition views
+    /// Wrapper view for multiple media views
     ///
-    pub struct Editions {
+    access(all) struct Medias {
 
-        /// An arbitrary-sized list for any number of editions
-        /// that the NFT might be a part of
-        pub let infoList: [Edition]
+        /// An arbitrary-sized list for any number of Media items
+        access(all) let items: [Media]
 
-        init(_ infoList: [Edition]) {
-            self.infoList = infoList
+        view init(_ items: [Media]) {
+            self.items = items
         }
     }
 
-    /// Helper to get Editions in a typesafe way
+    /// Helper to get Medias in a typesafe way
     ///
     /// @param viewResolver: A reference to the resolver resource
-    /// @return An optional Editions struct
+    /// @return A optional Medias struct
     ///
-    pub fun getEditions(_ viewResolver: &{Resolver}) : Editions? {
-        if let view = viewResolver.resolveView(Type<Editions>()) {
-            if let v = view as? Editions {
+    access(all) fun getMedias(_ viewResolver: &{ViewResolver.Resolver}) : Medias? {
+        if let view = viewResolver.resolveView(Type<Medias>()) {
+            if let v = view as? Medias {
                 return v
             }
         }
         return nil
     }
 
-    /// View representing a project-defined serial number for a specific NFT
-    /// Projects have different definitions for what a serial number should be
-    /// Some may use the NFTs regular ID and some may use a different
-    /// classification system. The serial number is expected to be unique among
-    /// other NFTs within that project
+    /// View to represent a license according to https://spdx.org/licenses/
+    /// This view can be used if the content of an NFT is licensed.
     ///
-    pub struct Serial {
-        pub let number: UInt64
+    access(all) struct License {
+        access(all) let spdxIdentifier: String
 
-        init(_ number: UInt64) {
-            self.number = number
+        view init(_ identifier: String) {
+            self.spdxIdentifier = identifier
         }
     }
 
-    /// Helper to get Serial in a typesafe way
+    /// Helper to get License in a typesafe way
     ///
     /// @param viewResolver: A reference to the resolver resource
-    /// @return An optional Serial struct
+    /// @return A optional License struct
     ///
-    pub fun getSerial(_ viewResolver: &{Resolver}) : Serial? {
-        if let view = viewResolver.resolveView(Type<Serial>()) {
-            if let v = view as? Serial {
+    access(all) fun getLicense(_ viewResolver: &{ViewResolver.Resolver}) : License? {
+        if let view = viewResolver.resolveView(Type<License>()) {
+            if let v = view as? License {
+                return v
+            }
+        }
+        return nil
+    }
+
+    /// View to expose a URL to this item on an external site.
+    /// This can be used by applications like .find and Blocto to direct users
+    /// to the original link for an NFT or a project page that describes the NFT collection.
+    /// eg https://www.my-nft-project.com/overview-of-nft-collection
+    ///
+    access(all) struct ExternalURL {
+        access(all) let url: String
+
+        view init(_ url: String) {
+            self.url=url
+        }
+    }
+
+    /// Helper to get ExternalURL in a typesafe way
+    ///
+    /// @param viewResolver: A reference to the resolver resource
+    /// @return A optional ExternalURL struct
+    ///
+    access(all) fun getExternalURL(_ viewResolver: &{ViewResolver.Resolver}) : ExternalURL? {
+        if let view = viewResolver.resolveView(Type<ExternalURL>()) {
+            if let v = view as? ExternalURL {
                 return v
             }
         }
@@ -292,7 +226,7 @@ pub contract MetadataViews {
     /// View that defines the composable royalty standard that gives marketplaces a
     /// unified interface to support NFT royalties.
     ///
-    pub struct Royalty {
+    access(all) struct Royalty {
 
         /// Generic FungibleToken Receiver for the beneficiary of the royalty
         /// Can get the concrete type of the receiver with receiver.getType()
@@ -300,7 +234,7 @@ pub contract MetadataViews {
         /// receiver for this using `getRoyaltyReceiverPublicPath()`, and not
         /// use the default FlowToken receiver. This will allow users to update
         /// the capability in the future to use a more generic capability
-        pub let receiver: Capability<&AnyResource{FungibleToken.Receiver}>
+        access(all) let receiver: Capability<&{FungibleToken.Receiver}>
 
         /// Multiplier used to calculate the amount of sale value transferred to
         /// royalty receiver. Note - It should be between 0.0 and 1.0
@@ -311,14 +245,14 @@ pub contract MetadataViews {
         /// that already supports the basis points use case because its
         /// operations are entirely deterministic integer operations and support
         /// up to 8 points of precision.
-        pub let cut: UFix64
+        access(all) let cut: UFix64
 
         /// Optional description: This can be the cause of paying the royalty,
         /// the relationship between the `wallet` and the NFT, or anything else
         /// that the owner might want to specify.
-        pub let description: String
+        access(all) let description: String
 
-        init(receiver: Capability<&AnyResource{FungibleToken.Receiver}>, cut: UFix64, description: String) {
+        view init(receiver: Capability<&{FungibleToken.Receiver}>, cut: UFix64, description: String) {
             pre {
                 cut >= 0.0 && cut <= 1.0 : "Cut value should be in valid range i.e [0,1]"
             }
@@ -332,12 +266,12 @@ pub contract MetadataViews {
     /// Marketplaces can query this `Royalties` struct from NFTs
     /// and are expected to pay royalties based on these specifications.
     ///
-    pub struct Royalties {
+    access(all) struct Royalties {
 
         /// Array that tracks the individual royalties
         access(self) let cutInfos: [Royalty]
 
-        pub init(_ cutInfos: [Royalty]) {
+        access(all) view init(_ cutInfos: [Royalty]) {
             // Validate that sum of all cut multipliers should not be greater than 1.0
             var totalCut = 0.0
             for royalty in cutInfos {
@@ -352,7 +286,7 @@ pub contract MetadataViews {
         ///
         /// @return An array containing all the royalties structs
         ///
-        pub fun getRoyalties(): [Royalty] {
+        access(all) view fun getRoyalties(): [Royalty] {
             return self.cutInfos
         }
     }
@@ -362,7 +296,7 @@ pub contract MetadataViews {
     /// @param viewResolver: A reference to the resolver resource
     /// @return A optional Royalties struct
     ///
-    pub fun getRoyalties(_ viewResolver: &{Resolver}) : Royalties? {
+    access(all) fun getRoyalties(_ viewResolver: &{ViewResolver.Resolver}) : Royalties? {
         if let view = viewResolver.resolveView(Type<Royalties>()) {
             if let v = view as? Royalties {
                 return v
@@ -377,155 +311,334 @@ pub contract MetadataViews {
     ///
     /// @return The PublicPath for the generic FT receiver
     ///
-    pub fun getRoyaltyReceiverPublicPath(): PublicPath {
+    access(all) view fun getRoyaltyReceiverPublicPath(): PublicPath {
         return /public/GenericFTReceiver
     }
 
-    /// View to represent, a file with an correspoiding mediaType.
+    /// View to represent a single field of metadata on an NFT.
+    /// This is used to get traits of individual key/value pairs along with some
+    /// contextualized data about the trait
     ///
-    pub struct Media {
+    access(all) struct Trait {
+        // The name of the trait. Like Background, Eyes, Hair, etc.
+        access(all) let name: String
 
-        /// File for the media
+        // The underlying value of the trait, the rest of the fields of a trait provide context to the value.
+        access(all) let value: AnyStruct
+
+        // displayType is used to show some context about what this name and value represent
+        // for instance, you could set value to a unix timestamp, and specify displayType as "Date" to tell
+        // platforms to consume this trait as a date and not a number
+        access(all) let displayType: String?
+
+        // Rarity can also be used directly on an attribute.
+        //
+        // This is optional because not all attributes need to contribute to the NFT's rarity.
+        access(all) let rarity: Rarity?
+
+        view init(name: String, value: AnyStruct, displayType: String?, rarity: Rarity?) {
+            self.name = name
+            self.value = value
+            self.displayType = displayType
+            self.rarity = rarity
+        }
+    }
+
+    /// Wrapper view to return all the traits on an NFT.
+    /// This is used to return traits as individual key/value pairs along with
+    /// some contextualized data about each trait.
+    access(all) struct Traits {
+        access(all) let traits: [Trait]
+
+        view init(_ traits: [Trait]) {
+            self.traits = traits
+        }
+
+        /// Adds a single Trait to the Traits view
+        ///
+        /// @param Trait: The trait struct to be added
         ///
-        pub let file: AnyStruct{File}
+        access(all) fun addTrait(_ t: Trait) {
+            self.traits.append(t)
+        }
+    }
 
-        /// media-type comes on the form of type/subtype as described here
-        /// https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types
+    /// Helper to get Traits view in a typesafe way
+    ///
+    /// @param viewResolver: A reference to the resolver resource
+    /// @return A optional Traits struct
+    ///
+    access(all) fun getTraits(_ viewResolver: &{ViewResolver.Resolver}) : Traits? {
+        if let view = viewResolver.resolveView(Type<Traits>()) {
+            if let v = view as? Traits {
+                return v
+            }
+        }
+        return nil
+    }
+
+    /// Helper function to easily convert a dictionary to traits. For NFT
+    /// collections that do not need either of the optional values of a Trait,
+    /// this method should suffice to give them an array of valid traits.
+    ///
+    /// @param dict: The dictionary to be converted to Traits
+    /// @param excludedNames: An optional String array specifying the `dict`
+    ///         keys that are not wanted to become `Traits`
+    /// @return The generated Traits view
+    ///
+    access(all) fun dictToTraits(dict: {String: AnyStruct}, excludedNames: [String]?): Traits {
+        // Collection owners might not want all the fields in their metadata included.
+        // They might want to handle some specially, or they might just not want them included at all.
+        if excludedNames != nil {
+            for k in excludedNames! {
+                dict.remove(key: k)
+            }
+        }
+
+        let traits: [Trait] = []
+        for k in dict.keys {
+            let trait = Trait(name: k, value: dict[k]!, displayType: nil, rarity: nil)
+            traits.append(trait)
+        }
+
+        return Traits(traits)
+    }
+
+    /// Optional view for collections that issue multiple objects
+    /// with the same or similar metadata, for example an X of 100 set. This
+    /// information is useful for wallets and marketplaces.
+    /// An NFT might be part of multiple editions, which is why the edition
+    /// information is returned as an arbitrary sized array
+    ///
+    access(all) struct Edition {
+
+        /// The name of the edition
+        /// For example, this could be Set, Play, Series,
+        /// or any other way a project could classify its editions
+        access(all) let name: String?
+
+        /// The edition number of the object.
+        /// For an "24 of 100 (#24/100)" item, the number is 24.
+        access(all) let number: UInt64
+
+        /// The max edition number of this type of objects.
+        /// This field should only be provided for limited-editioned objects.
+        /// For an "24 of 100 (#24/100)" item, max is 100.
+        /// For an item with unlimited edition, max should be set to nil.
         ///
-        pub let mediaType: String
+        access(all) let max: UInt64?
 
-        init(file: AnyStruct{File}, mediaType: String) {
-          self.file=file
-          self.mediaType=mediaType
+        view init(name: String?, number: UInt64, max: UInt64?) {
+            if max != nil {
+                assert(number <= max!, message: "The number cannot be greater than the max number!")
+            }
+            self.name = name
+            self.number = number
+            self.max = max
         }
     }
 
-    /// Wrapper view for multiple media views
+    /// Wrapper view for multiple Edition views
     ///
-    pub struct Medias {
+    access(all) struct Editions {
 
-        /// An arbitrary-sized list for any number of Media items
-        pub let items: [Media]
+        /// An arbitrary-sized list for any number of editions
+        /// that the NFT might be a part of
+        access(all) let infoList: [Edition]
 
-        init(_ items: [Media]) {
-            self.items = items
+        view init(_ infoList: [Edition]) {
+            self.infoList = infoList
         }
     }
 
-    /// Helper to get Medias in a typesafe way
+    /// Helper to get Editions in a typesafe way
     ///
     /// @param viewResolver: A reference to the resolver resource
-    /// @return A optional Medias struct
+    /// @return An optional Editions struct
     ///
-    pub fun getMedias(_ viewResolver: &{Resolver}) : Medias? {
-        if let view = viewResolver.resolveView(Type<Medias>()) {
-            if let v = view as? Medias {
+    access(all) fun getEditions(_ viewResolver: &{ViewResolver.Resolver}) : Editions? {
+        if let view = viewResolver.resolveView(Type<Editions>()) {
+            if let v = view as? Editions {
                 return v
             }
         }
         return nil
     }
 
-    /// View to represent a license according to https://spdx.org/licenses/
-    /// This view can be used if the content of an NFT is licensed.
+    /// View representing a project-defined serial number for a specific NFT
+    /// Projects have different definitions for what a serial number should be
+    /// Some may use the NFTs regular ID and some may use a different
+    /// classification system. The serial number is expected to be unique among
+    /// other NFTs within that project
     ///
-    pub struct License {
-        pub let spdxIdentifier: String
+    access(all) struct Serial {
+        access(all) let number: UInt64
 
-        init(_ identifier: String) {
-            self.spdxIdentifier = identifier
+        view init(_ number: UInt64) {
+            self.number = number
         }
     }
 
-    /// Helper to get License in a typesafe way
+    /// Helper to get Serial in a typesafe way
     ///
     /// @param viewResolver: A reference to the resolver resource
-    /// @return A optional License struct
+    /// @return An optional Serial struct
     ///
-    pub fun getLicense(_ viewResolver: &{Resolver}) : License? {
-        if let view = viewResolver.resolveView(Type<License>()) {
-            if let v = view as? License {
+    access(all) fun getSerial(_ viewResolver: &{ViewResolver.Resolver}) : Serial? {
+        if let view = viewResolver.resolveView(Type<Serial>()) {
+            if let v = view as? Serial {
                 return v
             }
         }
         return nil
     }
 
-    /// View to expose a URL to this item on an external site.
-    /// This can be used by applications like .find and Blocto to direct users
-    /// to the original link for an NFT or a project page that describes the NFT collection.
-    /// eg https://www.my-nft-project.com/overview-of-nft-collection
+    /// View to expose rarity information for a single rarity
+    /// Note that a rarity needs to have either score or description but it can
+    /// have both
     ///
-    pub struct ExternalURL {
-        pub let url: String
+    access(all) struct Rarity {
+        /// The score of the rarity as a number
+        access(all) let score: UFix64?
 
-        init(_ url: String) {
-            self.url=url
+        /// The maximum value of score
+        access(all) let max: UFix64?
+
+        /// The description of the rarity as a string.
+        ///
+        /// This could be Legendary, Epic, Rare, Uncommon, Common or any other string value
+        access(all) let description: String?
+
+        view init(score: UFix64?, max: UFix64?, description: String?) {
+            if score == nil && description == nil {
+                panic("A Rarity needs to set score, description or both")
+            }
+
+            self.score = score
+            self.max = max
+            self.description = description
         }
     }
 
-    /// Helper to get ExternalURL in a typesafe way
+    /// Helper to get Rarity view in a typesafe way
     ///
     /// @param viewResolver: A reference to the resolver resource
-    /// @return A optional ExternalURL struct
+    /// @return A optional Rarity struct
     ///
-    pub fun getExternalURL(_ viewResolver: &{Resolver}) : ExternalURL? {
-        if let view = viewResolver.resolveView(Type<ExternalURL>()) {
-            if let v = view as? ExternalURL {
+    access(all) fun getRarity(_ viewResolver: &{ViewResolver.Resolver}) : Rarity? {
+        if let view = viewResolver.resolveView(Type<Rarity>()) {
+            if let v = view as? Rarity {
                 return v
             }
         }
         return nil
     }
 
+    /// NFTView wraps all Core views along `id` and `uuid` fields, and is used
+    /// to give a complete picture of an NFT. Most NFTs should implement this
+    /// view.
+    ///
+    access(all) struct NFTView {
+        access(all) let id: UInt64
+        access(all) let uuid: UInt64
+        access(all) let display: MetadataViews.Display?
+        access(all) let externalURL: MetadataViews.ExternalURL?
+        access(all) let collectionData: NFTCollectionData?
+        access(all) let collectionDisplay: NFTCollectionDisplay?
+        access(all) let royalties: Royalties?
+        access(all) let traits: Traits?
+
+        view init(
+            id : UInt64,
+            uuid : UInt64,
+            display : MetadataViews.Display?,
+            externalURL : MetadataViews.ExternalURL?,
+            collectionData : NFTCollectionData?,
+            collectionDisplay : NFTCollectionDisplay?,
+            royalties : Royalties?,
+            traits: Traits?
+        ) {
+            self.id = id
+            self.uuid = uuid
+            self.display = display
+            self.externalURL = externalURL
+            self.collectionData = collectionData
+            self.collectionDisplay = collectionDisplay
+            self.royalties = royalties
+            self.traits = traits
+        }
+    }
+
+    /// Helper to get an NFT view
+    ///
+    /// @param id: The NFT id
+    /// @param viewResolver: A reference to the resolver resource
+    /// @return A NFTView struct
+    ///
+    access(all) fun getNFTView(id: UInt64, viewResolver: &{ViewResolver.Resolver}) : NFTView {
+        let nftView = viewResolver.resolveView(Type<NFTView>())
+        if nftView != nil {
+            return nftView! as! NFTView
+        }
+
+        return NFTView(
+            id : id,
+            uuid: viewResolver.uuid,
+            display: MetadataViews.getDisplay(viewResolver),
+            externalURL : MetadataViews.getExternalURL(viewResolver),
+            collectionData : self.getNFTCollectionData(viewResolver),
+            collectionDisplay : self.getNFTCollectionDisplay(viewResolver),
+            royalties : self.getRoyalties(viewResolver),
+            traits : self.getTraits(viewResolver)
+        )
+    }
+
     /// View to expose the information needed store and retrieve an NFT.
     /// This can be used by applications to setup a NFT collection with proper
     /// storage and public capabilities.
     ///
-    pub struct NFTCollectionData {
+    access(all) struct NFTCollectionData {
         /// Path in storage where this NFT is recommended to be stored.
-        pub let storagePath: StoragePath
+        access(all) let storagePath: StoragePath
 
         /// Public path which must be linked to expose public capabilities of this NFT
         /// including standard NFT interfaces and metadataviews interfaces
-        pub let publicPath: PublicPath
+        access(all) let publicPath: PublicPath
 
         /// Private path which should be linked to expose the provider
         /// capability to withdraw NFTs from the collection holding NFTs
-        pub let providerPath: PrivatePath
+        access(all) let providerPath: PrivatePath
 
         /// Public collection type that is expected to provide sufficient read-only access to standard
-        /// functions (deposit + getIDs + borrowNFT)
-        /// This field is for backwards compatibility with collections that have not used the standard
-        /// NonFungibleToken.CollectionPublic interface when setting up collections. For new
+        /// functions (deposit + getIDs + borrowNFT). For new
         /// collections, this may be set to be equal to the type specified in `publicLinkedType`.
-        pub let publicCollection: Type
+        access(all) let publicCollection: Type
 
         /// Type that should be linked at the aforementioned public path. This is normally a
-        /// restricted type with many interfaces. Notably the `NFT.CollectionPublic`,
-        /// `NFT.Receiver`, and `MetadataViews.ResolverCollection` interfaces are required.
-        pub let publicLinkedType: Type
+        /// restricted type with many interfaces. Notably the
+        /// `NFT.Receiver`, and `ViewResolver.ResolverCollection` interfaces are required.
+        access(all) let publicLinkedType: Type
 
         /// Type that should be linked at the aforementioned private path. This is normally
         /// a restricted type with at a minimum the `NFT.Provider` interface
-        pub let providerLinkedType: Type
+        access(all) let providerLinkedType: Type
 
         /// Function that allows creation of an empty NFT collection that is intended to store
         /// this NFT.
-        pub let createEmptyCollection: ((): @NonFungibleToken.Collection)
+        access(all) let createEmptyCollection: fun(): @{NonFungibleToken.Collection}
 
-        init(
+        view init(
             storagePath: StoragePath,
             publicPath: PublicPath,
             providerPath: PrivatePath,
             publicCollection: Type,
             publicLinkedType: Type,
             providerLinkedType: Type,
-            createEmptyCollectionFunction: ((): @NonFungibleToken.Collection)
+            createEmptyCollectionFunction: fun(): @{NonFungibleToken.Collection}
         ) {
             pre {
-                publicLinkedType.isSubtype(of: Type<&{NonFungibleToken.CollectionPublic, NonFungibleToken.Receiver, MetadataViews.ResolverCollection}>()): "Public type must include NonFungibleToken.CollectionPublic, NonFungibleToken.Receiver, and MetadataViews.ResolverCollection interfaces."
-                providerLinkedType.isSubtype(of: Type<&{NonFungibleToken.Provider, NonFungibleToken.CollectionPublic, MetadataViews.ResolverCollection}>()): "Provider type must include NonFungibleToken.Provider, NonFungibleToken.CollectionPublic, and MetadataViews.ResolverCollection interface."
+                publicLinkedType.isSubtype(of: Type<&{NonFungibleToken.Receiver, ViewResolver.ResolverCollection}>()): "Public type must include NonFungibleToken.Receiver and ViewResolver.ResolverCollection interfaces."
+                providerLinkedType.isSubtype(of: Type<&{NonFungibleToken.Provider, ViewResolver.ResolverCollection}>()): "Provider type must include NonFungibleToken.Provider and ViewResolver.ResolverCollection interface."
             }
             self.storagePath=storagePath
             self.publicPath=publicPath
@@ -542,7 +655,7 @@ pub contract MetadataViews {
     /// @param viewResolver: A reference to the resolver resource
     /// @return A optional NFTCollectionData struct
     ///
-    pub fun getNFTCollectionData(_ viewResolver: &{Resolver}) : NFTCollectionData? {
+    access(all) fun getNFTCollectionData(_ viewResolver: &{ViewResolver.Resolver}) : NFTCollectionData? {
         if let view = viewResolver.resolveView(Type<NFTCollectionData>()) {
             if let v = view as? NFTCollectionData {
                 return v
@@ -555,33 +668,33 @@ pub contract MetadataViews {
     /// collection. This can be used by applications to give an overview and
     /// graphics of the NFT collection this NFT belongs to.
     ///
-    pub struct NFTCollectionDisplay {
+    access(all) struct NFTCollectionDisplay {
         // Name that should be used when displaying this NFT collection.
-        pub let name: String
+        access(all) let name: String
 
         // Description that should be used to give an overview of this collection.
-        pub let description: String
+        access(all) let description: String
 
         // External link to a URL to view more information about this collection.
-        pub let externalURL: ExternalURL
+        access(all) let externalURL: MetadataViews.ExternalURL
 
         // Square-sized image to represent this collection.
-        pub let squareImage: Media
+        access(all) let squareImage: MetadataViews.Media
 
         // Banner-sized image for this collection, recommended to have a size near 1200x630.
-        pub let bannerImage: Media
+        access(all) let bannerImage: MetadataViews.Media
 
         // Social links to reach this collection's social homepages.
         // Possible keys may be "instagram", "twitter", "discord", etc.
-        pub let socials: {String: ExternalURL}
+        access(all) let socials: {String: MetadataViews.ExternalURL}
 
-        init(
+        view init(
             name: String,
             description: String,
-            externalURL: ExternalURL,
-            squareImage: Media,
-            bannerImage: Media,
-            socials: {String: ExternalURL}
+            externalURL: MetadataViews.ExternalURL,
+            squareImage: MetadataViews.Media,
+            bannerImage: MetadataViews.Media,
+            socials: {String: MetadataViews.ExternalURL}
         ) {
             self.name = name
             self.description = description
@@ -598,7 +711,7 @@ pub contract MetadataViews {
     /// @param viewResolver: A reference to the resolver resource
     /// @return A optional NFTCollection struct
     ///
-    pub fun getNFTCollectionDisplay(_ viewResolver: &{Resolver}) : NFTCollectionDisplay? {
+    access(all) fun getNFTCollectionDisplay(_ viewResolver: &{ViewResolver.Resolver}) : NFTCollectionDisplay? {
         if let view = viewResolver.resolveView(Type<NFTCollectionDisplay>()) {
             if let v = view as? NFTCollectionDisplay {
                 return v
@@ -606,135 +719,4 @@ pub contract MetadataViews {
         }
         return nil
     }
-
-    /// View to expose rarity information for a single rarity
-    /// Note that a rarity needs to have either score or description but it can
-    /// have both
-    ///
-    pub struct Rarity {
-        /// The score of the rarity as a number
-        pub let score: UFix64?
-
-        /// The maximum value of score
-        pub let max: UFix64?
-
-        /// The description of the rarity as a string.
-        ///
-        /// This could be Legendary, Epic, Rare, Uncommon, Common or any other string value
-        pub let description: String?
-
-        init(score: UFix64?, max: UFix64?, description: String?) {
-            if score == nil && description == nil {
-                panic("A Rarity needs to set score, description or both")
-            }
-
-            self.score = score
-            self.max = max
-            self.description = description
-        }
-    }
-
-    /// Helper to get Rarity view in a typesafe way
-    ///
-    /// @param viewResolver: A reference to the resolver resource
-    /// @return A optional Rarity struct
-    ///
-    pub fun getRarity(_ viewResolver: &{Resolver}) : Rarity? {
-        if let view = viewResolver.resolveView(Type<Rarity>()) {
-            if let v = view as? Rarity {
-                return v
-            }
-        }
-        return nil
-    }
-
-    /// View to represent a single field of metadata on an NFT.
-    /// This is used to get traits of individual key/value pairs along with some
-    /// contextualized data about the trait
-    ///
-    pub struct Trait {
-        // The name of the trait. Like Background, Eyes, Hair, etc.
-        pub let name: String
-
-        // The underlying value of the trait, the rest of the fields of a trait provide context to the value.
-        pub let value: AnyStruct
-
-        // displayType is used to show some context about what this name and value represent
-        // for instance, you could set value to a unix timestamp, and specify displayType as "Date" to tell
-        // platforms to consume this trait as a date and not a number
-        pub let displayType: String?
-
-        // Rarity can also be used directly on an attribute.
-        //
-        // This is optional because not all attributes need to contribute to the NFT's rarity.
-        pub let rarity: Rarity?
-
-        init(name: String, value: AnyStruct, displayType: String?, rarity: Rarity?) {
-            self.name = name
-            self.value = value
-            self.displayType = displayType
-            self.rarity = rarity
-        }
-    }
-
-    /// Wrapper view to return all the traits on an NFT.
-    /// This is used to return traits as individual key/value pairs along with
-    /// some contextualized data about each trait.
-    pub struct Traits {
-        pub let traits: [Trait]
-
-        init(_ traits: [Trait]) {
-            self.traits = traits
-        }
-
-        /// Adds a single Trait to the Traits view
-        ///
-        /// @param Trait: The trait struct to be added
-        ///
-        pub fun addTrait(_ t: Trait) {
-            self.traits.append(t)
-        }
-    }
-
-    /// Helper to get Traits view in a typesafe way
-    ///
-    /// @param viewResolver: A reference to the resolver resource
-    /// @return A optional Traits struct
-    ///
-    pub fun getTraits(_ viewResolver: &{Resolver}) : Traits? {
-        if let view = viewResolver.resolveView(Type<Traits>()) {
-            if let v = view as? Traits {
-                return v
-            }
-        }
-        return nil
-    }
-
-    /// Helper function to easily convert a dictionary to traits. For NFT
-    /// collections that do not need either of the optional values of a Trait,
-    /// this method should suffice to give them an array of valid traits.
-    ///
-    /// @param dict: The dictionary to be converted to Traits
-    /// @param excludedNames: An optional String array specifying the `dict`
-    ///         keys that are not wanted to become `Traits`
-    /// @return The generated Traits view
-    ///
-    pub fun dictToTraits(dict: {String: AnyStruct}, excludedNames: [String]?): Traits {
-        // Collection owners might not want all the fields in their metadata included.
-        // They might want to handle some specially, or they might just not want them included at all.
-        if excludedNames != nil {
-            for k in excludedNames! {
-                dict.remove(key: k)
-            }
-        }
-
-        let traits: [Trait] = []
-        for k in dict.keys {
-            let trait = Trait(name: k, value: dict[k]!, displayType: nil, rarity: nil)
-            traits.append(trait)
-        }
-
-        return Traits(traits)
-    }
-
 }