update txs infos

Author: memekas

nodecore-spv/src/main/java/org/veriblock/spv/SpvContext.kt

@@ -148,7 +148,6 @@ class SpvContext(
                 logger.info { "SPV Disconnected" }
             }
         )
-        startPendingTransactionsUpdateTask()
         startAddressStateUpdateTask()
 
         Threading.PEER_TABLE_SCOPE.launchWithFixedDelay(40_000, 120_000) {

nodecore-spv/src/main/java/org/veriblock/spv/net/PeerEventListener.kt

@@ -115,7 +115,8 @@ class PeerEventListener(
                 ))
                 return
             }
-            // TODO: add mempool management
+            val fullBlock = MessageSerializer.deserialize(event.content)
+            pendingTransactionContainer.updateTransactionsByBlock(fullBlock)
         } catch (e: Exception) {
             logger.warn("Could not queue network block $blockHash", e)
         }

nodecore-spv/src/main/java/org/veriblock/spv/service/PendingTransactionContainer.kt

@@ -4,17 +4,24 @@ import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.asCoroutineDispatcher
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
+import nodecore.api.grpc.RpcOutput
+import nodecore.api.grpc.RpcTransaction
 import nodecore.api.grpc.RpcTransactionUnion
 import nodecore.api.grpc.utilities.ByteStringUtility
+import nodecore.api.grpc.utilities.extensions.toHex
+import nodecore.api.grpc.utilities.extensions.toProperAddressType
 import org.veriblock.core.crypto.VbkTxId
+import org.veriblock.core.crypto.asVbkTxId
 import org.veriblock.core.utilities.createLogger
 import org.veriblock.sdk.models.Address
 import org.veriblock.sdk.models.VeriBlockBlock
 import org.veriblock.spv.SpvContext
+import org.veriblock.spv.model.FullBlock
 import org.veriblock.spv.model.Transaction
 import org.veriblock.spv.serialization.MessageSerializer
 import org.veriblock.spv.util.SpvEventBus
 import org.veriblock.spv.util.Threading
+import java.lang.IllegalArgumentException
 import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.locks.ReentrantLock
 import kotlin.concurrent.withLock
