In Web2, your profile is your identity.
In Web3, your identity is your keys.

They get you from Banks to DeFi.
They get you from Facebook to Lens Protocol.

This thread is about the most important piece that is still missing:

It’s no secret that Meta (Twitter) owns you.

They own your content, your connections, your messages, and your images.
With a flick of a switch they can block you. You won’t know why.

As a creator, your business entirely depends on their algorithms,  rules and outages.

Web3 will fix this. It is just a matter of time.

On @lensprotocol you own your profile, your connections, and your content.
You can take it with you to whichever platform you prefer.

But there is one big missing piece that will still keep us at BigTech.

Can you guess it?

It’s Messaging.

The core primitive of the internet, with which it all started at ARPANET in the 70s.

The fine team at @xmtp_ made it its mission to build the messaging infrastructure of Web3.

Here is how it works:

XMTP, short for Extensible Message Transport Protocol is a
“protocol, network and standard for secure, private web3 messaging”.

The idea is to allow any two wallets (that is, keys) to communicate with each other, without relying on existing centralised messaging infrastructure.

Email requires an ISP.
Telegram requires a phone number.
Messenger requires a Facebook account.

XMTP requires a key pair, which anyone can create at any time without asking for permission.

This means you own your messages.

This is akin to Lens Profiles or Crypto Tokens.
Your messages are tied to your wallet and therefore agnostic of the frontend application you are using to read and write them.

XMTP is chain-agnostic, but restricted to EVM compatibility (for the moment).

All wallets that are EVM compatible can message each other via the protocol, given that both of them joined the XMTP network.

XMTP does not run on a blockchain, but instead is an off-chain network itself.

Currently, XMTP Labs runs all of the network nodes, meaning it is fully centralised.

They will step by step decentralise this network through a so called phased decentralisation.

XMTP is not a blockchain itself either, but a set of nodes that sync the information with each other.

It shares with blockchains data availability is guaranteed through a network of distributed nodes that sync with each other.

Unlike Blockchains, it doesn’t produce blocks, but is a system that is highly tuned to store and relay encrypted messages.

Now to the juicy part: what about costs and spam?

As of now, messaging between any two clients on XMTP does not incur a fee.

It will get interesting, however, once the network decentralises, as it needs to sustain itself.

In particular, node operators need an economic incentive to provide their service.

Another important factor is spam.

When email was conceived in the early 70s, the inventors probably didn’t think of billions of unsolicited emails being sent around the world, mostly advertising very dubious products, to say the very least.

XMTP plans to and will have to strike the right economic incentive to make spam and unsolicited messaging infeasible.

One way to go about it is a technique similar to how Ethereum secures its network: Staking.

In order to write to a wallet you are not connected to yet, you will have to put some tokens at stake, to prove your good intent.

Finally, and maybe most importantly, here are some of the use cases:

Wallet-to-Wallet:

In Web2, your profile is your identity.
In Web3, your identity are your keys.

Consequently, you decide how much of your personality should shine through.

XMTP allows users to communicate, solely based on their identities as given by their wallet addresses.

I can discuss an NFT swap with @Snowden, without knowing it’s him.
But I know I am talking to the person who owns the identity.

dApp-to-Wallet:

The promise of Web3 is a trustless and permissionless web in which everyone can interact with protocols as they please.

Soon, these protocols won’t need any email addresses or other identifiable handles anymore to reach out to their users.

XMTP will allow them to reach out via notifications, chat interfaces, or messages delivered to a Software Wallet - the possibilities are endless.

On-Chain communities:

It is often said that Web3 is a Renaissance for creators and artists. That’s because it is!

Using XMTP makes it straight forward to reach out to all wallets who own or owned your art as proven by the NFT’s on-chain provenance.

Just like Lens Protocol, XMTP aims to build the best-in-class infrastructure that will be used by developers to build truly remarkable experiences on top of it.

As Co-Founder @ShaneMac put it:

“28 developers launched on XMTP, and 22 [of those] ideas, none of us had thought of!”

I’m excited for what’s next (and, of course, for the release of the Swift SDK :))

You can read the unrolled version of this thread here: https://typefully.com/CordtMinzer/876a0KU

Back to where it all started: Messaging in Web3

Last Friday, the first lecture of @unicmetaverse was held by @giaglis and @punk6529.

I have read and written about NFTs various times, but there is always new perspectives to be gained.

One golden nugget in the lecture really struck me:

Back in the day and all the way until today, buying a piece of land means buying a signature on a piece of paper.

Some authority granting you (restricted) use of a patch of land on this planet.

No wonder the piece of paper is called land register.

