The Metanet Starts

a 4-Dimensional Supercomputer that lives on Bitcoin.

_unwriter
_unwriter
Jun 24 · 13 min read

Metanet is the world’s first 4 dimensional computer, natively powered by Bitcoin, and lives on Bitcoin.

Metanet has very powerful properties such as:

  1. Absolute data ownership: Many, many, many, many “decentralized” wannabes have tried to solve this problem, all have failed. Metanet solves this on a fundamental level by using Bitcoin.
  2. Fungible computation: Bitcoin is private and fungible when used correctly. Metanet makes use of this property to its fullest and provides a fungible computation framework, never possible in any other “blockchain platform”.
  3. Infinite computation: A combination of two powerful schemes opens a new dimension of computation.

And today, I am releasing a system that can help power the Metanet: Metanet Planaria.

But first, let’s take a look at what Metanet is.

It’s not what most people think.

Table of Contents

  1. Intro to Metanet
  2. Building Metanet Apps
  3. Conclusion

1. Intro to Metanet

Since last winter, many people have been raving about how great the “Metanet” is. But the fact of the matter is, none of those were Metanet. Metanet never existed.

This changed last weekend. It exists now.

Before you panic, let me clarify that Metanet doesn’t invalidate anything you’ve been building on top of Bitcoin. It’s like an extension to existing protocols, which means you don’t have to use it, but it will be much more powerful if you do. Read on to learn more.

The Genesis Metanet Graph was made last weekend:

Most people don’t understand: Metanet is not some philosophical concept. Nor is it a meme. Metanet is a very specific protocol that is also very generic at the same time, so generic that it becomes philosophical.

Sound like contradiction? The best things in life are contradiction.

So what IS Metanet?

Here’s a great presentation:

Let me just break it down to one line:

Metanet is data structure over Bitcoin.

Metanet: Data Structure over Bitcoin

Metanet is a simple protocol that lets you create virtual data structures on Bitcoin. By taking the form of a DAG (Directed Acyclic Graph) it lets you build any typical data structure used in computer science.

  1. An array is a tree with a parent + its children represented in chronological/topological order.
  2. A map is a tree with a parent + its children, each of which is identified by a unique key.
  3. You can even invent your own data structure.

And it’s not just any data structure. It’s a data structure for storing, transferring, and authorizing real value. All this is natively powered by Bitcoin and can be programmatically operated with Bitcoin, in any way you can imagine.

Bitcoin + Metanet: The Most Efficient Programmable Data Ledger

Bitcoin is the most efficient data storage protocol, and Metanet is the most efficient data structure protocol which sits on top of it.

Read below tweet thread first to understand what an efficient data storage protocol means.

Unlike other bloated “blockchain” projects that ripped off Bitcoin but in a completely naive and amateur way and stored their entire state history on chain, making them fundamentally unscalable, Bitcoin is based on UTXO (Unspent Transaction Output).

The minimal UTXO structure allows for a powerful interplay between on-chain and off-chain computation, and is infinitely scalable.

Why build cats on the blockchain when you can build Schrödinger’s cats on the blockchain?

The difference between the functional vs. object oriented paradigm here is huge. For starters, functional programming can do anything OOP can do, but in much more minimal, scalable, and robust manner. As my tweet thread mentions above, there’s a reason why all large enterprise companies are moving their mission critical systems from object oriented to functional paradigm.

But more importantly, this functional programming paradigm is how Metanet adds an additional dimension which no other system can achieve because of their primitive rigid structure based on object oriented programming paradigm.

You take the most minimal data storage protocol (Bitcoin), and build the most minimal data structure protocol on top (Metanet), and when these two create a chemical reaction, you end up with the simplest yet most powerful programmable ledger.

Simplicity is the ultimate sophistication.

Metanet is up there on its own dimension. When you see it, everything else will look like a toy. If you don’t believe me or don’t get it, just ignore and keep playing with your amateur calculator. We will obliterate with a supercomputer.

