The Efficient Breach of Smart Contracts

Smart con­tracts are described as self-execut­ing: how they are formed is how they will be per­formed. This is why some of us see no (or at least less) room for leg­al dis­pute over them.

It shouldn’t be this way. Where it’s effi­cient, it should be pos­sible to breach a smart con­tract. Even though this may lead to a leg­al dispute.

The Implicit Premise

In How Do We Resolve Dis­putes? I spoke at length about dis­pute res­ol­u­tion, in the phys­ic­al world and in cyber­space, and by and for whom, and how. All this was based on one basic premise: there will be leg­al dis­putes in the first place.

But is this premise correct?

There are these new kids on the block who, some say, come with the poten­tial to reduce the amount of (or even do away entirely with) leg­al dis­putes, at least as far as leg­al dis­putes over con­tracts are con­cerned. With them, their cham­pi­ons argue, there will be less (or even no) need for the often costly res­ol­u­tion of leg­al dis­pute, thus less (or even no) need for the some­times com­plic­ated and time-con­sum­ing, at times even impossible, enforce­ment of such dis­pute resolution.

Smart con­tracts.

They haven’t really made an entrance yet, but it’s like their advance guard has already arrived.

Self-Executing Agreements

What are smart con­tracts? In today’s under­stand­ing, they’re con­tracts coded on block­chains, as I’ve touched on when I wrote about smar­ti­fy­ing block­chains, leg­ally. There’s a good and more detailed write-up on smart con­tracts here. In a nut­shell, smart con­tracts facil­it­ate, veri­fy and enact agree­ments between con­sent­ing parties.

Enact as in: self-execute.

Self-execut­ing agree­ments. This is pacta sunt ser­vanda 2.0. Or: pacta erunt ser­vanda. No longer agree­ments are to be kept, but agree­ments will be kept.

Bye Bye, Disputes?

Of course, with an agree­ment that executes itself, how can there still be room for leg­al dis­pute over it, right? How you form it is how you per­form it. Or per­haps not?

A thes­is like this is based entirely on the under­stand­ing of a smart con­tract as execut­able code and noth­ing else. In this under­stand­ing, there is room for leg­al dis­pute only where it turns out the code isn’t execut­able, say because it con­tains crit­ic­al errors. Seen this way, a leg­al dis­pute over unclear con­trac­tu­al terms can only be the res­ult of an abnor­mal ter­min­a­tion due to a severe bug. But if you can avoid such crit­ic­al faults in your con­tract code, the trans­ac­tion will take its course and come to its end, all as agreed.

How­ever, while indeed every smart con­tract con­tains execut­able code, not every leg­al dis­pute over a smart con­tract may only be the res­ult of crit­ic­ally faulty con­tract terms. There’s also that kind of dis­pute which arises because one party breaches the con­tract vol­un­tar­ily. This has noth­ing to do with the con­tract itself. For what it’s worth, the con­tract itself might be flawless.

Contract Law Made Me Do It

Accord­ing to the the­ory of effi­cient breach of con­tract, a party should be allowed to breach a con­tract if (i) the breach is effi­cient (mean­ing per­form­ance of the con­tract is not), and (ii) the party in breach pays dam­ages to the oth­er party.

This is eco­nom­ic ana­lys­is of law at work. Con­tracts help alloc­ate resources to their highest-val­ued use. Con­tract law, there­fore, aims to facil­it­ate this. This is why breach­ing a con­tract is not a crime. In fact, under cer­tain cir­cum­stances it may be the right thing to do.

The ‘law’ of self-execut­ing smart con­tracts – that is to say, the way they are coded – does not seem to ful­fil this effi­ciency-serving func­tion as well as tra­di­tion­al con­tract law.

How­ever, if we want smart con­tracts to serve a sim­il­ar func­tion of alloc­at­ing resources effi­ciently, then their code shouldn’t coun­ter­act but facil­it­ate that. In short: we should code smart con­tracts in such a way as to allow a party to breach them. As with old-school con­tracts, this will lead to the ques­tion wheth­er the breach is effi­cient so that the oth­er party may claim dam­ages? And if so, to how much?

I daresay the answers to these ques­tions are open to dis­pute. As far as I can see at this point in time, the answers can’t lie embed­ded in a smart contract.