text: #!/usr/bin/env python2
  # coding=utf-8
  # ^^^^^^^^^^^^ TODO remove when supporting only Python3
  # Copyright (c) 2014-2015 The Bitcoin Core developers
  # Distributed under the MIT software license, see the accompanying
  # file COPYING or http://www.opensource.org/licenses/mit-license.php.
  
  from test_framework.test_framework import BitcoinTestFramework
  from test_framework.util import *
  
  class WalletTest (BitcoinTestFramework):
  
      def check_fee_amount(self, curr_balance, balance_with_fee, fee_per_byte, tx_size):
          """Return curr_balance after asserting the fee was in range"""
          fee = balance_with_fee - curr_balance
          target_fee = fee_per_byte * tx_size
          if fee < target_fee:
              raise AssertionError("Fee of %s ABS too low! (Should be %s ABS)"%(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 ABS too high! (Should be %s ABS)"%(str(fee), str(target_fee)))
          return curr_balance
  
      def setup_chain(self):
          print("Initializing test directory "+self.options.tmpdir)
          initialize_chain_clean(self.options.tmpdir, 4)
  
      def setup_network(self, split=False):
          self.nodes = start_nodes(3, self.options.tmpdir)
          connect_nodes_bi(self.nodes,0,1)
          connect_nodes_bi(self.nodes,1,2)
          connect_nodes_bi(self.nodes,0,2)
          self.is_network_split=False
          self.sync_all()
  
      def run_test (self):
  
          # Check that there's no UTXO on none of the nodes
          assert_equal(len(self.nodes[0].listunspent()), 0)
          assert_equal(len(self.nodes[1].listunspent()), 0)
          assert_equal(len(self.nodes[2].listunspent()), 0)
  
          print "Mining blocks..."
  
          self.nodes[0].generate(1)
  
          walletinfo = self.nodes[0].getwalletinfo()
          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(), 500)
          assert_equal(self.nodes[1].getbalance(), 500)
          assert_equal(self.nodes[2].getbalance(), 0)
  
          # Check that only first and second nodes have UTXOs
          assert_equal(len(self.nodes[0].listunspent()), 1)
          assert_equal(len(self.nodes[1].listunspent()), 1)
          assert_equal(len(self.nodes[2].listunspent()), 0)
  
          # Send 210 ABS 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(), 110)
          self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 100)
  
          walletinfo = self.nodes[0].getwalletinfo()
          assert_equal(walletinfo['immature_balance'], 0)
  
          # Have node0 mine a block, thus it will collect its own fee.
          self.nodes[0].generate(1)
          self.sync_all()
  
          # Exercise locking of unspent outputs
          unspent_0 = self.nodes[2].listunspent()[0]
          unspent_0 = {"txid": unspent_0["txid"], "vout": unspent_0["vout"]}
          self.nodes[2].lockunspent(False, [unspent_0])
          assert_raises(JSONRPCException, self.nodes[2].sendtoaddress, self.nodes[2].getnewaddress(), 200)
          assert_equal([unspent_0], self.nodes[2].listlockunspent())
          self.nodes[2].lockunspent(True, [unspent_0])
          assert_equal(len(self.nodes[2].listlockunspent()), 0)
  
          # Have node1 generate 100 blocks (so node0 can recover the fee)
          self.nodes[1].generate(100)
          self.sync_all()
  
          # node0 should end up with 1000 ABS 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
          # node1, and make sure both node0 and node2 pick them up properly:
          node0utxos = self.nodes[0].listunspent(1)
          assert_equal(len(node0utxos), 2)
  
          # create both transactions
          txns_to_send = []
          for utxo in node0utxos:
              inputs = []
              outputs = {}
              inputs.append({ "txid" : utxo["txid"], "vout" : utxo["vout"]})
              outputs[self.nodes[2].getnewaddress("from1")] = utxo["amount"]
              raw_tx = self.nodes[0].createrawtransaction(inputs, outputs)
              txns_to_send.append(self.nodes[0].signrawtransaction(raw_tx))
  
          # Have node 1 (miner) send the transactions
          self.nodes[1].sendrawtransaction(txns_to_send[0]["hex"], True)
          self.nodes[1].sendrawtransaction(txns_to_send[1]["hex"], True)
  
          # Have node1 mine a block to confirm transactions:
          self.nodes[1].generate(1)
          self.sync_all()
  
          assert_equal(self.nodes[0].getbalance(), 0)
          assert_equal(self.nodes[2].getbalance(), 1000)
          assert_equal(self.nodes[2].getbalance("from1"), 1000-210)
  
          # Send 100 ABS normal
          address = self.nodes[0].getnewaddress("test")
          fee_per_byte = Decimal('0.00001') / 1000
          self.nodes[2].settxfee(fee_per_byte * 1000)
          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('900'), fee_per_byte, count_bytes(self.nodes[2].getrawtransaction(txid)))
          assert_equal(self.nodes[0].getbalance(), Decimal('100'))
  
          # Send 100 ABS 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('100')
          assert_equal(self.nodes[2].getbalance(), node_2_bal)
          node_0_bal = self.check_fee_amount(self.nodes[0].getbalance(), Decimal('200'), fee_per_byte, count_bytes(self.nodes[2].getrawtransaction(txid)))
  
          # Sendmany 100 ABS
          txid = self.nodes[2].sendmany('from1', {address: 100}, 0, False, "", [])
          self.nodes[2].generate(1)
          self.sync_all()
          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 100 ABS with subtract fee from amount
          txid = self.nodes[2].sendmany('from1', {address: 100}, 0, False, "", [address])
          self.nodes[2].generate(1)
          self.sync_all()
          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('100'), fee_per_byte, count_bytes(self.nodes[2].getrawtransaction(txid)))
  
          # Test ResendWalletTransactions:
          # Create a couple of transactions, then start up a fourth
          # node (nodes[3]) and ask nodes[0] to rebroadcast.
          # EXPECT: nodes[3] should have those transactions in its mempool.
          txid1 = self.nodes[0].sendtoaddress(self.nodes[1].getnewaddress(), 1)
          txid2 = self.nodes[1].sendtoaddress(self.nodes[0].getnewaddress(), 1)
          sync_mempools(self.nodes)
  
          self.nodes.append(start_node(3, self.options.tmpdir))
          connect_nodes_bi(self.nodes, 0, 3)
          sync_blocks(self.nodes)
  
          relayed = self.nodes[0].resendwallettransactions()
          assert_equal(set(relayed), {txid1, txid2})
          sync_mempools(self.nodes)
  
          assert(txid1 in self.nodes[3].getrawmempool())
  
          # Exercise balance rpcs
          assert_equal(self.nodes[0].getwalletinfo()["unconfirmed_balance"], 1)
          assert_equal(self.nodes[0].getunconfirmedbalance(), 1)
  
          #check if we can list zero value tx as available coins
          #1. create rawtx
          #2. hex-changed one output to 0.0
          #3. sign and send
          #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(): 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)
          signedRawTx = self.nodes[1].signrawtransaction(rawTx)
          decRawTx = self.nodes[1].decoderawtransaction(signedRawTx['hex'])
          zeroValueTxid= decRawTx['txid']
          sendResp = self.nodes[1].sendrawtransaction(signedRawTx['hex'])
  
          self.sync_all()
          self.nodes[1].generate(1) #mine a block
          self.sync_all()
  
          unspentTxs = self.nodes[0].listunspent() #zero value tx must be in listunspents output
          found = False
          for uTx in unspentTxs:
              if uTx['txid'] == zeroValueTxid:
                  found = True
                  assert_equal(uTx['amount'], Decimal('0'))
          assert(found)
  
          #do some -walletbroadcast tests
          stop_nodes(self.nodes)
          wait_bitcoinds()
          self.nodes = start_nodes(3, self.options.tmpdir, [["-walletbroadcast=0"],["-walletbroadcast=0"],["-walletbroadcast=0"]])
          connect_nodes_bi(self.nodes,0,1)
          connect_nodes_bi(self.nodes,1,2)
          connect_nodes_bi(self.nodes,0,2)
          self.sync_all()
  
          txIdNotBroadcasted  = self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 2)
          txObjNotBroadcasted = self.nodes[0].gettransaction(txIdNotBroadcasted)
          self.nodes[1].generate(1) #mine a block, tx should not be in there
          self.sync_all()
          assert_equal(self.nodes[2].getbalance(), node_2_bal) #should not be changed because tx was not broadcasted
  
          #now broadcast from another node, mine a block, sync, and check the balance
          self.nodes[1].sendrawtransaction(txObjNotBroadcasted['hex'])
          self.nodes[1].generate(1)
          self.sync_all()
          node_2_bal += 2
          txObjNotBroadcasted = self.nodes[0].gettransaction(txIdNotBroadcasted)
          assert_equal(self.nodes[2].getbalance(), node_2_bal)
  
          #create another tx
          txIdNotBroadcasted  = self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 2)
  
          #restart the nodes with -walletbroadcast=1
          stop_nodes(self.nodes)
          wait_bitcoinds()
          self.nodes = start_nodes(3, self.options.tmpdir)
          connect_nodes_bi(self.nodes,0,1)
          connect_nodes_bi(self.nodes,1,2)
          connect_nodes_bi(self.nodes,0,2)
          sync_blocks(self.nodes)
  
          self.nodes[0].generate(1)
          sync_blocks(self.nodes)
          node_2_bal += 2
  
          #tx should be added to balance because after restarting the nodes tx should be broadcastet
          assert_equal(self.nodes[2].getbalance(), node_2_bal)
  
          #send a tx with value in a string (PR#6380 +)
          txId  = self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), "2")
          txObj = self.nodes[0].gettransaction(txId)
          assert_equal(txObj['amount'], Decimal('-2'))
  
          txId  = self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), "0.0001")
          txObj = self.nodes[0].gettransaction(txId)
          assert_equal(txObj['amount'], Decimal('-0.0001'))
  
          #check if JSON parser can handle scientific notation in strings
          txId  = self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), "1e-4")
          txObj = self.nodes[0].gettransaction(txId)
          assert_equal(txObj['amount'], Decimal('-0.0001'))
  
          try:
              txId  = self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), "1f-4")
          except JSONRPCException as e:
              assert("Invalid amount" in e.error['message'])
          else:
              raise AssertionError("Must not parse invalid amounts")
  
  
          try:
              self.nodes[0].generate("2")
              raise AssertionError("Must not accept strings as numeric")
          except JSONRPCException as e:
              assert("not an integer" in e.error['message'])
  
          # Import address and private key to check correct behavior of spendable unspents
          # 1. Send some coins to generate new UTXO
          address_to_import = self.nodes[2].getnewaddress()
          txid = self.nodes[0].sendtoaddress(address_to_import, 1)
          self.nodes[0].generate(1)
          self.sync_all()
  
          # 2. Import address from node2 to node1
          self.nodes[1].importaddress(address_to_import)
  
          # 3. Validate that the imported address is watch-only on node1
          assert(self.nodes[1].validateaddress(address_to_import)["iswatchonly"])
  
          # 4. Check that the unspents after import are not spendable
          assert_array_result(self.nodes[1].listunspent(),
                             {"address": address_to_import},
                             {"spendable": False})
  
          # 5. Import private key of the previously imported address on node1
          priv_key = self.nodes[2].dumpprivkey(address_to_import)
          self.nodes[1].importprivkey(priv_key)
  
          # 6. Check that the unspents are now spendable on node1
          assert_array_result(self.nodes[1].listunspent(),
                             {"address": address_to_import},
                             {"spendable": True})
  
          #check if wallet or blochchain maintenance changes the balance
          self.sync_all()
          blocks = self.nodes[0].generate(2)
          self.sync_all()
          balance_nodes = [self.nodes[i].getbalance() for i in range(3)]
          block_count = self.nodes[0].getblockcount()
  
          # Check modes:
          #   - True: unicode escaped as \u....
          #   - False: unicode directly as UTF-8
          for mode in [True, False]:
              self.nodes[0].ensure_ascii = mode
              # unicode check: Basic Multilingual Plane, Supplementary Plane respectively
              for s in [u'рыба', u'𝅘𝅥𝅯']:
                  addr = self.nodes[0].getaccountaddress(s)
                  label = self.nodes[0].getaccount(addr)
                  assert_equal(label.encode('utf-8'), s.encode('utf-8')) # TODO remove encode(...) when supporting only Python3
                  assert(s in self.nodes[0].listaccounts().keys())
          self.nodes[0].ensure_ascii = True # restore to default
  
          # maintenance tests
          maintenance = [
              '-rescan',
              '-reindex',
              '-zapwallettxes=1',
              '-zapwallettxes=2',
              '-salvagewallet',
          ]
          for m in maintenance:
              print "check " + m
              stop_nodes(self.nodes)
              wait_bitcoinds()
              self.nodes = start_nodes(3, self.options.tmpdir, [[m]] * 3)
              while m == '-reindex' and [block_count] * 3 != [self.nodes[i].getblockcount() for i in range(3)]:
                  # reindex will leave rpc warm up "early"; Wait for it to finish
                  time.sleep(0.1)
              assert_equal(balance_nodes, [self.nodes[i].getbalance() for i in range(3)])
  
          # Exercise listsinceblock with the last two blocks
          coinbase_tx_1 = self.nodes[0].listsinceblock(blocks[0])
          assert_equal(coinbase_tx_1["lastblock"], blocks[1])
          assert_equal(len(coinbase_tx_1["transactions"]), 1)
          assert_equal(coinbase_tx_1["transactions"][0]["blockhash"], blocks[1])
          assert_equal(len(self.nodes[0].listsinceblock(blocks[1])["transactions"]), 0)
  
  if __name__ == '__main__':
      WalletTest ().main ()
  