kernel-community / honour Goto Github PK

Ideally, we'd want to pop up a modal before Honouring any Proposal, or Accepting any Forgiveness.

This modal must explain that you balance is equivalent to your creditworthiness (higher balance == less creditworthy) and that your transaction history is equivalent to your trustworthiness.

Therefore, you don't want to honour proposals that put you too much in debt, nor do you want to honour proposals from accounts that have 'strange' transactions in their history. You also don't want to just accept Forgiveness from a random account (even if they offer a lot of forgiveness) because this would make your own account look suspicious.

This raises the question: "what is strange?" That is, what kinds of transactions in a given history make an account "suspicious".

My hunch is that it is largely contextual. There are some big giveaways though:

1. Taking on large debt only to forgive large amounts to a "botnet" like shape of inter-related accounts (i.e. dense interconnections, not many connections to other accounts outside the net)
2. Sudden forgiveness of a large debt from an account that the forgiven account has not interacted with before.

That said, how do "botnets" differ from local trade in a tight network of friends? Is there a way to reliably discern between the two. This gets us to:

3. Large transaction volume relative to the rest of the network (local groups are not likely to exchange more than once or twice a day at most).

So, in building our "trust model", we're looking at anomalous transactions (where anomalous == sudden change in relative magnitude of transaction size, either honouring - taking on debt - or forigiving - removing the debt of others) and anomalous transaction volumes.

For a v1, I think that simply putting up a modal which displays the transaction history of the proposer of the forgiver, before anyone either honours or accepts a given transaction is a good start. However, we will definitely need to do more to make it easy and intuitive for people to decide upon trustworthiness when interacting via HON.

You can't forgive someone more than your current balance, and you can't forgive them more than their current balance.

Check this before allowing people to sign a tx which then fails.

We don't need such a fancy execution button, yet our ErrorModal currently depends on it.

The ErrorModal is triggered if, for instance, someone rejects a transaction when asked to sign for it. So we do use it in the app: we can just strip out all other leftovers in the ExecutionButton.js file (prob remove the whole file and put the limited functionality we need directly into ErrorModal.js itself).

Currently, there is no good way to figure out if a given proposal has been honoured, or if a given forgiveness has been accepted.

This is complicated further by the fact that honour() accepts an amount param (as there is a case to be made that I might wish to accept this obligation from you, but not one you previously tried to create which I don't agree to). However, accept() simply accepts whatever forgiveness is in the mapping, because there is no reason not to accept all forgiveness offered to you.

Currently, I am removing proposals which have honours that match the proposer and the amount. Obviously, this will cause issues down the line where the same account proposes the same amount to me multiple times.

Moreover, when filtering the forgives we show to the user, we will likely need to collaps all forgives from the same address into one row, and then somehow make sure that row doesn't appear again once accepted (yet new rows from the same account will appear if new forgiveness has been offered).

All in all, it's quite the story...