Smart contracts are described as self-executing: how they are formed is how they will be performed. This is why some of us see no (or at least less) room for legal dispute over them.
It shouldn’t be this way. Where it’s efficient, it should be possible to breach a smart contract. Even though this may lead to a legal dispute.
The Implicit Premise
In How Do We Resolve Disputes? I spoke at length about dispute resolution, in the physical world and in cyberspace, and by and for whom, and how. All this was based on one basic premise: there will be legal disputes in the first place.
But is this premise correct?
There are these new kids on the block who, some say, come with the potential to reduce the amount of (or even do away entirely with) legal disputes, at least as far as legal disputes over contracts are concerned. With them, their champions argue, there will be less (or even no) need for the often costly resolution of legal dispute, thus less (or even no) need for the sometimes complicated and time-consuming, at times even impossible, enforcement of such dispute resolution.
They haven’t really made an entrance yet, but it’s like their advance guard has already arrived.
What are smart contracts? In today’s understanding, they’re contracts coded on blockchains, as I’ve touched on when I wrote about smartifying blockchains, legally. There’s a good and more detailed write-up on smart contracts here. In a nutshell, smart contracts facilitate, verify and enact agreements between consenting parties.
Enact as in: self-execute.
Self-executing agreements. This is pacta sunt servanda 2.0. Or: pacta erunt servanda. No longer agreements are to be kept, but agreements will be kept.
Bye Bye, Disputes?
Of course, with an agreement that executes itself, how can there still be room for legal dispute over it, right? How you form it is how you perform it. Or perhaps not?
A thesis like this is based entirely on the understanding of a smart contract as executable code and nothing else. In this understanding, there is room for legal dispute only where it turns out the code isn’t executable, say because it contains critical errors. Seen this way, a legal dispute over unclear contractual terms can only be the result of an abnormal termination due to a severe bug. But if you can avoid such critical faults in your contract code, the transaction will take its course and come to its end, all as agreed.
However, while indeed every smart contract contains executable code, not every legal dispute over a smart contract may only be the result of critically faulty contract terms. There’s also that kind of dispute which arises because one party breaches the contract voluntarily. This has nothing to do with the contract itself. For what it’s worth, the contract itself might be flawless.
Contract Law Made Me Do It
According to the theory of efficient breach of contract, a party should be allowed to breach a contract if (i) the breach is efficient (meaning performance of the contract is not), and (ii) the party in breach pays damages to the other party.
This is economic analysis of law at work. Contracts help allocate resources to their highest-valued use. Contract law, therefore, aims to facilitate this. This is why breaching a contract is not a crime. In fact, under certain circumstances it may be the right thing to do.
The ‘law’ of self-executing smart contracts – that is to say, the way they are coded – does not seem to fulfil this efficiency-serving function as well as traditional contract law.
However, if we want smart contracts to serve a similar function of allocating resources efficiently, then their code shouldn’t counteract but facilitate that. In short: we should code smart contracts in such a way as to allow a party to breach them. As with old-school contracts, this will lead to the question whether the breach is efficient so that the other party may claim damages? And if so, to how much?
I daresay the answers to these questions are open to dispute. As far as I can see at this point in time, the answers can’t lie embedded in a smart contract.