Merge #14954: build: Require python 3.5
fa2797808e
test: Remove python3.4 workaround in feature_dbcrash (MarcoFalke)dddd1d05d3
.python-version: Specify full version 3.5.6 (MarcoFalke)faa7cdf764
scripted-diff: Update copyright in ./test (MarcoFalke)fa0e65b772
scripted-diff: test: Remove brackets after assert (MarcoFalke)fab5a1e0f4
build: Require python 3.5 (MarcoFalke)fa6bf21f5e
scripted-diff: test: Use py3.5 bytes::hex() method (MarcoFalke) Pull request description: Python 3.4 is EOL after March 2019, so switch to 3.5. See https://devguide.python.org/#status-of-python-branches This pull does the following in a bunch of commits: * scripted diff to use the `bytes::hex()` method in place of previous wrappers (`b2x`, `bytes_to_hex_str`, `hexlify`, ...) * Update the build system (gitian and travis) to remove python2.7 and replace it with python3.5 * Another scripted-diff to remove brackets after `assert`. This is unrelated to the python3.5 switch, but a stylistic commit, so probably not worth to split up. The motivation behind it is to avoid asserting on data structures (such as tuples of length one), which never fails: ```py >>> assert(False,) # with brackets >>> assert False, # without brackets SyntaxError: invalid syntax >>> assert False # proper assertion AssertionError ``` * And then a final scripted diff to update the copyright headers in the `test` subfolder, since I touched most of the files anyway and it wouldn't make sense to split this commit out into a separate pull. For reference (contributed by luke-jr): Ubuntu LTS (bionic): 3.6.5 Debian stable (stretch): 3.5.3 RHEL 8 (expected before v0.19): 3.6.x Gentoo stable: 3.6.5 Arch: 3.7.1 Tree-SHA512: 643c28cd2d5b9543ce4bf8ad2a8b282bc79b37dc5b25c9c8358e6ce201e2a67a546463e5f3430b16652eb2489d7c3ed4b0772cd2e2bf790fe68a5e3cc8a25029
This commit is contained in:
commit
a74d588f21
88 changed files with 492 additions and 621 deletions
|
@ -1 +1 @@
|
|||
3.4.9
|
||||
3.5.6
|
||||
|
|
|
@ -46,7 +46,7 @@ jobs:
|
|||
env:
|
||||
cache: false
|
||||
language: python
|
||||
python: '3.4' # Oldest supported version according to doc/dependencies.md
|
||||
python: '3.5' # Oldest supported version according to doc/dependencies.md
|
||||
install:
|
||||
- set -o errexit; source .travis/lint_04_install.sh
|
||||
before_script:
|
||||
|
@ -158,7 +158,7 @@ jobs:
|
|||
name: 'macOS 10.10 [GOAL: deploy] [no functional tests]'
|
||||
env: >-
|
||||
HOST=x86_64-apple-darwin14
|
||||
PACKAGES="cmake imagemagick libcap-dev librsvg2-bin libz-dev libbz2-dev libtiff-tools python-dev python3-setuptools-git"
|
||||
PACKAGES="cmake imagemagick libcap-dev librsvg2-bin libz-dev libbz2-dev libtiff-tools python3-dev python3-setuptools-git"
|
||||
OSX_SDK=10.11
|
||||
RUN_UNIT_TESTS=false
|
||||
RUN_FUNCTIONAL_TESTS=false
|
||||
|
|
|
@ -85,8 +85,8 @@ AC_PATH_TOOL(RANLIB, ranlib)
|
|||
AC_PATH_TOOL(STRIP, strip)
|
||||
AC_PATH_TOOL(GCOV, gcov)
|
||||
AC_PATH_PROG(LCOV, lcov)
|
||||
dnl Python 3.4 is specified in .python-version and should be used if available, see doc/dependencies.md
|
||||
AC_PATH_PROGS([PYTHON], [python3.4 python3.5 python3.6 python3.7 python3 python])
|
||||
dnl Python 3.5 is specified in .python-version and should be used if available, see doc/dependencies.md
|
||||
AC_PATH_PROGS([PYTHON], [python3.5 python3.6 python3.7 python3.8 python3 python])
|
||||
AC_PATH_PROG(GENHTML, genhtml)
|
||||
AC_PATH_PROG([GIT], [git])
|
||||
AC_PATH_PROG(CCACHE,ccache)
|
||||
|
|
|
@ -167,7 +167,7 @@ still compatible with the minimum supported Linux distribution versions.
|
|||
|
||||
Example usage after a gitian build:
|
||||
|
||||
find ../gitian-builder/build -type f -executable | xargs python contrib/devtools/symbol-check.py
|
||||
find ../gitian-builder/build -type f -executable | xargs python3 contrib/devtools/symbol-check.py
|
||||
|
||||
If only supported symbols are used the return value will be 0 and the output will be empty.
|
||||
|
||||
|
|
|
@ -9,7 +9,7 @@ still compatible with the minimum supported Linux distribution versions.
|
|||
|
||||
Example usage:
|
||||
|
||||
find ../gitian-builder/build -type f -executable | xargs python contrib/devtools/symbol-check.py
|
||||
find ../gitian-builder/build -type f -executable | xargs python3 contrib/devtools/symbol-check.py
|
||||
'''
|
||||
import subprocess
|
||||
import re
|
||||
|
|
|
@ -30,7 +30,7 @@ packages:
|
|||
- "faketime"
|
||||
- "bsdmainutils"
|
||||
- "ca-certificates"
|
||||
- "python"
|
||||
- "python3"
|
||||
remotes:
|
||||
- "url": "https://github.com/bitcoin/bitcoin.git"
|
||||
"dir": "bitcoin"
|
||||
|
|
|
@ -23,9 +23,9 @@ packages:
|
|||
- "libcap-dev"
|
||||
- "libz-dev"
|
||||
- "libbz2-dev"
|
||||
- "python"
|
||||
- "python-dev"
|
||||
- "python-setuptools"
|
||||
- "python3"
|
||||
- "python3-dev"
|
||||
- "python3-setuptools"
|
||||
- "fonts-tuffy"
|
||||
remotes:
|
||||
- "url": "https://github.com/bitcoin/bitcoin.git"
|
||||
|
|
|
@ -20,7 +20,7 @@ packages:
|
|||
- "nsis"
|
||||
- "zip"
|
||||
- "ca-certificates"
|
||||
- "python"
|
||||
- "python3"
|
||||
- "rename"
|
||||
remotes:
|
||||
- "url": "https://github.com/bitcoin/bitcoin.git"
|
||||
|
|
|
@ -1,6 +1,5 @@
|
|||
# Linearize
|
||||
Construct a linear, no-fork, best version of the Bitcoin blockchain. The scripts
|
||||
run using Python 3 but are compatible with Python 2.
|
||||
Construct a linear, no-fork, best version of the Bitcoin blockchain.
|
||||
|
||||
## Step 1: Download hash list
|
||||
|
||||
|
|
|
@ -16,7 +16,7 @@ import hashlib
|
|||
import datetime
|
||||
import time
|
||||
from collections import namedtuple
|
||||
from binascii import hexlify, unhexlify
|
||||
from binascii import unhexlify
|
||||
|
||||
settings = {}
|
||||
|
||||
|
@ -61,7 +61,7 @@ def calc_hash_str(blk_hdr):
|
|||
hash = calc_hdr_hash(blk_hdr)
|
||||
hash = bufreverse(hash)
|
||||
hash = wordreverse(hash)
|
||||
hash_str = hexlify(hash).decode('utf-8')
|
||||
hash_str = hash.hex()
|
||||
return hash_str
|
||||
|
||||
def get_blk_dt(blk_hdr):
|
||||
|
@ -213,7 +213,7 @@ class BlockDataCopier:
|
|||
|
||||
inMagic = inhdr[:4]
|
||||
if (inMagic != self.settings['netmagic']):
|
||||
print("Invalid magic: " + hexlify(inMagic).decode('utf-8'))
|
||||
print("Invalid magic: " + inMagic.hex())
|
||||
return
|
||||
inLenLE = inhdr[4:]
|
||||
su = struct.unpack("<I", inLenLE)
|
||||
|
|
|
@ -1,90 +0,0 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2014-2018 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
|
||||
"""
|
||||
ZMQ example using python3's asyncio
|
||||
|
||||
Bitcoin should be started with the command line arguments:
|
||||
bitcoind -testnet -daemon \
|
||||
-zmqpubrawtx=tcp://127.0.0.1:28332 \
|
||||
-zmqpubrawblock=tcp://127.0.0.1:28332 \
|
||||
-zmqpubhashtx=tcp://127.0.0.1:28332 \
|
||||
-zmqpubhashblock=tcp://127.0.0.1:28332
|
||||
|
||||
We use the asyncio library here. `self.handle()` installs itself as a
|
||||
future at the end of the function. Since it never returns with the event
|
||||
loop having an empty stack of futures, this creates an infinite loop. An
|
||||
alternative is to wrap the contents of `handle` inside `while True`.
|
||||
|
||||
The `@asyncio.coroutine` decorator and the `yield from` syntax found here
|
||||
was introduced in python 3.4 and has been deprecated in favor of the `async`
|
||||
and `await` keywords respectively.
|
||||
|
||||
A blocking example using python 2.7 can be obtained from the git history:
|
||||
https://github.com/bitcoin/bitcoin/blob/37a7fe9e440b83e2364d5498931253937abe9294/contrib/zmq/zmq_sub.py
|
||||
"""
|
||||
|
||||
import binascii
|
||||
import asyncio
|
||||
import zmq
|
||||
import zmq.asyncio
|
||||
import signal
|
||||
import struct
|
||||
import sys
|
||||
|
||||
if (sys.version_info.major, sys.version_info.minor) < (3, 4):
|
||||
print("This example only works with Python 3.4 and greater")
|
||||
sys.exit(1)
|
||||
|
||||
port = 28332
|
||||
|
||||
class ZMQHandler():
|
||||
def __init__(self):
|
||||
self.loop = asyncio.get_event_loop()
|
||||
self.zmqContext = zmq.asyncio.Context()
|
||||
|
||||
self.zmqSubSocket = self.zmqContext.socket(zmq.SUB)
|
||||
self.zmqSubSocket.setsockopt(zmq.RCVHWM, 0)
|
||||
self.zmqSubSocket.setsockopt_string(zmq.SUBSCRIBE, "hashblock")
|
||||
self.zmqSubSocket.setsockopt_string(zmq.SUBSCRIBE, "hashtx")
|
||||
self.zmqSubSocket.setsockopt_string(zmq.SUBSCRIBE, "rawblock")
|
||||
self.zmqSubSocket.setsockopt_string(zmq.SUBSCRIBE, "rawtx")
|
||||
self.zmqSubSocket.connect("tcp://127.0.0.1:%i" % port)
|
||||
|
||||
@asyncio.coroutine
|
||||
def handle(self) :
|
||||
msg = yield from self.zmqSubSocket.recv_multipart()
|
||||
topic = msg[0]
|
||||
body = msg[1]
|
||||
sequence = "Unknown"
|
||||
if len(msg[-1]) == 4:
|
||||
msgSequence = struct.unpack('<I', msg[-1])[-1]
|
||||
sequence = str(msgSequence)
|
||||
if topic == b"hashblock":
|
||||
print('- HASH BLOCK ('+sequence+') -')
|
||||
print(binascii.hexlify(body))
|
||||
elif topic == b"hashtx":
|
||||
print('- HASH TX ('+sequence+') -')
|
||||
print(binascii.hexlify(body))
|
||||
elif topic == b"rawblock":
|
||||
print('- RAW BLOCK HEADER ('+sequence+') -')
|
||||
print(binascii.hexlify(body[:80]))
|
||||
elif topic == b"rawtx":
|
||||
print('- RAW TX ('+sequence+') -')
|
||||
print(binascii.hexlify(body))
|
||||
# schedule ourselves to receive the next message
|
||||
asyncio.ensure_future(self.handle())
|
||||
|
||||
def start(self):
|
||||
self.loop.add_signal_handler(signal.SIGINT, self.stop)
|
||||
self.loop.create_task(self.handle())
|
||||
self.loop.run_forever()
|
||||
|
||||
def stop(self):
|
||||
self.loop.stop()
|
||||
self.zmqContext.destroy()
|
||||
|
||||
daemon = ZMQHandler()
|
||||
daemon.start()
|
|
@ -34,7 +34,7 @@ No other options are needed, the paths are automatically configured.
|
|||
|
||||
#### For macOS cross compilation
|
||||
|
||||
sudo apt-get install curl librsvg2-bin libtiff-tools bsdmainutils cmake imagemagick libcap-dev libz-dev libbz2-dev python-setuptools
|
||||
sudo apt-get install curl librsvg2-bin libtiff-tools bsdmainutils cmake imagemagick libcap-dev libz-dev libbz2-dev python3-setuptools
|
||||
|
||||
#### For Win32/Win64 cross compilation
|
||||
|
||||
|
|
|
@ -22,7 +22,7 @@ These are the dependencies currently used by Bitcoin Core. You can find instruct
|
|||
| OpenSSL | [1.0.1k](https://www.openssl.org/source) | | Yes | | |
|
||||
| PCRE | | | | | [Yes](https://github.com/bitcoin/bitcoin/blob/master/depends/packages/qt.mk#L66) |
|
||||
| protobuf | [2.6.1](https://github.com/google/protobuf/releases) | | No | | |
|
||||
| Python (tests) | | [3.4](https://www.python.org/downloads) | | | |
|
||||
| Python (tests) | | [3.5](https://www.python.org/downloads) | | | |
|
||||
| qrencode | [3.4.4](https://fukuchi.org/works/qrencode) | | No | | |
|
||||
| Qt | [5.9.7](https://download.qt.io/official_releases/qt/) | [5.5.1](https://github.com/bitcoin/bitcoin/issues/13478) | No | | |
|
||||
| XCB | | | | | [Yes](https://github.com/bitcoin/bitcoin/blob/master/depends/packages/qt.mk#L87) (Linux only) |
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2017-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2017-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""An example functional test
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2014-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2014-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Test logic for skipping signature validation on old blocks.
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2014-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2014-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Test BIP68 implementation."""
|
||||
|
@ -10,7 +10,7 @@ from test_framework.blocktools import create_block, create_coinbase, add_witness
|
|||
from test_framework.messages import COIN, COutPoint, CTransaction, CTxIn, CTxOut, FromHex, ToHex
|
||||
from test_framework.script import CScript
|
||||
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, get_bip9_status, satoshi_round, sync_blocks
|
||||
from test_framework.util import assert_equal, assert_greater_than, assert_raises_rpc_error, get_bip9_status, satoshi_round, sync_blocks
|
||||
|
||||
SEQUENCE_LOCKTIME_DISABLE_FLAG = (1<<31)
|
||||
SEQUENCE_LOCKTIME_TYPE_FLAG = (1<<22) # this means use time (0 means height)
|
||||
|
@ -63,7 +63,7 @@ class BIP68Test(BitcoinTestFramework):
|
|||
self.nodes[0].sendtoaddress(new_addr, 2) # send 2 BTC
|
||||
|
||||
utxos = self.nodes[0].listunspent(0, 0)
|
||||
assert(len(utxos) > 0)
|
||||
assert len(utxos) > 0
|
||||
|
||||
utxo = utxos[0]
|
||||
|
||||
|
@ -253,7 +253,7 @@ class BIP68Test(BitcoinTestFramework):
|
|||
self.nodes[0].generate(1)
|
||||
cur_time += 600
|
||||
|
||||
assert(tx2.hash in self.nodes[0].getrawmempool())
|
||||
assert tx2.hash in self.nodes[0].getrawmempool()
|
||||
|
||||
test_nonzero_locks(tx2, self.nodes[0], self.relayfee, use_height_lock=True)
|
||||
test_nonzero_locks(tx2, self.nodes[0], self.relayfee, use_height_lock=False)
|
||||
|
@ -264,23 +264,23 @@ class BIP68Test(BitcoinTestFramework):
|
|||
# Advance the time on the node so that we can test timelocks
|
||||
self.nodes[0].setmocktime(cur_time+600)
|
||||
self.nodes[0].generate(1)
|
||||
assert(tx2.hash not in self.nodes[0].getrawmempool())
|
||||
assert tx2.hash not in self.nodes[0].getrawmempool()
|
||||
|
||||
# Now that tx2 is not in the mempool, a sequence locked spend should
|
||||
# succeed
|
||||
tx3 = test_nonzero_locks(tx2, self.nodes[0], self.relayfee, use_height_lock=False)
|
||||
assert(tx3.hash in self.nodes[0].getrawmempool())
|
||||
assert tx3.hash in self.nodes[0].getrawmempool()
|
||||
|
||||
self.nodes[0].generate(1)
|
||||
assert(tx3.hash not in self.nodes[0].getrawmempool())
|
||||
assert tx3.hash not in self.nodes[0].getrawmempool()
|
||||
|
||||
# One more test, this time using height locks
|
||||
tx4 = test_nonzero_locks(tx3, self.nodes[0], self.relayfee, use_height_lock=True)
|
||||
assert(tx4.hash in self.nodes[0].getrawmempool())
|
||||
assert tx4.hash in self.nodes[0].getrawmempool()
|
||||
|
||||
# Now try combining confirmed and unconfirmed inputs
|
||||
tx5 = test_nonzero_locks(tx4, self.nodes[0], self.relayfee, use_height_lock=True)
|
||||
assert(tx5.hash not in self.nodes[0].getrawmempool())
|
||||
assert tx5.hash not in self.nodes[0].getrawmempool()
|
||||
|
||||
utxos = self.nodes[0].listunspent()
|
||||
tx5.vin.append(CTxIn(COutPoint(int(utxos[0]["txid"], 16), utxos[0]["vout"]), nSequence=1))
|
||||
|
@ -299,8 +299,8 @@ class BIP68Test(BitcoinTestFramework):
|
|||
# If we invalidate the tip, tx3 should get added to the mempool, causing
|
||||
# tx4 to be removed (fails sequence-lock).
|
||||
self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash())
|
||||
assert(tx4.hash not in self.nodes[0].getrawmempool())
|
||||
assert(tx3.hash in self.nodes[0].getrawmempool())
|
||||
assert tx4.hash not in self.nodes[0].getrawmempool()
|
||||
assert tx3.hash in self.nodes[0].getrawmempool()
|
||||
|
||||
# Now mine 2 empty blocks to reorg out the current tip (labeled tip-1 in
|
||||
# diagram above).
|
||||
|
@ -319,8 +319,8 @@ class BIP68Test(BitcoinTestFramework):
|
|||
cur_time += 1
|
||||
|
||||
mempool = self.nodes[0].getrawmempool()
|
||||
assert(tx3.hash not in mempool)
|
||||
assert(tx2.hash in mempool)
|
||||
assert tx3.hash not in mempool
|
||||
assert tx2.hash in mempool
|
||||
|
||||
# Reset the chain and get rid of the mocktimed-blocks
|
||||
self.nodes[0].setmocktime(0)
|
||||
|
@ -332,7 +332,7 @@ class BIP68Test(BitcoinTestFramework):
|
|||
# being run, then it's possible the test has activated the soft fork, and
|
||||
# this test should be moved to run earlier, or deleted.
|
||||
def test_bip68_not_consensus(self):
|
||||
assert(get_bip9_status(self.nodes[0], 'csv')['status'] != 'active')
|
||||
assert get_bip9_status(self.nodes[0], 'csv')['status'] != 'active'
|
||||
txid = self.nodes[0].sendtoaddress(self.nodes[0].getnewaddress(), 2)
|
||||
|
||||
tx1 = FromHex(CTransaction(), self.nodes[0].getrawtransaction(txid))
|
||||
|
@ -372,7 +372,7 @@ class BIP68Test(BitcoinTestFramework):
|
|||
add_witness_commitment(block)
|
||||
block.solve()
|
||||
|
||||
self.nodes[0].submitblock(bytes_to_hex_str(block.serialize(True)))
|
||||
self.nodes[0].submitblock(block.serialize(True).hex())
|
||||
assert_equal(self.nodes[0].getbestblockhash(), block.hash)
|
||||
|
||||
def activateCSV(self):
|
||||
|
|
|
@ -773,7 +773,7 @@ class FullBlockTest(BitcoinTestFramework):
|
|||
self.move_tip(57)
|
||||
b58 = self.next_block(58, spend=out[17])
|
||||
tx = CTransaction()
|
||||
assert(len(out[17].vout) < 42)
|
||||
assert len(out[17].vout) < 42
|
||||
tx.vin.append(CTxIn(COutPoint(out[17].sha256, 42), CScript([OP_TRUE]), 0xffffffff))
|
||||
tx.vout.append(CTxOut(0, b""))
|
||||
tx.calc_sha256()
|
||||
|
@ -824,7 +824,7 @@ class FullBlockTest(BitcoinTestFramework):
|
|||
tx.nLockTime = 0xffffffff # this locktime is non-final
|
||||
tx.vin.append(CTxIn(COutPoint(out[18].sha256, 0))) # don't set nSequence
|
||||
tx.vout.append(CTxOut(0, CScript([OP_TRUE])))
|
||||
assert(tx.vin[0].nSequence < 0xffffffff)
|
||||
assert tx.vin[0].nSequence < 0xffffffff
|
||||
tx.calc_sha256()
|
||||
b62 = self.update_block(62, [tx])
|
||||
self.sync_blocks([b62], success=False, reject_reason='bad-txns-nonfinal')
|
||||
|
@ -1143,8 +1143,8 @@ class FullBlockTest(BitcoinTestFramework):
|
|||
# now check that tx78 and tx79 have been put back into the peer's mempool
|
||||
mempool = self.nodes[0].getrawmempool()
|
||||
assert_equal(len(mempool), 2)
|
||||
assert(tx78.hash in mempool)
|
||||
assert(tx79.hash in mempool)
|
||||
assert tx78.hash in mempool
|
||||
assert tx79.hash in mempool
|
||||
|
||||
# Test invalid opcodes in dead execution paths.
|
||||
#
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2015-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2015-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Test BIP65 (CHECKLOCKTIMEVERIFY).
|
||||
|
@ -15,7 +15,6 @@ from test_framework.script import CScript, OP_1NEGATE, OP_CHECKLOCKTIMEVERIFY, O
|
|||
from test_framework.test_framework import BitcoinTestFramework
|
||||
from test_framework.util import (
|
||||
assert_equal,
|
||||
bytes_to_hex_str,
|
||||
hex_str_to_bytes,
|
||||
)
|
||||
|
||||
|
@ -114,7 +113,7 @@ class BIP65Test(BitcoinTestFramework):
|
|||
# rejected from the mempool for exactly that reason.
|
||||
assert_equal(
|
||||
[{'txid': spendtx.hash, 'allowed': False, 'reject-reason': '64: non-mandatory-script-verify-flag (Negative locktime)'}],
|
||||
self.nodes[0].testmempoolaccept(rawtxs=[bytes_to_hex_str(spendtx.serialize())], allowhighfees=True)
|
||||
self.nodes[0].testmempoolaccept(rawtxs=[spendtx.serialize().hex()], allowhighfees=True)
|
||||
)
|
||||
|
||||
# Now we verify that a block with this transaction is also invalid.
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2017-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2017-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Test various command line arguments and configuration file parameters."""
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2015-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2015-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Test activation of the first version bits soft fork.
|
||||
|
@ -106,7 +106,7 @@ def send_generic_input_tx(node, coinbases, address):
|
|||
def create_bip68txs(node, bip68inputs, txversion, address, locktime_delta=0):
|
||||
"""Returns a list of bip68 transactions with different bits set."""
|
||||
txs = []
|
||||
assert(len(bip68inputs) >= 16)
|
||||
assert len(bip68inputs) >= 16
|
||||
for i, (sdf, srhb, stf, srlb) in enumerate(product(*[[True, False]] * 4)):
|
||||
locktime = relative_locktime(sdf, srhb, stf, srlb)
|
||||
tx = create_transaction(node, bip68inputs[i], address, amount=Decimal("49.98"))
|
||||
|
@ -121,7 +121,7 @@ def create_bip68txs(node, bip68inputs, txversion, address, locktime_delta=0):
|
|||
def create_bip112txs(node, bip112inputs, varyOP_CSV, txversion, address, locktime_delta=0):
|
||||
"""Returns a list of bip68 transactions with different bits set."""
|
||||
txs = []
|
||||
assert(len(bip112inputs) >= 16)
|
||||
assert len(bip112inputs) >= 16
|
||||
for i, (sdf, srhb, stf, srlb) in enumerate(product(*[[True, False]] * 4)):
|
||||
locktime = relative_locktime(sdf, srhb, stf, srlb)
|
||||
tx = create_transaction(node, bip112inputs[i], address, amount=Decimal("49.98"))
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2017-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2017-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Test recovery from a crash during chainstate writing.
|
||||
|
@ -28,18 +28,12 @@
|
|||
import errno
|
||||
import http.client
|
||||
import random
|
||||
import sys
|
||||
import time
|
||||
|
||||
from test_framework.messages import COIN, COutPoint, CTransaction, CTxIn, CTxOut, ToHex
|
||||
from test_framework.test_framework import BitcoinTestFramework
|
||||
from test_framework.util import assert_equal, create_confirmed_utxos, hex_str_to_bytes
|
||||
|
||||
HTTP_DISCONNECT_ERRORS = [http.client.CannotSendRequest]
|
||||
try:
|
||||
HTTP_DISCONNECT_ERRORS.append(http.client.RemoteDisconnected)
|
||||
except AttributeError:
|
||||
pass
|
||||
|
||||
class ChainstateWriteCrashTest(BitcoinTestFramework):
|
||||
def set_test_params(self):
|
||||
|
@ -110,14 +104,7 @@ class ChainstateWriteCrashTest(BitcoinTestFramework):
|
|||
try:
|
||||
self.nodes[node_index].submitblock(block)
|
||||
return True
|
||||
except http.client.BadStatusLine as e:
|
||||
# Prior to 3.5 BadStatusLine('') was raised for a remote disconnect error.
|
||||
if sys.version_info[0] == 3 and sys.version_info[1] < 5 and e.line == "''":
|
||||
self.log.debug("node %d submitblock raised exception: %s", node_index, e)
|
||||
return False
|
||||
else:
|
||||
raise
|
||||
except tuple(HTTP_DISCONNECT_ERRORS) as e:
|
||||
except (http.client.CannotSendRequest, http.client.RemoteDisconnected) as e:
|
||||
self.log.debug("node %d submitblock raised exception: %s", node_index, e)
|
||||
return False
|
||||
except OSError as e:
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2015-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2015-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Test BIP66 (DER SIG).
|
||||
|
@ -14,7 +14,6 @@ from test_framework.script import CScript
|
|||
from test_framework.test_framework import BitcoinTestFramework
|
||||
from test_framework.util import (
|
||||
assert_equal,
|
||||
bytes_to_hex_str,
|
||||
wait_until,
|
||||
)
|
||||
|
||||
|
@ -103,7 +102,7 @@ class BIP66Test(BitcoinTestFramework):
|
|||
# rejected from the mempool for exactly that reason.
|
||||
assert_equal(
|
||||
[{'txid': spendtx.hash, 'allowed': False, 'reject-reason': '64: non-mandatory-script-verify-flag (Non-canonical DER signature)'}],
|
||||
self.nodes[0].testmempoolaccept(rawtxs=[bytes_to_hex_str(spendtx.serialize())], allowhighfees=True)
|
||||
self.nodes[0].testmempoolaccept(rawtxs=[spendtx.serialize().hex()], allowhighfees=True)
|
||||
)
|
||||
|
||||
# Now we verify that a block with this transaction is also invalid.
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2014-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2014-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Test the -alertnotify, -blocknotify and -walletnotify options."""
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2016-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2016-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Test NULLDUMMY softfork.
|
||||
|
@ -18,7 +18,7 @@ from test_framework.blocktools import create_coinbase, create_block, create_tran
|
|||
from test_framework.messages import CTransaction
|
||||
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
|
||||
from test_framework.util import assert_equal, assert_raises_rpc_error
|
||||
|
||||
NULLDUMMY_ERROR = "non-mandatory-script-verify-flag (Dummy CHECKMULTISIG argument must be zero) (code 64)"
|
||||
|
||||
|
@ -27,7 +27,7 @@ def trueDummy(tx):
|
|||
newscript = []
|
||||
for i in scriptSig:
|
||||
if (len(newscript) == 0):
|
||||
assert(len(i) == 0)
|
||||
assert len(i) == 0
|
||||
newscript.append(b'\x51')
|
||||
else:
|
||||
newscript.append(i)
|
||||
|
@ -64,17 +64,17 @@ class NULLDUMMYTest(BitcoinTestFramework):
|
|||
|
||||
self.log.info("Test 1: NULLDUMMY compliant base transactions should be accepted to mempool and mined before activation [430]")
|
||||
test1txs = [create_transaction(self.nodes[0], coinbase_txid[0], self.ms_address, amount=49)]
|
||||
txid1 = self.nodes[0].sendrawtransaction(bytes_to_hex_str(test1txs[0].serialize_with_witness()), True)
|
||||
txid1 = self.nodes[0].sendrawtransaction(test1txs[0].serialize_with_witness().hex(), True)
|
||||
test1txs.append(create_transaction(self.nodes[0], txid1, self.ms_address, amount=48))
|
||||
txid2 = self.nodes[0].sendrawtransaction(bytes_to_hex_str(test1txs[1].serialize_with_witness()), True)
|
||||
txid2 = self.nodes[0].sendrawtransaction(test1txs[1].serialize_with_witness().hex(), True)
|
||||
test1txs.append(create_transaction(self.nodes[0], coinbase_txid[1], self.wit_ms_address, amount=49))
|
||||
txid3 = self.nodes[0].sendrawtransaction(bytes_to_hex_str(test1txs[2].serialize_with_witness()), True)
|
||||
txid3 = self.nodes[0].sendrawtransaction(test1txs[2].serialize_with_witness().hex(), True)
|
||||
self.block_submit(self.nodes[0], test1txs, False, True)
|
||||
|
||||
self.log.info("Test 2: Non-NULLDUMMY base multisig transaction should not be accepted to mempool before activation")
|
||||
test2tx = create_transaction(self.nodes[0], txid2, self.ms_address, amount=47)
|
||||
trueDummy(test2tx)
|
||||
assert_raises_rpc_error(-26, NULLDUMMY_ERROR, self.nodes[0].sendrawtransaction, bytes_to_hex_str(test2tx.serialize_with_witness()), True)
|
||||
assert_raises_rpc_error(-26, NULLDUMMY_ERROR, self.nodes[0].sendrawtransaction, test2tx.serialize_with_witness().hex(), True)
|
||||
|
||||
self.log.info("Test 3: Non-NULLDUMMY base transactions should be accepted in a block before activation [431]")
|
||||
self.block_submit(self.nodes[0], [test2tx], False, True)
|
||||
|
@ -83,19 +83,19 @@ class NULLDUMMYTest(BitcoinTestFramework):
|
|||
test4tx = create_transaction(self.nodes[0], test2tx.hash, self.address, amount=46)
|
||||
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)
|
||||
assert_raises_rpc_error(-26, NULLDUMMY_ERROR, self.nodes[0].sendrawtransaction, test4tx.serialize_with_witness().hex(), True)
|
||||
self.block_submit(self.nodes[0], [test4tx])
|
||||
|
||||
self.log.info("Test 5: Non-NULLDUMMY P2WSH multisig transaction invalid after activation")
|
||||
test5tx = create_transaction(self.nodes[0], txid3, self.wit_address, amount=48)
|
||||
test6txs.append(CTransaction(test5tx))
|
||||
test5tx.wit.vtxinwit[0].scriptWitness.stack[0] = b'\x01'
|
||||
assert_raises_rpc_error(-26, NULLDUMMY_ERROR, self.nodes[0].sendrawtransaction, bytes_to_hex_str(test5tx.serialize_with_witness()), True)
|
||||
assert_raises_rpc_error(-26, NULLDUMMY_ERROR, self.nodes[0].sendrawtransaction, test5tx.serialize_with_witness().hex(), True)
|
||||
self.block_submit(self.nodes[0], [test5tx], True)
|
||||
|
||||
self.log.info("Test 6: NULLDUMMY compliant base/witness transactions should be accepted to mempool and in block after activation [432]")
|
||||
for i in test6txs:
|
||||
self.nodes[0].sendrawtransaction(bytes_to_hex_str(i.serialize_with_witness()), True)
|
||||
self.nodes[0].sendrawtransaction(i.serialize_with_witness().hex(), True)
|
||||
self.block_submit(self.nodes[0], test6txs, True, True)
|
||||
|
||||
def block_submit(self, node, txs, witness=False, accept=False):
|
||||
|
@ -108,7 +108,7 @@ class NULLDUMMYTest(BitcoinTestFramework):
|
|||
witness and add_witness_commitment(block)
|
||||
block.rehash()
|
||||
block.solve()
|
||||
node.submitblock(bytes_to_hex_str(block.serialize(True)))
|
||||
node.submitblock(block.serialize(True).hex())
|
||||
if (accept):
|
||||
assert_equal(node.getbestblockhash(), block.hash)
|
||||
self.tip = block.sha256
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2015-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2015-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Test bitcoind with different proxy configuration.
|
||||
|
@ -95,7 +95,7 @@ class ProxyTest(BitcoinTestFramework):
|
|||
# Test: outgoing IPv4 connection through node
|
||||
node.addnode("15.61.23.23:1234", "onetry")
|
||||
cmd = proxies[0].queue.get()
|
||||
assert(isinstance(cmd, Socks5Command))
|
||||
assert isinstance(cmd, Socks5Command)
|
||||
# Note: bitcoind's SOCKS5 implementation only sends atyp DOMAINNAME, even if connecting directly to IPv4/IPv6
|
||||
assert_equal(cmd.atyp, AddressType.DOMAINNAME)
|
||||
assert_equal(cmd.addr, b"15.61.23.23")
|
||||
|
@ -109,7 +109,7 @@ class ProxyTest(BitcoinTestFramework):
|
|||
# Test: outgoing IPv6 connection through node
|
||||
node.addnode("[1233:3432:2434:2343:3234:2345:6546:4534]:5443", "onetry")
|
||||
cmd = proxies[1].queue.get()
|
||||
assert(isinstance(cmd, Socks5Command))
|
||||
assert isinstance(cmd, Socks5Command)
|
||||
# Note: bitcoind's SOCKS5 implementation only sends atyp DOMAINNAME, even if connecting directly to IPv4/IPv6
|
||||
assert_equal(cmd.atyp, AddressType.DOMAINNAME)
|
||||
assert_equal(cmd.addr, b"1233:3432:2434:2343:3234:2345:6546:4534")
|
||||
|
@ -123,7 +123,7 @@ class ProxyTest(BitcoinTestFramework):
|
|||
# Test: outgoing onion connection through node
|
||||
node.addnode("bitcoinostk4e4re.onion:8333", "onetry")
|
||||
cmd = proxies[2].queue.get()
|
||||
assert(isinstance(cmd, Socks5Command))
|
||||
assert isinstance(cmd, Socks5Command)
|
||||
assert_equal(cmd.atyp, AddressType.DOMAINNAME)
|
||||
assert_equal(cmd.addr, b"bitcoinostk4e4re.onion")
|
||||
assert_equal(cmd.port, 8333)
|
||||
|
@ -135,7 +135,7 @@ class ProxyTest(BitcoinTestFramework):
|
|||
# Test: outgoing DNS name connection through node
|
||||
node.addnode("node.noumenon:8333", "onetry")
|
||||
cmd = proxies[3].queue.get()
|
||||
assert(isinstance(cmd, Socks5Command))
|
||||
assert isinstance(cmd, Socks5Command)
|
||||
assert_equal(cmd.atyp, AddressType.DOMAINNAME)
|
||||
assert_equal(cmd.addr, b"node.noumenon")
|
||||
assert_equal(cmd.port, 8333)
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2014-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2014-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Test the pruning code.
|
||||
|
@ -151,7 +151,7 @@ class PruneTest(BitcoinTestFramework):
|
|||
self.nodes[1].invalidateblock(curhash)
|
||||
curhash = self.nodes[1].getblockhash(invalidheight - 1)
|
||||
|
||||
assert(self.nodes[1].getblockcount() == invalidheight - 1)
|
||||
assert self.nodes[1].getblockcount() == invalidheight - 1
|
||||
self.log.info("New best height: %d" % self.nodes[1].getblockcount())
|
||||
|
||||
# Reboot node1 to clear those giant tx's from mempool
|
||||
|
@ -219,17 +219,17 @@ class PruneTest(BitcoinTestFramework):
|
|||
blocks_to_mine = first_reorg_height + 1 - self.mainchainheight
|
||||
self.log.info("Rewind node 0 to prev main chain to mine longer chain to trigger redownload. Blocks needed: %d" % blocks_to_mine)
|
||||
self.nodes[0].invalidateblock(curchainhash)
|
||||
assert(self.nodes[0].getblockcount() == self.mainchainheight)
|
||||
assert(self.nodes[0].getbestblockhash() == self.mainchainhash2)
|
||||
assert self.nodes[0].getblockcount() == self.mainchainheight
|
||||
assert self.nodes[0].getbestblockhash() == self.mainchainhash2
|
||||
goalbesthash = self.nodes[0].generate(blocks_to_mine)[-1]
|
||||
goalbestheight = first_reorg_height + 1
|
||||
|
||||
self.log.info("Verify node 2 reorged back to the main chain, some blocks of which it had to redownload")
|
||||
# Wait for Node 2 to reorg to proper height
|
||||
wait_until(lambda: self.nodes[2].getblockcount() >= goalbestheight, timeout=900)
|
||||
assert(self.nodes[2].getbestblockhash() == goalbesthash)
|
||||
assert self.nodes[2].getbestblockhash() == goalbesthash
|
||||
# Verify we can now have the data for a block previously pruned
|
||||
assert(self.nodes[2].getblock(self.forkhash)["height"] == self.forkheight)
|
||||
assert self.nodes[2].getblock(self.forkhash)["height"] == self.forkheight
|
||||
|
||||
def manual_test(self, node_number, use_timestamp):
|
||||
# at this point, node has 995 blocks and has not yet run in prune mode
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2014-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2014-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Test the RBF code."""
|
||||
|
@ -9,12 +9,12 @@ from decimal import Decimal
|
|||
from test_framework.messages import COIN, COutPoint, CTransaction, CTxIn, CTxOut
|
||||
from test_framework.script import CScript, OP_DROP
|
||||
from test_framework.test_framework import BitcoinTestFramework
|
||||
from test_framework.util import assert_equal, assert_raises_rpc_error, bytes_to_hex_str, satoshi_round
|
||||
from test_framework.util import assert_equal, assert_raises_rpc_error, satoshi_round
|
||||
|
||||
MAX_REPLACEMENT_LIMIT = 100
|
||||
|
||||
def txToHex(tx):
|
||||
return bytes_to_hex_str(tx.serialize())
|
||||
return tx.serialize().hex()
|
||||
|
||||
def make_utxo(node, amount, confirmed=True, scriptPubKey=CScript([1])):
|
||||
"""Create a txout with a given amount and scriptPubKey
|
||||
|
@ -56,7 +56,7 @@ def make_utxo(node, amount, confirmed=True, scriptPubKey=CScript([1])):
|
|||
new_size = len(node.getrawmempool())
|
||||
# Error out if we have something stuck in the mempool, as this
|
||||
# would likely be a bug.
|
||||
assert(new_size < mempool_size)
|
||||
assert new_size < mempool_size
|
||||
mempool_size = new_size
|
||||
|
||||
return COutPoint(int(txid, 16), 0)
|
||||
|
@ -163,8 +163,8 @@ class ReplaceByFeeTest(BitcoinTestFramework):
|
|||
|
||||
mempool = self.nodes[0].getrawmempool()
|
||||
|
||||
assert (tx1a_txid not in mempool)
|
||||
assert (tx1b_txid in mempool)
|
||||
assert tx1a_txid not in mempool
|
||||
assert tx1b_txid in mempool
|
||||
|
||||
assert_equal(tx1b_hex, self.nodes[0].getrawtransaction(tx1b_txid))
|
||||
|
||||
|
@ -211,7 +211,7 @@ class ReplaceByFeeTest(BitcoinTestFramework):
|
|||
|
||||
mempool = self.nodes[0].getrawmempool()
|
||||
for doublespent_txid in chain_txids:
|
||||
assert(doublespent_txid not in mempool)
|
||||
assert doublespent_txid not in mempool
|
||||
|
||||
def test_doublespend_tree(self):
|
||||
"""Doublespend of a big tree of transactions"""
|
||||
|
@ -236,7 +236,7 @@ class ReplaceByFeeTest(BitcoinTestFramework):
|
|||
tx.vout = vout
|
||||
tx_hex = txToHex(tx)
|
||||
|
||||
assert(len(tx.serialize()) < 100000)
|
||||
assert len(tx.serialize()) < 100000
|
||||
txid = self.nodes[0].sendrawtransaction(tx_hex, True)
|
||||
yield tx
|
||||
_total_txs[0] += 1
|
||||
|
@ -274,7 +274,7 @@ class ReplaceByFeeTest(BitcoinTestFramework):
|
|||
|
||||
for tx in tree_txs:
|
||||
tx.rehash()
|
||||
assert (tx.hash not in mempool)
|
||||
assert tx.hash not in mempool
|
||||
|
||||
# Try again, but with more total transactions than the "max txs
|
||||
# double-spent at once" anti-DoS limit.
|
||||
|
@ -529,7 +529,7 @@ class ReplaceByFeeTest(BitcoinTestFramework):
|
|||
# Now tx1b should be able to replace tx1a
|
||||
tx1b_txid = self.nodes[0].sendrawtransaction(tx1b_hex, True)
|
||||
|
||||
assert(tx1b_txid in self.nodes[0].getrawmempool())
|
||||
assert tx1b_txid in self.nodes[0].getrawmempool()
|
||||
|
||||
# 2. Check that absolute fee checks use modified fee.
|
||||
tx1_outpoint = make_utxo(self.nodes[0], int(1.1*COIN))
|
||||
|
@ -556,7 +556,7 @@ class ReplaceByFeeTest(BitcoinTestFramework):
|
|||
# tx2b should now be accepted
|
||||
tx2b_txid = self.nodes[0].sendrawtransaction(tx2b_hex, True)
|
||||
|
||||
assert(tx2b_txid in self.nodes[0].getrawmempool())
|
||||
assert tx2b_txid in self.nodes[0].getrawmempool()
|
||||
|
||||
def test_rpc(self):
|
||||
us0 = self.nodes[0].listunspent()[0]
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2016-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2016-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Test the SegWit changeover logic."""
|
||||
|
@ -18,7 +18,7 @@ from test_framework.blocktools import witness_script, send_to_witness
|
|||
from test_framework.messages import COIN, COutPoint, CTransaction, CTxIn, CTxOut, FromHex, sha256, ToHex
|
||||
from test_framework.script import CScript, OP_HASH160, OP_CHECKSIG, OP_0, hash160, OP_EQUAL, OP_DUP, OP_EQUALVERIFY, OP_1, OP_2, OP_CHECKMULTISIG, OP_TRUE, OP_DROP
|
||||
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 test_framework.util import assert_equal, assert_raises_rpc_error, connect_nodes, hex_str_to_bytes, sync_blocks, try_rpc
|
||||
|
||||
NODE_0 = 0
|
||||
NODE_2 = 2
|
||||
|
@ -93,17 +93,17 @@ class SegWitTest(BitcoinTestFramework):
|
|||
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)
|
||||
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)
|
||||
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
|
||||
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)
|
||||
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
|
||||
|
||||
balance_presetup = self.nodes[0].getbalance()
|
||||
|
@ -172,16 +172,16 @@ 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(blockhash, False) != self.nodes[0].getblock(blockhash, False))
|
||||
assert(self.nodes[1].getblock(blockhash, False) == self.nodes[2].getblock(blockhash, False))
|
||||
assert self.nodes[2].getblock(blockhash, False) != self.nodes[0].getblock(blockhash, False)
|
||||
assert self.nodes[1].getblock(blockhash, False) == self.nodes[2].getblock(blockhash, False)
|
||||
|
||||
for tx_id in segwit_tx_list:
|
||||
tx = FromHex(CTransaction(), self.nodes[2].gettransaction(tx_id)["hex"])
|
||||
assert(self.nodes[2].getrawtransaction(tx_id, False, blockhash) != self.nodes[0].getrawtransaction(tx_id, False, blockhash))
|
||||
assert(self.nodes[1].getrawtransaction(tx_id, False, blockhash) == self.nodes[2].getrawtransaction(tx_id, False, blockhash))
|
||||
assert(self.nodes[0].getrawtransaction(tx_id, False, blockhash) != self.nodes[2].gettransaction(tx_id)["hex"])
|
||||
assert(self.nodes[1].getrawtransaction(tx_id, False, blockhash) == self.nodes[2].gettransaction(tx_id)["hex"])
|
||||
assert(self.nodes[0].getrawtransaction(tx_id, False, blockhash) == bytes_to_hex_str(tx.serialize_without_witness()))
|
||||
assert self.nodes[2].getrawtransaction(tx_id, False, blockhash) != self.nodes[0].getrawtransaction(tx_id, False, blockhash)
|
||||
assert self.nodes[1].getrawtransaction(tx_id, False, blockhash) == self.nodes[2].getrawtransaction(tx_id, False, blockhash)
|
||||
assert self.nodes[0].getrawtransaction(tx_id, False, blockhash) != self.nodes[2].gettransaction(tx_id)["hex"]
|
||||
assert self.nodes[1].getrawtransaction(tx_id, False, blockhash) == self.nodes[2].gettransaction(tx_id)["hex"]
|
||||
assert self.nodes[0].getrawtransaction(tx_id, False, blockhash) == tx.serialize_without_witness().hex()
|
||||
|
||||
self.log.info("Verify witness txs without witness data are invalid after the fork")
|
||||
self.fail_accept(self.nodes[2], 'non-mandatory-script-verify-flag (Witness program hash mismatch) (code 64)', wit_ids[NODE_2][WIT_V0][2], sign=False)
|
||||
|
@ -198,11 +198,11 @@ class SegWitTest(BitcoinTestFramework):
|
|||
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']})
|
||||
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)
|
||||
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
|
||||
|
||||
|
@ -214,8 +214,8 @@ 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(txid1 in self.nodes[0].getrawmempool())
|
||||
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.
|
||||
tx = CTransaction()
|
||||
|
@ -224,7 +224,7 @@ class SegWitTest(BitcoinTestFramework):
|
|||
tx2_hex = self.nodes[0].signrawtransactionwithwallet(ToHex(tx))['hex']
|
||||
txid2 = self.nodes[0].sendrawtransaction(tx2_hex)
|
||||
tx = FromHex(CTransaction(), tx2_hex)
|
||||
assert(not tx.wit.is_null())
|
||||
assert not tx.wit.is_null()
|
||||
|
||||
# Now create tx3, which will spend from txid2
|
||||
tx = CTransaction()
|
||||
|
@ -232,15 +232,15 @@ class SegWitTest(BitcoinTestFramework):
|
|||
tx.vout.append(CTxOut(int(49.95 * COIN), CScript([OP_TRUE, OP_DROP] * 15 + [OP_TRUE]))) # Huge fee
|
||||
tx.calc_sha256()
|
||||
txid3 = self.nodes[0].sendrawtransaction(ToHex(tx))
|
||||
assert(tx.wit.is_null())
|
||||
assert(txid3 in self.nodes[0].getrawmempool())
|
||||
assert tx.wit.is_null()
|
||||
assert txid3 in self.nodes[0].getrawmempool()
|
||||
|
||||
# Check that getblocktemplate includes all transactions.
|
||||
template = self.nodes[0].getblocktemplate({"rules": ["segwit"]})
|
||||
template_txids = [t['txid'] for t in template['transactions']]
|
||||
assert(txid1 in template_txids)
|
||||
assert(txid2 in template_txids)
|
||||
assert(txid3 in template_txids)
|
||||
assert txid1 in template_txids
|
||||
assert txid2 in template_txids
|
||||
assert txid3 in template_txids
|
||||
|
||||
# Check that wtxid is properly reported in mempool entry
|
||||
assert_equal(int(self.nodes[0].getmempoolentry(txid3)["wtxid"], 16), tx.calc_sha256(True))
|
||||
|
@ -392,22 +392,22 @@ class SegWitTest(BitcoinTestFramework):
|
|||
v = self.nodes[0].getaddressinfo(i)
|
||||
if (v['isscript']):
|
||||
bare = hex_str_to_bytes(v['hex'])
|
||||
importlist.append(bytes_to_hex_str(bare))
|
||||
importlist.append(bytes_to_hex_str(CScript([OP_0, sha256(bare)])))
|
||||
importlist.append(bare.hex())
|
||||
importlist.append(CScript([OP_0, sha256(bare)]).hex())
|
||||
else:
|
||||
pubkey = hex_str_to_bytes(v['pubkey'])
|
||||
p2pk = CScript([pubkey, OP_CHECKSIG])
|
||||
p2pkh = CScript([OP_DUP, OP_HASH160, hash160(pubkey), OP_EQUALVERIFY, OP_CHECKSIG])
|
||||
importlist.append(bytes_to_hex_str(p2pk))
|
||||
importlist.append(bytes_to_hex_str(p2pkh))
|
||||
importlist.append(bytes_to_hex_str(CScript([OP_0, hash160(pubkey)])))
|
||||
importlist.append(bytes_to_hex_str(CScript([OP_0, sha256(p2pk)])))
|
||||
importlist.append(bytes_to_hex_str(CScript([OP_0, sha256(p2pkh)])))
|
||||
importlist.append(p2pk.hex())
|
||||
importlist.append(p2pkh.hex())
|
||||
importlist.append(CScript([OP_0, hash160(pubkey)]).hex())
|
||||
importlist.append(CScript([OP_0, sha256(p2pk)]).hex())
|
||||
importlist.append(CScript([OP_0, sha256(p2pkh)]).hex())
|
||||
|
||||
importlist.append(bytes_to_hex_str(unsolvablep2pkh))
|
||||
importlist.append(bytes_to_hex_str(unsolvablep2wshp2pkh))
|
||||
importlist.append(bytes_to_hex_str(op1))
|
||||
importlist.append(bytes_to_hex_str(p2wshop1))
|
||||
importlist.append(unsolvablep2pkh.hex())
|
||||
importlist.append(unsolvablep2wshp2pkh.hex())
|
||||
importlist.append(op1.hex())
|
||||
importlist.append(p2wshop1.hex())
|
||||
|
||||
for i in importlist:
|
||||
# import all generated addresses. The wallet already has the private keys for some of these, so catch JSON RPC
|
||||
|
@ -535,7 +535,7 @@ class SegWitTest(BitcoinTestFramework):
|
|||
for i in script_list:
|
||||
tx.vout.append(CTxOut(10000000, i))
|
||||
tx.rehash()
|
||||
signresults = self.nodes[0].signrawtransactionwithwallet(bytes_to_hex_str(tx.serialize_without_witness()))['hex']
|
||||
signresults = self.nodes[0].signrawtransactionwithwallet(tx.serialize_without_witness().hex())['hex']
|
||||
txid = self.nodes[0].sendrawtransaction(signresults, True)
|
||||
txs_mined[txid] = self.nodes[0].generate(1)[0]
|
||||
sync_blocks(self.nodes)
|
||||
|
@ -587,7 +587,7 @@ class SegWitTest(BitcoinTestFramework):
|
|||
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']
|
||||
signresults = self.nodes[0].signrawtransactionwithwallet(tx.serialize_without_witness().hex())['hex']
|
||||
self.nodes[0].sendrawtransaction(signresults, True)
|
||||
self.nodes[0].generate(1)
|
||||
sync_blocks(self.nodes)
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2016-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2016-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Test version bits warning system.
|
||||
|
@ -74,8 +74,8 @@ class VersionBitsWarningTest(BitcoinTestFramework):
|
|||
node.generatetoaddress(VB_PERIOD - VB_THRESHOLD + 1, node_deterministic_address)
|
||||
|
||||
# Check that we're not getting any versionbit-related errors in get*info()
|
||||
assert(not VB_PATTERN.match(node.getmininginfo()["warnings"]))
|
||||
assert(not VB_PATTERN.match(node.getnetworkinfo()["warnings"]))
|
||||
assert not VB_PATTERN.match(node.getmininginfo()["warnings"])
|
||||
assert not VB_PATTERN.match(node.getnetworkinfo()["warnings"])
|
||||
|
||||
# Build one period of blocks with VB_THRESHOLD blocks signaling some unknown bit
|
||||
self.send_blocks_with_version(node.p2p, VB_THRESHOLD, VB_UNKNOWN_VERSION)
|
||||
|
@ -95,8 +95,8 @@ class VersionBitsWarningTest(BitcoinTestFramework):
|
|||
# Generating one more block will be enough to generate an error.
|
||||
node.generatetoaddress(1, node_deterministic_address)
|
||||
# Check that get*info() shows the versionbits unknown rules warning
|
||||
assert(WARN_UNKNOWN_RULES_ACTIVE in node.getmininginfo()["warnings"])
|
||||
assert(WARN_UNKNOWN_RULES_ACTIVE in node.getnetworkinfo()["warnings"])
|
||||
assert WARN_UNKNOWN_RULES_ACTIVE in node.getmininginfo()["warnings"]
|
||||
assert WARN_UNKNOWN_RULES_ACTIVE in node.getnetworkinfo()["warnings"]
|
||||
# Check that the alert file shows the versionbits unknown rules warning
|
||||
wait_until(lambda: self.versionbits_in_alert_file(), timeout=60)
|
||||
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2017-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2017-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Test bitcoin-cli"""
|
||||
|
@ -16,7 +16,7 @@ class TestBitcoinCli(BitcoinTestFramework):
|
|||
"""Main test logic"""
|
||||
|
||||
cli_response = self.nodes[0].cli("-version").send_cli()
|
||||
assert("Bitcoin Core RPC client version" in cli_response)
|
||||
assert "Bitcoin Core RPC client version" in cli_response
|
||||
|
||||
self.log.info("Compare responses from getwalletinfo RPC and `bitcoin-cli getwalletinfo`")
|
||||
if self.is_wallet_compiled():
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2014-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2014-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Test the RPC HTTP basics."""
|
||||
|
@ -30,14 +30,14 @@ class HTTPBasicsTest (BitcoinTestFramework):
|
|||
conn.connect()
|
||||
conn.request('POST', '/', '{"method": "getbestblockhash"}', headers)
|
||||
out1 = conn.getresponse().read()
|
||||
assert(b'"error":null' in out1)
|
||||
assert(conn.sock is not None) #according to http/1.1 connection must still be open!
|
||||
assert b'"error":null' in out1
|
||||
assert conn.sock is not None #according to http/1.1 connection must still be open!
|
||||
|
||||
#send 2nd request without closing connection
|
||||
conn.request('POST', '/', '{"method": "getchaintips"}', headers)
|
||||
out1 = conn.getresponse().read()
|
||||
assert(b'"error":null' in out1) #must also response with a correct json-rpc message
|
||||
assert(conn.sock is not None) #according to http/1.1 connection must still be open!
|
||||
assert b'"error":null' in out1 #must also response with a correct json-rpc message
|
||||
assert conn.sock is not None #according to http/1.1 connection must still be open!
|
||||
conn.close()
|
||||
|
||||
#same should be if we add keep-alive because this should be the std. behaviour
|
||||
|
@ -47,14 +47,14 @@ class HTTPBasicsTest (BitcoinTestFramework):
|
|||
conn.connect()
|
||||
conn.request('POST', '/', '{"method": "getbestblockhash"}', headers)
|
||||
out1 = conn.getresponse().read()
|
||||
assert(b'"error":null' in out1)
|
||||
assert(conn.sock is not None) #according to http/1.1 connection must still be open!
|
||||
assert b'"error":null' in out1
|
||||
assert conn.sock is not None #according to http/1.1 connection must still be open!
|
||||
|
||||
#send 2nd request without closing connection
|
||||
conn.request('POST', '/', '{"method": "getchaintips"}', headers)
|
||||
out1 = conn.getresponse().read()
|
||||
assert(b'"error":null' in out1) #must also response with a correct json-rpc message
|
||||
assert(conn.sock is not None) #according to http/1.1 connection must still be open!
|
||||
assert b'"error":null' in out1 #must also response with a correct json-rpc message
|
||||
assert conn.sock is not None #according to http/1.1 connection must still be open!
|
||||
conn.close()
|
||||
|
||||
#now do the same with "Connection: close"
|
||||
|
@ -64,8 +64,8 @@ class HTTPBasicsTest (BitcoinTestFramework):
|
|||
conn.connect()
|
||||
conn.request('POST', '/', '{"method": "getbestblockhash"}', headers)
|
||||
out1 = conn.getresponse().read()
|
||||
assert(b'"error":null' in out1)
|
||||
assert(conn.sock is None) #now the connection must be closed after the response
|
||||
assert b'"error":null' in out1
|
||||
assert conn.sock is None #now the connection must be closed after the response
|
||||
|
||||
#node1 (2nd node) is running with disabled keep-alive option
|
||||
urlNode1 = urllib.parse.urlparse(self.nodes[1].url)
|
||||
|
@ -76,7 +76,7 @@ class HTTPBasicsTest (BitcoinTestFramework):
|
|||
conn.connect()
|
||||
conn.request('POST', '/', '{"method": "getbestblockhash"}', headers)
|
||||
out1 = conn.getresponse().read()
|
||||
assert(b'"error":null' in out1)
|
||||
assert b'"error":null' in out1
|
||||
|
||||
#node2 (third node) is running with standard keep-alive parameters which means keep-alive is on
|
||||
urlNode2 = urllib.parse.urlparse(self.nodes[2].url)
|
||||
|
@ -87,8 +87,8 @@ class HTTPBasicsTest (BitcoinTestFramework):
|
|||
conn.connect()
|
||||
conn.request('POST', '/', '{"method": "getbestblockhash"}', headers)
|
||||
out1 = conn.getresponse().read()
|
||||
assert(b'"error":null' in out1)
|
||||
assert(conn.sock is not None) #connection must be closed because bitcoind should use keep-alive by default
|
||||
assert b'"error":null' in out1
|
||||
assert conn.sock is not None #connection must be closed because bitcoind should use keep-alive by default
|
||||
|
||||
# Check excessive request size
|
||||
conn = http.client.HTTPConnection(urlNode2.hostname, urlNode2.port)
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2014-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2014-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Test the REST API."""
|
||||
|
@ -152,7 +152,7 @@ class RESTTest (BitcoinTestFramework):
|
|||
bin_response = self.test_rest_request("/getutxos", http_method='POST', req_type=ReqType.BIN, body=bin_request, ret_type=RetType.BYTES)
|
||||
output = BytesIO(bin_response)
|
||||
chain_height, = unpack("i", output.read(4))
|
||||
response_hash = binascii.hexlify(output.read(32)[::-1]).decode('ascii')
|
||||
response_hash = output.read(32)[::-1].hex()
|
||||
|
||||
assert_equal(bb_hash, response_hash) # check if getutxo's chaintip during calculation was fine
|
||||
assert_equal(chain_height, 102) # chain height must be 102
|
||||
|
@ -252,7 +252,7 @@ class RESTTest (BitcoinTestFramework):
|
|||
resp_hex = self.test_rest_request("/blockhashbyheight/{}".format(block_json_obj['height']), req_type=ReqType.HEX, ret_type=RetType.OBJ)
|
||||
assert_equal(resp_hex.read().decode('utf-8').rstrip(), bb_hash)
|
||||
resp_bytes = self.test_rest_request("/blockhashbyheight/{}".format(block_json_obj['height']), req_type=ReqType.BIN, ret_type=RetType.BYTES)
|
||||
blockhash = binascii.hexlify(resp_bytes[::-1]).decode('utf-8')
|
||||
blockhash = resp_bytes[::-1].hex()
|
||||
assert_equal(blockhash, bb_hash)
|
||||
|
||||
# Check invalid blockhashbyheight requests
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2018-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Tests some generic aspects of the RPC interface."""
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2015-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2015-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Test the ZMQ notification interface."""
|
||||
|
@ -10,7 +10,6 @@ from test_framework.test_framework import BitcoinTestFramework
|
|||
from test_framework.messages import CTransaction
|
||||
from test_framework.util import (
|
||||
assert_equal,
|
||||
bytes_to_hex_str,
|
||||
hash256,
|
||||
)
|
||||
from io import BytesIO
|
||||
|
@ -94,17 +93,17 @@ class ZMQTest (BitcoinTestFramework):
|
|||
tx = CTransaction()
|
||||
tx.deserialize(BytesIO(hex))
|
||||
tx.calc_sha256()
|
||||
assert_equal(tx.hash, bytes_to_hex_str(txid))
|
||||
assert_equal(tx.hash, txid.hex())
|
||||
|
||||
# Should receive the generated block hash.
|
||||
hash = bytes_to_hex_str(self.hashblock.receive())
|
||||
hash = self.hashblock.receive().hex()
|
||||
assert_equal(genhashes[x], hash)
|
||||
# The block should only have the coinbase txid.
|
||||
assert_equal([bytes_to_hex_str(txid)], self.nodes[1].getblock(hash)["tx"])
|
||||
assert_equal([txid.hex()], self.nodes[1].getblock(hash)["tx"])
|
||||
|
||||
# Should receive the generated raw block.
|
||||
block = self.rawblock.receive()
|
||||
assert_equal(genhashes[x], bytes_to_hex_str(hash256(block[:80])))
|
||||
assert_equal(genhashes[x], hash256(block[:80]).hex())
|
||||
|
||||
if self.is_wallet_compiled():
|
||||
self.log.info("Wait for tx from second node")
|
||||
|
@ -113,11 +112,11 @@ class ZMQTest (BitcoinTestFramework):
|
|||
|
||||
# Should receive the broadcasted txid.
|
||||
txid = self.hashtx.receive()
|
||||
assert_equal(payment_txid, bytes_to_hex_str(txid))
|
||||
assert_equal(payment_txid, txid.hex())
|
||||
|
||||
# Should receive the broadcasted raw transaction.
|
||||
hex = self.rawtx.receive()
|
||||
assert_equal(payment_txid, bytes_to_hex_str(hash256(hex)))
|
||||
assert_equal(payment_txid, hash256(hex).hex())
|
||||
|
||||
|
||||
self.log.info("Test the getzmqnotifications RPC")
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2017-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2017-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Test mempool acceptance of raw transactions."""
|
||||
|
@ -27,7 +27,6 @@ from test_framework.script import (
|
|||
from test_framework.util import (
|
||||
assert_equal,
|
||||
assert_raises_rpc_error,
|
||||
bytes_to_hex_str,
|
||||
hex_str_to_bytes,
|
||||
)
|
||||
|
||||
|
@ -101,7 +100,7 @@ class MempoolAcceptanceTest(BitcoinTestFramework):
|
|||
tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_final)))
|
||||
self.check_mempool_result(
|
||||
result_expected=[{'txid': tx.rehash(), 'allowed': True}],
|
||||
rawtxs=[bytes_to_hex_str(tx.serialize())],
|
||||
rawtxs=[tx.serialize().hex()],
|
||||
allowhighfees=True,
|
||||
)
|
||||
node.sendrawtransaction(hexstring=raw_tx_final, allowhighfees=True)
|
||||
|
@ -119,7 +118,7 @@ class MempoolAcceptanceTest(BitcoinTestFramework):
|
|||
tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_0)))
|
||||
tx.vout[0].nValue -= int(fee * COIN) # Double the fee
|
||||
tx.vin[0].nSequence = BIP125_SEQUENCE_NUMBER + 1 # Now, opt out of RBF
|
||||
raw_tx_0 = node.signrawtransactionwithwallet(bytes_to_hex_str(tx.serialize()))['hex']
|
||||
raw_tx_0 = node.signrawtransactionwithwallet(tx.serialize().hex())['hex']
|
||||
tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_0)))
|
||||
txid_0 = tx.rehash()
|
||||
self.check_mempool_result(
|
||||
|
@ -129,14 +128,14 @@ class MempoolAcceptanceTest(BitcoinTestFramework):
|
|||
|
||||
self.log.info('A transaction that conflicts with an unconfirmed tx')
|
||||
# Send the transaction that replaces the mempool transaction and opts out of replaceability
|
||||
node.sendrawtransaction(hexstring=bytes_to_hex_str(tx.serialize()), allowhighfees=True)
|
||||
node.sendrawtransaction(hexstring=tx.serialize().hex(), allowhighfees=True)
|
||||
# take original raw_tx_0
|
||||
tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_0)))
|
||||
tx.vout[0].nValue -= int(4 * fee * COIN) # Set more fee
|
||||
# skip re-signing the tx
|
||||
self.check_mempool_result(
|
||||
result_expected=[{'txid': tx.rehash(), 'allowed': False, 'reject-reason': '18: txn-mempool-conflict'}],
|
||||
rawtxs=[bytes_to_hex_str(tx.serialize())],
|
||||
rawtxs=[tx.serialize().hex()],
|
||||
allowhighfees=True,
|
||||
)
|
||||
|
||||
|
@ -146,13 +145,13 @@ class MempoolAcceptanceTest(BitcoinTestFramework):
|
|||
# skip re-signing the tx
|
||||
self.check_mempool_result(
|
||||
result_expected=[{'txid': tx.rehash(), 'allowed': False, 'reject-reason': 'missing-inputs'}],
|
||||
rawtxs=[bytes_to_hex_str(tx.serialize())],
|
||||
rawtxs=[tx.serialize().hex()],
|
||||
)
|
||||
|
||||
self.log.info('A transaction with missing inputs, that existed once in the past')
|
||||
tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_0)))
|
||||
tx.vin[0].prevout.n = 1 # Set vout to 1, to spend the other outpoint (49 coins) of the in-chain-tx we want to double spend
|
||||
raw_tx_1 = node.signrawtransactionwithwallet(bytes_to_hex_str(tx.serialize()))['hex']
|
||||
raw_tx_1 = node.signrawtransactionwithwallet(tx.serialize().hex())['hex']
|
||||
txid_1 = node.sendrawtransaction(hexstring=raw_tx_1, allowhighfees=True)
|
||||
# Now spend both to "clearly hide" the outputs, ie. remove the coins from the utxo set by spending them
|
||||
raw_tx_spend_both = node.signrawtransactionwithwallet(node.createrawtransaction(
|
||||
|
@ -184,17 +183,17 @@ class MempoolAcceptanceTest(BitcoinTestFramework):
|
|||
# Reference tx should be valid on itself
|
||||
self.check_mempool_result(
|
||||
result_expected=[{'txid': tx.rehash(), 'allowed': True}],
|
||||
rawtxs=[bytes_to_hex_str(tx.serialize())],
|
||||
rawtxs=[tx.serialize().hex()],
|
||||
)
|
||||
|
||||
self.log.info('A transaction with no outputs')
|
||||
tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_reference)))
|
||||
tx.vout = []
|
||||
# Skip re-signing the transaction for context independent checks from now on
|
||||
# tx.deserialize(BytesIO(hex_str_to_bytes(node.signrawtransactionwithwallet(bytes_to_hex_str(tx.serialize()))['hex'])))
|
||||
# tx.deserialize(BytesIO(hex_str_to_bytes(node.signrawtransactionwithwallet(tx.serialize().hex())['hex'])))
|
||||
self.check_mempool_result(
|
||||
result_expected=[{'txid': tx.rehash(), 'allowed': False, 'reject-reason': '16: bad-txns-vout-empty'}],
|
||||
rawtxs=[bytes_to_hex_str(tx.serialize())],
|
||||
rawtxs=[tx.serialize().hex()],
|
||||
)
|
||||
|
||||
self.log.info('A really large transaction')
|
||||
|
@ -202,7 +201,7 @@ class MempoolAcceptanceTest(BitcoinTestFramework):
|
|||
tx.vin = [tx.vin[0]] * math.ceil(MAX_BLOCK_BASE_SIZE / len(tx.vin[0].serialize()))
|
||||
self.check_mempool_result(
|
||||
result_expected=[{'txid': tx.rehash(), 'allowed': False, 'reject-reason': '16: bad-txns-oversize'}],
|
||||
rawtxs=[bytes_to_hex_str(tx.serialize())],
|
||||
rawtxs=[tx.serialize().hex()],
|
||||
)
|
||||
|
||||
self.log.info('A transaction with negative output value')
|
||||
|
@ -210,7 +209,7 @@ class MempoolAcceptanceTest(BitcoinTestFramework):
|
|||
tx.vout[0].nValue *= -1
|
||||
self.check_mempool_result(
|
||||
result_expected=[{'txid': tx.rehash(), 'allowed': False, 'reject-reason': '16: bad-txns-vout-negative'}],
|
||||
rawtxs=[bytes_to_hex_str(tx.serialize())],
|
||||
rawtxs=[tx.serialize().hex()],
|
||||
)
|
||||
|
||||
self.log.info('A transaction with too large output value')
|
||||
|
@ -218,7 +217,7 @@ class MempoolAcceptanceTest(BitcoinTestFramework):
|
|||
tx.vout[0].nValue = 21000000 * COIN + 1
|
||||
self.check_mempool_result(
|
||||
result_expected=[{'txid': tx.rehash(), 'allowed': False, 'reject-reason': '16: bad-txns-vout-toolarge'}],
|
||||
rawtxs=[bytes_to_hex_str(tx.serialize())],
|
||||
rawtxs=[tx.serialize().hex()],
|
||||
)
|
||||
|
||||
self.log.info('A transaction with too large sum of output values')
|
||||
|
@ -227,7 +226,7 @@ class MempoolAcceptanceTest(BitcoinTestFramework):
|
|||
tx.vout[0].nValue = 21000000 * COIN
|
||||
self.check_mempool_result(
|
||||
result_expected=[{'txid': tx.rehash(), 'allowed': False, 'reject-reason': '16: bad-txns-txouttotal-toolarge'}],
|
||||
rawtxs=[bytes_to_hex_str(tx.serialize())],
|
||||
rawtxs=[tx.serialize().hex()],
|
||||
)
|
||||
|
||||
self.log.info('A transaction with duplicate inputs')
|
||||
|
@ -235,7 +234,7 @@ class MempoolAcceptanceTest(BitcoinTestFramework):
|
|||
tx.vin = [tx.vin[0]] * 2
|
||||
self.check_mempool_result(
|
||||
result_expected=[{'txid': tx.rehash(), 'allowed': False, 'reject-reason': '16: bad-txns-inputs-duplicate'}],
|
||||
rawtxs=[bytes_to_hex_str(tx.serialize())],
|
||||
rawtxs=[tx.serialize().hex()],
|
||||
)
|
||||
|
||||
self.log.info('A coinbase transaction')
|
||||
|
@ -244,7 +243,7 @@ class MempoolAcceptanceTest(BitcoinTestFramework):
|
|||
tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_coinbase_spent)))
|
||||
self.check_mempool_result(
|
||||
result_expected=[{'txid': tx.rehash(), 'allowed': False, 'reject-reason': '16: coinbase'}],
|
||||
rawtxs=[bytes_to_hex_str(tx.serialize())],
|
||||
rawtxs=[tx.serialize().hex()],
|
||||
)
|
||||
|
||||
self.log.info('Some nonstandard transactions')
|
||||
|
@ -252,19 +251,19 @@ class MempoolAcceptanceTest(BitcoinTestFramework):
|
|||
tx.nVersion = 3 # A version currently non-standard
|
||||
self.check_mempool_result(
|
||||
result_expected=[{'txid': tx.rehash(), 'allowed': False, 'reject-reason': '64: version'}],
|
||||
rawtxs=[bytes_to_hex_str(tx.serialize())],
|
||||
rawtxs=[tx.serialize().hex()],
|
||||
)
|
||||
tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_reference)))
|
||||
tx.vout[0].scriptPubKey = CScript([OP_0]) # Some non-standard script
|
||||
self.check_mempool_result(
|
||||
result_expected=[{'txid': tx.rehash(), 'allowed': False, 'reject-reason': '64: scriptpubkey'}],
|
||||
rawtxs=[bytes_to_hex_str(tx.serialize())],
|
||||
rawtxs=[tx.serialize().hex()],
|
||||
)
|
||||
tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_reference)))
|
||||
tx.vin[0].scriptSig = CScript([OP_HASH160]) # Some not-pushonly scriptSig
|
||||
self.check_mempool_result(
|
||||
result_expected=[{'txid': tx.rehash(), 'allowed': False, 'reject-reason': '64: scriptsig-not-pushonly'}],
|
||||
rawtxs=[bytes_to_hex_str(tx.serialize())],
|
||||
rawtxs=[tx.serialize().hex()],
|
||||
)
|
||||
tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_reference)))
|
||||
output_p2sh_burn = CTxOut(nValue=540, scriptPubKey=CScript([OP_HASH160, hash160(b'burn'), OP_EQUAL]))
|
||||
|
@ -272,21 +271,21 @@ class MempoolAcceptanceTest(BitcoinTestFramework):
|
|||
tx.vout = [output_p2sh_burn] * num_scripts
|
||||
self.check_mempool_result(
|
||||
result_expected=[{'txid': tx.rehash(), 'allowed': False, 'reject-reason': '64: tx-size'}],
|
||||
rawtxs=[bytes_to_hex_str(tx.serialize())],
|
||||
rawtxs=[tx.serialize().hex()],
|
||||
)
|
||||
tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_reference)))
|
||||
tx.vout[0] = output_p2sh_burn
|
||||
tx.vout[0].nValue -= 1 # Make output smaller, such that it is dust for our policy
|
||||
self.check_mempool_result(
|
||||
result_expected=[{'txid': tx.rehash(), 'allowed': False, 'reject-reason': '64: dust'}],
|
||||
rawtxs=[bytes_to_hex_str(tx.serialize())],
|
||||
rawtxs=[tx.serialize().hex()],
|
||||
)
|
||||
tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_reference)))
|
||||
tx.vout[0].scriptPubKey = CScript([OP_RETURN, b'\xff'])
|
||||
tx.vout = [tx.vout[0]] * 2
|
||||
self.check_mempool_result(
|
||||
result_expected=[{'txid': tx.rehash(), 'allowed': False, 'reject-reason': '64: multi-op-return'}],
|
||||
rawtxs=[bytes_to_hex_str(tx.serialize())],
|
||||
rawtxs=[tx.serialize().hex()],
|
||||
)
|
||||
|
||||
self.log.info('A timelocked transaction')
|
||||
|
@ -295,7 +294,7 @@ class MempoolAcceptanceTest(BitcoinTestFramework):
|
|||
tx.nLockTime = node.getblockcount() + 1
|
||||
self.check_mempool_result(
|
||||
result_expected=[{'txid': tx.rehash(), 'allowed': False, 'reject-reason': '64: non-final'}],
|
||||
rawtxs=[bytes_to_hex_str(tx.serialize())],
|
||||
rawtxs=[tx.serialize().hex()],
|
||||
)
|
||||
|
||||
self.log.info('A transaction that is locked by BIP68 sequence logic')
|
||||
|
@ -304,7 +303,7 @@ class MempoolAcceptanceTest(BitcoinTestFramework):
|
|||
# Can skip re-signing the tx because of early rejection
|
||||
self.check_mempool_result(
|
||||
result_expected=[{'txid': tx.rehash(), 'allowed': False, 'reject-reason': '64: non-BIP68-final'}],
|
||||
rawtxs=[bytes_to_hex_str(tx.serialize())],
|
||||
rawtxs=[tx.serialize().hex()],
|
||||
allowhighfees=True,
|
||||
)
|
||||
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2014-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2014-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Test mempool limiting together/eviction with the wallet."""
|
||||
|
@ -47,9 +47,9 @@ class MempoolLimitTest(BitcoinTestFramework):
|
|||
txids[i] = create_lots_of_big_transactions(self.nodes[0], txouts, utxos[30*i:30*i+30], 30, (i+1)*base_fee)
|
||||
|
||||
self.log.info('The tx should be evicted by now')
|
||||
assert(txid not in self.nodes[0].getrawmempool())
|
||||
assert txid not in self.nodes[0].getrawmempool()
|
||||
txdata = self.nodes[0].gettransaction(txid)
|
||||
assert(txdata['confirmations'] == 0) #confirmation should still be 0
|
||||
assert txdata['confirmations'] == 0 #confirmation should still be 0
|
||||
|
||||
self.log.info('Check that mempoolminfee is larger than minrelytxfee')
|
||||
assert_equal(self.nodes[0].getmempoolinfo()['minrelaytxfee'], Decimal('0.00001000'))
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2014-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2014-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Test descendant package tracking code."""
|
||||
|
@ -33,7 +33,7 @@ class MempoolPackagesTest(BitcoinTestFramework):
|
|||
signedtx = node.signrawtransactionwithwallet(rawtx)
|
||||
txid = node.sendrawtransaction(signedtx['hex'])
|
||||
fulltx = node.getrawtransaction(txid, 1)
|
||||
assert(len(fulltx['vout']) == num_outputs) # make sure we didn't generate a change output
|
||||
assert len(fulltx['vout']) == num_outputs # make sure we didn't generate a change output
|
||||
return (txid, send_value)
|
||||
|
||||
def run_test(self):
|
||||
|
@ -125,13 +125,13 @@ class MempoolPackagesTest(BitcoinTestFramework):
|
|||
assert_equal(len(v_ancestors), len(chain)-1)
|
||||
for x in v_ancestors.keys():
|
||||
assert_equal(mempool[x], v_ancestors[x])
|
||||
assert(chain[-1] not in v_ancestors.keys())
|
||||
assert chain[-1] not in v_ancestors.keys()
|
||||
|
||||
v_descendants = self.nodes[0].getmempooldescendants(chain[0], True)
|
||||
assert_equal(len(v_descendants), len(chain)-1)
|
||||
for x in v_descendants.keys():
|
||||
assert_equal(mempool[x], v_descendants[x])
|
||||
assert(chain[0] not in v_descendants.keys())
|
||||
assert chain[0] not in v_descendants.keys()
|
||||
|
||||
# Check that ancestor modified fees includes fee deltas from
|
||||
# prioritisetransaction
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2014-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2014-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Test resurrection of mined transactions when the blockchain is re-organized."""
|
||||
|
@ -45,7 +45,7 @@ class MempoolCoinbaseTest(BitcoinTestFramework):
|
|||
assert_equal(set(self.nodes[0].getrawmempool()), set())
|
||||
for txid in spends1_id+spends2_id:
|
||||
tx = self.nodes[0].gettransaction(txid)
|
||||
assert(tx["confirmations"] > 0)
|
||||
assert tx["confirmations"] > 0
|
||||
|
||||
# Use invalidateblock to re-org back
|
||||
for node in self.nodes:
|
||||
|
@ -55,7 +55,7 @@ class MempoolCoinbaseTest(BitcoinTestFramework):
|
|||
assert_equal(set(self.nodes[0].getrawmempool()), set(spends1_id+spends2_id))
|
||||
for txid in spends1_id+spends2_id:
|
||||
tx = self.nodes[0].gettransaction(txid)
|
||||
assert(tx["confirmations"] == 0)
|
||||
assert tx["confirmations"] == 0
|
||||
|
||||
# Generate another block, they should all get mined
|
||||
self.nodes[0].generate(1)
|
||||
|
@ -63,7 +63,7 @@ class MempoolCoinbaseTest(BitcoinTestFramework):
|
|||
assert_equal(set(self.nodes[0].getrawmempool()), set())
|
||||
for txid in spends1_id+spends2_id:
|
||||
tx = self.nodes[0].gettransaction(txid)
|
||||
assert(tx["confirmations"] > 0)
|
||||
assert tx["confirmations"] > 0
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
|
|
|
@ -27,7 +27,6 @@ from test_framework.test_framework import BitcoinTestFramework
|
|||
from test_framework.util import (
|
||||
assert_equal,
|
||||
assert_raises_rpc_error,
|
||||
bytes_to_hex_str as b2x,
|
||||
connect_nodes_bi,
|
||||
)
|
||||
from test_framework.script import CScriptNum
|
||||
|
@ -36,7 +35,7 @@ from test_framework.script import CScriptNum
|
|||
def assert_template(node, block, expect, rehash=True):
|
||||
if rehash:
|
||||
block.hashMerkleRoot = block.calc_merkle_root()
|
||||
rsp = node.getblocktemplate(template_request={'data': b2x(block.serialize()), 'mode': 'proposal', 'rules': ['segwit']})
|
||||
rsp = node.getblocktemplate(template_request={'data': block.serialize().hex(), 'mode': 'proposal', 'rules': ['segwit']})
|
||||
assert_equal(rsp, expect)
|
||||
|
||||
|
||||
|
@ -64,8 +63,8 @@ class MiningTest(BitcoinTestFramework):
|
|||
def assert_submitblock(block, result_str_1, result_str_2=None):
|
||||
block.solve()
|
||||
result_str_2 = result_str_2 or 'duplicate-invalid'
|
||||
assert_equal(result_str_1, node.submitblock(hexdata=b2x(block.serialize())))
|
||||
assert_equal(result_str_2, node.submitblock(hexdata=b2x(block.serialize())))
|
||||
assert_equal(result_str_1, node.submitblock(hexdata=block.serialize().hex()))
|
||||
assert_equal(result_str_2, node.submitblock(hexdata=block.serialize().hex()))
|
||||
|
||||
self.log.info('getmininginfo')
|
||||
mining_info = node.getmininginfo()
|
||||
|
@ -112,7 +111,7 @@ class MiningTest(BitcoinTestFramework):
|
|||
assert_template(node, block, None)
|
||||
|
||||
self.log.info("submitblock: Test block decode failure")
|
||||
assert_raises_rpc_error(-22, "Block decode failed", node.submitblock, b2x(block.serialize()[:-15]))
|
||||
assert_raises_rpc_error(-22, "Block decode failed", node.submitblock, block.serialize()[:-15].hex())
|
||||
|
||||
self.log.info("getblocktemplate: Test bad input hash for coinbase transaction")
|
||||
bad_block = copy.deepcopy(block)
|
||||
|
@ -121,10 +120,10 @@ class MiningTest(BitcoinTestFramework):
|
|||
assert_template(node, bad_block, 'bad-cb-missing')
|
||||
|
||||
self.log.info("submitblock: Test invalid coinbase transaction")
|
||||
assert_raises_rpc_error(-22, "Block does not start with a coinbase", node.submitblock, b2x(bad_block.serialize()))
|
||||
assert_raises_rpc_error(-22, "Block does not start with a coinbase", node.submitblock, bad_block.serialize().hex())
|
||||
|
||||
self.log.info("getblocktemplate: Test truncated final transaction")
|
||||
assert_raises_rpc_error(-22, "Block decode failed", node.getblocktemplate, {'data': b2x(block.serialize()[:-1]), 'mode': 'proposal', 'rules': ['segwit']})
|
||||
assert_raises_rpc_error(-22, "Block decode failed", node.getblocktemplate, {'data': block.serialize()[:-1].hex(), 'mode': 'proposal', 'rules': ['segwit']})
|
||||
|
||||
self.log.info("getblocktemplate: Test duplicate transaction")
|
||||
bad_block = copy.deepcopy(block)
|
||||
|
@ -153,7 +152,7 @@ class MiningTest(BitcoinTestFramework):
|
|||
bad_block_sn = bytearray(block.serialize())
|
||||
assert_equal(bad_block_sn[BLOCK_HEADER_SIZE], 1)
|
||||
bad_block_sn[BLOCK_HEADER_SIZE] += 1
|
||||
assert_raises_rpc_error(-22, "Block decode failed", node.getblocktemplate, {'data': b2x(bad_block_sn), 'mode': 'proposal', 'rules': ['segwit']})
|
||||
assert_raises_rpc_error(-22, "Block decode failed", node.getblocktemplate, {'data': bad_block_sn.hex(), 'mode': 'proposal', 'rules': ['segwit']})
|
||||
|
||||
self.log.info("getblocktemplate: Test bad bits")
|
||||
bad_block = copy.deepcopy(block)
|
||||
|
@ -184,7 +183,7 @@ class MiningTest(BitcoinTestFramework):
|
|||
self.log.info('submitheader tests')
|
||||
assert_raises_rpc_error(-22, 'Block header decode failed', lambda: node.submitheader(hexdata='xx' * BLOCK_HEADER_SIZE))
|
||||
assert_raises_rpc_error(-22, 'Block header decode failed', lambda: node.submitheader(hexdata='ff' * (BLOCK_HEADER_SIZE-2)))
|
||||
assert_raises_rpc_error(-25, 'Must submit previous header', lambda: node.submitheader(hexdata=b2x(super(CBlock, bad_block).serialize())))
|
||||
assert_raises_rpc_error(-25, 'Must submit previous header', lambda: node.submitheader(hexdata=super(CBlock, bad_block).serialize().hex()))
|
||||
|
||||
block.nTime += 1
|
||||
block.solve()
|
||||
|
@ -193,23 +192,23 @@ class MiningTest(BitcoinTestFramework):
|
|||
return {'hash': b_hash, 'height': 202, 'branchlen': branchlen, 'status': status}
|
||||
|
||||
assert chain_tip(block.hash) not in node.getchaintips()
|
||||
node.submitheader(hexdata=b2x(block.serialize()))
|
||||
node.submitheader(hexdata=block.serialize().hex())
|
||||
assert chain_tip(block.hash) in node.getchaintips()
|
||||
node.submitheader(hexdata=b2x(CBlockHeader(block).serialize())) # Noop
|
||||
node.submitheader(hexdata=CBlockHeader(block).serialize().hex()) # Noop
|
||||
assert chain_tip(block.hash) in node.getchaintips()
|
||||
|
||||
bad_block_root = copy.deepcopy(block)
|
||||
bad_block_root.hashMerkleRoot += 2
|
||||
bad_block_root.solve()
|
||||
assert chain_tip(bad_block_root.hash) not in node.getchaintips()
|
||||
node.submitheader(hexdata=b2x(CBlockHeader(bad_block_root).serialize()))
|
||||
node.submitheader(hexdata=CBlockHeader(bad_block_root).serialize().hex())
|
||||
assert chain_tip(bad_block_root.hash) in node.getchaintips()
|
||||
# Should still reject invalid blocks, even if we have the header:
|
||||
assert_equal(node.submitblock(hexdata=b2x(bad_block_root.serialize())), 'bad-txnmrklroot')
|
||||
assert_equal(node.submitblock(hexdata=b2x(bad_block_root.serialize())), 'bad-txnmrklroot')
|
||||
assert_equal(node.submitblock(hexdata=bad_block_root.serialize().hex()), 'bad-txnmrklroot')
|
||||
assert_equal(node.submitblock(hexdata=bad_block_root.serialize().hex()), 'bad-txnmrklroot')
|
||||
assert chain_tip(bad_block_root.hash) in node.getchaintips()
|
||||
# We know the header for this invalid block, so should just return early without error:
|
||||
node.submitheader(hexdata=b2x(CBlockHeader(bad_block_root).serialize()))
|
||||
node.submitheader(hexdata=CBlockHeader(bad_block_root).serialize().hex())
|
||||
assert chain_tip(bad_block_root.hash) in node.getchaintips()
|
||||
|
||||
bad_block_lock = copy.deepcopy(block)
|
||||
|
@ -217,19 +216,19 @@ class MiningTest(BitcoinTestFramework):
|
|||
bad_block_lock.vtx[0].rehash()
|
||||
bad_block_lock.hashMerkleRoot = bad_block_lock.calc_merkle_root()
|
||||
bad_block_lock.solve()
|
||||
assert_equal(node.submitblock(hexdata=b2x(bad_block_lock.serialize())), 'bad-txns-nonfinal')
|
||||
assert_equal(node.submitblock(hexdata=b2x(bad_block_lock.serialize())), 'duplicate-invalid')
|
||||
assert_equal(node.submitblock(hexdata=bad_block_lock.serialize().hex()), 'bad-txns-nonfinal')
|
||||
assert_equal(node.submitblock(hexdata=bad_block_lock.serialize().hex()), 'duplicate-invalid')
|
||||
# Build a "good" block on top of the submitted bad block
|
||||
bad_block2 = copy.deepcopy(block)
|
||||
bad_block2.hashPrevBlock = bad_block_lock.sha256
|
||||
bad_block2.solve()
|
||||
assert_raises_rpc_error(-25, 'bad-prevblk', lambda: node.submitheader(hexdata=b2x(CBlockHeader(bad_block2).serialize())))
|
||||
assert_raises_rpc_error(-25, 'bad-prevblk', lambda: node.submitheader(hexdata=CBlockHeader(bad_block2).serialize().hex()))
|
||||
|
||||
# Should reject invalid header right away
|
||||
bad_block_time = copy.deepcopy(block)
|
||||
bad_block_time.nTime = 1
|
||||
bad_block_time.solve()
|
||||
assert_raises_rpc_error(-25, 'time-too-old', lambda: node.submitheader(hexdata=b2x(CBlockHeader(bad_block_time).serialize())))
|
||||
assert_raises_rpc_error(-25, 'time-too-old', lambda: node.submitheader(hexdata=CBlockHeader(bad_block_time).serialize().hex()))
|
||||
|
||||
# Should ask for the block from a p2p node, if they announce the header as well:
|
||||
node.add_p2p_connection(P2PDataStore())
|
||||
|
@ -240,11 +239,11 @@ class MiningTest(BitcoinTestFramework):
|
|||
|
||||
# Building a few blocks should give the same results
|
||||
node.generatetoaddress(10, node.get_deterministic_priv_key().address)
|
||||
assert_raises_rpc_error(-25, 'time-too-old', lambda: node.submitheader(hexdata=b2x(CBlockHeader(bad_block_time).serialize())))
|
||||
assert_raises_rpc_error(-25, 'bad-prevblk', lambda: node.submitheader(hexdata=b2x(CBlockHeader(bad_block2).serialize())))
|
||||
node.submitheader(hexdata=b2x(CBlockHeader(block).serialize()))
|
||||
node.submitheader(hexdata=b2x(CBlockHeader(bad_block_root).serialize()))
|
||||
assert_equal(node.submitblock(hexdata=b2x(block.serialize())), 'duplicate') # valid
|
||||
assert_raises_rpc_error(-25, 'time-too-old', lambda: node.submitheader(hexdata=CBlockHeader(bad_block_time).serialize().hex()))
|
||||
assert_raises_rpc_error(-25, 'bad-prevblk', lambda: node.submitheader(hexdata=CBlockHeader(bad_block2).serialize().hex()))
|
||||
node.submitheader(hexdata=CBlockHeader(block).serialize().hex())
|
||||
node.submitheader(hexdata=CBlockHeader(bad_block_root).serialize().hex())
|
||||
assert_equal(node.submitblock(hexdata=block.serialize().hex()), 'duplicate') # valid
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2014-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2014-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Test longpolling with getblocktemplate."""
|
||||
|
@ -38,27 +38,27 @@ class GetBlockTemplateLPTest(BitcoinTestFramework):
|
|||
longpollid = template['longpollid']
|
||||
# longpollid should not change between successive invocations if nothing else happens
|
||||
template2 = self.nodes[0].getblocktemplate({'rules': ['segwit']})
|
||||
assert(template2['longpollid'] == longpollid)
|
||||
assert template2['longpollid'] == longpollid
|
||||
|
||||
# Test 1: test that the longpolling wait if we do nothing
|
||||
thr = LongpollThread(self.nodes[0])
|
||||
thr.start()
|
||||
# check that thread still lives
|
||||
thr.join(5) # wait 5 seconds or until thread exits
|
||||
assert(thr.is_alive())
|
||||
assert thr.is_alive()
|
||||
|
||||
# Test 2: test that longpoll will terminate if another node generates a block
|
||||
self.nodes[1].generate(1) # generate a block on another node
|
||||
# check that thread will exit now that new transaction entered mempool
|
||||
thr.join(5) # wait 5 seconds or until thread exits
|
||||
assert(not thr.is_alive())
|
||||
assert not thr.is_alive()
|
||||
|
||||
# Test 3: test that longpoll will terminate if we generate a block ourselves
|
||||
thr = LongpollThread(self.nodes[0])
|
||||
thr.start()
|
||||
self.nodes[0].generate(1) # generate a block on another node
|
||||
thr.join(5) # wait 5 seconds or until thread exits
|
||||
assert(not thr.is_alive())
|
||||
assert not thr.is_alive()
|
||||
|
||||
# Test 4: test that introducing a new transaction into the mempool will terminate the longpoll
|
||||
thr = LongpollThread(self.nodes[0])
|
||||
|
@ -69,7 +69,7 @@ class GetBlockTemplateLPTest(BitcoinTestFramework):
|
|||
(txid, txhex, fee) = random_transaction(self.nodes, Decimal("1.1"), min_relay_fee, Decimal("0.001"), 20)
|
||||
# after one minute, every 10 seconds the mempool is probed, so in 80 seconds it should have returned
|
||||
thr.join(60 + 20)
|
||||
assert(not thr.is_alive())
|
||||
assert not thr.is_alive()
|
||||
|
||||
if __name__ == '__main__':
|
||||
GetBlockTemplateLPTest().main()
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2015-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2015-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Test the prioritisetransaction mining RPC."""
|
||||
|
@ -63,9 +63,9 @@ class PrioritiseTransactionTest(BitcoinTestFramework):
|
|||
sizes = [0, 0, 0]
|
||||
for i in range(3):
|
||||
for j in txids[i]:
|
||||
assert(j in mempool)
|
||||
assert j in mempool
|
||||
sizes[i] += mempool[j]['size']
|
||||
assert(sizes[i] > MAX_BLOCK_BASE_SIZE) # Fail => raise utxo_count
|
||||
assert sizes[i] > MAX_BLOCK_BASE_SIZE # Fail => raise utxo_count
|
||||
|
||||
# add a fee delta to something in the cheapest bucket and make sure it gets mined
|
||||
# also check that a different entry in the cheapest bucket is NOT mined
|
||||
|
@ -75,8 +75,8 @@ class PrioritiseTransactionTest(BitcoinTestFramework):
|
|||
|
||||
mempool = self.nodes[0].getrawmempool()
|
||||
self.log.info("Assert that prioritised transaction was mined")
|
||||
assert(txids[0][0] not in mempool)
|
||||
assert(txids[0][1] in mempool)
|
||||
assert txids[0][0] not in mempool
|
||||
assert txids[0][1] in mempool
|
||||
|
||||
high_fee_tx = None
|
||||
for x in txids[2]:
|
||||
|
@ -84,7 +84,7 @@ class PrioritiseTransactionTest(BitcoinTestFramework):
|
|||
high_fee_tx = x
|
||||
|
||||
# Something high-fee should have been mined!
|
||||
assert(high_fee_tx is not None)
|
||||
assert high_fee_tx is not None
|
||||
|
||||
# Add a prioritisation before a tx is in the mempool (de-prioritising a
|
||||
# high-fee transaction so that it's now low fee).
|
||||
|
@ -95,7 +95,7 @@ class PrioritiseTransactionTest(BitcoinTestFramework):
|
|||
|
||||
# Check to make sure our high fee rate tx is back in the mempool
|
||||
mempool = self.nodes[0].getrawmempool()
|
||||
assert(high_fee_tx in mempool)
|
||||
assert high_fee_tx in mempool
|
||||
|
||||
# Now verify the modified-high feerate transaction isn't mined before
|
||||
# the other high fee transactions. Keep mining until our mempool has
|
||||
|
@ -107,14 +107,14 @@ class PrioritiseTransactionTest(BitcoinTestFramework):
|
|||
# transactions should have been.
|
||||
mempool = self.nodes[0].getrawmempool()
|
||||
self.log.info("Assert that de-prioritised transaction is still in mempool")
|
||||
assert(high_fee_tx in mempool)
|
||||
assert high_fee_tx in mempool
|
||||
for x in txids[2]:
|
||||
if (x != high_fee_tx):
|
||||
assert(x not in mempool)
|
||||
assert x not in mempool
|
||||
|
||||
# Create a free transaction. Should be rejected.
|
||||
utxo_list = self.nodes[0].listunspent()
|
||||
assert(len(utxo_list) > 0)
|
||||
assert len(utxo_list) > 0
|
||||
utxo = utxo_list[0]
|
||||
|
||||
inputs = []
|
||||
|
@ -127,7 +127,7 @@ class PrioritiseTransactionTest(BitcoinTestFramework):
|
|||
|
||||
# This will raise an exception due to min relay fee not being met
|
||||
assert_raises_rpc_error(-26, "min relay fee not met", self.nodes[0].sendrawtransaction, tx_hex)
|
||||
assert(tx_id not in self.nodes[0].getrawmempool())
|
||||
assert tx_id not in self.nodes[0].getrawmempool()
|
||||
|
||||
# This is a less than 1000-byte transaction, so just set the fee
|
||||
# to be the minimum for a 1000-byte transaction and check that it is
|
||||
|
@ -136,7 +136,7 @@ class PrioritiseTransactionTest(BitcoinTestFramework):
|
|||
|
||||
self.log.info("Assert that prioritised free transaction is accepted to mempool")
|
||||
assert_equal(self.nodes[0].sendrawtransaction(tx_hex), tx_id)
|
||||
assert(tx_id in self.nodes[0].getrawmempool())
|
||||
assert tx_id in self.nodes[0].getrawmempool()
|
||||
|
||||
# Test that calling prioritisetransaction is sufficient to trigger
|
||||
# getblocktemplate to (eventually) return a new block.
|
||||
|
@ -147,7 +147,7 @@ class PrioritiseTransactionTest(BitcoinTestFramework):
|
|||
self.nodes[0].setmocktime(mock_time+10)
|
||||
new_template = self.nodes[0].getblocktemplate({'rules': ['segwit']})
|
||||
|
||||
assert(template != new_template)
|
||||
assert template != new_template
|
||||
|
||||
if __name__ == '__main__':
|
||||
PrioritiseTransactionTest().main()
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2016-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2016-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Test compact blocks (BIP 152).
|
||||
|
@ -120,7 +120,7 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
# Doesn't matter which node we use, just use node0.
|
||||
block = self.build_block_on_tip(self.nodes[0])
|
||||
self.test_node.send_and_ping(msg_block(block))
|
||||
assert(int(self.nodes[0].getbestblockhash(), 16) == block.sha256)
|
||||
assert int(self.nodes[0].getbestblockhash(), 16) == block.sha256
|
||||
self.nodes[0].generate(100)
|
||||
|
||||
total_value = block.vtx[0].vout[0].nValue
|
||||
|
@ -167,7 +167,7 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
peer.clear_block_announcement()
|
||||
block_hash = int(node.generate(1)[0], 16)
|
||||
peer.wait_for_block_announcement(block_hash, timeout=30)
|
||||
assert(peer.block_announced)
|
||||
assert peer.block_announced
|
||||
|
||||
with mininode_lock:
|
||||
assert predicate(peer), (
|
||||
|
@ -303,7 +303,7 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
# Now fetch and check the compact block
|
||||
header_and_shortids = None
|
||||
with mininode_lock:
|
||||
assert("cmpctblock" in test_node.last_message)
|
||||
assert "cmpctblock" in test_node.last_message
|
||||
# Convert the on-the-wire representation to absolute indexes
|
||||
header_and_shortids = HeaderAndShortIDs(test_node.last_message["cmpctblock"].header_and_shortids)
|
||||
self.check_compactblock_construction_from_block(version, header_and_shortids, block_hash, block)
|
||||
|
@ -319,7 +319,7 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
# Now fetch and check the compact block
|
||||
header_and_shortids = None
|
||||
with mininode_lock:
|
||||
assert("cmpctblock" in test_node.last_message)
|
||||
assert "cmpctblock" in test_node.last_message
|
||||
# Convert the on-the-wire representation to absolute indexes
|
||||
header_and_shortids = HeaderAndShortIDs(test_node.last_message["cmpctblock"].header_and_shortids)
|
||||
self.check_compactblock_construction_from_block(version, header_and_shortids, block_hash, block)
|
||||
|
@ -330,7 +330,7 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
assert_equal(header_and_shortids.header.sha256, block_hash)
|
||||
|
||||
# Make sure the prefilled_txn appears to have included the coinbase
|
||||
assert(len(header_and_shortids.prefilled_txn) >= 1)
|
||||
assert len(header_and_shortids.prefilled_txn) >= 1
|
||||
assert_equal(header_and_shortids.prefilled_txn[0].index, 0)
|
||||
|
||||
# Check that all prefilled_txn entries match what's in the block.
|
||||
|
@ -345,7 +345,7 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
assert_equal(wtxid, block.vtx[entry.index].calc_sha256(True))
|
||||
else:
|
||||
# Shouldn't have received a witness
|
||||
assert(entry.tx.wit.is_null())
|
||||
assert entry.tx.wit.is_null()
|
||||
|
||||
# Check that the cmpctblock message announced all the transactions.
|
||||
assert_equal(len(header_and_shortids.prefilled_txn) + len(header_and_shortids.shortids), len(block.vtx))
|
||||
|
@ -407,7 +407,7 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
assert_equal(int(node.getbestblockhash(), 16), block.hashPrevBlock)
|
||||
# Expect a getblocktxn message.
|
||||
with mininode_lock:
|
||||
assert("getblocktxn" in test_node.last_message)
|
||||
assert "getblocktxn" in test_node.last_message
|
||||
absolute_indexes = test_node.last_message["getblocktxn"].block_txn_request.to_absolute()
|
||||
assert_equal(absolute_indexes, [0]) # should be a coinbase request
|
||||
|
||||
|
@ -447,7 +447,7 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
msg = msg_cmpctblock(compact_block.to_p2p())
|
||||
peer.send_and_ping(msg)
|
||||
with mininode_lock:
|
||||
assert("getblocktxn" in peer.last_message)
|
||||
assert "getblocktxn" in peer.last_message
|
||||
absolute_indexes = peer.last_message["getblocktxn"].block_txn_request.to_absolute()
|
||||
assert_equal(absolute_indexes, expected_result)
|
||||
|
||||
|
@ -487,7 +487,7 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
block = self.build_block_with_transactions(node, utxo, 5)
|
||||
self.utxos.append([block.vtx[-1].sha256, 0, block.vtx[-1].vout[0].nValue])
|
||||
test_node.send_and_ping(msg_tx(block.vtx[1]))
|
||||
assert(block.vtx[1].hash in node.getrawmempool())
|
||||
assert block.vtx[1].hash in node.getrawmempool()
|
||||
|
||||
# Prefill 4 out of the 6 transactions, and verify that only the one
|
||||
# that was not in the mempool is requested.
|
||||
|
@ -508,7 +508,7 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
# Make sure all transactions were accepted.
|
||||
mempool = node.getrawmempool()
|
||||
for tx in block.vtx[1:]:
|
||||
assert(tx.hash in mempool)
|
||||
assert tx.hash in mempool
|
||||
|
||||
# Clear out last request.
|
||||
with mininode_lock:
|
||||
|
@ -519,7 +519,7 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
test_tip_after_message(node, test_node, msg_cmpctblock(comp_block.to_p2p()), block.sha256)
|
||||
with mininode_lock:
|
||||
# Shouldn't have gotten a request for any transaction
|
||||
assert("getblocktxn" not in test_node.last_message)
|
||||
assert "getblocktxn" not in test_node.last_message
|
||||
|
||||
# Incorrectly responding to a getblocktxn shouldn't cause the block to be
|
||||
# permanently failed.
|
||||
|
@ -537,7 +537,7 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
# Make sure all transactions were accepted.
|
||||
mempool = node.getrawmempool()
|
||||
for tx in block.vtx[1:6]:
|
||||
assert(tx.hash in mempool)
|
||||
assert tx.hash in mempool
|
||||
|
||||
# Send compact block
|
||||
comp_block = HeaderAndShortIDs()
|
||||
|
@ -545,7 +545,7 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
test_node.send_and_ping(msg_cmpctblock(comp_block.to_p2p()))
|
||||
absolute_indexes = []
|
||||
with mininode_lock:
|
||||
assert("getblocktxn" in test_node.last_message)
|
||||
assert "getblocktxn" in test_node.last_message
|
||||
absolute_indexes = test_node.last_message["getblocktxn"].block_txn_request.to_absolute()
|
||||
assert_equal(absolute_indexes, [6, 7, 8, 9, 10])
|
||||
|
||||
|
@ -569,7 +569,7 @@ 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
|
||||
|
@ -606,7 +606,7 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
assert_equal(tx.sha256, block.vtx[index].sha256)
|
||||
if version == 1:
|
||||
# Witnesses should have been stripped
|
||||
assert(tx.wit.is_null())
|
||||
assert tx.wit.is_null()
|
||||
else:
|
||||
# Check that the witness matches
|
||||
assert_equal(tx.calc_sha256(True), block.vtx[index].calc_sha256(True))
|
||||
|
@ -669,7 +669,7 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
assert_equal(x["status"], "headers-only")
|
||||
found = True
|
||||
break
|
||||
assert(found)
|
||||
assert found
|
||||
|
||||
# Requesting this block via getblocktxn should silently fail
|
||||
# (to avoid fingerprinting attacks).
|
||||
|
@ -707,7 +707,7 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
# Test that we don't get disconnected if we relay a compact block with valid header,
|
||||
# but invalid transactions.
|
||||
def test_invalid_tx_in_compactblock(self, node, test_node, use_segwit):
|
||||
assert(len(self.utxos))
|
||||
assert len(self.utxos)
|
||||
utxo = self.utxos[0]
|
||||
|
||||
block = self.build_block_with_transactions(node, utxo, 5)
|
||||
|
@ -728,7 +728,7 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
test_node.send_and_ping(msg)
|
||||
|
||||
# Check that the tip didn't advance
|
||||
assert(int(node.getbestblockhash(), 16) is not block.sha256)
|
||||
assert int(node.getbestblockhash(), 16) is not block.sha256
|
||||
test_node.sync_with_ping()
|
||||
|
||||
# Helper for enabling cb announcements
|
||||
|
@ -743,7 +743,7 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
peer.send_and_ping(msg)
|
||||
|
||||
def test_compactblock_reconstruction_multiple_peers(self, node, stalling_peer, delivery_peer):
|
||||
assert(len(self.utxos))
|
||||
assert len(self.utxos)
|
||||
|
||||
def announce_cmpct_block(node, peer):
|
||||
utxo = self.utxos.pop(0)
|
||||
|
@ -764,7 +764,7 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
delivery_peer.sync_with_ping()
|
||||
mempool = node.getrawmempool()
|
||||
for tx in block.vtx[1:]:
|
||||
assert(tx.hash in mempool)
|
||||
assert tx.hash in mempool
|
||||
|
||||
delivery_peer.send_and_ping(msg_cmpctblock(cmpct_block.to_p2p()))
|
||||
assert_equal(int(node.getbestblockhash(), 16), block.sha256)
|
||||
|
@ -783,7 +783,7 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
|
||||
cmpct_block.use_witness = True
|
||||
delivery_peer.send_and_ping(msg_cmpctblock(cmpct_block.to_p2p()))
|
||||
assert(int(node.getbestblockhash(), 16) != block.sha256)
|
||||
assert int(node.getbestblockhash(), 16) != block.sha256
|
||||
|
||||
msg = msg_blocktxn()
|
||||
msg.block_transactions.blockhash = block.sha256
|
||||
|
@ -882,7 +882,7 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
# Need to manually sync node0 and node1, because post-segwit activation,
|
||||
# node1 will not download blocks from node0.
|
||||
self.log.info("Syncing nodes...")
|
||||
assert(self.nodes[0].getbestblockhash() != self.nodes[1].getbestblockhash())
|
||||
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)
|
||||
self.nodes[1].submitblock(self.nodes[0].getblock(block_hash, False))
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2016-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2016-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Test processing of feefilter messages."""
|
||||
|
@ -57,7 +57,7 @@ class FeeFilterTest(BitcoinTestFramework):
|
|||
# Test that invs are received for all txs at feerate of 20 sat/byte
|
||||
node1.settxfee(Decimal("0.00020000"))
|
||||
txids = [node1.sendtoaddress(node1.getnewaddress(), 1) for x in range(3)]
|
||||
assert(allInvsMatch(txids, self.nodes[0].p2p))
|
||||
assert allInvsMatch(txids, self.nodes[0].p2p)
|
||||
self.nodes[0].p2p.clear_invs()
|
||||
|
||||
# Set a filter of 15 sat/byte
|
||||
|
@ -65,7 +65,7 @@ class FeeFilterTest(BitcoinTestFramework):
|
|||
|
||||
# Test that txs are still being received (paying 20 sat/byte)
|
||||
txids = [node1.sendtoaddress(node1.getnewaddress(), 1) for x in range(3)]
|
||||
assert(allInvsMatch(txids, self.nodes[0].p2p))
|
||||
assert allInvsMatch(txids, self.nodes[0].p2p)
|
||||
self.nodes[0].p2p.clear_invs()
|
||||
|
||||
# Change tx fee rate to 10 sat/byte and test they are no longer received
|
||||
|
@ -82,13 +82,13 @@ class FeeFilterTest(BitcoinTestFramework):
|
|||
# as well.
|
||||
node0.settxfee(Decimal("0.00020000"))
|
||||
txids = [node0.sendtoaddress(node0.getnewaddress(), 1)]
|
||||
assert(allInvsMatch(txids, self.nodes[0].p2p))
|
||||
assert allInvsMatch(txids, self.nodes[0].p2p)
|
||||
self.nodes[0].p2p.clear_invs()
|
||||
|
||||
# Remove fee filter and check that txs are received again
|
||||
self.nodes[0].p2p.send_and_ping(msg_feefilter(0))
|
||||
txids = [node1.sendtoaddress(node1.getnewaddress(), 1) for x in range(3)]
|
||||
assert(allInvsMatch(txids, self.nodes[0].p2p))
|
||||
assert allInvsMatch(txids, self.nodes[0].p2p)
|
||||
self.nodes[0].p2p.clear_invs()
|
||||
|
||||
if __name__ == '__main__':
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2017-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2017-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Test message sending before handshake completion.
|
||||
|
@ -117,9 +117,9 @@ class P2PLeakTest(BitcoinTestFramework):
|
|||
wait_until(lambda: len(self.nodes[0].getpeerinfo()) == 0)
|
||||
|
||||
# Make sure no unexpected messages came in
|
||||
assert(no_version_bannode.unexpected_msg == False)
|
||||
assert(no_version_idlenode.unexpected_msg == False)
|
||||
assert(no_verack_idlenode.unexpected_msg == False)
|
||||
assert no_version_bannode.unexpected_msg == False
|
||||
assert no_version_idlenode.unexpected_msg == False
|
||||
assert no_verack_idlenode.unexpected_msg == False
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
|
|
|
@ -1,9 +1,8 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2016-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2016-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Test segwit transactions and blocks on P2P network."""
|
||||
from binascii import hexlify
|
||||
import math
|
||||
import random
|
||||
import struct
|
||||
|
@ -74,7 +73,6 @@ from test_framework.script import (
|
|||
from test_framework.test_framework import BitcoinTestFramework
|
||||
from test_framework.util import (
|
||||
assert_equal,
|
||||
bytes_to_hex_str,
|
||||
connect_nodes,
|
||||
disconnect_nodes,
|
||||
get_bip9_status,
|
||||
|
@ -317,7 +315,7 @@ class SegWitTest(BitcoinTestFramework):
|
|||
|
||||
self.test_node.send_message(msg_witness_tx(tx))
|
||||
self.test_node.sync_with_ping() # make sure the tx was processed
|
||||
assert(tx.hash in self.nodes[0].getrawmempool())
|
||||
assert tx.hash in self.nodes[0].getrawmempool()
|
||||
# Save this transaction for later
|
||||
self.utxo.append(UTXO(tx.sha256, 0, 49 * 100000000))
|
||||
self.nodes[0].generate(1)
|
||||
|
@ -335,7 +333,7 @@ class SegWitTest(BitcoinTestFramework):
|
|||
# Verify the hash with witness differs from the txid
|
||||
# (otherwise our testing framework must be broken!)
|
||||
tx.rehash()
|
||||
assert(tx.sha256 != tx.calc_sha256(with_witness=True))
|
||||
assert tx.sha256 != tx.calc_sha256(with_witness=True)
|
||||
|
||||
# Construct a segwit-signaling block that includes the transaction.
|
||||
block = self.build_next_block(version=(VB_TOP_BITS | (1 << VB_WITNESS_BIT)))
|
||||
|
@ -371,20 +369,20 @@ class SegWitTest(BitcoinTestFramework):
|
|||
block1.solve()
|
||||
|
||||
self.test_node.announce_block_and_wait_for_getdata(block1, use_header=False)
|
||||
assert(self.test_node.last_message["getdata"].inv[0].type == blocktype)
|
||||
assert self.test_node.last_message["getdata"].inv[0].type == blocktype
|
||||
test_witness_block(self.nodes[0], self.test_node, block1, True)
|
||||
|
||||
block2 = self.build_next_block(version=4)
|
||||
block2.solve()
|
||||
|
||||
self.test_node.announce_block_and_wait_for_getdata(block2, use_header=True)
|
||||
assert(self.test_node.last_message["getdata"].inv[0].type == blocktype)
|
||||
assert self.test_node.last_message["getdata"].inv[0].type == blocktype
|
||||
test_witness_block(self.nodes[0], self.test_node, block2, True)
|
||||
|
||||
block3 = self.build_next_block(version=(VB_TOP_BITS | (1 << 15)))
|
||||
block3.solve()
|
||||
self.test_node.announce_block_and_wait_for_getdata(block3, use_header=True)
|
||||
assert(self.test_node.last_message["getdata"].inv[0].type == blocktype)
|
||||
assert self.test_node.last_message["getdata"].inv[0].type == blocktype
|
||||
test_witness_block(self.nodes[0], self.test_node, block3, True)
|
||||
|
||||
# Check that we can getdata for witness blocks or regular blocks,
|
||||
|
@ -413,8 +411,8 @@ class SegWitTest(BitcoinTestFramework):
|
|||
block = self.build_next_block()
|
||||
self.update_witness_block_with_transactions(block, [])
|
||||
# This gives us a witness commitment.
|
||||
assert(len(block.vtx[0].wit.vtxinwit) == 1)
|
||||
assert(len(block.vtx[0].wit.vtxinwit[0].scriptWitness.stack) == 1)
|
||||
assert len(block.vtx[0].wit.vtxinwit) == 1
|
||||
assert len(block.vtx[0].wit.vtxinwit[0].scriptWitness.stack) == 1
|
||||
test_witness_block(self.nodes[0], self.test_node, block, accepted=True)
|
||||
# Now try to retrieve it...
|
||||
rpc_block = self.nodes[0].getblock(block.hash, False)
|
||||
|
@ -448,7 +446,7 @@ class SegWitTest(BitcoinTestFramework):
|
|||
msg.headers = [CBlockHeader(block4)]
|
||||
self.old_node.send_message(msg)
|
||||
self.old_node.announce_tx_and_wait_for_getdata(block4.vtx[0])
|
||||
assert(block4.sha256 not in self.old_node.getdataset)
|
||||
assert block4.sha256 not in self.old_node.getdataset
|
||||
|
||||
@subtest
|
||||
def test_v0_outputs_arent_spendable(self):
|
||||
|
@ -537,7 +535,7 @@ class SegWitTest(BitcoinTestFramework):
|
|||
"""Mine enough blocks for segwit's vb state to be 'started'."""
|
||||
height = self.nodes[0].getblockcount()
|
||||
# Will need to rewrite the tests here if we are past the first period
|
||||
assert(height < VB_PERIOD - 1)
|
||||
assert height < VB_PERIOD - 1
|
||||
# Advance to end of period, status should now be 'started'
|
||||
self.nodes[0].generate(VB_PERIOD - height - 1)
|
||||
assert_equal(get_bip9_status(self.nodes[0], 'segwit')['status'], 'started')
|
||||
|
@ -554,19 +552,19 @@ class SegWitTest(BitcoinTestFramework):
|
|||
# If this is a non-segwit node, we should not get a witness
|
||||
# commitment, nor a version bit signalling segwit.
|
||||
assert_equal(block_version & (1 << VB_WITNESS_BIT), 0)
|
||||
assert('default_witness_commitment' not in gbt_results)
|
||||
assert 'default_witness_commitment' not in gbt_results
|
||||
else:
|
||||
# For segwit-aware nodes, check the version bit and the witness
|
||||
# commitment are correct.
|
||||
assert(block_version & (1 << VB_WITNESS_BIT) != 0)
|
||||
assert('default_witness_commitment' in gbt_results)
|
||||
assert block_version & (1 << VB_WITNESS_BIT) != 0
|
||||
assert 'default_witness_commitment' in gbt_results
|
||||
witness_commitment = gbt_results['default_witness_commitment']
|
||||
|
||||
# Check that default_witness_commitment is present.
|
||||
witness_root = CBlock.get_merkle_root([ser_uint256(0),
|
||||
ser_uint256(txid)])
|
||||
script = get_witness_script(witness_root, 0)
|
||||
assert_equal(witness_commitment, bytes_to_hex_str(script))
|
||||
assert_equal(witness_commitment, script.hex())
|
||||
|
||||
@subtest
|
||||
def advance_to_segwit_lockin(self):
|
||||
|
@ -575,7 +573,7 @@ class SegWitTest(BitcoinTestFramework):
|
|||
# Advance to end of period, and verify lock-in happens at the end
|
||||
self.nodes[0].generate(VB_PERIOD - 1)
|
||||
height = self.nodes[0].getblockcount()
|
||||
assert((height % VB_PERIOD) == VB_PERIOD - 2)
|
||||
assert (height % VB_PERIOD) == VB_PERIOD - 2
|
||||
assert_equal(get_bip9_status(self.nodes[0], 'segwit')['status'], 'started')
|
||||
self.nodes[0].generate(1)
|
||||
assert_equal(get_bip9_status(self.nodes[0], 'segwit')['status'], 'locked_in')
|
||||
|
@ -600,7 +598,7 @@ class SegWitTest(BitcoinTestFramework):
|
|||
# Verify that if a peer doesn't set nServices to include NODE_WITNESS,
|
||||
# the getdata is just for the non-witness portion.
|
||||
self.old_node.announce_tx_and_wait_for_getdata(tx)
|
||||
assert(self.old_node.last_message["getdata"].inv[0].type == 1)
|
||||
assert self.old_node.last_message["getdata"].inv[0].type == 1
|
||||
|
||||
# Since we haven't delivered the tx yet, inv'ing the same tx from
|
||||
# a witness transaction ought not result in a getdata.
|
||||
|
@ -686,13 +684,13 @@ class SegWitTest(BitcoinTestFramework):
|
|||
if self.segwit_status != 'active':
|
||||
# Just check mempool acceptance, but don't add the transaction to the mempool, since witness is disallowed
|
||||
# in blocks and the tx is impossible to mine right now.
|
||||
assert_equal(self.nodes[0].testmempoolaccept([bytes_to_hex_str(tx3.serialize_with_witness())]), [{'txid': tx3.hash, 'allowed': True}])
|
||||
assert_equal(self.nodes[0].testmempoolaccept([tx3.serialize_with_witness().hex()]), [{'txid': tx3.hash, 'allowed': True}])
|
||||
# Create the same output as tx3, but by replacing tx
|
||||
tx3_out = tx3.vout[0]
|
||||
tx3 = tx
|
||||
tx3.vout = [tx3_out]
|
||||
tx3.rehash()
|
||||
assert_equal(self.nodes[0].testmempoolaccept([bytes_to_hex_str(tx3.serialize_with_witness())]), [{'txid': tx3.hash, 'allowed': True}])
|
||||
assert_equal(self.nodes[0].testmempoolaccept([tx3.serialize_with_witness().hex()]), [{'txid': tx3.hash, 'allowed': True}])
|
||||
test_transaction_acceptance(self.nodes[0], self.test_node, tx3, with_witness=True, accepted=True)
|
||||
|
||||
self.nodes[0].generate(1)
|
||||
|
@ -792,7 +790,7 @@ class SegWitTest(BitcoinTestFramework):
|
|||
block.solve()
|
||||
|
||||
# Test the test -- witness serialization should be different
|
||||
assert(msg_witness_block(block).serialize() != msg_block(block).serialize())
|
||||
assert msg_witness_block(block).serialize() != msg_block(block).serialize()
|
||||
|
||||
# This empty block should be valid.
|
||||
test_witness_block(self.nodes[0], self.test_node, block, accepted=True)
|
||||
|
@ -803,7 +801,7 @@ class SegWitTest(BitcoinTestFramework):
|
|||
block_2.solve()
|
||||
|
||||
# The commitment should have changed!
|
||||
assert(block_2.vtx[0].vout[-1] != block.vtx[0].vout[-1])
|
||||
assert block_2.vtx[0].vout[-1] != block.vtx[0].vout[-1]
|
||||
|
||||
# This should also be valid.
|
||||
test_witness_block(self.nodes[0], self.test_node, block_2, accepted=True)
|
||||
|
@ -850,7 +848,7 @@ class SegWitTest(BitcoinTestFramework):
|
|||
block_3.vtx[0].rehash()
|
||||
block_3.hashMerkleRoot = block_3.calc_merkle_root()
|
||||
block_3.rehash()
|
||||
assert(len(block_3.vtx[0].vout) == 4) # 3 OP_returns
|
||||
assert len(block_3.vtx[0].vout) == 4 # 3 OP_returns
|
||||
block_3.solve()
|
||||
test_witness_block(self.nodes[0], self.test_node, block_3, accepted=True)
|
||||
|
||||
|
@ -881,19 +879,19 @@ class SegWitTest(BitcoinTestFramework):
|
|||
block.solve()
|
||||
|
||||
block.vtx[0].wit.vtxinwit[0].scriptWitness.stack.append(b'a' * 5000000)
|
||||
assert(get_virtual_size(block) > MAX_BLOCK_BASE_SIZE)
|
||||
assert get_virtual_size(block) > MAX_BLOCK_BASE_SIZE
|
||||
|
||||
# We can't send over the p2p network, because this is too big to relay
|
||||
# TODO: repeat this test with a block that can be relayed
|
||||
self.nodes[0].submitblock(bytes_to_hex_str(block.serialize(True)))
|
||||
self.nodes[0].submitblock(block.serialize(True).hex())
|
||||
|
||||
assert(self.nodes[0].getbestblockhash() != block.hash)
|
||||
assert self.nodes[0].getbestblockhash() != block.hash
|
||||
|
||||
block.vtx[0].wit.vtxinwit[0].scriptWitness.stack.pop()
|
||||
assert(get_virtual_size(block) < MAX_BLOCK_BASE_SIZE)
|
||||
self.nodes[0].submitblock(bytes_to_hex_str(block.serialize(True)))
|
||||
assert get_virtual_size(block) < MAX_BLOCK_BASE_SIZE
|
||||
self.nodes[0].submitblock(block.serialize(True).hex())
|
||||
|
||||
assert(self.nodes[0].getbestblockhash() == block.hash)
|
||||
assert self.nodes[0].getbestblockhash() == block.hash
|
||||
|
||||
# Now make sure that malleating the witness reserved value doesn't
|
||||
# result in a block permanently marked bad.
|
||||
|
@ -918,7 +916,7 @@ class SegWitTest(BitcoinTestFramework):
|
|||
# Test that witness-bearing blocks are limited at ceil(base + wit/4) <= 1MB.
|
||||
block = self.build_next_block()
|
||||
|
||||
assert(len(self.utxo) > 0)
|
||||
assert len(self.utxo) > 0
|
||||
|
||||
# Create a P2WSH transaction.
|
||||
# The witness program will be a bunch of OP_2DROP's, followed by OP_TRUE.
|
||||
|
@ -940,7 +938,7 @@ class SegWitTest(BitcoinTestFramework):
|
|||
for i in range(NUM_OUTPUTS):
|
||||
parent_tx.vout.append(CTxOut(child_value, script_pubkey))
|
||||
parent_tx.vout[0].nValue -= 50000
|
||||
assert(parent_tx.vout[0].nValue > 0)
|
||||
assert parent_tx.vout[0].nValue > 0
|
||||
parent_tx.rehash()
|
||||
|
||||
child_tx = CTransaction()
|
||||
|
@ -970,7 +968,7 @@ class SegWitTest(BitcoinTestFramework):
|
|||
assert_equal(vsize, MAX_BLOCK_BASE_SIZE + 1)
|
||||
# Make sure that our test case would exceed the old max-network-message
|
||||
# limit
|
||||
assert(len(block.serialize(True)) > 2 * 1024 * 1024)
|
||||
assert len(block.serialize(True)) > 2 * 1024 * 1024
|
||||
|
||||
test_witness_block(self.nodes[0], self.test_node, block, accepted=False)
|
||||
|
||||
|
@ -980,7 +978,7 @@ class SegWitTest(BitcoinTestFramework):
|
|||
block.vtx[0].vout.pop()
|
||||
add_witness_commitment(block)
|
||||
block.solve()
|
||||
assert(get_virtual_size(block) == MAX_BLOCK_BASE_SIZE)
|
||||
assert get_virtual_size(block) == MAX_BLOCK_BASE_SIZE
|
||||
|
||||
test_witness_block(self.nodes[0], self.test_node, block, accepted=True)
|
||||
|
||||
|
@ -998,14 +996,14 @@ class SegWitTest(BitcoinTestFramework):
|
|||
add_witness_commitment(block, nonce=1)
|
||||
block.vtx[0].wit = CTxWitness() # drop the nonce
|
||||
block.solve()
|
||||
self.nodes[0].submitblock(bytes_to_hex_str(block.serialize(True)))
|
||||
assert(self.nodes[0].getbestblockhash() != block.hash)
|
||||
self.nodes[0].submitblock(block.serialize(True).hex())
|
||||
assert self.nodes[0].getbestblockhash() != block.hash
|
||||
|
||||
# Now redo commitment with the standard nonce, but let bitcoind fill it in.
|
||||
add_witness_commitment(block, nonce=0)
|
||||
block.vtx[0].wit = CTxWitness()
|
||||
block.solve()
|
||||
self.nodes[0].submitblock(bytes_to_hex_str(block.serialize(True)))
|
||||
self.nodes[0].submitblock(block.serialize(True).hex())
|
||||
assert_equal(self.nodes[0].getbestblockhash(), block.hash)
|
||||
|
||||
# This time, add a tx with non-empty witness, but don't supply
|
||||
|
@ -1020,9 +1018,9 @@ class SegWitTest(BitcoinTestFramework):
|
|||
block_2.vtx[0].vout.pop()
|
||||
block_2.vtx[0].wit = CTxWitness()
|
||||
|
||||
self.nodes[0].submitblock(bytes_to_hex_str(block_2.serialize(True)))
|
||||
self.nodes[0].submitblock(block_2.serialize(True).hex())
|
||||
# Tip should not advance!
|
||||
assert(self.nodes[0].getbestblockhash() != block_2.hash)
|
||||
assert self.nodes[0].getbestblockhash() != block_2.hash
|
||||
|
||||
@subtest
|
||||
def test_extra_witness_data(self):
|
||||
|
@ -1142,7 +1140,7 @@ class SegWitTest(BitcoinTestFramework):
|
|||
|
||||
# This program is 19 max pushes (9937 bytes), then 64 more opcode-bytes.
|
||||
long_witness_program = CScript([b'a' * 520] * 19 + [OP_DROP] * 63 + [OP_TRUE])
|
||||
assert(len(long_witness_program) == MAX_PROGRAM_LENGTH + 1)
|
||||
assert len(long_witness_program) == MAX_PROGRAM_LENGTH + 1
|
||||
long_witness_hash = sha256(long_witness_program)
|
||||
long_script_pubkey = CScript([OP_0, long_witness_hash])
|
||||
|
||||
|
@ -1166,7 +1164,7 @@ class SegWitTest(BitcoinTestFramework):
|
|||
|
||||
# Try again with one less byte in the witness program
|
||||
witness_program = CScript([b'a' * 520] * 19 + [OP_DROP] * 62 + [OP_TRUE])
|
||||
assert(len(witness_program) == MAX_PROGRAM_LENGTH)
|
||||
assert len(witness_program) == MAX_PROGRAM_LENGTH
|
||||
witness_hash = sha256(witness_program)
|
||||
script_pubkey = CScript([OP_0, witness_hash])
|
||||
|
||||
|
@ -1197,7 +1195,7 @@ class SegWitTest(BitcoinTestFramework):
|
|||
for i in range(10):
|
||||
tx.vout.append(CTxOut(int(value / 10), script_pubkey))
|
||||
tx.vout[0].nValue -= 1000
|
||||
assert(tx.vout[0].nValue >= 0)
|
||||
assert tx.vout[0].nValue >= 0
|
||||
|
||||
block = self.build_next_block()
|
||||
self.update_witness_block_with_transactions(block, [tx])
|
||||
|
@ -1347,8 +1345,8 @@ class SegWitTest(BitcoinTestFramework):
|
|||
assert_equal(raw_tx["vsize"], vsize)
|
||||
assert_equal(raw_tx["weight"], weight)
|
||||
assert_equal(len(raw_tx["vin"][0]["txinwitness"]), 1)
|
||||
assert_equal(raw_tx["vin"][0]["txinwitness"][0], hexlify(witness_program).decode('ascii'))
|
||||
assert(vsize != raw_tx["size"])
|
||||
assert_equal(raw_tx["vin"][0]["txinwitness"][0], witness_program.hex())
|
||||
assert vsize != raw_tx["size"]
|
||||
|
||||
# Cleanup: mine the transactions and update utxo for next test
|
||||
self.nodes[0].generate(1)
|
||||
|
@ -1398,7 +1396,7 @@ class SegWitTest(BitcoinTestFramework):
|
|||
|
||||
self.nodes[0].generate(1) # Mine all the transactions
|
||||
sync_blocks(self.nodes)
|
||||
assert(len(self.nodes[0].getrawmempool()) == 0)
|
||||
assert len(self.nodes[0].getrawmempool()) == 0
|
||||
|
||||
# Finally, verify that version 0 -> version 1 transactions
|
||||
# are non-standard
|
||||
|
@ -1667,7 +1665,7 @@ class SegWitTest(BitcoinTestFramework):
|
|||
# Create a slight bias for producing more utxos
|
||||
num_outputs = random.randint(1, 11)
|
||||
random.shuffle(temp_utxos)
|
||||
assert(len(temp_utxos) > num_inputs)
|
||||
assert len(temp_utxos) > num_inputs
|
||||
tx = CTransaction()
|
||||
total_value = 0
|
||||
for i in range(num_inputs):
|
||||
|
@ -1928,7 +1926,7 @@ class SegWitTest(BitcoinTestFramework):
|
|||
sync_blocks(self.nodes)
|
||||
|
||||
# Make sure that this peer thinks segwit has activated.
|
||||
assert(get_bip9_status(self.nodes[2], 'segwit')['status'] == "active")
|
||||
assert get_bip9_status(self.nodes[2], 'segwit')['status'] == "active"
|
||||
|
||||
# Make sure this peer's blocks match those of node0.
|
||||
height = self.nodes[2].getblockcount()
|
||||
|
@ -1955,7 +1953,7 @@ class SegWitTest(BitcoinTestFramework):
|
|||
extra_sigops_available = MAX_SIGOP_COST % sigops_per_script
|
||||
|
||||
# We chose the number of checkmultisigs/checksigs to make this work:
|
||||
assert(extra_sigops_available < 100) # steer clear of MAX_OPS_PER_SCRIPT
|
||||
assert extra_sigops_available < 100 # steer clear of MAX_OPS_PER_SCRIPT
|
||||
|
||||
# This script, when spent with the first
|
||||
# N(=MAX_SIGOP_COST//sigops_per_script) outputs of our transaction,
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2015-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2015-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Test processing of unrequested blocks.
|
||||
|
@ -114,7 +114,7 @@ class AcceptBlockTest(BitcoinTestFramework):
|
|||
if x['hash'] == block_h1f.hash:
|
||||
assert_equal(x['status'], "headers-only")
|
||||
tip_entry_found = True
|
||||
assert(tip_entry_found)
|
||||
assert tip_entry_found
|
||||
assert_raises_rpc_error(-1, "Block not found on disk", self.nodes[0].getblock, block_h1f.hash)
|
||||
|
||||
# 4. Send another two block that build on the fork.
|
||||
|
@ -131,7 +131,7 @@ class AcceptBlockTest(BitcoinTestFramework):
|
|||
if x['hash'] == block_h2f.hash:
|
||||
assert_equal(x['status'], "headers-only")
|
||||
tip_entry_found = True
|
||||
assert(tip_entry_found)
|
||||
assert tip_entry_found
|
||||
|
||||
# But this block should be accepted by node since it has equal work.
|
||||
self.nodes[0].getblock(block_h2f.hash)
|
||||
|
@ -150,7 +150,7 @@ class AcceptBlockTest(BitcoinTestFramework):
|
|||
if x['hash'] == block_h3.hash:
|
||||
assert_equal(x['status'], "headers-only")
|
||||
tip_entry_found = True
|
||||
assert(tip_entry_found)
|
||||
assert tip_entry_found
|
||||
self.nodes[0].getblock(block_h3.hash)
|
||||
|
||||
# But this block should be accepted by node since it has more work.
|
||||
|
@ -263,7 +263,7 @@ class AcceptBlockTest(BitcoinTestFramework):
|
|||
if x['hash'] == block_292.hash:
|
||||
assert_equal(x['status'], "headers-only")
|
||||
tip_entry_found = True
|
||||
assert(tip_entry_found)
|
||||
assert tip_entry_found
|
||||
assert_raises_rpc_error(-1, "Block not found on disk", self.nodes[0].getblock, block_292.hash)
|
||||
|
||||
test_node.send_message(msg_block(block_289f))
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2014-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2014-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Test running bitcoind with the -rpcbind and -rpcallowip options."""
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2014-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2014-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Test RPCs related to blockchainstate.
|
||||
|
@ -172,9 +172,9 @@ class BlockchainTest(BitcoinTestFramework):
|
|||
assert_equal(chaintxstats['txcount'], 2)
|
||||
assert_equal(chaintxstats['window_final_block_hash'], b1_hash)
|
||||
assert_equal(chaintxstats['window_block_count'], 0)
|
||||
assert('window_tx_count' not in chaintxstats)
|
||||
assert('window_interval' not in chaintxstats)
|
||||
assert('txrate' not in chaintxstats)
|
||||
assert 'window_tx_count' not in chaintxstats
|
||||
assert 'window_interval' not in chaintxstats
|
||||
assert 'txrate' not in chaintxstats
|
||||
|
||||
def _test_gettxoutsetinfo(self):
|
||||
node = self.nodes[0]
|
||||
|
|
|
@ -1,12 +1,12 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2015-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2015-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Test decoding scripts via decodescript RPC command."""
|
||||
|
||||
from test_framework.messages import CTransaction, sha256
|
||||
from test_framework.test_framework import BitcoinTestFramework
|
||||
from test_framework.util import assert_equal, bytes_to_hex_str, hex_str_to_bytes
|
||||
from test_framework.util import assert_equal, hex_str_to_bytes
|
||||
|
||||
from io import BytesIO
|
||||
|
||||
|
@ -81,7 +81,7 @@ class DecodeScriptTest(BitcoinTestFramework):
|
|||
rpc_result = self.nodes[0].decodescript(multisig_script)
|
||||
assert_equal('2 ' + public_key + ' ' + public_key + ' ' + public_key + ' 3 OP_CHECKMULTISIG', rpc_result['asm'])
|
||||
# multisig in P2WSH
|
||||
multisig_script_hash = bytes_to_hex_str(sha256(hex_str_to_bytes(multisig_script)))
|
||||
multisig_script_hash = sha256(hex_str_to_bytes(multisig_script)).hex()
|
||||
assert_equal('0 ' + multisig_script_hash, rpc_result['segwit']['asm'])
|
||||
|
||||
# 4) P2SH scriptPubKey
|
||||
|
@ -119,7 +119,7 @@ class DecodeScriptTest(BitcoinTestFramework):
|
|||
rpc_result = self.nodes[0].decodescript(cltv_script)
|
||||
assert_equal('OP_IF ' + public_key + ' OP_CHECKSIGVERIFY OP_ELSE 500000 OP_CHECKLOCKTIMEVERIFY OP_DROP OP_ENDIF ' + public_key + ' OP_CHECKSIG', rpc_result['asm'])
|
||||
# CLTV script in P2WSH
|
||||
cltv_script_hash = bytes_to_hex_str(sha256(hex_str_to_bytes(cltv_script)))
|
||||
cltv_script_hash = sha256(hex_str_to_bytes(cltv_script)).hex()
|
||||
assert_equal('0 ' + cltv_script_hash, rpc_result['segwit']['asm'])
|
||||
|
||||
# 7) P2PK scriptPubKey
|
||||
|
@ -196,7 +196,7 @@ class DecodeScriptTest(BitcoinTestFramework):
|
|||
# some more full transaction tests of varying specific scriptSigs. used instead of
|
||||
# tests in decodescript_script_sig because the decodescript RPC is specifically
|
||||
# for working on scriptPubKeys (argh!).
|
||||
push_signature = bytes_to_hex_str(txSave.vin[0].scriptSig)[2:(0x48*2+4)]
|
||||
push_signature = txSave.vin[0].scriptSig.hex()[2:(0x48*2+4)]
|
||||
signature = push_signature[2:]
|
||||
der_signature = signature[:-2]
|
||||
signature_sighash_decoded = der_signature + '[ALL]'
|
||||
|
@ -206,23 +206,23 @@ class DecodeScriptTest(BitcoinTestFramework):
|
|||
|
||||
# 1) P2PK scriptSig
|
||||
txSave.vin[0].scriptSig = hex_str_to_bytes(push_signature)
|
||||
rpc_result = self.nodes[0].decoderawtransaction(bytes_to_hex_str(txSave.serialize()))
|
||||
rpc_result = self.nodes[0].decoderawtransaction(txSave.serialize().hex())
|
||||
assert_equal(signature_sighash_decoded, rpc_result['vin'][0]['scriptSig']['asm'])
|
||||
|
||||
# make sure that the sighash decodes come out correctly for a more complex / lesser used case.
|
||||
txSave.vin[0].scriptSig = hex_str_to_bytes(push_signature_2)
|
||||
rpc_result = self.nodes[0].decoderawtransaction(bytes_to_hex_str(txSave.serialize()))
|
||||
rpc_result = self.nodes[0].decoderawtransaction(txSave.serialize().hex())
|
||||
assert_equal(signature_2_sighash_decoded, rpc_result['vin'][0]['scriptSig']['asm'])
|
||||
|
||||
# 2) multisig scriptSig
|
||||
txSave.vin[0].scriptSig = hex_str_to_bytes('00' + push_signature + push_signature_2)
|
||||
rpc_result = self.nodes[0].decoderawtransaction(bytes_to_hex_str(txSave.serialize()))
|
||||
rpc_result = self.nodes[0].decoderawtransaction(txSave.serialize().hex())
|
||||
assert_equal('0 ' + signature_sighash_decoded + ' ' + signature_2_sighash_decoded, rpc_result['vin'][0]['scriptSig']['asm'])
|
||||
|
||||
# 3) test a scriptSig that contains more than push operations.
|
||||
# in fact, it contains an OP_RETURN with data specially crafted to cause improper decode if the code does not catch it.
|
||||
txSave.vin[0].scriptSig = hex_str_to_bytes('6a143011020701010101010101020601010101010101')
|
||||
rpc_result = self.nodes[0].decoderawtransaction(bytes_to_hex_str(txSave.serialize()))
|
||||
rpc_result = self.nodes[0].decoderawtransaction(txSave.serialize().hex())
|
||||
assert_equal('OP_RETURN 3011020701010101010101020601010101010101', rpc_result['vin'][0]['scriptSig']['asm'])
|
||||
|
||||
def run_test(self):
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2017-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2017-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Test deprecation of RPC calls."""
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2018-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Test the deriveaddresses rpc call."""
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2014-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2014-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Test the fundrawtransaction RPC."""
|
||||
|
@ -94,7 +94,7 @@ class RawTransactionsTest(BitcoinTestFramework):
|
|||
rawtxfund = self.nodes[2].fundrawtransaction(rawtx)
|
||||
fee = rawtxfund['fee']
|
||||
dec_tx = self.nodes[2].decoderawtransaction(rawtxfund['hex'])
|
||||
assert(len(dec_tx['vin']) > 0) #test that we have enough inputs
|
||||
assert len(dec_tx['vin']) > 0 #test that we have enough inputs
|
||||
|
||||
##############################
|
||||
# simple test with two coins #
|
||||
|
@ -107,7 +107,7 @@ class RawTransactionsTest(BitcoinTestFramework):
|
|||
rawtxfund = self.nodes[2].fundrawtransaction(rawtx)
|
||||
fee = rawtxfund['fee']
|
||||
dec_tx = self.nodes[2].decoderawtransaction(rawtxfund['hex'])
|
||||
assert(len(dec_tx['vin']) > 0) #test if we have enough inputs
|
||||
assert len(dec_tx['vin']) > 0 #test if we have enough inputs
|
||||
|
||||
##############################
|
||||
# simple test with two coins #
|
||||
|
@ -120,7 +120,7 @@ class RawTransactionsTest(BitcoinTestFramework):
|
|||
rawtxfund = self.nodes[2].fundrawtransaction(rawtx)
|
||||
fee = rawtxfund['fee']
|
||||
dec_tx = self.nodes[2].decoderawtransaction(rawtxfund['hex'])
|
||||
assert(len(dec_tx['vin']) > 0)
|
||||
assert len(dec_tx['vin']) > 0
|
||||
assert_equal(dec_tx['vin'][0]['scriptSig']['hex'], '')
|
||||
|
||||
|
||||
|
@ -139,7 +139,7 @@ class RawTransactionsTest(BitcoinTestFramework):
|
|||
for out in dec_tx['vout']:
|
||||
totalOut += out['value']
|
||||
|
||||
assert(len(dec_tx['vin']) > 0)
|
||||
assert len(dec_tx['vin']) > 0
|
||||
assert_equal(dec_tx['vin'][0]['scriptSig']['hex'], '')
|
||||
|
||||
|
||||
|
@ -363,7 +363,7 @@ class RawTransactionsTest(BitcoinTestFramework):
|
|||
|
||||
#compare fee
|
||||
feeDelta = Decimal(fundedTx['fee']) - Decimal(signedFee)
|
||||
assert(feeDelta >= 0 and feeDelta <= feeTolerance)
|
||||
assert feeDelta >= 0 and feeDelta <= feeTolerance
|
||||
############################################################
|
||||
|
||||
############################################################
|
||||
|
@ -378,7 +378,7 @@ class RawTransactionsTest(BitcoinTestFramework):
|
|||
|
||||
#compare fee
|
||||
feeDelta = Decimal(fundedTx['fee']) - Decimal(signedFee)
|
||||
assert(feeDelta >= 0 and feeDelta <= feeTolerance)
|
||||
assert feeDelta >= 0 and feeDelta <= feeTolerance
|
||||
############################################################
|
||||
|
||||
|
||||
|
@ -405,7 +405,7 @@ class RawTransactionsTest(BitcoinTestFramework):
|
|||
|
||||
#compare fee
|
||||
feeDelta = Decimal(fundedTx['fee']) - Decimal(signedFee)
|
||||
assert(feeDelta >= 0 and feeDelta <= feeTolerance)
|
||||
assert feeDelta >= 0 and feeDelta <= feeTolerance
|
||||
############################################################
|
||||
|
||||
|
||||
|
@ -438,7 +438,7 @@ class RawTransactionsTest(BitcoinTestFramework):
|
|||
|
||||
#compare fee
|
||||
feeDelta = Decimal(fundedTx['fee']) - Decimal(signedFee)
|
||||
assert(feeDelta >= 0 and feeDelta <= feeTolerance)
|
||||
assert feeDelta >= 0 and feeDelta <= feeTolerance
|
||||
############################################################
|
||||
|
||||
|
||||
|
@ -558,7 +558,7 @@ class RawTransactionsTest(BitcoinTestFramework):
|
|||
|
||||
#compare fee
|
||||
feeDelta = Decimal(fundedTx['fee']) - Decimal(signedFee)
|
||||
assert(feeDelta >= 0 and feeDelta <= feeTolerance*19) #~19 inputs
|
||||
assert feeDelta >= 0 and feeDelta <= feeTolerance*19 #~19 inputs
|
||||
|
||||
|
||||
#############################################
|
||||
|
@ -620,7 +620,7 @@ class RawTransactionsTest(BitcoinTestFramework):
|
|||
assert_equal(len(res_dec["vin"]), 1)
|
||||
assert_equal(res_dec["vin"][0]["txid"], watchonly_txid)
|
||||
|
||||
assert("fee" in result.keys())
|
||||
assert "fee" in result.keys()
|
||||
assert_greater_than(result["changepos"], -1)
|
||||
|
||||
###############################################################
|
||||
|
@ -635,16 +635,16 @@ class RawTransactionsTest(BitcoinTestFramework):
|
|||
result = self.nodes[3].fundrawtransaction(rawtx, True)
|
||||
res_dec = self.nodes[0].decoderawtransaction(result["hex"])
|
||||
assert_equal(len(res_dec["vin"]), 2)
|
||||
assert(res_dec["vin"][0]["txid"] == watchonly_txid or res_dec["vin"][1]["txid"] == watchonly_txid)
|
||||
assert res_dec["vin"][0]["txid"] == watchonly_txid or res_dec["vin"][1]["txid"] == watchonly_txid
|
||||
|
||||
assert_greater_than(result["fee"], 0)
|
||||
assert_greater_than(result["changepos"], -1)
|
||||
assert_equal(result["fee"] + res_dec["vout"][result["changepos"]]["value"], watchonly_amount / 10)
|
||||
|
||||
signedtx = self.nodes[3].signrawtransactionwithwallet(result["hex"])
|
||||
assert(not signedtx["complete"])
|
||||
assert not signedtx["complete"]
|
||||
signedtx = self.nodes[0].signrawtransactionwithwallet(signedtx["hex"])
|
||||
assert(signedtx["complete"])
|
||||
assert signedtx["complete"]
|
||||
self.nodes[0].sendrawtransaction(signedtx["hex"])
|
||||
self.nodes[0].generate(1)
|
||||
self.sync_all()
|
||||
|
@ -676,10 +676,10 @@ class RawTransactionsTest(BitcoinTestFramework):
|
|||
for out in res_dec['vout']:
|
||||
if out['value'] > 1.0:
|
||||
changeaddress += out['scriptPubKey']['addresses'][0]
|
||||
assert(changeaddress != "")
|
||||
assert changeaddress != ""
|
||||
nextaddr = self.nodes[3].getnewaddress()
|
||||
# Now the change address key should be removed from the keypool
|
||||
assert(changeaddress != nextaddr)
|
||||
assert changeaddress != nextaddr
|
||||
|
||||
######################################
|
||||
# Test subtractFeeFromOutputs option #
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2017-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2017-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2016-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2016-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Test using named arguments for RPCs."""
|
||||
|
@ -17,7 +17,7 @@ class NamedArgumentTest(BitcoinTestFramework):
|
|||
def run_test(self):
|
||||
node = self.nodes[0]
|
||||
h = node.help(command='getblockchaininfo')
|
||||
assert(h.startswith('getblockchaininfo\n'))
|
||||
assert h.startswith('getblockchaininfo\n')
|
||||
|
||||
assert_raises_rpc_error(-8, 'Unknown named parameter', node.help, random='getblockchaininfo')
|
||||
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2015-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2015-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Test the preciousblock RPC."""
|
||||
|
@ -16,7 +16,7 @@ def unidirectional_node_sync_via_rpc(node_src, node_dest):
|
|||
blockhash = node_src.getbestblockhash()
|
||||
while True:
|
||||
try:
|
||||
assert(len(node_dest.getblock(blockhash, False)) > 0)
|
||||
assert len(node_dest.getblock(blockhash, False)) > 0
|
||||
break
|
||||
except:
|
||||
blocks_to_copy.append(blockhash)
|
||||
|
@ -24,7 +24,7 @@ def unidirectional_node_sync_via_rpc(node_src, node_dest):
|
|||
blocks_to_copy.reverse()
|
||||
for blockhash in blocks_to_copy:
|
||||
blockdata = node_src.getblock(blockhash, False)
|
||||
assert(node_dest.submitblock(blockdata) in (None, 'inconclusive'))
|
||||
assert node_dest.submitblock(blockdata) in (None, 'inconclusive')
|
||||
|
||||
def node_sync_via_rpc(nodes):
|
||||
for node_src in nodes:
|
||||
|
@ -57,7 +57,7 @@ class PreciousTest(BitcoinTestFramework):
|
|||
self.log.info("Mine competing blocks E-F-G on Node 1")
|
||||
hashG = self.nodes[1].generatetoaddress(3, gen_address(1))[-1]
|
||||
assert_equal(self.nodes[1].getblockcount(), 5)
|
||||
assert(hashC != hashG)
|
||||
assert hashC != hashG
|
||||
self.log.info("Connect nodes and check no reorg occurs")
|
||||
# Submit competing blocks via RPC so any reorg should occur before we proceed (no way to wait on inaction for p2p sync)
|
||||
node_sync_via_rpc(self.nodes[0:2])
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2018-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Test the Partially Signed Transaction RPCs.
|
||||
|
@ -47,11 +47,11 @@ class PSBTTest(BitcoinTestFramework):
|
|||
utxos = online_node.listunspent(addresses=[offline_addr])
|
||||
raw = online_node.createrawtransaction([{"txid":utxos[0]["txid"], "vout":utxos[0]["vout"]}],[{online_addr:0.9999}])
|
||||
psbt = online_node.walletprocesspsbt(online_node.converttopsbt(raw))["psbt"]
|
||||
assert("non_witness_utxo" in mining_node.decodepsbt(psbt)["inputs"][0])
|
||||
assert "non_witness_utxo" in mining_node.decodepsbt(psbt)["inputs"][0]
|
||||
|
||||
# Have the offline node sign the PSBT (which will update the UTXO to segwit)
|
||||
signed_psbt = offline_node.walletprocesspsbt(psbt)["psbt"]
|
||||
assert("witness_utxo" in mining_node.decodepsbt(signed_psbt)["inputs"][0])
|
||||
assert "witness_utxo" in mining_node.decodepsbt(signed_psbt)["inputs"][0]
|
||||
|
||||
# Make sure we can mine the resulting transaction
|
||||
txid = mining_node.sendrawtransaction(mining_node.finalizepsbt(signed_psbt)["hex"])
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2014-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2014-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Test the rawtransaction RPCs.
|
||||
|
@ -17,7 +17,7 @@ from decimal import Decimal
|
|||
from io import BytesIO
|
||||
from test_framework.messages import CTransaction, ToHex
|
||||
from test_framework.test_framework import BitcoinTestFramework
|
||||
from test_framework.util import assert_equal, assert_raises_rpc_error, bytes_to_hex_str, connect_nodes_bi, hex_str_to_bytes
|
||||
from test_framework.util import assert_equal, assert_raises_rpc_error, connect_nodes_bi, hex_str_to_bytes
|
||||
|
||||
class multidict(dict):
|
||||
"""Dictionary that allows duplicate keys.
|
||||
|
@ -119,21 +119,21 @@ class RawTransactionsTest(BitcoinTestFramework):
|
|||
tx.deserialize(BytesIO(hex_str_to_bytes(self.nodes[2].createrawtransaction(inputs=[{'txid': txid, 'vout': 9}], outputs={address: 99}))))
|
||||
assert_equal(len(tx.vout), 1)
|
||||
assert_equal(
|
||||
bytes_to_hex_str(tx.serialize()),
|
||||
tx.serialize().hex(),
|
||||
self.nodes[2].createrawtransaction(inputs=[{'txid': txid, 'vout': 9}], outputs=[{address: 99}]),
|
||||
)
|
||||
# Two outputs
|
||||
tx.deserialize(BytesIO(hex_str_to_bytes(self.nodes[2].createrawtransaction(inputs=[{'txid': txid, 'vout': 9}], outputs=OrderedDict([(address, 99), (address2, 99)])))))
|
||||
assert_equal(len(tx.vout), 2)
|
||||
assert_equal(
|
||||
bytes_to_hex_str(tx.serialize()),
|
||||
tx.serialize().hex(),
|
||||
self.nodes[2].createrawtransaction(inputs=[{'txid': txid, 'vout': 9}], outputs=[{address: 99}, {address2: 99}]),
|
||||
)
|
||||
# Multiple mixed outputs
|
||||
tx.deserialize(BytesIO(hex_str_to_bytes(self.nodes[2].createrawtransaction(inputs=[{'txid': txid, 'vout': 9}], outputs=multidict([(address, 99), (address2, 99), ('data', '99')])))))
|
||||
assert_equal(len(tx.vout), 3)
|
||||
assert_equal(
|
||||
bytes_to_hex_str(tx.serialize()),
|
||||
tx.serialize().hex(),
|
||||
self.nodes[2].createrawtransaction(inputs=[{'txid': txid, 'vout': 9}], outputs=[{address: 99}, {address2: 99}, {'data': '99'}]),
|
||||
)
|
||||
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2018-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Test the scantxoutset rpc call."""
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2016-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2016-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Test RPC commands for signing and verifying messages."""
|
||||
|
@ -25,18 +25,18 @@ class SignMessagesTest(BitcoinTestFramework):
|
|||
expected_signature = 'INbVnW4e6PeRmsv2Qgu8NuopvrVjkcxob+sX8OcZG0SALhWybUjzMLPdAsXI46YZGb0KQTRii+wWIQzRpG/U+S0='
|
||||
signature = self.nodes[0].signmessagewithprivkey(priv_key, message)
|
||||
assert_equal(expected_signature, signature)
|
||||
assert(self.nodes[0].verifymessage(address, signature, message))
|
||||
assert self.nodes[0].verifymessage(address, signature, message)
|
||||
|
||||
self.log.info('test signing with an address with wallet')
|
||||
address = self.nodes[0].getnewaddress()
|
||||
signature = self.nodes[0].signmessage(address, message)
|
||||
assert(self.nodes[0].verifymessage(address, signature, message))
|
||||
assert self.nodes[0].verifymessage(address, signature, message)
|
||||
|
||||
self.log.info('test verifying with another address should not work')
|
||||
other_address = self.nodes[0].getnewaddress()
|
||||
other_signature = self.nodes[0].signmessage(other_address, message)
|
||||
assert(not self.nodes[0].verifymessage(other_address, signature, message))
|
||||
assert(not self.nodes[0].verifymessage(address, other_signature, message))
|
||||
assert not self.nodes[0].verifymessage(other_address, signature, message)
|
||||
assert not self.nodes[0].verifymessage(address, other_signature, message)
|
||||
|
||||
if __name__ == '__main__':
|
||||
SignMessagesTest().main()
|
||||
|
|
|
@ -1,11 +1,11 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2015-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2015-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Test transaction signing using the signrawtransaction* RPCs."""
|
||||
|
||||
from test_framework.test_framework import BitcoinTestFramework
|
||||
from test_framework.util import assert_equal, assert_raises_rpc_error, bytes_to_hex_str, hex_str_to_bytes
|
||||
from test_framework.util import assert_equal, assert_raises_rpc_error, hex_str_to_bytes
|
||||
from test_framework.messages import sha256
|
||||
from test_framework.script import CScript, OP_0
|
||||
|
||||
|
@ -161,7 +161,7 @@ class SignRawTransactionsTest(BitcoinTestFramework):
|
|||
unspent_output = self.nodes[1].listunspent(0, 999999, [p2sh_p2wsh_address["address"]])[0]
|
||||
assert_equal(unspent_output["witnessScript"], p2sh_p2wsh_address["redeemScript"])
|
||||
p2sh_redeemScript = CScript([OP_0, sha256(hex_str_to_bytes(p2sh_p2wsh_address["redeemScript"]))])
|
||||
assert_equal(unspent_output["redeemScript"], bytes_to_hex_str(p2sh_redeemScript))
|
||||
assert_equal(unspent_output["redeemScript"], p2sh_redeemScript.hex())
|
||||
# Now create and sign a transaction spending that output on node[0], which doesn't know the scripts or keys
|
||||
spending_tx = self.nodes[0].createrawtransaction([unspent_output], {self.nodes[1].getnewaddress(): Decimal("49.998")})
|
||||
spending_tx_signed = self.nodes[0].signrawtransactionwithkey(spending_tx, [embedded_privkey], [unspent_output])
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2017-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2017-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Test the RPC call related to the uptime command.
|
||||
|
@ -23,7 +23,7 @@ class UptimeTest(BitcoinTestFramework):
|
|||
def _test_uptime(self):
|
||||
wait_time = 10
|
||||
self.nodes[0].setmocktime(int(time.time() + wait_time))
|
||||
assert(self.nodes[0].uptime() >= wait_time)
|
||||
assert self.nodes[0].uptime() >= wait_time
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
|
|
|
@ -1,11 +1,11 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2016-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2016-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Encode and decode BASE58, P2PKH and P2SH addresses."""
|
||||
|
||||
from .script import hash256, hash160, sha256, CScript, OP_0
|
||||
from .util import bytes_to_hex_str, hex_str_to_bytes
|
||||
from .util import hex_str_to_bytes
|
||||
|
||||
from . import segwit_addr
|
||||
|
||||
|
@ -16,9 +16,9 @@ chars = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
|
|||
|
||||
def byte_to_base58(b, version):
|
||||
result = ''
|
||||
str = bytes_to_hex_str(b)
|
||||
str = bytes_to_hex_str(chr(version).encode('latin-1')) + str
|
||||
checksum = bytes_to_hex_str(hash256(hex_str_to_bytes(str)))
|
||||
str = b.hex()
|
||||
str = chr(version).encode('latin-1').hex() + str
|
||||
checksum = hash256(hex_str_to_bytes(str)).hex()
|
||||
str += checksum[:8]
|
||||
value = int('0x'+str,0)
|
||||
while value > 0:
|
||||
|
@ -32,12 +32,12 @@ def byte_to_base58(b, version):
|
|||
# TODO: def base58_decode
|
||||
|
||||
def keyhash_to_p2pkh(hash, main = False):
|
||||
assert (len(hash) == 20)
|
||||
assert len(hash) == 20
|
||||
version = 0 if main else 111
|
||||
return byte_to_base58(hash, version)
|
||||
|
||||
def scripthash_to_p2sh(hash, main = False):
|
||||
assert (len(hash) == 20)
|
||||
assert len(hash) == 20
|
||||
version = 5 if main else 196
|
||||
return byte_to_base58(hash, version)
|
||||
|
||||
|
@ -80,11 +80,11 @@ def check_key(key):
|
|||
key = hex_str_to_bytes(key) # Assuming this is hex string
|
||||
if (type(key) is bytes and (len(key) == 33 or len(key) == 65)):
|
||||
return key
|
||||
assert(False)
|
||||
assert False
|
||||
|
||||
def check_script(script):
|
||||
if (type(script) is str):
|
||||
script = hex_str_to_bytes(script) # Assuming this is hex string
|
||||
if (type(script) is bytes or type(script) is CScript):
|
||||
return script
|
||||
assert(False)
|
||||
assert False
|
||||
|
|
|
@ -20,7 +20,6 @@ from .messages import (
|
|||
CTxOut,
|
||||
FromHex,
|
||||
ToHex,
|
||||
bytes_to_hex_str,
|
||||
hash256,
|
||||
hex_str_to_bytes,
|
||||
ser_string,
|
||||
|
@ -132,7 +131,7 @@ def create_tx_with_script(prevtx, n, script_sig=b"", *, amount, script_pub_key=C
|
|||
Can optionally pass scriptPubKey and scriptSig, default is anyone-can-spend output.
|
||||
"""
|
||||
tx = CTransaction()
|
||||
assert(n < len(prevtx.vout))
|
||||
assert n < len(prevtx.vout)
|
||||
tx.vin.append(CTxIn(COutPoint(prevtx.sha256, n), script_sig, 0xffffffff))
|
||||
tx.vout.append(CTxOut(amount, script_pub_key))
|
||||
tx.calc_sha256()
|
||||
|
@ -190,7 +189,7 @@ def witness_script(use_p2wsh, pubkey):
|
|||
witness_program = CScript([OP_1, hex_str_to_bytes(pubkey), OP_1, OP_CHECKMULTISIG])
|
||||
scripthash = sha256(witness_program)
|
||||
pkscript = CScript([OP_0, scripthash])
|
||||
return bytes_to_hex_str(pkscript)
|
||||
return pkscript.hex()
|
||||
|
||||
def create_witness_tx(node, use_p2wsh, utxo, pubkey, encode_p2sh, amount):
|
||||
"""Return a transaction (in hex) that spends the given utxo to a segwit output.
|
||||
|
@ -215,7 +214,7 @@ def send_to_witness(use_p2wsh, node, utxo, pubkey, encode_p2sh, amount, sign=Tru
|
|||
tx_to_witness = create_witness_tx(node, use_p2wsh, utxo, pubkey, encode_p2sh, amount)
|
||||
if (sign):
|
||||
signed = node.signrawtransactionwithwallet(tx_to_witness)
|
||||
assert("errors" not in signed or len(["errors"]) == 0)
|
||||
assert "errors" not in signed or len(["errors"]) == 0
|
||||
return node.sendrawtransaction(signed["hex"])
|
||||
else:
|
||||
if (insert_redeem_script):
|
||||
|
|
|
@ -1,7 +1,7 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2010 ArtForz -- public domain half-a-node
|
||||
# Copyright (c) 2012 Jeff Garzik
|
||||
# Copyright (c) 2010-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2010-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Bitcoin test framework primitive and message structures
|
||||
|
@ -28,7 +28,7 @@ import struct
|
|||
import time
|
||||
|
||||
from test_framework.siphash import siphash256
|
||||
from test_framework.util import hex_str_to_bytes, bytes_to_hex_str, assert_equal
|
||||
from test_framework.util import hex_str_to_bytes, assert_equal
|
||||
|
||||
MIN_VERSION_SUPPORTED = 60001
|
||||
MY_VERSION = 70014 # past bip-31 for ping/pong
|
||||
|
@ -181,7 +181,7 @@ def FromHex(obj, hex_string):
|
|||
|
||||
# Convert a binary-serializable object to hex (eg for submission via RPC)
|
||||
def ToHex(obj):
|
||||
return bytes_to_hex_str(obj.serialize())
|
||||
return obj.serialize().hex()
|
||||
|
||||
# Objects that map to bitcoind objects, which can be serialized/deserialized
|
||||
|
||||
|
@ -319,7 +319,7 @@ class CTxIn:
|
|||
|
||||
def __repr__(self):
|
||||
return "CTxIn(prevout=%s scriptSig=%s nSequence=%i)" \
|
||||
% (repr(self.prevout), bytes_to_hex_str(self.scriptSig),
|
||||
% (repr(self.prevout), self.scriptSig.hex(),
|
||||
self.nSequence)
|
||||
|
||||
|
||||
|
@ -343,7 +343,7 @@ class CTxOut:
|
|||
def __repr__(self):
|
||||
return "CTxOut(nValue=%i.%08i scriptPubKey=%s)" \
|
||||
% (self.nValue // COIN, self.nValue % COIN,
|
||||
bytes_to_hex_str(self.scriptPubKey))
|
||||
self.scriptPubKey.hex())
|
||||
|
||||
|
||||
class CScriptWitness:
|
||||
|
@ -355,7 +355,7 @@ class CScriptWitness:
|
|||
|
||||
def __repr__(self):
|
||||
return "CScriptWitness(%s)" % \
|
||||
(",".join([bytes_to_hex_str(x) for x in self.stack]))
|
||||
(",".join([x.hex() for x in self.stack]))
|
||||
|
||||
def is_null(self):
|
||||
if self.stack:
|
||||
|
|
|
@ -1,7 +1,7 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2010 ArtForz -- public domain half-a-node
|
||||
# Copyright (c) 2012 Jeff Garzik
|
||||
# Copyright (c) 2010-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2010-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Bitcoin P2P network half-a-node.
|
||||
|
@ -218,10 +218,7 @@ class P2PConnection(asyncio.Protocol):
|
|||
def maybe_write():
|
||||
if not self._transport:
|
||||
return
|
||||
# Python <3.4.4 does not have is_closing, so we have to check for
|
||||
# its existence explicitly as long as Bitcoin Core supports all
|
||||
# Python 3.4 versions.
|
||||
if hasattr(self._transport, 'is_closing') and self._transport.is_closing():
|
||||
if self._transport.is_closing():
|
||||
return
|
||||
self._transport.write(raw_message_bytes)
|
||||
NetworkThread.network_event_loop.call_soon_threadsafe(maybe_write)
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2014-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2014-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Linux network utilities.
|
||||
|
@ -12,7 +12,7 @@ import socket
|
|||
import struct
|
||||
import array
|
||||
import os
|
||||
from binascii import unhexlify, hexlify
|
||||
from binascii import unhexlify
|
||||
|
||||
# STATE_ESTABLISHED = '01'
|
||||
# STATE_SYN_SENT = '02'
|
||||
|
@ -129,17 +129,17 @@ def addr_to_hex(addr):
|
|||
if i == 0 or i == (len(addr)-1): # skip empty component at beginning or end
|
||||
continue
|
||||
x += 1 # :: skips to suffix
|
||||
assert(x < 2)
|
||||
assert x < 2
|
||||
else: # two bytes per component
|
||||
val = int(comp, 16)
|
||||
sub[x].append(val >> 8)
|
||||
sub[x].append(val & 0xff)
|
||||
nullbytes = 16 - len(sub[0]) - len(sub[1])
|
||||
assert((x == 0 and nullbytes == 0) or (x == 1 and nullbytes > 0))
|
||||
assert (x == 0 and nullbytes == 0) or (x == 1 and nullbytes > 0)
|
||||
addr = sub[0] + ([0] * nullbytes) + sub[1]
|
||||
else:
|
||||
raise ValueError('Could not parse address %s' % addr)
|
||||
return hexlify(bytearray(addr)).decode('ascii')
|
||||
return bytearray(addr).hex()
|
||||
|
||||
def test_ipv6_local():
|
||||
'''
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2015-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2015-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Functionality to build scripts, as well as SignatureHash().
|
||||
|
@ -9,7 +9,6 @@ This file is modified from python-bitcoinlib.
|
|||
|
||||
from .messages import CTransaction, CTxOut, sha256, hash256, uint256_from_str, ser_uint256, ser_string
|
||||
|
||||
from binascii import hexlify
|
||||
import hashlib
|
||||
import struct
|
||||
|
||||
|
@ -450,10 +449,6 @@ class CScript(bytes):
|
|||
# join makes no sense for a CScript()
|
||||
raise NotImplementedError
|
||||
|
||||
# Python 3.4 compatibility
|
||||
def hex(self):
|
||||
return hexlify(self).decode('ascii')
|
||||
|
||||
def __new__(cls, value=b''):
|
||||
if isinstance(value, bytes) or isinstance(value, bytearray):
|
||||
return super(CScript, cls).__new__(cls, value)
|
||||
|
@ -545,7 +540,7 @@ class CScript(bytes):
|
|||
def __repr__(self):
|
||||
def _repr(o):
|
||||
if isinstance(o, bytes):
|
||||
return "x('%s')" % hexlify(o).decode('ascii')
|
||||
return "x('%s')" % o.hex()
|
||||
else:
|
||||
return repr(o)
|
||||
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2015-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2015-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Dummy Socks5 server for testing."""
|
||||
|
@ -144,7 +144,7 @@ class Socks5Server():
|
|||
thread.start()
|
||||
|
||||
def start(self):
|
||||
assert(not self.running)
|
||||
assert not self.running
|
||||
self.running = True
|
||||
self.thread = threading.Thread(None, self.run)
|
||||
self.thread.daemon = True
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2014-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2014-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Base class for RPC testing."""
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2017-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2017-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Class for bitcoind node under test"""
|
||||
|
@ -31,9 +31,6 @@ from .util import (
|
|||
p2p_port,
|
||||
)
|
||||
|
||||
# For Python 3.4 compatibility
|
||||
JSONDecodeError = getattr(json, "JSONDecodeError", ValueError)
|
||||
|
||||
BITCOIND_PROC_WAIT_TIMEOUT = 60
|
||||
|
||||
|
||||
|
@ -565,5 +562,5 @@ class TestNodeCLI():
|
|||
raise subprocess.CalledProcessError(returncode, self.binary, output=cli_stderr)
|
||||
try:
|
||||
return json.loads(cli_stdout, parse_float=decimal.Decimal)
|
||||
except JSONDecodeError:
|
||||
except json.JSONDecodeError:
|
||||
return cli_stdout.rstrip("\n")
|
||||
|
|
|
@ -1,11 +1,11 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2014-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2014-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Helpful routines for regression testing."""
|
||||
|
||||
from base64 import b64encode
|
||||
from binascii import hexlify, unhexlify
|
||||
from binascii import unhexlify
|
||||
from decimal import Decimal, ROUND_DOWN
|
||||
import hashlib
|
||||
import inspect
|
||||
|
@ -182,9 +182,6 @@ def check_json_precision():
|
|||
def count_bytes(hex_string):
|
||||
return len(bytearray.fromhex(hex_string))
|
||||
|
||||
def bytes_to_hex_str(byte_str):
|
||||
return hexlify(byte_str).decode('ascii')
|
||||
|
||||
def hash256(byte_str):
|
||||
sha256 = hashlib.sha256()
|
||||
sha256.update(byte_str)
|
||||
|
@ -267,7 +264,7 @@ def get_rpc_proxy(url, node_number, timeout=None, coveragedir=None):
|
|||
return coverage.AuthServiceProxyWrapper(proxy, coverage_logfile)
|
||||
|
||||
def p2p_port(n):
|
||||
assert(n <= MAX_NODES)
|
||||
assert n <= MAX_NODES
|
||||
return PORT_MIN + n + (MAX_NODES * PortSeed.n) % (PORT_RANGE - 1 - MAX_NODES)
|
||||
|
||||
def rpc_port(n):
|
||||
|
@ -425,7 +422,7 @@ def gather_inputs(from_node, amount_needed, confirmations_required=1):
|
|||
"""
|
||||
Return a random set of unspent txouts that are enough to pay amount_needed
|
||||
"""
|
||||
assert(confirmations_required >= 0)
|
||||
assert confirmations_required >= 0
|
||||
utxo = from_node.listunspent(confirmations_required)
|
||||
random.shuffle(utxo)
|
||||
inputs = []
|
||||
|
@ -503,7 +500,7 @@ def create_confirmed_utxos(fee, node, count):
|
|||
node.generate(1)
|
||||
|
||||
utxos = node.listunspent()
|
||||
assert(len(utxos) >= count)
|
||||
assert len(utxos) >= count
|
||||
return utxos
|
||||
|
||||
# Create large OP_RETURN txouts that can be appended to a transaction
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2014-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2014-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Run regression test suite.
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2017-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2017-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Test that the wallet can send and receive using all combinations of address types.
|
||||
|
@ -102,62 +102,62 @@ class AddressTypeTest(BitcoinTestFramework):
|
|||
def test_address(self, node, address, multisig, typ):
|
||||
"""Run sanity checks on an address."""
|
||||
info = self.nodes[node].getaddressinfo(address)
|
||||
assert(self.nodes[node].validateaddress(address)['isvalid'])
|
||||
assert self.nodes[node].validateaddress(address)['isvalid']
|
||||
assert_equal(info.get('solvable'), True)
|
||||
|
||||
if not multisig and typ == 'legacy':
|
||||
# P2PKH
|
||||
assert(not info['isscript'])
|
||||
assert(not info['iswitness'])
|
||||
assert('pubkey' in info)
|
||||
assert not info['isscript']
|
||||
assert not info['iswitness']
|
||||
assert 'pubkey' in info
|
||||
elif not multisig and typ == 'p2sh-segwit':
|
||||
# P2SH-P2WPKH
|
||||
assert(info['isscript'])
|
||||
assert(not info['iswitness'])
|
||||
assert info['isscript']
|
||||
assert not info['iswitness']
|
||||
assert_equal(info['script'], 'witness_v0_keyhash')
|
||||
assert('pubkey' in info)
|
||||
assert 'pubkey' in info
|
||||
elif not multisig and typ == 'bech32':
|
||||
# P2WPKH
|
||||
assert(not info['isscript'])
|
||||
assert(info['iswitness'])
|
||||
assert not info['isscript']
|
||||
assert info['iswitness']
|
||||
assert_equal(info['witness_version'], 0)
|
||||
assert_equal(len(info['witness_program']), 40)
|
||||
assert('pubkey' in info)
|
||||
assert 'pubkey' in info
|
||||
elif typ == 'legacy':
|
||||
# P2SH-multisig
|
||||
assert(info['isscript'])
|
||||
assert info['isscript']
|
||||
assert_equal(info['script'], 'multisig')
|
||||
assert(not info['iswitness'])
|
||||
assert('pubkeys' in info)
|
||||
assert not info['iswitness']
|
||||
assert 'pubkeys' in info
|
||||
elif typ == 'p2sh-segwit':
|
||||
# P2SH-P2WSH-multisig
|
||||
assert(info['isscript'])
|
||||
assert info['isscript']
|
||||
assert_equal(info['script'], 'witness_v0_scripthash')
|
||||
assert(not info['iswitness'])
|
||||
assert(info['embedded']['isscript'])
|
||||
assert not info['iswitness']
|
||||
assert info['embedded']['isscript']
|
||||
assert_equal(info['embedded']['script'], 'multisig')
|
||||
assert(info['embedded']['iswitness'])
|
||||
assert info['embedded']['iswitness']
|
||||
assert_equal(info['embedded']['witness_version'], 0)
|
||||
assert_equal(len(info['embedded']['witness_program']), 64)
|
||||
assert('pubkeys' in info['embedded'])
|
||||
assert 'pubkeys' in info['embedded']
|
||||
elif typ == 'bech32':
|
||||
# P2WSH-multisig
|
||||
assert(info['isscript'])
|
||||
assert info['isscript']
|
||||
assert_equal(info['script'], 'multisig')
|
||||
assert(info['iswitness'])
|
||||
assert info['iswitness']
|
||||
assert_equal(info['witness_version'], 0)
|
||||
assert_equal(len(info['witness_program']), 64)
|
||||
assert('pubkeys' in info)
|
||||
assert 'pubkeys' in info
|
||||
else:
|
||||
# Unknown type
|
||||
assert(False)
|
||||
assert False
|
||||
|
||||
def test_desc(self, node, address, multisig, typ, utxo):
|
||||
"""Run sanity checks on a descriptor reported by getaddressinfo."""
|
||||
info = self.nodes[node].getaddressinfo(address)
|
||||
assert('desc' in info)
|
||||
assert 'desc' in info
|
||||
assert_equal(info['desc'], utxo['desc'])
|
||||
assert(self.nodes[node].validateaddress(address)['isvalid'])
|
||||
assert self.nodes[node].validateaddress(address)['isvalid']
|
||||
|
||||
# Use a ridiculously roundabout way to find the key origin info through
|
||||
# the PSBT logic. However, this does test consistency between the PSBT reported
|
||||
|
@ -172,11 +172,11 @@ class AddressTypeTest(BitcoinTestFramework):
|
|||
key_descs[deriv['pubkey']] = '[' + deriv['master_fingerprint'] + deriv['path'][1:] + ']' + deriv['pubkey']
|
||||
|
||||
# Verify the descriptor checksum against the Python implementation
|
||||
assert(descsum_check(info['desc']))
|
||||
assert descsum_check(info['desc'])
|
||||
# Verify that stripping the checksum and recreating it using Python roundtrips
|
||||
assert(info['desc'] == descsum_create(info['desc'][:-9]))
|
||||
assert info['desc'] == descsum_create(info['desc'][:-9])
|
||||
# Verify that stripping the checksum and feeding it to getdescriptorinfo roundtrips
|
||||
assert(info['desc'] == self.nodes[0].getdescriptorinfo(info['desc'][:-9])['descriptor'])
|
||||
assert info['desc'] == self.nodes[0].getdescriptorinfo(info['desc'][:-9])['descriptor']
|
||||
|
||||
if not multisig and typ == 'legacy':
|
||||
# P2PKH
|
||||
|
@ -198,7 +198,7 @@ class AddressTypeTest(BitcoinTestFramework):
|
|||
assert_equal(info['desc'], descsum_create("wsh(multi(2,%s,%s))" % (key_descs[info['pubkeys'][0]], key_descs[info['pubkeys'][1]])))
|
||||
else:
|
||||
# Unknown type
|
||||
assert(False)
|
||||
assert False
|
||||
|
||||
def test_change_output_type(self, node_sender, destinations, expected_type):
|
||||
txid = self.nodes[node_sender].sendmany(dummy="", amounts=dict.fromkeys(destinations, 0.001))
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2016-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2016-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Test the bumpfee RPC.
|
||||
|
@ -19,7 +19,7 @@ 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
|
||||
from test_framework.util import assert_equal, assert_greater_than, assert_raises_rpc_error, connect_nodes_bi, hex_str_to_bytes, sync_mempools
|
||||
|
||||
WALLET_PASSPHRASE = "test"
|
||||
WALLET_PASSPHRASE_TIMEOUT = 3600
|
||||
|
@ -298,7 +298,7 @@ def submit_block_with_tx(node, tx):
|
|||
block.hashMerkleRoot = block.calc_merkle_root()
|
||||
add_witness_commitment(block)
|
||||
block.solve()
|
||||
node.submitblock(bytes_to_hex_str(block.serialize(True)))
|
||||
node.submitblock(block.serialize(True).hex())
|
||||
return block
|
||||
|
||||
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2018-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2018-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Test createwallet arguments.
|
||||
|
@ -40,8 +40,8 @@ class CreateWalletTest(BitcoinTestFramework):
|
|||
privkey = w0.dumpprivkey(addr)
|
||||
assert_raises_rpc_error(-4, 'Cannot import private keys to a wallet with private keys disabled', w1.importprivkey, privkey)
|
||||
result = w1.importmulti([{'scriptPubKey': {'address': addr}, 'timestamp': 'now', 'keys': [privkey]}])
|
||||
assert(not result[0]['success'])
|
||||
assert('warning' not in result[0])
|
||||
assert not result[0]['success']
|
||||
assert 'warning' not in result[0]
|
||||
assert_equal(result[0]['error']['code'], -4)
|
||||
assert_equal(result[0]['error']['message'], 'Cannot import private keys to a wallet with private keys disabled')
|
||||
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2015-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2015-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Test a node with the -disablewallet option.
|
||||
|
@ -21,9 +21,9 @@ class DisableWalletTest (BitcoinTestFramework):
|
|||
# Make sure wallet is really disabled
|
||||
assert_raises_rpc_error(-32601, 'Method not found', self.nodes[0].getwalletinfo)
|
||||
x = self.nodes[0].validateaddress('3J98t1WpEZ73CNmQviecrnyiWrnqRhWNLy')
|
||||
assert(x['isvalid'] == False)
|
||||
assert x['isvalid'] == False
|
||||
x = self.nodes[0].validateaddress('mneYUmWYsuk7kySiURxCi3AGxrAqZxLgPZ')
|
||||
assert(x['isvalid'] == True)
|
||||
assert x['isvalid'] == True
|
||||
|
||||
# Checking mining to an address without a wallet. Generating to a valid address should succeed
|
||||
# but generating to an invalid address will fail.
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2016-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2016-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Test the dumpwallet RPC."""
|
||||
|
@ -46,10 +46,10 @@ def read_dump(file_name, addrs, script_addrs, hd_master_addr_old):
|
|||
keypath = None
|
||||
if keytype == "inactivehdseed=1":
|
||||
# ensure the old master is still available
|
||||
assert (hd_master_addr_old == addr)
|
||||
assert hd_master_addr_old == addr
|
||||
elif keytype == "hdseed=1":
|
||||
# ensure we have generated a new hd master key
|
||||
assert (hd_master_addr_old != addr)
|
||||
assert hd_master_addr_old != addr
|
||||
hd_master_addr_ret = addr
|
||||
elif keytype == "script=1":
|
||||
# scripts don't have keypaths
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2016-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2016-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Test Hierarchical Deterministic wallet function."""
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2014-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2014-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Test the importmulti RPC.
|
||||
|
@ -25,7 +25,6 @@ from test_framework.util import (
|
|||
assert_equal,
|
||||
assert_greater_than,
|
||||
assert_raises_rpc_error,
|
||||
bytes_to_hex_str,
|
||||
)
|
||||
from test_framework.wallet_util import (
|
||||
get_key,
|
||||
|
@ -127,7 +126,7 @@ class ImportMultiTest(BitcoinTestFramework):
|
|||
|
||||
# Nonstandard scriptPubKey + !internal
|
||||
self.log.info("Should not import a nonstandard scriptPubKey without internal flag")
|
||||
nonstandardScriptPubKey = key.p2pkh_script + bytes_to_hex_str(CScript([OP_NOP]))
|
||||
nonstandardScriptPubKey = key.p2pkh_script + CScript([OP_NOP]).hex()
|
||||
key = get_key(self.nodes[0])
|
||||
self.test_importmulti({"scriptPubKey": nonstandardScriptPubKey,
|
||||
"timestamp": "now"},
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2014-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2014-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Test the wallet keypool and interaction with wallet encryption/locking."""
|
||||
|
@ -21,7 +21,7 @@ class KeyPoolTest(BitcoinTestFramework):
|
|||
addr_before_encrypting = nodes[0].getnewaddress()
|
||||
addr_before_encrypting_data = nodes[0].getaddressinfo(addr_before_encrypting)
|
||||
wallet_info_old = nodes[0].getwalletinfo()
|
||||
assert(addr_before_encrypting_data['hdseedid'] == wallet_info_old['hdseedid'])
|
||||
assert addr_before_encrypting_data['hdseedid'] == wallet_info_old['hdseedid']
|
||||
|
||||
# Encrypt wallet and wait to terminate
|
||||
nodes[0].encryptwallet('test')
|
||||
|
@ -29,8 +29,8 @@ class KeyPoolTest(BitcoinTestFramework):
|
|||
addr = nodes[0].getnewaddress()
|
||||
addr_data = nodes[0].getaddressinfo(addr)
|
||||
wallet_info = nodes[0].getwalletinfo()
|
||||
assert(addr_before_encrypting_data['hdseedid'] != wallet_info['hdseedid'])
|
||||
assert(addr_data['hdseedid'] == wallet_info['hdseedid'])
|
||||
assert addr_before_encrypting_data['hdseedid'] != wallet_info['hdseedid']
|
||||
assert addr_data['hdseedid'] == wallet_info['hdseedid']
|
||||
assert_raises_rpc_error(-12, "Error: Keypool ran out, please call keypoolrefill first", nodes[0].getnewaddress)
|
||||
|
||||
# put six (plus 2) new keys in the keypool (100% external-, +100% internal-keys, 1 in min)
|
||||
|
@ -59,7 +59,7 @@ class KeyPoolTest(BitcoinTestFramework):
|
|||
addr.add(nodes[0].getnewaddress())
|
||||
addr.add(nodes[0].getnewaddress())
|
||||
addr.add(nodes[0].getnewaddress())
|
||||
assert(len(addr) == 6)
|
||||
assert len(addr) == 6
|
||||
# the next one should fail
|
||||
assert_raises_rpc_error(-12, "Error: Keypool ran out, please call keypoolrefill first", nodes[0].getnewaddress)
|
||||
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2017-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2017-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Test HD Wallet keypool restore function.
|
||||
|
@ -55,11 +55,11 @@ class KeypoolRestoreTest(BitcoinTestFramework):
|
|||
# Make sure we're creating the outputs we expect
|
||||
address_details = self.nodes[idx].validateaddress(addr_extpool)
|
||||
if i == 0:
|
||||
assert(not address_details["isscript"] and not address_details["iswitness"])
|
||||
assert not address_details["isscript"] and not address_details["iswitness"]
|
||||
elif i == 1:
|
||||
assert(address_details["isscript"] and not address_details["iswitness"])
|
||||
assert address_details["isscript"] and not address_details["iswitness"]
|
||||
else:
|
||||
assert(not address_details["isscript"] and address_details["iswitness"])
|
||||
assert not address_details["isscript"] and address_details["iswitness"]
|
||||
|
||||
|
||||
self.log.info("Send funds to wallet")
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2014-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2014-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Test the listtransactions API."""
|
||||
|
@ -11,7 +11,6 @@ from test_framework.test_framework import BitcoinTestFramework
|
|||
from test_framework.util import (
|
||||
assert_array_result,
|
||||
assert_equal,
|
||||
bytes_to_hex_str,
|
||||
hex_str_to_bytes,
|
||||
sync_mempools,
|
||||
)
|
||||
|
@ -126,7 +125,7 @@ class ListTransactionsTest(BitcoinTestFramework):
|
|||
|
||||
# 1. Chain a few transactions that don't opt-in.
|
||||
txid_1 = self.nodes[0].sendtoaddress(self.nodes[1].getnewaddress(), 1)
|
||||
assert(not is_opt_in(self.nodes[0], txid_1))
|
||||
assert not is_opt_in(self.nodes[0], txid_1)
|
||||
assert_array_result(self.nodes[0].listtransactions(), {"txid": txid_1}, {"bip125-replaceable": "no"})
|
||||
sync_mempools(self.nodes)
|
||||
assert_array_result(self.nodes[1].listtransactions(), {"txid": txid_1}, {"bip125-replaceable": "no"})
|
||||
|
@ -146,7 +145,7 @@ class ListTransactionsTest(BitcoinTestFramework):
|
|||
txid_2 = self.nodes[1].sendrawtransaction(tx2_signed)
|
||||
|
||||
# ...and check the result
|
||||
assert(not is_opt_in(self.nodes[1], txid_2))
|
||||
assert not is_opt_in(self.nodes[1], txid_2)
|
||||
assert_array_result(self.nodes[1].listtransactions(), {"txid": txid_2}, {"bip125-replaceable": "no"})
|
||||
sync_mempools(self.nodes)
|
||||
assert_array_result(self.nodes[0].listtransactions(), {"txid": txid_2}, {"bip125-replaceable": "no"})
|
||||
|
@ -158,11 +157,11 @@ class ListTransactionsTest(BitcoinTestFramework):
|
|||
tx3 = self.nodes[0].createrawtransaction(inputs, outputs)
|
||||
tx3_modified = tx_from_hex(tx3)
|
||||
tx3_modified.vin[0].nSequence = 0
|
||||
tx3 = bytes_to_hex_str(tx3_modified.serialize())
|
||||
tx3 = tx3_modified.serialize().hex()
|
||||
tx3_signed = self.nodes[0].signrawtransactionwithwallet(tx3)['hex']
|
||||
txid_3 = self.nodes[0].sendrawtransaction(tx3_signed)
|
||||
|
||||
assert(is_opt_in(self.nodes[0], txid_3))
|
||||
assert is_opt_in(self.nodes[0], txid_3)
|
||||
assert_array_result(self.nodes[0].listtransactions(), {"txid": txid_3}, {"bip125-replaceable": "yes"})
|
||||
sync_mempools(self.nodes)
|
||||
assert_array_result(self.nodes[1].listtransactions(), {"txid": txid_3}, {"bip125-replaceable": "yes"})
|
||||
|
@ -176,7 +175,7 @@ class ListTransactionsTest(BitcoinTestFramework):
|
|||
tx4_signed = self.nodes[1].signrawtransactionwithwallet(tx4)["hex"]
|
||||
txid_4 = self.nodes[1].sendrawtransaction(tx4_signed)
|
||||
|
||||
assert(not is_opt_in(self.nodes[1], txid_4))
|
||||
assert not is_opt_in(self.nodes[1], txid_4)
|
||||
assert_array_result(self.nodes[1].listtransactions(), {"txid": txid_4}, {"bip125-replaceable": "yes"})
|
||||
sync_mempools(self.nodes)
|
||||
assert_array_result(self.nodes[0].listtransactions(), {"txid": txid_4}, {"bip125-replaceable": "yes"})
|
||||
|
@ -184,10 +183,10 @@ class ListTransactionsTest(BitcoinTestFramework):
|
|||
# Replace tx3, and check that tx4 becomes unknown
|
||||
tx3_b = tx3_modified
|
||||
tx3_b.vout[0].nValue -= int(Decimal("0.004") * COIN) # bump the fee
|
||||
tx3_b = bytes_to_hex_str(tx3_b.serialize())
|
||||
tx3_b = tx3_b.serialize().hex()
|
||||
tx3_b_signed = self.nodes[0].signrawtransactionwithwallet(tx3_b)['hex']
|
||||
txid_3b = self.nodes[0].sendrawtransaction(tx3_b_signed, True)
|
||||
assert(is_opt_in(self.nodes[0], txid_3b))
|
||||
assert is_opt_in(self.nodes[0], txid_3b)
|
||||
|
||||
assert_array_result(self.nodes[0].listtransactions(), {"txid": txid_4}, {"bip125-replaceable": "unknown"})
|
||||
sync_mempools(self.nodes)
|
||||
|
@ -203,7 +202,7 @@ class ListTransactionsTest(BitcoinTestFramework):
|
|||
|
||||
# After mining a transaction, it's no longer BIP125-replaceable
|
||||
self.nodes[0].generate(1)
|
||||
assert(txid_3b not in self.nodes[0].getrawmempool())
|
||||
assert txid_3b not in self.nodes[0].getrawmempool()
|
||||
assert_equal(self.nodes[0].gettransaction(txid_3b)["bip125-replaceable"], "no")
|
||||
assert_equal(self.nodes[0].gettransaction(txid_4)["bip125-replaceable"], "unknown")
|
||||
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2017-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2017-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Test multiwallet.
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2014-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2014-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Test the wallet accounts properly when there are cloned transactions with malleated scriptsigs."""
|
||||
|
@ -8,7 +8,6 @@ import io
|
|||
from test_framework.test_framework import BitcoinTestFramework
|
||||
from test_framework.util import (
|
||||
assert_equal,
|
||||
bytes_to_hex_str as b2x,
|
||||
connect_nodes,
|
||||
disconnect_nodes,
|
||||
sync_blocks,
|
||||
|
@ -82,7 +81,7 @@ class TxnMallTest(BitcoinTestFramework):
|
|||
|
||||
# Use a different signature hash type to sign. This creates an equivalent but malleated clone.
|
||||
# Don't send the clone anywhere yet
|
||||
tx1_clone = self.nodes[0].signrawtransactionwithwallet(b2x(clone_tx.serialize()), None, "ALL|ANYONECANPAY")
|
||||
tx1_clone = self.nodes[0].signrawtransactionwithwallet(clone_tx.serialize().hex(), None, "ALL|ANYONECANPAY")
|
||||
assert_equal(tx1_clone["complete"], True)
|
||||
|
||||
# Have node0 mine a block, if requested:
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2014-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2014-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Test the wallet accounts properly when there is a double-spend conflict."""
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
# Copyright (c) 2015-2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2015-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
|
||||
|
|
|
@ -1,6 +1,6 @@
|
|||
#!/usr/bin/env python3
|
||||
#
|
||||
# Copyright (c) 2018 The Bitcoin Core developers
|
||||
# Copyright (c) 2018-2019 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
#
|
||||
|
@ -39,7 +39,7 @@ def parse_function_calls(function_name, source_code):
|
|||
>>> len(parse_function_calls("foo", "#define FOO foo();"))
|
||||
0
|
||||
"""
|
||||
assert(type(function_name) is str and type(source_code) is str and function_name)
|
||||
assert type(function_name) is str and type(source_code) is str and function_name
|
||||
lines = [re.sub("// .*", " ", line).strip()
|
||||
for line in source_code.split("\n")
|
||||
if not line.strip().startswith("#")]
|
||||
|
@ -53,7 +53,7 @@ def normalize(s):
|
|||
>>> normalize(" /* nothing */ foo\tfoo /* bar */ foo ")
|
||||
'foo foo foo'
|
||||
"""
|
||||
assert(type(s) is str)
|
||||
assert type(s) is str
|
||||
s = s.replace("\n", " ")
|
||||
s = s.replace("\t", " ")
|
||||
s = re.sub("/\*.*?\*/", " ", s)
|
||||
|
@ -77,7 +77,7 @@ def escape(s):
|
|||
>>> escape(r'foo \\t foo \\n foo \\\\ foo \\ foo \\"bar\\"')
|
||||
'foo [escaped-tab] foo [escaped-newline] foo \\\\\\\\ foo \\\\ foo [escaped-quote]bar[escaped-quote]'
|
||||
"""
|
||||
assert(type(s) is str)
|
||||
assert type(s) is str
|
||||
for raw_value, escaped_value in ESCAPE_MAP.items():
|
||||
s = s.replace(raw_value, escaped_value)
|
||||
return s
|
||||
|
@ -92,7 +92,7 @@ def unescape(s):
|
|||
>>> unescape("foo [escaped-tab] foo [escaped-newline] foo \\\\\\\\ foo \\\\ foo [escaped-quote]bar[escaped-quote]")
|
||||
'foo \\\\t foo \\\\n foo \\\\\\\\ foo \\\\ foo \\\\"bar\\\\"'
|
||||
"""
|
||||
assert(type(s) is str)
|
||||
assert type(s) is str
|
||||
for raw_value, escaped_value in ESCAPE_MAP.items():
|
||||
s = s.replace(escaped_value, raw_value)
|
||||
return s
|
||||
|
@ -151,10 +151,10 @@ def parse_function_call_and_arguments(function_name, function_call):
|
|||
>>> parse_function_call_and_arguments("strprintf", 'strprintf("%s (%d)", foo>foo<1,2>(1,2),err)');
|
||||
['strprintf(', '"%s (%d)",', ' foo>foo<1,2>(1,2),', 'err', ')']
|
||||
"""
|
||||
assert(type(function_name) is str and type(function_call) is str and function_name)
|
||||
assert type(function_name) is str and type(function_call) is str and function_name
|
||||
remaining = normalize(escape(function_call))
|
||||
expected_function_call = "{}(".format(function_name)
|
||||
assert(remaining.startswith(expected_function_call))
|
||||
assert remaining.startswith(expected_function_call)
|
||||
parts = [expected_function_call]
|
||||
remaining = remaining[len(expected_function_call):]
|
||||
open_parentheses = 1
|
||||
|
@ -213,7 +213,7 @@ def parse_string_content(argument):
|
|||
>>> parse_string_content('1 2 3')
|
||||
''
|
||||
"""
|
||||
assert(type(argument) is str)
|
||||
assert type(argument) is str
|
||||
string_content = ""
|
||||
in_string = False
|
||||
for char in normalize(escape(argument)):
|
||||
|
@ -240,7 +240,7 @@ def count_format_specifiers(format_string):
|
|||
>>> count_format_specifiers("foo %d bar %i foo %% foo %*d foo")
|
||||
4
|
||||
"""
|
||||
assert(type(format_string) is str)
|
||||
assert type(format_string) is str
|
||||
format_string = format_string.replace('%%', 'X')
|
||||
n = 0
|
||||
in_specifier = False
|
||||
|
|
Loading…
Reference in a new issue