Merge pull request #1766 from evoskuil/master

evoskuil · web-flow · commit 103fac33aa6e · 2025-12-05T20:09:37.000-05:00
Fix block.fees() (use cb.spend, not cb.value).
diff --git a/include/bitcoin/system/chain/transaction.hpp b/include/bitcoin/system/chain/transaction.hpp
@@ -105,7 +105,7 @@ class BC_API transaction
     /// Computed properties.
     size_t weight() const NOEXCEPT;
     uint64_t fee() const NOEXCEPT;
-    uint64_t claim() const NOEXCEPT;
+    uint64_t spend() const NOEXCEPT;
     uint64_t value() const NOEXCEPT;
     bool is_coinbase() const NOEXCEPT;
     bool is_segregated() const NOEXCEPT;
diff --git a/src/chain/block.cpp b/src/chain/block.cpp
@@ -669,26 +669,25 @@ static uint64_t block_subsidy(size_t height, uint64_t subsidy_interval,
 
 // Prevouts required.
 
+// The fees() is the sum of all transaction fees (coinbase is zero).
 uint64_t block::fees() const NOEXCEPT
 {
-    if (txs_->empty())
-        return {};
-
     // Overflow returns max_uint64.
     const auto value = [](uint64_t total, const auto& tx) NOEXCEPT
     {
         return ceilinged_add(total, tx->fee());
     };
 
-    return std::accumulate(std::next(txs_->begin()), txs_->end(),
-        uint64_t{}, value);
+    return std::accumulate(txs_->begin(), txs_->end(), 0_u64, value);
 }
 
+// The claim() is the spend of the coinbase transaction.
 uint64_t block::claim() const NOEXCEPT
 {
-    return txs_->empty() ? zero : txs_->front()->value();
+    return txs_->empty() ? zero : txs_->front()->spend();
 }
 
+// The reward() is the sum of all transaction.fee() and the block subsidy.
 uint64_t block::reward(size_t height, uint64_t subsidy_interval,
     uint64_t initial_block_subsidy_satoshi, bool bip42) const NOEXCEPT
 {
diff --git a/src/chain/transaction.cpp b/src/chain/transaction.cpp
@@ -347,8 +347,8 @@ const outputs_cptr& transaction::outputs_ptr() const NOEXCEPT
 uint64_t transaction::fee() const NOEXCEPT
 {
     // Underflow returns zero (and is_overspent() will be true).
-    // This is value of prevouts spent by inputs minus that claimed by outputs.
-    return floored_subtract(value(), claim());
+    // The value of prevouts referenced by inputs minus that spent by outputs.
+    return floored_subtract(value(), spend());
 }
 
 // Methods.
@@ -650,36 +650,39 @@ bool transaction::is_missing_prevouts() const NOEXCEPT
     return std::any_of(inputs_->begin(), inputs_->end(), missing);
 }
 
-uint64_t transaction::claim() const NOEXCEPT
+// The value() is the sum of own inputs.
+uint64_t transaction::value() const NOEXCEPT
 {
-    // Overflow returns max_uint64.
-    const auto sum = [](uint64_t total, const auto& output) NOEXCEPT
+    // Overflow returns max_uint64. Not populated/coinbase return zero.
+    const auto sum = [](uint64_t total, const auto& input) NOEXCEPT
     {
-        return ceilinged_add(total, output->value());
+        const auto value = input->prevout ? input->prevout->value() : zero;
+        return ceilinged_add(total, value);
     };
 
-    // The amount claimed by outputs.
-    return std::accumulate(outputs_->begin(), outputs_->end(), 0_u64, sum);
+    // The amount referenced by inputs.
+    return std::accumulate(inputs_->begin(), inputs_->end(), 0_u64, sum);
 }
 
-uint64_t transaction::value() const NOEXCEPT
+// The spend() is the sum of own outputs.
+uint64_t transaction::spend() const NOEXCEPT
 {
-    // Overflow, not populated, and coinbase (default) return max_uint64.
-    const auto sum = [](uint64_t total, const auto& input) NOEXCEPT
+    // Overflow returns max_uint64.
+    const auto sum = [](uint64_t total, const auto& output) NOEXCEPT
     {
-        const auto value = input->prevout ? input->prevout->value() : max_uint64;
-        return ceilinged_add(total, value);
+        return ceilinged_add(total, output->value());
     };
 
-    // The amount of prevouts (referenced by inputs).
-    return std::accumulate(inputs_->begin(), inputs_->end(), 0_u64, sum);
+    // The amount spent by outputs.
+    return std::accumulate(outputs_->begin(), outputs_->end(), 0_u64, sum);
 }
 
+// Overspent is invalid (spend exceeds value), while underspent is the fee().
 bool transaction::is_overspent() const NOEXCEPT
 {
     BC_ASSERT(!is_coinbase());
 
-    return claim() > value();
+    return spend() > value();
 }
 
 constexpr bool is_non_coinbase_mature(size_t tx_height, size_t height) NOEXCEPT
diff --git a/test/chain/transaction.cpp b/test/chain/transaction.cpp
@@ -425,7 +425,7 @@ BOOST_AUTO_TEST_CASE(transaction__fee__empty__zero)
     BOOST_REQUIRE_EQUAL(instance.fee(), 0u);
 }
 
