watchtower

Documentation

Index

• Constants
• type CancelBondReductions
  • func NewCancelBondReductions(ctx context.Context, sp *services.ServiceProvider, logger *log.Logger, ...) *CancelBondReductions
  • func (t *CancelBondReductions) Run(state *state.NetworkState) error
• type CheckSoloMigrations
  • func NewCheckSoloMigrations(ctx context.Context, sp *services.ServiceProvider, logger *log.Logger, ...) *CheckSoloMigrations
  • func (t *CheckSoloMigrations) Run(state *state.NetworkState) error
• type DissolveTimedOutMinipools
  • func NewDissolveTimedOutMinipools(sp *services.ServiceProvider, logger *log.Logger) *DissolveTimedOutMinipools
  • func (t *DissolveTimedOutMinipools) Run(state *state.NetworkState) error
• type FinalizePdaoProposals
  • func NewFinalizePdaoProposals(sp *services.ServiceProvider, logger *log.Logger) *FinalizePdaoProposals
  • func (t *FinalizePdaoProposals) Run(state *state.NetworkState) error
• type GenerateRewardsTree
  • func NewGenerateRewardsTree(ctx context.Context, sp *services.ServiceProvider, logger *log.Logger) *GenerateRewardsTree
  • func (t *GenerateRewardsTree) Run() error
• type RespondChallenges
  • func NewRespondChallenges(sp *services.ServiceProvider, logger *log.Logger, m *state.NetworkStateManager) *RespondChallenges
  • func (t *RespondChallenges) Run() error
• type SubmitNetworkBalances
  • func NewSubmitNetworkBalances(ctx context.Context, sp *services.ServiceProvider, logger *log.Logger) *SubmitNetworkBalances
  • func (t *SubmitNetworkBalances) Run(state *state.NetworkState) error
• type SubmitRewardsTree_Rolling
  • func NewSubmitRewardsTree_Rolling(ctx context.Context, sp *services.ServiceProvider, logger *log.Logger, ...) (*SubmitRewardsTree_Rolling, error)
  • func (t *SubmitRewardsTree_Rolling) Run(headState *state.NetworkState) error
• type SubmitRewardsTree_Stateless
  • func NewSubmitRewardsTree_Stateless(ctx context.Context, sp *services.ServiceProvider, logger *log.Logger, ...) *SubmitRewardsTree_Stateless
  • func (t *SubmitRewardsTree_Stateless) Run(nodeTrusted bool, state *state.NetworkState, beaconSlot uint64) error
• type SubmitRplPrice
  • func NewSubmitRplPrice(ctx context.Context, sp *services.ServiceProvider, logger *log.Logger) *SubmitRplPrice
  • func (t *SubmitRplPrice) Run(state *state.NetworkState) error
• type SubmitScrubMinipools
  • func NewSubmitScrubMinipools(sp *services.ServiceProvider, logger *log.Logger, ...) *SubmitScrubMinipools
  • func (t *SubmitScrubMinipools) Run(state *state.NetworkState) error
• type TaskManager
  • func NewTaskManager(sp *services.ServiceProvider, stateMgr *state.NetworkStateManager, ...) *TaskManager
  • func (t *TaskManager) Initialize(stateMgr *state.NetworkStateManager) error
  • func (t *TaskManager) Run(isOnOdao bool, state *state.NetworkState) error

Constants

const (
	SubmissionKey string = "network.prices.submitted.node.key"
	BlocksPerTurn uint64 = 75 // Approx. 15 minutes

)

Settings

const BlockStartOffset = 100000

const MinScrubSafetyTime = time.Duration(0) * time.Hour

const MinipoolBatchSize = 20

Settings

const MinipoolStatusBatchSize = 20

Settings

const ScrubSafetyDivider = 2

Types

type CancelBondReductions

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

func NewCancelBondReductions

func NewCancelBondReductions(ctx context.Context, sp *services.ServiceProvider, logger *log.Logger, coll *collectors.BondReductionCollector) *CancelBondReductions

Create cancel bond reductions task

func (*CancelBondReductions) Run

func (t *CancelBondReductions) Run(state *state.NetworkState) error

Start the bond reduction cancellation thread

type CheckSoloMigrations

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

func NewCheckSoloMigrations

func NewCheckSoloMigrations(ctx context.Context, sp *services.ServiceProvider, logger *log.Logger, coll *collectors.SoloMigrationCollector) *CheckSoloMigrations

Create check solo migrations task

func (*CheckSoloMigrations) Run

func (t *CheckSoloMigrations) Run(state *state.NetworkState) error

Start the solo migration checking thread

type DissolveTimedOutMinipools

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

Dissolve timed out minipools task

func NewDissolveTimedOutMinipools

