app: use multiple logical databases

node/app/wire.go

@@ -50,16 +50,44 @@ var keyManagerSet = wire.NewSet(
 	wire.Bind(new(keys.KeyManager), new(*keys.FileKeyManager)),
 )
 
+func provideBaseDB(dbConfig *config.DBConfig) *store.MDBXDB {
+	return store.NewMDBXDB(dbConfig)
+}
+
+func providePebbleClockStore(db *store.MDBXDB, logger *zap.Logger) *store.PebbleClockStore {
+	return store.NewPebbleClockStore(db.OpenDB("clock_store"), logger)
+}
+
+func providePebbleCoinStore(db *store.MDBXDB, logger *zap.Logger) *store.PebbleCoinStore {
+	return store.NewPebbleCoinStore(db.OpenDB("coin_store"), logger)
+}
+
+func providePebbleKeyStore(db *store.MDBXDB, logger *zap.Logger) *store.PebbleKeyStore {
+	return store.NewPebbleKeyStore(db.OpenDB("key_store"), logger)
+}
+
+func providePebbleDataProofStore(db *store.MDBXDB, logger *zap.Logger) *store.PebbleDataProofStore {
+	return store.NewPebbleDataProofStore(db.OpenDB("data_proof_store"), logger)
+}
+
+func providePebbleHypergraphStore(db *store.MDBXDB, logger *zap.Logger) *store.PebbleHypergraphStore {
+	return store.NewPebbleHypergraphStore(db.OpenDB("hypergraph_store"), logger)
+}
+
+func providePeerstoreDatastore(db *store.MDBXDB, logger *zap.Logger) *store.PeerstoreDatastore {
+	return store.NewPeerstoreDatastore(db.OpenDB("peerstore"))
+}
+
 var storeSet = wire.NewSet(
 	wire.FieldsOf(new(*config.Config), "DB"),
-	store.NewMDBXDB,
+	provideBaseDB,
 	wire.Bind(new(store.KVDB), new(*store.MDBXDB)),
-	store.NewPebbleClockStore,
-	store.NewPebbleCoinStore,
-	store.NewPebbleKeyStore,
-	store.NewPebbleDataProofStore,
-	store.NewPebbleHypergraphStore,
-	store.NewPeerstoreDatastore,
+	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)),

node/app/wire_gen.go

@@ -37,21 +37,21 @@ func NewDHTNode(configConfig *config.Config) (*DHTNode, error) {
 func NewDebugNode(configConfig *config.Config, selfTestReport *protobufs.SelfTestReport) (*Node, error) {
 	zapLogger := debugLogger()
 	dbConfig := configConfig.DB
-	mdbxdb := store.NewMDBXDB(dbConfig)
-	pebbleDataProofStore := store.NewPebbleDataProofStore(mdbxdb, zapLogger)
-	pebbleClockStore := store.NewPebbleClockStore(mdbxdb, zapLogger)
-	pebbleCoinStore := store.NewPebbleCoinStore(mdbxdb, zapLogger)
+	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 := store.NewPebbleHypergraphStore(mdbxdb, zapLogger)
+	pebbleHypergraphStore := providePebbleHypergraphStore(mdbxdb, zapLogger)
 	engineConfig := configConfig.Engine
 	masterTimeReel := time.NewMasterTimeReel(zapLogger, pebbleClockStore, engineConfig, frameProver)
 	inMemoryPeerInfoManager := p2p.NewInMemoryPeerInfoManager(zapLogger)
-	pebbleKeyStore := store.NewPebbleKeyStore(mdbxdb, 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)
@@ -64,21 +64,21 @@ func NewDebugNode(configConfig *config.Config, selfTestReport *protobufs.SelfTes
 func NewNode(configConfig *config.Config, selfTestReport *protobufs.SelfTestReport) (*Node, error) {
 	zapLogger := logger()
 	dbConfig := configConfig.DB
-	mdbxdb := store.NewMDBXDB(dbConfig)
-	pebbleDataProofStore := store.NewPebbleDataProofStore(mdbxdb, zapLogger)
-	pebbleClockStore := store.NewPebbleClockStore(mdbxdb, zapLogger)
-	pebbleCoinStore := store.NewPebbleCoinStore(mdbxdb, zapLogger)
+	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 := store.NewPebbleHypergraphStore(mdbxdb, zapLogger)
+	pebbleHypergraphStore := providePebbleHypergraphStore(mdbxdb, zapLogger)
 	engineConfig := configConfig.Engine
 	masterTimeReel := time.NewMasterTimeReel(zapLogger, pebbleClockStore, engineConfig, frameProver)
 	inMemoryPeerInfoManager := p2p.NewInMemoryPeerInfoManager(zapLogger)
-	pebbleKeyStore := store.NewPebbleKeyStore(mdbxdb, 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)
@@ -98,9 +98,9 @@ func NewDBConsole(configConfig *config.Config) (*DBConsole, error) {
 
 func NewClockStore(configConfig *config.Config) (store.ClockStore, error) {
 	dbConfig := configConfig.DB
-	mdbxdb := store.NewMDBXDB(dbConfig)
+	mdbxdb := provideBaseDB(dbConfig)
 	zapLogger := logger()
-	pebbleClockStore := store.NewPebbleClockStore(mdbxdb, zapLogger)
+	pebbleClockStore := providePebbleClockStore(mdbxdb, zapLogger)
 	return pebbleClockStore, nil
 }
 
@@ -134,7 +134,41 @@ var debugLoggerSet = wire.NewSet(
 
 var keyManagerSet = wire.NewSet(wire.FieldsOf(new(*config.Config), "Key"), keys.NewFileKeyManager, wire.Bind(new(keys.KeyManager), new(*keys.FileKeyManager)))
 
-var storeSet = wire.NewSet(wire.FieldsOf(new(*config.Config), "DB"), store.NewMDBXDB, wire.Bind(new(store.KVDB), new(*store.MDBXDB)), store.NewPebbleClockStore, store.NewPebbleCoinStore, store.NewPebbleKeyStore, store.NewPebbleDataProofStore, store.NewPebbleHypergraphStore, store.NewPeerstoreDatastore, 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)))
+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)))
 

node/store/mdbx.go

@@ -67,15 +67,10 @@ func NewMDBXDB(config *config.DBConfig) *MDBXDB {
 
 	// Open the default database. Other databases are opened using OpenDB)
 	db := &MDBXDB{env: env}
-	db, err = db.OpenDB(DEFAULT_TABLE)
-	if err != nil {
-		panic(err)
-	}
-
-	return db
+	return db.OpenDB(DEFAULT_TABLE)
 }
 
-func (m *MDBXDB) OpenDB(name string) (*MDBXDB, error) {
+func (m *MDBXDB) OpenDB(name string) *MDBXDB {
 	var dbi mdbx.DBI
 	var err error
 	err = m.env.Update(func(txn *mdbx.Txn) error {
@@ -86,9 +81,9 @@ func (m *MDBXDB) OpenDB(name string) (*MDBXDB, error) {
 		return nil
 	})
 	if err != nil {
-		return nil, err
+		panic(err)
 	}
-	return &MDBXDB{env: m.env, dbi: dbi}, nil
+	return &MDBXDB{env: m.env, dbi: dbi}
 }
 
 // KVDB interface implementation

node/store/mdbx_test.go

@@ -411,7 +411,7 @@ func TestMDBXDB(t *testing.T) {
 		names := []string{DEFAULT_TABLE, "table1", "table2"}
 		var dbs []MDBXDB
 		for _, name := range names {
-			newdb, err := db.OpenDB(name)
+			newdb := db.OpenDB(name)
 			if err != nil {
 				t.Errorf("error opening db: %v", err)
 				t.Fail()

node/store/peerstore.go

@@ -41,11 +41,10 @@ var _ ds.Batching = (*PeerstoreDatastore)(nil)
 var _ ds.Batch = (*batch)(nil)
 var _ Peerstore = (*PeerstoreDatastore)(nil)
 
-func NewPeerstoreDatastore(db KVDB) (*PeerstoreDatastore, error) {
-	ds := PeerstoreDatastore{
+func NewPeerstoreDatastore(db KVDB) *PeerstoreDatastore {
+	return &PeerstoreDatastore{
 		db: db,
 	}
-	return &ds, nil
 }
 
 func (d *PeerstoreDatastore) Put(