import math
import random
+import sys
import time
from twisted.internet import defer, protocol, reactor
try:
return f(**kwargs)
except p2protocol.TooLong:
- att(f, **dict((k, v[:len(v)//2]) for k, v in kwargs.iteritems()))
- return att(f, **dict((k, v[len(v)//2:]) for k, v in kwargs.iteritems()))
+ fragment(f, **dict((k, v[:len(v)//2]) for k, v in kwargs.iteritems()))
+ return fragment(f, **dict((k, v[len(v)//2:]) for k, v in kwargs.iteritems()))
class Protocol(p2protocol.Protocol):
max_remembered_txs_size = 2500000
self.addr = self.transport.getPeer().host, self.transport.getPeer().port
self.send_version(
- version=4,
+ version=8,
services=0,
addr_to=dict(
services=0,
self.remembered_txs = {} # view of peer's mining_txs
self.remembered_txs_size = 0
+ self.known_txs_cache = {}
def _connect_timeout(self):
self.timeout_delayed = None
if best_share_hash is not None:
self.node.handle_share_hashes([best_share_hash], self)
+ if self.other_version < 8:
+ return
+
def update_remote_view_of_my_known_txs(before, after):
added = set(after) - set(before)
removed = set(before) - set(after)
self.send_have_tx(tx_hashes=list(added))
if removed:
self.send_losing_tx(tx_hashes=list(removed))
- # XXX cache locally
+
+ # cache forgotten txs here for a little while so latency of "losing_tx" packets doesn't cause problems
+ key = max(self.known_txs_cache) + 1 if self.known_txs_cache else 0
+ self.known_txs_cache[key] = dict((h, before[h]) for h in removed)
+ reactor.callLater(20, self.known_txs_cache.pop, key)
watch_id = self.node.known_txs_var.transitioned.watch(update_remote_view_of_my_known_txs)
self.connection_lost_event.watch(lambda: self.node.known_txs_var.transitioned.unwatch(watch_id))
assert self.remote_remembered_txs_size <= self.max_remembered_txs_size
fragment(self.send_remember_tx, tx_hashes=[x for x in added if x in self.remote_tx_hashes], txs=[after[x] for x in added if x not in self.remote_tx_hashes])
if removed:
- self.send_forget_tx(tx_hashes=removed)
+ self.send_forget_tx(tx_hashes=list(removed))
self.remote_remembered_txs_size -= sum(len(bitcoin_data.tx_type.pack(before[x])) for x in removed)
watch_id2 = self.node.mining_txs_var.transitioned.watch(update_remote_view_of_my_mining_txs)
self.connection_lost_event.watch(lambda: self.node.mining_txs_var.transitioned.unwatch(watch_id2))
if not shares:
return defer.succeed(None)
- tx_hashes = set()
- for share in shares:
- if share.hash in include_txs_with:
- tx_hashes.update(share.get_other_tx_hashes(tracker))
-
- hashes_to_send = [x for x in tx_hashes if x not in self.node.mining_txs_var.value and x in known_txs]
-
- new_remote_remembered_txs_size = self.remote_remembered_txs_size + sum(len(bitcoin_data.tx_type.pack(known_txs[x])) for x in hashes_to_send)
- if new_remote_remembered_txs_size > self.max_remembered_txs_size:
- raise ValueError('shares have too many txs')
- self.remote_remembered_txs_size = new_remote_remembered_txs_size
-
- fragment(self.send_remember_tx, tx_hashes=[x for x in hashes_to_send if x in self.remote_tx_hashes], txs=[known_txs[x] for x in hashes_to_send if x not in self.remote_tx_hashes])
- fragment(self.send_shares, shares=[share.as_share() for share in shares])
- res = self.send_forget_tx(tx_hashes=hashes_to_send)
-
- self.remote_remembered_txs_size -= sum(len(bitcoin_data.tx_type.pack(known_txs[x])) for x in hashes_to_send)
+ if self.other_version >= 8:
+ tx_hashes = set()
+ for share in shares:
+ if share.hash in include_txs_with:
+ tx_hashes.update(share.get_other_tx_hashes(tracker))
+
+ hashes_to_send = [x for x in tx_hashes if x not in self.node.mining_txs_var.value and x in known_txs]
+
+ new_remote_remembered_txs_size = self.remote_remembered_txs_size + sum(len(bitcoin_data.tx_type.pack(known_txs[x])) for x in hashes_to_send)
+ if new_remote_remembered_txs_size > self.max_remembered_txs_size:
+ raise ValueError('shares have too many txs')
+ self.remote_remembered_txs_size = new_remote_remembered_txs_size
+
+ fragment(self.send_remember_tx, tx_hashes=[x for x in hashes_to_send if x in self.remote_tx_hashes], txs=[known_txs[x] for x in hashes_to_send if x not in self.remote_tx_hashes])
+
+ res = fragment(self.send_shares, shares=[share.as_share() for share in shares])
+
+ if self.other_version >= 8:
+ res = self.send_forget_tx(tx_hashes=hashes_to_send)
+
+ self.remote_remembered_txs_size -= sum(len(bitcoin_data.tx_type.pack(known_txs[x])) for x in hashes_to_send)
return res
('tx_hashes', pack.ListType(pack.IntType(256))),
])
def handle_have_tx(self, tx_hashes):
+ assert self.remote_tx_hashes.isdisjoint(tx_hashes)
self.remote_tx_hashes.update(tx_hashes)
message_losing_tx = pack.ComposedType([
('tx_hashes', pack.ListType(pack.IntType(256))),
])
def handle_losing_tx(self, tx_hashes):
+ assert self.remote_tx_hashes.issuperset(tx_hashes)
self.remote_tx_hashes.difference_update(tx_hashes)
])
def handle_remember_tx(self, tx_hashes, txs):
for tx_hash in tx_hashes:
- if tx_hash not in self.remembered_txs:
- self.remembered_txs[tx_hash] = self.node.known_txs_var.value[tx_hash]
- self.remembered_txs_size += len(bitcoin_data.tx_type.pack(self.node.known_txs_var.value[tx_hash]))
+ if tx_hash in self.remembered_txs:
+ print >>sys.stderr, 'Peer referenced transaction twice, disconnecting'
+ self.transport.loseConnection()
+ return
+
+ if tx_hash in self.node.known_txs_var.value:
+ tx = self.node.known_txs_var.value[tx_hash]
+ else:
+ for cache in self.known_txs_cache.itervalues():
+ if tx_hash in cache:
+ tx = cache[tx_hash]
+ print 'Transaction rescued from peer latency cache!'
+ break
+ else:
+ print >>sys.stderr, 'Peer referenced unknown transaction, disconnecting'
+ self.transport.loseConnection()
+ return
+
+ self.remembered_txs[tx_hash] = tx
+ self.remembered_txs_size += len(bitcoin_data.tx_type.pack(tx))
new_known_txs = dict(self.node.known_txs_var.value)
+ warned = False
for tx in txs:
tx_hash = bitcoin_data.hash256(bitcoin_data.tx_type.pack(tx))
- if tx_hash not in self.remembered_txs:
- self.remembered_txs[tx_hash] = tx
- self.remembered_txs_size += len(bitcoin_data.tx_type.pack(tx))
+ if tx_hash in self.remembered_txs:
+ print >>sys.stderr, 'Peer referenced transaction twice, disconnecting'
+ self.transport.loseConnection()
+ return
+
+ if tx_hash in self.node.known_txs_var.value and not warned:
+ print 'Peer sent entire transaction that was already received'
+ warned = True
+
+ self.remembered_txs[tx_hash] = tx
+ self.remembered_txs_size += len(bitcoin_data.tx_type.pack(tx))
new_known_txs[tx_hash] = tx
self.node.known_txs_var.set(new_known_txs)
if self.remembered_txs_size >= self.max_remembered_txs_size: