Main Category

Learn About Rollup Protocol

The Optimistic Rollup is the key concept that enables optimism. We’ll go through a high-level explanation of how Optimistic Rollups function. Then we’ll describe why Optimism is designed as an Optimistic Rollup and why we feel it’s the greatest option for a system that meets all of our design objectives.

Optimistic Rollups TL;DR

Optimism is an “Optimistic Rollup,” which is a fancy way of saying a blockchain that benefits from the security of another “parent” blockchain. Specifically, Optimistic Rollups use their parent chain’s consensus process (such as PoW or PoS) rather than supplying their own. This parent blockchain in Optimism’s instance is Ethereum.

Block Storage

All Optimism blocks are saved in a special Ethereum smart contract called the CanonicalTransactionChain (opens in a new window) (or CTC for short). Inside the CTC, optimism blocks are stored in an append-only list (we’ll describe how blocks are added to this list in the following section). The Optimism blockchain is formed by this append-only list.

The CanonicalTransactionChain comprises code that ensures that new Ethereum transactions cannot modify the existing list of blocks. This promise, however, can be violated if the Ethereum blockchain is rearranged and the sequencing of previous Ethereum transactions is altered. The Optimism mainnet is built to withstand block reorganisations of up to 50 Ethereum blocks. If Ethereum undergoes a broader reorg, Optimism will also undergo a reorg.

Avoiding such major block reorganisations is a core security aim of Ethereum. Optimism is, therefore, safe from huge block reorganisations as long as the Ethereum consensus process is. Optimism obtains its security features from Ethereum (at least in part) through this link.

Block Production

The production of optimism blocks is generally coordinated by a single entity known as the “sequencer,” who assists the network by offering the following services:

Offering real-time transaction confirmations and status changes.

L2 block construction and execution

L1 is receiving user transactions.

There is no mempool in the sequencer. Thus, transactions are accepted or denied in the order they were received. When a user submits a transaction to the sequencer, it validates it (pays a suitable fee) and then adds the transaction to its local state as a pending block. These pending blocks are frequently submitted to Ethereum in big batches for finalization. This batching approach drastically decreases overall transaction expenses by distributing fixed costs and transactions within a batch. The sequencer employs some rudimentary compression methods to reduce the quantity of data broadcast to Ethereum.

Because the sequencer has priority write access to the L2 chain, it can ensure what state will be completed as soon as it settles on a new pending block. In other words, the consequence of the transaction is accurately known. As a result, the L2 state may be changed consistently and fast. This provides a quick, rapid user experience, with features such as near-real-time Uniswap pricing changes.

Alternately, users can completely omit the sequencer and instead submit their transactions to the CanonicalTransactionChain by means of an Ethereum transaction. One is often more expensive since the user pays the whole fixed cost of submitting this transaction, which is not amortized across many such transactions. However, this alternate submission approach has the advantage of being immune to sequencer censoring. Even if the sequencer deliberately blocks a user, they may still utilize Optimism and use this approach to get their money back.

For the time being, the lone block producer is Optimism PBC.

Block Execution

Ethereum nodes obtain blocks from Ethereum’s peer-to-peer network. Instead, optimism nodes download blocks straight from the CanonicalTransactionChain contract’s append-only list of blocks. For additional details on how blocks are kept within this contract, see the section on block storage above.

The Optimism client software and the Ethereum data indexer are the two main components of Optimism nodes. The Ethereum data indexer (or DTL) rebuilds the Optimism blockchain from blocks submitted to the CanonicalTransactionChain contract. The DTL looks for events generated by the CanonicalTransactionChain that indicate the publication of fresh Optimism blocks. It then looks at the transactions that generated these events to recreate the published blocks using the typical Ethereum block format.

The Optimism client program, the second component of the Optimism node, is a nearly vanilla version of Geth. This implies that behind the hood, Optimism is nearly identical to Ethereum. Specifically, Optimism and Ethereum share the same Ethereum Virtual Machine , account and state structure, gas metering system, and fee schedule. This design is known as “EVM Equivalence”, and it implies that the majority of Ethereum tools (including the most complicated ones) “simply work” with Optimism.

The DTL is constantly monitored by the Optimism client program for freshly indexed blocks. When a new block is indexed, the client program downloads it and performs the transactions contained inside it. To execute a transaction on Optimism, use the identical steps as on Ethereum: first, load the Optimism state, then apply the transaction against it. Finally, record the state changes that arise. This method is then repeated for each new DTL-indexed block.