The important point is that you cannot buy the land itself.

While you say you buy it, what you really buy is the deed.

And the deed is only as good as the authority issuing it.

Now, how does that relate to NFTs?

People pointing at the fact that you can simply right-click images to get hold of an NFT are fully misunderstanding what an NFT actually is.

The NFT is the deed. It is the pointer to the land with a cryptographic signature.

So this his how an NFT is similar to a deed from the land register.

And how is it different?

The issuing authority is not a government or any other bureaucracy. It is a blockchain, which has the distinct property of not requiring any trust.

Whether or how much you or the market value the jpeg the NFT might be pointing at is a different topic.

You might as well discuss the price tag on the Mona Lisa.

The real breakthrough is that we built a system that can establish deeds, without authorities it relies on.

You can read the unrolled version of this thread here: https://typefully.com/CordtMinzer/MlkFZdP

NFTs are Deeds

Oracles predict the future.

Except in Blockchains, they don’t.

How Oracles work and why they are a cornerstone of Web3 Infrastructure:

“Danger will threat from a wooden boat, and a herald in scarlet”
— The Pythoness

Oracles are known to have existed for more than 4K years, basically making predictions when prompted with a question.

The correctness of those predictions, however, has always been rather doubtful.

Blockchain Oracles are not that different from the ancient ones, with the notable difference that it is sufficient for the answers to stem from the present, but we do expect it to be accurate.

Here is all you need to know:

Why do we need Oracles?

Smart Contracts can only interact with other accounts (including other contracts) on the blockchain itself (on-chain).

If they were to rely on external APIs, Nodes wouldn't be guaranteed to agree on the chain’s state, thereby breaking consensus.

But many dApps, especially in DeFi, rely on real-world data like price feeds to do their work.

Oracles are the missing piece that gets them the required data.

How do Oracles work?

Oracles are an adapter to the outside world, providing Smart Contracts with whichever data they are asking for.

The key difference to directly getting off-chain data is that the oracle writes the answer it was asked for back on chain in a transaction.

The data doesn’t arrive in real-time like in an API, but instead trickles back onto the chain in form of transactions.

Block by block.
Immutable and agreeable.

What is the Oracle Problem?

While this sounds neat in theory, a system as described above would break the key property of a blockchain: decentralisation.

By relying on a single, centralised source for even one piece of information, the Smart Contract immediately becomes the weakest link in the application.

In 2017, @chainlink embarked on a mission to solve the Oracle Problem.

How does @chainlink solve the Oracle Problem?

Basically, in two steps:

1️⃣ A network of Nodes (that anyone can run) fulfils data requests coming from the Contracts.

The oracle contract on the blockchain evaluates the answer from multiple Nodes to arrive at a trustworthy answer.

2️⃣ A set of careful incentives makes sure that Nodes act honest.

The node needs to put some Tokens at Stake when fulfilling requests. If it was detected to act maliciously, some or all of the stake might be slashed.

What makes Oracles a cornerstone of Web3 Infrastructure?

Without data from the real world, many crypto projects would be a solution looking for a problem. Killer Apps in data silos.

Here are three examples of applications that heavily rely on off-chain data:

1️⃣ Lottery

Any dApp that requires a random number (e.g. pick a winner), will need an oracle. Since Blockchains are deterministic, there is no way to generate truly random numbers on-chain.

Applications like @PoolTogether_ thus rely on oracles to pick a winner each week 🎉

2️⃣ Stablecoins

Most Stables are pegged to fiat currencies like USD.

This in turn means that a USD price feed is necessary, to run the mechanisms that keep the Stablecoin at peg.

3️⃣ Insurances

In the near future, Blockchain powered insurances might be able to fully automate and transparently manage premium payments and claim payouts.

To do so, the contracts powering this application will heavily rely on data that proofs whether a given claim is sound.

This could, for example, be weather data that describes catastrophic events.

Wrapping it up

Blockchains are an amazing technology, but many of the game-changing innovations will rely on off-chain data that is reliably and temper-proof fed into the system.

Oracles will play a key role in providing it.

You can read the unrolled version of this thread here: https://typefully.com/CordtMinzer/iydyRYj

Oracles: The window to the outside world for Smart Contracts

The future of Social Networks is in Web3.

Which platform you ask?

No platform. A protocol 🧵👇

@lensprotocol completely redefines the social network:

Users own their profiles and data.
Users choose whichever interface (dApp) suits their needs best.
Users define how others can interact with their content.

Let’s dive into it :)

While it seems similar to traditional social networks on the outside, Lens defines a whole new paradigm of how we connect and interact. 

