mirror of
https://github.com/dashpay/dash.git
synced 2024-12-25 03:52:49 +01:00
Merge pull request #4504 from kittywhiskers/explicit_ref
merge bitcoin #13013, #14908, #14906: Make explicit CMutableTransaction -> CTransaction conversion
This commit is contained in:
commit
2a5b5bb32a
@ -35,14 +35,14 @@ SetupDummyInputs(CBasicKeyStore& keystoreRet, CCoinsViewCache& coinsRet)
|
||||
dummyTransactions[0].vout[0].scriptPubKey << ToByteVector(key[0].GetPubKey()) << OP_CHECKSIG;
|
||||
dummyTransactions[0].vout[1].nValue = 50 * COIN;
|
||||
dummyTransactions[0].vout[1].scriptPubKey << ToByteVector(key[1].GetPubKey()) << OP_CHECKSIG;
|
||||
AddCoins(coinsRet, dummyTransactions[0], 0);
|
||||
AddCoins(coinsRet, CTransaction(dummyTransactions[0]), 0);
|
||||
|
||||
dummyTransactions[1].vout.resize(2);
|
||||
dummyTransactions[1].vout[0].nValue = 21 * COIN;
|
||||
dummyTransactions[1].vout[0].scriptPubKey = GetScriptForDestination(key[2].GetPubKey().GetID());
|
||||
dummyTransactions[1].vout[1].nValue = 22 * COIN;
|
||||
dummyTransactions[1].vout[1].scriptPubKey = GetScriptForDestination(key[3].GetPubKey().GetID());
|
||||
AddCoins(coinsRet, dummyTransactions[1], 0);
|
||||
AddCoins(coinsRet, CTransaction(dummyTransactions[1]), 0);
|
||||
|
||||
return dummyTransactions;
|
||||
}
|
||||
@ -80,7 +80,7 @@ static void CCoinsCaching(benchmark::Bench& bench)
|
||||
bench.run([&] {
|
||||
bool success = AreInputsStandard(tx_1, coins);
|
||||
assert(success);
|
||||
CAmount value = coins.GetValueIn(t1);
|
||||
CAmount value = coins.GetValueIn(tx_1);
|
||||
assert(value == (50 + 21 + 22) * COIN);
|
||||
});
|
||||
}
|
||||
|
@ -9,7 +9,7 @@
|
||||
#include <list>
|
||||
#include <vector>
|
||||
|
||||
static void AddTx(const CMutableTransaction& tx, const CAmount& nFee, CTxMemPool& pool) EXCLUSIVE_LOCKS_REQUIRED(cs_main, pool.cs)
|
||||
static void AddTx(const CTransactionRef& tx, const CAmount& nFee, CTxMemPool& pool) EXCLUSIVE_LOCKS_REQUIRED(cs_main, pool.cs)
|
||||
{
|
||||
int64_t nTime = 0;
|
||||
unsigned int nHeight = 1;
|
||||
@ -17,7 +17,7 @@ static void AddTx(const CMutableTransaction& tx, const CAmount& nFee, CTxMemPool
|
||||
unsigned int sigOpCost = 4;
|
||||
LockPoints lp;
|
||||
pool.addUnchecked(CTxMemPoolEntry(
|
||||
MakeTransactionRef(tx), nFee, nTime, nHeight,
|
||||
tx, nFee, nTime, nHeight,
|
||||
spendsCoinbase, sigOpCost, lp));
|
||||
}
|
||||
|
||||
@ -97,16 +97,25 @@ static void MempoolEviction(benchmark::Bench& bench)
|
||||
tx7.vout[1].nValue = 10 * COIN;
|
||||
|
||||
CTxMemPool pool;
|
||||
// Create transaction references outside the "hot loop"
|
||||
const CTransactionRef tx1_r{MakeTransactionRef(tx1)};
|
||||
const CTransactionRef tx2_r{MakeTransactionRef(tx2)};
|
||||
const CTransactionRef tx3_r{MakeTransactionRef(tx3)};
|
||||
const CTransactionRef tx4_r{MakeTransactionRef(tx4)};
|
||||
const CTransactionRef tx5_r{MakeTransactionRef(tx5)};
|
||||
const CTransactionRef tx6_r{MakeTransactionRef(tx6)};
|
||||
const CTransactionRef tx7_r{MakeTransactionRef(tx7)};
|
||||
|
||||
LOCK2(cs_main, pool.cs);
|
||||
|
||||
bench.run([&]() NO_THREAD_SAFETY_ANALYSIS {
|
||||
AddTx(tx1, 10000LL, pool);
|
||||
AddTx(tx2, 5000LL, pool);
|
||||
AddTx(tx3, 20000LL, pool);
|
||||
AddTx(tx4, 7000LL, pool);
|
||||
AddTx(tx5, 1000LL, pool);
|
||||
AddTx(tx6, 1100LL, pool);
|
||||
AddTx(tx7, 9000LL, pool);
|
||||
AddTx(tx1_r, 10000LL, pool);
|
||||
AddTx(tx2_r, 5000LL, pool);
|
||||
AddTx(tx3_r, 20000LL, pool);
|
||||
AddTx(tx4_r, 7000LL, pool);
|
||||
AddTx(tx5_r, 1000LL, pool);
|
||||
AddTx(tx6_r, 1100LL, pool);
|
||||
AddTx(tx7_r, 9000LL, pool);
|
||||
pool.TrimToSize(pool.DynamicMemoryUsage() * 3 / 4);
|
||||
pool.TrimToSize(::GetSerializeSize(tx1, SER_NETWORK, PROTOCOL_VERSION));
|
||||
});
|
||||
|
@ -491,7 +491,7 @@ bool CCoinJoinClientSession::SendDenominate(const std::vector<std::pair<CTxDSIn,
|
||||
|
||||
// store our entry for later use
|
||||
LOCK(cs_coinjoin);
|
||||
vecEntries.emplace_back(vecTxDSInTmp, vecTxOutTmp, txMyCollateral);
|
||||
vecEntries.emplace_back(vecTxDSInTmp, vecTxOutTmp, CTransaction(txMyCollateral));
|
||||
RelayIn(vecEntries.back(), connman);
|
||||
nTimeLastSuccessfulStep = GetTime();
|
||||
|
||||
@ -923,7 +923,7 @@ bool CCoinJoinClientSession::DoAutomaticDenominating(CConnman& connman, bool fDr
|
||||
return false;
|
||||
}
|
||||
} else {
|
||||
if (!CCoinJoin::IsCollateralValid(txMyCollateral)) {
|
||||
if (!CCoinJoin::IsCollateralValid(CTransaction(txMyCollateral))) {
|
||||
LogPrint(BCLog::COINJOIN, "CCoinJoinClientSession::DoAutomaticDenominating -- invalid collateral, recreating...\n");
|
||||
if (!CreateCollateralTransaction(txMyCollateral, strReason)) {
|
||||
LogPrint(BCLog::COINJOIN, "CCoinJoinClientSession::DoAutomaticDenominating -- create collateral error: %s\n", strReason);
|
||||
|
@ -324,7 +324,7 @@ void CCoinJoinServer::CreateFinalTransaction(CConnman& connman)
|
||||
|
||||
// request signatures from clients
|
||||
SetState(POOL_STATE_SIGNING);
|
||||
RelayFinalTransaction(finalMutableTransaction, connman);
|
||||
RelayFinalTransaction(CTransaction(finalMutableTransaction), connman);
|
||||
}
|
||||
|
||||
void CCoinJoinServer::CommitFinalTransaction(CConnman& connman)
|
||||
@ -701,7 +701,7 @@ bool CCoinJoinServer::IsAcceptableDSA(const CCoinJoinAccept& dsa, PoolMessage& n
|
||||
}
|
||||
|
||||
// check collateral
|
||||
if (!fUnitTest && !CCoinJoin::IsCollateralValid(dsa.txCollateral)) {
|
||||
if (!fUnitTest && !CCoinJoin::IsCollateralValid(CTransaction(dsa.txCollateral))) {
|
||||
LogPrint(BCLog::COINJOIN, "CCoinJoinServer::%s -- collateral not valid!\n", __func__);
|
||||
nMessageIDRet = ERR_INVALID_COLLATERAL;
|
||||
return false;
|
||||
|
@ -137,7 +137,7 @@ CTransactionBuilder::CTransactionBuilder(std::shared_ptr<CWallet> pwalletIn, con
|
||||
dummyBatch.TxnAbort();
|
||||
dummyScript = ::GetScriptForDestination(dummyPubkey.GetID());
|
||||
// Calculate required bytes for the dummy signed tx with tallyItem's inputs only
|
||||
nBytesBase = CalculateMaximumSignedTxSize(dummyTx, pwallet.get(), false);
|
||||
nBytesBase = CalculateMaximumSignedTxSize(CTransaction(dummyTx), pwallet.get(), false);
|
||||
}
|
||||
// Calculate the output size
|
||||
nBytesOutput = ::GetSerializeSize(CTxOut(0, dummyScript), SER_NETWORK, PROTOCOL_VERSION);
|
||||
|
@ -772,7 +772,7 @@ static int CommandLineRawTx(int argc, char* argv[])
|
||||
MutateTx(tx, key, value);
|
||||
}
|
||||
|
||||
OutputTx(tx);
|
||||
OutputTx(CTransaction(tx));
|
||||
}
|
||||
catch (const std::exception& e) {
|
||||
strPrint = std::string("error: ") + e.what();
|
||||
|
@ -211,7 +211,7 @@ public:
|
||||
CTransaction();
|
||||
|
||||
/** Convert a CMutableTransaction into a CTransaction. */
|
||||
CTransaction(const CMutableTransaction &tx);
|
||||
explicit CTransaction(const CMutableTransaction &tx);
|
||||
CTransaction(CMutableTransaction &&tx);
|
||||
|
||||
template <typename Stream>
|
||||
|
@ -551,7 +551,7 @@ static UniValue createrawtransaction(const JSONRPCRequest& request)
|
||||
|
||||
CMutableTransaction rawTx = ConstructTransaction(request.params[0], request.params[1], request.params[2]);
|
||||
|
||||
return EncodeHexTx(rawTx);
|
||||
return EncodeHexTx(CTransaction(rawTx));
|
||||
}
|
||||
|
||||
static UniValue decoderawtransaction(const JSONRPCRequest& request)
|
||||
@ -779,7 +779,7 @@ static UniValue combinerawtransaction(const JSONRPCRequest& request)
|
||||
UpdateInput(txin, sigdata);
|
||||
}
|
||||
|
||||
return EncodeHexTx(mergedTx);
|
||||
return EncodeHexTx(CTransaction(mergedTx));
|
||||
}
|
||||
|
||||
UniValue SignTransaction(CMutableTransaction& mtx, const UniValue& prevTxsUnival, CBasicKeyStore *keystore, bool is_temp_keystore, const UniValue& hashType)
|
||||
@ -905,7 +905,7 @@ UniValue SignTransaction(CMutableTransaction& mtx, const UniValue& prevTxsUnival
|
||||
bool fComplete = vErrors.empty();
|
||||
|
||||
UniValue result(UniValue::VOBJ);
|
||||
result.pushKV("hex", EncodeHexTx(mtx));
|
||||
result.pushKV("hex", EncodeHexTx(CTransaction(mtx)));
|
||||
result.pushKV("complete", fComplete);
|
||||
if (!vErrors.empty()) {
|
||||
result.pushKV("errors", vErrors);
|
||||
|
@ -235,7 +235,7 @@ static void FundSpecialTx(CWallet* pwallet, CMutableTransaction& tx, const Speci
|
||||
template<typename SpecialTxPayload>
|
||||
static void UpdateSpecialTxInputsHash(const CMutableTransaction& tx, SpecialTxPayload& payload)
|
||||
{
|
||||
payload.inputsHash = CalcTxInputsHash(tx);
|
||||
payload.inputsHash = CalcTxInputsHash(CTransaction(tx));
|
||||
}
|
||||
|
||||
template<typename SpecialTxPayload>
|
||||
@ -277,7 +277,7 @@ static std::string SignAndSendSpecialTx(const CMutableTransaction& tx, bool fSub
|
||||
LOCK(cs_main);
|
||||
|
||||
CValidationState state;
|
||||
if (!CheckSpecialTx(tx, chainActive.Tip(), state, *pcoinsTip.get())) {
|
||||
if (!CheckSpecialTx(CTransaction(tx), chainActive.Tip(), state, *pcoinsTip.get())) {
|
||||
throw std::runtime_error(FormatStateMessage(state));
|
||||
}
|
||||
} // cs_main
|
||||
@ -592,7 +592,7 @@ static UniValue protx_register(const JSONRPCRequest& request)
|
||||
SetTxPayload(tx, ptx);
|
||||
|
||||
UniValue ret(UniValue::VOBJ);
|
||||
ret.pushKV("tx", EncodeHexTx(tx));
|
||||
ret.pushKV("tx", EncodeHexTx(CTransaction(tx)));
|
||||
ret.pushKV("collateralAddress", EncodeDestination(txDest));
|
||||
ret.pushKV("signMessage", ptx.MakeSignString());
|
||||
return ret;
|
||||
|
@ -380,7 +380,7 @@ BOOST_AUTO_TEST_CASE(updatecoins_simulation_test)
|
||||
|
||||
// Call UpdateCoins on the top cache
|
||||
CTxUndo undo;
|
||||
UpdateCoins(tx, *(stack.back()), undo, height);
|
||||
UpdateCoins(CTransaction(tx), *(stack.back()), undo, height);
|
||||
|
||||
// Update the utxo set for future spends
|
||||
utxoset.insert(outpoint);
|
||||
|
@ -109,7 +109,7 @@ static CMutableTransaction CreateProRegTx(SimpleUTXOMap& utxos, int port, const
|
||||
tx.nVersion = 3;
|
||||
tx.nType = TRANSACTION_PROVIDER_REGISTER;
|
||||
FundTransaction(tx, utxos, scriptPayout, 1000 * COIN, coinbaseKey);
|
||||
proTx.inputsHash = CalcTxInputsHash(tx);
|
||||
proTx.inputsHash = CalcTxInputsHash(CTransaction(tx));
|
||||
SetTxPayload(tx, proTx);
|
||||
SignTransaction(tx, coinbaseKey);
|
||||
|
||||
@ -127,7 +127,7 @@ static CMutableTransaction CreateProUpServTx(SimpleUTXOMap& utxos, const uint256
|
||||
tx.nVersion = 3;
|
||||
tx.nType = TRANSACTION_PROVIDER_UPDATE_SERVICE;
|
||||
FundTransaction(tx, utxos, GetScriptForDestination(coinbaseKey.GetPubKey().GetID()), 1 * COIN, coinbaseKey);
|
||||
proTx.inputsHash = CalcTxInputsHash(tx);
|
||||
proTx.inputsHash = CalcTxInputsHash(CTransaction(tx));
|
||||
proTx.sig = operatorKey.Sign(::SerializeHash(proTx));
|
||||
SetTxPayload(tx, proTx);
|
||||
SignTransaction(tx, coinbaseKey);
|
||||
@ -147,7 +147,7 @@ static CMutableTransaction CreateProUpRegTx(SimpleUTXOMap& utxos, const uint256&
|
||||
tx.nVersion = 3;
|
||||
tx.nType = TRANSACTION_PROVIDER_UPDATE_REGISTRAR;
|
||||
FundTransaction(tx, utxos, GetScriptForDestination(coinbaseKey.GetPubKey().GetID()), 1 * COIN, coinbaseKey);
|
||||
proTx.inputsHash = CalcTxInputsHash(tx);
|
||||
proTx.inputsHash = CalcTxInputsHash(CTransaction(tx));
|
||||
CHashSigner::SignHash(::SerializeHash(proTx), mnKey, proTx.vchSig);
|
||||
SetTxPayload(tx, proTx);
|
||||
SignTransaction(tx, coinbaseKey);
|
||||
@ -164,7 +164,7 @@ static CMutableTransaction CreateProUpRevTx(SimpleUTXOMap& utxos, const uint256&
|
||||
tx.nVersion = 3;
|
||||
tx.nType = TRANSACTION_PROVIDER_UPDATE_REVOKE;
|
||||
FundTransaction(tx, utxos, GetScriptForDestination(coinbaseKey.GetPubKey().GetID()), 1 * COIN, coinbaseKey);
|
||||
proTx.inputsHash = CalcTxInputsHash(tx);
|
||||
proTx.inputsHash = CalcTxInputsHash(CTransaction(tx));
|
||||
proTx.sig = operatorKey.Sign(::SerializeHash(proTx));
|
||||
SetTxPayload(tx, proTx);
|
||||
SignTransaction(tx, coinbaseKey);
|
||||
@ -293,8 +293,8 @@ BOOST_FIXTURE_TEST_CASE(dip3_protx, TestChainDIP3Setup)
|
||||
auto tx2 = MalleateProTxPayout<CProRegTx>(tx);
|
||||
CValidationState dummyState;
|
||||
// Technically, the payload is still valid...
|
||||
BOOST_ASSERT(CheckProRegTx(tx, chainActive.Tip(), dummyState, *pcoinsTip.get()));
|
||||
BOOST_ASSERT(CheckProRegTx(tx2, chainActive.Tip(), dummyState, *pcoinsTip.get()));
|
||||
BOOST_ASSERT(CheckProRegTx(CTransaction(tx), chainActive.Tip(), dummyState, *pcoinsTip.get()));
|
||||
BOOST_ASSERT(CheckProRegTx(CTransaction(tx2), chainActive.Tip(), dummyState, *pcoinsTip.get()));
|
||||
// But the signature should not verify anymore
|
||||
BOOST_ASSERT(CheckTransactionSignature(tx));
|
||||
BOOST_ASSERT(!CheckTransactionSignature(tx2));
|
||||
@ -396,8 +396,8 @@ BOOST_FIXTURE_TEST_CASE(dip3_protx, TestChainDIP3Setup)
|
||||
// check malleability protection again, but this time by also relying on the signature inside the ProUpRegTx
|
||||
auto tx2 = MalleateProTxPayout<CProUpRegTx>(tx);
|
||||
CValidationState dummyState;
|
||||
BOOST_ASSERT(CheckProUpRegTx(tx, chainActive.Tip(), dummyState, *pcoinsTip.get()));
|
||||
BOOST_ASSERT(!CheckProUpRegTx(tx2, chainActive.Tip(), dummyState, *pcoinsTip.get()));
|
||||
BOOST_ASSERT(CheckProUpRegTx(CTransaction(tx), chainActive.Tip(), dummyState, *pcoinsTip.get()));
|
||||
BOOST_ASSERT(!CheckProUpRegTx(CTransaction(tx2), chainActive.Tip(), dummyState, *pcoinsTip.get()));
|
||||
BOOST_ASSERT(CheckTransactionSignature(tx));
|
||||
BOOST_ASSERT(!CheckTransactionSignature(tx2));
|
||||
// now process the block
|
||||
@ -486,7 +486,7 @@ BOOST_FIXTURE_TEST_CASE(dip3_test_mempool_reorg, TestChainDIP3Setup)
|
||||
tx_reg.nVersion = 3;
|
||||
tx_reg.nType = TRANSACTION_PROVIDER_REGISTER;
|
||||
FundTransaction(tx_reg, utxos, scriptPayout, 1000 * COIN, coinbaseKey);
|
||||
payload.inputsHash = CalcTxInputsHash(tx_reg);
|
||||
payload.inputsHash = CalcTxInputsHash(CTransaction(tx_reg));
|
||||
CMessageSigner::SignMessage(payload.MakeSignString(), payload.vchSig, collateralKey);
|
||||
SetTxPayload(tx_reg, payload);
|
||||
SignTransaction(tx_reg, coinbaseKey);
|
||||
@ -556,7 +556,7 @@ BOOST_FIXTURE_TEST_CASE(dip3_test_mempool_dual_proregtx, TestChainDIP3Setup)
|
||||
tx_reg2.nVersion = 3;
|
||||
tx_reg2.nType = TRANSACTION_PROVIDER_REGISTER;
|
||||
FundTransaction(tx_reg2, utxos, scriptPayout, 1000 * COIN, coinbaseKey);
|
||||
payload.inputsHash = CalcTxInputsHash(tx_reg2);
|
||||
payload.inputsHash = CalcTxInputsHash(CTransaction(tx_reg2));
|
||||
CMessageSigner::SignMessage(payload.MakeSignString(), payload.vchSig, collateralKey);
|
||||
SetTxPayload(tx_reg2, payload);
|
||||
SignTransaction(tx_reg2, coinbaseKey);
|
||||
@ -567,7 +567,7 @@ BOOST_FIXTURE_TEST_CASE(dip3_test_mempool_dual_proregtx, TestChainDIP3Setup)
|
||||
|
||||
testPool.addUnchecked(entry.FromTx(tx_reg1));
|
||||
BOOST_CHECK_EQUAL(testPool.size(), 1U);
|
||||
BOOST_CHECK(testPool.existsProviderTxConflict(tx_reg2));
|
||||
BOOST_CHECK(testPool.existsProviderTxConflict(CTransaction(tx_reg2)));
|
||||
}
|
||||
|
||||
BOOST_FIXTURE_TEST_CASE(dip3_verify_db, TestChainDIP3Setup)
|
||||
@ -617,7 +617,7 @@ BOOST_FIXTURE_TEST_CASE(dip3_verify_db, TestChainDIP3Setup)
|
||||
tx_reg.nVersion = 3;
|
||||
tx_reg.nType = TRANSACTION_PROVIDER_REGISTER;
|
||||
FundTransaction(tx_reg, utxos, scriptPayout, 1000 * COIN, coinbaseKey);
|
||||
payload.inputsHash = CalcTxInputsHash(tx_reg);
|
||||
payload.inputsHash = CalcTxInputsHash(CTransaction(tx_reg));
|
||||
CMessageSigner::SignMessage(payload.MakeSignString(), payload.vchSig, collateralKey);
|
||||
SetTxPayload(tx_reg, payload);
|
||||
SignTransaction(tx_reg, coinbaseKey);
|
||||
|
@ -58,13 +58,13 @@ BOOST_AUTO_TEST_CASE(MempoolRemoveTest)
|
||||
|
||||
// Nothing in pool, remove should do nothing:
|
||||
unsigned int poolSize = testPool.size();
|
||||
testPool.removeRecursive(txParent);
|
||||
testPool.removeRecursive(CTransaction(txParent));
|
||||
BOOST_CHECK_EQUAL(testPool.size(), poolSize);
|
||||
|
||||
// Just the parent:
|
||||
testPool.addUnchecked(entry.FromTx(txParent));
|
||||
poolSize = testPool.size();
|
||||
testPool.removeRecursive(txParent);
|
||||
testPool.removeRecursive(CTransaction(txParent));
|
||||
BOOST_CHECK_EQUAL(testPool.size(), poolSize - 1);
|
||||
|
||||
// Parent, children, grandchildren:
|
||||
@ -76,18 +76,18 @@ BOOST_AUTO_TEST_CASE(MempoolRemoveTest)
|
||||
}
|
||||
// Remove Child[0], GrandChild[0] should be removed:
|
||||
poolSize = testPool.size();
|
||||
testPool.removeRecursive(txChild[0]);
|
||||
testPool.removeRecursive(CTransaction(txChild[0]));
|
||||
BOOST_CHECK_EQUAL(testPool.size(), poolSize - 2);
|
||||
// ... make sure grandchild and child are gone:
|
||||
poolSize = testPool.size();
|
||||
testPool.removeRecursive(txGrandChild[0]);
|
||||
testPool.removeRecursive(CTransaction(txGrandChild[0]));
|
||||
BOOST_CHECK_EQUAL(testPool.size(), poolSize);
|
||||
poolSize = testPool.size();
|
||||
testPool.removeRecursive(txChild[0]);
|
||||
testPool.removeRecursive(CTransaction(txChild[0]));
|
||||
BOOST_CHECK_EQUAL(testPool.size(), poolSize);
|
||||
// Remove parent, all children/grandchildren should go:
|
||||
poolSize = testPool.size();
|
||||
testPool.removeRecursive(txParent);
|
||||
testPool.removeRecursive(CTransaction(txParent));
|
||||
BOOST_CHECK_EQUAL(testPool.size(), poolSize - 5);
|
||||
BOOST_CHECK_EQUAL(testPool.size(), 0U);
|
||||
|
||||
@ -100,7 +100,7 @@ BOOST_AUTO_TEST_CASE(MempoolRemoveTest)
|
||||
// Now remove the parent, as might happen if a block-re-org occurs but the parent cannot be
|
||||
// put into the mempool (maybe because it is non-standard):
|
||||
poolSize = testPool.size();
|
||||
testPool.removeRecursive(txParent);
|
||||
testPool.removeRecursive(CTransaction(txParent));
|
||||
BOOST_CHECK_EQUAL(testPool.size(), poolSize - 6);
|
||||
BOOST_CHECK_EQUAL(testPool.size(), 0U);
|
||||
}
|
||||
|
@ -155,7 +155,7 @@ static void TestPackageSelection(const CChainParams& chainparams, const CScript&
|
||||
// Test that packages above the min relay fee do get included, even if one
|
||||
// of the transactions is below the min relay fee
|
||||
// Remove the low fee transaction and replace with a higher fee transaction
|
||||
mempool.removeRecursive(tx);
|
||||
mempool.removeRecursive(CTransaction(tx));
|
||||
tx.vout[0].nValue -= 2; // Now we should be just over the min relay fee
|
||||
hashLowFeeTx = tx.GetHash();
|
||||
mempool.addUnchecked(entry.Fee(feeToUse+2).FromTx(tx));
|
||||
@ -447,9 +447,9 @@ BOOST_AUTO_TEST_CASE(CreateNewBlock_validity)
|
||||
tx.nLockTime = 0;
|
||||
hash = tx.GetHash();
|
||||
mempool.addUnchecked(entry.Fee(HIGHFEE).Time(GetTime()).SpendsCoinbase(true).FromTx(tx));
|
||||
BOOST_CHECK(CheckFinalTx(tx, flags)); // Locktime passes
|
||||
BOOST_CHECK(!TestSequenceLocks(tx, flags)); // Sequence locks fail
|
||||
BOOST_CHECK(SequenceLocks(tx, flags, &prevheights, CreateBlockIndex(chainActive.Tip()->nHeight + 2))); // Sequence locks pass on 2nd block
|
||||
BOOST_CHECK(CheckFinalTx(CTransaction(tx), flags)); // Locktime passes
|
||||
BOOST_CHECK(!TestSequenceLocks(CTransaction(tx), flags)); // Sequence locks fail
|
||||
BOOST_CHECK(SequenceLocks(CTransaction(tx), flags, &prevheights, CreateBlockIndex(chainActive.Tip()->nHeight + 2))); // Sequence locks pass on 2nd block
|
||||
|
||||
// relative time locked
|
||||
tx.vin[0].prevout.hash = txFirst[1]->GetHash();
|
||||
@ -457,12 +457,12 @@ BOOST_AUTO_TEST_CASE(CreateNewBlock_validity)
|
||||
prevheights[0] = baseheight + 2;
|
||||
hash = tx.GetHash();
|
||||
mempool.addUnchecked(entry.Time(GetTime()).FromTx(tx));
|
||||
BOOST_CHECK(CheckFinalTx(tx, flags)); // Locktime passes
|
||||
BOOST_CHECK(!TestSequenceLocks(tx, flags)); // Sequence locks fail
|
||||
BOOST_CHECK(CheckFinalTx(CTransaction(tx), flags)); // Locktime passes
|
||||
BOOST_CHECK(!TestSequenceLocks(CTransaction(tx), flags)); // Sequence locks fail
|
||||
|
||||
for (int i = 0; i < CBlockIndex::nMedianTimeSpan; i++)
|
||||
chainActive.Tip()->GetAncestor(chainActive.Tip()->nHeight - i)->nTime += 512; //Trick the MedianTimePast
|
||||
BOOST_CHECK(SequenceLocks(tx, flags, &prevheights, CreateBlockIndex(chainActive.Tip()->nHeight + 1))); // Sequence locks pass 512 seconds later
|
||||
BOOST_CHECK(SequenceLocks(CTransaction(tx), flags, &prevheights, CreateBlockIndex(chainActive.Tip()->nHeight + 1))); // Sequence locks pass 512 seconds later
|
||||
for (int i = 0; i < CBlockIndex::nMedianTimeSpan; i++)
|
||||
chainActive.Tip()->GetAncestor(chainActive.Tip()->nHeight - i)->nTime -= 512; //undo tricked MTP
|
||||
|
||||
@ -473,9 +473,9 @@ BOOST_AUTO_TEST_CASE(CreateNewBlock_validity)
|
||||
tx.nLockTime = chainActive.Tip()->nHeight + 1;
|
||||
hash = tx.GetHash();
|
||||
mempool.addUnchecked(entry.Time(GetTime()).FromTx(tx));
|
||||
BOOST_CHECK(!CheckFinalTx(tx, flags)); // Locktime fails
|
||||
BOOST_CHECK(TestSequenceLocks(tx, flags)); // Sequence locks pass
|
||||
BOOST_CHECK(IsFinalTx(tx, chainActive.Tip()->nHeight + 2, chainActive.Tip()->GetMedianTimePast())); // Locktime passes on 2nd block
|
||||
BOOST_CHECK(!CheckFinalTx(CTransaction(tx), flags)); // Locktime fails
|
||||
BOOST_CHECK(TestSequenceLocks(CTransaction(tx), flags)); // Sequence locks pass
|
||||
BOOST_CHECK(IsFinalTx(CTransaction(tx), chainActive.Tip()->nHeight + 2, chainActive.Tip()->GetMedianTimePast())); // Locktime passes on 2nd block
|
||||
|
||||
// absolute time locked
|
||||
tx.vin[0].prevout.hash = txFirst[3]->GetHash();
|
||||
@ -484,23 +484,23 @@ BOOST_AUTO_TEST_CASE(CreateNewBlock_validity)
|
||||
prevheights[0] = baseheight + 4;
|
||||
hash = tx.GetHash();
|
||||
mempool.addUnchecked(entry.Time(GetTime()).FromTx(tx));
|
||||
BOOST_CHECK(!CheckFinalTx(tx, flags)); // Locktime fails
|
||||
BOOST_CHECK(TestSequenceLocks(tx, flags)); // Sequence locks pass
|
||||
BOOST_CHECK(IsFinalTx(tx, chainActive.Tip()->nHeight + 2, chainActive.Tip()->GetMedianTimePast() + 1)); // Locktime passes 1 second later
|
||||
BOOST_CHECK(!CheckFinalTx(CTransaction(tx), flags)); // Locktime fails
|
||||
BOOST_CHECK(TestSequenceLocks(CTransaction(tx), flags)); // Sequence locks pass
|
||||
BOOST_CHECK(IsFinalTx(CTransaction(tx), chainActive.Tip()->nHeight + 2, chainActive.Tip()->GetMedianTimePast() + 1)); // Locktime passes 1 second later
|
||||
|
||||
// mempool-dependent transactions (not added)
|
||||
tx.vin[0].prevout.hash = hash;
|
||||
prevheights[0] = chainActive.Tip()->nHeight + 1;
|
||||
tx.nLockTime = 0;
|
||||
tx.vin[0].nSequence = 0;
|
||||
BOOST_CHECK(CheckFinalTx(tx, flags)); // Locktime passes
|
||||
BOOST_CHECK(TestSequenceLocks(tx, flags)); // Sequence locks pass
|
||||
BOOST_CHECK(CheckFinalTx(CTransaction(tx), flags)); // Locktime passes
|
||||
BOOST_CHECK(TestSequenceLocks(CTransaction(tx), flags)); // Sequence locks pass
|
||||
tx.vin[0].nSequence = 1;
|
||||
BOOST_CHECK(!TestSequenceLocks(tx, flags)); // Sequence locks fail
|
||||
BOOST_CHECK(!TestSequenceLocks(CTransaction(tx), flags)); // Sequence locks fail
|
||||
tx.vin[0].nSequence = CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG;
|
||||
BOOST_CHECK(TestSequenceLocks(tx, flags)); // Sequence locks pass
|
||||
BOOST_CHECK(TestSequenceLocks(CTransaction(tx), flags)); // Sequence locks pass
|
||||
tx.vin[0].nSequence = CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG | 1;
|
||||
BOOST_CHECK(!TestSequenceLocks(tx, flags)); // Sequence locks fail
|
||||
BOOST_CHECK(!TestSequenceLocks(CTransaction(tx), flags)); // Sequence locks fail
|
||||
|
||||
BOOST_CHECK(pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey));
|
||||
|
||||
|
@ -76,20 +76,20 @@ BOOST_AUTO_TEST_CASE(multisig_verify)
|
||||
// Test a AND b:
|
||||
keys.assign(1,key[0]);
|
||||
keys.push_back(key[1]);
|
||||
s = sign_multisig(a_and_b, keys, txTo[0], 0);
|
||||
s = sign_multisig(a_and_b, keys, CTransaction(txTo[0]), 0);
|
||||
BOOST_CHECK(VerifyScript(s, a_and_b, flags, MutableTransactionSignatureChecker(&txTo[0], 0, amount), &err));
|
||||
BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
|
||||
|
||||
for (int i = 0; i < 4; i++)
|
||||
{
|
||||
keys.assign(1,key[i]);
|
||||
s = sign_multisig(a_and_b, keys, txTo[0], 0);
|
||||
s = sign_multisig(a_and_b, keys, CTransaction(txTo[0]), 0);
|
||||
BOOST_CHECK_MESSAGE(!VerifyScript(s, a_and_b, flags, MutableTransactionSignatureChecker(&txTo[0], 0, amount), &err), strprintf("a&b 1: %d", i));
|
||||
BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_INVALID_STACK_OPERATION, ScriptErrorString(err));
|
||||
|
||||
keys.assign(1,key[1]);
|
||||
keys.push_back(key[i]);
|
||||
s = sign_multisig(a_and_b, keys, txTo[0], 0);
|
||||
s = sign_multisig(a_and_b, keys, CTransaction(txTo[0]), 0);
|
||||
BOOST_CHECK_MESSAGE(!VerifyScript(s, a_and_b, flags, MutableTransactionSignatureChecker(&txTo[0], 0, amount), &err), strprintf("a&b 2: %d", i));
|
||||
BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, ScriptErrorString(err));
|
||||
}
|
||||
@ -98,7 +98,7 @@ BOOST_AUTO_TEST_CASE(multisig_verify)
|
||||
for (int i = 0; i < 4; i++)
|
||||
{
|
||||
keys.assign(1,key[i]);
|
||||
s = sign_multisig(a_or_b, keys, txTo[1], 0);
|
||||
s = sign_multisig(a_or_b, keys, CTransaction(txTo[1]), 0);
|
||||
if (i == 0 || i == 1)
|
||||
{
|
||||
BOOST_CHECK_MESSAGE(VerifyScript(s, a_or_b, flags, MutableTransactionSignatureChecker(&txTo[1], 0, amount), &err), strprintf("a|b: %d", i));
|
||||
@ -121,7 +121,7 @@ BOOST_AUTO_TEST_CASE(multisig_verify)
|
||||
{
|
||||
keys.assign(1,key[i]);
|
||||
keys.push_back(key[j]);
|
||||
s = sign_multisig(escrow, keys, txTo[2], 0);
|
||||
s = sign_multisig(escrow, keys, CTransaction(txTo[2]), 0);
|
||||
if (i < j && i < 3 && j < 3)
|
||||
{
|
||||
BOOST_CHECK_MESSAGE(VerifyScript(s, escrow, flags, MutableTransactionSignatureChecker(&txTo[2], 0, amount), &err), strprintf("escrow 1: %d %d", i, j));
|
||||
@ -209,7 +209,7 @@ BOOST_AUTO_TEST_CASE(multisig_Sign)
|
||||
|
||||
for (int i = 0; i < 3; i++)
|
||||
{
|
||||
BOOST_CHECK_MESSAGE(SignSignature(keystore, txFrom, txTo[i], 0, SIGHASH_ALL), strprintf("SignSignature %d", i));
|
||||
BOOST_CHECK_MESSAGE(SignSignature(keystore, CTransaction(txFrom), txTo[i], 0, SIGHASH_ALL), strprintf("SignSignature %d", i));
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -88,7 +88,7 @@ BOOST_AUTO_TEST_CASE(sign)
|
||||
txFrom.vout[i+4].scriptPubKey = standardScripts[i];
|
||||
txFrom.vout[i+4].nValue = COIN;
|
||||
}
|
||||
BOOST_CHECK(IsStandardTx(txFrom, reason));
|
||||
BOOST_CHECK(IsStandardTx(CTransaction(txFrom), reason));
|
||||
|
||||
CMutableTransaction txTo[8]; // Spending transactions
|
||||
for (int i = 0; i < 8; i++)
|
||||
@ -102,7 +102,7 @@ BOOST_AUTO_TEST_CASE(sign)
|
||||
}
|
||||
for (int i = 0; i < 8; i++)
|
||||
{
|
||||
BOOST_CHECK_MESSAGE(SignSignature(keystore, txFrom, txTo[i], 0, SIGHASH_ALL), strprintf("SignSignature %d", i));
|
||||
BOOST_CHECK_MESSAGE(SignSignature(keystore, CTransaction(txFrom), txTo[i], 0, SIGHASH_ALL), strprintf("SignSignature %d", i));
|
||||
}
|
||||
// All of the above should be OK, and the txTos have valid signatures
|
||||
// Check to make sure signature verification fails if we use the wrong ScriptSig:
|
||||
@ -112,7 +112,7 @@ BOOST_AUTO_TEST_CASE(sign)
|
||||
{
|
||||
CScript sigSave = txTo[i].vin[0].scriptSig;
|
||||
txTo[i].vin[0].scriptSig = txTo[j].vin[0].scriptSig;
|
||||
bool sigOK = CScriptCheck(txFrom.vout[txTo[i].vin[0].prevout.n], txTo[i], 0, SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_STRICTENC, false, &txdata)();
|
||||
bool sigOK = CScriptCheck(txFrom.vout[txTo[i].vin[0].prevout.n], CTransaction(txTo[i]), 0, SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_STRICTENC, false, &txdata)();
|
||||
if (i == j)
|
||||
BOOST_CHECK_MESSAGE(sigOK, strprintf("VerifySignature %d %d", i, j));
|
||||
else
|
||||
@ -184,7 +184,7 @@ BOOST_AUTO_TEST_CASE(set)
|
||||
txFrom.vout[i].scriptPubKey = outer[i];
|
||||
txFrom.vout[i].nValue = CENT;
|
||||
}
|
||||
BOOST_CHECK(IsStandardTx(txFrom, reason));
|
||||
BOOST_CHECK(IsStandardTx(CTransaction(txFrom), reason));
|
||||
|
||||
CMutableTransaction txTo[4]; // Spending transactions
|
||||
for (int i = 0; i < 4; i++)
|
||||
@ -199,8 +199,8 @@ BOOST_AUTO_TEST_CASE(set)
|
||||
}
|
||||
for (int i = 0; i < 4; i++)
|
||||
{
|
||||
BOOST_CHECK_MESSAGE(SignSignature(keystore, txFrom, txTo[i], 0, SIGHASH_ALL), strprintf("SignSignature %d", i));
|
||||
BOOST_CHECK_MESSAGE(IsStandardTx(txTo[i], reason), strprintf("txTo[%d].IsStandard", i));
|
||||
BOOST_CHECK_MESSAGE(SignSignature(keystore, CTransaction(txFrom), txTo[i], 0, SIGHASH_ALL), strprintf("SignSignature %d", i));
|
||||
BOOST_CHECK_MESSAGE(IsStandardTx(CTransaction(txTo[i]), reason), strprintf("txTo[%d].IsStandard", i));
|
||||
}
|
||||
}
|
||||
|
||||
@ -325,7 +325,7 @@ BOOST_AUTO_TEST_CASE(AreInputsStandard)
|
||||
txFrom.vout[6].scriptPubKey = GetScriptForDestination(CScriptID(twentySigops));
|
||||
txFrom.vout[6].nValue = 6000;
|
||||
|
||||
AddCoins(coins, txFrom, 0);
|
||||
AddCoins(coins, CTransaction(txFrom), 0);
|
||||
|
||||
CMutableTransaction txTo;
|
||||
txTo.vout.resize(1);
|
||||
@ -337,18 +337,18 @@ BOOST_AUTO_TEST_CASE(AreInputsStandard)
|
||||
txTo.vin[i].prevout.n = i;
|
||||
txTo.vin[i].prevout.hash = txFrom.GetHash();
|
||||
}
|
||||
BOOST_CHECK(SignSignature(keystore, txFrom, txTo, 0, SIGHASH_ALL));
|
||||
BOOST_CHECK(SignSignature(keystore, txFrom, txTo, 1, SIGHASH_ALL));
|
||||
BOOST_CHECK(SignSignature(keystore, txFrom, txTo, 2, SIGHASH_ALL));
|
||||
BOOST_CHECK(SignSignature(keystore, CTransaction(txFrom), txTo, 0, SIGHASH_ALL));
|
||||
BOOST_CHECK(SignSignature(keystore, CTransaction(txFrom), txTo, 1, SIGHASH_ALL));
|
||||
BOOST_CHECK(SignSignature(keystore, CTransaction(txFrom), txTo, 2, SIGHASH_ALL));
|
||||
// SignSignature doesn't know how to sign these. We're
|
||||
// not testing validating signatures, so just create
|
||||
// dummy signatures that DO include the correct P2SH scripts:
|
||||
txTo.vin[3].scriptSig << OP_11 << OP_11 << std::vector<unsigned char>(oneAndTwo.begin(), oneAndTwo.end());
|
||||
txTo.vin[4].scriptSig << std::vector<unsigned char>(fifteenSigops.begin(), fifteenSigops.end());
|
||||
|
||||
BOOST_CHECK(::AreInputsStandard(txTo, coins));
|
||||
BOOST_CHECK(::AreInputsStandard(CTransaction(txTo), coins));
|
||||
// 22 P2SH sigops for all inputs (1 for vin[0], 6 for vin[3], 15 for vin[4]
|
||||
BOOST_CHECK_EQUAL(GetP2SHSigOpCount(txTo, coins), 22U);
|
||||
BOOST_CHECK_EQUAL(GetP2SHSigOpCount(CTransaction(txTo), coins), 22U);
|
||||
|
||||
CMutableTransaction txToNonStd1;
|
||||
txToNonStd1.vout.resize(1);
|
||||
@ -359,8 +359,8 @@ BOOST_AUTO_TEST_CASE(AreInputsStandard)
|
||||
txToNonStd1.vin[0].prevout.hash = txFrom.GetHash();
|
||||
txToNonStd1.vin[0].scriptSig << std::vector<unsigned char>(sixteenSigops.begin(), sixteenSigops.end());
|
||||
|
||||
BOOST_CHECK(!::AreInputsStandard(txToNonStd1, coins));
|
||||
BOOST_CHECK_EQUAL(GetP2SHSigOpCount(txToNonStd1, coins), 16U);
|
||||
BOOST_CHECK(!::AreInputsStandard(CTransaction(txToNonStd1), coins));
|
||||
BOOST_CHECK_EQUAL(GetP2SHSigOpCount(CTransaction(txToNonStd1), coins), 16U);
|
||||
|
||||
CMutableTransaction txToNonStd2;
|
||||
txToNonStd2.vout.resize(1);
|
||||
@ -371,8 +371,8 @@ BOOST_AUTO_TEST_CASE(AreInputsStandard)
|
||||
txToNonStd2.vin[0].prevout.hash = txFrom.GetHash();
|
||||
txToNonStd2.vin[0].scriptSig << std::vector<unsigned char>(twentySigops.begin(), twentySigops.end());
|
||||
|
||||
BOOST_CHECK(!::AreInputsStandard(txToNonStd2, coins));
|
||||
BOOST_CHECK_EQUAL(GetP2SHSigOpCount(txToNonStd2, coins), 20U);
|
||||
BOOST_CHECK(!::AreInputsStandard(CTransaction(txToNonStd2), coins));
|
||||
BOOST_CHECK_EQUAL(GetP2SHSigOpCount(CTransaction(txToNonStd2), coins), 20U);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_SUITE_END()
|
||||
|
@ -1046,18 +1046,18 @@ BOOST_AUTO_TEST_CASE(script_CHECKMULTISIG12)
|
||||
const CTransaction txFrom12{BuildCreditingTransaction(scriptPubKey12)};
|
||||
CMutableTransaction txTo12 = BuildSpendingTransaction(CScript(), txFrom12);
|
||||
|
||||
CScript goodsig1 = sign_multisig(scriptPubKey12, key1, txTo12);
|
||||
CScript goodsig1 = sign_multisig(scriptPubKey12, key1, CTransaction(txTo12));
|
||||
BOOST_CHECK(VerifyScript(goodsig1, scriptPubKey12, gFlags, MutableTransactionSignatureChecker(&txTo12, 0, txFrom12.vout[0].nValue), &err));
|
||||
BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
|
||||
txTo12.vout[0].nValue = 2;
|
||||
BOOST_CHECK(!VerifyScript(goodsig1, scriptPubKey12, gFlags, MutableTransactionSignatureChecker(&txTo12, 0, txFrom12.vout[0].nValue), &err));
|
||||
BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, ScriptErrorString(err));
|
||||
|
||||
CScript goodsig2 = sign_multisig(scriptPubKey12, key2, txTo12);
|
||||
CScript goodsig2 = sign_multisig(scriptPubKey12, key2, CTransaction(txTo12));
|
||||
BOOST_CHECK(VerifyScript(goodsig2, scriptPubKey12, gFlags, MutableTransactionSignatureChecker(&txTo12, 0, txFrom12.vout[0].nValue), &err));
|
||||
BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
|
||||
|
||||
CScript badsig1 = sign_multisig(scriptPubKey12, key3, txTo12);
|
||||
CScript badsig1 = sign_multisig(scriptPubKey12, key3, CTransaction(txTo12));
|
||||
BOOST_CHECK(!VerifyScript(badsig1, scriptPubKey12, gFlags, MutableTransactionSignatureChecker(&txTo12, 0, txFrom12.vout[0].nValue), &err));
|
||||
BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, ScriptErrorString(err));
|
||||
}
|
||||
@ -1079,54 +1079,54 @@ BOOST_AUTO_TEST_CASE(script_CHECKMULTISIG23)
|
||||
|
||||
std::vector<CKey> keys;
|
||||
keys.push_back(key1); keys.push_back(key2);
|
||||
CScript goodsig1 = sign_multisig(scriptPubKey23, keys, txTo23);
|
||||
CScript goodsig1 = sign_multisig(scriptPubKey23, keys, CTransaction(txTo23));
|
||||
BOOST_CHECK(VerifyScript(goodsig1, scriptPubKey23, gFlags, MutableTransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue), &err));
|
||||
BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
|
||||
|
||||
keys.clear();
|
||||
keys.push_back(key1); keys.push_back(key3);
|
||||
CScript goodsig2 = sign_multisig(scriptPubKey23, keys, txTo23);
|
||||
CScript goodsig2 = sign_multisig(scriptPubKey23, keys, CTransaction(txTo23));
|
||||
BOOST_CHECK(VerifyScript(goodsig2, scriptPubKey23, gFlags, MutableTransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue), &err));
|
||||
BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
|
||||
|
||||
keys.clear();
|
||||
keys.push_back(key2); keys.push_back(key3);
|
||||
CScript goodsig3 = sign_multisig(scriptPubKey23, keys, txTo23);
|
||||
CScript goodsig3 = sign_multisig(scriptPubKey23, keys, CTransaction(txTo23));
|
||||
BOOST_CHECK(VerifyScript(goodsig3, scriptPubKey23, gFlags, MutableTransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue), &err));
|
||||
BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
|
||||
|
||||
keys.clear();
|
||||
keys.push_back(key2); keys.push_back(key2); // Can't re-use sig
|
||||
CScript badsig1 = sign_multisig(scriptPubKey23, keys, txTo23);
|
||||
CScript badsig1 = sign_multisig(scriptPubKey23, keys, CTransaction(txTo23));
|
||||
BOOST_CHECK(!VerifyScript(badsig1, scriptPubKey23, gFlags, MutableTransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue), &err));
|
||||
BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, ScriptErrorString(err));
|
||||
|
||||
keys.clear();
|
||||
keys.push_back(key2); keys.push_back(key1); // sigs must be in correct order
|
||||
CScript badsig2 = sign_multisig(scriptPubKey23, keys, txTo23);
|
||||
CScript badsig2 = sign_multisig(scriptPubKey23, keys, CTransaction(txTo23));
|
||||
BOOST_CHECK(!VerifyScript(badsig2, scriptPubKey23, gFlags, MutableTransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue), &err));
|
||||
BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, ScriptErrorString(err));
|
||||
|
||||
keys.clear();
|
||||
keys.push_back(key3); keys.push_back(key2); // sigs must be in correct order
|
||||
CScript badsig3 = sign_multisig(scriptPubKey23, keys, txTo23);
|
||||
CScript badsig3 = sign_multisig(scriptPubKey23, keys, CTransaction(txTo23));
|
||||
BOOST_CHECK(!VerifyScript(badsig3, scriptPubKey23, gFlags, MutableTransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue), &err));
|
||||
BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, ScriptErrorString(err));
|
||||
|
||||
keys.clear();
|
||||
keys.push_back(key4); keys.push_back(key2); // sigs must match pubkeys
|
||||
CScript badsig4 = sign_multisig(scriptPubKey23, keys, txTo23);
|
||||
CScript badsig4 = sign_multisig(scriptPubKey23, keys, CTransaction(txTo23));
|
||||
BOOST_CHECK(!VerifyScript(badsig4, scriptPubKey23, gFlags, MutableTransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue), &err));
|
||||
BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, ScriptErrorString(err));
|
||||
|
||||
keys.clear();
|
||||
keys.push_back(key1); keys.push_back(key4); // sigs must match pubkeys
|
||||
CScript badsig5 = sign_multisig(scriptPubKey23, keys, txTo23);
|
||||
CScript badsig5 = sign_multisig(scriptPubKey23, keys, CTransaction(txTo23));
|
||||
BOOST_CHECK(!VerifyScript(badsig5, scriptPubKey23, gFlags, MutableTransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue), &err));
|
||||
BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, ScriptErrorString(err));
|
||||
|
||||
keys.clear(); // Must have signatures
|
||||
CScript badsig6 = sign_multisig(scriptPubKey23, keys, txTo23);
|
||||
CScript badsig6 = sign_multisig(scriptPubKey23, keys, CTransaction(txTo23));
|
||||
BOOST_CHECK(!VerifyScript(badsig6, scriptPubKey23, gFlags, MutableTransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue), &err));
|
||||
BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_INVALID_STACK_OPERATION, ScriptErrorString(err));
|
||||
}
|
||||
@ -1157,7 +1157,7 @@ BOOST_AUTO_TEST_CASE(script_combineSigs)
|
||||
}
|
||||
|
||||
CMutableTransaction txFrom = BuildCreditingTransaction(GetScriptForDestination(keys[0].GetPubKey().GetID()));
|
||||
CMutableTransaction txTo = BuildSpendingTransaction(CScript(), txFrom);
|
||||
CMutableTransaction txTo = BuildSpendingTransaction(CScript(), CTransaction(txFrom));
|
||||
CScript& scriptPubKey = txFrom.vout[0].scriptPubKey;
|
||||
SignatureData scriptSig;
|
||||
|
||||
@ -1166,7 +1166,7 @@ BOOST_AUTO_TEST_CASE(script_combineSigs)
|
||||
BOOST_CHECK(combined.scriptSig.empty());
|
||||
|
||||
// Single signature case:
|
||||
BOOST_CHECK(SignSignature(keystore, txFrom, txTo, 0, SIGHASH_ALL)); // changes scriptSig
|
||||
BOOST_CHECK(SignSignature(keystore, CTransaction(txFrom), txTo, 0, SIGHASH_ALL)); // changes scriptSig
|
||||
scriptSig = DataFromTransaction(txTo, 0, txFrom.vout[0]);
|
||||
combined = CombineSignatures(txFrom.vout[0], txTo, scriptSig, empty);
|
||||
BOOST_CHECK(combined.scriptSig == scriptSig.scriptSig);
|
||||
@ -1174,7 +1174,7 @@ BOOST_AUTO_TEST_CASE(script_combineSigs)
|
||||
BOOST_CHECK(combined.scriptSig == scriptSig.scriptSig);
|
||||
SignatureData scriptSigCopy = scriptSig;
|
||||
// Signing again will give a different, valid signature:
|
||||
BOOST_CHECK(SignSignature(keystore, txFrom, txTo, 0, SIGHASH_ALL));
|
||||
BOOST_CHECK(SignSignature(keystore, CTransaction(txFrom), txTo, 0, SIGHASH_ALL));
|
||||
scriptSig = DataFromTransaction(txTo, 0, txFrom.vout[0]);
|
||||
combined = CombineSignatures(txFrom.vout[0], txTo, scriptSigCopy, scriptSig);
|
||||
BOOST_CHECK(combined.scriptSig == scriptSigCopy.scriptSig || combined.scriptSig == scriptSig.scriptSig);
|
||||
@ -1183,14 +1183,14 @@ BOOST_AUTO_TEST_CASE(script_combineSigs)
|
||||
CScript pkSingle; pkSingle << ToByteVector(keys[0].GetPubKey()) << OP_CHECKSIG;
|
||||
BOOST_CHECK(keystore.AddCScript(pkSingle));
|
||||
scriptPubKey = GetScriptForDestination(CScriptID(pkSingle));
|
||||
BOOST_CHECK(SignSignature(keystore, txFrom, txTo, 0, SIGHASH_ALL));
|
||||
BOOST_CHECK(SignSignature(keystore, CTransaction(txFrom), txTo, 0, SIGHASH_ALL));
|
||||
scriptSig = DataFromTransaction(txTo, 0, txFrom.vout[0]);
|
||||
combined = CombineSignatures(txFrom.vout[0], txTo, scriptSig, empty);
|
||||
BOOST_CHECK(combined.scriptSig == scriptSig.scriptSig);
|
||||
combined = CombineSignatures(txFrom.vout[0], txTo, empty, scriptSig);
|
||||
BOOST_CHECK(combined.scriptSig == scriptSig.scriptSig);
|
||||
scriptSigCopy = scriptSig;
|
||||
BOOST_CHECK(SignSignature(keystore, txFrom, txTo, 0, SIGHASH_ALL));
|
||||
BOOST_CHECK(SignSignature(keystore, CTransaction(txFrom), txTo, 0, SIGHASH_ALL));
|
||||
scriptSig = DataFromTransaction(txTo, 0, txFrom.vout[0]);
|
||||
combined = CombineSignatures(txFrom.vout[0], txTo, scriptSigCopy, scriptSig);
|
||||
BOOST_CHECK(combined.scriptSig == scriptSigCopy.scriptSig || combined.scriptSig == scriptSig.scriptSig);
|
||||
@ -1198,7 +1198,7 @@ BOOST_AUTO_TEST_CASE(script_combineSigs)
|
||||
// Hardest case: Multisig 2-of-3
|
||||
scriptPubKey = GetScriptForMultisig(2, pubkeys);
|
||||
BOOST_CHECK(keystore.AddCScript(scriptPubKey));
|
||||
BOOST_CHECK(SignSignature(keystore, txFrom, txTo, 0, SIGHASH_ALL));
|
||||
BOOST_CHECK(SignSignature(keystore, CTransaction(txFrom), txTo, 0, SIGHASH_ALL));
|
||||
scriptSig = DataFromTransaction(txTo, 0, txFrom.vout[0]);
|
||||
combined = CombineSignatures(txFrom.vout[0], txTo, scriptSig, empty);
|
||||
BOOST_CHECK(combined.scriptSig == scriptSig.scriptSig);
|
||||
|
@ -137,7 +137,7 @@ BOOST_AUTO_TEST_CASE(sighash_test)
|
||||
int nIn = InsecureRandRange(txTo.vin.size());
|
||||
|
||||
uint256 sh, sho;
|
||||
sho = SignatureHashOld(scriptCode, txTo, nIn, nHashType);
|
||||
sho = SignatureHashOld(scriptCode, CTransaction(txTo), nIn, nHashType);
|
||||
sh = SignatureHash(scriptCode, txTo, nIn, nHashType, 0, SigVersion::BASE);
|
||||
#if defined(PRINT_SIGHASH_JSON)
|
||||
CDataStream ss(SER_NETWORK, PROTOCOL_VERSION);
|
||||
|
@ -248,11 +248,11 @@ BOOST_AUTO_TEST_CASE(basic_transaction_tests)
|
||||
CMutableTransaction tx;
|
||||
stream >> tx;
|
||||
CValidationState state;
|
||||
BOOST_CHECK_MESSAGE(CheckTransaction(tx, state) && state.IsValid(), "Simple deserialized transaction should be valid.");
|
||||
BOOST_CHECK_MESSAGE(CheckTransaction(CTransaction(tx), state) && state.IsValid(), "Simple deserialized transaction should be valid.");
|
||||
|
||||
// Check that duplicate txins fail
|
||||
tx.vin.push_back(tx.vin[0]);
|
||||
BOOST_CHECK_MESSAGE(!CheckTransaction(tx, state) || !state.IsValid(), "Transaction with duplicate txins should be invalid.");
|
||||
BOOST_CHECK_MESSAGE(!CheckTransaction(CTransaction(tx), state) || !state.IsValid(), "Transaction with duplicate txins should be invalid.");
|
||||
}
|
||||
|
||||
//
|
||||
@ -281,14 +281,14 @@ SetupDummyInputs(CBasicKeyStore& keystoreRet, CCoinsViewCache& coinsRet)
|
||||
dummyTransactions[0].vout[0].scriptPubKey << ToByteVector(key[0].GetPubKey()) << OP_CHECKSIG;
|
||||
dummyTransactions[0].vout[1].nValue = 50*CENT;
|
||||
dummyTransactions[0].vout[1].scriptPubKey << ToByteVector(key[1].GetPubKey()) << OP_CHECKSIG;
|
||||
AddCoins(coinsRet, dummyTransactions[0], 0);
|
||||
AddCoins(coinsRet, CTransaction(dummyTransactions[0]), 0);
|
||||
|
||||
dummyTransactions[1].vout.resize(2);
|
||||
dummyTransactions[1].vout[0].nValue = 21*CENT;
|
||||
dummyTransactions[1].vout[0].scriptPubKey = GetScriptForDestination(key[2].GetPubKey().GetID());
|
||||
dummyTransactions[1].vout[1].nValue = 22*CENT;
|
||||
dummyTransactions[1].vout[1].scriptPubKey = GetScriptForDestination(key[3].GetPubKey().GetID());
|
||||
AddCoins(coinsRet, dummyTransactions[1], 0);
|
||||
AddCoins(coinsRet, CTransaction(dummyTransactions[1]), 0);
|
||||
|
||||
return dummyTransactions;
|
||||
}
|
||||
@ -315,8 +315,8 @@ BOOST_AUTO_TEST_CASE(test_Get)
|
||||
t1.vout[0].nValue = 90*CENT;
|
||||
t1.vout[0].scriptPubKey << OP_1;
|
||||
|
||||
BOOST_CHECK(AreInputsStandard(t1, coins));
|
||||
BOOST_CHECK_EQUAL(coins.GetValueIn(t1), (50+21+22)*CENT);
|
||||
BOOST_CHECK(AreInputsStandard(CTransaction(t1), coins));
|
||||
BOOST_CHECK_EQUAL(coins.GetValueIn(CTransaction(t1)), (50+21+22)*CENT);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(test_IsStandard)
|
||||
@ -339,17 +339,17 @@ BOOST_AUTO_TEST_CASE(test_IsStandard)
|
||||
t.vout[0].scriptPubKey = GetScriptForDestination(key.GetPubKey().GetID());
|
||||
|
||||
std::string reason;
|
||||
BOOST_CHECK(IsStandardTx(t, reason));
|
||||
BOOST_CHECK(IsStandardTx(CTransaction(t), reason));
|
||||
|
||||
// Check dust with default relay fee:
|
||||
CAmount nDustThreshold = 182 * dustRelayFee.GetFeePerK()/1000;
|
||||
BOOST_CHECK_EQUAL(nDustThreshold, 546);
|
||||
// dust:
|
||||
t.vout[0].nValue = nDustThreshold - 1;
|
||||
BOOST_CHECK(!IsStandardTx(t, reason));
|
||||
BOOST_CHECK(!IsStandardTx(CTransaction(t), reason));
|
||||
// not dust:
|
||||
t.vout[0].nValue = nDustThreshold;
|
||||
BOOST_CHECK(IsStandardTx(t, reason));
|
||||
BOOST_CHECK(IsStandardTx(CTransaction(t), reason));
|
||||
|
||||
// Disallowed nVersion
|
||||
t.nVersion = -1;
|
||||
@ -381,58 +381,58 @@ BOOST_AUTO_TEST_CASE(test_IsStandard)
|
||||
minRelayTxFee = CFeeRate(3702);
|
||||
// dust:
|
||||
t.vout[0].nValue = 546 - 1;
|
||||
BOOST_CHECK(!IsStandardTx(t, reason));
|
||||
BOOST_CHECK(!IsStandardTx(CTransaction(t), reason));
|
||||
// not dust:
|
||||
t.vout[0].nValue = 546;
|
||||
BOOST_CHECK(IsStandardTx(t, reason));
|
||||
BOOST_CHECK(IsStandardTx(CTransaction(t), reason));
|
||||
minRelayTxFee = CFeeRate(DUST_RELAY_TX_FEE);
|
||||
|
||||
t.vout[0].scriptPubKey = CScript() << OP_1;
|
||||
BOOST_CHECK(!IsStandardTx(t, reason));
|
||||
BOOST_CHECK(!IsStandardTx(CTransaction(t), reason));
|
||||
|
||||
// MAX_OP_RETURN_RELAY-byte TX_NULL_DATA (standard)
|
||||
t.vout[0].scriptPubKey = CScript() << OP_RETURN << ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef3804678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38");
|
||||
BOOST_CHECK_EQUAL(MAX_OP_RETURN_RELAY, t.vout[0].scriptPubKey.size());
|
||||
BOOST_CHECK(IsStandardTx(t, reason));
|
||||
BOOST_CHECK(IsStandardTx(CTransaction(t), reason));
|
||||
|
||||
// MAX_OP_RETURN_RELAY+1-byte TX_NULL_DATA (non-standard)
|
||||
t.vout[0].scriptPubKey = CScript() << OP_RETURN << ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef3804678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef3800");
|
||||
BOOST_CHECK_EQUAL(MAX_OP_RETURN_RELAY + 1, t.vout[0].scriptPubKey.size());
|
||||
BOOST_CHECK(!IsStandardTx(t, reason));
|
||||
BOOST_CHECK(!IsStandardTx(CTransaction(t), reason));
|
||||
|
||||
// Data payload can be encoded in any way...
|
||||
t.vout[0].scriptPubKey = CScript() << OP_RETURN << ParseHex("");
|
||||
BOOST_CHECK(IsStandardTx(t, reason));
|
||||
BOOST_CHECK(IsStandardTx(CTransaction(t), reason));
|
||||
t.vout[0].scriptPubKey = CScript() << OP_RETURN << ParseHex("00") << ParseHex("01");
|
||||
BOOST_CHECK(IsStandardTx(t, reason));
|
||||
BOOST_CHECK(IsStandardTx(CTransaction(t), reason));
|
||||
// OP_RESERVED *is* considered to be a PUSHDATA type opcode by IsPushOnly()!
|
||||
t.vout[0].scriptPubKey = CScript() << OP_RETURN << OP_RESERVED << -1 << 0 << ParseHex("01") << 2 << 3 << 4 << 5 << 6 << 7 << 8 << 9 << 10 << 11 << 12 << 13 << 14 << 15 << 16;
|
||||
BOOST_CHECK(IsStandardTx(t, reason));
|
||||
BOOST_CHECK(IsStandardTx(CTransaction(t), reason));
|
||||
t.vout[0].scriptPubKey = CScript() << OP_RETURN << 0 << ParseHex("01") << 2 << ParseHex("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
|
||||
BOOST_CHECK(IsStandardTx(t, reason));
|
||||
BOOST_CHECK(IsStandardTx(CTransaction(t), reason));
|
||||
|
||||
// ...so long as it only contains PUSHDATA's
|
||||
t.vout[0].scriptPubKey = CScript() << OP_RETURN << OP_RETURN;
|
||||
BOOST_CHECK(!IsStandardTx(t, reason));
|
||||
BOOST_CHECK(!IsStandardTx(CTransaction(t), reason));
|
||||
|
||||
// TX_NULL_DATA w/o PUSHDATA
|
||||
t.vout.resize(1);
|
||||
t.vout[0].scriptPubKey = CScript() << OP_RETURN;
|
||||
BOOST_CHECK(IsStandardTx(t, reason));
|
||||
BOOST_CHECK(IsStandardTx(CTransaction(t), reason));
|
||||
|
||||
// Only one TX_NULL_DATA permitted in all cases
|
||||
t.vout.resize(2);
|
||||
t.vout[0].scriptPubKey = CScript() << OP_RETURN << ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38");
|
||||
t.vout[1].scriptPubKey = CScript() << OP_RETURN << ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38");
|
||||
BOOST_CHECK(!IsStandardTx(t, reason));
|
||||
BOOST_CHECK(!IsStandardTx(CTransaction(t), reason));
|
||||
|
||||
t.vout[0].scriptPubKey = CScript() << OP_RETURN << ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38");
|
||||
t.vout[1].scriptPubKey = CScript() << OP_RETURN;
|
||||
BOOST_CHECK(!IsStandardTx(t, reason));
|
||||
BOOST_CHECK(!IsStandardTx(CTransaction(t), reason));
|
||||
|
||||
t.vout[0].scriptPubKey = CScript() << OP_RETURN;
|
||||
t.vout[1].scriptPubKey = CScript() << OP_RETURN;
|
||||
BOOST_CHECK(!IsStandardTx(t, reason));
|
||||
BOOST_CHECK(!IsStandardTx(CTransaction(t), reason));
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_SUITE_END()
|
||||
|
@ -205,20 +205,20 @@ BOOST_FIXTURE_TEST_CASE(checkinputs_test, TestChain100Setup)
|
||||
CValidationState state;
|
||||
PrecomputedTransactionData ptd_spend_tx(spend_tx);
|
||||
|
||||
BOOST_CHECK(!CheckInputs(spend_tx, state, pcoinsTip.get(), true, SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_DERSIG, true, true, ptd_spend_tx, nullptr));
|
||||
BOOST_CHECK(!CheckInputs(CTransaction(spend_tx), state, pcoinsTip.get(), true, SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_DERSIG, true, true, ptd_spend_tx, nullptr));
|
||||
|
||||
// If we call again asking for scriptchecks (as happens in
|
||||
// ConnectBlock), we should add a script check object for this -- we're
|
||||
// not caching invalidity (if that changes, delete this test case).
|
||||
std::vector<CScriptCheck> scriptchecks;
|
||||
BOOST_CHECK(CheckInputs(spend_tx, state, pcoinsTip.get(), true, SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_DERSIG, true, true, ptd_spend_tx, &scriptchecks));
|
||||
BOOST_CHECK(CheckInputs(CTransaction(spend_tx), state, pcoinsTip.get(), true, SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_DERSIG, true, true, ptd_spend_tx, &scriptchecks));
|
||||
BOOST_CHECK_EQUAL(scriptchecks.size(), 1U);
|
||||
|
||||
// Test that CheckInputs returns true iff DERSIG-enforcing flags are
|
||||
// not present. Don't add these checks to the cache, so that we can
|
||||
// test later that block validation works fine in the absence of cached
|
||||
// successes.
|
||||
ValidateCheckInputsForAllFlags(spend_tx, SCRIPT_VERIFY_DERSIG | SCRIPT_VERIFY_LOW_S | SCRIPT_VERIFY_STRICTENC, false);
|
||||
ValidateCheckInputsForAllFlags(CTransaction(spend_tx), SCRIPT_VERIFY_DERSIG | SCRIPT_VERIFY_LOW_S | SCRIPT_VERIFY_STRICTENC, false);
|
||||
}
|
||||
|
||||
// And if we produce a block with this tx, it should be valid (DERSIG not
|
||||
@ -244,7 +244,7 @@ BOOST_FIXTURE_TEST_CASE(checkinputs_test, TestChain100Setup)
|
||||
std::vector<unsigned char> vchSig2(p2pk_scriptPubKey.begin(), p2pk_scriptPubKey.end());
|
||||
invalid_under_p2sh_tx.vin[0].scriptSig << vchSig2;
|
||||
|
||||
ValidateCheckInputsForAllFlags(invalid_under_p2sh_tx, SCRIPT_VERIFY_P2SH, true);
|
||||
ValidateCheckInputsForAllFlags(CTransaction(invalid_under_p2sh_tx), SCRIPT_VERIFY_P2SH, true);
|
||||
}
|
||||
|
||||
// Test CHECKLOCKTIMEVERIFY
|
||||
@ -267,13 +267,13 @@ BOOST_FIXTURE_TEST_CASE(checkinputs_test, TestChain100Setup)
|
||||
vchSig.push_back((unsigned char)SIGHASH_ALL);
|
||||
invalid_with_cltv_tx.vin[0].scriptSig = CScript() << vchSig << 101;
|
||||
|
||||
ValidateCheckInputsForAllFlags(invalid_with_cltv_tx, SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY, true);
|
||||
ValidateCheckInputsForAllFlags(CTransaction(invalid_with_cltv_tx), SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY, true);
|
||||
|
||||
// Make it valid, and check again
|
||||
invalid_with_cltv_tx.vin[0].scriptSig = CScript() << vchSig << 100;
|
||||
CValidationState state;
|
||||
PrecomputedTransactionData txdata(invalid_with_cltv_tx);
|
||||
BOOST_CHECK(CheckInputs(invalid_with_cltv_tx, state, pcoinsTip.get(), true, SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY, true, true, txdata, nullptr));
|
||||
BOOST_CHECK(CheckInputs(CTransaction(invalid_with_cltv_tx), state, pcoinsTip.get(), true, SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY, true, true, txdata, nullptr));
|
||||
}
|
||||
|
||||
// TEST CHECKSEQUENCEVERIFY
|
||||
@ -295,13 +295,13 @@ BOOST_FIXTURE_TEST_CASE(checkinputs_test, TestChain100Setup)
|
||||
vchSig.push_back((unsigned char)SIGHASH_ALL);
|
||||
invalid_with_csv_tx.vin[0].scriptSig = CScript() << vchSig << 101;
|
||||
|
||||
ValidateCheckInputsForAllFlags(invalid_with_csv_tx, SCRIPT_VERIFY_CHECKSEQUENCEVERIFY, true);
|
||||
ValidateCheckInputsForAllFlags(CTransaction(invalid_with_csv_tx), SCRIPT_VERIFY_CHECKSEQUENCEVERIFY, true);
|
||||
|
||||
// Make it valid, and check again
|
||||
invalid_with_csv_tx.vin[0].scriptSig = CScript() << vchSig << 100;
|
||||
CValidationState state;
|
||||
PrecomputedTransactionData txdata(invalid_with_csv_tx);
|
||||
BOOST_CHECK(CheckInputs(invalid_with_csv_tx, state, pcoinsTip.get(), true, SCRIPT_VERIFY_CHECKSEQUENCEVERIFY, true, true, txdata, nullptr));
|
||||
BOOST_CHECK(CheckInputs(CTransaction(invalid_with_csv_tx), state, pcoinsTip.get(), true, SCRIPT_VERIFY_CHECKSEQUENCEVERIFY, true, true, txdata, nullptr));
|
||||
}
|
||||
|
||||
// TODO: add tests for remaining script flags
|
||||
|
@ -3536,7 +3536,7 @@ static UniValue fundrawtransaction(const JSONRPCRequest& request)
|
||||
FundTransaction(pwallet, tx, fee, change_position, request.params[1]);
|
||||
|
||||
UniValue result(UniValue::VOBJ);
|
||||
result.pushKV("hex", EncodeHexTx(tx));
|
||||
result.pushKV("hex", EncodeHexTx(CTransaction(tx)));
|
||||
result.pushKV("fee", ValueFromAmount(fee));
|
||||
result.pushKV("changepos", change_position);
|
||||
|
||||
|
@ -3681,7 +3681,7 @@ bool CWallet::CreateTransaction(const std::vector<CRecipient>& vecSend, CTransac
|
||||
|
||||
auto calculateFee = [&](CAmount& nFee) -> bool {
|
||||
AssertLockHeld(cs_wallet);
|
||||
nBytes = CalculateMaximumSignedTxSize(txNew, this, coin_control.fAllowWatchOnly);
|
||||
nBytes = CalculateMaximumSignedTxSize(CTransaction(txNew), this, coin_control.fAllowWatchOnly);
|
||||
if (nBytes < 0) {
|
||||
strFailReason = _("Signing transaction failed");
|
||||
return false;
|
||||
|
Loading…
Reference in New Issue
Block a user