-BOOST_AUTO_TEST_CASE(transaction__fee__default_input__max_uint64)
+BOOST_AUTO_TEST_CASE(transaction__fee__default_input__zero)
 {
     const transaction instance
     {
@@ -435,8 +435,7 @@ BOOST_AUTO_TEST_CASE(transaction__fee__default_input__max_uint64)
         0
     };
 
-    // floored_subtract(max_uint64, 0)
-    BOOST_REQUIRE_EQUAL(instance.fee(), max_uint64);
+    BOOST_REQUIRE_EQUAL(instance.fee(), zero);
 }
 
 BOOST_AUTO_TEST_CASE(transaction__fee__default_output__zero)
@@ -449,17 +448,16 @@ BOOST_AUTO_TEST_CASE(transaction__fee__default_output__zero)
         0
     };
 
-    // floored_subtract(0, max_uint64)
     BOOST_REQUIRE_EQUAL(instance.fee(), 0u);
 }
 
-BOOST_AUTO_TEST_CASE(transaction__fee__nonempty__outputs_minus_inputs)
+BOOST_AUTO_TEST_CASE(transaction__fee__nonempty__prevouts_minus_outputs)
 {
     constexpr uint64_t value0 = 123;
     constexpr uint64_t value1 = 321;
-    constexpr uint64_t claim0 = 11;
-    constexpr uint64_t claim1 = 11;
-    constexpr uint64_t claim2 = 22;
+    constexpr uint64_t spend0 = 11;
+    constexpr uint64_t spend1 = 11;
+    constexpr uint64_t spend2 = 22;
 
     input input0;
     input input1;
@@ -471,41 +469,41 @@ BOOST_AUTO_TEST_CASE(transaction__fee__nonempty__outputs_minus_inputs)
         0,
         { input0, input1 },
         {
-            { claim0, script{} },
-            { claim1, script{} },
-            { claim2, script{} }
+            { spend0, script{} },
+            { spend1, script{} },
+            { spend2, script{} }
         },
         0
     };
 
-    // floored_subtract(values, claims)
-    BOOST_REQUIRE_EQUAL(instance.fee(), value0 + value1 - claim0 - claim1 - claim2);
+    // floored_subtract(values, spend)
+    BOOST_REQUIRE_EQUAL(instance.fee(), value0 + value1 - spend0 - spend1 - spend2);
 }
 
