Geth (Go Ethereum)

What Is Geth (Go Ethereum)?

Geth, short for Go Ethereum, is an open-source Ethereum execution client written in the Go programming language.

It is software that allows a computer to connect to Ethereum, verify blockchain activity, execute smart contracts, maintain Ethereum’s current state, and provide blockchain data to wallets and decentralized applications.

The official Go Ethereum website describes Geth as a Go implementation of Ethereum and a gateway into the decentralized web.

Geth has been part of Ethereum since the network’s early development and has operated on Ethereum mainnet since its launch in 2015.

It is not a cryptocurrency, wallet token, consensus mechanism, or separate blockchain.

Instead, Geth is one implementation of the software rules that define Ethereum’s execution layer.

A user can run Geth to operate an Ethereum node, access blockchain information without depending entirely on a third-party data provider, broadcast signed transactions, inspect smart contract execution, or build cryptocurrency infrastructure.

Since Ethereum moved to proof of stake, Geth must normally run alongside a consensus client to form a complete Ethereum node.

What Does Geth Do?

Geth processes the execution side of Ethereum.

It receives transactions from users and other nodes, verifies whether those transactions follow Ethereum’s rules, and stores valid pending transactions in its transaction pool.

It executes smart contract code through the Ethereum Virtual Machine, commonly called the EVM.

It calculates changes to account balances, token balances, contract storage, gas usage, and other parts of Ethereum’s state.

It checks the execution payloads contained in new blocks to confirm that every included transaction produces the correct result.

It maintains a local database containing blockchain headers, transaction data, receipts, contract code, and the Ethereum state required by the selected node configuration.

It communicates with other Ethereum execution nodes through a peer-to-peer network.

It also exposes APIs that allow wallets, analytics tools, trading systems, blockchain explorers, and decentralized applications to request Ethereum data.

The official Geth node architecture documentation explains that Geth is responsible for transaction handling, transaction propagation, state management, execution payload creation, and EVM execution.

Is Geth a Complete Ethereum Node?

Geth alone is not normally a complete Ethereum node under Ethereum’s proof-of-stake architecture.

A complete node consists of an execution client and a consensus client working together.

Geth serves as the execution client, while the consensus client follows the proof-of-stake chain, processes attestations, applies fork-choice rules, and determines which block represents the current chain head.

The two clients exchange information through an authenticated interface called the Engine API.

The connection is protected with a shared JSON Web Token secret, commonly called a JWT secret.

Geth uses the consensus client’s chain information to determine the block toward which it should synchronize.

The consensus client uses Geth to verify transaction execution and obtain execution payloads for proposed blocks.

The official consensus client connection guide explains how the clients communicate through an authenticated RPC port.

A validator operator also needs separate validator software connected to the consensus client.

Running Geth does not automatically make the operator a validator and does not require the operator to stake ETH.

What Is an Ethereum Execution Client?

An execution client is software that applies Ethereum’s transaction and smart contract rules.

It maintains the execution-layer state, which records information such as ETH balances, account nonces, deployed contract code, and contract storage values.

When a transaction reaches Geth, the client checks the sender’s signature, nonce, gas settings, available balance, transaction format, and other validity conditions.

If a smart contract is involved, Geth runs the relevant EVM bytecode and calculates the resulting state changes.

When Geth receives a block from its connected consensus client, it re-executes the block’s transactions rather than blindly trusting the proposed result.

If the execution result conflicts with Ethereum’s rules, Geth reports that the payload is invalid.

This independent verification is an important part of Ethereum’s security because each node enforces the protocol locally.

How Geth Uses the Ethereum Virtual Machine

The Ethereum Virtual Machine is the computational environment in which Ethereum smart contracts run.

Developers usually write smart contracts in a higher-level language and compile them into EVM bytecode.

Geth includes an EVM implementation that reads this bytecode and executes its instructions.

These instructions can perform calculations, read contract storage, update token balances, emit event logs, create contracts, or call other contracts.

Every operation consumes a defined amount of gas, which prevents unlimited computation from blocking the network.

Geth calculates the gas consumed during execution and rejects transactions that exceed their gas limit or violate Ethereum’s execution rules.

Developers can also use Geth’s EVM tracing tools to inspect individual operations performed during a transaction.

Tracing is useful for investigating failed transactions, measuring gas consumption, analyzing contract behavior, and identifying the source of an unexpected state change.

