node

package
v0.10.11 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 24, 2023 License: MIT Imports: 31 Imported by: 10

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var (
	// UnsafeBlockSignerAddressSystemConfigStorageSlot is the storage slot identifier of the unsafeBlockSigner
	// `address` storage value in the SystemConfig L1 contract. Computed as `keccak256("systemconfig.unsafeblocksigner")`
	UnsafeBlockSignerAddressSystemConfigStorageSlot = common.HexToHash("0x65a7ed542fb37fe237fdfbdd70b31598523fe5b32879e307bae27a0bd9581c08")
)

Functions

func NewAdminAPI 

func NewAdminAPI(dr driverClient, m rpcMetrics) *adminAPI

func NewNodeAPI 

func NewNodeAPI(config *rollup.Config, l2Client l2EthClient, dr driverClient, log log.Logger, m rpcMetrics) *nodeAPI

Types

type Config 

type Config struct {
	L1 L1EndpointSetup
	L2 L2EndpointSetup

	Driver driver.Config

	Rollup rollup.Config

	// P2PSigner will be used for signing off on published content
	// if the node is sequencing and if the p2p stack is enabled
	P2PSigner p2p.SignerSetup

	RPC RPCConfig

	P2P p2p.SetupP2P

	Metrics MetricsConfig

	Pprof oppprof.CLIConfig

	// Used to poll the L1 for new finalized or safe blocks
	L1EpochPollInterval time.Duration

	// Optional
	Tracer    Tracer
	Heartbeat HeartbeatConfig
}

func (*Config) Check 

func (cfg *Config) Check() error

Check verifies that the given configuration makes sense

type HeartbeatConfig 

type HeartbeatConfig struct {
	Enabled bool
	Moniker string
	URL     string
}

type L1EndpointConfig 

type L1EndpointConfig struct {
	L1NodeAddr string // Address of L1 User JSON-RPC endpoint to use (eth namespace required)

	// L1TrustRPC: if we trust the L1 RPC we do not have to validate L1 response contents like headers
	// against block hashes, or cached transaction sender addresses.
	// Thus we can sync faster at the risk of the source RPC being wrong.
	L1TrustRPC bool

	// L1RPCKind identifies the RPC provider kind that serves the RPC,
	// to inform the optimal usage of the RPC for transaction receipts fetching.
	L1RPCKind sources.RPCProviderKind
}

func (*L1EndpointConfig) Setup 

func (cfg *L1EndpointConfig) Setup(ctx context.Context, log log.Logger) (cl client.RPC, trust bool, kind sources.RPCProviderKind, err error)

type L1EndpointSetup 

type L1EndpointSetup interface {
	// Setup a RPC client to a L1 node to pull rollup input-data from.
	// The results of the RPC client may be trusted for faster processing, or strictly validated.
	// The kind of the RPC may be non-basic, to optimize RPC usage.
	Setup(ctx context.Context, log log.Logger) (cl client.RPC, trust bool, kind sources.RPCProviderKind, err error)
}

type L2EndpointConfig 

type L2EndpointConfig struct {
	L2EngineAddr string // Address of L2 Engine JSON-RPC endpoint to use (engine and eth namespace required)

	// JWT secrets for L2 Engine API authentication during HTTP or initial Websocket communication.
	// Any value for an IPC connection.
	L2EngineJWTSecret [32]byte
}

func (*L2EndpointConfig) Check 

func (cfg *L2EndpointConfig) Check() error

func (*L2EndpointConfig) Setup 

func (cfg *L2EndpointConfig) Setup(ctx context.Context, log log.Logger) (client.RPC, error)

type L2EndpointSetup 

type L2EndpointSetup interface {
	// Setup a RPC client to a L2 execution engine to process rollup blocks with.
	Setup(ctx context.Context, log log.Logger) (cl client.RPC, err error)
	Check() error
}

type LogConfig 

type LogConfig struct {
	Level  string // Log level: trace, debug, info, warn, error, crit. Capitals are accepted too.
	Color  bool   // Color the log output. Defaults to true if terminal is detected.
	Format string // Format the log output. Supported formats: 'text', 'json'
}

func DefaultLogConfig 

func DefaultLogConfig() LogConfig

func (*LogConfig) Check 

func (cfg *LogConfig) Check() error

Check verifes that the LogConfig is valid. Calls to `NewLogger` may fail if this returns an error.

func (*LogConfig) NewLogger 

func (cfg *LogConfig) NewLogger() log.Logger

NewLogger creates a logger based on the supplied configuration

type MetricsConfig 

type MetricsConfig struct {
	Enabled    bool
	ListenAddr string
	ListenPort int
}

func (MetricsConfig) Check 

func (m MetricsConfig) Check() error

type OpNode 

type OpNode struct {
	// contains filtered or unexported fields
}

func New 

func New(ctx context.Context, cfg *Config, log log.Logger, snapshotLog log.Logger, appVersion string, m *metrics.Metrics) (*OpNode, error)

func (*OpNode) Close 

func (n *OpNode) Close() error

Close closes all resources.

func (*OpNode) HTTPEndpoint 

func (n *OpNode) HTTPEndpoint() string

func (*OpNode) ListenAddr 

func (n *OpNode) ListenAddr() string

func (*OpNode) OnNewL1Finalized 

func (n *OpNode) OnNewL1Finalized(ctx context.Context, sig eth.L1BlockRef)

func (*OpNode) OnNewL1Head 

func (n *OpNode) OnNewL1Head(ctx context.Context, sig eth.L1BlockRef)

func (*OpNode) OnNewL1Safe 

func (n *OpNode) OnNewL1Safe(ctx context.Context, sig eth.L1BlockRef)

func (*OpNode) OnUnsafeL2Payload 

func (n *OpNode) OnUnsafeL2Payload(ctx context.Context, from peer.ID, payload *eth.ExecutionPayload) error

func (*OpNode) P2P 

func (n *OpNode) P2P() p2p.Node

func (*OpNode) PublishL2Payload 

func (n *OpNode) PublishL2Payload(ctx context.Context, payload *eth.ExecutionPayload) error

func (*OpNode) Start 

func (n *OpNode) Start(ctx context.Context) error

type PreparedL1Endpoint 

type PreparedL1Endpoint struct {
	Client          client.RPC
	TrustRPC        bool
	RPCProviderKind sources.RPCProviderKind
}

PreparedL1Endpoint enables testing with an in-process pre-setup RPC connection to L1

func (*PreparedL1Endpoint) Setup 

func (p *PreparedL1Endpoint) Setup(ctx context.Context, log log.Logger) (cl client.RPC, trust bool, kind sources.RPCProviderKind, err error)

type PreparedL2Endpoints 

type PreparedL2Endpoints struct {
	Client client.RPC
}

PreparedL2Endpoints enables testing with in-process pre-setup RPC connections to L2 engines

func (*PreparedL2Endpoints) Check 

func (p *PreparedL2Endpoints) Check() error

func (*PreparedL2Endpoints) Setup 

func (p *PreparedL2Endpoints) Setup(ctx context.Context, log log.Logger) (client.RPC, error)

type RPCConfig 

type RPCConfig struct {
	ListenAddr  string
	ListenPort  int
	EnableAdmin bool
}

func (*RPCConfig) HttpEndpoint 

func (cfg *RPCConfig) HttpEndpoint() string

type RuntimeCfgL1Source added in v0.10.5 

type RuntimeCfgL1Source interface {
	ReadStorageAt(ctx context.Context, address common.Address, storageSlot common.Hash, blockHash common.Hash) (common.Hash, error)
}

type RuntimeConfig added in v0.10.5 

type RuntimeConfig struct {
	// contains filtered or unexported fields
}

RuntimeConfig maintains runtime-configurable options. These options are loaded based on initial loading + updates for every subsequent L1 block. Only the *latest* values are maintained however, the runtime config has no concept of chain history, does not require any archive data, and may be out of sync with the rollup derivation process.

func NewRuntimeConfig added in v0.10.5 

func NewRuntimeConfig(log log.Logger, l1Client RuntimeCfgL1Source, rollupCfg *rollup.Config) *RuntimeConfig

func (*RuntimeConfig) Load added in v0.10.5 

func (r *RuntimeConfig) Load(ctx context.Context, l1Ref eth.L1BlockRef) error

Load resets the runtime configuration by fetching the latest config data from L1 at the given L1 block. Load is safe to call concurrently, but will lock the runtime configuration modifications only, and will thus not block other Load calls with possibly alternative L1 block views.

func (*RuntimeConfig) P2PSequencerAddress added in v0.10.5 

func (r *RuntimeConfig) P2PSequencerAddress() common.Address

type Tracer 

type Tracer interface {
	OnNewL1Head(ctx context.Context, sig eth.L1BlockRef)
	OnUnsafeL2Payload(ctx context.Context, from peer.ID, payload *eth.ExecutionPayload)
	OnPublishL2Payload(ctx context.Context, payload *eth.ExecutionPayload)
}

Tracer configures the OpNode to share events

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.