Directories
      ΒΆ
    
    | Path | Synopsis | 
|---|---|
| 
         
          
            client/beacon
            
            
          
           
      Package beacon provides a client for interacting with the standard Eth Beacon Node API. 
         | 
      Package beacon provides a client for interacting with the standard Eth Beacon Node API. | 
| 
         
          
            pagination
            
            
          
           
      Package pagination contains useful pagination-related helpers. 
         | 
      Package pagination contains useful pagination-related helpers. | 
| 
       Package async includes helpers for scheduling runnable, periodic functions and contains useful helpers for converting multi-processor computation. 
         | 
      Package async includes helpers for scheduling runnable, periodic functions and contains useful helpers for converting multi-processor computation. | 
| 
         
          
            abool
            
            
          
           
      Package abool provides atomic Boolean type for cleaner code and better performance. 
         | 
      Package abool provides atomic Boolean type for cleaner code and better performance. | 
| 
       beacon-chain
        | 
      |
| 
         
          
            blockchain
            
            
          
           
      Package blockchain defines the life-cycle of the blockchain at the core of Ethereum, including processing of new blocks and attestations using proof of stake. 
         | 
      Package blockchain defines the life-cycle of the blockchain at the core of Ethereum, including processing of new blocks and attestations using proof of stake. | 
| 
         
          
            blockchain/testing
            
            
          
           
      Package testing includes useful mocks for writing unit tests which depend on logic from the blockchain package. 
         | 
      Package testing includes useful mocks for writing unit tests which depend on logic from the blockchain package. | 
| 
         
          
            cache
            
            
          
           
      Package cache includes all important caches for the runtime of an Ethereum Beacon Node, ensuring the node does not spend resources computing duplicate operations such as committee calculations for validators during the same epoch, etc. 
         | 
      Package cache includes all important caches for the runtime of an Ethereum Beacon Node, ensuring the node does not spend resources computing duplicate operations such as committee calculations for validators during the same epoch, etc. | 
| 
         
          
            cache/depositsnapshot
            
            
          
           
      Package depositsnapshot implements the EIP-4881 standard for minimal sparse Merkle tree. 
         | 
      Package depositsnapshot implements the EIP-4881 standard for minimal sparse Merkle tree. | 
| 
         
          
            core/blocks
            
            
          
           
      Package blocks contains block processing libraries according to the Ethereum beacon chain spec. 
         | 
      Package blocks contains block processing libraries according to the Ethereum beacon chain spec. | 
| 
         
          
            core/epoch
            
            
          
           
      Package epoch contains epoch processing libraries according to spec, able to process new balance for validators, justify and finalize new check points, and shuffle validators to different slots and shards. 
         | 
      Package epoch contains epoch processing libraries according to spec, able to process new balance for validators, justify and finalize new check points, and shuffle validators to different slots and shards. | 
| 
         
          
            core/epoch/precompute
            
            
          
           
      Package precompute provides gathering of nicely-structured data important to feed into epoch processing, such as attesting records and balances, for faster computation. 
         | 
      Package precompute provides gathering of nicely-structured data important to feed into epoch processing, such as attesting records and balances, for faster computation. | 
| 
         
          
            core/feed
            
            
          
           
      Package feed defines event feed types for inter-service communication during a beacon node's runtime. 
         | 
      Package feed defines event feed types for inter-service communication during a beacon node's runtime. | 
| 
         
          
            core/feed/block
            
            
          
           
      Package block contains types for block-specific events fired during the runtime of a beacon node. 
         | 
      Package block contains types for block-specific events fired during the runtime of a beacon node. | 
| 
         
          
            core/feed/operation
            
            
          
           
      Package operation contains types for block operation-specific events fired during the runtime of a beacon node. 
         | 
      Package operation contains types for block operation-specific events fired during the runtime of a beacon node. | 
| 
         
          
            core/feed/state
            
            
          
           
      Package state contains types for state operation-specific events fired during the runtime of a beacon node such state initialization, state updates, and chain start. 
         | 
      Package state contains types for state operation-specific events fired during the runtime of a beacon node such state initialization, state updates, and chain start. | 
| 
         
          
            core/helpers
            
            
          
           
      Package helpers contains helper functions outlined in the Ethereum Beacon Chain spec, such as computing committees, randao, rewards/penalties, and more. 
         | 
      Package helpers contains helper functions outlined in the Ethereum Beacon Chain spec, such as computing committees, randao, rewards/penalties, and more. | 
| 
         
          
            core/transition
            
            
          
           
      Package transition implements the whole state transition function which consists of per slot, per-epoch transitions. 
         | 
      Package transition implements the whole state transition function which consists of per slot, per-epoch transitions. | 
| 
         
          
            core/transition/interop
            
            
          
           
      Package interop contains useful utilities for persisting ssz-encoded states and blocks to disk during each state transition for development purposes. 
         | 
      Package interop contains useful utilities for persisting ssz-encoded states and blocks to disk during each state transition for development purposes. | 
| 
         
          
            core/transition/stateutils
            
            
          
           
      Package stateutils contains useful tools for faster computation of state transitions using maps to represent validators instead of slices. 
         | 
      Package stateutils contains useful tools for faster computation of state transitions using maps to represent validators instead of slices. | 
| 
         
          
            core/validators
            
            
          
           
      Package validators contains libraries to shuffle validators and retrieve active validator indices from a given slot or an attestation. 
         | 
      Package validators contains libraries to shuffle validators and retrieve active validator indices from a given slot or an attestation. | 
| 
         
          
            db
            
            
          
           
      Package db defines the ability to create a new database for an Ethereum Beacon Node. 
         | 
      Package db defines the ability to create a new database for an Ethereum Beacon Node. | 
| 
         
          
            db/filters
            
            
          
           
      Package filters specifies utilities for building a set of data attribute filters to be used when filtering data through database queries in practice. 
         | 
      Package filters specifies utilities for building a set of data attribute filters to be used when filtering data through database queries in practice. | 
| 
         
          
            db/iface
            
            
          
           
      Package iface defines the actual database interface used by a Prysm beacon node, also containing useful, scoped interfaces such as a ReadOnlyDatabase. 
         | 
      Package iface defines the actual database interface used by a Prysm beacon node, also containing useful, scoped interfaces such as a ReadOnlyDatabase. | 
| 
         
          
            db/kv
            
            
          
           
      Package kv defines a bolt-db, key-value store implementation of the Database interface defined by a Prysm beacon node. 
         | 
      Package kv defines a bolt-db, key-value store implementation of the Database interface defined by a Prysm beacon node. | 
| 
         
          
            db/slasherkv
            
            
          
           
      Package slasherkv defines a bolt-db, key-value store implementation of the slasher database interface for Prysm. 
         | 
      Package slasherkv defines a bolt-db, key-value store implementation of the slasher database interface for Prysm. | 
| 
         
          
            db/testing
            
            
          
           
      Package testing allows for spinning up a real bolt-db instance for unit tests throughout the Prysm repo. 
         | 
      Package testing allows for spinning up a real bolt-db instance for unit tests throughout the Prysm repo. | 
| 
         
          
            execution
            
            
          
           
      Package execution defines a runtime service which is tasked with communicating with an eth1 endpoint, processing logs from a deposit contract, and the latest eth1 data headers for usage in the beacon node. 
         | 
      Package execution defines a runtime service which is tasked with communicating with an eth1 endpoint, processing logs from a deposit contract, and the latest eth1 data headers for usage in the beacon node. | 
| 
         
          
            execution/testing
            
            
          
           
      Package testing provides useful mocks for an eth1 powchain service as needed by unit tests for the beacon node. 
         | 
      Package testing provides useful mocks for an eth1 powchain service as needed by unit tests for the beacon node. | 
| 
         
          
            forkchoice
            
            
          
           
      Package forkchoice implements the service to support fork choice for the Ethereum beacon chain. 
         | 
      Package forkchoice implements the service to support fork choice for the Ethereum beacon chain. | 
| 
         
          
            forkchoice/doubly-linked-tree
            
            
          
           
      Package doublylinkedtree implements eth2 LMD GHOST fork choice using the doubly linked proto array node structure. 
         | 
      Package doublylinkedtree implements eth2 LMD GHOST fork choice using the doubly linked proto array node structure. | 
| 
         
          
            monitor
            
            
          
           
      Package monitor defines a runtime service which receives notifications triggered by events related to performance of tracked validating keys. 
         | 
      Package monitor defines a runtime service which receives notifications triggered by events related to performance of tracked validating keys. | 
| 
         
          
            node
            
            
          
           
      Package node is the main service which launches a beacon node and manages the lifecycle of all its associated services at runtime, such as p2p, RPC, sync, gracefully closing them if the process ends. 
         | 
      Package node is the main service which launches a beacon node and manages the lifecycle of all its associated services at runtime, such as p2p, RPC, sync, gracefully closing them if the process ends. | 
| 
         
          
            operations/attestations
            
            
          
           
      Package attestations defines an attestation pool service implementation which is used to manage the lifecycle of aggregated, unaggregated, and fork-choice attestations. 
         | 
      Package attestations defines an attestation pool service implementation which is used to manage the lifecycle of aggregated, unaggregated, and fork-choice attestations. | 
| 
         
          
            operations/attestations/kv
            
            
          
           
      Package kv includes a key-value store implementation of an attestation cache used to satisfy important use-cases such as aggregation in a beacon node runtime. 
         | 
      Package kv includes a key-value store implementation of an attestation cache used to satisfy important use-cases such as aggregation in a beacon node runtime. | 
| 
         
          
            operations/attestations/mock
            
            
          
           
      lint:nopanic -- Mock / test code, panic is allowed. 
         | 
      lint:nopanic -- Mock / test code, panic is allowed. | 
| 
         
          
            operations/blstoexec
            
            
          
           
      Package blstoexecchanges defines an in-memory pool of received BLS-to-ETH1 change objects. 
         | 
      Package blstoexecchanges defines an in-memory pool of received BLS-to-ETH1 change objects. | 
| 
         
          
            operations/slashings
            
            
          
           
      Package slashings defines an in-memory pool of received slashing events by the beacon node, handling their lifecycle and performing integrity checks before serving them as objects for validators to include in blocks. 
         | 
      Package slashings defines an in-memory pool of received slashing events by the beacon node, handling their lifecycle and performing integrity checks before serving them as objects for validators to include in blocks. | 
| 
         
          
            operations/voluntaryexits
            
            
          
           
      Package voluntaryexits defines an in-memory pool of received voluntary exit events by the beacon node, handling their lifecycle and performing integrity checks before serving them as objects for validators to include in blocks. 
         | 
      Package voluntaryexits defines an in-memory pool of received voluntary exit events by the beacon node, handling their lifecycle and performing integrity checks before serving them as objects for validators to include in blocks. | 
| 
         
          
            p2p
            
            
          
           
      Package p2p implements the Ethereum consensus networking specification. 
         | 
      Package p2p implements the Ethereum consensus networking specification. | 
| 
         
          
            p2p/encoder
            
            
          
           
      Package encoder allows for registering custom data encoders for information sent as raw bytes over the wire via p2p to other nodes. 
         | 
      Package encoder allows for registering custom data encoders for information sent as raw bytes over the wire via p2p to other nodes. | 
| 
         
          
            p2p/peers
            
            
          
           
      Package peers provides information about peers at the Ethereum consensus protocol level. 
         | 
      Package peers provides information about peers at the Ethereum consensus protocol level. | 
| 
         
          
            p2p/testing
            
            
          
           
      Package testing includes useful utilities for mocking a beacon node's p2p service for unit tests. 
         | 
      Package testing includes useful utilities for mocking a beacon node's p2p service for unit tests. | 
| 
         
          
            p2p/types
            
            
          
           
      Package types contains all the respective p2p types that are required for sync but cannot be represented as a protobuf schema. 
         | 
      Package types contains all the respective p2p types that are required for sync but cannot be represented as a protobuf schema. | 
| 
         
          
            rpc
            
            
          
           
      Package rpc defines a gRPC server implementing the Ethereum consensus API as needed by validator clients and consumers of chain data. 
         | 
      Package rpc defines a gRPC server implementing the Ethereum consensus API as needed by validator clients and consumers of chain data. | 
| 
         
          
            rpc/eth/beacon
            
            
          
           
      Package beacon defines a gRPC beacon service implementation, following the official API standards https://ethereum.github.io/beacon-apis/#/. 
         | 
      Package beacon defines a gRPC beacon service implementation, following the official API standards https://ethereum.github.io/beacon-apis/#/. | 
| 
         
          
            rpc/eth/debug
            
            
          
           
      Package debug defines a gRPC beacon service implementation, following the official API standards https://ethereum.github.io/beacon-apis/#/. 
         | 
      Package debug defines a gRPC beacon service implementation, following the official API standards https://ethereum.github.io/beacon-apis/#/. | 
| 
         
          
            rpc/eth/events
            
            
          
           
      Package events defines a gRPC events service implementation, following the official API standards https://ethereum.github.io/beacon-apis/#/. 
         | 
      Package events defines a gRPC events service implementation, following the official API standards https://ethereum.github.io/beacon-apis/#/. | 
| 
         
          
            rpc/eth/node
            
            
          
           
      Package node defines a gRPC node service implementation, providing useful endpoints for checking a node's sync status, peer info, genesis data, and version information. 
         | 
      Package node defines a gRPC node service implementation, providing useful endpoints for checking a node's sync status, peer info, genesis data, and version information. | 
| 
         
          
            rpc/prysm/v1alpha1/beacon
            
            
          
           
      Package beacon defines a gRPC beacon service implementation, providing useful endpoints for checking fetching chain-specific data such as blocks, committees, validators, assignments, and more. 
         | 
      Package beacon defines a gRPC beacon service implementation, providing useful endpoints for checking fetching chain-specific data such as blocks, committees, validators, assignments, and more. | 
| 
         
          
            rpc/prysm/v1alpha1/debug
            
            
          
           
      Package debug defines a gRPC server implementation of a debugging service which allows for helpful endpoints to debug a beacon node at runtime, this server is gated behind the feature flag --enable-debug-rpc-endpoints. 
         | 
      Package debug defines a gRPC server implementation of a debugging service which allows for helpful endpoints to debug a beacon node at runtime, this server is gated behind the feature flag --enable-debug-rpc-endpoints. | 
| 
         
          
            rpc/prysm/v1alpha1/node
            
            
          
           
      Package node defines a gRPC node service implementation, providing useful endpoints for checking a node's sync status, peer info, genesis data, and version information. 
         | 
      Package node defines a gRPC node service implementation, providing useful endpoints for checking a node's sync status, peer info, genesis data, and version information. | 
| 
         
          
            rpc/prysm/v1alpha1/validator
            
            
          
           
      Package validator defines a gRPC validator service implementation, providing critical endpoints for validator clients to submit blocks/attestations to the beacon node, receive assignments, and more. 
         | 
      Package validator defines a gRPC validator service implementation, providing critical endpoints for validator clients to submit blocks/attestations to the beacon node, receive assignments, and more. | 
| 
         
          
            slasher
            
            
          
           
      Package slasher implements slashing detection for eth2, able to catch slashable attestations and proposals that it receives via two event feeds, respectively. 
         | 
      Package slasher implements slashing detection for eth2, able to catch slashable attestations and proposals that it receives via two event feeds, respectively. | 
| 
         
          
            state
            
            
          
           
      Package state defines the actual beacon state interface used by a Prysm beacon node, also containing useful, scoped interfaces such as a ReadOnlyState and WriteOnlyBeaconState. 
         | 
      Package state defines the actual beacon state interface used by a Prysm beacon node, also containing useful, scoped interfaces such as a ReadOnlyState and WriteOnlyBeaconState. | 
| 
         
          
            state/state-native
            
            
          
           
      Package state_native defines how the beacon chain state for Ethereum functions in the running beacon node, using an advanced, immutable implementation of the state data structure. 
         | 
      Package state_native defines how the beacon chain state for Ethereum functions in the running beacon node, using an advanced, immutable implementation of the state data structure. | 
| 
         
          
            state/stategen
            
            
          
           
      Package stategen defines functions to regenerate beacon chain states by replaying blocks from a stored state checkpoint, useful for optimization and reducing a beacon node's resource consumption. 
         | 
      Package stategen defines functions to regenerate beacon chain states by replaying blocks from a stored state checkpoint, useful for optimization and reducing a beacon node's resource consumption. | 
| 
         
          
            state/stategen/mock
            
            
          
           
      lint:nopanic -- Mock code, OK to panic. 
         | 
      lint:nopanic -- Mock code, OK to panic. | 
| 
         
          
            sync
            
            
          
           
      Package sync TODO(3147): Add details on how sync works. 
         | 
      Package sync TODO(3147): Add details on how sync works. | 
| 
         
          
            sync/initial-sync
            
            
          
           
      Package initialsync includes all initial block download and processing logic for the beacon node, using a round robin strategy and a finite-state-machine to handle edge-cases in a beacon node's sync status. 
         | 
      Package initialsync includes all initial block download and processing logic for the beacon node, using a round robin strategy and a finite-state-machine to handle edge-cases in a beacon node's sync status. | 
| 
         
          
            sync/initial-sync/testing
            
            
          
           
      Package testing includes useful mocks for testing initial sync status in unit tests. 
         | 
      Package testing includes useful mocks for testing initial sync status in unit tests. | 
| 
       build
        | 
      |
| 
       cache
        | 
      |
| 
       Package cmd defines the command line flags for the shared utilities. 
         | 
      Package cmd defines the command line flags for the shared utilities. | 
| 
         
          
            beacon-chain
            
            command
          
           
      Package beacon-chain defines the entire runtime of an Ethereum beacon node. 
         | 
      Package beacon-chain defines the entire runtime of an Ethereum beacon node. | 
| 
         
          
            beacon-chain/flags
            
            
          
           
      Package flags defines beacon-node specific runtime flags for setting important values such as ports, eth1 endpoints, and more. 
         | 
      Package flags defines beacon-node specific runtime flags for setting important values such as ports, eth1 endpoints, and more. | 
| 
         
          
            client-stats
            
            command
          
           
      This code was adapted from https://github.com/ethereum/go-ethereum/blob/master/cmd/geth/usage.go 
         | 
      This code was adapted from https://github.com/ethereum/go-ethereum/blob/master/cmd/geth/usage.go | 
| 
         
          
            client-stats/flags
            
            
          
           
      Package flags contains all configuration runtime flags for the client-stats daemon. 
         | 
      Package flags contains all configuration runtime flags for the client-stats daemon. | 
| 
         
          
            mock
            
            
          
           
      Package mock_cmd is a generated GoMock package. 
         | 
      Package mock_cmd is a generated GoMock package. | 
| 
         
          
            prysmctl
            
            command
          
          
         
       | 
      |
| 
         
          
            validator
            
            command
          
           
      Package main defines a validator client, a critical actor in Ethereum which manages a keystore of private keys, connects to a beacon node to receive assignments, and submits blocks/attestations as needed. 
         | 
      Package main defines a validator client, a critical actor in Ethereum which manages a keystore of private keys, connects to a beacon node to receive assignments, and submits blocks/attestations as needed. | 
| 
         
          
            validator/flags
            
            
          
           
      Package flags contains all configuration runtime flags for the validator service. 
         | 
      Package flags contains all configuration runtime flags for the validator service. | 
| 
         
          
            features
            
            
          
           
      Package features defines which features are enabled for runtime in order to selectively enable certain features to maintain a stable runtime. 
         | 
      Package features defines which features are enabled for runtime in order to selectively enable certain features to maintain a stable runtime. | 
| 
         
          
            params
            
            
          
           
      Package params defines important constants that are essential to Prysm services. 
         | 
      Package params defines important constants that are essential to Prysm services. | 
| 
         
          
            mock
            
            
          
           
      package mock lint:nopanic -- This is test / mock code, allowed to panic. 
         | 
      package mock lint:nopanic -- This is test / mock code, allowed to panic. | 
| 
       container
        | 
      |
| 
         
          
            leaky-bucket
            
            
          
           
      Package leakybucket implements a scalable leaky bucket algorithm. 
         | 
      Package leakybucket implements a scalable leaky bucket algorithm. | 
| 
         
          
            multi-value-slice
            
            
          
           
      Package mvslice defines a multi value slice container. 
         | 
      Package mvslice defines a multi value slice container. | 
| 
         
          
            queue
            
            
          
           
      Package queue provides Vault plugins with a Priority Queue. 
         | 
      Package queue provides Vault plugins with a Priority Queue. | 
| 
         
          
            slice
            
            
          
           
      Package slice implements set operations for specified data type 
         | 
      Package slice implements set operations for specified data type | 
| 
         
          
            thread-safe
            
            
          
           
      Package threadsafe contains generic containers that are protected either by Mutexes or atomics underneath the hood. 
         | 
      Package threadsafe contains generic containers that are protected either by Mutexes or atomics underneath the hood. | 
| 
         
          
            trie
            
            
          
           
      Package trie defines utilities for sparse merkle tries for Ethereum consensus. 
         | 
      Package trie defines utilities for sparse merkle tries for Ethereum consensus. | 
| 
       contracts
        | 
      |
| 
         
          
            deposit
            
            
          
           
      Code generated - DO NOT EDIT. 
         | 
      Code generated - DO NOT EDIT. | 
| 
       crypto
        | 
      |
| 
         
          
            bls
            
            
          
           
      Package bls implements a go-wrapper around a library implementing the BLS12-381 curve and signature scheme. 
         | 
      Package bls implements a go-wrapper around a library implementing the BLS12-381 curve and signature scheme. | 
| 
         
          
            bls/blst
            
            
          
           
      Package blst implements a go-wrapper around a library implementing the BLS12-381 curve and signature scheme. 
         | 
      Package blst implements a go-wrapper around a library implementing the BLS12-381 curve and signature scheme. | 
| 
         
          
            bls/common
            
            
          
           
      Package common provides the BLS interfaces that are implemented by the various BLS wrappers. 
         | 
      Package common provides the BLS interfaces that are implemented by the various BLS wrappers. | 
| 
         
          
            bls/common/mock
            
            
          
           
      Package mock is a generated GoMock package. 
         | 
      Package mock is a generated GoMock package. | 
| 
         
          
            hash
            
            
          
           
      Package hashutil includes all hash-function related helpers for Prysm. 
         | 
      Package hashutil includes all hash-function related helpers for Prysm. | 
| 
         
          
            rand
            
            
          
           
      Package rand defines methods of obtaining random number generators. 
         | 
      Package rand defines methods of obtaining random number generators. | 
| 
       encoding
        | 
      |
| 
         
          
            bytesutil
            
            
          
           
      Package bytesutil defines helper methods for converting integers to byte slices. 
         | 
      Package bytesutil defines helper methods for converting integers to byte slices. | 
| 
         
          
            ssz
            
            
          
           
      Package ssz defines HashTreeRoot utility functions. 
         | 
      Package ssz defines HashTreeRoot utility functions. | 
| 
       io
        | 
      |
| 
         
          
            logs
            
            
          
           
      Package logs creates a Multi writer instance that write all logs that are written to stdout. 
         | 
      Package logs creates a Multi writer instance that write all logs that are written to stdout. | 
| 
       Package math includes important helpers for Ethereum such as fast integer square roots. 
         | 
      Package math includes important helpers for Ethereum such as fast integer square roots. | 
| 
       monitoring
        | 
      |
| 
         
          
            journald
            
            
          
           
      Package journald was copied directly from https://github.com/wercker/journalhook, where this library was previously hosted. 
         | 
      Package journald was copied directly from https://github.com/wercker/journalhook, where this library was previously hosted. | 
| 
         
          
            prometheus
            
            
          
           
      Package prometheus defines a service which is used for metrics collection and health of a node in Prysm. 
         | 
      Package prometheus defines a service which is used for metrics collection and health of a node in Prysm. | 
| 
         
          
            tracing
            
            
          
           
      Package tracing includes useful functions for opentracing annotations. 
         | 
      Package tracing includes useful functions for opentracing annotations. | 
| 
       Package network contains useful functions for ip address formatting. 
         | 
      Package network contains useful functions for ip address formatting. | 
| 
         
          
            forks
            
            
          
           
      Package forks contains useful helpers for Ethereum consensus fork-related functionality. 
         | 
      Package forks contains useful helpers for Ethereum consensus fork-related functionality. | 
| 
       proto
        | 
      |
| 
         
          
            engine/v1
            
            
          
           
      Code generated by fastssz. 
         | 
      Code generated by fastssz. | 
| 
         
          
            eth/v1
            
            
          
           
      Code generated by fastssz. 
         | 
      Code generated by fastssz. | 
| 
         
          
            prysm/v1alpha1
            
            
          
           
      Code generated by fastssz. 
         | 
      Code generated by fastssz. | 
| 
         
          
            prysm/v1alpha1/attestation
            
            
          
           
      Package attestationutil contains useful helpers for converting attestations into indexed form. 
         | 
      Package attestationutil contains useful helpers for converting attestations into indexed form. | 
| 
         
          
            prysm/v1alpha1/attestation/aggregation
            
            
          
           
      Package aggregation contains implementations of bitlist aggregation algorithms and heuristics. 
         | 
      Package aggregation contains implementations of bitlist aggregation algorithms and heuristics. | 
| 
       Package runtime includes useful utilities globally accessible in the Prysm monorepo. 
         | 
      Package runtime includes useful utilities globally accessible in the Prysm monorepo. | 
| 
         
          
            debug
            
            
          
           
      Package debug defines useful profiling utils that came originally with go-ethereum. 
         | 
      Package debug defines useful profiling utils that came originally with go-ethereum. | 
| 
         
          
            interop
            
            
          
           
      Package interop contains deterministic utilities for generating genesis states and keys. 
         | 
      Package interop contains deterministic utilities for generating genesis states and keys. | 
| 
         
          
            maxprocs
            
            
          
           
      Package maxprocs automatically sets GOMAXPROCS to match the Linux container CPU quota, if any. 
         | 
      Package maxprocs automatically sets GOMAXPROCS to match the Linux container CPU quota, if any. | 
| 
         
          
            messagehandler
            
            
          
           
      Package messagehandler contains useful helpers for recovering from panic conditions at runtime and logging their trace. 
         | 
      Package messagehandler contains useful helpers for recovering from panic conditions at runtime and logging their trace. | 
| 
         
          
            version
            
            
          
           
      Package version executes and returns the version string for the currently running process. 
         | 
      Package version executes and returns the version string for the currently running process. | 
| 
       testing
        | 
      |
| 
         
          
            benchmark
            
            
          
           
      Package benchmark contains useful helpers for pregenerating filled data structures such as blocks/states for benchmarks. 
         | 
      Package benchmark contains useful helpers for pregenerating filled data structures such as blocks/states for benchmarks. | 
| 
         
          
            endtoend/components
            
            
          
           
      Package components defines utilities to spin up actual beacon node and validator processes as needed by end to end tests. 
         | 
      Package components defines utilities to spin up actual beacon node and validator processes as needed by end to end tests. | 
| 
         
          
            endtoend/evaluators
            
            
          
           
      Package evaluators defines functions which can peer into end to end tests to determine if a chain is running as required. 
         | 
      Package evaluators defines functions which can peer into end to end tests to determine if a chain is running as required. | 
| 
         
          
            endtoend/helpers
            
            
          
           
      Package helpers defines helper functions to peer into end to end processes and kill processes as needed. 
         | 
      Package helpers defines helper functions to peer into end to end processes and kill processes as needed. | 
| 
         
          
            endtoend/params
            
            
          
           
      Package params defines all custom parameter configurations for running end to end tests. 
         | 
      Package params defines all custom parameter configurations for running end to end tests. | 
| 
         
          
            endtoend/types
            
            
          
           
      Package types includes important structs used by end to end tests, such as a configuration type, an evaluator type, and more. 
         | 
      Package types includes important structs used by end to end tests, such as a configuration type, an evaluator type, and more. | 
| 
         
          
            middleware/engine-api-proxy
            
            
          
           
      Package proxy provides a proxy middleware for engine API requests between Ethereum consensus clients and execution clients accordingly. 
         | 
      Package proxy provides a proxy middleware for engine API requests between Ethereum consensus clients and execution clients accordingly. | 
| 
         
          
            mock
            
            
          
           
      Package mock is a generated GoMock package. 
         | 
      Package mock is a generated GoMock package. | 
| 
         
          
            slasher/simulator
            
            
          
           
      lint:nopanic -- Test tooling / code. 
         | 
      lint:nopanic -- Test tooling / code. | 
| 
         
          
            spectest/general/phase0/bls
            
            
          
           
      Package bls includes tests to ensure conformity with the Ethereum BLS cryptography specification. 
         | 
      Package bls includes tests to ensure conformity with the Ethereum BLS cryptography specification. | 
| 
         
          
            spectest/shared/phase0/shuffling/core/shuffle
            
            
          
           
      Package shuffle contains all conformity specification tests for validator shuffling logic according to the Ethereum Beacon Node spec. 
         | 
      Package shuffle contains all conformity specification tests for validator shuffling logic according to the Ethereum Beacon Node spec. | 
| 
         
          
            spectest/utils
            
            
          
           
      Package utils allows for easy switching of chain configuration parameters in spec conformity unit tests. 
         | 
      Package utils allows for easy switching of chain configuration parameters in spec conformity unit tests. | 
| 
         
          
            validator-mock
            
            
          
           
      Package validator_mock is a generated GoMock package. 
         | 
      Package validator_mock is a generated GoMock package. | 
| 
       third_party
        | 
      |
| 
         
          
            hid
            
            
          
           
      Package hid provide interfaces for generic USB devices. 
         | 
      Package hid provide interfaces for generic USB devices. | 
| 
       Package time is a wrapper around the go standard time library. 
         | 
      Package time is a wrapper around the go standard time library. | 
| 
         
          
            mclock
            
            
          
           
      Package mclockutil is a wrapper for a monotonic clock source. 
         | 
      Package mclockutil is a wrapper for a monotonic clock source. | 
| 
         
          
            slots
            
            
          
           
      Package slots includes ticker and timer-related functions for Ethereum consensus. 
         | 
      Package slots includes ticker and timer-related functions for Ethereum consensus. | 
| 
         
          
            slots/testing
            
            
          
           
      Package testing includes useful mocks for slot tickers in unit tests. 
         | 
      Package testing includes useful mocks for slot tickers in unit tests. | 
| 
       tools
        | 
      |
| 
         
          
            analyzers/comparesame
            
            
          
           
      Package comparesame implements a static analyzer to ensure that code does not contain comparisons of identical expressions. 
         | 
      Package comparesame implements a static analyzer to ensure that code does not contain comparisons of identical expressions. | 
| 
         
          
            analyzers/cryptorand
            
            
          
           
      Package cryptorand implements a static analyzer to ensure that the crypto/rand package is used for randomness throughout the codebase. 
         | 
      Package cryptorand implements a static analyzer to ensure that the crypto/rand package is used for randomness throughout the codebase. | 
| 
         
          
            analyzers/errcheck
            
            
          
           
      Package errcheck implements an static analysis analyzer to ensure that errors are handled in go code. 
         | 
      Package errcheck implements an static analysis analyzer to ensure that errors are handled in go code. | 
| 
         
          
            analyzers/featureconfig
            
            
          
           
      Package featureconfig implements a static analyzer to prevent leaking globals in tests. 
         | 
      Package featureconfig implements a static analyzer to prevent leaking globals in tests. | 
| 
         
          
            analyzers/ineffassign
            
            
          
           
      Package ineffassign implements a static analyzer to ensure that there are no ineffectual assignments in source code. 
         | 
      Package ineffassign implements a static analyzer to ensure that there are no ineffectual assignments in source code. | 
| 
         
          
            analyzers/interfacechecker
            
            
          
           
      Package interfacechecker implements a static analyzer to prevent incorrect conditional checks on select interfaces. 
         | 
      Package interfacechecker implements a static analyzer to prevent incorrect conditional checks on select interfaces. | 
| 
         
          
            analyzers/logruswitherror
            
            
          
           
      Package logruswitherror implements a static analyzer to ensure that log statements do not use errors in templated log statements. 
         | 
      Package logruswitherror implements a static analyzer to ensure that log statements do not use errors in templated log statements. | 
| 
         
          
            analyzers/maligned
            
            
          
           
      Package maligned implements a static analyzer to ensure that Go structs take up the least possible memory. 
         | 
      Package maligned implements a static analyzer to ensure that Go structs take up the least possible memory. | 
| 
         
          
            analyzers/nop
            
            
          
           
      Package nop implements a static analyzer to ensure that code does not contain no-op instructions. 
         | 
      Package nop implements a static analyzer to ensure that code does not contain no-op instructions. | 
| 
         
          
            analyzers/properpermissions
            
            
          
           
      Package properpermissions implements a static analyzer to ensure that Prysm does not use ioutil.MkdirAll or os.WriteFile as they are unsafe when it comes to guaranteeing file permissions and not overriding existing permissions. 
         | 
      Package properpermissions implements a static analyzer to ensure that Prysm does not use ioutil.MkdirAll or os.WriteFile as they are unsafe when it comes to guaranteeing file permissions and not overriding existing permissions. | 
| 
         
          
            analyzers/shadowpredecl
            
            
          
           
      Package shadowpredecl implements a static analyzer which disallows declaring constructs that shadow predeclared Go identifiers by having the same name. 
         | 
      Package shadowpredecl implements a static analyzer which disallows declaring constructs that shadow predeclared Go identifiers by having the same name. | 
| 
         
          
            analyzers/slicedirect
            
            
          
           
      Package slicedirect implements a static analyzer to ensure that code does not contain applications of [:] on expressions which are already slices. 
         | 
      Package slicedirect implements a static analyzer to ensure that code does not contain applications of [:] on expressions which are already slices. | 
| 
         
          
            beacon-fuzz
            
            command
          
          
         
       | 
      |
| 
         
          
            benchmark-files-gen
            
            command
          
          
         
       | 
      |
| 
         
          
            blocktree
            
            command
          
           
      * 
         | 
      * | 
| 
         
          
            bootnode
            
            command
          
           
      * 
         | 
      * | 
| 
         
          
            enr-calculator
            
            command
          
           
      This binary is a simple rest API endpoint to calculate the ENR value of a node given its private key,ip address and port. 
         | 
      This binary is a simple rest API endpoint to calculate the ENR value of a node given its private key,ip address and port. | 
| 
         
          
            eth1exporter
            
            command
          
           
      Prometheus exporter for Ethereum address balances. 
         | 
      Prometheus exporter for Ethereum address balances. | 
| 
         
          
            eth1voting
            
            command
          
          
         
       | 
      |
| 
         
          
            exploredb
            
            command
          
          
         
       | 
      |
