api

Nov 27, 2023

Changes in this version

type Backend

+ GetPastRoundRoots func(ctx context.Context, request *RuntimeRequest) (map[uint64]RoundRoots, error)

+ GetRoundRoots func(ctx context.Context, request *RoundRootsRequest) (*RoundRoots, error)

+ type RoundRootsRequest struct

+ Height int64

+ Round uint64

+ RuntimeID common.Namespace

Nov 9, 2023

Changes in this version

type ExecutionDiscrepancyDetectedEvent

+ Round uint64

Oct 10, 2023

Changes in this version

+ const TimeoutNever

+ var ErrNoCommittee = errors.New(ModuleName, 6, "roothash: no committee")

type Backend

+ WatchExecutorCommitments func(ctx context.Context) (<-chan *commitment.ExecutorCommitment, pubsub.ClosableSubscription, error)

type ConsensusParameterChanges

+ MaxPastRootsStored *uint64

type ConsensusParameters

+ MaxPastRootsStored uint64

type ExecutionDiscrepancyDetectedEvent

+ Rank uint64

type LivenessStatistics

+ FinalizedProposals []uint64

+ MissedProposals []uint64

+ type RoundRoots struct

+ IORoot hash.Hash

+ StateRoot hash.Hash

type RuntimeState

+ CommitmentPool *commitment.Pool

+ Committee *scheduler.Committee

+ LastBlock *block.Block

+ LastBlockHeight int64

+ NextTimeout int64

Oct 14, 2022

Changes in this version

type BlockHistory

+ GetCommittedBlock func(ctx context.Context, round uint64) (*block.Block, error)

+ LastStorageSyncedRound func() (uint64, error)

+ StorageSyncCheckpoint func(ctx context.Context, round uint64) error

+ WaitRoundSynced func(ctx context.Context, round uint64) (uint64, error)

+ WatchBlocks func() (<-chan *AnnotatedBlock, pubsub.ClosableSubscription, error)

+ type ConsensusParameterChanges struct

+ GasCosts transaction.Costs

+ MaxEvidenceAge *uint64

+ MaxInRuntimeMessages *uint32

+ MaxRuntimeMessages *uint32

+ func (c *ConsensusParameterChanges) Apply(params *ConsensusParameters) error

+ func (c *ConsensusParameterChanges) SanityCheck() error

type ConsensusParameters

+ func (p *ConsensusParameters) SanityCheck() error

Mar 1, 2022

Changes in this version

+ const GasOpSubmitMsg

+ var ErrIncomingMessageInsufficientFee = errors.New(ModuleName, 12, "roothash: insufficient fee")

+ var ErrIncomingMessageQueueFull = errors.New(ModuleName, 11, "roothash: incoming message queue full")

+ var ErrMaxInMessagesTooBig = errors.New(ModuleName, 13, "roothash: max incoming runtime messages is too big")

+ var MethodSubmitMsg = transaction.NewMethodName(ModuleName, "SubmitMsg", SubmitMsg{})

+ func NewSubmitMsgTx(nonce uint64, fee *transaction.Fee, msg *SubmitMsg) *transaction.Transaction

type Backend

+ GetIncomingMessageQueue func(ctx context.Context, request *InMessageQueueRequest) ([]*message.IncomingMessage, error)

+ GetIncomingMessageQueueMeta func(ctx context.Context, request *RuntimeRequest) (*message.IncomingMessageQueueMeta, error)

+ GetLastRoundResults func(ctx context.Context, request *RuntimeRequest) (*RoundResults, error)

type ConsensusParameters

+ MaxInRuntimeMessages uint32

+ type EquivocationProposalEvidence struct

+ ProposalA commitment.Proposal

+ ProposalB commitment.Proposal

+ func (ev *EquivocationProposalEvidence) ValidateBasic(id common.Namespace) error

type Event

+ InMsgProcessed *InMsgProcessedEvent

type Evidence

+ EquivocationProposal *EquivocationProposalEvidence

type ExecutionDiscrepancyDetectedEvent

+ func (e *ExecutionDiscrepancyDetectedEvent) EventKind() string

type ExecutorCommittedEvent

+ func (e *ExecutorCommittedEvent) EventKind() string

type FinalizedEvent

+ func (e *FinalizedEvent) EventKind() string

+ type InMessageQueueRequest struct

+ Height int64

+ Limit uint32

+ Offset uint64

+ RuntimeID common.Namespace

+ type InMsgProcessedEvent struct

+ Caller staking.Address

+ ID uint64

+ Round uint64

+ Tag uint64

+ func (e *InMsgProcessedEvent) EventKind() string

+ type LivenessStatistics struct

+ LiveRounds []uint64

+ TotalRounds uint64

+ func NewLivenessStatistics(numNodes int) *LivenessStatistics

