mirror of
https://github.com/dashpay/dash.git
synced 2024-12-25 12:02:48 +01:00
UdjinM6
Holger Schinzel
parent
b682fcb8d6
commit
31ff9c2ff8
@ -36,7 +36,7 @@ output (example: `PYTHON_DEBUG=1 qa/pull-tester/rpc-tests.py wallet`).
|
||||
A 200-block -regtest blockchain and wallets for four nodes
|
||||
is created the first time a regression test is run and
|
||||
is stored in the cache/ directory. Each node has 25 mature
|
||||
blocks (25*50=1250 BTC) in its wallet.
|
||||
blocks (25*500=12500 DASH) in its wallet.
|
||||
|
||||
After the first run, the cache/ blockchain and wallets are
|
||||
copied into a temporary directory and used as the initial
|
||||
|
||||
@ -97,35 +97,35 @@ testScripts = [
|
||||
'nodehandling.py',
|
||||
'reindex.py',
|
||||
'decodescript.py',
|
||||
'p2p-fullblocktest.py',
|
||||
'p2p-fullblocktest.py', # TODO: works, needs dash_hash
|
||||
'blockchain.py',
|
||||
'disablewallet.py',
|
||||
'sendheaders.py',
|
||||
'sendheaders.py', # TODO: works, needs dash_hash
|
||||
'keypool.py',
|
||||
'prioritise_transaction.py',
|
||||
'invalidblockrequest.py',
|
||||
'invalidtxrequest.py',
|
||||
'invalidblockrequest.py', # TODO: works, needs dash_hash
|
||||
'invalidtxrequest.py', # TODO: works, needs dash_hash
|
||||
'abandonconflict.py',
|
||||
]
|
||||
testScriptsExt = [
|
||||
'bip65-cltv.py',
|
||||
'bip65-cltv-p2p.py',
|
||||
'bipdersig-p2p.py',
|
||||
'bip65-cltv-p2p.py', # TODO: works, needs dash_hash
|
||||
'bipdersig-p2p.py', # TODO: works, needs dash_hash
|
||||
'bipdersig.py',
|
||||
'getblocktemplate_longpoll.py',
|
||||
'getblocktemplate_longpoll.py', # FIXME: "socket.error: [Errno 54] Connection reset by peer" on my Mac, same as https://github.com/bitcoin/bitcoin/issues/6651
|
||||
'getblocktemplate_proposals.py',
|
||||
'txn_doublespend.py',
|
||||
'txn_clone.py --mineblock',
|
||||
'pruning.py',
|
||||
# 'pruning.py', # Prune mode is incompatible with -txindex.
|
||||
'forknotify.py',
|
||||
'invalidateblock.py',
|
||||
# 'rpcbind_test.py', #temporary, bug in libevent, see #6655
|
||||
'smartfees.py',
|
||||
'maxblocksinflight.py',
|
||||
'p2p-acceptblock.py',
|
||||
'p2p-acceptblock.py', # TODO: works, needs dash_hash
|
||||
'mempool_packages.py',
|
||||
'maxuploadtarget.py',
|
||||
'replace-by-fee.py',
|
||||
# 'replace-by-fee.py', # RBF is disabled in Dash
|
||||
]
|
||||
|
||||
#Enable ZMQ tests
|
||||
|
||||
@ -49,11 +49,11 @@ class BlockchainTest(BitcoinTestFramework):
|
||||
node = self.nodes[0]
|
||||
res = node.gettxoutsetinfo()
|
||||
|
||||
assert_equal(res[u'total_amount'], Decimal('8725.00000000'))
|
||||
assert_equal(res[u'total_amount'], Decimal('98214.28571450'))
|
||||
assert_equal(res[u'transactions'], 200)
|
||||
assert_equal(res[u'height'], 200)
|
||||
assert_equal(res[u'txouts'], 200)
|
||||
assert_equal(res[u'bytes_serialized'], 13924),
|
||||
assert_equal(res[u'bytes_serialized'], 14273),
|
||||
assert_equal(len(res[u'bestblock']), 64)
|
||||
assert_equal(len(res[u'hash_serialized']), 64)
|
||||
|
||||
|
||||
@ -24,9 +24,9 @@ class DisableWalletTest (BitcoinTestFramework):
|
||||
|
||||
def run_test (self):
|
||||
# Check regression: https://github.com/bitcoin/bitcoin/issues/6963#issuecomment-154548880
|
||||
x = self.nodes[0].validateaddress('3J98t1WpEZ73CNmQviecrnyiWrnqRhWNLy')
|
||||
x = self.nodes[0].validateaddress('7TSBtVu959hGEGPKyHjJz9k55RpWrPffXz')
|
||||
assert(x['isvalid'] == False)
|
||||
x = self.nodes[0].validateaddress('mneYUmWYsuk7kySiURxCi3AGxrAqZxLgPZ')
|
||||
x = self.nodes[0].validateaddress('xwJHtLhWeRzaDXrQqYuDaF1NrwYbgMWYDS')
|
||||
assert(x['isvalid'] == True)
|
||||
|
||||
if __name__ == '__main__':
|
||||
|
||||
@ -48,14 +48,14 @@ class RawTransactionsTest(BitcoinTestFramework):
|
||||
|
||||
watchonly_address = self.nodes[0].getnewaddress()
|
||||
watchonly_pubkey = self.nodes[0].validateaddress(watchonly_address)["pubkey"]
|
||||
watchonly_amount = 200
|
||||
watchonly_amount = 2000
|
||||
self.nodes[3].importpubkey(watchonly_pubkey, "", True)
|
||||
watchonly_txid = self.nodes[0].sendtoaddress(watchonly_address, watchonly_amount)
|
||||
self.nodes[0].sendtoaddress(self.nodes[3].getnewaddress(), watchonly_amount / 10)
|
||||
|
||||
self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 1.5)
|
||||
self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 1.0)
|
||||
self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 5.0)
|
||||
self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 15)
|
||||
self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 10)
|
||||
self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 50)
|
||||
|
||||
self.sync_all()
|
||||
self.nodes[0].generate(1)
|
||||
@ -65,7 +65,7 @@ class RawTransactionsTest(BitcoinTestFramework):
|
||||
# simple test #
|
||||
###############
|
||||
inputs = [ ]
|
||||
outputs = { self.nodes[0].getnewaddress() : 1.0 }
|
||||
outputs = { self.nodes[0].getnewaddress() : 10 }
|
||||
rawtx = self.nodes[2].createrawtransaction(inputs, outputs)
|
||||
dec_tx = self.nodes[2].decoderawtransaction(rawtx)
|
||||
rawtxfund = self.nodes[2].fundrawtransaction(rawtx)
|
||||
@ -77,7 +77,7 @@ class RawTransactionsTest(BitcoinTestFramework):
|
||||
# simple test with two coins #
|
||||
##############################
|
||||
inputs = [ ]
|
||||
outputs = { self.nodes[0].getnewaddress() : 2.2 }
|
||||
outputs = { self.nodes[0].getnewaddress() : 22 }
|
||||
rawtx = self.nodes[2].createrawtransaction(inputs, outputs)
|
||||
dec_tx = self.nodes[2].decoderawtransaction(rawtx)
|
||||
|
||||
@ -90,7 +90,7 @@ class RawTransactionsTest(BitcoinTestFramework):
|
||||
# simple test with two coins #
|
||||
##############################
|
||||
inputs = [ ]
|
||||
outputs = { self.nodes[0].getnewaddress() : 2.6 }
|
||||
outputs = { self.nodes[0].getnewaddress() : 26 }
|
||||
rawtx = self.nodes[2].createrawtransaction(inputs, outputs)
|
||||
dec_tx = self.nodes[2].decoderawtransaction(rawtx)
|
||||
|
||||
@ -105,7 +105,7 @@ class RawTransactionsTest(BitcoinTestFramework):
|
||||
# simple test with two outputs #
|
||||
################################
|
||||
inputs = [ ]
|
||||
outputs = { self.nodes[0].getnewaddress() : 2.6, self.nodes[1].getnewaddress() : 2.5 }
|
||||
outputs = { self.nodes[0].getnewaddress() : 26, self.nodes[1].getnewaddress() : 25 }
|
||||
rawtx = self.nodes[2].createrawtransaction(inputs, outputs)
|
||||
dec_tx = self.nodes[2].decoderawtransaction(rawtx)
|
||||
|
||||
@ -126,14 +126,14 @@ class RawTransactionsTest(BitcoinTestFramework):
|
||||
utx = False
|
||||
listunspent = self.nodes[2].listunspent()
|
||||
for aUtx in listunspent:
|
||||
if aUtx['amount'] == 5.0:
|
||||
if aUtx['amount'] == 50:
|
||||
utx = aUtx
|
||||
break
|
||||
|
||||
assert_equal(utx!=False, True)
|
||||
|
||||
inputs = [ {'txid' : utx['txid'], 'vout' : utx['vout']}]
|
||||
outputs = { self.nodes[0].getnewaddress() : 1.0 }
|
||||
outputs = { self.nodes[0].getnewaddress() : 10 }
|
||||
rawtx = self.nodes[2].createrawtransaction(inputs, outputs)
|
||||
dec_tx = self.nodes[2].decoderawtransaction(rawtx)
|
||||
assert_equal(utx['txid'], dec_tx['vin'][0]['txid'])
|
||||
@ -155,14 +155,14 @@ class RawTransactionsTest(BitcoinTestFramework):
|
||||
utx = False
|
||||
listunspent = self.nodes[2].listunspent()
|
||||
for aUtx in listunspent:
|
||||
if aUtx['amount'] == 5.0:
|
||||
if aUtx['amount'] == 50:
|
||||
utx = aUtx
|
||||
break
|
||||
|
||||
assert_equal(utx!=False, True)
|
||||
|
||||
inputs = [ {'txid' : utx['txid'], 'vout' : utx['vout']}]
|
||||
outputs = { self.nodes[0].getnewaddress() : Decimal(5.0) - fee - feeTolerance }
|
||||
outputs = { self.nodes[0].getnewaddress() : Decimal(50) - fee - feeTolerance }
|
||||
rawtx = self.nodes[2].createrawtransaction(inputs, outputs)
|
||||
dec_tx = self.nodes[2].decoderawtransaction(rawtx)
|
||||
assert_equal(utx['txid'], dec_tx['vin'][0]['txid'])
|
||||
@ -185,14 +185,14 @@ class RawTransactionsTest(BitcoinTestFramework):
|
||||
utx = False
|
||||
listunspent = self.nodes[2].listunspent()
|
||||
for aUtx in listunspent:
|
||||
if aUtx['amount'] == 1.0:
|
||||
if aUtx['amount'] == 10:
|
||||
utx = aUtx
|
||||
break
|
||||
|
||||
assert_equal(utx!=False, True)
|
||||
|
||||
inputs = [ {'txid' : utx['txid'], 'vout' : utx['vout']}]
|
||||
outputs = { self.nodes[0].getnewaddress() : 1.0 }
|
||||
outputs = { self.nodes[0].getnewaddress() : 10 }
|
||||
rawtx = self.nodes[2].createrawtransaction(inputs, outputs)
|
||||
|
||||
# 4-byte version + 1-byte vin count + 36-byte prevout then script_len
|
||||
@ -228,16 +228,16 @@ class RawTransactionsTest(BitcoinTestFramework):
|
||||
utx2 = False
|
||||
listunspent = self.nodes[2].listunspent()
|
||||
for aUtx in listunspent:
|
||||
if aUtx['amount'] == 1.0:
|
||||
if aUtx['amount'] == 10:
|
||||
utx = aUtx
|
||||
if aUtx['amount'] == 5.0:
|
||||
if aUtx['amount'] == 50:
|
||||
utx2 = aUtx
|
||||
|
||||
|
||||
assert_equal(utx!=False, True)
|
||||
|
||||
inputs = [ {'txid' : utx['txid'], 'vout' : utx['vout']},{'txid' : utx2['txid'], 'vout' : utx2['vout']} ]
|
||||
outputs = { self.nodes[0].getnewaddress() : 6.0 }
|
||||
outputs = { self.nodes[0].getnewaddress() : 60 }
|
||||
rawtx = self.nodes[2].createrawtransaction(inputs, outputs)
|
||||
dec_tx = self.nodes[2].decoderawtransaction(rawtx)
|
||||
assert_equal(utx['txid'], dec_tx['vin'][0]['txid'])
|
||||
@ -270,16 +270,16 @@ class RawTransactionsTest(BitcoinTestFramework):
|
||||
utx2 = False
|
||||
listunspent = self.nodes[2].listunspent()
|
||||
for aUtx in listunspent:
|
||||
if aUtx['amount'] == 1.0:
|
||||
if aUtx['amount'] == 10:
|
||||
utx = aUtx
|
||||
if aUtx['amount'] == 5.0:
|
||||
if aUtx['amount'] == 50:
|
||||
utx2 = aUtx
|
||||
|
||||
|
||||
assert_equal(utx!=False, True)
|
||||
|
||||
inputs = [ {'txid' : utx['txid'], 'vout' : utx['vout']},{'txid' : utx2['txid'], 'vout' : utx2['vout']} ]
|
||||
outputs = { self.nodes[0].getnewaddress() : 6.0, self.nodes[0].getnewaddress() : 1.0 }
|
||||
outputs = { self.nodes[0].getnewaddress() : 60, self.nodes[0].getnewaddress() : 10 }
|
||||
rawtx = self.nodes[2].createrawtransaction(inputs, outputs)
|
||||
dec_tx = self.nodes[2].decoderawtransaction(rawtx)
|
||||
assert_equal(utx['txid'], dec_tx['vin'][0]['txid'])
|
||||
@ -302,7 +302,7 @@ class RawTransactionsTest(BitcoinTestFramework):
|
||||
##############################################
|
||||
listunspent = self.nodes[2].listunspent()
|
||||
inputs = [ {'txid' : "1c7f966dab21119bac53213a2bc7532bff1fa844c124fd750a7d0b1332440bd1", 'vout' : 0} ] #invalid vin!
|
||||
outputs = { self.nodes[0].getnewaddress() : 1.0}
|
||||
outputs = { self.nodes[0].getnewaddress() : 10}
|
||||
rawtx = self.nodes[2].createrawtransaction(inputs, outputs)
|
||||
dec_tx = self.nodes[2].decoderawtransaction(rawtx)
|
||||
|
||||
@ -319,12 +319,12 @@ class RawTransactionsTest(BitcoinTestFramework):
|
||||
############################################################
|
||||
#compare fee of a standard pubkeyhash transaction
|
||||
inputs = []
|
||||
outputs = {self.nodes[1].getnewaddress():1.1}
|
||||
outputs = {self.nodes[1].getnewaddress():11}
|
||||
rawTx = self.nodes[0].createrawtransaction(inputs, outputs)
|
||||
fundedTx = self.nodes[0].fundrawtransaction(rawTx)
|
||||
|
||||
#create same transaction over sendtoaddress
|
||||
txId = self.nodes[0].sendtoaddress(self.nodes[1].getnewaddress(), 1.1)
|
||||
txId = self.nodes[0].sendtoaddress(self.nodes[1].getnewaddress(), 11)
|
||||
signedFee = self.nodes[0].getrawmempool(True)[txId]['fee']
|
||||
|
||||
#compare fee
|
||||
@ -335,7 +335,7 @@ class RawTransactionsTest(BitcoinTestFramework):
|
||||
############################################################
|
||||
#compare fee of a standard pubkeyhash transaction with multiple outputs
|
||||
inputs = []
|
||||
outputs = {self.nodes[1].getnewaddress():1.1,self.nodes[1].getnewaddress():1.2,self.nodes[1].getnewaddress():0.1,self.nodes[1].getnewaddress():1.3,self.nodes[1].getnewaddress():0.2,self.nodes[1].getnewaddress():0.3}
|
||||
outputs = {self.nodes[1].getnewaddress():11,self.nodes[1].getnewaddress():12,self.nodes[1].getnewaddress():1,self.nodes[1].getnewaddress():13,self.nodes[1].getnewaddress():2,self.nodes[1].getnewaddress():3}
|
||||
rawTx = self.nodes[0].createrawtransaction(inputs, outputs)
|
||||
fundedTx = self.nodes[0].fundrawtransaction(rawTx)
|
||||
#create same transaction over sendtoaddress
|
||||
@ -361,12 +361,12 @@ class RawTransactionsTest(BitcoinTestFramework):
|
||||
mSigObj = self.nodes[1].addmultisigaddress(2, [addr1Obj['pubkey'], addr2Obj['pubkey']])
|
||||
|
||||
inputs = []
|
||||
outputs = {mSigObj:1.1}
|
||||
outputs = {mSigObj:11}
|
||||
rawTx = self.nodes[0].createrawtransaction(inputs, outputs)
|
||||
fundedTx = self.nodes[0].fundrawtransaction(rawTx)
|
||||
|
||||
#create same transaction over sendtoaddress
|
||||
txId = self.nodes[0].sendtoaddress(mSigObj, 1.1)
|
||||
txId = self.nodes[0].sendtoaddress(mSigObj, 11)
|
||||
signedFee = self.nodes[0].getrawmempool(True)[txId]['fee']
|
||||
|
||||
#compare fee
|
||||
@ -394,12 +394,12 @@ class RawTransactionsTest(BitcoinTestFramework):
|
||||
mSigObj = self.nodes[1].addmultisigaddress(4, [addr1Obj['pubkey'], addr2Obj['pubkey'], addr3Obj['pubkey'], addr4Obj['pubkey'], addr5Obj['pubkey']])
|
||||
|
||||
inputs = []
|
||||
outputs = {mSigObj:1.1}
|
||||
outputs = {mSigObj:11}
|
||||
rawTx = self.nodes[0].createrawtransaction(inputs, outputs)
|
||||
fundedTx = self.nodes[0].fundrawtransaction(rawTx)
|
||||
|
||||
#create same transaction over sendtoaddress
|
||||
txId = self.nodes[0].sendtoaddress(mSigObj, 1.1)
|
||||
txId = self.nodes[0].sendtoaddress(mSigObj, 11)
|
||||
signedFee = self.nodes[0].getrawmempool(True)[txId]['fee']
|
||||
|
||||
#compare fee
|
||||
@ -421,15 +421,15 @@ class RawTransactionsTest(BitcoinTestFramework):
|
||||
mSigObj = self.nodes[2].addmultisigaddress(2, [addr1Obj['pubkey'], addr2Obj['pubkey']])
|
||||
|
||||
|
||||
# send 1.2 BTC to msig addr
|
||||
txId = self.nodes[0].sendtoaddress(mSigObj, 1.2)
|
||||
# send 12 DASH to msig addr
|
||||
txId = self.nodes[0].sendtoaddress(mSigObj, 12)
|
||||
self.sync_all()
|
||||
self.nodes[1].generate(1)
|
||||
self.sync_all()
|
||||
|
||||
oldBalance = self.nodes[1].getbalance()
|
||||
inputs = []
|
||||
outputs = {self.nodes[1].getnewaddress():1.1}
|
||||
outputs = {self.nodes[1].getnewaddress():11}
|
||||
rawTx = self.nodes[2].createrawtransaction(inputs, outputs)
|
||||
fundedTx = self.nodes[2].fundrawtransaction(rawTx)
|
||||
|
||||
@ -440,7 +440,7 @@ class RawTransactionsTest(BitcoinTestFramework):
|
||||
self.sync_all()
|
||||
|
||||
# make sure funds are received at node1
|
||||
assert_equal(oldBalance+Decimal('1.10000000'), self.nodes[1].getbalance())
|
||||
assert_equal(oldBalance+Decimal('11.0000000'), self.nodes[1].getbalance())
|
||||
|
||||
############################################################
|
||||
# locked wallet test
|
||||
@ -464,7 +464,7 @@ class RawTransactionsTest(BitcoinTestFramework):
|
||||
|
||||
error = False
|
||||
try:
|
||||
self.nodes[1].sendtoaddress(self.nodes[0].getnewaddress(), 1.2)
|
||||
self.nodes[1].sendtoaddress(self.nodes[0].getnewaddress(), 12)
|
||||
except:
|
||||
error = True
|
||||
assert(error)
|
||||
@ -472,7 +472,7 @@ class RawTransactionsTest(BitcoinTestFramework):
|
||||
oldBalance = self.nodes[0].getbalance()
|
||||
|
||||
inputs = []
|
||||
outputs = {self.nodes[0].getnewaddress():1.1}
|
||||
outputs = {self.nodes[0].getnewaddress():11}
|
||||
rawTx = self.nodes[1].createrawtransaction(inputs, outputs)
|
||||
fundedTx = self.nodes[1].fundrawtransaction(rawTx)
|
||||
|
||||
@ -485,7 +485,7 @@ class RawTransactionsTest(BitcoinTestFramework):
|
||||
self.sync_all()
|
||||
|
||||
# make sure funds are received at node1
|
||||
assert_equal(oldBalance+Decimal('51.10000000'), self.nodes[0].getbalance())
|
||||
assert_equal(oldBalance+Decimal('511.0000000'), self.nodes[0].getbalance())
|
||||
|
||||
|
||||
|
||||
@ -548,7 +548,7 @@ class RawTransactionsTest(BitcoinTestFramework):
|
||||
self.sync_all()
|
||||
self.nodes[0].generate(1)
|
||||
self.sync_all()
|
||||
assert_equal(oldBalance+Decimal('50.19000000'), self.nodes[0].getbalance()) #0.19+block reward
|
||||
assert_equal(oldBalance+Decimal('500.19000000'), self.nodes[0].getbalance()) #0.19+block reward
|
||||
|
||||
#####################################################
|
||||
# test fundrawtransaction with OP_RETURN and no vin #
|
||||
|
||||
@ -103,7 +103,7 @@ class InvalidBlockRequestTest(ComparisonTestFramework):
|
||||
'''
|
||||
block3 = create_block(self.tip, create_coinbase(height), self.block_time)
|
||||
self.block_time += 1
|
||||
block3.vtx[0].vout[0].nValue = 100*100000000 # Too high!
|
||||
block3.vtx[0].vout[0].nValue = 1000*100000000 # Too high!
|
||||
block3.vtx[0].sha256=None
|
||||
block3.vtx[0].calc_sha256()
|
||||
block3.hashMerkleRoot = block3.calc_merkle_root()
|
||||
|
||||
@ -111,7 +111,8 @@ class ListTransactionsTest(BitcoinTestFramework):
|
||||
{"category":"receive","amount":Decimal("0.1")},
|
||||
{"txid":txid, "account" : "watchonly"} )
|
||||
|
||||
self.run_rbf_opt_in_test()
|
||||
# rbf is disabled in Dash
|
||||
# self.run_rbf_opt_in_test()
|
||||
|
||||
# Check that the opt-in-rbf flag works properly, for sent and received
|
||||
# transactions.
|
||||
|
||||
@ -89,7 +89,7 @@ class MaxUploadTest(BitcoinTestFramework):
|
||||
def add_options(self, parser):
|
||||
parser.add_option("--testbinary", dest="testbinary",
|
||||
default=os.getenv("DASHD", "dashd"),
|
||||
help="bitcoind binary to test")
|
||||
help="dashd binary to test")
|
||||
|
||||
def setup_chain(self):
|
||||
initialize_chain_clean(self.options.tmpdir, 2)
|
||||
|
||||
@ -26,7 +26,7 @@ class MempoolLimitTest(BitcoinTestFramework):
|
||||
|
||||
def run_test(self):
|
||||
txids = []
|
||||
utxos = create_confirmed_utxos(self.relayfee, self.nodes[0], 90)
|
||||
utxos = create_confirmed_utxos(self.relayfee, self.nodes[0], 490)
|
||||
|
||||
#create a mempool tx that will be evicted
|
||||
us0 = utxos.pop()
|
||||
|
||||
@ -52,12 +52,12 @@ class MempoolCoinbaseTest(BitcoinTestFramework):
|
||||
# and make sure the mempool code behaves correctly.
|
||||
b = [ self.nodes[0].getblockhash(n) for n in range(101, 105) ]
|
||||
coinbase_txids = [ self.nodes[0].getblock(h)['tx'][0] for h in b ]
|
||||
spend_101_raw = self.create_tx(coinbase_txids[1], node1_address, 50)
|
||||
spend_102_raw = self.create_tx(coinbase_txids[2], node0_address, 50)
|
||||
spend_103_raw = self.create_tx(coinbase_txids[3], node0_address, 50)
|
||||
spend_101_raw = self.create_tx(coinbase_txids[1], node1_address, 500)
|
||||
spend_102_raw = self.create_tx(coinbase_txids[2], node0_address, 500)
|
||||
spend_103_raw = self.create_tx(coinbase_txids[3], node0_address, 500)
|
||||
|
||||
# Create a block-height-locked transaction which will be invalid after reorg
|
||||
timelock_tx = self.nodes[0].createrawtransaction([{"txid": coinbase_txids[0], "vout": 0}], {node0_address: 50})
|
||||
timelock_tx = self.nodes[0].createrawtransaction([{"txid": coinbase_txids[0], "vout": 0}], {node0_address: 500})
|
||||
# Set the time lock
|
||||
timelock_tx = timelock_tx.replace("ffffffff", "11111111", 1)
|
||||
timelock_tx = timelock_tx[:-8] + hex(self.nodes[0].getblockcount() + 2)[2:] + "000000"
|
||||
@ -71,8 +71,8 @@ class MempoolCoinbaseTest(BitcoinTestFramework):
|
||||
assert_raises(JSONRPCException, self.nodes[0].sendrawtransaction, timelock_tx)
|
||||
|
||||
# Create 102_1 and 103_1:
|
||||
spend_102_1_raw = self.create_tx(spend_102_id, node1_address, 50)
|
||||
spend_103_1_raw = self.create_tx(spend_103_id, node1_address, 50)
|
||||
spend_102_1_raw = self.create_tx(spend_102_id, node1_address, 500)
|
||||
spend_103_1_raw = self.create_tx(spend_103_id, node1_address, 500)
|
||||
|
||||
# Broadcast and mine 103_1:
|
||||
spend_103_1_id = self.nodes[0].sendrawtransaction(spend_103_1_raw)
|
||||
|
||||
@ -42,9 +42,9 @@ class MerkleBlockTest(BitcoinTestFramework):
|
||||
assert_equal(self.nodes[2].getbalance(), 0)
|
||||
|
||||
node0utxos = self.nodes[0].listunspent(1)
|
||||
tx1 = self.nodes[0].createrawtransaction([node0utxos.pop()], {self.nodes[1].getnewaddress(): 50})
|
||||
tx1 = self.nodes[0].createrawtransaction([node0utxos.pop()], {self.nodes[1].getnewaddress(): 500})
|
||||
txid1 = self.nodes[0].sendrawtransaction(self.nodes[0].signrawtransaction(tx1)["hex"])
|
||||
tx2 = self.nodes[0].createrawtransaction([node0utxos.pop()], {self.nodes[1].getnewaddress(): 50})
|
||||
tx2 = self.nodes[0].createrawtransaction([node0utxos.pop()], {self.nodes[1].getnewaddress(): 500})
|
||||
txid2 = self.nodes[0].sendrawtransaction(self.nodes[0].signrawtransaction(tx2)["hex"])
|
||||
assert_raises(JSONRPCException, self.nodes[0].gettxoutproof, [txid1])
|
||||
|
||||
@ -62,7 +62,7 @@ class MerkleBlockTest(BitcoinTestFramework):
|
||||
assert_equal(self.nodes[2].verifytxoutproof(self.nodes[2].gettxoutproof([txid1, txid2], blockhash)), txlist)
|
||||
|
||||
txin_spent = self.nodes[1].listunspent(1).pop()
|
||||
tx3 = self.nodes[1].createrawtransaction([txin_spent], {self.nodes[0].getnewaddress(): 50})
|
||||
tx3 = self.nodes[1].createrawtransaction([txin_spent], {self.nodes[0].getnewaddress(): 500})
|
||||
self.nodes[0].sendrawtransaction(self.nodes[1].signrawtransaction(tx3)["hex"])
|
||||
self.nodes[0].generate(1)
|
||||
self.sync_all()
|
||||
@ -71,7 +71,8 @@ class MerkleBlockTest(BitcoinTestFramework):
|
||||
txid_unspent = txid1 if txin_spent["txid"] != txid1 else txid2
|
||||
|
||||
# We cant find the block from a fully-spent tx
|
||||
assert_raises(JSONRPCException, self.nodes[2].gettxoutproof, [txid_spent])
|
||||
# Doesn't apply to Dash - we have txindex always on
|
||||
# assert_raises(JSONRPCException, self.nodes[2].gettxoutproof, [txid_spent])
|
||||
# ...but we can if we specify the block
|
||||
assert_equal(self.nodes[2].verifytxoutproof(self.nodes[2].gettxoutproof([txid_spent], blockhash)), [txid_spent])
|
||||
# ...or if the first tx is not fully-spent
|
||||
|
||||
@ -27,10 +27,10 @@ class HTTPBasicsTest (BitcoinTestFramework):
|
||||
def setup_chain(self):
|
||||
print("Initializing test directory "+self.options.tmpdir)
|
||||
initialize_chain(self.options.tmpdir)
|
||||
#Append rpcauth to bitcoin.conf before initialization
|
||||
#Append rpcauth to dash.conf before initialization
|
||||
rpcauth = "rpcauth=rt:93648e835a54c573682c2eb19f882535$7681e9c5b74bdd85e78166031d2058e1069b3ed7ed967c93fc63abba06f31144"
|
||||
rpcauth2 = "rpcauth=rt2:f8607b1a88861fac29dfccf9b52ff9f$ff36a0c23c8c62b4846112e50fa888416e94c17bfd4c42f88fd8f55ec6a3137e"
|
||||
with open(os.path.join(self.options.tmpdir+"/node0", "bitcoin.conf"), 'a') as f:
|
||||
with open(os.path.join(self.options.tmpdir+"/node0", "dash.conf"), 'a') as f:
|
||||
f.write(rpcauth+"\n")
|
||||
f.write(rpcauth2+"\n")
|
||||
|
||||
|
||||
@ -137,7 +137,7 @@ class RawTransactionsTest(BitcoinTestFramework):
|
||||
self.sync_all()
|
||||
self.nodes[0].generate(1)
|
||||
self.sync_all()
|
||||
assert_equal(self.nodes[0].getbalance(), bal+Decimal('50.00000000')+Decimal('2.19000000')) #block reward + tx
|
||||
assert_equal(self.nodes[0].getbalance(), bal+Decimal('500.00000000')+Decimal('2.19000000')) #block reward + tx
|
||||
|
||||
if __name__ == '__main__':
|
||||
RawTransactionsTest().main()
|
||||
|
||||
@ -74,7 +74,7 @@ class RESTTest (BitcoinTestFramework):
|
||||
self.nodes[2].generate(100)
|
||||
self.sync_all()
|
||||
|
||||
assert_equal(self.nodes[0].getbalance(), 50)
|
||||
assert_equal(self.nodes[0].getbalance(), 500)
|
||||
|
||||
txid = self.nodes[0].sendtoaddress(self.nodes[1].getnewaddress(), 0.1)
|
||||
self.sync_all()
|
||||
|
||||
@ -33,7 +33,7 @@ class SignRawTransactionsTest(BitcoinTestFramework):
|
||||
'scriptPubKey': '76a91460baa0f494b38ce3c940dea67f3804dc52d1fb9488ac'}
|
||||
]
|
||||
|
||||
outputs = {'mpLQjfK79b7CCV4VMJWEWAj5Mpx8Up5zxB': 0.1}
|
||||
outputs = {'xxE2Q5yK8qgJnytakFyeAoxXirWJH9eaSW': 0.1}
|
||||
|
||||
rawTx = self.nodes[0].createrawtransaction(inputs, outputs)
|
||||
rawTxSigned = self.nodes[0].signrawtransaction(rawTx, inputs, privKeys)
|
||||
@ -74,7 +74,7 @@ class SignRawTransactionsTest(BitcoinTestFramework):
|
||||
'scriptPubKey': 'badbadbadbad'}
|
||||
]
|
||||
|
||||
outputs = {'mpLQjfK79b7CCV4VMJWEWAj5Mpx8Up5zxB': 0.1}
|
||||
outputs = {'xxE2Q5yK8qgJnytakFyeAoxXirWJH9eaSW': 0.1}
|
||||
|
||||
rawTx = self.nodes[0].createrawtransaction(inputs, outputs)
|
||||
rawTxSigned = self.nodes[0].signrawtransaction(rawTx, scripts, privKeys)
|
||||
|
||||
@ -13,12 +13,32 @@ from test_framework.util import *
|
||||
# Construct 2 trivial P2SH's and the ScriptSigs that spend them
|
||||
# So we can create many many transactions without needing to spend
|
||||
# time signing.
|
||||
P2SH_1 = "2MySexEGVzZpRgNQ1JdjdP5bRETznm3roQ2" # P2SH of "OP_1 OP_DROP"
|
||||
P2SH_2 = "2NBdpwq8Aoo1EEKEXPNrKvr5xQr3M9UfcZA" # P2SH of "OP_2 OP_DROP"
|
||||
P2SH_1 = "8kctg1WWKdoLveifyNnDYtRAqBPpqgL8z2" # P2SH of "OP_1 OP_DROP"
|
||||
P2SH_2 = "8xp4fcNB8rz9UbZC47tv6eui1ZSPMd3iYT" # P2SH of "OP_2 OP_DROP"
|
||||
# Associated ScriptSig's to spend satisfy P2SH_1 and P2SH_2
|
||||
# 4 bytes of OP_TRUE and push 2-byte redeem script of "OP_1 OP_DROP" or "OP_2 OP_DROP"
|
||||
SCRIPT_SIG = ["0451025175", "0451025275"]
|
||||
|
||||
class DecimalEncoder(json.JSONEncoder):
|
||||
def default(self, o):
|
||||
if isinstance(o, Decimal):
|
||||
return float(o)
|
||||
return super(DecimalEncoder, self).default(o)
|
||||
|
||||
def swap_outputs_in_rawtx(rawtx, outputs, inputnum):
|
||||
'''
|
||||
Since dictionaries in python are unsorted make sure that our outputs are correctly ordered.
|
||||
Note: comparing strings to get "correct order" is based on the fact that
|
||||
P2SH_1 string is < P2SH_2 string in this particular case.
|
||||
'''
|
||||
outputs_unordered = json.dumps(outputs, cls=DecimalEncoder)
|
||||
outputs_ordered = json.dumps(outputs, sort_keys=True, cls=DecimalEncoder)
|
||||
if outputs_ordered != outputs_unordered: # nope, we need to do some work here
|
||||
first_rawoutput = rawtx[12+82*inputnum:12+82*inputnum+64]
|
||||
second_rawoutput = rawtx[12+82*inputnum+64:12+82*inputnum+64+64]
|
||||
rawtx = rawtx[0:12+82*inputnum] + second_rawoutput + first_rawoutput + rawtx[12+82*inputnum+64+64:]
|
||||
return rawtx
|
||||
|
||||
def small_txpuzzle_randfee(from_node, conflist, unconflist, amount, min_fee, fee_increment):
|
||||
'''
|
||||
Create and send a transaction with a random fee.
|
||||
@ -52,6 +72,7 @@ def small_txpuzzle_randfee(from_node, conflist, unconflist, amount, min_fee, fee
|
||||
outputs[P2SH_1] = total_in - amount - fee
|
||||
outputs[P2SH_2] = amount
|
||||
rawtx = from_node.createrawtransaction(inputs, outputs)
|
||||
rawtx = swap_outputs_in_rawtx(rawtx, outputs, len(inputs))
|
||||
# Createrawtransaction constructions a transaction that is ready to be signed
|
||||
# These transactions don't need to be signed, but we still have to insert the ScriptSig
|
||||
# that will satisfy the ScriptPubKey.
|
||||
@ -81,10 +102,11 @@ def split_inputs(from_node, txins, txouts, initial_split = False):
|
||||
outputs = {}
|
||||
inputs.append({ "txid" : prevtxout["txid"], "vout" : prevtxout["vout"] })
|
||||
half_change = satoshi_round(prevtxout["amount"]/2)
|
||||
rem_change = prevtxout["amount"] - half_change - Decimal("0.00001000")
|
||||
rem_change = prevtxout["amount"] - half_change - Decimal("0.00010000")
|
||||
outputs[P2SH_1] = half_change
|
||||
outputs[P2SH_2] = rem_change
|
||||
rawtx = from_node.createrawtransaction(inputs, outputs)
|
||||
rawtx = swap_outputs_in_rawtx(rawtx, outputs, len(inputs))
|
||||
# If this is the initial split we actually need to sign the transaction
|
||||
# Otherwise we just need to insert the property ScriptSig
|
||||
if (initial_split) :
|
||||
@ -208,7 +230,7 @@ class EstimateFeeTest(BitcoinTestFramework):
|
||||
self.sync_all()
|
||||
|
||||
def transact_and_mine(self, numblocks, mining_node):
|
||||
min_fee = Decimal("0.00001")
|
||||
min_fee = Decimal("0.0001")
|
||||
# We will now mine numblocks blocks generating on average 100 transactions between each block
|
||||
# We shuffle our confirmed txout set before each set of transactions
|
||||
# small_txpuzzle_randfee will use the transactions that have inputs already in the chain when possible
|
||||
|
||||
@ -45,7 +45,7 @@ def create_coinbase(height, pubkey = None):
|
||||
coinbase.vin.append(CTxIn(COutPoint(0, 0xffffffff),
|
||||
ser_string(serialize_script_num(height)), 0xffffffff))
|
||||
coinbaseoutput = CTxOut()
|
||||
coinbaseoutput.nValue = 50*100000000
|
||||
coinbaseoutput.nValue = 500*100000000
|
||||
halvings = int(height/150) # regtest
|
||||
coinbaseoutput.nValue >>= halvings
|
||||
if (pubkey != None):
|
||||
|
||||
@ -9,7 +9,7 @@ from blockstore import BlockStore, TxStore
|
||||
from util import p2p_port
|
||||
|
||||
'''
|
||||
This is a tool for comparing two or more bitcoinds to each other
|
||||
This is a tool for comparing two or more dashds to each other
|
||||
using a script provided.
|
||||
|
||||
To use, create a class that implements get_tests(), and pass it in
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
# mininode.py - Bitcoin P2P network half-a-node
|
||||
# mininode.py - Dash P2P network half-a-node
|
||||
#
|
||||
# Distributed under the MIT/X11 software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
@ -6,12 +6,12 @@
|
||||
# This python code was modified from ArtForz' public domain half-a-node, as
|
||||
# found in the mini-node branch of http://github.com/jgarzik/pynode.
|
||||
#
|
||||
# NodeConn: an object which manages p2p connectivity to a bitcoin node
|
||||
# NodeConn: an object which manages p2p connectivity to a dash node
|
||||
# NodeConnCB: a base class that describes the interface for receiving
|
||||
# callbacks with network messages from a NodeConn
|
||||
# CBlock, CTransaction, CBlockHeader, CTxIn, CTxOut, etc....:
|
||||
# data structures that should map to corresponding structures in
|
||||
# bitcoin/primitives
|
||||
# dash/primitives
|
||||
# msg_block, msg_tx, msg_headers, etc.:
|
||||
# data structures that represent network messages
|
||||
# ser_*, deser_*: functions that handle serialization/deserialization
|
||||
@ -31,8 +31,10 @@ from threading import Thread
|
||||
import logging
|
||||
import copy
|
||||
|
||||
import dash_hash
|
||||
|
||||
BIP0031_VERSION = 60000
|
||||
MY_VERSION = 60001 # past bip-31 for ping/pong
|
||||
MY_VERSION = 70103 # past bip-31 for ping/pong
|
||||
MY_SUBVERSION = "/python-mininode-tester:0.0.1/"
|
||||
|
||||
MAX_INV_SZ = 50000
|
||||
@ -59,6 +61,8 @@ def sha256(s):
|
||||
def hash256(s):
|
||||
return sha256(sha256(s))
|
||||
|
||||
def dashhash(s):
|
||||
return dash_hash.getPoWHash(s)
|
||||
|
||||
def deser_string(f):
|
||||
nit = struct.unpack("<B", f.read(1))[0]
|
||||
@ -232,7 +236,7 @@ def ser_int_vector(l):
|
||||
return r
|
||||
|
||||
|
||||
# Objects that map to bitcoind objects, which can be serialized/deserialized
|
||||
# Objects that map to dashd objects, which can be serialized/deserialized
|
||||
|
||||
class CAddress(object):
|
||||
def __init__(self):
|
||||
@ -481,8 +485,8 @@ class CBlockHeader(object):
|
||||
r += struct.pack("<I", self.nTime)
|
||||
r += struct.pack("<I", self.nBits)
|
||||
r += struct.pack("<I", self.nNonce)
|
||||
self.sha256 = uint256_from_str(hash256(r))
|
||||
self.hash = hash256(r)[::-1].encode('hex_codec')
|
||||
self.sha256 = uint256_from_str(dashhash(r))
|
||||
self.hash = dashhash(r)[::-1].encode('hex_codec')
|
||||
|
||||
def rehash(self):
|
||||
self.sha256 = None
|
||||
@ -957,7 +961,7 @@ class msg_headers(object):
|
||||
self.headers = []
|
||||
|
||||
def deserialize(self, f):
|
||||
# comment in bitcoind indicates these should be deserialized as blocks
|
||||
# comment in dashd indicates these should be deserialized as blocks
|
||||
blocks = deser_vector(f, CBlock)
|
||||
for x in blocks:
|
||||
self.headers.append(CBlockHeader(x))
|
||||
@ -1098,9 +1102,9 @@ class NodeConn(asyncore.dispatcher):
|
||||
"mempool": msg_mempool
|
||||
}
|
||||
MAGIC_BYTES = {
|
||||
"mainnet": "\xf9\xbe\xb4\xd9", # mainnet
|
||||
"testnet3": "\x0b\x11\x09\x07", # testnet3
|
||||
"regtest": "\xfa\xbf\xb5\xda" # regtest
|
||||
"mainnet": "\xbf\x0c\x6b\xbd", # mainnet
|
||||
"testnet3": "\xce\xe2\xca\xff", # testnet3
|
||||
"regtest": "\xfc\xc1\xb7\xdc" # regtest
|
||||
}
|
||||
|
||||
def __init__(self, dstaddr, dstport, rpc, callback, net="regtest", services=1):
|
||||
@ -1127,7 +1131,7 @@ class NodeConn(asyncore.dispatcher):
|
||||
vt.addrFrom.ip = "0.0.0.0"
|
||||
vt.addrFrom.port = 0
|
||||
self.send_message(vt, True)
|
||||
print 'MiniNode: Connecting to Bitcoin Node IP # ' + dstaddr + ':' \
|
||||
print 'MiniNode: Connecting to Dash Node IP # ' + dstaddr + ':' \
|
||||
+ str(dstport)
|
||||
|
||||
try:
|
||||
|
||||
@ -151,7 +151,7 @@ class BitcoinTestFramework(object):
|
||||
stop_nodes(self.nodes)
|
||||
wait_bitcoinds()
|
||||
else:
|
||||
print("Note: bitcoinds were not stopped and may still be running")
|
||||
print("Note: dashds were not stopped and may still be running")
|
||||
|
||||
if not self.options.nocleanup and not self.options.noshutdown:
|
||||
print("Cleaning up")
|
||||
|
||||
@ -141,7 +141,7 @@ def initialize_chain(test_dir):
|
||||
subprocess.check_call([ os.getenv("DASHCLI", "dash-cli"), "-datadir="+datadir,
|
||||
"-rpcwait", "getblockcount"], stdout=devnull)
|
||||
if os.getenv("PYTHON_DEBUG", ""):
|
||||
print "initialize_chain: bitcoin-cli -rpcwait getblockcount completed"
|
||||
print "initialize_chain: dassh-cli -rpcwait getblockcount completed"
|
||||
devnull.close()
|
||||
|
||||
rpcs = []
|
||||
|
||||
@ -21,8 +21,8 @@ class TxnMallTest(BitcoinTestFramework):
|
||||
return super(TxnMallTest, self).setup_network(True)
|
||||
|
||||
def run_test(self):
|
||||
# All nodes should start with 1,250 BTC:
|
||||
starting_balance = 1250
|
||||
# All nodes should start with 12,500 DASH:
|
||||
starting_balance = 12500
|
||||
for i in range(4):
|
||||
assert_equal(self.nodes[i].getbalance(), starting_balance)
|
||||
self.nodes[i].getnewaddress("") # bug workaround, coins generated assigned to first getnewaddress!
|
||||
@ -31,22 +31,22 @@ class TxnMallTest(BitcoinTestFramework):
|
||||
self.nodes[0].settxfee(.001)
|
||||
|
||||
node0_address_foo = self.nodes[0].getnewaddress("foo")
|
||||
fund_foo_txid = self.nodes[0].sendfrom("", node0_address_foo, 1219)
|
||||
fund_foo_txid = self.nodes[0].sendfrom("", node0_address_foo, 12190)
|
||||
fund_foo_tx = self.nodes[0].gettransaction(fund_foo_txid)
|
||||
|
||||
node0_address_bar = self.nodes[0].getnewaddress("bar")
|
||||
fund_bar_txid = self.nodes[0].sendfrom("", node0_address_bar, 29)
|
||||
fund_bar_txid = self.nodes[0].sendfrom("", node0_address_bar, 290)
|
||||
fund_bar_tx = self.nodes[0].gettransaction(fund_bar_txid)
|
||||
|
||||
assert_equal(self.nodes[0].getbalance(""),
|
||||
starting_balance - 1219 - 29 + fund_foo_tx["fee"] + fund_bar_tx["fee"])
|
||||
starting_balance - 12190 - 290 + fund_foo_tx["fee"] + fund_bar_tx["fee"])
|
||||
|
||||
# Coins are sent to node1_address
|
||||
node1_address = self.nodes[1].getnewaddress("from0")
|
||||
|
||||
# Send tx1, and another transaction tx2 that won't be cloned
|
||||
txid1 = self.nodes[0].sendfrom("foo", node1_address, 40, 0)
|
||||
txid2 = self.nodes[0].sendfrom("bar", node1_address, 20, 0)
|
||||
txid1 = self.nodes[0].sendfrom("foo", node1_address, 400, 0)
|
||||
txid2 = self.nodes[0].sendfrom("bar", node1_address, 200, 0)
|
||||
|
||||
# Construct a clone of tx1, to be malleated
|
||||
rawtx1 = self.nodes[0].getrawtransaction(txid1,1)
|
||||
@ -64,12 +64,12 @@ class TxnMallTest(BitcoinTestFramework):
|
||||
|
||||
# manipulation 2. createrawtransaction randomizes the order of its outputs, so swap them if necessary.
|
||||
# output 0 is at version+#inputs+input+sigstub+sequence+#outputs
|
||||
# 40 BTC serialized is 00286bee00000000
|
||||
# 400 DASH serialized is 00902f5009000000
|
||||
pos0 = 2*(4+1+36+1+4+1)
|
||||
hex40 = "00286bee00000000"
|
||||
hex400 = "00902f5009000000"
|
||||
output_len = 16 + 2 + 2 * int("0x" + clone_raw[pos0 + 16 : pos0 + 16 + 2], 0)
|
||||
if (rawtx1["vout"][0]["value"] == 40 and clone_raw[pos0 : pos0 + 16] != hex40 or
|
||||
rawtx1["vout"][0]["value"] != 40 and clone_raw[pos0 : pos0 + 16] == hex40):
|
||||
if (rawtx1["vout"][0]["value"] == 400 and clone_raw[pos0 : pos0 + 16] != hex400 or
|
||||
rawtx1["vout"][0]["value"] != 400 and clone_raw[pos0 : pos0 + 16] == hex400):
|
||||
output0 = clone_raw[pos0 : pos0 + output_len]
|
||||
output1 = clone_raw[pos0 + output_len : pos0 + 2 * output_len]
|
||||
clone_raw = clone_raw[:pos0] + output1 + output0 + clone_raw[pos0 + 2 * output_len:]
|
||||
@ -92,17 +92,17 @@ class TxnMallTest(BitcoinTestFramework):
|
||||
tx1 = self.nodes[0].gettransaction(txid1)
|
||||
tx2 = self.nodes[0].gettransaction(txid2)
|
||||
|
||||
# Node0's balance should be starting balance, plus 50BTC for another
|
||||
# Node0's balance should be starting balance, plus 500DASH for another
|
||||
# matured block, minus tx1 and tx2 amounts, and minus transaction fees:
|
||||
expected = starting_balance + fund_foo_tx["fee"] + fund_bar_tx["fee"]
|
||||
if self.options.mine_block: expected += 50
|
||||
if self.options.mine_block: expected += 500
|
||||
expected += tx1["amount"] + tx1["fee"]
|
||||
expected += tx2["amount"] + tx2["fee"]
|
||||
assert_equal(self.nodes[0].getbalance(), expected)
|
||||
|
||||
# foo and bar accounts should be debited:
|
||||
assert_equal(self.nodes[0].getbalance("foo", 0), 1219 + tx1["amount"] + tx1["fee"])
|
||||
assert_equal(self.nodes[0].getbalance("bar", 0), 29 + tx2["amount"] + tx2["fee"])
|
||||
assert_equal(self.nodes[0].getbalance("foo", 0), 12190 + tx1["amount"] + tx1["fee"])
|
||||
assert_equal(self.nodes[0].getbalance("bar", 0), 290 + tx2["amount"] + tx2["fee"])
|
||||
|
||||
if self.options.mine_block:
|
||||
assert_equal(tx1["confirmations"], 1)
|
||||
@ -136,26 +136,26 @@ class TxnMallTest(BitcoinTestFramework):
|
||||
assert_equal(tx1_clone["confirmations"], 2)
|
||||
assert_equal(tx2["confirmations"], 1)
|
||||
|
||||
# Check node0's total balance; should be same as before the clone, + 100 BTC for 2 matured,
|
||||
# Check node0's total balance; should be same as before the clone, + 1000 DASH for 2 matured,
|
||||
# less possible orphaned matured subsidy
|
||||
expected += 100
|
||||
expected += 1000
|
||||
if (self.options.mine_block):
|
||||
expected -= 50
|
||||
expected -= 500
|
||||
assert_equal(self.nodes[0].getbalance(), expected)
|
||||
assert_equal(self.nodes[0].getbalance("*", 0), expected)
|
||||
|
||||
# Check node0's individual account balances.
|
||||
# "foo" should have been debited by the equivalent clone of tx1
|
||||
assert_equal(self.nodes[0].getbalance("foo"), 1219 + tx1["amount"] + tx1["fee"])
|
||||
assert_equal(self.nodes[0].getbalance("foo"), 12190 + tx1["amount"] + tx1["fee"])
|
||||
# "bar" should have been debited by (possibly unconfirmed) tx2
|
||||
assert_equal(self.nodes[0].getbalance("bar", 0), 29 + tx2["amount"] + tx2["fee"])
|
||||
assert_equal(self.nodes[0].getbalance("bar", 0), 290 + tx2["amount"] + tx2["fee"])
|
||||
# "" should have starting balance, less funding txes, plus subsidies
|
||||
assert_equal(self.nodes[0].getbalance("", 0), starting_balance
|
||||
- 1219
|
||||
- 12190
|
||||
+ fund_foo_tx["fee"]
|
||||
- 29
|
||||
- 290
|
||||
+ fund_bar_tx["fee"]
|
||||
+ 100)
|
||||
+ 1000)
|
||||
|
||||
# Node1's "from0" account balance
|
||||
assert_equal(self.nodes[1].getbalance("from0", 0), -(tx1["amount"] + tx2["amount"]))
|
||||
|
||||
@ -21,48 +21,48 @@ class TxnMallTest(BitcoinTestFramework):
|
||||
return super(TxnMallTest, self).setup_network(True)
|
||||
|
||||
def run_test(self):
|
||||
# All nodes should start with 1,250 BTC:
|
||||
starting_balance = 1250
|
||||
# All nodes should start with 12,500 DASH:
|
||||
starting_balance = 12500
|
||||
for i in range(4):
|
||||
assert_equal(self.nodes[i].getbalance(), starting_balance)
|
||||
self.nodes[i].getnewaddress("") # bug workaround, coins generated assigned to first getnewaddress!
|
||||
|
||||
# Assign coins to foo and bar accounts:
|
||||
node0_address_foo = self.nodes[0].getnewaddress("foo")
|
||||
fund_foo_txid = self.nodes[0].sendfrom("", node0_address_foo, 1219)
|
||||
fund_foo_txid = self.nodes[0].sendfrom("", node0_address_foo, 12190)
|
||||
fund_foo_tx = self.nodes[0].gettransaction(fund_foo_txid)
|
||||
|
||||
node0_address_bar = self.nodes[0].getnewaddress("bar")
|
||||
fund_bar_txid = self.nodes[0].sendfrom("", node0_address_bar, 29)
|
||||
fund_bar_txid = self.nodes[0].sendfrom("", node0_address_bar, 290)
|
||||
fund_bar_tx = self.nodes[0].gettransaction(fund_bar_txid)
|
||||
|
||||
assert_equal(self.nodes[0].getbalance(""),
|
||||
starting_balance - 1219 - 29 + fund_foo_tx["fee"] + fund_bar_tx["fee"])
|
||||
starting_balance - 12190 - 290 + fund_foo_tx["fee"] + fund_bar_tx["fee"])
|
||||
|
||||
# Coins are sent to node1_address
|
||||
node1_address = self.nodes[1].getnewaddress("from0")
|
||||
|
||||
# First: use raw transaction API to send 1240 BTC to node1_address,
|
||||
# First: use raw transaction API to send 12400 DASH to node1_address,
|
||||
# but don't broadcast:
|
||||
doublespend_fee = Decimal('-.02')
|
||||
rawtx_input_0 = {}
|
||||
rawtx_input_0["txid"] = fund_foo_txid
|
||||
rawtx_input_0["vout"] = find_output(self.nodes[0], fund_foo_txid, 1219)
|
||||
rawtx_input_0["vout"] = find_output(self.nodes[0], fund_foo_txid, 12190)
|
||||
rawtx_input_1 = {}
|
||||
rawtx_input_1["txid"] = fund_bar_txid
|
||||
rawtx_input_1["vout"] = find_output(self.nodes[0], fund_bar_txid, 29)
|
||||
rawtx_input_1["vout"] = find_output(self.nodes[0], fund_bar_txid, 290)
|
||||
inputs = [rawtx_input_0, rawtx_input_1]
|
||||
change_address = self.nodes[0].getnewaddress()
|
||||
outputs = {}
|
||||
outputs[node1_address] = 1240
|
||||
outputs[change_address] = 1248 - 1240 + doublespend_fee
|
||||
outputs[node1_address] = 12400
|
||||
outputs[change_address] = 12480 - 12400 + doublespend_fee
|
||||
rawtx = self.nodes[0].createrawtransaction(inputs, outputs)
|
||||
doublespend = self.nodes[0].signrawtransaction(rawtx)
|
||||
assert_equal(doublespend["complete"], True)
|
||||
|
||||
# Create two spends using 1 50 BTC coin each
|
||||
txid1 = self.nodes[0].sendfrom("foo", node1_address, 40, 0)
|
||||
txid2 = self.nodes[0].sendfrom("bar", node1_address, 20, 0)
|
||||
# Create two spends using 1 500 DASH coin each
|
||||
txid1 = self.nodes[0].sendfrom("foo", node1_address, 400, 0)
|
||||
txid2 = self.nodes[0].sendfrom("bar", node1_address, 200, 0)
|
||||
|
||||
# Have node0 mine a block:
|
||||
if (self.options.mine_block):
|
||||
@ -72,17 +72,17 @@ class TxnMallTest(BitcoinTestFramework):
|
||||
tx1 = self.nodes[0].gettransaction(txid1)
|
||||
tx2 = self.nodes[0].gettransaction(txid2)
|
||||
|
||||
# Node0's balance should be starting balance, plus 50BTC for another
|
||||
# matured block, minus 40, minus 20, and minus transaction fees:
|
||||
# Node0's balance should be starting balance, plus 500DASH for another
|
||||
# matured block, minus 400, minus 200, and minus transaction fees:
|
||||
expected = starting_balance + fund_foo_tx["fee"] + fund_bar_tx["fee"]
|
||||
if self.options.mine_block: expected += 50
|
||||
if self.options.mine_block: expected += 500
|
||||
expected += tx1["amount"] + tx1["fee"]
|
||||
expected += tx2["amount"] + tx2["fee"]
|
||||
assert_equal(self.nodes[0].getbalance(), expected)
|
||||
|
||||
# foo and bar accounts should be debited:
|
||||
assert_equal(self.nodes[0].getbalance("foo", 0), 1219+tx1["amount"]+tx1["fee"])
|
||||
assert_equal(self.nodes[0].getbalance("bar", 0), 29+tx2["amount"]+tx2["fee"])
|
||||
assert_equal(self.nodes[0].getbalance("foo", 0), 12190+tx1["amount"]+tx1["fee"])
|
||||
assert_equal(self.nodes[0].getbalance("bar", 0), 290+tx2["amount"]+tx2["fee"])
|
||||
|
||||
if self.options.mine_block:
|
||||
assert_equal(tx1["confirmations"], 1)
|
||||
@ -114,28 +114,28 @@ class TxnMallTest(BitcoinTestFramework):
|
||||
assert_equal(tx1["confirmations"], -2)
|
||||
assert_equal(tx2["confirmations"], -2)
|
||||
|
||||
# Node0's total balance should be starting balance, plus 100BTC for
|
||||
# two more matured blocks, minus 1240 for the double-spend, plus fees (which are
|
||||
# Node0's total balance should be starting balance, plus 1000DASH for
|
||||
# two more matured blocks, minus 12400 for the double-spend, plus fees (which are
|
||||
# negative):
|
||||
expected = starting_balance + 100 - 1240 + fund_foo_tx["fee"] + fund_bar_tx["fee"] + doublespend_fee
|
||||
expected = starting_balance + 1000 - 12400 + fund_foo_tx["fee"] + fund_bar_tx["fee"] + doublespend_fee
|
||||
assert_equal(self.nodes[0].getbalance(), expected)
|
||||
assert_equal(self.nodes[0].getbalance("*"), expected)
|
||||
|
||||
# Final "" balance is starting_balance - amount moved to accounts - doublespend + subsidies +
|
||||
# fees (which are negative)
|
||||
assert_equal(self.nodes[0].getbalance("foo"), 1219)
|
||||
assert_equal(self.nodes[0].getbalance("bar"), 29)
|
||||
assert_equal(self.nodes[0].getbalance("foo"), 12190)
|
||||
assert_equal(self.nodes[0].getbalance("bar"), 290)
|
||||
assert_equal(self.nodes[0].getbalance(""), starting_balance
|
||||
-1219
|
||||
- 29
|
||||
-1240
|
||||
+ 100
|
||||
-12190
|
||||
- 290
|
||||
-12400
|
||||
+ 1000
|
||||
+ fund_foo_tx["fee"]
|
||||
+ fund_bar_tx["fee"]
|
||||
+ doublespend_fee)
|
||||
|
||||
# Node1's "from0" account balance should be just the doublespend:
|
||||
assert_equal(self.nodes[1].getbalance("from0"), 1240)
|
||||
assert_equal(self.nodes[1].getbalance("from0"), 12400)
|
||||
|
||||
if __name__ == '__main__':
|
||||
TxnMallTest().main()
|
||||
|
||||
@ -14,10 +14,10 @@ class WalletTest (BitcoinTestFramework):
|
||||
fee = balance_with_fee - curr_balance
|
||||
target_fee = fee_per_byte * tx_size
|
||||
if fee < target_fee:
|
||||
raise AssertionError("Fee of %s BTC too low! (Should be %s BTC)"%(str(fee), str(target_fee)))
|
||||
raise AssertionError("Fee of %s DASH too low! (Should be %s DASH)"%(str(fee), str(target_fee)))
|
||||
# allow the node's estimation to be at most 2 bytes off
|
||||
if fee > fee_per_byte * (tx_size + 2):
|
||||
raise AssertionError("Fee of %s BTC too high! (Should be %s BTC)"%(str(fee), str(target_fee)))
|
||||
raise AssertionError("Fee of %s DASH too high! (Should be %s DASH)"%(str(fee), str(target_fee)))
|
||||
return curr_balance
|
||||
|
||||
def setup_chain(self):
|
||||
@ -38,21 +38,21 @@ class WalletTest (BitcoinTestFramework):
|
||||
self.nodes[0].generate(1)
|
||||
|
||||
walletinfo = self.nodes[0].getwalletinfo()
|
||||
assert_equal(walletinfo['immature_balance'], 50)
|
||||
assert_equal(walletinfo['immature_balance'], 500)
|
||||
assert_equal(walletinfo['balance'], 0)
|
||||
|
||||
self.sync_all()
|
||||
self.nodes[1].generate(101)
|
||||
self.sync_all()
|
||||
|
||||
assert_equal(self.nodes[0].getbalance(), 50)
|
||||
assert_equal(self.nodes[1].getbalance(), 50)
|
||||
assert_equal(self.nodes[0].getbalance(), 500)
|
||||
assert_equal(self.nodes[1].getbalance(), 500)
|
||||
assert_equal(self.nodes[2].getbalance(), 0)
|
||||
|
||||
# Send 21 BTC from 0 to 2 using sendtoaddress call.
|
||||
# Send 210 DASH from 0 to 2 using sendtoaddress call.
|
||||
# Second transaction will be child of first, and will require a fee
|
||||
self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 11)
|
||||
self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 10)
|
||||
self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 110)
|
||||
self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 100)
|
||||
|
||||
walletinfo = self.nodes[0].getwalletinfo()
|
||||
assert_equal(walletinfo['immature_balance'], 0)
|
||||
@ -65,10 +65,10 @@ class WalletTest (BitcoinTestFramework):
|
||||
self.nodes[1].generate(100)
|
||||
self.sync_all()
|
||||
|
||||
# node0 should end up with 100 btc in block rewards plus fees, but
|
||||
# minus the 21 plus fees sent to node2
|
||||
assert_equal(self.nodes[0].getbalance(), 100-21)
|
||||
assert_equal(self.nodes[2].getbalance(), 21)
|
||||
# node0 should end up with 1000 DASH in block rewards plus fees, but
|
||||
# minus the 210 plus fees sent to node2
|
||||
assert_equal(self.nodes[0].getbalance(), 1000-210)
|
||||
assert_equal(self.nodes[2].getbalance(), 210)
|
||||
|
||||
# Node0 should have two unspent outputs.
|
||||
# Create a couple of transactions to send them to node2, submit them through
|
||||
@ -95,42 +95,42 @@ class WalletTest (BitcoinTestFramework):
|
||||
self.sync_all()
|
||||
|
||||
assert_equal(self.nodes[0].getbalance(), 0)
|
||||
assert_equal(self.nodes[2].getbalance(), 100)
|
||||
assert_equal(self.nodes[2].getbalance("from1"), 100-21)
|
||||
assert_equal(self.nodes[2].getbalance(), 1000)
|
||||
assert_equal(self.nodes[2].getbalance("from1"), 1000-210)
|
||||
|
||||
# Send 10 BTC normal
|
||||
# Send 100 DASH normal
|
||||
address = self.nodes[0].getnewaddress("test")
|
||||
fee_per_byte = Decimal('0.001') / 1000
|
||||
self.nodes[2].settxfee(fee_per_byte * 1000)
|
||||
txid = self.nodes[2].sendtoaddress(address, 10, "", "", False)
|
||||
txid = self.nodes[2].sendtoaddress(address, 100, "", "", False)
|
||||
self.nodes[2].generate(1)
|
||||
self.sync_all()
|
||||
node_2_bal = self.check_fee_amount(self.nodes[2].getbalance(), Decimal('90'), fee_per_byte, count_bytes(self.nodes[2].getrawtransaction(txid)))
|
||||
assert_equal(self.nodes[0].getbalance(), Decimal('10'))
|
||||
node_2_bal = self.check_fee_amount(self.nodes[2].getbalance(), Decimal('900'), fee_per_byte, count_bytes(self.nodes[2].getrawtransaction(txid)))
|
||||
assert_equal(self.nodes[0].getbalance(), Decimal('100'))
|
||||
|
||||
# Send 10 BTC with subtract fee from amount
|
||||
txid = self.nodes[2].sendtoaddress(address, 10, "", "", True)
|
||||
# Send 100 DASH with subtract fee from amount
|
||||
txid = self.nodes[2].sendtoaddress(address, 100, "", "", True)
|
||||
self.nodes[2].generate(1)
|
||||
self.sync_all()
|
||||
node_2_bal -= Decimal('10')
|
||||
node_2_bal -= Decimal('100')
|
||||
assert_equal(self.nodes[2].getbalance(), node_2_bal)
|
||||
node_0_bal = self.check_fee_amount(self.nodes[0].getbalance(), Decimal('20'), fee_per_byte, count_bytes(self.nodes[2].getrawtransaction(txid)))
|
||||
node_0_bal = self.check_fee_amount(self.nodes[0].getbalance(), Decimal('200'), fee_per_byte, count_bytes(self.nodes[2].getrawtransaction(txid)))
|
||||
|
||||
# Sendmany 10 BTC
|
||||
txid = self.nodes[2].sendmany('from1', {address: 10}, 0, "", [])
|
||||
# Sendmany 100 DASH
|
||||
txid = self.nodes[2].sendmany('from1', {address: 100}, 0, "", [])
|
||||
self.nodes[2].generate(1)
|
||||
self.sync_all()
|
||||
node_0_bal += Decimal('10')
|
||||
node_2_bal = self.check_fee_amount(self.nodes[2].getbalance(), node_2_bal - Decimal('10'), fee_per_byte, count_bytes(self.nodes[2].getrawtransaction(txid)))
|
||||
node_0_bal += Decimal('100')
|
||||
node_2_bal = self.check_fee_amount(self.nodes[2].getbalance(), node_2_bal - Decimal('100'), fee_per_byte, count_bytes(self.nodes[2].getrawtransaction(txid)))
|
||||
assert_equal(self.nodes[0].getbalance(), node_0_bal)
|
||||
|
||||
# Sendmany 10 BTC with subtract fee from amount
|
||||
txid = self.nodes[2].sendmany('from1', {address: 10}, 0, "", [address])
|
||||
# Sendmany 100 DASH with subtract fee from amount
|
||||
txid = self.nodes[2].sendmany('from1', {address: 100}, 0, "", [address])
|
||||
self.nodes[2].generate(1)
|
||||
self.sync_all()
|
||||
node_2_bal -= Decimal('10')
|
||||
node_2_bal -= Decimal('100')
|
||||
assert_equal(self.nodes[2].getbalance(), node_2_bal)
|
||||
node_0_bal = self.check_fee_amount(self.nodes[0].getbalance(), node_0_bal + Decimal('10'), fee_per_byte, count_bytes(self.nodes[2].getrawtransaction(txid)))
|
||||
node_0_bal = self.check_fee_amount(self.nodes[0].getbalance(), node_0_bal + Decimal('100'), fee_per_byte, count_bytes(self.nodes[2].getrawtransaction(txid)))
|
||||
|
||||
# Test ResendWalletTransactions:
|
||||
# Create a couple of transactions, then start up a fourth
|
||||
@ -157,7 +157,7 @@ class WalletTest (BitcoinTestFramework):
|
||||
#4. check if recipient (node0) can list the zero value tx
|
||||
usp = self.nodes[1].listunspent()
|
||||
inputs = [{"txid":usp[0]['txid'], "vout":usp[0]['vout']}]
|
||||
outputs = {self.nodes[1].getnewaddress(): 49.998, self.nodes[0].getnewaddress(): 11.11}
|
||||
outputs = {self.nodes[1].getnewaddress(): 499.998, self.nodes[0].getnewaddress(): 11.11}
|
||||
|
||||
rawTx = self.nodes[1].createrawtransaction(inputs, outputs).replace("c0833842", "00000000") #replace 11.11 with 0.0 (int32)
|
||||
decRawTx = self.nodes[1].decoderawtransaction(rawTx)
|
||||
|
||||
@ -10,7 +10,7 @@ Test case is:
|
||||
4 nodes. 1 2 and 3 send transactions between each other,
|
||||
fourth node is a miner.
|
||||
1 2 3 each mine a block to start, then
|
||||
Miner creates 100 blocks so 1 2 3 each have 50 mature
|
||||
Miner creates 100 blocks so 1 2 3 each have 500 mature
|
||||
coins to spend.
|
||||
Then 5 iterations of 1/2/3 sending coins amongst
|
||||
themselves to get transactions in the wallets,
|
||||
@ -23,7 +23,7 @@ Miner then generates 101 more blocks, so any
|
||||
transaction fees paid mature.
|
||||
|
||||
Sanity check:
|
||||
Sum(1,2,3,4 balances) == 114*50
|
||||
Sum(1,2,3,4 balances) == 114*500
|
||||
|
||||
1/2/3 are shutdown, and their wallets erased.
|
||||
Then restore using wallet.dat backup. And
|
||||
@ -110,9 +110,9 @@ class WalletBackupTest(BitcoinTestFramework):
|
||||
self.nodes[3].generate(100)
|
||||
sync_blocks(self.nodes)
|
||||
|
||||
assert_equal(self.nodes[0].getbalance(), 50)
|
||||
assert_equal(self.nodes[1].getbalance(), 50)
|
||||
assert_equal(self.nodes[2].getbalance(), 50)
|
||||
assert_equal(self.nodes[0].getbalance(), 500)
|
||||
assert_equal(self.nodes[1].getbalance(), 500)
|
||||
assert_equal(self.nodes[2].getbalance(), 500)
|
||||
assert_equal(self.nodes[3].getbalance(), 0)
|
||||
|
||||
logging.info("Creating transactions")
|
||||
@ -144,8 +144,8 @@ class WalletBackupTest(BitcoinTestFramework):
|
||||
total = balance0 + balance1 + balance2 + balance3
|
||||
|
||||
# At this point, there are 214 blocks (103 for setup, then 10 rounds, then 101.)
|
||||
# 114 are mature, so the sum of all wallets should be 114 * 50 = 5700.
|
||||
assert_equal(total, 5700)
|
||||
# 114 are mature, so the sum of all wallets should be 114 * 500 = 57000.
|
||||
assert_equal(total, 57000)
|
||||
|
||||
##
|
||||
# Test restoring spender wallets from backups
|
||||
|
||||
@ -28,7 +28,7 @@ class ZapWalletTXesTest (BitcoinTestFramework):
|
||||
self.nodes[1].generate(101)
|
||||
self.sync_all()
|
||||
|
||||
assert_equal(self.nodes[0].getbalance(), 50)
|
||||
assert_equal(self.nodes[0].getbalance(), 500)
|
||||
|
||||
txid0 = self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 11)
|
||||
txid1 = self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 10)
|
||||
|
||||
Loading…
Reference in New Issue
Block a user