That German-Singapore Lawyer

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?

French graffito: Confirm you're not a machine

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.


The Arts and the Law in Singapore


No, I Won’t Help You Whitewash Your Token Sale Scam


  1. Pat– Sounds very reas­on­able, but I’d also say there appears to be a reas­on­able way to code a solu­tion. How about if the con­tract gives each party (or one party) the option to can­cel the con­tract with auto­mat­ic pay­ment of the pen­alty? At any time pri­or to set­tle­ment, a party wish­ing to breach records a “can­cel the con­tract” mes­sage to the ledger; when it’s time for set­tle­ment, the con­tract logic pays the con­tract amount if the con­tract con­di­tions are ful­filled AND the “can­cel the con­tract” mes­sage has not been recor­ded; oth­er­wise (and if the con­di­tions are ful­filled) the con­tract logic pays the agreed pen­alty. (And a vari­ation is that the con­tract is can­celled and pen­alty paid as soon as the “can­cel the con­tract” mes­sage is pos­ted, but then the con­tract code would have to be polling the ledger to notice the mes­sage, or the mes­sage code would have to noti­fy the con­tract code.)
    Mean­while, even without these fea­tures in the smart con­tract, I assume the parties would have some recourse to the courts to get an order for the pay­ment to be returned to the buy­er after smart-con­tract exe­cu­tion, assum­ing there were good cause. (I assume how­ever that there is prob­ably no case-law yet to sup­port this approach.)
    And finally: as you know, the huge lim­it­a­tion on auto­mated enforce­ment via smart con­tract is that all the rel­ev­ant data needed to determ­ine that con­tract terms have been ful­filled must be access­ible (in a very reli­able and un-hack­able way, from an author­it­at­ive source) to the smart-con­tract code. That is likely to be hard to achieve for com­plex con­tracts that rely on judge­ment in any way.

    • Patorikku

      Thanks for your com­ment, Martin.

      The solu­tion you sug­gest is pro­act­ive. Noth­ing wrong with pro­activ­ity, but agree­ing on a pen­alty pay­able on a breach is not the same as hav­ing to pay dam­ages. To determ­ine a pen­alty is anti­cip­at­ory. A per­son who is liable in dam­ages must restore the pos­i­tion that would exist if the cir­cum­stance obli­ging him to pay dam­ages had not occurred. This is react­ive. This dis­tinc­tion is rel­ev­ant because parties are only so much able to anti­cip­ate the dam­ages they might suf­fer. Chances are they will be able to quanti­fy the dam­age suffered in full after the dam­aging event. But even this may be dif­fi­cult if not impossible.

      How to include all this in a smart con­tract? I daresay we can­’t, as long as we are creatures crawl­ing from left to right on a single timeline. 😉 Since not all the facts of any giv­en case are fore­see­able and includ­able at the time a smart con­tract is entered into, dis­putes over it will remain. Com­mon points of issue are: Is there a dam­aging event, an effi­cient breach of con­tract for example, in the first place (includ­ing the issue of caus­a­tion)? If so, what are the dam­ages suffered – does dam­age include wasted expendit­ure only or does it extend to expect­a­tion loss (lost profits)? What about intan­gible dam­age? Did the dam­aged party con­trib­ute to the dam­age (con­trib­ut­ory neg­li­gence)? If so, does it mat­ter? If it does, to which extent, fin­an­cially? It’s easy to get lost in details once you start think­ing of it.

      This is why we, the pro­ponents of smart con­tracts, should­n’t be taken in by the idea smart con­tracts will be self-execut­ing so very much that dis­putes will no longer arise from them.

      Now, tomor­row’s res­ol­u­tion and enforce­ment of such dis­putes, that’s a hot top­ic. If you’re inter­ested in it, check out Robots and Leg­al Reas­on­ing: Think­ing Like a Law­yer 2.0 by Alv­in Chen, or even my How Do We Resolve Dis­putes? What’s with Those Algorithms?

      On a side note, did you know con­trac­tu­al pen­alty clauses (mean­ing clauses which do not merely fix a real­ist­ic sum as liquid­ated dam­ages in case of a fore­seen breach event) are not enforce­able in many (most?) com­mon law jur­is­dic­tions pre­cisely because of their pen­al char­ac­ter? Con­trac­tu­al pen­al­ties are deemed uncon­scion­able per se. Where­as most civil law jur­is­dic­tions are okay with con­trac­tu­al pen­alty clauses in gen­er­al, as long as the pen­alty amount stays on this side of uncon­scion­ab­il­ity. The trans­gres­sion of this lim­it remains a leg­al defence.

Leave a Reply

Your email address will not be published. Required fields are marked *

Powered by WordPress & Theme by Anders Norén