manifest

type ChainExchangeConfig struct {
	SubscriptionBufferSize         int
	MaxChainLength                 int
	MaxInstanceLookahead           uint64
	MaxDiscoveredChainsPerInstance int
	MaxWantedChainsPerInstance     int
	RebroadcastInterval            time.Duration
	MaxTimestampAge                time.Duration
}

type CxConfig struct {
	// Request timeout for the certificate exchange client.
	ClientRequestTimeout time.Duration
	// Request timeout for the certificate exchange server.
	ServerRequestTimeout time.Duration
	// Minimum CX polling interval.
	MinimumPollInterval time.Duration
	// Maximum CX polling interval.
	MaximumPollInterval time.Duration
}

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

type DynamicManifestProviderOption func(cfg *dynamicManifestProviderConfig) error

type EcConfig struct {
	// The delay between tipsets.
	Period time.Duration
	// Number of epochs required to reach EC defined finality
	Finality int64
	// The multiplier on top of the Period of the time we will wait before starting a new instance,
	// referencing the timestamp of the latest finalized tipset.
	DelayMultiplier float64
	// Table of incremental multipliers to backoff in units of Delay in case of base decisions
	BaseDecisionBackoffTable []float64
	// HeadLookback number of unfinalized tipsets to remove from the head
	HeadLookback int
	// Finalize indicates whether F3 should finalize tipsets as F3 agrees on them.
	Finalize bool
}

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

type GpbftConfig struct {
	Delta                  time.Duration
	DeltaBackOffExponent   float64
	QualityDeltaMultiplier float64
	MaxLookaheadRounds     uint64

	ChainProposedLength int

	RebroadcastBackoffBase     time.Duration
	RebroadcastBackoffExponent float64
	RebroadcastBackoffSpread   float64
	RebroadcastBackoffMax      time.Duration
}

type HeadGetter interface {
	GetHead(context.Context) (ec.TipSet, error)
}

type Manifest struct {
	// Pause stops the participation in F3.
	Pause bool
	// ProtocolVersion specifies protocol version to be used
	ProtocolVersion uint64
	// Initial instance to used for the f3 instance
	InitialInstance uint64
	// BootstrapEpoch from which the manifest should be applied
	BootstrapEpoch int64
	// Network name to apply for this manifest.
	NetworkName gpbft.NetworkName
	// Updates to perform over the power table from EC (by replacement). Any entries with 0
	// power will disable the participant.
	ExplicitPower gpbft.PowerEntries
	// Ignore the power table from EC.
	IgnoreECPower bool
	// InitialPowerTable specifies the optional CID of the initial power table
	InitialPowerTable cid.Cid // !Defined() if nil
	// We take the current power table from the head tipset this many instances ago.
	CommitteeLookback uint64
	// The alignment of instances while catching up. This should be slightly larger than the
	// expected time to complete an instance.
	//
	// A good default is `4 * Manifest.Gpbft.Delta` (the expected time for a single-round
	// instance).
	CatchUpAlignment time.Duration
	// Config parameters for gpbft
	Gpbft GpbftConfig
	// EC-specific parameters
	EC EcConfig
	// Certificate Exchange specific parameters
	CertificateExchange CxConfig
	// PubSubConfig specifies the pubsub related configuration.
	PubSub PubSubConfig
	// ChainExchange specifies the chain exchange configuration parameters.
	ChainExchange ChainExchangeConfig
}

type ManifestProvider interface {
	// Start any background tasks required for the operation of the manifest provider.
	Start(context.Context) error
	// Stop stops a running manifest provider.
	Stop(context.Context) error
	// The channel on which manifest updates are returned.
	ManifestUpdates() <-chan *Manifest
}

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

type ManifestUpdateMessage struct {
	// An increasing sequence number for ordering manifest updates received over the network.
	MessageSequence uint64
	// The manifest to apply or nil to pause the network.
	Manifest Manifest
}

type NoopManifestProvider struct{}

type PubSubConfig struct {
	CompressionEnabled bool
}

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