Let's look at three core concepts of the protocol:

1️⃣ Lens defines a so called Social Graph

1. This graph lives transparently and censorship-resistant on the @0xPolygon network

2. All connections and interactions between the network participants are stored in it

3. It is defined by a set of Smart Contracts

2️⃣ Your profile is represented as an NFT

1. You are the owner of your profile

2. Your ownership is given by the fact that you hold the NFT with your wallet

3️⃣ Interactions between network participants do not require a Lens profile

1. Everyone can interact permissionless with the network

2. The claiming of profile handles is moderated though, in that the Lens governance currently needs to whitelist wallets for claiming handles

So Lens Protocol is exactly what it says: 
A protocol, i.e. a set of smart contracts.

It is not the network (the network is @0xPolygon).

It doesn't own the profiles (the profiles are represented by NFTs, owned by the users).

It's contracts, which define the connections.

The core Smart Contract that powers most of the interactions is an upgradable contract, meaning that it can be changed to some degree, when the team wants to improve functionality.

More on that here:
https://twitter.com/CordtMinzer/status/1537027144634642432

Now, if Lens only defines how the Social Graph works, what does that mean for the applications users interact with?

Who builds the User Interface?

Since the graph happens to run on @0xPolygon, which transparently shows all transactions and data, it means... 

...anyone can build dApps on top of it to visualise this graph and allow to interact with it!

Every user can decide to use whichever dApp they prefer, fully agnostic of the network that you built.

This is the power of Web3. 
You own your data and take it whereever you want.

Think you can build the next Twitter on Web3? 
Go ahead, the users are already there :)

I fact, I believe the next Twitter will be built right there:
https://twitter.com/CordtMinzer/status/1547219319746019328

One feature of Lens really stands out in comparison to Social Media as we know it: 

Modules.

Technically, modules are smart contracts that extend the functionality of the protocol.

Modules allow to modify the three key interactions within the protocol:

1. Following
2. Collecting
3. Referencing

They are executed, whenever one of those key interactions is performed.

It's like combining Twitter with Zapier: 
When @dabit3 tweets, send me an automated E-mail.

1️⃣ Following

The module is executed whenever someone follows a given profile.

You could, for example, require a fee of 0.1 Matic for someone to follow you. 
Being connected to you has its price tag 💰

Want to grow your audience? 
Why not offer 0.1 Matic for following you 🤓

2️⃣ Collecting

This module is executed whenever someone wants to “collect” your content.

To my mind, this is the real Web3 native core feature right there: 

The possibility to support and participate in a creator’s content, in every imaginable(=programmable) way:

Do you like this thread? 
Become the unique donator of it by purchasing the NFT that represents it for 10 Matic.

For your generosity and to share the success of it, I’ll pay you 0.01 Matic for every Mirror of it thereafter.

Think of @viamirror built into a social network!

3️⃣ Referencing

This module is executed when a profile comments on or mirrors (think shares) your content.

Again, your imagination is the limit to as what could possibly be done upon this interaction:

Comment on this thread until tomorrow and I will pick a winner at random who will be awarded 10 Matic.

Don’t believe me? 

It’s written in the code of my reference module. 
All conditions, all caveats. 
In plain text (i.e. Solidity) for you to check.

That's it for now about Lens Protocol :)

I hope you are as excited about this technology as I am!

In the following weeks I will build an iOS Client on top of @LensProtocol and share my progress here

Make sure to follow me, if you are interested!

You can read the unrolled version of this thread here: https://typefully.com/CordtMinzer/AF4WV1W

Lens Protocol - How the future of Social Networks might look like

In 2003, Facebook defined Web 2.0 by leveraging user-generated content at scale.

Zuck turned the network effect into a money printing machine.


In 2022, Web3 brought the technology to disrupt this machine.

This year will be remembered for defining a new Shelling point.
🧵

Back in the day Harvard had no online face book, which Zuck commented as follows:

“I think it's kind of silly that it would take the University a couple of years to get around to it. I can do it better than they can, and I can do it in a week.”

The idea he had (after FaceMash, which almost got him expelled), is what we all now know by the name of Facebook.

His (and any other network’s) now biggest asset, was his biggest challenge when he started:

The network effect.

The network effect is defined as the phenomenon by which the value or utility of a service depends on the number of users, who are part of the network.

Value and utility. 
Both matter, but for different reasons.

1️⃣ Value

Suppose I'm a wedding photographer in New York.
Facebook allows me to run an ad that targets recently engaged couples, mid to high salary, east coast.

This  o n l y  works because the network is so incredibly extensive, covering virtually every possible target group.

2️⃣ Utility

