Web3, DApps, ERC20 Tokens, NFTs & IPFS Explained


Web3, Dapps, ERC20 Tokens, and NFTs… it feels like these are the next set of tech buzzwords, But what do they all mean?

web3 dapp social media joinspace smart contract
(JoinSpace – Web 3.0 Social Media DApp)

Context: For a while, I have been diving into the interesting world of Blockchain and developing a few Web3.0 Projects.

The latest Web3 Project:
A Web3.0 Social Media DApp, where users can earn tokens, and Tip eth based on upvotes of their content posted. (Like Reddit in Web3.0).

This post would explain the key fundamentals behind the upcoming social media decentralized application.

In this article, we would go over quite a few concepts starting from the evolution of the internet to web3.0. We’ll also, cover what are DApps?, DApp Architecture, ERC20 Tokens, NFTs, and how data is stored on the Blockchain.

It’s a long one, So let’s begin!

Web 1.0 vs Web 2.0 vs Web 3.0

The Web: An informational hub home to many of the largest sites used by billions across the world. Gaining Information, and human productivity has been drastically improved… many can self-educate, watch entertainment, or even earn a living through the web.

But how did we get to this stage?

In order to understand where we are with web 3.0, let’s understand where the web first started, with Web 1.0. Although there are no official dates, The Web evolution can be characterized by the following.

History of the Web Evolutions – Web 1.0


Web 1.0 can be characterized as the first iteration of the Web. A static, read-only page. Web 1.0 consisted of sites serving static content to the user.

Revolutionary for the time, users could collect knowledge on anything, by navigating around through a series of documents connected by Hyperlinks.

Web 1.0 was read-only meaning a user was typically served a static page. You could not interact with the site, apart from clicking on different documents.

As a result, Users were seen as consumers of content, whereby the creator was usually the developer behind the site. (Approx. 1991 – 2004)

In fact, the first website was published by Tim Berners-Lee, 1991. Dedicated to information on the world wide web. A site providing an explanation of how to set up your own website.

Web 2.0 – Era of Internet Interaction

(Web 2.0 Summary)

Fast Forward to around 2004, where we saw an adoption of websites providing user interactivity.
Characterized by the ability for users to interact with the web, Web2.0 started off simply as a user being able to change the state of a website, which lead to ordering books, flights booking with a backend database.

Fast forward to the present time, and now the user can create and earn money, order meals from apps, gig economy, and freelancing.

Web 2.0 refers to the current iteration, and what most technologies we use daily operate on.

Fast forward to the present time, and with the advancement of development tools and wider internet access. Users can create content and earn money, order meals from apps, earn a living within the gig economy, and even freelance.

As a result, web 2.0 can be characterized by the participants being both the Consumers and Creators through web iteration.

Knowledge hasn’t been spread faster on information, allowing people to experience events in real-time.

web 2.0 centralised servers
Web2.0 – Centralised Servers

However, over time we’ve seen a degree of centralization of services where a few corporations make up what we use every day. Whereby in most cases, you don’t have control of your data, or how it is stored.

Additionally, certain business models, such as Meta/Facebook operate on collecting personal data on users to sell to advertisers. In effect, making us the product.

The important takeaway is a high proportion of Web 2.0 apps and services we use every day are owned by Big Tech.

Web 3.0 – Era of Decentralization

So, What’s Web 3.0?

The big fundamental difference between web2 vs web3 is Decentralization.

Web 3.0, however, being a loose term refers to  a decentralized, secure web where people can exchange money and information without the need of an unnecessary middleman like banks or a payment system.” – You become the owner of digital goods.

An Example of a Blockchain used in Web3 is Ethereum.

Ethereum, can be seen as a distributed network of computers where all participants (known as nodes) have to agree on the same state of the network of the data throughout the network.

web3 decentralised architecture
Decentralized Blockchain Nature

Web3 ideally enhances the internet experience we have today, by providing a few other characteristics, such as:

Decentralized Application that runs on the Blockchain:

  • Verifiable, Trusties, Permissionless, Self-governing, and Robust
  • Not Centralised by any authority. Peer to Peer.

This Twitter thread also provides an argument for web3:

Web 3 Use Cases:

There are many examples of existing applications running on web3 including DAO’s, DeFi, and DApps. (we’ll cover DApps shortly). In the meantime, below are some real-world examples of Web3 applications:

AAVE – Example of a DeFi Open Source Liquidity Protocol

Decentralized Finance (DeFi):

AAVE (DeFi Liquidity Protocol) – where users can Stake earn APY, on cryptocurrencies. Or make loans, or even Flash loans.

Decentraland – A virtual world/metaverse where you can earn tokens when buying, selling land.

What Are DApps:

web3 social media dapp architecture
Simplified DApp Architecture (Ethereum Blockchain)

A DApp is a Decentralized Application.

DApps are similar to everyday apps that perform a utility for the user. In fact, the user interface is identical to a normal website or App. An example of a DApp is Uniswap, a decentralized crypto exchange.

(Excerpt – Ethereum.org)

TL;DR – The fundamental difference between a web2.0 website and a DApp, is that DApps have their backend code deployed to the blockchain, known as Smart Contracts.

How do DApps work?

web2 architecture diagram
Simplified Web 2.0 Architecture (Frontend and Backend)

In web 2.0, we usually build applications that run on a centralized server whereby the data is owned by the company and the app is operated by a central authority.

Typically, when we build a web application. (Consisting of a Frontend, Backend) the web application is deployed where the backend code resides on a centralized cloud hosting service like AWS, where it is managed and scaled to your needs.

Take Ethereum as an example, (note, there are many Blockchains that replicate a similar architecture.

web3 architecture diagram simplified
Simplified Web 3.0 Architecture (Frontend interacting with the Blockchain)

For a decentralized app on the blockchain, your backend code is contained in a smart contract and deployed to the Blockchain, usually written in Solidity (language).

A smart contract can be viewed as a piece of code that executes a piece of logic and lives on the blockchain that we can interact with across multiple wallets.

smart contract remix
Create a Smart Contract – Remix IDE (Solidity)

Applications that interact with a Smart Contract on a Blockchain, are known as Decentralized apps. Or a DApps for short. (Hence the name).

The key characteristics of a smart contract are that Smart contracts are immutable. Once a DApp/smart contract is deployed on the Ethereum Network it’s for all to view and interact with.

Due to its immutable nature, once DApps/ Smart Contracts are deployed on the Ethereum network you can’t change them.

ethereum-dapp architecture
(Simple DApp Reading State on Chain, shown in DApp UI)

In summary, DApps are decentralized applications where the backend of the application is deployed to the Ethereum Blockchain known as Smart Contracts. Users interact with the front end to interact with data on-chain.

Advantages of a decentralized blockchain include:

  1. Free from Censorship (Can’t be removed) – With Blockchain’s decentralized nature, there’s no centralized single point of failure
  2. Built-in Payments – Send Payments to any wallet
  3. Secured by Cryptography
  4. Open Source – Encourages transparency

A Smart Contracts code, transaction history, and user activity can be seen on a Block Explorer, such as Etherscan.io. Here’s the Smart Contract for JoinSpace (Social Media DApp).

Social Media DApp:

A Reddit Base Media DApp – JoinSpace (like Reddit but on Web3)

JoinSpace.xyz – An example of DApp I’ve developed that runs 100% on-chain.
Users can earn tokens with upvotes, Tip eth, and own their content store on the Blockchain. Create a community known as subspace “s/” in relation to “/r” for subreddits.

Other use cases of DApps, include DAO, Arbitrage Trading, and many more that are being developed.

How can we develop a DApp?

web3 dapp architecture development stack
Ethereum Development Stack
spongebob thinking developing dapps on ethereum

Building a DApp requires a few different pieces a few tools and can be its own separate article on its own. However, this is the overview of building a DApp on the Ethereum Blockchain.

Note: The following developer stack focuses on Ethereum based DApps using JavaScript/NodeJS. However, below are some tools that Support Python.

Front End – ReactJS is a front-end JavaScript library for building web applications (alternatively HTML, JavaScript). Similar to any 2.0 web application.

solidity logo

Back End
Solidity is an object-oriented, high-level programming language used to write Smart Contracts. You can test and deploy your Smart Contract with Remix, Ethereum Browser IDE.

Web Client Libraries:

Ether.js – Proves your applications a way to interact with the smart contract.  to communicate with the End User and Smart Contract on the Blockchain. Two popular libraries. (Note: Ethers is supported on JS Only)

Note: for Python developers,  web3py, and web3js are also popular alternatives.


metamask logo

Handles account management and connects the currently active user to the blockchain. Once a user has connected their MetaMask wallet, we (developers), can interact with the Globally available Ethereum API (window.ethereum).

Provider: A provider links to a running node that talks to the Ethereum network

Infura API – Provided you wish to deploy to a Testnet like Ropsten. As well as providing access for Ethereum and IPFS networks based on its hosted Ethereum node cluster.

Frameworks: for testing, debugging Smart Contracts, creating a local blockchain instance, and deploying scripts:

  • JS Developers: Hardhat – Ethereum development environment for professionals
  • Python Developers: Brownie – Python-based development and testing framework.

Note: Before going into the Rabbit whole of DApp development. It would help to get a fundamental understanding of the Blockchain Stack, such as Ethereum miners and nodes.

Great, so we now got our Front End and Solidity Contract Deployed to the blockchain. Let’s now take a deep dive into how our DApp would interact with our Smart Contract Deployed to Blockchain.

How does the DApp Front End interact with Smart Contracts?

web3 architecture diagram generic
Web 3.0 DApp Architecture

A Provider, allows a Dapp to communicate with smart contracts deployed on the blockchain. This allows our DApp to read the state/data stored on the Smart Contract.

However, If we wish to write to the same state, we’ll need to “sign” the transaction with our private key – validating that the transaction came from a genuine public wallet address. Known as a signer.

Note: A signer is not required when reading from the blockchain, only when submitting a transaction.

What is a wallet?

public private key
Public-Private Key Pair

Ideally, A wallet is a term to describe a medium that stores sets of private and public keys. It’s what we can use to sign transactions. You can think of it as our account equivalent on the Blockchain

How to Connect a wallet to a DApp?

connect wallet to dapps
web 3 connected wallet
(Frontend UI – Connecting a User Wallet to DApp)

Unlike web2.0, where a user’s credentials are stored on a centralized database. With Web3.0 the end-user owns all their data. There isn’t a need for a developer to collect the username or password. 

With Web3.0, the end-user would require connecting to a browser extension such as MetaMask in order to make their wallet’s details available to a DApp.

metamask private public keys
MetaMask Wallet – Public Private Key

Metamask stores the user’s private key in the browser, whenever the front end-user needs to sign a transaction, e.g buy a token, the MetaMask window is invoked.

The end-user has a public address that can receive payments and a private key that can sign transactions – to interact with the blockchain to send payments mint tokens, etc.

How does this look from a developer’s perspective?

MetaMask provides documentation on how to connect your DApp to MetaMask wallet
In summary: MetaMask injects a global API into websites visited by its users with a global variable, window.ethereum.

web3, dapps, erc20 and nft's explained - window.ethereum
(window.ethereum global environment – in browser console)

Once a user has connected their MetaMask wallet, the DApp can interact with the Globally available Ethereum API (window.ethereum) to access details regarding the wallet.

pani and kalm meme crypto

Note: Your private key is used to sign cryptographic hashes with your wallet. This is why as a user/ wallet holder it’s important to keep your private keys secure.

Once a private key is compromised anyone with access has full control over your wallet!

We have covered what is a Dapp, how to build DApps, and the Web3.0 DApp architecture. Let’s take a detour into the world of tokens and Cryptocurrencies.

ERC20 Tokens – The Cryptocurrency Mania

ERC20 Explained

ERC20 Tokens – the technology standard behind your favorite projects. From decentralized stablecoins such as DAI to the crypto meme coins of SHIBA. With all that’s going on within this space, ERC20 Tokens can be a whole much more than dog coin projects. Let’s dive in.

What is a Token?

A token can represent virtually anything on the Blockchain that we can earn or trade with other people. Whether being points in an online game. No. of points to a user’s profile, lottery tickets, and of course… cryptocurrencies.

erc20 standard exchanges
ERC20 Tokens – developers can utilize tokens in their applications.

However, instead of every developer building their own token implementation. (Which would be chaotic)

There needs to be some standardization, making it easier for others such as exchanges to list these tokens by building functions into the smart contract to transfer, withdraw and swap these tokens. This is where the ERC20 standard comes in.

The ERC20 standard presents a token standard that helps keep track of Fungible tokens. Meaning, each token has the exact same properties (both in type and value) when compared to another token.

fungible tokens
ERC20 Fungible Tokens

I.e, an ERC20 Token named ABC. One ABC Token is always equal to all the other ABC tokens. As a result, this makes ERC20 Tokens ideal for mediums of exchange – currency, staking, and voting rights.

fungible-real world coin
Real-World example of Fungible Tokens, £1 Coin

In order for a Smart Contract to be called an ERC20 Token Smart Contract, the Smart Contract would need to comply with the ERC20 token standard.  (Ethereum Request for Comments 20)

web3, dapps, erc20 and nft's explained - solidity remix functions
Minting ERC20 Token Functions

Examples of the methods and events that would need to be implemented:

  • Transfer() – Transfer tokens from one account to another account /wallet address.
  • balanceOf() – Get the current token balance of the account
  • totalSupply() – Total supply available on the blockchain network (e.g. mainnet).
  • approve() – Approve whether a token amount can be spent or transferred by a third-party account. E.g. use for AirDrops etc.
web3, dapps, erc20 and nft's explained - erc20 solidity token
Smart Contract Code to Mint an ERC20 (no really, that’s all!)

Constructing an ERC20 Token Contract has been made simpler with OpenZepplin; which is a library that provides reusable templates for writing a smart contract that complies with the ERC20 standard.
Using OpenZepplin, we can inherit the methods where we can change the name, symbol, and decimals. These tokens are sent to an address specified during the minting process. Being the, msg.sender argument.

By default: ERC20 uses 18 decimals. Where 1 Eth, is equal to 10^18. Or (1 Ether = 1,000,000,000,000,000,000 wei).

You can have a look at an example of an ERC20 Smart Contract in Remix. In fact, OpenZepplin provides a Smart Contract Wizard for creating your own token.

License to Mint Tokens

As interesting as it is, this can theoretically make anyone their own federal reserve of their own currency. This may explain the 500,000+ Tokens deployed on the Ethereum main net. It’s important to note, some are only designed to part you from your cash. (Given that, anyone could literally recreate your smart contract, name, ID, and symbol). That’s why, It’s important to verify the contract address, and whether it’s legitimate.

Additionally, further examples of using tokens as reward points include gaming, loyalty points in online services, or even a gift card. (In the form of cryptocurrencies)/

This can even expand to social media platforms. JoinSpace.xyz is a decentralized social media platform I developed, which allows users to earn tokens based on their content quality.

NFTs and the Cryptocurrency Craze

The World of NFTs – NFTs is Bigger than Digitial Art!

Bore Ape Yatch Club, NFT

Ah, yes, we’ve now hit the Crescendo of the current Crypto Craze. Welcome to the world of NFT’s where digital arts and collectibles are being immortalized on the Blockchain, Artists, celebrities, and influencers alike selling digital arts for an are eye-watering sum to buyers. However, NFT’s do get a fair share of a bad rep. It should be emphasized that Digital art is just a one-use case of using an NFT.

What’s an NFT?

picture of mona lisa an non fungible
Non-Fungible Painting, Mona Lisa

NFTs stands for non-fungible token. For the purpose of a high-level overview, non-fungible means the item in question is unique and can’t be replaced. An example of a non-fungible in the real world can involve assets such as Land, your passport, or an original piece of art. Something unique like the Mona Lisa.

Which in turn is the exact opposite of what fungible is. A fungible item in the real world is an item that you can readily replace with an equivalent type. A Dollar bill is a great example. $1 is $1, or a piece of gold can be easily replaceable with another piece.

non-fungible land owned
The same Land can’t be bought twice, it’s already owned!

Taking the real-life art piece into the digital world means the art piece retains its unique characteristics and attributes such as rarity. Note: NFT is not only digital art, this can expand to concert tickets, unique fashion collectibles, proof of deed, etc.

non fungible use cases real world
NFTs does not only have to be digital art – Other Use cases of NFT in the Real World

TL; DR – NFT’s are unique tokens that we can associate unique characteristics to it in the form of rareties. The scarcity of the item increases value. Based on Supply & Demand.

There are two main types of Digital Artwork NFT, you’ll see:
– Non-Generative NFT created by a person, e.g. Beeple NFT’s
User-Generative – NFT’s that make use of generating unique attributes in the form of rareties such as look and traits. Bored Ape, CryptoPunks, CrypoKitties.

We’ll focus on the latter example:

The Bored APE Project is a well-known example… which has a max quantity of 10,000 artwork

non-fungible rarity
Bored Ape – Rarities and unique attributes

The Bored Ape NFT are created with a few base layers such as hair, eyes, nose, and mouth. These base layers are randomly combined to generate a unique graphic, with each layer having its own rarity to generate an image.

bored ape

Depending on the rarity score some of these Apes are more in demand increasing their perceived value.

All these apes have different rarity scores making some more sought after than others.

These NFT are “claimed” in a process named minting where we send Crypto to a Smart Contract and we in return receive an NFT.

And by owning this really means, by that we mean somewhere on the blockchain there’s a transaction linking your public address to the NFT in question. Where anyone can view and verify that you’re the owner.

I.e. Ideally you own the receipt to the transaction… becoming a certificate of ownership.
These Tokens follow a standard known as ERC21. Where ERC721 standard ensures that each individual token is unique, transferable, and tracks ownership at a minimum within the Smart Contract. This is one of many standards,

Similar to how we have ERC20 for Fungible Crypto Tokens (…and more ERC-1155)

So how does this work with NFTs?

erc 721 contract solidity
(ERC721 Solidity Contract Snippet – Create your NFT for your DApp)

On a high level, information about the NFT such as metadata, tokenURI/hash is stored on the blockchain, where the can be accessed off-chain.

To recap, an NFT is simply a token that can be distinguished from another.
From a developer’s perspective: Typically, this is how NFT’s work:

Say, for example, the Bored Ape Yatch Club Projects

nft-non-fungible stored ipfs
Bored Ape Stored on IPFS, Smart Contract points to IPFS Hash

The original image along with its attributes and metadata are stored on some form of a decentralized database. When stored, this provides us a hash which is a reference to where this image is located.

The hash of this image, along with its’ metadata is stored on the Smart Contract.
As a result, the Smart contract created the association, referencing where the image is stored along with its metadata and attributes.

Given that the image hash is stored on the blockchain (which is very difficult to change).
When a buyer purchases an NFT, the smart contract keeps track of the buyer’s wallet address.

bore ape onchain ipfs
On-Chain IPFS Hash

Which can be easily looked up to verify who owns the NFT / as a proof of ownership on the Blockchain. But, you may be wondering where is this image stored in the first place. And similar to how fungible tokens follow an ERC20 token standard. NFT’s follow a separate standard known as ERC721 to mint your own NFT’s.

The following social media, I’m developing known as JoinSpace would involve ERC721 Standard to mint NFTs

This perfectly leads us to how data is stored on the blockchain. E.g. images etc.

Storing Data on the Blockchain – Introducing IPFS

web3 architecture diagram generic ipfs store data on blockchain
(Web 3.0 DApp Implementation of Off-Chain Storage with IPFS)
web3, dapps, erc20 and nft's explained - IPFS logo

Unlike current software web2.0 where we can store data on a centralized database. Storing data on the blockchain would not be practical, and in fact, very expensive (if possible).

As a result, Data is primarily stored off-chain with decentralized networks like IPFS.

“IPFS, (Interplanetary File System) is a distributed system for storing and accessing files, websites, applications, and data.” – ipfs.io

A peer-to-peer network for storing and sharing data in a distributed filesystem. Like how BitTorrent works.

When we require direct access to an image, the current internet (web2.0) requires you to put in the full URL address you’ll like to access. This is called location-based addressing. Every piece of content has its own unique address which is located where some server could serve the image to your browser.

The problem is that it leads to a single point of failure. If an image, information, or your favorite video. Gets deleted there’s no easy way of retrieving the file. This could be important for political censorship.

How can we store blockchain data off-chain with IPFS?

web3, dapps, erc20 and nft's explained - solidirty image hash
JoinSpace – Smart Contract

IPFS uses content-based addressing. Content-based addressing means that every file has its own address.

When files are uploaded to IPFS, each file is split into smaller chunks that are cryptographically hashed, a unique figure print is created called a CID (content identifier).

The interesting part is you can access any images using the URI. E.g. Filename: Ethereum-logo

Here’s an example of Ethereum’s logo uploaded to IPFS. (Look at the URI above – interesting, isn’t it?!)

This CID acts as a permanent record of the file. Due to its distributed nature when a user views or downloads your file. They also store a cache or copy of your content. Hence the more people view your content the more distributed the image becomes.

non-fungible ipfs cid hash
Image Uploaded to IPFS to retrieve the CID

Given, that storing would be very expensive, the NFT represents a link to that image, which points to the content uploaded URI off-chain.

This can be as simple as storing the uploaded CID to the blockchain. IPFS solves this by passing the image through a hash function to provide you with a CID.


https://ipfs.infura.io/ipfs/<CID>, where, the CID is the hash of the image.

Your meta URI can be accessed – E.g. View this image of the ETH Logo:


ethereum logo stored in ipfs
This image was pulled via IPFS – inspect the URL ?

This is essentially how Images works are stored “on-chain”. By storing the IPFS URI along with the image properties. Meaning, you “own” the transaction which has the record of the CID address. This means, you theoretically “own” the image. As you (the user) own is the receipt of the transaction stored on the blockchain.

The Current Web3 social media DApp, JoinSpace.xyz being developed incorporates IPFS. So, you can upload your own images or mint your own “NFT”.

Note: In some cases, NFT has been found to be using a URL to a Google Drive or cloud storage (being centralized servers). The issue here is that anyone can replace the contents of the image after being sold.
Meaning you can receive an image that is different from what you bought. Or worse, a seller could simply delete the image. As a result, you own a transaction to a link that doesn’t exist.

As with Prometheus bringing fire to Humans. These new technologies such as ERC721/NFTs can bring new innovations / new industries – how they would be used would be down to the user. Which leads us to if Web3 is just hype?

Web3 Scepticism – Is web 3.0 all Hype?

So, is Web3 all Hype?

In relation to Web3, DApps, and the Blockchain: in general, we’re still relatively in the early stages of web3/Dapps developments. And it’s definitely going to be the new Buzzword, and there are valid arguments for Blockchain ability to scale

With all-new technologies, it’s always good to have a cautious optimism to them and evaluate the best and worst case. There are valid arguments against web3 such as Former Twitter CEO, Jack Dorsey’s comments on Web3:

Although this article doesn’t go into detail on the arguments against web3 the above Twitter thread does point out some main points such as insider’s ownership and scalability.

While on that point, this leads us to the current limitations of the Ethereum Blockchain.

Blockchain / Smart Contract Limitations:

Before being accused of spreading FUD, while the Blockchain provides a whole array of potential and realized advantages. There are current issues and limitations faced:

Hacks and Vulnerabilities – Although there are great frameworks and smart contract standards, such as OpenZeppelin. Your Smart Contract is only as good as you program it.

Given that Smart contracts can be viewed. Blackhat Hackers have the opportunity to probe through your code for weaknesses and vulnerabilities. One example is the DAO, Hack of 2016.

ethereum gas fees are too high meme
(taking out your £5 ETH profit)

Gas Fees – Specifically for the Ethereum network. High Gas fees are a notorious issue, with some gas fees costing more than the transaction itself. However, with the upcoming Eth2.0 and release of ZK-Rollups, these issues are hoped to be resolved/ significantly reduced.

User Experience – This may be subjective but worth noting specifically to DApps. When any transaction is required to be written on the blockchain, this would require a new window confirming the transaction – typically via MetaMask or a similar Wallet Provider. This may lead to bad UX for new users.

Scaling: At this current stage, the Ethereum Blockchain is known for its scale issues. Leading to other scaling solutions such as Polygon, (a Layer 2 Scaling solution).
We’ll cover this more in the next post about Building a Social Media DApp on Web 3.0.

Final Thoughts

Web3 has its use cases for specific applications, and there would be a tonne of upcoming new products and services that would provide value to a specific use case.

We’ve covered a lot. From Web3.0, DApp, ERC20 Tokens, NFTs to IPFS. Either way, DApps is going to be an interesting technology to watch unfold, such as the use of DAO’s for crowdfunding.

If you’re interested in DApp Developing here’s a Full Stack Ethereum Development Guide.

Or if you have any innovative ideas worth contributing join the discord on the social media DApp being developed known as JoinSpace.xyz – (an alternative to Reddit, on Web3)

Consider Supporting by Tipping Eth: 0x231543214c0FaaD6570c9bbFAe0Eb07DA0fc8E10