Simpler ops/stack counting; drop unused var

bitcoin/script/miniscript.cpp

@@ -342,7 +342,7 @@ bool ParseScriptNumber(const std::pair<opcodetype, std::vector<unsigned char>>&
         try {
             k = CScriptNum(in.second, true).GetInt64();
             return true;
-        } catch(const scriptnum_error& error) {}
+        } catch(const scriptnum_error&) {}
     }
     return false;
 }

bitcoin/script/miniscript.h

@@ -497,18 +497,16 @@ private:
             case NodeType::JUST_1: return {0, 0, {}};
             case NodeType::JUST_0: return {0, {}, 0};
             case NodeType::THRESH: {
-                uint32_t stat = 0, dsat = 0;
+                uint32_t stat = 0;
-                int32_t sat_sum = 0;
+                auto sats = Vector(internal::MaxInt<uint32_t>(0));
-                std::vector<int32_t> diffs;
                 for (const auto& sub : subs) {
                     stat += sub->ops.stat + 1;
-                    dsat += sub->ops.dsat.value; // The type system requires "d" for thresh, so dsat must always be valid.
+                    auto next_sats = Vector(sats[0] + sub->ops.dsat);
-                    if (sub->ops.sat.valid) diffs.push_back((int32_t)sub->ops.sat.value - (int32_t)sub->ops.dsat.value);
+                    for (size_t j = 1; j < sats.size(); ++j) next_sats.push_back(Choose(sats[j] + sub->ops.dsat, sats[j - 1] + sub->ops.sat));
+                    next_sats.push_back(sats[sats.size() - 1] + sub->ops.sat);
+                    sats = std::move(next_sats);
                 }
-                if (diffs.size() < k) return {stat, {}, dsat};
+                return {stat, sats[k], sats[0]};
-                std::sort(diffs.begin(), diffs.end());
-                for (size_t i = diffs.size() - k; i < diffs.size(); ++i) sat_sum += diffs[i];
-                return {stat, sat_sum + dsat, dsat};
             }
         }
         assert(false);
@@ -543,17 +541,14 @@ private:
             case NodeType::JUST_1: return {0, {}};
             case NodeType::JUST_0: return {{}, 0};
             case NodeType::THRESH: {
-                uint32_t dsat = 0;
+                auto sats = Vector(internal::MaxInt<uint32_t>(0));
-                int32_t sat_sum = 0;
-                std::vector<int32_t> diffs;
                 for (const auto& sub : subs) {
-                    dsat += sub->ss.dsat.value; // The type system requires "d" for thresh, so dsat must always be valid.
+                    auto next_sats = Vector(sats[0] + sub->ss.dsat);
-                    if (sub->ss.sat.valid) diffs.push_back((int32_t)sub->ss.sat.value - (int32_t)sub->ss.dsat.value);
+                    for (size_t j = 1; j < sats.size(); ++j) next_sats.push_back(Choose(sats[j] + sub->ss.dsat, sats[j - 1] + sub->ss.sat));
+                    next_sats.push_back(sats[sats.size() - 1] + sub->ss.sat);
+                    sats = std::move(next_sats);
                 }
-                if (diffs.size() < k) return {{}, dsat};
+                return {sats[k], sats[0]};
-                std::sort(diffs.begin(), diffs.end());
-                for (size_t i = diffs.size() - k; i < diffs.size(); ++i) sat_sum += diffs[i];
-                return {sat_sum + dsat, dsat};
             }
         }
         assert(false);