Bridging Assets Between Layers

Optimism allows users to transmit arbitrary messages between Optimism and Ethereum smart contracts. This allows assets, especially ERC20 tokens, to be transferred across the two networks. The precise technique by which this communication takes place varies based on the direction in which information is transmitted.

This capability of the Standard bridge is used by Optimism to enable users to transfer assets (ERC20 tokens and ETH) from Ethereum to Optimism. Users can withdraw the same assets from Optimism and send them back to Ethereum. 

Transitioning from Ethereum to Optimism

Users merely need to activate the CanonicalTransactionChain contract on Ethereum to generate a new block on the Optimism block to convey messages from Ethereum to Optimism. For further information, see the section on block creation above. Blocks that users generate may include transactions that seem to come from that address.

Moving from Optimism to Ethereum

In the same manner that Ethereum contracts may easily produce transactions on Optimism, this is not feasible for contracts on Optimism. As a result, returning data from Optimism to Ethereum requires a little more effort. We need to be able to make verifiable claims about the optimism of Ethereum-based contracts rather than automatically producing verified transactions.

Making claims about the state of optimism that can be proven needs a cryptographic commitment in the form of the trie’s root. This commitment will alter after each block since optimism’s status is changed. Approximately once or twice per hour, a smart contract on Ethereum called the StateCommitmentChain publishes commitments.

Users can use these promises to produce Merkle tree proofs regarding the optimistic situation. Ethereum smart contracts can verify these proofs. The L1CrossDomainMessenger, a handy cross-chain communication contract that Optimism manages, may validate these proofs on behalf of other contracts.

These proofs may support verifiable claims regarding the information stored in any contract on Optimism at a particular block height. Then, using this fundamental capability, it will be possible for contracts on Optimism to communicate with contracts on Ethereum. Contracts on Optimism can utilize the L2ToL1MessagePasser contract (predeployed to the Optimism network) to store a message in the state of Optimism. Users may then demonstrate to Ethereum contracts that a certain Optimism contract wanted to deliver a specific message by demonstrating that the L2ToL1MessagePasser contract has saved the message’s hash.

Fault proofs

Fault proofs Instead, for a while, these promises are regarded as pending (called the “challenge window”). A proposed state commitment is deemed final if it is not contested during the challenge window, which is presently set to seven days. On Ethereum, smart contracts may securely receive evidence about the status of Optimism based on a commitment after it is deemed to be final.

When a state promise is contested, a “defect proof” procedure—previously known as a “fraud-proof” method—can be used to render it invalid. If the challenge is successful, the commitment is withdrawn from the StateCommitmentChain, at which point another proposed commitment will take its place. It’s crucial to understand that only the publicly available promises on the status of the chain are reversed by a successful challenge, not Optimism itself. A fault-proof challenge leaves the transaction sequencing and optimism unaltered.

The November 11th EVM Equivalence update is adversely influencing the fault-proof process, which is now undergoing significant rebuilding. The Protocol specifications area of this website has further information about this procedure.

Main Category

NFTs VS Crypto: Which One is Better?

NFTs, Cryptocurrencies, Web 3.0, Bitcoin or even Ethereum, the crypto world might appear complex, confusing and outwardly weird to someone who has never personally engaged with these things before.

The introduction of Blockchain and the technologies it enables represents a paradigm shift on par with the introduction of the internet itself. People’s reactions to Blockchain-based technologies today are similar to how they responded to the early days of the internet, which included skepticism, enthusiasm and downright terror.

The two most significant unknowns in technology manifest as Cryptocurrencies and NFTs. Therefore, you must understand what they are and how they are entirely different from each other. 

What are Cryptocurrencies?

Cryptocurrencies are digital currencies. The name “crypto” refers to the fact that these currencies (also known as digital tokens) are secured via a technique known as cryptography, which means they are highly secure and impossible to double-spend or duplicate.

This security is achieved through various mechanisms (including public-private key pairs, encryption algorithms and more), each of which has controversy. Still, for this explainer, it’s enough to know that cryptocurrencies are essentially a digital form of money — which is why digital tokens are frequently referred to as “X-coin.”

Ethereum (ETH) and Bitcoin (BTC) are the most well-known cryptocurrencies, each operating within their Blockchain system, although hundreds of other cryptocurrencies exist across dozens of Blockchain platforms.

What’s an NFT?

NFT stands for non-fungible token. They are digital tokens, similar to cryptocurrencies but unlike fungible. They are cryptographic assets that live on the Blockchain.

