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

package/contracts/FungibleTokenMetadataViews.cdc

@@ -4,21 +4,21 @@ import "ViewResolver"
 
 /// This contract implements the metadata standard proposed
 /// in FLIP-1087.
-///
+/// 
 /// Ref: https://github.com/onflow/flips/blob/main/application/20220811-fungible-tokens-metadata.md
-///
+/// 
 /// Structs and resources can implement one or more
 /// metadata types, called views. Each view type represents
 /// a different kind of metadata.
 ///
 access(all) contract FungibleTokenMetadataViews {
 
-    /// FTView wraps FTDisplay and FTVaultData, and is used to give a complete
-    /// picture of a Fungible Token. Most Fungible Token contracts should
+    /// FTView wraps FTDisplay and FTVaultData, and is used to give a complete 
+    /// picture of a Fungible Token. Most Fungible Token contracts should 
     /// implement this view.
     ///
     access(all) struct FTView {
-        access(all) let ftDisplay: FTDisplay?
+        access(all) let ftDisplay: FTDisplay?     
         access(all) let ftVaultData: FTVaultData?
         view init(
             ftDisplay: FTDisplay?,
@@ -45,8 +45,8 @@ access(all) contract FungibleTokenMetadataViews {
         )
     }
 
-    /// View to expose the information needed to showcase this FT.
-    /// This can be used by applications to give an overview and
+    /// View to expose the information needed to showcase this FT. 
+    /// This can be used by applications to give an overview and 
     /// graphics of the FT.
     ///
     access(all) struct FTDisplay {
@@ -94,7 +94,7 @@ access(all) contract FungibleTokenMetadataViews {
     }
 
     /// Helper to get FTDisplay in a way that will return a typed optional.
-    ///
+    /// 
     /// @param viewResolver: A reference to the resolver resource
     /// @return An optional FTDisplay struct
     ///
@@ -108,7 +108,7 @@ access(all) contract FungibleTokenMetadataViews {
     }
 
     /// View to expose the information needed store and interact with a FT vault.
-    /// This can be used by applications to setup a FT vault with proper
+    /// This can be used by applications to setup a FT vault with proper 
     /// storage and public capabilities.
     ///
     access(all) struct FTVaultData {
@@ -121,22 +121,14 @@ access(all) contract FungibleTokenMetadataViews {
         /// Public path which must be linked to expose the balance and resolver public capabilities.
         access(all) let metadataPath: PublicPath
 
-        /// Private path which should be linked to expose the provider capability to withdraw funds
-        /// from the vault.
-        access(all) let providerPath: PrivatePath
-
-        /// Type that should be linked at the `receiverPath`. This is a restricted type requiring
+        /// Type that should be linked at the `receiverPath`. This is a restricted type requiring 
         /// the `FungibleToken.Receiver` interface.
         access(all) let receiverLinkedType: Type
 
-        /// Type that should be linked at the `receiverPath`. This is a restricted type requiring
+        /// Type that should be linked at the `receiverPath`. This is a restricted type requiring 
         /// the `ViewResolver.Resolver` interfaces.
         access(all) let metadataLinkedType: Type
 
-        /// Type that should be linked at the aforementioned private path. This
-        /// is normally a restricted type with at a minimum the `FungibleToken.Provider` interface.
-        access(all) let providerLinkedType: Type
-
         /// Function that allows creation of an empty FT vault that is intended
         /// to store the funds.
         access(all) let createEmptyVault: fun(): @{FungibleToken.Vault}
@@ -145,24 +137,19 @@ access(all) contract FungibleTokenMetadataViews {
             storagePath: StoragePath,
             receiverPath: PublicPath,
             metadataPath: PublicPath,
-            providerPath: PrivatePath,
             receiverLinkedType: Type,
             metadataLinkedType: Type,
-            providerLinkedType: Type,
             createEmptyVaultFunction: fun(): @{FungibleToken.Vault}
         ) {
             pre {
                 receiverLinkedType.isSubtype(of: Type<&{FungibleToken.Receiver}>()): "Receiver public type must include FungibleToken.Receiver."
-                metadataLinkedType.isSubtype(of: Type<&{ViewResolver.Resolver}>()): "Metadata public type must include ViewResolver.Resolver interfaces."
-                providerLinkedType.isSubtype(of: Type<&{FungibleToken.Provider}>()): "Provider type must include FungibleToken.Provider interface."
+                metadataLinkedType.isSubtype(of: Type<&{FungibleToken.Vault}>()): "Metadata linked type must be a fungible token vault"
             }
             self.storagePath = storagePath
             self.receiverPath = receiverPath
             self.metadataPath = metadataPath
-            self.providerPath = providerPath
             self.receiverLinkedType = receiverLinkedType
             self.metadataLinkedType = metadataLinkedType
-            self.providerLinkedType = providerLinkedType
             self.createEmptyVault = createEmptyVaultFunction
         }
     }
@@ -190,3 +177,4 @@ access(all) contract FungibleTokenMetadataViews {
         }
     }
 }
+ 

package/contracts/MetadataViews.cdc

@@ -126,15 +126,39 @@ access(all) contract MetadataViews {
         }
     }
 
-    /// View to represent a file with an correspoiding mediaType.
-    ///
+    /// A struct to represent a generic URI. May be used to represent the URI of
+    /// the NFT where the type of URI is not able to be determined (i.e. HTTP,
+    /// IPFS, etc.)
+    ///
+    access(all) struct URI: File {
+        /// The base URI prefix, if any. Not needed for all URIs, but helpful
+        /// for some use cases For example, updating a whole NFT collection's
+        /// image host easily
+        ///
+        access(all) let baseURI: String?
+        /// The URI string value
+        /// NOTE: this is set on init as a concatenation of the baseURI and the
+        /// value if baseURI != nil
+        ///
+        access(self) let value: String
+
+        access(all) view fun uri(): String {
+            return self.value
+        }
+
+        init(baseURI: String?, value: String) {
+            self.baseURI = baseURI
+            self.value = baseURI != nil ? baseURI!.concat(value) : value
+        }
+    }
+
     access(all) struct Media {
 
         /// File for the media
         ///
         access(all) let file: {File}
 
-        /// media-type comes on the form of type/subtype as described here
+        /// 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
         ///
         access(all) let mediaType: String
@@ -185,7 +209,7 @@ access(all) contract MetadataViews {
     /// Helper to get License in a typesafe way
     ///
     /// @param viewResolver: A reference to the resolver resource
-    /// @return A optional License struct
+    /// @return An optional License struct
     ///
     access(all) fun getLicense(_ viewResolver: &{ViewResolver.Resolver}) : License? {
         if let view = viewResolver.resolveView(Type<License>()) {
@@ -197,7 +221,7 @@ access(all) contract MetadataViews {
     }
 
     /// 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
+    /// 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
     ///
@@ -212,7 +236,7 @@ access(all) contract MetadataViews {
     /// Helper to get ExternalURL in a typesafe way
     ///
     /// @param viewResolver: A reference to the resolver resource
-    /// @return A optional ExternalURL struct
+    /// @return An optional ExternalURL struct
     ///
     access(all) fun getExternalURL(_ viewResolver: &{ViewResolver.Resolver}) : ExternalURL? {
         if let view = viewResolver.resolveView(Type<ExternalURL>()) {
@@ -223,27 +247,27 @@ access(all) contract MetadataViews {
         return nil
     }
 
-    /// View that defines the composable royalty standard that gives marketplaces a
+    /// View that defines the composable royalty standard that gives marketplaces a 
     /// unified interface to support NFT royalties.
     ///
     access(all) struct Royalty {
 
         /// Generic FungibleToken Receiver for the beneficiary of the royalty
         /// Can get the concrete type of the receiver with receiver.getType()
-        /// Recommendation - Users should create a new link for a FlowToken
-        /// receiver for this using `getRoyaltyReceiverPublicPath()`, and not
-        /// use the default FlowToken receiver. This will allow users to update
+        /// Recommendation - Users should create a new link for a FlowToken 
+        /// 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
         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
-        /// Ex - If the sale value is x and multiplier is 0.56 then the royalty
+        /// Multiplier used to calculate the amount of sale value transferred to 
+        /// royalty receiver. Note - It should be between 0.0 and 1.0 
+        /// Ex - If the sale value is x and multiplier is 0.56 then the royalty 
         /// value would be 0.56 * x.
         /// Generally percentage get represented in terms of basis points
-        /// in solidity based smart contracts while cadence offers `UFix64`
-        /// that already supports the basis points use case because its
-        /// operations are entirely deterministic integer operations and support
+        /// in solidity based smart contracts while cadence offers `UFix64` 
+        /// that already supports the basis points use case because its 
+        /// operations are entirely deterministic integer operations and support 
         /// up to 8 points of precision.
         access(all) let cut: UFix64
 
@@ -263,7 +287,7 @@ access(all) contract MetadataViews {
     }
 
     /// Wrapper view for multiple Royalty views.
-    /// Marketplaces can query this `Royalties` struct from NFTs
+    /// Marketplaces can query this `Royalties` struct from NFTs 
     /// and are expected to pay royalties based on these specifications.
     ///
     access(all) struct Royalties {
@@ -353,9 +377,9 @@ access(all) contract MetadataViews {
         view init(_ traits: [Trait]) {
             self.traits = traits
         }
-
+            
         /// Adds a single Trait to the Traits view
-        ///
+        /// 
         /// @param Trait: The trait struct to be added
         ///
         access(all) fun addTrait(_ t: Trait) {
@@ -377,8 +401,8 @@ access(all) contract MetadataViews {
         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,
+    /// 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
@@ -494,7 +518,7 @@ access(all) contract MetadataViews {
     }
 
     /// View to expose rarity information for a single rarity
-    /// Note that a rarity needs to have either score or description but it can
+    /// Note that a rarity needs to have either score or description but it can 
     /// have both
     ///
     access(all) struct Rarity {
@@ -534,8 +558,8 @@ access(all) contract MetadataViews {
         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
+    /// 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 {
@@ -569,7 +593,7 @@ access(all) contract MetadataViews {
         }
     }
 
-    /// Helper to get an NFT view
+    /// Helper to get an NFT view 
     ///
     /// @param id: The NFT id
     /// @param viewResolver: A reference to the resolver resource
@@ -594,7 +618,7 @@ access(all) contract MetadataViews {
     }
 
     /// View to expose the information needed store and retrieve an NFT.
-    /// This can be used by applications to setup a NFT collection with proper
+    /// This can be used by applications to setup a NFT collection with proper 
     /// storage and public capabilities.
     ///
     access(all) struct NFTCollectionData {
@@ -605,24 +629,13 @@ access(all) contract MetadataViews {
         /// including standard NFT interfaces and metadataviews interfaces
         access(all) let publicPath: PublicPath
 
-        /// Private path which should be linked to expose the provider
-        /// capability to withdraw NFTs from the collection holding NFTs
-        access(all) let providerPath: PrivatePath
-
-        /// Public collection type that is expected to provide sufficient read-only access to standard
-        /// functions (deposit + getIDs + borrowNFT). For new
-        /// collections, this may be set to be equal to the type specified in `publicLinkedType`.
+        /// The concrete type of the collection that is exposed to the public
+        /// now that entitlements exist, it no longer needs to be restricted to a specific interface
         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.Receiver`, and `ViewResolver.ResolverCollection` interfaces are required.
+        /// Type that should be linked at the aforementioned public path
         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
-        access(all) let providerLinkedType: Type
-
         /// Function that allows creation of an empty NFT collection that is intended to store
         /// this NFT.
         access(all) let createEmptyCollection: fun(): @{NonFungibleToken.Collection}
@@ -630,22 +643,17 @@ access(all) contract MetadataViews {
         view init(
             storagePath: StoragePath,
             publicPath: PublicPath,
-            providerPath: PrivatePath,
             publicCollection: Type,
             publicLinkedType: Type,
-            providerLinkedType: Type,
             createEmptyCollectionFunction: fun(): @{NonFungibleToken.Collection}
         ) {
             pre {
-                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."
+                publicLinkedType.isSubtype(of: Type<&{NonFungibleToken.Collection}>()): "Public type must be a subtype of NonFungibleToken.Collection interface."
             }
             self.storagePath=storagePath
             self.publicPath=publicPath
-            self.providerPath = providerPath
             self.publicCollection=publicCollection
             self.publicLinkedType=publicLinkedType
-            self.providerLinkedType = providerLinkedType
             self.createEmptyCollection=createEmptyCollectionFunction
         }
     }
@@ -665,7 +673,7 @@ access(all) contract MetadataViews {
     }
 
     /// View to expose the information needed to showcase this NFT's
-    /// collection. This can be used by applications to give an overview and
+    /// collection. This can be used by applications to give an overview and 
     /// graphics of the NFT collection this NFT belongs to.
     ///
     access(all) struct NFTCollectionDisplay {
@@ -681,7 +689,7 @@ access(all) contract MetadataViews {
         // Square-sized image to represent this collection.
         access(all) let squareImage: MetadataViews.Media
 
-        // Banner-sized image for this collection, recommended to have a size near 1200x630.
+        // Banner-sized image for this collection, recommended to have a size near 1400x350.
         access(all) let bannerImage: MetadataViews.Media
 
         // Social links to reach this collection's social homepages.
@@ -705,7 +713,7 @@ access(all) contract MetadataViews {
         }
     }
 
-    /// Helper to get NFTCollectionDisplay in a way that will return a typed
+    /// Helper to get NFTCollectionDisplay in a way that will return a typed 
     /// Optional
     ///
     /// @param viewResolver: A reference to the resolver resource
@@ -719,4 +727,53 @@ access(all) contract MetadataViews {
         }
         return nil
     }
-}
+    /// This view may be used by Cadence-native projects to define their
+    /// contract- and token-level metadata according to EVM-compatible formats.
+    /// Several ERC standards (e.g. ERC20, ERC721, etc.) expose name and symbol
+    /// values to define assets as well as contract- & token-level metadata view
+    /// `tokenURI(uint256)` and `contractURI()` methods. This view enables
+    /// Cadence projects to define in their own contracts how they would like
+    /// their metadata to be defined when bridged to EVM.
+    ///
+    access(all) struct EVMBridgedMetadata {
+
+        /// The name of the asset
+        ///
+        access(all) let name: String
+
+        /// The symbol of the asset
+        ///
+        access(all) let symbol: String
+
+        /// The URI of the asset - this can either be contract-level or
+        /// token-level URI depending on where the metadata is resolved. It
+        /// is recommended to reference EVM metadata standards for how to best
+        /// prepare your view's formatted value.
+        ///
+        /// For example, while you may choose to take advantage of onchain
+        /// metadata, as is the case for most Cadence NFTs, you may also choose
+        /// to represent your asset's metadata in IPFS and assign this value as
+        /// an IPFSFile struct pointing to that IPFS file. Alternatively, you
+        /// may serialize your NFT's metadata and assign it as a JSON string
+        /// data URL representating the NFT's onchain metadata at the time this
+        /// view is resolved.
+        ///
+        access(all) let uri: {File}
+
+        init(name: String, symbol: String, uri: {File}) {
+            self.name = name
+            self.symbol = symbol
+            self.uri = uri
+        }
+    }
+
+    access(all) fun getEVMBridgedMetadata(_ viewResolver: &{ViewResolver.Resolver}) : EVMBridgedMetadata? {
+        if let view = viewResolver.resolveView(Type<EVMBridgedMetadata>()) {
+            if let v = view as? EVMBridgedMetadata {
+                return v
+            }
+        }
+        return nil
+    }
+
+}