kernel: Process transactions

Author: TheCharlatan

src/kernel/bitcoinkernel.cpp

@@ -1367,6 +1367,20 @@ bool kernel_chainstate_manager_process_block_header(const kernel_Context* contex
     return chainman.ProcessNewBlockHeaders(headers, true, state);
 }
 
+bool kernel_chainstate_manager_process_transaction(
+    const kernel_Context* context,
+    kernel_ChainstateManager* chainman_,
+    kernel_Transaction* transaction_,
+    bool test_accept)
+{
+    auto& chainman{*cast_chainstate_manager(chainman_)};
+    auto transaction{cast_transaction_ref(transaction_)};
+
+    MempoolAcceptResult res = WITH_LOCK(::cs_main, return chainman.ProcessTransaction(*transaction, test_accept));
+
+    return res.m_result_type ==  MempoolAcceptResult::ResultType::VALID;
+}
+
 bool kernel_chainstate_manager_process_block(
     const kernel_Context* context_,
     kernel_ChainstateManager* chainman_,

src/kernel/bitcoinkernel.h

@@ -1140,6 +1140,24 @@ bool BITCOINKERNEL_WARN_UNUSED_RESULT kernel_chainstate_manager_process_block_he
     kernel_BlockHeader* header
 ) BITCOINKERNEL_ARG_NONNULL(1) BITCOINKERNEL_ARG_NONNULL(2) BITCOINKERNEL_ARG_NONNULL(3);
 
+/**
+ * @brief Validates a single passed in transaction. Requires a mempool to have
+ * been configured previously for the chainstate manager through the chainstate
+ * load options.
+ *
+ * @param[in] context     Non-null.
+ * @param[in] chainman    Non-null.
+ * @param[in] transaction Non-null.
+ * @param[in] test_accept If true, will only check the transaction validity and will not submit it to the mempool.
+ * @return                True if the transaction was successfully validated.
+ */
+bool kernel_chainstate_manager_process_transaction(
+    const kernel_Context* context,
+    kernel_ChainstateManager* chainman,
+    kernel_Transaction* transaction,
+    bool test_accept
+) BITCOINKERNEL_ARG_NONNULL(1) BITCOINKERNEL_ARG_NONNULL(2) BITCOINKERNEL_ARG_NONNULL(3);
+
 /**
  * @brief Destroy the block index.
  */

src/kernel/bitcoinkernel_wrapper.h

@@ -524,6 +524,8 @@ class Transaction
         kernel_byte_array_destroy(serialized_transaction);
         return vec;
     }
+
+    friend class ChainMan;
 };
 
 class Block
@@ -746,6 +748,11 @@ class ChainMan
         return kernel_chainstate_manager_process_block_header(m_context.m_context.get(), m_chainman, header.m_block_header.get());
     }
 
+    bool ProcessTransaction(Transaction& transaction, bool test_accept) const noexcept
+    {
+        return kernel_chainstate_manager_process_transaction(m_context.m_context.get(), m_chainman, transaction.m_transaction.get(), test_accept);
+    }
+
     bool ProcessBlock(Block& block, kernel_ProcessBlockStatus& status) const noexcept
     {
         return kernel_chainstate_manager_process_block(m_context.m_context.get(), m_chainman, block.m_block.get(), &status);

src/test/kernel/test_kernel.cpp

@@ -612,16 +612,28 @@ void chainman_regtest_validation_test()
         }
     }
 
+    // Validated the rest on a new chainman, but leave the last block.
     auto chainman{create_chainman(test_directory, false, false, false, false, context)};
 
-    for (size_t i{mid}; i < REGTEST_BLOCK_DATA.size(); i++) {
+    for (size_t i{mid}; i < REGTEST_BLOCK_DATA.size() - 1; i++) {
         Block block{REGTEST_BLOCK_DATA[i]};
         assert(block);
         auto status{kernel_ProcessBlockStatus::kernel_PROCESS_BLOCK_OK};
-        assert(chainman->ProcessBlock(block, status));
+        chainman->ProcessBlock(block, status);
         assert(status == kernel_PROCESS_BLOCK_OK);
     }
 
+    Block block{REGTEST_BLOCK_DATA[REGTEST_BLOCK_DATA.size() - 1]};
+    assert(block);
+    for (size_t i{1}; i < block.GetNumberOfTransactions(); i++) {
+        Transaction tx{block.GetTransaction(i)};
+        assert(tx);
+        assert(chainman->ProcessTransaction(tx, true));
+    }
+    auto status{kernel_ProcessBlockStatus::kernel_PROCESS_BLOCK_OK};
+    chainman->ProcessBlock(block, status);
+    assert(status == kernel_PROCESS_BLOCK_OK);
+
     auto tip = chainman->GetBlockIndexFromTip();
     auto read_block = chainman->ReadBlock(tip).value();
     assert(read_block.GetBlockData() == REGTEST_BLOCK_DATA[REGTEST_BLOCK_DATA.size() - 1]);