Suppose I did a semester abroad in Zurich (which I highly recommend).

Facebook lets me connect to all the folks I met there, so we can stay in touch. 

No pen pals. Web 2.0 pals.

This  o n l y  works because the network is so incredibly widespread, everyone's there!

For the very same reason the network effect is also your biggest challenge when you start off: 

No network, no value, no utility.

Now, this sounds all fun and games until Zuck is obscenely rich, but all the users, let alone content creators, don’t see a dime.

Every piece of content, every single like, every photo, video and story you shared.

All of it belongs to, increases the value of, and serves the interest of Facebook.

The network became so massive, that it virtually doesn’t see any competition in its realm.

Nobody is going to build a “better” social network that will throw Facebook off its throne.

New products won’t make the cut. 
But technology will.

Web3 is going to redefine social media. 
Here is how:

The reason why FB’s position is so untouchable is the extreme user lock-in.

All your friends are there, many of them are indeed only there.
Not in your phone book - only in your Facebook.

If you are a content creator it goes much further than this.

Your audience, your interactions and your channels for outreach. 
Everything is locked-in.

Now that I really hammered this point. Can you imagine what would be disruptive?

Taking your content with you would be.

Not in a delete-your-profile sense.

Rather in a -taking your content, connections, and reputation and making use of it on a platform that suits you better- sense.

How does it work?

The distinct feature of Blockchains like Ethereum is having a programmable, censorship-resistant, permissionless computer that is available 24/7 and owned by its users.

It's everyone's servant.

Noone is its master.

If you now place a social network onto this blockchain, you create a truly decentralised, user-owned, and transparent platform.

@LensProtocol and @desoprotocol are two examples of what will happen in this exciting space.

Will write about them soon!

Admittedly, I am being a little imprecise here. 
I’m not comparing like with like.

The “network”, in fact, stays exactly where it is (on the blockchain). 
You don’t take it anywhere (you cannot even delete it 😬).

What you can actually swap is the application that runs on it.

I expect many Interfaces (dApps) to emerge that will offer users different views and entry points to the social graphs that live on the Blockchain.

Many of them already exist and many will follow.

And users will pick whichever lets them interact with content best.

It’s a complete paradigm shift:

People publish and connect on the blockchain. They decide, at any point in time, who can interact in which ways with their profile and publications.

Your wallet holds access to your content.

The next Web is user owned.

You can read the unrolled version of this thread here: https://typefully.com/CordtMinzer/QJVdaWy

Why Web3 redefines Social Media

Smart Contracts are an agreement written in code.

A guarantee that the contract you send your funds to will always stay the same.

Unfortunately, this is not exactly true 🧵👇

“If you’re not embarrassed by the first version of your product, you’ve launched too late.” — Reid Hoffman

I agree with Mr. Hoffman, but when developing in Web3, things look a little different.

Here is the fundamental difference between running your backend on AWS vs Ethereum:

Let's say you find a bug in your product.

AWS: Change your code and deploy the new version.
Your users won't even notice.

Ethereum: Change your code and deploy a new contract.
Convince every single one of your users to migrate to your new contract.

Though posing a major challenge to developers, immutability is a core concept of blockchain technology:

You are guaranteed that the contract your send your funds to cannot change.

The Smart Contract's code is the truth, no trust required.

Why is that a challenge for developers? 

Every dev worth their salt will tell you that bugs in software are inevitable. It is just a matter of discovering them.

Being unable to change a Smart Contract, once deployed, therefore poses a big challenge:

How to fix bugs?

Immutability is a core property of the EVM. 

A contract cannot be changed anymore, once it was deployed.


Immutability is a feature, not a bug. 

When you send funds to a contract you have a guarantee that they can only be used according to the contract’s implementation.

So code is immutable.

But data is not.

Let's look at upgradability on Ethereum.

Upgradable means the code that is executed can be changed, while the state - that is balance and storage - are preserved.

Emphasis is on "that is executed".

We cannot change the code, but we can decide to use a different contract.

There are basically three ways to achieve some degree of upgradability:

1️⃣ Parametrisation
2️⃣ Migration
3️⃣ Proxy

1️⃣ Parametrisation

Admittedly, calling this an upgrade is a bit far-fetched.

The basic idea is to be able to modify the way your contract works by parameterising it.

E.g. setting the fee that a DeFi app charges on each transaction.

This doesn't help to solve any bugs though.

2️⃣ Migration

Easy but painful; never a 100% solution.

A new contract is deployed and users are asked to migrate their funds to the new one.

Due to the fact that you'll never be able to get all users to move - let alone at once - this rarely is an option.

