Add e2e tests for gRPC requests and CLI commands (#13)

- Add E2E tests following pattern suggested in cosmos-sdk docs:
  https://docs.cosmos.network/v0.50/build/building-modules/testing#end-to-end-tests
  - Tests for gRPC requests
  - Tests for manually configured CLI commands
- Add a CI workflow to run these E2E tests

Reviewed-on: deep-stack/laconic2d#13
Co-authored-by: Prathamesh Musale <prathamesh.musale0@gmail.com>
Co-committed-by: Prathamesh Musale <prathamesh.musale0@gmail.com>

.gitea/workflows/test-e2e.yml

@@ -0,0 +1,19 @@
+name: E2E Tests
+on:
+  pull_request:
+  push:
+    branches:
+      - main
+
+jobs:
+  test-e2e:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/setup-go@v3
+        with:
+          go-version: 1.21
+          check-latest: true
+      - uses: actions/checkout@v3
+      - name: Test
+        run: |
+          make test-e2e

Makefile

@@ -88,3 +88,6 @@ lint-fix:
 
 test-integration:
 	$(MAKE) -C tests test-integration
+
+test-e2e:
+	$(MAKE) -C tests test-e2e

README.md

@@ -10,11 +10,15 @@ Install and run `laconic2d`:
   make init
 
   # start the chain
-  laconic2d start
+  laconic2d start --gql-playground --gql-server
   ```
 
 Run tests:
 
   ```bash
+  # integration tests
   make test-integration
+
+  # e2e tests
+  make test-e2e
   ```

api/cerc/bond/v1/genesis.pulsar.go

@@ -608,7 +608,6 @@ type GenesisState struct {
 	// params defines all the parameters of the module.
 	Params *Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params,omitempty"`
 	// bonds defines all the bonds
-	// TODO: Add nullable = false ?
 	Bonds []*Bond `protobuf:"bytes,2,rep,name=bonds,proto3" json:"bonds,omitempty"`
 }
 

proto/cerc/auction/v1/query.proto

@@ -123,8 +123,6 @@ message QueryAuctionsByBidderRequest {
 message QueryAuctionsByBidderResponse {
   // List of auctions
   Auctions auctions = 1;
-
-  // TODO: Add pagination?
 }
 
 // AuctionsByOwnerRequest is the format for querying all auctions created by an owner

proto/cerc/bond/v1/genesis.proto

@@ -13,6 +13,5 @@ message GenesisState {
   Params params = 1 [(gogoproto.nullable) = false];
 
   // bonds defines all the bonds
-  // TODO: Add nullable = false ?
   repeated Bond bonds = 2 [(gogoproto.moretags) = "json:\"bonds\" yaml:\"bonds\""];
 }

scripts/protocgen.sh

@@ -16,7 +16,6 @@ for dir in $proto_dirs; do
   done
 done
 
-# TODO: Check if required
 echo "Generating pulsar proto code"
 buf generate --template buf.gen.pulsar.yaml
 

tests/Makefile

@@ -1,2 +1,5 @@
 test-integration:
 	go test -mod=readonly ./integration/... -test.v -timeout 10m
+
+test-e2e:
+	go test ./e2e/... -mod=readonly -test.v -timeout 10m

tests/e2e/auction/cli_test.go

@@ -0,0 +1,17 @@
+package auction
+
+import (
+	"testing"
+
+	"github.com/cosmos/cosmos-sdk/testutil/network"
+	"github.com/stretchr/testify/suite"
+
+	"git.vdb.to/cerc-io/laconic2d/tests/e2e"
+)
+
+func TestAuctionE2ETestSuite(t *testing.T) {
+	cfg := network.DefaultConfig(e2e.NewTestNetworkFixture)
+	cfg.NumValidators = 1
+
+	suite.Run(t, NewE2ETestSuite(cfg))
+}

tests/e2e/auction/grpc.go

@@ -0,0 +1,263 @@
+package auction
+
+import (
+	"fmt"
+
+	"github.com/cosmos/cosmos-sdk/testutil"
+
+	auctiontypes "git.vdb.to/cerc-io/laconic2d/x/auction"
+)
+
+const (
+	randomAuctionId     = "randomAuctionId"
+	randomBidderAddress = "randomBidderAddress"
+	randomOwnerAddress  = "randomOwnerAddress"
+)
+
+func (ets *E2ETestSuite) TestQueryParamsGrpc() {
+	val := ets.network.Validators[0]
+	sr := ets.Require()
+	reqURL := fmt.Sprintf("%s/cerc/auction/v1/params", val.APIAddress)
+
+	ets.Run("valid request to get auction params", func() {
+		resp, err := testutil.GetRequest(reqURL)
+		ets.Require().NoError(err)
+
+		var params auctiontypes.QueryParamsResponse
+		err = val.ClientCtx.Codec.UnmarshalJSON(resp, &params)
+
+		sr.NoError(err)
+		sr.Equal(*params.GetParams(), auctiontypes.DefaultParams())
+	})
+}
+
+func (ets *E2ETestSuite) TestGetAllAuctionsGrpc() {
+	val := ets.network.Validators[0]
+	sr := ets.Require()
+	reqURL := fmt.Sprintf("%s/cerc/auction/v1/auctions", val.APIAddress)
+
+	testCases := []struct {
+		msg             string
+		url             string
+		errorMsg        string
+		isErrorExpected bool
+	}{
+		{
+			"invalid request to get all auctions",
+			reqURL + randomAuctionId,
+			"",
+			true,
+		},
+		{
+			"valid request to get all auctions",
+			reqURL,
+			"",
+			false,
+		},
+	}
+	for _, tc := range testCases {
+		ets.Run(tc.msg, func() {
+			resp, err := testutil.GetRequest(tc.url)
+			if tc.isErrorExpected {
+				sr.Contains(string(resp), tc.errorMsg)
+			} else {
+				sr.NoError(err)
+				var auctions auctiontypes.QueryAuctionsResponse
+				err = val.ClientCtx.Codec.UnmarshalJSON(resp, &auctions)
+				sr.NoError(err)
+				sr.NotZero(len(auctions.Auctions.Auctions))
+			}
+		})
+	}
+}
+
+func (ets *E2ETestSuite) TestGetAuctionGrpc() {
+	val := ets.network.Validators[0]
+	sr := ets.Require()
+	reqURL := fmt.Sprintf("%s/cerc/auction/v1/auctions/", val.APIAddress)
+
+	testCases := []struct {
+		msg             string
+		url             string
+		errorMsg        string
+		isErrorExpected bool
+		preRun          func() string
+	}{
+		{
+			"invalid request to get an auction",
+			reqURL + randomAuctionId,
+			"",
+			true,
+			func() string { return "" },
+		},
+		{
+			"valid request to get an auction",
+			reqURL,
+			"",
+			false,
+			func() string { return ets.defaultAuctionId },
+		},
+	}
+	for _, tc := range testCases {
+		ets.Run(tc.msg, func() {
+			auctionId := tc.preRun()
+			resp, err := testutil.GetRequest(tc.url + auctionId)
+			if tc.isErrorExpected {
+				sr.Contains(string(resp), tc.errorMsg)
+			} else {
+				sr.NoError(err)
+				var auction auctiontypes.QueryAuctionResponse
+				err = val.ClientCtx.Codec.UnmarshalJSON(resp, &auction)
+				sr.NoError(err)
+				sr.Equal(auctionId, auction.Auction.Id)
+			}
+		})
+	}
+}
+
+func (ets *E2ETestSuite) TestGetBidsGrpc() {
+	val := ets.network.Validators[0]
+	sr := ets.Require()
+	reqURL := fmt.Sprintf("%s/cerc/auction/v1/bids/", val.APIAddress)
+	testCases := []struct {
+		msg             string
+		url             string
+		errorMsg        string
+		isErrorExpected bool
+		preRun          func() string
+	}{
+		{
+			"invalid request to get all bids",
+			reqURL,
+			"",
+			true,
+			func() string { return "" },
+		},
+		{
+			"valid request to get all bids",
+			reqURL,
+			"",
+			false,
+			func() string { return ets.createAuctionAndBid(false, true) },
+		},
+	}
+
+	for _, tc := range testCases {
+		ets.Run(tc.msg, func() {
+			auctionId := tc.preRun()
+			tc.url += auctionId
+			resp, err := testutil.GetRequest(tc.url)
+			if tc.isErrorExpected {
+				sr.Contains(string(resp), tc.errorMsg)
+			} else {
+				sr.NoError(err)
+				var bids auctiontypes.QueryBidsResponse
+				err = val.ClientCtx.Codec.UnmarshalJSON(resp, &bids)
+				sr.NoError(err)
+				sr.Equal(auctionId, bids.Bids[0].AuctionId)
+			}
+		})
+	}
+}
+
+func (ets *E2ETestSuite) TestGetBidGrpc() {
+	val := ets.network.Validators[0]
+	sr := ets.Require()
+	reqURL := fmt.Sprintf("%s/cerc/auction/v1/bids/", val.APIAddress)
+	testCases := []struct {
+		msg             string
+		url             string
+		errorMsg        string
+		isErrorExpected bool
+		preRun          func() string
+	}{
+		{
+			"invalid request to get bid",
+			reqURL,
+			"",
+			true,
+			func() string { return randomAuctionId },
+		},
+		{
+			"valid request to get bid",
+			reqURL,
+			"",
+			false,
+			func() string { return ets.createAuctionAndBid(false, true) },
+		},
+	}
+	for _, tc := range testCases {
+		ets.Run(tc.msg, func() {
+			auctionId := tc.preRun()
+			tc.url += auctionId + "/" + bidderAddress
+			resp, err := testutil.GetRequest(tc.url)
+
+			if tc.isErrorExpected {
+				sr.Contains(string(resp), tc.errorMsg)
+			} else {
+				sr.NoError(err)
+				var bid auctiontypes.QueryBidResponse
+				err = val.ClientCtx.Codec.UnmarshalJSON(resp, &bid)
+				sr.NoError(err)
+			}
+		})
+	}
+}
+
+func (ets *E2ETestSuite) TestGetAuctionsByOwnerGrpc() {
+	val := ets.network.Validators[0]
+	sr := ets.Require()
+	reqURL := fmt.Sprintf("%s/cerc/auction/v1/by-owner/", val.APIAddress)
+	testCases := []struct {
+		msg             string
+		url             string
+		errorMsg        string
+		isErrorExpected bool
+	}{
+		{
+			"invalid request to get auctions by owner",
+			reqURL,
+			"",
+			true,
+		},
+		{
+			"valid request to get auctions by owner",
+			fmt.Sprintf("%s/%s", reqURL, ownerAddress),
+			"",
+			false,
+		},
+	}
+	for _, tc := range testCases {
+		ets.Run(tc.msg, func() {
+			resp, err := testutil.GetRequest(tc.url)
+			if tc.isErrorExpected {
+				sr.Contains(string(resp), tc.errorMsg)
+			} else {
+				sr.NoError(err)
+				var auctions auctiontypes.QueryAuctionsResponse
+				err = val.ClientCtx.Codec.UnmarshalJSON(resp, &auctions)
+				sr.NoError(err)
+			}
+		})
+	}
+}
+
+func (ets *E2ETestSuite) TestQueryBalanceGrpc() {
+	val := ets.network.Validators[0]
+	sr := ets.Require()
+	reqURL := fmt.Sprintf("%s/cerc/auction/v1/balance", val.APIAddress)
+	msg := "valid request to get the auction module balance"
+
+	ets.createAuctionAndBid(false, true)
+
+	ets.Run(msg, func() {
+		resp, err := testutil.GetRequest(reqURL)
+		sr.NoError(err)
+
+		var response auctiontypes.QueryGetAuctionModuleBalanceResponse
+		err = val.ClientCtx.Codec.UnmarshalJSON(resp, &response)
+
+		sr.NoError(err)
+		sr.NotZero(len(response.GetBalance()))
+	})
+}

tests/e2e/auction/query.go

@@ -0,0 +1,45 @@
+package auction
+
+import (
+	"fmt"
+
+	"github.com/cosmos/cosmos-sdk/client/flags"
+	clitestutil "github.com/cosmos/cosmos-sdk/testutil/cli"
+
+	types "git.vdb.to/cerc-io/laconic2d/x/auction"
+	"git.vdb.to/cerc-io/laconic2d/x/auction/client/cli"
+)
+
+var queryJSONFlag = []string{fmt.Sprintf("--%s=json", flags.FlagOutput)}
+
+func (ets *E2ETestSuite) TestGetCmdList() {
+	val := ets.network.Validators[0]
+	sr := ets.Require()
+
+	testCases := []struct {
+		msg           string
+		createAuction bool
+	}{
+		{
+			"list auctions when no auctions exist",
+			false,
+		},
+		{
+			"list auctions after creating an auction",
+			true,
+		},
+	}
+
+	for _, test := range testCases {
+		ets.Run(fmt.Sprintf("Case %s", test.msg), func() {
+			out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cli.GetCmdList(), queryJSONFlag)
+			sr.NoError(err)
+			var auctions types.QueryAuctionsResponse
+			err = val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &auctions)
+			sr.NoError(err)
+			if test.createAuction {
+				sr.NotZero(len(auctions.Auctions.Auctions))
+			}
+		})
+	}
+}

