In my last article I talked about why I favor an extremely simple multisig smart contract design. I’ve decided to turn this into a two parter because I think the benefits might become clearer if I show why this is useful.

The Benefits of Standardization

I’ve noticed a lot of discussion in the Ethereum community about standards, which are very tricky to enforce. We’ve seen the first true Ethereum standard emerge (ERC20), which has been by most measurements wildly successful. It is easier than ever to clone an ERC20 token and give it a purpose. By comparison, here is an example of a developer who tried to write a token that was not to ERC20 spec and became confused when his wallet UI wouldn’t read it.

A standard, in my opinion, should be the smallest amount of functionality for a tool that can be referenced from a layer above. In the case of ERC20 tokens, wallets (e.g. MEW, Metamask, Parity) can call four common functions to parse metadata and transfer tokens. This has been hugely beneficial for the entire ecosystem.

A Multisig Standard

To this end, I have written an ERC proposal outlining a standard specification for multisig contracts. The purpose of this would be to allow all Ethereum wallets the ability to interface with multisig contracts that the user could trust. In my opinion, it is not ideal that today we have a Parity wallet that uses one multisig and an Ethereum Foundation wallet that uses another. Meanwhile, MyEtherWallet and Metamask do not have native multisig functionality. This mish-mash is exactly why we need such a standard. Multisigs are too important to get pushed aside.

Imagining a Multisig UI

This brings me to my proposal. At a basic level, my ERC outlines a single function to execute any arbitrary transaction and some public variables that give necessary metadata to determine multisig owners and the number of signers required for a transaction to execute.

Again, this is simply a bare-bones specification upon which additional functionality could be built at the application’s discretion. But I think the community would benefit from every wallet allowing an easy, simple multisig setup. Users should trust that the core functionality (i.e. sending a transaction) is safe and that the contract will not lose its funds. They should also trust that anyone they are sharing a multisig wallet has the same functionality as them, regardless of which wallet they are using.

Example

Let’s solidify this concept with an example. Imagine you want to start a multisig with your parents. This will be a 2-of-3 contract, meaning two people must co-sign every transaction in order for it to execute.

Step 1

You open up your wallet and click “New Vault” (or whatever the lingo becomes):

Step 2

Upon setting up your vault, you add your parents either by Ethereum address, or ENS domain (another successful Ethereum standard).

Once this vault is created, you can access it at any time.

Step 3

You can now send a transaction.

On clicking “Send”, one user needs to collect signatures from the other. Depending on the application, this could either be through a client/server relationship or a p2p messaging protocol like Signal.

Note: Off-chain signature aggregation is my personal preference, but if the application wanted to store temporary signatures in the contract, there’s nothing stopping it. As long as the application implemented a contract whose execution function was formatted properly, it would comply with the standard.

Anyway, back to the UI. The I need to fill in the transaction information.

Once I submit the transaction, my mom and dad will both get notifications.

Once my mom co-signs the transaction (since my dad wouldn’t let me send money), the transaction would get sent. And that’s all there is to it!

Standards for the Win

Imagine if your interface looked like that. Do you think your parents would be more likely to use Ethereum? I do. This is why standards are important — they take us from deeply technical interfaces to ones that are ready for mass-market consumption. They drive better interfaces because they define functionality, which leaves organizations to compete on usability.

I am impressed by the standards that Ethereum has been implementing (there are more than the ones I mentioned and several more emerging), but I feel as though multisigs have been neglected. I would feel much safer if I could spread the risk of asset ownership to trusted parties on the blockchain itself.

At Grid+, we will be installing native multi-sig functionality on our agent device. We would like to further the discussion on an open Ethereum multi-sig standard, so if you’re interested, join our telegram group and post any thoughts on my ERC proposal.

Thanks to Yunyun Chen for the images!