def main():
global rpc
APP_NAME = 'bch-interlinker'
NEW_TIP_CHECK_INTERVAL_SECONDS = 5
config_path = save_config_path(APP_NAME)
cache_path = save_cache_path(APP_NAME)
db_path = path.join(cache_path, 'db')
config_file_path = path.join(config_path, 'config.ini')
config = configparser.ConfigParser()
config.read(config_file_path)
rpc = AuthServiceProxy("http://%s:%s@%s:%s" %
(config['daemon']['user'], config['daemon']['password'],
config['daemon']['host'], config['daemon']['port']))
logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', datefmt='%d/%m/%y %H:%M:%S %Z')
logger = logging.getLogger(APP_NAME)
logger.setLevel(logging.DEBUG)
tip_id = ''
while True:
possibly_new_tip_id = rpc.getbestblockhash()
if possibly_new_tip_id == tip_id:
sleep(NEW_TIP_CHECK_INTERVAL_SECONDS)
continue
tip_id = possibly_new_tip_id
logger.info('new block "%s"', tip_id)
with shelve.open(db_path) as db:
new_interlink = interlink(tip_id, db)
logger.debug('new interlink "%s"', new_interlink)
logger.info('mtr hash "%s"', new_interlink.hash().hex())
logger.info('velvet tx "%s"', send_velvet_tx(new_interlink.hash()))
class BitcoinCLI:
def __init__(self):
self.rpc_connection = AuthServiceProxy(config.endpoint)
def get_best_block_hash(self):
return self.rpc_connection.getbestblockhash()
def get_block_count(self):
return self.rpc_connection.getblockcount()
def get_best_block(self):
return self.rpc_connection.getblock(self.rpc_connection.getbestblockhash())
def get_block_hash(self, height):
return self.rpc_connection.getblockhash(height)
def get_block(self, hash):
return self.rpc_connection.getblock(hash)
def get_transaction(self, hash):
return self.rpc_connection.gettransaction(hash)
def get_txn_list_from_block(self, hash):
block = self.get_block(hash)
if 'tx' in block:
return block['tx']
else:
raise KeyError('Block {0} has no attribute tx'.format(hash))
def get_raw_transaction(self, tx_id):
out = self.rpc_connection.getrawtransaction(tx_id, 1)
return out
def decoderawtransaction(self, tx_id):
out = self.rpc_connection.decoderawtransaction(raw)
return out
def get_tx_outputs(self, tx_id):
tx = self.rpc_connection.getrawtransaction(tx_id, 1)
outputs = [float(i['value']) for i in tx['vout']]
return outputs
def get_tx_details(self, tx_id):
tx = self.rpc_connection.getrawtransaction(tx_id, 1)
outputs = [float(i['value']) for i in tx['vout']]
return outputs
def main():
rpc_user = '******'
rpc_password = '******'
rpc = AuthServiceProxy(f'http://{rpc_user}:{rpc_password}@127.0.0.1:18332/')
#rpc = AuthServiceProxy(f'http://{rpc_user}:{rpc_password}@172.17.0.2:18332/')
print(rpc.getinfo())
best_block_hash = rpc.getbestblockhash()
print(rpc.getblock(best_block_hash))
blhash = rpc.getblockhash(0) #blhashはブロックのhash文字列
bl = rpc.getblock(blhash) #blはブロック情報
print(bl)
dummy_address = '2MudgRfNaaw96kqAWziZ5JGsPbo2pzQp7Jy'
change_address = '2NAVrak22jX3DQyDqnoqdm5ZTak1RgXWPzo'
filename = 'mark_token.btc.json'
url='https://drive.google.com/file/d/1ZR6Q5sCM_acUpPy7s3d9GJH8I2Plh4FI/view?usp=sharing'
with open(filename, 'rb') as f:
data2 = f.read()
hashdata=hashlib.sha256(data2).hexdigest()
js={'file_hash':hashdata,'url':url}
data=json.dumps(js).encode("UTF-8")
while True:
if len(data) >= 80:
buffer = data[:80]
data = data[80:]
elif len(data) == 0:
break
else:
buffer = data
data = b''
first_unspent = rpc.listunspent()[0]
txid = first_unspent['txid']
vout = first_unspent['vout']
input_amount = first_unspent['amount']
SATOSHI = Decimal("0.00000001")
change_amount = input_amount - Decimal("0.005") - SATOSHI
tx = rpc.createrawtransaction([{"txid": txid, "vout": vout}],[{change_address: change_amount}, {'data': hexlify(buffer).decode('utf-8')}, ])
tx = rpc.signrawtransactionwithwallet(tx)['hex']
rpc.sendrawtransaction(tx)
block_hash = rpc.generatetoaddress(1, change_address)[0]
block = rpc.getblock(block_hash)
txs = block['tx'][1:]
print(f'# of txs: {len(txs)}')
pprint(txs)
for tx_hash in txs:
raw_tx = rpc.gettransaction(tx_hash)['hex']
decoded_tx = rpc.decoderawtransaction(raw_tx)
# pprint(decoded_tx)
print(decoded_tx['vout'][1]['scriptPubKey']['asm'])
def main():
# rpc_user and rpc_password are set in the bitcoin.conf file
rpc_connection = AuthServiceProxy("http://%s:%[email protected]:8332" % (rpc_user, rpc_password))
best_block_hash = rpc_connection.getbestblockhash()
print(rpc_connection.getblock(best_block_hash))
# batch support : print timestamps of blocks 0 to 99 in 2 RPC round-trips:
commands = [["getblockhash", height] for height in range(100)]
block_hashes = rpc_connection.batch_(commands)
blocks = rpc_connection.batch_([["getblock", h] for h in block_hashes])
block_times = [block["time"] for block in blocks]
print(block_times)
async def update_dashboard_network(self, message):
rpc_connection_CRYPTO = 'http://{0}:{1}@{2}:{3}'.format(
crypto_perams.CRYPTO_RPC_USER, crypto_perams.CRYPTO_RPC_PW,
crypto_perams.CRYPTO_RPC_IP, crypto_perams.CRYPTO_RPC_PORT)
wallet = AuthServiceProxy(rpc_connection_CRYPTO)
getmininginfo_response = wallet.getmininginfo()
embed = discord.Embed(title="Shib Stats",
color=discord.Color.from_rgb(193, 151, 79))
#1440 blocksper day
#7.2 mn reward
#row 1
embed.add_field(
name="Version",
value=str(wallet.getnetworkinfo()["subversion"]).replace("/", ""),
inline=True)
embed.add_field(name="Connections",
value=str(wallet.getconnectioncount()),
inline=True)
embed.add_field(name="Block Count",
value=getmininginfo_response["blocks"],
inline=True)
embed.add_field(name="Difficulty",
value=round(getmininginfo_response["difficulty"], 2),
inline=True)
embed.add_field(name="Nethash",
value=calc_converted_nethash(
getmininginfo_response["networkhashps"]),
inline=True)
best_hash = wallet.getbestblockhash()
#print("best hash = "+best_hash)
embed.add_field(name="Blockhash",
value=best_hash[:8] + "..." + best_hash[-8:],
inline=True)
embed.timestamp = datetime.datetime.utcnow()
embed.set_footer(text="Last updated")
#row 2
embed.set_author(name=self.bot.user.name,
url=crypto_perams.WALLET_LINK,
icon_url=self.bot.user.avatar_url)
await message.edit(content="", embed=embed)
class BtcRpc(object):
def __init__(self, uri):
logger.debug("init")
self.uri = uri
self.rpc = AuthServiceProxy(uri,timeout=600)
# wait for rpc to be ready
last_exc = None
for _ in xrange(30):
try:
logger.info("best block: %s"%self.rpc.getbestblockhash())
#logger.info("block count: %s" % self.rpc.getblockcount())
break
except Exception, e:
last_exc = e
logger.info("trying to connect ...")
time.sleep(2)
if last_exc:
raise last_exc
logger.debug("connected.")
def run_cheetah(prevheight, rpc_user, rpc_password, rpc_port, cpu):
# rpc_user and rpc_password are set in the bitcoin.conf file
rpc_connection = AuthServiceProxy("http://%s:%[email protected]:%d" %
(rpc_user, rpc_password, rpc_port))
best_block_hash = rpc_connection.getbestblockhash()
bestblock = rpc_connection.getblock(best_block_hash)
cur_epoch = int(time.time())
bcstucktime = cur_epoch - bestblock['time']
if bcstucktime < 0:
print "Height {} block Time is ahead of current time {} seconds, possible miner cheating on timestamp, current {} GMT".format(
bestblock['height'], bcstucktime, datetime.utcnow())
mining_info = rpc_connection.getmininginfo()
if (bcstucktime > 120):
print "ASIC/GPU miners got stuck on NENG blockchain for {} seconds".format(
bcstucktime)
print "Cheetah running, block {}: {} {} GMT".format(
bestblock['height'], bestblock['time'], datetime.utcnow())
if not mining_info['generate']:
print("Cheetah accelerates, NENG CPU Mining Started")
rpc_connection.setgenerate(True, cpu)
elif bestblock['height'] != prevheight:
print("Cheetah jumps, NENG CPU Mining Restarted")
rpc_connection.setgenerate(False)
rpc_connection.setgenerate(True, cpu)
else:
if mining_info['generate']:
print "block {}: {} {} GMT".format(bestblock['height'],
bestblock['time'],
datetime.utcnow())
print("Cheetah rests, NENG CPU Mining Stopped")
rpc_connection.setgenerate(False)
return bestblock['height']
# user-config section
rpchost = ''
rpcuser = ''
rpcpass = ''
#main loop, catch exceptions
print ' '
oldhash = ''
txiter=[]
txmemory=[]
primenumber = '030331ef01000000001976a914'
rpcpipe = AuthServiceProxy('http://' + rpcuser + ':' + rpcpass + '@' + rpchost + ':11000')
while True:
try:
#heartbeat
comms = rpcpipe.getbestblockhash()
if comms not in oldhash:
oldhash = comms
print oldhash + ' ' + str(rpcpipe.getblockcount())
time.sleep(5)
#check for tx
incmd = rpcpipe.listtransactions()
for tx in incmd:
if tx not in txmemory:
if 'receive' in str(tx):
fields = str(tx).split(',')
for field in fields:
if 'txid' in field:
temptxid = field.split('u')[2].replace('{','').replace('}','').replace('\'','').strip()
bypass=False
if temptxid not in txiter:
print(' \\ /')
print(' \\_/')
elif len(str(int(round(sum(outset),-1)))) == 10:
print(' /\\')
print(' / \\')
print(' / \\')
print(' / \\')
print(' / \\')
print(' '+str(int(round(sum(outset,-1)))))
print(' \\ /')
print(' \\ /')
print(' \\ /')
print(' \\ /')
print(' \\/')
outset.clear()
bestblockhash = rpc_doge.getbestblockhash()
if bestblockhash not in cache:
block = rpc_doge.getblock(bestblockhash)
print(' _____________________ ')
print(' | |')
print(' | |')
print(' | |')
print(' | |')
print(' | |')
print(' | wow such block |')
print(' '+str(len(block['tx'])))
print(' | many txs |')
print(' | |')
print(' | |')
print(' | |')
print(' | |')
class QtumBlockchain(BlockchainHandler):
def __init__(self, qtum_rpc):
self.qtum_rpc = qtum_rpc
self.decode_hex = codecs.getdecoder("hex_codec")
self.encode_hex = codecs.getencoder("hex_codec")
@classmethod
def from_http_provider(cls, http_provider):
return cls(AuthServiceProxy(http_provider))
def reload_http_provider(self, http_provider):
self.qtum_rpc = AuthServiceProxy(http_provider)
def get_block_count(self):
return self.qtum_rpc.getblockcount()
def get_balance(self):
return self.qtum_rpc.getbalance()
def get_last_block_hash(self):
return self.qtum_rpc.getbestblockhash()
def get_second_last_block_hash(self):
return self.get_block_hash(self.get_block_count() - 1)
def get_block_hash(self, height):
return self.qtum_rpc.getblockhash(height)
def get_block_id(self, height):
block_hash = self.get_block_hash(height)
l = sha256(self.decode_hex(block_hash)[0]).hexdigest()
r = hex(height)
return l[0:10] + r[2:].rjust(10, '0')
def get_last_block_id(self):
last_block_height = self.get_block_count()
return self.get_block_id(last_block_height)
def get_second_last_block_id(self):
last_block_height = self.get_block_count() - 1
return self.get_block_id(last_block_height)
def get_accounts(self):
unspent = self.qtum_rpc.listunspent()
res = [tx['address'] for tx in unspent]
return res
def get_unspent(self):
unspent = self.qtum_rpc.listunspent()
res = {tx['address']: tx['amount'] for tx in unspent}
return res
def from_hex_address(self, address):
return self.qtum_rpc.fromhexaddress(address)
from bitcoinrpc.authproxy import AuthServiceProxy
import simplejson as json
for x in range(1, 4):
access = AuthServiceProxy("http://*****:*****@172.17.0." + str(x + 1) +
":18332")
blockbesthash = access.getbestblockhash()
blockbest = access.getblock(blockbesthash)
#Affiche la hauteur du dernier block présent dans chaque noeuds
print("node n:" + str(x) + " " + str(blockbest["height"]))
#Affichage des informations du dernier noeud
print json.dumps(access.getmininginfo(), indent=4, separators=(',', ': '))
print json.dumps(access.getpeerinfo(), indent=4, separators=(',', ': '))
print json.dumps(access.getnetworkinfo(), indent=4, separators=(',', ': '))
print json.dumps(access.getblockchaininfo(), indent=4, separators=(',', ': '))
print json.dumps(access.getrawmempool(), indent=4, separators=(',', ': '))
print access.getaddressesbyaccount(acct)
except:
print "\n---An error occurred---\n"
elif cmd == "getbalance":
try:
acct = raw_input("Enter an account (optional): ")
mc = raw_input("Minimum confirmations (optional): ")
try:
print access.getbalance(acct, mc)
except:
print access.getbalance()
except:
print "\n---An error occurred---\n"
elif cmd == "getbestblockhash":
print access.getbestblockhash()
elif cmd == "getblockbycount":
height = raw_input("Height: ")
print access.getblockbycount(height)
elif cmd == "getblockcount":
print access.getblockcount()
elif cmd == "getblocknumber":
print access.getblocknumber()
elif cmd == "getconnectioncount":
try:
print access.getconnectioncount()
except:
while time > from_time:
header = rpc.getblockheader(block_hash)
time = datetime.utcfromtimestamp(header['time'])
headers[time] = header
block_hash = header['previousblockhash']
def find(from_time, to_time, from_value, to_value):
addresses = {}
for time in sorted(headers):
if from_time <= time <= to_time:
header = headers[time]
block_hash = header['hash']
block = rpc.getblock(block_hash, 2)
for tx in block['tx']:
for vout in tx['vout']:
value = vout['value']
if from_value <= value <= to_value:
address = vout['scriptPubKey']['addresses'][0]
if address not in addresses:
addresses[address] = []
addresses[address].append((time, value))
return addresses
fetch_headers(rpc.getbestblockhash(), datetime.fromisoformat("2021-05-01"))
result_1 = find(datetime.fromisoformat("2021-05-08"), datetime.fromisoformat("2021-05-09"), 74.99, 75.01)
print(result_1)
result_2 = find(datetime.fromisoformat("2021-05-11"), datetime.fromisoformat("2021-05-12"), 78.28, 78.30)
print(result_2)
from bitcoinrpc.authproxy import AuthServiceProxy, JSONRPCException
import time
# rpc_user and rpc_password are set in the bitcoin.conf file
rpc_connection = AuthServiceProxy("http://*****:*****@172.17.0.3:18332")
# best_block_hash = rpc_connection.getbestblockhash()
# print(rpc_connection.getblock(best_block_hash))
for x in range(5):
start = time.time()
#result = rpc_connection.generate(1)
result = rpc_connection.getbestblockhash()
# result = rpc_connection.getblocktemplate()
end = time.time()
print(rpc_connection.generate(1))
print(end-start)
exit(1)
# batch support : print timestamps of blocks 0 to 99 in 2 RPC round-trips:
commands = [ [ "getblockhash", height] for height in range(100) ]
block_hashes = rpc_connection.batch_(commands)
blocks = rpc_connection.batch_([ [ "getblock", h ] for h in block_hashes ])
block_times = [ block["time"] for block in blocks ]
print(block_times)
"""
Transmit a raw bitcoin transaction using Fldigi
"""
from bitcoinrpc.authproxy import AuthServiceProxy, JSONRPCException
import pyfldigi
CALLSIGN = 'KBBL' # update this
fldigi = pyfldigi.Client()
fldigi.modem.id = 40 # try 40-45 for BPSK31-500
btc = AuthServiceProxy("http://%s:%[email protected]:18443"%('foo','bar'))
btc.getbestblockhash() # check to make sure it's working
addr = btc.getnewaddress() # generate address
txhash = btc.sendtoaddress(addr, 1) # send 1 bitcoin to new address
tx = btc.getrawtransaction(txhash) # get raw transaction
print(tx)
txQueue = """QST DE %s\n \
<SIZE %s>%s<EOT>\n\
DE %s K
""" % (CALLSIGN, len(tx), tx, CALLSIGN)
timeout = round(len(tx)/3)
fldigi.main.send(txQueue, block=True, timeout=timeout)
fldigi.main.rx()
class BitcoindRPCWrapper(BlockchainDataWrapper):
'''
A connection manager for bitcoind's RPC interface
All RPC configuration variables will be set using the following env vars:
* BOLTZMANN_RPC_USERNAME
* BOLTZMANN_RPC_PASSWORD
* BOLTZMANN_RPC_HOST
* BOLTZMANN_RPC_PORT
'''
GENESIS_BLOCK = { #rpc-style format
'txid': ('4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2'
'127b7afdeda33b'),
'version': 1,
'locktime': 0,
'vin': [{
"sequence":4294967295,
'coinbase': ('04ffff001d0104455468652054696d65732030332f4a6'
'16e2f32303039204368616e63656c6c6f72206f6e2062'
'72696e6b206f66207365636f6e64206261696c6f75742'
'0666f722062616e6b73')
}],
'vout': [
{
'value': 50.00000000,
'n': 0,
'scriptPubKey': {
'asm': ('04678afdb0fe5548271967f1a67130b7105cd6a828'
'e03909a67962e0ea1f61deb649f6bc3f4cef38c4f3'
'5504e51ec112de5c384df7ba0b8d578a4c702b6bf1'
'1d5f OP_CHECKSIG'),
'hex': ('4104678afdb0fe5548271967f1a67130b7105cd6a8'
'28e03909a67962e0ea1f61deb649f6bc3f4cef38c4'
'f35504e51ec112de5c384df7ba0b8d578a4c702b6b'
'f11d5fac'),
'reqSigs': 1,
'type': 'pubkey',
'addresses': ['1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa']
}
}
]
}
def __init__(self):
rpc = dict()
rpc['username'] = _get_env('BOLTZMANN_RPC_USERNAME')
rpc['password'] = _get_env('BOLTZMANN_RPC_PASSWORD')
rpc['host'] = _get_env('BOLTZMANN_RPC_HOST')
rpc['port'] = _get_env('BOLTZMANN_RPC_PORT')
self._con = AuthServiceProxy(
"http://{username}:{password}@{host}:{port}".format(**rpc))
def _get_raw_tx(self, txid):
"""Returns the transaction in raw format."""
if txid == ('4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7af'
'deda33b'):
raise NoDataAvailableForGenesisBlockError()
else:
return self._con.getrawtransaction(txid)
def _get_decoded_tx(self, txid):
"""Gets a human-readable string of the transaction in JSON format."""
try:
return self._con.getrawtransaction(txid, 1)
except NoDataAvailableForGenesisBlockError:
#bitcoind won't generate this, but here's what it would look like
return self.GENESIS_BLOCK
def _get_block_height(self, txid, rpc_tx=None):
"""Return the block height at which the transaction was mined.
Args:
txid (str)
rpc_tx (Optional[dict]): The data for the specified transaction, if
it has already been queried previously from the RPC interface.
Raises: NoBlockHeightAvailableError: If no block height found.
"""
best_block_hash = self._con.getbestblockhash()
best_block = self._con.getblock(best_block_hash)
best_block_height = best_block['height']
if rpc_tx is None:
rpc_tx = self._get_decoded_tx(txid)
#ready for a fun hack? We can compute block height, but only if the
#transaction in question has at least one unspent output.
for idx, _ in enumerate(rpc_tx['vout']):
#Find number of confirmations for this transaction
txout = self._con.gettxout(txid, idx)
if txout is not None:
return best_block_height - txout['confirmations'] + 1
warn("Could not find number of confirmations in any txo for {0}".format(
txid))
return -1
def _get_output_address(self, prev_txid, output_index, prev_tx=None):
"""Get the address associated with the specified txo.
Args:
prev_txid (str): The id of the tx the output belongs to
output_index (int): Index within the outputs corresponding to the
output
prev_tx (Optional[dict]): The RPC-style prev tx the output belongs
to. If not specified, this will be fetched from the RPC
interface.
TODO: This does not properly handle multisig outputs that list multiple
addresses per output.
Raises: PrevOutAddressCannotBeDecodedError
"""
if prev_tx is None:
prev_tx = self._get_decoded_tx(prev_txid)
if('vout' in prev_tx and len(prev_tx['vout']) > output_index and
'scriptPubKey' in prev_tx['vout'][output_index]):
if 'addresses' not in prev_tx['vout'][output_index]['scriptPubKey']:
raise PrevOutAddressCannotBeDecodedError(
"Can't decode address for txo {0}:{1}".format(prev_txid,
output_index))
else:
return ' '.join(prev_tx['vout'][output_index]['scriptPubKey']['addresses'])
else:
raise PrevOutAddressCannotBeDecodedError(
("Missing element for vout in get_output_address() with tx "
"id {0} and output index {1}").format(prev_txid, output_index))
def _rpc_to_bci_input(self, rpc_input):
"""Convert RPC-style input to BCI-style input.
Args:
rpc_input (dict): The RPC-style representation of an input, found in
a transaction's 'vin' array.
Returns: dict: Representation of input, to be appended to a list
attribute called 'inputs'. The input contains these fields:
* 'prev_out' (dict)
* 'tx_index' (None)
* 'txid' (str): previous tx id
* 'addr' (str)
* 'n' (int): position of txo in prev tx
* 'value' (int)
"""
bci_input = dict()
#do not create prev_out field if this input is part of a coinbase
# transaction. This is consistent with the BCI JSON format.
if 'txid' in rpc_input:
bci_input['prev_out'] = dict()
bci_input['prev_out']['tx_index'] = None
prev_txid = rpc_input['txid']
prev_vout_num = rpc_input['vout'] #RPC field is ambiguously named :/
bci_input['prev_out']['n'] = prev_vout_num
prev_tx = self._get_decoded_tx(prev_txid)
bci_input['prev_out']['addr'] = self._get_output_address(
prev_txid, prev_vout_num, prev_tx)
bci_input['prev_out']['script'] = (prev_tx['vout'][prev_vout_num]
['scriptPubKey']['hex'])
float_val = prev_tx['vout'][prev_vout_num]['value']
bci_input['prev_out']['value'] = _float_to_satoshi(float_val)
return bci_input
def get_tx(self, txid, testnet):
"""Get the `Transaction` object for specified hash.
Testnet parameter isn't used.
For now, we assume that a single bitcoind is running on the machine.
The `Transaction` constructors expects these fields for a dict:
* 'block_height' (int)
* 'time' (None)
* 'hash' (str)
* 'inputs' (List[dict]):
* 'prev_out' (dict):
* 'n' (int)
* 'value' (int)
* 'addr' (str)
* 'tx_index' (None)
* 'out' (List[dict]): same as 'prev_out'
"""
rpc_style_tx = self._get_decoded_tx(txid)
rpc_style_tx['block_height'] = self._get_block_height(txid, rpc_style_tx)
rpc_style_tx['time'] = None
rpc_style_tx['hash'] = rpc_style_tx['txid']
rpc_style_tx['inputs'] = list()
for txin in rpc_style_tx['vin']:
inpt = self._rpc_to_bci_input(txin)
rpc_style_tx['inputs'].append(inpt)
rpc_style_tx['out'] = list()
for txout in rpc_style_tx['vout']:
outpt = _rpc_to_bci_output(txout)
rpc_style_tx['out'].append(outpt)
return Transaction(rpc_style_tx)
thefile = open('address.txt', 'w')
for i in addrlist:
# print( i )
thefile.write("%s\n" % i)
thefile.close()
if __name__ == '__main__':
# your bitcoin daemon on your server running full-node
rpc_user = "******"
rpc_password = "******"
rpc_connection = AuthServiceProxy("http://%s:%[email protected]:8332" %
(rpc_user, rpc_password),
timeout=1200)
best_block_hash = rpc_connection.getbestblockhash()
blk = rpc_connection.getblock(best_block_hash)
# dump current block count height
print("getblockcount = %s" % rpc_connection.getblockcount())
txlist = []
alist = []
for txid in blk['tx']:
txlist.append(txid)
al = addrlistVout(txid)
alist.append(al)
# make list & remove duplicates in list
from bitcoinrpc.authproxy import AuthServiceProxy
import simplejson as json
for x in range(1, 4):
access = AuthServiceProxy("http://*****:*****@172.17.0."+str(x+1)+":18332")
blockbesthash = access.getbestblockhash()
blockbest = access.getblock(blockbesthash)
#Affiche la hauteur du dernier block présent dans chaque noeuds
print ("node n:"+str(x)+" "+str(blockbest["height"]))
#Affichage des informations du dernier noeud
print json.dumps(access.getmininginfo(), indent=4, separators=(',', ': '))
print json.dumps(access.getpeerinfo(), indent=4, separators=(',', ': '))
print json.dumps(access.getnetworkinfo(), indent=4, separators=(',', ': '))
print json.dumps(access.getblockchaininfo(), indent=4, separators=(',', ': '))
print json.dumps(access.getrawmempool(), indent=4, separators=(',', ': '))