Instead, the default use case for Migrations is a rich feature upgrade.

Ever wonder why version numbers are so prevalent in Web3?

For example, Uniswap v3 introduced "Concentrated Liquidity", a feature so complex that it justified a whole new version of the exchange.

3️⃣ Proxy

Of the three, the proxy pattern is the only one that allows for an actual upgrade in the sense of software development.

The basic idea is to have a proxy contract that the dApp interacts with, which points to the logic contract.

To upgrade the system, two steps are necessary:

1. A new logic contract is deployed
2. The field in the proxy contract that points to the logic contract is updated to the new contract address

Since the address of the proxy contract never changes, users never have to migrate, but seamlessly interact with the new contract.

This pattern is more than a trick of some smart developer, it’s a feature of the EVM!

In distinction to the CALL function, the DELEGATECALL function does execute the code in the logic contract, but it does so in the context of the delegate contract.

This is means that the state will never be subject to an upgrade, only the code will.

The crucial question is how can the delegated contract be updated?

One of the easiest implementations is to restrict the upgrade function that changes the address to an admin user.

The address of this admin user is defined in the contract itself, clearly defining this responsibility at the time of deployment.

For contracts that handle large amounts of funds, this responsibility is usually assigned to multi-signature wallets.

You might be wondering how this doesn’t completely undermine Ethereum’s immutability property.

I would say it does, but in a very defined manner and only in a very limited way - here are my 2 cents:

First, state cannot change, only the code can:

Due to the state in which every transaction is executed being stored in the proxy contract, any future upgrade must be fully compatible with the schema.

Second, it's defined and visible:

Since the possibility to use this pattern is part of the Solidity language, it is a dedicated mechanism that can be comprehended reading the contract itself - for example on Etherscan.

One example that uses the Proxy Pattern is @LensProtocol.

It makes use of upgradable contracts, but only to a very limited degree.

The “admin” in that scenario is multi-sig key controlled by the protocol’s governance, allowing only the community to upgrade to a new contract.

In practice, this is only meant to be used as a backup (for bug fixes), the actual modularity of the protocol is achieved differently.

How does it work?

Follow for the next thread :)

https://docs.lens.xyz/docs/lenshub

You can read the unrolled version of this thread here: https://typefully.com/CordtMinzer/tyGh70t

Upgradability: Designing for Improvement

Provenance sounds like a region in France, but is in fact a key concept for NFTs.

I recommend you to visit the region at some point, but let’s focus on the concept for now 🧵👇

First off, let’s establish what an NFT is NOT: 
It is not the piece of art you are buying.

So, @punk6529’s Cryptopunk is not the NFT, but the art.

The underlying NFT is, as the name suggest, a unique token on Ethereum that represents ownership of the Cryptopunk, related to it.

In short: 

An NFT is a token on a blockchain that establishes the ownership of a digital or physical asset.

While it might be straightforward to imagine how the Token and the Owner can be stored on the Blockchain, it is much harder to record the art itself and the place where it is stored.

Provenance is defined as the “record of ownership of a piece of art” or “the place of origin”.

In the case of NFTs on Ethereum, Provenance basically refers to three things:

1️⃣ Sequence of formal ownership
2️⃣ Place of storage
3️⃣ Mechanism to verify the NFT's integrity

Let's unpack them, one by one.

1️⃣ Sequence of formal ownership

This is, for the first time, unequivocally and invariably recorded, using a Blockchain like Ethereum.

It all starts with an NFT project, deploying their collection on the mainnet:

The NFTs of the collection are owned by the contract itself, with the contract also defining precisely how the minting will work.

Once a user mints an NFT, which means generating it from the contract’s collection, both the transfer and the ownership are recorded on Ethereum.

1. The owner is stored directly in the Contract.

2. The transfer from the contract to the new owner is included as a transaction in a block.

This design ensures that both the sequence of ownership and the current owner are always unambiguously retrievable from the Ethereum Blockchain.

This is Sequence of formal ownership. 

Ouster impossible.

2️⃣ Place of storage

Each item in the collection is given a specific location in form of a URI (Unique Resource Identifier).

This is a requirement of ERC-721, Ethereums implementation of NFTs.

https://twitter.com/CordtMinzer/status/1522229641209020416

But this, for some projects, introduces a hole in the otherwise seamless ledger:

If the place of storage is not Ethereum itself, but an external location, all security guarantees are gone and the availability and integrity of the item depend on this external location 🕳

Storing the asset on Ethereum itself is rarely an option either, as the Blockchain offers one of the most expensive digital real estate out there 💰

What can be done? Let's look at two prominent examples:

