Merge #14296: [wallet] Remove addwitnessaddress
2b91e42ece[docs] Add release note for removing getwitnessaddress (John Newbery)ebec90ac97[wallet] Remove deprecated addwitnessaddress RPC method (John Newbery)07e3f585ab[test] Remove deprecated addwitnessaddress from feature_segwit.py (John Newbery)82f2fa03a5[test] Remove deprecated addwitnessaddress from wallet_bumpfee.py (John Newbery)9d7ee187a3[test] Remove deprecated addwitnessaddress from p2p_compactblocks.py (John Newbery)3cf77f0b3e[tests] Remove deprecated addwitnessaddress call from wallet_dump.py (John Newbery)bdefc9705d[tests] Remove deprecated addwitnessaddress call from feature_nulldummy (John Newbery)67d7d67cf3[test] Fix flake8 warnings in tests (John Newbery) Pull request description: Fully removes the `addwitnessaddress` RPC method, which was deprecated in V0.17 Tree-SHA512: 8fa8a2a721a81262fbdedbe1cef031e6a07aa6abbc9760dbc62738fc4f688b44bd737d0f3cdb1aec046866a6395befbfecde0f34e76a99e11d3cf566cad1d0de
This commit is contained in:
MarcoFalke
commit
9dda5fdf64
8 changed files with 130 additions and 306 deletions
5
doc/release-notes-14296.md
Normal file
5
doc/release-notes-14296.md
Normal file
|
|
@ -0,0 +1,5 @@
|
|||
addwitnessaddress RPC method removed
|
||||
------------------------------------
|
||||
|
||||
The `addwitnessaddress` RPC was added for segwit testing in version 0.13.0. It
|
||||
was deprecated in version 0.16.0. This version fully removes the RPC method.
|
||||
|
|
@ -147,7 +147,6 @@ static const CRPCConvertParam vRPCConvertParams[] =
|
|||
{ "logging", 0, "include" },
|
||||
{ "logging", 1, "exclude" },
|
||||
{ "disconnectnode", 1, "nodeid" },
|
||||
{ "addwitnessaddress", 1, "p2sh" },
|
||||
// Echo with conversion (For testing only)
|
||||
{ "echojson", 0, "arg0" },
|
||||
{ "echojson", 1, "arg1" },
|
||||
|
|
|
|||
|
|
@ -982,131 +982,6 @@ static UniValue addmultisigaddress(const JSONRPCRequest& request)
|
|||
return result;
|
||||
}
|
||||
|
||||
class Witnessifier : public boost::static_visitor<bool>
|
||||
{
|
||||
public:
|
||||
CWallet * const pwallet;
|
||||
CTxDestination result;
|
||||
bool already_witness;
|
||||
|
||||
explicit Witnessifier(CWallet *_pwallet) : pwallet(_pwallet), already_witness(false) {}
|
||||
|
||||
bool operator()(const CKeyID &keyID) {
|
||||
if (pwallet) {
|
||||
CScript basescript = GetScriptForDestination(keyID);
|
||||
CScript witscript = GetScriptForWitness(basescript);
|
||||
if (!IsSolvable(*pwallet, witscript)) {
|
||||
return false;
|
||||
}
|
||||
return ExtractDestination(witscript, result);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool operator()(const CScriptID &scriptID) {
|
||||
CScript subscript;
|
||||
if (pwallet && pwallet->GetCScript(scriptID, subscript)) {
|
||||
int witnessversion;
|
||||
std::vector<unsigned char> witprog;
|
||||
if (subscript.IsWitnessProgram(witnessversion, witprog)) {
|
||||
ExtractDestination(subscript, result);
|
||||
already_witness = true;
|
||||
return true;
|
||||
}
|
||||
CScript witscript = GetScriptForWitness(subscript);
|
||||
if (!IsSolvable(*pwallet, witscript)) {
|
||||
return false;
|
||||
}
|
||||
return ExtractDestination(witscript, result);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool operator()(const WitnessV0KeyHash& id)
|
||||
{
|
||||
already_witness = true;
|
||||
result = id;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool operator()(const WitnessV0ScriptHash& id)
|
||||
{
|
||||
already_witness = true;
|
||||
result = id;
|
||||
return true;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
bool operator()(const T& dest) { return false; }
|
||||
};
|
||||
|
||||
static UniValue addwitnessaddress(const JSONRPCRequest& request)
|
||||
{
|
||||
std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
|
||||
CWallet* const pwallet = wallet.get();
|
||||
|
||||
if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
|
||||
return NullUniValue;
|
||||
}
|
||||
|
||||
if (request.fHelp || request.params.size() < 1 || request.params.size() > 2)
|
||||
{
|
||||
std::string msg = "addwitnessaddress \"address\" ( p2sh )\n"
|
||||
"\nDEPRECATED: set the address_type argument of getnewaddress, or option -addresstype=[bech32|p2sh-segwit] instead.\n"
|
||||
"Add a witness address for a script (with pubkey or redeemscript known). Requires a new wallet backup.\n"
|
||||
"It returns the witness script.\n"
|
||||
|
||||
"\nArguments:\n"
|
||||
"1. \"address\" (string, required) An address known to the wallet\n"
|
||||
"2. p2sh (bool, optional, default=true) Embed inside P2SH\n"
|
||||
|
||||
"\nResult:\n"
|
||||
"\"witnessaddress\", (string) The value of the new address (P2SH or BIP173).\n"
|
||||
"}\n"
|
||||
;
|
||||
throw std::runtime_error(msg);
|
||||
}
|
||||
|
||||
if (!IsDeprecatedRPCEnabled("addwitnessaddress")) {
|
||||
throw JSONRPCError(RPC_METHOD_DEPRECATED, "addwitnessaddress is deprecated and will be fully removed in v0.17. "
|
||||
"To use addwitnessaddress in v0.16, restart bitcoind with -deprecatedrpc=addwitnessaddress.\n"
|
||||
"Projects should transition to using the address_type argument of getnewaddress, or option -addresstype=[bech32|p2sh-segwit] instead.\n");
|
||||
}
|
||||
|
||||
CTxDestination dest = DecodeDestination(request.params[0].get_str());
|
||||
if (!IsValidDestination(dest)) {
|
||||
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid Bitcoin address");
|
||||
}
|
||||
|
||||
bool p2sh = true;
|
||||
if (!request.params[1].isNull()) {
|
||||
p2sh = request.params[1].get_bool();
|
||||
}
|
||||
|
||||
Witnessifier w(pwallet);
|
||||
bool ret = boost::apply_visitor(w, dest);
|
||||
if (!ret) {
|
||||
throw JSONRPCError(RPC_WALLET_ERROR, "Public key or redeemscript not known to wallet, or the key is uncompressed");
|
||||
}
|
||||
|
||||
CScript witprogram = GetScriptForDestination(w.result);
|
||||
|
||||
if (p2sh) {
|
||||
w.result = CScriptID(witprogram);
|
||||
}
|
||||
|
||||
if (w.already_witness) {
|
||||
if (!(dest == w.result)) {
|
||||
throw JSONRPCError(RPC_WALLET_ERROR, "Cannot convert between witness address types");
|
||||
}
|
||||
} else {
|
||||
pwallet->AddCScript(witprogram); // Implicit for single-key now, but necessary for multisig and for compatibility with older software
|
||||
pwallet->SetAddressBook(w.result, "", "receive");
|
||||
}
|
||||
|
||||
return EncodeDestination(w.result);
|
||||
}
|
||||
|
||||
struct tallyitem
|
||||
{
|
||||
CAmount nAmount;
|
||||
|
|
@ -4097,7 +3972,6 @@ static const CRPCCommand commands[] =
|
|||
{ // category name actor (function) argNames
|
||||
// --------------------- ------------------------ ----------------------- ----------
|
||||
{ "generating", "generate", &generate, {"nblocks","maxtries"} },
|
||||
{ "hidden", "addwitnessaddress", &addwitnessaddress, {"address","p2sh"} },
|
||||
{ "hidden", "resendwallettransactions", &resendwallettransactions, {} },
|
||||
{ "rawtransactions", "fundrawtransaction", &fundrawtransaction, {"hexstring","options","iswitness"} },
|
||||
{ "wallet", "abandontransaction", &abandontransaction, {"txid"} },
|
||||
|
|
|
|||
|
|
@ -12,6 +12,7 @@ Generate 427 more blocks.
|
|||
[Consensus] Check that the new NULLDUMMY rules are not enforced on the 431st block.
|
||||
[Policy/Consensus] Check that the new NULLDUMMY rules are enforced on the 432nd block.
|
||||
"""
|
||||
import time
|
||||
|
||||
from test_framework.blocktools import create_coinbase, create_block, create_transaction, add_witness_commitment
|
||||
from test_framework.messages import CTransaction
|
||||
|
|
@ -19,8 +20,6 @@ from test_framework.script import CScript
|
|||
from test_framework.test_framework import BitcoinTestFramework
|
||||
from test_framework.util import assert_equal, assert_raises_rpc_error, bytes_to_hex_str
|
||||
|
||||
import time
|
||||
|
||||
NULLDUMMY_ERROR = "non-mandatory-script-verify-flag (Dummy CHECKMULTISIG argument must be zero) (code 64)"
|
||||
|
||||
def trueDummy(tx):
|
||||
|
|
@ -42,7 +41,7 @@ class NULLDUMMYTest(BitcoinTestFramework):
|
|||
self.setup_clean_chain = True
|
||||
# This script tests NULLDUMMY activation, which is part of the 'segwit' deployment, so we go through
|
||||
# normal segwit activation here (and don't use the default always-on behaviour).
|
||||
self.extra_args = [['-whitelist=127.0.0.1', '-vbparams=segwit:0:999999999999', '-addresstype=legacy', "-deprecatedrpc=addwitnessaddress"]]
|
||||
self.extra_args = [['-whitelist=127.0.0.1', '-vbparams=segwit:0:999999999999', '-addresstype=legacy']]
|
||||
|
||||
def skip_test_if_missing_module(self):
|
||||
self.skip_if_no_wallet()
|
||||
|
|
@ -50,14 +49,14 @@ class NULLDUMMYTest(BitcoinTestFramework):
|
|||
def run_test(self):
|
||||
self.address = self.nodes[0].getnewaddress()
|
||||
self.ms_address = self.nodes[0].addmultisigaddress(1, [self.address])['address']
|
||||
self.wit_address = self.nodes[0].addwitnessaddress(self.address)
|
||||
self.wit_address = self.nodes[0].getnewaddress(address_type='p2sh-segwit')
|
||||
self.wit_ms_address = self.nodes[0].addmultisigaddress(1, [self.address], '', 'p2sh-segwit')['address']
|
||||
|
||||
self.coinbase_blocks = self.nodes[0].generate(2) # Block 2
|
||||
self.coinbase_blocks = self.nodes[0].generate(2) # Block 2
|
||||
coinbase_txid = []
|
||||
for i in self.coinbase_blocks:
|
||||
coinbase_txid.append(self.nodes[0].getblock(i)['tx'][0])
|
||||
self.nodes[0].generate(427) # Block 429
|
||||
self.nodes[0].generate(427) # Block 429
|
||||
self.lastblockhash = self.nodes[0].getbestblockhash()
|
||||
self.tip = int("0x" + self.lastblockhash, 0)
|
||||
self.lastblockheight = 429
|
||||
|
|
@ -82,7 +81,7 @@ class NULLDUMMYTest(BitcoinTestFramework):
|
|||
|
||||
self.log.info("Test 4: Non-NULLDUMMY base multisig transaction is invalid after activation")
|
||||
test4tx = create_transaction(self.nodes[0], test2tx.hash, self.address, amount=46)
|
||||
test6txs=[CTransaction(test4tx)]
|
||||
test6txs = [CTransaction(test4tx)]
|
||||
trueDummy(test4tx)
|
||||
assert_raises_rpc_error(-26, NULLDUMMY_ERROR, self.nodes[0].sendrawtransaction, bytes_to_hex_str(test4tx.serialize_with_witness()), True)
|
||||
self.block_submit(self.nodes[0], [test4tx])
|
||||
|
|
@ -99,8 +98,7 @@ class NULLDUMMYTest(BitcoinTestFramework):
|
|||
self.nodes[0].sendrawtransaction(bytes_to_hex_str(i.serialize_with_witness()), True)
|
||||
self.block_submit(self.nodes[0], test6txs, True, True)
|
||||
|
||||
|
||||
def block_submit(self, node, txs, witness = False, accept = False):
|
||||
def block_submit(self, node, txs, witness=False, accept=False):
|
||||
block = create_block(self.tip, create_coinbase(self.lastblockheight + 1), self.lastblocktime + 1)
|
||||
block.nVersion = 4
|
||||
for tx in txs:
|
||||
|
|
|
|||
|
|
@ -5,11 +5,10 @@
|
|||
"""Test the SegWit changeover logic."""
|
||||
|
||||
from decimal import Decimal
|
||||
from io import BytesIO
|
||||
|
||||
from test_framework.address import (
|
||||
key_to_p2pkh,
|
||||
key_to_p2sh_p2wpkh,
|
||||
key_to_p2wpkh,
|
||||
program_to_witness,
|
||||
script_to_p2sh,
|
||||
script_to_p2sh_p2wsh,
|
||||
|
|
@ -21,8 +20,6 @@ from test_framework.script import CScript, OP_HASH160, OP_CHECKSIG, OP_0, hash16
|
|||
from test_framework.test_framework import BitcoinTestFramework
|
||||
from test_framework.util import assert_equal, assert_raises_rpc_error, bytes_to_hex_str, connect_nodes, hex_str_to_bytes, sync_blocks, try_rpc
|
||||
|
||||
from io import BytesIO
|
||||
|
||||
NODE_0 = 0
|
||||
NODE_2 = 2
|
||||
WIT_V0 = 0
|
||||
|
|
@ -51,20 +48,17 @@ class SegWitTest(BitcoinTestFramework):
|
|||
"-rpcserialversion=0",
|
||||
"-vbparams=segwit:0:999999999999",
|
||||
"-addresstype=legacy",
|
||||
"-deprecatedrpc=addwitnessaddress",
|
||||
],
|
||||
[
|
||||
"-blockversion=4",
|
||||
"-rpcserialversion=1",
|
||||
"-vbparams=segwit:0:999999999999",
|
||||
"-addresstype=legacy",
|
||||
"-deprecatedrpc=addwitnessaddress",
|
||||
],
|
||||
[
|
||||
"-blockversion=536870915",
|
||||
"-vbparams=segwit:0:999999999999",
|
||||
"-addresstype=legacy",
|
||||
"-deprecatedrpc=addwitnessaddress",
|
||||
],
|
||||
]
|
||||
|
||||
|
|
@ -91,9 +85,8 @@ class SegWitTest(BitcoinTestFramework):
|
|||
def fail_accept(self, node, error_msg, txid, sign, redeem_script=""):
|
||||
assert_raises_rpc_error(-26, error_msg, send_to_witness, use_p2wsh=1, node=node, utxo=getutxo(txid), pubkey=self.pubkey[0], encode_p2sh=False, amount=Decimal("49.998"), sign=sign, insert_redeem_script=redeem_script)
|
||||
|
||||
|
||||
def run_test(self):
|
||||
self.nodes[0].generate(161) #block 161
|
||||
self.nodes[0].generate(161) # block 161
|
||||
|
||||
self.log.info("Verify sigops are counted in GBT with pre-BIP141 rules before the fork")
|
||||
txid = self.nodes[0].sendtoaddress(self.nodes[0].getnewaddress(), 1)
|
||||
|
|
@ -103,28 +96,24 @@ class SegWitTest(BitcoinTestFramework):
|
|||
assert(tmpl['sigoplimit'] == 20000)
|
||||
assert(tmpl['transactions'][0]['hash'] == txid)
|
||||
assert(tmpl['transactions'][0]['sigops'] == 2)
|
||||
tmpl = self.nodes[0].getblocktemplate({'rules':['segwit']})
|
||||
tmpl = self.nodes[0].getblocktemplate({'rules': ['segwit']})
|
||||
assert(tmpl['sizelimit'] == 1000000)
|
||||
assert('weightlimit' not in tmpl)
|
||||
assert(tmpl['sigoplimit'] == 20000)
|
||||
assert(tmpl['transactions'][0]['hash'] == txid)
|
||||
assert(tmpl['transactions'][0]['sigops'] == 2)
|
||||
self.nodes[0].generate(1) #block 162
|
||||
self.nodes[0].generate(1) # block 162
|
||||
|
||||
balance_presetup = self.nodes[0].getbalance()
|
||||
self.pubkey = []
|
||||
p2sh_ids = [] # p2sh_ids[NODE][VER] is an array of txids that spend to a witness version VER pkscript to an address for NODE embedded in p2sh
|
||||
wit_ids = [] # wit_ids[NODE][VER] is an array of txids that spend to a witness version VER pkscript to an address for NODE via bare witness
|
||||
p2sh_ids = [] # p2sh_ids[NODE][VER] is an array of txids that spend to a witness version VER pkscript to an address for NODE embedded in p2sh
|
||||
wit_ids = [] # wit_ids[NODE][VER] is an array of txids that spend to a witness version VER pkscript to an address for NODE via bare witness
|
||||
for i in range(3):
|
||||
newaddress = self.nodes[i].getnewaddress()
|
||||
self.pubkey.append(self.nodes[i].getaddressinfo(newaddress)["pubkey"])
|
||||
multiscript = CScript([OP_1, hex_str_to_bytes(self.pubkey[-1]), OP_1, OP_CHECKMULTISIG])
|
||||
p2sh_addr = self.nodes[i].addwitnessaddress(newaddress)
|
||||
bip173_addr = self.nodes[i].addwitnessaddress(newaddress, False)
|
||||
p2sh_ms_addr = self.nodes[i].addmultisigaddress(1, [self.pubkey[-1]], '', 'p2sh-segwit')['address']
|
||||
bip173_ms_addr = self.nodes[i].addmultisigaddress(1, [self.pubkey[-1]], '', 'bech32')['address']
|
||||
assert_equal(p2sh_addr, key_to_p2sh_p2wpkh(self.pubkey[-1]))
|
||||
assert_equal(bip173_addr, key_to_p2wpkh(self.pubkey[-1]))
|
||||
assert_equal(p2sh_ms_addr, script_to_p2sh_p2wsh(multiscript))
|
||||
assert_equal(bip173_ms_addr, script_to_p2wsh(multiscript))
|
||||
p2sh_ids.append([])
|
||||
|
|
@ -139,32 +128,32 @@ class SegWitTest(BitcoinTestFramework):
|
|||
wit_ids[n][v].append(send_to_witness(v, self.nodes[0], find_spendable_utxo(self.nodes[0], 50), self.pubkey[n], False, Decimal("49.999")))
|
||||
p2sh_ids[n][v].append(send_to_witness(v, self.nodes[0], find_spendable_utxo(self.nodes[0], 50), self.pubkey[n], True, Decimal("49.999")))
|
||||
|
||||
self.nodes[0].generate(1) #block 163
|
||||
self.nodes[0].generate(1) # block 163
|
||||
sync_blocks(self.nodes)
|
||||
|
||||
# Make sure all nodes recognize the transactions as theirs
|
||||
assert_equal(self.nodes[0].getbalance(), balance_presetup - 60*50 + 20*Decimal("49.999") + 50)
|
||||
assert_equal(self.nodes[1].getbalance(), 20*Decimal("49.999"))
|
||||
assert_equal(self.nodes[2].getbalance(), 20*Decimal("49.999"))
|
||||
assert_equal(self.nodes[0].getbalance(), balance_presetup - 60 * 50 + 20 * Decimal("49.999") + 50)
|
||||
assert_equal(self.nodes[1].getbalance(), 20 * Decimal("49.999"))
|
||||
assert_equal(self.nodes[2].getbalance(), 20 * Decimal("49.999"))
|
||||
|
||||
self.nodes[0].generate(260) #block 423
|
||||
self.nodes[0].generate(260) # block 423
|
||||
sync_blocks(self.nodes)
|
||||
|
||||
self.log.info("Verify witness txs are skipped for mining before the fork")
|
||||
self.skip_mine(self.nodes[2], wit_ids[NODE_2][WIT_V0][0], True) #block 424
|
||||
self.skip_mine(self.nodes[2], wit_ids[NODE_2][WIT_V1][0], True) #block 425
|
||||
self.skip_mine(self.nodes[2], p2sh_ids[NODE_2][WIT_V0][0], True) #block 426
|
||||
self.skip_mine(self.nodes[2], p2sh_ids[NODE_2][WIT_V1][0], True) #block 427
|
||||
self.skip_mine(self.nodes[2], wit_ids[NODE_2][WIT_V0][0], True) # block 424
|
||||
self.skip_mine(self.nodes[2], wit_ids[NODE_2][WIT_V1][0], True) # block 425
|
||||
self.skip_mine(self.nodes[2], p2sh_ids[NODE_2][WIT_V0][0], True) # block 426
|
||||
self.skip_mine(self.nodes[2], p2sh_ids[NODE_2][WIT_V1][0], True) # block 427
|
||||
|
||||
self.log.info("Verify unsigned p2sh witness txs without a redeem script are invalid")
|
||||
self.fail_accept(self.nodes[2], "mandatory-script-verify-flag", p2sh_ids[NODE_2][WIT_V0][1], False)
|
||||
self.fail_accept(self.nodes[2], "mandatory-script-verify-flag", p2sh_ids[NODE_2][WIT_V1][1], False)
|
||||
|
||||
self.nodes[2].generate(4) # blocks 428-431
|
||||
self.nodes[2].generate(4) # blocks 428-431
|
||||
|
||||
self.log.info("Verify previous witness txs skipped for mining can now be mined")
|
||||
assert_equal(len(self.nodes[2].getrawmempool()), 4)
|
||||
block = self.nodes[2].generate(1) #block 432 (first block with new rules; 432 = 144 * 3)
|
||||
block = self.nodes[2].generate(1) # block 432 (first block with new rules; 432 = 144 * 3)
|
||||
sync_blocks(self.nodes)
|
||||
assert_equal(len(self.nodes[2].getrawmempool()), 0)
|
||||
segwit_tx_list = self.nodes[2].getblock(block[0])["tx"]
|
||||
|
|
@ -181,8 +170,8 @@ class SegWitTest(BitcoinTestFramework):
|
|||
self.fail_accept(self.nodes[0], "mandatory-script-verify-flag", p2sh_ids[NODE_0][WIT_V1][0], False, witness_script(True, self.pubkey[0]))
|
||||
|
||||
self.log.info("Verify block and transaction serialization rpcs return differing serializations depending on rpc serialization flag")
|
||||
assert(self.nodes[2].getblock(block[0], False) != self.nodes[0].getblock(block[0], False))
|
||||
assert(self.nodes[1].getblock(block[0], False) == self.nodes[2].getblock(block[0], False))
|
||||
assert(self.nodes[2].getblock(block[0], False) != self.nodes[0].getblock(block[0], False))
|
||||
assert(self.nodes[1].getblock(block[0], False) == self.nodes[2].getblock(block[0], False))
|
||||
for i in range(len(segwit_tx_list)):
|
||||
tx = FromHex(CTransaction(), self.nodes[2].gettransaction(segwit_tx_list[i])["hex"])
|
||||
assert(self.nodes[2].getrawtransaction(segwit_tx_list[i]) != self.nodes[0].getrawtransaction(segwit_tx_list[i]))
|
||||
|
|
@ -198,21 +187,21 @@ class SegWitTest(BitcoinTestFramework):
|
|||
self.fail_accept(self.nodes[2], 'non-mandatory-script-verify-flag (Witness program was passed an empty witness) (code 64)', p2sh_ids[NODE_2][WIT_V1][2], sign=False, redeem_script=witness_script(True, self.pubkey[2]))
|
||||
|
||||
self.log.info("Verify default node can now use witness txs")
|
||||
self.success_mine(self.nodes[0], wit_ids[NODE_0][WIT_V0][0], True) #block 432
|
||||
self.success_mine(self.nodes[0], wit_ids[NODE_0][WIT_V1][0], True) #block 433
|
||||
self.success_mine(self.nodes[0], p2sh_ids[NODE_0][WIT_V0][0], True) #block 434
|
||||
self.success_mine(self.nodes[0], p2sh_ids[NODE_0][WIT_V1][0], True) #block 435
|
||||
self.success_mine(self.nodes[0], wit_ids[NODE_0][WIT_V0][0], True) # block 432
|
||||
self.success_mine(self.nodes[0], wit_ids[NODE_0][WIT_V1][0], True) # block 433
|
||||
self.success_mine(self.nodes[0], p2sh_ids[NODE_0][WIT_V0][0], True) # block 434
|
||||
self.success_mine(self.nodes[0], p2sh_ids[NODE_0][WIT_V1][0], True) # block 435
|
||||
|
||||
self.log.info("Verify sigops are counted in GBT with BIP141 rules after the fork")
|
||||
txid = self.nodes[0].sendtoaddress(self.nodes[0].getnewaddress(), 1)
|
||||
tmpl = self.nodes[0].getblocktemplate({'rules':['segwit']})
|
||||
tmpl = self.nodes[0].getblocktemplate({'rules': ['segwit']})
|
||||
assert(tmpl['sizelimit'] >= 3999577) # actual maximum size is lower due to minimum mandatory non-witness data
|
||||
assert(tmpl['weightlimit'] == 4000000)
|
||||
assert(tmpl['sigoplimit'] == 80000)
|
||||
assert(tmpl['transactions'][0]['txid'] == txid)
|
||||
assert(tmpl['transactions'][0]['sigops'] == 8)
|
||||
|
||||
self.nodes[0].generate(1) # Mine a block to clear the gbt cache
|
||||
self.nodes[0].generate(1) # Mine a block to clear the gbt cache
|
||||
|
||||
self.log.info("Non-segwit miners are able to use GBT response after activation.")
|
||||
# Create a 3-tx chain: tx1 (non-segwit input, paying to a segwit output) ->
|
||||
|
|
@ -222,7 +211,7 @@ class SegWitTest(BitcoinTestFramework):
|
|||
txid1 = send_to_witness(1, self.nodes[0], find_spendable_utxo(self.nodes[0], 50), self.pubkey[0], False, Decimal("49.996"))
|
||||
hex_tx = self.nodes[0].gettransaction(txid)['hex']
|
||||
tx = FromHex(CTransaction(), hex_tx)
|
||||
assert(tx.wit.is_null()) # This should not be a segwit input
|
||||
assert(tx.wit.is_null()) # This should not be a segwit input
|
||||
assert(txid1 in self.nodes[0].getrawmempool())
|
||||
|
||||
# Now create tx2, which will spend from txid1.
|
||||
|
|
@ -247,13 +236,13 @@ class SegWitTest(BitcoinTestFramework):
|
|||
template = self.nodes[0].getblocktemplate()
|
||||
|
||||
# Check that tx1 is the only transaction of the 3 in the template.
|
||||
template_txids = [ t['txid'] for t in template['transactions'] ]
|
||||
template_txids = [t['txid'] for t in template['transactions']]
|
||||
assert(txid2 not in template_txids and txid3 not in template_txids)
|
||||
assert(txid1 in template_txids)
|
||||
|
||||
# Check that running with segwit support results in all 3 being included.
|
||||
template = self.nodes[0].getblocktemplate({"rules": ["segwit"]})
|
||||
template_txids = [ t['txid'] for t in template['transactions'] ]
|
||||
template_txids = [t['txid'] for t in template['transactions']]
|
||||
assert(txid1 in template_txids)
|
||||
assert(txid2 in template_txids)
|
||||
assert(txid3 in template_txids)
|
||||
|
|
@ -264,17 +253,17 @@ class SegWitTest(BitcoinTestFramework):
|
|||
# Mine a block to clear the gbt cache again.
|
||||
self.nodes[0].generate(1)
|
||||
|
||||
self.log.info("Verify behaviour of importaddress, addwitnessaddress and listunspent")
|
||||
self.log.info("Verify behaviour of importaddress and listunspent")
|
||||
|
||||
# Some public keys to be used later
|
||||
pubkeys = [
|
||||
"0363D44AABD0F1699138239DF2F042C3282C0671CC7A76826A55C8203D90E39242", # cPiM8Ub4heR9NBYmgVzJQiUH1if44GSBGiqaeJySuL2BKxubvgwb
|
||||
"02D3E626B3E616FC8662B489C123349FECBFC611E778E5BE739B257EAE4721E5BF", # cPpAdHaD6VoYbW78kveN2bsvb45Q7G5PhaPApVUGwvF8VQ9brD97
|
||||
"04A47F2CBCEFFA7B9BCDA184E7D5668D3DA6F9079AD41E422FA5FD7B2D458F2538A62F5BD8EC85C2477F39650BD391EA6250207065B2A81DA8B009FC891E898F0E", # 91zqCU5B9sdWxzMt1ca3VzbtVm2YM6Hi5Rxn4UDtxEaN9C9nzXV
|
||||
"02A47F2CBCEFFA7B9BCDA184E7D5668D3DA6F9079AD41E422FA5FD7B2D458F2538", # cPQFjcVRpAUBG8BA9hzr2yEzHwKoMgLkJZBBtK9vJnvGJgMjzTbd
|
||||
"036722F784214129FEB9E8129D626324F3F6716555B603FFE8300BBCB882151228", # cQGtcm34xiLjB1v7bkRa4V3aAc9tS2UTuBZ1UnZGeSeNy627fN66
|
||||
"0266A8396EE936BF6D99D17920DB21C6C7B1AB14C639D5CD72B300297E416FD2EC", # cTW5mR5M45vHxXkeChZdtSPozrFwFgmEvTNnanCW6wrqwaCZ1X7K
|
||||
"0450A38BD7F0AC212FEBA77354A9B036A32E0F7C81FC4E0C5ADCA7C549C4505D2522458C2D9AE3CEFD684E039194B72C8A10F9CB9D4764AB26FCC2718D421D3B84", # 92h2XPssjBpsJN5CqSP7v9a7cf2kgDunBC6PDFwJHMACM1rrVBJ
|
||||
"0363D44AABD0F1699138239DF2F042C3282C0671CC7A76826A55C8203D90E39242", # cPiM8Ub4heR9NBYmgVzJQiUH1if44GSBGiqaeJySuL2BKxubvgwb
|
||||
"02D3E626B3E616FC8662B489C123349FECBFC611E778E5BE739B257EAE4721E5BF", # cPpAdHaD6VoYbW78kveN2bsvb45Q7G5PhaPApVUGwvF8VQ9brD97
|
||||
"04A47F2CBCEFFA7B9BCDA184E7D5668D3DA6F9079AD41E422FA5FD7B2D458F2538A62F5BD8EC85C2477F39650BD391EA6250207065B2A81DA8B009FC891E898F0E", # 91zqCU5B9sdWxzMt1ca3VzbtVm2YM6Hi5Rxn4UDtxEaN9C9nzXV
|
||||
"02A47F2CBCEFFA7B9BCDA184E7D5668D3DA6F9079AD41E422FA5FD7B2D458F2538", # cPQFjcVRpAUBG8BA9hzr2yEzHwKoMgLkJZBBtK9vJnvGJgMjzTbd
|
||||
"036722F784214129FEB9E8129D626324F3F6716555B603FFE8300BBCB882151228", # cQGtcm34xiLjB1v7bkRa4V3aAc9tS2UTuBZ1UnZGeSeNy627fN66
|
||||
"0266A8396EE936BF6D99D17920DB21C6C7B1AB14C639D5CD72B300297E416FD2EC", # cTW5mR5M45vHxXkeChZdtSPozrFwFgmEvTNnanCW6wrqwaCZ1X7K
|
||||
"0450A38BD7F0AC212FEBA77354A9B036A32E0F7C81FC4E0C5ADCA7C549C4505D2522458C2D9AE3CEFD684E039194B72C8A10F9CB9D4764AB26FCC2718D421D3B84", # 92h2XPssjBpsJN5CqSP7v9a7cf2kgDunBC6PDFwJHMACM1rrVBJ
|
||||
]
|
||||
|
||||
# Import a compressed key and an uncompressed key, generate some multisig addresses
|
||||
|
|
@ -282,8 +271,8 @@ class SegWitTest(BitcoinTestFramework):
|
|||
uncompressed_spendable_address = ["mvozP4UwyGD2mGZU4D2eMvMLPB9WkMmMQu"]
|
||||
self.nodes[0].importprivkey("cNC8eQ5dg3mFAVePDX4ddmPYpPbw41r9bm2jd1nLJT77e6RrzTRR")
|
||||
compressed_spendable_address = ["mmWQubrDomqpgSYekvsU7HWEVjLFHAakLe"]
|
||||
assert ((self.nodes[0].getaddressinfo(uncompressed_spendable_address[0])['iscompressed'] == False))
|
||||
assert ((self.nodes[0].getaddressinfo(compressed_spendable_address[0])['iscompressed'] == True))
|
||||
assert not self.nodes[0].getaddressinfo(uncompressed_spendable_address[0])['iscompressed']
|
||||
assert self.nodes[0].getaddressinfo(compressed_spendable_address[0])['iscompressed']
|
||||
|
||||
self.nodes[0].importpubkey(pubkeys[0])
|
||||
compressed_solvable_address = [key_to_p2pkh(pubkeys[0])]
|
||||
|
|
@ -305,7 +294,6 @@ class SegWitTest(BitcoinTestFramework):
|
|||
uncompressed_solvable_address.append(self.nodes[0].addmultisigaddress(2, [compressed_spendable_address[0], uncompressed_solvable_address[0]])['address'])
|
||||
compressed_solvable_address.append(self.nodes[0].addmultisigaddress(2, [compressed_spendable_address[0], compressed_solvable_address[0]])['address'])
|
||||
compressed_solvable_address.append(self.nodes[0].addmultisigaddress(2, [compressed_solvable_address[0], compressed_solvable_address[1]])['address'])
|
||||
unknown_address = ["mtKKyoHabkk6e4ppT7NaM7THqPUt7AzPrT", "2NDP3jLWAFT8NDAiUa9qiE6oBt2awmMq7Dx"]
|
||||
|
||||
# Test multisig_without_privkey
|
||||
# We have 2 public keys without private keys, use addmultisigaddress to add to wallet.
|
||||
|
|
@ -386,7 +374,6 @@ class SegWitTest(BitcoinTestFramework):
|
|||
op1 = CScript([OP_1])
|
||||
op0 = CScript([OP_0])
|
||||
# 2N7MGY19ti4KDMSzRfPAssP6Pxyuxoi6jLe is the P2SH(P2PKH) version of mjoE3sSrb8ByYEvgnC3Aox86u1CHnfJA4V
|
||||
unsolvable_address = ["mjoE3sSrb8ByYEvgnC3Aox86u1CHnfJA4V", "2N7MGY19ti4KDMSzRfPAssP6Pxyuxoi6jLe", script_to_p2sh(op1), script_to_p2sh(op0)]
|
||||
unsolvable_address_key = hex_str_to_bytes("02341AEC7587A51CDE5279E0630A531AEA2615A9F80B17E8D9376327BAEAA59E3D")
|
||||
unsolvablep2pkh = CScript([OP_DUP, OP_HASH160, hash160(unsolvable_address_key), OP_EQUALVERIFY, OP_CHECKSIG])
|
||||
unsolvablep2wshp2pkh = CScript([OP_0, sha256(unsolvablep2pkh)])
|
||||
|
|
@ -394,9 +381,9 @@ class SegWitTest(BitcoinTestFramework):
|
|||
p2wshop1 = CScript([OP_0, sha256(op1)])
|
||||
unsolvable_after_importaddress.append(unsolvablep2pkh)
|
||||
unsolvable_after_importaddress.append(unsolvablep2wshp2pkh)
|
||||
unsolvable_after_importaddress.append(op1) # OP_1 will be imported as script
|
||||
unsolvable_after_importaddress.append(op1) # OP_1 will be imported as script
|
||||
unsolvable_after_importaddress.append(p2wshop1)
|
||||
unseen_anytime.append(op0) # OP_0 will be imported as P2SH address with no script provided
|
||||
unseen_anytime.append(op0) # OP_0 will be imported as P2SH address with no script provided
|
||||
unsolvable_after_importaddress.append(p2shop0)
|
||||
|
||||
spendable_txid = []
|
||||
|
|
@ -432,27 +419,14 @@ class SegWitTest(BitcoinTestFramework):
|
|||
# exceptions and continue.
|
||||
try_rpc(-4, "The wallet already contains the private key for this address or script", self.nodes[0].importaddress, i, "", False, True)
|
||||
|
||||
self.nodes[0].importaddress(script_to_p2sh(op0)) # import OP_0 as address only
|
||||
self.nodes[0].importaddress(multisig_without_privkey_address) # Test multisig_without_privkey
|
||||
self.nodes[0].importaddress(script_to_p2sh(op0)) # import OP_0 as address only
|
||||
self.nodes[0].importaddress(multisig_without_privkey_address) # Test multisig_without_privkey
|
||||
|
||||
spendable_txid.append(self.mine_and_test_listunspent(spendable_anytime + spendable_after_importaddress, 2))
|
||||
solvable_txid.append(self.mine_and_test_listunspent(solvable_anytime + solvable_after_importaddress, 1))
|
||||
self.mine_and_test_listunspent(unsolvable_after_importaddress, 1)
|
||||
self.mine_and_test_listunspent(unseen_anytime, 0)
|
||||
|
||||
# addwitnessaddress should refuse to return a witness address if an uncompressed key is used
|
||||
# note that no witness address should be returned by unsolvable addresses
|
||||
for i in uncompressed_spendable_address + uncompressed_solvable_address + unknown_address + unsolvable_address:
|
||||
assert_raises_rpc_error(-4, "Public key or redeemscript not known to wallet, or the key is uncompressed", self.nodes[0].addwitnessaddress, i)
|
||||
|
||||
# addwitnessaddress should return a witness addresses even if keys are not in the wallet
|
||||
self.nodes[0].addwitnessaddress(multisig_without_privkey_address)
|
||||
|
||||
for i in compressed_spendable_address + compressed_solvable_address:
|
||||
witaddress = self.nodes[0].addwitnessaddress(i)
|
||||
# addwitnessaddress should return the same address if it is a known P2SH-witness address
|
||||
assert_equal(witaddress, self.nodes[0].addwitnessaddress(witaddress))
|
||||
|
||||
spendable_txid.append(self.mine_and_test_listunspent(spendable_anytime + spendable_after_importaddress, 2))
|
||||
solvable_txid.append(self.mine_and_test_listunspent(solvable_anytime + solvable_after_importaddress, 1))
|
||||
self.mine_and_test_listunspent(unsolvable_after_importaddress, 1)
|
||||
|
|
@ -470,8 +444,6 @@ class SegWitTest(BitcoinTestFramework):
|
|||
self.nodes[0].importpubkey(pubkeys[6])
|
||||
uncompressed_solvable_address = [key_to_p2pkh(pubkeys[6])]
|
||||
|
||||
spendable_after_addwitnessaddress = [] # These outputs should be seen after importaddress
|
||||
solvable_after_addwitnessaddress=[] # These outputs should be seen after importaddress but not spendable
|
||||
unseen_anytime = [] # These outputs should never be seen
|
||||
solvable_anytime = [] # These outputs should be solvable after importpubkey
|
||||
unseen_anytime = [] # These outputs should never be seen
|
||||
|
|
@ -488,8 +460,6 @@ class SegWitTest(BitcoinTestFramework):
|
|||
v = self.nodes[0].getaddressinfo(i)
|
||||
if (v['isscript']):
|
||||
[bare, p2sh, p2wsh, p2sh_p2wsh] = self.p2sh_address_to_script(v)
|
||||
# P2WSH and P2SH(P2WSH) multisig with compressed keys are spendable after addwitnessaddress
|
||||
spendable_after_addwitnessaddress.extend([p2wsh, p2sh_p2wsh])
|
||||
premature_witaddress.append(script_to_p2sh(p2wsh))
|
||||
else:
|
||||
[p2wpkh, p2sh_p2wpkh, p2pk, p2pkh, p2sh_p2pk, p2sh_p2pkh, p2wsh_p2pk, p2wsh_p2pkh, p2sh_p2wsh_p2pk, p2sh_p2wsh_p2pkh] = self.p2pkh_address_to_script(v)
|
||||
|
|
@ -510,9 +480,7 @@ class SegWitTest(BitcoinTestFramework):
|
|||
for i in compressed_solvable_address:
|
||||
v = self.nodes[0].getaddressinfo(i)
|
||||
if (v['isscript']):
|
||||
# P2WSH multisig without private key are seen after addwitnessaddress
|
||||
[bare, p2sh, p2wsh, p2sh_p2wsh] = self.p2sh_address_to_script(v)
|
||||
solvable_after_addwitnessaddress.extend([p2wsh, p2sh_p2wsh])
|
||||
premature_witaddress.append(script_to_p2sh(p2wsh))
|
||||
else:
|
||||
[p2wpkh, p2sh_p2wpkh, p2pk, p2pkh, p2sh_p2pk, p2sh_p2pkh, p2wsh_p2pk, p2wsh_p2pkh, p2sh_p2wsh_p2pk, p2sh_p2wsh_p2pkh] = self.p2pkh_address_to_script(v)
|
||||
|
|
@ -521,29 +489,11 @@ class SegWitTest(BitcoinTestFramework):
|
|||
|
||||
self.mine_and_test_listunspent(spendable_anytime, 2)
|
||||
self.mine_and_test_listunspent(solvable_anytime, 1)
|
||||
self.mine_and_test_listunspent(spendable_after_addwitnessaddress + solvable_after_addwitnessaddress + unseen_anytime, 0)
|
||||
|
||||
# addwitnessaddress should refuse to return a witness address if an uncompressed key is used
|
||||
# note that a multisig address returned by addmultisigaddress is not solvable until it is added with importaddress
|
||||
# premature_witaddress are not accepted until the script is added with addwitnessaddress first
|
||||
for i in uncompressed_spendable_address + uncompressed_solvable_address + premature_witaddress:
|
||||
# This will raise an exception
|
||||
assert_raises_rpc_error(-4, "Public key or redeemscript not known to wallet, or the key is uncompressed", self.nodes[0].addwitnessaddress, i)
|
||||
|
||||
# after importaddress it should pass addwitnessaddress
|
||||
v = self.nodes[0].getaddressinfo(compressed_solvable_address[1])
|
||||
self.nodes[0].importaddress(v['hex'],"",False,True)
|
||||
for i in compressed_spendable_address + compressed_solvable_address + premature_witaddress:
|
||||
witaddress = self.nodes[0].addwitnessaddress(i)
|
||||
assert_equal(witaddress, self.nodes[0].addwitnessaddress(witaddress))
|
||||
|
||||
spendable_txid.append(self.mine_and_test_listunspent(spendable_after_addwitnessaddress + spendable_anytime, 2))
|
||||
solvable_txid.append(self.mine_and_test_listunspent(solvable_after_addwitnessaddress + solvable_anytime, 1))
|
||||
self.mine_and_test_listunspent(unseen_anytime, 0)
|
||||
|
||||
# Check that createrawtransaction/decoderawtransaction with non-v0 Bech32 works
|
||||
v1_addr = program_to_witness(1, [3,5])
|
||||
v1_tx = self.nodes[0].createrawtransaction([getutxo(spendable_txid[0])],{v1_addr: 1})
|
||||
v1_addr = program_to_witness(1, [3, 5])
|
||||
v1_tx = self.nodes[0].createrawtransaction([getutxo(spendable_txid[0])], {v1_addr: 1})
|
||||
v1_decoded = self.nodes[1].decoderawtransaction(v1_tx)
|
||||
assert_equal(v1_decoded['vout'][0]['scriptPubKey']['addresses'][0], v1_addr)
|
||||
assert_equal(v1_decoded['vout'][0]['scriptPubKey']['hex'], "51020305")
|
||||
|
|
@ -586,7 +536,7 @@ class SegWitTest(BitcoinTestFramework):
|
|||
def mine_and_test_listunspent(self, script_list, ismine):
|
||||
utxo = find_spendable_utxo(self.nodes[0], 50)
|
||||
tx = CTransaction()
|
||||
tx.vin.append(CTxIn(COutPoint(int('0x'+utxo['txid'],0), utxo['vout'])))
|
||||
tx.vin.append(CTxIn(COutPoint(int('0x' + utxo['txid'], 0), utxo['vout'])))
|
||||
for i in script_list:
|
||||
tx.vout.append(CTxOut(10000000, i))
|
||||
tx.rehash()
|
||||
|
|
@ -599,7 +549,7 @@ class SegWitTest(BitcoinTestFramework):
|
|||
for i in self.nodes[0].listunspent():
|
||||
if (i['txid'] == txid):
|
||||
watchcount += 1
|
||||
if (i['spendable'] == True):
|
||||
if i['spendable']:
|
||||
spendcount += 1
|
||||
if (ismine == 2):
|
||||
assert_equal(spendcount, len(script_list))
|
||||
|
|
@ -610,14 +560,14 @@ class SegWitTest(BitcoinTestFramework):
|
|||
assert_equal(watchcount, 0)
|
||||
return txid
|
||||
|
||||
def p2sh_address_to_script(self,v):
|
||||
def p2sh_address_to_script(self, v):
|
||||
bare = CScript(hex_str_to_bytes(v['hex']))
|
||||
p2sh = CScript(hex_str_to_bytes(v['scriptPubKey']))
|
||||
p2wsh = CScript([OP_0, sha256(bare)])
|
||||
p2sh_p2wsh = CScript([OP_HASH160, hash160(p2wsh), OP_EQUAL])
|
||||
return([bare, p2sh, p2wsh, p2sh_p2wsh])
|
||||
|
||||
def p2pkh_address_to_script(self,v):
|
||||
def p2pkh_address_to_script(self, v):
|
||||
pubkey = hex_str_to_bytes(v['pubkey'])
|
||||
p2wpkh = CScript([OP_0, hash160(pubkey)])
|
||||
p2sh_p2wpkh = CScript([OP_HASH160, hash160(p2wpkh), OP_EQUAL])
|
||||
|
|
@ -631,7 +581,7 @@ class SegWitTest(BitcoinTestFramework):
|
|||
p2sh_p2wsh_p2pkh = CScript([OP_HASH160, hash160(p2wsh_p2pkh), OP_EQUAL])
|
||||
return [p2wpkh, p2sh_p2wpkh, p2pk, p2pkh, p2sh_p2pk, p2sh_p2pkh, p2wsh_p2pk, p2wsh_p2pkh, p2sh_p2wsh_p2pk, p2sh_p2wsh_p2pkh]
|
||||
|
||||
def create_and_mine_tx_from_txids(self, txids, success = True):
|
||||
def create_and_mine_tx_from_txids(self, txids, success=True):
|
||||
tx = CTransaction()
|
||||
for i in txids:
|
||||
txtmp = CTransaction()
|
||||
|
|
@ -639,7 +589,7 @@ class SegWitTest(BitcoinTestFramework):
|
|||
f = BytesIO(hex_str_to_bytes(txraw))
|
||||
txtmp.deserialize(f)
|
||||
for j in range(len(txtmp.vout)):
|
||||
tx.vin.append(CTxIn(COutPoint(int('0x'+i,0), j)))
|
||||
tx.vin.append(CTxIn(COutPoint(int('0x' + i, 0), j)))
|
||||
tx.vout.append(CTxOut(0, CScript()))
|
||||
tx.rehash()
|
||||
signresults = self.nodes[0].signrawtransactionwithwallet(bytes_to_hex_str(tx.serialize_without_witness()))['hex']
|
||||
|
|
|
|||
|
|
@ -7,7 +7,6 @@
|
|||
Version 1 compact blocks are pre-segwit (txids)
|
||||
Version 2 compact blocks are post-segwit (wtxids)
|
||||
"""
|
||||
|
||||
from decimal import Decimal
|
||||
import random
|
||||
|
||||
|
|
@ -99,7 +98,7 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
self.num_nodes = 2
|
||||
# This test was written assuming SegWit is activated using BIP9 at height 432 (3x confirmation window).
|
||||
# TODO: Rewrite this test to support SegWit being always active.
|
||||
self.extra_args = [["-vbparams=segwit:0:0"], ["-vbparams=segwit:0:999999999999", "-txindex", "-deprecatedrpc=addwitnessaddress"]]
|
||||
self.extra_args = [["-vbparams=segwit:0:0"], ["-vbparams=segwit:0:999999999999", "-txindex"]]
|
||||
self.utxos = []
|
||||
|
||||
def skip_test_if_missing_module(self):
|
||||
|
|
@ -189,7 +188,7 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
|
||||
# Now try a SENDCMPCT message with too-high version
|
||||
sendcmpct = msg_sendcmpct()
|
||||
sendcmpct.version = preferred_version+1
|
||||
sendcmpct.version = preferred_version + 1
|
||||
sendcmpct.announce = True
|
||||
test_node.send_and_ping(sendcmpct)
|
||||
check_announcement_of_new_block(node, test_node, lambda p: "cmpctblock" not in p.last_message)
|
||||
|
|
@ -220,7 +219,7 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
check_announcement_of_new_block(node, test_node, lambda p: "cmpctblock" in p.last_message)
|
||||
|
||||
# Try one more time, after sending a version-1, announce=false message.
|
||||
sendcmpct.version = preferred_version-1
|
||||
sendcmpct.version = preferred_version - 1
|
||||
sendcmpct.announce = False
|
||||
test_node.send_and_ping(sendcmpct)
|
||||
check_announcement_of_new_block(node, test_node, lambda p: "cmpctblock" in p.last_message)
|
||||
|
|
@ -234,7 +233,7 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
if old_node is not None:
|
||||
# Verify that a peer using an older protocol version can receive
|
||||
# announcements from this node.
|
||||
sendcmpct.version = preferred_version-1
|
||||
sendcmpct.version = preferred_version - 1
|
||||
sendcmpct.announce = True
|
||||
old_node.send_and_ping(sendcmpct)
|
||||
# Header sync
|
||||
|
|
@ -265,9 +264,9 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
if use_witness_address:
|
||||
# Want at least one segwit spend, so move all funds to
|
||||
# a witness address.
|
||||
address = node.addwitnessaddress(address)
|
||||
address = node.getnewaddress(address_type='bech32')
|
||||
value_to_send = node.getbalance()
|
||||
node.sendtoaddress(address, satoshi_round(value_to_send-Decimal(0.1)))
|
||||
node.sendtoaddress(address, satoshi_round(value_to_send - Decimal(0.1)))
|
||||
node.generate(1)
|
||||
|
||||
segwit_tx_generated = False
|
||||
|
|
@ -279,7 +278,7 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
segwit_tx_generated = True
|
||||
|
||||
if use_witness_address:
|
||||
assert(segwit_tx_generated) # check that our test is not broken
|
||||
assert segwit_tx_generated # check that our test is not broken
|
||||
|
||||
# Wait until we've seen the block announcement for the resulting tip
|
||||
tip = int(node.getbestblockhash(), 16)
|
||||
|
|
@ -403,8 +402,7 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
coinbase_hash = block.vtx[0].sha256
|
||||
if version == 2:
|
||||
coinbase_hash = block.vtx[0].calc_sha256(True)
|
||||
comp_block.shortids = [
|
||||
calculate_shortid(k0, k1, coinbase_hash) ]
|
||||
comp_block.shortids = [calculate_shortid(k0, k1, coinbase_hash)]
|
||||
test_node.send_and_ping(msg_cmpctblock(comp_block.to_p2p()))
|
||||
assert_equal(int(node.getbestblockhash(), 16), block.hashPrevBlock)
|
||||
# Expect a getblocktxn message.
|
||||
|
|
@ -443,7 +441,7 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
# node needs, and that responding to them causes the block to be
|
||||
# reconstructed.
|
||||
def test_getblocktxn_requests(self, node, test_node, version):
|
||||
with_witness = (version==2)
|
||||
with_witness = (version == 2)
|
||||
|
||||
def test_getblocktxn_response(compact_block, peer, expected_result):
|
||||
msg = msg_cmpctblock(compact_block.to_p2p())
|
||||
|
|
@ -470,7 +468,7 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
|
||||
msg_bt = msg_blocktxn()
|
||||
if with_witness:
|
||||
msg_bt = msg_witness_blocktxn() # serialize with witnesses
|
||||
msg_bt = msg_witness_blocktxn() # serialize with witnesses
|
||||
msg_bt.block_transactions = BlockTransactions(block.sha256, block.vtx[1:])
|
||||
test_tip_after_message(node, test_node, msg_bt, block.sha256)
|
||||
|
||||
|
|
@ -560,7 +558,7 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
# verifying that the block isn't marked bad permanently. This is good
|
||||
# enough for now.
|
||||
msg = msg_blocktxn()
|
||||
if version==2:
|
||||
if version == 2:
|
||||
msg = msg_witness_blocktxn()
|
||||
msg.block_transactions = BlockTransactions(block.sha256, [block.vtx[5]] + block.vtx[7:])
|
||||
test_node.send_and_ping(msg)
|
||||
|
|
@ -571,11 +569,11 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
# We should receive a getdata request
|
||||
wait_until(lambda: "getdata" in test_node.last_message, timeout=10, lock=mininode_lock)
|
||||
assert_equal(len(test_node.last_message["getdata"].inv), 1)
|
||||
assert(test_node.last_message["getdata"].inv[0].type == 2 or test_node.last_message["getdata"].inv[0].type == 2|MSG_WITNESS_FLAG)
|
||||
assert(test_node.last_message["getdata"].inv[0].type == 2 or test_node.last_message["getdata"].inv[0].type == 2 | MSG_WITNESS_FLAG)
|
||||
assert_equal(test_node.last_message["getdata"].inv[0].hash, block.sha256)
|
||||
|
||||
# Deliver the block
|
||||
if version==2:
|
||||
if version == 2:
|
||||
test_node.send_and_ping(msg_witness_block(block))
|
||||
else:
|
||||
test_node.send_and_ping(msg_block(block))
|
||||
|
|
@ -655,7 +653,7 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
|
||||
# Generate an old compactblock, and verify that it's not accepted.
|
||||
cur_height = node.getblockcount()
|
||||
hashPrevBlock = int(node.getblockhash(cur_height-5), 16)
|
||||
hashPrevBlock = int(node.getblockhash(cur_height - 5), 16)
|
||||
block = self.build_block_on_tip(node)
|
||||
block.hashPrevBlock = hashPrevBlock
|
||||
block.solve()
|
||||
|
|
@ -684,7 +682,7 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
assert "blocktxn" not in test_node.last_message
|
||||
|
||||
def activate_segwit(self, node):
|
||||
node.generate(144*3)
|
||||
node.generate(144 * 3)
|
||||
assert_equal(get_bip9_status(node, "segwit")["status"], 'active')
|
||||
|
||||
def test_end_to_end_block_relay(self, node, listeners):
|
||||
|
|
@ -780,7 +778,7 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
delivery_peer.send_message(msg_tx(tx))
|
||||
delivery_peer.sync_with_ping()
|
||||
|
||||
cmpct_block.prefilled_txn[0].tx.wit.vtxinwit = [ CTxInWitness() ]
|
||||
cmpct_block.prefilled_txn[0].tx.wit.vtxinwit = [CTxInWitness()]
|
||||
cmpct_block.prefilled_txn[0].tx.wit.vtxinwit[0].scriptWitness.stack = [ser_uint256(0)]
|
||||
|
||||
cmpct_block.use_witness = True
|
||||
|
|
@ -886,7 +884,7 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
self.log.info("Syncing nodes...")
|
||||
assert(self.nodes[0].getbestblockhash() != self.nodes[1].getbestblockhash())
|
||||
while (self.nodes[0].getblockcount() > self.nodes[1].getblockcount()):
|
||||
block_hash = self.nodes[0].getblockhash(self.nodes[1].getblockcount()+1)
|
||||
block_hash = self.nodes[0].getblockhash(self.nodes[1].getblockcount() + 1)
|
||||
self.nodes[1].submitblock(self.nodes[0].getblock(block_hash, False))
|
||||
assert_equal(self.nodes[0].getbestblockhash(), self.nodes[1].getbestblockhash())
|
||||
|
||||
|
|
|
|||
|
|
@ -13,26 +13,22 @@ can be disabled or reordered if needed for debugging. If new test cases are
|
|||
added in the future, they should try to follow the same convention and not
|
||||
make assumptions about execution order.
|
||||
"""
|
||||
|
||||
from decimal import Decimal
|
||||
import io
|
||||
|
||||
from test_framework.blocktools import add_witness_commitment, create_block, create_coinbase, send_to_witness
|
||||
from test_framework.messages import BIP125_SEQUENCE_NUMBER, CTransaction
|
||||
from test_framework.test_framework import BitcoinTestFramework
|
||||
from test_framework.util import assert_equal, assert_greater_than, assert_raises_rpc_error, bytes_to_hex_str, connect_nodes_bi, hex_str_to_bytes, sync_mempools
|
||||
|
||||
import io
|
||||
|
||||
WALLET_PASSPHRASE = "test"
|
||||
WALLET_PASSPHRASE_TIMEOUT = 3600
|
||||
|
||||
|
||||
class BumpFeeTest(BitcoinTestFramework):
|
||||
def set_test_params(self):
|
||||
self.num_nodes = 2
|
||||
self.setup_clean_chain = True
|
||||
self.extra_args = [[
|
||||
"-deprecatedrpc=addwitnessaddress",
|
||||
"-walletrbf={}".format(i),
|
||||
"-mintxfee=0.00002",
|
||||
] for i in range(self.num_nodes)]
|
||||
|
|
@ -107,8 +103,7 @@ def test_segwit_bumpfee_succeeds(rbf_node, dest_address):
|
|||
# which spends it, and make sure bumpfee can be called on it.
|
||||
|
||||
segwit_in = next(u for u in rbf_node.listunspent() if u["amount"] == Decimal("0.001"))
|
||||
segwit_out = rbf_node.getaddressinfo(rbf_node.getnewaddress())
|
||||
rbf_node.addwitnessaddress(segwit_out["address"])
|
||||
segwit_out = rbf_node.getaddressinfo(rbf_node.getnewaddress(address_type='p2sh-segwit'))
|
||||
segwitid = send_to_witness(
|
||||
use_p2wsh=False,
|
||||
node=rbf_node,
|
||||
|
|
@ -157,7 +152,7 @@ def test_notmine_bumpfee_fails(rbf_node, peer_node, dest_address):
|
|||
signedtx = peer_node.signrawtransactionwithwallet(signedtx["hex"])
|
||||
rbfid = rbf_node.sendrawtransaction(signedtx["hex"])
|
||||
assert_raises_rpc_error(-4, "Transaction contains inputs that don't belong to this wallet",
|
||||
rbf_node.bumpfee, rbfid)
|
||||
rbf_node.bumpfee, rbfid)
|
||||
|
||||
|
||||
def test_bumpfee_with_descendant_fails(rbf_node, rbf_node_address, dest_address):
|
||||
|
|
@ -187,11 +182,11 @@ def test_dust_to_fee(rbf_node, dest_address):
|
|||
# (32-byte p2sh-pwpkh output size + 148 p2pkh spend estimate) * 10k(discard_rate) / 1000 = 1800
|
||||
# P2SH outputs are slightly "over-discarding" due to the IsDust calculation assuming it will
|
||||
# be spent as a P2PKH.
|
||||
bumped_tx = rbf_node.bumpfee(rbfid, {"totalFee": 50000-1800})
|
||||
bumped_tx = rbf_node.bumpfee(rbfid, {"totalFee": 50000 - 1800})
|
||||
full_bumped_tx = rbf_node.getrawtransaction(bumped_tx["txid"], 1)
|
||||
assert_equal(bumped_tx["fee"], Decimal("0.00050000"))
|
||||
assert_equal(len(fulltx["vout"]), 2)
|
||||
assert_equal(len(full_bumped_tx["vout"]), 1) #change output is eliminated
|
||||
assert_equal(len(full_bumped_tx["vout"]), 1) # change output is eliminated
|
||||
|
||||
|
||||
def test_settxfee(rbf_node, dest_address):
|
||||
|
|
@ -222,7 +217,7 @@ def test_rebumping_not_replaceable(rbf_node, dest_address):
|
|||
rbfid = spend_one_input(rbf_node, dest_address)
|
||||
bumped = rbf_node.bumpfee(rbfid, {"totalFee": 10000, "replaceable": False})
|
||||
assert_raises_rpc_error(-4, "Transaction is not BIP 125 replaceable", rbf_node.bumpfee, bumped["txid"],
|
||||
{"totalFee": 20000})
|
||||
{"totalFee": 20000})
|
||||
|
||||
|
||||
def test_unconfirmed_not_spendable(rbf_node, rbf_node_address):
|
||||
|
|
@ -276,7 +271,7 @@ def test_locked_wallet_fails(rbf_node, dest_address):
|
|||
rbfid = spend_one_input(rbf_node, dest_address)
|
||||
rbf_node.walletlock()
|
||||
assert_raises_rpc_error(-13, "Please enter the wallet passphrase with walletpassphrase first.",
|
||||
rbf_node.bumpfee, rbfid)
|
||||
rbf_node.bumpfee, rbfid)
|
||||
|
||||
|
||||
def spend_one_input(node, dest_address):
|
||||
|
|
|
|||
|
|
@ -3,7 +3,6 @@
|
|||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Test the dumpwallet RPC."""
|
||||
|
||||
import os
|
||||
|
||||
from test_framework.test_framework import BitcoinTestFramework
|
||||
|
|
@ -19,11 +18,12 @@ def read_dump(file_name, addrs, script_addrs, hd_master_addr_old):
|
|||
Also check that the old hd_master is inactive
|
||||
"""
|
||||
with open(file_name, encoding='utf8') as inputfile:
|
||||
found_addr = 0
|
||||
found_legacy_addr = 0
|
||||
found_p2sh_segwit_addr = 0
|
||||
found_bech32_addr = 0
|
||||
found_script_addr = 0
|
||||
found_addr_chg = 0
|
||||
found_addr_rsv = 0
|
||||
witness_addr_ret = None
|
||||
hd_master_addr_ret = None
|
||||
for line in inputfile:
|
||||
# only read non comment lines
|
||||
|
|
@ -60,14 +60,14 @@ def read_dump(file_name, addrs, script_addrs, hd_master_addr_old):
|
|||
# count key types
|
||||
for addrObj in addrs:
|
||||
if addrObj['address'] == addr.split(",")[0] and addrObj['hdkeypath'] == keypath and keytype == "label=":
|
||||
# a labeled entry in the wallet should contain both a native address
|
||||
# and the p2sh-p2wpkh address that was added at wallet setup
|
||||
if len(addr.split(",")) == 2:
|
||||
addr_list = addr.split(",")
|
||||
# the entry should be of the first key in the wallet
|
||||
assert_equal(addrs[0]['address'], addr_list[0])
|
||||
witness_addr_ret = addr_list[1]
|
||||
found_addr += 1
|
||||
if addr.startswith('m') or addr.startswith('n'):
|
||||
# P2PKH address
|
||||
found_legacy_addr += 1
|
||||
elif addr.startswith('2'):
|
||||
# P2SH-segwit address
|
||||
found_p2sh_segwit_addr += 1
|
||||
elif addr.startswith('bcrt1'):
|
||||
found_bech32_addr += 1
|
||||
break
|
||||
elif keytype == "change=1":
|
||||
found_addr_chg += 1
|
||||
|
|
@ -82,13 +82,13 @@ def read_dump(file_name, addrs, script_addrs, hd_master_addr_old):
|
|||
found_script_addr += 1
|
||||
break
|
||||
|
||||
return found_addr, found_script_addr, found_addr_chg, found_addr_rsv, hd_master_addr_ret, witness_addr_ret
|
||||
return found_legacy_addr, found_p2sh_segwit_addr, found_bech32_addr, found_script_addr, found_addr_chg, found_addr_rsv, hd_master_addr_ret
|
||||
|
||||
|
||||
class WalletDumpTest(BitcoinTestFramework):
|
||||
def set_test_params(self):
|
||||
self.num_nodes = 1
|
||||
self.extra_args = [["-keypool=90", "-addresstype=legacy", "-deprecatedrpc=addwitnessaddress"]]
|
||||
self.extra_args = [["-keypool=90", "-addresstype=legacy"]]
|
||||
self.rpc_timeout = 120
|
||||
|
||||
def skip_test_if_missing_module(self):
|
||||
|
|
@ -102,49 +102,54 @@ class WalletDumpTest(BitcoinTestFramework):
|
|||
wallet_unenc_dump = os.path.join(self.nodes[0].datadir, "wallet.unencrypted.dump")
|
||||
wallet_enc_dump = os.path.join(self.nodes[0].datadir, "wallet.encrypted.dump")
|
||||
|
||||
# generate 20 addresses to compare against the dump
|
||||
# but since we add a p2sh-p2wpkh address for the first pubkey in the
|
||||
# wallet, we will expect 21 addresses in the dump
|
||||
test_addr_count = 20
|
||||
# generate 30 addresses to compare against the dump
|
||||
# - 10 legacy P2PKH
|
||||
# - 10 P2SH-segwit
|
||||
# - 10 bech32
|
||||
test_addr_count = 10
|
||||
addrs = []
|
||||
for i in range(0,test_addr_count):
|
||||
addr = self.nodes[0].getnewaddress()
|
||||
vaddr= self.nodes[0].getaddressinfo(addr) #required to get hd keypath
|
||||
addrs.append(vaddr)
|
||||
# Should be a no-op:
|
||||
self.nodes[0].keypoolrefill()
|
||||
for address_type in ['legacy', 'p2sh-segwit', 'bech32']:
|
||||
for i in range(0, test_addr_count):
|
||||
addr = self.nodes[0].getnewaddress(address_type=address_type)
|
||||
vaddr = self.nodes[0].getaddressinfo(addr) # required to get hd keypath
|
||||
addrs.append(vaddr)
|
||||
|
||||
# Test scripts dump by adding a P2SH witness and a 1-of-1 multisig address
|
||||
witness_addr = self.nodes[0].addwitnessaddress(addrs[0]["address"], True)
|
||||
# Test scripts dump by adding a 1-of-1 multisig address
|
||||
multisig_addr = self.nodes[0].addmultisigaddress(1, [addrs[1]["address"]])["address"]
|
||||
script_addrs = [witness_addr, multisig_addr]
|
||||
|
||||
# Refill the keypool. getnewaddress() refills the keypool *before* taking a key from
|
||||
# the keypool, so the final call to getnewaddress leaves the keypool with one key below
|
||||
# its capacity
|
||||
self.nodes[0].keypoolrefill()
|
||||
|
||||
# dump unencrypted wallet
|
||||
result = self.nodes[0].dumpwallet(wallet_unenc_dump)
|
||||
assert_equal(result['filename'], wallet_unenc_dump)
|
||||
|
||||
found_addr, found_script_addr, found_addr_chg, found_addr_rsv, hd_master_addr_unenc, witness_addr_ret = \
|
||||
read_dump(wallet_unenc_dump, addrs, script_addrs, None)
|
||||
assert_equal(found_addr, test_addr_count) # all keys must be in the dump
|
||||
assert_equal(found_script_addr, 2) # all scripts must be in the dump
|
||||
found_legacy_addr, found_p2sh_segwit_addr, found_bech32_addr, found_script_addr, found_addr_chg, found_addr_rsv, hd_master_addr_unenc = \
|
||||
read_dump(wallet_unenc_dump, addrs, [multisig_addr], None)
|
||||
assert_equal(found_legacy_addr, test_addr_count) # all keys must be in the dump
|
||||
assert_equal(found_p2sh_segwit_addr, test_addr_count) # all keys must be in the dump
|
||||
assert_equal(found_bech32_addr, test_addr_count) # all keys must be in the dump
|
||||
assert_equal(found_script_addr, 1) # all scripts must be in the dump
|
||||
assert_equal(found_addr_chg, 0) # 0 blocks where mined
|
||||
assert_equal(found_addr_rsv, 90 * 2) # 90 keys plus 100% internal keys
|
||||
assert_equal(witness_addr_ret, witness_addr) # p2sh-p2wsh address added to the first key
|
||||
|
||||
#encrypt wallet, restart, unlock and dump
|
||||
# encrypt wallet, restart, unlock and dump
|
||||
self.nodes[0].encryptwallet('test')
|
||||
self.nodes[0].walletpassphrase('test', 10)
|
||||
# Should be a no-op:
|
||||
self.nodes[0].keypoolrefill()
|
||||
self.nodes[0].dumpwallet(wallet_enc_dump)
|
||||
|
||||
found_addr, found_script_addr, found_addr_chg, found_addr_rsv, _, witness_addr_ret = \
|
||||
read_dump(wallet_enc_dump, addrs, script_addrs, hd_master_addr_unenc)
|
||||
assert_equal(found_addr, test_addr_count)
|
||||
assert_equal(found_script_addr, 2)
|
||||
found_legacy_addr, found_p2sh_segwit_addr, found_bech32_addr, found_script_addr, found_addr_chg, found_addr_rsv, _ = \
|
||||
read_dump(wallet_enc_dump, addrs, [multisig_addr], hd_master_addr_unenc)
|
||||
assert_equal(found_legacy_addr, test_addr_count) # all keys must be in the dump
|
||||
assert_equal(found_p2sh_segwit_addr, test_addr_count) # all keys must be in the dump
|
||||
assert_equal(found_bech32_addr, test_addr_count) # all keys must be in the dump
|
||||
assert_equal(found_script_addr, 1)
|
||||
assert_equal(found_addr_chg, 90 * 2) # old reserve keys are marked as change now
|
||||
assert_equal(found_addr_rsv, 90 * 2)
|
||||
assert_equal(witness_addr_ret, witness_addr)
|
||||
|
||||
# Overwriting should fail
|
||||
assert_raises_rpc_error(-8, "already exists", lambda: self.nodes[0].dumpwallet(wallet_enc_dump))
|
||||
|
|
@ -155,13 +160,13 @@ class WalletDumpTest(BitcoinTestFramework):
|
|||
|
||||
# Make sure the address is not IsMine before import
|
||||
result = self.nodes[0].getaddressinfo(multisig_addr)
|
||||
assert(result['ismine'] == False)
|
||||
assert not result['ismine']
|
||||
|
||||
self.nodes[0].importwallet(wallet_unenc_dump)
|
||||
|
||||
# Now check IsMine is true
|
||||
result = self.nodes[0].getaddressinfo(multisig_addr)
|
||||
assert(result['ismine'] == True)
|
||||
assert result['ismine']
|
||||
|
||||
if __name__ == '__main__':
|
||||
WalletDumpTest().main()
|
||||
|
|
|
|||
Loading…
Reference in a new issue