optimus

type Blacklist interface {
	Update(ctx context.Context) error
	IsAllowed(addr common.Address) bool
}

type BruteForceModel struct{}

type Clock func() time.Time

type Config struct {
	Blockchain   *blockchain.Config         `yaml:"blockchain"`
	PrivateKey   privateKey                 `yaml:"ethereum" json:"-"`
	Logging      logging.Config             `yaml:"logging"`
	Node         nodeConfig                 `yaml:"node"`
	Workers      map[auth.Addr]workerConfig `yaml:"workers"`
	Benchmarks   benchmarks.Config          `yaml:"benchmarks"`
	Marketplace  marketplaceConfig          `yaml:"marketplace"`
	Optimization optimizationConfig
}

type Consumer interface {
	LowerBound() []float64
	DeviceType() sonm.DeviceType
	DeviceBenchmark(id int) (*sonm.Benchmark, bool)
	SplittingAlgorithm() sonm.SplittingAlgorithm
	Result(criteria float64) interface{}
}

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

type FittingFunc struct {
	Filters []func(order *sonm.Order) bool
}

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

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

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

type MarketOrder = sonm.DWHOrder

type MarketScanner interface {
	ActiveOrders(ctx context.Context) ([]*MarketOrder, error)
}

type Model interface {
	// Train runs the training process, returning the trained model on success.
	// The "trainingSet" argument is a MxN matrix, while "expectation" must be
	// a M-length vector.
	Train(trainingSet [][]float64, expectation []float64) (TrainedModel, error)
}

type Normalizer interface {
	Normalize(x float64) float64
	NormalizeBatch(x []float64)
	Denormalize(x float64) float64
	IsDegenerated() bool
}

type OptimizationMethod interface {
	Optimize(knapsack *Knapsack, orders []*MarketOrder) error
}

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

type Option func(o *options)

type OrderClassification struct {
	WeightedOrders []WeightedOrder
	Predictor      *OrderPredictor
	Sigmoid        sigmoid
	Clock          Clock
}

type OrderClassifier interface {
	Classify(orders []*MarketOrder) ([]WeightedOrder, error)
}

type OrderPolicy int

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

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

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

type TrainedModel interface {
	Predict(vec []float64) (float64, error)
}

type Watcher interface {
	OnRun()
	OnShutdown()
	Execute(ctx context.Context)
}

type WeightedOrder struct {
	// Order is an initial market order.
	Order *MarketOrder
	// Price is an order price in USD/s.
	Price float64
	// PredictedPrice is a order price in USD/s, that is calculated during
	// scanning and analysing the market.
	PredictedPrice float64
	// Weight represents some specific order weight.
	//
	// It fits in [0; +Inf] range and is used to reduce an order attractiveness
	// if it has been laying on the market for a long time without being sold.
	Weight float64
}

type WorkerManagementClientExt interface {
	sonm.WorkerManagementClient
	RemoveAskPlans(ctx context.Context, ids []string) error
}