| 
         
          
            extractor
            
            command
          
          
         
       | 
      |
| 
         
          
            forkchecker
            
            command
          
           
      * 
         | 
      * | 
| 
         
          
            gocovmerge
            
            command
          
           
      gocovmerge takes the results from multiple `go test -coverprofile` runs and merges them into one profile 
         | 
      gocovmerge takes the results from multiple `go test -coverprofile` runs and merges them into one profile | 
| 
         
          
            http-request-sink
            
            command
          
           
      Package main implements a simple, http-request-sink which writes incoming http request bodies to an append-only text file at a specified directory. 
         | 
      Package main implements a simple, http-request-sink which writes incoming http request bodies to an append-only text file at a specified directory. | 
| 
         
          
            interop/convert-keys
            
            command
          
           
      Used for converting keys.yaml files from eth2.0-pm for interop testing. 
         | 
      Used for converting keys.yaml files from eth2.0-pm for interop testing. | 
| 
         
          
            interop/export-genesis
            
            command
          
          
         
       | 
      |
| 
         
          
            interop/split-keys
            
            command
          
           
      Package main provides a tool named split-keys which allows for generating any number of Ethereum validator keys from a list of BIP39 mnemonics and spreading them across any number of Prysm wallets. 
         | 
      Package main provides a tool named split-keys which allows for generating any number of Ethereum validator keys from a list of BIP39 mnemonics and spreading them across any number of Prysm wallets. | 
| 
         
          
            keystores
            
            command
          
           
      This tool allows for simple encrypting and decrypting of EIP-2335 compliant, BLS12-381 keystore.json files which as password protected. 
         | 
      This tool allows for simple encrypting and decrypting of EIP-2335 compliant, BLS12-381 keystore.json files which as password protected. | 
| 
         
          
            nogo_config
            
            command
          
          
         
       | 
      |
| 
         
          
            pcli
            
            command
          
          
         
       | 
      |
| 
         
          
            replay-http
            
            command
          
           
      * Tool for replaying http requests from a file of base64 encoded, line-delimited Go http raw requests. 
         | 
      * Tool for replaying http requests from a file of base64 encoded, line-delimited Go http raw requests. | 
| 
         
          
            specs-checker
            
            command
          
          
         
       | 
      |
| 
         
          
            unencrypted-keys-gen
            
            command
          
          
         
       | 
      |
| 
       validator
        | 
      |
| 
         
          
            accounts
            
            
          
           
      Package accounts defines a new model for accounts management in Prysm, using best practices for user security, UX, and extensibility via different wallet types including HD wallets, imported (non-HD) wallets, and remote-signing capable configurations. 
         | 
      Package accounts defines a new model for accounts management in Prysm, using best practices for user security, UX, and extensibility via different wallet types including HD wallets, imported (non-HD) wallets, and remote-signing capable configurations. | 
| 
         
          
            accounts/testing
            
            
          
           
      package mock 
         | 
      package mock | 
| 
         
          
            client
            
            
          
           
      Package client represents a gRPC polling-based implementation of an Ethereum validator client. 
         | 
      Package client represents a gRPC polling-based implementation of an Ethereum validator client. | 
| 
         
          
            client/beacon-api/mock
            
            
          
           
      Package mock is a generated GoMock package. 
         | 
      Package mock is a generated GoMock package. | 
| 
         
          
            db/iface
            
            
          
           
      Package iface defines an interface for the validator database. 
         | 
      Package iface defines an interface for the validator database. | 
| 
         
          
            db/kv
            
            
          
           
      Package kv defines a persistent backend for the validator service. 
         | 
      Package kv defines a persistent backend for the validator service. | 
| 
         
          
            keymanager/local
            
            
          
           
      Package local defines an implementation of an on-disk, EIP-2335 keystore.json approach towards defining validator accounts in Prysm. 
         | 
      Package local defines an implementation of an on-disk, EIP-2335 keystore.json approach towards defining validator accounts in Prysm. | 
| 
         
          
            keymanager/remote-web3signer/types
            
            
          
           
      Package v1 defines mappings of types as defined by the web3signer official specification for its v1 version i.e. 
         | 
      Package v1 defines mappings of types as defined by the web3signer official specification for its v1 version i.e. | 
| 
         
          
            node
            
            
          
           
      Package node is the main process which handles the lifecycle of the runtime services in a validator client process, gracefully shutting everything down upon close. 
         | 
      Package node is the main process which handles the lifecycle of the runtime services in a validator client process, gracefully shutting everything down upon close. | 
| 
         
          
            slashing-protection-history
            
            
          
           
      Package history defines methods to parse, import, and export slashing protection data from a standard JSON file according to EIP-3076 https://eips.ethereum.org/EIPS/eip-3076. 
         | 
      Package history defines methods to parse, import, and export slashing protection data from a standard JSON file according to EIP-3076 https://eips.ethereum.org/EIPS/eip-3076. | 
| 
         
          
            web
            
            
          
           
      Package web is the service to serve the Prysm web UI. 
         | 
      Package web is the service to serve the Prysm web UI. | 
 Click to show internal directories. 
   Click to hide internal directories. 
