When we request at startup the blocks from a seed which has not yet
received out capabilities or node address we will not get a response.
We do not want to depend on the state in the getData domain in the
p2p network by using only a seed which has already responded but we
prefer to make sure the seednode will get all the data by our request
to be able to respond.
- Check if conflicting node is seed node or not. Show info in list entry
and only show resync button and red color in text if conflict is with
seed node.
- At resync move all p2p network data to a dedicated directory so they
will be reloaded from the seeds.
We don't want to break consensus and persisted data at current
dao_regtest by removing the date now. It is not used anywhere so it is
irrelevant but would break things as the hash would be different and
persisted data would not be readable anymore. So we delay that change
to the mainnet launch.
In case of an invalid tx we burn all available BSQ input. We only know
that at parsing time. We renamed the burntFee field to burntBsq to make
it more generic and use it for the burnt fee in case if a normal tx and
as invalidatedBsq in case of an invalid tx.
We don't want to burn BSQ in cases like that the tx was published too
late, which is a valid case if the tx does not make it in the next block.
We set such txs as IRREGULAR and allow spending of the BSQ, but there
function in the governance is invalidated.
We also add a check if the sum of all UTXO is the same as the sum of the
genesis + sum of issuance txs - burned fees.
We can evaluate the nonBsqTxOutputs without storing it.
Storing them in the map would have required to remove them as well
once withdrawn from the wallet.
To avoid the need to change the required bond in the BondedRoleType
if the BSQ price changes we use the BONDED_ROLE_FACTOR param where the
factor can be changed. In the BondedRoleType we use the requiredBondUnit
which will be multiplied with the BONDED_ROLE_FACTOR value to get the
required bond amount.
In some tests it seemed that SHA3-256 is 30% fast than SHA256 but later
with the data we used in dao testnet it was actually slower.
To avoid confusion which hash function to use and to avoid mixing them
without strong reason I prefer to remove it again.
- Move dao state monitor classes to other package structure
- Add support for proposal payload monitor (WIP)
- Use generics and sub classes for common functionality
- Add hashChain to snapshot
- Use TreeMap instead of Map to have deterministic order
- Use eventCoordinator to make correct order of execution transparent
- Fix missing applying of nonBsqTxOutputMap at applySnapshot
Refactor dao state monitor domain.
Add support for requesting all hashed from genesis from a peer which is
in conflict (can help to find at which block the issue started).
At Capabilities I got an exception after going back from a new dev
branch to master and getting p2p network data from nodes still running
on the dev branch as that newly added capability was outside of the
existing scope.
I found another potential issue with DaoPhase.Phase and added a check
there as well.
We create a chain of hashes of the dao state starting from the genesis
block height and using the previous hash in the hash. This ensures that
the history need to be correct if a particular hash at a block height is
correct. We request from seed nodes the last 10 hashes and broadcast to
our peers our hash at each new block. We build our list in memory and
listen on the new onSnapShotApplied event to start building our chain
from the genesis height up to the last snapshot block and after that
from each parsed block.
If we detect a mismatch we store it in a collection and the UI can show
a warning to the user.
We added also the onDaoStateChanged handler to the DaoStateListener.
This event is called after all parsing is completed and listeners have
completed their work. We must not use time based delays in the listener
code otherwise we would get changed our dao state after that event.
To detect such we added a assert method to throw an exception if the
dao state gets changed after the allowDaoStateChange is set to false.
