def get_user_details(self, user):
desired_pseudoshare_target = None
if '+' in user:
user, desired_pseudoshare_difficulty_str = user.rsplit('+', 1)
try:
desired_pseudoshare_target = bitcoin_data.difficulty_to_target(
float(desired_pseudoshare_difficulty_str))
except:
pass
desired_share_target = 2**256 - 1
if '/' in user:
user, min_diff_str = user.rsplit('/', 1)
try:
desired_share_target = bitcoin_data.difficulty_to_target(
float(min_diff_str))
except:
pass
current_txouts = self.node.get_current_txouts()
current_pay_out = current_txouts.get(
bitcoin_data.pubkey_to_script2(self.my_pubkey), 0) * 1e-6
if current_pay_out == 0 or random.uniform(0, 100) < self.worker_fee:
script = bitcoin_data.pubkey_to_script2(self.my_pubkey)
else:
try:
script = bitcoin_data.pubkey_hash_to_script2(
bitcoin_data.address_to_pubkey_hash(
user, self.node.net.PARENT))
except: # XXX blah
script = bitcoin_data.pubkey_to_script2(self.my_pubkey)
return user, script, desired_share_target, desired_pseudoshare_target
def get_user_details(self, user):
desired_pseudoshare_target = None
if '+' in user:
user, desired_pseudoshare_difficulty_str = user.rsplit('+', 1)
try:
desired_pseudoshare_target = bitcoin_data.difficulty_to_target(float(desired_pseudoshare_difficulty_str))
except:
pass
desired_share_target = 2**256 - 1
if '/' in user:
user, min_diff_str = user.rsplit('/', 1)
try:
desired_share_target = bitcoin_data.difficulty_to_target(float(min_diff_str))
except:
pass
current_txouts = self.node.get_current_txouts()
current_pay_out = current_txouts.get(bitcoin_data.pubkey_to_script2(self.my_pubkey), 0)*1e-6
if current_pay_out == 0 or random.uniform(0, 100) < self.worker_fee:
script = bitcoin_data.pubkey_to_script2(self.my_pubkey)
else:
try:
script = bitcoin_data.pubkey_hash_to_script2(bitcoin_data.address_to_pubkey_hash(user, self.node.net.PARENT))
except: # XXX blah
script = bitcoin_data.pubkey_to_script2(self.my_pubkey)
return user, script, desired_share_target, desired_pseudoshare_target
def add_point():
if node.tracker.get_height(node.best_share_var.value) < 10:
return None
lookbehind = min(node.net.CHAIN_LENGTH, 60*60//node.net.SHARE_PERIOD, node.tracker.get_height(node.best_share_var.value))
t = time.time()
pool_rates = p2pool_data.get_stale_counts(node.tracker, node.best_share_var.value, lookbehind, rates=True)
pool_total = sum(pool_rates.itervalues())
hd.datastreams['pool_rates'].add_datum(t, pool_rates)
current_txouts = node.get_current_txouts()
hd.datastreams['current_payout'].add_datum(t, current_txouts.get(bitcoin_data.pubkey_to_script2(wb.my_pubkey), 0)*1e-6)
miner_hash_rates, miner_dead_hash_rates = get_local_rates()
current_txouts_by_address = dict((bitcoin_data.script2_to_address(script, node.net.PARENT), amount) for script, amount in current_txouts.iteritems())
hd.datastreams['current_payouts'].add_datum(t, dict((user, current_txouts_by_address[user]*1e-6) for user in miner_hash_rates if user in current_txouts_by_address))
hd.datastreams['incoming_peers'].add_datum(t, sum(1 for peer in node.p2p_node.peers.itervalues() if peer.incoming))
hd.datastreams['outgoing_peers'].add_datum(t, sum(1 for peer in node.p2p_node.peers.itervalues() if not peer.incoming))
vs = p2pool_data.get_desired_version_counts(node.tracker, node.best_share_var.value, lookbehind)
vs_total = sum(vs.itervalues())
hd.datastreams['desired_versions'].add_datum(t, dict((str(k), v/vs_total) for k, v in vs.iteritems()))
hd.datastreams['desired_version_rates'].add_datum(t, dict((str(k), v/vs_total*pool_total) for k, v in vs.iteritems()))
try:
hd.datastreams['memory_usage'].add_datum(t, memory.resident())
except:
if p2pool.DEBUG:
traceback.print_exc()
def update_stat_log():
while stat_log and stat_log[0]['time'] < time.time() - 24*60*60:
stat_log.pop(0)
lookbehind = 3600//node.net.SHARE_PERIOD
if node.tracker.get_height(node.best_share_var.value) < lookbehind:
return None
global_stale_prop = p2pool_data.get_average_stale_prop(node.tracker, node.best_share_var.value, lookbehind)
(stale_orphan_shares, stale_doa_shares), shares, _ = wb.get_stale_counts()
miner_hash_rates, miner_dead_hash_rates = get_local_rates()
stat_log.append(dict(
time=time.time(),
pool_hash_rate=p2pool_data.get_pool_attempts_per_second(node.tracker, node.best_share_var.value, lookbehind)/(1-global_stale_prop),
pool_stale_prop=global_stale_prop,
local_hash_rates=miner_hash_rates,
local_dead_hash_rates=miner_dead_hash_rates,
shares=shares,
stale_shares=stale_orphan_shares + stale_doa_shares,
stale_shares_breakdown=dict(orphan=stale_orphan_shares, doa=stale_doa_shares),
current_payout=node.get_current_txouts().get(bitcoin_data.pubkey_to_script2(wb.my_pubkey), 0)*1e-6,
peers=dict(
incoming=sum(1 for peer in node.p2p_node.peers.itervalues() if peer.incoming),
outgoing=sum(1 for peer in node.p2p_node.peers.itervalues() if not peer.incoming),
),
attempts_to_share=bitcoin_data.target_to_average_attempts(node.tracker.items[node.best_share_var.value].max_target),
attempts_to_block=bitcoin_data.target_to_average_attempts(node.bitcoind_work.value['bits'].target),
block_value=node.bitcoind_work.value['subsidy']*1e-6,
))
with open(os.path.join(datadir_path, 'stats'), 'wb') as f:
f.write(json.dumps(stat_log))
def get_payout_script2(bitcoind, net):
address = yield bitcoind.rpc_getaccountaddress('p2pool')
validate_response = yield bitcoind.rpc_validateaddress(address)
if 'pubkey' not in validate_response:
print ' Pubkey request failed. Falling back to payout to address.'
defer.returnValue(bitcoin_data.pubkey_hash_to_script2(bitcoin_data.address_to_pubkey_hash(address, net)))
pubkey = validate_response['pubkey'].decode('hex')
defer.returnValue(bitcoin_data.pubkey_to_script2(pubkey))
def get_payout_script2(bitcoind, net):
address = yield bitcoind.rpc_getaccountaddress('p2pool')
validate_response = yield bitcoind.rpc_validateaddress(address)
if 'pubkey' not in validate_response:
print ' Pubkey request failed. Falling back to payout to address.'
defer.returnValue(
bitcoin_data.pubkey_hash_to_script2(
bitcoin_data.address_to_pubkey_hash(address, net)))
pubkey = validate_response['pubkey'].decode('hex')
defer.returnValue(bitcoin_data.pubkey_to_script2(pubkey))
def status_thread():
last_str = None
last_time = 0
while True:
yield deferral.sleep(3)
try:
height = node.tracker.get_height(node.best_share_var.value)
this_str = 'P2Pool: %i shares in chain (%i verified/%i total) Peers: %i (%i incoming)' % (
height,
len(node.tracker.verified.items),
len(node.tracker.items),
len(node.p2p_node.peers),
sum(1 for peer in node.p2p_node.peers.itervalues() if peer.incoming),
) + (' FDs: %i R/%i W' % (len(reactor.getReaders()), len(reactor.getWriters())) if p2pool.DEBUG else '')
datums, dt = wb.local_rate_monitor.get_datums_in_last()
my_att_s = sum(datum['work']/dt for datum in datums)
this_str += '\n Local: %sH/s in last %s Local dead on arrival: %s Expected time to share: %s' % (
math.format(int(my_att_s)),
math.format_dt(dt),
math.format_binomial_conf(sum(1 for datum in datums if datum['dead']), len(datums), 0.95),
math.format_dt(2**256 / node.tracker.items[node.best_share_var.value].max_target / my_att_s) if my_att_s and node.best_share_var.value else '???',
)
if height > 2:
(stale_orphan_shares, stale_doa_shares), shares, _ = wb.get_stale_counts()
stale_prop = p2pool_data.get_average_stale_prop(node.tracker, node.best_share_var.value, min(60*60//net.SHARE_PERIOD, height))
real_att_s = p2pool_data.get_pool_attempts_per_second(node.tracker, node.best_share_var.value, min(height - 1, 60*60//net.SHARE_PERIOD)) / (1 - stale_prop)
this_str += '\n Shares: %i (%i orphan, %i dead) Stale rate: %s Efficiency: %s Current payout: %.4f %s' % (
shares, stale_orphan_shares, stale_doa_shares,
math.format_binomial_conf(stale_orphan_shares + stale_doa_shares, shares, 0.95),
math.format_binomial_conf(stale_orphan_shares + stale_doa_shares, shares, 0.95, lambda x: (1 - x)/(1 - stale_prop)),
node.get_current_txouts().get(bitcoin_data.pubkey_to_script2(my_pubkey), 0) * 1e-6, net.PARENT.SYMBOL,
)
this_str += '\n Pool: %sH/s Stale rate: %.1f%% Expected time to block: %s' % (
math.format(int(real_att_s)),
100*stale_prop,
math.format_dt(2**256 / node.bitcoind_work.value['bits'].target / real_att_s),
)
for warning in p2pool_data.get_warnings(node.tracker, node.best_share_var.value, net, bitcoind_warning_var.value, node.bitcoind_work.value):
print >>sys.stderr, '#'*40
print >>sys.stderr, '>>> Warning: ' + warning
print >>sys.stderr, '#'*40
if gc.garbage:
print '%i pieces of uncollectable cyclic garbage! Types: %r' % (len(gc.garbage), map(type, gc.garbage))
if this_str != last_str or time.time() > last_time + 15:
print this_str
last_str = this_str
last_time = time.time()
except:
log.err()
def get_user_details(self, user):
contents = re.split('([+/])', user)
assert len(contents) % 2 == 1
user, contents2 = contents[0], contents[1:]
desired_pseudoshare_target = None
desired_share_target = 2**256 - 1
for symbol, parameter in zip(contents2[::2], contents2[1::2]):
if symbol == '+':
try:
desired_pseudoshare_target = bitcoin_data.difficulty_to_target(
float(parameter))
except:
pass
elif symbol == '/':
try:
desired_share_target = bitcoin_data.difficulty_to_target(
float(parameter))
except:
pass
if random.uniform(0, 100) < self.worker_fee:
pubkey = self.my_pubkey
elif self.node.get_current_txouts().get(
bitcoin_data.pubkey_to_script2(self.my_pubkey), 0) < 10000:
pubkey = self.my_pubkey
else:
if user not in self.res2 or 'isvalid' not in self.res2[user]:
@defer.inlineCallbacks
def validate_pubkey(self, pubkey1):
res = yield self.node.bitcoind.rpc_validatepubkey(pubkey1)
defer.returnValue(res)
res1 = validate_pubkey(self, user)
def mycallback(x):
self.res2[user] = x
res1.addCallback(mycallback)
while user not in self.res2 or 'isvalid' not in self.res2[user]:
reactor.iterate(0.05)
time.sleep(0.001)
if self.res2[user]['isvalid']:
pubkey = user.decode('hex')
else:
pubkey = self.my_pubkey
return user, pubkey, desired_share_target, desired_pseudoshare_target
def get_user_details(self, user):
contents = re.split('([+/])', user)
assert len(contents) % 2 == 1
user, contents2 = contents[0], contents[1:]
desired_pseudoshare_target = None
desired_share_target = 2**256 - 1
for symbol, parameter in zip(contents2[::2], contents2[1::2]):
if symbol == '+':
try:
desired_pseudoshare_target = bitcoin_data.difficulty_to_target(float(parameter))
except:
pass
elif symbol == '/':
try:
desired_share_target = bitcoin_data.difficulty_to_target(float(parameter))
except:
pass
if random.uniform(0, 100) < self.worker_fee:
pubkey = self.my_pubkey
elif self.node.get_current_txouts().get(bitcoin_data.pubkey_to_script2(self.my_pubkey), 0) < 10000:
pubkey = self.my_pubkey
else:
if user not in self.res2 or 'isvalid' not in self.res2[user]:
@defer.inlineCallbacks
def validate_pubkey(self, pubkey1):
res = yield self.node.bitcoind.rpc_validatepubkey(pubkey1)
defer.returnValue(res)
res1 = validate_pubkey(self, user)
def mycallback(x):
self.res2[user] = x
res1.addCallback(mycallback)
while user not in self.res2 or 'isvalid' not in self.res2[user]:
reactor.iterate(0.05)
time.sleep(0.001)
if self.res2[user]['isvalid']:
pubkey = user.decode('hex')
else:
pubkey = self.my_pubkey
return user, pubkey, desired_share_target, desired_pseudoshare_target
def get_user_details(self, user):
desired_pseudoshare_target = None
if '+' in user:
user, desired_pseudoshare_difficulty_str = user.rsplit('+', 1)
try:
desired_pseudoshare_target = bitcoin_data.difficulty_to_target(float(desired_pseudoshare_difficulty_str))
except:
pass
desired_share_target = 2**256 - 1
if '/' in user:
user, min_diff_str = user.rsplit('/', 1)
try:
desired_share_target = bitcoin_data.difficulty_to_target(float(min_diff_str))
except:
pass
if random.uniform(0, 100) < self.worker_fee:
pubkey = self.my_pubkey
elif self.node.get_current_txouts().get(bitcoin_data.pubkey_to_script2(self.my_pubkey), 0) < 10000:
pubkey = self.my_pubkey
else:
if user not in self.res2 or 'isvalid' not in self.res2[user]:
@defer.inlineCallbacks
def validate_pubkey(self, pubkey1):
res = yield self.node.bitcoind.rpc_validatepubkey(pubkey1)
defer.returnValue(res)
res1 = validate_pubkey(self, user)
def mycallback(x):
self.res2[user] = x
res1.addCallback(mycallback)
while user not in self.res2 or 'isvalid' not in self.res2[user]:
reactor.iterate(0.05)
time.sleep(0.001)
if self.res2[user]['isvalid']:
pubkey = user.decode('hex')
else:
pubkey = self.my_pubkey
return user, pubkey, desired_share_target, desired_pseudoshare_target