tests/e2e/auction/suite.go

@@ -0,0 +1,148 @@
+package auction
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"cosmossdk.io/math"
+	"github.com/stretchr/testify/suite"
+
+	"github.com/cosmos/cosmos-sdk/client/flags"
+	addresscodec "github.com/cosmos/cosmos-sdk/codec/address"
+	"github.com/cosmos/cosmos-sdk/crypto/hd"
+	"github.com/cosmos/cosmos-sdk/crypto/keyring"
+	clitestutil "github.com/cosmos/cosmos-sdk/testutil/cli"
+	"github.com/cosmos/cosmos-sdk/testutil/network"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+
+	types "git.vdb.to/cerc-io/laconic2d/x/auction"
+	"git.vdb.to/cerc-io/laconic2d/x/auction/client/cli"
+)
+
+var (
+	ownerAccount  = "owner"
+	bidderAccount = "bidder"
+	ownerAddress  string
+	bidderAddress string
+)
+
+type E2ETestSuite struct {
+	suite.Suite
+
+	cfg     network.Config
+	network *network.Network
+
+	defaultAuctionId string
+}
+
+func NewE2ETestSuite(cfg network.Config) *E2ETestSuite {
+	return &E2ETestSuite{cfg: cfg}
+}
+
+func (ets *E2ETestSuite) SetupSuite() { //nolint: all
+	sr := ets.Require()
+	ets.T().Log("setting up e2e test suite")
+
+	var err error
+
+	ets.network, err = network.New(ets.T(), ets.T().TempDir(), ets.cfg)
+	sr.NoError(err)
+
+	_, err = ets.network.WaitForHeight(1)
+	sr.NoError(err)
+
+	// setting up random owner and bidder accounts
+	ets.createAccountWithBalance(ownerAccount, &ownerAddress)
+	ets.createAccountWithBalance(bidderAccount, &bidderAddress)
+
+	ets.defaultAuctionId = ets.createAuctionAndBid(true, false)
+}
+
+func (ets *E2ETestSuite) TearDownSuite() {
+	ets.T().Log("tearing down integration test suite")
+	ets.network.Cleanup()
+
+	ets.cleanupBidFiles()
+}
+
+func (ets *E2ETestSuite) createAccountWithBalance(accountName string, accountAddress *string) {
+	val := ets.network.Validators[0]
+	sr := ets.Require()
+
+	info, _, err := val.ClientCtx.Keyring.NewMnemonic(accountName, keyring.English, sdk.FullFundraiserPath, keyring.DefaultBIP39Passphrase, hd.Secp256k1)
+	sr.NoError(err)
+
+	newAddr, _ := info.GetAddress()
+	_, err = clitestutil.MsgSendExec(
+		val.ClientCtx,
+		val.Address,
+		newAddr,
+		sdk.NewCoins(sdk.NewCoin(ets.cfg.BondDenom, math.NewInt(200000))),
+		addresscodec.NewBech32Codec("laconic"),
+		fmt.Sprintf("--%s=%s", flags.FlagFrom, accountName),
+		fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
+		fmt.Sprintf("--%s=json", flags.FlagOutput),
+		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastSync),
+		fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(ets.cfg.BondDenom, math.NewInt(10))).String()),
+	)
+	sr.NoError(err)
+	*accountAddress = newAddr.String()
+
+	// wait for tx to take effect
+	err = ets.network.WaitForNextBlock()
+	sr.NoError(err)
+}
+
+func (ets *E2ETestSuite) createAuctionAndBid(createAuction, createBid bool) string {
+	val := ets.network.Validators[0]
+	sr := ets.Require()
+	auctionId := ""
+
+	if createAuction {
+		auctionArgs := []string{
+			sampleCommitTime, sampleRevealTime,
+			fmt.Sprintf("10%s", ets.cfg.BondDenom),
+			fmt.Sprintf("10%s", ets.cfg.BondDenom),
+			fmt.Sprintf("100%s", ets.cfg.BondDenom),
+		}
+
+		resp, err := ets.executeTx(cli.GetCmdCreateAuction(), auctionArgs, ownerAccount)
+		sr.NoError(err)
+		sr.Zero(resp.Code)
+		out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cli.GetCmdList(), queryJSONFlag)
+		sr.NoError(err)
+		var queryResponse types.QueryAuctionsResponse
+		err = val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &queryResponse)
+		sr.NoError(err)
+		auctionId = queryResponse.Auctions.Auctions[0].Id
+	} else {
+		auctionId = ets.defaultAuctionId
+	}
+
+	if createBid {
+		bidArgs := []string{auctionId, fmt.Sprintf("200%s", ets.cfg.BondDenom)}
+		resp, err := ets.executeTx(cli.GetCmdCommitBid(), bidArgs, bidderAccount)
+		sr.NoError(err)
+		sr.Zero(resp.Code)
+	}
+
+	return auctionId
+}
+
+func (ets *E2ETestSuite) cleanupBidFiles() error {
+	matches, err := filepath.Glob(fmt.Sprintf("%s-*.json", bidderAccount))
+	if err != nil {
+		ets.T().Errorf("Error matching bidder files: %v\n", err)
+		return err
+	}
+
+	for _, match := range matches {
+		err := os.Remove(match)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}

tests/e2e/auction/tx.go

@@ -0,0 +1,105 @@
+package auction
+
+import (
+	"fmt"
+
+	"github.com/cosmos/cosmos-sdk/client/flags"
+	clitestutil "github.com/cosmos/cosmos-sdk/testutil/cli"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/spf13/cobra"
+
+	auctiontypes "git.vdb.to/cerc-io/laconic2d/x/auction"
+	"git.vdb.to/cerc-io/laconic2d/x/auction/client/cli"
+)
+
+const (
+	sampleCommitTime     = "90s"
+	sampleRevealTime     = "5s"
+	placeholderAuctionId = "placeholder_auction_id"
+)
+
+func (ets *E2ETestSuite) TestTxCommitBid() {
+	val := ets.network.Validators[0]
+	sr := ets.Require()
+	testCases := []struct {
+		msg           string
+		args          []string
+		createAuction bool
+	}{
+		{
+			"commit bid with missing args",
+			[]string{fmt.Sprintf("200%s", ets.cfg.BondDenom)},
+			false,
+		},
+		{
+			"commit bid with valid args",
+			[]string{
+				placeholderAuctionId,
+				fmt.Sprintf("200%s", ets.cfg.BondDenom),
+			},
+			true,
+		},
+	}
+
+	for _, test := range testCases {
+		ets.Run(fmt.Sprintf("Case %s", test.msg), func() {
+			if test.createAuction {
+				auctionArgs := []string{
+					sampleCommitTime, sampleRevealTime,
+					fmt.Sprintf("10%s", ets.cfg.BondDenom),
+					fmt.Sprintf("10%s", ets.cfg.BondDenom),
+					fmt.Sprintf("100%s", ets.cfg.BondDenom),
+				}
+
+				_, err := ets.executeTx(cli.GetCmdCreateAuction(), auctionArgs, ownerAccount)
+				sr.NoError(err)
+
+				out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cli.GetCmdList(),
+					[]string{fmt.Sprintf("--%s=json", flags.FlagOutput)})
+				sr.NoError(err)
+				var queryResponse auctiontypes.QueryAuctionsResponse
+				err = val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &queryResponse)
+				sr.NoError(err)
+				sr.NotNil(queryResponse.GetAuctions())
+				test.args[0] = queryResponse.GetAuctions().Auctions[0].Id
+			}
+
+			resp, err := ets.executeTx(cli.GetCmdCommitBid(), test.args, bidderAccount)
+			if test.createAuction {
+				sr.NoError(err)
+				sr.Zero(resp.Code)
+			} else {
+				sr.Error(err)
+			}
+		})
+	}
+}
+
+func (ets *E2ETestSuite) executeTx(cmd *cobra.Command, args []string, caller string) (sdk.TxResponse, error) {
+	val := ets.network.Validators[0]
+	additionalArgs := []string{
+		fmt.Sprintf("--%s=%s", flags.FlagFrom, caller),
+		fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
+		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastSync),
+		fmt.Sprintf("--%s=%s", flags.FlagFees, fmt.Sprintf("3%s", ets.cfg.BondDenom)),
+	}
+	args = append(args, additionalArgs...)
+
+	out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cmd, args)
+	if err != nil {
+		return sdk.TxResponse{}, err
+	}
+
+	var resp sdk.TxResponse
+	err = val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &resp)
+	if err != nil {
+		return sdk.TxResponse{}, err
+	}
+
+	err = ets.network.WaitForNextBlock()
+	if err != nil {
+		return sdk.TxResponse{}, err
+	}
+
+	return resp, nil
+}

