Release v0.6.0

Author: vitsalis

.circleci/config.yml

@@ -2,49 +2,50 @@
 # See: https://circleci.com/docs/2.0/configuration-reference
 version: 2.1
 
-# Define a job to be invoked later in a workflow.
-# See: https://circleci.com/docs/2.0/configuration-reference/#jobs
+orbs:
+  go: circleci/go@1.7.3
+
 jobs:
   test:
-    # Specify the execution environment. You can specify an image from Dockerhub or use one of our Convenience Images from CircleCI's Developer Hub.
-    # See: https://circleci.com/docs/2.0/configuration-reference/#docker-machine-macos-windows-executor
     machine:
-      image: ubuntu-2204:2022.07.1
-      resource_class: large
-    # Add steps to the job
-    # See: https://circleci.com/docs/2.0/configuration-reference/#steps
+      image: ubuntu-2204:2022.10.1
     steps:
+      - go/install:
+          version: "1.20"
       - checkout
-      - add_ssh_keys
       - run:
           name: Print Go environment
           command: "go env"
-      - restore_cache: # restores saved cache if no changes are detected since last run
-          keys:
-            - go-mod-v6-{{ checksum "go.sum" }}
-      - run:
-          name: Install Dependencies
-          command: sudo apt-get install libzmq3-dev
-      - run:
-          name: Retrieve dependencies
-          command: go mod download
-      - save_cache:
+      - go/load-cache:
           key: go-mod-v6-{{ checksum "go.sum" }}
-          paths:
-            - "/home/circleci/.go_workspace/pkg/mod"
-      - run:
-          name: Lint
-          command: |
-            curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sh -s v1.50.1 
-            ./bin/golangci-lint run
+      - go/mod-download
+      - go/save-cache:
+          key: go-mod-v6-{{ checksum "go.sum" }}
+          path: "/home/circleci/.go_workspace/pkg/mod"
       - run:
           name: Run tests
           command: |
             make test
+  lint:
+    machine:
+      image: ubuntu-2204:2022.10.1
+    steps:
+      - go/install:
+          version: "1.20"
+      - checkout
+      - run:
+          name: Lint
+          command: |
+            curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sh -s v1.52.2
+            ./bin/golangci-lint run
 
 # Invoke jobs via workflows
 # See: https://circleci.com/docs/2.0/configuration-reference/#workflows
 workflows:
-  build-lint-test:
+  version: 2
+  test:
     jobs:
       - test
+  lint:
+    jobs:
+      - lint

Makefile

@@ -9,3 +9,4 @@ test:
 mock-gen:
 	mkdir -p $(MOCKS_DIR)
 	$(MOCKGEN_CMD) -source=client/interface.go -package mocks -destination $(MOCKS_DIR)/client.go
+	$(MOCKGEN_CMD) -source=query/interface.go -package mocks -destination $(MOCKS_DIR)/query.go

client/client.go

@@ -1,25 +1,22 @@
 package client
 
 import (
-	"fmt"
-	"time"
+	lensclient "github.com/strangelove-ventures/lens/client"
 
 	"github.com/babylonchain/rpc-client/config"
-	lensclient "github.com/strangelove-ventures/lens/client"
+	"github.com/babylonchain/rpc-client/query"
 )
 
 var _ BabylonClient = &Client{}
 
 type Client struct {
 	*lensclient.ChainClient
-	cfg *config.BabylonConfig
+	*query.QueryClient
 
-	// retry attributes
-	retrySleepTime    time.Duration
-	maxRetrySleepTime time.Duration
+	cfg *config.BabylonConfig
 }
 
-func New(cfg *config.BabylonConfig, retrySleepTime, maxRetrySleepTime time.Duration) (*Client, error) {
+func New(cfg *config.BabylonConfig) (*Client, error) {
 	// ensure cfg is valid
 	if err := cfg.Validate(); err != nil {
 		return nil, err
@@ -31,8 +28,14 @@ func New(cfg *config.BabylonConfig, retrySleepTime, maxRetrySleepTime time.Durat
 		return nil, err
 	}
 
+	// create a queryClient so that the Client inherits all query functions
+	queryClient, err := query.NewWithClient(cc.RPCClient, cfg.Timeout)
+	if err != nil {
+		return nil, err
+	}
+
 	// wrap to our type
-	client := &Client{cc, cfg, retrySleepTime, maxRetrySleepTime}
+	client := &Client{cc, queryClient, cfg}
 
 	return client, nil
 }
@@ -41,15 +44,6 @@ func (c *Client) GetConfig() *config.BabylonConfig {
 	return c.cfg
 }
 
-func (c *Client) GetTagIdx() uint8 {
-	tagIdxStr := c.cfg.TagIdx
-	if len(tagIdxStr) != 1 {
-		panic(fmt.Errorf("tag index should be one byte"))
-	}
-	// convert tagIdx from string to its ascii value
-	return uint8(rune(tagIdxStr[0]))
-}
-
 func (c *Client) Stop() {
 	if c.ChainClient.RPCClient != nil && c.ChainClient.RPCClient.IsRunning() {
 		<-c.ChainClient.RPCClient.Quit()

client/interface.go

@@ -3,49 +3,20 @@ package client
 import (
 	btcctypes "github.com/babylonchain/babylon/x/btccheckpoint/types"
 	btclctypes "github.com/babylonchain/babylon/x/btclightclient/types"
-	checkpointingtypes "github.com/babylonchain/babylon/x/checkpointing/types"
-	epochingtypes "github.com/babylonchain/babylon/x/epoching/types"
-	"github.com/babylonchain/rpc-client/config"
-	"github.com/btcsuite/btcd/chaincfg/chainhash"
-	"github.com/btcsuite/btcd/wire"
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
+
+	"github.com/babylonchain/rpc-client/config"
+	bbnquery "github.com/babylonchain/rpc-client/query"
 )
 
 type BabylonClient interface {
-	Stop()
+	bbnquery.BabylonQueryClient
+
 	GetConfig() *config.BabylonConfig
-	GetTagIdx() uint8
 	GetAddr() (sdk.AccAddress, error)
 	MustGetAddr() sdk.AccAddress
+
 	InsertBTCSpvProof(msg *btcctypes.MsgInsertBTCSpvProof) (*sdk.TxResponse, error)
 	InsertHeader(msg *btclctypes.MsgInsertHeader) (*sdk.TxResponse, error)
 	InsertHeaders(msgs []*btclctypes.MsgInsertHeader) (*sdk.TxResponse, error)
-	MustInsertBTCSpvProof(msg *btcctypes.MsgInsertBTCSpvProof) *sdk.TxResponse
-
-	// staking module related queries
-	QueryStakingParams() (*stakingtypes.Params, error)
-
-	// epoch module related queries
-	QueryEpochingParams() (*epochingtypes.Params, error)
-	QueryCurrentEpoch() (uint64, error)
-
-	// btclightclient module related queries
-	QueryBTCLightclientParams() (*btclctypes.Params, error)
-	QueryHeaderChainTip() (*chainhash.Hash, uint64, error)
-	QueryBaseHeader() (*wire.BlockHeader, uint64, error)
-	QueryContainsBlock(blockHash *chainhash.Hash) (bool, error)
-
-	// btccheckpoint module related queries
-	QueryBTCCheckpointParams() (*btcctypes.Params, error)
-	MustQueryBTCCheckpointParams() *btcctypes.Params
-
-	// checkpointing module related queries
-	QueryRawCheckpoint(epochNumber uint64) (*checkpointingtypes.RawCheckpointWithMeta, error)
-	QueryRawCheckpointList(status checkpointingtypes.CheckpointStatus) ([]*checkpointingtypes.RawCheckpointWithMeta, error)
-	BlsPublicKeyList(epochNumber uint64) ([]*checkpointingtypes.ValidatorWithBlsKey, error)
-
-	// monitor module related queries
-	QueryEndedEpochBtcHeight(epochNum uint64) (uint64, error)
-	QueryReportedCheckpointBtcHeight(hash string) (uint64, error)
 }

client/keys_test.go

@@ -1,50 +1,48 @@
 package client_test
 
 import (
-	"math/rand"
-	"strings"
-	"testing"
-	"time"
-
 	bbn "github.com/babylonchain/babylon/app"
 	"github.com/babylonchain/babylon/testutil/datagen"
 	"github.com/babylonchain/rpc-client/client"
 	"github.com/babylonchain/rpc-client/config"
 	"github.com/cosmos/cosmos-sdk/crypto/hd"
 	"github.com/cosmos/cosmos-sdk/crypto/keyring"
 	"github.com/stretchr/testify/require"
+	"math/rand"
+	"strings"
+	"testing"
 )
 
 func FuzzKeys(f *testing.F) {
 	datagen.AddRandomSeedsToFuzzer(f, 10)
 
 	f.Fuzz(func(t *testing.T, seed int64) {
-		rand.Seed(seed)
+		r := rand.New(rand.NewSource(seed))
 
 		// create a keyring
-		keyringName := datagen.GenRandomHexStr(10)
+		keyringName := datagen.GenRandomHexStr(r, 10)
 		dir := t.TempDir()
 		mockIn := strings.NewReader("")
-		cdc := bbn.MakeTestEncodingConfig()
+		cdc := bbn.GetEncodingConfig()
 		kr, err := keyring.New(keyringName, "test", dir, mockIn, cdc.Marshaler)
 		require.NoError(t, err)
 
 		// create a random key pair in this keyring
-		keyName := datagen.GenRandomHexStr(10)
+		keyName := datagen.GenRandomHexStr(r, 10)
 		_, _, err = kr.NewMnemonic(
 			keyName,
 			keyring.English,
 			hd.CreateHDPath(118, 0, 0).String(),
 			keyring.DefaultBIP39Passphrase,
 			hd.Secp256k1,
 		)
-        require.NoError(t, err)
+		require.NoError(t, err)
 
 		// create a Babylon client with this random keyring
 		cfg := config.DefaultBabylonConfig()
 		cfg.KeyDirectory = dir
 		cfg.Key = keyName
-		cl, err := client.New(&cfg, 1*time.Minute, 5*time.Minute)
+		cl, err := client.New(&cfg)
 		require.NoError(t, err)
 
 		// retrieve the key info from key ring

client/modified_lensclient.go

@@ -21,7 +21,7 @@ func newLensClient(ccc *lensclient.ChainClientConfig, kro ...keyring.Option) (*l
 	cc := &lensclient.ChainClient{
 		KeyringOptions: keyringOptions,
 		Config:         ccc,
-		Codec:          lensclient.MakeCodec(ccc.Modules),
+		Codec:          lensclient.MakeCodec(ccc.Modules, []string{}),
 	}
 	if err := cc.Init(); err != nil {
 		return nil, err