The most common comparison here is between physical money and distinct physical items people buy because they are unique. We talked about how cryptocurrencies are fungible, which means that the same amount of ETH in your digital wallet and ETH in someone else’s wallet has the same value and function.

Consider a tangible thing that is unique to you and exists just once. This could be a portrait you bought, a collectible like a playing card or a stamp or a signed copy of the first edition of a book you love.

These things can’t be changed. If someone asked you to trade your signed copy of the first edition of a book for a signed copy of the fifth edition, we hope you would say no. Even though they both have the exact words, they are not identical and can’t be changed.

What’s the Major Difference?

The most significant difference is that cryptocurrencies can be exchanged with each other, while NFTs are all different and have different values.

How crypto coins are put into circulation is another difference. NFTs are made, while coins are “mined”. It’s a complicated process, but in a nutshell, a miner is a computer that does accounting work on the Blockchain and gets paid in new coins.

To “mine” an NFT, you must turn a file into a token that can be used on a Blockchain. The Blockchain checks the transaction and adds a fee to it.

Which One is Really Better?

Both have various uses and can’t be compared with each other. NFTs and Cryptocurrencies are built on Blockchain and employ the same technology and ideas. They thus frequently attract others of similar backgrounds. However, they are entirely unlike in terms of their identities and ways of working.

– Trading


Since NFTs are bought and exchanged online and kept in a digital ledger, they cannot be traded. Instead of purchasing a tangible image to place on the wall, the buyer receives an original digital file.


Cryptocurrencies may be traded or swapped without losing any value. Based on Blockchain technology, their peer-to-peer system allows anybody to make and receive payments in any digital cash or cryptocurrency.

– Uses


Each non-fungible token shows that a digital asset is unique and can’t be traded with anything else. Due to the cryptographic principles of the Blockchain, an NFT can never be modified, edited, or stolen.


Like traditional currencies, it is a means of exchanging digital information while avoiding existing currency difficulties. It enables speedy, safe & decentralized transactions and the purchase & payment of products & services.

– Volatility 


NFTs are claimed to be less volatile than cryptocurrencies. The creative, aesthetic side of NFTs has drawn both artists and traders. However, it may prevent people who find the work of creating NFTs too challenging, complex or cumbersome.


As crypto opponents and authorities have often indicated in their criticism of cryptocurrencies, in particular, are viewed as high-risk investments. Specific cryptocurrencies, such as Bitcoin, have been designed to be more stable than others.

The Final Verdict? 

NFTs are now a good choice for artistic people who want to make money from their digital work. Because of the market’s creative, artistic component, artists and traders have been drawn to it. Cryptocurrency, on the other hand, is a bit surprising. It is used for trading, on the other hand some cryptocurrencies were intentionally built to be more stable than others. Stablecoins are cryptocurrencies with lower volatility than others, such as Bitcoin and Ethereum.

Apps Development blockchain Blockchain development Crypto Exchange

What Is NFT Metadata

NFT metadata is a crucial element of NFT projects and blockchain technology. Digital assets are tracked, and their owners are identified using them. This blog article will examine NFT Metadata and its application to blockchain technology. 

NFT Metadata

The metadata of an NFT describes the digital asset’s extra attributes and characteristics. This can contain the item’s creation date and time, the name and contact details of the creator, an explanation of the asset, and searchable keywords. Blockchain ledgers that hold metadata enable NFT owners to keep track of and maintain their assets.

An NFT maker can create something that is one-of-a-kind and hard to replicate because of the metadata. As a result, investors and collectors are very interested in NFTs with comprehensive metadata.

Where is the NFT Metadata Kept?

NFTs are kept in the decentralized IPFS (interplanetary file system), a group of machines that interact using the same protocol. To support a large number of users and NFTs, the system is distributed and scalable. The interplanetary file system’s resistance to censorship and data loss is its key benefit. This is so that if one node in the network goes offline, it won’t impact the other nodes since the data is dispersed among several distinct nodes.

The interplanetary file system has the drawback of being slower and less effective than other storage systems. However, this compromise is worthwhile for many users who prioritize censorship resistance and data confidentiality.

This distinguishes and adds value to NFTs: since their data is kept on the blockchain, they cannot be duplicated or altered. A token that reflects the underlying data is what you purchase when buying an NFT. The data is unchangeable and stored safely on the Ethereum blockchain. As a result, using NFTs to acquire and sell digital assets is safe.

