251        }
252        if (fRequireMinimal && vch.size() > 0) {
253            // Check that the number is encoded with the minimum possible
254            // number of bytes.
255            //
256            // If the most-significant-byte - excluding the sign bit - is zero
257            // then we're not minimal. Note how this test also rejects the
258            // negative-zero encoding, 0x80.
259            if ((vch.back() & 0x7f) == 0) {
260                // One exception: if there's more than one byte and the most
261                // significant bit of the second-most-significant-byte is set
262                // it would conflict with the sign bit. An example of this case
263                // is +-255, which encode to 0xff00 and 0xff80 respectively.
264                // (big-endian).
265                if (vch.size() <= 1 || (vch[vch.size() - 2] & 0x80) == 0) {
266                    throw scriptnum_error("non-minimally encoded script number");
267                }
268            }
269        }
270        m_value = set_vch(vch);
271    }
272
273    inline bool operator==(const int64_t& rhs) const    { return m_value == rhs; }
274    inline auto operator<=>(const int64_t& rhs) const    { return m_value <=> rhs; }
275
276    inline bool operator==(const CScriptNum& rhs) const { return operator==(rhs.m_value); }
277    inline auto operator<=>(const CScriptNum& rhs) const { return operator<=>(rhs.m_value); }
278
279    inline CScriptNum operator+(   const int64_t& rhs)    const { return CScriptNum(m_value + rhs);}
280    inline CScriptNum operator-(   const int64_t& rhs)    const { return CScriptNum(m_value - rhs);}
281    inline CScriptNum operator+(   const CScriptNum& rhs) const { return operator+(rhs.m_value);   }
282    inline CScriptNum operator-(   const CScriptNum& rhs) const { return operator-(rhs.m_value);   }
283
284    inline CScriptNum& operator+=( const CScriptNum& rhs)       { return operator+=(rhs.m_value);  }
285    inline CScriptNum& operator-=( const CScriptNum& rhs)       { return operator-=(rhs.m_value);  }
286
287    inline CScriptNum operator&(   const int64_t& rhs)    const { return CScriptNum(m_value & rhs);}
288    inline CScriptNum operator&(   const CScriptNum& rhs) const { return operator&(rhs.m_value);   }
289
290    inline CScriptNum& operator&=( const CScriptNum& rhs)       { return operator&=(rhs.m_value);  }
291
292    inline CScriptNum operator-()                         const
293    {
294        assert(m_value != std::numeric_limits<int64_t>::min());
295        return CScriptNum(-m_value);
296    }
297
298    inline CScriptNum& operator=( const int64_t& rhs)
299    {
300        m_value = rhs;
301        return *this;
302    }
303
304    inline CScriptNum& operator+=( const int64_t& rhs)
305    {
306        assert(rhs == 0 || (rhs > 0 && m_value <= std::numeric_limits<int64_t>::max() - rhs) ||
307                           (rhs < 0 && m_value >= std::numeric_limits<int64_t>::min() - rhs));
308        m_value += rhs;
309        return *this;
310    }
311
312    inline CScriptNum& operator-=( const int64_t& rhs)
313    {
314        assert(rhs == 0 || (rhs > 0 && m_value >= std::numeric_limits<int64_t>::min() + rhs) ||
315                           (rhs < 0 && m_value <= std::numeric_limits<int64_t>::max() + rhs));
316        m_value -= rhs;
317        return *this;
318    }
319
320    inline CScriptNum& operator&=( const int64_t& rhs)
321    {
322        m_value &= rhs;
323        return *this;
324    }
325
326    int getint() const
327    {
328        if (m_value > std::numeric_limits<int>::max())
329            return std::numeric_limits<int>::max();
330        else if (m_value < std::numeric_limits<int>::min())
331            return std::numeric_limits<int>::min();
332        return m_value;
333    }
334
335    int64_t GetInt64() const { return m_value; }
336
337    std::vector<unsigned char> getvch() const
338    {
339        return serialize(m_value);
340    }
341
342    static std::vector<unsigned char> serialize(const int64_t& value)
343    {
344        if(value == 0)
345            return std::vector<unsigned char>();
346
347        std::vector<unsigned char> result;
348        const bool neg = value < 0;
349        uint64_t absvalue = neg ? ~static_cast<uint64_t>(value) + 1 : static_cast<uint64_t>(value);
350
351        while(absvalue)
352        {
353            result.push_back(absvalue & 0xff);
354            absvalue >>= 8;
355        }
356
357//    - If the most significant byte is >= 0x80 and the value is positive, push a
358//    new zero-byte to make the significant byte < 0x80 again.
359
360//    - If the most significant byte is >= 0x80 and the value is negative, push a
361//    new 0x80 byte that will be popped off when converting to an integral.
362
363//    - If the most significant byte is < 0x80 and the value is negative, add
364//    0x80 to it, since it will be subtracted and interpreted as a negative when
365//    converting to an integral.
366
367        if (result.back() & 0x80)
368            result.push_back(neg ? 0x80 : 0);
369        else if (neg)
370            result.back() |= 0x80;
371
372        return result;
373    }
374
375private:
376    static int64_t set_vch(const std::vector<unsigned char>& vch)
377    {
378      if (vch.empty())
379          return 0;
380
381      int64_t result = 0;
382      for (size_t i = 0; i != vch.size(); ++i)
383          result |= static_cast<int64_t>(vch[i]) << 8*i;
384
385      // If the input vector's most significant byte is 0x80, remove it from
386      // the result's msb and return a negative.
387      if (vch.back() & 0x80)
388          return -((int64_t)(result & ~(0x80ULL << (8 * (vch.size() - 1)))));
389
390      return result;
391    }
392
393    int64_t m_value;
394};
395
396/**
397 * We use a prevector for the script to reduce the considerable memory overhead
398 *  of vectors in cases where they normally contain a small number of small elements.
399 */
400using CScriptBase = prevector<36, uint8_t>;
401
402bool GetScriptOp(CScriptBase::const_iterator& pc, CScriptBase::const_iterator end, opcodetype& opcodeRet, std::vector<unsigned char>* pvchRet);
403
404/** Serialized script, used inside transaction inputs and outputs */
405class CScript : public CScriptBase
406{
407private:
408    inline void AppendDataSize(const uint32_t size)
409    {
410        if (size < OP_PUSHDATA1) {
411            insert(end(), static_cast<value_type>(size));
412        } else if (size <= 0xff) {
413            insert(end(), OP_PUSHDATA1);
414            insert(end(), static_cast<value_type>(size));
415        } else if (size <= 0xffff) {
416            insert(end(), OP_PUSHDATA2);
417            value_type data[2];
418            WriteLE16(data, size);
419            insert(end(), std::cbegin(data), std::cend(data));
420        } else {
421            insert(end(), OP_PUSHDATA4);
422            value_type data[4];
423            WriteLE32(data, size);
424            insert(end(), std::cbegin(data), std::cend(data));
425        }
426    }
427
428    void AppendData(std::span<const value_type> data)
429    {
430        insert(end(), data.begin(), data.end());
431    }
432
433protected:
434    CScript& push_int64(int64_t n)
435    {
436        if (n == -1 || (n >= 1 && n <= 16))
437        {
438            push_back(n + (OP_1 - 1));
439        }
440        else if (n == 0)
441        {
442            push_back(OP_0);
443        }
444        else
445        {
446            *this << CScriptNum::serialize(n);
447        }
448        return *this;
449    }
450
451public:
452    CScript() = default;
453    template <std::input_iterator InputIterator>
454    CScript(InputIterator first, InputIterator last) : CScriptBase{first, last} { }
455
456    SERIALIZE_METHODS(CScript, obj) { READWRITE(AsBase<CScriptBase>(obj)); }
457
458    explicit CScript(int64_t b) { operator<<(b); }
459    explicit CScript(opcodetype b)     { operator<<(b); }
460    explicit CScript(const CScriptNum& b) { operator<<(b); }
461    // delete non-existent constructor to defend against future introduction
462    // e.g. via prevector
463    explicit CScript(const std::vector<unsigned char>& b) = delete;
464
465    /** Delete non-existent operator to defend against future introduction */
466    CScript& operator<<(const CScript& b) = delete;
467
468    CScript& operator<<(int64_t b) LIFETIMEBOUND { return push_int64(b); }
469
470    CScript& operator<<(opcodetype opcode) LIFETIMEBOUND
471    {
472        if (opcode < 0 || opcode > 0xff)
473            throw std::runtime_error("CScript::operator<<(): invalid opcode");
474        insert(end(), (unsigned char)opcode);
475        return *this;
476    }
477
478    CScript& operator<<(const CScriptNum& b) LIFETIMEBOUND
479    {
480        *this << b.getvch();
481        return *this;
482    }
483
484    CScript& operator<<(std::span<const std::byte> b) LIFETIMEBOUND
485    {
486        AppendDataSize(b.size());
487        AppendData({reinterpret_cast<const value_type*>(b.data()), b.size()});
488        return *this;
489    }
490
491    // For compatibility reasons. In new code, prefer using std::byte instead of uint8_t.
492    CScript& operator<<(std::span<const value_type> b) LIFETIMEBOUND
493    {
494        return *this << std::as_bytes(b);
495    }
496
497    bool GetOp(const_iterator& pc, opcodetype& opcodeRet, std::vector<unsigned char>& vchRet) const
498    {
499        return GetScriptOp(pc, end(), opcodeRet, &vchRet);
500    }