Inside Bitcoin

1001    t.vout[0].nValue = 329;
1002    CheckIsNotStandard(t, "dust");
1003
1004    // Check future Witness Program versions dust threshold (non-32-byte pushes are undefined for version 1)
1005    for (int op = OP_1; op <= OP_16; op += 1) {
1006        t.vout[0].scriptPubKey = CScript() << (opcodetype)op << std::vector<unsigned char>(2, 0);
1007        t.vout[0].nValue = 240;
1008        CheckIsStandard(t);
1009
1010        t.vout[0].nValue = 239;
1011        CheckIsNotStandard(t, "dust");
1012    }
1013
1014    // Check anchor outputs
1015    t.vout[0].scriptPubKey = CScript() << OP_1 << ANCHOR_BYTES;
1016    BOOST_CHECK(t.vout[0].scriptPubKey.IsPayToAnchor());
1017    t.vout[0].nValue = 240;
1018    CheckIsStandard(t);
1019    t.vout[0].nValue = 239;
1020    CheckIsNotStandard(t, "dust");
1021}
1022
1023BOOST_AUTO_TEST_CASE(max_standard_legacy_sigops)
1024{
1025    CCoinsViewCache coins{&CoinsViewEmpty::Get()};
1026    CKey key;
1027    key.MakeNewKey(true);
1028
1029    // Create a pathological P2SH script padded with as many sigops as is standard.
1030    CScript max_sigops_redeem_script{CScript() << std::vector<unsigned char>{} << key.GetPubKey()};
1031    for (unsigned i{0}; i < MAX_P2SH_SIGOPS - 1; ++i) max_sigops_redeem_script << OP_2DUP << OP_CHECKSIG << OP_DROP;
1032    max_sigops_redeem_script << OP_CHECKSIG << OP_NOT;
1033    const CScript max_sigops_p2sh{GetScriptForDestination(ScriptHash(max_sigops_redeem_script))};
1034
1035    // Create a transaction fanning out as many such P2SH outputs as is standard to spend in a
1036    // single transaction, and a transaction spending them.
1037    CMutableTransaction tx_create, tx_max_sigops;
1038    const unsigned p2sh_inputs_count{MAX_TX_LEGACY_SIGOPS / MAX_P2SH_SIGOPS};
1039    tx_create.vout.reserve(p2sh_inputs_count);
1040    for (unsigned i{0}; i < p2sh_inputs_count; ++i) {
1041        tx_create.vout.emplace_back(424242 + i, max_sigops_p2sh);
1042    }
1043    auto prev_txid{tx_create.GetHash()};
1044    tx_max_sigops.vin.reserve(p2sh_inputs_count);
1045    for (unsigned i{0}; i < p2sh_inputs_count; ++i) {
1046        tx_max_sigops.vin.emplace_back(prev_txid, i, CScript() << ToByteVector(max_sigops_redeem_script));
1047    }
1048
1049    // p2sh_inputs_count is truncated to 166 (from 166.6666..)
1050    BOOST_CHECK_LT(p2sh_inputs_count * MAX_P2SH_SIGOPS, MAX_TX_LEGACY_SIGOPS);
1051    AddCoins(coins, CTransaction(tx_create), 0, false);
1052
1053    // 2490 sigops is below the limit.
1054    BOOST_CHECK_EQUAL(GetP2SHSigOpCount(CTransaction(tx_max_sigops), coins), 2490);
1055    BOOST_CHECK(::ValidateInputsStandardness(CTransaction(tx_max_sigops), coins).IsValid());
1056
1057    // Adding one more input will bump this to 2505, hitting the limit.
1058    tx_create.vout.emplace_back(424242, max_sigops_p2sh);
1059    prev_txid = tx_create.GetHash();
1060    for (unsigned i{0}; i < p2sh_inputs_count; ++i) {
1061        tx_max_sigops.vin[i] = CTxIn(COutPoint(prev_txid, i), CScript() << ToByteVector(max_sigops_redeem_script));
1062    }
1063    tx_max_sigops.vin.emplace_back(prev_txid, p2sh_inputs_count, CScript() << ToByteVector(max_sigops_redeem_script));
1064    AddCoins(coins, CTransaction(tx_create), 0, false);
1065    BOOST_CHECK_GT((p2sh_inputs_count + 1) * MAX_P2SH_SIGOPS, MAX_TX_LEGACY_SIGOPS);
1066    auto legacy_sigops_count = GetP2SHSigOpCount(CTransaction(tx_max_sigops), coins);
1067    BOOST_CHECK_EQUAL(legacy_sigops_count, 2505);
1068    std::string reject_reason("bad-txns-nonstandard-inputs");
1069    std::string sigop_limit_reject_debug_message("non-witness sigops exceed bip54 limit");
1070    {
1071        auto validation_state = ValidateInputsStandardness(CTransaction(tx_max_sigops), coins);
1072        BOOST_CHECK(validation_state.IsInvalid());
1073        BOOST_CHECK_EQUAL(validation_state.GetRejectReason(), reject_reason);
1074        BOOST_CHECK_EQUAL(validation_state.GetDebugMessage(), sigop_limit_reject_debug_message);
1075    }
1076
1077
1078    // Now, check the limit can be reached with regular P2PK outputs too. Use a separate
1079    // preparation transaction, to demonstrate spending coins from a single tx is irrelevant.
1080    CMutableTransaction tx_create_p2pk;
1081    const auto p2pk_script{CScript() << key.GetPubKey() << OP_CHECKSIG};
1082    unsigned p2pk_inputs_count{10}; // From 2490 to 2500.
1083    for (unsigned i{0}; i < p2pk_inputs_count; ++i) {
1084        tx_create_p2pk.vout.emplace_back(212121 + i, p2pk_script);
1085    }
1086    prev_txid = tx_create_p2pk.GetHash();
1087    tx_max_sigops.vin.resize(p2sh_inputs_count); // Drop the extra input.
1088    for (unsigned i{0}; i < p2pk_inputs_count; ++i) {
1089        tx_max_sigops.vin.emplace_back(prev_txid, i);
1090    }
1091    AddCoins(coins, CTransaction(tx_create_p2pk), 0, false);
1092
1093    // The transaction now contains exactly 2500 sigops, the check should pass.
1094    BOOST_CHECK_EQUAL(p2sh_inputs_count * MAX_P2SH_SIGOPS + p2pk_inputs_count * 1, MAX_TX_LEGACY_SIGOPS);
1095    BOOST_CHECK(::ValidateInputsStandardness(CTransaction(tx_max_sigops), coins).IsValid());
1096
1097    // Now, add some Segwit inputs. We add one for each defined Segwit output type. The limit
1098    // is exclusively on non-witness sigops and therefore those should not be counted.
1099    CMutableTransaction tx_create_segwit;
1100    const auto witness_script{CScript() << key.GetPubKey() << OP_CHECKSIG};
1101    tx_create_segwit.vout.emplace_back(121212, GetScriptForDestination(WitnessV0KeyHash(key.GetPubKey())));
1102    tx_create_segwit.vout.emplace_back(131313, GetScriptForDestination(WitnessV0ScriptHash(witness_script)));
1103    tx_create_segwit.vout.emplace_back(141414, GetScriptForDestination(WitnessV1Taproot{XOnlyPubKey(key.GetPubKey())}));
1104    prev_txid = tx_create_segwit.GetHash();
1105    for (unsigned i{0}; i < tx_create_segwit.vout.size(); ++i) {
1106        tx_max_sigops.vin.emplace_back(prev_txid, i);
1107    }
1108
1109    // The transaction now still contains exactly 2500 sigops, the check should pass.
1110    AddCoins(coins, CTransaction(tx_create_segwit), 0, false);
1111    BOOST_REQUIRE(::ValidateInputsStandardness(CTransaction(tx_max_sigops), coins).IsValid());
1112
1113    // Add one more P2PK input. We'll reach the limit.
1114    tx_create_p2pk.vout.emplace_back(212121, p2pk_script);
1115    prev_txid = tx_create_p2pk.GetHash();
1116    tx_max_sigops.vin.resize(p2sh_inputs_count);
1117    ++p2pk_inputs_count;
1118    for (unsigned i{0}; i < p2pk_inputs_count; ++i) {
1119        tx_max_sigops.vin.emplace_back(prev_txid, i);
1120    }
1121    AddCoins(coins, CTransaction(tx_create_p2pk), 0, false);
1122    auto legacy_sigop_count_p2pk = p2sh_inputs_count * MAX_P2SH_SIGOPS + p2pk_inputs_count * 1;
1123    BOOST_CHECK_GT(legacy_sigop_count_p2pk, MAX_TX_LEGACY_SIGOPS);
1124    {
1125        auto validation_state = ValidateInputsStandardness(CTransaction(tx_max_sigops), coins);
1126        BOOST_CHECK(validation_state.IsInvalid());
1127        BOOST_CHECK_EQUAL(validation_state.GetRejectReason(), reject_reason);
1128        BOOST_CHECK_EQUAL(validation_state.GetDebugMessage(), sigop_limit_reject_debug_message);
1129    }
1130}
1131
1132BOOST_AUTO_TEST_CASE(getlegacysigopcount_inaccurate_test)
1133{
1134    // Legacy sigops are counted inaccurately in both the scriptSig and the
1135    // scriptPubKey: a CHECKMULTISIG counts as MAX_PUBKEYS_PER_MULTISIG even when the
1136    // preceding OP_N says it takes fewer keys. Counting it accurately would
1137    // undercount, letting a block over the sigop limit through.
1138    const CScript multisig{CScript() << OP_1 << OP_CHECKMULTISIG};
1139
1140    CMutableTransaction mtx;
1141    mtx.vin.emplace_back(COutPoint{}, multisig);
1142    BOOST_CHECK_EQUAL(GetLegacySigOpCount(CTransaction{mtx}), MAX_PUBKEYS_PER_MULTISIG);
1143
1144    mtx.vout.emplace_back(0, multisig);
1145    BOOST_CHECK_EQUAL(GetLegacySigOpCount(CTransaction{mtx}), 2 * MAX_PUBKEYS_PER_MULTISIG);
1146}
1147
1148BOOST_AUTO_TEST_CASE(checktxinputs_invalid_transactions_test)
1149{
1150    auto check_invalid{[](CAmount input_value, CAmount output_value, bool coinbase, int spend_height, TxValidationResult expected_result, std::string_view expected_reason) {
1151        CCoinsViewCache inputs{&CoinsViewEmpty::Get()};
1152
1153        const COutPoint prevout{Txid::FromUint256(uint256::ONE), 0};
1154        inputs.AddCoin(prevout, Coin{{input_value, CScript() << OP_TRUE}, /*nHeightIn=*/1, coinbase}, /*possible_overwrite=*/false);
1155
1156        CMutableTransaction mtx;
1157        mtx.vin.emplace_back(prevout);
1158        mtx.vout.emplace_back(output_value, CScript() << OP_TRUE);
1159
1160        TxValidationState state;
1161        CAmount txfee{0};
1162        BOOST_CHECK(!Consensus::CheckTxInputs(CTransaction{mtx}, state, inputs, spend_height, txfee));
1163        BOOST_CHECK(state.IsInvalid());
1164        BOOST_CHECK_EQUAL(state.GetResult(), expected_result);
1165        BOOST_CHECK_EQUAL(state.GetRejectReason(), expected_reason);
1166    }};
1167
1168    check_invalid(/*input_value=*/MAX_MONEY + 1,
1169                  /*output_value=*/0,
1170                  /*coinbase=*/false,
1171                  /*spend_height=*/2,
1172                  TxValidationResult::TX_CONSENSUS, /*expected_reason=*/"bad-txns-inputvalues-outofrange");
1173
1174    check_invalid(/*input_value=*/1 * COIN,
1175                  /*output_value=*/2 * COIN,
1176                  /*coinbase=*/false,
1177                  /*spend_height=*/2,
1178                  TxValidationResult::TX_CONSENSUS, /*expected_reason=*/"bad-txns-in-belowout");
1179
1180    check_invalid(/*input_value=*/1 * COIN,
1181                  /*output_value=*/0,
1182                  /*coinbase=*/true,
1183                  /*spend_height=*/COINBASE_MATURITY,
1184                  TxValidationResult::TX_PREMATURE_SPEND, /*expected_reason=*/"bad-txns-premature-spend-of-coinbase");
1185}
1186
1187BOOST_AUTO_TEST_CASE(isfinaltx_sequences_test)
1188{
1189    constexpr int height{100};
1190
1191    // Every transaction here has the same unsatisfied nLockTime, so only the
1192    // sequences decide the outcome.
1193    auto check_final{[](const std::vector<uint32_t>& sequences, bool expected_final) {
1194        CMutableTransaction mtx;
1195        mtx.nLockTime = height;
1196        for (const uint32_t sequence : sequences) {
1197            mtx.vin.emplace_back(COutPoint{}, CScript{}, sequence);
1198        }
1199
1200        BOOST_CHECK_EQUAL(IsFinalTx(CTransaction{mtx}, /*nBlockHeight=*/height, /*nBlockTime=*/0), expected_final);
1201    }};
1202
1203    check_final(/*sequences=*/{CTxIn::SEQUENCE_FINAL, CTxIn::SEQUENCE_FINAL}, /*expected_final=*/true);
1204
1205    // nLockTime is only ignored when every input is SEQUENCE_FINAL
1206    check_final(/*sequences=*/{CTxIn::SEQUENCE_FINAL, CTxIn::MAX_SEQUENCE_NONFINAL}, /*expected_final=*/false);
1207    check_final(/*sequences=*/{CTxIn::MAX_SEQUENCE_NONFINAL, CTxIn::SEQUENCE_FINAL}, /*expected_final=*/false);
1208}
1209
1210BOOST_AUTO_TEST_CASE(calculatesequencelocks_tx_version_test)
1211{
1212    constexpr int coin_height{100};
1213
1214    // A single input with a height-based relative locktime of one block. Only the
1215    // height branch is taken, so the block index is never dereferenced.
1216    auto check_min_height{[](uint32_t version, int expected_min_height) {
1217        CMutableTransaction mtx;
1218        mtx.version = version;
1219        mtx.vin.emplace_back(COutPoint{}, CScript{}, /*nSequenceIn=*/1);
1220
1221        std::vector<int> prev_heights{coin_height};
1222        const CBlockIndex block{};
1223        const auto lock_pair{CalculateSequenceLocks(CTransaction{mtx}, LOCKTIME_VERIFY_SEQUENCE, prev_heights, block)};
1224        BOOST_CHECK_EQUAL(lock_pair.first, expected_min_height);
1225    }};
1226
1227    // BIP68 only applies to versions 2 and up
1228    check_min_height(/*version=*/0, /*expected_min_height=*/-1);
1229    check_min_height(/*version=*/1, /*expected_min_height=*/-1);
1230    check_min_height(/*version=*/2, /*expected_min_height=*/coin_height);
1231    check_min_height(/*version=*/std::numeric_limits<uint32_t>::max(), /*expected_min_height=*/coin_height);
1232}
1233
1234BOOST_AUTO_TEST_CASE(getvalueout_out_of_range_throws)
1235{
1236    CMutableTransaction mtx;
1237    mtx.vout.emplace_back(MAX_MONEY + 1, CScript() << OP_TRUE);
1238
1239    const CTransaction tx{mtx};
1240    BOOST_CHECK_EXCEPTION(tx.GetValueOut(), std::runtime_error, HasReason("GetValueOut: value out of range"));
1241}
1242
1243/** Sanity check the return value of SpendsNonAnchorWitnessProg for various output types. */
1244BOOST_AUTO_TEST_CASE(spends_witness_prog)
1245{
1246    CCoinsViewCache coins{&CoinsViewEmpty::Get()};
1247    CKey key;
1248    key.MakeNewKey(true);
1249    const CPubKey pubkey{key.GetPubKey()};
1250    CMutableTransaction tx_create{}, tx_spend{};