ceremonyclient/node/app/wire_gen.go

// Code generated by Wire. DO NOT EDIT.

//go:generate go run github.com/google/wire/cmd/wire
//go:build !wireinject
// +build !wireinject

package app

import (
	"github.com/google/wire"
	"go.uber.org/zap"
	"source.quilibrium.com/quilibrium/monorepo/node/config"
	"source.quilibrium.com/quilibrium/monorepo/node/consensus"
	"source.quilibrium.com/quilibrium/monorepo/node/consensus/master"
	"source.quilibrium.com/quilibrium/monorepo/node/consensus/time"
	"source.quilibrium.com/quilibrium/monorepo/node/crypto"
	"source.quilibrium.com/quilibrium/monorepo/node/execution/intrinsics/token"
	"source.quilibrium.com/quilibrium/monorepo/node/keys"
	"source.quilibrium.com/quilibrium/monorepo/node/p2p"
	"source.quilibrium.com/quilibrium/monorepo/node/protobufs"
	"source.quilibrium.com/quilibrium/monorepo/node/store"
)

// Injectors from wire.go:

func NewDHTNode(configConfig *config.Config) (*DHTNode, error) {
	p2PConfig := configConfig.P2P
	zapLogger := debugLogger()
	blossomSub := p2p.NewBlossomSub(p2PConfig, zapLogger)
	dhtNode, err := newDHTNode(blossomSub)
	if err != nil {
		return nil, err
	}
	return dhtNode, nil
}

func NewDebugNode(configConfig *config.Config, selfTestReport *protobufs.SelfTestReport) (*Node, error) {
	zapLogger := debugLogger()
	dbConfig := configConfig.DB
	mdbxdb := provideBaseDB(dbConfig)
	pebbleDataProofStore := providePebbleDataProofStore(mdbxdb, zapLogger)
	pebbleClockStore := providePebbleClockStore(mdbxdb, zapLogger)
	pebbleCoinStore := providePebbleCoinStore(mdbxdb, zapLogger)
	keyConfig := configConfig.Key
	fileKeyManager := keys.NewFileKeyManager(keyConfig, zapLogger)
	p2PConfig := configConfig.P2P
	blossomSub := p2p.NewBlossomSub(p2PConfig, zapLogger)
	frameProver := crypto.NewCachedWesolowskiFrameProver(zapLogger)
	kzgInclusionProver := crypto.NewKZGInclusionProver(zapLogger)
	pebbleHypergraphStore := providePebbleHypergraphStore(mdbxdb, zapLogger)
	engineConfig := configConfig.Engine
	masterTimeReel := time.NewMasterTimeReel(zapLogger, pebbleClockStore, engineConfig, frameProver)
	inMemoryPeerInfoManager := p2p.NewInMemoryPeerInfoManager(zapLogger)
	pebbleKeyStore := providePebbleKeyStore(mdbxdb, zapLogger)
	tokenExecutionEngine := token.NewTokenExecutionEngine(zapLogger, configConfig, fileKeyManager, blossomSub, frameProver, kzgInclusionProver, pebbleClockStore, pebbleDataProofStore, pebbleHypergraphStore, pebbleCoinStore, masterTimeReel, inMemoryPeerInfoManager, pebbleKeyStore, selfTestReport)
	masterClockConsensusEngine := master.NewMasterClockConsensusEngine(engineConfig, zapLogger, pebbleClockStore, fileKeyManager, blossomSub, kzgInclusionProver, frameProver, masterTimeReel, inMemoryPeerInfoManager, selfTestReport)
	node, err := newNode(zapLogger, pebbleDataProofStore, pebbleClockStore, pebbleCoinStore, fileKeyManager, blossomSub, tokenExecutionEngine, masterClockConsensusEngine, mdbxdb)
	if err != nil {
		return nil, err
	}
	return node, nil
}

func NewNode(configConfig *config.Config, selfTestReport *protobufs.SelfTestReport) (*Node, error) {
	zapLogger := logger()
	dbConfig := configConfig.DB
	mdbxdb := provideBaseDB(dbConfig)
	pebbleDataProofStore := providePebbleDataProofStore(mdbxdb, zapLogger)
	pebbleClockStore := providePebbleClockStore(mdbxdb, zapLogger)
	pebbleCoinStore := providePebbleCoinStore(mdbxdb, zapLogger)
	keyConfig := configConfig.Key
	fileKeyManager := keys.NewFileKeyManager(keyConfig, zapLogger)
	p2PConfig := configConfig.P2P
	blossomSub := p2p.NewBlossomSub(p2PConfig, zapLogger)
	frameProver := crypto.NewCachedWesolowskiFrameProver(zapLogger)
	kzgInclusionProver := crypto.NewKZGInclusionProver(zapLogger)
	pebbleHypergraphStore := providePebbleHypergraphStore(mdbxdb, zapLogger)
	engineConfig := configConfig.Engine
	masterTimeReel := time.NewMasterTimeReel(zapLogger, pebbleClockStore, engineConfig, frameProver)
	inMemoryPeerInfoManager := p2p.NewInMemoryPeerInfoManager(zapLogger)
	pebbleKeyStore := providePebbleKeyStore(mdbxdb, zapLogger)
	tokenExecutionEngine := token.NewTokenExecutionEngine(zapLogger, configConfig, fileKeyManager, blossomSub, frameProver, kzgInclusionProver, pebbleClockStore, pebbleDataProofStore, pebbleHypergraphStore, pebbleCoinStore, masterTimeReel, inMemoryPeerInfoManager, pebbleKeyStore, selfTestReport)
	masterClockConsensusEngine := master.NewMasterClockConsensusEngine(engineConfig, zapLogger, pebbleClockStore, fileKeyManager, blossomSub, kzgInclusionProver, frameProver, masterTimeReel, inMemoryPeerInfoManager, selfTestReport)
	node, err := newNode(zapLogger, pebbleDataProofStore, pebbleClockStore, pebbleCoinStore, fileKeyManager, blossomSub, tokenExecutionEngine, masterClockConsensusEngine, mdbxdb)
	if err != nil {
		return nil, err
	}
	return node, nil
}

