refactor(tm2): make rpc client not depend on goleveldb

contribs/gnodev/pkg/dev/node.go

@@ -70,13 +70,12 @@ func NewDevNode(ctx context.Context, logger *slog.Logger, emitter emitter.Emitte
 	if err != nil {
 		return nil, fmt.Errorf("unable to initialize the node: %w", err)
 	}
-	client := client.NewLocal(node)
 
 	return &Node{
 		Node: node,
 
 		emitter:        emitter,
-		client:         client,
+		client:         client.NewLocal(),
 		pkgs:           mpkgs,
 		logger:         logger,
 		loadedPackages: len(pkgsTxs),

contribs/gnokeykc/go.mod

@@ -10,7 +10,6 @@ require (
 )
 
 require (
-	dario.cat/mergo v1.0.0 // indirect
 	github.com/alessio/shellescape v1.4.1 // indirect
 	github.com/btcsuite/btcd/btcec/v2 v2.3.2 // indirect
 	github.com/btcsuite/btcd/btcutil v1.1.3 // indirect
@@ -31,7 +30,6 @@ require (
 	github.com/peterbourgon/ff/v3 v3.4.0 // indirect
 	github.com/pkg/errors v0.9.1 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
-	github.com/rs/cors v1.10.1 // indirect
 	github.com/stretchr/testify v1.8.4 // indirect
 	github.com/zondax/hid v0.9.2 // indirect
 	github.com/zondax/ledger-go v0.14.3 // indirect

tm2/pkg/bft/proxy/app_conn.go → tm2/pkg/bft/appconn/app_conn.go

@@ -1,4 +1,5 @@
-package proxy
+// Package appconn manages the connection of Tendermint to the application layer.
+package appconn
 
 import (
 	abcicli "github.com/gnolang/gno/tm2/pkg/bft/abci/client"
@@ -8,7 +9,7 @@ import (
 //----------------------------------------------------------------------------------------
 // Enforce which abci msgs can be sent on a connection at the type level
 
-type AppConnConsensus interface {
+type Consensus interface {
 	SetResponseCallback(abcicli.Callback)
 	Error() error
 
@@ -20,7 +21,7 @@ type AppConnConsensus interface {
 	CommitSync() (abci.ResponseCommit, error)
 }
 
-type AppConnMempool interface {
+type Mempool interface {
 	SetResponseCallback(abcicli.Callback)
 	Error() error
 
@@ -30,7 +31,7 @@ type AppConnMempool interface {
 	FlushSync() error
 }
 
-type AppConnQuery interface {
+type Query interface {
 	Error() error
 
 	EchoSync(string) (abci.ResponseEcho, error)
@@ -41,104 +42,104 @@ type AppConnQuery interface {
 }
 
 //-----------------------------------------------------------------------------------------
-// Implements AppConnConsensus (subset of abcicli.Client)
+// Implements Consensus (subset of abcicli.Client)
 
-type appConnConsensus struct {
+type consensus struct {
 	appConn abcicli.Client
 }
 
-func NewAppConnConsensus(appConn abcicli.Client) *appConnConsensus {
-	return &appConnConsensus{
+func NewConsensus(appConn abcicli.Client) *consensus {
+	return &consensus{
 		appConn: appConn,
 	}
 }
 
-func (app *appConnConsensus) SetResponseCallback(cb abcicli.Callback) {
+func (app *consensus) SetResponseCallback(cb abcicli.Callback) {
 	app.appConn.SetResponseCallback(cb)
 }
 
-func (app *appConnConsensus) Error() error {
+func (app *consensus) Error() error {
 	return app.appConn.Error()
 }
 
-func (app *appConnConsensus) InitChainSync(req abci.RequestInitChain) (abci.ResponseInitChain, error) {
+func (app *consensus) InitChainSync(req abci.RequestInitChain) (abci.ResponseInitChain, error) {
 	return app.appConn.InitChainSync(req)
 }
 
-func (app *appConnConsensus) BeginBlockSync(req abci.RequestBeginBlock) (abci.ResponseBeginBlock, error) {
+func (app *consensus) BeginBlockSync(req abci.RequestBeginBlock) (abci.ResponseBeginBlock, error) {
 	return app.appConn.BeginBlockSync(req)
 }
 
-func (app *appConnConsensus) DeliverTxAsync(req abci.RequestDeliverTx) *abcicli.ReqRes {
+func (app *consensus) DeliverTxAsync(req abci.RequestDeliverTx) *abcicli.ReqRes {
 	return app.appConn.DeliverTxAsync(req)
 }
 
-func (app *appConnConsensus) EndBlockSync(req abci.RequestEndBlock) (abci.ResponseEndBlock, error) {
+func (app *consensus) EndBlockSync(req abci.RequestEndBlock) (abci.ResponseEndBlock, error) {
 	return app.appConn.EndBlockSync(req)
 }
 
-func (app *appConnConsensus) CommitSync() (abci.ResponseCommit, error) {
+func (app *consensus) CommitSync() (abci.ResponseCommit, error) {
 	return app.appConn.CommitSync()
 }
 
 //------------------------------------------------
-// Implements AppConnMempool (subset of abcicli.Client)
+// Implements Mempool (subset of abcicli.Client)
 
-type appConnMempool struct {
+type mempool struct {
 	appConn abcicli.Client
 }
 
-func NewAppConnMempool(appConn abcicli.Client) *appConnMempool {
-	return &appConnMempool{
+func NewMempool(appConn abcicli.Client) *mempool {
+	return &mempool{
 		appConn: appConn,
 	}
 }
 
-func (app *appConnMempool) SetResponseCallback(cb abcicli.Callback) {
+func (app *mempool) SetResponseCallback(cb abcicli.Callback) {
 	app.appConn.SetResponseCallback(cb)
 }
 
-func (app *appConnMempool) Error() error {
+func (app *mempool) Error() error {
 	return app.appConn.Error()
 }
 
-func (app *appConnMempool) FlushAsync() *abcicli.ReqRes {
+func (app *mempool) FlushAsync() *abcicli.ReqRes {
 	return app.appConn.FlushAsync()
 }
 
-func (app *appConnMempool) FlushSync() error {
+func (app *mempool) FlushSync() error {
 	return app.appConn.FlushSync()
 }
 
-func (app *appConnMempool) CheckTxAsync(req abci.RequestCheckTx) *abcicli.ReqRes {
+func (app *mempool) CheckTxAsync(req abci.RequestCheckTx) *abcicli.ReqRes {
 	return app.appConn.CheckTxAsync(req)
 }
 
 //------------------------------------------------
-// Implements AppConnQuery (subset of abcicli.Client)
+// Implements Query (subset of abcicli.Client)
 
-type appConnQuery struct {
+type query struct {
 	appConn abcicli.Client
 }
 
-func NewAppConnQuery(appConn abcicli.Client) *appConnQuery {
-	return &appConnQuery{
+func NewQuery(appConn abcicli.Client) *query {
+	return &query{
 		appConn: appConn,
 	}
 }
 
-func (app *appConnQuery) Error() error {
+func (app *query) Error() error {
 	return app.appConn.Error()
 }
 
-func (app *appConnQuery) EchoSync(msg string) (abci.ResponseEcho, error) {
+func (app *query) EchoSync(msg string) (abci.ResponseEcho, error) {
 	return app.appConn.EchoSync(msg)
 }
 
-func (app *appConnQuery) InfoSync(req abci.RequestInfo) (abci.ResponseInfo, error) {
+func (app *query) InfoSync(req abci.RequestInfo) (abci.ResponseInfo, error) {
 	return app.appConn.InfoSync(req)
 }
 
-func (app *appConnQuery) QuerySync(reqQuery abci.RequestQuery) (abci.ResponseQuery, error) {
+func (app *query) QuerySync(reqQuery abci.RequestQuery) (abci.ResponseQuery, error) {
 	return app.appConn.QuerySync(reqQuery)
 }

tm2/pkg/bft/proxy/multi_app_conn.go → tm2/pkg/bft/appconn/multi_app_conn.go

@@ -1,6 +1,7 @@
-package proxy
+package appconn
 
 import (
+	abcicli "github.com/gnolang/gno/tm2/pkg/bft/abci/client"
 	"github.com/gnolang/gno/tm2/pkg/errors"
 	"github.com/gnolang/gno/tm2/pkg/service"
 )
@@ -11,56 +12,61 @@ import (
 type AppConns interface {
 	service.Service
 
-	Mempool() AppConnMempool
-	Consensus() AppConnConsensus
-	Query() AppConnQuery
+	Mempool() Mempool
+	Consensus() Consensus
+	Query() Query
+}
+
+// NewABCIClient returns newly connected client
+type ClientCreator interface {
+	NewABCIClient() (abcicli.Client, error)
 }
 
 func NewAppConns(clientCreator ClientCreator) AppConns {
-	return NewMultiAppConn(clientCreator)
+	return NewMulti(clientCreator)
 }
 
 //-----------------------------
-// multiAppConn implements AppConns
+// multi implements AppConns
 
-// a multiAppConn is made of a few appConns (mempool, consensus, query)
+// a multi is made of a few appConns (mempool, consensus, query)
 // and manages their underlying abci clients
 // TODO: on app restart, clients must reboot together
-type multiAppConn struct {
+type multi struct {
 	service.BaseService
 
-	mempoolConn   *appConnMempool
-	consensusConn *appConnConsensus
-	queryConn     *appConnQuery
+	mempoolConn   *mempool
+	consensusConn *consensus
+	queryConn     *query
 
 	clientCreator ClientCreator
 }
 
 // Make all necessary abci connections to the application
-func NewMultiAppConn(clientCreator ClientCreator) *multiAppConn {
-	multiAppConn := &multiAppConn{
+func NewMulti(clientCreator ClientCreator) *multi {
+	multi := &multi{
 		clientCreator: clientCreator,
 	}
-	multiAppConn.BaseService = *service.NewBaseService(nil, "multiAppConn", multiAppConn)
-	return multiAppConn
+	multi.BaseService = *service.NewBaseService(nil, "multi", multi)
+	return multi
 }
 
 // Returns the mempool connection
-func (app *multiAppConn) Mempool() AppConnMempool {
+func (app *multi) Mempool() Mempool {
 	return app.mempoolConn
 }
 
 // Returns the consensus Connection
-func (app *multiAppConn) Consensus() AppConnConsensus {
+func (app *multi) Consensus() Consensus {
 	return app.consensusConn
 }
 
 // Returns the query Connection
-func (app *multiAppConn) Query() AppConnQuery {
+func (app *multi) Query() Query {
 	return app.queryConn
 }
 
-func (app *multiAppConn) OnStart() error {
+func (app *multi) OnStart() error {
 	// query connection
 	querycli, err := app.clientCreator.NewABCIClient()
 	if err != nil {
@@ -70,7 +76,7 @@ func (app *multiAppConn) OnStart() error {
 	if err := querycli.Start(); err != nil {
 		return errors.Wrap(err, "Error starting ABCI client (query connection)")
 	}
-	app.queryConn = NewAppConnQuery(querycli)
+	app.queryConn = NewQuery(querycli)
 
 	// mempool connection
 	memcli, err := app.clientCreator.NewABCIClient()
@@ -81,7 +87,7 @@ func (app *multiAppConn) OnStart() error {
 	if err := memcli.Start(); err != nil {
 		return errors.Wrap(err, "Error starting ABCI client (mempool connection)")
 	}
-	app.mempoolConn = NewAppConnMempool(memcli)
+	app.mempoolConn = NewMempool(memcli)
 
 	// consensus connection
 	concli, err := app.clientCreator.NewABCIClient()
@@ -92,7 +98,7 @@ func (app *multiAppConn) OnStart() error {
 	if err := concli.Start(); err != nil {
 		return errors.Wrap(err, "Error starting ABCI client (consensus connection)")
 	}
-	app.consensusConn = NewAppConnConsensus(concli)
+	app.consensusConn = NewConsensus(concli)
 
 	return nil
 }

tm2/pkg/bft/blockchain/reactor_test.go

@@ -10,6 +10,7 @@ import (
 	"github.com/stretchr/testify/assert"
 
 	abci "github.com/gnolang/gno/tm2/pkg/bft/abci/types"
+	"github.com/gnolang/gno/tm2/pkg/bft/appconn"
 	cfg "github.com/gnolang/gno/tm2/pkg/bft/config"
 	"github.com/gnolang/gno/tm2/pkg/bft/mempool/mock"
 	"github.com/gnolang/gno/tm2/pkg/bft/proxy"
@@ -48,7 +49,7 @@ func randGenesisDoc(numValidators int, randPower bool, minPower int64) (*types.G
 
 type BlockchainReactorPair struct {
 	reactor *BlockchainReactor
-	app     proxy.AppConns
+	app     appconn.AppConns
 }
 
 func newBlockchainReactor(logger *slog.Logger, genDoc *types.GenesisDoc, privVals []types.PrivValidator, maxBlockHeight int64) BlockchainReactorPair {
@@ -58,7 +59,7 @@ func newBlockchainReactor(logger *slog.Logger, genDoc *types.GenesisDoc, privVal
 
 	app := &testApp{}
 	cc := proxy.NewLocalClientCreator(app)
-	proxyApp := proxy.NewAppConns(cc)
+	proxyApp := appconn.NewAppConns(cc)
 	err := proxyApp.Start()
 	if err != nil {
 		panic(errors.Wrap(err, "error start app"))