-BOOST_AUTO_TEST_CASE(transaction__claim__empty_outputs__zero)
+BOOST_AUTO_TEST_CASE(transaction__spend__empty_outputs__zero)
 {
     transaction instance;
-    BOOST_REQUIRE_EQUAL(instance.claim(), 0u);
+    BOOST_REQUIRE_EQUAL(instance.spend(), 0u);
 }
 
-BOOST_AUTO_TEST_CASE(transaction__claim__two_outputs__sum)
+BOOST_AUTO_TEST_CASE(transaction__spend__two_outputs__sum)
 {
-    const uint64_t claim0 = 123;
-    const uint64_t claim1 = 321;
+    constexpr uint64_t spend0{ 123 };
+    constexpr uint64_t spend1{ 321 };
     const transaction instance
     {
         0,
         {},
         {
-            { claim0, script{} },
-            { claim1, script{} }
+            { spend0, script{} },
+            { spend1, script{} }
         },
         0
     };
 
 
-    // ceilinged_add(claim0, claim1)
-    BOOST_REQUIRE_EQUAL(instance.claim(), claim0 + claim1);
+    // ceilinged_add(spend0, spend1)
+    BOOST_REQUIRE_EQUAL(instance.spend(), spend0 + spend1);
 }
 
 BOOST_AUTO_TEST_CASE(transaction__value__no_inputs__zero)
@@ -514,7 +512,7 @@ BOOST_AUTO_TEST_CASE(transaction__value__no_inputs__zero)
     BOOST_REQUIRE_EQUAL(instance.value(), 0u);
 }
 