func NewDissolveTimedOutMinipools(sp *services.ServiceProvider, logger *log.Logger) *DissolveTimedOutMinipools

Create dissolve timed out minipools task

func (*DissolveTimedOutMinipools) Run

func (t *DissolveTimedOutMinipools) Run(state *state.NetworkState) error

Dissolve timed out minipools

type FinalizePdaoProposals

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

Finalize PDAO proposals task

func NewFinalizePdaoProposals

func NewFinalizePdaoProposals(sp *services.ServiceProvider, logger *log.Logger) *FinalizePdaoProposals

Create finalize PDAO proposals task task

func (*FinalizePdaoProposals) Run

func (t *FinalizePdaoProposals) Run(state *state.NetworkState) error

Dissolve timed out minipools

type GenerateRewardsTree

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

Generate rewards Merkle Tree task

func NewGenerateRewardsTree

func NewGenerateRewardsTree(ctx context.Context, sp *services.ServiceProvider, logger *log.Logger) *GenerateRewardsTree

Create generate rewards Merkle Tree task

func (*GenerateRewardsTree) Run

func (t *GenerateRewardsTree) Run() error

Check for generation requests

type RespondChallenges

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

Respond to challenges task

func NewRespondChallenges

func NewRespondChallenges(sp *services.ServiceProvider, logger *log.Logger, m *state.NetworkStateManager) *RespondChallenges

Create respond to challenges task

func (*RespondChallenges) Run

func (t *RespondChallenges) Run() error

Respond to challenges

type SubmitNetworkBalances

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

Submit network balances task

func NewSubmitNetworkBalances

func NewSubmitNetworkBalances(ctx context.Context, sp *services.ServiceProvider, logger *log.Logger) *SubmitNetworkBalances

Create submit network balances task

func (*SubmitNetworkBalances) Run

func (t *SubmitNetworkBalances) Run(state *state.NetworkState) error

Submit network balances

type SubmitRewardsTree_Rolling

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

Process balances and rewards task

func NewSubmitRewardsTree_Rolling

func NewSubmitRewardsTree_Rolling(ctx context.Context, sp *services.ServiceProvider, logger *log.Logger, stateMgr *state.NetworkStateManager) (*SubmitRewardsTree_Rolling, error)

Create submit rewards tree with rolling record support

func (*SubmitRewardsTree_Rolling) Run

func (t *SubmitRewardsTree_Rolling) Run(headState *state.NetworkState) error

Update the rolling record and run the submission process if applicable

type SubmitRewardsTree_Stateless

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

Submit rewards Merkle Tree task

func NewSubmitRewardsTree_Stateless

func NewSubmitRewardsTree_Stateless(ctx context.Context, sp *services.ServiceProvider, logger *log.Logger, m *state.NetworkStateManager) *SubmitRewardsTree_Stateless

Create submit rewards Merkle Tree task

func (*SubmitRewardsTree_Stateless) Run

func (t *SubmitRewardsTree_Stateless) Run(nodeTrusted bool, state *state.NetworkState, beaconSlot uint64) error

Submit rewards Merkle Tree

type SubmitRplPrice

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

Submit RPL price task

func NewSubmitRplPrice

func NewSubmitRplPrice(ctx context.Context, sp *services.ServiceProvider, logger *log.Logger) *SubmitRplPrice

Create submit RPL price task

func (*SubmitRplPrice) Run

func (t *SubmitRplPrice) Run(state *state.NetworkState) error

Submit RPL price

type SubmitScrubMinipools

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

Submit scrub minipools task

func NewSubmitScrubMinipools

func NewSubmitScrubMinipools(sp *services.ServiceProvider, logger *log.Logger, coll *collectors.ScrubCollector) *SubmitScrubMinipools

Create submit scrub minipools task

func (*SubmitScrubMinipools) Run

func (t *SubmitScrubMinipools) Run(state *state.NetworkState) error

Submit scrub minipools

type TaskManager

type TaskManager struct {

	// Collectors
	ScrubCollector         *collectors.ScrubCollector
	BondReductionCollector *collectors.BondReductionCollector
	SoloMigrationCollector *collectors.SoloMigrationCollector
	// contains filtered or unexported fields
}

func NewTaskManager

func NewTaskManager(
	sp *services.ServiceProvider,
	stateMgr *state.NetworkStateManager,
	scrubCollector *collectors.ScrubCollector,
	bondReductionCollector *collectors.BondReductionCollector,
	soloMigrationCollector *collectors.SoloMigrationCollector,
) *TaskManager

func (*TaskManager) Initialize

func (t *TaskManager) Initialize(stateMgr *state.NetworkStateManager) error

func (*TaskManager) Run

func (t *TaskManager) Run(isOnOdao bool, state *state.NetworkState) error

Run the task loop