What Is the Latest Geth Version?

The official Geth downloads page listed version 1.17.4 as the latest stable release in July 2026.

Users should check the official Geth downloads page before installing or updating because new maintenance and security releases may appear at any time.

Stable releases are recommended for most node operators because they have received more testing than development builds.

Running an outdated version can cause synchronization problems, expose the node to known vulnerabilities, or prevent it from following a scheduled Ethereum network upgrade.

A node operator can check the installed version by running

in a command-line environment.

Geth also includes the

command, which checks the installed release against the project’s published vulnerability information.

The official Geth vulnerability disclosure documentation explains how this security check works.

How Does Geth Synchronization Work?

Synchronization is the process through which Geth downloads and verifies enough Ethereum data to reach the latest valid blockchain state.

A newly installed node does not automatically know current account balances, contract storage, transaction history, or the latest block.

It must obtain data from peers and verify that the information is consistent with Ethereum’s protocol rules.

After Ethereum’s transition to proof of stake, Geth also needs a synchronized consensus client to provide a trusted target for execution-layer synchronization.

Geth offers different synchronization and storage configurations for different use cases.

The appropriate configuration depends on whether the operator needs current state, older transaction history, historical contract state, cryptographic proofs, or high-performance data access.

What Is Snap Sync in Geth?

Snap sync is Geth’s default synchronization mode for creating a full Ethereum node.

Instead of executing every block from genesis before reaching the current state, snap sync begins from a relatively recent state snapshot and verifies the data required to catch up with the chain.

This approach is significantly faster than rebuilding all Ethereum state from the first block.

During snap sync, Geth downloads block headers, block bodies, transaction receipts, and state data from its peers.

It also performs a process known as state healing to obtain missing pieces of the state and confirm that the local database is complete.

After reaching the chain head, the node switches to normal block-by-block processing.

The official Geth sync mode documentation identifies snap sync as the default behavior.

A snap-synchronized node still independently verifies Ethereum data and is considered a full node.

The word “snap” describes how the initial synchronization is performed rather than suggesting that the node permanently depends on an unverified snapshot.

What Is Full Sync in Geth?

Full sync processes Ethereum blocks sequentially from an earlier point, potentially beginning with the genesis block.

Geth downloads each block, executes its transactions, and reconstructs the resulting state.

This method requires more time and computation than snap sync.

It may be useful for specialized research, archive-node construction, protocol testing, or situations where an operator specifically wants to rebuild execution history.

A full-sync node is not automatically an archive node because Geth may still remove older state data after it is no longer required for normal operation.

Archive behavior must be configured separately when the operator needs direct access to historical account and contract states.

What Is a Geth Full Node?

A Geth full node verifies Ethereum execution and stores enough data to serve current blockchain information and process new blocks.

It can independently verify transactions instead of trusting a remote service to report valid results.

A full node can provide account balances, contract code, transaction receipts, event logs, recent state information, and other data through its APIs.

It does not necessarily keep every historical version of every account and smart contract storage slot.

Older states may be pruned or reconstructed when possible to reduce storage requirements.

This makes a standard full node more practical for home operators and application developers than a complete archive node.

Running a full node also improves personal control because the operator can submit transactions and query Ethereum through locally verified infrastructure.

What Is a Geth Archive Node?

A Geth archive node stores historical Ethereum state so that users can query account balances, contract storage, or other state values as they existed at older blocks.

This is different from keeping only historical transactions and receipts.

A normal node may know that a transaction occurred years ago without keeping an immediately accessible copy of every contract storage value produced at that point.

Archive nodes are useful for blockchain analytics, tax systems, compliance tools, explorers, historical simulations, smart contract research, and advanced debugging.

Geth supports legacy hash-based archive nodes and newer path-based archive nodes.

The official Geth archive mode guide recommends the path-based approach for current deployments.

What Is Path-Based Archive Mode?

Path-based archive mode is a newer Geth storage design introduced in version 1.16.0.

It stores historical state more efficiently than the legacy hash-based archive design.

The official documentation estimates that a path-based Ethereum mainnet archive containing full flat state history can require around 2 TB of storage.

Keeping additional historical trie data for broader proof support can increase the storage requirement substantially.

By comparison, a legacy hash-based archive database can exceed 20 TB and may require months to build from genesis.

