def test_expiring_dict1(self):
e = expiring_dict.ExpiringDict(3, get_touches=True)
e[1] = 2
yield deferral.sleep(1.5)
assert 1 in e
yield deferral.sleep(3)
assert 1 not in e
def test_expiring_dict2(self):
e = expiring_dict.ExpiringDict(3, get_touches=True)
e[1] = 2
yield deferral.sleep(2.25)
e[1]
yield deferral.sleep(2.25)
assert 1 in e
def download_shares():
while True:
desired = yield self.node.desired_var.get_when_satisfies(lambda val: len(val) != 0)
peer_addr, share_hash = random.choice(desired)
if len(self.peers) == 0:
yield deferral.sleep(1)
continue
peer = random.choice(self.peers.values())
print 'Requesting parent share %s from %s' % (p2pool_data.format_hash(share_hash), '%s:%i' % peer.addr)
try:
shares = yield peer.get_shares(
hashes=[share_hash],
parents=random.randrange(500), # randomize parents so that we eventually get past a too large block of shares
stops=list(set(self.node.tracker.heads) | set(
self.node.tracker.get_nth_parent_hash(head, min(max(0, self.node.tracker.get_height_and_last(head)[0] - 1), 10)) for head in self.node.tracker.heads
))[:100],
)
except defer.TimeoutError:
print 'Share request timed out!'
continue
except:
log.err(None, 'in download_shares:')
continue
if not shares:
yield deferral.sleep(1) # sleep so we don't keep rerequesting the same share nobody has
continue
self.handle_shares([(share, []) for share in shares], peer)
def test_expiring_dict1(self):
e = expiring_dict.ExpiringDict(3, get_touches=True)
e[1] = 2
yield deferral.sleep(1.5)
assert 1 in e
yield deferral.sleep(3)
assert 1 not in e
def test_expiring_dict3(self):
e = expiring_dict.ExpiringDict(3, get_touches=False)
e[1] = 2
yield deferral.sleep(2.25)
e[1]
yield deferral.sleep(2.25)
assert 1 not in e
def test_expiring_dict3(self):
e = expiring_dict.ExpiringDict(3, get_touches=False)
e[1] = 2
yield deferral.sleep(2.25)
e[1]
yield deferral.sleep(2.25)
assert 1 not in e
def test_nodes(self):
N = 3
SHARES = 600
bitd = bitcoind()
nodes = []
for i in xrange(N):
nodes.append((yield MiniNode.start(mynet, bitd, bitd, [mn.n.p2p_node.serverfactory.listen_port.getHost().port for mn in nodes], [])))
yield deferral.sleep(3)
for i in xrange(SHARES):
proxy = jsonrpc.HTTPProxy('http://127.0.0.1:' + str(random.choice(nodes).web_port.getHost().port),
headers=dict(Authorization='Basic ' + base64.b64encode('user/0:password')))
blah = yield proxy.rpc_getwork()
yield proxy.rpc_getwork(blah['data'])
yield deferral.sleep(.05)
print i
print type(nodes[0].n.tracker.items[nodes[0].n.best_share_var.value])
# crawl web pages
from p2pool import web
stop_event = variable.Event()
web2_root = web.get_web_root(nodes[0].wb, tempfile.mkdtemp(), variable.Variable({'errors': '', 'version': 100000}), stop_event)
web2_port = reactor.listenTCP(0, server.Site(web2_root))
for name in web2_root.listNames() + ['web/' + x for x in web2_root.getChildWithDefault('web', None).listNames()]:
if name in ['web/graph_data', 'web/share', 'web/share_data', 'web/payout_address']: continue
print
print name
try:
res = yield client.getPage('http://127.0.0.1:%i/%s' % (web2_port.getHost().port, name))
except:
import traceback
traceback.print_exc()
else:
print repr(res)[:100]
print
yield web2_port.stopListening()
stop_event.happened()
del web2_root
yield deferral.sleep(3)
for i, n in enumerate(nodes):
assert len(n.n.tracker.items) == SHARES, (i, len(n.n.tracker.items))
assert n.n.tracker.verified.get_height(n.n.best_share_var.value) == SHARES, (i, n.n.tracker.verified.get_height(n.n.best_share_var.value))
assert type(n.n.tracker.items[nodes[0].n.best_share_var.value]) is (data.Share.SUCCESSOR if data.Share.SUCCESSOR is not None else data.Share)
assert type(n.n.tracker.items[n.n.tracker.get_nth_parent_hash(nodes[0].n.best_share_var.value, SHARES - 5)]) is data.Share
for n in nodes:
yield n.stop()
del nodes, n
import gc
gc.collect()
gc.collect()
gc.collect()
yield deferral.sleep(20) # waiting for work_poller to exit
def test_expiring_dict2(self):
e = expiring_dict.ExpiringDict(3, get_touches=True)
e[1] = 2
yield deferral.sleep(2.25)
e[1]
yield deferral.sleep(2.25)
assert 1 in e
def test_nodes(self):
N = 3
SHARES = 600
bitd = mued()
nodes = []
for i in xrange(N):
nodes.append((yield MiniNode.start(mynet, bitd, bitd, [mn.n.p2p_node.serverfactory.listen_port.getHost().port for mn in nodes], [])))
yield deferral.sleep(3)
for i in xrange(SHARES):
proxy = jsonrpc.HTTPProxy('http://127.0.0.1:' + str(random.choice(nodes).web_port.getHost().port),
headers=dict(Authorization='Basic ' + base64.b64encode('user/0:password')))
blah = yield proxy.rpc_getwork()
yield proxy.rpc_getwork(blah['data'])
yield deferral.sleep(.05)
print i
print type(nodes[0].n.tracker.items[nodes[0].n.best_share_var.value])
# crawl web pages
from p2pool import web
stop_event = variable.Event()
web2_root = web.get_web_root(nodes[0].wb, tempfile.mkdtemp(), variable.Variable(None), stop_event)
web2_port = reactor.listenTCP(0, server.Site(web2_root))
for name in web2_root.listNames() + ['web/' + x for x in web2_root.getChildWithDefault('web', None).listNames()]:
if name in ['web/graph_data', 'web/share', 'web/share_data']: continue
print
print name
try:
res = yield client.getPage('http://127.0.0.1:%i/%s' % (web2_port.getHost().port, name))
except:
import traceback
traceback.print_exc()
else:
print repr(res)[:100]
print
yield web2_port.stopListening()
stop_event.happened()
del web2_root
yield deferral.sleep(3)
for i, n in enumerate(nodes):
assert len(n.n.tracker.items) == SHARES, (i, len(n.n.tracker.items))
assert n.n.tracker.verified.get_height(n.n.best_share_var.value) == SHARES, (i, n.n.tracker.verified.get_height(n.n.best_share_var.value))
assert type(n.n.tracker.items[nodes[0].n.best_share_var.value]) is (data.Share.SUCCESSOR if data.Share.SUCCESSOR is not None else data.Share)
assert type(n.n.tracker.items[n.n.tracker.get_nth_parent_hash(nodes[0].n.best_share_var.value, SHARES - 5)]) is data.Share
for n in nodes:
yield n.stop()
del nodes, n
import gc
gc.collect()
gc.collect()
gc.collect()
yield deferral.sleep(20) # waiting for work_poller to exit
def download_shares():
while True:
desired = yield self.node.desired_var.get_when_satisfies(
lambda val: len(val) != 0)
peer2, share_hash = random.choice(desired)
if len(self.peers) == 0:
yield deferral.sleep(1)
continue
peer = random.choice(self.peers.values())
print 'Requesting parent share %s from %s' % (
p2pool_data.format_hash(share_hash), '%s:%i' % peer.addr)
try:
shares = yield peer.get_shares(
hashes=[share_hash],
parents=500,
stops=[],
)
except:
log.err(None, 'in download_shares:')
continue
if not shares:
yield deferral.sleep(
1
) # sleep so we don't keep rerequesting the same share nobody has
continue
self.handle_shares(shares, peer)
def download_shares():
while True:
desired = yield self.node.desired_var.get_when_satisfies(lambda val: len(val) != 0)
peer_addr, share_hash = random.choice(desired)
if len(self.peers) == 0:
yield deferral.sleep(1)
continue
peer = random.choice(self.peers.values())
print 'Requesting parent share %s from %s' % (p2pool_data.format_hash(share_hash), '%s:%i' % peer.addr)
try:
shares = yield peer.get_shares(
hashes=[share_hash],
parents=random.randrange(500), # randomize parents so that we eventually get past a too large block of shares
stops=list(set(self.node.tracker.heads) | set(
self.node.tracker.get_nth_parent_hash(head, min(max(0, self.node.tracker.get_height_and_last(head)[0] - 1), 10)) for head in self.node.tracker.heads
))[:100],
)
except defer.TimeoutError:
print 'Share request timed out!'
continue
except:
log.err(None, 'in download_shares:')
continue
if not shares:
yield deferral.sleep(1) # sleep so we don't keep rerequesting the same share nobody has
continue
self.handle_shares([(share, []) for share in shares], peer)
def test_node(self):
bitd = dcrd()
mm_root = resource.Resource()
mm_root.putChild('', jsonrpc.HTTPServer(mm_provider))
mm_port = reactor.listenTCP(0, server.Site(mm_root))
n = node.Node(bitd, bitd, [], [], mynet)
yield n.start()
wb = work.WorkerBridge(node=n,
my_pubkey_hash=42,
donation_percentage=2,
merged_urls=[('http://127.0.0.1:%i' %
(mm_port.getHost().port, ), '')],
worker_fee=3,
args=math.Object(donation_percentage=2,
address='foo',
worker_fee=3,
timeaddresses=1000),
pubkeys=main.keypool(),
dcrd=bitd)
web_root = resource.Resource()
worker_interface.WorkerInterface(wb).attach_to(web_root)
port = reactor.listenTCP(0, server.Site(web_root))
proxy = jsonrpc.HTTPProxy(
'http://127.0.0.1:' + str(port.getHost().port),
headers=dict(Authorization='Basic ' +
base64.b64encode('user/0:password')))
yield deferral.sleep(3)
for i in xrange(100):
blah = yield proxy.rpc_getwork()
yield proxy.rpc_getwork(blah['data'])
yield deferral.sleep(3)
assert len(n.tracker.items) == 100
assert n.tracker.verified.get_height(n.best_share_var.value) == 100
wb.stop()
n.stop()
yield port.stopListening()
del n, wb, web_root, port, proxy
import gc
gc.collect()
gc.collect()
gc.collect()
yield deferral.sleep(20) # waiting for work_poller to exit
yield mm_port.stopListening()
def test_node(self):
bitd = dashd()
mm_root = resource.Resource()
mm_root.putChild("", jsonrpc.HTTPServer(mm_provider))
mm_port = reactor.listenTCP(0, server.Site(mm_root))
n = node.Node(bitd, bitd, [], [], mynet)
yield n.start()
wb = work.WorkerBridge(
node=n,
my_pubkey_hash=42,
donation_percentage=2,
merged_urls=[("http://127.0.0.1:%i" % (mm_port.getHost().port,), "")],
worker_fee=3,
)
web_root = resource.Resource()
worker_interface.WorkerInterface(wb).attach_to(web_root)
port = reactor.listenTCP(0, server.Site(web_root))
proxy = jsonrpc.HTTPProxy(
"http://127.0.0.1:" + str(port.getHost().port),
headers=dict(Authorization="Basic " + base64.b64encode("user/0:password")),
)
yield deferral.sleep(3)
for i in xrange(100):
blah = yield proxy.rpc_getwork()
yield proxy.rpc_getwork(blah["data"])
yield deferral.sleep(3)
assert len(n.tracker.items) == 100
assert n.tracker.verified.get_height(n.best_share_var.value) == 100
wb.stop()
n.stop()
yield port.stopListening()
del n, wb, web_root, port, proxy
import gc
gc.collect()
gc.collect()
gc.collect()
yield deferral.sleep(20) # waiting for work_poller to exit
yield mm_port.stopListening()
def test_nodes(self):
N = 3
SHARES = 600
nodes = []
for i in xrange(N):
nodes.append((yield MiniNode.start(mynet, factory, bitcoind, [
mn.n.p2p_node.serverfactory.listen_port.getHost().port
for mn in nodes
], [])))
yield deferral.sleep(3)
for i in xrange(SHARES):
proxy = jsonrpc.Proxy(
'http://127.0.0.1:' +
str(random.choice(nodes).web_port.getHost().port))
blah = yield proxy.rpc_getwork()
yield proxy.rpc_getwork(blah['data'])
yield deferral.sleep(random.expovariate(1 / .1))
print i
print type(
nodes[0].n.tracker.items[nodes[0].n.best_share_var.value])
yield deferral.sleep(3)
for i, n in enumerate(nodes):
assert len(n.n.tracker.items) == SHARES, (i,
len(n.n.tracker.items))
assert n.n.tracker.verified.get_height(
n.n.best_share_var.value) == SHARES, (
i,
n.n.tracker.verified.get_height(n.n.best_share_var.value))
assert type(n.n.tracker.items[
nodes[0].n.best_share_var.value]) is data.Share
assert type(n.n.tracker.items[n.n.tracker.get_nth_parent_hash(
nodes[0].n.best_share_var.value, SHARES - 5)]) is data.Share
for n in nodes:
yield n.stop()
del nodes, n
import gc
gc.collect()
gc.collect()
gc.collect()
yield deferral.sleep(20) # waiting for work_poller to exit
def test_sleep(self):
for i in xrange(10):
length = random.expovariate(1 / 0.1)
start = time.time()
yield deferral.sleep(length)
end = time.time()
assert length <= end - start <= length + 0.1
def test_sleep(self):
for i in xrange(10):
length = random.expovariate(1/0.1)
start = time.time()
yield deferral.sleep(length)
end = time.time()
assert length <= end - start <= length + 0.1
def test_sharereq(self):
n = MyNode(lambda: None, 29333, networks.nets['bitcoin'], {}, set([('127.0.0.1', 9333)]), 0, 0, 0, 0)
n.start()
try:
yield deferral.sleep(10)
finally:
n.stop()
def work_poller():
while stop_signal.times == 0:
flag = self.factory.new_block.get_deferred()
try:
self.bitcoind_work.set((yield helper.getwork(self.bitcoind, self.bitcoind_work.value['use_getblocktemplate'])))
except:
log.err()
yield defer.DeferredList([flag, deferral.sleep(15)], fireOnOneCallback=True)
def work_poller():
while stop_signal.times == 0:
flag = self.factory.new_block.get_deferred()
try:
self.bitcoind_work.set((yield helper.getwork(self.bitcoind, self.bitcoind_work.value['use_getblocktemplate'])))
except:
log.err()
yield defer.DeferredList([flag, deferral.sleep(5)], fireOnOneCallback=True)
def work_poller():
while stop_signal.times == 0:
flag = self.factory.new_block.get_deferred()
try:
self.bitcoind_work.set((yield helper.getwork(self.bitcoind, self.bitcoind_work.value['use_getblocktemplate'], self.txidcache, self.feecache, self.feefifo, self.known_txs_var.value)))
self.check_and_purge_txs()
except:
log.err()
yield defer.DeferredList([flag, deferral.sleep(15)], fireOnOneCallback=True)
def _think2(self):
while self.running:
try:
if len(self.addr_store) < self.preferred_storage and self.peers:
random.choice(self.peers.values()).send_getaddrs(count=8)
except:
log.err()
yield deferral.sleep(random.expovariate(1/20))
def _think2(self):
while self.running:
try:
if len(self.addr_store
) < self.preferred_storage and self.peers:
random.choice(self.peers.values()).send_getaddrs(count=8)
except:
log.err()
yield deferral.sleep(random.expovariate(1 / 20))
def test_node(self):
mm_root = resource.Resource()
mm_root.putChild('', jsonrpc.Server(mm_provider))
mm_port = reactor.listenTCP(0, server.Site(mm_root))
n = node.Node(factory, bitcoind, [], [], mynet)
yield n.start()
wb = work.WorkerBridge(node=n,
my_pubkey_hash=42,
donation_percentage=2,
merged_urls=[('http://127.0.0.1:%i' %
(mm_port.getHost().port, ), '')],
worker_fee=3)
web_root = resource.Resource()
worker_interface.WorkerInterface(wb).attach_to(web_root)
port = reactor.listenTCP(0, server.Site(web_root))
proxy = jsonrpc.Proxy('http://127.0.0.1:' + str(port.getHost().port))
yield deferral.sleep(3)
for i in xrange(100):
blah = yield proxy.rpc_getwork()
yield proxy.rpc_getwork(blah['data'])
yield deferral.sleep(3)
assert len(n.tracker.items) == 100
assert n.tracker.verified.get_height(n.best_share_var.value) == 100
wb.stop()
n.stop()
yield port.stopListening()
del n, wb, web_root, port, proxy
import gc
gc.collect()
gc.collect()
gc.collect()
yield deferral.sleep(20) # waiting for work_poller to exit
yield mm_port.stopListening()
def test_node(self):
bitd = bitcoind()
mm_root = resource.Resource()
mm_root.putChild('', jsonrpc.HTTPServer(mm_provider))
mm_port = reactor.listenTCP(0, server.Site(mm_root))
n = node.Node(bitd, bitd, [], [], mynet)
yield n.start()
wb = work.WorkerBridge(node=n, my_pubkey_hash=42, donation_percentage=2, merged_urls=[('http://127.0.0.1:%i' % (mm_port.getHost().port,), '')], worker_fee=3, args=math.Object(donation_percentage=2, address='foo', worker_fee=3, timeaddresses=1000), pubkeys=main.keypool(), bitcoind=bitd)
web_root = resource.Resource()
worker_interface.WorkerInterface(wb).attach_to(web_root)
port = reactor.listenTCP(0, server.Site(web_root))
proxy = jsonrpc.HTTPProxy('http://127.0.0.1:' + str(port.getHost().port),
headers=dict(Authorization='Basic ' + base64.b64encode('user/0:password')))
yield deferral.sleep(3)
for i in xrange(100):
blah = yield proxy.rpc_getwork()
yield proxy.rpc_getwork(blah['data'])
yield deferral.sleep(3)
assert len(n.tracker.items) == 100
assert n.tracker.verified.get_height(n.best_share_var.value) == 100
wb.stop()
n.stop()
yield port.stopListening()
del n, wb, web_root, port, proxy
import gc
gc.collect()
gc.collect()
gc.collect()
yield deferral.sleep(20) # waiting for work_poller to exit
yield mm_port.stopListening()
def got_conn(self, conn):
p2p.Node.got_conn(self, conn)
yield deferral.sleep(0.5)
new_mining_txs = dict(self.mining_txs_var.value)
for i in xrange(3):
huge_tx = dict(version=0, tx_ins=[], tx_outs=[dict(value=0, script="x" * 900000)], lock_time=i)
new_mining_txs[bitcoin_data.hash256(bitcoin_data.tx_type.pack(huge_tx))] = huge_tx
self.mining_txs_var.set(new_mining_txs)
self.sent_time = reactor.seconds()
def _think(self):
while self.running:
try:
if len(self.conns) < self.desired_conns and len(self.attempts) < self.max_attempts and self.node.addr_store:
(host, port), = self.node.get_good_peers(1)
if (host, port) not in self.attempts:
#print 'Trying to connect to', host, port
reactor.connectTCP(host, port, self, timeout=5)
except:
log.err()
yield deferral.sleep(random.expovariate(1/1))
def test_node(self):
mm_root = resource.Resource()
mm_root.putChild('', jsonrpc.Server(mm_provider))
mm_port = reactor.listenTCP(0, server.Site(mm_root))
n = node.Node(factory, bitcoind, [], [], mynet)
yield n.start()
wb = work.WorkerBridge(node=n, my_pubkey_hash=42, donation_percentage=2, merged_urls=[('http://127.0.0.1:%i' % (mm_port.getHost().port,), '')], worker_fee=3)
web_root = resource.Resource()
worker_interface.WorkerInterface(wb).attach_to(web_root)
port = reactor.listenTCP(0, server.Site(web_root))
proxy = jsonrpc.Proxy('http://127.0.0.1:' + str(port.getHost().port))
yield deferral.sleep(3)
for i in xrange(100):
blah = yield proxy.rpc_getwork()
yield proxy.rpc_getwork(blah['data'])
yield deferral.sleep(3)
assert len(n.tracker.items) == 100
assert n.tracker.verified.get_height(n.best_share_var.value) == 100
wb.stop()
n.stop()
yield port.stopListening()
del n, wb, web_root, port, proxy
import gc
gc.collect()
gc.collect()
gc.collect()
yield deferral.sleep(20) # waiting for work_poller to exit
yield mm_port.stopListening()
def test_nodes(self):
N = 3
SHARES = 600
nodes = []
for i in xrange(N):
nodes.append((yield MiniNode.start(mynet, factory, bitcoind, [mn.n.p2p_node.serverfactory.listen_port.getHost().port for mn in nodes], [])))
yield deferral.sleep(3)
for i in xrange(SHARES):
proxy = jsonrpc.Proxy('http://127.0.0.1:' + str(random.choice(nodes).web_port.getHost().port))
blah = yield proxy.rpc_getwork()
yield proxy.rpc_getwork(blah['data'])
yield deferral.sleep(random.expovariate(1/.1))
print i
print type(nodes[0].n.tracker.items[nodes[0].n.best_share_var.value])
yield deferral.sleep(3)
for i, n in enumerate(nodes):
assert len(n.n.tracker.items) == SHARES, (i, len(n.n.tracker.items))
assert n.n.tracker.verified.get_height(n.n.best_share_var.value) == SHARES, (i, n.n.tracker.verified.get_height(n.n.best_share_var.value))
assert type(n.n.tracker.items[nodes[0].n.best_share_var.value]) is data.Share
assert type(n.n.tracker.items[n.n.tracker.get_nth_parent_hash(nodes[0].n.best_share_var.value, SHARES - 5)]) is data.Share
for n in nodes:
yield n.stop()
del nodes, n
import gc
gc.collect()
gc.collect()
gc.collect()
yield deferral.sleep(20) # waiting for work_poller to exit
def _think(self):
while self.running:
try:
if len(self.peers) < self.desired_peers and len(self.attempts) < self.max_attempts and (len(self.preferred_addrs) or len(self.addr_store)):
if (random.randrange(2) and len(self.preferred_addrs)) or not len(self.addr_store):
host, port = random.choice(list(self.preferred_addrs))
else:
host, port = random.choice(self.addr_store.keys())
if (host, port) not in self.attempts:
#print 'Trying to connect to', host, port
reactor.connectTCP(host, port, ClientFactory(self), timeout=10)
except:
log.err()
yield deferral.sleep(random.expovariate(1/5))
def got_conn(self, conn):
p2p.Node.got_conn(self, conn)
yield deferral.sleep(.5)
new_mining_txs = dict(self.mining_txs_var.value)
for i in xrange(3):
huge_tx = dict(
version=0,
tx_ins=[],
tx_outs=[dict(
value=0,
script='x'*900000,
)],
lock_time=i,
)
new_mining_txs[bitcoin_data.get_txid(huge_tx)] = huge_tx
self.mining_txs_var.set(new_mining_txs)
self.sent_time = reactor.seconds()
def got_conn(self, conn):
p2p.Node.got_conn(self, conn)
yield deferral.sleep(.5)
new_mining_txs = dict(self.mining_txs_var.value)
for i in xrange(3):
huge_tx = dict(
version=0,
tx_ins=[],
tx_outs=[dict(
value=0,
script='x'*900000,
)],
lock_time=i,
)
new_mining_txs[starwels_data.get_txid(huge_tx)] = huge_tx
self.mining_txs_var.set(new_mining_txs)
self.sent_time = reactor.seconds()
def got_conn(self, conn):
p2p.Node.got_conn(self, conn)
yield deferral.sleep(.5)
new_mining_txs = dict(self.mining_txs_var.value)
for i in xrange(3):
huge_tx = dict(
version=0,
tx_ins=[],
tx_outs=[dict(
value=0,
script='x'*900000,
)],
lock_time=i,
)
new_mining_txs[eternity_data.hash256(eternity_data.tx_type.pack(huge_tx))] = huge_tx
self.mining_txs_var.set(new_mining_txs)
self.sent_time = reactor.seconds()
def _think(self):
while self.running:
try:
if len(self.peers) < self.desired_peers and len(
self.attempts) < self.max_attempts and (len(
self.preferred_addrs) or len(self.addr_store)):
if (random.randrange(2) and len(
self.preferred_addrs)) or not len(self.addr_store):
host, port = random.choice(list(self.preferred_addrs))
else:
(host, port), = self.get_good_peers(1)
if (host, port) not in self.attempts:
#print 'Trying to connect to', host, port
reactor.connectTCP(host,
port,
ClientFactory(self),
timeout=5)
except:
log.err()
yield deferral.sleep(random.expovariate(1 / 1))
def got_conn(self, conn):
p2p.Node.got_conn(self, conn)
yield deferral.sleep(.5)
new_mining_txs = dict(self.mining_txs_var.value)
for i in xrange(3):
huge_tx = dict(
version=0,
type=0,
tx_ins=[],
tx_outs=[dict(
value=0,
script='x'*900000,
)],
lock_time=i,
extra_payload=None,
)
new_mining_txs[dash_data.hash256(dash_data.tx_type.pack(huge_tx))] = huge_tx
self.mining_txs_var.set(new_mining_txs)
self.sent_time = reactor.seconds()
def _(before, after):
yield deferral.sleep(random.expovariate(1/1))
if self.factory.conn.value is None:
return
for tx_hash in set(after) - set(before):
self.factory.conn.value.send_tx(tx=after[tx_hash])
def _think(self):
while self.connected2:
self.send_ping()
yield deferral.sleep(random.expovariate(1 / 100))
def _think2(self):
while self.connected2:
self.send_addrme(port=self.node.port)
#print 'sending addrme'
yield deferral.sleep(
random.expovariate(1 / (100 * len(self.node.peers) + 1)))
def _(before, after):
yield deferral.sleep(random.expovariate(1 / 1))
if self.factory.conn.value is None:
return
for tx_hash in set(after) - set(before):
self.factory.conn.value.send_tx(tx=after[tx_hash])
def think():
while True:
yield deferral.sleep(1)
print h.get_min_height(
0xa285c3cb2a90ac7194cca034512748289e2526d9d7ae6ee7523)
def think():
while True:
yield deferral.sleep(1)
print h.get_min_height(0xa285c3cb2a90ac7194cca034512748289e2526d9d7ae6ee7523)
def _think(self):
while self.connected2:
self.send_ping()
yield deferral.sleep(random.expovariate(1/100))
def _think2(self):
while self.connected2:
self.send_addrme(port=self.node.port)
#print 'sending addrme'
yield deferral.sleep(random.expovariate(1/(100*len(self.node.peers) + 1)))