tests/e2e/bond/cli_test.go

@@ -0,0 +1,17 @@
+package bond
+
+import (
+	"testing"
+
+	"github.com/cosmos/cosmos-sdk/testutil/network"
+	"github.com/stretchr/testify/suite"
+
+	"git.vdb.to/cerc-io/laconic2d/tests/e2e"
+)
+
+func TestBondE2ETestSuite(t *testing.T) {
+	cfg := network.DefaultConfig(e2e.NewTestNetworkFixture)
+	cfg.NumValidators = 1
+
+	suite.Run(t, NewE2ETestSuite(cfg))
+}

tests/e2e/bond/grpc.go

@@ -0,0 +1,183 @@
+package bond
+
+import (
+	"fmt"
+
+	"github.com/cosmos/cosmos-sdk/testutil"
+
+	bondtypes "git.vdb.to/cerc-io/laconic2d/x/bond"
+)
+
+func (ets *E2ETestSuite) TestGRPCGetParams() {
+	val := ets.network.Validators[0]
+	sr := ets.Require()
+	reqURL := fmt.Sprintf("%s/cerc/bond/v1/params", val.APIAddress)
+
+	resp, err := testutil.GetRequest(reqURL)
+	ets.Require().NoError(err)
+
+	var params bondtypes.QueryParamsResponse
+	err = val.ClientCtx.Codec.UnmarshalJSON(resp, &params)
+
+	sr.NoError(err)
+	sr.Equal(params.GetParams().MaxBondAmount, bondtypes.DefaultParams().MaxBondAmount)
+}
+
+func (ets *E2ETestSuite) TestGRPCGetBonds() {
+	val := ets.network.Validators[0]
+	sr := ets.Require()
+	reqURL := fmt.Sprintf("%s/cerc/bond/v1/bonds", val.APIAddress)
+
+	testCases := []struct {
+		name     string
+		url      string
+		expErr   bool
+		errorMsg string
+		preRun   func() string
+	}{
+		{
+			"invalid request with headers",
+			reqURL + "asdasdas",
+			true,
+			"",
+			func() string { return "" },
+		},
+		{
+			"valid request",
+			reqURL,
+			false,
+			"",
+			func() string { return ets.createBond() },
+		},
+	}
+	for _, tc := range testCases {
+		ets.Run(tc.name, func() {
+			tc.preRun()
+
+			resp, _ := testutil.GetRequest(tc.url)
+			if tc.expErr {
+				sr.Contains(string(resp), tc.errorMsg)
+			} else {
+				var response bondtypes.QueryGetBondsResponse
+				err := val.ClientCtx.Codec.UnmarshalJSON(resp, &response)
+				sr.NoError(err)
+				sr.NotZero(len(response.GetBonds()))
+			}
+		})
+	}
+}
+
+func (ets *E2ETestSuite) TestGRPCGetBondsByOwner() {
+	val := ets.network.Validators[0]
+	sr := ets.Require()
+	reqURL := val.APIAddress + "/cerc/bond/v1/by-owner/%s"
+
+	testCases := []struct {
+		name   string
+		url    string
+		expErr bool
+		preRun func() string
+	}{
+		{
+			"empty list",
+			fmt.Sprintf(reqURL, "asdasd"),
+			true,
+			func() string { return "" },
+		},
+		{
+			"valid request",
+			fmt.Sprintf(reqURL, ets.accountAddress),
+			false,
+			func() string { return ets.createBond() },
+		},
+	}
+
+	for _, tc := range testCases {
+		ets.Run(tc.name, func() {
+			tc.preRun()
+
+			resp, err := testutil.GetRequest(tc.url)
+			ets.Require().NoError(err)
+
+			var bonds bondtypes.QueryGetBondsByOwnerResponse
+			err = val.ClientCtx.Codec.UnmarshalJSON(resp, &bonds)
+			sr.NoError(err)
+			if tc.expErr {
+				sr.Empty(bonds.GetBonds())
+			} else {
+				bondsList := bonds.GetBonds()
+				sr.NotZero(len(bondsList))
+				sr.Equal(ets.accountAddress, bondsList[0].GetOwner())
+			}
+		})
+	}
+}
+
+func (ets *E2ETestSuite) TestGRPCGetBondById() {
+	val := ets.network.Validators[0]
+	sr := ets.Require()
+	reqURL := val.APIAddress + "/cerc/bond/v1/bonds/%s"
+
+	testCases := []struct {
+		name   string
+		url    string
+		expErr bool
+		preRun func() string
+	}{
+		{
+			"invalid request",
+			fmt.Sprintf(reqURL, "asdadad"),
+			true,
+			func() string { return "" },
+		},
+		{
+			"valid request",
+			reqURL,
+			false,
+			func() string { return ets.createBond() },
+		},
+	}
+	for _, tc := range testCases {
+		ets.Run(tc.name, func() {
+			var bondId string
+			if !tc.expErr {
+				bondId = tc.preRun()
+				tc.url = fmt.Sprintf(reqURL, bondId)
+			}
+
+			resp, err := testutil.GetRequest(tc.url)
+			ets.Require().NoError(err)
+
+			var bonds bondtypes.QueryGetBondByIdResponse
+			err = val.ClientCtx.Codec.UnmarshalJSON(resp, &bonds)
+
+			if tc.expErr {
+				sr.Empty(bonds.GetBond().GetId())
+			} else {
+				sr.NoError(err)
+				sr.NotZero(bonds.GetBond().GetId())
+				sr.Equal(bonds.GetBond().GetId(), bondId)
+			}
+		})
+	}
+}
+
+func (ets *E2ETestSuite) TestGRPCGetBondModuleBalance() {
+	val := ets.network.Validators[0]
+	sr := ets.Require()
+	reqURL := fmt.Sprintf("%s/cerc/bond/v1/balance", val.APIAddress)
+
+	// creating the bond
+	ets.createBond()
+
+	ets.Run("valid request", func() {
+		resp, err := testutil.GetRequest(reqURL)
+		sr.NoError(err)
+
+		var response bondtypes.QueryGetBondModuleBalanceResponse
+		err = val.ClientCtx.Codec.UnmarshalJSON(resp, &response)
+
+		sr.NoError(err)
+		sr.False(response.GetBalance().IsZero())
+	})
+}

tests/e2e/bond/query.go

