@flowtyio/flow-contracts 0.1.0-beta.16 → 0.1.0-beta.17

package/contracts/NonFungibleToken.cdc

@@ -49,9 +49,6 @@ access(all) contract interface NonFungibleToken: ViewResolver {
     /// An entitlement for allowing updates and update events for an NFT
     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
     /// with an `Updatable` entitled reference to the NFT that was updated
@@ -63,7 +60,7 @@ access(all) contract interface NonFungibleToken: ViewResolver {
     /// and query the updated metadata from the owners' collections.
     ///
     access(all) event Updated(type: String, id: UInt64, uuid: UInt64, owner: Address?)
-    access(contract) view fun emitNFTUpdated(_ nftRef: auth(Update | Owner) &{NonFungibleToken.NFT})
+    access(all) view fun emitNFTUpdated(_ nftRef: auth(Update) &{NonFungibleToken.NFT})
     {
         emit Updated(type: nftRef.getType().identifier, id: nftRef.id, uuid: nftRef.uuid, owner: nftRef.owner?.address)
     }
@@ -85,9 +82,6 @@ access(all) contract interface NonFungibleToken: ViewResolver {
     ///
     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 {
@@ -105,6 +99,7 @@ access(all) contract interface NonFungibleToken: ViewResolver {
         access(all) fun createEmptyCollection(): @{Collection} {
             post {
                 result.getLength() == 0: "The created collection must be empty!"
+                result.isSupportedNFTType(type: self.getType()): "The created collection must support this NFT type"
             }
         }
 
@@ -141,7 +136,7 @@ access(all) contract interface NonFungibleToken: ViewResolver {
         /// withdraw removes an NFT from the collection and moves it to the caller
         /// It does not specify whether the ID is UUID or not
         /// @param withdrawID: The id of the NFT to withdraw from the collection
-        access(Withdraw | Owner) fun withdraw(withdrawID: UInt64): @{NFT} {
+        access(Withdraw) fun withdraw(withdrawID: UInt64): @{NFT} {
             post {
                 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)
@@ -174,6 +169,7 @@ access(all) contract interface NonFungibleToken: ViewResolver {
         access(all) fun deposit(token: @{NFT})
         access(all) view fun getLength(): Int
         access(all) view fun getIDs(): [UInt64]
+        access(all) fun forEachID(_ f: fun (UInt64): Bool): Void
         access(all) view fun borrowNFT(_ id: UInt64): &{NFT}?
     }
 
@@ -182,6 +178,8 @@ access(all) contract interface NonFungibleToken: ViewResolver {
     ///
     access(all) resource interface Collection: Provider, Receiver, CollectionPublic, ViewResolver.ResolverCollection {
 
+        access(all) var ownedNFTs: @{UInt64: {NonFungibleToken.NFT}}
+
         /// 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}) {
@@ -196,7 +194,16 @@ access(all) contract interface NonFungibleToken: ViewResolver {
 
         /// Gets the amount of NFTs stored in the collection
         /// @return An integer indicating the size of the collection
-        access(all) view fun getLength(): Int
+        access(all) view fun getLength(): Int {
+            return self.ownedNFTs.length
+        }
+
+        /// Allows a given function to iterate through the list
+        /// of owned NFT IDs in a collection without first
+        /// having to load the entire list into memory
+        access(all) fun forEachID(_ f: fun (UInt64): Bool): Void {
+            self.ownedNFTs.forEachKey(f)
+        }
 
         /// Borrows a reference to an NFT stored in the collection
         /// If the NFT with the specified ID is not in the collection,
@@ -231,4 +238,4 @@ access(all) contract interface NonFungibleToken: ViewResolver {
             result.getIDs().length == 0: "The created collection must be empty!"
         }
     }
-}
+}

package/contracts/dapper/TopShot.cdc

@@ -1060,7 +1060,7 @@ access(all) contract TopShot: NonFungibleToken {
     access(all) resource Collection: MomentCollectionPublic, NonFungibleToken.Collection {
         // Dictionary of Moment conforming tokens
         // NFT is a resource type with a UInt64 ID field
-        access(contract) var ownedNFTs: @{UInt64: {NonFungibleToken.NFT}}
+        access(all) var ownedNFTs: @{UInt64: {NonFungibleToken.NFT}}
 
         init() {
             self.ownedNFTs <- {}
@@ -1098,7 +1098,7 @@ access(all) contract TopShot: NonFungibleToken {
         // that is to be removed from the Collection
         //
         // returns: @NonFungibleToken.NFT the token that was withdrawn
-        access(NonFungibleToken.Withdraw | NonFungibleToken.Owner) fun withdraw(withdrawID: UInt64): @{NonFungibleToken.NFT} {
+        access(NonFungibleToken.Withdraw) fun withdraw(withdrawID: UInt64): @{NonFungibleToken.NFT} {
 
             // Borrow nft and check if locked
             let nft = self.borrowNFT(withdrawID)
@@ -1124,7 +1124,7 @@ access(all) contract TopShot: NonFungibleToken {
         // Returns: @NonFungibleToken.Collection: A collection that contains
         //                                        the withdrawn moments
         //
-        access(NonFungibleToken.Withdraw | NonFungibleToken.Owner) fun batchWithdraw(ids: [UInt64]): @{NonFungibleToken.Collection} {
+        access(NonFungibleToken.Withdraw) fun batchWithdraw(ids: [UInt64]): @{NonFungibleToken.Collection} {
             // Create a new empty Collection
             var batchCollection <- create Collection()
             
@@ -1181,7 +1181,7 @@ access(all) contract TopShot: NonFungibleToken {
 
         // lock takes a token id and a duration in seconds and locks
         // the moment for that duration
-        access(NonFungibleToken.Update | NonFungibleToken.Owner) fun lock(id: UInt64, duration: UFix64) {
+        access(NonFungibleToken.Update) fun lock(id: UInt64, duration: UFix64) {
             // Remove the nft from the Collection
             let token <- self.ownedNFTs.remove(key: id) 
                 ?? panic("Cannot lock: Moment does not exist in the collection")
@@ -1195,7 +1195,7 @@ access(all) contract TopShot: NonFungibleToken {
 
         // batchLock takes an array of token ids and a duration in seconds
         // it iterates through the ids and locks each for the specified duration
-        access(NonFungibleToken.Update | NonFungibleToken.Owner) fun batchLock(ids: [UInt64], duration: UFix64) {
+        access(NonFungibleToken.Update) fun batchLock(ids: [UInt64], duration: UFix64) {
             // Iterate through the ids and lock them
             for id in ids {
                 self.lock(id: id, duration: duration)
@@ -1204,7 +1204,7 @@ access(all) contract TopShot: NonFungibleToken {
 
         // unlock takes a token id and attempts to unlock it
         // TopShotLocking.unlockNFT contains business logic around unlock eligibility
-        access(NonFungibleToken.Update | NonFungibleToken.Owner) fun unlock(id: UInt64) {
+        access(NonFungibleToken.Update) fun unlock(id: UInt64) {
             // Remove the nft from the Collection
             let token <- self.ownedNFTs.remove(key: id) 
                 ?? panic("Cannot lock: Moment does not exist in the collection")
@@ -1218,7 +1218,7 @@ access(all) contract TopShot: NonFungibleToken {
 
         // batchUnlock takes an array of token ids
         // it iterates through the ids and unlocks each if they are eligible
-        access(NonFungibleToken.Update | NonFungibleToken.Owner) fun batchUnlock(ids: [UInt64]) {
+        access(NonFungibleToken.Update) fun batchUnlock(ids: [UInt64]) {
             // Iterate through the ids and unlocks them
             for id in ids {
                 self.unlock(id: id)
@@ -1230,7 +1230,7 @@ access(all) contract TopShot: NonFungibleToken {
         //
         // Parameters: ids: An array of NFT IDs
         // to be destroyed from the Collection
-        access(NonFungibleToken.Update | NonFungibleToken.Owner) fun destroyMoments(ids: [UInt64]) {
+        access(NonFungibleToken.Update) fun destroyMoments(ids: [UInt64]) {
             let topShotLockingAdmin = TopShot.account.storage.borrow<&TopShotLocking.Admin>(from: TopShotLocking.AdminStoragePath())
                 ?? panic("No TopShotLocking admin resource in storage")
 

package/contracts/dapper/offers/OffersV2.cdc

@@ -130,7 +130,7 @@ access(all) contract OffersV2 {
         // This will accept the offer if provided with the NFT id that matches the Offer
         //
         access(all) fun accept(
-            item: @{NonFungibleToken.INFT, ViewResolver.Resolver},
+            item: @{NonFungibleToken.NFT, ViewResolver.Resolver},
             receiverCapability: Capability<&{FungibleToken.Receiver}>,
         ): Void
         // getDetails
@@ -210,7 +210,7 @@ access(all) contract OffersV2 {
         // - Provided with a NFT matching the NFT Type within the Offer details.
         //
         access(all) fun accept(
-                item: @{NonFungibleToken.INFT, ViewResolver.Resolver},
+                item: @{NonFungibleToken.NFT, ViewResolver.Resolver},
                 receiverCapability: Capability<&{FungibleToken.Receiver}>,
             ): Void {
 
@@ -221,7 +221,7 @@ access(all) contract OffersV2 {
 
             let resolverCapability = self.resolverCapability.borrow() ?? panic("could not borrow resolver")
             let resolverResult = resolverCapability.checkOfferResolver(
-                item: &item as &{NonFungibleToken.INFT, ViewResolver.Resolver},
+                item: &item as &{NonFungibleToken.NFT, ViewResolver.Resolver},
                 offerParamsString: self.details.offerParamsString,
                 offerParamsUInt64: self.details.offerParamsUInt64,
                 offerParamsUFix64: self.details.offerParamsUFix64,

package/contracts/dapper/offers/Resolver.cdc

@@ -15,7 +15,7 @@ access(all) contract Resolver {
     // which is used within the Resolver resource for offer acceptance validation
     access(all) resource interface ResolverPublic {
         access(all) fun checkOfferResolver(
-         item: &{NonFungibleToken.INFT, ViewResolver.Resolver},
+         item: &{NonFungibleToken.NFT, ViewResolver.Resolver},
          offerParamsString: {String:String},
          offerParamsUInt64: {String:UInt64},
          offerParamsUFix64: {String:UFix64}): Bool
@@ -28,7 +28,7 @@ access(all) contract Resolver {
         // Holds the validation rules for resolver each type of supported ResolverType
         // Function returns TRUE if the provided nft item passes the criteria for exchange
         access(all) fun checkOfferResolver(
-         item: &{NonFungibleToken.INFT, ViewResolver.Resolver},
+         item: &{NonFungibleToken.NFT, ViewResolver.Resolver},
          offerParamsString: {String:String},
          offerParamsUInt64: {String:UInt64},
          offerParamsUFix64: {String:UFix64}): Bool {

package/contracts/example/ExampleNFT.cdc

@@ -164,7 +164,7 @@ access(all) contract ExampleNFT: ViewResolver {
 
         // dictionary of NFT conforming tokens
         // NFT is a resource type with an `UInt64` ID field
-        access(self) var ownedNFTs: @{UInt64: {NonFungibleToken.NFT}}
+        access(all) var ownedNFTs: @{UInt64: {NonFungibleToken.NFT}}
 
         init () {
             self.ownedNFTs <- {}
@@ -206,7 +206,7 @@ access(all) contract ExampleNFT: ViewResolver {
         }
 
         // withdraw removes an NFT from the collection and moves it to the caller
-        access(NonFungibleToken.Withdraw | NonFungibleToken.Owner) fun withdraw(withdrawID: UInt64): @{NonFungibleToken.NFT} {
+        access(NonFungibleToken.Withdraw) fun withdraw(withdrawID: UInt64): @{NonFungibleToken.NFT} {
             let token <- self.ownedNFTs.remove(key: withdrawID) ?? panic("missing NFT")
 
             emit Withdraw(id: token.id, from: self.owner?.address)

package/contracts/flow-utils/ScopedNFTProviders.cdc

@@ -78,7 +78,7 @@ access(all) contract ScopedNFTProviders {
     //
     // Wrapper around an NFT Provider that is restricted to specific ids.
     access(all) resource ScopedNFTProvider: NonFungibleToken.Provider {
-        access(self) let provider: Capability<auth(NonFungibleToken.Withdraw, NonFungibleToken.Owner) &{NonFungibleToken.Provider, NonFungibleToken.CollectionPublic}>
+        access(self) let provider: Capability<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Provider, NonFungibleToken.CollectionPublic}>
         access(self) let filters: [{NFTFilter}]
 
         // block timestamp that this provider can no longer be used after
@@ -91,7 +91,7 @@ access(all) contract ScopedNFTProviders {
             return false
         }
 
-        access(all) init(provider: Capability<auth(NonFungibleToken.Withdraw, NonFungibleToken.Owner) &{NonFungibleToken.Provider, NonFungibleToken.CollectionPublic}>, filters: [{NFTFilter}], expiration: UFix64?) {
+        access(all) init(provider: Capability<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Provider, NonFungibleToken.CollectionPublic}>, filters: [{NFTFilter}], expiration: UFix64?) {
             self.provider = provider
             self.expiration = expiration
             self.filters = filters
@@ -125,7 +125,7 @@ access(all) contract ScopedNFTProviders {
             return self.provider.check()
         }
 
-        access(NonFungibleToken.Withdraw | NonFungibleToken.Owner) fun withdraw(withdrawID: UInt64): @{NonFungibleToken.NFT} {
+        access(NonFungibleToken.Withdraw) fun withdraw(withdrawID: UInt64): @{NonFungibleToken.NFT} {
             pre {
                 !self.isExpired(): "provider has expired"
             }
@@ -157,7 +157,7 @@ access(all) contract ScopedNFTProviders {
     }
 
     access(all) fun createScopedNFTProvider(
-        provider: Capability<auth(NonFungibleToken.Withdraw, NonFungibleToken.Owner) &{NonFungibleToken.Provider, NonFungibleToken.CollectionPublic}>,
+        provider: Capability<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Provider, NonFungibleToken.CollectionPublic}>,
         filters: [{NFTFilter}],
         expiration: UFix64?
     ): @ScopedNFTProvider {

package/contracts/hybrid-custody/factories/FTVaultFactory.cdc

@@ -34,15 +34,12 @@ access(all) contract FTVaultFactory {
         }
 
         access(all) view fun getPublicCapability(acct: &Account, path: PublicPath): Capability? {
-            if let cap = acct.capabilities.get<&{FungibleToken.Vault}>(path) {
-                if !cap.check() {
-                    return nil
-                }
-                
-                return cap
+            let cap = acct.capabilities.get<&{FungibleToken.Vault}>(path)
+            if !cap.check() {
+                return nil
             }
-
-            return nil
+            
+            return cap
         }
     }
 }

package/contracts/hybrid-custody/factories/NFTCollectionFactory.cdc

@@ -5,11 +5,11 @@ access(all) contract NFTProviderAndCollectionFactory {
     access(all) struct WithdrawFactory: CapabilityFactory.Factory {
         access(all) view fun getCapability(acct: auth(Capabilities) &Account, controllerID: UInt64): Capability? {
             if let con = acct.capabilities.storage.getController(byCapabilityID: controllerID) {
-                if !con.capability.check<auth(NonFungibleToken.Withdraw, NonFungibleToken.Owner) &{NonFungibleToken.Collection}>() {
+                if !con.capability.check<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Collection}>() {
                     return nil
                 }
 
-                return con.capability as! Capability<auth(NonFungibleToken.Withdraw, NonFungibleToken.Owner) &{NonFungibleToken.Collection}>
+                return con.capability as! Capability<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Collection}>
             }
 
             return nil
@@ -34,15 +34,12 @@ access(all) contract NFTProviderAndCollectionFactory {
         }
 
         access(all) view fun getPublicCapability(acct: &Account, path: PublicPath): Capability? {
-            if let cap = acct.capabilities.get<&{NonFungibleToken.Collection}>(path) {
-                if !cap.check() {
-                    return nil
-                }
-                
-                return cap
+            let cap = acct.capabilities.get<&{NonFungibleToken.Collection}>(path)
+            if !cap.check() {
+                return nil
             }
-
-            return nil
+            
+            return cap
         }
     }
 }

package/contracts/hybrid-custody/factories/NFTProviderAndCollectionFactory.cdc

@@ -5,11 +5,11 @@ access(all) contract NFTProviderAndCollectionFactory {
     access(all) struct Factory: CapabilityFactory.Factory {
         access(all) view fun getCapability(acct: auth(Capabilities) &Account, controllerID: UInt64): Capability? {
             if let con = acct.capabilities.storage.getController(byCapabilityID: controllerID) {
-                if !con.capability.check<auth(NonFungibleToken.Withdraw, NonFungibleToken.Owner) &{NonFungibleToken.Provider, NonFungibleToken.CollectionPublic}>() {
+                if !con.capability.check<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Provider, NonFungibleToken.CollectionPublic}>() {
                     return nil
                 }
 
-                return con.capability as! Capability<auth(NonFungibleToken.Withdraw, NonFungibleToken.Owner) &{NonFungibleToken.Provider, NonFungibleToken.CollectionPublic}>
+                return con.capability as! Capability<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Provider, NonFungibleToken.CollectionPublic}>
             }
 
             return nil

package/contracts/hybrid-custody/factories/NFTProviderFactory.cdc

@@ -5,11 +5,11 @@ access(all) contract NFTProviderFactory {
     access(all) struct Factory: CapabilityFactory.Factory {
         access(all) view fun getCapability(acct: auth(Capabilities) &Account, controllerID: UInt64): Capability? {
             if let con = acct.capabilities.storage.getController(byCapabilityID: controllerID) {
-                if !con.capability.check<auth(NonFungibleToken.Withdraw, NonFungibleToken.Owner) &{NonFungibleToken.Provider}>() {
+                if !con.capability.check<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Provider}>() {
                     return nil
                 }
 
-                return con.capability as! Capability<auth(NonFungibleToken.Withdraw, NonFungibleToken.Owner) &{NonFungibleToken.Provider}>
+                return con.capability as! Capability<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Provider}>
             }
 
             return nil

package/package.json

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