501
502    bool GetOp(const_iterator& pc, opcodetype& opcodeRet) const
503    {
504        return GetScriptOp(pc, end(), opcodeRet, nullptr);
505    }
506
507    /** Encode/decode small integers: */
508    static int DecodeOP_N(opcodetype opcode)
509    {
510        if (opcode == OP_0)
511            return 0;
512        assert(opcode >= OP_1 && opcode <= OP_16);
513        return (int)opcode - (int)(OP_1 - 1);
514    }
515    static opcodetype EncodeOP_N(int n)
516    {
517        assert(n >= 0 && n <= 16);
518        if (n == 0)
519            return OP_0;
520        return (opcodetype)(OP_1+n-1);
521    }
522
523    /**
524     * Pre-version-0.6, Bitcoin always counted CHECKMULTISIGs
525     * as 20 sigops. With pay-to-script-hash, that changed:
526     * CHECKMULTISIGs serialized in scriptSigs are
527     * counted more accurately, assuming they are of the form
528     *  ... OP_N CHECKMULTISIG ...
529     */
530    unsigned int GetSigOpCount(bool fAccurate) const;
531
532    /**
533     * Accurately count sigOps, including sigOps in
534     * pay-to-script-hash transactions:
535     */
536    unsigned int GetSigOpCount(const CScript& scriptSig) const;
537
538    /*
539     * OP_1 <0x4e73>
540     */
541    bool IsPayToAnchor() const;
542    /** Checks if output of IsWitnessProgram comes from a P2A output script
543     */
544    static bool IsPayToAnchor(int version, const std::vector<unsigned char>& program);
545
546    bool IsPayToScriptHash() const;
547    bool IsPayToWitnessScriptHash() const;
548    bool IsWitnessProgram(int& version, std::vector<unsigned char>& program) const;
549
550    bool IsPayToTaproot() const;
551
552    /** Called by IsStandardTx and P2SH/BIP62 VerifyScript (which makes it consensus-critical). */
553    bool IsPushOnly(const_iterator pc) const;
554    bool IsPushOnly() const;
555
556    /** Check if the script contains valid OP_CODES */
557    bool HasValidOps() const;
558
559    /**
560     * Returns whether the script is guaranteed to fail at execution,
561     * regardless of the initial stack. This allows outputs to be pruned
562     * instantly when entering the UTXO set.
563     */
564    bool IsUnspendable() const
565    {
566        return (size() > 0 && *begin() == OP_RETURN) || (size() > MAX_SCRIPT_SIZE);
567    }
568
569    void clear()
570    {
571        // The default prevector::clear() does not release memory
572        CScriptBase::clear();
573        shrink_to_fit();
574    }
575};
576
577struct CScriptWitness
578{
579    // Note that this encodes the data elements being pushed, rather than
580    // encoding them as a CScript that pushes them.
581    std::vector<std::vector<unsigned char> > stack;
582
583    // Some compilers complain without a default constructor
584    CScriptWitness() = default;
585
586    bool IsNull() const { return stack.empty(); }
587
588    void SetNull() { stack.clear(); stack.shrink_to_fit(); }
589
590    std::string ToString() const;
591
592    bool operator==(const CScriptWitness&) const = default;
593};
594
595/** A reference to a CScript: the Hash160 of its serialization */
596class CScriptID : public BaseHash<uint160>
597{
598public:
599    CScriptID() : BaseHash() {}
600    explicit CScriptID(const CScript& in);
601    explicit CScriptID(const uint160& in) : BaseHash(in) {}
602};
603
604/** Test for OP_SUCCESSx opcodes as defined by BIP342. */
605bool IsOpSuccess(const opcodetype& opcode);
606
607bool CheckMinimalPush(const std::vector<unsigned char>& data, opcodetype opcode);
608
609/** Build a script by concatenating other scripts, or any argument accepted by CScript::operator<<. */
610template<typename... Ts>
611CScript BuildScript(Ts&&... inputs)
612{
613    CScript ret;
614    int cnt{0};
615
616    ([&ret, &cnt] (Ts&& input) {
617        if constexpr (std::is_same_v<std::remove_cv_t<std::remove_reference_t<Ts>>, CScript>) {
618            // If it is a CScript, extend ret with it. Move or copy the first element instead.
619            if (cnt == 0) {
620                ret = std::forward<Ts>(input);
621            } else {
622                ret.insert(ret.end(), input.begin(), input.end());
623            }
624        } else {
625            // Otherwise invoke CScript::operator<<.
626            ret << input;
627        }
628        cnt++;
629    } (std::forward<Ts>(inputs)), ...);
630
631    return ret;
632}
633
634#endif // BITCOIN_SCRIPT_SCRIPT_H
635