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 rpc_loop(ncurses_q, json_q):
config = ConfigParser.ConfigParser()
config.read('bitcoind-ncurses.conf')
rpcuser = config.get('rpc', 'rpcuser')
rpcpassword = config.get('rpc', 'rpcpassword')
rpcip = config.get('rpc', 'rpcip')
rpcport = config.get('rpc', 'rpcport')
rpcurl = "http://" + rpcuser + ":" + rpcpassword + "@" + rpcip + ":" + rpcport
rpchandle = AuthServiceProxy(rpcurl, None, 500)
last_blockcount = 0 # ensures block info is updated initially
last_update = time.time() - 2
while 1:
try: s = json_q.get(False)
except: s = {}
if 'blockheight' in s:
blockhash = rpchandle.getblockhash(s['blockheight'])
blockinfo = rpchandle.getblock(blockhash)
ncurses_q.put(blockinfo)
last_blockcount = cur_blockcount
elif 'txid' in s:
raw_tx = rpchandle.getrawtransaction(s['txid'])
decoded_tx = rpchandle.decoderawtransaction(raw_tx)
ncurses_q.put(decoded_tx)
if (time.time() - last_update) > 2:
info = rpchandle.getinfo()
ncurses_q.put(info)
nettotals = rpchandle.getnettotals()
ncurses_q.put(nettotals)
walletinfo = rpchandle.getwalletinfo()
ncurses_q.put(walletinfo)
cur_blockcount = info['blocks']
if (cur_blockcount != last_blockcount): # minimise RPC calls
#if (last_blockcount == 0):
lastblocktime = {'lastblocktime': time.time()}
ncurses_q.put(lastblocktime)
blockhash = rpchandle.getblockhash(cur_blockcount)
blockinfo = rpchandle.getblock(blockhash)
ncurses_q.put(blockinfo)
last_blockcount = cur_blockcount
last_update = time.time()
time.sleep(0.5) # minimise RPC calls
def handle_block(height):
rpc_connection = AuthServiceProxy(
"http://%s:%[email protected]:8332" % (rpc_user, rpc_password))
hash = rpc_connection.getblockhash(height)
block = rpc_connection.getblock(hash, 2)
cjs = np.zeros((0, 9))
txids = []
for tx in block['tx']:
out_values = Counter([o['value'] for o in tx['vout']])
m_c = out_values.most_common()
candidates = filter(lambda m: m[1] > 1, m_c)
candidates = list(filter(lambda m: m[0] > 0, candidates))
if len(candidates) == 0:
continue
cj = candidates[0]
addresses = [o['scriptPubKey']['addresses']
for o in tx['vout'] if 'addresses' in o['scriptPubKey'].keys()]
addresses = [item for sublist in addresses for item in sublist]
is_wasabi = wasabi_address in addresses
has_op_return = any([out['scriptPubKey']['type'] ==
'nulldata' for out in tx['vout']])
features = [height, len(tx['vin']), len(
tx['vout']), cj[0], cj[1], max(out_values), min(out_values), has_op_return, is_wasabi]
cjs = np.vstack((cjs, features))
txids.append(tx['txid'])
# logging.info("processed {}, {} cjs".format(height, len(txids)))
return height, cjs, txids
def getBlock(i, ctx):
bc_client = ctx.obj['bitcoin_client']
rpc_connection = AuthServiceProxy('http://{}:{}@{}:{}'.format(
bc_client['user'], bc_client['pwd'], bc_client['host'],
bc_client['port']))
block_hash = rpc_connection.getblockhash(i)
return rpc_connection.getblock(block_hash)
def do_RPC(env, send_resp):
_, args, cur = urlparse.parse_qs(
env['QUERY_STRING']), env['PATH_INFO'].split(
'/')[2:], sqc.dbpool.get().cursor()
send_resp('200 OK', [('Content-Type', 'application/json')])
result = []
if args[0] == "getblockcount":
result = json.dumps(sqc.cfg['block'])
elif args[0] == "getinfo":
result = json.dumps({
'blocks':
sqc.cfg['block'],
'difficulty':
bits2diff(gethdr(sqc.cfg['block'], sqc.cfg, 'bits'))
})
elif args[0] == "getdifficulty":
result = json.dumps(
bits2diff(gethdr(sqc.cfg['block'], sqc.cfg, 'bits')))
else:
rpc = AuthServiceProxy(sqc.cfg['rpc'])
if args[0] == "getblock":
result = json.dumps(rpc.getblock(args[1]), cls=btcEncoder)
elif args[0] == "getblockhash":
result = json.dumps(rpc.getblockhash(int(args[1])))
elif args[0] == "getrawtransaction":
result = json.dumps(rpc.getrawtransaction(args[1], 1),
cls=btcEncoder)
elif args[0] == "gettxout":
result = json.dumps(rpcTxOut(cur, args[1], args[2]))
elif args[0] == "getmempoolinfo":
result = json.dumps(rpc.getmempoolinfo(), cls=btcEncoder)
elif args[0] == "getrawmempool":
result = json.dumps(rpc.getrawmempool(False), cls=btcEncoder)
return result
def do_RPC(env, send_resp):
get, args, cur = urlparse.parse_qs(env["QUERY_STRING"]), env["PATH_INFO"].split("/")[2:], sqc.dbpool.get().cursor()
send_resp("200 OK", [("Content-Type", "application/json")])
if args[0] == "getblockcount":
return json.dumps(sqc.cfg["block"])
if args[0] == "getinfo":
return json.dumps(
{"blocks": sqc.cfg["block"], "difficulty": bits2diff(gethdr(sqc.cfg["block"], "bits", sqc.cfg["path"]))}
)
if args[0] == "getdifficulty":
return json.dumps(bits2diff(gethdr(sqc.cfg["block"], "bits", sqc.cfg["path"])))
rpc = AuthServiceProxy(sqc.cfg["rpc"])
if args[0] == "getblock":
return json.dumps(rpc.getblock(args[1]), cls=btcEncoder)
if args[0] == "getblockhash":
return json.dumps(rpc.getblockhash(int(args[1])))
if args[0] == "getrawtransaction":
return json.dumps(rpc.getrawtransaction(args[1], 1), cls=btcEncoder)
if args[0] == "gettxout":
return json.dumps(rpcTxOut(cur, args[1], args[2]))
if args[0] == "getmempoolinfo":
return json.dumps(rpc.getmempoolinfo(), cls=btcEncoder)
if args[0] == "getrawmempool":
return json.dumps(rpc.getrawmempool(False), cls=btcEncoder)
return []
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 btc_block(block):
rpc_connection = AuthServiceProxy(
"http://%s:%s@bitcoin-node:%s" % (rpc_user, rpc_password, rpc_port), timeout=120)
block_dict = rpc_connection.getblock(block)
print("new block_json")
producer.send(TOPIC, key=bytes(str(block), "utf-8"),
value=bytes(json.dumps(block_dict, cls=DecimalEncoder), "utf-8"))
return "OK"
def parseBlock(blockHash):
hostURL = "http://{0}:{1}@{2}:{3}".format(
config["rpcuser"]["rpcid"], config["rpcuser"]["rpcpass"],
config["rpcsetting"]["host"], config["rpcsetting"]["port"])
rpcConnection = AuthServiceProxy(hostURL)
block = rpcConnection.getblock(blockHash)
tx = block["tx"]
for txid in tx:
parseTx(rpcConnection, txid)
def main():
while True:
try:
access = AuthServiceProxy(authserv)
function = access.getnettotals()
funcname = str("getnettotals")
for subkey in ['totalbytesrecv', 'totalbytessent']:
value = function[subkey]
printValue("counter", funcname, funcname, subkey, value)
function = access.getnetworkinfo()
funcname = str("getnetworkinfo")
subkey = str("connections")
value = function[subkey]
printValue("gauge", subkey, funcname, subkey, value)
function = access.getmempoolinfo()
funcname = str("getmempoolinfo")
for subkey in ['size', 'bytes']:
value = function[subkey]
#without this it will appear "stacked" in CGP Panel
funccat = (str(funcname) + "_" + str(subkey))
printValue("gauge", funccat, funcname, subkey, value)
#since 0.12 estimatefee 1 fails. Use estimatefee 2 instead.
#see https://github.com/bitcoin/bitcoin/issues/7545
function = access.estimatefee(2)
funcname = str("estimatefee")
value = function
printValue("gauge", funcname, funcname, funcname, value)
#get size, height, diff of the last block
function = access.getblockcount()
blockcount = function
#get hash of last block
function = access.getblockhash(blockcount)
blockhash = function
#get info from blockhash
function = access.getblock(blockhash)
funcname = str("getblock")
for subkey in ['size', 'height', 'difficulty']:
funccat = (str(funcname) + "_" + str(subkey))
value = function[subkey]
printValue("gauge", funccat, funcname, subkey, value)
#network hashrate
function = access.getnetworkhashps()
funcname = str("getnetworkhashps")
value = function
printValue("gauge", funcname, funcname, funcname, value)
except:
pass
sys.stdout.flush()
time.sleep(interval)
def search(search_term):
try:
rpc_user = get_bitcoin_rpc_username()
rpc_pass = get_bitcoin_rpc_password()
rpc_connection = AuthServiceProxy("http://%s:%[email protected]:8332" %
(rpc_user, rpc_pass),
timeout=10)
results = {}
results["type"] = "not_found"
results["id"] = ""
search_term = search_term.strip()
# Try to get a block (by height)
try:
if (search_term.isdigit()):
blockhash = rpc_connection.getblockhash(int(search_term))
results["type"] = "block"
results["id"] = blockhash
return results
except JSONRPCException as e:
pass
# Try to get address
try:
if is_bitcoin_address(search_term):
results["type"] = "addr"
results["id"] = search_term
return results
except:
pass
# Try to get a block (by hash)
try:
block = rpc_connection.getblock(search_term)
results["type"] = "block"
results["id"] = search_term
return results
except JSONRPCException as e:
pass
# Try to get a transaction
try:
rawtx = rpc_connection.getrawtransaction(search_term)
results["type"] = "tx"
results["id"] = search_term
return results
except JSONRPCException as e:
pass
except Exception as e:
results["type"] = "error"
results["error_message"] = str(e)
return results
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)
def block_updater():
logger = logging.getLogger('Block Updater')
logger.setLevel(logging.INFO)
while 1:
rpc_connection = AuthServiceProxy(config.config["rpc_server_uri"])
block = rpc_connection.getblock(config.config["current_block"])
logger.info(f"Update Tip: Block={config.config['current_block']},Height={block['height']}")
if "confirmations" in block and "nextblockhash" in block:
config.config["current_block"] = block["nextblockhash"]
config.save_config()
for i in block["tx"]:
tx = rpc_connection.decoderawtransaction(rpc_connection.getrawtransaction(i))
decode_opreturn_msg(tx, block)
else:
time.sleep(6)
def getblockhash(height):
"""taking in block height and return block hash"""
with open("config.yml", 'r') as ymlfile:
cfg = yaml.load(ymlfile)
url = cfg['bitcoind']['url']
rpc_connection = AuthServiceProxy(url)
blockhash = rpc_connection.getblockhash(height)
print("blockhash of height " + str(height) + " = " + blockhash)
print(rpc_connection.getblock(blockhash))
print(height)
#print(rpc_connection.getrawtransaction(''))
rawtransaction = rpc_connection.getrawtransaction(
'75a98ce35b869772adbf643b3f8acadfa5b46b4cd8bfef26f9e079c517018285')
print(rawtransaction)
tx = Transaction.from_hex(rawtransaction)
print(tx.json().dumps(parsed, indent=4, sort_keys=True))
def block_page(block_hash):
check_logged_in()
try:
# Get info
rpc_user = get_bitcoin_rpc_username()
rpc_pass = get_bitcoin_rpc_password()
rpc_connection = AuthServiceProxy("http://%s:%[email protected]:8332" %
(rpc_user, rpc_pass),
timeout=10)
block = rpc_connection.getblock(block_hash)
txs = []
for t in block["tx"]:
txs.append(t)
t = time.gmtime(int(block["time"]))
tstring = time.strftime("%Y-%m-%d %H:%M:%S", t)
templateData = {
"title": "myNode Bitcoin",
"raw": pformat(block, indent=2),
"height": block["height"],
"hash": block["hash"],
"confirmations": block["confirmations"],
"num_tx": block["nTx"],
"difficulty": "{:.3g}".format(block["difficulty"]),
"size": int(block["size"] / 1000),
"date": tstring,
"txs": txs,
"ui_settings": read_ui_settings()
}
return render_template('bitcoind_block.html', **templateData)
except Exception as e:
templateData = {
"title":
"myNode Bitcoin Error",
"message":
Markup(
"Error communicating with bitcoind. Node may be busy syncing.<br/><br/>{}"
.format(str(e))),
"back_url":
"/bitcoind",
"ui_settings":
read_ui_settings()
}
return render_template('bitcoind_error.html', **templateData)
class ChainData:
RPC_USER = RPC_NODE["user"]
RPC_PASSWORD = RPC_NODE["password"]
RPC_SERVER = RPC_NODE["server"]
RPC_PORT = RPC_NODE["port"]
MIN_BLOCK = CHAIN["start_block"]
MIN_CONFIRMS = CHAIN["confirms"]
COIN = CHAIN["name"]
def __init__(self):
self.rpc_conn = AuthServiceProxy(
"http://%s:%s@%s:%s" %
(self.RPC_USER, self.RPC_PASSWORD, self.RPC_SERVER, self.RPC_PORT))
def get_blocks(self):
resp = self.rpc_conn.getblockchaininfo()
return resp["blocks"]
def get_headers(self):
resp = self.rpc_conn.getblockchaininfo()
return resp["headers"]
def get_blockhash(self, block):
resp = self.rpc_conn.getblockhash(block)
return resp
def _get_blocktransactions(self, block):
blockhash = self.get_blockhash(block)
resp = self.rpc_conn.getblock(blockhash, 2)
return resp["tx"], blockhash
def getblock_out_balances(self, block):
txs, blockhash = self._get_blocktransactions(block)
balances = []
for tx in txs:
for iout in tx['vout']:
if iout.get("scriptPubKey") and iout.get("scriptPubKey").get(
"addresses"):
balances.append(
(iout["scriptPubKey"]["addresses"][0], iout["value"]))
if len(iout["scriptPubKey"]["addresses"]) > 1:
logger.error(
"More than one address detected! block %s, addresses: %s"
% (block, iout["scriptPubKey"]["addresses"]))
return balances, blockhash
def get_block_txs(height):
"""
Method used to get tx hashes from block
Args:
block height (int)
Returns:
List of transaction ids (array)
"""
rpc = AuthServiceProxy(
("http://%s:%[email protected]:%s/") %
(config['RPC_USER'], config['RPC_PASS'], config['RPC_PORT']))
block_hash = rpc.getblockhash(height)
block = rpc.getblock(block_hash)
return block['tx']
class ChainData:
RPC_USER = RPC_NODE["user"]
RPC_PASSWORD = RPC_NODE["password"]
RPC_SERVER = RPC_NODE["server"]
RPC_PORT = RPC_NODE["port"]
def __init__(self):
self.db1 = db.DataBase()
self.rpc_conn = AuthServiceProxy(
"http://%s:%s@%s:%s" %
(self.RPC_USER, self.RPC_PASSWORD, self.RPC_SERVER, self.RPC_PORT))
def get_blocks(self):
resp = self.rpc_conn.getblockchaininfo()
return resp["blocks"]
def get_headers(self):
resp = self.rpc_conn.getblockchaininfo()
return resp["headers"]
def get_blockhash(self, block):
resp = self.rpc_conn.getblockhash(block)
return resp
def _get_blocktransactions(self, block):
blockhash = self.get_blockhash(block)
resp = self.rpc_conn.getblock(blockhash, 2)
return resp["tx"], blockhash
def getblock_out_addresses(self, block):
txs, blockhash = self._get_blocktransactions(block)
count = 0
for tx in txs:
for iout in tx['vout']:
if iout.get("scriptPubKey") and iout.get("scriptPubKey").get(
"addresses"):
addresses = iout["scriptPubKey"]["addresses"]
for ad in addresses:
count += 1
self.db1.add_unique(ad)
def main(height, best):
rpc_connection = AuthServiceProxy(
'http://%s:%s@%s:%d' % (rpc_user, rpc_password, rpc_ip, rpc_port))
es = Elasticsearch("%s:%d" % (es_ip, es_port))
while height < best:
print 'height: %d' % height
try:
block_hash = rpc_connection.getblockhash(height)
block = rpc_connection.getblock(block_hash, 2)
except Exception as e:
print e
time.sleep(3)
rpc_connection = AuthServiceProxy(
'http://%s:%s@%s:%d' %
(rpc_user, rpc_password, rpc_ip, rpc_port))
else:
txs = block['tx']
txs_result = txs_to_es(rpc_connection, es, txs, block)
if txs_result == 1:
height += 1
class Coind:
def __init__(self):
# connect to the local coin daemon.
self.access = AuthServiceProxy("http://%s:%[email protected]:12341" %
('RPCuser', 'RPCpassword'))
def getblockhash(self, idx):
b_hash = self.access.getblockhash(idx)
return (b_hash)
def getblock(self, b_hash):
block = self.access.getblock(b_hash)
#{ u'merkleroot': u'74a2d1db8db7dc5e65d3d6f2058a6f1b5e893ddaf87c4c98d1a008e406b9beae',
# u'nonce': 122400,
# u'previousblockhash': u'6850dc01c014a262018fe2e29c299fc33dfe6d47fe5ef2f7cfa5f51f10bc61b3',
# u'hash': u'642b7b504b315dd12683eb132e9a536958a89c03638ebc7582ef4d50893f0b89',
# u'version': 2,
# u'tx': [
# u'46eb85610e8260a5eeccdfb14bf393b83ff704ccaca08e2dc639c2ebd9cdff57',
# u'dd28e708147c66b2ebaa23bfcce436afddfcdd1a268867465389c8c6d114cf82'
# ],
# u'height': 176058,
# u'difficulty': Decimal('587.97880435'),
# u'nextblockhash': u'530761664af30cc6e119cef47222ff179982cdc6e5f1fd70d06bb72bafde649c',
# u'confirmations': 7,
# u'time': 1419937013,
# u'bits': u'1b6f7546',
# u'size': 1227
# }
return (block)
def gettransaction(self, t_hash):
try:
trans = self.access.gettransaction(t_hash)
except:
return (False)
return (trans)
def getblockcount(self):
return (self.access.getblockcount())
class Coind:
def __init__(self):
# connect to the local coin daemon.
self.access = AuthServiceProxy("http://%s:%[email protected]:12341"%('RPCuser', 'RPCpassword'))
def getblockhash(self, idx):
b_hash = self.access.getblockhash(idx)
return(b_hash)
def getblock(self, b_hash):
block = self.access.getblock(b_hash)
#{ u'merkleroot': u'74a2d1db8db7dc5e65d3d6f2058a6f1b5e893ddaf87c4c98d1a008e406b9beae',
# u'nonce': 122400,
# u'previousblockhash': u'6850dc01c014a262018fe2e29c299fc33dfe6d47fe5ef2f7cfa5f51f10bc61b3',
# u'hash': u'642b7b504b315dd12683eb132e9a536958a89c03638ebc7582ef4d50893f0b89',
# u'version': 2,
# u'tx': [
# u'46eb85610e8260a5eeccdfb14bf393b83ff704ccaca08e2dc639c2ebd9cdff57',
# u'dd28e708147c66b2ebaa23bfcce436afddfcdd1a268867465389c8c6d114cf82'
# ],
# u'height': 176058,
# u'difficulty': Decimal('587.97880435'),
# u'nextblockhash': u'530761664af30cc6e119cef47222ff179982cdc6e5f1fd70d06bb72bafde649c',
# u'confirmations': 7,
# u'time': 1419937013,
# u'bits': u'1b6f7546',
# u'size': 1227
# }
return(block)
def gettransaction(self, t_hash):
try:
trans = self.access.gettransaction(t_hash)
except:
return(False)
return(trans)
def getblockcount(self):
return(self.access.getblockcount())
class RPCBitcoinCoreCommand:
def __init__(self, username, password, port):
self.rpc_connection = AuthServiceProxy("http://%s:%[email protected]:%s" %
(username, password, port),
timeout=1000)
def callCommand(self, command, hash):
if (command is None or hash is None):
raise Exception('The command or the hash is null')
try:
if command == 'getrawtransaction':
tx = self.rpc_connection.getrawtransaction(hash)
logging.debug(tx)
return "OK"
elif command == 'getblock':
blc = self.rpc_connection.getblock(hash)
logging.debug(blc)
return "OK"
except JSONRPCException as jsone:
logging.warning('Exception generated: ' + str(jsone))
return hash
return "KO"
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']
from bitcoinrpc.authproxy import AuthServiceProxy, JSONRPCException
CSVFiles = "D:\BTC CSV"
rpc_connection = AuthServiceProxy("http://%s:%[email protected]:8332"%("username", "password"))
blockCount = rpc_connection.getblockcount()
for i in range(100000, 100100):#blockCount):
currentHash = rpc_connection.getblockhash(i)
currentBlock = rpc_connection.getblock(currentHash)
currentTime = currentBlock['time']
for transaction in currentBlock['tx']:
txInfo = rpc_connection.getrawtransaction(transaction)
txDecoded = rpc_connection.decoderawtransaction(txInfo)
processed = [txDecoded['txid'], currentTime, txDecoded['weight']]
for output in txDecoded['vout']:
processed.append(str(output['value']))
print("Processed: " + str(processed))
print("Done with block " + str(i))
class LocalBlockchainRPCReader(BlockExplorerReader):
rpc_connection = None
#transaction_output_cache = None ''' deprecated '''
def __init__(self, database_connector = None):
BlockExplorerReader.__init__(self, database_connector) #super
self.rpc_connection = AuthServiceProxy(
"http://%s:%s@%s:%s" % (self.config.RPC_USERNAME,
self.config.RPC_PASSWORD,
self.config.RPC_HOST,
self.config.RPC_PORT))
def get_current_blockchain_block_height(self):
return self.rpc_connection.getblockcount() #TODO: Error checking? - This should already be an integer.
#Retreives a list of transactions at specified block height. Each tx
# will be formatted as a BCI-like tuple per
# get_bci_like_tuple_for_tx_id().
#param0: block_height: Height at which to get a list of txs for.
#param1: use_tx_out_addr_cache_only (Optional): When looking up addresses
# for previous transactions, ONLY refer to cache in SQLite database,
# rather than slower option of using RPC interface. If set to True,
# process will sleep until the data is available in the cache. Default:
# False.
def get_tx_list(self, block_height, use_tx_out_addr_cache_only = False):
ids = self.get_tx_ids_at_height(block_height)
txs = []
for tx_id in ids:
bci_like_tuple = self.get_bci_like_tuple_for_tx_id(
tx_id, use_tx_out_addr_cache_only)
txs.append(bci_like_tuple)
return txs
#Checks if the specified transaction is the first time the specified address
# has received funds. If it is, it will cache this for the specified
# block height in the database so subsequent lookups will answer
# correctly. IMPORTANT: This function assumes that that blocks are being
# processed in a complete, monotonically-increasing fashion from the
# genesis block. Otherwise, correct results not guaranteed! It is the
# caller's responsibility to ensure that enough blocks have been
# processed.
def is_first_transaction_for_address(self, addr, tx_id, block_height,
benchmarker = None):
if self.database_connector.has_address_been_seen_cache_if_not(addr,
block_height):
dprint("Address %s at block height %d was already seen." %
(addr, block_height))
return False
else:
dprint("Address %s at block height %d has no prior tx history." %
(addr, block_height))
return True
def get_block_hash_at_height(self, block_height):
return self.rpc_connection.getblockhash(block_height)
def get_tx_json_for_block_hash(self, block_hash):
return self.rpc_connection.getblock(block_hash)
def get_tx_ids_at_height(self, block_height):
block_hash = self.get_block_hash_at_height(block_height)
tx_json = self.get_tx_json_for_block_hash(block_hash)
tx_ids = []
for tx_id in tx_json['tx']:
tx_ids.append(tx_id)
return tx_ids
#Returns the transaction in raw format. If the requested transaction is
# the sole transaction of the genesis block, bitcoind's RPC interface
# will throw an error 'No information available about transaction
# (code -5)' so we preempt this by raising a custom error that callers
# should handle; iterating callers should just move onto the next tx.
#throws: NoDataAvailableForGenesisBlockError
def get_raw_tx(self, tx_id):
if tx_id == ('4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7af'
'deda33b'):
raise custom_errors.NoDataAvailableForGenesisBlockError()
else:
return self.rpc_connection.getrawtransaction(tx_id)
#Gets a human-readable string of the transaction in JSON format.
def get_decoded_tx(self, tx_id):
try:
return self.rpc_connection.decoderawtransaction(
self.get_raw_tx(tx_id))
except custom_errors.NoDataAvailableForGenesisBlockError:
#bitcoind won't generate this, but here's what it would look like
genesis_json = {
'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']
}
}
]
}
return genesis_json
#Converts required infromation from local bitcoind RPC into a format similar
# to that returned by Blockchain.info's API. This helps to make the code
# more agnostic as to the source of blockchain data.
#Note: When an output address cannot be decoded, BCI excludes the "addr"
# field from the JSON returned. Therefore, this function will do the same.
# See:
# https://blockchain.info/tx/cee16a9b222f636cd27d734da0a131cee5dd7a1d09cb5f14f4d1330b22aaa38e
#Note: When a previous output address for an input cannot be decoded, BCI
# excludes the "addr" field from the JSON returned. Therefore, this
# function will do the same. See:
# https://blockchain.info/tx/8ebe1df6ebf008f7ec42ccd022478c9afaec3ca0444322243b745aa2e317c272
#param0: tx_id: Specified transaction hash
#param1: use_tx_out_addr_cache_only (Optional): When looking up addresses
# for previous transactions, ONLY refer to cache in SQLite database,
# rather than slower option of using RPC interface. If set to True,
# process will sleep until the data is available in the cache. Default:
# False.
def get_bci_like_tuple_for_tx_id(self, tx_id,
use_tx_out_addr_cache_only = False):
json_tuple = {}
json_tuple['hash'] = tx_id
json_tuple['inputs'] = []
json_tuple['out'] = []
subscription = None
if use_tx_out_addr_cache_only:
subscription = data_subscription.TxOutputAddressCacheSubscriber(
database = self.database_connector)
tx_json = self.get_decoded_tx(tx_id)
#populate input addresses
for vin in tx_json['vin']:
#look up address based on its previous transaction
prev_txid = None
if 'txid' in vin:
prev_txid = vin['txid']
prev_vout = None
if 'vout' in vin:
prev_vout_num = vin['vout'] #yes, this RPC field is poorly named
prev_out = {'n': prev_vout_num}
try:
if use_tx_out_addr_cache_only:
#flag specifies that we will wait for cache to catch up
# before continuing this operation. Process/thread
# will sleep until then.
subscription.next_tx_id_needed = prev_txid
subscription.next_prev_tx_ouput_pos_needed = prev_vout_num
dprint(("get_bci_like_tuple_for_tx_id: May sleep until "
"tx output address is cached..."))
subscription.do_sleep_until_producers_ready()
address = self.get_output_address(prev_txid, prev_vout_num)
prev_out['addr'] = address
except custom_errors.PrevOutAddressCannotBeDecodedError:
pass
current_input = {'prev_out': prev_out}
json_tuple['inputs'].append(current_input)
else:
#If there's no index specifying the txo from prev tx, there's
# probably nothing to do here. Should only come up for
# coinbase transactions.
continue
#populate output addresses
for vout in tx_json['vout']:
output_index = vout['n']
current_output = {'n':output_index}
if 'scriptPubKey' in vout and 'addresses' in vout['scriptPubKey']:
address = vout['scriptPubKey']['addresses'][0]
current_output['addr'] = address
json_tuple['out'].append(current_output)
return json_tuple
#Returns an ordered list of output addresses for the specified transaction
# JSON as returned by the bitcoind RPC interface. If an address cannot be
# decoded for one of the outputs, a value of None will be inserted
# at that position in the list.
#TODO: This does not properly handle multisig outputs that list multiple
# addresses per output. See:
# http://bitcoin.stackexchange.com/questions/4687/can-a-scriptpubkey-have-multiple-addresses
# When support for this is added, make sure to add a test case.
def get_output_addresses(self, tx_json):
assert 'vout' in tx_json
output_addresses = []
for vout in tx_json['vout']:
assert 'scriptPubKey' in vout
if 'addresses' in vout['scriptPubKey']:
ouput_address = vout['scriptPubKey']['addresses'][0]
output_addresses.append(ouput_address)
else:
output_addresses.append(None)
return output_addresses
#Raises: custom_errors.PrevOutAddressCannotBeDecoded
#TODO: This does not properly handle multisig outputs that list multiple
# addresses per output.
def get_output_address(self, tx_id, output_index, tx_json = None):
if USE_TX_OUTPUT_ADDR_CACHE_FIRST:
addr = self.database_connector.get_output_address(tx_id,
output_index)
if addr is not None:
return addr
#not in cache, fall back to querying RPC interface
if tx_json is None:
tx_json = self.get_decoded_tx(tx_id)
if 'vout' in tx_json and len(tx_json['vout']) > output_index and \
'scriptPubKey' in tx_json['vout'][output_index]:
if 'addresses' not in tx_json['vout'][output_index]['scriptPubKey']:
raise custom_errors.PrevOutAddressCannotBeDecodedError
else:
return tx_json['vout'][output_index]['scriptPubKey'][
'addresses'][0]
else:
msg = ("Missing element for vout in get_output_address() with tx "
"id %s and output index %d") % (tx_id, output_index)
logger.log_and_die(msg)
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)
except ImportError as exc:
sys.stderr.write("Error: install python-bitcoinrpc (https://github.com/jgarzik/python-bitcoinrpc)\n")
exit(-1)
twister = AuthServiceProxy(main_config['rpc_url'])
try:
db = anydbm.open(os.path.expanduser(dbfilename), 'c')
if not 'lastblockhash' in db.keys():
db['lastblockhash'] = twister.getblockhash(0)
nextHash = db['lastblockhash']
except ImportError as exc:
sys.stderr.write("Did not manage to open databases\n")
exit(-1)
while True:
block = twister.getblock(nextHash)
db['lastblockhash'] = block["hash"]
#print str(block["height"]) + "\r",
usernames = block["usernames"]
for u in usernames:
if not str(u) in db.keys():
db['user:'******'taken'
if block.has_key("nextblockhash"):
nextHash = block["nextblockhash"]
else:
break
db.close()
def getBlock(i):
rpc_connection = AuthServiceProxy("http://%s:%[email protected]:8332" %
getCredentials())
block_hash = rpc_connection.getblockhash(i)
return rpc_connection.getblock(block_hash)
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(' | |')
print(' |_____________________|')
cache.add(bestblockhash)
def do(self):
rpc = AuthServiceProxy('http://' + settings.BITCOIN_RPC_USERNAME + ':' + settings.BITCOIN_RPC_PASSWORD + '@' + settings.BITCOIN_RPC_IP + ':' + str(settings.BITCOIN_RPC_PORT))
# Total number of blocks
blocks = rpc.getblockcount()
blocks_processed_queryset = CurrentBlockHeight.objects.order_by('-block_height')
blocks_processed = blocks_processed_queryset[0].block_height if blocks_processed_queryset.count() else 0
# Now incoming transactions will be processed and added to database. Transactions
# from new blocks are selected, but also transactions from several older blocks.
# These extra transactions are updated in case something (for example fork?) is
# able to modify transactions in old blocks.
EXTRA_BLOCKS_TO_PROCESS = 6
process_since = max(0, blocks_processed - EXTRA_BLOCKS_TO_PROCESS)
process_since_hash = rpc.getblockhash(process_since)
# Get all old transactions, that require updating
old_txs = Transaction.objects.filter(incoming_txid__isnull=False, block_height__gt=process_since)
old_txs = [old_tx for old_tx in old_txs]
txs = rpc.listsinceblock(process_since_hash)['transactions']
for tx in txs:
# Skip other than receiving transactions
if tx['category'] != 'receive':
continue
# Skip unconfirmed transactions for now
# TODO: Show these too!
if 'blockhash' not in tx:
continue
# Get required info
txid = tx['txid']
address = tx['address']
amount = tx['amount']
block_height = rpc.getblock(tx['blockhash'])['height']
created_at = datetime.datetime.utcfromtimestamp(tx['timereceived']).replace(tzinfo=pytz.utc)
# Skip transaction if it doesn't belong to any Wallet
try:
address = Address.objects.get(address=address)
except Address.DoesNotExist:
continue
# Check if transaction already exists
already_found = False
for old_tx in old_txs:
if old_tx.incoming_txid == txid:
# Transaction already exists, so do not care about it any more
old_txs.remove(old_tx)
already_found = True
break
# If transaction is new one
if not already_found:
new_tx = Transaction.objects.create(
wallet=address.wallet,
amount=amount,
description='Received',
incoming_txid=txid,
block_height=block_height,
receiving_address=address,
)
new_tx.created_at = created_at
new_tx.save(update_fields=['created_at'])
# Clean remaining old transactions
for old_tx in old_txs:
old_tx.delete()
# Mark down what the last processed block was
blocks = rpc.getblockcount()
if blocks_processed_queryset.count() > 0:
blocks_processed_queryset.update(block_height=blocks)
else:
CurrentBlockHeight.objects.create(block_height=blocks)
class Bitcoind:
"""
Connection to a Bitcoin daemon process.
"""
def __init__(self, settings):
"""
Arguments:
settings: a settings object; must contain the attribute bitcoinRPCURL.
Connects to a Bitcoin daemon process, indicated by settings.bitcoinRPCURL.
If settings.bitcoinRPCURL is empty, this object will not be connected.
"""
if settings.bitcoinRPCURL != "":
log.log("Making connection to Bitcoin daemon...")
self.access = AuthServiceProxy(settings.bitcoinRPCURL)
log.log("...done")
else:
log.log("Bitcoin-RPC URL is not set: not connecting")
self.access = None
def isConnected(self):
"""
Return value:
bool
Returns whether this object is connected.
"""
return self.access != None
def getBalance(self):
"""
Return value:
int, in Satoshi
Returns the balance.
"""
return self.DecimaltoAmount(self.access.getbalance())
def getBlockCount(self):
"""
Return value:
int
Returns the block count.
"""
return self.access.getblockcount()
def getPrivateKey(self, address):
"""
Arguments:
address: str, Base58Check-encoded address
Return value:
str, Base58Check-encoded private key
Returns the private key corresponding to the given address.
"""
return self.access.dumpprivkey(address)
def getTransactionHashesByBlockHeight(self, height):
"""
Arguments:
height: int
Return value:
list of str, hexadecimal, Bitcoin hash byte order
Returns the transaction hashes in the block (in the main chain) at the
given height.
"""
bhash = self.access.getblockhash(height)
block = self.access.getblock(bhash)
return block["tx"]
def getTransaction(self, thash):
"""
Arguments:
thash: str, hexadecimal, Bitcoin hash byte order
Return value:
dict, containing:
vin: list of dict, each element containing:
coinbase [only for coinbase transactions]
txid [only for non-coinbase transactions]:
str, hexadecimal, Bitcoin hash byte order
hash of input transaction
Returns information about the transaction indicated by the given hash.
"""
return self.access.getrawtransaction(thash, 1)
def listUnspent(self):
"""
Return value:
list of dict, each element containing:
address:
str, Base58Check-encoded address
amount:
int, in Satoshi
scriptPubKey:
str, binary
txid:
str, binary, OpenSSL byte order
vout:
int
Returns information about the available unspent transaction outputs.
"""
ret = self.access.listunspent()
for vout in ret:
vout["txid"] = binascii.unhexlify(vout["txid"])[::-1] #reversed; TODO: is this the right place?
vout["scriptPubKey"] = binascii.unhexlify(vout["scriptPubKey"])
vout["amount"] = self.DecimaltoAmount(vout["amount"])
return ret
def sendRawTransaction(self, txData):
"""
Arguments:
txData: str, binary
Send the given serialized transaction over the Bitcoin network.
"""
self.access.sendrawtransaction(txData.encode("hex"))
def DecimaltoAmount(self, value):
return int(value*100000000)
class TwisterScraper:
CACHE_MAX_DURATION = datetime.timedelta(7) # ([days [, seconds [,microseconds]]])
def __init__(self, dbPath, server='localhost', port=28332, user='******', password='******', protocol='http'):
self.serverUrl = '{protocol}://{user}:{passwd}@{server}:{port}'.format(protocol=protocol,
server=server,
port=port,
user=user,
passwd=password)
self.twister = AuthServiceProxy(self.serverUrl)
self.dbFile = dbPath
self.locService = GeoLocationService()
try:
with open(self.dbFile, 'rb') as dbFile:
self.db = pickle.load(dbFile)
except FileNotFoundError:
self.db = TwisterDb()
self.saveDb()
def get_user(self, username):
if username in self.db.users:
return self.db.users[username]
else:
return None
def scrape_users(self):
nextHash = 0
nextHash = self.twister.getblockhash(0)
usernames = set()
index = 0
while True:
block = self.twister.getblock(nextHash)
self.db.lastBlockHash = block['hash']
usernames = usernames.union(set(block['usernames']))
if len(usernames) > index:
index = len(usernames)
print('Found {0} usernames'.format(index))
if "nextblockhash" in block:
nextHash = block["nextblockhash"]
else:
break
if len(self.db.users) == 0:
# first run
for u in usernames:
blankUser = User()
blankUser.username = u
blankUser.updateTime = datetime.datetime.now() - self.CACHE_MAX_DURATION
self.saveDb()
now = datetime.datetime.now()
old_users = self.db.users.keys()
need_refresh = [u for u in old_users if (self.db.users[u].updateTime + self.CACHE_MAX_DURATION) < now]
new_users = usernames.difference(set(old_users))
to_fetch = new_users.union(set(need_refresh))
total_to_fetch = len(to_fetch)
for n, u in enumerate(to_fetch):
try:
user = self._fetch_user_details(u)
if hasattr(u, 'location'):
try:
u.locate()
except MaxGeoRequestsException:
print("Could not locate '' because of max request limit reached")
self.db.users[user.username] = user
if n % 5 == 0:
self.saveDb()
print("({line} of {total}) Fetched {user} ...".format(user=u, line=n, total=total_to_fetch))
except HTTPException as e:
print("Connection error retrieving user {0}: {1}".format(u, str(e)))
def saveDb(self):
print("Saving db")
try:
with open(self.dbFile, 'wb') as dbFile:
pickle.dump(self.db, dbFile)
except (KeyboardInterrupt, Exception):
print("Closing db before quitting...")
if dbFile:
# close the hung descriptor and re-try the dumping
try:
dbFile.close()
except Exception:
pass
with open(self.dbFile, 'wb') as dbFile:
pickle.dump(self.db, dbFile)
# once clean, re-raise
raise
def get_posts_since(self, username, dateObj, maxNum=1000):
since_epoch = time.mktime(dateObj.timetuple())
all_posts = self.twister.getposts(1000, [{'username': username}])
all_posts = sorted(all_posts, key=lambda x: x['userpost']['time'])
index = int(len(all_posts) / 2)
def _post_time(i):
return all_posts[i]['userpost']['time']
while 0 > index > len(all_posts):
if _post_time(index - 1) < since_epoch < _post_time(index + 1):
if _post_time(index) < since_epoch:
index += 1
break
elif _post_time(index) > since_epoch:
index = int(index / 2)
elif _post_time(index) < since_epoch:
index = int(index + index / 2)
return all_posts[index:]
def _fetch_user_details(self, username):
user = User()
user.username = username
avatarData = self.twister.dhtget(username, "avatar", "s")
if len(avatarData) == 1:
if 'p' in avatarData[0]:
if 'v' in avatarData[0]['p']:
user.avatar = avatarData[0]['p']['v']
profileData = self.twister.dhtget(username, 'profile', 's')
if len(profileData) == 1:
if 'p' in profileData[0]:
if 'v' in profileData[0]['p']:
profile = profileData[0]['p']['v']
for key in ['location', 'url', 'bio', 'fullname']:
if key in profile:
setattr(user, key, profile[key])
user.following = self.twister.getfollowing(username)
user.updateTime = datetime.datetime.now()
return user
from bitcoinrpc.authproxy import AuthServiceProxy, JSONRPCException
import config
import logging
logging.basicConfig()
logging.getLogger("BitcoinRPC").setLevel(logging.DEBUG)
# rpc_user and rpc_password are set in the bitcoin.conf file
rpc_connection = AuthServiceProxy("http://%s:%[email protected]:8332"%(config.rpcuser, config.rpcpassword))
block_hash = rpc_connection.getblockhash(1)
print(block_hash)
block = rpc_connection.getblock(block_hash)
print(block)
#// get the first block
#//get raw data
#// convert it to hex
#// convert to ascii
#// print output
#// check if it has any english words
if len(sys.argv) > 1:
blockHash = sys.argv[1]
elif "crawl" in config and "nextblock" in config["crawl"]:
blockHash = config["crawl"]["nextblock"]
num = 100
if len(sys.argv) > 2:
num = int(sys.argv[2])
if len(blockHash) != 0:
hostURL = "http://{0}:{1}@{2}:{3}".format(
config["rpcuser"]["rpcid"],
config["rpcuser"]["rpcpass"],
config["rpcsetting"]["host"],
config["rpcsetting"]["port"]
)
print(hostURL)
rpcConnection = AuthServiceProxy(hostURL)
# for i in range(num):
while(True):
print(blockHash)
block = rpcConnection.getblock(blockHash)
blockHash = block["nextblockhash"]
res = subprocess.run(
["python", "getdistribution.py", blockHash], stdout=subprocess.PIPE)
sys.stdout.buffer.write(res.stdout)
try:
config.set("crawl", 'nextblock', blockHash)
config.write(open("config.ini", 'w'))
except Exception as e:
print >> sys.stderr, 'Error: Could not write to config file: %s' % e
sys.exit(1)
from bitcoinrpc.authproxy import AuthServiceProxy, JSONRPCException
import logging
RPC_USER = '******'
RPC_PASSWORD = '******'
BITCOIN_SERVER = '127.0.0.1:8332'
AUTHSERV = 'http://' + RPC_USER + ':' + RPC_PASSWORD + '@' + BITCOIN_SERVER
print "AUTHSERV: %s" % (AUTHSERV)
# set logging to debug
logging.basicConfig()
logging.getLogger("BitcoinRPC").setLevel(logging.DEBUG)
# rpc_user and rpc_password are set in the bitcoin.conf file
rpc_connection = AuthServiceProxy(AUTHSERV)
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)
class RPCConnection:
"""Creates a continuous connection to the bitcoind RPC interface.
RPC connections are configured by the configuration file referred to by
`CONFIG_FILENAME`.
Attributes:
conn (`AuthServiceProxy`): A connection to the RPC interface.
"""
def __init__(self):
config_parser = ConfigParser.ConfigParser()
config_parser.read(CONFIG_FILENAME)
username = config_parser.get(section='RPC', option='rpc_username')
password = config_parser.get(section='RPC', option='rpc_password')
host = config_parser.get(section='RPC', option='rpc_host')
port = config_parser.get(section='RPC', option='rpc_port')
self.conn = AuthServiceProxy("http://%s:%s@%s:%s" %
(username, password, host, port))
def get_block_hash_at_height(self, block_height):
"""Get the hash of the block at the specified block height."""
return self.conn.getblockhash(block_height)
def get_json_for_block_hash(self, block_hash):
"""Get a JSON represntation of the specified block."""
return self.conn.getblock(block_hash)
def get_tx_ids_at_height(self, block_height):
"""Get a list of transaction IDs contained in the specified block."""
block_hash = self.get_block_hash_at_height(block_height)
tx_json = self.get_json_for_block_hash(block_hash)
tx_ids = []
for tx_id in tx_json['tx']:
tx_ids.append(tx_id)
return tx_ids
def get_raw_tx(self, tx_id):
"""Return transaction in raw format.
If the requested transaction is the sole transaction of the genesis
block, bitcoind's RPC interface will throw an error 'No information
available about transaction (code -5)' so we preempt this by raising a
custom error that callers should handle; iterating callers should just
move onto the next tx.
"""
if tx_id == ('4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7af'
'deda33b'):
raise IndexError
else:
return self.conn.getrawtransaction(tx_id)
def get_decoded_tx(self, tx_id):
"""Gets the transaction in JSON format from the RPC interface."""
try:
return self.conn.decoderawtransaction(self.get_raw_tx(tx_id))
except IndexError:
#bitcoind won't generate this, but here's what it would look like
genesis_json = {
'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']
}
}
]
}
return genesis_json
current_total_size = 0
total_size = []
list = []
# parameters for iteration printing
digits = len(str(blockchain_length - 1))
delete = "\b" * digits
start_time = time.time()
for i in range(blockchain_length + 1):
print("{0}{1:{2}}".format(delete, i, digits), end="")
sys.stdout.flush()
if i == 0:
current_block_hash = genesis_block_hash
else:
current_block_hash = list[0]
# [0] first elemnent in 'list': current block next hash
# [1] second element in 'list': current block size
list = at(rpc_connection.getblock(current_block_hash), 'nextblockhash',
'size')
current_total_size += list[1]
total_size.append(current_total_size)
x = np.arange(0, blockchain_length + 1, 1)
plt.plot(x, total_size)
plt.xlabel('block_number')
plt.ylabel('blockchain_size')
print("\nThe program took", time.time() - start_time, "seconds to run")
plt.show()
from bitcoinrpc.authproxy import AuthServiceProxy, JSONRPCException
# rpc_user and rpc_password are set in the bitcoin.conf file
rpc_btc = AuthServiceProxy("http://%s:%[email protected]:8332"%('rpc_user', 'rpc_password'))
blockchain = open('blockchain.txt', 'ab+') #you will need to make this blank file in your python folder before running the program
for i in range(1,416570,1): #the range of blocks to grab data for, in this case blocks 1 to 416570, incrementing 1 block at a time
get_block_hash = rpc_btc.getblockhash(i)
block = rpc_btc.getblock(get_block_hash)
coinbase = rpc_btc.decoderawtransaction(rpc_btc.getrawtransaction(block['tx'][0]))
value = coinbase['vout'][0]['value'] #this gets total block reward
print(i)
blockchain.write(str(block['height'])+', '+str(value)+', '+str(block['hash'])+', '+str(block['size'])+', '+str(len(block['tx']))+', '+str(block['version'])+', '+str(block['merkleroot'])+', '+str(block['time'])+', '+str(block['nonce'])+', '+str(block['bits'])+', '+str(block['difficulty'])+', '+str(block['chainwork'])+'\n')
blockchain.close()
print('done')
curblock = int(progress.read())
progress.closed
else:
curblock = 0
rpcpipe = AuthServiceProxy('http://' + rpcuser + ':' + rpcpass + '@' +
rpchost + ':44663')
while (1 != 2):
curblock = curblock + 1
totalblk = rpcpipe.getblockcount()
if (curblock > totalblk - txnconf):
with open('/root/moonaudit/progress.dat', 'w') as progress:
progress.write(str(curblock - 1))
progress.closed
exit()
rawblockhash = rpcpipe.getblockhash(curblock)
rawblockdata = rpcpipe.getblock(rawblockhash)
print 'checking block %08d' % (curblock)
timestamp = find_between(str(rawblockdata), 'time\': ', ', u\'bits')
sendnum = 0
for txhash in rawblockdata['tx']:
sendnum = sendnum + 1
txraw = rpcpipe.getrawtransaction(txhash)
txdata = rpcpipe.decoderawtransaction(txraw)
curvout = -1
for outputs in txdata['vout']:
curvout = curvout + 1
address = ''
value = 0
address = find_between(str(outputs), '[u\'', '\']')
value = find_between(str(outputs), 'Decimal(\'', '\')')
if (float(str(value)) > 28999999.99999999):
location = ""
updateTime = 0
class MyDb:
lastBlockHash = 0
try:
db = cPickle.load(open(dbFileName))
nextHash = db.lastBlockHash
except:
db = MyDb()
db.usernames = {}
nextHash = commentchain.getblockhash(0)
while True:
block = commentchain.getblock(nextHash)
db.lastBlockHash = block["hash"]
print str(block["height"]) + "\r",
usernames = block["usernames"]
for u in usernames:
if not db.usernames.has_key(u):
db.usernames[u] = User()
if block.has_key("nextblockhash"):
nextHash = block["nextblockhash"]
else:
break
now = time.time()
for u in db.usernames.keys():
if db.usernames[u].updateTime + cacheTimeout < now:
data["denom_10"] = data["denom_10"][:-3]
data["denom_50"] = data["denom_50"][:-3]
data["denom_100"] = data["denom_100"][:-3]
data["denom_500"] = data["denom_500"][:-3]
data["denom_1000"] = data["denom_1000"][:-3]
data["denom_5000"] = data["denom_5000"][:-3]
data["total"] = data["total"][:-3]
data["blocks_axis"] = data["blocks_axis"][:-3]
# Add new data points
blockCount = conn.getblockcount()
while data["lastBlockNum"] + 100 <= blockCount:
data["lastBlockNum"] += 100
data["lastBlockHash"] = conn.getblockhash(data["lastBlockNum"])
print("Getting block %d..." % data["lastBlockNum"])
block = conn.getblock(data["lastBlockHash"], True)
data["denom_1"].append(int(block["zPIVsupply"]["1"]))
data["denom_5"].append(int(block["zPIVsupply"]["5"]))
data["denom_10"].append(int(block["zPIVsupply"]["10"]))
data["denom_50"].append(int(block["zPIVsupply"]["50"]))
data["denom_100"].append(int(block["zPIVsupply"]["100"]))
data["denom_500"].append(int(block["zPIVsupply"]["500"]))
data["denom_1000"].append(int(block["zPIVsupply"]["1000"]))
data["denom_5000"].append(int(block["zPIVsupply"]["5000"]))
data["total"].append(int(block["zPIVsupply"]["total"]))
data["blocks_axis"].append(data["lastBlockNum"])
# Save to file
try:
with open("zdogecsupplydata.json", 'w+') as f:
json.dump(data, f)
sys.exit()
txid = bitcoin.sendtoaddress(send_address, Decimal(args.coinAmt))
print("sendtoaddress - Sent tx with id %s" % txid)
elif args.command == "claim-on-sidechain":
raw_bitcoin_tx = bitcoin.getrawtransaction(args.sidechainRcvTx, 1)
if not "confirmations" in raw_bitcoin_tx or raw_bitcoin_tx["confirmations"] <= 10:
print("Please wait for at least 10 confirmations on the bitcoin transaction first")
exit(1)
raw_bitcoin_tx_hex = bitcoin.getrawtransaction(args.sidechainRcvTx, 0)
# Might need to calculate the scriptSig here
secondScriptSig = "1"
bitcoin_block = bitcoin.getblock(raw_bitcoin_tx["blockhash"])
coinbase_txid = bitcoin_block["tx"][0]
raw_coinbase_tx_hex = bitcoin.getrawtransaction(coinbase_txid, 0)
spv_proof = bitcoin.gettxoutproof([coinbase_txid, args.sidechainRcvTx])
cht = os.popen("%s %s -g -r %s -d %s -n %s" % (contracthashtool_path, testnet_arg, redeem_script, args.sidechainP2SHaddr, args.nonce))
cht_read = cht.read()
assert(cht.close() == None)
raw_dest = cht_read.split("\n")[1 + is_testnet][66:]
full_contract = cht_read.split("\n")[1 + is_testnet][26:]
send_address = cht_read.split("\n")[3 + is_testnet][40:]
assert(len(raw_dest) == 40)
nout = -1
value = -1
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=(',', ': '))
class Parsing_block():
def __init__(self,
from_block=0,
to_block=-1,
db_name="pars",
collection="wallet7"):
self.from_block = from_block
self.to_block = to_block
self.qtum = AuthServiceProxy("http://%s:%[email protected]:8333" %
("qtumuser", "qtum2018"))
self.db_wallet = Table_new(db_name, collection)
def block_hash_num(self, block=None):
try:
if not block:
block = self.from_block
block_hash = self.qtum.getblockhash(block)
return block_hash
except:
pass
def get_transaction_in_block(self, block_hash=None):
try:
if not block_hash:
block_hash = self.block_hash_num()
block = self.qtum.getblock(block_hash)
list_tx = block["tx"]
return list_tx
except:
pass
def get_raw_transaction(self, transaction_blocks=None):
try:
if not transaction_blocks:
transaction_blocks = self.get_transaction_in_block()
transaction_list = []
for transaction_block in transaction_blocks:
try:
transaction_data = self.qtum.getrawtransaction(
transaction_block)
except JSONRPCException:
try:
send_data = self.qtum.sendrawtransaction(
transaction_block)
pprint(send_data)
except JSONRPCException:
pass
else:
transaction_list += [transaction_data]
return transaction_list
except:
pass
'''
def insert_db(self, vout):
for vout_i in vout:
try:
n_dict = {}
script_pub_key = vout_i["scriptPubKey"]
addresses = script_pub_key["addresses"]
value = vout_i["value"]
n = vout_i["n"]
n_str = str(n)
list_adr = []
for iter_adr in addresses:
list_adr += [{iter_adr: value}]
n_dict[n_str] = list_adr
print(n_dict)
except KeyError:
pass
'''
def transaction_in(self, vin):
try:
for vin_i in vin:
try:
txid = vin_i["txid"]
vout_num = vin_i["vout"]
encoded_datas = self.get_raw_transaction([txid])
for i in encoded_datas:
transaction_data = self.qtum.decoderawtransaction(i)
vout_prev = transaction_data["vout"]
vout_prev_data = vout_prev[vout_num]
value_dec = vout_prev_data["value"]
script_pub_key = vout_prev_data["scriptPubKey"]
addresses = script_pub_key["addresses"]
value_int = int(value_dec * (10**8))
for address in addresses:
news = self.db_wallet.update_inc(
address, "value", -value_int)
except KeyError:
pass
except:
pass
def transaction_out(self, vout):
try:
for vout_i in vout:
try:
script_pub_key = vout_i["scriptPubKey"]
addresses = script_pub_key["addresses"]
value = vout_i["value"]
value_int = int(value * (10**8))
for adr in addresses:
if not self.db_wallet.find({'id': adr}):
data = self.db_wallet.insert(adr, **{"value": 0})
news = self.db_wallet.update_inc(
adr, "value", value_int)
#self.db_wallet.delete(adr)
except KeyError:
pass
except:
pass
def decode_raw_transaction(self, encoded_datas=None):
try:
if not encoded_datas:
encoded_datas = self.get_raw_transaction()
for encoded_data in encoded_datas:
transaction_data = self.qtum.decoderawtransaction(encoded_data)
vin = transaction_data["vin"]
vout = transaction_data["vout"]
self.transaction_out(vout)
self.transaction_in(vin)
except:
pass
def show_db(self):
return self.db_wallet.show_db()
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
newlist = []
class Bitcoind_Real:
"""
Connection to a Bitcoin daemon process.
"""
def __init__(self, settings):
"""
Arguments:
settings: a settings object; must contain the attribute bitcoinRPCURL.
Connects to a Bitcoin daemon process, indicated by settings.bitcoinRPCURL.
If settings.bitcoinRPCURL is empty, this object will not be connected.
"""
if settings.bitcoinRPCURL != "":
log.log("Making connection to Bitcoin daemon...")
self.access = AuthServiceProxy(settings.bitcoinRPCURL)
log.log("...done")
else:
log.log("Bitcoin-RPC URL is not set: not connecting")
self.access = None
def isConnected(self):
"""
Return value:
bool
Returns whether this object is connected.
"""
return self.access != None
def getBalance(self):
"""
Return value:
int, in Satoshi
Returns the balance.
"""
return self.DecimaltoAmount(self.access.getbalance())
def getBlockCount(self):
"""
Return value:
int
Returns the block count.
"""
return self.access.getblockcount()
def getNewAddress(self):
"""
Return value:
str, Base58Check-encoded address
Generates and returns a new address.
"""
return self.access.getnewaddress()
def getPrivateKey(self, address):
"""
Arguments:
address: str, Base58Check-encoded address
Return value:
str, Base58Check-encoded private key
Returns the private key corresponding to the given address.
"""
return self.access.dumpprivkey(address)
def getBlockInfoByBlockHeight(self, height):
"""
Arguments:
height: int
Return value:
dict; containing:
hash: str; the block hash (hexadecimal)
merkleroot: str; the block Merkle root (hexadecimal, Bitcoin hash byte order)
time: int; the block timestamp (UNIX time)
Returns information about the block (in the main chain) at the
given height.
"""
bhash = self.access.getblockhash(height)
binfo = self.access.getblock(bhash)
return {"hash": binfo["hash"], "merkleroot": binfo["merkleroot"], "time": binfo["time"]}
def getTransactionHashesByBlockHeight(self, height):
"""
Arguments:
height: int
Return value:
list of str, hexadecimal, Bitcoin hash byte order
Returns the transaction hashes in the block (in the main chain) at the
given height.
"""
bhash = self.access.getblockhash(height)
block = self.access.getblock(bhash)
return block["tx"]
def getTransaction(self, thash):
"""
Arguments:
thash: str, hexadecimal, Bitcoin hash byte order
Return value:
dict, containing:
vin: list of dict, each element containing:
coinbase [only for coinbase transactions]
txid [only for non-coinbase transactions]:
str, hexadecimal, Bitcoin hash byte order
hash of input transaction
hex: str, hexadecimal, serialization of the transaction
confirmations: int, number of confirmations
Returns information about the transaction indicated by the given hash.
"""
return self.access.getrawtransaction(thash, 1)
def importprivkey(self, privateKey, description, rescan):
return self.access.importprivkey(privateKey, description, rescan)
def listUnspent(self):
"""
Return value:
list of dict, each element containing:
address:
str, Base58Check-encoded address
amount:
int, in Satoshi
scriptPubKey:
str, binary
txid:
str, binary, OpenSSL byte order
vout:
int
Returns information about the available unspent transaction outputs.
"""
ret = self.access.listunspent()
for vout in ret:
vout["txid"] = binascii.unhexlify(vout["txid"])[::-1] # reversed; TODO: is this the right place?
vout["scriptPubKey"] = binascii.unhexlify(vout["scriptPubKey"])
vout["amount"] = self.DecimaltoAmount(vout["amount"])
return ret
def sendRawTransaction(self, txData):
"""
Arguments:
txData: str, binary
Send the given serialized transaction over the Bitcoin network.
"""
try:
self.access.sendrawtransaction(txData.encode("hex"))
except JSONRPCException as e:
if e.error["code"] == RPC_TRANSACTION_ALREADY_IN_CHAIN:
# It's perfectly fine (but very unlikely) that the transaction is
# already in the block chain.
# After all, we WANT it to end up in the block chain!
pass
else:
raise
def DecimaltoAmount(self, value):
return int(value * 100000000)
def handleMessage(self, msg):
return [
messages.BitcoinReturnValue(value=msg.function(self), ID=msg.returnID, channelIndex=msg.returnChannelIndex)
]