Path-based archive mode also allows operators to select how many historical states they want to retain.

Setting a limited retention window can reduce storage consumption when a project does not need state from every historical block.

Beginning with Geth 1.17.x, operators can configure historical trie-node retention when historical Merkle proof support is required.

Archive settings should be planned before deployment because state removed through pruning may not be recoverable without rebuilding or importing the required data.

What Is Pruning in Geth?

Pruning removes blockchain data that is no longer needed for the node’s selected operating mode.

Ethereum produces new transactions, receipts, contract states, and execution data continuously, so an unpruned database can grow beyond the capacity of the storage device.

State pruning removes older state structures while preserving the data required to verify the current chain.

History pruning can remove older block bodies and receipts while retaining headers and the information needed for consensus verification.

The Geth history pruning guide explains how operators can reduce storage use while preserving normal node functionality.

A pruning operation should only be performed according to official instructions and with Geth fully stopped when the command requires offline database access.

Interrupting database maintenance or allowing multiple processes to access the same data directory can cause corruption.

Operators who need old data later may be able to restore selected history through verified Era files, depending on the type of information that was removed.

What Hardware Does Geth Require?

Geth should generally run on a computer with a modern multi-core processor, sufficient memory, a fast solid-state drive, a stable broadband connection, and enough storage for continuing blockchain growth.

Disk speed is especially important because synchronization and state healing involve many database reads and writes.

A traditional hard disk may be too slow for the active Geth database used by a normal mainnet node.

Archive configurations require much more storage than standard full-node configurations.

The required capacity also depends on pruning settings, cache allocation, historical retention, operating system, consensus client, and other software running on the machine.

Operators should consult the latest official Geth hardware requirements before purchasing equipment.

Storage should not be allowed to become completely full because database operations and pruning may require additional free working space.

A backup strategy should focus on private keys, configuration files, JWT secrets, and other irreplaceable information rather than assuming that a full blockchain database must always be copied.

How Do Applications Connect to Geth?

Applications usually connect to Geth through Ethereum’s JSON-RPC interface.

JSON-RPC allows software to send structured requests and receive structured responses from the node.

A wallet might request an account balance, while a decentralized application might call a contract function or estimate the gas required for a transaction.

Geth supports JSON-RPC over HTTP, WebSocket, and inter-process communication sockets.

The official Geth JSON-RPC documentation explains the available transports and configuration settings.

HTTP is widely used for standard requests such as reading a balance or submitting a signed transaction.

WebSocket connections support persistent communication and subscriptions to real-time events.

Local inter-process communication generally offers a safer and more complete interface when the application runs on the same machine as Geth.

What Are Geth RPC Namespaces?

Geth groups JSON-RPC methods into namespaces according to their purpose.

The

namespace contains common Ethereum methods involving blocks, transactions, accounts, logs, calls, and gas estimation.

The

namespace provides basic network information.

The

namespace includes general utility functions.

The

namespace exposes information about pending and queued transactions.

The

namespace provides advanced tracing and inspection methods.

The

namespace provides control over peers and parts of the local Geth instance.

Sensitive namespaces should not be exposed to untrusted networks because they can reveal internal information, consume large amounts of resources, or permit administrative actions.

Geth enables only a limited set of namespaces on HTTP by default.

Can Geth Be Used as an RPC Node?

Yes, Geth can provide Ethereum RPC services to wallets, websites, automated systems, and blockchain applications.

Running a private Geth RPC endpoint can reduce dependence on an outside infrastructure provider.

It can also improve privacy because account queries and transaction submissions do not need to be sent to an unrelated public endpoint.

However, a reliable public RPC service requires more than starting Geth with an HTTP flag.

The operator must plan for authentication, filtering, rate limits, monitoring, load balancing, backups, abuse prevention, and protection against resource-intensive requests.

Public access to tracing or administrative APIs can create serious security and performance risks.

The Geth security documentation advises against directly exposing API endpoints to the public internet without additional protective infrastructure.

How Does Geth Connect to Other Nodes?

Geth uses Ethereum’s peer-to-peer networking protocols to discover and communicate with other execution nodes.

Peers exchange block information, transactions, state data, and synchronization messages.

A healthy peer set helps the node receive new transactions and chain data from multiple independent sources.

Geth verifies received data rather than trusting a peer simply because a connection was established.

