Universal Protocol v1

Universal Standard

Let's talk about cryptographic wunderwares from 0xPARC company - authors of that very article about Programmable Cryptography. If you remember, they mentioned "universal cryptographic protocol", which was supposed to solve the unification problem. The problem is fundamental: you come to a domain, you see N standards, you try to unify them, but instead of "the ring that rules them all" you just create another standard. Let's try to solve this problem as #progcrypto-experts.

Let's say you've formed N+1 standards. What would make it universal?

Step 1.

First, let's write N algorithms that convert the old standards into the new one. To avoid multiple competing implementations, we will create a formal specification¹. Using formal proofs of the correctness of the code in this specification, we will have a canonical way of working with the standard - and with all existing standards. This will allow predictable data transformation between all possible representations. Great functionality!

Step 2.

Now we need to prove the consistency between the original data and its transformed version. There are two approaches here: either re-executing the converter code (re-execution) from the previous point, or using a cryptographic protocol that supports short proofs (zk-SNARK², zk-STARK³ and others). The first option is unsuccessful: it requires the old data format to be transmitted along with the new one. The second one allows you to take with you only a small proof confirming the correctness of the transformation. For example, if the original data has been cryptographically signed, or its hash is publicly available, we can create mathematical guarantees that our N+1 format corresponds to any of the legacy formats.

The skeptical reader has already spotted the catch. Data can be verified in many ways, and it is impossible to take them all into account in a single circuit - there are hundreds of cryptographic signature methods alone. A simple scheme will not help here.

For our protocol to really "rule over the others", we need an execution environment that supports two key features: formal conformance of the adapter to the specification and cryptographic proof of actions performed.

There is room for experimentation here, but let's take this approach: create a virtual machine (VM) that works with logical operations!

Sounds massive, but a logic VM is just an engine for math expressions. The inputs of the legacy protocol are axioms, and inside the program we use Domain-Specific Language (DSL) to prove their conformance to our new format. This is an extremely simplified variation of CoQ/Lean, which nevertheless allows to realize any verification. For example, cryptographic signatures are always specified mathematically, so that even an average LLM can reprint most of such proof programs from PDF with a little help. Now we will get out of the box both circuit and formal specification compliance, because both of these tools reduce transformations of ordinary processor operations to logical ones.

So, we have created a runtime environment that allows us to convert old standards to a new one and back, to formally specify these conversions.

However, the following problem arises: any change in the data completely nullifies the entire chain of evidence. When we receive the data, we know that it is correct and unified, but change even one byte and our N+1 format loses all its advantages. Or does it? Can we use the previously created execution environment for any transformations? Yes!

Step 3.

Now our format requires that any operation be performed inside a logical VM. This creates overhead, but is it possible that the advantages outweigh the disadvantages? If we make the system modular and reusable, we can assemble any logic we want from its components. As a result, our N+1 format ceases to be just a format and becomes a universal adapter where the entire chain of computation is both provable and verifiable. And if the underlying protocol supports zk⁴, we can handle private data without revealing it. As a result, by solving the problem of N+1 standard, we have a real wunderwatch - a way to connect everything to everything without the need for instant migration of participants.

What problems can be solved with such a wunderwaffle?

Let's imagine.

1. Move a profile from one platform to another.

Indeed: take some ready-made algo-cubes, connect them together - and get data within another platform, and without developing a specific solution.

2. Disprove your "personal data", without revealing your passport.

Most passports contain a state-certified cryptographic signature. This can now be used to confirm any information about you without revealing the document itself. Yes, KYC (Know Your Customer), but KYC of a healthy person!

3. Aggregate all your financial data in one place.

Dozens of legacy bank formats, data from different blockchains, and your cash accounting app can all be easily brought into a single view, calculate any metrics, and even prove properties over them.

And for all these cases, it is mathematically guaranteed to be error free (if the data itself is correct). Has someone made a universal N+2 standard? You may well be compatible with each other and be competed only by the algorithmic completeness of the platform.

It's a beauty!

PS

You may think, of course, that this sounds too fantastic. But is it achievable? Yes! And POC (Proof-of-Concept) not only exists, but is even open-source and can be touched. This time I won't repeat my mistake with "hallucinating servers" when I just left a link, but will try to explain more in a future post.

• ¹ ¹ A formal specification is a mathematical description of a system that unambiguously defines its behavior and allows you to formally prove the correctness of an implementation. awesome-rust-formalized-reasoning
• ² zk-SNARK - compact, non-interactive zero-disclosure proof, as exemplified by halo2-protocol.
• ³ zk-STARK is a scalable and transparent zero-disclosure proof that does not require trusted customization and is resistant to quantum attacks.
• ⁴ zk is a property of cryptographic protocols that allows proving the truth of an assertion without revealing additional information.