@@ -27,10 +34,13 @@ class PendingTransactionContainer(
 ) {
     // TODO(warchant): use Address as a key, instead of String
     private val pendingTransactionsByAddress: MutableMap<String, MutableList<Transaction>> = ConcurrentHashMap()
-    private val confirmedTransactionReplies: MutableMap<VbkTxId, TransactionInfo> = ConcurrentHashMap()
-    private val confirmedTransactions: MutableMap<VbkTxId, Transaction> = ConcurrentHashMap()
     private val pendingTransactions: MutableMap<VbkTxId, Transaction> = ConcurrentHashMap()
-    private val transactionsToMonitor: MutableSet<VbkTxId> = ConcurrentHashMap.newKeySet()
+    // FIXME: add converting between TransactionData <-> Transaction and delete this
+    private val pendingTransactionsInfo: MutableMap<VbkTxId, TransactionInfo> = ConcurrentHashMap()
+
+    private val addedToBlockchainTransactions: MutableMap<VbkTxId, Transaction> = ConcurrentHashMap()
+    // FIXME: add converting between TransactionData <-> Transaction and delete this
+    private val addedToBlockchainTransactionsInfo: MutableMap<VbkTxId, TransactionInfo> = ConcurrentHashMap()
 
     private val lock = ReentrantLock()
 
@@ -45,48 +55,50 @@ class PendingTransactionContainer(
             .sortedBy { it.value.getSignatureIndex() }
             .map { it.key }
             .toSet()
-        return pendingTransactions + transactionsToMonitor
+        return pendingTransactions
     }
 
     fun getTransactionInfo(txId: VbkTxId): TransactionInfo? {
-        confirmedTransactionReplies[txId]?.let {
+        pendingTransactionsInfo[txId]?.let {
             return it
         }
-        if (!pendingTransactions.containsKey(txId)) {
-            transactionsToMonitor.add(txId)
+        addedToBlockchainTransactionsInfo[txId]?.let {
+            return it
         }
         return null
     }
 
     fun updateTransactionInfo(transactionInfo: TransactionInfo) = lock.withLock {
         val transaction = transactionInfo.transaction
-        if (pendingTransactions.containsKey(transaction.txId) || transactionsToMonitor.contains(transaction.txId)) {
-            confirmedTransactionReplies[transaction.txId] = transactionInfo
+        if (pendingTransactions.containsKey(transaction.txId)) {
+            pendingTransactionsInfo[transaction.txId] = transactionInfo
             val pendingTx = pendingTransactions[transaction.txId]
             if (pendingTx != null) {
-                confirmedTransactions[transaction.txId] = pendingTx
                 if (pendingTx.getSignatureIndex() > lastConfirmedSignatureIndex) {
                     lastConfirmedSignatureIndex = pendingTx.getSignatureIndex()
                 }
             }
             if (transactionInfo.confirmations > 0) {
+                addedToBlockchainTransactions[transaction.txId] = pendingTx!!
+                addedToBlockchainTransactionsInfo[transaction.txId] = pendingTransactionsInfo[transaction.txId]!!
+
                 pendingTransactions.remove(transaction.txId)
-                transactionsToMonitor.remove(transaction.txId)
+                pendingTransactionsInfo.remove(transaction.txId)
                 pendingTransactionsByAddress[transaction.sourceAddress]?.removeIf { it.txId == transaction.txId }
             }
         }
 
         // Prune confirmed transactions
-        if (confirmedTransactionReplies.size > 10_000) {
-            val topConfirmedBlockHeight = confirmedTransactionReplies.values.maxOf { it.blockNumber }
-            val txToRemove = confirmedTransactionReplies.values.asSequence().filter {
+        if (addedToBlockchainTransactionsInfo.size > 10_000) {
+            val topConfirmedBlockHeight = addedToBlockchainTransactionsInfo.values.maxOf { it.blockNumber }
+            val txToRemove = addedToBlockchainTransactionsInfo.values.asSequence().filter {
                 it.blockNumber < topConfirmedBlockHeight - 1_000
             }.map {
                 it.transaction.txId
             }
             for (txId in txToRemove) {
-                confirmedTransactionReplies.remove(txId)
-                confirmedTransactions.remove(txId)
+                addedToBlockchainTransactions.remove(txId)
+                addedToBlockchainTransactionsInfo.remove(txId)
             }
         }
     }
@@ -170,7 +182,6 @@ class PendingTransactionContainer(
                             logger.info { "All the transactions for that address will be pruned in order to prevent further transactions from being rejected." }
                             for (tx in newTransactions) {
                                 pendingTransactions.remove(tx.txId)
-                                transactionsToMonitor.remove(tx.txId)
                             }
                             newTransactions.clear()
                         }
@@ -182,21 +193,75 @@ class PendingTransactionContainer(
     }
 
     private fun handleRemovedBestBlock(removedBlock: VeriBlockBlock) = lock.withLock {
-        val reorganizedTransactions = confirmedTransactionReplies.values.filter {
+        val reorganizedTransactions = addedToBlockchainTransactionsInfo.values.filter {
             it.blockNumber == removedBlock.height
         }.mapNotNull {
-            confirmedTransactions[it.transaction.txId]
+            addedToBlockchainTransactions[it.transaction.txId]
         }
         for (transaction in reorganizedTransactions) {
-            confirmedTransactionReplies.remove(transaction.txId)
-            confirmedTransactions.remove(transaction.txId)
+            addedToBlockchainTransactions.remove(transaction.txId)
             addTransaction(transaction)
         }
     }
 
+    fun updateTransactionsByBlock(block: FullBlock) = lock.withLock {
+        /*
+         * We are removing only transactions that match the exact String from the block. If the block validation
+         * fails, NO transactions are removed from the transaction pool.
+         */
+        val normalTransactions = block.normalTransactions
+            ?: throw IllegalArgumentException(
+                "removeTransactionsInBlock cannot be called with a block with a " +
+                    "null transaction set!"
+            )
+        var allSuccessful = true
+        for (transaction in normalTransactions) {
+            // FIXME: convert StandardTransaction to TransactionData
+            val builder = transaction.getSignedMessageBuilder(context.config.networkParameters)
+            val rpcTx = builder.build()
+            val txData = rpcTx.transaction.toModel()
+
+            val txInfo = TransactionInfo(
+                blockNumber = block.height,
+                timestamp = block.timestamp,
+                transaction = txData,
+                confirmations = context.blockchain.getChainHeadIndex().height + 1 - block.height,
+                blockHash = block.hash.toString(),
+                merklePath = "", // FIXME: is it possible to calculate merklePath in SPV?
+                endorsedBlockHash = "", // FIXME: for POP
+                bitcoinBlockHash = "", // FIXME: for POP
+                bitcoinTxId = "", // FIXME: for POP
+                bitcoinConfirmations = 0, // FIXME: for POP
+            )
+            updateTransactionInfo(txInfo)
+        }
+    }
+
     enum class AddTransactionResult {
         SUCCESS,
         INVALID,
         DUPLICATE
     }
+
+    private fun RpcTransaction.toModel() = TransactionData(
+        type = TransactionType.valueOf(type.name),
+        sourceAddress = sourceAddress.toProperAddressType(),
+        sourceAmount = sourceAmount,
+        outputs = outputsList.map { it.toModel() },
+        transactionFee = transactionFee,
+        data = data.toHex(),
+        bitcoinTransaction = bitcoinTransaction.toHex(),
+        endorsedBlockHeader = endorsedBlockHeader.toHex(),
+        bitcoinBlockHeaderOfProof = "",
+        merklePath = merklePath,
+        contextBitcoinBlockHeaders = listOf(),
+        timestamp = timestamp,
+        size = size,
+        txId = txId.toByteArray().asVbkTxId()
+    )
+
+    private fun RpcOutput.toModel() = OutputData(
+        address = address.toHex(),
+        amount = amount
+    )
 }