Metanet: a Fungible Supercomputer

People talk about “fungibility” in Bitcoin all the time, but most of these people have a complete misunderstanding of how fungibility works. This is why you see unfortunate, inferior, and illegal solutions such as Mixing services which mix multiple people’s transactions in order to obfuscate the flow of money.

At the same time while they rave about the “transparency of the blockchain”, they talk about obfuscating transactions.

At the same time while they praise Bitcoin as being the “truth machine”, they work on moving transactions off the blockchain so they can hide the truth.

They don’t understand the power of Bitcoin blockchain lies in the “chain”. And they don’t understand that there may be a better way to preserve the transparent flow of money yet achieve privacy. Just because you are not imaginative enough to think of a solution, doesn’t mean the solution doesn’t exist. It just means you’re not imaginative enough.

Also, the inventor himself explicitly mentioned all of this in the whitepaper as a whole section (Read the whole thing):

The key to Bitcoin’s fungibility is not to illegally mix coins. The key to fungibility is to never reuse keys, you generate a new key every time you make a transaction. Of course, there are times when reusing keys is convenient or unavoidable, but for most cases, you can achieve fungibility by deriving a new key every time.

But Metanet goes further.

If you thought fungible transactions were cool, wait till you learn about Fungible computation.

There have been various silly “blockchain as a computer” attempts in the past, but ALL of them fail at fungibility.

All blockchain systems that call themselves a “DApp platform” fall under this category. All these so-called “blockchain as a computer” are simplistic systems that are inherently limited in their architecture due to their abandonment of the UTXO system, which results in a lack of fungibility and limited computational capacity.

if you look deep into these “DApp blockchain platforms”, they are nothing more than very primitive key/value database systems. In fact if you compare them to any typical application that powers the enterprise and consumer apps we use today, they look like toys.

We can see them as “2D” computing. Primitive and Finite.

Next up we have “3D computation”. These systems didn’t make the mistake of throwing away the elegant UTXO system invented by Bitcoin. Most of these are protocols built on top of Bitcoin. However they are also limited in what they can achieve. They had the potential because of the UTXO based architecture, but all of them failed to realize their full potential. None of them could figure out a way to make use of keys like Metanet does, and they all suffer from brittle systems, bad usability, and most importantly, lack of fungibility.

Finally we have Metanet, a UTXO based 4 dimensional computer. By generating a new key for every new transaction AND identifying each node in the data structure with the generated key AND and allowing a combination of the Metanet tree with an HD key tree, the combination opens the door to a whole new dimension.

We not only have fungible transactions, but also a way to achieve fungible computation, because of the powerful interplay between Bitcoin, Metanet, and Keys.

It’s very important to note that Metanet is NOT about some amateur idea of “decentralized but primitive and amateur computing”.

The goal is NOT about building some amateur “decentralization” science project.

The goal is a whole new deterministic supercomputing paradigm that has never been possible before. If you look at it this way, all other “blockchain projects” look like a toy or a cute social experiment.

And most importantly, unlike all the “DApp platforms”, the way Bitcoin+Metanet works is 100% legal, scalable, and secured by the very consensus mechanism that started this entire industry: Proof of Work mining.

Metanet is Bitcoin’s Infinite Transform Function

I posted this message last year:

And Metanet is this “transform function” that’s been missing from Bitcoin. It doesn’t change a thing about how Bitcoin works. Instead it utilizes the existing unique properties of Bitcoin in the most powerful way.

It’s infinitely scalable. But only if you have the open mind to see past the next dimension.

Now that I’ve discussed briefly about Metanet, let’s see how we can build actual apps on Metanet.

2. Building Metanet Apps

The Metanet Paradigm

So how does Metanet work in practice? What is the paradigm?

It’s like a cloud that exists on Bitcoin. And no, it’s NOT at all “just a Dropbox-like system”. I laugh at anyone who has ever said “so it’s just like a dropbox?”. Get out of your little dropbox and think outside of it. It’s a completely new paradigm.

