Jesse Walden’s blog post on Complete vs. Incomplete Contracts got me thinking about how games (or protocols) are complete, but we experience them in controlled and governed instances, or incomplete contracts. Applying this framework to Layer 2 scaling projects, we see that some Layer 2 scaling projects are pursuing games that fall in the middle ground – enabling contracts that are “complete until incomplete”.

Recapping “Incomplete Contracts” (with examples):

Complete contracts are protocols that have a complete set of rules. As a result, they can be fully implemented on-chain without the need for any off-chain data.

  • Regardless of the specific implementation, the rules of these games will be followed by anyone who participates or interacts with them. Any disputes about whether or not an action (state transition) is valid can be resolved deterministically and on chain. 
  • Example: In poker, the rules determining which party wins a hand are clearly defined. Assuming the randomness of the card dealing is implemented on-chain, any dispute can be settled using a deterministic process.

Incomplete contracts on the other hand, require off-chain governance. This governance mechanism’s opines on the outcomes of specific disputes that are not handled by the protocol.

  • In practice, this can take the form of a decentralized oracle (e.g. Chainlink), a human coordination problem/staking mechanism (e.g. MakerDAO’s governance mechanism), or a centralized entity.
  • Example: A regulated casino can decide who is allowed to come to the table to play poker, and the rules under which they can play.

Deterministic Protocols vs. Subjective Instances

Complete contracts reflect “protocols”, which keep track of state and the parameters that govern state transitions, resolving each step deterministically. Even if formalized in smart contracts, though, their success in the real world is dependent on their existence in “controlled instances” that encourage “desired behavior” via subjective governance. These “controlled instances” are the “businesses” in the fat protocol thesis, which I’ve previously written about.

Going through a few more examples might further drive the point:

  • A protocol for sending data like text messages, videos, GIFs across the internet is deterministic, but we experience them through the controlled instances of Facebook, Youtube, and Twitter that moderate the content we interact with.
  • The games of Starcraft and Counterstrike are often experienced when players connect to servers running game tournaments.
  • Poker and blackjack are deterministic, but regulated casinos control who comes to the table and how they play.
  • A stablecoin issued by an algorithmic central bank would be deterministic in deciding monetary policy, but the MakerDAO system is a stablecoin with a subjective “central bank” (governance mechanism).

Deterministic Until Subjective?

Is there a middle ground? Can we have instances of games that are mostly deterministic, but subjective only when they need to be?

Yes, if it makes sense to create an “insured instance” of the protocol.

In an “insured instance”, participants follow deterministic protocols without oversight, but can raise issues to an external and subjective process when they see fit. Each participant posts a bond as collateral (insurance). When a dispute is raised, the bond is used to pay a penalty to the disputer if, in the subjective resolution process, the disputer is correct.

A few examples here, some of which have already been tried:

  • Email users could “insure” their emails with deposits to promise their recipients that they’re not spam. was one implementation of this.
  • Decentralized casinos could accept deposits from all participants to protect against “bad behavior”, where “bad behavior” is another participant (e.g. your opponent in blackjack) claiming that you’re rigging the deck, etc.
  • Margin trading protocols like the one described in UMA’s whitepaper move a portion of participants’ margin to the other as a penalty if a dispute rules that he has behaved badly (defaulted).

This approach doesn’t apply to all games – you can see how MakerDAO’s process, for example, wouldn’t make much sense if translated into an “insured instance” of the MakerDAO protocol.

Deterministic vs. Subjective Layer 2 Solutions

Sound familiar? We’re seeing this categorization of protocols in the different approaches of Layer 2 solutions today. The below analysis generally assumes that Layer 2 solutions involve off-chain activity (sidechains, state channels) that need to be somehow reconciled on-chain. In state channels with exit games for example, transfers of data between the participants can be executed according to a deterministic protocol in the state channel, with an exit game that surfaces disputes to a main chain.

We can then categorize Layer 2 solutions based on how disputes are recognized and how those disputes are resolved:

  • Deterministic resolution:
    • Layer 1 blockchains (like those underlying Bitcoin and Ethereum) have very frequent disputes (at every block) and use deterministic proofs to resolve them (is this block valid?).
    • Arbitrum (from Offchain Labs) uses Merkle trees to identify the source of disputes in side-chains, which are resolved using a deterministic process. Arbitrum therefore works well for games that don’t rely on off-chain data (e.g. chess, poker/blackjack using on-chain randomness), but not for games that do (e.g. real-world derivatives).
  • Subjective resolution:
    • Private/public permissioned blockchains, with limited validator nodes that also have authority over the addition of new validator nodes, are entirely subjective. Blocks are only considered for inclusion when the validator nodes say they are, and they have final say over whether or not they eventually are included.
    • Libra (Facebook/Libra Association) and Quorum (JPMorgan) would qualify. Generally, “enterprise” should work as a shorthand for these projects.
  • Deterministic until subjective:
    • Some Layer 2 solutions suggest having participants stake as insurance against invalid behavior on sidechains. When a dispute is raised, a subjective process determines whether or not the offending actor’s stake should be paid to other participants.

How do we scale incomplete contracts?

Most protocols and games are not compatible with the strictly “deterministic” type of Layer 2 solution like Arbitrum’s, since they rely on some connection to the real-world (e.g. most financial transactions reflect real-world assets and liabilities). “Subjective” solutions, on the other hand, can feel like a Google Sheet with edit permissions.

Layer 2 solutions that create insured instances of deterministic games could be the decentralized middle ground we’re looking for.