type MessageEvent

+ Result cbor.RawMessage

+ type RuntimeIDAttribute struct

+ ID common.Namespace

+ func (e *RuntimeIDAttribute) DecodeValue(value string) error

+ func (e *RuntimeIDAttribute) EventKind() string

+ func (e *RuntimeIDAttribute) EventValue() string

type RuntimeState

+ LivenessStatistics *LivenessStatistics

+ type SubmitMsg struct

+ Data []byte

+ Fee quantity.Quantity

+ ID common.Namespace

+ Tag uint64

+ Tokens quantity.Quantity

Oct 20, 2021

Changes in this version

type BlockHistory

+ GetEarliestBlock func(ctx context.Context) (*block.Block, error)

Sep 27, 2021

Changes in this version

+ const RoundLatest

type BlockHistory

+ GetAnnotatedBlock func(ctx context.Context, round uint64) (*AnnotatedBlock, error)

Aug 9, 2021

Changes in this version

type Backend

+ ConsensusParameters func(ctx context.Context, height int64) (*ConsensusParameters, error)

Jun 7, 2021

Changes in this version

+ func RegisterService(server *grpc.Server, service Backend)

type Backend

+ func NewRootHashClient(c *grpc.ClientConn) Backend

+ type RuntimeRequest struct

+ Height int64

+ RuntimeID common.Namespace

Mar 18, 2021

Changes in this version

+ const EvidenceKindEquivocation

+ const GasOpEvidence

+ const RoundInvalid

+ var ErrDuplicateEvidence = errors.New(ModuleName, 9, "roothash: duplicate evidence")

+ var ErrInvalidEvidence = errors.New(ModuleName, 10, "roothash: invalid evidence")

+ var ErrMaxMessagesTooBig = errors.New(ModuleName, 7, "roothash: max runtime messages is too big")

+ var ErrRuntimeDoesNotSlash = errors.New(ModuleName, 8, "roothash: runtime does not slash")

+ var MethodEvidence = transaction.NewMethodName(ModuleName, "Evidence", Evidence{})

+ func NewEvidenceTx(nonce uint64, fee *transaction.Fee, evidence *Evidence) *transaction.Transaction

+ func VerifyRuntimeParameters(logger *logging.Logger, rt *registry.Runtime, params *ConsensusParameters) error

type Backend

+ GetRuntimeState func(ctx context.Context, runtimeID common.Namespace, height int64) (*RuntimeState, error)

type BlockHistory

+ GetRoundResults func(ctx context.Context, round uint64) (*RoundResults, error)

type ConsensusParameters

+ MaxEvidenceAge uint64

+ MaxRuntimeMessages uint32

+ type EquivocationBatchEvidence struct

+ BatchA commitment.SignedProposedBatch

+ BatchB commitment.SignedProposedBatch

+ func (ev *EquivocationBatchEvidence) ValidateBasic(id common.Namespace) error

+ type EquivocationExecutorEvidence struct

+ CommitA commitment.ExecutorCommitment

+ CommitB commitment.ExecutorCommitment

+ func (ev *EquivocationExecutorEvidence) ValidateBasic(id common.Namespace) error

type Event

+ Finalized *FinalizedEvent

+ Message *MessageEvent

+ type Evidence struct

+ EquivocationBatch *EquivocationBatchEvidence

+ EquivocationExecutor *EquivocationExecutorEvidence

+ ID common.Namespace

+ func (ev *Evidence) Hash() (hash.Hash, error)

+ func (ev *Evidence) ValidateBasic() error

+ type EvidenceKind uint8

type FinalizedEvent

+ BadComputeNodes []signature.PublicKey

+ GoodComputeNodes []signature.PublicKey

+ type GenesisRuntimeState struct

+ MessageResults []*MessageEvent

+ type MessageEvent struct

+ Code uint32

+ Index uint32

+ Module string

+ func (me *MessageEvent) IsSuccess() bool

+ type RoundResults struct

+ BadComputeEntities []signature.PublicKey

+ GoodComputeEntities []signature.PublicKey

+ Messages []*MessageEvent

+ type RuntimeState struct

+ CurrentBlock *block.Block

+ CurrentBlockHeight int64

+ ExecutorPool *commitment.Pool

+ GenesisBlock *block.Block

+ LastNormalHeight int64

+ LastNormalRound uint64

+ Runtime *registry.Runtime

+ Suspended bool

Sep 9, 2020

Changes in this version

+ const GasOpProposerTimeout

+ var ErrNoExecutorPool = errors.New(ModuleName, 4, "roothash: no executor pool")

+ var ErrProposerTimeoutNotAllowed = errors.New(ModuleName, 6, "roothash: proposer timeout not allowed")

