1// Copyright (c) 2024-present The Bitcoin Core developers
2// Distributed under the MIT software license, see the accompanying
3// file COPYING or http://www.opensource.org/licenses/mit-license.php.
4
5#ifndef BITCOIN_KERNEL_BITCOINKERNEL_WRAPPER_H
6#define BITCOIN_KERNEL_BITCOINKERNEL_WRAPPER_H
7
8#include <kernel/bitcoinkernel.h>
9
10#include <array>
11#include <chrono>
12#include <exception>
13#include <functional>
14#include <memory>
15#include <optional>
16#include <span>
17#include <stdexcept>
18#include <string>
19#include <string_view>
20#include <type_traits>
21#include <utility>
22#include <vector>
23
24namespace btck {
25
26enum class LogCategory : btck_LogCategory {
27    ALL = btck_LogCategory_ALL,
28    BENCH = btck_LogCategory_BENCH,
29    BLOCKSTORAGE = btck_LogCategory_BLOCKSTORAGE,
30    COINDB = btck_LogCategory_COINDB,
31    LEVELDB = btck_LogCategory_LEVELDB,
32    MEMPOOL = btck_LogCategory_MEMPOOL,
33    PRUNE = btck_LogCategory_PRUNE,
34    RAND = btck_LogCategory_RAND,
35    REINDEX = btck_LogCategory_REINDEX,
36    VALIDATION = btck_LogCategory_VALIDATION,
37    KERNEL = btck_LogCategory_KERNEL
38};
39
40enum class LogLevel : btck_LogLevel {
41    TRACE_LEVEL = btck_LogLevel_TRACE,
42    DEBUG_LEVEL = btck_LogLevel_DEBUG,
43    INFO_LEVEL = btck_LogLevel_INFO
44};
45
46enum class ChainType : btck_ChainType {
47    MAINNET = btck_ChainType_MAINNET,
48    TESTNET = btck_ChainType_TESTNET,
49    TESTNET_4 = btck_ChainType_TESTNET_4,
50    SIGNET = btck_ChainType_SIGNET,
51    REGTEST = btck_ChainType_REGTEST
52};
53
54enum class SynchronizationState : btck_SynchronizationState {
55    INIT_REINDEX = btck_SynchronizationState_INIT_REINDEX,
56    INIT_DOWNLOAD = btck_SynchronizationState_INIT_DOWNLOAD,
57    POST_INIT = btck_SynchronizationState_POST_INIT
58};
59
60enum class Warning : btck_Warning {
61    UNKNOWN_NEW_RULES_ACTIVATED = btck_Warning_UNKNOWN_NEW_RULES_ACTIVATED,
62    LARGE_WORK_INVALID_CHAIN = btck_Warning_LARGE_WORK_INVALID_CHAIN
63};
64
65enum class ValidationMode : btck_ValidationMode {
66    VALID = btck_ValidationMode_VALID,
67    INVALID = btck_ValidationMode_INVALID,
68    INTERNAL_ERROR = btck_ValidationMode_INTERNAL_ERROR
69};
70
71enum class BlockValidationResult : btck_BlockValidationResult {
72    UNSET = btck_BlockValidationResult_UNSET,
73    CONSENSUS = btck_BlockValidationResult_CONSENSUS,
74    CACHED_INVALID = btck_BlockValidationResult_CACHED_INVALID,
75    INVALID_HEADER = btck_BlockValidationResult_INVALID_HEADER,
76    MUTATED = btck_BlockValidationResult_MUTATED,
77    MISSING_PREV = btck_BlockValidationResult_MISSING_PREV,
78    INVALID_PREV = btck_BlockValidationResult_INVALID_PREV,
79    TIME_FUTURE = btck_BlockValidationResult_TIME_FUTURE,
80    HEADER_LOW_WORK = btck_BlockValidationResult_HEADER_LOW_WORK
81};
82
83enum class TxValidationResult : btck_TxValidationResult {
84    UNSET               = btck_TxValidationResult_UNSET,
85    CONSENSUS           = btck_TxValidationResult_CONSENSUS,
86    INPUTS_NOT_STANDARD = btck_TxValidationResult_INPUTS_NOT_STANDARD,
87    NOT_STANDARD        = btck_TxValidationResult_NOT_STANDARD,
88    MISSING_INPUTS      = btck_TxValidationResult_MISSING_INPUTS,
89    PREMATURE_SPEND     = btck_TxValidationResult_PREMATURE_SPEND,
90    WITNESS_MUTATED     = btck_TxValidationResult_WITNESS_MUTATED,
91    WITNESS_STRIPPED    = btck_TxValidationResult_WITNESS_STRIPPED,
92    CONFLICT            = btck_TxValidationResult_CONFLICT,
93    MEMPOOL_POLICY      = btck_TxValidationResult_MEMPOOL_POLICY,
94    NO_MEMPOOL          = btck_TxValidationResult_NO_MEMPOOL,
95    RECONSIDERABLE      = btck_TxValidationResult_RECONSIDERABLE,
96    UNKNOWN             = btck_TxValidationResult_UNKNOWN
97};
98
99enum class ScriptVerifyStatus : btck_ScriptVerifyStatus {
100    OK = btck_ScriptVerifyStatus_OK,
101    ERROR_INVALID_FLAGS_COMBINATION = btck_ScriptVerifyStatus_ERROR_INVALID_FLAGS_COMBINATION,
102    ERROR_SPENT_OUTPUTS_REQUIRED = btck_ScriptVerifyStatus_ERROR_SPENT_OUTPUTS_REQUIRED,
103};
104
105enum class ScriptVerificationFlags : btck_ScriptVerificationFlags {
106    NONE = btck_ScriptVerificationFlags_NONE,
107    P2SH = btck_ScriptVerificationFlags_P2SH,
108    DERSIG = btck_ScriptVerificationFlags_DERSIG,
109    NULLDUMMY = btck_ScriptVerificationFlags_NULLDUMMY,
110    CHECKLOCKTIMEVERIFY = btck_ScriptVerificationFlags_CHECKLOCKTIMEVERIFY,
111    CHECKSEQUENCEVERIFY = btck_ScriptVerificationFlags_CHECKSEQUENCEVERIFY,
112    WITNESS = btck_ScriptVerificationFlags_WITNESS,
113    TAPROOT = btck_ScriptVerificationFlags_TAPROOT,
114    ALL = btck_ScriptVerificationFlags_ALL
115};
116
117enum class BlockCheckFlags : btck_BlockCheckFlags {
118    BASE = btck_BlockCheckFlags_BASE,
119    POW = btck_BlockCheckFlags_POW,
120    MERKLE = btck_BlockCheckFlags_MERKLE,
121    ALL = btck_BlockCheckFlags_ALL
122};
123
124template <typename T>
125struct is_bitmask_enum : std::false_type {
126};
127
128template <>
129struct is_bitmask_enum<ScriptVerificationFlags> : std::true_type {
130};
131
132template <>
133struct is_bitmask_enum<BlockCheckFlags> : std::true_type {
134};
135
136template <typename T>
137concept BitmaskEnum = is_bitmask_enum<T>::value;
138
139template <BitmaskEnum T>
140constexpr T operator|(T lhs, T rhs)
141{
142    return static_cast<T>(
143        static_cast<std::underlying_type_t<T>>(lhs) | static_cast<std::underlying_type_t<T>>(rhs));
144}
145
146template <BitmaskEnum T>
147constexpr T operator&(T lhs, T rhs)
148{
149    return static_cast<T>(
150        static_cast<std::underlying_type_t<T>>(lhs) & static_cast<std::underlying_type_t<T>>(rhs));
151}
152
153template <BitmaskEnum T>
154constexpr T operator^(T lhs, T rhs)
155{
156    return static_cast<T>(
157        static_cast<std::underlying_type_t<T>>(lhs) ^ static_cast<std::underlying_type_t<T>>(rhs));
158}
159
160template <BitmaskEnum T>
161constexpr T operator~(T value)
162{
163    return static_cast<T>(~static_cast<std::underlying_type_t<T>>(value));
164}
165
166template <BitmaskEnum T>
167constexpr T& operator|=(T& lhs, T rhs)
168{
169    return lhs = lhs | rhs;
170}
171
172template <BitmaskEnum T>
173constexpr T& operator&=(T& lhs, T rhs)
174{
175    return lhs = lhs & rhs;
176}
177
178template <BitmaskEnum T>
179constexpr T& operator^=(T& lhs, T rhs)
180{
181    return lhs = lhs ^ rhs;
182}
183
184template <typename T>
185T check(T ptr)
186{
187    if (ptr == nullptr) {
188        throw std::runtime_error("failed to instantiate btck object");
189    }
190    return ptr;
191}
192
193template <typename Collection, typename ValueType, auto GetFunc>
194class Iterator
195{
196public:
197    using iterator_category = std::random_access_iterator_tag;
198    using iterator_concept = std::random_access_iterator_tag;
199    using difference_type = std::ptrdiff_t;
200    using value_type = ValueType;
201
202private:
203    const Collection* m_collection;
204    size_t m_idx;
205
206public:
207    Iterator() = default;
208    Iterator(const Collection* ptr) : m_collection{ptr}, m_idx{0} {}
209    Iterator(const Collection* ptr, size_t idx) : m_collection{ptr}, m_idx{idx} {}
210
211    // This is just a view, so return a copy.
212    auto operator*() const { return std::invoke(GetFunc, *m_collection, m_idx); }
213
214    auto& operator++() { m_idx++; return *this; }
215    auto operator++(int) { Iterator tmp = *this; ++(*this); return tmp; }
216
217    auto& operator--() { m_idx--; return *this; }
218    auto operator--(int) { auto temp = *this; --m_idx; return temp; }
219
220    auto& operator+=(difference_type n) { m_idx += n; return *this; }
221    auto& operator-=(difference_type n) { m_idx -= n; return *this; }
222
223    auto operator+(difference_type n) const { return Iterator(m_collection, m_idx + n); }
224    auto operator-(difference_type n) const { return Iterator(m_collection, m_idx - n); }
225
226    auto operator-(const Iterator& other) const { return static_cast<difference_type>(m_idx) - static_cast<difference_type>(other.m_idx); }
227
228    ValueType operator[](difference_type n) const { return *(*this + n); }
229
230    auto operator<=>(const Iterator& other) const { return m_idx <=> other.m_idx; }
231
232    bool operator==(const Iterator& other) const { return m_collection == other.m_collection && m_idx == other.m_idx; }
233
234private:
235    friend Iterator operator+(difference_type n, const Iterator& it) { return it + n; }
236};
237
238template <typename Container, typename SizeFunc, typename GetFunc>
239concept IndexedContainer = requires(const Container& c, SizeFunc size_func, GetFunc get_func, std::size_t i) {
240    { std::invoke(size_func, c) } -> std::convertible_to<std::size_t>;
241    { std::invoke(get_func, c, i) }; // Return type is deduced
242};
243
244template <typename Container, auto SizeFunc, auto GetFunc>
245    requires IndexedContainer<Container, decltype(SizeFunc), decltype(GetFunc)>
246class Range
247{
248public:
249    using value_type = std::invoke_result_t<decltype(GetFunc), const Container&, size_t>;
250    using difference_type = std::ptrdiff_t;