@@ -0,0 +1,49 @@
+package bond
+
+import (
+	"fmt"
+
+	"github.com/cosmos/cosmos-sdk/client/flags"
+	clitestutil "github.com/cosmos/cosmos-sdk/testutil/cli"
+
+	bondtypes "git.vdb.to/cerc-io/laconic2d/x/bond"
+	"git.vdb.to/cerc-io/laconic2d/x/bond/client/cli"
+)
+
+func (ets *E2ETestSuite) TestGetQueryBondList() {
+	val := ets.network.Validators[0]
+	sr := ets.Require()
+
+	testCases := []struct {
+		name       string
+		args       []string
+		createBond bool
+		preRun     func()
+	}{
+		{
+			"create and get bond lists",
+			[]string{fmt.Sprintf("--%s=json", flags.FlagOutput)},
+			true,
+			func() {
+				ets.createBond()
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		ets.Run(fmt.Sprintf("Case %s", tc.name), func() {
+			clientCtx := val.ClientCtx
+			if tc.createBond {
+				tc.preRun()
+			}
+
+			cmd := cli.GetQueryBondList()
+			out, err := clitestutil.ExecTestCLICmd(clientCtx, cmd, tc.args)
+			sr.NoError(err)
+			var queryResponse bondtypes.QueryGetBondsResponse
+			err = clientCtx.Codec.UnmarshalJSON(out.Bytes(), &queryResponse)
+			sr.NoError(err)
+			sr.NotZero(len(queryResponse.GetBonds()))
+		})
+	}
+}

tests/e2e/bond/suite.go

@@ -0,0 +1,123 @@
+package bond
+
+import (
+	"fmt"
+
+	"cosmossdk.io/math"
+	"github.com/stretchr/testify/suite"
+
+	"github.com/cosmos/cosmos-sdk/client/flags"
+	addresscodec "github.com/cosmos/cosmos-sdk/codec/address"
+	"github.com/cosmos/cosmos-sdk/crypto/hd"
+	"github.com/cosmos/cosmos-sdk/crypto/keyring"
+	clitestutil "github.com/cosmos/cosmos-sdk/testutil/cli"
+	"github.com/cosmos/cosmos-sdk/testutil/network"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+
+	bondtypes "git.vdb.to/cerc-io/laconic2d/x/bond"
+	"git.vdb.to/cerc-io/laconic2d/x/bond/client/cli"
+)
+
+type E2ETestSuite struct {
+	suite.Suite
+
+	cfg     network.Config
+	network *network.Network
+
+	accountName    string
+	accountAddress string
+}
+
+func NewE2ETestSuite(cfg network.Config) *E2ETestSuite {
+	return &E2ETestSuite{cfg: cfg}
+}
+
+func (ets *E2ETestSuite) SetupSuite() { //nolint: all
+	sr := ets.Require()
+	ets.T().Log("setting up e2e test suite")
+
+	var err error
+
+	ets.network, err = network.New(ets.T(), ets.T().TempDir(), ets.cfg)
+	sr.NoError(err)
+
+	_, err = ets.network.WaitForHeight(1)
+	sr.NoError(err)
+
+	// setting up random account
+	ets.accountName = "accountName"
+	ets.createAccountWithBalance(ets.accountName, &ets.accountAddress)
+}
+
+func (ets *E2ETestSuite) TearDownSuite() {
+	ets.T().Log("tearing down e2e test suite")
+	ets.network.Cleanup()
+}
+
+func (ets *E2ETestSuite) createAccountWithBalance(accountName string, accountAddress *string) {
+	val := ets.network.Validators[0]
+	sr := ets.Require()
+
+	info, _, err := val.ClientCtx.Keyring.NewMnemonic(accountName, keyring.English, sdk.FullFundraiserPath, keyring.DefaultBIP39Passphrase, hd.Secp256k1)
+	sr.NoError(err)
+
+	newAddr, _ := info.GetAddress()
+	_, err = clitestutil.MsgSendExec(
+		val.ClientCtx,
+		val.Address,
+		newAddr,
+		sdk.NewCoins(sdk.NewCoin(ets.cfg.BondDenom, math.NewInt(200000))),
+		addresscodec.NewBech32Codec("laconic"),
+		fmt.Sprintf("--%s=%s", flags.FlagFrom, accountName),
+		fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
+		fmt.Sprintf("--%s=json", flags.FlagOutput),
+		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastSync),
+		fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(ets.cfg.BondDenom, math.NewInt(10))).String()),
+	)
+	sr.NoError(err)
+	*accountAddress = newAddr.String()
+
+	// wait for tx to take effect
+	err = ets.network.WaitForNextBlock()
+	sr.NoError(err)
+}
+
+func (ets *E2ETestSuite) createBond() string {
+	val := ets.network.Validators[0]
+	sr := ets.Require()
+	createBondCmd := cli.NewCreateBondCmd()
+	args := []string{
+		fmt.Sprintf("10%s", ets.cfg.BondDenom),
+		fmt.Sprintf("--%s=%s", flags.FlagFrom, ets.accountName),
+		fmt.Sprintf("--%s=json", flags.FlagOutput),
+		fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
+		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastSync),
+		fmt.Sprintf("--%s=%s", flags.FlagFees, fmt.Sprintf("3%s", ets.cfg.BondDenom)),
+	}
+	out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, createBondCmd, args)
+	sr.NoError(err)
+	var d sdk.TxResponse
+	err = val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &d)
+	sr.NoError(err)
+	sr.Zero(d.Code)
+
+	// wait for tx to take effect
+	err = ets.network.WaitForNextBlock()
+	sr.NoError(err)
+
+	// getting the bonds list and returning the bond-id
+	clientCtx := val.ClientCtx
+	cmd := cli.GetQueryBondList()
+	args = []string{
+		fmt.Sprintf("--%s=json", flags.FlagOutput),
+	}
+	out, err = clitestutil.ExecTestCLICmd(clientCtx, cmd, args)
+	sr.NoError(err)
+	var queryResponse bondtypes.QueryGetBondsResponse
+	err = val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &queryResponse)
+	sr.NoError(err)
+
+	// extract bond id from bonds list
+	bond := queryResponse.GetBonds()[0]
+	return bond.GetId()
+}

tests/e2e/bond/tx.go

@@ -0,0 +1,63 @@
+package bond
+
+import (
+	"fmt"
+
+	"github.com/cosmos/cosmos-sdk/client/flags"
+	clitestutil "github.com/cosmos/cosmos-sdk/testutil/cli"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+
+	"git.vdb.to/cerc-io/laconic2d/x/bond/client/cli"
+)
+
+func (ets *E2ETestSuite) TestTxCreateBond() {
+	val := ets.network.Validators[0]
+	sr := ets.Require()
+
+	testCases := []struct {
+		name string
+		args []string
+		err  bool
+	}{
+		{
+			"without deposit",
+			[]string{
+				fmt.Sprintf("--%s=%s", flags.FlagFrom, ets.accountName),
+				fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastSync),
+				fmt.Sprintf("--%s=%s", flags.FlagFees, fmt.Sprintf("3%s", ets.cfg.BondDenom)),
+			},
+			true,
+		},
+		{
+			"create bond",
+			[]string{
+				fmt.Sprintf("10%s", ets.cfg.BondDenom),
+				fmt.Sprintf("--%s=%s", flags.FlagFrom, ets.accountName),
+				fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
+				fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastSync),
+				fmt.Sprintf("--%s=json", flags.FlagOutput),
+				fmt.Sprintf("--%s=%s", flags.FlagFees, fmt.Sprintf("3%s", ets.cfg.BondDenom)),
+			},
+			false,
+		},
+	}
+
+	for _, tc := range testCases {
+		ets.Run(fmt.Sprintf("Case %s", tc.name), func() {
+			clientCtx := val.ClientCtx
+			cmd := cli.NewCreateBondCmd()
+
+			out, err := clitestutil.ExecTestCLICmd(clientCtx, cmd, tc.args)
+			if tc.err {
+				sr.Error(err)
+			} else {
+				sr.NoError(err)
+				var d sdk.TxResponse
+				err = val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &d)
+				sr.Nil(err)
+				sr.NoError(err)
+				sr.Zero(d.Code)
+			}
+		})
+	}
+}

tests/e2e/common.go

@@ -0,0 +1,67 @@
+package e2e
+
+import (
+	"fmt"
+	"os"
+
+	"cosmossdk.io/log"
+	pruningtypes "cosmossdk.io/store/pruning/types"
+
+	dbm "github.com/cosmos/cosmos-db"
+	bam "github.com/cosmos/cosmos-sdk/baseapp"
+	"github.com/cosmos/cosmos-sdk/client/flags"
+	servertypes "github.com/cosmos/cosmos-sdk/server/types"
+	"github.com/cosmos/cosmos-sdk/testutil/network"
+	simtestutil "github.com/cosmos/cosmos-sdk/testutil/sims"
+	"github.com/cosmos/cosmos-sdk/types/module/testutil"
+	"github.com/cosmos/cosmos-sdk/x/auth"
+	"github.com/cosmos/cosmos-sdk/x/staking"
+
+	laconicApp "git.vdb.to/cerc-io/laconic2d/app"
+	auctionmodule "git.vdb.to/cerc-io/laconic2d/x/auction/module"
+	bondmodule "git.vdb.to/cerc-io/laconic2d/x/bond/module"
+	registrymodule "git.vdb.to/cerc-io/laconic2d/x/registry/module"
+
+	_ "git.vdb.to/cerc-io/laconic2d/app/params" // import for side-effects (see init)
+)
+
+// NewTestNetworkFixture returns a new LaconicApp AppConstructor for network simulation tests
+func NewTestNetworkFixture() network.TestFixture {
+	dir, err := os.MkdirTemp("", "laconic")
+	if err != nil {
+		panic(fmt.Sprintf("failed creating temporary directory: %v", err))
+	}
+	defer os.RemoveAll(dir)
+
+	app, err := laconicApp.NewLaconicApp(log.NewNopLogger(), dbm.NewMemDB(), nil, true, simtestutil.NewAppOptionsWithFlagHome(dir))
+	if err != nil {
+		panic(fmt.Sprintf("failed to create laconic app: %v", err))
+	}
+
+	appCtr := func(val network.ValidatorI) servertypes.Application {
+		app, err := laconicApp.NewLaconicApp(
+			val.GetCtx().Logger, dbm.NewMemDB(), nil, true,
+			simtestutil.NewAppOptionsWithFlagHome(val.GetCtx().Config.RootDir),
+			bam.SetPruning(pruningtypes.NewPruningOptionsFromString(val.GetAppConfig().Pruning)),
+			bam.SetMinGasPrices(val.GetAppConfig().MinGasPrices),
+			bam.SetChainID(val.GetCtx().Viper.GetString(flags.FlagChainID)),
+		)
+		if err != nil {
+			panic(fmt.Sprintf("failed creating temporary directory: %v", err))
+		}
+
+		return app
+	}
+
+	return network.TestFixture{
+		AppConstructor: appCtr,
+		GenesisState:   app.DefaultGenesis(),
+		EncodingConfig: testutil.MakeTestEncodingConfig(
+			auth.AppModuleBasic{},
+			staking.AppModuleBasic{},
+			auctionmodule.AppModule{},
+			bondmodule.AppModule{},
+			registrymodule.AppModule{},
+		),
+	}
+}

tests/e2e/registry/cli_test.go

@@ -0,0 +1,17 @@
+package registry
+
+import (
+	"testing"
+
+	"github.com/cosmos/cosmos-sdk/testutil/network"
+	"github.com/stretchr/testify/suite"
+
+	"git.vdb.to/cerc-io/laconic2d/tests/e2e"
+)
+
+func TestRegistryE2ETestSuite(t *testing.T) {
+	cfg := network.DefaultConfig(e2e.NewTestNetworkFixture)
+	cfg.NumValidators = 1
+
+	suite.Run(t, NewE2ETestSuite(cfg))
+}

tests/e2e/registry/grpc.go

