New computational tools are creating transactional spaces with boundaries defined by cryptography. The operation of these new "crypto" spaces is increasingly at odds with the traditional institutional tools for governing transactions.
Common law legal contracts are more flexible than many people know. We can take advantage of this flexibility to "contract out" of unproductive legal defaults and reduce the tension between the systems.
In the following article we propose a simple idea and enumerate the implications.
Smart contract code is the canonical description of the rights and obligations of transaction parties except to the extent that the legal system alters them compulsorily.
When a lawyer drafts legal wrappers for smart contracts, they often look for ways to fit the smart contract into existing legal concepts. We think that’s a mistake.
If we want better smart contracting to develop, we shouldn't define how the smart contract works by reference to legal concepts because:
The way to do this is to “separate the concerns” of crypto and law, which is to say, reduce the overlap of what the systems deal with as much as possible.
In the OSI Model (Open Systems Interconnection Model) used to run the Internet, there’s an engineering separation of concerns between:
In this system:
The functional layers are ignorant of each other except to the extent that they:
We think an OSI-like-model applied to smart contracting looks like this:
By using layer separation to govern the interaction of smart contracts and the legal system we allow each system to operate in their own internally consistent ways without having to attempt to reconcile the fundamental inconsistencies between them.
If we take this approach:
Consistent with the ideas above, here’s an attempt to define the principle for how the legal wrapper “understands” input from the crypto layer above.
Smart contract code is the canonical description of the transaction except to the extent that the legal system is unavoidable.
A further idea follows.
Where the legal system is unavoidable, traditional contracting between the parties should be used to improve the operation of the legal system where possible.
So, for the purposes of the legal wrapper, the outcome of the code’s operation (as distinct from the intent expressed by the code in writing) is agreed to represent the intent of the parties unless a legal system intervenes unavoidably, whereupon, to the fullest extent available under the law:
Here are some other ideas for topics to address in the legal wrapper for specific types of transaction.
There’s a good technical analogy for the emergent dynamic we’re looking for here.
In an "optimistic user interface", the client side of an application assumes a user action on the client side is valid, so it shows the user action result to the user before a round trip to the server to check the user action validity with trusted code.
This dynamic creates a better user experience because the user interface is not blocked by the time taken for server validation.
The rationale for this approach is that the overwhelming majority of user actions will be valid and there are ways to reverse the outcome if they aren’t, so why wait for the server round trip?
We see the operation of blockchain and the legal system similarly.
In our view, the smart contract should “run ahead” unhindered but be followed up by the slow validation / problem solving processes of the legal system.
The views expressed above privilege smart contracts in many ways, but they are not a dismissal of the traditional legal system.
We should still use legal mechanisms to regulate non-blockchain entities. Like people, for instance. Over time we think smart code systems will regulate people with incentives rather than legal compulsion, but in the interim, there’s a role to play.
There are a few well publicised examples of DAOs voting for developers to do things and those developers not following the vote. It was a mistake to have the mechanism to begin with. Code doesn't regulate people - that's the domain of the traditional legal system.