Invalid or harmful data can be rejected, and peers that violate protocol rules may be disconnected or penalized.

The peer-to-peer port should be reachable when the operator wants the node to accept incoming connections.

The JSON-RPC port serves a different purpose and normally should not be publicly exposed merely to improve peer connectivity.

Firewalls should distinguish between the public peer-to-peer port and private administrative or application interfaces.

How Does Geth Handle Pending Transactions?

Geth stores valid transactions that have not yet been included in a block inside its transaction pool.

The pool separates transactions that are ready for inclusion from transactions that cannot yet be executed.

A transaction may be queued because an earlier transaction from the same account has not arrived or because its nonce is too high.

Geth propagates eligible transactions to other execution nodes through the peer-to-peer network.

Transactions can be replaced when a new transaction uses the same account nonce and meets the replacement fee requirements.

Applications can inspect pending activity through selected transaction-pool APIs when those methods are enabled.

A transaction appearing in the local pool is not guaranteed to be included in a block.

It may be replaced, dropped, rejected by other nodes, or remain pending when its fee is too low for current network conditions.

Can Geth Store Cryptocurrency Private Keys?

Geth includes keystore functionality that can store encrypted Ethereum private keys.

The encrypted files are protected by passwords chosen by the user.

Losing both the key file and its backup can permanently remove access to the associated cryptocurrency.

An attacker who obtains an unencrypted private key can control the assets associated with that key.

The Geth team recommends separating transaction signing from the node process through an external signer.

Modern Geth releases no longer bundle Clef directly, and users who choose that signer should obtain it from its separately maintained official project.

The older

RPC namespace has been deprecated in favor of safer external signing workflows.

Node operators should never expose unlocked accounts or sensitive signing methods through a public RPC endpoint.

How to Install Geth Safely

Geth can be installed through official prebuilt packages, supported package managers, container images, or source code.

The official Geth installation guide provides instructions for major operating systems.

Users should obtain binaries only from the official project or a verified package source.

Release signatures and checksums should be verified when the installation process provides them.

A stable release is normally more appropriate for a production cryptocurrency node than an untested development build.

The node should be stopped cleanly before a manual software upgrade.

Operators should read release notes before upgrading because a release may change command-line flags, database formats, network upgrade requirements, or security procedures.

A recent backup of irreplaceable configuration and key material should exist before performing maintenance.

Can Geth Run on Ethereum Testnets?

Geth can connect to supported Ethereum public testnets when started with the appropriate network configuration.

Testnets allow developers to deploy contracts, send transactions, test wallet connections, and study node operations without using mainnet ETH.

Testnet ETH has no intended real-world monetary value and exists separately from mainnet ETH.

Developers should choose a currently maintained testnet rather than relying on a deprecated network.

Geth must still run with a compatible consensus client when the selected testnet uses Ethereum’s proof-of-stake architecture.

Contract addresses, balances, transaction histories, and tokens do not automatically carry from one testnet to another.

Private keys used in experimental environments should not be reused for valuable mainnet cryptocurrency because test systems may expose keys through logs, scripts, or insecure development tools.

Can Geth Create a Private Ethereum Network?

Geth can be used to create an isolated Ethereum-compatible network with a custom genesis configuration.

A private network has its own chain ID, accounts, protocol settings, nodes, and blockchain history.

It does not automatically connect to Ethereum mainnet or inherit mainnet assets.

The official Geth private network guide explains how a custom genesis file initializes the network database.

Private networks can support multi-user application tests, blockchain research, network experiments, and controlled development environments.

The word “private” means that access to the network is restricted or isolated.

It does not mean that the network is automatically encrypted, secure, or protected from every attack.

Production private networks require carefully designed consensus, access control, peer management, monitoring, and key security.

Geth for Smart Contract Developers

Smart contract developers can use Geth as a local source of verified Ethereum data.

They can submit deployments, call contract functions, retrieve event logs, estimate gas, simulate transactions, and inspect execution traces.

Geth’s development mode can create a temporary local blockchain for testing without connecting to a public network.

The project also provides an in-memory simulated blockchain through its Go libraries.

Developers can use tracing APIs to understand why a transaction reverted or consumed more gas than expected.

Running a local node can make testing more reproducible because the developer controls the software version, APIs, and stored data.

A successful test through Geth does not prove that a smart contract is secure.

Production contracts still require testing, code review, permission analysis, economic modeling, and appropriate security audits.

Geth as a Go Library

Go Ethereum is not limited to the command-line Geth program.

Developers can import its packages into Go applications to build custom Ethereum infrastructure.

The official Geth library documentation describes how projects can reuse its node container, networking, Ethereum service, RPC system, contract bindings, and simulated blockchain.

A developer can build a specialized node, add a custom RPC namespace, connect to Ethereum through a Go client, or create an application-specific indexing system.

The

package provides a Go interface for common Ethereum JSON-RPC operations.

The

tool generates type-safe Go bindings from a smart contract’s application binary interface.

The

command allows developers to execute and inspect EVM bytecode in a controlled environment.

Using Geth as a library gives developers access to code that has been tested through years of Ethereum operation, but custom modifications still require independent security review.

Geth and Ethereum Staking

Geth can serve as the execution client for an Ethereum validator setup.

The validator software communicates with a consensus client, which communicates with Geth through the Engine API.

Geth validates transactions and prepares execution payloads when the validator is selected to propose a block.

It also verifies execution payloads received from the network.

Geth does not store the validator’s proof-of-stake signing key as part of its normal execution-client role.

Validator keys are handled through the validator software and its associated security procedures.

A Geth failure can affect validator performance because the validator may be unable to propose a complete block or verify execution data.

Staking operators therefore need monitoring, sufficient hardware, reliable internet access, timely updates, and a tested recovery process.

Geth Security Best Practices

Node operators should keep Geth updated because client releases regularly include bug fixes, performance improvements, protocol changes, and security patches.

RPC interfaces should listen only on trusted addresses unless a properly secured public service is intentionally being operated.

Administrative, debugging, transaction-pool, and signing APIs should not be made available to untrusted users.

Firewalls, reverse proxies, authentication, transport encryption, request filtering, rate limiting, logging, and monitoring can reduce the risks of a public endpoint.

Private keys and passwords should be stored separately from publicly accessible services.

The JWT secret used between the execution and consensus clients must also be protected from unauthorized access.

Only one Geth process should access a data directory at a time.

The official Geth security guide warns that public APIs can create denial-of-service risks, privacy risks, resource exhaustion, and unauthorized signing attempts.

Users should also verify all transaction details because a secure node cannot prevent a person from approving a malicious smart contract interaction.

Benefits of Running Geth

Running Geth allows a user to verify Ethereum execution locally instead of trusting every response from a remote provider.

It can improve privacy because balance checks, contract reads, and transaction submissions can remain within infrastructure controlled by the user.

It gives developers direct access to advanced RPC methods, transaction pools, logs, traces, and node configuration.

It improves Ethereum’s peer-to-peer network by adding another independently operated node.

It allows cryptocurrency businesses to control data retention, request limits, software updates, and service availability.

It can support validator operations, blockchain research, monitoring systems, wallets, and decentralized applications.

It also provides an educational way to understand how Ethereum verifies transactions and maintains state.

Limitations of Running Geth

Geth requires continuous maintenance, storage capacity, bandwidth, software updates, and system monitoring.

Initial synchronization may take a significant amount of time depending on hardware, network speed, peer quality, and the selected node mode.

A standard full node cannot answer every historical state query as quickly as an archive node.

An archive node can require several terabytes of storage and specialized operational planning.

Incorrect RPC configuration can expose the node or connected accounts to serious security risks.

Running Geth also introduces dependence on one execution-client codebase for that particular node.

Ethereum benefits when node operators use multiple independently developed client implementations across the overall network.

The Ethereum client diversity guide explains how a balanced client distribution can limit the network-wide effect of a software bug.

Common Misunderstandings About Geth

One misunderstanding is that Geth is a cryptocurrency that can be bought or traded.

Geth is software, and ETH is the native cryptocurrency used on Ethereum.

Another misunderstanding is that installing Geth automatically begins cryptocurrency mining.

Ethereum no longer uses proof-of-work mining, and Geth’s historical mining functions are deprecated.

A third misunderstanding is that Geth alone is enough to follow Ethereum mainnet.

Under proof of stake, a production node normally requires both Geth and a consensus client.

A fourth misunderstanding is that a full node stores every historical state.

Complete historical state access requires an archive configuration.

A fifth misunderstanding is that opening every RPC namespace makes the node more useful.

Unnecessary namespaces increase the attack surface and should remain disabled.

A sixth misunderstanding is that a synchronized node guarantees every smart contract is safe.

Geth verifies protocol execution but does not guarantee that a contract’s business logic is fair, secure, or free from malicious behavior.

FAQ

What does Geth stand for?

Geth is short for Go Ethereum because the client is an implementation of Ethereum written in the Go programming language.

Is Geth a cryptocurrency?

No, Geth is Ethereum node software rather than a cryptocurrency or token.

Is Geth the same as Ethereum?

No, Ethereum is the blockchain protocol and network, while Geth is one software implementation of Ethereum’s execution-layer rules.

What is Geth used for?

Geth is used to verify Ethereum transactions, execute smart contracts, synchronize blockchain data, provide RPC access, operate node infrastructure, and support validators.

Can Geth run by itself?

Geth can be used alone for certain development and library scenarios, but a complete production proof-of-stake Ethereum node normally requires a connected consensus client.

Does Geth mine ETH?

No, Ethereum replaced proof-of-work mining with proof-of-stake validation, so Geth’s old mining functions are no longer used on Ethereum mainnet.

Does running Geth require 32 ETH?

No, anyone can run a non-validating Geth node without staking ETH.

Can Geth make me an Ethereum validator?

No, validation also requires a consensus client, validator software, validator keys, and the required staking deposit.

What is Geth snap sync?

Snap sync is the default synchronization method that obtains a recent Ethereum state and verifies the data needed to catch up with the current chain.

Is a snap-synced Geth node a full node?

Yes, a snap-synced node independently verifies Ethereum execution and becomes a normal full node after reaching the chain head.

What is the difference between a Geth full node and archive node?

A full node maintains the data required for current verification, while an archive node also retains historical versions of Ethereum state for direct old-block queries.

How much storage does a Geth archive node need?

The amount depends on its configuration, but current documentation estimates around 2 TB for a path-based archive with full flat state history and more when historical trie data is retained.

What port does Geth JSON-RPC use?

Geth’s HTTP JSON-RPC server commonly uses port 8545 by default when the HTTP interface is enabled.

What port connects Geth to a consensus client?

The authenticated Engine API commonly uses port 8551, although the operator can configure a different port.

Is it safe to expose Geth RPC to the internet?

Direct public exposure is not recommended without authentication, filtering, rate limits, monitoring, and other security controls.

Can Geth hold private keys?

Geth supports encrypted keystore files, but external signing and careful separation of keys from public node services provide safer operational practices.

Can Geth be used for smart contract development?

Yes, developers can use Geth for contract deployment, calls, event queries, gas estimation, simulations, transaction tracing, and local blockchain testing.

Can Geth connect to a testnet?

Yes, Geth can connect to supported Ethereum testnets when it is launched with the correct network and consensus-client configuration.

Can Geth create a private blockchain?

Yes, Geth can initialize an isolated Ethereum-compatible network using a custom genesis configuration.

How do I check my Geth version?

Run

in the command line to display the installed release information.

How do I check Geth for known vulnerabilities?

Run

and review the official release and vulnerability information before operating a production node.

Should Geth always be kept updated?

Yes, timely stable-version updates are important for security, network upgrade compatibility, reliability, and performance.

Conclusion

Geth is an open-source Ethereum execution client written in Go and one of the foundational software implementations used to interact with the Ethereum blockchain.

It validates transactions, executes smart contracts through the EVM, maintains Ethereum state, communicates with peers, and provides blockchain data through JSON-RPC interfaces.

Under Ethereum’s proof-of-stake architecture, Geth normally works alongside a consensus client to form a complete node.

Users can run Geth as a standard full node, configure an archive node for historical state, connect applications through RPC, support validator infrastructure, or reuse its Go packages in custom blockchain software.

Snap sync provides a practical default for most node operators, while newer path-based archive storage reduces the resources required for advanced historical analysis.

Running Geth can improve verification, privacy, infrastructure control, and access to detailed Ethereum data.

However, it also requires sufficient hardware, secure API configuration, regular updates, monitoring, and careful key management.

Geth should be understood as critical cryptocurrency infrastructure rather than as a cryptocurrency itself.

Its main purpose is to enforce Ethereum’s execution rules independently and give users direct access to a locally verified view of the network.