NODE-2618 Fixed GRPC getNFTList

grpc-server/src/test/scala/com/wavesplatform/api/grpc/test/AssetsApiGrpcSpec.scala

@@ -3,6 +3,7 @@ package com.wavesplatform.api.grpc.test
 import com.google.protobuf.ByteString
 import com.wavesplatform.account.KeyPair
 import com.wavesplatform.api.grpc.{AssetInfoResponse, AssetsApiGrpcImpl, NFTRequest, NFTResponse}
+import com.wavesplatform.block.Block.ProtoBlockVersion
 import com.wavesplatform.db.WithDomain
 import com.wavesplatform.db.WithState.AddrWithBalance
 import com.wavesplatform.features.BlockchainFeatures
@@ -55,6 +56,49 @@ class AssetsApiGrpcSpec extends FreeSpec with BeforeAndAfterAll with DiffMatcher
     }
   }
 
+  "NODE-999. GetNftList limit should work properly" in withDomain(
+    RideV6.addFeatures(BlockchainFeatures.ReduceNFTFee),
+    AddrWithBalance.enoughBalances(sender)
+  ) { d =>
+    val nftIssues = (1 to 5).map(idx => TxHelpers.issue(sender, 1, name = s"nft$idx", reissuable = false))
+    val limit     = 2
+    val afterId   = 1 // second element
+
+    d.appendBlock()
+    val mb1 = d.appendMicroBlock(nftIssues.take(afterId + 1)*)
+    d.appendMicroBlock(nftIssues.drop(afterId + 1)*)
+
+    // full liquid
+    d.rocksDBWriter.containsTransaction(nftIssues(afterId)) shouldBe false
+    d.rocksDBWriter.containsTransaction(nftIssues(afterId + 1)) shouldBe false
+    check()
+
+    // liquid afterId
+    d.appendBlock(d.createBlock(ProtoBlockVersion, nftIssues.drop(afterId + 1), Some(mb1)))
+    d.rocksDBWriter.containsTransaction(nftIssues(afterId)) shouldBe true
+    d.rocksDBWriter.containsTransaction(nftIssues(afterId + 1)) shouldBe false
+    check()
+
+    // full solid
+    d.appendBlock()
+    d.rocksDBWriter.containsTransaction(nftIssues(afterId)) shouldBe true
+    d.rocksDBWriter.containsTransaction(nftIssues(afterId + 1)) shouldBe true
+    check()
+
+    def check() = {
+      val (observer, result) = createObserver[NFTResponse]
+      val request = NFTRequest.of(
+        ByteString.copyFrom(sender.toAddress.bytes),
+        limit,
+        afterAssetId = ByteString.copyFrom(nftIssues(afterId).asset.id.arr)
+      )
+      getGrpcApi(d).getNFTList(request, observer)
+      val response = result.runSyncUnsafe()
+      response.size shouldBe limit
+      response.map(_.assetInfo.get.name) shouldBe nftIssues.slice(afterId + 1, afterId + limit + 1).map(_.name.toStringUtf8)
+    }
+  }
+
   private def getGrpcApi(d: Domain) =
     new AssetsApiGrpcImpl(d.assetsApi, d.accountsApi)
 }

node/src/main/scala/com/wavesplatform/api/common/AddressPortfolio.scala

@@ -29,9 +29,8 @@ class NFTIterator(addressId: AddressId, maybeAfter: Option[IssuedAsset], resourc
       def skipEntry(key: Array[Byte]): Boolean =
         !key.endsWith(after.id.arr)
 
-      while (dbIterator.isValid && skipEntry(dbIterator.key())) {
+      while (dbIterator.isValid && skipEntry(dbIterator.key()))
         dbIterator.next()
-      }
       if (dbIterator.isValid && !skipEntry(dbIterator.key()))
         dbIterator.next()
     }
@@ -100,18 +99,20 @@ class BalanceIterator(
     address: Address,
     underlying: Iterator[Seq[(IssuedAsset, Long)]],
     includeAsset: IssuedAsset => Boolean,
-    private var pendingOverrides: Map[(Address, Asset), Long]
+    private var pendingOverrides: Map[(Address, Asset), Long],
+    maybeAfter: Option[IssuedAsset]
 ) extends AbstractIterator[Seq[(IssuedAsset, Long)]] {
-
   private def nextOverride(): Seq[(IssuedAsset, Long)] =
     if (pendingOverrides.isEmpty) endOfData()
     else {
       val balances = pendingOverrides.collect {
         case ((`address`, asset: IssuedAsset), balance) if includeAsset(asset) =>
           asset -> balance
-      }.toSeq
+      }
       pendingOverrides = Map.empty
-      balances
+      maybeAfter.filter(balances.contains)
+        .fold(balances)(after => balances.dropWhile(_._1 != after).drop(1))
+        .toSeq
     }
 
   override def computeNext(): Seq[(IssuedAsset, Long)] =
@@ -139,10 +140,13 @@ object AddressPortfolio {
         .get(Keys.addressId(address))
         .fold(Iterator.empty[Seq[(IssuedAsset, Long)]])(addressId => new NFTIterator(addressId, maybeAfter, resource).asScala),
       asset => loadAssetDescription(asset).exists(_.nft),
-      snapshot.balances
+      snapshot.balances,
+      maybeAfter
     ).asScala
-      .map(_.collect { case (asset, balance) if balance > 0 => asset }
-        .flatMap(a => loadAssetDescription(a).map(a -> _)))
+      .map(
+        _.collect { case (asset, balance) if balance > 0 => asset }
+          .flatMap(a => loadAssetDescription(a).map(a -> _))
+      )
 
   def assetBalanceIterator(
       resource: DBResource,
@@ -156,9 +160,10 @@ object AddressPortfolio {
         .get(Keys.addressId(address))
         .fold(Iterator.empty[Seq[(IssuedAsset, Long)]])(addressId => new AssetBalanceIterator(addressId, resource).asScala),
       includeAsset,
-      snapshot.balances
+      snapshot.balances,
+      None
     ).asScala
-      .map(_.filter { case (asset, balance) =>
-        includeAsset(asset) && balance > 0
-      })
+      .map(
+        _.filter { case (asset, balance) => includeAsset(asset) && balance > 0 }
+      )
 }