Bitcoin issues:

  1. Mining is wasteful (paid to do work, not be useful)
  2. Little/no incentive to run reliable nodes
  3. Verification times are long (blocks come at fix spacing ~10 minutes)
  4. Does not handle large volumes of payments (not good for 1 billion people doing 0.1 cent payments to dozens of web pages a day for example)
  5. Nodes require non-constant space and time (gets harder as more transactions occur)
  6. Nodes must receive ans store all blocks (Lots of bandwidth!)

Bitcoin gets its trust via proof of work. This work however is not otherwise useful, its simply busy work (mining). They do collect and process some transactions, which they are compensated for (via transaction fees), but that work is easily dominated by the busy work of solving blocks (mining). This is the intention of the design.

Bitcoin nodes, which collect, share, process and log all transactions get no reward, other than knowing the transaction history and being able to validate transactions.

My Idea

First, this design is no where near ready for any attempt at implementation: the details are not worked out and it very well might be inherently vulnerable to many attacks. Bitcoin as is actually works and is quite safe and stable.

Suppose instead of mining, the rewards were given to nodes based on how well they served the network. Well connected high availability low latency nodes that detect double spend attacks the fastest, and tend to agree with the rest of the network (ex: in the case of a double spend, they tend to choose the transaction thats eventually accepted, and do so early) would be compensated. The idea is to reward nodes financially for being useful.

Nodes that perform well, and can be trusted (because they lose money if if they violate that trust) effectively reduce the amount of time it takes the network to verify transactions. In addition to this, having some trust involved allows thin clients to work, which is important for scaling.

Instead of a block-chain I suggest a DAG. Each node in the DAG would represent all transactions from its parents (recursively) as well as a set of transactions included in it. In this respect, a given node in the DAG is equivalent to a node in the block-chain. The key difference is that there is no competition to get the one accepted block, instead multiple (as long as they are non-conflicting) node may be accepted. Deduplication of shared histories can be employed to make the storage used similar to the block chain model.


DAG Node
A node in the block DAG contain transactions, and including transactions from its parents recursively
Worker Node
A server (or multiple servers) which produce DAG Nodes. Formally, the Worker node is an entity that signs DAG nodes.

For this to work, DAG nodes need some measure of usefulness+trustworthiness (lets call this "Quality"). To do this, when forming DAG nodes, the worker nodes can credit the parent nodes based on quality. After some time, worker nodes can take credit for their DAG Nodes and attempt to pay themselves for their work. Other worker nodes can accept, reject or simply omit this attempted special transaction. Worker Nodes may communicate with other Worker nodes and negotiate hoe much they will be able to pay them selves (this can not be prevented, and should be considered useful).

The key here is that Worker Nodes are allowed to employ what ever heuristics they wish to rate other nodes. After a significant amount of time (and thus a significant investment) they have a significant amount of potential pending payout on the line. Loss of this investment is intended to be the discouragement for nodes behaving badly. Fortunately, like in bitcoin, the amount of harm a node can do is pretty limited.

Resisting/avoiding block spamming: Spamming tons of redundant and/or small nodes is counter productive (bloats history metadata). If this is done by a small number (or 1) worker node, the fix is simply to consider their nodes low quality (not useful), and not include them. If they contain some new transactions (and even parents or parents transactions), those can be copied out and included in the other worker's nodes which nets the abusing nodes nothing. This allows merging/removing/ignoring of DAG nodes who's usefulness/quality is less than the cost incurred by bloating nodes with their metadata. Operating a worker node is only profitable if this does not happen to your DAG nodes.

Resisting ignoring other nodes: A worker node could produce a DAG that consisted entirely out of DAG nodes it (and/or its co-conspirators) created/signed. To resist this, users and worker Nodes need to favor well connected DAG nodes: they are more trust worthy and thus more useful and should be favored. Having higher quality parent nodes should cause nodes that have your node as a parent to score it higher. Nodes that score their parent's quality in a believable way should get higher quality scores. Worker nodes, if desired can apply their quality heuristics as deep recursively as desired.

Thus, low latency highly connected non redundant DAG nodes with quality ratings that tend to be accurate will end up paying out the most.

The fees from transactions and created coins goes into a pool which can attempt to be claimed by worker nodes. If they claim less than they deserve, and wait a long enough time for their service to be useful (under threat of losing their investment), they are more likable to have that accepted.

It could even be possible to allow nodes to inflate their risk (which they will no be able to recover if they act badly and thus are opposed by the network) by explicitly paying into the fees pool (make a special 100% fee transaction from their DAG signature address). This might earn them more trust and thus higher quality and more income.

The idea is that worker nodes have an investment for their recent service, which if they provide quality service can cache out, and if they provide low quality or abusive service, will lose. Worker node flooding will either produce low quality nodes and no income, or quality service to the network and corresponding payout. Producing quality nodes that then turn malicious after acquiring trust will lose their pending investment, and not really gain anything. Thats the goal anyway, I'm sure their are exploits.

In this model, thin client users can act as low quality worker nodes: they put their transactions into trivially small DAG nodes and send them off to workers of their choice which will likely merge the node, but could also use it as a parent.

Copyright © 2011-2013 Craig Macomber