* removed `numTxIdsToRequest` (not used & wrong) * replaced repeated code with a new function `splitAcknowledgedTxIds` * added test for `splitAcknowledgedTxIds`
When we are acknowledging txs we also choose tx-s to be submitted to the mempool. We shouldn't disregard all acknowledged tx-s when we find a first buffered one, instead we can ignore them since they were already successfully submitted to the mempool.
Allow monadic action when trying to pipeline more messages, while collecting responses.
The flag enables an initial 60s delay on the inbound side in the same way as for in the V1 version.
Added tx submission diffusion test-net test. This test checks that even in the presence of a node that keeps disconnecting, but eventually stays online, we manage to learn about all its transactions.
Module structure needs to be reorganised to have just one debug tracer.
Just to make it more outstanding what the output of `acknowledgeTxIds` is indented for.
The property is only satisfied if there are no transaction which advertise wrong size.
* Fixed Show instance for TestAddress: Deriving via Quiet produces a string which is not syntactivly valid Haskell * Show instance for `NodeArgs`: added brackes where needed. * Imports which work when pasting examples (still some imports need to be added). Using `-Wno-unused-imports` though.
- Factored out common type definitions, their generators and properties to a Common.hs file. - Added a TxSubmissionV2 module with the boilerplate to run the new, more accurate submission that uses the V2 version of TxSubmission protocol
Add `max_TX_SIZE` which is shared between * `defaultTxDecisionPolicy`, and * `txSubmissionProtocolLimits`
Export all functions & supporting types.
We don't need to compute `max 0` twice, since the inputs are always non-negative (e.g. `n ≥ 0`) and thus `drained + n ≥ 0`.
There was a race condition between the `decisionLogicThread` producing
a `TxDecision` and an inbound server picking up the most up to date
`TxDecision`. This would lead to the inbound side issuing a blocking request
when the client was awaiting for a non-blocking request. This blocking
request isn't wrong considering the issued decision; it is a legit
decision that's made which leads to the inbound server issuing a
blocking request but because we have received a txid in the meantime and
didn't manage to read it soon enough we didn't create a more important
decision. The fix involved being aware of how many requests for txs we
have in flight and not generate "low priority" policies.
`hasTxIdsToAcknowledge` is not used anywhere in the code so it is
removed.
`filterActivePeers` is improved by making its decision logic more closed
to `pickTxsToDownload`.
`filterActivePeers` test is fixed, since it doesn't hold under the new
logic:
`filterActivePeers` will not compute a decision for peers which have
`requestedTxIdsInflight` and `makeDecisions` computes non-empty decisions
for peers with no `requestedTxIdsInflight`. So:
1. "The set of active peers is a superset of peers for which a decision
was made" this is not true since it is possible that a non active
peer has a legitimate decision, but due to our race-condition
protection condition we just don't generate it.
2. "The set of active peer which can acknowledge txids is a subset of
peers for which a decision was made" this is removed since
hasTxIdsToAcknowledge function is removed
3. "Decisions made from the results of `filterActivePeers` is the same
as from the original set" this isn't true because of what I said
above
So I refactored the test to check that the number of filtered decisions
is a subset of the total number of decisions, which I believe to be a
more accurate test for the current logic