Cryptopunks: 

Ever wonder why pixel-art is so prominent in our space? It's because it needs so little storage.

In the case of Cryptopunks, both Bytes and SVG are directly stored in the contract. 

Query, download, open in your browser.

Expensive, but secured by Ethereum.

BAYC: 

Looking at a Bored Ape jpeg, you can immediately tell that this will be wildly expensive to store on Ethereum.

Instead, the project stores a reference to the Metadata on IPFS in the contract. 

This is where Provenance, in terms of integrity, becomes important.

3️⃣ Mechanism to verify the NFT's integrity

What's needed is a guarantee that the NFT that is stored at a given location is indeed the one that was minted or bought.

This comes down to two important properties:

1. It can be verified that a given asset (e.g. an image) is actually the image that belongs to the NFT and hasn’t been tampered with (integrity).

2. It can be verified that the asset which belongs to the NFT you minted was associated with it in the first place (authenticity).

Why is this even important?

Many PFP NFT projects use generative art to create the various different images.

This basically means mixing so called ‘traits’ to form the final image.

Which hat, is it smoking, cool sunglasses? You name it.

Mixing these traits forms the image and comes with a certain rarity.

The rarity is basically the combination of how rare every single trait occurs within the collection.

So for the highest upside, you look for the rarest NFTs.

To prevent savvy traders from front-running everyone else by targeting the rarest elements of the collection, the project often uses a reveal date, which is slightly after the mint date.

That way you buy the pig in a poke :)

Coming back to the problem, how can we ensure the two required properties (integrity and authenticity)?

Let’s look at it using the example of BAYC:

Each Ape is associated a Token ID.

This already happened pre-mint by the creators, Yuga Labs.

Then, each Ape is associated with a Fingerprint. This is as simple as using a hash function on the Image Data.

Looking closely at the BAYC Contract on Ethereum, you will notice a field called “BAYC_PROVENANCE”.

Just one field for all apes?  Here is the trick:

The provenance field in the contract is a hash of all fingerprints of all Apes concatenated together and then hashed again 🤯


The reason for this is that it both combines the integrity of all Ape Images as well as their order, which was defined pre-mint:

Changing the order of the Images or just a single pixel of one of the apes would yield a different result.

All the data required to reproduce this result can be found on their website:
https://boredapeyachtclub.com/#/provenance

You can have a look at the contract on Ethereum here: https://etherscan.io/address/0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d#readContract

Ok, that was a lot. Here is a short recap:

1️⃣ An NFT is a token on a blockchain that establishes the ownership of a digital or physical asset.

2️⃣ Provenance means sequence of formal ownership, place of storage and mechanism to verify the NFT's integrity.

3️⃣ Some projects store NFT data on Ethereum, but that's expensive.

4️⃣ Other projects store NFT data on IPFS, but need to use Provenance to verify integrity.

You can read the unrolled version of this thread here: https://typefully.com/CordtMinzer/UXJjaWu

Provenance: A Record of Ownership on the Blockchain

When you want to ape into the next hot NFT project, everyone, including @chriscantino and your grandma will tell you to DYOR!

And they are, of course, right.

Here is how to find, read and use an NFT contract on Ethereum 🧵👇

Before we dive into it, let’s establish what Contract means and how it works.

A contract on Ethereum is a piece of code that acts similar to Backend Code on other systems, with the notable difference that all of it is public.

That means that everyone can interact with this code, which most of you do all the time:

When you use your favourite DEX, when you buy an NFT on OpenSea, etc.

Every time you sign a Transaction with your wallet, you interact with a contract.

One important thing to note is that interacting with Ethereum “might” incur costs. 

These costs are called gas fees :)

Why “might”? 

Because by and far, this is only the case when you make requests that change the state of the Blockchain. 

That is, writing to it.

When you just read from the contract, it’s for free.

We will see later how to make use of this and how you can tell from the contract that this is a read-property.

Now let’s move on and explore a contract!

ERC-20 defines fungible Tokens on Ethereum, like $MKR, the MakerDAO Token.

In contrast to this, ERC-721 defines tokens that are non-fungible (each is unique).

Hence the name NFT, Non-Fungible Token.

The interface of ERC-721 defines how an NFT collection is stored on Ethereum.

It is described in much detail (including the actual interface) here: http://erc721.org

The interface defines several functions, let's have a look at a few important ones!

transferFrom: 

Transfers the ownership from the current owner to a new one. 
As stated in the comments of the function, it won’t work unless the wallet calling this function is the actual current owner of the NFT :)

ownerOf: 

Takes the index of the NFT and returns the wallet address of the current owner.