+ var MethodExecutorProposerTimeout = transaction.NewMethodName(ModuleName, "ExecutorProposerTimeout", ExecutorProposerTimeoutRequest{})

+ func NewRequestProposerTimeoutTx(nonce uint64, fee *transaction.Fee, runtimeID common.Namespace, round uint64) *transaction.Transaction

+ type ExecutorProposerTimeoutRequest struct

+ ID common.Namespace

+ Round uint64

Aug 5, 2020

Changes in this version

+ const GasOpComputeCommit

+ const GasOpMergeCommit

+ const LogEventExecutionDiscrepancyDetected

+ const LogEventHistoryReindexing

+ const LogEventMergeDiscrepancyDetected

+ const LogEventMessageUnsat

+ const LogEventRoundFailed

+ const LogEventTimerFired

+ const ModuleName

+ var DefaultGasCosts = transaction.Costs

+ var ErrInvalidArgument = errors.New(ModuleName, 1, "roothash: invalid argument")

+ var ErrInvalidRuntime = errors.New(ModuleName, 3, "roothash: invalid runtime")

+ var ErrNoRound = errors.New(ModuleName, 4, "roothash: no round is in progress")

+ var ErrNotFound = errors.New(ModuleName, 2, "roothash: block not found")

+ var ErrRuntimeSuspended = errors.New(ModuleName, 5, "roothash: runtime is suspended")

+ var MethodExecutorCommit = transaction.NewMethodName(ModuleName, "ExecutorCommit", ExecutorCommit{})

+ var MethodMergeCommit = transaction.NewMethodName(ModuleName, "MergeCommit", MergeCommit{})

+ var Methods = []transaction.MethodName

+ func NewExecutorCommitTx(nonce uint64, fee *transaction.Fee, runtimeID common.Namespace, ...) *transaction.Transaction

+ func NewMergeCommitTx(nonce uint64, fee *transaction.Fee, runtimeID common.Namespace, ...) *transaction.Transaction

+ func SanityCheckBlocks(blocks map[common.Namespace]*block.Block) error

+ type AnnotatedBlock struct

+ Block *block.Block

+ Height int64

+ type Backend interface

+ Cleanup func()

+ GetEvents func(ctx context.Context, height int64) ([]*Event, error)

+ GetGenesisBlock func(ctx context.Context, runtimeID common.Namespace, height int64) (*block.Block, error)

+ GetLatestBlock func(ctx context.Context, runtimeID common.Namespace, height int64) (*block.Block, error)

+ StateToGenesis func(ctx context.Context, height int64) (*Genesis, error)

+ TrackRuntime func(ctx context.Context, history BlockHistory) error

+ WatchBlocks func(runtimeID common.Namespace) (<-chan *AnnotatedBlock, *pubsub.Subscription, error)

+ WatchEvents func(runtimeID common.Namespace) (<-chan *Event, *pubsub.Subscription, error)

+ type BlockHistory interface

+ Commit func(blk *AnnotatedBlock) error

+ ConsensusCheckpoint func(height int64) error

+ GetBlock func(ctx context.Context, round uint64) (*block.Block, error)

+ GetLatestBlock func(ctx context.Context) (*block.Block, error)

+ LastConsensusHeight func() (int64, error)

+ RuntimeID func() common.Namespace

+ type ConsensusParameters struct

+ DebugBypassStake bool

+ DebugDoNotSuspendRuntimes bool

+ GasCosts transaction.Costs

+ type Event struct

+ ExecutionDiscrepancyDetected *ExecutionDiscrepancyDetectedEvent

+ ExecutorCommitted *ExecutorCommittedEvent

+ FinalizedEvent *FinalizedEvent

+ Height int64

+ MergeCommitted *MergeCommittedEvent

+ MergeDiscrepancyDetected *MergeDiscrepancyDetectedEvent

+ RuntimeID common.Namespace

+ TxHash hash.Hash

+ type ExecutionDiscrepancyDetectedEvent struct

+ CommitteeID hash.Hash

+ Timeout bool

+ type ExecutorCommit struct

+ Commits []commitment.ExecutorCommitment

+ ID common.Namespace

+ type ExecutorCommittedEvent struct

+ Commit commitment.ExecutorCommitment

+ type FinalizedEvent struct

+ Round uint64

+ type Genesis struct

+ Parameters ConsensusParameters

+ RuntimeStates map[common.Namespace]*api.RuntimeGenesis

+ func (g *Genesis) SanityCheck() error

+ type MergeCommit struct

+ Commits []commitment.MergeCommitment

+ ID common.Namespace

+ type MergeCommittedEvent struct

+ Commit commitment.MergeCommitment

+ type MergeDiscrepancyDetectedEvent struct

+ type MetricsMonitorable interface

+ WatchAllBlocks func() (<-chan *block.Block, *pubsub.Subscription)