text: # Copyright (c) 2018 The Monero Project
  # 
  # All rights reserved.
  # 
  # Redistribution and use in source and binary forms, with or without modification, are
  # permitted provided that the following conditions are met:
  # 
  # 1. Redistributions of source code must retain the above copyright notice, this list of
  #    conditions and the following disclaimer.
  # 
  # 2. Redistributions in binary form must reproduce the above copyright notice, this list
  #    of conditions and the following disclaimer in the documentation and/or other
  #    materials provided with the distribution.
  # 
  # 3. Neither the name of the copyright holder nor the names of its contributors may be
  #    used to endorse or promote products derived from this software without specific
  #    prior written permission.
  # 
  # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
  # EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  # MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
  # THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  # PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  # INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  # STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
  # THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  
  """Daemon class to make rpc calls and store state."""
  
  from .rpc import JSONRPC 
  
  class Daemon(object):
  
      def __init__(self, protocol='http', host='127.0.0.1', port=0, idx=0, restricted_rpc = False):
          base = 18480 if restricted_rpc else 18180
          self.host = host
          self.port = port
          self.rpc = JSONRPC('{protocol}://{host}:{port}'.format(protocol=protocol, host=host, port=port if port else base+idx))
  
      def getblocktemplate(self, address, prev_block = "", client = ""):
          getblocktemplate = {
              'method': 'getblocktemplate',
              'params': {
                  'client': client,
                  'wallet_address': address,
                  'reserve_size' : 1,
                  'prev_block' : prev_block,
              },
              'jsonrpc': '2.0', 
              'id': '0'
          }
          return self.rpc.send_json_rpc_request(getblocktemplate)
      get_block_template = getblocktemplate
  
      def get_miner_data(self):
          get_miner_data = {
              'method': 'get_miner_data',
              'jsonrpc': '2.0',
              'id': '0'
          }
          return self.rpc.send_json_rpc_request(get_miner_data)
  
      def send_raw_transaction(self, tx_as_hex, do_not_relay = False, do_sanity_checks = True, client = ""):
          send_raw_transaction = {
              'client': client,
              'tx_as_hex': tx_as_hex,
              'do_not_relay': do_not_relay,
              'do_sanity_checks': do_sanity_checks,
          }
          return self.rpc.send_request("/send_raw_transaction", send_raw_transaction)
      sendrawtransaction = send_raw_transaction
  
      def submitblock(self, block):
          submitblock = {
              'method': 'submitblock',
              'params': [ block ],    
              'jsonrpc': '2.0', 
              'id': '0'
          }    
          return self.rpc.send_json_rpc_request(submitblock)
      submit_block = submitblock
  
      def getblock(self, hash = '', height = 0, fill_pow_hash = False, client = ""):
          getblock = {
              'method': 'getblock',
              'params': {
                  'client': client,
                  'hash': hash,
                  'height': height,
                  'fill_pow_hash': fill_pow_hash,
              },
              'jsonrpc': '2.0', 
              'id': '0'
          }
          return self.rpc.send_json_rpc_request(getblock)
      get_block = getblock
  
      def getlastblockheader(self, client = ""):
          getlastblockheader = {
              'method': 'getlastblockheader',
              'params': {
                  'client': client,
              },
              'jsonrpc': '2.0', 
              'id': '0'
          }
          return self.rpc.send_json_rpc_request(getlastblockheader)
      get_last_block_header = getlastblockheader
  
      def getblockheaderbyhash(self, hash = "", hashes = [], client = ""):
          getblockheaderbyhash = {
              'method': 'getblockheaderbyhash',
              'params': {
                  'client': client,
                  'hash': hash,
                  'hashes': hashes,
              },
              'jsonrpc': '2.0', 
              'id': '0'
          }
          return self.rpc.send_json_rpc_request(getblockheaderbyhash)
      get_block_header_by_hash = getblockheaderbyhash
  
      def getblockheaderbyheight(self, height, client = ""):
          getblockheaderbyheight = {
              'method': 'getblockheaderbyheight',
              'params': {
                  'client': client,
                  'height': height,
              },
              'jsonrpc': '2.0', 
              'id': '0'
          }
          return self.rpc.send_json_rpc_request(getblockheaderbyheight)
      get_block_header_by_height = getblockheaderbyheight
  
      def getblockheadersrange(self, start_height, end_height, fill_pow_hash = False, client = ""):
          getblockheadersrange = {
              'method': 'getblockheadersrange',
              'params': {
                  'client': client,
                  'start_height': start_height,
                  'end_height': end_height,
                  'fill_pow_hash': fill_pow_hash,
              },
              'jsonrpc': '2.0', 
              'id': '0'
          }
          return self.rpc.send_json_rpc_request(getblockheadersrange)
      get_block_headers_range = getblockheadersrange
  
      def get_connections(self, client = ""):
          get_connections = {
              'client': client,
              'method': 'get_connections',
              'jsonrpc': '2.0', 
              'id': '0'
          }
          return self.rpc.send_json_rpc_request(get_connections)
  
      def get_info(self, client = ""):
          get_info = {
              'method': 'get_info',
              'params': {
                  'client': client,
              },
              'jsonrpc': '2.0',
              'id': '0'
          }    
          return self.rpc.send_json_rpc_request(get_info)
      getinfo = get_info
  
      def hard_fork_info(self, client = ""):
          hard_fork_info = {
              'method': 'hard_fork_info',
              'params': {
                  'client': client,
              },
              'jsonrpc': '2.0',
              'id': '0'
          }    
          return self.rpc.send_json_rpc_request(hard_fork_info)
  
      def generateblocks(self, address, blocks=1, prev_block = "", starting_nonce = 0):
          generateblocks = {
              'method': 'generateblocks',
              'params': {
                  'amount_of_blocks' : blocks,
                  'reserve_size' : 20,
                  'wallet_address': address,
                  'prev_block': prev_block,
                  'starting_nonce': starting_nonce,
              },
              'jsonrpc': '2.0', 
              'id': '0'
          }
          return self.rpc.send_json_rpc_request(generateblocks)
  
      def get_height(self, client = ""):
          get_height = {
                  'method': 'get_height',
                  'jsonrpc': '2.0',
                  'id': '0'
          }
          return self.rpc.send_request("/get_height", get_height)
      getheight = get_height
  
      def pop_blocks(self, nblocks = 1):
          pop_blocks = {
              'nblocks' : nblocks,
          }
          return self.rpc.send_request("/pop_blocks", pop_blocks)
  
      def start_mining(self, miner_address, threads_count = 0, do_background_mining = False, ignore_battery = False):
          start_mining = {
              'miner_address' : miner_address,
              'threads_count' : threads_count,
              'do_background_mining' : do_background_mining,
              'ignore_battery' : ignore_battery,
          }
          return self.rpc.send_request('/start_mining', start_mining)
  
      def stop_mining(self):
          stop_mining = {
          }
          return self.rpc.send_request('/stop_mining', stop_mining)
  
      def mining_status(self):
          mining_status = {
          }
          return self.rpc.send_request('/mining_status', mining_status)
  
      def get_transaction_pool(self, client = ""):
          get_transaction_pool = {
              'client': client,
          }
          return self.rpc.send_request('/get_transaction_pool', get_transaction_pool)
  
      def get_transaction_pool_hashes(self, client = ""):
          get_transaction_pool_hashes = {
              'client': client,
          }
          return self.rpc.send_request('/get_transaction_pool_hashes', get_transaction_pool_hashes)
  
      def get_transaction_pool_stats(self, client = ""):
          get_transaction_pool_stats = {
              'client': client,
          }
          return self.rpc.send_request('/get_transaction_pool_stats', get_transaction_pool_stats)
  
      def flush_txpool(self, txids = []):
          flush_txpool = {
              'method': 'flush_txpool',
              'params': {
                  'txids': txids
              },
              'jsonrpc': '2.0',
              'id': '0'
          }
          return self.rpc.send_json_rpc_request(flush_txpool)
  
      def get_version(self):
          get_version = {
              'method': 'get_version',
              'jsonrpc': '2.0',
              'id': '0'
          }
          return self.rpc.send_json_rpc_request(get_version)
  
      def get_bans(self):
          get_bans = {
              'method': 'get_bans',
              'params': {
              },
              'jsonrpc': '2.0',
              'id': '0'
          }
          return self.rpc.send_json_rpc_request(get_bans)
  
      def set_bans(self, bans = []):
          set_bans = {
              'method': 'set_bans',
              'params': {
                  'bans': bans
              },
              'jsonrpc': '2.0',
              'id': '0'
          }
          return self.rpc.send_json_rpc_request(set_bans)
  
      def banned(self, address = ''):
          banned = {
              'method': 'banned',
              'params': {
                  'address': address
              },
              'jsonrpc': '2.0',
              'id': '0'
          }
          return self.rpc.send_json_rpc_request(banned)
  
      def set_bootstrap_daemon(self, address, username = '', password = ''):
          set_bootstrap_daemon = {
              'address': address,
              'username': username,
              'password': password,
          }
          return self.rpc.send_request('/set_bootstrap_daemon', set_bootstrap_daemon)
  
      def get_public_nodes(self, gray = False, white = True):
          get_public_nodes = {
              'gray': gray,
              'white': white,
          }
          return self.rpc.send_request('/get_public_nodes', get_public_nodes)
  
      def get_transactions(self, txs_hashes = [], decode_as_json = False, prune = False, split = False, client = ""):
          get_transactions = {
              'client': client,
              'txs_hashes': txs_hashes,
              'decode_as_json': decode_as_json,
              'prune': prune,
              'split': split,
          }
          return self.rpc.send_request('/get_transactions', get_transactions)
      gettransactions = get_transactions
  
      def get_outs(self, outputs = [], get_txid = False, client = ""):
          get_outs = {
              'client': client,
              'outputs': outputs,
              'get_txid': get_txid,
          }
          return self.rpc.send_request('/get_outs', get_outs)
  
      def get_coinbase_tx_sum(self, height, count, client = ""):
          get_coinbase_tx_sum = {
              'method': 'get_coinbase_tx_sum',
              'params': {
                  'client': client,
                  'height': height,
                  'count': count,
              },
              'jsonrpc': '2.0',
              'id': '0'
          }
          return self.rpc.send_json_rpc_request(get_coinbase_tx_sum)
  
      def get_output_distribution(self, amounts = [], from_height = 0, to_height = 0, cumulative = False, binary = False, compress = False, client = ""):
          get_output_distribution = {
              'method': 'get_output_distribution',
              'params': {
                  'client': client,
                  'amounts': amounts,
                  'from_height': from_height,
                  'to_height': to_height,
                  'cumulative': cumulative,
                  'binary': binary,
                  'compress': compress,
              },
              'jsonrpc': '2.0',
              'id': '0'
          }
          return self.rpc.send_json_rpc_request(get_output_distribution)
  
      def get_output_histogram(self, amounts = [], min_count = 0, max_count = 0, unlocked = False, recent_cutoff = 0, client = ""):
          get_output_histogram = {
              'method': 'get_output_histogram',
              'params': {
                  'client': client,
                  'amounts': amounts,
                  'min_count': min_count,
                  'max_count': max_count,
                  'unlocked': unlocked,
                  'recent_cutoff': recent_cutoff,
              },
              'jsonrpc': '2.0',
              'id': '0'
          }
          return self.rpc.send_json_rpc_request(get_output_histogram)
  
      def set_log_level(self, level):
          set_log_level = {
              'level': level,
          }
          return self.rpc.send_request('/set_log_level', set_log_level)
  
      def set_log_categories(self, categories = ''):
          set_log_categories = {
              'categories': categories,
          }
          return self.rpc.send_request('/set_log_categories', set_log_categories)
  
      def get_alt_blocks_hashes(self, client = ""):
          get_alt_blocks_hashes = {
              'client': client,
          }
          return self.rpc.send_request('/get_alt_blocks_hashes', get_alt_blocks_hashes)
  
      def get_alternate_chains(self, client = ""):
          get_alternate_chains = {
              'method': 'get_alternate_chains',
              'params': {
                  'client': client,
              },
              'jsonrpc': '2.0',
              'id': '0'
          }
          return self.rpc.send_json_rpc_request(get_alternate_chains)
  
      def get_fee_estimate(self, grace_blocks = 0):
          get_fee_estimate = {
              'method': 'get_fee_estimate',
              'params': {
                  'grace_blocks': grace_blocks,
              },
              'jsonrpc': '2.0',
              'id': '0'
          }
          return self.rpc.send_json_rpc_request(get_fee_estimate)
  
      def is_key_image_spent(self, key_images = [], client = ""):
          is_key_image_spent = {
              'key_images': key_images,
              'client': client,
          }
          return self.rpc.send_request('/is_key_image_spent', is_key_image_spent)
  
      def save_bc(self):
          save_bc = {
          }
          return self.rpc.send_request('/save_bc', save_bc)
  
      def get_peer_list(self):
          get_peer_list = {
          }
          return self.rpc.send_request('/get_peer_list', get_peer_list)
  
      def set_log_hash_rate(self, visible):
          set_log_hash_rate = {
              'visible': visible,
          }
          return self.rpc.send_request('/set_log_hash_rate', set_log_hash_rate)
  
      def stop_daemon(self):
          stop_daemon = {
          }
          return self.rpc.send_request('/stop_daemon', stop_daemon)
  
      def get_net_stats(self):
          get_net_stats = {
          }
          return self.rpc.send_request('/get_net_stats', get_net_stats)
  
      def get_limit(self):
          get_limit = {
          }
          return self.rpc.send_request('/get_limit', get_limit)
  
      def set_limit(self, limit_down, limit_up):
          set_limit = {
              'limit_down': limit_down,
              'limit_up': limit_up,
          }
          return self.rpc.send_request('/set_limit', set_limit)
  
      def out_peers(self, out_peers):
          out_peers = {
              'out_peers': out_peers,
          }
          return self.rpc.send_request('/out_peers', out_peers)
  
      def in_peers(self, in_peers):
          in_peers = {
              'in_peers': in_peers,
          }
          return self.rpc.send_request('/in_peers', in_peers)
  
      def update(self, command, path = None):
          update = {
              'command': command,
              'path': path,
          }
          return self.rpc.send_request('/update', update)
  
      def get_block_count(self):
          get_block_count = {
              'method': 'get_block_count',
              'params': {
              },
              'jsonrpc': '2.0', 
              'id': '0'
          }
          return self.rpc.send_json_rpc_request(get_block_count)
      getblockcount = get_block_count
  
      def get_block_hash(self, height):
          get_block_hash = {
              'method': 'get_block_hash',
              'params': [height],
              'jsonrpc': '2.0', 
              'id': '0'
          }
          return self.rpc.send_json_rpc_request(get_block_hash)
      on_get_block_hash = get_block_hash
      on_getblockhash = get_block_hash
  
      def relay_tx(self, txids = [], client = ""):
          relay_tx = {
              'method': 'relay_tx',
              'params': {
                  'txids': txids,
                  'client': client,
              },
              'jsonrpc': '2.0', 
              'id': '0'
          }
          return self.rpc.send_json_rpc_request(relay_tx)
  
      def sync_info(self, client = ""):
          sync_info = {
              'method': 'sync_info',
              'params': {
                  'client': client,
              },
              'jsonrpc': '2.0', 
              'id': '0'
          }
          return self.rpc.send_json_rpc_request(sync_info)
  
      def get_txpool_backlog(self, client = ""):
          get_txpool_backlog = {
              'method': 'get_txpool_backlog',
              'params': {
                  'client': client,
              },
              'jsonrpc': '2.0', 
              'id': '0'
          }
          return self.rpc.send_json_rpc_request(get_txpool_backlog)
  
      def prune_blockchain(self, check = False):
          prune_blockchain = {
              'method': 'prune_blockchain',
              'params': {
                  'check': check,
              },
              'jsonrpc': '2.0', 
              'id': '0'
          }
          return self.rpc.send_json_rpc_request(prune_blockchain)
  
      def flush_cache(self, bad_txs = False):
          flush_cache = {
              'method': 'flush_cache',
              'params': {
                  'bad_txs': bad_txs,
              },
              'jsonrpc': '2.0',
              'id': '0'
          }
          return self.rpc.send_json_rpc_request(flush_cache)
  
      def sync_txpool(self):
          sync_txpool = {
              'method': 'sync_txpool',
              'params': {
              },
              'jsonrpc': '2.0',
              'id': '0'
          }
          return self.rpc.send_json_rpc_request(sync_txpool)
  
      def rpc_access_info(self, client):
          rpc_access_info = {
              'method': 'rpc_access_info',
              'params': {
                  'client': client,
              },
              'jsonrpc': '2.0',
              'id': '0'
          }
          return self.rpc.send_json_rpc_request(rpc_access_info)
  
      def rpc_access_submit_nonce(self, client, nonce, cookie):
          rpc_access_submit_nonce = {
              'method': 'rpc_access_submit_nonce',
              'params': {
                  'client': client,
                  'nonce': nonce,
                  'cookie': cookie,
              },
              'jsonrpc': '2.0',
              'id': '0'
          }
          return self.rpc.send_json_rpc_request(rpc_access_submit_nonce)
  
      def rpc_access_pay(self, client, paying_for, payment):
          rpc_access_pay = {
              'method': 'rpc_access_pay',
              'params': {
                  'client': client,
                  'paying_for': paying_for,
                  'payment': payment,
              },
              'jsonrpc': '2.0',
              'id': '0'
          }
          return self.rpc.send_json_rpc_request(rpc_access_pay)
  
      def rpc_access_tracking(self, clear = False):
          rpc_access_tracking = {
              'method': 'rpc_access_tracking',
              'params': {
                  'clear': clear,
              },
              'jsonrpc': '2.0',
              'id': '0'
          }
          return self.rpc.send_json_rpc_request(rpc_access_tracking)
  
      def rpc_access_data(self):
          rpc_access_data = {
              'method': 'rpc_access_data',
              'params': {
              },
              'jsonrpc': '2.0',
              'id': '0'
          }
          return self.rpc.send_json_rpc_request(rpc_access_data)
  
      def rpc_access_account(self, client, delta_balance = 0):
          rpc_access_account = {
              'method': 'rpc_access_account',
              'params': {
                  'client': client,
                  'delta_balance': delta_balance,
              },
              'jsonrpc': '2.0',
              'id': '0'
          }
          return self.rpc.send_json_rpc_request(rpc_access_account)
  