Inside Bitcoin

751{
752    FillableSigningProvider keystore;
753    CCoinsViewCache coins{&CoinsViewEmpty::Get()};
754    std::vector<CMutableTransaction> dummyTransactions =
755        SetupDummyInputs(keystore, coins, {11*CENT, 50*CENT, 21*CENT, 22*CENT});
756
757    CMutableTransaction t;
758    t.vin.resize(1);
759    t.vin[0].prevout.hash = dummyTransactions[0].GetHash();
760    t.vin[0].prevout.n = 1;
761    t.vin[0].scriptSig << std::vector<unsigned char>(65, 0);
762    t.vout.resize(1);
763    t.vout[0].nValue = 90*CENT;
764    CKey key = GenerateRandomKey();
765    t.vout[0].scriptPubKey = GetScriptForDestination(PKHash(key.GetPubKey()));
766
767    constexpr auto CheckIsStandard = [](const auto& t, const unsigned int max_op_return_relay = MAX_OP_RETURN_RELAY) {
768        std::string reason;
769        BOOST_CHECK(IsStandardTx(CTransaction{t}, max_op_return_relay, g_bare_multi, g_dust, reason));
770        BOOST_CHECK(reason.empty());
771    };
772    constexpr auto CheckIsNotStandard = [](const auto& t, const std::string& reason_in, const unsigned int max_op_return_relay = MAX_OP_RETURN_RELAY) {
773        std::string reason;
774        BOOST_CHECK(!IsStandardTx(CTransaction{t}, max_op_return_relay, g_bare_multi, g_dust, reason));
775        BOOST_CHECK_EQUAL(reason_in, reason);
776    };
777
778    CheckIsStandard(t);
779
780    // Check dust with default relay fee:
781    CAmount nDustThreshold = 182 * g_dust.GetFeePerK() / 1000;
782    BOOST_CHECK_EQUAL(nDustThreshold, 546);
783
784    // Add dust outputs up to allowed maximum, still standard!
785    for (size_t i{0}; i < MAX_DUST_OUTPUTS_PER_TX; ++i) {
786        t.vout.emplace_back(0, t.vout[0].scriptPubKey);
787        CheckIsStandard(t);
788    }
789
790    // dust:
791    t.vout[0].nValue = nDustThreshold - 1;
792    CheckIsNotStandard(t, "dust");
793    // not dust:
794    t.vout[0].nValue = nDustThreshold;
795    CheckIsStandard(t);
796
797    // Disallowed version
798    t.version = std::numeric_limits<uint32_t>::max();
799    CheckIsNotStandard(t, "version");
800
801    t.version = 0;
802    CheckIsNotStandard(t, "version");
803
804    t.version = TX_MAX_STANDARD_VERSION + 1;
805    CheckIsNotStandard(t, "version");
806
807    // Allowed version
808    t.version = 1;
809    CheckIsStandard(t);
810
811    t.version = 2;
812    CheckIsStandard(t);
813
814    // Check dust with odd relay fee to verify rounding:
815    // nDustThreshold = 182 * 3702 / 1000
816    g_dust = CFeeRate(3702);
817    // dust:
818    t.vout[0].nValue = 674 - 1;
819    CheckIsNotStandard(t, "dust");
820    // not dust:
821    t.vout[0].nValue = 674;
822    CheckIsStandard(t);
823    g_dust = CFeeRate{DUST_RELAY_TX_FEE};
824
825    t.vout[0].scriptPubKey = CScript() << OP_1;
826    CheckIsNotStandard(t, "scriptpubkey");
827
828    // Custom 83-byte TxoutType::NULL_DATA (standard with max_op_return_relay of 83)
829    t.vout[0].scriptPubKey = CScript() << OP_RETURN << "04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef3804678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38"_hex;
830    BOOST_CHECK_EQUAL(83, t.vout[0].scriptPubKey.size());
831    CheckIsStandard(t, /*max_op_return_relay=*/83);
832
833    // Non-standard if max_op_return_relay datacarrier arg is one less
834    CheckIsNotStandard(t, "datacarrier", /*max_op_return_relay=*/82);
835
836    // Data payload can be encoded in any way...
837    t.vout[0].scriptPubKey = CScript() << OP_RETURN << ""_hex;
838    CheckIsStandard(t);
839    t.vout[0].scriptPubKey = CScript() << OP_RETURN << "00"_hex << "01"_hex;
840    CheckIsStandard(t);
841    // OP_RESERVED *is* considered to be a PUSHDATA type opcode by IsPushOnly()!
842    t.vout[0].scriptPubKey = CScript() << OP_RETURN << OP_RESERVED << -1 << 0 << "01"_hex << 2 << 3 << 4 << 5 << 6 << 7 << 8 << 9 << 10 << 11 << 12 << 13 << 14 << 15 << 16;
843    CheckIsStandard(t);
844    t.vout[0].scriptPubKey = CScript() << OP_RETURN << 0 << "01"_hex << 2 << "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"_hex;
845    CheckIsStandard(t);
846
847    // ...so long as it only contains PUSHDATA's
848    t.vout[0].scriptPubKey = CScript() << OP_RETURN << OP_RETURN;
849    CheckIsNotStandard(t, "scriptpubkey");
850
851    // TxoutType::NULL_DATA w/o PUSHDATA
852    t.vout.resize(1);
853    t.vout[0].scriptPubKey = CScript() << OP_RETURN;
854    CheckIsStandard(t);
855
856    // Multiple TxoutType::NULL_DATA are permitted
857    t.vout.resize(2);
858    t.vout[0].scriptPubKey = CScript() << OP_RETURN << "04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38"_hex;
859    t.vout[0].nValue = 0;
860    t.vout[1].scriptPubKey = CScript() << OP_RETURN << "04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38"_hex;
861    t.vout[1].nValue = 0;
862    CheckIsStandard(t);
863
864    t.vout[0].scriptPubKey = CScript() << OP_RETURN << "04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38"_hex;
865    t.vout[1].scriptPubKey = CScript() << OP_RETURN;
866    CheckIsStandard(t);
867
868    t.vout[0].scriptPubKey = CScript() << OP_RETURN;
869    t.vout[1].scriptPubKey = CScript() << OP_RETURN;
870    CheckIsStandard(t);
871
872    t.vout[0].scriptPubKey = CScript() << OP_RETURN << "04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef3804678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38"_hex;
873    t.vout[1].scriptPubKey = CScript() << OP_RETURN << "04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef3804678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38"_hex;
874    const auto datacarrier_size = t.vout[0].scriptPubKey.size() + t.vout[1].scriptPubKey.size();
875    CheckIsStandard(t); // Default max relay should never trigger
876    CheckIsStandard(t, /*max_op_return_relay=*/datacarrier_size);
877    CheckIsNotStandard(t, "datacarrier", /*max_op_return_relay=*/datacarrier_size-1);
878
879    // Check large scriptSig (non-standard if size is >1650 bytes)
880    t.vout.resize(1);
881    t.vout[0].nValue = MAX_MONEY;
882    t.vout[0].scriptPubKey = GetScriptForDestination(PKHash(key.GetPubKey()));
883    // OP_PUSHDATA2 with len (3 bytes) + data (1647 bytes) = 1650 bytes
884    t.vin[0].scriptSig = CScript() << std::vector<unsigned char>(1647, 0); // 1650
885    CheckIsStandard(t);
886
887    t.vin[0].scriptSig = CScript() << std::vector<unsigned char>(1648, 0); // 1651
888    CheckIsNotStandard(t, "scriptsig-size");
889
890    // Check scriptSig format (non-standard if there are any other ops than just PUSHs)
891    t.vin[0].scriptSig = CScript()
892        << OP_TRUE << OP_0 << OP_1NEGATE << OP_16 // OP_n (single byte pushes: n = 1, 0, -1, 16)
893        << std::vector<unsigned char>(75, 0)      // OP_PUSHx [...x bytes...]
894        << std::vector<unsigned char>(235, 0)     // OP_PUSHDATA1 x [...x bytes...]
895        << std::vector<unsigned char>(1234, 0)    // OP_PUSHDATA2 x [...x bytes...]
896        << OP_9;
897    CheckIsStandard(t);
898
899    const std::vector<unsigned char> non_push_ops = { // arbitrary set of non-push operations
900        OP_NOP, OP_VERIFY, OP_IF, OP_ROT, OP_3DUP, OP_SIZE, OP_EQUAL, OP_ADD, OP_SUB,
901        OP_HASH256, OP_CODESEPARATOR, OP_CHECKSIG, OP_CHECKLOCKTIMEVERIFY };
902
903    CScript::const_iterator pc = t.vin[0].scriptSig.begin();
904    while (pc < t.vin[0].scriptSig.end()) {
905        opcodetype opcode;
906        CScript::const_iterator prev_pc = pc;
907        t.vin[0].scriptSig.GetOp(pc, opcode); // advance to next op
908        // for the sake of simplicity, we only replace single-byte push operations
909        if (opcode >= 1 && opcode <= OP_PUSHDATA4)
910            continue;
911
912        int index = prev_pc - t.vin[0].scriptSig.begin();
913        unsigned char orig_op = *prev_pc; // save op
914        // replace current push-op with each non-push-op
915        for (auto op : non_push_ops) {
916            t.vin[0].scriptSig[index] = op;
917            CheckIsNotStandard(t, "scriptsig-not-pushonly");
918        }
919        t.vin[0].scriptSig[index] = orig_op; // restore op
920        CheckIsStandard(t);
921    }
922
923    // Check tx-size (non-standard if transaction weight is > MAX_STANDARD_TX_WEIGHT)
924    t.vin.clear();
925    t.vin.resize(2438); // size per input (empty scriptSig): 41 bytes
926    t.vout[0].scriptPubKey = CScript() << OP_RETURN << std::vector<unsigned char>(19, 0); // output size: 30 bytes
927    // tx header:                12 bytes =>     48 weight units
928    // 2438 inputs: 2438*41 = 99958 bytes => 399832 weight units
929    //    1 output:              30 bytes =>    120 weight units
930    //                      ======================================
931    //                                total: 400000 weight units
932    BOOST_CHECK_EQUAL(GetTransactionWeight(CTransaction(t)), 400000);
933    CheckIsStandard(t);
934
935    // increase output size by one byte, so we end up with 400004 weight units
936    t.vout[0].scriptPubKey = CScript() << OP_RETURN << std::vector<unsigned char>(20, 0); // output size: 31 bytes
937    BOOST_CHECK_EQUAL(GetTransactionWeight(CTransaction(t)), 400004);
938    CheckIsNotStandard(t, "tx-size");
939
940    // Check bare multisig (standard if policy flag g_bare_multi is set)
941    g_bare_multi = true;
942    t.vout[0].scriptPubKey = GetScriptForMultisig(1, {key.GetPubKey()}); // simple 1-of-1
943    t.vin.resize(1);
944    t.vin[0].scriptSig = CScript() << std::vector<unsigned char>(65, 0);
945    CheckIsStandard(t);
946
947    g_bare_multi = false;
948    CheckIsNotStandard(t, "bare-multisig");
949    g_bare_multi = DEFAULT_PERMIT_BAREMULTISIG;
950
951    // Add dust outputs up to allowed maximum
952    assert(t.vout.size() == 1);
953    t.vout.insert(t.vout.end(), MAX_DUST_OUTPUTS_PER_TX, {0, t.vout[0].scriptPubKey});
954
955    // Check compressed P2PK outputs dust threshold (must have leading 02 or 03)
956    t.vout[0].scriptPubKey = CScript() << std::vector<unsigned char>(33, 0x02) << OP_CHECKSIG;
957    t.vout[0].nValue = 576;
958    CheckIsStandard(t);
959    t.vout[0].nValue = 575;
960    CheckIsNotStandard(t, "dust");
961
962    // Check uncompressed P2PK outputs dust threshold (must have leading 04/06/07)
963    t.vout[0].scriptPubKey = CScript() << std::vector<unsigned char>(65, 0x04) << OP_CHECKSIG;
964    t.vout[0].nValue = 672;
965    CheckIsStandard(t);
966    t.vout[0].nValue = 671;
967    CheckIsNotStandard(t, "dust");
968
969    // Check P2PKH outputs dust threshold
970    t.vout[0].scriptPubKey = CScript() << OP_DUP << OP_HASH160 << std::vector<unsigned char>(20, 0) << OP_EQUALVERIFY << OP_CHECKSIG;
971    t.vout[0].nValue = 546;
972    CheckIsStandard(t);
973    t.vout[0].nValue = 545;
974    CheckIsNotStandard(t, "dust");
975
976    // Check P2SH outputs dust threshold
977    t.vout[0].scriptPubKey = CScript() << OP_HASH160 << std::vector<unsigned char>(20, 0) << OP_EQUAL;
978    t.vout[0].nValue = 540;
979    CheckIsStandard(t);
980    t.vout[0].nValue = 539;
981    CheckIsNotStandard(t, "dust");
982
983    // Check P2WPKH outputs dust threshold
984    t.vout[0].scriptPubKey = CScript() << OP_0 << std::vector<unsigned char>(20, 0);
985    t.vout[0].nValue = 294;
986    CheckIsStandard(t);
987    t.vout[0].nValue = 293;
988    CheckIsNotStandard(t, "dust");
989
990    // Check P2WSH outputs dust threshold
991    t.vout[0].scriptPubKey = CScript() << OP_0 << std::vector<unsigned char>(32, 0);
992    t.vout[0].nValue = 330;
993    CheckIsStandard(t);
994    t.vout[0].nValue = 329;
995    CheckIsNotStandard(t, "dust");
996
997    // Check P2TR outputs dust threshold (Invalid xonly key ok!)
998    t.vout[0].scriptPubKey = CScript() << OP_1 << std::vector<unsigned char>(32, 0);
999    t.vout[0].nValue = 330;
1000    CheckIsStandard(t);