Bridging the C kernel API to validation internals

1251btck_Block* btck_block_read(const btck_ChainstateManager* chainman, const btck_BlockTreeEntry* entry)
1252{
1253    auto block{std::make_shared<CBlock>()};
1254    if (!btck_ChainstateManager::get(chainman).m_chainman->m_blockman.ReadBlock(*block, btck_BlockTreeEntry::get(entry))) {
1255        LogError("Failed to read block.");
1256        return nullptr;
1257    }
1258    return btck_Block::create(block);
1259}
1260
1261btck_BlockHeader* btck_block_tree_entry_get_block_header(const btck_BlockTreeEntry* entry)
1262{
1263    return btck_BlockHeader::create(btck_BlockTreeEntry::get(entry).GetBlockHeader());
1264}
1265
1266int32_t btck_block_tree_entry_get_height(const btck_BlockTreeEntry* entry)
1267{
1268    return btck_BlockTreeEntry::get(entry).nHeight;
1269}
1270
1271const btck_BlockHash* btck_block_tree_entry_get_block_hash(const btck_BlockTreeEntry* entry)
1272{
1273    return btck_BlockHash::ref(btck_BlockTreeEntry::get(entry).phashBlock);
1274}
1275
1276int btck_block_tree_entry_equals(const btck_BlockTreeEntry* entry1, const btck_BlockTreeEntry* entry2)
1277{
1278    return &btck_BlockTreeEntry::get(entry1) == &btck_BlockTreeEntry::get(entry2);
1279}
1280
1281btck_BlockHash* btck_block_hash_create(const unsigned char block_hash[32])
1282{
1283    return btck_BlockHash::create(std::span<const unsigned char>{block_hash, 32});
1284}
1285
1286btck_BlockHash* btck_block_hash_copy(const btck_BlockHash* block_hash)
1287{
1288    return btck_BlockHash::copy(block_hash);
1289}
1290
1291void btck_block_hash_to_bytes(const btck_BlockHash* block_hash, unsigned char output[32])
1292{
1293    std::memcpy(output, btck_BlockHash::get(block_hash).begin(), 32);
1294}
1295
1296int btck_block_hash_equals(const btck_BlockHash* hash1, const btck_BlockHash* hash2)
1297{
1298    return btck_BlockHash::get(hash1) == btck_BlockHash::get(hash2);
1299}
1300
1301void btck_block_hash_destroy(btck_BlockHash* hash)
1302{
1303    delete hash;
1304}
1305
1306btck_BlockSpentOutputs* btck_block_spent_outputs_read(const btck_ChainstateManager* chainman, const btck_BlockTreeEntry* entry)
1307{
1308    auto block_undo{std::make_shared<CBlockUndo>()};
1309    if (btck_BlockTreeEntry::get(entry).nHeight < 1) {
1310        LogDebug(BCLog::KERNEL, "The genesis block does not have any spent outputs.");
1311        return btck_BlockSpentOutputs::create(block_undo);
1312    }
1313    if (!btck_ChainstateManager::get(chainman).m_chainman->m_blockman.ReadBlockUndo(*block_undo, btck_BlockTreeEntry::get(entry))) {
1314        LogError("Failed to read block spent outputs data.");
1315        return nullptr;
1316    }
1317    return btck_BlockSpentOutputs::create(block_undo);
1318}
1319
1320btck_BlockSpentOutputs* btck_block_spent_outputs_copy(const btck_BlockSpentOutputs* block_spent_outputs)
1321{
1322    return btck_BlockSpentOutputs::copy(block_spent_outputs);
1323}
1324
1325size_t btck_block_spent_outputs_count(const btck_BlockSpentOutputs* block_spent_outputs)
1326{
1327    return btck_BlockSpentOutputs::get(block_spent_outputs)->vtxundo.size();
1328}
1329
1330const btck_TransactionSpentOutputs* btck_block_spent_outputs_get_transaction_spent_outputs_at(const btck_BlockSpentOutputs* block_spent_outputs, size_t transaction_index)
1331{
1332    assert(transaction_index < btck_BlockSpentOutputs::get(block_spent_outputs)->vtxundo.size());
1333    const auto* tx_undo{&btck_BlockSpentOutputs::get(block_spent_outputs)->vtxundo.at(transaction_index)};
1334    return btck_TransactionSpentOutputs::ref(tx_undo);
1335}
1336
1337void btck_block_spent_outputs_destroy(btck_BlockSpentOutputs* block_spent_outputs)
1338{
1339    delete block_spent_outputs;
1340}
1341
1342btck_TransactionSpentOutputs* btck_transaction_spent_outputs_copy(const btck_TransactionSpentOutputs* transaction_spent_outputs)
1343{
1344    return btck_TransactionSpentOutputs::copy(transaction_spent_outputs);
1345}
1346
1347size_t btck_transaction_spent_outputs_count(const btck_TransactionSpentOutputs* transaction_spent_outputs)
1348{
1349    return btck_TransactionSpentOutputs::get(transaction_spent_outputs).vprevout.size();
1350}
1351
1352void btck_transaction_spent_outputs_destroy(btck_TransactionSpentOutputs* transaction_spent_outputs)
1353{
1354    delete transaction_spent_outputs;
1355}
1356
1357const btck_Coin* btck_transaction_spent_outputs_get_coin_at(const btck_TransactionSpentOutputs* transaction_spent_outputs, size_t coin_index)
1358{
1359    assert(coin_index < btck_TransactionSpentOutputs::get(transaction_spent_outputs).vprevout.size());
1360    const Coin* coin{&btck_TransactionSpentOutputs::get(transaction_spent_outputs).vprevout.at(coin_index)};
1361    return btck_Coin::ref(coin);
1362}
1363
1364btck_Coin* btck_coin_copy(const btck_Coin* coin)
1365{
1366    return btck_Coin::copy(coin);
1367}
1368
1369uint32_t btck_coin_confirmation_height(const btck_Coin* coin)
1370{
1371    return btck_Coin::get(coin).nHeight;
1372}
1373
1374int btck_coin_is_coinbase(const btck_Coin* coin)
1375{
1376    return btck_Coin::get(coin).IsCoinBase() ? 1 : 0;
1377}
1378
1379const btck_TransactionOutput* btck_coin_get_output(const btck_Coin* coin)
1380{
1381    return btck_TransactionOutput::ref(&btck_Coin::get(coin).out);
1382}
1383
1384void btck_coin_destroy(btck_Coin* coin)
1385{
1386    delete coin;
1387}
1388
1389int btck_chainstate_manager_process_block(
1390    btck_ChainstateManager* chainman,
1391    const btck_Block* block,
1392    int* _new_block)
1393{
1394    bool new_block;
1395    auto result = btck_ChainstateManager::get(chainman).m_chainman->ProcessNewBlock(btck_Block::get(block), /*force_processing=*/true, /*min_pow_checked=*/true, /*new_block=*/&new_block);
1396    if (_new_block) {
1397        *_new_block = new_block ? 1 : 0;
1398    }
1399    return result ? 0 : -1;
1400}
1401
1402btck_BlockValidationState* btck_chainstate_manager_process_block_header(
1403    btck_ChainstateManager* chainstate_manager,
1404    const btck_BlockHeader* header)
1405{
1406    try {
1407        auto& chainman = btck_ChainstateManager::get(chainstate_manager).m_chainman;
1408
1409        auto state = btck_BlockValidationState::create();
1410        bool result{chainman->ProcessNewBlockHeaders({&btck_BlockHeader::get(header), 1}, /*min_pow_checked=*/true, btck_BlockValidationState::get(state))};
1411        assert(result == btck_BlockValidationState::get(state).IsValid());
1412        return state;
1413    } catch (const std::exception& e) {
1414        LogError("Failed to process block header: %s", e.what());
1415        return nullptr;
1416    }
1417}
1418
1419const btck_Chain* btck_chainstate_manager_get_active_chain(const btck_ChainstateManager* chainman)
1420{
1421    return btck_Chain::ref(&WITH_LOCK(btck_ChainstateManager::get(chainman).m_chainman->GetMutex(), return btck_ChainstateManager::get(chainman).m_chainman->ActiveChain()));
1422}
1423
1424int32_t btck_chain_get_height(const btck_Chain* chain)
1425{
1426    LOCK(::cs_main);
1427    return btck_Chain::get(chain).Height();
1428}
1429
1430const btck_BlockTreeEntry* btck_chain_get_by_height(const btck_Chain* chain, int32_t height)
1431{
1432    LOCK(::cs_main);
1433    return btck_BlockTreeEntry::ref(btck_Chain::get(chain)[height]);
1434}
1435
1436int btck_chain_contains(const btck_Chain* chain, const btck_BlockTreeEntry* entry)
1437{
1438    LOCK(::cs_main);
1439    return btck_Chain::get(chain).Contains(btck_BlockTreeEntry::get(entry)) ? 1 : 0;
1440}
1441
1442btck_BlockHeader* btck_block_header_create(const void* raw_block_header, size_t raw_block_header_len)
1443{
1444    assert(raw_block_header != nullptr && raw_block_header_len == 80);
1445    auto header{std::make_unique<CBlockHeader>()};
1446    SpanReader stream{std::span{reinterpret_cast<const std::byte*>(raw_block_header), raw_block_header_len}};
1447
1448    try {
1449        stream >> *header;
1450    } catch (...) {
1451        LogError("Block header decode failed.");
1452        return nullptr;
1453    }
1454
1455    return btck_BlockHeader::ref(header.release());
1456}
1457
1458btck_BlockHeader* btck_block_header_copy(const btck_BlockHeader* header)
1459{
1460    return btck_BlockHeader::copy(header);
1461}
1462
1463btck_BlockHash* btck_block_header_get_hash(const btck_BlockHeader* header)
1464{
1465    return btck_BlockHash::create(btck_BlockHeader::get(header).GetHash());
1466}
1467
1468const btck_BlockHash* btck_block_header_get_prev_hash(const btck_BlockHeader* header)
1469{
1470    return btck_BlockHash::ref(&btck_BlockHeader::get(header).hashPrevBlock);
1471}
1472
1473uint32_t btck_block_header_get_timestamp(const btck_BlockHeader* header)
1474{
1475    return btck_BlockHeader::get(header).nTime;
1476}
1477
1478uint32_t btck_block_header_get_bits(const btck_BlockHeader* header)
1479{
1480    return btck_BlockHeader::get(header).nBits;
1481}
1482
1483int32_t btck_block_header_get_version(const btck_BlockHeader* header)
1484{
1485    return btck_BlockHeader::get(header).nVersion;
1486}
1487
1488uint32_t btck_block_header_get_nonce(const btck_BlockHeader* header)
1489{
1490    return btck_BlockHeader::get(header).nNonce;
1491}
1492
1493int btck_block_header_to_bytes(const btck_BlockHeader* header, unsigned char output[80])
1494{
1495    try {
1496        SpanWriter{std::as_writable_bytes(std::span{output, 80})} << btck_BlockHeader::get(header);
1497        return 0;
1498    } catch (...) {
1499        return -1;
1500    }