Promissory Notes As Smart Contracts

Legal applications of smart contracts — part 1

image by author

This article is the first in a series of articles in which I attempt the application of legal instruments into code.

First, I’ll explain the concept as it stands in Maltese law, then provide an explanation of how they can be implemented into smart contracts. This explanation will use pseudocode to explain coding concepts in natural language. Building on this, I will attempt to develop these concepts into a Solidity smart contract, then provide a link to the GitHub repo for each article.

These articles will assume that the reader has a basic working knowledge of blockchain technology, however, all concepts will be explained as clearly as possible.

A note on language choice

I chose to use Solidity as the language of choice purely because I am most comfortable with it. Smart contracts can be coded in other languages, depending on the blockchain they operate on, such as the Rust language for the Solana blockchain.

Promissory Notes Under Maltese Law

Photo by Adeolu Eletu on Unsplash

A promissory note is a written order for payment, with one party promising to pay a set sum of money to someone else, on-demand or at a predetermined date (Bugeja, 2020). Simply put, it’s an IOU. It creates a sui generis — of its own kind — executive title, which is different from a bill of exchange because it is “not drawn to any intermediate party” (Tsakatoura, 2002).

This means that the relationship it governs is between two parties: the person promising to pay the money, and the person who is promised the money. In order to render the promissory note an executive title, a judicial letter must be submitted (Muscat, 2010). Title VII of the Commercial Code (Cap 13. of the Laws of Malta) regulates promissory notes, which applies most of the provisions applicable to bills of exchange to promissory notes.

Article 260 of the Commercial Code

The Use Case

As far back as 2010, Muscat was considering the possibility of a digital form of the promissory note, considering that in order for the promissory note to be valid, it has to be ‘in writing,’ and ‘signed.’ Clifford Chance LLP (2021) examined this notion, questioning whether a smart contract can fulfill these criteria. However, it was concluded by the Law Commission of England and Wales (2021) that a smart contract could indeed be considered legally binding.

Camilleri (2019) argued that smart contracts could satisfy the requirements of Maltese contract law, as long as “parties ensure that the object and causa of the agreement are always lawful.” However, it was also noted that problems are faced with the verification of identity since this is an important requisite for the establishment of valid consent (Camilleri, 2019).

The efficiency of the promissory note is one of its best features. Using technology to bolster these characteristics could be very useful, and failure to recognise digital versions of promissory notes could be detrimental. As quoted by Muscat (2010), Tsakatoura (2002) held that:

“For negotiable instruments in the form of bills of exchange and promissory notes to preserve their expediency in international trade during the third millennium, they must be recognised as valid in electronic form.”

The application of blockchain technology to promissory notes was also examined by the Polish Ministry of Digital Affairs (2018), holding that:

“[…] blockchain technology allows us to simulate the material world in such a way that we can create digital equivalents of handing over a document, making annotations, crossing out its provisions or even destroying it altogether.”

Promissory notes provide a clean, simple agreement to be tested when examining the use of smart contracts for legal instruments. It does not usually contain many moving parts, which makes it easier to implement in the form of a smart contract, when compared to a fully-fledged 20-page contract, for example. So, how can it be done?

Building a Promissory Note Smart Contract

This experiment is based on several assumptions, namely the following:

• That methods for identity verification and digital consent capture are available, and accepted legally
• That the courts are willing to accept the validity of smart contracts
• That both parties are knowledgeable enough to make use of the smart contract

Based on the Commercial Code, the smart contract will collect or generate the following information:

As per Article 261:

Article 261 of the Commercial Code

• The identification of both parties — using their names and wallet addresses
• The information pertaining to the note itself — namely the date of entry (automatically generated), the sum to be paid, how the value is given, the date when it becomes due, where it was drawn up, and where it should be paid
• The consent of both parties, and the date when consent was given

For certainty:

• The URL to the natural language version of the note

These are stored in a ‘data structure’ called a note which stores variables for this information, and follows the noteInfo template. This can be seen in the pseudocode below:

Pseudo-code for data structure template called noteInfo, and initialising a data strutcure based on it called note.

If you want to get to know more about the variable types used, you can check out the Solidity language documentation on the topic here.

Contract Structure and Flow

The smart contract will work as follows:

1. The smart contract is initiated by the Holder, who provides their name.
2. The Holder enters information about the note through the setDetails function.

Pseudo-code for initialising the contract, and setting details through the setDetails() function

3. The contract then records the consent of the Holder and the Drawer, recording the date when consent is given.

4. If both have given consent, then the date of entry of the note is generated — i.e., when the note was drawn.

Pseudo-code for recording consent, and date of consent. Setting dateOfEntry if both consented

Flowchart for the first part of the contract which creates the promissory note

5. The contract then has the function payNote which allows the Drawer to pay the amount into the smart contract, only if it is the right amount.

Flowchart for the payNote() function

6. Once the amount has been deposited, the Holder can accept the payment, which sends the amount to their wallet and kills the contract.

Flowchart for acceptPayment() function

Pseudo-code for payment of note into smart contract, accepting payment, transfer to Holder, and contract kill

Contract code

Now that the barebones of the contract have been established, I attempt to translate this into a Solidity smart contract. I am by no means an expert in Solidity, and I am still gaining confidence in working with it — so any feedback is welcome! This is the contract code I wrote:

Solidity code for the Promissory Note smart contract

As you can see, I also introduced the function ‘kill,’ which self-destructs the contract, and the function getInfo, which returns the information in the note in the form of a tuple. However, this format for viewing the information is not ideal. I am still working on finding a way to translate this into a JSON metadata file.

The result of the current getInfo() function

I also struggled considerably with stack depth. Since the contract accepts a lot of variables, and the Ethereum Virtual Machine has a limited stack size of 16 variables, I had to amend the contract several times to get it right. As you can see, at the end, I have several modifiers — these are just a cleaner way of implementing if/then logic based on checking if a statement is true. If you’d like to delve deeper, you can check out the GitHub repo here.

How To Make It Better?

There are many ways in which the contract could be improved, several of which I am too inexperienced to notice. However, the following are what I will be working on since I believe they could provide an added level of certainty, and functionality:

1. The first main improvement is to develop a function that mints an NFT, which has on-chain metadata representing the information found in the note. This NFT is then sent to the Holder, who retains it as a ‘token’ of the promissory note. Once the payment is accepted, this token can be burnt automatically. Representing the information in a JSON file — human readable language — will also make it easier to interpret. An example of how this file can look can be found here.
2. The second is to develop a script and interface which can interact with the functions of the smart contract, in order to make it user friendly.
3. The third is to split the contract into smaller subcontracts and streamline its efficiency. I would also heavily recommend making sure that the security of the contract is up to scratch. A number of design patterns were proposed by Wohrer et al. in 2018 for better smart contracts on the Ethereum blockchain, a GitHub repo providing templates which can be found here.
4. The final is to encrypt the data in such a way that the personal details of the parties and the information about the note are only visible to the parties, and whoever they choose to show it to.

There you go! A relatively simple way to implement a promissory note through a smart contract. This is only a proof of concept and is far from ready for being used in actual commercial applications. In the coming articles, this series will focus on a number of these potential applications, such as the verification of documents, rental agreements, and online identity verification.

Thanks for reading. Stay tuned for more.