When I say cloud I don’t mean “cloud” in a traditional sense, I mean a cloud that literally lives on the blockchain. Because of this subtle yet important difference, you can finally truly own your own data.

And it’s more secure than any existing cloud platform because all synchronization is carried out by the keys YOU own. As long as you own the key, you can instantly “sync” from the blockchain, from any where and from any time. And combined with HD key derivation, it gives us another dimension to computation, enabling many things that’s never been possible before.

Here’s a diagram straight from the Metanet presentation:

There are 2 parts to this:

  1. Blockchain data provider: Since synchronizing directly from the blockchain is inefficient, you connect to data providers such as Planaria or Bitbus to request and synchronize ONLY the data you need. (Planaria if you want to run a serverless app; Bitbus if you want to build your OWN specialized Planaria backend and provide it as a Planaria node of your own) These data providers have a deterministic data derivation mechanism that turns the blockchain into a a queryable API. Also, it’s important to note that these are “dumb” APIs, with no lock-in mechanism that will make applications less portable.
  2. SPV: Use SPV to verify the authenticity of the data you received from said data providers. This part is optional but will become increasingly important as more mission critical applications are built around this paradigm. This part will need more work, but we will get there.

This is consistent with the original vision of Planaria (I discuss this in Planaria documentation’s “Write unbundled from Read” section):

It is important that these data carriers unbundle read from write.

And it is also important that these data carriers unbundle authentication from data delivery, giving wallets all the power, yet providing its “dumb” service to users, creating a powerful interplay between the unbundled parties (Read “Decentralized Auth” section of the Planaria documentation)

From here on, you can go even further and build a whole powerful computing framework using systems such as Neon Planaria, and even compute back to the blockchain, but that’s a story for another day. Today let’s focus on the READ part.

Bitcom + Metanet

A while ago, I proposed a new, decentralized way to register Bitcoin application protocols called Bitcom: https://bitcom.planaria.network

Bitcom is a “protocol protocol”, a protocol for registering protocols.

Prior to Bitcom, the conventional approach for distinguishing one application protocol transaction from another was for the application protocol admins to come up with an arbitrary OP_RETURN “prefix” convention, which is just the first push data after OP_RETURN.

This naturally centralized application protocol handling because the application developers had to arbitrarily come up with their own protocol prefix and register it somewhere in a centralized directory, where a group of centralized committee gave or rejected permission to list. This was necessary in order to avoid namespace collision.

Bitcom was created to solve this problem.

The solution was to use a randomly generated Bitcoin address as the prefix and publish it to the blockchain. The uniqueness of randomly generated Bitcoin addresses ensured that there is no need for a centralized directory while avoiding name collision, and the direct publishing to the blockchain gave us a decentralized protocol registry.

Since then, many of the Bitcoin SV application developer community have embraced this convention, spurring protocols like B://, C://, D://, MAP, BCAT, AIP, etc.

You can see the global log here:

So how does Bitcom play with Metanet?

Thanks to the elegant design of Metanet protocol, Bitcom and Metanet are perfectly compatible. In fact it’s almost as if the two protocols were meant for each other.

A good way to think of this is:

  • Bitcom is a data schema protocol
  • Metanet is a data structure protocol

In Metanet, each node may have an additional sequence of push data that implements the application protocol, and the metanet protocol creates an overlay data structure made up of these nodes. In the following example, we see a Metanet node transaction that contains the B Bitcom protocol.

Querying the Metanet: The Naive Way

Metanet uses the prefix meta to indicate that a transaction is a metanet transaction. Since Metanet transactions are all just Bitcoin transactions, you can already see metanet transactions on Neon Genesis:

https://neongenesis.bitdb.network/query/1HcBPzWoKDL2FhCMbocQmLuFTYsiD73u1j/ewogICJ2IjogMywKICAicSI6IHsKICAgICJmaW5kIjogewogICAgICAib3V0LnMxIjogIm1ldGEiCiAgICB9CiAgfQp9

