@flowtyio/flow-contracts 0.1.0-beta.3 → 0.1.0-beta.4

package/contracts/Burner.cdc

@@ -0,0 +1,44 @@
+/// Burner is a contract that can facilitate the destruction of any resource on flow.
+///
+/// Contributors
+/// - Austin Kline - https://twitter.com/austin_flowty
+/// - Deniz Edincik - https://twitter.com/bluesign
+/// - Bastian Müller - https://twitter.com/turbolent
+access(all) contract Burner {
+    /// When Crescendo (Cadence 1.0) is released, custom destructors will be removed from cadece.
+    /// Burnable is an interface meant to replace this lost feature, allowing anyone to add a callback
+    /// method to ensure they do not destroy something which is not meant to be,
+    /// or to add logic based on destruction such as tracking the supply of a FT Collection
+    ///
+    /// NOTE: The only way to see benefit from this interface
+    /// is to always use the burn method in this contract. Anyone who owns a resource can always elect **not**
+    /// to destroy a resource this way
+    access(all) resource interface Burnable {
+        access(contract) fun burnCallback()
+    }
+
+    /// burn is a global method which will destroy any resource it is given.
+    /// If the provided resource implements the Burnable interface,
+    /// it will call the burnCallback method and then destroy afterwards.
+    access(all) fun burn(_ r: @AnyResource) {
+        if let s <- r as? @{Burnable} {
+            s.burnCallback()
+            destroy s
+        } else if let arr <- r as? @[AnyResource] {
+            while arr.length > 0 {
+                let item <- arr.removeFirst()
+                self.burn(<-item)
+            }
+            destroy arr
+        } else if let dict <- r as? @{HashableStruct: AnyResource} {
+            let keys = dict.keys
+            while keys.length > 0 {
+                let item <- dict.remove(key: keys.removeFirst())!
+                self.burn(<-item)
+            }
+            destroy dict
+        } else {
+            destroy r
+        }
+    }
+}

package/contracts/FlowStorageFees.cdc

@@ -1,17 +1,17 @@
 /*
  * The FlowStorageFees smart contract
  *
- * An account's storage capacity determines up to how much storage on chain it can use.
+ * An account's storage capacity determines up to how much storage on chain it can use. 
  * A storage capacity is calculated by multiplying the amount of reserved flow with `StorageFee.storageMegaBytesPerReservedFLOW`
  * The minimum amount of flow tokens reserved for storage capacity is `FlowStorageFees.minimumStorageReservation` this is paid during account creation, by the creator.
- *
- * At the end of all transactions, any account that had any value changed in their storage
+ * 
+ * At the end of all transactions, any account that had any value changed in their storage 
  * has their storage capacity checked against their storage used and their main flow token vault against the minimum reservation.
  * If any account fails this check the transaction wil fail.
- *
- * An account moving/deleting its `FlowToken.Vault` resource will result
+ * 
+ * An account moving/deleting its `FlowToken.Vault` resource will result 
  * in the transaction failing because the account will have no storage capacity.
- *
+ * 
  */
 
 import "FungibleToken"