Off-Chain NFT Storage

Your NFTs are entrusted to a third-party service when you store them off-chain, such as with a cloud storage provider like Google Drive or AWS. Your NFTs are tracked by this service, which also makes sure they’re always available to you. One should be aware that off-chain storage of NFTs has several dangers. First, your NFTs can be permanently lost if the provider goes out of business. Second, your NFTs could’ve been taken if the service had been hacked.

Your NFTs can become unreachable due to the service, which would prohibit you from trading or transferring them. Therefore, before choosing, it is crucial to consider the advantages and disadvantages of holding your NFTs off-chain.

NFT Metadata With JSON Data

To mint an NFT, you must first produce a JSON file with the necessary NFT information that describes what the token represents.

A JSON file format for encoding metadata will soon be implemented on the Ethereum network, making it simpler for NFTs to communicate with smart contracts. Developers may store JSON information on the Ethereum blockchain thanks to the ERC 721 Ethereum NFT standard.

This is especially helpful for NFTs, which frequently require to contain extra information like the name of the artist, a description of the NFT, or license details. The web3 API and other JSON-based systems, such as them, are more easily interoperable with NFTs thanks to the JSON standard. Additionally, it enables metadata-based querying and filtering of NFTs.

A few crucial data bits must be present in the JSON file for constructing NFT metadata. You must first give the NFT a unique identification. It may be a URL or another distinctive string. The NFT’s description, title, and keywords must be added, along with some other foundational metadata.

The file type for the NFT itself should also be specified. Doing this will make it possible for people to interact with it and show it properly. You may generate a whole and valuable JSON file for your NFTs by including these necessary data bits.

NFT Metadata Technicalities:

The following NFT discussion will employ the traditional Ethereum ERC-721 token standard.

The description of each ERC-721 includes a “metadata” string that describes the non-fungible token in detail. For instance, this information may identify a certain. JPEG, yet a CryptoPunk.JPEG and a DeadFellaz.JPEG differ significantly. Although JPEG files are similar in size, their values are very different.

The main issue that confuses people regarding NFT metadata is where files are stored off-chain—is it anything like Google Drive? Is it a storage area for files on Amazon Web Services? Who oversees the online storage of NFT metadata?

Each NFT refers to online-based audio or visual (image, audio, etc.) asset. It sends a request to a particular place for the material, returning the requested content for you to view or hear. NFTs often point to an HTTP URL or an IPFS  hash that is located online.

