Lexon 0.3 Aragon
brainiacfive opened this issue · comments
Nest Program Proposal: Human-Readable Aragon Contracts
About
Project name: Lexon 0.3 "Aragon"
Project description
Funding is sought to make one set of Aragon smart contracts readable for non-programmers using a new programming language that reads like natural English and can be understood with a 0-learning curve.
For examples, see: http://demo.lexon.tech
This entails 1) enhancing the current Lexon language and compiler to add capabilities that Aragon contracts require, and 2) to translate existing Aragon smart contract code from Solidity to Lexon.
The improvements this will realize, will be usable for many other projects, on the blockchain, or off-chain.
Lexon is a computer language that anyone can read.
Lexon was made for blockchain smart contracts and can be used to write normal contracts that work as blockchain smart contracts: with Lexon, the same text can be both program and legal agreement.
This is useful for any organization that wants its smart contracts, or any program it uses, on- or off-chain, to be readable for all its members. It works for legal agreements as well as for internal process flow or high-level business logic.
Specifically, a DAO's charta when programmed in Lexon can be the legal document of registration itself that allows the DAO to achieve legal personhood, defensibly own assets and legally shield its members. Tests have shown that a Lexon smart contract can be both the programmed governance mechanism and the document required for registration.
Eventually, humans will be able to write 'Robotic Laws' in Lexon that machines can literally read. This allows us, through lawmakers and regulators of any layer and legitimation, to mandate hardware makers, military contractors as well as social media to build into their products concrete code that limits and controls potentially harmful functions. Because these laws are executable without any additional bespoke 'translation' process, this eliminates human error and potential for deception.
Lexon is a programming language, based on advanced paradigms, implemented using mainstream compiler technology.
Deliverable
Lexon version 0.3 with a focus on Aragon contracts.
- We will deliver documentation to write, and a compiler to translate, Lexon code that describes Aragon contracts into Solidity code.
This builds on our work as presented for Lexon 0.2.
- As a proof, learning example and for actual use, we will manually translate one set of existing Aragon contracts (e.g. one of Planning, Payroll, Espresso or Governance) from Solidity to Lexon.
Proof and use lying in the fact that the Lexon compiler then translates this code (back) from Lexon to Solidity, to be deployed on Ethereum. (The Solidity code resulting from this process will not look anything like Aragon's current Solidity code as it will be machine-created.)
This code will extensively be tested for readability with non-programmers and tested for robustness with test frameworks to be built as part of this project stage.
All results will be free to use and Open Source.
Rational
The Aragon ecosystem is governed by bi- und multilateral agreements between network participants (Aragon Agreements). Inherent to the nature of a decentralized network such as Aragon, these agreements include clauses which are to self-execute in case certain conditions are met. E.g. a penal clause that results in the slashing of a participant’s stake in case the triggering condition is met. This slashing mechanism is not only expressed as Aragon Agreement in written form. Its logic is also translated and implemented as self-executable smart contract code, i.e. in the Ethereum smart contract language, Solidity. This translation inevitably creates the risk – even likeliness – of a discrepancy between the written agreement (on paper) and its code-based performance (by smart contract). Because Solidity smart contract code can solely be read and understood by people with specific programming skills, oversight and transparency of this important element in the Aragon community are severely limited. The dichotomy between the Aragon Agreement and its execution re-inserts the need for trust – of programmers. By its complexity it is conducive to errors and attacks, to the degree that it may impede wider adoption.
A convergence of these two types of contracts is needed to ensure transparency, eliminate the tacit third party trust requirement (in programmers), democratize the process of implementing contracts in code, and make it safer and easier to develop, verify and discuss the meaning of contracts. So as to not include blockchain-native agents, an Aragon Agreement should ideally be written entirely in ONE self-performing document that is "human-readable" – i.e. readable also by non-programmers. An Aragon Agreement could then consist of only ONE document that is readable by both human and machine participants.
In order to achieve this, we propose to express Aragon Agreements in Lexon, a “human-readable” smart contract programming language developed by the Lexon Foundation.
This reflects Aragon’s vision as expressed in Section 2 of the Aragon Whitepaper:
“Enforceable agreements are a tool used to reduce friction between agents which do not trust each other. Ethereum provides one type of enforceable agreement, a smart-contract, which is enforced by protocol rules and cryptographic security. However, the types of agreements which are practical to encode in a smart-contract are limited. Smart-contracts require the terms of an agreement to be machine interpretable, do not allow for human-friendly or subjective language, and their rigidity creates a complex attack surface that is difficult and expensive to secure.
"In cases where smart-contracts are not practical, agents may instead turn to traditional legal agreements. However, this poses a problem for blockchain-native agents which may not be linked to traditional legal entities. Projects like Mattereum and Openlaw are working on making it easier to link blockchain entities to traditional legal forms, but much of the censorship resistant properties that make public blockchains so valuable are lost as soon as an agent links their pseudonymous blockchain identity with their physical identity."
"To resolve this tension we propose a mechanism that allows any agent to be a party to a human-readable, enforceable agreement. We define an Aragon Agreement as a set of smart-contracts and a human readable document that is cryptographically signed. Aragon Agreements specify the responsibilities of relevant agents, their respective liabilities, and what mechanism will be used to enforce the agreement in the event of a dispute.”
The core idea of Lexon is to bridge the “machine-interpretable” to the “human-readable” by providing a new, very easy to read, open source language. As a language, Lexon is not restricted to any specific philosophy: it can be used in the context of a traditional legal system, or in the context of post-legal systems. The research and development is centered around the Lexon compiler that translates human-readable Lexon contracts into Solidity. Lexon code does require a special grammar to be employed that is similar to legal prose. It does not require any prerequisite learning to be read and interpreted correctly.
Expressing Aragon Agreements in Lexon would allow Aragon participants to understand the exact logic of Aragon Agreements and a standardized way to create self-executable smart contracts from them, without the need of any programming skills. Aragon Agreements that are articulated in human-readable Lexon code are compiled into executable Solidity code.
Code repo and website URL
website:
https://www.lexon.tech
source:
https://gitlab.com/lexon-foundation/lexon-rust
https://gitlab.com/lexon-foundation/lexon-editor
tutorial:
https://www.lexon.tech/tutorial
examples:
http://demo.lexon.tech
book:
https://www.amazon.com/dp/169774768X
attached as PDF, link below.
Where did you hear about the Nest program and what prompted you to apply?
Maria Gomez, at COALA Prague, told us that the idea of human-readable contracts had been discussed by Aragon members as a core desirable element and we should talk.
There has been exchange with Aragon tech leads at Aracon that resulted in interest to explore further.
Discussions went deeper with John Light at DGov II.
Team
Henning Diedrich – hd@lexon.tech
Marcelo Alaniz
Florian Idelberger
Arjan van Eersel
Roles
We are focussed on development.
The team is lead by Henning. Everyone implements and tests compiler and UI code.
Everyone does full–stack and blockchain at system-level.
All have as background a focus on Ethereum with exposure to other chains like Aeternity, Dfinity and Tezos.
Has the team already worked together?
Yes, we are currently working in this constellation.
Henning leads the project and designs and co-implements the current Lexon compiler release 0.2 with Marcelo:
tutorial: https://www.lexon.tech/tutorial
online: http://demo.lexon.tech
source: https://gitlab.com/lexon-foundation/lexon-rust
Marcelo creates Lexon's online editor and contract manager with Henning and Arjan's help, and has created a first stand-alone virtual machine for Lexon:
live at: http://demo.lexon.com
source: https://gitlab.com/lexon-foundation/lexon-rust
Florian builds the Lexon plugin for Ethereum's Remix online editor with Marcelo's help:
soon live at: http://remix.ethereum.org
source: https://gitlab.com/lexontech/lexon-remix-plugin
Arjan builds a Lexon enhancement for the Aeternity Fire Editor, with Marcelo's help:
soon live at: http://fireeditor.nikitafuchs.de
source: https://gitlab.com/lexon-foundation/aeternity-fire-editor
Is your team already present on the Aragon Forum? If Yes, what are your usernames?
Henning: as Brainiac Five.
Progress
How far along are you?
Lexon 0.2 nears completion with a focus on de-risking the concept, proving a multitude of smaller examples and cross-compilation to Ethereum and Aeternity.
Design-wise, the language is at 60% with a focus on the essential core over the expectable later extensions that are more obvious and less novel.
Robustness is at 80% and will see ups and downs with each new feature upgrade.
A live demo of the compiler revision 0.2.x with many examples is available online:
The source code is online at gitlab:
https://gitlab.com/lexon-foundation/lexon-rust
https://gitlab.com/lexontech/lexon-remix-plugin
https://gitlab.com/lexon-foundation/aeternity-fire-editor
Documentation is at 30% and a first draft of a book is available at Amazon.
https://www.lexon.tech/tutorial
https://www.amazon.com/dp/169774768X
Is anyone using your product/application?
Yes, as intended, the current results are being used in academia and the legal profession, e.g. the proposal for the reform of US Uniform Commercial Code (UCC) (see book, code from pg. 43).
Robustness for production use is not yet achieved.
Idea / Problem
Why did you pick this idea to work on? Do you have domain expertise in this area?
Excitement for the idea of human-readable smart contracts was evident in 2016 after asking around in the space for some months. This indicated such a project should find support and users and have viral potential.
I had programmed a language, compiler and VM before that made for a successful exit of founders and was in use for more than a decade.
What's new about what you're making? What do people resort to because it doesn't exist yet (or they don't know about it)?
Human-readable programs seem to be new beyond the blockchain space. See appendix II of the book that lists previous efforts of programming languages pointing in a similar direction. No project before went all the way.
The application scope of this language clearly goes beyond blockchain as well as beyond the legal aspects.
As this potential is not known yet, people at this point resign to the fact that smart contracts have to be written, read and explained to them by programmers. There is usually no notion that this could be any different. The consequence is a tacit hole in the concept of trustlessness: everyone at this point has to trust the programmers. Trustless technology is truly trustless only for coders. Lexon brings a qualitative change to this, ' disintermediating the programmers'.
Have you talked to people about what you're making? Do people want it and do you have examples of this?
Excitement is universally high, but especially in academia and by people who are engaged in the blockchain space but are not programmers themselves. It is a quick process to explain the usefulness for pure, off-chain, trustfull business-flow implementation.
People have already taken it up and ran with it to do things that it was not meant for, like seriously proposing bits of law written in Lexon. But it's not robust and versatile enough for production just yet.
The idea is communicated fast and a live demo takes only ten minutes. Courageous people literally start coding immediately but importantly everyone can read and comment on contract contents from the very first moment they are shown code. This happens so seamlessly that people are often not aware.
As would be expected, a sufficient number of practitioning programmers, and lawyers, are indifferent. For both groups Lexon might mean change.
Market
What is the target market or end user in mind for this project?
Both the long tail of private commerce that will emerge thanks to blockchain, i.e. private users, DAO communities as well as corporate trade and trade finance.
The Lexon language and compiler is free and Open Source and the hope is that it will find wide traction.
What are the alternatives or competitors to this project?
There is nothing quite like this. Ricardian contracts have been described as similar but Ian Grigg, the inventor, comments that Lexon adds a new and better dimension over their capabilities.
How will this project get users? If your project is the type that faces a chicken-and-egg problem in the sense that it won't be attractive to users until it has a lot of users (e.g. a marketplace), how will you overcome that?
There is no critical mass needed to get started. One person alone can benefit.
The marketing strategy is to build reputation and enabling viral adoption by empowering the user community, furnishing product, documentation, and references.
Legal
Will you be using an Aragon DAO for operating this project and receiving the funds?
A long term option, things are set up different at this point.
Are any of the project team members covered by non-competes or intellectual property agreements that overlap with your project? If so, please explain.
No.
Aragon
Why do you think Aragon is a good fit for this project?
We were told so by Aragon members. As can be seen from the Aragon whitepaper quotes above, Lexon appears to align perfectly with Aragon's mission and spirit, solving a central challenge. It was also related to us that the vision of human-readable contracts was harbored by Aragon members long before learning about Lexon, for the very reason to better include non-programmers of the community.
Vibes of community and aspirations regarding goals, empowerment and social application seem to match.
Are there any existing Aragon projects that are similar or complementary to your project?
No.
Funding
How much money are you requesting as a grant? (the maximum grant size we provide is $150k in USD value)
EURO 100,000 (~ USD 110,000)
Are you applying for funding to any other DAO platforms or grant programs? If so, that is not a problem as it increases the likelihood of your success, but it's important that we can take that into consideration if your project relies on multiple grants.
We plan to.
How do you plan to deploy grant funds? (split between research / development / marketing / etc)
Almost 100% development and documentation. Some community outreach and conference travel.
What is your expected monthly burn rate?
EURO 25,000 (~ USD 27,500)
Do you think this project will require additional funds once you have depleted the grant funds? If so, why? Where do you plan on acquiring further funding?
This grant will suffice to complete the self-sufficient stage needed for Aragon contracts and have a production-level result.
We will be excited to discuss the implementation of another set of Aragon contracts after. But the goal is to finish at a point where Aragon can do this independently of us.
Lexon per se is a long-term project, started with angel money and applying for other grants for other steps forward. Other areas of work include creating compiler variants based on other natural languages than English, and targeting other blockchain platforms like Dfinity or Cardano.
Virtually all such future steps will retro-actively benefit Aragon: making its core contracts more readable, more inclusive and future-proof, i.e. allow for a switch of blockchain platforms.
Roadmap
How long do you plan on working on this project before shipping?
4 months.
What are the key milestones you have to accomplish before you can ship a production ready product to users?
Robustness and Enhancements: current working Lexon contracts are typical small code examples. The Aragon smart contracts are more complex:
Robustness
Expansive tests and refactoring will make the compiler produce reliable and safe bytecode to run on-chain.
Enhancements
Research into the existing Aragon smart contract code resulted into a list of extensions that need to be added to the Lexon 0.2 core functionality, to be able to deliver all functionalities that the Aragon smart contracts require.
Notes
Lexon is exceptional close to core Aragon concerns, eliminating the need to trust developers and closing this gap that remained in the concept of trustless-ness.
Beyond the concrete contract we want to produce as result, a main deliverable is a general-purpose, more robust tool that will be useful for any Aragon contract or the smart contract needs of any other DAO.
Hey this is really cool. Thanks for applying. At this point, however, we're focused on the Aragon Court and proposal agreements as a vehicle to allow any agent to be a party to a human-readable, enforceable agreement.
Closing this Issue as it's not a good fit right now, but best of luck! This seems like a really cool project :)