Add NFT Storage Requirement to Collection and forEachID()

contracts/ExampleNFT.cdc

@@ -134,7 +134,7 @@ access(all) contract ExampleNFT: NonFungibleToken {
     access(all) resource Collection: NonFungibleToken.Collection, ExampleNFTCollectionPublic {
         /// dictionary of NFT conforming tokens
         /// NFT is a resource type with an `UInt64` ID field
-        access(contract) var ownedNFTs: @{UInt64: {NonFungibleToken.NFT}}
+        access(all) var ownedNFTs: @{UInt64: {NonFungibleToken.NFT}}
 
         init () {
             self.ownedNFTs <- {}
@@ -150,11 +150,7 @@ access(all) contract ExampleNFT: NonFungibleToken {
         /// Returns whether or not the given type is accepted by the collection
         /// A collection that can accept any type should just return true by default
         access(all) view fun isSupportedNFTType(type: Type): Bool {
-           if type == Type<@ExampleNFT.NFT>() {
-            return true
-           } else {
-            return false
-           }
+            return type == Type<@ExampleNFT.NFT>()
         }
 
         /// withdraw removes an NFT from the collection and moves it to the caller

contracts/NonFungibleToken.cdc

@@ -172,6 +172,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}?
     }
 
@@ -180,6 +181,10 @@ access(all) contract interface NonFungibleToken: ViewResolver {
     ///
     access(all) resource interface Collection: Provider, Receiver, CollectionPublic, ViewResolver.ResolverCollection {
 
+        /// Cadence allows implementing types to specify less restrictive access
+        /// so implementing contracts can have this as `access(all)` with no problem
+        access(contract) 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}) {
@@ -194,7 +199,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,

tests/example_nft_test.cdc

@@ -247,6 +247,18 @@ fun testGetCollectionLength() {
     Test.assertEqual(1, collectionLength)
 }
 
+access(all)
+fun testGetIterator() {
+    let scriptResult = executeScript(
+        "../transactions/scripts/iterate_ids.cdc",
+        [admin.address, 10]
+    )
+    Test.expect(scriptResult, Test.beSucceeded())
+
+    let nftRefArrayLength = scriptResult.returnValue! as! Int
+    Test.assertEqual(1, nftRefArrayLength)
+}
+
 access(all)
 fun testGetContractStoragePath() {
     let scriptResult = executeScript(

transactions/generic_transfer_with_address.cdc

@@ -38,10 +38,7 @@ transaction(to: Address, id: UInt64, contractAddress: Address, contractName: Str
         let recipient = getAccount(to)
 
         // borrow a public reference to the receivers collection
-        let receiverCap = recipient.capabilities.get<&{NonFungibleToken.Receiver}>(self.collectionData.publicPath)
-            ?? panic("Could not get the recipient's Receiver Capability")
-
-        let receiverRef = receiverCap.borrow()
+        let receiverRef = recipient.capabilities.borrow<&{NonFungibleToken.Receiver}>(self.collectionData.publicPath)
             ?? panic("Could not borrow reference to the recipient's receiver")
 
         // Deposit the NFT to the receiver

transactions/generic_transfer_with_paths.cdc

@@ -32,10 +32,7 @@ transaction(to: Address, id: UInt64, senderPathIdentifier: String, receiverPathI
         let recipient = getAccount(to)
 
         // borrow a public reference to the receivers collection
-        let receiverCap = recipient.capabilities.get<&{NonFungibleToken.Receiver}>(publicPath)
-            ?? panic("Could not get the recipient's Receiver Capability")
-
-        let receiverRef = receiverCap.borrow()
+        let receiverRef = recipient.capabilities.borrow<&{NonFungibleToken.Receiver}>(publicPath)
             ?? panic("Could not borrow reference to the recipient's receiver")
 
         // Deposit the NFT to the receiver

transactions/scripts/iterate_ids.cdc

@@ -0,0 +1,31 @@
+import "NonFungibleToken"
+
+access(all) fun main(ownerAddress: Address, limit: Int): Int {
+
+    let response: [&{NonFungibleToken.NFT}] = []
+
+    let account = getAuthAccount<auth(BorrowValue) &Account>(ownerAddress)
+
+    account.storage.forEachStored(fun (path: StoragePath, type: Type): Bool {
+
+        if !type.isSubtype(of: Type<@{NonFungibleToken.Collection}>()) {
+
+            return true
+        }
+
+        let storageCollection = account.storage.borrow<&{NonFungibleToken.Collection}>(from: path)!
+
+        storageCollection.forEachID(fun (nftId: UInt64): Bool {
+
+            let nft = storageCollection.borrowNFT(nftId)!
+
+            response.append(nft)
+
+            return response.length < limit
+        })
+
+        return response.length < limit
+    })
+
+    return response.length
+}