ERC-721s specify metadata in a standardized JSON format, which resembles this: ERC-721s specify metadata in a standardized JSON (JavaScript Object Notation) format, which often is maintained by the website that hosts the NFT.

    "title": "Asset Metadata",
    "type": "object",
    "properties": {
        "name": {
            "type": "string",
            "description": "Identifies the asset to which this NFT represents",
        "description": {
            "type": "string",
            "description": "Describes the asset to which this NFT represents",
        "image": {
            "type": "string",
            "description": "A URI pointing to a resource with mime type image/* representing the asset to which this NFT represents. Consider making any images at a width between 320 and 1080 pixels and aspect ratio between 1.91:1 and 4:5 inclusive.",

Since storing a JSON would be excessively costly and resource-demanding, the data is kept as a URI  inside the Ethereum contract. However, the URI string directs the visitor to a page where they may get the JSON description of the token.

On the blockchain, the token’s metadata is a permanent, irrevocable record containing information about its ownership, what it stands for, and its transaction history. The image’s name, description, URL for hosting, and occasionally other specific information like the project’s total supply, the type of encryption used, and a unique signature are all contained in the JSON file.

NFTs’ Limitations

Typically, this JSON metadata just serves to identify the object and doesn’t offer any further information beyond the absolute minimum.

Multiple initiatives are aiming to fix the Ethereum network’s flaw and restriction that the data isn’t particularly searchable or accessible by other smart contracts.

The token issuers, the legal owners of the NFT contract, provide the data. For better or worse, users cannot update the data, which can be difficult for several reasons.

Links can break, as we have observed in the changing Internet ecology. Since the NFT metadata contains a link that directs you to another location where you may view the art, if that link is broken, you will be required to a highly costly 404 error page. Users are unable to change either the JSON data or the links.

The main problem is that the NFT’s inherent worth may be in jeopardy if the data could be updated. The market would react, most certainly severely, if, for instance, a hostile third party discovered an exploit to replace all of the Bored Ape Yacht Club image information with images of real apes found on Google.

Main Category

Beginner’s Guide to IPFS

Let’s start with a basic description of IPFS:

IPFS is a distributed system that allows you to store and access files, webpages, apps, and data.

What precisely does that mean? Assume you’re conducting a study on Leafy seadragon. Did you know they are classed as a Protected Species in South Australia and have no known predators? To begin, go to the Wikipedia page on seadragon at:

When you enter that URL into your browser’s address bar, your computer requests the Leafy seadragon page from one of Wikipedia’s computers, which may be on the other side of the country (or perhaps the world).

However, it isn’t your only choice for fulfilling your Leafy seadragon demands! There is an IPFS mirror of Wikipedia that you might use instead. If you utilize IPFS, your computer will request the Leafy seadragon website as follows:

/ipfs/QmXoypizjW3WknFiJnKLwHCnL72vedxjQkDDP1mXWo6uco/wiki/Leafy seadragon.html

IPFS can discover that delectable Leafy seadragon information based on its contents rather than its location. The IPFS-ified version of the Leafy seadragon information is represented by the string of numbers in the middle of the URL (QmXo…), and rather than asking one of Wikipedia’s computer systems for the page, your computer uses IPFS to request a large number of computers all over the world to share the page with you. It can obtain Leafy seadragon information from anyone, not only Wikipedia.

When you utilize IPFS, you don’t merely get things from somewhere else; your computer also contributes to their distribution. When your neighbor or anybody using IPFS wants the same Wikipedia article as you, they may be just as likely to obtain it from you as they are from your neighbor or anybody using IPFS.

IPFS enables this for any type of file a computer may store, such as an email, a document, or even a database record.

There are various IPFS distributions and installation methods. However, this article will be using the cross-platform command-line interface program. The command interface is extensively documented and broad. Don’t be intimidated by the lengthy number of instructions; you’ll only need a few easy ones to get started with IPFS.

You must first generate a peer ID before you can use it. Open a terminal and type the following command:

ipfs init 

The significance of that command and its result will be described in greater detail later; for now, simply go to the next step.

Publication of an Image File:

Let’s see if we can post this PNG image. Once you’ve saved it as ipfs-logo.png, launch a terminal in the directory where it is stored and type the following command:

ipfs add ipfs-logo.png

The result will be as follows:

added QmbYq2pMi91Xd5Hu6Z1edrvP4BwJXCH9HhRX8Tk99DJWG6 ipfs-logo.png

A multihash is a lengthy string that begins with Qm… It is a one-of-a-kind identifier derived from the file’s contents. No matter when and how often a file is rereleased, it will always be the same for that particular file.

Obtaining the File:

It’s just as easy to get the file back:

ipfs get QmbYq2pMi91Xd5Hu6Z1edrvP4BwJXCH9HhRX8Tk99DJWG6 --output out.png

The – -output parameter allows you to provide the name of the downloaded file.

Creating a Directory:

You may even publish an entire directory with files and nested directories simultaneously. To do so, add the -r (short for — recursive) parameter to the add command. Place the logo file in the logo directory, then run:

ipfs add -r logo

The result will be as follows:

added QmbYq2pMi91Xd5Hu6Z1edrvP4BwJXCH9HhRX8Tk99DJWG6 logo/ipfs-logo.png 
added QmU1muwAeYjHX1kUnYEXPWEhnFxcVGS6wv8tggoHLHkm3f logo

The directory’s identification appears on the bottom line. It may be accessed using ipfs get, just like a single file.

Each file in the directory may be identified by its relative path to the parent directory. Each file, however, has been granted a unique identification. Without any directory context, a specific file can be accessed by its multihash. In our example, the following commands should return the same file without fetching the whole directory:

ipfs get QmU1muwAeYjHX1kUnYEXPWEhnFxcVGS6wv8tggoHLHkm3f/ipfs-logo.png 
ipfs get QmbYq2pMi91Xd5Hu6Z1edrvP4BwJXCH9HhRX8Tk99DJWG6 --output ipfs-logo2.png

Embracing the Swarm:

You’ve just published some files to your local IPFS storage and retrieved them. However, your file is not yet accessible to the entire world. To accomplish this, you must first launch an IPFS node:

ipfs daemon

The node functions as both a server and a client. It will link to several other nodes and share information on available material. You can see which nodes are related to you by entering:

ipfs swarm peers

The result will include several lines that like the following (the exact addresses and hashes may vary):

/ip4/ /ip6/2604:a880:cad:d0::17:2001/tcp/4001/ipfs/QmUR8d2WLbNcAFRMWn3SMdBRDhJugZUezfwLkDYti3Gc3w

Each line represents an IPFS node’s multiaddress. It comprises an IP network location (address and port) and a distinctive peer identification. The node’s address may change (when your laptop goes from place to place to café, for example), but the peer ID remains constant.

Data Storage:

No one node can conceivably store all of the data ever released. This indicates that your node may opt to discard some of the data. This also implies that you cannot rely entirely on your peers: if no one is interested in retaining your data, it may just vanish from the network.

You can pin the data object’s identification to prevent it from vanishing. This ensures that the data is not erased if your local node decides to clear up some space.

Because the files you’ve uploaded are automatically pinned, let’s pin something you don’t have yet:

ipfs pin add /ipfs/QmNhFJjGcMPqpuYfxL62VVB9528NXqDNMFXiqN5bgFYiZ1/its-time-for-the-permanent-web.html

The result should be as follows:

pinned Qmcx3KZXdANNsYfSRU1Vu4pchM8mvYXH4N8Zwdpux57YNL recursively

This process also downloads the data to your computer to ensure that it never disappears. However, recovering it should be a breeze now:

ipfs get Qmcx3KZXdANNsYfSRU1Vu4pchM8mvYXH4N8Zwdpux57YNL -o article.html

How to Find the Right Data:

Despite the fact that the file was just 26 kB in size, the last action may have taken a while. This occurs because data must first be identified until it can be saved.

The requested data block might be stored on any IPFS node worldwide. Because your local node is unlikely to maintain direct links to every other server or keep a record of every block added elsewhere, locating the correct node might take some time.

The information about which node holds which blocks is arranged in a distributed hash table, which is spread among nodes in the same way as data is. When searching for data specified by a specific hash, your node must first discover the node with that block. The node requests several of its immediate peers, so if one of them happens to have the block in question, the search is over. If a peer does not hold the data, it makes the identical query to its peers until the data block’s keeper is discovered.

The network’s nodes are configured so that this procedure has minimal overhead, and the entire network may be traversed in minutes. However, in the worst-case scenario, the search may take several minutes. This is true for recently released data, and knowing your colleague seated next to you published it can be aggravating. Fortunately, you can avoid the worldwide search if you already know where to seek it.

Recall the Qm… hash that the init command printed out? That was your node’s peer ID, after all. When you type the command, it will be presented with some more information, so don’t worry if you forgot to write it down.

ipfs id

The resulting JSON object will include various fields. For the time being, the most significant is the node ID.

If you know the node ID that must hold the data you want, you may bypass the time-consuming search by providing a direct connection with that node. To accomplish this, use the command:

ipfs swarm connect /ipfs/Qm…

replacing the node’s ID for the Qm… path

Your IPFS node must first look for a new peer before connecting. This step can also be skipped if you know the distant node’s entire multi-address. In such a scenario, you may run the same command with the complete multiaddress as an input, as seen below:

ipfs swarm connect /ip4/<IP address>/tcp/<port number>/ipfs/<peer ID>

IPFS may operate over various network protocols, and a node often listens on numerous network interfaces.  As a result, a node will often have many multi addresses with somewhat varied forms.

Each one contains the peer ID and information on how it may be accessed (e. g. an IPv5 address and port).

You may also retrieve the node’s addresses by using its peer IDs:

ipfs dht findpeer Qm...

When a Peer Connection Fails:

It’s possible that your colleague at the workstation next to yours has uploaded a data block — say, a new Fury build — but you can’t seem to get it or even connect to his IPFS node. The most common reason for these problems is a network connection, such as a firewall that stops machines on the very same network from communicating with one another. The following procedures will assist you in determining the root of the problem.

Attempt to access the data using a WWW gateway. The IPFS logo, for example, described at the start of this article, may be seen at this URL:

This usually takes several minutes for newly released data. If, however, the request expires, one of these things happens:

The node(s) that used to hold the data block is presently offline, or the node that published the block is disconnected from the entire network, maybe due to a network firewall.

Whether the gateway successfully retrieves the data, but the local IPFS node did not use telnet to see if you can access the peer’s address and port. You’re out of luck if the connection could be formed. Data sharing is still feasible, but not in all cases, only through a third node that you and your peer can access. You have two options for resolving the issue:

Speak with your network administrator about allowing IPFS connections on your local network.

Hosting your data at one of the pinning providers may move it outside the limited network.