totalSupply: 

Returns the total number of NFTs in the given collection. 
In the case of BAYC, it’s 10,000.

Ok, so far so good.
Now, let’s say we want to learn about a particular Ape from BAYC and see what we find!

First, head to etherscan.io and type “BAYC” into the search field.

The list of suggestions will offer you “Bored Ape Yacht Club", among others. Select it.

This will take you directly to the ERC-721 Contract for BAYC on Ethereum: https://etherscan.io/token/0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d

The list of transfers at the bottom gives you an overview of the various Apes changing their owners. 

But we are interested in the Contract, so click on the Tab.

The Contract Source Code shows you the source code of this contract.

It's written in Solidity, the programming language to write Smart Contracts on Ethereum.

Jump to line 1906 to convince yourself that this contract is indeed one that adheres to the ERC-721 standard:

contract BoredApeYachtClub is ERC721, Ownable { … }

Now we are not going to start dissecting the code line by line, but instead do some actual research.

On the top, next to the “Code” button, click on “Read Contract”.

This shows a list of fields that can be read or queried.

Read means this is a field in the contract that you can simply look at.

Let’s check the maximum number of Apes available. Click on “MAX_APES”. 

It will tell you that there are a total of 10,000 Apes 🦧

Query means we need to give the contract an input parameter first for it to return us a result.

Let’s say we want to know who the owner of Ape 648 is. Go to ownerOf, enter 648 and hit “Query”.

This gives you the public Address of the Wallet that owns Ape 648!

Next, we might want to know how the “Art” is stored. Basically, there are two options:

1️⃣ Directly stored on Ethereum
2️⃣ Stored somewhere else, with a reference left on Ethereum

I will write a more detailed thread on this topic, for the moment let’s just understand where the Apes are stored.

Head to field 20 in the Contract. It's called "TokenURI".

Enter 648 and hit Query. If you read my previous threads, this will look familiar to you!

It’s an IPFS Content Identifier!
https://twitter.com/CordtMinzer/status/1514226909239939080

To open it, we can directly use the browser: https://ipfs.io/ipfs/QmeSjSinHpPnmXmspMjwiXyN6zS4E9zccariGR3jxcaWtq/648

What you see here is the Metadata, associated with the Ape, stored on the Interplanetary File System.

If reading it gives you a headache, you can use a JSON Linter to improve readability. Just paste the content here:
https://jsonlint.com

As you can see, all the traits of the Ape are listed here, as well as the place where the Image of the Ape is stored!


This is pretty much the information that OpenSea would display to you as well. 

Now you know where it’s all coming from :)

Next, let’s track the image. 

Take the Content Identifier from the Metadata and construct the URL:

https://ipfs.io/ipfs/QmXK1CPJ4rUGDnGVwdXiQQ9LUCi6g832XBQQYiskhMYigK

Voila, this is Ape number 648, that is associated with the NFT we just investigated.

This was an introduction to reading a Contract on Ethereum, but obviously there is much more to researching an NFT project well.

One question you might ask is, how one can make sure that the Ape Jpeg was not and will not be tampered with.

Will write about it in detail soon!

I also recommend having a look at @chriscantino’s Thread that highlights some other aspects of contracts and project metrics:

https://twitter.com/chriscantino/status/1480300076786274304

You can read the unrolled version of this thread here: https://typefully.com/CordtMinzer/2ghtKGa

How to read an NFT Contract on Ethereum

Decentralising storage is a corner stone of Web3 Infrastructure.

To make it work, incentives need to be aligned carefully.

How @Filecoin is building a decentralised Dropbox 🧵👇

The basic idea of Filecoin is a simple one:

Anyone can offer to store data.

Anyone can pay money to have their data stored.

Bargained and recorded on a Blockchain. No intermediary required.

The idea is also very similar to how Bitcoin works: 

A user asks a Storage Provider (SP) to store and retain a file for a fee.

This is a transaction between the two, whose details are stored on the Blockchain.

Filecoin ($FIL) is the utility token that fuels this economy.

There are also two important differences to Blockchains like Bitcoin, adding significantly to Filecoin's complexity:

1️⃣ The SP needs to prove that they actually stored the file

2️⃣ The SP needs to continuously prove that they still retain the file and can provide it as needed

Two specific Proof-Systems have been developed that address those requirements:

1️⃣ Proof of Replication (PoRep)
2️⃣ Proof of Spacetime (PoSt)

Let's understand them on a high level!

1️⃣ Proof of Replication (PoRep)

This proof has two parts:

First, the prover proves to the verifier that a certain amount of disk space has been "spent".