The problem with this is that it is just a dumb list of global metanet transactions.

However, the REAL power of Metanet is in the graph.

There’s not really much you can do with above data because it doesn’t support a graph traversal query.

We need something that can deal with graphs.

And that’s what Metanet Planaria does.

Introducing Metanet Planaria

Above I’ve mentioned there are two parts to Metanet:

  1. Data Provider
  2. SPV

And Planaria can power the first piece of the puzzle: Data Provider.

Here’s how Metanet is different from other Planaria nodes such as Genesis, Babel, and Chronos.

  1. Only Indexes Metanet: All meta prefixed transactions and nothing more.
  2. Graph traversal: Ability to only query a subgraph of the Metanet

This means you’ll get the global Metanet when you simply query:

{
"v": 3,
"q": {
"find": {}
}
}

from the metanet planaria.

But the important part is the graph query. Let’s take a look.

Planaria Metanet Query

Below is an example Metanet graph. Let’s start by imagining that “Domain P0” is the Bitstagram universe.

The problem with the current version of Bitstgram is that it’s just a global feed, and there is no concept of users. But we can imagine a Bitstagram which supports user accounts, powered by Metanet.

“Domain P1, P2, …” may be its user accounts. Each user has child nodes, each used to organize the data structure of the subtree.

For example “Domain P1,1” may represent the user’s timeline. To be able to get the user’s timeline, we may want to use a query such as:

Find all nodes under Domain P1,1 which follows a Bitcom protocol 19HxigV4QyBv3tHpQVcUEQyq1pzZVdoAut

To do this, you will first want to select the node (P1,1 — TxID1,1) and then traverse all its descendants (P1,1,1 — TxID1,1,1 and P1,1,2 — TxID1,1,2) to filter out only the transactions that contain the 19HxigV4QyBv3tHpQVcUEQyq1pzZVdoAut prefix.

Also sometimes you may want to traverse down to a certain level. And sometimes you may want to traverse and at the same time filter by attributes. Sometimes you may want to project the filtered result to only return certain attributes.

Sounds powerful? Well, all this is possible TODAY.

So how would it exactly work? What should you query for?

Bitquery: Metanet Edition

Being able to make flexible graph queries efficiently means the following types of queries become possible:

  1. Get all items for the global metanet graph that follows a Bitcom protocol X (For example, B)
  2. Get all “files” for a single user in a Metanet graph.
  3. Filter metanet for certain specific attributes that appear anywhere in the subtree.
  4. Get a subtree of an organization’s graph which contains certain attributes, but run a partial traversal (instead of fully traversing to the leaf nodes).

To provide this feature, we introduce a new attribute to Bitquery: “select”.

Basically, it selects a node by any of its three attributes:

  • “a”: address
  • “tx”: transaction_id
  • “id”: H(address||transaction_id)

And then from there traverses its descendants to filter exactly what you’re looking for. The rest of the query language should be familiar if you’ve used Bitquery before, since it’s the same Bitquery used in all of public Planaria nodes as well as Bitbus.

Note how it’s just an extension of Bitquery and supports all the features you’re already familiar with, such as “project”, and even the transformer function “r.f” powered by JQ.

Example Queries

Here are some example queries:

Here we select the very root node (A0, Tx0) and run the query from there. The query will filter the subtree and return the response.

Below we select (A2, Tx2) and from there traverse the graph and query its descendants.

Finally in the diagram below, we select (A3, Tx3) and start the query from there:

3. Conclusion

Metanet is a powerful protocol for creating data structure out of Bitcoin transactions.

It is the first and only fungible computation platform.

It’s the first ever solution that lets you truly own your data.

It lets you build a portable infinite computer.

And it is ready for you to build on, today.

Welcome to the 4th dimension.

Visit Metanet Planaria

https://metanet.planaria.network

Read the Whitepaper:

_unwriter

Written by

_unwriter

https://neon.planaria.network