Today we are releasing version 2.7.0 and adding another tool that makes Obyte a safe environment for commerce.

We already have smart contracts that allow two parties to create a both human- and machine-readable contract that is enforced automatically, in a decentralized way, by all network participants. The parties can be anonymous, they don’t need to have any reputation, and the trust is provided by a large community of independent automated verifiers who make sure all the rules are being followed. However, the scope of smart contracts is limited: they can operate only based on data available on the ledger and allow only the terms that can be represented in a precise machine-readable language.

We also have a connection to the real world: a real-world identity that can be verified and privately stored on the user’s wallet, while a personal-data-free proof of this identity is published on the public DAG.

We now leverage the real-world identity to sign conventional contracts. We call them prosaic contracts because they are written in natural language, contrary to smart contracts that have code under the hood (and code is poetry).

The solution is very simple: Enable two parties to sign the text of the contract through an easy-to-use interface, store the contract’s text privately in the wallets of both parties, and post their signatures to the DAG where they are verified, timestamped, and stored forever by the network participants. After signing, the parties can easily find the contract text in their wallets to check that they are executed as agreed upon. In case of dispute, any of the parties can reveal the full contract to a third party, who can easily verify the validity of signatures through the DAG.

The private key and address used to sign the contract can optionally (and preferably) be a real-name attested address linked to a user’s verified government issued ID. This proves that the contract was signed by a real person and that it satisfies all 4 requirements of “advanced electronic signature” under Article 26 of eIDAS regulation in the EU (This is not to be taken as legal advice. Always consult your lawyer familiar with any local regulations and ongoing legislation on the topic).

How it works

The usual, generally adopted, and stipulated in contract law of many countries, process for contract signing consists of two steps:

one party (offeror) offers the other party a contract;

the other party (offeree) can either choose to accept it or decline it.

These steps can be repeated multiple times until both parties reach agreement. They can even change roles (who offers and who accepts).

Obyte has an excellent medium to facilitate the exchange of offers — chat, which is integrated with private keys necessary for signing the contracts.

Example Process

Before making an offer, the parties initiate a chat and optionally exchange their real name attested profiles, to let the other party know who they are dealing with.

The receiving party must save the private profile of the counterpart in order to see her name on the contract.

Then, one of the parties sends her (attested) wallet address to the peer.

The other party (who is going to become the offeror) clicks the wallet address link and selects “Offer prosaic contract”.

Here the offering party writes all the proposed terms and conditions of the contract and sends the offer to the other party.

The offeree reviews the proposed text and either accepts or declines it.

If the contract is approved, the wallets of the two parties start working in the background to create a transaction on the DAG that proves that the contract was signed, and does so without disclosing its content publicly:

The offeror’s wallet creates a shared sub-wallet address (shared between the two parties) that can be signed only by both parties. The offering user’s wallet then sends 2000 bytes to the shared sub-wallet address to provide sufficient funds for transaction fees. Finally, it creates a transaction that is authored by the shared sub-wallet address and includes the hash of the contract. It adds its own signature, requests the signature from the counterpart, and publishes the transaction signed by both parties to the DAG.

All of this happens in the background, without active participation of any of the parties. They may still need to confirm signing again, especially if they are using multi-signature or password-protected wallets.

After signing the contract, its full text is saved privately in the wallets of both parties from where they can view it any time on the corresponding details page. It also allows the parties to verify that the contract hash published on the DAG is the same as the hash of the contract they see.

Applications

Although prosaic contracts are not enforced automatically, they are linked to real world identity, which is another (less perfect) source of trust in faithful execution of contracts, and they have much broader potential scope. For example, an uncollateralized lending contract is one of the obvious possibilities.

Application developers are welcome to use this new tool to build apps that leverage the benefits of a trustworthy environment. Bots can offer and sign prosaic contracts just like any other wallets, developer documentation will be available shortly at https://developer.obyte.org/.