Merge pull request #1676 from evoskuil/master

Use shared_ptr to make annex a safe copyable object.

Author: evoskuil

Makefile.am

@@ -596,6 +596,7 @@ include_bitcoin_system_impl_chain_HEADERS = \
     include/bitcoin/system/impl/chain/compact.ipp \
     include/bitcoin/system/impl/chain/operation_patterns.ipp \
     include/bitcoin/system/impl/chain/script_patterns.ipp \
+    include/bitcoin/system/impl/chain/transaction_patterns.ipp \
     include/bitcoin/system/impl/chain/witness_patterns.ipp
 
 include_bitcoin_system_impl_datadir = ${includedir}/bitcoin/system/impl/data

builds/msvc/vs2022/libbitcoin-system/libbitcoin-system.vcxproj

@@ -366,6 +366,7 @@
     <ClInclude Include="..\..\..\..\include\bitcoin\system\hash\sha\sha512.hpp" />
     <ClInclude Include="..\..\..\..\include\bitcoin\system\hash\siphash.hpp" />
     <ClInclude Include="..\..\..\..\include\bitcoin\system\have.hpp" />
+    <ClInclude Include="..\..\..\..\include\bitcoin\system\impl\chain\transaction_patterns.ipp" />
     <ClInclude Include="..\..\..\..\include\bitcoin\system\intrinsics\arm\arm.hpp" />
     <ClInclude Include="..\..\..\..\include\bitcoin\system\intrinsics\arm\functional.hpp" />
     <ClInclude Include="..\..\..\..\include\bitcoin\system\intrinsics\arm\sha.hpp" />
@@ -655,4 +656,4 @@
   <ItemGroup>
     <Natvis Include="..\..\debug.natvis" />
   </ItemGroup>
-</Project>
+</Project>

builds/msvc/vs2022/libbitcoin-system/libbitcoin-system.vcxproj.filters

@@ -1460,6 +1460,9 @@
     <ClInclude Include="..\..\resource.h">
       <Filter>resource</Filter>
     </ClInclude>
+    <ClInclude Include="..\..\..\..\include\bitcoin\system\impl\chain\transaction_patterns.ipp">
+      <Filter>include\bitcoin\system\impl\chain</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <None Include="..\..\..\..\include\bitcoin\system\impl\chain\annex.ipp">
@@ -1745,4 +1748,4 @@
       <Filter>resource</Filter>
     </ResourceCompile>
   </ItemGroup>
-</Project>
+</Project>

include/bitcoin/system/chain/annex.hpp