@@ -26,8 +26,8 @@ access(all) contract FlowStorageFees {
     access(all) event MinimumStorageReservationChanged(_ minimumStorageReservation: UFix64)
 
     // Defines how much storage capacity every account has per reserved Flow token.
-    // definition is written per unit of flow instead of the inverse,
-    // so there is no loss of precision calculating storage from flow,
+    // definition is written per unit of flow instead of the inverse, 
+    // so there is no loss of precision calculating storage from flow, 
     // but there is loss of precision when calculating flow per storage.
     access(all) var storageMegaBytesPerReservedFLOW: UFix64
 
@@ -68,7 +68,7 @@ access(all) contract FlowStorageFees {
         let acct = getAccount(accountAddress)
 
         if let balanceRef = acct.capabilities.borrow<&FlowToken.Vault>(/public/flowTokenBalance) {
-            balance = balanceRef.getBalance()
+            balance = balanceRef.balance
         }
 
         return self.accountBalanceToAccountStorageCapacity(balance)
@@ -86,7 +86,7 @@ access(all) contract FlowStorageFees {
 
     // getAccountsCapacityForTransactionStorageCheck returns the storage capacity of a batch of accounts
     // This is used to check if a transaction will fail because of any account being over the storage capacity
-    // The payer is an exception as its storage capacity is derived from its balance minus the maximum possible transaction fees
+    // The payer is an exception as its storage capacity is derived from its balance minus the maximum possible transaction fees 
     // (transaction fees if the execution effort is at the execution efort limit, a.k.a.: computation limit, a.k.a.: gas limit)
     access(all) fun getAccountsCapacityForTransactionStorageCheck(accountAddresses: [Address], payer: Address, maxTxFees: UFix64): [UFix64] {
         let capacities: [UFix64] = []
@@ -97,13 +97,13 @@ access(all) contract FlowStorageFees {
             if let balanceRef = acct.capabilities.borrow<&FlowToken.Vault>(/public/flowTokenBalance) {
                 if accountAddress == payer {
                     // if the account is the payer, deduct the maximum possible transaction fees from the balance
-                    balance = balanceRef.getBalance().saturatingSubtract(maxTxFees)
+                    balance = balanceRef.balance.saturatingSubtract(maxTxFees)
                 } else {
-                    balance = balanceRef.getBalance()
+                    balance = balanceRef.balance
                 }
             }
 
-            capacities.append(self.accountBalanceToAccountStorageCapacity(balance))
+            capacities.append(self.accountBalanceToAccountStorageCapacity(balance)) 
         }
         return capacities
     }
@@ -117,7 +117,7 @@ access(all) contract FlowStorageFees {
             return 0.0
         }
 
-        // return balance multiplied with megabytes per flow
+        // return balance multiplied with megabytes per flow 
         return self.flowToStorageCapacity(balance)
     }
 
@@ -157,7 +157,7 @@ access(all) contract FlowStorageFees {
         var balance = 0.0
 
         if let balanceRef = acct.capabilities.borrow<&FlowToken.Vault>(/public/flowTokenBalance) {
-            balance = balanceRef.getBalance()
+            balance = balanceRef.balance
         }
 
         // get how much should be reserved for storage

package/contracts/FlowToken.cdc

@@ -1,16 +1,13 @@
 import "FungibleToken"
 import "MetadataViews"
 import "FungibleTokenMetadataViews"
-import "ViewResolver"
+import "Burner"
 
-access(all) contract FlowToken: ViewResolver {
+access(all) contract FlowToken: FungibleToken {
 
     // Total supply of Flow tokens in existence
     access(all) var totalSupply: UFix64
 
-    // Event that is emitted when the contract is created
-    access(all) event TokensInitialized(initialSupply: UFix64)
-
     // Event that is emitted when tokens are withdrawn from a Vault
     access(all) event TokensWithdrawn(amount: UFix64, from: Address?)
 
@@ -20,9 +17,6 @@ access(all) contract FlowToken: ViewResolver {
     // Event that is emitted when new tokens are minted
     access(all) event TokensMinted(amount: UFix64)
 
-    // Event that is emitted when tokens are destroyed
-    access(all) event TokensBurned(amount: UFix64)
-
     // Event that is emitted when a new minter resource is created
     access(all) event MinterCreated(allowedAmount: UFix64)
 
@@ -41,20 +35,24 @@ access(all) contract FlowToken: ViewResolver {
     // out of thin air. A special Minter resource needs to be defined to mint
     // new tokens.
     //
-    access(all) resource Vault: FungibleToken.Vault, FungibleToken.Provider, FungibleToken.Receiver, ViewResolver.Resolver {
+    access(all) resource Vault: FungibleToken.Vault {
 
         // holds the balance of a users tokens
         access(all) var balance: UFix64
 
-        access(all) view fun getBalance(): UFix64 {
-            return self.balance
-        }
-
         // initialize the balance at resource creation time
         init(balance: UFix64) {
             self.balance = balance
         }
 
+        /// Called when a fungible token is burned via the `Burner.burn()` method
+        access(contract) fun burnCallback() {
+            if self.balance > 0.0 {
+                FlowToken.totalSupply = FlowToken.totalSupply - self.balance
+            }
+            self.balance = 0.0
+        }
+
         /// getSupportedVaultTypes optionally returns a list of vault types that this receiver accepts
         access(all) view fun getSupportedVaultTypes(): {Type: Bool} {
             return {self.getType(): true}
@@ -64,14 +62,9 @@ access(all) contract FlowToken: ViewResolver {
             if (type == self.getType()) { return true } else { return false }
         }
 
-        /// Returns the storage path where the vault should typically be stored
-        access(all) view fun getDefaultStoragePath(): StoragePath? {
-            return /storage/flowTokenVault
-        }
-
-        /// Returns the public path where this vault should have a public capability
-        access(all) view fun getDefaultPublicPath(): PublicPath? {
-            return /public/flowTokenReceiver
+        /// Asks if the amount can be withdrawn from this vault
+        access(all) view fun isAvailableToWithdraw(amount: UFix64): Bool {
+            return amount <= self.balance
         }
 
         // withdraw
@@ -83,7 +76,7 @@ access(all) contract FlowToken: ViewResolver {
         // created Vault to the context that called so it can be deposited
         // elsewhere.
         //
-        access(FungibleToken.Withdrawable) fun withdraw(amount: UFix64): @{FungibleToken.Vault} {
+        access(FungibleToken.Withdraw) fun withdraw(amount: UFix64): @{FungibleToken.Vault} {
             self.balance = self.balance - amount
             emit TokensWithdrawn(amount: amount, from: self.owner?.address)
             return <-create Vault(balance: amount)
@@ -110,7 +103,7 @@ access(all) contract FlowToken: ViewResolver {
         ///         developers to know which parameter to pass to the resolveView() method.
         ///
         access(all) view fun getViews(): [Type]{
-            return FlowToken.getViews()
+            return FlowToken.getContractViews(resourceType: nil)
         }
 
         /// Get a Metadata View from FlowToken
@@ -119,7 +112,7 @@ access(all) contract FlowToken: ViewResolver {
         /// @return A structure representing the requested view.
         ///
         access(all) fun resolveView(_ view: Type): AnyStruct? {
-            return FlowToken.resolveView(view)
+            return FlowToken.resolveContractView(resourceType: nil, viewType: view)
         }
 
         access(all) fun createEmptyVault(): @{FungibleToken.Vault} {
@@ -134,11 +127,12 @@ access(all) contract FlowToken: ViewResolver {
     // and store the returned Vault in their storage in order to allow their
     // account to be able to receive deposits of this token type.
     //
-    access(all) fun createEmptyVault(): @FlowToken.Vault {
+    access(all) fun createEmptyVault(vaultType: Type): @FlowToken.Vault {
         return <-create Vault(balance: 0.0)
     }
 
-    access(all) view fun getViews(): [Type] {
+    /// Gets a list of the metadata views that this contract supports
+    access(all) view fun getContractViews(resourceType: Type?): [Type] {
         return [Type<FungibleTokenMetadataViews.FTView>(),
                 Type<FungibleTokenMetadataViews.FTDisplay>(),
                 Type<FungibleTokenMetadataViews.FTVaultData>(),
@@ -150,12 +144,12 @@ access(all) contract FlowToken: ViewResolver {
     /// @param view: The Type of the desired view.
     /// @return A structure representing the requested view.
     ///
-    access(all) fun resolveView(_ view: Type): AnyStruct? {
-        switch view {
+    access(all) fun resolveContractView(resourceType: Type?, viewType: Type): AnyStruct? {
+        switch viewType {
             case Type<FungibleTokenMetadataViews.FTView>():
                 return FungibleTokenMetadataViews.FTView(
-                    ftDisplay: self.resolveView(Type<FungibleTokenMetadataViews.FTDisplay>()) as! FungibleTokenMetadataViews.FTDisplay?,
-                    ftVaultData: self.resolveView(Type<FungibleTokenMetadataViews.FTVaultData>()) as! FungibleTokenMetadataViews.FTVaultData?
+                    ftDisplay: self.resolveContractView(resourceType: nil, viewType: Type<FungibleTokenMetadataViews.FTDisplay>()) as! FungibleTokenMetadataViews.FTDisplay?,
+                    ftVaultData: self.resolveContractView(resourceType: nil, viewType: Type<FungibleTokenMetadataViews.FTVaultData>()) as! FungibleTokenMetadataViews.FTVaultData?
                 )
             case Type<FungibleTokenMetadataViews.FTDisplay>():
                 let media = MetadataViews.Media(
@@ -176,16 +170,16 @@ access(all) contract FlowToken: ViewResolver {
                     }
                 )
             case Type<FungibleTokenMetadataViews.FTVaultData>():
+                let vaultRef = FlowToken.account.storage.borrow<auth(FungibleToken.Withdraw) &FlowToken.Vault>(from: /storage/flowTokenVault)
+			        ?? panic("Could not borrow reference to the contract's Vault!")
                 return FungibleTokenMetadataViews.FTVaultData(
                     storagePath: /storage/flowTokenVault,
                     receiverPath: /public/flowTokenReceiver,
                     metadataPath: /public/flowTokenBalance,
-                    providerPath: /private/flowTokenVault,
-                    receiverLinkedType: Type<&FlowToken.Vault>(),
-                    metadataLinkedType: Type<&FlowToken.Vault>(),
-                    providerLinkedType: Type<&FlowToken.Vault>(),
+                    receiverLinkedType: Type<&{FungibleToken.Receiver, FungibleToken.Vault}>(),
+                    metadataLinkedType: Type<&{FungibleToken.Balance, FungibleToken.Vault}>(),
                     createEmptyVaultFunction: (fun (): @{FungibleToken.Vault} {
-                        return <-FlowToken.createEmptyVault()
+                        return <-vaultRef.createEmptyVault()
                     })
                 )
             case Type<FungibleTokenMetadataViews.TotalSupply>():
@@ -203,15 +197,6 @@ access(all) contract FlowToken: ViewResolver {
             emit MinterCreated(allowedAmount: allowedAmount)
             return <-create Minter(allowedAmount: allowedAmount)
         }
-
-        // createNewBurner
-        //
-        // Function that creates and returns a new burner resource
-        //
-        access(all) fun createNewBurner(): @Burner {
-            emit BurnerCreated()
-            return <-create Burner()
-        }
     }
 
     // Minter
@@ -244,34 +229,6 @@ access(all) contract FlowToken: ViewResolver {
         }
     }
 
-    // Burner
-    //
-    // Resource object that token admin accounts can hold to burn tokens.
-    //
-    access(all) resource Burner {
-
-        // burnTokens
-        //
-        // Function that destroys a Vault instance, effectively burning the tokens.
-        //
-        // Note: the burned tokens are automatically subtracted from the
-        // total supply in the Vault destructor.
-        //
-        access(all) fun burnTokens(from: @FlowToken.Vault) {
-            FlowToken.burnTokens(from: <-from)
-        }
-    }
-
-    access(all) fun burnTokens(from: @FlowToken.Vault) {
-        let vault <- from as! @FlowToken.Vault
-        let amount = vault.balance
-        destroy vault
-        if amount > 0.0 {
-            FlowToken.totalSupply = FlowToken.totalSupply - amount
-            emit TokensBurned(amount: amount)
-        }
-    }
-
     /// Gets the Flow Logo XML URI from storage
     access(all) fun getLogoURI(): String {
         return FlowToken.account.storage.copy<String>(from: /storage/flowTokenLogoURI) ?? ""
@@ -284,9 +241,6 @@ access(all) contract FlowToken: ViewResolver {
         //
         let vault <- create Vault(balance: self.totalSupply)
 
-        // Example of how to resolve a metadata view for a Vault
-        let ftView = vault.resolveView(Type<FungibleTokenMetadataViews.FTView>())
-
         adminAccount.storage.save(<-vault, to: /storage/flowTokenVault)
 
         // Create a public capability to the stored Vault that only exposes
@@ -304,8 +258,5 @@ access(all) contract FlowToken: ViewResolver {
         let admin <- create Administrator()
         adminAccount.storage.save(<-admin, to: /storage/flowTokenAdmin)
 
-        // Emit an event that shows that the contract was initialized
-        emit TokensInitialized(initialSupply: self.totalSupply)
-
     }
 }

package/contracts/FungibleToken.cdc

@@ -32,6 +32,7 @@ to the Provider interface.
 */
 
 import "ViewResolver"
+import "Burner"
 
 /// FungibleToken
 ///
@@ -40,16 +41,28 @@ import "ViewResolver"
 /// utility methods that many projects will still want to have on their contracts,
 /// but they are by no means required. all that is required is that the token
 /// implements the `Vault` interface
-access(all) contract FungibleToken {
+access(all) contract interface FungibleToken: ViewResolver {
 
     // An entitlement for allowing the withdrawal of tokens from a Vault
-    access(all) entitlement Withdrawable
+    access(all) entitlement Withdraw
 
     /// The event that is emitted when tokens are withdrawn from a Vault
-    access(all) event Withdraw(amount: UFix64, from: Address?, type: String)
+    access(all) event Withdrawn(type: String, amount: UFix64, from: Address?, fromUUID: UInt64, withdrawnUUID: UInt64)
 
     /// The event that is emitted when tokens are deposited to a Vault
-    access(all) event Deposit(amount: UFix64, to: Address?, type: String)
+    access(all) event Deposited(type: String, amount: UFix64, to: Address?, toUUID: UInt64, depositedUUID: UInt64)
+
+    /// Event that is emitted when the global burn method is called with a non-zero balance
+    access(all) event Burned(type: String, amount: UFix64, fromUUID: UInt64)
+
+    /// Balance
+    ///
+    /// The interface that provides standard functions\
+    /// for getting balance information
+    ///
+    access(all) resource interface Balance {
+        access(all) var balance: UFix64
+    }
 
     /// Provider
     ///
@@ -62,27 +75,29 @@ access(all) contract FungibleToken {
     ///
     access(all) resource interface Provider {
 
-        /// withdraw subtracts tokens from the owner's Vault
+        /// Function to ask a provider if a specific amount of tokens
+        /// is available to be withdrawn
+        /// This could be useful to avoid panicing when calling withdraw
+        /// when the balance is unknown
+        /// Additionally, if the provider is pulling from multiple vaults
+        /// it only needs to check some of the vaults until the desired amount
+        /// is reached, potentially helping with performance.
+        /// 
+        access(all) view fun isAvailableToWithdraw(amount: UFix64): Bool
+
+        /// withdraw subtracts tokens from the implementing resource
         /// and returns a Vault with the removed tokens.
         ///
-        /// The function's access level is public, but this is not a problem
-        /// because only the owner storing the resource in their account
-        /// can initially call this function.
-        ///
-        /// The owner may grant other accounts access by creating a private
-        /// capability that allows specific other users to access
-        /// the provider resource through a reference.
-        ///
-        /// The owner may also grant all accounts access by creating a public
-        /// capability that allows all users to access the provider
-        /// resource through a reference.
+        /// The function's access level is `access(Withdraw)`
+        /// So in order to access it, one would either need the object itself
+        /// or an entitled reference with `Withdraw`.
         ///
-        access(Withdrawable) fun withdraw(amount: UFix64): @{Vault} {
+        access(Withdraw) fun withdraw(amount: UFix64): @{Vault} {
             post {
                 // `result` refers to the return value
-                result.getBalance() == amount:
+                result.balance == amount:
                     "Withdrawal amount must be the same as the balance of the withdrawn Vault"
-                emit Withdraw(amount: amount, from: self.owner?.address, type: self.getType().identifier)
+                emit Withdrawn(type: self.getType().identifier, amount: amount, from: self.owner?.address, fromUUID: self.uuid, withdrawnUUID: result.uuid)
             }
         }
     }
@@ -104,15 +119,11 @@ access(all) contract FungibleToken {
         access(all) fun deposit(from: @{Vault})
 
         /// getSupportedVaultTypes optionally returns a list of vault types that this receiver accepts
-        access(all) view fun getSupportedVaultTypes(): {Type: Bool} {
-            pre { true: "dummy" }
-        }
+        access(all) view fun getSupportedVaultTypes(): {Type: Bool}
 
         /// Returns whether or not the given type is accepted by the Receiver
         /// A vault that can accept any type should just return true by default
-        access(all) view fun isSupportedVaultType(type: Type): Bool {
-            pre { true: "dummy" }
-        }
+        access(all) view fun isSupportedVaultType(type: Type): Bool
     }
 
     /// Vault
@@ -120,17 +131,35 @@ access(all) contract FungibleToken {
     /// Ideally, this interface would also conform to Receiver, Balance, Transferor, Provider, and Resolver
     /// but that is not supported yet
     ///
-    access(all) resource interface Vault: Receiver, Provider, ViewResolver.Resolver {
-
-        //access(all) event ResourceDestroyed(balance: UFix64 = self.getBalance())
-
-        /// Get the balance of the vault
-        access(all) view fun getBalance(): UFix64
+    access(all) resource interface Vault: Receiver, Provider, Balance, ViewResolver.Resolver, Burner.Burnable {
+
+        /// Field that tracks the balance of a vault
+        access(all) var balance: UFix64
+
+        /// Called when a fungible token is burned via the `Burner.burn()` method
+        /// Implementations can do any bookkeeping or emit any events
+        /// that should be emitted when a vault is destroyed.
+        /// Many implementations will want to update the token's total supply
+        /// to reflect that the tokens have been burned and removed from the supply.
+        /// Implementations also need to set the balance to zero before the end of the function
+        /// This is to prevent vault owners from spamming fake Burned events.
+        access(contract) fun burnCallback() {
+            pre {
+                emit Burned(type: self.getType().identifier, amount: self.balance, fromUUID: self.uuid)
+            }
+            post {
+                self.balance == 0.0: "The balance must be set to zero during the burnCallback method so that it cannot be spammed"
+            }
+            self.balance = 0.0
+        }
 
         /// getSupportedVaultTypes optionally returns a list of vault types that this receiver accepts
+        /// The default implementation is included here because vaults are expected
+        /// to only accepted their own type, so they have no need to provide an implementation
+        /// for this function
         access(all) view fun getSupportedVaultTypes(): {Type: Bool} {
             // Below check is implemented to make sure that run-time type would
-            // only get returned when the parent resource conforms with `FungibleToken.Vault`.
+            // only get returned when the parent resource conforms with `FungibleToken.Vault`. 
             if self.getType().isSubtype(of: Type<@{FungibleToken.Vault}>()) {
                 return {self.getType(): true}
             } else {
@@ -140,36 +169,25 @@ access(all) contract FungibleToken {
             }
         }
 
+        /// Checks if the given type is supported by this Vault
         access(all) view fun isSupportedVaultType(type: Type): Bool {
             return self.getSupportedVaultTypes()[type] ?? false
         }
 
-        /// Returns the storage path where the vault should typically be stored
-        access(all) view fun getDefaultStoragePath(): StoragePath?
-
-        /// Returns the public path where this vault should have a public capability
-        access(all) view fun getDefaultPublicPath(): PublicPath?
-
-        /// Returns the public path where this vault's Receiver should have a public capability
-        /// Publishing a Receiver Capability at a different path enables alternate Receiver implementations to be used
-        /// in the same canonical namespace as the underlying Vault.
-        access(all) view fun getDefaultReceiverPath(): PublicPath? {
-            return nil
-        }
-
         /// withdraw subtracts `amount` from the Vault's balance
         /// and returns a new Vault with the subtracted balance
         ///
-        access(Withdrawable) fun withdraw(amount: UFix64): @{Vault} {
+        access(Withdraw) fun withdraw(amount: UFix64): @{Vault} {
             pre {
-                self.getBalance() >= amount:
+                self.balance >= amount:
                     "Amount withdrawn must be less than or equal than the balance of the Vault"
             }
             post {
+                result.getType() == self.getType(): "Must return the same vault type as self"
                 // use the special function `before` to get the value of the `balance` field
                 // at the beginning of the function execution
                 //
-                self.getBalance() == before(self.getBalance()) - amount:
+                self.balance == before(self.balance) - amount:
                     "New Vault balance must be the difference of the previous balance and the withdrawn Vault balance"
             }
         }
@@ -180,12 +198,12 @@ access(all) contract FungibleToken {
             // Assert that the concrete type of the deposited vault is the same
             // as the vault that is accepting the deposit
             pre {
-                from.isInstance(self.getType()):
+                from.isInstance(self.getType()): 
                     "Cannot deposit an incompatible token type"
-                emit Deposit(amount: from.getBalance(), to: self.owner?.address, type: from.getType().identifier)
+                emit Deposited(type: from.getType().identifier, amount: from.balance, to: self.owner?.address, toUUID: self.uuid, depositedUUID: from.uuid)
             }
             post {
-                self.getBalance() == before(self.getBalance()) + before(from.getBalance()):
+                self.balance == before(self.balance) + before(from.balance):
                     "New Vault balance must be the sum of the previous balance and the deposited Vault"
             }
         }
@@ -194,8 +212,17 @@ access(all) contract FungibleToken {
         ///
         access(all) fun createEmptyVault(): @{Vault} {
             post {
-                result.getBalance() == 0.0: "The newly created Vault must have zero balance"
+                result.balance == 0.0: "The newly created Vault must have zero balance"
             }
         }
     }
-}
+
+    /// createEmptyVault allows any user to create a new Vault that has a zero balance
+    ///
+    access(all) fun createEmptyVault(vaultType: Type): @{FungibleToken.Vault} {
+        post {
+            result.getType() == vaultType: "The returned vault does not match the desired type"
+            result.balance == 0.0: "The newly created Vault must have zero balance"
+        }
+    }
+}

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

@@ -134,7 +134,7 @@ access(all) contract MetadataViews {
         ///
         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
@@ -197,7 +197,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
     ///
@@ -223,27 +223,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 +263,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 +353,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 +377,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 +494,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 +534,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 +569,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 +594,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 +605,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 +619,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 +649,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 {
@@ -705,7 +689,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

package/contracts/NonFungibleToken.cdc

@@ -2,20 +2,17 @@
 
 ## The Flow Non-Fungible Token standard
 
-## `NonFungibleToken` contract interface
+## `NonFungibleToken` contract
 
 The interface that all Non-Fungible Token contracts should conform to.
-If a user wants to deploy a new NFT contract, their contract would need
-to implement the NonFungibleToken interface.
+If a user wants to deploy a new NFT contract, their contract should implement
+The types defined here
 
-Their contract must follow all the rules and naming
-that the interface specifies.
-
-## `NFT` resource
+## `NFT` resource interface
 
 The core resource type that represents an NFT in the smart contract.
 
-## `Collection` Resource
+## `Collection` Resource interface
 
 The resource that stores a user's NFT collection.
 It includes a few functions to allow the owner to easily
@@ -26,10 +23,8 @@ move tokens in and out of the collection.
 These interfaces declare functions with some pre and post conditions
 that require the Collection to follow certain naming and behavior standards.
 
-They are separate because it gives the user the ability to share a reference
-to their Collection that only exposes the fields and functions in one or more
-of the interfaces. It also gives users the ability to make custom resources
-that implement these interfaces to do various things with the tokens.
+They are separate because it gives developers the ability to define functions
+that can use any type that implements these interfaces
 
 By using resources and interfaces, users of NFT smart contracts can send
 and receive tokens peer-to-peer, without having to interact with a central ledger
@@ -43,16 +38,19 @@ Collection to complete the transfer.
 
 import "ViewResolver"
 
-/// The main NFT contract interface. Other NFT contracts will
-/// import and implement this interface
+/// The main NFT contract. Other NFT contracts will
+/// import and implement the interfaces defined in this contract
 ///
-access(all) contract NonFungibleToken {
+access(all) contract interface NonFungibleToken: ViewResolver {
 
     /// An entitlement for allowing the withdrawal of tokens from a Vault
-    access(all) entitlement Withdrawable
+    access(all) entitlement Withdraw
 
     /// An entitlement for allowing updates and update events for an NFT
-    access(all) entitlement Updatable
+    access(all) entitlement Update
+
+    /// entitlement for owner that grants Withdraw and Update
+    access(all) entitlement Owner
 
     /// Event that contracts should emit when the metadata of an NFT is updated
     /// It can only be emitted by calling the `emitNFTUpdated` function
@@ -60,45 +58,69 @@ access(all) contract NonFungibleToken {
     /// The entitlement prevents spammers from calling this from other users' collections
     /// because only code within a collection or that has special entitled access
     /// to the collections methods will be able to get the entitled reference
-    ///
+    /// 
     /// The event makes it so that third-party indexers can monitor the events
     /// and query the updated metadata from the owners' collections.
     ///
-    access(all) event Updated(id: UInt64, uuid: UInt64, owner: Address?, type: String)
-    access(all) view fun emitNFTUpdated(_ nftRef: auth(Updatable) &{NonFungibleToken.NFT})
+    access(all) event Updated(type: String, id: UInt64, uuid: UInt64, owner: Address?)
+    access(contract) view fun emitNFTUpdated(_ nftRef: auth(Update | Owner) &{NonFungibleToken.NFT})
     {
-        emit Updated(id: nftRef.getID(), uuid: nftRef.uuid, owner: nftRef.owner?.address, type: nftRef.getType().identifier)
+        emit Updated(type: nftRef.getType().identifier, id: nftRef.id, uuid: nftRef.uuid, owner: nftRef.owner?.address)
     }
 
 
     /// Event that is emitted when a token is withdrawn,
-    /// indicating the owner of the collection that it was withdrawn from.
+    /// indicating the type, id, uuid, the owner of the collection that it was withdrawn from,
+    /// and the UUID of the resource it was withdrawn from, usually a collection.
     ///
     /// If the collection is not in an account's storage, `from` will be `nil`.
     ///
-    access(all) event Withdraw(id: UInt64, uuid: UInt64, from: Address?, type: String)
+    access(all) event Withdrawn(type: String, id: UInt64, uuid: UInt64, from: Address?, providerUUID: UInt64)
 
     /// Event that emitted when a token is deposited to a collection.
+    /// Indicates the type, id, uuid, the owner of the collection that it was deposited to,
+    /// and the UUID of the collection it was deposited to
     ///
-    /// It indicates the owner of the collection that it was deposited to.
+    /// If the collection is not in an account's storage, `from`, will be `nil`.
     ///
-    access(all) event Deposit(id: UInt64, uuid: UInt64, to: Address?, type: String)
+    access(all) event Deposited(type: String, id: UInt64, uuid: UInt64, to: Address?, collectionUUID: UInt64)
+
+    /// Included for backwards-compatibility
+    access(all) resource interface INFT: NFT {}
 
     /// Interface that the NFTs must conform to
     ///
     access(all) resource interface NFT: ViewResolver.Resolver {
-        /// The unique ID that each NFT has
-        access(all) view fun getID(): UInt64
 
-        // access(all) event ResourceDestroyed(uuid: UInt64 = self.uuid, type: self.getType().identifier)
+        /// unique ID for the NFT
+        access(all) let id: UInt64
+
+        /// Event that is emitted automatically every time a resource is destroyed
+        /// The type information is included in the metadata event so it is not needed as an argument
+        access(all) event ResourceDestroyed(id: UInt64 = self.id, uuid: UInt64 = self.uuid)
+
+        /// createEmptyCollection creates an empty Collection that is able to store the NFT
+        /// and returns it to the caller so that they can own NFTs
+        /// @return A an empty collection that can store this NFT
+        access(all) fun createEmptyCollection(): @{Collection} {
+            post {
+                result.getLength() == 0: "The created collection must be empty!"
+            }
+        }
+
+        /// Gets all the NFTs that this NFT directly owns
+        /// @return A dictionary of all subNFTS keyed by type
+        access(all) view fun getAvailableSubNFTS(): {Type: UInt64} {
+            return {}
+        }
 
         /// Get a reference to an NFT that this NFT owns
         /// Both arguments are optional to allow the NFT to choose
         /// how it returns sub NFTs depending on what arguments are provided
-        /// For example, if `type` has a value, but `id` doesn't, the NFT
+        /// For example, if `type` has a value, but `id` doesn't, the NFT 
         /// can choose which NFT of that type to return if there is a "default"
         /// If both are `nil`, then NFTs that only store a single NFT can just return
-        /// that. This helps callers who aren't sure what they are looking for
+        /// that. This helps callers who aren't sure what they are looking for 
         ///
         /// @param type: The Type of the desired NFT
         /// @param id: The id of the NFT to borrow
@@ -109,7 +131,7 @@ access(all) contract NonFungibleToken {
         }
     }
 
-    /// Interface to mediate withdraws from the Collection
+    /// Interface to mediate withdrawals from a resource, usually a Collection
     ///
     access(all) resource interface Provider {
 
@@ -118,10 +140,11 @@ access(all) contract NonFungibleToken {
 
         /// withdraw removes an NFT from the collection and moves it to the caller
         /// It does not specify whether the ID is UUID or not
-        access(Withdrawable) fun withdraw(withdrawID: UInt64): @{NFT} {
+        /// @param withdrawID: The id of the NFT to withdraw from the collection
+        access(Withdraw | Owner) fun withdraw(withdrawID: UInt64): @{NFT} {
             post {
-                result.getID() == withdrawID: "The ID of the withdrawn token must be the same as the requested ID"
-                emit Withdraw(id: result.getID(), uuid: result.uuid, from: self.owner?.address, type: result.getType().identifier)
+                result.id == withdrawID: "The ID of the withdrawn token must be the same as the requested ID"
+                emit Withdrawn(type: result.getType().identifier, id: result.id, uuid: result.uuid, from: self.owner?.address, providerUUID: self.uuid)
             }
         }
     }
@@ -131,61 +154,81 @@ access(all) contract NonFungibleToken {
     access(all) resource interface Receiver {
 
         /// deposit takes an NFT as an argument and adds it to the Collection
-        ///
+        /// @param token: The NFT to deposit
         access(all) fun deposit(token: @{NFT})
 
         /// getSupportedNFTTypes returns a list of NFT types that this receiver accepts
+        /// @return A dictionary of types mapped to booleans indicating if this
+        ///         reciever supports it
         access(all) view fun getSupportedNFTTypes(): {Type: Bool}
 
         /// 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
+        /// @param type: An NFT type
+        /// @return A boolean indicating if this receiver can recieve the desired NFT type
         access(all) view fun isSupportedNFTType(type: Type): Bool
     }
 
+    /// Kept for backwards-compatibility reasons
+    access(all) resource interface CollectionPublic {
+        access(all) fun deposit(token: @{NFT})
+        access(all) view fun getLength(): Int
+        access(all) view fun getIDs(): [UInt64]
+        access(all) view fun borrowNFT(_ id: UInt64): &{NFT}?
+    }
+
     /// Requirement for the concrete resource type
     /// to be declared in the implementing contract
     ///
-    access(all) resource interface Collection: Provider, Receiver, ViewResolver.ResolverCollection {
-
-        /// Return the default storage path for the collection
-        access(all) view fun getDefaultStoragePath(): StoragePath?
+    access(all) resource interface Collection: Provider, Receiver, CollectionPublic, ViewResolver.ResolverCollection {
 
-        /// Return the default public path for the collection
-        access(all) view fun getDefaultPublicPath(): PublicPath?
-
-        /// Normally we would require that the collection specify
-        /// a specific dictionary to store the NFTs, but this isn't necessary any more
-        /// as long as all the other functions are there
-
-        /// createEmptyCollection creates an empty Collection
-        /// and returns it to the caller so that they can own NFTs
-        access(all) fun createEmptyCollection(): @{Collection} {
-            post {
-                result.getLength() == 0: "The created collection must be empty!"
-            }
-        }
-
-        /// deposit takes a NFT and adds it to the collections dictionary
-        /// and adds the ID to the id array
+        /// deposit takes a NFT as an argument and stores it in the collection
+        /// @param token: The NFT to deposit into the collection
         access(all) fun deposit(token: @{NonFungibleToken.NFT}) {
             pre {
                 // We emit the deposit event in the `Collection` interface
                 // because the `Collection` interface is almost always the final destination
                 // of tokens and deposit emissions from custom receivers could be confusing
                 // and hard to reconcile to event listeners
-                emit Deposit(id: token.getID(), uuid: token.uuid, to: self.owner?.address, type: token.getType().identifier)
+                emit Deposited(type: token.getType().identifier, id: token.id, uuid: token.uuid, to: self.owner?.address, collectionUUID: self.uuid)
             }
         }
 
         /// Gets the amount of NFTs stored in the collection
+        /// @return An integer indicating the size of the collection
         access(all) view fun getLength(): Int
 
+        /// Borrows a reference to an NFT stored in the collection
+        /// If the NFT with the specified ID is not in the collection,
+        /// the function should return `nil` and not panic.
+        ///
+        /// @param id: The desired nft id in the collection to return a referece for.
+        /// @return An optional reference to the NFT
         access(all) view fun borrowNFT(_ id: UInt64): &{NonFungibleToken.NFT}? {
             post {
-                (result == nil) || (result?.getID() == id):
+                (result == nil) || (result?.id == id): 
                     "Cannot borrow NFT reference: The ID of the returned reference does not match the ID that was specified"
             }
-            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(): @{Collection} {
+            post {
+                result.getType() == self.getType(): "The created collection does not have the same type as this collection"
+                result.getLength() == 0: "The created collection must be empty!"
+            }
+        }
+    }
+
+    /// createEmptyCollection creates an empty Collection for the specified NFT type
+    /// and returns it to the caller so that they can own NFTs
+    /// @param nftType: The desired nft type to return a collection for.
+    /// @return An array of NFT Types that the implementing contract defines.
+    access(all) fun createEmptyCollection(nftType: Type): @{NonFungibleToken.Collection} {
+        post {
+            result.getIDs().length == 0: "The created collection must be empty!"
         }
     }
 }

package/contracts/ViewResolver.cdc

@@ -1,43 +1,47 @@
-// Taken from the NFT Metadata standard, this contract exposes an interface to let
+// Taken from the NFT Metadata standard, this contract exposes an interface to let 
 // anyone borrow a contract and resolve views on it.
 //
 // This will allow you to obtain information about a contract without necessarily knowing anything about it.
 // All you need is its address and name and you're good to go!
 access(all) contract interface ViewResolver {
 
-    /// Function that returns all the Metadata Views implemented by the resolving contract
+    /// Function that returns all the Metadata Views implemented by the resolving contract.
+    /// Some contracts may have multiple resource types that support metadata views
+    /// so there there is an optional parameter for specify which resource type the caller
+    /// is looking for views for.
+    /// Some contract-level views may be type-agnostic. In that case, the contract
+    /// should return the same views regardless of what type is passed in.
     ///
+    /// @param resourceType: An optional resource type to return views for
     /// @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 getViews(): [Type] {
-        return []
-    }
+    access(all) view fun getContractViews(resourceType: Type?): [Type]
 
     /// Function that resolves a metadata view for this token.
+    /// Some contracts may have multiple resource types that support metadata views
+    /// so there there is an optional parameter for specify which resource type the caller
+    /// is looking for views for.
+    /// Some contract-level views may be type-agnostic. In that case, the contract
+    /// should return the same views regardless of what type is passed in.
     ///
+    /// @param resourceType: An optional resource type to return views for
     /// @param view: The Type of the desired view.
     /// @return A structure representing the requested view.
     ///
-    access(all) fun resolveView(_ view: Type): AnyStruct? {
-        return nil
-    }
+    access(all) fun resolveContractView(resourceType: Type?, viewType: Type): AnyStruct?
 
-    /// Provides access to a set of metadata views. A struct or
-    /// resource (e.g. an NFT) can implement this interface to provide access to
+    /// 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.
     ///
     access(all) resource interface Resolver {
 
         /// Same as getViews above, but on a specific NFT instead of a contract
-        access(all) view fun getViews(): [Type] {
-            return []
-        }
+        access(all) view fun getViews(): [Type]
 
         /// Same as resolveView above, but on a specific NFT instead of a contract
-        access(all) fun resolveView(_ view: Type): AnyStruct? {
-            return nil
-        }
+        access(all) fun resolveView(_ view: Type): AnyStruct?
     }
 
     /// A group of view resolvers indexed by ID.

package/contracts/example/ExampleNFT.cdc

@@ -110,10 +110,8 @@ access(all) contract ExampleNFT: ViewResolver {
                     return MetadataViews.NFTCollectionData(
                         storagePath: ExampleNFT.CollectionStoragePath,
                         publicPath: ExampleNFT.CollectionPublicPath,
-                        providerPath: /private/exampleNFTCollection,
                         publicCollection: Type<&ExampleNFT.Collection>(),
                         publicLinkedType: Type<&ExampleNFT.Collection>(),
-                        providerLinkedType: Type<auth(NonFungibleToken.Withdrawable) &ExampleNFT.Collection>(),
                         createEmptyCollectionFunction: (fun (): @{NonFungibleToken.Collection} {
                             return <-ExampleNFT.createEmptyCollection()
                         })

package/flow.json

@@ -1,6 +1,7 @@
 {
   "networks": {
     "emulator": "127.0.0.1:3569",
+    "testing": "127.0.0.1:3569",
     "mainnet": "access.mainnet.nodes.onflow.org:9000",
     "sandboxnet": "access.sandboxnet.nodes.onflow.org:9000",
     "testnet": "access.devnet.nodes.onflow.org:9000"
@@ -28,6 +29,14 @@
         "mainnet": "0x1d7e57aa55817448"
       }
     },
+    "Burner": {
+      "source": "./contracts/Burner.cdc",
+      "aliases": {
+        "emulator": "0xf8d6e0586b0a20c7",
+        "testnet": "0x631e88ae7f1d7c20",
+        "mainnet": "0x1d7e57aa55817448"
+      }
+    },
     "MetadataViews": {
       "source": "./contracts/MetadataViews.cdc",
       "aliases": {
@@ -342,6 +351,7 @@
   "deployments": {
     "emulator": {
       "emulator-account": [
+        "Burner",
         "NonFungibleToken",
         "MetadataViews",
         "ViewResolver",

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@flowtyio/flow-contracts",
-    "version": "0.1.0-beta.3",
+    "version": "0.1.0-beta.4",
     "main": "index.json",
     "description": "An NPM package for common flow contracts",
     "author": "flowtyio",