@@ -0,0 +1,429 @@
+package registry
+
+import (
+	"encoding/json"
+	"fmt"
+
+	"github.com/cosmos/cosmos-sdk/client/flags"
+	"github.com/cosmos/cosmos-sdk/testutil"
+	clitestutil "github.com/cosmos/cosmos-sdk/testutil/cli"
+
+	registrytypes "git.vdb.to/cerc-io/laconic2d/x/registry"
+	"git.vdb.to/cerc-io/laconic2d/x/registry/client/cli"
+)
+
+const badPath = "/asdasd"
+
+func (ets *E2ETestSuite) TestGRPCQueryParams() {
+	val := ets.network.Validators[0]
+	sr := ets.Require()
+	reqURL := val.APIAddress + "/cerc/registry/v1/params"
+
+	testCases := []struct {
+		name      string
+		url       string
+		expectErr bool
+		errorMsg  string
+	}{
+		{
+			"invalid request",
+			reqURL + badPath,
+			true,
+			"",
+		},
+		{
+			"valid request",
+			reqURL,
+			false,
+			"",
+		},
+	}
+
+	for _, tc := range testCases {
+		ets.Run(tc.name, func() {
+			resp, err := testutil.GetRequest(tc.url)
+			ets.NoError(err)
+			require := ets.Require()
+			if tc.expectErr {
+				require.Contains(string(resp), tc.errorMsg)
+			} else {
+				var response registrytypes.QueryParamsResponse
+				err := val.ClientCtx.Codec.UnmarshalJSON(resp, &response)
+				sr.NoError(err)
+
+				params := registrytypes.DefaultParams()
+				ets.updateParams(&params)
+				sr.Equal(params.String(), response.GetParams().String())
+			}
+		})
+	}
+}
+
+func (ets *E2ETestSuite) TestGRPCQueryWhoIs() {
+	val := ets.network.Validators[0]
+	sr := ets.Require()
+	reqUrl := val.APIAddress + "/cerc/registry/v1/whois/%s"
+	authorityName := "QueryWhoIS"
+	testCases := []struct {
+		name      string
+		url       string
+		expectErr bool
+		errorMsg  string
+		preRun    func(authorityName string)
+	}{
+		{
+			"invalid url",
+			reqUrl + badPath,
+			true,
+			"",
+			func(authorityName string) {
+			},
+		},
+		{
+			"valid request",
+			reqUrl,
+			false,
+			"",
+			func(authorityName string) { ets.reserveName(authorityName) },
+		},
+	}
+
+	for _, tc := range testCases {
+		ets.Run(tc.name, func() {
+			tc.preRun(authorityName)
+			tc.url = fmt.Sprintf(tc.url, authorityName)
+
+			resp, err := testutil.GetRequest(tc.url)
+			ets.NoError(err)
+			require := ets.Require()
+			if tc.expectErr {
+				require.Contains(string(resp), tc.errorMsg)
+			} else {
+				var response registrytypes.QueryWhoisResponse
+				err := val.ClientCtx.Codec.UnmarshalJSON(resp, &response)
+				sr.NoError(err)
+				sr.Equal(registrytypes.AuthorityActive, response.GetNameAuthority().Status)
+			}
+		})
+	}
+}
+
+func (ets *E2ETestSuite) TestGRPCQueryLookup() {
+	val := ets.network.Validators[0]
+	sr := ets.Require()
+	reqURL := val.APIAddress + "/cerc/registry/v1/lookup"
+	authorityName := "QueryLookUp"
+
+	testCases := []struct {
+		name      string
+		url       string
+		expectErr bool
+		errorMsg  string
+		preRun    func(authorityName string)
+	}{
+		{
+			"invalid url",
+			reqURL + badPath,
+			true,
+			"",
+			func(authorityName string) {
+			},
+		},
+		{
+			"valid request",
+			fmt.Sprintf(reqURL+"?lrn=lrn://%s/", authorityName),
+			false,
+			"",
+			func(authorityName string) {
+				// create name record
+				ets.createNameRecord(authorityName)
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		ets.Run(tc.name, func() {
+			tc.preRun(authorityName)
+			resp, err := testutil.GetRequest(tc.url)
+			ets.NoError(err)
+			if tc.expectErr {
+				sr.Contains(string(resp), tc.errorMsg)
+			} else {
+				var response registrytypes.QueryLookupLrnResponse
+				err := val.ClientCtx.Codec.UnmarshalJSON(resp, &response)
+				sr.NoError(err)
+				sr.NotZero(len(response.Name.Latest.Id))
+			}
+		})
+	}
+}
+
+func (ets *E2ETestSuite) TestGRPCQueryListRecords() {
+	val := ets.network.Validators[0]
+	sr := ets.Require()
+	reqUrl := val.APIAddress + "/cerc/registry/v1/records"
+
+	testCases := []struct {
+		name      string
+		url       string
+		expectErr bool
+		errorMsg  string
+		preRun    func(bondId string)
+	}{
+		{
+			"invalid url",
+			reqUrl + badPath,
+			true,
+			"",
+			func(bondId string) {
+			},
+		},
+		{
+			"valid request",
+			reqUrl,
+			false,
+			"",
+			func(bondId string) { ets.createRecord(bondId) },
+		},
+	}
+
+	for _, tc := range testCases {
+		ets.Run(tc.name, func() {
+			tc.preRun(ets.bondId)
+			resp, err := testutil.GetRequest(tc.url)
+			ets.NoError(err)
+			require := ets.Require()
+			if tc.expectErr {
+				require.Contains(string(resp), tc.errorMsg)
+			} else {
+				var response registrytypes.QueryRecordsResponse
+				err := val.ClientCtx.Codec.UnmarshalJSON(resp, &response)
+				sr.NoError(err)
+				sr.NotZero(len(response.GetRecords()))
+				sr.Equal(ets.bondId, response.GetRecords()[0].GetBondId())
+			}
+		})
+	}
+}
+
+func (ets *E2ETestSuite) TestGRPCQueryGetRecordById() {
+	val := ets.network.Validators[0]
+	sr := ets.Require()
+	reqURL := val.APIAddress + "/cerc/registry/v1/records/%s"
+
+	testCases := []struct {
+		name      string
+		url       string
+		expectErr bool
+		errorMsg  string
+		preRun    func(bondId string) string
+	}{
+		{
+			"invalid url",
+			reqURL + badPath,
+			true,
+			"",
+			func(bondId string) string {
+				return ""
+			},
+		},
+		{
+			"valid request",
+			reqURL,
+			false,
+			"",
+			func(bondId string) string {
+				// creating the record
+				ets.createRecord(bondId)
+
+				// list the records
+				clientCtx := val.ClientCtx
+				cmd := cli.GetCmdList()
+				args := []string{
+					fmt.Sprintf("--%s=json", flags.FlagOutput),
+				}
+				out, err := clitestutil.ExecTestCLICmd(clientCtx, cmd, args)
+				sr.NoError(err)
+				var records []registrytypes.ReadableRecord
+				err = json.Unmarshal(out.Bytes(), &records)
+				sr.NoError(err)
+				return records[0].Id
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		ets.Run(tc.name, func() {
+			recordId := tc.preRun(ets.bondId)
+			tc.url = fmt.Sprintf(reqURL, recordId)
+
+			resp, err := testutil.GetRequest(tc.url)
+			ets.NoError(err)
+			require := ets.Require()
+			if tc.expectErr {
+				require.Contains(string(resp), tc.errorMsg)
+			} else {
+				var response registrytypes.QueryRecordByIdResponse
+				err := val.ClientCtx.Codec.UnmarshalJSON(resp, &response)
+				sr.NoError(err)
+				record := response.GetRecord()
+				sr.NotZero(len(record.GetId()))
+				sr.Equal(record.GetId(), recordId)
+			}
+		})
+	}
+}
+
+func (ets *E2ETestSuite) TestGRPCQueryGetRecordByBondId() {
+	val := ets.network.Validators[0]
+	sr := ets.Require()
+	reqURL := val.APIAddress + "/cerc/registry/v1/records-by-bond-id/%s"
+
+	testCases := []struct {
+		name      string
+		url       string
+		expectErr bool
+		errorMsg  string
+		preRun    func(bondId string)
+	}{
+		{
+			"invalid url",
+			reqURL + badPath,
+			true,
+			"",
+			func(bondId string) {
+			},
+		},
+		{
+			"valid request",
+			reqURL,
+			false,
+			"",
+			func(bondId string) {
+				// creating the record
+				ets.createRecord(bondId)
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		ets.Run(tc.name, func() {
+			tc.preRun(ets.bondId)
+			tc.url = fmt.Sprintf(reqURL, ets.bondId)
+
+			resp, err := testutil.GetRequest(tc.url)
+			ets.NoError(err)
+			require := ets.Require()
+			if tc.expectErr {
+				require.Contains(string(resp), tc.errorMsg)
+			} else {
+				var response registrytypes.QueryRecordsByBondIdResponse
+				err := val.ClientCtx.Codec.UnmarshalJSON(resp, &response)
+				sr.NoError(err)
+				records := response.GetRecords()
+				sr.NotZero(len(records))
+				sr.Equal(records[0].GetBondId(), ets.bondId)
+			}
+		})
+	}
+}
+
+func (ets *E2ETestSuite) TestGRPCQueryGetRegistryModuleBalance() {
+	val := ets.network.Validators[0]
+	sr := ets.Require()
+	reqURL := val.APIAddress + "/cerc/registry/v1/balance"
+
+	testCases := []struct {
+		name      string
+		url       string
+		expectErr bool
+		errorMsg  string
+		preRun    func(bondId string)
+	}{
+		{
+			"invalid url",
+			reqURL + badPath,
+			true,
+			"",
+			func(bondId string) {
+			},
+		},
+		{
+			"Success",
+			reqURL,
+			false,
+			"",
+			func(bondId string) {
+				// creating the record
+				ets.createRecord(bondId)
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		ets.Run(tc.name, func() {
+			tc.preRun(ets.bondId)
+			resp, err := testutil.GetRequest(tc.url)
+			ets.NoError(err)
+			require := ets.Require()
+			if tc.expectErr {
+				require.Contains(string(resp), tc.errorMsg)
+			} else {
+				var response registrytypes.QueryGetRegistryModuleBalanceResponse
+				err := val.ClientCtx.Codec.UnmarshalJSON(resp, &response)
+				sr.NoError(err)
+				sr.NotZero(len(response.GetBalances()))
+			}
+		})
+	}
+}
+
+func (ets *E2ETestSuite) TestGRPCQueryNamesList() {
+	val := ets.network.Validators[0]
+	sr := ets.Require()
+	reqURL := val.APIAddress + "/cerc/registry/v1/names"
+
+	testCases := []struct {
+		name      string
+		url       string
+		expectErr bool
+		errorMsg  string
+		preRun    func(authorityName string)
+	}{
+		{
+			"invalid url",
+			reqURL + badPath,
+			true,
+			"",
+			func(authorityName string) {
+			},
+		},
+		{
+			"valid request",
+			reqURL,
+			false,
+			"",
+			func(authorityName string) {
+				// create name record
+				ets.createNameRecord(authorityName)
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		ets.Run(tc.name, func() {
+			tc.preRun("ListNameRecords")
+			resp, err := testutil.GetRequest(tc.url)
+			ets.NoError(err)
+			require := ets.Require()
+			if tc.expectErr {
+				require.Contains(string(resp), tc.errorMsg)
+			} else {
+				var response registrytypes.QueryNameRecordsResponse
+				err := val.ClientCtx.Codec.UnmarshalJSON(resp, &response)
+				sr.NoError(err)
+				sr.NotZero(len(response.GetNames()))
+			}
+		})
+	}
+}

tests/e2e/registry/suite.go

@@ -0,0 +1,282 @@
+package registry
+
+import (
+	"fmt"
+	"path/filepath"
+	"time"
+
+	"cosmossdk.io/math"
+	"github.com/stretchr/testify/suite"
+
+	"github.com/cosmos/cosmos-sdk/client/flags"
+	addresscodec "github.com/cosmos/cosmos-sdk/codec/address"
+	"github.com/cosmos/cosmos-sdk/crypto/hd"
+	"github.com/cosmos/cosmos-sdk/crypto/keyring"
+	clitestutil "github.com/cosmos/cosmos-sdk/testutil/cli"
+	"github.com/cosmos/cosmos-sdk/testutil/network"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+
+	bondtypes "git.vdb.to/cerc-io/laconic2d/x/bond"
+	bondcli "git.vdb.to/cerc-io/laconic2d/x/bond/client/cli"
+	registrytypes "git.vdb.to/cerc-io/laconic2d/x/registry"
+	"git.vdb.to/cerc-io/laconic2d/x/registry/client/cli"
+)
+
+type E2ETestSuite struct {
+	suite.Suite
+
+	cfg     network.Config
+	network *network.Network
+
+	accountName    string
+	accountAddress string
+
+	bondId string
+}
+
+func NewE2ETestSuite(cfg network.Config) *E2ETestSuite {
+	return &E2ETestSuite{cfg: cfg}
+}
+
+func (ets *E2ETestSuite) SetupSuite() {
+	sr := ets.Require()
+	ets.T().Log("setting up e2e test suite")
+
+	var err error
+
+	genesisState := ets.cfg.GenesisState
+	var registryGenesis registrytypes.GenesisState
+	ets.Require().NoError(ets.cfg.Codec.UnmarshalJSON(genesisState[registrytypes.ModuleName], &registryGenesis))
+
+	ets.updateParams(&registryGenesis.Params)
+
+	registryGenesisBz, err := ets.cfg.Codec.MarshalJSON(&registryGenesis)
+	ets.Require().NoError(err)
+	genesisState[registrytypes.ModuleName] = registryGenesisBz
+	ets.cfg.GenesisState = genesisState
+
+	ets.network, err = network.New(ets.T(), ets.T().TempDir(), ets.cfg)
+	sr.NoError(err)
+
+	_, err = ets.network.WaitForHeight(2)
+	sr.NoError(err)
+
+	// setting up random account
+	ets.accountName = "accountName"
+	ets.createAccountWithBalance(ets.accountName, &ets.accountAddress)
+
+	ets.bondId = ets.createBond()
+}
+
+func (ets *E2ETestSuite) TearDownSuite() {
+	ets.T().Log("tearing down e2e test suite")
+	ets.network.Cleanup()
+}
+
+func (ets *E2ETestSuite) createAccountWithBalance(accountName string, accountAddress *string) {
+	val := ets.network.Validators[0]
+	sr := ets.Require()
+
+	info, _, err := val.ClientCtx.Keyring.NewMnemonic(accountName, keyring.English, sdk.FullFundraiserPath, keyring.DefaultBIP39Passphrase, hd.Secp256k1)
+	sr.NoError(err)
+
+	newAddr, _ := info.GetAddress()
+	_, err = clitestutil.MsgSendExec(
+		val.ClientCtx,
+		val.Address,
+		newAddr,
+		sdk.NewCoins(sdk.NewCoin(ets.cfg.BondDenom, math.NewInt(100000000))),
+		addresscodec.NewBech32Codec("laconic"),
+		fmt.Sprintf("--%s=%s", flags.FlagFrom, accountName),
+		fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
+		fmt.Sprintf("--%s=json", flags.FlagOutput),
+		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastSync),
+		fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(ets.cfg.BondDenom, math.NewInt(10))).String()),
+	)
+	sr.NoError(err)
+	*accountAddress = newAddr.String()
+
+	// wait for tx to take effect
+	err = ets.network.WaitForNextBlock()
+	sr.NoError(err)
+}
+
+func (ets *E2ETestSuite) createBond() string {
+	val := ets.network.Validators[0]
+	sr := ets.Require()
+	createBondCmd := bondcli.NewCreateBondCmd()
+	args := []string{
+		fmt.Sprintf("1000000%s", ets.cfg.BondDenom),
+		fmt.Sprintf("--%s=%s", flags.FlagFrom, ets.accountName),
+		fmt.Sprintf("--%s=json", flags.FlagOutput),
+		fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
+		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastSync),
+		fmt.Sprintf("--%s=%s", flags.FlagFees, fmt.Sprintf("3%s", ets.cfg.BondDenom)),
+	}
+	out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, createBondCmd, args)
+	sr.NoError(err)
+	var d sdk.TxResponse
+	err = val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &d)
+	sr.NoError(err)
+	sr.Zero(d.Code)
+
+	// wait for tx to take effect
+	err = ets.network.WaitForNextBlock()
+	sr.NoError(err)
+
+	// getting the bonds list and returning the bond-id
+	clientCtx := val.ClientCtx
+	cmd := bondcli.GetQueryBondList()
+	args = []string{
+		fmt.Sprintf("--%s=json", flags.FlagOutput),
+	}
+	out, err = clitestutil.ExecTestCLICmd(clientCtx, cmd, args)
+	sr.NoError(err)
+	var queryResponse bondtypes.QueryGetBondsResponse
+	err = val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &queryResponse)
+	sr.NoError(err)
+
+	// extract bond id from bonds list
+	bond := queryResponse.GetBonds()[0]
+	return bond.GetId()
+}
+
+func (ets *E2ETestSuite) reserveName(authorityName string) {
+	val := ets.network.Validators[0]
+	sr := ets.Require()
+
+	clientCtx := val.ClientCtx
+	cmd := cli.GetCmdReserveName()
+	args := []string{
+		authorityName,
+		fmt.Sprintf("--owner=%s", ets.accountAddress),
+		fmt.Sprintf("--%s=%s", flags.FlagFrom, ets.accountName),
+		fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
+		fmt.Sprintf("--%s=json", flags.FlagOutput),
+		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastSync),
+		fmt.Sprintf("--%s=%s", flags.FlagFees, fmt.Sprintf("3%s", ets.cfg.BondDenom)),
+	}
+	out, err := clitestutil.ExecTestCLICmd(clientCtx, cmd, args)
+	sr.NoError(err)
+
+	var d sdk.TxResponse
+	err = val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &d)
+	sr.NoError(err)
+	sr.Zero(d.Code)
+
+	err = ets.network.WaitForNextBlock()
+	sr.NoError(err)
+}
+
+func (ets *E2ETestSuite) createNameRecord(authorityName string) {
+	val := ets.network.Validators[0]
+	sr := ets.Require()
+
+	// reserving the name
+	clientCtx := val.ClientCtx
+	cmd := cli.GetCmdReserveName()
+	args := []string{
+		authorityName,
+		fmt.Sprintf("--owner=%s", ets.accountAddress),
+		fmt.Sprintf("--%s=%s", flags.FlagFrom, ets.accountName),
+		fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
+		fmt.Sprintf("--%s=json", flags.FlagOutput),
+		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastSync),
+		fmt.Sprintf("--%s=%s", flags.FlagFees, fmt.Sprintf("3%s", ets.cfg.BondDenom)),
+	}
+	out, err := clitestutil.ExecTestCLICmd(clientCtx, cmd, args)
+	sr.NoError(err)
+	var d sdk.TxResponse
+	err = val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &d)
+	sr.NoError(err)
+	sr.Zero(d.Code)
+
+	err = ets.network.WaitForNextBlock()
+	sr.NoError(err)
+
+	// Get the bond-id
+	bondId := ets.bondId
+
+	// adding bond-id to name authority
+	args = []string{
+		authorityName, bondId,
+		fmt.Sprintf("--%s=%s", flags.FlagFrom, ets.accountName),
+		fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
+		fmt.Sprintf("--%s=json", flags.FlagOutput),
+		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastSync),
+		fmt.Sprintf("--%s=%s", flags.FlagFees, fmt.Sprintf("3%s", ets.cfg.BondDenom)),
+	}
+	cmd = cli.GetCmdSetAuthorityBond()
+
+	out, err = clitestutil.ExecTestCLICmd(clientCtx, cmd, args)
+	sr.NoError(err)
+	err = val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &d)
+	sr.NoError(err)
+	sr.Zero(d.Code)
+
+	err = ets.network.WaitForNextBlock()
+	sr.NoError(err)
+
+	args = []string{
+		fmt.Sprintf("lrn://%s/", authorityName),
+		"test_hello_cid",
+		fmt.Sprintf("--%s=%s", flags.FlagFrom, ets.accountName),
+		fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
+		fmt.Sprintf("--%s=json", flags.FlagOutput),
+		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastSync),
+		fmt.Sprintf("--%s=%s", flags.FlagFees, fmt.Sprintf("3%s", ets.cfg.BondDenom)),
+	}
+
+	cmd = cli.GetCmdSetName()
+
+	out, err = clitestutil.ExecTestCLICmd(clientCtx, cmd, args)
+	sr.NoError(err)
+	err = val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &d)
+	sr.NoError(err)
+	sr.Zero(d.Code)
+
+	err = ets.network.WaitForNextBlock()
+	sr.NoError(err)
+}
+
+func (ets *E2ETestSuite) createRecord(bondId string) {
+	val := ets.network.Validators[0]
+	sr := ets.Require()
+
+	payloadPath := "../../data/examples/service_provider_example.yml"
+	payloadFilePath, err := filepath.Abs(payloadPath)
+	sr.NoError(err)
+
+	args := []string{
+		fmt.Sprintf("--%s=%s", flags.FlagFrom, ets.accountName),
+		fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
+		fmt.Sprintf("--%s=json", flags.FlagOutput),
+		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastSync),
+		fmt.Sprintf("--%s=%s", flags.FlagFees, fmt.Sprintf("3%s", ets.cfg.BondDenom)),
+	}
+	args = append([]string{payloadFilePath, bondId}, args...)
+	clientCtx := val.ClientCtx
+	cmd := cli.GetCmdSetRecord()
+
+	out, err := clitestutil.ExecTestCLICmd(clientCtx, cmd, args)
+	sr.NoError(err)
+	var d sdk.TxResponse
+	err = val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &d)
+	sr.NoError(err)
+	sr.Zero(d.Code, d.RawLog)
+
+	err = ets.network.WaitForNextBlock()
+	sr.NoError(err)
+}
+
+func (ets *E2ETestSuite) updateParams(params *registrytypes.Params) {
+	params.RecordRent = sdk.NewCoin(ets.cfg.BondDenom, math.NewInt(1000))
+	params.RecordRentDuration = 10 * time.Second
+
+	params.AuthorityRent = sdk.NewCoin(ets.cfg.BondDenom, math.NewInt(1000))
+	params.AuthorityGracePeriod = 10 * time.Second
+
+	params.AuthorityAuctionCommitFee = sdk.NewCoin(ets.cfg.BondDenom, math.NewInt(100))
+	params.AuthorityAuctionRevealFee = sdk.NewCoin(ets.cfg.BondDenom, math.NewInt(100))
+	params.AuthorityAuctionMinimumBid = sdk.NewCoin(ets.cfg.BondDenom, math.NewInt(500))
+}

tests/e2e/registry/tx.go

@@ -0,0 +1,70 @@
+package registry
+
+import (
+	"fmt"
+	"path/filepath"
+
+	"github.com/cosmos/cosmos-sdk/client/flags"
+	clitestutil "github.com/cosmos/cosmos-sdk/testutil/cli"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+
+	"git.vdb.to/cerc-io/laconic2d/x/registry/client/cli"
+)
+
+func (ets *E2ETestSuite) TestGetCmdSetRecord() {
+	val := ets.network.Validators[0]
+	sr := ets.Require()
+
+	bondId := ets.bondId
+	payloadPath := "../../data/examples/service_provider_example.yml"
+	payloadFilePath, err := filepath.Abs(payloadPath)
+	sr.NoError(err)
+
+	testCases := []struct {
+		name string
+		args []string
+		err  bool
+	}{
+		{
+			"invalid request without bond id/without payload",
+			[]string{
+				fmt.Sprintf("--%s=%s", flags.FlagFrom, ets.accountName),
+				fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
+				fmt.Sprintf("--%s=json", flags.FlagOutput),
+				fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastSync),
+				fmt.Sprintf("--%s=%s", flags.FlagFees, fmt.Sprintf("3%s", ets.cfg.BondDenom)),
+			},
+			true,
+		},
+		{
+			"success",
+			[]string{
+				payloadFilePath, bondId,
+				fmt.Sprintf("--%s=%s", flags.FlagFrom, ets.accountName),
+				fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
+				fmt.Sprintf("--%s=json", flags.FlagOutput),
+				fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastSync),
+				fmt.Sprintf("--%s=%s", flags.FlagFees, fmt.Sprintf("3%s", ets.cfg.BondDenom)),
+			},
+			false,
+		},
+	}
+
+	for _, tc := range testCases {
+		ets.Run(fmt.Sprintf("Case %s", tc.name), func() {
+			clientCtx := val.ClientCtx
+			cmd := cli.GetCmdSetRecord()
+
+			out, err := clitestutil.ExecTestCLICmd(clientCtx, cmd, tc.args)
+			if tc.err {
+				sr.Error(err)
+			} else {
+				sr.NoError(err)
+				var d sdk.TxResponse
+				err = val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &d)
+				sr.NoError(err)
+				sr.Zero(d.Code)
+			}
+		})
+	}
+}

tests/integration/registry/keeper/query_server_test.go

@@ -37,9 +37,9 @@ func (kts *KeeperTestSuite) TestGrpcGetRecordLists() {
 
 	var recordId string
 	examples := []string{
-		"../../data/examples/service_provider_example.yml",
+		"../../../data/examples/service_provider_example.yml",
-		"../../data/examples/website_registration_example.yml",
+		"../../../data/examples/website_registration_example.yml",
-		"../../data/examples/general_record_example.yml",
+		"../../../data/examples/general_record_example.yml",
 	}
 	testCases := []struct {
 		msg           string
@@ -268,7 +268,7 @@ func (kts *KeeperTestSuite) TestGrpcGetRecordLists() {
 	}
 
 	// Get the records by record id
-	testCasesByBondID := []struct {
+	testCasesByBondId := []struct {
 		msg          string
 		req          *types.QueryRecordsByBondIdRequest
 		createRecord bool
@@ -292,7 +292,7 @@ func (kts *KeeperTestSuite) TestGrpcGetRecordLists() {
 			1,
 		},
 	}
-	for _, test := range testCasesByBondID {
+	for _, test := range testCasesByBondId {
 		kts.Run(fmt.Sprintf("Case %s ", test.msg), func() {
 			resp, err := queryClient.GetRecordsByBondId(context.Background(), test.req)
 
@@ -314,8 +314,8 @@ func (kts *KeeperTestSuite) TestGrpcQueryRegistryModuleBalance() {
 	queryClient, ctx := kts.queryClient, kts.SdkCtx
 	sr := kts.Require()
 	examples := []string{
-		"../../data/examples/service_provider_example.yml",
+		"../../../data/examples/service_provider_example.yml",
-		"../../data/examples/website_registration_example.yml",
+		"../../../data/examples/website_registration_example.yml",
 	}
 	testCases := []struct {
 		msg           string

x/auction/client/cli/query.go

@@ -0,0 +1,35 @@
+package cli
+
+import (
+	"github.com/cosmos/cosmos-sdk/client"
+	"github.com/cosmos/cosmos-sdk/client/flags"
+	"github.com/spf13/cobra"
+
+	types "git.vdb.to/cerc-io/laconic2d/x/auction"
+)
+
+// GetCmdList queries all auctions.
+func GetCmdList() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "list",
+		Short: "List auctions.",
+		Args:  cobra.ExactArgs(0),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			clientCtx, err := client.GetClientQueryContext(cmd)
+			if err != nil {
+				return err
+			}
+
+			queryClient := types.NewQueryClient(clientCtx)
+			res, err := queryClient.Auctions(cmd.Context(), &types.QueryAuctionsRequest{})
+			if err != nil {
+				return err
+			}
+
+			return clientCtx.PrintProto(res)
+		},
+	}
+
+	flags.AddQueryFlagsToCmd(cmd)
+	return cmd
+}

x/auction/client/cli/tx.go

@@ -4,6 +4,7 @@ import (
 	"encoding/hex"
 	"fmt"
 	"os"
+	"time"
 
 	"github.com/cosmos/cosmos-sdk/client"
 	"github.com/cosmos/cosmos-sdk/client/flags"
@@ -128,3 +129,60 @@ func GetCmdRevealBid() *cobra.Command {
 
 	return cmd
 }
+
+func GetCmdCreateAuction() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "create [commits-duration] [reveals-duration] [commit-fee] [reveal-fee] [minimum-bid]",
+		Short: "Create auction.",
+		Args:  cobra.ExactArgs(5),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			clientCtx, err := client.GetClientTxContext(cmd)
+			if err != nil {
+				return err
+			}
+
+			commitsDuration, err := time.ParseDuration(args[0])
+			if err != nil {
+				return err
+			}
+
+			revealsDuration, err := time.ParseDuration(args[1])
+			if err != nil {
+				return err
+			}
+
+			commitFee, err := sdk.ParseCoinNormalized(args[2])
+			if err != nil {
+				return err
+			}
+
+			revealFee, err := sdk.ParseCoinNormalized(args[3])
+			if err != nil {
+				return err
+			}
+
+			minimumBid, err := sdk.ParseCoinNormalized(args[4])
+			if err != nil {
+				return err
+			}
+
+			params := auctiontypes.Params{
+				CommitsDuration: commitsDuration,
+				RevealsDuration: revealsDuration,
+				CommitFee:       commitFee,
+				RevealFee:       revealFee,
+				MinimumBid:      minimumBid,
+			}
+			msg := auctiontypes.NewMsgCreateAuction(params, clientCtx.GetFromAddress())
+			err = msg.ValidateBasic()
+			if err != nil {
+				return err
+			}
+
+			return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), &msg)
+		},
+	}
+
+	flags.AddTxFlagsToCmd(cmd)
+	return cmd
+}

x/auction/msgs.go

@@ -33,6 +33,27 @@ func NewMsgCommitBid(auctionId string, commitHash string, signer sdk.AccAddress)
 	}
 }
 
+// ValidateBasic Implements Msg.
+func (msg MsgCreateAuction) ValidateBasic() error {
+	if msg.Signer == "" {
+		return errorsmod.Wrap(sdkerrors.ErrInvalidAddress, msg.Signer)
+	}
+
+	if msg.CommitsDuration <= 0 {
+		return errorsmod.Wrap(sdkerrors.ErrInvalidRequest, "commit phase duration invalid.")
+	}
+
+	if msg.RevealsDuration <= 0 {
+		return errorsmod.Wrap(sdkerrors.ErrInvalidRequest, "reveal phase duration invalid.")
+	}
+
+	if !msg.MinimumBid.IsPositive() {
+		return errorsmod.Wrap(sdkerrors.ErrInvalidRequest, "minimum bid should be greater than zero.")
+	}
+
+	return nil
+}
+
 // ValidateBasic Implements Msg.
 func (msg MsgCommitBid) ValidateBasic() error {
 	if msg.Signer == "" {

x/bond/client/cli/query.go

@@ -0,0 +1,48 @@
+package cli
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/cosmos/cosmos-sdk/client"
+	"github.com/cosmos/cosmos-sdk/client/flags"
+	"github.com/cosmos/cosmos-sdk/version"
+	"github.com/spf13/cobra"
+
+	bondtypes "git.vdb.to/cerc-io/laconic2d/x/bond"
+)
+
+// GetQueryBondList implements the bond lists query command.
+func GetQueryBondList() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "list",
+		Short: "List bonds.",
+		Long: strings.TrimSpace(
+			fmt.Sprintf(`Get bond list .
+
+Example:
+$ %s query %s list
+`,
+				version.AppName, bondtypes.ModuleName,
+			),
+		),
+		Args: cobra.ExactArgs(0),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			clientCtx, err := client.GetClientQueryContext(cmd)
+			if err != nil {
+				return err
+			}
+			queryClient := bondtypes.NewQueryClient(clientCtx)
+			res, err := queryClient.Bonds(cmd.Context(), &bondtypes.QueryGetBondsRequest{})
+			if err != nil {
+				return err
+			}
+
+			return clientCtx.PrintProto(res)
+		},
+	}
+
+	flags.AddQueryFlagsToCmd(cmd)
+
+	return cmd
+}

