Blockscout supports multiple chains, and each chain has its own database that stores verified smart-contracts. Because these databases are independent of one another, verified contracts and their method identifiers typically cannot be shared between chains.

For example, if a contract is verified on Ethereum Mainnet, it cannot be accessed on Gnosis Chain even if the creation transaction input is the same.

To address this issue, we have implemented a database for verified contract information which can be shared across all supported chains. This database and it's associated functionality has been created as a Blockscout microservice called the Ethereum Bytecode Database (Blockscout EBD).

Initial Planning

Initial plans were to create a distinct service with a database responsible for maintaining verification results. This database could then be shared among all supported chains. The service would track the contract address and the chain where the contract was deployed. The source files would also be stored so they could be extracted for verified contracts. The service would also find and match unverified contracts to their verified counterparts if they already existed in the database.

Restructuring the Search Process

It is possible to search for similar bytecodes if the bytecodes (or their hashes) are stored in the database along with verification results. The list of already verified bytecodes can then be checked when searching for the source codes of unverified contracts.

However, with this type of search the chainId and contractAddress arguments are typically required, as source codes for already verified contracts are stored based on the chain and address where these contracts are deployed. This is how most source code databases are designed (e.g., Sourcify, Etherscan, Blockscout).

With this new service, our main goal was not just to return source codes for verified contracts (since that data is already stored and processed internally within Blockscout's main storage), but also to search for source codes for unverified contracts. To do this, we realized we could eliminate chainId and contractAddress and gain some advantages.

Solution - Ethereum Bytecode Database (Blockscout EBD)

A solution can be found by mapping source codes directly to bytecodes. In this case, chainId and contractAddress are not needed, only the bytecode-sourceCode correspondence if required. This is similar to what 4bytes or sigEth does. However, instead of looking for the function signature based on its identifier, we look for the contracts' source code based on its bytecode.

• Current Approaches: Chain → Contract Address → Sources

• Blockscout Ethereum Bytecode Database: Bytecode → Sources

Basics

In the following diagram for the new service, notice that there is no notion of chainId and contractAddress—only raw bytecodes are important.

Verification

Bytecode Source Search

The microservice does not care where the contract is deployed (which chain) or even whether a contract with the corresponding bytecode is deployed at all.

Similar Contracts Search Enhancement

In Blockscout, two contracts share the same source code only if their bytecodes are entirely identical. However, not every part of the bytecode is functional (see Sourcify partial vs. full match). There may also be a metadata hash, usually located at the end of the creation input or deployed bytecode. The source code can also produce different metadata hashes for inconsequential changes, such as when a new space is appended to the file or the file is renamed. This results in bytecodes with the same EVM-executed portion, but they may not be identified by Blockscout's current similar contracts search algorithm.

As described in smart-contract verification, our verification service allows us to split the bytecode into 2 parts, Main and Metadata. The Ethereum Bytecode Database takes advantage of this and searches for similar bytecodes based only on the Main (functionally significant) parts.

Adding Extractors

Removing the notion of chains and contract addresses is powerful in and of itself. However, the addition of extractors provides the opportunity for an extremely robust database.

Extractors can be implemented as separate extensions which can index different explorers and different chains, then automatically submit newly verified bytecodes into the Ethereum Bytecode Database. It can also import contracts verified long ago.

This has the potential rapidly increase the dataset, allowing the service to collect sources for almost all bytecodes that have been publicly verified. Every time a new contract is verified on a monitored explorer, the extractor can upload the source code to the Ethereum Bytecode Database*. *This is in the research phase.

In addition, anyone can start the service from scratch and eventually obtain their own repository of verified contracts by running extractors they are interested in. Those who would like to host their own instance can obtain a populated database which can also be updated from other chains in the ecosystem.

Bytecode DB in Action

In this video we show a simple example where a contract is deployed and verified on Optimism Goerli. The same contract is then deployed to the Base Goerli instance, and the contract is automatically verified using the Blockscout Bytecode Database.

Conclusion

Implemented as a separate service, Ethereum Bytecode Database may become a unique source of verified contracts working with many chains. Furthermore, the addition of extractors allows verified contracts to be combined from an unlimited number of explorers, and gives users the ability to run the service locally using independently-obtained data.

Extractors implemented within a Blockscout private setting also allow for the creation of a unique and useful ecosystem-wide database. This will likely create a data source that will be attractive to different explorers and other data aggregators. We are currently looking into the best way to provide 3rd party access to this dataset, possibly as a paid database or verifier service in the future.

Implementation Details

API Integration

The service has the same public API as the smart-contract-verifier service. If a chain wants to start saving verified bytecodes into a database, the only required change is to point RUST_VERIFICATION_SERVICE_URL to the eth-bytecode-db service instead of the verifier. The service will proxy all requests to the underlying verifier internally.

Completed Processes

1. The Eth-bytecode-db service is implemented with both contract verification proxy and database search functionality (https://github.com/blockscout/blockscout-rs/tree/main/eth-bytecode-db).

2. All hosted blockscout instances are using eth-bytecode-db instead of the original smart-contract-verifier; all newly verified bytecodes and corresponding sources are now stored directly in the database.

3. Search functionality is integrated. (https://github.com/blockscout/blockscout/pull/7187).

4. DB is available on production instances including Ethereum Mainnet, Goerli, Gnosis, Optimism and more.

5. Extractor has been implemented for the "smart-contract-fiesta" dataset.

Current production database contains >130k source codes, where ~100k have unique main parts.

Future Plans

1. Implement a Blockscout extractor and import all previously verified contracts from Blockscout instances into the running eth-bytecode-db database (should expand the current database up to ~100-150k contracts).

2. Estimate and implement prioritization techniques, so that the service returns potential contracts that are the most probable for the given bytecode first.

3. Create a separate page similar to https://www.4byte.directory/ which allows users to search for the source code for a given bytecode directly, and submit new contracts into the database (to better understand how the service works and expand our database).

4. Support verification of contracts verified via metadata. Write a Sourcify extractor to import these contracts into our database (should expand the database up to ~400-500k contracts).

Blockscout provides a comprehensive, easy-to-use interface for users to view, confirm, inspect and interact on EVM (Ethereum Virtual Machine) blockchains.

Blockscout currently supports a wide range of projects and chains, see our chains and projects page for more details.

While there are several explorers available to blockchain projects, most are closed systems (ie Etherscan, Routescan) which are not independently verifiable and do not support all chains in the ecosystem. Blockscout provides a much needed open-source alternative.

As the multi-chain paradigm continues to take hold in both private and public settings, transparent tools are needed to analyze and validate transactions and provide an explorer for all networks, including rollups, L2s, L3s and appchains.

Information on the latest release and version history is available in the Github repo.

Blockscout has been serving the greater Ethereum ecosystem since 2018. During that time we've improved features and processing speed and have seen broad adoption of Blockscout across many EVM chains. We've also seen many changes in the space that demand more user-friendly functionality. As a result, we've been working diligently behind the scenes to improve the Blockscout explorer experience and build the tools, views, and features that users need now and into the future.

In 2023 we rolled out a newly redesigned open-source Blockscout explorer 🎉! The frontend Github repository is available here.

The redesign reimagines the blockchain explorer as a universal portal for exploring chain data, analytics, tools, apps, projects and more. Similar to a web 2.0 search engine, Blockscout will provide a web3 engine for deep exploration of all aspects of a chain.

Features include:

• React frontend redesigned from the ground up to allow for easier customizations and faster data rendering.

• Rust microservices provide code modularity and extend functionality with a more accessible language for web3 developers.

• My Account section for customizable views, API keys, watch list, tags and custom smart contract interaction.

• Custom transaction views break down txs step-by-step to provide insight and transparency into each action performed.

• DApp marketplace featuring access to applications and on-chain projects.

• Native DApp integrations will include common ecosystem tools like swaps, access revoke, and multisender.

• NFT dashboard built for discoverability, tracking and trading.

• API layer designed for applications to quickly and confidently retrieve the data they need.

• Advanced analytics with a robust collection of charts to monitor network health, market data, smart contract views and more.

What can I do with Blockscout?

• Deep Search: Find all the information you need on Blocks, Transactions, Tags and more through the integrated search box.

• Interact with Contracts: Read and write to contracts directly from the Blockscout UI.

• Verify Contracts: Use Hardhat, Sourcify, and other tools to quickly verify contracts.

• Make API Calls: Make requests to a robust API using standard and customized endpoints.

• Customize Views: Use the My Account features to add tags, watchlists and other features.

• Interact with Apps: Chains with the Apps Marketplace enabled include a portal for discovery and interaction with applications deployed on-chain.

Key Features

• Open source development: The code is community driven and available for anyone to use, explore, and improve.

• Broad multi-chain ecosystem support: Blockscout supports Ethereum mainnet, EVM forks like Ethereum Classic, Celo, & Gnosis Chain, Polkadot Parachains, Cosmos ecosystem, optimistic rollups, and many additional public and private EVM networks. See the list

• Real time transaction tracking: Transactions are updated in real time - no page refresh required. Infinite scrolling is also enabled.

• Smart contract interaction: Users can read and verify Solidity & Vyper smart contracts and access pre-existing contracts to fast-track development.

• Token support: Support for ERC20 and ERC721 tokens.

• Decoded views: Contract method calls and logs are decoded to provide additional information within the UI.

• Full-featured API: GraphQL provides the opportunity to test API calls directly from a web interface, and RPC methods are well documented.

• User customization: Users can easily deploy on a network and customize the Bootstrap-based interface.

• Modular and extendible: We're building next generation modularity into Blockscout with Rust-designed microservices.

The Vera application does not send verification requests directly to your instance, rather it stores the contract in the Verifier Alliance DB for your chain, then asks your instance to import contract details from that shared DB. The eth-bytecode-db service is responsible for retrieving the contract details and for contract verification.

Add your chain

1. Set the correct CHAIN_ID value and check you are using the Blockscout hosted eth-bytecode-db service. To do this, specify the following ENV variables in your Blockscout instance:

   Copy

   CHAIN_ID={chain_id}
   MICROSERVICE_SC_VERIFIER_ENABLED=true
   MICROSERVICE_SC_VERIFIER_URL=https://eth-bytecode-db.services.blockscout.com/
   MICROSERVICE_SC_VERIFIER_TYPE=eth_bytecode_db
   

   The eth-bytecode-db has read access to the Verifier Alliance database and can retrieve stored data.

2. Generate an API key consisting of letters and numbers and set it as the API_SENSITIVE_ENDPOINTS_KEY environment variable. If needed, Blockscout can generate and share it with you. This allows the Vera application service to trigger the lookup for verified contracts. Contracts are not verified directly when stored in the Vera database, so the instance must retrieve them for verification. Generally, the instance performs this retrieval on-demand when someone accesses the contract page. This process does not require any special access rights but has a timeout to prevent abuse. The API_SENSITIVE_ENDPOINTS_KEY allows the use of a special /api/v2/import/smart-contracts/{address} endpoint, bypassing the timeout limitation. The Vera application service uses this private endpoint to enforce the contract lookup on the instance. If not installed, the contract will remain unverified from the instance's point of view and will be verified later only when someone accesses the contract page.

3. Share the following values with Blockscout to add the chain to the Vera application (if we don't already have a shared group, contact an admin through Discord and let them know you want to add a chain to VERA).

   1. Network name (e.g., Eth Mainnet)

   2. Blockscout URL (e.g., https://eth.blockscout.com/)

   3. API_SENSITIVE_ENDPOINTS_KEY

Current list of supported chains

The following request returns the list of Vera supported chains.

GET http://proxy-verifier.services.blockscout.com/api/v1/chains

// Response
{
  "chains": [
    {
      "id": "string",
      "name": "string",
      "iconUrl": "string"
    }
  ]
}

Many Rollup-as-a-Service providers are using Blockscout as the default explorer for their instances. Once deployed, Blockscout can provide explorer support services when rollups want to customize or augment their explorers.

Each RaaS has their own processes and specializations including zkRollups or opRollups optimized for different environments. If you have questions about which RaaS to choose, or need customizations for your RaaS Blockscout instance, please contact us and we can direct you to the best option for your chain.

Blockscout features many 3rd party integrations. Additional services are also integrating Blockscout, including many Rollup-as-a-Service (RaaS) providers.

Blockscout Partners

Partners provide vital data, infrastructure, and contract support to Blockscout.

Tools and Utilities

Blockscout provides links to relevant, useful tools related to specific transactions and contracts for easy enhanced inspection.

Linked Explorers

Blockscout includes links to additional blockchain explorers for verification and transparency on hosted instances. Self-hosted instances can choose which additional explorers to link with using front-end ENVs during deployment.

Contract Verification

Contract verification integrations make it easier to verify contracts from a variety of development environments and bring in additional verified contract information.

Tokens and TVL

Feeds can be sourced from several options to provide the latest up-to-date token information. These options are set through application ENVs during deployment.

Ad Providers

Ad providers can be selected to bring relevant, web3 based ads based on the network where Blockscout is deployed. Ad options are set using front-end ENVs during deployment.

The Verifier Alliance is an ecosystem collective aiming for easy, unified, and open access to the source-code of EVM smart contracts. It is made up of projects across the ecosystem dedicated to making source code verification information freely available for all. Blockscout is a founding member of the collective and major contributor to the Vera Database.

• Blockscout Vera app: Verify and Publish contracts to supported networks.

• Add your network to the Vera DB

• Verify contracts programmatically via the API

Seed Funding Announcement

OurNetwork Blockscout Feature

OurNetwork is a leading crypto publication providing data-driven insights on blockchain industry trends. This deep dive on Blockscout features coverage about Blockscout Network Health, User Trends, Explorer-as-a-Service, and the DAppscout Marketplace.

Dappcon 2024 Blockscout Presentation

Head of research Kirill Fedoseev presented on network resilience and the need for reliable, transparent, and available explorers in a multi-chain world (starts at 7:50:00)

EthCC 2023 Blockscout Presentation

Head of Product Ulyana Skladchikova presented on the future of block explorers at ETHCC 2023 in Paris.

The Evolution & Future of Infrastructure at Optimism's On-Chain Summit

Base + Blockscout mainnet launch announcement

Base + Blockscout original press release

The Blockscout Newsletter is sent out monthly. It includes information on updates, new chains, integrations and other related information. If you use the My Account feature on Blockscout, an email newsletter subscription is automatically enabled when you sign up. You can unsubscribe at any time by clicking the unsubscribe link at the bottom of the email.

You can also subscribe to receive the newsletter.

Past newsletters are available on the Blockscout Blog. If you have anything you'd like to see featured in our newsletters, please let us know!