settlement

Documentation

Index

• Constants
• Variables
• func QueryForEvent(eventType string) tmpubsub.Query
• type BaseLayerClient
  • func (b *BaseLayerClient) GetProposer() *types.Sequencer
  • func (b *BaseLayerClient) GetSequencersList() []*types.Sequencer
  • func (b *BaseLayerClient) Init(config Config, pubsub *pubsub.Server, logger log.Logger, options ...Option) error
  • func (b *BaseLayerClient) RetrieveBatch(stateIndex ...uint64) (*ResultRetrieveBatch, error)
  • func (b *BaseLayerClient) Start() error
  • func (b *BaseLayerClient) Stop() error
  • func (b *BaseLayerClient) SubmitBatch(batch *types.Batch, daClient da.Client, daResult *da.ResultSubmitBatch)
• type BaseResult
• type Batch
• type BatchMetaData
• type Config
  • func (c Config) Validate() error
• type DAMetaData
  • func (d *DAMetaData) FromPath(path string) (*DAMetaData, error)
  • func (d *DAMetaData) ToPath() string
• type EventDataNewBatchAccepted
• type EventDataNewSettlementBatchAccepted
• type EventDataSequencersListUpdated
• type EventDataSettlementHealthStatus
• type HubClient
• type LayerI
• type Option
  • func WithHubClient(hubClient HubClient) Option
• type ResultRetrieveBatch
• type StatusCode

Constants

const (
	// This event should be emitted internally in order to communicate between the settlement layer and the hub client
	EventNewSettlementBatchAccepted = "EventNewSettlementBatchAccepted"
	// This event should be emitted externally when a batch is accepted
	EventNewBatchAccepted       = "EventNewBatchAccepted"
	EventSequencersListUpdated  = "SequencersListUpdated"
	EventSettlementHealthStatus = "SettlementHealthStatus"
)

Define the event types

const (
	// EventTypeKey is a reserved composite key for event name.
	EventTypeKey = "settlement.event"
)

Define the event type keys

Variables

var (
	// ErrBatchNotFound is returned when a batch is not found for the rollapp.
	ErrBatchNotFound = errors.New("batch not found")
	// ErrNoSequencerForRollapp is returned when a sequencer is not found for the rollapp.
	ErrNoSequencerForRollapp = errors.New("no sequencer registered on the hub for this rollapp")
	// ErrBatchNotAccepted is returned when a batch is not accepted by the settlement layer.
	ErrBatchNotAccepted = errors.New("batch not accepted")
)

var (
	EventQueryNewSettlementBatchAccepted = QueryForEvent(EventNewSettlementBatchAccepted)
	EventQueryNewBatchAccepted           = QueryForEvent(EventNewBatchAccepted)
	EventQuerySettlementHealthStatus     = QueryForEvent(EventSettlementHealthStatus)
)

Define queries

Functions

func QueryForEvent

func QueryForEvent(eventType string) tmpubsub.Query

QueryForEvent returns a query for the given event.

Types

type BaseLayerClient

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

BaseLayerClient is intended only for usage in tests.

func (*BaseLayerClient) GetProposer

func (b *BaseLayerClient) GetProposer() *types.Sequencer

GetProposer returns the sequencer which is currently the proposer

func (*BaseLayerClient) GetSequencersList

func (b *BaseLayerClient) GetSequencersList() []*types.Sequencer

GetSequencersList returns the current list of sequencers from the settlement layer

func (*BaseLayerClient) Init

func (b *BaseLayerClient) Init(config Config, pubsub *pubsub.Server, logger log.Logger, options ...Option) error

Init is called once. it initializes the struct members.

func (*BaseLayerClient) RetrieveBatch

func (b *BaseLayerClient) RetrieveBatch(stateIndex ...uint64) (*ResultRetrieveBatch, error)

RetrieveBatch Gets the batch which contains the given slHeight. Empty slHeight returns the latest batch.

func (*BaseLayerClient) Start

func (b *BaseLayerClient) Start() error

Start is called once, after init. It initializes the query client.

func (*BaseLayerClient) Stop

func (b *BaseLayerClient) Stop() error

Stop is called once, after Start.

func (*BaseLayerClient) SubmitBatch

func (b *BaseLayerClient) SubmitBatch(batch *types.Batch, daClient da.Client, daResult *da.ResultSubmitBatch)

SubmitBatch tries submitting the batch in an async broadcast mode to the settlement layer. Events are emitted on success or failure.

type BaseResult

type BaseResult struct {
	// Code is to determine if the action succeeded.
	Code StatusCode
	// Message may contain settlement layer specific information (like detailed error message, etc)
	Message string
	//TODO(omritoptix): Move StateIndex to be part of the batch struct
	// StateIndex is the rollapp-specific index the batch was saved in the SL
	StateIndex uint64
}

BaseResult contains basic information returned by the settlement layer.

type Batch

type Batch struct {
	StartHeight uint64
	EndHeight   uint64
	AppHashes   [][32]byte
	// MetaData about the batch in the DA layer
	MetaData *BatchMetaData
}

Batch defines a batch structure for the settlement layer

type BatchMetaData

type BatchMetaData struct {
	DA *DAMetaData
}

BatchMetaData aggregates all the batch metadata.

type Config

type Config struct {
	KeyringBackend string `mapstructure:"keyring_backend"`
	NodeAddress    string `mapstructure:"node_address"`
	KeyringHomeDir string `mapstructure:"keyring_home_dir"`
	DymAccountName string `mapstructure:"dym_account_name"`
	RollappID      string `mapstructure:"rollapp_id"`
	GasLimit       uint64 `mapstructure:"gas_limit"`
	GasPrices      string `mapstructure:"gas_prices"`
	GasFees        string `mapstructure:"gas_fees"`

	//For testing only. probably should be refactored
	ProposerPubKey string `json:"proposer_pub_key"`
}

Config for the DymensionLayerClient

func (Config) Validate

func (c Config) Validate() error

type DAMetaData

type DAMetaData struct {
	// Height is the height of the block in the da layer
	Height uint64
	// Client is the client to use to fetch data from the da layer
	Client da.Client
}

DAMetaData contains meta data about a batch on the Data Availability Layer.

func (*DAMetaData) FromPath

func (d *DAMetaData) FromPath(path string) (*DAMetaData, error)

FromPath parses a path to a DAMetaData.

func (*DAMetaData) ToPath

func (d *DAMetaData) ToPath() string

ToPath converts a DAMetaData to a path.

type EventDataNewBatchAccepted

type EventDataNewBatchAccepted struct {
	// EndHeight is the height of the last accepted batch
	EndHeight uint64
	// StateIndex is the rollapp-specific index the batch was saved in the SL
	StateIndex uint64
}

EventDataNewBatchAccepted defines the structure of the event data for the EventNewBatchAccepted

type EventDataNewSettlementBatchAccepted

type EventDataNewSettlementBatchAccepted EventDataNewBatchAccepted

EventDataNewSettlementBatchAccepted defines the structure of the event data for the EventNewSettlementBatchAccepted

type EventDataSequencersListUpdated

type EventDataSequencersListUpdated struct {
	// Sequencers is the list of sequencers
	Sequencers []types.Sequencer
}

EventDataSequencersListUpdated defines the structure of the event data for the EventSequencersListUpdated

type EventDataSettlementHealthStatus

type EventDataSettlementHealthStatus struct {
	// Healthy is true if the settlement layer is healthy
	Healthy bool
	// Error is the error that was encountered in case of a health check failure
	Error error
}

EventDataSettlementHealthStatus defines the structure of the event data for the EventDataSettlementHealthStatus

type HubClient

type HubClient interface {
	Start() error
	Stop() error
	PostBatch(batch *types.Batch, daClient da.Client, daResult *da.ResultSubmitBatch)
	GetLatestBatch(rollappID string) (*ResultRetrieveBatch, error)
	GetBatchAtIndex(rollappID string, index uint64) (*ResultRetrieveBatch, error)
	GetSequencers(rollappID string) ([]*types.Sequencer, error)
}

HubClient is an helper interface for a more granualr interaction with the hub. Implementing a new settlement layer client basically requires embedding the base client and implementing the helper interfaces.

type LayerI

type LayerI interface {

	// Init is called once for the client initialization
	Init(config Config, pubsub *pubsub.Server, logger log.Logger, options ...Option) error

	// Start is called once, after Init. It's implementation should start the client service.
	Start() error

	// Stop is called once, after Start. It should stop the client service.
	Stop() error

	// SubmitBatch tries submiting the batch in an async way to the settlement layer. This should create a transaction which (potentially)
	// triggers a state transition in the settlement layer. Events are emitted on success or failure.
	SubmitBatch(batch *types.Batch, daClient da.Client, daResult *da.ResultSubmitBatch)

	// RetrieveBatch Gets the batch which contains the given height. Empty height returns the latest batch.
	RetrieveBatch(stateIndex ...uint64) (*ResultRetrieveBatch, error)

	// GetSequencersList returns the list of the sequencers for this chain.
	GetSequencersList() []*types.Sequencer

	// GetProposer returns the current proposer for this chain.
	GetProposer() *types.Sequencer
}

LayerI defines generic interface for Settlement layer interaction.

type Option

type Option func(LayerI)

Option is a function that sets a parameter on the settlement layer.

func WithHubClient

func WithHubClient(hubClient HubClient) Option

WithHubClient is an option which sets the hub client.

type ResultRetrieveBatch

type ResultRetrieveBatch struct {
	BaseResult
	*Batch
}

ResultRetrieveBatch contains information returned from settlement layer after batch retrieva

type StatusCode

type StatusCode uint64

StatusCode is a type for settlement layer return status.

const (
	StatusUnknown StatusCode = iota
	StatusSuccess
	StatusTimeout
	StatusError
)

settlement layer return codes.