x/bond/client/cli/tx.go

@@ -0,0 +1,38 @@
+package cli
+
+import (
+	"github.com/cosmos/cosmos-sdk/client"
+	"github.com/cosmos/cosmos-sdk/client/flags"
+	"github.com/cosmos/cosmos-sdk/client/tx"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/spf13/cobra"
+
+	bondtypes "git.vdb.to/cerc-io/laconic2d/x/bond"
+)
+
+// NewCreateBondCmd is the CLI command for creating a bond.
+// Used in e2e tests
+func NewCreateBondCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "create [amount]",
+		Short: "Create bond.",
+		Args:  cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			clientCtx, err := client.GetClientTxContext(cmd)
+			if err != nil {
+				return err
+			}
+			coin, err := sdk.ParseCoinNormalized(args[0])
+			if err != nil {
+				return err
+			}
+
+			msg := bondtypes.NewMsgCreateBond(sdk.NewCoins(coin), clientCtx.GetFromAddress())
+			return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), &msg)
+		},
+	}
+
+	flags.AddTxFlagsToCmd(cmd)
+
+	return cmd
+}

x/bond/genesis.pb.go

@@ -28,7 +28,6 @@ type GenesisState struct {
 	// params defines all the parameters of the module.
 	Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"`
 	// bonds defines all the bonds
-	// TODO: Add nullable = false ?
 	Bonds []*Bond `protobuf:"bytes,2,rep,name=bonds,proto3" json:"bonds,omitempty" json:"bonds" yaml:"bonds"`
 }
 

x/bond/keeper/msg_server.go

@@ -26,7 +26,8 @@ func (ms msgServer) CreateBond(c context.Context, msg *bond.MsgCreateBond) (*bon
 	if err != nil {
 		return nil, err
 	}
-	_, err = ms.k.CreateBond(ctx, signerAddress, msg.Coins)
+
+	resp, err := ms.k.CreateBond(ctx, signerAddress, msg.Coins)
 	if err != nil {
 		return nil, err
 	}
@@ -44,7 +45,7 @@ func (ms msgServer) CreateBond(c context.Context, msg *bond.MsgCreateBond) (*bon
 		),
 	})
 
-	return &bond.MsgCreateBondResponse{}, nil
+	return &bond.MsgCreateBondResponse{Id: resp.Id}, nil
 }
 
 // RefillBond implements bond.MsgServer.

x/bond/msgs.go

@@ -0,0 +1,17 @@
+package bond
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+var (
+	_ sdk.Msg = &MsgCreateBond{}
+)
+
+// NewMsgCreateBond is the constructor function for MsgCreateBond.
+func NewMsgCreateBond(coins sdk.Coins, signer sdk.AccAddress) MsgCreateBond {
+	return MsgCreateBond{
+		Coins:  coins,
+		Signer: signer.String(),
+	}
+}

x/registry/client/cli/query.go

@@ -0,0 +1,58 @@
+package cli
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+
+	"github.com/cosmos/cosmos-sdk/client"
+	"github.com/cosmos/cosmos-sdk/client/flags"
+	"github.com/cosmos/cosmos-sdk/version"
+	"github.com/spf13/cobra"
+
+	registrytypes "git.vdb.to/cerc-io/laconic2d/x/registry"
+)
+
+// GetCmdList queries all records.
+func GetCmdList() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "list",
+		Short: "List records.",
+		Long: strings.TrimSpace(
+			fmt.Sprintf(`Get the records.
+Example:
+$ %s query %s list
+`,
+				version.AppName, registrytypes.ModuleName,
+			),
+		),
+		Args: cobra.ExactArgs(0),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			clientCtx, err := client.GetClientQueryContext(cmd)
+			if err != nil {
+				return err
+			}
+
+			queryClient := registrytypes.NewQueryClient(clientCtx)
+			res, err := queryClient.Records(cmd.Context(), &registrytypes.QueryRecordsRequest{})
+			if err != nil {
+				return err
+			}
+
+			recordsList := res.GetRecords()
+			records := make([]registrytypes.ReadableRecord, len(recordsList))
+			for i, record := range res.GetRecords() {
+				records[i] = record.ToReadableRecord()
+			}
+			bytesResult, err := json.Marshal(records)
+			if err != nil {
+				return err
+			}
+			return clientCtx.PrintBytes(bytesResult)
+		},
+	}
+
+	flags.AddQueryFlagsToCmd(cmd)
+
+	return cmd
+}

x/registry/client/cli/tx.go

@@ -1,11 +1,15 @@
 package cli
 
 import (
+	"fmt"
 	"os"
+	"strings"
 
 	"github.com/cosmos/cosmos-sdk/client"
 	"github.com/cosmos/cosmos-sdk/client/flags"
 	"github.com/cosmos/cosmos-sdk/client/tx"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/version"
 	"gopkg.in/yaml.v3"
 
 	"github.com/spf13/cobra"
@@ -80,3 +84,111 @@ func GetPayloadFromFile(filePath string) (*registrytypes.ReadablePayload, error)
 
 	return &payload, nil
 }
+
+// GetCmdReserveName is the CLI command for reserving a name.
+func GetCmdReserveName() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "reserve-name [name]",
+		Short: "Reserve name.",
+		Long: strings.TrimSpace(
+			fmt.Sprintf(`Reserver name with owner address .
+Example:
+$ %s tx %s reserve-name [name] --owner [ownerAddress]
+`,
+				version.AppName, registrytypes.ModuleName,
+			),
+		),
+		Args: cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			clientCtx, err := client.GetClientTxContext(cmd)
+			if err != nil {
+				return err
+			}
+			owner, err := cmd.Flags().GetString("owner")
+			if err != nil {
+				return err
+			}
+			ownerAddress, err := sdk.AccAddressFromBech32(owner)
+			if err != nil {
+				return err
+			}
+
+			msg := registrytypes.NewMsgReserveAuthority(args[0], clientCtx.GetFromAddress(), ownerAddress)
+			err = msg.ValidateBasic()
+			if err != nil {
+				return err
+			}
+
+			return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), &msg)
+		},
+	}
+
+	cmd.Flags().String("owner", "", "Owner address, if creating a sub-authority.")
+
+	flags.AddTxFlagsToCmd(cmd)
+
+	return cmd
+}
+
+// GetCmdSetAuthorityBond is the CLI command for associating a bond with an authority.
+func GetCmdSetAuthorityBond() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "authority-bond [name] [bond-id]",
+		Short: "Associate authority with bond.",
+		Long: strings.TrimSpace(
+			fmt.Sprintf(`Reserver name with owner address .
+Example:
+$ %s tx %s authority-bond [name] [bond-id]
+`,
+				version.AppName, registrytypes.ModuleName,
+			),
+		),
+		Args: cobra.ExactArgs(2),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			clientCtx, err := client.GetClientTxContext(cmd)
+			if err != nil {
+				return err
+			}
+			msg := registrytypes.NewMsgSetAuthorityBond(args[0], args[1], clientCtx.GetFromAddress())
+			return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), &msg)
+		},
+	}
+
+	flags.AddTxFlagsToCmd(cmd)
+
+	return cmd
+}
+
+// GetCmdSetName is the CLI command for mapping a name to a CID.
+func GetCmdSetName() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "set-name [crn] [cid]",
+		Short: "Set CRN to CID mapping.",
+		Long: strings.TrimSpace(
+			fmt.Sprintf(`Set name with crn and cid.
+Example:
+$ %s tx %s set-name [crn] [cid]
+`,
+				version.AppName, registrytypes.ModuleName,
+			),
+		),
+		Args: cobra.ExactArgs(2),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			clientCtx, err := client.GetClientTxContext(cmd)
+			if err != nil {
+				return err
+			}
+
+			msg := registrytypes.NewMsgSetName(args[0], args[1], clientCtx.GetFromAddress())
+			err = msg.ValidateBasic()
+			if err != nil {
+				return err
+			}
+			return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg)
+		},
+	}
+
+	flags.AddTxFlagsToCmd(cmd)
+
+	return cmd
+}

x/registry/msgs.go

@@ -33,3 +33,60 @@ func (msg MsgSetRecord) ValidateBasic() error {
 
 	return nil
 }
+
+// NewMsgReserveAuthority is the constructor function for MsgReserveName.
+func NewMsgReserveAuthority(name string, signer sdk.AccAddress, owner sdk.AccAddress) MsgReserveAuthority {
+	return MsgReserveAuthority{
+		Name:   name,
+		Owner:  owner.String(),
+		Signer: signer.String(),
+	}
+}
+
+// ValidateBasic Implements Msg.
+func (msg MsgReserveAuthority) ValidateBasic() error {
+	if len(msg.Name) == 0 {
+		return errorsmod.Wrap(sdkerrors.ErrInvalidRequest, "name is required.")
+	}
+
+	if len(msg.Signer) == 0 {
+		return errorsmod.Wrap(sdkerrors.ErrInvalidAddress, "invalid signer")
+	}
+
+	return nil
+}
+
+// NewMsgSetAuthorityBond is the constructor function for MsgSetAuthorityBond.
+func NewMsgSetAuthorityBond(name string, bondID string, signer sdk.AccAddress) MsgSetAuthorityBond {
+	return MsgSetAuthorityBond{
+		Name:   name,
+		Signer: signer.String(),
+		BondId: bondID,
+	}
+}
+
+// NewMsgSetName is the constructor function for MsgSetName.
+func NewMsgSetName(lrn string, cid string, signer sdk.AccAddress) *MsgSetName {
+	return &MsgSetName{
+		Lrn:    lrn,
+		Cid:    cid,
+		Signer: signer.String(),
+	}
+}
+
+// ValidateBasic Implements Msg.
+func (msg MsgSetName) ValidateBasic() error {
+	if msg.Lrn == "" {
+		return errorsmod.Wrap(sdkerrors.ErrInvalidRequest, "LRN is required.")
+	}
+
+	if msg.Cid == "" {
+		return errorsmod.Wrap(sdkerrors.ErrInvalidRequest, "CID is required.")
+	}
+
+	if len(msg.Signer) == 0 {
+		return errorsmod.Wrap(sdkerrors.ErrInvalidAddress, "invalid signer")
+	}
+
+	return nil
+}