Bridging the C kernel API to validation internals

751
752btck_TransactionOutPoint* btck_transaction_out_point_copy(const btck_TransactionOutPoint* out_point)
753{
754    return btck_TransactionOutPoint::copy(out_point);
755}
756
757uint32_t btck_transaction_out_point_get_index(const btck_TransactionOutPoint* out_point)
758{
759    return btck_TransactionOutPoint::get(out_point).n;
760}
761
762const btck_Txid* btck_transaction_out_point_get_txid(const btck_TransactionOutPoint* out_point)
763{
764    return btck_Txid::ref(&btck_TransactionOutPoint::get(out_point).hash);
765}
766
767void btck_transaction_out_point_destroy(btck_TransactionOutPoint* out_point)
768{
769    delete out_point;
770}
771
772btck_Txid* btck_txid_copy(const btck_Txid* txid)
773{
774    return btck_Txid::copy(txid);
775}
776
777void btck_txid_to_bytes(const btck_Txid* txid, unsigned char output[32])
778{
779    std::memcpy(output, btck_Txid::get(txid).begin(), 32);
780}
781
782int btck_txid_equals(const btck_Txid* txid1, const btck_Txid* txid2)
783{
784    return btck_Txid::get(txid1) == btck_Txid::get(txid2);
785}
786
787void btck_txid_destroy(btck_Txid* txid)
788{
789    delete txid;
790}
791
792void btck_logging_set_options(const btck_LoggingOptions options)
793{
794    LOCK(cs_main);
795    LogInstance().m_log_timestamps = options.log_timestamps;
796    LogInstance().m_log_time_micros = options.log_time_micros;
797    LogInstance().m_log_threadnames = options.log_threadnames;
798    LogInstance().m_log_sourcelocations = options.log_sourcelocations;
799    LogInstance().m_always_print_category_level = options.always_print_category_levels;
800}
801
802void btck_logging_set_level_category(btck_LogCategory category, btck_LogLevel level)
803{
804    LOCK(cs_main);
805    if (category == btck_LogCategory_ALL) {
806        LogInstance().SetLogLevel(get_bclog_level(level));
807    }
808
809    LogInstance().AddCategoryLogLevel(get_bclog_flag(category), get_bclog_level(level));
810}
811
812void btck_logging_enable_category(btck_LogCategory category)
813{
814    LogInstance().EnableCategory(get_bclog_flag(category));
815}
816
817void btck_logging_disable_category(btck_LogCategory category)
818{
819    LogInstance().DisableCategory(get_bclog_flag(category));
820}
821
822void btck_logging_disable()
823{
824    LogInstance().DisableLogging();
825}
826
827btck_LoggingConnection* btck_logging_connection_create(btck_LogCallback callback, void* user_data, btck_DestroyCallback user_data_destroy_callback)
828{
829    try {
830        return btck_LoggingConnection::create(callback, user_data, user_data_destroy_callback);
831    } catch (const std::exception&) {
832        return nullptr;
833    }
834}
835
836void btck_logging_connection_destroy(btck_LoggingConnection* connection)
837{
838    delete connection;
839}
840
841btck_ChainParameters* btck_chain_parameters_create(const btck_ChainType chain_type)
842{
843    switch (chain_type) {
844    case btck_ChainType_MAINNET: {
845        return btck_ChainParameters::ref(const_cast<CChainParams*>(CChainParams::Main().release()));
846    }
847    case btck_ChainType_TESTNET: {
848        return btck_ChainParameters::ref(const_cast<CChainParams*>(CChainParams::TestNet().release()));
849    }
850    case btck_ChainType_TESTNET_4: {
851        return btck_ChainParameters::ref(const_cast<CChainParams*>(CChainParams::TestNet4().release()));
852    }
853    case btck_ChainType_SIGNET: {
854        return btck_ChainParameters::ref(const_cast<CChainParams*>(CChainParams::SigNet().release()));
855    }
856    case btck_ChainType_REGTEST: {
857        return btck_ChainParameters::ref(const_cast<CChainParams*>(CChainParams::RegTest().release()));
858    }
859    }
860    assert(false);
861}
862
863btck_ChainParameters* btck_chain_parameters_create_signet(const void* challenge, size_t challenge_len)
864{
865    assert(challenge != nullptr || challenge_len == 0);
866    const uint8_t* p = static_cast<const uint8_t*>(challenge);
867    CChainParams::SigNetOptions options{
868        .challenge = std::vector<uint8_t>{p, p + challenge_len},
869    };
870    return btck_ChainParameters::ref(const_cast<CChainParams*>(CChainParams::SigNet(options).release()));
871}
872
873btck_ChainParameters* btck_chain_parameters_copy(const btck_ChainParameters* chain_parameters)
874{
875    return btck_ChainParameters::copy(chain_parameters);
876}
877
878const btck_ConsensusParams* btck_chain_parameters_get_consensus_params(const btck_ChainParameters* chain_parameters)
879{
880    return btck_ConsensusParams::ref(&btck_ChainParameters::get(chain_parameters).GetConsensus());
881}
882
883void btck_chain_parameters_destroy(btck_ChainParameters* chain_parameters)
884{
885    delete chain_parameters;
886}
887
888btck_ContextOptions* btck_context_options_create()
889{
890    return btck_ContextOptions::create();
891}
892
893void btck_context_options_set_chainparams(btck_ContextOptions* options, const btck_ChainParameters* chain_parameters)
894{
895    // Copy the chainparams, so the caller can free it again
896    LOCK(btck_ContextOptions::get(options).m_mutex);
897    btck_ContextOptions::get(options).m_chainparams = std::make_unique<const CChainParams>(btck_ChainParameters::get(chain_parameters));
898}
899
900void btck_context_options_set_notifications(btck_ContextOptions* options, btck_NotificationInterfaceCallbacks notifications)
901{
902    // The KernelNotifications are copy-initialized, so the caller can free them again.
903    LOCK(btck_ContextOptions::get(options).m_mutex);
904    btck_ContextOptions::get(options).m_notifications = std::make_shared<KernelNotifications>(notifications);
905}
906
907void btck_context_options_set_validation_interface(btck_ContextOptions* options, btck_ValidationInterfaceCallbacks vi_cbs)
908{
909    LOCK(btck_ContextOptions::get(options).m_mutex);
910    btck_ContextOptions::get(options).m_validation_interface = std::make_shared<KernelValidationInterface>(vi_cbs);
911}
912
913void btck_context_options_destroy(btck_ContextOptions* options)
914{
915    delete options;
916}
917
918btck_Context* btck_context_create(const btck_ContextOptions* options)
919{
920    bool sane{true};
921    const ContextOptions* opts = options ? &btck_ContextOptions::get(options) : nullptr;
922    auto context{std::make_shared<const Context>(opts, sane)};
923    if (!sane) {
924        LogError("Kernel context sanity check failed.");
925        return nullptr;
926    }
927    return btck_Context::create(context);
928}
929
930btck_Context* btck_context_copy(const btck_Context* context)
931{
932    return btck_Context::copy(context);
933}
934
935int btck_context_interrupt(btck_Context* context)
936{
937    return (*btck_Context::get(context)->m_interrupt)() ? 0 : -1;
938}
939
940void btck_context_destroy(btck_Context* context)
941{
942    delete context;
943}
944
945const btck_BlockTreeEntry* btck_block_tree_entry_get_previous(const btck_BlockTreeEntry* entry)
946{
947    if (!btck_BlockTreeEntry::get(entry).pprev) {
948        LogInfo("Genesis block has no previous.");
949        return nullptr;
950    }
951
952    return btck_BlockTreeEntry::ref(btck_BlockTreeEntry::get(entry).pprev);
953}
954
955const btck_BlockTreeEntry* btck_block_tree_entry_get_ancestor(const btck_BlockTreeEntry* block_tree_entry, int32_t height)
956{
957    const auto* ancestor{btck_BlockTreeEntry::get(block_tree_entry).GetAncestor(height)};
958    assert(ancestor);
959    return btck_BlockTreeEntry::ref(ancestor);
960}
961
962btck_BlockValidationState* btck_block_validation_state_create()
963{
964    return btck_BlockValidationState::create();
965}
966
967btck_BlockValidationState* btck_block_validation_state_copy(const btck_BlockValidationState* state)
968{
969    return btck_BlockValidationState::copy(state);
970}
971
972void btck_block_validation_state_destroy(btck_BlockValidationState* state)
973{
974    delete state;
975}
976
977btck_ValidationMode btck_block_validation_state_get_validation_mode(const btck_BlockValidationState* block_validation_state_)
978{
979    auto& block_validation_state = btck_BlockValidationState::get(block_validation_state_);
980    if (block_validation_state.IsValid()) return btck_ValidationMode_VALID;
981    if (block_validation_state.IsInvalid()) return btck_ValidationMode_INVALID;
982    return btck_ValidationMode_INTERNAL_ERROR;
983}
984
985btck_BlockValidationResult btck_block_validation_state_get_block_validation_result(const btck_BlockValidationState* block_validation_state_)
986{
987    auto& block_validation_state = btck_BlockValidationState::get(block_validation_state_);
988    switch (block_validation_state.GetResult()) {
989    case BlockValidationResult::BLOCK_RESULT_UNSET:
990        return btck_BlockValidationResult_UNSET;
991    case BlockValidationResult::BLOCK_CONSENSUS:
992        return btck_BlockValidationResult_CONSENSUS;
993    case BlockValidationResult::BLOCK_CACHED_INVALID:
994        return btck_BlockValidationResult_CACHED_INVALID;
995    case BlockValidationResult::BLOCK_INVALID_HEADER:
996        return btck_BlockValidationResult_INVALID_HEADER;
997    case BlockValidationResult::BLOCK_MUTATED:
998        return btck_BlockValidationResult_MUTATED;
999    case BlockValidationResult::BLOCK_MISSING_PREV:
1000        return btck_BlockValidationResult_MISSING_PREV;