Documentation
¶
Index ¶
- Constants
- type BasicErrHealthStatus
- type BatchMsg
- type BlockStream
- type EnclaveService
- type GroupErrsHealthStatus
- type HealthCheck
- type HealthStatus
- type Host
- type Identity
- type L1BlockHandler
- type L1BlockRepository
- type L1Publisher
- type L1RepoService
- type L2BatchHandler
- type L2BatchRepository
- type LogSubscriptionManager
- type P2P
- type P2PBatchHandler
- type P2PBatchRequestHandler
- type P2PHostService
- type P2PTxHandler
- type Service
Constants ¶
const ( P2PName = "p2p" L1BlockRepositoryName = "l1-block-repo" L1PublisherName = "l1-publisher" L2BatchRepositoryName = "l2-batch-repo" EnclaveServiceName = "enclaves" LogSubscriptionServiceName = "log-subs" FilterAPIServiceName = "filter-api" CrossChainServiceName = "cross-chain" )
service names - these are the keys used to register known services with the host
Variables ¶
This section is empty.
Functions ¶
This section is empty.
Types ¶
type BasicErrHealthStatus ¶
type BasicErrHealthStatus struct {
ErrMsg string
}
BasicErrHealthStatus is a simple health status implementation, if the ErrMsg is non-empty then OK() returns false
func (*BasicErrHealthStatus) Message ¶
func (l *BasicErrHealthStatus) Message() string
func (*BasicErrHealthStatus) OK ¶
func (l *BasicErrHealthStatus) OK() bool
type BlockStream ¶
type EnclaveService ¶
type EnclaveService interface { // LookupBatchBySeqNo is used to fetch batch data from the enclave - it is only used as a fallback for the sequencer // host if it's missing a batch (other host services should use L2Repo to fetch batch data) LookupBatchBySeqNo(ctx context.Context, seqNo *big.Int) (*common.ExtBatch, error) // GetEnclaveClient returns an enclave client // todo (@matt) we probably don't want to expose this GetEnclaveClient() common.Enclave // SubmitAndBroadcastTx submits an encrypted transaction to the enclave, and broadcasts it to other hosts on the network (in particular, to the sequencer) SubmitAndBroadcastTx(ctx context.Context, encryptedParams common.EncryptedParamsSendRawTx) (*responses.RawTx, error) Subscribe(id rpc.ID, encryptedLogSubscription common.EncryptedParamsLogSubscription) error Unsubscribe(id rpc.ID) error }
EnclaveService provides access to the host enclave(s), it monitors and manages the states of the enclaves, so it can help with failover, gate-keeping (throttling/load-balancing) and circuit-breaking when the enclave is not available
type GroupErrsHealthStatus ¶ added in v0.24.0
type GroupErrsHealthStatus struct {
Errors []error
}
func (*GroupErrsHealthStatus) Message ¶ added in v0.24.0
func (g *GroupErrsHealthStatus) Message() string
func (*GroupErrsHealthStatus) OK ¶ added in v0.24.0
func (g *GroupErrsHealthStatus) OK() bool
type HealthCheck ¶
HealthCheck is the object returned by the host API with the Health of the Node
type HealthStatus ¶
HealthStatus is an interface supported by all Services on the host
type Host ¶
type Host interface { Config() *config.HostConfig EnclaveClient() common.Enclave Storage() storage.Storage // Start initializes the main loop of the host. Start() error // SubmitAndBroadcastTx submits an encrypted transaction to the enclave, and broadcasts it to the other hosts on the network. SubmitAndBroadcastTx(ctx context.Context, encryptedParams common.EncryptedParamsSendRawTx) (*responses.RawTx, error) // SubscribeLogs feeds logs matching the encrypted log subscription to the matchedLogs channel. SubscribeLogs(id rpc.ID, encryptedLogSubscription common.EncryptedParamsLogSubscription, matchedLogs chan []byte) error // UnsubscribeLogs terminates a log subscription between the host and the enclave. UnsubscribeLogs(id rpc.ID) // Stop gracefully stops the host execution. Stop() error // HealthCheck returns the health status of the host + enclave + db HealthCheck(context.Context) (*HealthCheck, error) // ObscuroConfig returns the info of the Obscuro network ObscuroConfig() (*common.ObscuroNetworkInfo, error) // NewHeadsChan returns live batch headers // Note - do not use directly. This is meant only for the NewHeadsManager, which multiplexes the headers NewHeadsChan() chan *common.BatchHeader }
Host is the half of the Obscuro node that lives outside the enclave.
type Identity ¶
type Identity struct { ID gethcommon.Address P2PPublicAddress string IsGenesis bool IsSequencer bool }
func NewIdentity ¶
func NewIdentity(cfg *config.HostConfig) Identity
type L1BlockHandler ¶
type L1BlockHandler interface { // HandleBlock will be called in a new goroutine for each new block as it arrives HandleBlock(block *types.Block) }
L1BlockHandler is an interface for receiving new blocks from the repository as they arrive
type L1BlockRepository ¶
type L1BlockRepository interface { // Subscribe will register a block handler to receive new blocks as they arrive, returns unsubscribe func Subscribe(handler L1BlockHandler) func() FetchBlockByHeight(height *big.Int) (*types.Block, error) // FetchNextBlock returns the next canonical block after a given block hash // It returns the new block, a bool which is true if the block is the current L1 head and a bool if the block is on a different fork to prevBlock FetchNextBlock(prevBlock gethcommon.Hash) (*types.Block, bool, error) // FetchObscuroReceipts returns the receipts for a given L1 block FetchObscuroReceipts(block *common.L1Block) (types.Receipts, error) }
L1BlockRepository provides an interface for the host to request L1 block data (live-streaming and historical)
type L1Publisher ¶
type L1Publisher interface { // InitializeSecret will send a management contract transaction to initialize the network with the generated secret InitializeSecret(attestation *common.AttestationReport, encSecret common.EncryptedSharedEnclaveSecret) error // RequestSecret will send a management contract transaction to request a secret from the enclave, returning the L1 head at time of sending RequestSecret(report *common.AttestationReport) (gethcommon.Hash, error) // ExtractObscuroRelevantTransactions will return all Obscuro relevant tx from an L1 block ExtractObscuroRelevantTransactions(block *types.Block) ([]*ethadapter.L1RespondSecretTx, []*ethadapter.L1RollupTx, []*ethadapter.L1SetImportantContractsTx) // PublishRollup will create and publish a rollup tx to the management contract - fire and forget we don't wait for receipt // todo (#1624) - With a single sequencer, it is problematic if rollup publication fails; handle this case better PublishRollup(producedRollup *common.ExtRollup) // PublishSecretResponse will create and publish a secret response tx to the management contract - fire and forget we don't wait for receipt PublishSecretResponse(secretResponse *common.ProducedSecretResponse) error // PublishCrossChainBundle will create and publish a cross-chain bundle tx to the management contract PublishCrossChainBundle(*common.ExtCrossChainBundle, *big.Int, gethcommon.Hash) error FetchLatestSeqNo() (*big.Int, error) // GetImportantContracts returns a (cached) record of addresses of the important network contracts GetImportantContracts() map[string]gethcommon.Address // ResyncImportantContracts will fetch the latest important contracts from the management contract, update the cache ResyncImportantContracts() error // GetBundleRangeFromManagementContract returns the range of batches for which to build a bundle GetBundleRangeFromManagementContract(lastRollupNumber *big.Int, lastRollupUID gethcommon.Hash) (*gethcommon.Hash, *big.Int, *big.Int, error) }
L1Publisher provides an interface for the host to interact with Obscuro data (management contract etc.) on L1
type L1RepoService ¶
type L1RepoService interface { Service L1BlockRepository }
type L2BatchHandler ¶
type L2BatchHandler interface { // HandleBatch will be called in a new goroutine for each new batch as it arrives HandleBatch(batch *common.ExtBatch) }
L2BatchHandler is an interface for receiving new batches from the publisher as they arrive
type L2BatchRepository ¶
type L2BatchRepository interface { // SubscribeNewBatches will register a handler to receive new batches from the publisher as they arrive at the host SubscribeNewBatches(handler L2BatchHandler) func() // SubscribeValidatedBatches will register a handler to receive batches that have been validated by the enclave SubscribeValidatedBatches(handler L2BatchHandler) func() FetchBatchBySeqNo(background context.Context, seqNo *big.Int) (*common.ExtBatch, error) // AddBatch is used to notify the repository of a new batch, e.g. from the enclave when seq produces one or a rollup is consumed // Note: it is fine to add batches that the repo already has, it will just ignore them AddBatch(batch *common.ExtBatch) error // NotifyNewValidatedHead - called after an enclave validates a batch, to update the repo's validated head and notify subscribers NotifyNewValidatedHead(batch *common.ExtBatch) }
L2BatchRepository provides an interface for the host to request L2 batch data (live-streaming and historical)
type LogSubscriptionManager ¶
type LogSubscriptionManager interface { Subscribe(id rpc.ID, encryptedLogSubscription common.EncryptedParamsLogSubscription, matchedLogsCh chan []byte) error Unsubscribe(id rpc.ID) SendLogsToSubscribers(result *common.EncryptedSubscriptionLogs) }
LogSubscriptionManager provides an interface for the host to manage log subscriptions
type P2P ¶
type P2P interface { // BroadcastBatches sends live batch(es) to every other node on the network BroadcastBatches(batches []*common.ExtBatch) error // SendTxToSequencer sends the encrypted transaction to the sequencer. SendTxToSequencer(tx common.EncryptedTx) error // RequestBatchesFromSequencer asynchronously requests batches from the sequencer, from the given sequence number RequestBatchesFromSequencer(fromSeqNo *big.Int) error // RespondToBatchRequest sends the requested batches to the requesting peer RespondToBatchRequest(requestID string, batches []*common.ExtBatch) error // SubscribeForBatches will register a handler to receive new batches from peers, returns unsubscribe func SubscribeForBatches(handler P2PBatchHandler) func() // SubscribeForTx will register a handler to receive new transactions from peers, returns unsubscribe func SubscribeForTx(handler P2PTxHandler) func() // SubscribeForBatchRequests will register a handler to receive new batch requests from peers, returns unsubscribe func // todo (@matt) feels a bit weird to have this in this interface since it relates to serving data rather than receiving SubscribeForBatchRequests(handler P2PBatchRequestHandler) func() }
P2P provides an interface for the host to interact with the P2P network
type P2PBatchHandler ¶
type P2PBatchHandler interface { // HandleBatches will be called in a new goroutine for batches that arrive HandleBatches(batch []*common.ExtBatch, isLive bool) }
P2PBatchHandler is an interface for receiving new batches from the P2P network as they arrive
type P2PBatchRequestHandler ¶
type P2PHostService ¶
type P2PTxHandler ¶
type P2PTxHandler interface { // HandleTransaction will be called in a new goroutine for each new tx as it arrives HandleTransaction(tx common.EncryptedTx) }
P2PTxHandler is an interface for receiving new transactions from the P2P network as they arrive
type Service ¶
type Service interface { Start() error Stop() error HealthStatus(context.Context) HealthStatus }
Service interface allows the host to manage all services in a generic way Note: Services may depend on other services but they shouldn't use them during construction, only when 'Start()' is called. They should be resilient to services availability, because the construction ordering is not guaranteed.