func NewDBConsole(configConfig *config.Config) (*DBConsole, error) {
	dbConsole, err := newDBConsole(configConfig)
	if err != nil {
		return nil, err
	}
	return dbConsole, nil
}

func NewClockStore(configConfig *config.Config) (store.ClockStore, error) {
	dbConfig := configConfig.DB
	mdbxdb := provideBaseDB(dbConfig)
	zapLogger := logger()
	pebbleClockStore := providePebbleClockStore(mdbxdb, zapLogger)
	return pebbleClockStore, nil
}

// wire.go:

func logger() *zap.Logger {
	log, err := zap.NewProduction()
	if err != nil {
		panic(err)
	}

	return log
}

func debugLogger() *zap.Logger {
	log, err := zap.NewDevelopment()
	if err != nil {
		panic(err)
	}

	return log
}

var loggerSet = wire.NewSet(
	logger,
)

var debugLoggerSet = wire.NewSet(
	debugLogger,
)

var keyManagerSet = wire.NewSet(wire.FieldsOf(new(*config.Config), "Key"), keys.NewFileKeyManager, wire.Bind(new(keys.KeyManager), new(*keys.FileKeyManager)))

func provideBaseDB(dbConfig *config.DBConfig) *store.MDBXDB {
	return store.NewMDBXDB(dbConfig)
}

func providePebbleClockStore(db *store.MDBXDB, logger2 *zap.Logger) *store.PebbleClockStore {
	return store.NewPebbleClockStore(db.OpenDB("clock_store"), logger2)
}

func providePebbleCoinStore(db *store.MDBXDB, logger2 *zap.Logger) *store.PebbleCoinStore {
	return store.NewPebbleCoinStore(db.OpenDB("coin_store"), logger2)
}

func providePebbleKeyStore(db *store.MDBXDB, logger2 *zap.Logger) *store.PebbleKeyStore {
	return store.NewPebbleKeyStore(db.OpenDB("key_store"), logger2)
}

func providePebbleDataProofStore(db *store.MDBXDB, logger2 *zap.Logger) *store.PebbleDataProofStore {
	return store.NewPebbleDataProofStore(db.OpenDB("data_proof_store"), logger2)
}

func providePebbleHypergraphStore(db *store.MDBXDB, logger2 *zap.Logger) *store.PebbleHypergraphStore {
	return store.NewPebbleHypergraphStore(db.OpenDB("hypergraph_store"), logger2)
}

func providePeerstoreDatastore(db *store.MDBXDB, logger2 *zap.Logger) *store.PeerstoreDatastore {
	return store.NewPeerstoreDatastore(db.OpenDB("peerstore"))
}

var storeSet = wire.NewSet(wire.FieldsOf(new(*config.Config), "DB"), provideBaseDB, wire.Bind(new(store.KVDB), new(*store.MDBXDB)), providePebbleClockStore,
	providePebbleCoinStore,
	providePebbleKeyStore,
	providePebbleDataProofStore,
	providePebbleHypergraphStore,
	providePeerstoreDatastore, wire.Bind(new(store.ClockStore), new(*store.PebbleClockStore)), wire.Bind(new(store.CoinStore), new(*store.PebbleCoinStore)), wire.Bind(new(store.KeyStore), new(*store.PebbleKeyStore)), wire.Bind(new(store.DataProofStore), new(*store.PebbleDataProofStore)), wire.Bind(new(store.HypergraphStore), new(*store.PebbleHypergraphStore)), wire.Bind(new(store.Peerstore), new(*store.PeerstoreDatastore)),
)

var pubSubSet = wire.NewSet(wire.FieldsOf(new(*config.Config), "P2P"), p2p.NewInMemoryPeerInfoManager, p2p.NewBlossomSub, wire.Bind(new(p2p.PubSub), new(*p2p.BlossomSub)), wire.Bind(new(p2p.PeerInfoManager), new(*p2p.InMemoryPeerInfoManager)))

var engineSet = wire.NewSet(wire.FieldsOf(new(*config.Config), "Engine"), crypto.NewCachedWesolowskiFrameProver, crypto.NewKZGInclusionProver, wire.Bind(new(crypto.InclusionProver), new(*crypto.KZGInclusionProver)), time.NewMasterTimeReel, token.NewTokenExecutionEngine)

var consensusSet = wire.NewSet(master.NewMasterClockConsensusEngine, wire.Bind(
	new(consensus.ConsensusEngine),
	new(*master.MasterClockConsensusEngine),
),
)