Fields

• peerTxStates :: !(Map peeraddr (PeerTxState txid tx))

  Map of peer states.

  Invariant: for peeraddr's which are registered using withPeer, there's always an entry in this map even if the set of txids is empty.

• inflightTxs :: !(Map txid Int)

  Set of transactions which are in-flight (have already been requested) together with multiplicities (from how many peers it is currently in-flight)

  This set can intersect with availableTxIds.

• inflightTxsSize :: !SizeInBytes

  Overall size of all txs in-flight.

• bufferedTxs :: !(Map txid (Maybe tx))

  Map of tx which:

  • were downloaded and added to the mempool,
  • are already in the mempool (Nothing is inserted in that case),

  We only keep live txid, e.g. ones which txid is unacknowledged by at least one peer or has a timedTxs entry.

  Note: txids which tx were unknown by a peer are tracked separately in unknownTxs.

  Note: previous implementation also needed to explicitly track txids which were already acknowledged, but are still unacknowledged. In this implementation, this is done using reference counting.

  This map is useful to acknowledge txids, it's basically taking the longest prefix which contains entries in bufferedTxs or unknownTxs.

• referenceCounts :: !(Map txid Int)

  We track reference counts of all unacknowledged and timedTxs txids. Once the count reaches 0, a tx is removed from bufferedTxs.

  The bufferedTx map contains a subset of txid which referenceCounts contains.

  Invariants:

  • the txid count is equal to multiplicity of txid in all unacknowledgedTxIds sequences;
  • Map.keysSet bufferedTxs isSubsetOf Map.keysSet referenceCounts;
  • all counts are positive integers.
• timedTxs :: !(Map Time [txid])

  A set of timeouts for txids that have been added to bufferedTxs after being inserted into the mempool.

  We need these short timeouts to avoid re-downloading a tx. We could acknowledge this txid to all peers, when a peer from another continent presents us it again.

  Every txid entry has a reference count in referenceCounts.

• inSubmissionToMempoolTxs :: !(Map txid Int)

  A set of txids that have been downloaded by a peer and are on their way to the mempool. We won't issue further fetch-requests for TXs in this state. We track these txs to not re-download them from another peer.

  • We subtract from the counter when a given tx is added or rejected by the mempool or do that for all txs in toMempoolTxs when a peer is unregistered.
  • We add to the counter when a given tx is selected to be added to the mempool in pickTxsToDownload.
• peerRng :: !StdGen

  Rng used to randomly order peers

Fields

• unacknowledgedTxIds :: !(StrictSeq txid)

  Those transactions (by their identifier) that the client has told us about, and which we have not yet acknowledged. This is kept in the order in which the client gave them to us. This is the same order in which we submit them to the mempool (or for this example, the final result order). It is also the order we acknowledge in.

• availableTxIds :: !(Map txid SizeInBytes)

  Set of known transaction ids which can be requested from this peer.

• requestedTxIdsInflight :: !NumTxIdsToReq

  The number of transaction identifiers that we have requested but which have not yet been replied to. We need to track this it keep our requests within the limit on the number of unacknowledged txids.

• requestedTxsInflightSize :: !SizeInBytes

  The size in bytes of transactions that we have requested but which have not yet been replied to. We need to track this to keep our requests within the maxTxsSizeInflight limit.

• requestedTxsInflight :: !(Set txid)

  The set of requested txids.

• unknownTxs :: !(Set txid)

  A subset of unacknowledgedTxIds which were unknown to the peer (i.e. requested but not received). We need to track these txids since they need to be acknowledged.

  We track these txid per peer, rather than in bufferedTxs map, since that could potentially lead to corrupting the node, not being able to download a tx which is needed & available from other nodes.

• score :: !Double

  Score is a metric that tracks how usefull a peer has been. The larger the value the less usefull peer. It slowly decays towards zero.

• scoreTs :: !Time

  Timestamp for the last time score was drained.

• downloadedTxs :: !(Map txid tx)

  A set of TXs downloaded from the peer. They are not yet acknowledged and haven't been sent to the mempool yet.

  Life cycle of entries: * added when a tx is downloaded (see collectTxsImpl) * follows unacknowledgedTxIds (see acknowledgeTxIds)

• toMempoolTxs :: !(Map txid tx)

  A set of TXs on their way to the mempool. Tracked here so that we can cleanup inSubmissionToMempoolTxs if the peer dies.

  Life cycle of entries: * added by acknowledgeTxIds (where decide which txs can be submitted to the mempool) * removed by withMempoolSem

Fields

• txIdsToAck :: Map txid Int