@@ -27,23 +27,28 @@ namespace libbitcoin {
 namespace system {
 namespace chain {
 
-class witness;
-
-/// Annex is an abstraction over a witness stack.
+/// Annex is an abstraction over the top witness stack element.
 class BC_API annex
 {
 public:
     DEFAULT_COPY_MOVE_DESTRUCT(annex);
 
-    inline annex(const witness& owner) NOEXCEPT;
+    inline annex() NOEXCEPT;
+    inline annex(const chunk_cptr& data) NOEXCEPT;
+    inline annex(const chunk_cptrs& stack) NOEXCEPT;
 
     inline size_t size() const NOEXCEPT;
     inline const data_chunk& data() const NOEXCEPT;
     inline const hash_digest hash() const NOEXCEPT;
     inline operator bool() const NOEXCEPT;
 
+protected:
+    static inline chunk_cptr from_stack(const chunk_cptrs& stack) NOEXCEPT;
+
 private:
-    std::reference_wrapper<const witness> witness_;
+    static inline const data_chunk& empty_annex() NOEXCEPT;
+
+    chunk_cptr data_;
 };
 
 } // namespace chain

include/bitcoin/system/chain/enums/magic_numbers.hpp

@@ -88,12 +88,10 @@ constexpr uint8_t witness_enabled = 0x01;
 /// ---------------------------------------------------------------------------
 
 constexpr size_t signature_cost = 50;
-constexpr size_t control_block_base = 33;
-constexpr size_t control_block_node = 32;
-constexpr size_t control_block_range = 128;
-constexpr uint8_t taproot_leaf_mask = 0xfe;
-constexpr uint8_t taproot_leaf_tapscript = 0xc0;
+constexpr size_t taproot_max_nodes = 128;
 constexpr uint8_t taproot_annex_prefix = 0x50;
+constexpr uint8_t tapleaf_tapscript = 0b1100'0000; // 0xc0
+constexpr uint8_t tapleaf_root_mask = 0b1111'1110; // 0xfe
 
 /// Policy constants.
 /// ---------------------------------------------------------------------------

include/bitcoin/system/chain/script.hpp

@@ -50,6 +50,7 @@ class BC_API script
     static constexpr bool is_relaxed_push_pattern(const operations& ops) NOEXCEPT;
     static constexpr bool is_commitment_pattern(const operations& ops) NOEXCEPT;
     static constexpr bool is_witness_program_pattern(const operations& ops) NOEXCEPT;
+    static constexpr bool is_anchor_program_pattern(const operations& ops) NOEXCEPT;
     static constexpr bool is_pay_null_data_pattern(const operations& ops) NOEXCEPT;
     static constexpr bool is_pay_op_return_pattern(const operations& ops) NOEXCEPT;
     static constexpr bool is_pay_multisig_pattern(const operations& ops) NOEXCEPT;

include/bitcoin/system/chain/transaction.hpp

@@ -23,13 +23,15 @@
 #include <memory>
 #include <optional>
 #include <vector>
+#include <bitcoin/system/chain/enums/coverage.hpp>
 #include <bitcoin/system/chain/context.hpp>
 #include <bitcoin/system/chain/input.hpp>
 #include <bitcoin/system/chain/output.hpp>
 #include <bitcoin/system/chain/point.hpp>
 #include <bitcoin/system/define.hpp>
 #include <bitcoin/system/error/error.hpp>
 #include <bitcoin/system/hash/hash.hpp>
+#include <bitcoin/system/math/math.hpp>
 #include <bitcoin/system/stream/stream.hpp>
 
 namespace libbitcoin {
@@ -236,6 +238,20 @@ class BC_API transaction
 
 private:
     typedef struct { size_t nominal; size_t witnessed; } sizes;
+    typedef struct
+    {
+        hash_digest points;
+        hash_digest sequences;
+        hash_digest outputs;
+    } v0_cache;
+    typedef struct
+    {
+        hash_digest amounts;
+        hash_digest scripts;
+        hash_digest points;
+        hash_digest sequences;
+        hash_digest outputs;
+    } v1_cache;
 
     static bool segregated(const chain::inputs& inputs) NOEXCEPT;
     static bool segregated(const input_cptrs& inputs) NOEXCEPT;
@@ -250,24 +266,14 @@ class BC_API transaction
     code connect_input(const context& ctx,
         const input_iterator& it) const NOEXCEPT;
 
-    // Caching.
+    // Patterns.
     // ------------------------------------------------------------------------
 
-    typedef struct
-    {
-        hash_digest points;
-        hash_digest sequences;
-        hash_digest outputs;
-    } v0_cache;
+    static constexpr coverage mask_sighash(uint8_t sighash_flags) NOEXCEPT;
+    static constexpr bool is_anyone_can_pay(uint8_t sighash_flags) NOEXCEPT;
 
-    typedef struct
-    {
-        hash_digest amounts;
-        hash_digest scripts;
-        hash_digest points;
-        hash_digest sequences;
-        hash_digest outputs;
-    } v1_cache;
+    // Caching.
+    // ------------------------------------------------------------------------
 
     // Set sha256 cache if not set, so not thread safe unless cached.
     const hash_digest& single_hash_points() const NOEXCEPT;
@@ -293,8 +299,6 @@ class BC_API transaction
     // Signature hashing.
     // ------------------------------------------------------------------------
 
-    static coverage mask_sighash(uint8_t sighash_flags) NOEXCEPT;
-    static bool is_anyone_can_pay(uint8_t sighash_flags) NOEXCEPT;
     static uint32_t subscript_v1(const script& script) NOEXCEPT;
     uint8_t spend_type_v1(bool annex, bool tapscript) const NOEXCEPT;
     uint32_t input_index(const input_iterator& input) const NOEXCEPT;
@@ -353,6 +357,8 @@ DECLARE_JSON_VALUE_CONVERTORS(transaction::cptr);
 } // namespace system
 } // namespace libbitcoin
 
+#include <bitcoin/system/impl/chain/transaction_patterns.ipp>
+
 namespace std
 {
 template<>

include/bitcoin/system/chain/witness.hpp

@@ -103,6 +103,9 @@ class BC_API witness
     /// Patterns.
     /// -----------------------------------------------------------------------
 
+    /// The stack adheres to the annex pattern [bip341].
+    static constexpr bool is_annex_pattern(const chunk_cptrs& stack) NOEXCEPT;
+
     /// Verify the push size of each stack element [bip141].
     static constexpr bool is_push_size(const chunk_cptrs& stack) NOEXCEPT;
 
@@ -132,20 +135,17 @@ class BC_API witness
 private:
     // TODO: move to config serialization wrapper.
     static witness from_string(const std::string& mnemonic) NOEXCEPT;
-    static constexpr bool is_annex_pattern(const chunk_cptrs& stack) NOEXCEPT;
     static inline bool drop_annex(chunk_cptrs& stack) NOEXCEPT;
 
     void assign_data(reader& source, bool prefix) NOEXCEPT;
 
     // Witness should be stored as shared.
     chunk_cptrs stack_;
 
-    // Cache.
+    // Cache/alias.
     bool valid_;
     size_t size_;
-
-    // Annex member should not even consume space.
-    chain::annex annex_{ *this };
+    chain::annex annex_;
 };
 
 typedef std_vector<witness> witnesses;

include/bitcoin/system/data/memory.hpp

@@ -69,6 +69,16 @@ inline std::shared_ptr<const Type> to_shared(Args&&... values) NOEXCEPT
     return std::make_shared<const Type>(std::forward<Args>(values)...);
 }
 
+/// shared_ptr<non-const>
+/// ---------------------------------------------------------------------------
+
+/// Create non-const shared pointer from copied instance.
+template <typename Type>
+inline std::shared_ptr<Type> make_shared(const Type& value) NOEXCEPT
+{
+    return std::make_shared<Type>(value);
+}
+
 /// Obtain non constant pointer from shared_ptr to const.
 /// This is useful when allocating objects to shared const before population.
 template <typename Type>

include/bitcoin/system/error/script_error_t.hpp

@@ -47,6 +47,7 @@ enum script_error_t : uint8_t
     unexpected_witness,
     invalid_witness,
     invalid_witness_stack,
+    invalid_commitment,
     dirty_witness,
     stack_false,
 

include/bitcoin/system/impl/chain/annex.ipp

@@ -26,32 +26,48 @@
 namespace libbitcoin {
 namespace system {
 namespace chain {
+inline annex::annex() NOEXCEPT
+  : data_(nullptr)
+{
+}
 
-static const data_chunk& empty_annex() NOEXCEPT
+// Witness checks is_annex_pattern() and passes data, avoiding excess copying.
+inline annex::annex(const chunk_cptr& data) NOEXCEPT
+  : data_(data)
 {
-    static const data_chunk empty{};
-    return empty;
 }
 
-inline annex::annex(const witness& owner) NOEXCEPT
-  : witness_(owner)
+inline annex::annex(const chunk_cptrs& stack) NOEXCEPT
+  : data_(from_stack(stack))
+{
+}
+
+// static/protected
+inline chunk_cptr annex::from_stack(const chunk_cptrs& stack) NOEXCEPT
+{
+    return witness::is_annex_pattern(stack) ? stack.back() : nullptr;
+}
+
+// static/private
+inline const data_chunk& annex::empty_annex() NOEXCEPT
 {
+    static const data_chunk empty{};
+    return empty;
 }
 
 inline annex::operator bool() const NOEXCEPT
 {
-    return witness_.get().is_annex_pattern();
+    return data_.operator bool();
 }
 
 inline size_t annex::size() const NOEXCEPT
 {
-    return data().size();
+    return data_ ? data_->size() : zero;
 }
 
 inline const data_chunk& annex::data() const NOEXCEPT
 {
-    const auto& stack = witness_.get().stack();
-    return stack.empty() ? empty_annex() : *stack.back();
+    return data_ ? *data_ : empty_annex();
 }
 
 inline const hash_digest annex::hash() const NOEXCEPT

include/bitcoin/system/impl/chain/script_patterns.ipp

@@ -99,6 +99,15 @@ constexpr bool script::is_witness_program_pattern(
         && ops[1].data().size() <= max_witness_program;
 }
 
+// A witness program used only for policy (not implemented).
+constexpr bool script::is_anchor_program_pattern(const operations& ops) NOEXCEPT
+{
+    return is_witness_program_pattern(ops)
+        && ops[1].data().size() == 2
+        && ops[1].data()[0] == 0x4e
+        && ops[1].data()[1] == 0x73;
+}
+
 // The satoshi client now enables configurable data size for policy.
 constexpr bool script::is_pay_null_data_pattern(const operations& ops) NOEXCEPT
 {
@@ -208,8 +217,7 @@ constexpr bool script::is_pay_witness_script_hash_pattern(
 }
 
 // The first push is based on wacky satoshi op_check_multisig behavior that
-// we must perpetuate, though it's appearance here is policy not consensus.
-// Limiting to push_size_0 removes pattern ambiguity with little downside.
+// we must perpetuate, though this is not used in consensus validation.
 constexpr bool script::is_sign_multisig_pattern(const operations& ops) NOEXCEPT
 {
     const auto endorsement = [](const operation& op) NOEXCEPT

include/bitcoin/system/impl/chain/transaction_patterns.ipp

@@ -0,0 +1,57 @@
+/**
+ * Copyright (c) 2011-2025 libbitcoin developers (see AUTHORS)
+ *
+ * This file is part of libbitcoin.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef LIBBITCOIN_SYSTEM_CHAIN_TRANSACTION_PATTERNS_IPP
+#define LIBBITCOIN_SYSTEM_CHAIN_TRANSACTION_PATTERNS_IPP
+
+#include <bitcoin/system/chain/enums/coverage.hpp>
+#include <bitcoin/system/define.hpp>
+#include <bitcoin/system/math/math.hpp>
+
+namespace libbitcoin {
+namespace system {
+namespace chain {
+    
+//*****************************************************************************
+// CONSENSUS: Due to masking of bits 6/7 (8 is the anyone_can_pay flag), there
+// possible 7 bit values that can set "single" and 4 others are 4 that can set 
+// none, and yet all other values set "all".
+//*****************************************************************************
+constexpr coverage transaction::mask_sighash(uint8_t sighash_flags) NOEXCEPT
+{
+    switch (bit_and<uint8_t>(sighash_flags, coverage::mask))
+    {
+        case coverage::hash_single:
+            return coverage::hash_single;
+        case coverage::hash_none:
+            return coverage::hash_none;
+        default:
+            return coverage::hash_all;
+    }
+}
+
+constexpr bool transaction::is_anyone_can_pay(uint8_t sighash_flags) NOEXCEPT
+{
+    return get_right(sighash_flags, coverage::anyone_can_pay_bit);
+}
+
+} // namespace chain
+} // namespace system
+} // namespace libbitcoin
+
+#endif

include/bitcoin/system/impl/chain/witness_patterns.ipp

@@ -45,7 +45,7 @@ constexpr bool witness::is_reserved_pattern(const chunk_cptrs& stack) NOEXCEPT
     return is_one(stack.size()) && stack.front()->size() == hash_size;
 }
 
-// static/private
+// static
 constexpr bool witness::is_annex_pattern(const chunk_cptrs& stack) NOEXCEPT
 {
     // If at least two elements, discard annex if present.