-BOOST_AUTO_TEST_CASE(transaction__value__default_input2__max_uint64)
+BOOST_AUTO_TEST_CASE(transaction__value__default_input2__zero)
 {
     transaction instance
     {
@@ -524,14 +522,13 @@ BOOST_AUTO_TEST_CASE(transaction__value__default_input2__max_uint64)
         0
     };
 
-    // ceilinged_add(max_uint64, max_uint64)
-    BOOST_REQUIRE_EQUAL(instance.value(), max_uint64);
+    BOOST_REQUIRE_EQUAL(instance.value(), zero);
 }
 
 BOOST_AUTO_TEST_CASE(transaction__value__two_prevouts__sum)
 {
-    constexpr uint64_t value0 = 123;
-    constexpr uint64_t value1 = 321;
+    constexpr uint64_t value0{ 123 };
+    constexpr uint64_t value1{ 321 };
 
     const input input0;
     const input input1;

Original file line number	Diff line number	Diff line change
`@@ -669,26 +669,25 @@ static uint64_t block_subsidy(size_t height, uint64_t subsidy_interval,`
`669`	`669`
`670`	`670`	`// Prevouts required.`
`671`	`671`
	`672`	`+// The fees() is the sum of all transaction fees (coinbase is zero).`
`672`	`673`	`uint64_t block::fees() const NOEXCEPT`
`673`	`674`	`{`
`674`		`- if (txs_->empty())`
`675`		`- return {};`
`676`		`-`
`677`	`675`	`// Overflow returns max_uint64.`
`678`	`676`	`const auto value = [](uint64_t total, const auto& tx) NOEXCEPT`
`679`	`677`	`{`
`680`	`678`	`return ceilinged_add(total, tx->fee());`
`681`	`679`	`};`
`682`	`680`
`683`		`- return std::accumulate(std::next(txs_->begin()), txs_->end(),`
`684`		`- uint64_t{}, value);`
	`681`	`+ return std::accumulate(txs_->begin(), txs_->end(), 0_u64, value);`
`685`	`682`	`}`
`686`	`683`
	`684`	`+// The claim() is the spend of the coinbase transaction.`
`687`	`685`	`uint64_t block::claim() const NOEXCEPT`
`688`	`686`	`{`
`689`		`- return txs_->empty() ? zero : txs_->front()->value();`
	`687`	`+ return txs_->empty() ? zero : txs_->front()->spend();`
`690`	`688`	`}`
`691`	`689`
	`690`	`+// The reward() is the sum of all transaction.fee() and the block subsidy.`
`692`	`691`	`uint64_t block::reward(size_t height, uint64_t subsidy_interval,`
`693`	`692`	`uint64_t initial_block_subsidy_satoshi, bool bip42) const NOEXCEPT`
`694`	`693`	`{`
Original file line number	Diff line number	Diff line change
`@@ -347,8 +347,8 @@ const outputs_cptr& transaction::outputs_ptr() const NOEXCEPT`
`347`	`347`	`uint64_t transaction::fee() const NOEXCEPT`
`348`	`348`	`{`
`349`	`349`	`// Underflow returns zero (and is_overspent() will be true).`
`350`		`- // This is value of prevouts spent by inputs minus that claimed by outputs.`
`351`		`- return floored_subtract(value(), claim());`
	`350`	`+ // The value of prevouts referenced by inputs minus that spent by outputs.`
	`351`	`+ return floored_subtract(value(), spend());`
`352`	`352`	`}`
`353`	`353`
`354`	`354`	`// Methods.`
`@@ -650,36 +650,39 @@ bool transaction::is_missing_prevouts() const NOEXCEPT`
`650`	`650`	`return std::any_of(inputs_->begin(), inputs_->end(), missing);`
`651`	`651`	`}`
`652`	`652`
`653`		`-uint64_t transaction::claim() const NOEXCEPT`
	`653`	`+// The value() is the sum of own inputs.`
	`654`	`+uint64_t transaction::value() const NOEXCEPT`
`654`	`655`	`{`
`655`		`- // Overflow returns max_uint64.`
`656`		`- const auto sum = [](uint64_t total, const auto& output) NOEXCEPT`
	`656`	`+ // Overflow returns max_uint64. Not populated/coinbase return zero.`
	`657`	`+ const auto sum = [](uint64_t total, const auto& input) NOEXCEPT`
`657`	`658`	`{`
`658`		`- return ceilinged_add(total, output->value());`
	`659`	`+ const auto value = input->prevout ? input->prevout->value() : zero;`
	`660`	`+ return ceilinged_add(total, value);`
`659`	`661`	`};`
`660`	`662`
`661`		`- // The amount claimed by outputs.`
`662`		`- return std::accumulate(outputs_->begin(), outputs_->end(), 0_u64, sum);`
	`663`	`+ // The amount referenced by inputs.`
	`664`	`+ return std::accumulate(inputs_->begin(), inputs_->end(), 0_u64, sum);`
`663`	`665`	`}`
`664`	`666`
`665`		`-uint64_t transaction::value() const NOEXCEPT`
	`667`	`+// The spend() is the sum of own outputs.`
	`668`	`+uint64_t transaction::spend() const NOEXCEPT`
`666`	`669`	`{`
`667`		`- // Overflow, not populated, and coinbase (default) return max_uint64.`
`668`		`- const auto sum = [](uint64_t total, const auto& input) NOEXCEPT`
	`670`	`+ // Overflow returns max_uint64.`
	`671`	`+ const auto sum = [](uint64_t total, const auto& output) NOEXCEPT`
`669`	`672`	`{`
`670`		`- const auto value = input->prevout ? input->prevout->value() : max_uint64;`
`671`		`- return ceilinged_add(total, value);`
	`673`	`+ return ceilinged_add(total, output->value());`
`672`	`674`	`};`
`673`	`675`
`674`		`- // The amount of prevouts (referenced by inputs).`
`675`		`- return std::accumulate(inputs_->begin(), inputs_->end(), 0_u64, sum);`
	`676`	`+ // The amount spent by outputs.`
	`677`	`+ return std::accumulate(outputs_->begin(), outputs_->end(), 0_u64, sum);`
`676`	`678`	`}`
`677`	`679`
	`680`	`+// Overspent is invalid (spend exceeds value), while underspent is the fee().`
`678`	`681`	`bool transaction::is_overspent() const NOEXCEPT`
`679`	`682`	`{`
`680`	`683`	`BC_ASSERT(!is_coinbase());`
`681`	`684`
`682`		`- return claim() > value();`
	`685`	`+ return spend() > value();`
`683`	`686`	`}`
`684`	`687`
`685`	`688`	`constexpr bool is_non_coinbase_mature(size_t tx_height, size_t height) NOEXCEPT`
Original file line number	Diff line number	Diff line change
`@@ -425,7 +425,7 @@ BOOST_AUTO_TEST_CASE(transaction__fee__empty__zero)`
`425`	`425`	`BOOST_REQUIRE_EQUAL(instance.fee(), 0u);`
`426`	`426`	`}`
`427`	`427`
`428`		`-BOOST_AUTO_TEST_CASE(transaction__fee__default_input__max_uint64)`
	`428`	`+BOOST_AUTO_TEST_CASE(transaction__fee__default_input__zero)`
`429`	`429`	`{`
`430`	`430`	`const transaction instance`
`431`	`431`	`{`
`@@ -435,8 +435,7 @@ BOOST_AUTO_TEST_CASE(transaction__fee__default_input__max_uint64)`
`435`	`435`	`0`
`436`	`436`	`};`
`437`	`437`
`438`		`- // floored_subtract(max_uint64, 0)`
`439`		`- BOOST_REQUIRE_EQUAL(instance.fee(), max_uint64);`
	`438`	`+ BOOST_REQUIRE_EQUAL(instance.fee(), zero);`
`440`	`439`	`}`
`441`	`440`
`442`	`441`	`BOOST_AUTO_TEST_CASE(transaction__fee__default_output__zero)`
`@@ -449,17 +448,16 @@ BOOST_AUTO_TEST_CASE(transaction__fee__default_output__zero)`
`449`	`448`	`0`
`450`	`449`	`};`
`451`	`450`
`452`		`- // floored_subtract(0, max_uint64)`
`453`	`451`	`BOOST_REQUIRE_EQUAL(instance.fee(), 0u);`
`454`	`452`	`}`
`455`	`453`
`456`		`-BOOST_AUTO_TEST_CASE(transaction__fee__nonempty__outputs_minus_inputs)`
	`454`	`+BOOST_AUTO_TEST_CASE(transaction__fee__nonempty__prevouts_minus_outputs)`
`457`	`455`	`{`
`458`	`456`	`constexpr uint64_t value0 = 123;`
`459`	`457`	`constexpr uint64_t value1 = 321;`
`460`		`- constexpr uint64_t claim0 = 11;`
`461`		`- constexpr uint64_t claim1 = 11;`
`462`		`- constexpr uint64_t claim2 = 22;`
	`458`	`+ constexpr uint64_t spend0 = 11;`
	`459`	`+ constexpr uint64_t spend1 = 11;`
	`460`	`+ constexpr uint64_t spend2 = 22;`
`463`	`461`
`464`	`462`	`input input0;`
`465`	`463`	`input input1;`
`@@ -471,41 +469,41 @@ BOOST_AUTO_TEST_CASE(transaction__fee__nonempty__outputs_minus_inputs)`
`471`	`469`	`0,`
`472`	`470`	`{ input0, input1 },`
`473`	`471`	`{`
`474`		`- { claim0, script{} },`
`475`		`- { claim1, script{} },`
`476`		`- { claim2, script{} }`
	`472`	`+ { spend0, script{} },`
	`473`	`+ { spend1, script{} },`
	`474`	`+ { spend2, script{} }`
`477`	`475`	`},`
`478`	`476`	`0`
`479`	`477`	`};`
`480`	`478`
`481`		`- // floored_subtract(values, claims)`
`482`		`- BOOST_REQUIRE_EQUAL(instance.fee(), value0 + value1 - claim0 - claim1 - claim2);`
	`479`	`+ // floored_subtract(values, spend)`
	`480`	`+ BOOST_REQUIRE_EQUAL(instance.fee(), value0 + value1 - spend0 - spend1 - spend2);`
`483`	`481`	`}`
`484`	`482`
`485`		`-BOOST_AUTO_TEST_CASE(transaction__claim__empty_outputs__zero)`
	`483`	`+BOOST_AUTO_TEST_CASE(transaction__spend__empty_outputs__zero)`
`486`	`484`	`{`
`487`	`485`	`transaction instance;`
`488`		`- BOOST_REQUIRE_EQUAL(instance.claim(), 0u);`
	`486`	`+ BOOST_REQUIRE_EQUAL(instance.spend(), 0u);`
`489`	`487`	`}`
`490`	`488`
`491`		`-BOOST_AUTO_TEST_CASE(transaction__claim__two_outputs__sum)`
	`489`	`+BOOST_AUTO_TEST_CASE(transaction__spend__two_outputs__sum)`
`492`	`490`	`{`
`493`		`- const uint64_t claim0 = 123;`
`494`		`- const uint64_t claim1 = 321;`
	`491`	`+ constexpr uint64_t spend0{ 123 };`
	`492`	`+ constexpr uint64_t spend1{ 321 };`
`495`	`493`	`const transaction instance`
`496`	`494`	`{`
`497`	`495`	`0,`
`498`	`496`	`{},`
`499`	`497`	`{`
`500`		`- { claim0, script{} },`
`501`		`- { claim1, script{} }`
	`498`	`+ { spend0, script{} },`
	`499`	`+ { spend1, script{} }`
`502`	`500`	`},`
`503`	`501`	`0`
`504`	`502`	`};`
`505`	`503`
`506`	`504`
`507`		`- // ceilinged_add(claim0, claim1)`
`508`		`- BOOST_REQUIRE_EQUAL(instance.claim(), claim0 + claim1);`
	`505`	`+ // ceilinged_add(spend0, spend1)`
	`506`	`+ BOOST_REQUIRE_EQUAL(instance.spend(), spend0 + spend1);`
`509`	`507`	`}`
`510`	`508`
`511`	`509`	`BOOST_AUTO_TEST_CASE(transaction__value__no_inputs__zero)`
`@@ -514,7 +512,7 @@ BOOST_AUTO_TEST_CASE(transaction__value__no_inputs__zero)`
`514`	`512`	`BOOST_REQUIRE_EQUAL(instance.value(), 0u);`
`515`	`513`	`}`
`516`	`514`
`517`		`-BOOST_AUTO_TEST_CASE(transaction__value__default_input2__max_uint64)`
	`515`	`+BOOST_AUTO_TEST_CASE(transaction__value__default_input2__zero)`
`518`	`516`	`{`
`519`	`517`	`transaction instance`
`520`	`518`	`{`
`@@ -524,14 +522,13 @@ BOOST_AUTO_TEST_CASE(transaction__value__default_input2__max_uint64)`
`524`	`522`	`0`
`525`	`523`	`};`
`526`	`524`
`527`		`- // ceilinged_add(max_uint64, max_uint64)`
`528`		`- BOOST_REQUIRE_EQUAL(instance.value(), max_uint64);`
	`525`	`+ BOOST_REQUIRE_EQUAL(instance.value(), zero);`
`529`	`526`	`}`
`530`	`527`
`531`	`528`	`BOOST_AUTO_TEST_CASE(transaction__value__two_prevouts__sum)`
`532`	`529`	`{`
`533`		`- constexpr uint64_t value0 = 123;`
`534`		`- constexpr uint64_t value1 = 321;`
	`530`	`+ constexpr uint64_t value0{ 123 };`
	`531`	`+ constexpr uint64_t value1{ 321 };`
`535`	`532`
`536`	`533`	`const input input0;`
`537`	`534`	`const input input1;`