def check(dashd, net):
if not (yield net.PARENT.RPC_CHECK(dashd)):
print >> sys.stderr, " Check failed! Make sure that you're connected to the right dashd with --dashd-rpc-port!"
raise deferral.RetrySilentlyException()
if not net.VERSION_CHECK((yield dashd.rpc_getinfo())['version']):
print >> sys.stderr, ' Dash version too old! Upgrade to 0.11.0.11 or newer!'
raise deferral.RetrySilentlyException()
def check(bitcoind, net):
if not (yield net.PARENT.RPC_CHECK(bitcoind)):
print >> sys.stderr, " Check failed! Make sure that you're connected to the right bitcoind with --bitcoind-rpc-port!"
raise deferral.RetrySilentlyException()
version_check_result = net.VERSION_CHECK(
(yield bitcoind.rpc_getinfo())['version'])
if version_check_result == True: version_check_result = None # deprecated
if version_check_result == False:
version_check_result = 'Coin daemon too old! Upgrade!' # deprecated
if version_check_result is not None:
print >> sys.stderr, ' ' + version_check_result
raise deferral.RetrySilentlyException()
try:
blockchaininfo = yield bitcoind.rpc_getblockchaininfo()
softforks_supported = set(
item['id'] for item in blockchaininfo.get('softforks', []))
try:
softforks_supported |= set(
item['id']
for item in blockchaininfo.get('bip9_softforks', []))
except TypeError: # https://github.com/bitcoin/bitcoin/pull/7863
softforks_supported |= set(
item for item in blockchaininfo.get('bip9_softforks', []))
except jsonrpc.Error_for_code(-32601): # Method not found
softforks_supported = set()
if getattr(net, 'SOFTFORKS_REQUIRED', set()) - softforks_supported:
print 'Coin daemon too old! Upgrade!'
raise deferral.RetrySilentlyException()
def check(axed, net):
if not (yield net.PARENT.RPC_CHECK(axed)):
print >> sys.stderr, " Check failed! Make sure that you're connected to the right axed with --axed-rpc-port!"
raise deferral.RetrySilentlyException()
if not net.VERSION_CHECK((yield axed.rpc_getnetworkinfo())['version']):
print >> sys.stderr, ' axe version too old! Upgrade to 0.12.2.0 or newer!'
raise deferral.RetrySilentlyException()
def check(bitcoind, net):
if not (yield net.PARENT.RPC_CHECK(bitcoind)):
print >> sys.stderr, " Check failed! Make sure that you're connected to the right bitcoind with --bitcoind-rpc-port!"
raise deferral.RetrySilentlyException()
if not net.VERSION_CHECK((yield bitcoind.rpc_getinfo())['version']):
print >> sys.stderr, ' Bitcoin version too old! Upgrade to 0.6.4 or newer!'
raise deferral.RetrySilentlyException()
def check(bitcoind, net, args):
if not (yield net.PARENT.RPC_CHECK(bitcoind)):
print >>sys.stderr, " Check failed! Make sure that you're connected to the right bitcoind with --bitcoind-rpc-port, and that it has finished syncing!"
raise deferral.RetrySilentlyException()
version_check_result = net.VERSION_CHECK((yield bitcoind.rpc_getnetworkinfo())['version'])
if version_check_result == True: version_check_result = None # deprecated
if version_check_result == False: version_check_result = 'Coin daemon too old! Upgrade!' # deprecated
if version_check_result is not None:
print >>sys.stderr, ' ' + version_check_result
raise deferral.RetrySilentlyException()
try:
blockchaininfo = yield bitcoind.rpc_getblockchaininfo()
softforks_supported = set(item['id'] for item in blockchaininfo.get('softforks', []))
try:
softforks_supported |= set(item['id'] for item in blockchaininfo.get('bip9_softforks', []))
except TypeError: # https://github.com/bitcoin/bitcoin/pull/7863
softforks_supported |= set(item for item in blockchaininfo.get('bip9_softforks', []))
except jsonrpc.Error_for_code(-32601): # Method not found
softforks_supported = set()
unsupported_forks = getattr(net, 'SOFTFORKS_REQUIRED', set()) - softforks_supported
if unsupported_forks:
print "You are running a coin daemon that does not support all of the "
print "forking features that have been activated on this blockchain."
print "Consequently, your node may mine invalid blocks or may mine blocks that"
print "are not part of the Nakamoto consensus blockchain.\n"
print "Missing fork features:", ', '.join(unsupported_forks)
if not args.allow_obsolete_bitcoind:
print "\nIf you know what you're doing, this error may be overridden by running p2pool"
print "with the '--allow-obsolete-bitcoind' command-line option.\n\n\n"
raise deferral.RetrySilentlyException()
def check(dcrd, net):
if not (yield net.PARENT.RPC_CHECK(dcrd)):
print >>sys.stderr, " Check failed! Make sure that you're connected to the right dcrd with --dcrd-rpc-port!"
raise deferral.RetrySilentlyException()
version_check_result = net.VERSION_CHECK((yield dcrd.rpc_getinfo())['version'])
if version_check_result == True: version_check_result = None # deprecated
if version_check_result == False: version_check_result = 'Coin daemon too old! Upgrade!' # deprecated
if version_check_result is not None:
print >>sys.stderr, ' ' + version_check_result
raise deferral.RetrySilentlyException()
def submit_block_p2p(block, factory, net):
if factory.conn.value is None:
print >> sys.stderr, 'No axed connection when block submittal attempted! %s%064x' % (
net.PARENT.BLOCK_EXPLORER_URL_PREFIX,
axe_data.hash256(axe_data.block_header_type.pack(block['header'])))
raise deferral.RetrySilentlyException()
factory.conn.value.send_block(block=block)
def getwork(bitcoind, use_getblocktemplate=False):
def go():
if use_getblocktemplate:
return bitcoind.rpc_getblocktemplate(
dict(mode='template', rules=['segwit']))
else:
return bitcoind.rpc_getmemorypool()
try:
start = time.time()
work = yield go()
end = time.time()
except jsonrpc.Error_for_code(-32601): # Method not found
use_getblocktemplate = not use_getblocktemplate
try:
start = time.time()
work = yield go()
end = time.time()
except jsonrpc.Error_for_code(-32601): # Method not found
print >> sys.stderr, 'Error: Bitcoin version too old! Upgrade to v0.5 or newer!'
raise deferral.RetrySilentlyException()
packed_transactions = [
x['data'].decode('hex') for x in work['transactions']
if len(x.get('depends', [])) == 0
]
if 'height' not in work:
work['height'] = (yield bitcoind.rpc_getblock(
work['previousblockhash']))['height'] + 1
elif p2pool.DEBUG:
assert work['height'] == (yield bitcoind.rpc_getblock(
work['previousblockhash']))['height'] + 1
defer.returnValue(
dict(
version=work['version'],
previous_block=int(work['previousblockhash'], 16),
transactions=map(bitcoin_data.tx_type.unpack, packed_transactions),
transaction_hashes=map(bitcoin_data.hash256, packed_transactions),
transaction_fees=[
x.get('fee', None) if isinstance(x, dict) else None
for x in work['transactions']
],
subsidy=work['coinbasevalue'],
devreward_value=work['coinbasedevreward']['value'],
devreward_scriptpubkey=work['coinbasedevreward']['scriptpubkey'],
time=work['time'] if 'time' in work else work['curtime'],
bits=bitcoin_data.FloatingIntegerType().unpack(
work['bits'].decode('hex')[::-1]) if isinstance(
work['bits'],
(str,
unicode)) else bitcoin_data.FloatingInteger(work['bits']),
coinbaseflags=work['coinbaseflags'].decode('hex')
if 'coinbaseflags' in work else ''.join(
x.decode('hex') for x in work['coinbaseaux'].itervalues())
if 'coinbaseaux' in work else '',
height=work['height'],
rules=work.get('rules', []),
last_update=time.time(),
use_getblocktemplate=use_getblocktemplate,
latency=end - start,
))
def checkwallet(dcrdwallet, net):
print('wallet_check')
wallet_dcrd_server_check_result = (
yield dcrdwallet.rpc_walletinfo())['daemonconnected']
if wallet_dcrd_server_check_result == False:
print >> sys.stderr, ' ' + wallet_dcrd_server_check_result
raise deferral.RetrySilentlyException()
def height_cacher(block_hash):
try:
x = yield starwelsd.rpc_getblock('%x' % (block_hash,))
except jsonrpc.Error_for_code(-5): # Block not found
if not p2pool.DEBUG:
raise deferral.RetrySilentlyException()
else:
raise
defer.returnValue(x['blockcount'] if 'blockcount' in x else x['height'])
def height_cacher(block_hash):
if not block_hash in cached_heights:
try:
x = yield bitcoind.rpc_getblockheader('%x' % (block_hash,))
except jsonrpc.Error_for_code(-5): # Block not found
if not p2pool.DEBUG:
raise deferral.RetrySilentlyException()
else:
raise
cached_heights[block_hash] = x['blockcount'] if 'blockcount' in x else x['height']
defer.returnValue(cached_heights[block_hash])
def check(bitcoind, net):
if not (yield net.PARENT.RPC_CHECK(bitcoind)):
print >> sys.stderr, " Check failed! Make sure that you're connected to the right groestlcoind with --groestlcoind-rpc-port!"
raise deferral.RetrySilentlyException()
version_check_result = net.VERSION_CHECK(
(yield bitcoind.rpc_getnetworkinfo())['version'])
if version_check_result == True: version_check_result = None # deprecated
if version_check_result == False:
version_check_result = 'Coin daemon too old! Upgrade!' # deprecated
if version_check_result is not None:
print >> sys.stderr, ' ' + version_check_result
raise deferral.RetrySilentlyException()
try:
softforks_supported = set(item for item in (
yield bitcoind.rpc_getdeploymentinfo()).get('deployments', []))
except jsonrpc.Error_for_code(-32601): # Method not found
softforks_supported = set()
if getattr(net, 'SOFTFORKS_REQUIRED', set()) - softforks_supported:
print 'Coin daemon too old! Upgrade!'
raise deferral.RetrySilentlyException()
def submit_block_p2p(block, factory, net, bitcoind_work):
if factory.conn.value is None:
print >>sys.stderr, 'No bitcoind connection when block submittal attempted! %s%064x' % (net.PARENT.BLOCK_EXPLORER_URL_PREFIX, bitcoin_data.hash256(bitcoin_data.block_header_type.pack(block['header'])))
raise deferral.RetrySilentlyException()
segwit_rules = set(['!segwit', 'segwit'])
segwit_activated = len(segwit_rules - set(bitcoind_work.value['rules'])) < len(segwit_rules)
block_type = bitcoin_data.block_type if segwit_activated else bitcoin_data.stripped_block_type
block = block_type.pack(block)
block = block_type.unpack(block)
factory.conn.value.send_block(block=block)
def getwork(bitcoind, use_getblocktemplate=False):
def go():
if use_getblocktemplate:
return bitcoind.rpc_getblocktemplate(dict(mode='template'))
else:
return bitcoind.rpc_getmemorypool()
try:
start = time.time()
work = yield go()
end = time.time()
except jsonrpc.Error_for_code(-32601): # Method not found
use_getblocktemplate = not use_getblocktemplate
try:
start = time.time()
work = yield go()
end = time.time()
except jsonrpc.Error_for_code(-32601): # Method not found
print >>sys.stderr, 'Error: Bitcoin version too old! Upgrade to v0.5 or newer!'
raise deferral.RetrySilentlyException()
packed_transactions = [(x['data'] if isinstance(x, dict) else x).decode('hex') for x in work['transactions']]
if 'height' not in work:
work['height'] = (yield bitcoind.rpc_getblock(work['previousblockhash']))['height'] + 1
elif p2pool.DEBUG:
assert work['height'] == (yield bitcoind.rpc_getblock(work['previousblockhash']))['height'] + 1
fee_list = [x.get('fee', None) if isinstance(x, dict) else None for x in work['transactions']] # for FRC Parent transform unicode fees to int
fee_helper = []
for fee in fee_list:
if isinstance(fee, unicode):
float_fee = float(fee)
int_fee = int(float_fee * 100000000)
fee_helper.append(int_fee)
else:
fee_helper.append(fee)
fee_list = fee_helper
defer.returnValue(dict(
version=work['version'],
previous_block=int(work['previousblockhash'], 16),
transactions=map(bitcoin_data.tx_type.unpack, packed_transactions),
transaction_hashes=map(bitcoin_data.hash256, packed_transactions),
transaction_fees=fee_list, # for FRC Parent +fee_list
subsidy=work['coinbasevalue'],
time=work['time'] if 'time' in work else work['curtime'],
bits=bitcoin_data.FloatingIntegerType().unpack(work['bits'].decode('hex')[::-1]) if isinstance(work['bits'], (str, unicode)) else bitcoin_data.FloatingInteger(work['bits']),
coinbaseflags=work['coinbaseflags'].decode('hex') if 'coinbaseflags' in work else ''.join(x.decode('hex') for x in work['coinbaseaux'].itervalues()) if 'coinbaseaux' in work else '',
height=work['height'],
last_update=time.time(),
use_getblocktemplate=use_getblocktemplate,
latency=end - start,
))
def height_cacher(block_hash):
try:
block_hash_str = '%x' % (block_hash, )
if len(block_hash_str) != 64:
block_hash_str = '0' * (
64 - len(block_hash_str)) + block_hash_str
x = yield bitcoind.rpc_getblock(block_hash_str)
except jsonrpc.Error_for_code(-5): # Block not found
if not p2pool.DEBUG:
raise deferral.RetrySilentlyException()
else:
raise
defer.returnValue(x['blockcount'] if 'blockcount' in
x else x['height'])
def getwork(ezoncoind, net, use_getblocktemplate=False):
def go():
if use_getblocktemplate:
return ezoncoind.rpc_getblocktemplate(dict(mode='template'))
else:
return ezoncoind.rpc_getmemorypool()
try:
start = time.time()
work = yield go()
end = time.time()
except jsonrpc.Error_for_code(-32601): # Method not found
use_getblocktemplate = not use_getblocktemplate
try:
start = time.time()
work = yield go()
end = time.time()
except jsonrpc.Error_for_code(-32601): # Method not found
print >>sys.stderr, 'Error: Ezoncoin version too old! Upgrade to v0.11.0.11 or newer!'
raise deferral.RetrySilentlyException()
packed_transactions = [(x['data'] if isinstance(x, dict) else x).decode('hex') for x in work['transactions']]
packed_votes = [(x['data'] if isinstance(x, dict) else x).decode('hex') for x in work['votes']]
if 'height' not in work:
work['height'] = (yield ezoncoind.rpc_getblock(work['previousblockhash']))['height'] + 1
elif p2pool.DEBUG:
assert work['height'] == (yield ezoncoind.rpc_getblock(work['previousblockhash']))['height'] + 1
defer.returnValue(dict(
version=work['version'],
previous_block=int(work['previousblockhash'], 16),
transactions=map(ezoncoin_data.tx_type.unpack, packed_transactions),
transaction_hashes=map(ezoncoin_data.hash256, packed_transactions),
transaction_fees=[x.get('fee', None) if isinstance(x, dict) else None for x in work['transactions']],
subsidy=work['coinbasevalue'],
time=work['time'] if 'time' in work else work['curtime'],
bits=ezoncoin_data.FloatingIntegerType().unpack(work['bits'].decode('hex')[::-1]) if isinstance(work['bits'], (str, unicode)) else ezoncoin_data.FloatingInteger(work['bits']),
coinbaseflags=work['coinbaseflags'].decode('hex') if 'coinbaseflags' in work else ''.join(x.decode('hex') for x in work['coinbaseaux'].itervalues()) if 'coinbaseaux' in work else '',
height=work['height'],
last_update=time.time(),
use_getblocktemplate=use_getblocktemplate,
latency=end - start,
votes=map(ezoncoin_data.vote_type.unpack, packed_votes),
payee=ezoncoin_data.address_to_pubkey_hash(work['payee'], net.PARENT) if (work['payee'] != '') else None,
masternode_payments=work['masternode_payments'],
payee_amount=work['payee_amount'] if (work['payee_amount'] != '') else work['coinbasevalue'] / 5,
))
def getwork(bitcoind, use_getblocktemplate=False, txidcache={}, feecache={}, feefifo=[], known_txs={}):
def go():
if use_getblocktemplate:
return bitcoind.rpc_getblocktemplate(dict(mode='template', rules=['segwit']))
else:
return bitcoind.rpc_getmemorypool()
try:
start = time.time()
work = yield go()
end = time.time()
except jsonrpc.Error_for_code(-32601): # Method not found
use_getblocktemplate = not use_getblocktemplate
try:
start = time.time()
work = yield go()
end = time.time()
except jsonrpc.Error_for_code(-32601): # Method not found
print >>sys.stderr, 'Error: Bitcoin version too old! Upgrade to v0.5 or newer!'
raise deferral.RetrySilentlyException()
if not 'start' in txidcache: # we clear it every 30 min
txidcache['start'] = time.time()
t0 = time.time()
unpacked_transactions = []
txhashes = []
cachehits = 0
cachemisses = 0
knownhits = 0
knownmisses = 0
for x in work['transactions']:
fee = x['fee']
x = x['data'] if isinstance(x, dict) else x
packed = None
if x in txidcache:
cachehits += 1
txid = (txidcache[x])
txhashes.append(txid)
else:
cachemisses += 1
packed = x.decode('hex')
txid = bitcoin_data.hash256(packed)
txidcache[x] = txid
txhashes.append(txid)
if txid in known_txs:
knownhits += 1
unpacked = known_txs[txid]
else:
knownmisses += 1
if not packed:
packed = x.decode('hex')
unpacked = bitcoin_data.tx_type.unpack(packed)
unpacked_transactions.append(unpacked)
# The only place where we can get information on transaction fees is in GBT results, so we need to store those
# for a while so we can spot shares that miscalculate the block reward
if not txid in feecache:
feecache[txid] = fee
feefifo.append(txid)
if time.time() - txidcache['start'] > 30*60.:
keepers = {(x['data'] if isinstance(x, dict) else x):txid for x, txid in zip(work['transactions'], txhashes)}
txidcache.clear()
txidcache.update(keepers)
# limit the fee cache to 100,000 entries, which should be about 10-20 MB
fum = 100000
while len(feefifo) > fum:
del feecache[feefifo.pop(0)]
packed_transactions = [x['data'].decode('hex') for x in work['transactions'] if len(x.get('depends', [])) == 0]
if 'height' not in work:
work['height'] = (yield bitcoind.rpc_getblock(work['previousblockhash']))['height'] + 1
elif p2pool.DEBUG:
assert work['height'] == (yield bitcoind.rpc_getblock(work['previousblockhash']))['height'] + 1
t1 = time.time()
if p2pool.BENCH: print "%8.3f ms for helper.py:getwork(). Cache: %i hits %i misses, %i known_tx %i unknown %i cached" % ((t1 - t0)*1000., cachehits, cachemisses, knownhits, knownmisses, len(txidcache))
defer.returnValue(dict(
version=work['version'],
previous_block=int(work['previousblockhash'], 16),
transactions=unpacked_transactions,
transaction_hashes=txhashes,
transaction_fees=[x.get('fee', None) if isinstance(x, dict) else None for x in work['transactions']],
subsidy=work['coinbasevalue'],
time=work['time'] if 'time' in work else work['curtime'],
bits=bitcoin_data.FloatingIntegerType().unpack(work['bits'].decode('hex')[::-1]) if isinstance(work['bits'], (str, unicode)) else bitcoin_data.FloatingInteger(work['bits']),
coinbaseflags=work['coinbaseflags'].decode('hex') if 'coinbaseflags' in work else ''.join(x.decode('hex') for x in work['coinbaseaux'].itervalues()) if 'coinbaseaux' in work else '',
height=work['height'],
rules=work.get('rules', []),
last_update=time.time(),
use_getblocktemplate=use_getblocktemplate,
latency=end - start,
))
def getwork(dcrd, use_getblocktemplate=True):
def go():
print 'Getting blocktemplate ...'
if not use_getblocktemplate:
raise Exception("getblocktemplate only")
return dcrd.rpc_getblocktemplate(dict(mode='template'))
try:
start = time.time()
work = yield go()
end = time.time()
except jsonrpc.Error_for_code(-32601): # Method not found
print >>sys.stderr, 'Error: Decred version too old! Upgrade to v1.1.1 or newer!'
raise deferral.RetrySilentlyException()
#
# work
#
work['currtime'] = time.time()
#
# Block Header
#
block_header = work['header']
packed_header = block_header.decode('hex')
block_header_record = decred_data.block_header_type.unpack(packed_header)
work['version'] = block_header_record.version
work['bits'] = block_header_record.bits
work['height'] = block_header_record.height
work['previousblockhash'] = "{0:x}".format(block_header_record.previous_block)
if p2pool.DEBUG:
assert work['height'] == (yield dcrd.rpc_getblock(work['previousblockhash']))['height'] + 1
#
# Transactions/STransactions
#
txs = []
for regtx in work['transactions']:
tx = regtx['data']
hash = regtx['hash']
txs.append({'tx': tx, 'hash': hash})
stxs = []
for staketx in work['stransactions']:
stx = staketx['data']
hash = staketx['hash']
stxs.append({'tx': stx, 'hash': hash})
transaction_records = []
transaction_hashes = []
for t in txs:
ptx = t['tx'].decode('hex')
ptx_hash = t['hash'].decode('hex')
tx_full = decred_data.tx_type.unpack(ptx)
tx_full_hash = pack.IntType(256, endianness='big').unpack(ptx_hash) # sent in on getblocktemplate
transaction_records.append(tx_full)
transaction_hashes.append(tx_full_hash)
#
# TODO: Find out if we really need the prefix hashes at a later point in the logic flow
#
if p2pool.DEBUG:
alldata = decred_data.tx_type.get_all(ptx)
print(hex(tx_full_hash), 'tx_full_hash:')
print(hex(alldata['tx_full_hash']), 'alldata.tx_full_hash')
print(hex(alldata['prefix_hash']), 'alldata.prefix_hash')
print(hex(alldata['witness_hash']), 'alldata.witness_hash')
assert tx_full_hash == alldata['tx_full_hash']
print
stransaction_records = []
stransaction_hashes = []
for s in stxs:
ptx = s['tx'].decode('hex')
ptx_hash = s['hash'].decode('hex')
tx_full = decred_data.tx_type.unpack(ptx)
tx_full_hash = pack.IntType(256, endianness='big').unpack(ptx_hash) # sent in on getblocktemplate
stransaction_records.append(tx_full)
stransaction_hashes.append(tx_full_hash)
wd = dict(
version=work['version'],
previous_block=int(work['previousblockhash'], 16),
transactions=transaction_records,
transaction_hashes=transaction_hashes,
stransactions = stransaction_records,
stransaction_hashes=stransaction_hashes,
transaction_fees=[x.get('fee', None) if isinstance(x, dict) else None for x in work['transactions']], # TODO: FixMe for trans + strans
subsidy=work['coinbasevalue'],
time=work['currtime'],
bits=decred_data.FloatingInteger(work['bits']),
coinbaseflags=''.join(x.decode('hex') for x in work['coinbaseaux'].itervalues()),
height=work['height'],
last_update=time.time(),
use_getblocktemplate=use_getblocktemplate,
latency=end - start,
)
defer.returnValue(wd)
def getwork(axed, net, use_getblocktemplate=True):
def go():
if use_getblocktemplate:
return axed.rpc_getblocktemplate(dict(mode='template'))
else:
return axed.rpc_getmemorypool()
try:
start = time.time()
work = yield go()
end = time.time()
except jsonrpc.Error_for_code(-32601): # Method not found
use_getblocktemplate = not use_getblocktemplate
try:
start = time.time()
work = yield go()
end = time.time()
except jsonrpc.Error_for_code(-32601): # Method not found
print >> sys.stderr, 'Error: axe version too old! Upgrade to v0.11.2.17 or newer!'
raise deferral.RetrySilentlyException()
if work['transactions']:
packed_transactions = [
(x['data'] if isinstance(x, dict) else x).decode('hex')
for x in work['transactions']
]
else:
packed_transactions = []
if 'height' not in work:
work['height'] = (yield axed.rpc_getblock(
work['previousblockhash']))['height'] + 1
elif p2pool.DEBUG:
assert work['height'] == (yield axed.rpc_getblock(
work['previousblockhash']))['height'] + 1
# Axe Payments
packed_payments = []
payment_amount = 0
if 'payee' in work['masternode']:
g = {}
g['payee'] = str(work['masternode']['payee'])
g['amount'] = work['masternode']['amount']
if g['amount'] > 0:
payment_amount += g['amount']
packed_payments.append(g)
elif work['superblock']:
for obj in work['superblock']:
g = {}
g['payee'] = str(obj['payee'])
g['amount'] = obj['amount']
if g['amount'] > 0:
payment_amount += g['amount']
packed_payments.append(g)
defer.returnValue(
dict(
version=work['version'],
previous_block=int(work['previousblockhash'], 16),
transactions=map(axe_data.tx_type.unpack, packed_transactions),
transaction_hashes=map(axe_data.hash256, packed_transactions),
transaction_fees=[
x.get('fee', None) if isinstance(x, dict) else None
for x in work['transactions']
],
subsidy=work['coinbasevalue'],
time=work['time'] if 'time' in work else work['curtime'],
bits=axe_data.FloatingIntegerType().unpack(
work['bits'].decode('hex')[::-1]) if isinstance(
work['bits'],
(str,
unicode)) else axe_data.FloatingInteger(work['bits']),
coinbaseflags=work['coinbaseflags'].decode('hex')
if 'coinbaseflags' in work else ''.join(
x.decode('hex') for x in work['coinbaseaux'].itervalues())
if 'coinbaseaux' in work else '',
height=work['height'],
last_update=time.time(),
use_getblocktemplate=use_getblocktemplate,
latency=end - start,
payment_amount=payment_amount,
packed_payments=packed_payments,
))
def check(bitcoind, net):
if not (yield net.PARENT.RPC_CHECK(bitcoind)):
print >>sys.stderr, " Check failed! Make sure that you're connected to the right bitcoind with --bitcoind-rpc-port!"
raise deferral.RetrySilentlyException()
def check(bitcoind, net):
if not net.VERSION_CHECK((yield bitcoind.rpc_getinfo())['version']):
print >> sys.stderr, ' Coin daemon too old! Upgrade!'
raise deferral.RetrySilentlyException()
def getwork(dcrd,
use_getblocktemplate=False
): # TODO: remove getblocktemplate completely
def go():
if use_getblocktemplate:
# gf: TOSO: remove getblocktemplate - decred does not have it
raise Exception("getblocktemplate - not supported")
#<-gf:
# return dcrd.rpc_getrawmempool(True) # verbose - keyed on tx hash
return dcrd.rpc_getrawmempool(
False) # non-verbose - just the txids - keyed on tx hash
try:
start = time.time()
mpool = yield go()
end = time.time()
except jsonrpc.Error_for_code(-32601): # Method not found
print >> sys.stderr, 'Error: Decred version too old! Upgrade to v0.5 or newer!'
raise deferral.RetrySilentlyException()
# packed_transactions = [(x['data'] if isinstance(x, dict) else x).decode('hex') for x in work['transactions']]
# if 'height' not in work:
# work['height'] = (yield dcrd.rpc_getblock(work['previousblockhash']))['height'] + 1
# elif p2pool.DEBUG:
# assert work['height'] == (yield dcrd.rpc_getblock(work['previousblockhash']))['height'] + 1
# defer.returnValue(dict(
# version=work['version'],
# previous_block=int(work['previousblockhash'], 16),
# transactions=map(decred_data.tx_type.unpack, packed_transactions),
# transaction_hashes=map(decred_data.hash256, packed_transactions),
# transaction_fees=[x.get('fee', None) if isinstance(x, dict) else None for x in work['transactions']],
# subsidy=work['coinbasevalue'],
# time=work['time'] if 'time' in work else work['curtime'],
# bits=decred_data.FloatingIntegerType().unpack(work['bits'].decode('hex')[::-1]) if isinstance(work['bits'], (str, unicode)) else decred_data.FloatingInteger(work['bits']),
# coinbaseflags=work['coinbaseflags'].decode('hex') if 'coinbaseflags' in work else ''.join(x.decode('hex') for x in work['coinbaseaux'].itervalues()) if 'coinbaseaux' in work else '',
# height=work['height'],
# last_update=time.time(),
# use_getblocktemplate=use_getblocktemplate,
# latency=end - start,
# ))
#
# what we have is string transaction hashes in a list
#
transaction_hashes = [x for x in mpool]
#
# for each txid above get raw and json data - this only works if dcrd is started with --txindex
#
transactions = []
for txhash in transaction_hashes:
rawtx = yield dcrd.rpc_getrawtransaction(
txhash, 1) # verbose - raw tx + txid + tx inpu/output data, etc.
transactions.append(rawtx)
curr_tip_height = (yield dcrd.rpc_getbestblock())['height']
gw_previous_block = (yield dcrd.rpc_getblockhash(curr_tip_height))
work = dict()
defer.returnValue(work)