This is like Proof of Work, but the resource spent is disk space instead of computational work!

Second, the prover proves to the verifier that the stored data is intact and can be retrieved.

The first part is called Proof of Space.
The second part is called Proof of Retrievability.

A PoRep thus proves that unique resources have been dedicated to store some data.

2️⃣ Proof of Spacetime (PoSt)

In essence, a PoSt is a sequence of Proofs of Space over time.

To ensure that it is still the right piece of data, the proof requires information from the original data that only someone who performed the PoRep can possess.

Now, this was a whole lot of proofs to guarantee two things:

1️⃣ The file has actually been stored
2️⃣ The file is retained over time and can be retrieved

But how are Storage Providers rewarded for their efforts?

Let's move on to the incentive layer!

In my previous Thread, I explained the Interplanetary File System (IPFS).

It allows to store data in a decentralised way, without intermediary.

The missing part: 
An incentive layer that aligns the interests of Users, Storage Providers and Miners.

https://twitter.com/CordtMinzer/status/1514226909239939080

Filecoin is exactly that:

An incentive layer built right on top of IPFS, both of which are developed by @protocollabs. 

The protagonists are as follows:

1. Clients, who want to store data
2. SPs, who offer storage
3. Miners, who add transactions to the Filecoin Blockchain

The process goes like this:

Clients hire SPs to store Pieces of data - parts of or complete files.

They propose a deal to the SP, which contains
- the basic data of the deal and
- cryptographic information that defines the data.

The offer, which is the Client's bid to the SP for storing the data, is based on the market price.

If the SP agrees, the file is sent over and the deal is settled by a miner on the Filecoin Blockchain.

Now, what stops the SP from removing the data, once the deal is settled?

A vesting period for the reward does!

The rewards for storing the data are vested, meaning they are released to the SP over time.

But this is not enough.

What if the SP decides at some point to not store the data anymore, accepting to lose part of the deal sum?

To prevent this, SPs have to additionally stake some Filecoin as a collateral to guarantee good behaviour.

Whenever an SP fails to provide a PoSt upon request, a portion of their stake is slashed.

This set of incentives makes the most economic behaviour simple: Acting honestly.

If you want to dig deeper, here are some resources I used for this Thread:

https://eprint.iacr.org/2018/678.pdf
https://proto.school/verifying-storage-on-filecoin/


You can read the unrolled version of this thread here: https://typefully.com/CordtMinzer/dUTLMuc

Filecoin: A Decentralised Dropbox for Web3

Say you spend a solid 120⟠ on an NFT, just to have your new precious JPEG hosted on S3 🙈

Even worse, the location is permanently stored in the Contract.

If someone tampers with the file then what?

Let's look at an alternative that fits Web3 better 🧵👇

When you buy an NFT, your ownership is indisputably stored on the Blockchain.

But the data, say a JPEG, is too expensive to store so it ends up somewhere else.

One day you might wake up and your NFT doesn't show anymore, because the file was deleted.

Unlike Ethereum, most options for storing data on the internet are not permanent.

Hosters might remove the file, Goverments might censor it and networks might break.

Not the indisputable ownership you were looking for?

Let's look at an alternative suited to Web3: IPFS

IPFS, short for Interplanetary File System, is a protocol and peer-to-peer network for storing and sharing data.

The core idea of the network is to separate content from location. 

Separate the what from the where.

Before we get into it, let's look at three problems of data on the internet as we know it:

1️⃣ Integrity:

You might get different content for the same location, depending on when you ask.

This is because the internet relies on content by name, mostly in the form of DNS.

2️⃣ Availability: 

When the server to which the location is pointing fails, the content cannot be reached.

This is because the internet relies on centralised data centres, like AWS.

3️⃣ Reliability:

If the provider of the content decides to take it off the network, there is little you can do.

This is because we put our trust into BigTech, hoping they will act honest.

Do I expect Yuga Labs to secretly change your Ape? No.
Do I expect AWS to have an outage? No.
Do I expect OpenSea to delete your JPEG? No. 
(Actually, not sure about the last one)

But the power of Web3 all comes from not relying on a single company like in Web2.

Ok. This is what we don't want.

Next, let's understand how IPFS works, to see how to design a system better suited for the next version of the Web.

Similar to a Blockchain, IPFS has a protocol at its core that defines how the network operates.

Everyone can decide to participate by running the IPFS Client. Doing so makes you a Node in the network.

Here is what happens, when adding a file to IPFS:

The file is cut into equally-sized chunks and given a unique fingerprint, called Content Identifier (CID).

The CID is a permanent identifier that allows to retrieve the file from the network, regardless of where it is located.