migrate: add dxns module

1. add bond,auction, nameserivce module 2. update to v0.12.2 ethermint version 3. fix the test cases 4. add gql server
2022-04-05 12:39:27 +05:30
parent 4ddc8afd18
commit e90b21bc8e
137 changed files with 56381 additions and 26 deletions
@@ -0,0 +1,298 @@
+# Auction Module CLI Commands
+
+## Build the Chain
+
+The following command builds the Ethermint daemon and places the binary in the `build` directory
+
+```
+make build
+
+```
+
+## Setup the Chain
+
+The following steps need to be followed only before running the chain for the first time.
+
+1. Add the root key:
+   ```
+   ./build/ethermintd keys add root
+   ```
+   Keep a note of the keyring passphrase if you set it.
+2. Init the chain:
+   ```
+   ./build/ethermintd init test-moniker --chain-id ethermint_9000-1
+   ```
+3. Add genesis account:
+   ```
+   ./build/ethermintd add-genesis-account $(./build/ethermintd keys show root -a) 1000000000000000000aphoton,1000000000000000000stake
+   ```
+4. Make a genesis tx:
+   ```
+   ./build/ethermintd gentx root 1000000000000000000stake --chain-id ethermint_9000-1 
+   ```
+5. Collect gentxs:
+   ```
+   ./build/ethermintd collect-gentxs
+   ```
+
+The chain can now be started using:
+
+```
+./build/ethermintd start
+```
+
+## Querying the Params
+
+The following command will dislay the default params for the `auction` module:
+
+```
+# ./build/ethermintd q auction params -o json | jq
+
+{
+  "params": {
+    "commits_duration": "0s",
+    "reveals_duration": "0s",
+    "commit_fee": {
+      "denom": "",
+      "amount": "0"
+    },
+    "reveal_fee": {
+      "denom": "",
+      "amount": "0"
+    },
+    "minimum_bid": {
+      "denom": "",
+      "amount": "0"
+    }
+  }
+}
+```
+
+## Auction TX CLI Commands
+
+### Create Auction
+
+```
+# ./build/ethermintd tx auction create 100s 100s 10aphoton 10aphoton 1000aphoton --from root --chain-id $(./build/ethermintd status | jq .NodeInfo.network -r)
+
+Enter keyring passphrase:
+
+{"body":{"messages":[{"@type":"/vulcanize.auction.v1beta1.MsgCreateAuction","commits_duration":"100s","reveals_duration":"100s","commit_fee":{"denom":"aphoton","amount":"10"},"reveal_fee":{"denom":"aphoton","amount":"10"},"minimum_bid":{"denom":"aphoton","amount":"1000"},"signer":"ethm1l7cstwtf2lvev27ka67c23yk7mmj8ad7tetpqc"}],"memo":"","timeout_height":"0","extension_options":[],"non_critical_extension_options":[]},"auth_info":{"signer_infos":[],"fee":{"amount":[],"gas_limit":"200000","payer":"","granter":""}},"signatures":[]}
+
+confirm transaction before signing and broadcasting [y/N]: y
+
+code: 0
+codespace: ""
+data: ""
+gas_used: "0"
+gas_wanted: "0"
+height: "0"
+info: ""
+logs: []
+raw_log: '[]'
+timestamp: ""
+tx: null
+txhash: ECAD6DF1ECA763FBD26EB7C2C0B77425FFE2FBEA2BEC57CE0FBC173AE0F45298
+```
+
+### Commit Bid
+
+```
+# ./build/ethermintd tx auction commit-bid e7d14c7e7a6d7537cbdb8fbe62f22b1553c2ef4ce3705ada7c28f80faf2fbe0d 2000aphoton --from root --chain-id $(./build/ethermintd status | jq .NodeInfo.network -r)
+
+Enter keyring passphrase:
+
+{"body":{"messages":[{"@type":"/vulcanize.auction.v1beta1.MsgCommitBid","auction_id":"e7d14c7e7a6d7537cbdb8fbe62f22b1553c2ef4ce3705ada7c28f80faf2fbe0d","commit_hash":"bafyreibt4twofrc3xi2es27cfrroy346iy6lr3gkw33i5dltkqqarlyltm","signer":"ethm1l7cstwtf2lvev27ka67c23yk7mmj8ad7tetpqc"}],"memo":"","timeout_height":"0","extension_options":[],"non_critical_extension_options":[]},"auth_info":{"signer_infos":[],"fee":{"amount":[],"gas_limit":"200000","payer":"","granter":""}},"signatures":[]}
+
+confirm transaction before signing and broadcasting [y/N]: y
+
+code: 0
+codespace: ""
+data: ""
+gas_used: "0"
+gas_wanted: "0"
+height: "0"
+info: ""
+logs: []
+raw_log: '[]'
+timestamp: ""
+tx: null
+txhash: 71D8CF34026E32A3A34C2C2D4ADF25ABC8D7943A4619761BE27F196603D91B9D
+```
+
+### Reveal Bid
+
+```
+# ./build/ethermintd tx auction reveal-bid e7d14c7e7a6d7537cbdb8fbe62f22b1553c2ef4ce3705ada7c28f80faf2fbe0d root-bafyreibt4twofrc3xi2es27cfrroy346iy6lr3gkw33i5dltkqqarlyltm.json --from root --chain-id $(./build/ethermintd status | jq .NodeInfo.network -r)
+
+Enter keyring passphrase:
+
+{"body":{"messages":[{"@type":"/vulcanize.auction.v1beta1.MsgRevealBid","auction_id":"e7d14c7e7a6d7537cbdb8fbe62f22b1553c2ef4ce3705ada7c28f80faf2fbe0d","reveal":"7b2261756374696f6e4964223a2265376431346337653761366437353337636264623866626536326632326231353533633265663463653337303561646137633238663830666166326662653064222c22626964416d6f756e74223a22323030306170686f746f6e222c2262696464657241646472657373223a226574686d316c37637374777466326c76657632376b613637633233796b376d6d6a38616437746574707163222c22636861696e4964223a2265746865726d696e745f393030302d31222c226e6f697365223a22636c69666620737566666572206472616d6120676f7370656c2077656173656c207061706572206c696272617279206469736f726465722063757276652073706f74206375727461696e207a6562726120696e76657374206465766f74652072656e64657220636c6970207377616c6c6f77206d6f6e6b6579206f62736572766520726573706f6e7365206c696e6b206372616e6520766961626c6520736576656e227d","signer":"ethm1l7cstwtf2lvev27ka67c23yk7mmj8ad7tetpqc"}],"memo":"","timeout_height":"0","extension_options":[],"non_critical_extension_options":[]},"auth_info":{"signer_infos":[],"fee":{"amount":[],"gas_limit":"200000","payer":"","granter":""}},"signatures":[]}
+
+confirm transaction before signing and broadcasting [y/N]: y
+
+code: 0
+codespace: ""
+data: ""
+gas_used: "0"
+gas_wanted: "0"
+height: "0"
+info: ""
+logs: []
+raw_log: '[]'
+timestamp: ""
+tx: null
+txhash: 4D1C0B3DDA4050F9BB32240FBD5234229E5C32543C1A0A78033B9531EB0CF8BA
+```
+
+## Auction Query CLI Commands
+
+### List Auctions
+
+```
+# ./build/ethermintd q auction list
+
+auctions:
+  auctions:
+  - commit_fee:
+      amount: "10"
+      denom: aphoton
+    commits_end_time: "2021-09-30T07:57:07.933412800Z"
+    create_time: "2021-09-30T07:55:27.933412800Z"
+    id: e7d14c7e7a6d7537cbdb8fbe62f22b1553c2ef4ce3705ada7c28f80faf2fbe0d
+    minimum_bid:
+      amount: "1000"
+      denom: aphoton
+    owner_address: ethm1l7cstwtf2lvev27ka67c23yk7mmj8ad7tetpqc
+    reveal_fee:
+      amount: "10"
+      denom: aphoton
+    reveals_end_time: "2021-09-30T07:58:47.933412800Z"
+    status: commit
+    winner_address: ""
+    winning_bid:
+      amount: "0"
+      denom: ""
+    winning_price:
+      amount: "0"
+      denom: ""
+pagination: null
+```
+
+### Get Bid
+
+```
+# ./build/ethermintd q auction get-bid e7d14c7e7a6d7537cbdb8fbe62f22b1553c2ef4ce3705ada7c28f80faf2fbe0e ethm1l7cstwtf2lvev27ka67c23yk7mmj8ad7tetpqc
+
+bid:
+  auction_id: e7d14c7e7a6d7537cbdb8fbe62f22b1553c2ef4ce3705ada7c28f80faf2fbe0d
+  bid_amount:
+    amount: "0"
+    denom: ""
+  bidder_address: ethm1l7cstwtf2lvev27ka67c23yk7mmj8ad7tetpqc
+  commit_fee:
+    amount: "10"
+    denom: aphoton
+  commit_hash: bafyreibt4twofrc3xi2es27cfrroy346iy6lr3gkw33i5dltkqqarlyltm
+  commit_time: "2021-09-30T08:49:48.358878200Z"
+  reveal_fee:
+    amount: "10"
+    denom: aphoton
+  reveal_time: "0001-01-01T00:00:00Z"
+  status: commit
+```
+
+### Get All Bids for an Auction
+
+```
+./build/ethermintd q auction get-bids e7d14c7e7a6d7537cbdb8fbe62f22b1553c2ef4ce3705ada7c28f80faf2fbe0d
+
+bids:
+- auction_id: e7d14c7e7a6d7537cbdb8fbe62f22b1553c2ef4ce3705ada7c28f80faf2fbe0d
+  bid_amount:
+    amount: "0"
+    denom: ""
+  bidder_address: ethm1l7cstwtf2lvev27ka67c23yk7mmj8ad7tetpqc
+  commit_fee:
+    amount: "10"
+    denom: aphoton
+  commit_hash: bafyreibt4twofrc3xi2es27cfrroy346iy6lr3gkw33i5dltkqqarlyltm
+  commit_time: "2021-09-30T08:49:48.358878200Z"
+  reveal_fee:
+    amount: "10"
+    denom: aphoton
+  reveal_time: "0001-01-01T00:00:00Z"
+  status: commit
+```
+
+### Get Auction by AuctionID
+
+```
+# ./build/ethermintd q auction get e7d14c7e7a6d7537cbdb8fbe62f22b1553c2ef4ce3705ada7c28f80faf2fbe0d
+
+auction:
+  commit_fee:
+    amount: "10"
+    denom: aphoton
+  commits_end_time: "2021-09-30T07:57:07.933412800Z"
+  create_time: "2021-09-30T07:55:27.933412800Z"
+  id: e7d14c7e7a6d7537cbdb8fbe62f22b1553c2ef4ce3705ada7c28f80faf2fbe0d
+  minimum_bid:
+    amount: "1000"
+    denom: aphoton
+  owner_address: ethm1l7cstwtf2lvev27ka67c23yk7mmj8ad7tetpqc
+  reveal_fee:
+    amount: "10"
+    denom: aphoton
+  reveals_end_time: "2021-09-30T07:58:47.933412800Z"
+  status: commit
+  winner_address: ""
+  winning_bid:
+    amount: "0"
+    denom: ""
+  winning_price:
+    amount: "0"
+    denom: ""
+
+```
+
+### Get Auction by Bidder
+
+```
+# ./build/ethermintd q auction query-by-owner ethm1l7cstwtf2lvev27ka67c23yk7mmj8ad7tetpqc
+
+auctions:
+  auctions:
+  - commit_fee:
+      amount: "10"
+      denom: aphoton
+    commits_end_time: "2021-09-30T07:57:07.933412800Z"
+    create_time: "2021-09-30T07:55:27.933412800Z"
+    id: e7d14c7e7a6d7537cbdb8fbe62f22b1553c2ef4ce3705ada7c28f80faf2fbe0d
+    minimum_bid:
+      amount: "1000"
+      denom: aphoton
+    owner_address: ethm1l7cstwtf2lvev27ka67c23yk7mmj8ad7tetpqc
+    reveal_fee:
+      amount: "10"
+      denom: aphoton
+    reveals_end_time: "2021-09-30T07:58:47.933412800Z"
+    status: commit
+    winner_address: ""
+    winning_bid:
+      amount: "0"
+      denom: ""
+    winning_price:
+      amount: "0"
+      denom: ""
+```
+
+### Query Account Balance
+
+```
+# ./build/ethermintd q auction balance                                                   
+
+balance:
+- amount: "20"
+  denom: aphoton
+```
@@ -0,0 +1,13 @@
+package auction
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	abci "github.com/tendermint/tendermint/abci/types"
+	"github.com/tharsis/ethermint/x/auction/keeper"
+)
+
+// EndBlocker is called every block, returns updated validator set.
+func EndBlocker(ctx sdk.Context, k keeper.Keeper) []abci.ValidatorUpdate {
+	k.EndBlockerProcessAuctions(ctx)
+	return []abci.ValidatorUpdate{}
+}
@@ -0,0 +1,263 @@
+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"
+
+	"github.com/tharsis/ethermint/x/auction/types"
+)
+
+func GetQueryCmd() *cobra.Command {
+	auctionQueryCmd := &cobra.Command{
+		Use:                        types.ModuleName,
+		Short:                      fmt.Sprintf("Querying commands for the %s module", types.ModuleName),
+		DisableFlagParsing:         true,
+		SuggestionsMinimumDistance: 2,
+		RunE:                       client.ValidateCmd,
+	}
+	auctionQueryCmd.AddCommand(
+		GetCmdList(),
+		GetCmdGetAuction(),
+		GetCmdGetBid(),
+		GetCmdGetBids(),
+		GetCmdAuctionsByBidder(),
+		GetCmdAuctionsByOwner(),
+		GetCmdQueryParams(),
+		GetCmdBalance(),
+	)
+
+	return auctionQueryCmd
+}
+
+// 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.AuctionsRequest{})
+			if err != nil {
+				return err
+			}
+
+			return clientCtx.PrintProto(res)
+		},
+	}
+
+	flags.AddQueryFlagsToCmd(cmd)
+	return cmd
+}
+
+// GetCmdGetBid queries an auction bid.
+func GetCmdGetBid() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "get-bid [auction-id] [bidder]",
+		Short: "Get auction bid.",
+		Args:  cobra.ExactArgs(2),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			clientCtx, err := client.GetClientQueryContext(cmd)
+			if err != nil {
+				return err
+			}
+
+			id := args[0]
+			bidder := args[1]
+
+			queryClient := types.NewQueryClient(clientCtx)
+			res, err := queryClient.GetBid(cmd.Context(), &types.BidRequest{AuctionId: id, Bidder: bidder})
+			if err != nil {
+				return err
+			}
+
+			return clientCtx.PrintProto(res)
+		},
+	}
+
+	flags.AddQueryFlagsToCmd(cmd)
+	return cmd
+}
+
+// GetCmdGetBids queries all auction bids.
+func GetCmdGetBids() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "get-bids [auction-id]",
+		Short: "Get all auction bids.",
+		Args:  cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			clientCtx, err := client.GetClientQueryContext(cmd)
+			if err != nil {
+				return err
+			}
+
+			id := args[0]
+
+			queryClient := types.NewQueryClient(clientCtx)
+			res, err := queryClient.GetBids(cmd.Context(), &types.BidsRequest{AuctionId: id})
+			if err != nil {
+				return err
+			}
+
+			return clientCtx.PrintProto(res)
+		},
+	}
+
+	flags.AddQueryFlagsToCmd(cmd)
+	return cmd
+}
+
+// GetCmdGetAuction queries an auction.
+func GetCmdGetAuction() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "get [ID]",
+		Short: "Get auction.",
+		Args:  cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			clientCtx, err := client.GetClientQueryContext(cmd)
+			if err != nil {
+				return err
+			}
+
+			id := args[0]
+
+			queryClient := types.NewQueryClient(clientCtx)
+			res, err := queryClient.GetAuction(cmd.Context(), &types.AuctionRequest{Id: id})
+			if err != nil {
+				return err
+			}
+
+			return clientCtx.PrintProto(res)
+		},
+	}
+
+	flags.AddQueryFlagsToCmd(cmd)
+	return cmd
+}
+
+// GetCmdAuctionsByBidder queries auctions by bidder.
+func GetCmdAuctionsByBidder() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "query-by-bidder [address]",
+		Short: "Query auctions by bidder.",
+		Args:  cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			clientCtx, err := client.GetClientQueryContext(cmd)
+			if err != nil {
+				return err
+			}
+
+			address := args[0]
+
+			queryClient := types.NewQueryClient(clientCtx)
+			res, err := queryClient.AuctionsByBidder(cmd.Context(), &types.AuctionsByBidderRequest{BidderAddress: address})
+			if err != nil {
+				return err
+			}
+
+			return clientCtx.PrintProto(res)
+		},
+	}
+
+	flags.AddQueryFlagsToCmd(cmd)
+	return cmd
+}
+
+// GetCmdAuctionsByOwner queries auctions by owner
+func GetCmdAuctionsByOwner() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "query-by-owner [address]",
+		Short: "Query auctions by owner/creator.",
+		Args:  cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			clientCtx, err := client.GetClientQueryContext(cmd)
+			if err != nil {
+				return err
+			}
+
+			address := args[0]
+
+			queryClient := types.NewQueryClient(clientCtx)
+			res, err := queryClient.AuctionsByOwner(cmd.Context(), &types.AuctionsByOwnerRequest{OwnerAddress: address})
+			if err != nil {
+				return err
+			}
+
+			return clientCtx.PrintProto(res)
+		},
+	}
+
+	flags.AddQueryFlagsToCmd(cmd)
+	return cmd
+}
+
+// GetCmdQueryParams implements the params query command.
+func GetCmdQueryParams() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "params",
+		Args:  cobra.NoArgs,
+		Short: "Query the current auction parameters information.",
+		Long: strings.TrimSpace(
+			fmt.Sprintf(`Query values set as auction parameters.
+				Example:
+				$ %s query auction params
+				`,
+				version.AppName,
+			),
+		),
+		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.QueryParams(cmd.Context(), &types.QueryParamsRequest{})
+			if err != nil {
+				return err
+			}
+
+			return clientCtx.PrintProto(res)
+		},
+	}
+
+	flags.AddQueryFlagsToCmd(cmd)
+	return cmd
+}
+
+// GetCmdBalance queries the auction module account balance.
+func GetCmdBalance() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "balance",
+		Short: "Get auction module account balance.",
+		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.Balance(cmd.Context(), &types.BalanceRequest{})
+			if err != nil {
+				return err
+			}
+
+			return clientCtx.PrintProto(res)
+		},
+	}
+
+	flags.AddQueryFlagsToCmd(cmd)
+	return cmd
+}
@@ -0,0 +1,187 @@
+package cli
+
+import (
+	"encoding/hex"
+	"fmt"
+	"io/ioutil"
+	"time"
+
+	"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"
+	"github.com/spf13/viper"
+
+	"github.com/tharsis/ethermint/x/auction/types"
+
+	wnsUtils "github.com/tharsis/ethermint/utils"
+)
+
+// GetTxCmd returns transaction commands for this module.
+func GetTxCmd() *cobra.Command {
+	auctionTxCmd := &cobra.Command{
+		Use:                        types.ModuleName,
+		Short:                      "Auction transactions subcommands",
+		DisableFlagParsing:         true,
+		SuggestionsMinimumDistance: 2,
+		RunE:                       client.ValidateCmd,
+	}
+
+	auctionTxCmd.AddCommand(
+		GetCmdCreateAuction(),
+		GetCmdCommitBid(),
+		GetCmdRevealBid(),
+	)
+
+	return auctionTxCmd
+}
+
+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 := types.Params{
+				CommitsDuration: commitsDuration,
+				RevealsDuration: revealsDuration,
+				CommitFee:       commitFee,
+				RevealFee:       revealFee,
+				MinimumBid:      minimumBid,
+			}
+			msg := types.NewMsgCreateAuction(params, clientCtx.GetFromAddress())
+			err = msg.ValidateBasic()
+			if err != nil {
+				return err
+			}
+
+			return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), &msg)
+		},
+	}
+
+	flags.AddTxFlagsToCmd(cmd)
+	return cmd
+}
+
+// GetCmdCommitBid is the CLI command for committing a bid.
+func GetCmdCommitBid() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "commit-bid [auction-id] [bid-amount]",
+		Short: "Commit sealed bid.",
+		Args:  cobra.ExactArgs(2),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			clientCtx, err := client.GetClientTxContext(cmd)
+			if err != nil {
+				return err
+			}
+
+			bidAmount, err := sdk.ParseCoinNormalized(args[1])
+			if err != nil {
+				return err
+			}
+
+			mnemonic, err := wnsUtils.GenerateMnemonic()
+			if err != nil {
+				return err
+			}
+
+			chainID := viper.GetString("chain-id")
+			auctionID := args[0]
+
+			reveal := map[string]interface{}{
+				"chainId":       chainID,
+				"auctionId":     auctionID,
+				"bidderAddress": clientCtx.GetFromAddress().String(),
+				"bidAmount":     bidAmount.String(),
+				"noise":         mnemonic,
+			}
+
+			commitHash, content, err := wnsUtils.GenerateHash(reveal)
+			if err != nil {
+				return err
+			}
+
+			// Save reveal file.
+			ioutil.WriteFile(fmt.Sprintf("%s-%s.json", clientCtx.GetFromName(), commitHash), content, 0600)
+
+			msg := types.NewMsgCommitBid(auctionID, commitHash, clientCtx.GetFromAddress())
+			err = msg.ValidateBasic()
+			if err != nil {
+				return err
+			}
+
+			return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), &msg)
+		},
+	}
+
+	flags.AddTxFlagsToCmd(cmd)
+
+	return cmd
+}
+
+// GetCmdRevealBid is the CLI command for revealing a bid.
+func GetCmdRevealBid() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "reveal-bid [auction-id] [reveal-file-path]",
+		Short: "Reveal bid.",
+		Args:  cobra.ExactArgs(2),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			clientCtx, err := client.GetClientTxContext(cmd)
+			if err != nil {
+				return err
+			}
+
+			auctionID := args[0]
+			revealFilePath := args[1]
+
+			revealBytes, err := ioutil.ReadFile(revealFilePath)
+			if err != nil {
+				return err
+			}
+
+			msg := types.NewMsgRevealBid(auctionID, hex.EncodeToString(revealBytes), clientCtx.GetFromAddress())
+			err = msg.ValidateBasic()
+			if err != nil {
+				return err
+			}
+
+			return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), &msg)
+		},
+	}
+
+	flags.AddTxFlagsToCmd(cmd)
+
+	return cmd
+}
@@ -0,0 +1,16 @@
+package testutil
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/suite"
+
+	"github.com/tharsis/ethermint/testutil/network"
+)
+
+func TestIntegrationTestSuite(t *testing.T) {
+	cfg := network.DefaultConfig()
+	cfg.NumValidators = 1
+
+	suite.Run(t, NewIntegrationTestSuite(cfg))
+}
@@ -0,0 +1,80 @@
+package testutil
+
+import (
+	"fmt"
+
+	"github.com/cosmos/cosmos-sdk/client/flags"
+	"github.com/cosmos/cosmos-sdk/crypto/keyring"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	banktestutil "github.com/cosmos/cosmos-sdk/x/bank/client/testutil"
+	"github.com/stretchr/testify/suite"
+	tmcli "github.com/tendermint/tendermint/libs/cli"
+	"github.com/tharsis/ethermint/crypto/hd"
+	"github.com/tharsis/ethermint/testutil/network"
+)
+
+type IntegrationTestSuite struct {
+	suite.Suite
+
+	cfg              network.Config
+	network          *network.Network
+	defaultAuctionID string
+}
+
+var (
+	ownerAccount  = "owner"
+	bidderAccount = "bidder"
+	ownerAddress  string
+	bidderAddress string
+)
+
+func NewIntegrationTestSuite(cfg network.Config) *IntegrationTestSuite {
+	return &IntegrationTestSuite{cfg: cfg}
+}
+
+func (s *IntegrationTestSuite) SetupSuite() {
+	s.T().Log("setting up integration test suite")
+
+	var err error
+	s.network, err = network.New(s.T(), s.T().TempDir(), s.cfg)
+	s.Require().NoError(err)
+
+	_, err = s.network.WaitForHeight(1)
+	s.Require().NoError(err)
+
+	// setting up random owner and bidder accounts
+	s.createAccountWithBalance(ownerAccount, &ownerAddress)
+	s.createAccountWithBalance(bidderAccount, &bidderAddress)
+
+	s.defaultAuctionID = s.createAuctionAndBid(true, false)
+}
+
+func (s *IntegrationTestSuite) TearDownSuite() {
+	s.T().Log("tearing down integration test suite")
+	s.network.Cleanup()
+}
+
+func (s *IntegrationTestSuite) createAccountWithBalance(accountName string, accountAddress *string) {
+	val := s.network.Validators[0]
+	sr := s.Require()
+
+	info, _, err := val.ClientCtx.Keyring.NewMnemonic(accountName, keyring.English, sdk.FullFundraiserPath, keyring.DefaultBIP39Passphrase, hd.EthSecp256k1)
+	sr.NoError(err)
+
+	val.ClientCtx.Keyring.SavePubKey(accountName, info.GetPubKey(), hd.EthSecp256k1Type)
+
+	newAddr := sdk.AccAddress(info.GetPubKey().Address())
+	_, err = banktestutil.MsgSendExec(
+		val.ClientCtx,
+		val.Address,
+		newAddr,
+		sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, sdk.NewInt(200000))),
+		fmt.Sprintf("--%s=%s", flags.FlagFrom, accountName),
+		fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
+		fmt.Sprintf("--%s=json", tmcli.OutputFlag),
+		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock),
+		fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, sdk.NewInt(10))).String()),
+	)
+	sr.NoError(err)
+	*accountAddress = newAddr.String()
+}
@@ -0,0 +1,255 @@
+package testutil
+
+import (
+	"fmt"
+
+	"github.com/cosmos/cosmos-sdk/types/rest"
+	auctiontypes "github.com/tharsis/ethermint/x/auction/types"
+)
+
+const (
+	randomAuctionID     = "randomAuctionID"
+	randomBidderAddress = "randomBidderAddress"
+	randomOwnerAddress  = "randomOwnerAddress"
+)
+
+func (suite *IntegrationTestSuite) TestGetAllAuctionsGrpc() {
+	val := suite.network.Validators[0]
+	sr := suite.Require()
+	reqUrl := fmt.Sprintf("%s/vulcanize/auction/v1beta1/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 {
+		suite.Run(tc.msg, func() {
+			resp, err := rest.GetRequest(tc.url)
+			if tc.isErrorExpected {
+				sr.Contains(string(resp), tc.errorMsg)
+			} else {
+				sr.NoError(err)
+				var auctions auctiontypes.AuctionsResponse
+				err = val.ClientCtx.Codec.UnmarshalJSON(resp, &auctions)
+				sr.NotZero(len(auctions.Auctions.Auctions))
+			}
+		})
+	}
+}
+
+func (suite *IntegrationTestSuite) TestQueryParamsGrpc() {
+	val := suite.network.Validators[0]
+	sr := suite.Require()
+	reqUrl := fmt.Sprintf("%s/vulcanize/auction/v1beta1/params", val.APIAddress)
+
+	suite.Run("valid request to get auction params", func() {
+		resp, err := rest.GetRequest(reqUrl)
+		suite.Require().NoError(err)
+
+		var params auctiontypes.QueryParamsResponse
+		err = val.ClientCtx.Codec.UnmarshalJSON(resp, &params)
+
+		sr.NoError(err)
+		sr.Equal(*params.GetParams(), auctiontypes.DefaultParams())
+	})
+}
+
+func (suite *IntegrationTestSuite) TestGetAuctionGrpc() {
+	val := suite.network.Validators[0]
+	sr := suite.Require()
+	reqUrl := fmt.Sprintf("%s/vulcanize/auction/v1beta1/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 suite.defaultAuctionID },
+		},
+	}
+	for _, tc := range testCases {
+		suite.Run(tc.msg, func() {
+			auctionID := tc.preRun()
+			resp, err := rest.GetRequest(tc.url + auctionID)
+			if tc.isErrorExpected {
+				sr.Contains(string(resp), tc.errorMsg)
+			} else {
+				sr.NoError(err)
+				var auction auctiontypes.AuctionResponse
+				err = val.ClientCtx.Codec.UnmarshalJSON(resp, &auction)
+				sr.NoError(err)
+				sr.Equal(auctionID, auction.Auction.Id)
+			}
+		})
+	}
+}
+
+func (suite *IntegrationTestSuite) TestGetBidsGrpc() {
+	val := suite.network.Validators[0]
+	sr := suite.Require()
+	reqUrl := fmt.Sprintf("%s/vulcanize/auction/v1beta1/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 suite.createAuctionAndBid(false, true) },
+		},
+	}
+
+	for _, tc := range testCases {
+		suite.Run(tc.msg, func() {
+			auctionID := tc.preRun()
+			tc.url += auctionID
+			resp, err := rest.GetRequest(tc.url)
+			if tc.isErrorExpected {
+				sr.Contains(string(resp), tc.errorMsg)
+			} else {
+				sr.NoError(err)
+				var bids auctiontypes.BidsResponse
+				err = val.ClientCtx.Codec.UnmarshalJSON(resp, &bids)
+				sr.NoError(err)
+				sr.Equal(auctionID, bids.Bids[0].AuctionId)
+			}
+		})
+	}
+}
+
+func (suite *IntegrationTestSuite) TestGetBidGrpc() {
+	val := suite.network.Validators[0]
+	sr := suite.Require()
+	reqUrl := fmt.Sprintf("%s/vulcanize/auction/v1beta1/bids/", val.APIAddress)
+	testCases := []struct {
+		msg             string
+		url             string
+		errorMsg        string
+		isErrorExpected bool
+	}{
+		{
+			"invalid request to get bid",
+			fmt.Sprintf("%s/%s/", reqUrl, randomAuctionID),
+			"",
+			true,
+		},
+		{
+			"valid request to get bid",
+			fmt.Sprintf("%s/%s/%s", reqUrl, randomAuctionID, randomBidderAddress),
+			"",
+			false,
+		},
+	}
+	for _, tc := range testCases {
+		suite.Run(tc.msg, func() {
+			resp, err := rest.GetRequest(tc.url)
+			if tc.isErrorExpected {
+				sr.Contains(string(resp), tc.errorMsg)
+			} else {
+				sr.NoError(err)
+				var bid auctiontypes.BidResponse
+				err = val.ClientCtx.Codec.UnmarshalJSON(resp, &bid)
+				sr.NoError(err)
+			}
+		})
+	}
+}
+
+func (suite *IntegrationTestSuite) TestGetAuctionsByOwnerGrpc() {
+	val := suite.network.Validators[0]
+	sr := suite.Require()
+	reqUrl := fmt.Sprintf("%s/vulcanize/auction/v1beta1/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, randomOwnerAddress),
+			"",
+			false,
+		},
+	}
+	for _, tc := range testCases {
+		suite.Run(tc.msg, func() {
+			resp, err := rest.GetRequest(tc.url)
+			if tc.isErrorExpected {
+				sr.Contains(string(resp), tc.errorMsg)
+			} else {
+				sr.NoError(err)
+				var auctions auctiontypes.AuctionsResponse
+				err = val.ClientCtx.Codec.UnmarshalJSON(resp, &auctions)
+				sr.NoError(err)
+			}
+		})
+	}
+}
+
+func (suite *IntegrationTestSuite) TestQueryBalanceGrpc() {
+	val := suite.network.Validators[0]
+	sr := suite.Require()
+	reqUrl := fmt.Sprintf("%s/vulcanize/auction/v1beta1/balance", val.APIAddress)
+	msg := "valid request to get the auction module balance"
+
+	suite.createAuctionAndBid(false, true)
+
+	suite.Run(msg, func() {
+		resp, err := rest.GetRequest(reqUrl)
+		sr.NoError(err)
+
+		var response auctiontypes.BalanceResponse
+		err = val.ClientCtx.Codec.UnmarshalJSON(resp, &response)
+
+		sr.NoError(err)
+		sr.NotZero(len(response.GetBalance()))
+	})
+}
@@ -0,0 +1,311 @@
+package testutil
+
+import (
+	"fmt"
+
+	clitestutil "github.com/cosmos/cosmos-sdk/testutil/cli"
+	tmcli "github.com/tendermint/tendermint/libs/cli"
+	"github.com/tharsis/ethermint/x/auction/client/cli"
+	"github.com/tharsis/ethermint/x/auction/types"
+)
+
+var queryJSONFlag = []string{fmt.Sprintf("--%s=json", tmcli.OutputFlag)}
+
+func (suite *IntegrationTestSuite) TestGetCmdQueryParams() {
+	val := suite.network.Validators[0]
+	sr := suite.Require()
+
+	suite.Run(fmt.Sprintf("Case %s", "fetch query params"), func() {
+		out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cli.GetCmdQueryParams(), queryJSONFlag)
+		sr.NoError(err)
+		var params types.QueryParamsResponse
+		err = val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &params)
+		sr.NoError(err)
+		sr.Equal(types.DefaultParams(), *params.Params)
+	})
+}
+
+func (suite *IntegrationTestSuite) TestGetCmdBalance() {
+	val := suite.network.Validators[0]
+	sr := suite.Require()
+
+	testCases := []struct {
+		msg                 string
+		createAuctionAndBid bool
+	}{
+		{
+			"fetch module balance without creating auction and bid",
+			false,
+		},
+		{
+			"fetch module balance with valid auction and bid",
+			true,
+		},
+	}
+
+	for _, test := range testCases {
+		suite.Run(fmt.Sprintf("Case %s", test.msg), func() {
+			if test.createAuctionAndBid {
+				suite.createAuctionAndBid(false, true)
+			}
+
+			out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cli.GetCmdBalance(), queryJSONFlag)
+			sr.NoError(err)
+			var balance types.BalanceResponse
+			err = val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &balance)
+			sr.NoError(err)
+			if test.createAuctionAndBid {
+				sr.NotZero(len(balance.Balance))
+			}
+		})
+	}
+}
+
+func (suite *IntegrationTestSuite) TestGetCmdList() {
+	val := suite.network.Validators[0]
+	sr := suite.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 {
+		suite.Run(fmt.Sprintf("Case %s", test.msg), func() {
+			out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cli.GetCmdList(), queryJSONFlag)
+			sr.NoError(err)
+			var auctions types.AuctionsResponse
+			err = val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &auctions)
+			sr.NoError(err)
+			if test.createAuction {
+				sr.NotZero(len(auctions.Auctions.Auctions))
+			}
+		})
+	}
+}
+
+func (suite *IntegrationTestSuite) TestGetCmdGetBid() {
+	val := suite.network.Validators[0]
+	sr := suite.Require()
+
+	testCases := []struct {
+		msg                 string
+		args                []string
+		createAuctionAndBid bool
+	}{
+		{
+			"get bid without creating auction",
+			[]string{},
+			false,
+		},
+		{
+			"get bid after creating auction and bid",
+			[]string{},
+			true,
+		},
+	}
+
+	for _, test := range testCases {
+		suite.Run(fmt.Sprintf("Case %s", test.msg), func() {
+			if test.createAuctionAndBid {
+				auctionID := suite.createAuctionAndBid(false, true)
+				test.args = append(test.args, auctionID)
+				getBidsArgs := []string{auctionID, queryJSONFlag[0]}
+				out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cli.GetCmdGetBids(), getBidsArgs)
+				sr.NoError(err)
+				var bids types.BidsResponse
+				err = val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &bids)
+				sr.NoError(err)
+				test.args = append(test.args, bids.GetBids()[0].BidderAddress)
+			}
+
+			test.args = append(test.args, queryJSONFlag...)
+			out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cli.GetCmdGetBid(), test.args)
+			if test.createAuctionAndBid {
+				sr.NoError(err)
+				var bid types.BidResponse
+				err = val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &bid)
+				sr.NoError(err)
+				sr.NotNil(bid.GetBid())
+			} else {
+				sr.Error(err)
+			}
+		})
+	}
+}
+
+func (suite *IntegrationTestSuite) TestGetCmdGetBids() {
+	val := suite.network.Validators[0]
+	sr := suite.Require()
+
+	testCases := []struct {
+		msg                 string
+		args                []string
+		createAuctionAndBid bool
+	}{
+		{
+			"get bids without creating auction",
+			[]string{},
+			false,
+		},
+		{
+			"get bids after creating auction and bid",
+			[]string{},
+			true,
+		},
+	}
+
+	for _, test := range testCases {
+		suite.Run(fmt.Sprintf("Case %s", test.msg), func() {
+			if test.createAuctionAndBid {
+				auctionID := suite.createAuctionAndBid(false, true)
+				test.args = append(test.args, auctionID)
+			}
+
+			test.args = append(test.args, queryJSONFlag...)
+			out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cli.GetCmdGetBids(), test.args)
+			if test.createAuctionAndBid {
+				sr.NoError(err)
+				var bids types.BidsResponse
+				err = val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &bids)
+				sr.NoError(err)
+				sr.NotZero(len(bids.Bids))
+			} else {
+				sr.Error(err)
+			}
+		})
+	}
+}
+
+func (suite *IntegrationTestSuite) TestGetCmdGetAuction() {
+	val := suite.network.Validators[0]
+	sr := suite.Require()
+
+	testCases := []struct {
+		msg           string
+		auctionID     string
+		createAuction bool
+	}{
+		{
+			"get auction with empty auction ID",
+			"",
+			false,
+		},
+		{
+			"get auction with valid auction ID",
+			"",
+			true,
+		},
+	}
+
+	for _, test := range testCases {
+		suite.Run(fmt.Sprintf("Case %s", test.msg), func() {
+			if test.createAuction {
+				test.auctionID = suite.defaultAuctionID
+			}
+
+			args := []string{test.auctionID, queryJSONFlag[0]}
+			out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cli.GetCmdGetAuction(), args)
+			if test.createAuction {
+				sr.NoError(err)
+				var auction types.AuctionResponse
+				err = val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &auction)
+				sr.NoError(err)
+				sr.NotNil(auction.GetAuction())
+				sr.Equal(test.auctionID, auction.GetAuction().Id)
+			} else {
+				sr.Error(err)
+			}
+		})
+	}
+}
+
+func (suite *IntegrationTestSuite) TestGetCmdAuctionsByBidder() {
+	val := suite.network.Validators[0]
+	sr := suite.Require()
+
+	testCases := []struct {
+		msg                 string
+		createAuctionAndBid bool
+		bidderAddress       string
+	}{
+		{
+			"get auctions by bidder without creating auctions",
+			false,
+			"",
+		},
+		{
+			"get auctions by bidder for valid bidder address",
+			true,
+			"",
+		},
+	}
+
+	for _, test := range testCases {
+		suite.Run(fmt.Sprintf("Case %s", test.msg), func() {
+			if test.createAuctionAndBid {
+				auctionID := suite.createAuctionAndBid(false, true)
+				args := []string{auctionID, queryJSONFlag[0]}
+				out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cli.GetCmdGetBids(), args)
+				sr.NoError(err)
+				var bids types.BidsResponse
+				err = val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &bids)
+				sr.NoError(err)
+				test.bidderAddress = bids.Bids[0].BidderAddress
+			}
+
+			getByBidderArgs := []string{test.bidderAddress, queryJSONFlag[0]}
+			_, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cli.GetCmdAuctionsByBidder(), getByBidderArgs)
+			if test.createAuctionAndBid {
+				sr.NoError(err)
+			} else {
+				sr.Error(err)
+			}
+		})
+	}
+}
+
+func (suite IntegrationTestSuite) createAuctionAndBid(createAuction, createBid bool) string {
+	val := suite.network.Validators[0]
+	sr := suite.Require()
+	auctionID := ""
+
+	if createAuction {
+		auctionArgs := []string{
+			sampleCommitTime, sampleRevealTime,
+			fmt.Sprintf("10%s", suite.cfg.BondDenom),
+			fmt.Sprintf("10%s", suite.cfg.BondDenom),
+			fmt.Sprintf("100%s", suite.cfg.BondDenom),
+		}
+
+		resp, err := suite.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.AuctionsResponse
+		err = val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &queryResponse)
+		sr.NoError(err)
+		auctionID = queryResponse.Auctions.Auctions[0].Id
+	} else {
+		auctionID = suite.defaultAuctionID
+	}
+
+	if createBid {
+		bidArgs := []string{auctionID, fmt.Sprintf("200%s", suite.cfg.BondDenom)}
+		resp, err := suite.executeTx(cli.GetCmdCommitBid(), bidArgs, bidderAccount)
+		sr.NoError(err)
+		sr.Zero(resp.Code)
+	}
+
+	return auctionID
+}
@@ -0,0 +1,141 @@
+package testutil
+
+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"
+	tmcli "github.com/tendermint/tendermint/libs/cli"
+	"github.com/tharsis/ethermint/x/auction/client/cli"
+	"github.com/tharsis/ethermint/x/auction/types"
+)
+
+const (
+	sampleCommitTime     = "90s"
+	sampleRevealTime     = "5s"
+	placeholderAuctionID = "placeholder_auction_id"
+)
+
+func (suite *IntegrationTestSuite) TestTxCreateAuction() {
+	sr := suite.Require()
+	testCases := []struct {
+		msg       string
+		args      []string
+		expectErr bool
+	}{
+		{
+			"create auction with missing arguments",
+			[]string{sampleCommitTime, sampleRevealTime},
+			true,
+		},
+		{
+			"create auction with proper arguments",
+			[]string{
+				sampleCommitTime, sampleRevealTime,
+				fmt.Sprintf("10%s", suite.cfg.BondDenom),
+				fmt.Sprintf("10%s", suite.cfg.BondDenom),
+				fmt.Sprintf("100%s", suite.cfg.BondDenom),
+			},
+			false,
+		},
+	}
+
+	for _, test := range testCases {
+		suite.Run(fmt.Sprintf("Case %s", test.msg), func() {
+			resp, err := suite.executeTx(cli.GetCmdCreateAuction(), test.args, ownerAccount)
+			if test.expectErr {
+				sr.Error(err)
+			} else {
+				sr.NoError(err)
+				sr.Zero(resp.Code)
+			}
+		})
+	}
+}
+
+func (suite *IntegrationTestSuite) TestTxCommitBid() {
+	val := suite.network.Validators[0]
+	sr := suite.Require()
+	testCases := []struct {
+		msg           string
+		args          []string
+		createAuction bool
+	}{
+		{
+			"commit bid with missing args",
+			[]string{fmt.Sprintf("200%s", suite.cfg.BondDenom)},
+			false,
+		},
+		{
+			"commit bid with valid args",
+			[]string{
+				placeholderAuctionID,
+				fmt.Sprintf("200%s", suite.cfg.BondDenom),
+			},
+			true,
+		},
+	}
+
+	for _, test := range testCases {
+		suite.Run(fmt.Sprintf("Case %s", test.msg), func() {
+			if test.createAuction {
+				auctionArgs := []string{
+					sampleCommitTime, sampleRevealTime,
+					fmt.Sprintf("10%s", suite.cfg.BondDenom),
+					fmt.Sprintf("10%s", suite.cfg.BondDenom),
+					fmt.Sprintf("100%s", suite.cfg.BondDenom),
+				}
+				_, err := suite.executeTx(cli.GetCmdCreateAuction(), auctionArgs, ownerAccount)
+				sr.NoError(err)
+
+				out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cli.GetCmdList(),
+					[]string{fmt.Sprintf("--%s=json", tmcli.OutputFlag)})
+				sr.NoError(err)
+				var queryResponse types.AuctionsResponse
+				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 := suite.executeTx(cli.GetCmdCommitBid(), test.args, bidderAccount)
+			if test.createAuction {
+				sr.NoError(err)
+				sr.Zero(resp.Code)
+			} else {
+				sr.Error(err)
+			}
+		})
+	}
+}
+
+func (suite *IntegrationTestSuite) executeTx(cmd *cobra.Command, args []string, caller string) (sdk.TxResponse, error) {
+	val := suite.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.BroadcastBlock),
+		fmt.Sprintf("--%s=%s", flags.FlagFees, fmt.Sprintf("3%s", suite.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 = suite.network.WaitForNextBlock()
+	if err != nil {
+		return sdk.TxResponse{}, err
+	}
+
+	return resp, nil
+}
@@ -0,0 +1,44 @@
+package auction
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+
+	abci "github.com/tendermint/tendermint/abci/types"
+
+	"github.com/tharsis/ethermint/x/auction/keeper"
+	"github.com/tharsis/ethermint/x/auction/types"
+)
+
+// func NewGenesisState(params types.Params, auctions []types.Auction) types.GenesisState {
+// 	return types.GenesisState{Params: params, Auctions: &types.Auctions{Auctions: auctions}}
+// }
+
+func InitGenesis(ctx sdk.Context, keeper keeper.Keeper, data types.GenesisState) []abci.ValidatorUpdate {
+	keeper.SetParams(ctx, data.Params)
+
+	for _, auction := range data.Auctions {
+		keeper.SaveAuction(ctx, auction)
+	}
+
+	return []abci.ValidatorUpdate{}
+}
+
+func ExportGenesis(ctx sdk.Context, keeper keeper.Keeper) types.GenesisState {
+	params := keeper.GetParams(ctx)
+	auctions := keeper.ListAuctions(ctx)
+
+	var genesisAuctions []*types.Auction
+	for _, auction := range auctions {
+		genesisAuctions = append(genesisAuctions, &auction)
+	}
+	return types.GenesisState{Params: params, Auctions: genesisAuctions}
+}
+
+func ValidateGenesis(data types.GenesisState) error {
+	err := data.Params.Validate()
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
@@ -0,0 +1,91 @@
+package keeper
+
+import (
+	"context"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
+
+	"github.com/tharsis/ethermint/x/auction/types"
+)
+
+type Querier struct {
+	Keeper
+}
+
+var _ types.QueryServer = Querier{}
+
+// Auctions queries all auctions
+func (q Querier) Auctions(c context.Context, req *types.AuctionsRequest) (*types.AuctionsResponse, error) {
+	ctx := sdk.UnwrapSDKContext(c)
+	resp := q.Keeper.ListAuctions(ctx)
+	return &types.AuctionsResponse{Auctions: &types.Auctions{Auctions: resp}}, nil
+}
+
+// GetAuction queries an auction
+func (q Querier) GetAuction(c context.Context, req *types.AuctionRequest) (*types.AuctionResponse, error) {
+	ctx := sdk.UnwrapSDKContext(c)
+	if req.Id == "" {
+		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "auction ID is required")
+	}
+
+	resp := q.Keeper.GetAuction(ctx, req.Id)
+	return &types.AuctionResponse{Auction: resp}, nil
+}
+
+// GetBid queries and auction bid
+func (q Querier) GetBid(c context.Context, req *types.BidRequest) (*types.BidResponse, error) {
+	ctx := sdk.UnwrapSDKContext(c)
+	if req.AuctionId == "" {
+		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "auction ID is required")
+	}
+	if req.Bidder == "" {
+		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "bidder address is required")
+	}
+	resp := q.Keeper.GetBid(ctx, req.AuctionId, req.Bidder)
+	return &types.BidResponse{Bid: &resp}, nil
+}
+
+// GetBids queries all auction bids
+func (q Querier) GetBids(c context.Context, req *types.BidsRequest) (*types.BidsResponse, error) {
+	ctx := sdk.UnwrapSDKContext(c)
+	if req.AuctionId == "" {
+		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "auction ID is required")
+	}
+	resp := q.Keeper.GetBids(ctx, req.AuctionId)
+	return &types.BidsResponse{Bids: resp}, nil
+}
+
+// AuctionsByBidder queries auctions by bidder
+func (q Querier) AuctionsByBidder(c context.Context, req *types.AuctionsByBidderRequest) (*types.AuctionsByBidderResponse, error) {
+	ctx := sdk.UnwrapSDKContext(c)
+	if req.BidderAddress == "" {
+		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "bidder address is required")
+	}
+	resp := q.Keeper.QueryAuctionsByBidder(ctx, req.BidderAddress)
+	return &types.AuctionsByBidderResponse{Auctions: &types.Auctions{Auctions: resp}}, nil
+}
+
+// AuctionsByOwner queries auctions by owner
+func (q Querier) AuctionsByOwner(c context.Context, req *types.AuctionsByOwnerRequest) (*types.AuctionsByOwnerResponse, error) {
+	ctx := sdk.UnwrapSDKContext(c)
+	if req.OwnerAddress == "" {
+		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "owner address is required")
+	}
+	resp := q.Keeper.QueryAuctionsByOwner(ctx, req.OwnerAddress)
+	return &types.AuctionsByOwnerResponse{Auctions: &types.Auctions{Auctions: resp}}, nil
+}
+
+// QueryParams implements the params query command
+func (q Querier) QueryParams(c context.Context, req *types.QueryParamsRequest) (*types.QueryParamsResponse, error) {
+	ctx := sdk.UnwrapSDKContext(c)
+	resp := q.Keeper.GetParams(ctx)
+	return &types.QueryParamsResponse{Params: &resp}, nil
+}
+
+// Balance queries the auction module account balance
+func (q Querier) Balance(c context.Context, req *types.BalanceRequest) (*types.BalanceResponse, error) {
+	ctx := sdk.UnwrapSDKContext(c)
+	resp := q.Keeper.GetAuctionModuleBalances(ctx)
+	return &types.BalanceResponse{Balance: resp}, nil
+}
@@ -0,0 +1,355 @@
+package keeper_test
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/cosmos/cosmos-sdk/simapp"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/tharsis/ethermint/app"
+	"github.com/tharsis/ethermint/x/auction/types"
+)
+
+const testCommitHash = "71D8CF34026E32A3A34C2C2D4ADF25ABC8D7943A4619761BE27F196603D91B9D"
+
+func (suite *KeeperTestSuite) TestGrpcGetAllAuctions() {
+	client, ctx, k := suite.queryClient, suite.ctx, suite.app.AuctionKeeper
+
+	testCases := []struct {
+		msg            string
+		req            *types.AuctionsRequest
+		createAuctions bool
+		auctionCount   int
+	}{
+		{
+			"fetch auctions when no auctions exist",
+			&types.AuctionsRequest{},
+			false,
+			0,
+		},
+
+		{
+			"fetch auctions with one auction created",
+			&types.AuctionsRequest{},
+			true,
+			1,
+		},
+	}
+
+	for _, test := range testCases {
+		suite.Run(fmt.Sprintf("Case %s", test.msg), func() {
+			if test.createAuctions {
+				account := app.CreateRandomAccounts(1)[0]
+				err := simapp.FundAccount(suite.app.BankKeeper, ctx, account, sdk.NewCoins(
+					sdk.Coin{Amount: sdk.NewInt(100), Denom: sdk.DefaultBondDenom},
+				))
+
+				_, err = k.CreateAuction(ctx, types.NewMsgCreateAuction(k.GetParams(ctx), account))
+				suite.Require().NoError(err)
+			}
+
+			resp, _ := client.Auctions(context.Background(), test.req)
+			suite.Require().Equal(test.auctionCount, len(resp.GetAuctions().Auctions))
+		})
+	}
+}
+
+func (suite *KeeperTestSuite) TestGrpcQueryParams() {
+	testCases := []struct {
+		msg string
+		req *types.QueryParamsRequest
+	}{
+		{
+			"fetch params",
+			&types.QueryParamsRequest{},
+		},
+	}
+	for _, test := range testCases {
+		suite.Run(fmt.Sprintf("Case %s", test.msg), func() {
+			resp, err := suite.queryClient.QueryParams(context.Background(), test.req)
+			suite.Require().Nil(err)
+			suite.Require().Equal(*(resp.Params), types.DefaultParams())
+		})
+	}
+}
+
+func (suite *KeeperTestSuite) TestGrpcGetAuction() {
+	testCases := []struct {
+		msg           string
+		req           *types.AuctionRequest
+		createAuction bool
+	}{
+		{
+			"fetch auction with empty auction ID",
+			&types.AuctionRequest{},
+			false,
+		},
+		{
+			"fetch auction with valid auction ID",
+			&types.AuctionRequest{},
+			true,
+		},
+	}
+
+	for _, test := range testCases {
+		suite.Run(fmt.Sprintf("Case %s", test.msg), func() {
+			if test.createAuction {
+				auction, _, err := suite.createAuctionAndCommitBid(false)
+				suite.Require().NoError(err)
+				test.req.Id = auction.Id
+			}
+
+			resp, err := suite.queryClient.GetAuction(context.Background(), test.req)
+			if test.createAuction {
+				suite.Require().Nil(err)
+				suite.Require().NotNil(resp.GetAuction())
+				suite.Require().Equal(test.req.Id, resp.GetAuction().Id)
+			} else {
+				suite.Require().NotNil(err)
+				suite.Require().Error(err)
+			}
+		})
+	}
+}
+
+func (suite *KeeperTestSuite) TestGrpcGetBids() {
+	testCases := []struct {
+		msg           string
+		req           *types.BidsRequest
+		createAuction bool
+		commitBid     bool
+		bidCount      int
+	}{
+		{
+			"fetch all bids when no auction exists",
+			&types.BidsRequest{},
+			false,
+			false,
+			0,
+		},
+		{
+			"fetch all bids for valid auction but no added bids",
+			&types.BidsRequest{},
+			true,
+			false,
+			0,
+		},
+		{
+			"fetch all bids for valid auction and valid bid",
+			&types.BidsRequest{},
+			true,
+			true,
+			1,
+		},
+	}
+
+	for _, test := range testCases {
+		suite.Run(fmt.Sprintf("Case %s", test.msg), func() {
+			if test.createAuction {
+				auction, _, err := suite.createAuctionAndCommitBid(test.commitBid)
+				suite.Require().NoError(err)
+				test.req.AuctionId = auction.Id
+			}
+
+			resp, err := suite.queryClient.GetBids(context.Background(), test.req)
+			if test.createAuction {
+				suite.Require().Nil(err)
+				suite.Require().Equal(test.bidCount, len(resp.GetBids()))
+			} else {
+				suite.Require().NotNil(err)
+				suite.Require().Error(err)
+			}
+		})
+	}
+}
+
+func (suite *KeeperTestSuite) TestGrpcGetBid() {
+	testCases := []struct {
+		msg                 string
+		req                 *types.BidRequest
+		createAuctionAndBid bool
+	}{
+		{
+			"fetch bid when bid does not exist",
+			&types.BidRequest{},
+			false,
+		},
+		{
+			"fetch bid when valid bid exists",
+			&types.BidRequest{},
+			true,
+		},
+	}
+
+	for _, test := range testCases {
+		suite.Run(fmt.Sprintf("Case %s", test.msg), func() {
+			if test.createAuctionAndBid {
+				auction, bid, err := suite.createAuctionAndCommitBid(test.createAuctionAndBid)
+				suite.Require().NoError(err)
+				test.req.AuctionId = auction.Id
+				test.req.Bidder = bid.BidderAddress
+			}
+
+			resp, err := suite.queryClient.GetBid(context.Background(), test.req)
+			if test.createAuctionAndBid {
+				suite.Require().NoError(err)
+				suite.Require().NotNil(resp.Bid)
+				suite.Require().Equal(test.req.Bidder, resp.Bid.BidderAddress)
+			} else {
+				suite.Require().NotNil(err)
+				suite.Require().Error(err)
+			}
+		})
+	}
+}
+
+func (suite *KeeperTestSuite) TestGrpcGetAuctionsByBidder() {
+	testCases := []struct {
+		msg                       string
+		req                       *types.AuctionsByBidderRequest
+		createAuctionAndCommitBid bool
+		auctionCount              int
+	}{
+		{
+			"get auctions by bidder with invalid bidder address",
+			&types.AuctionsByBidderRequest{},
+			false,
+			0,
+		},
+		{
+			"get auctions by bidder with valid auction and bid",
+			&types.AuctionsByBidderRequest{},
+			true,
+			1,
+		},
+	}
+
+	for _, test := range testCases {
+		suite.Run(fmt.Sprintf("Case %s", test.msg), func() {
+			if test.createAuctionAndCommitBid {
+				_, bid, err := suite.createAuctionAndCommitBid(test.createAuctionAndCommitBid)
+				suite.Require().NoError(err)
+				test.req.BidderAddress = bid.BidderAddress
+			}
+
+			resp, err := suite.queryClient.AuctionsByBidder(context.Background(), test.req)
+			if test.createAuctionAndCommitBid {
+				suite.Require().NoError(err)
+				suite.Require().NotNil(resp.Auctions)
+				suite.Require().Equal(test.auctionCount, len(resp.Auctions.Auctions))
+			} else {
+				suite.Require().NotNil(err)
+				suite.Require().Error(err)
+			}
+		})
+	}
+}
+
+func (suite *KeeperTestSuite) TestGrpcGetAuctionsByOwner() {
+	testCases := []struct {
+		msg           string
+		req           *types.AuctionsByOwnerRequest
+		createAuction bool
+		auctionCount  int
+	}{
+		{
+			"get auctions by owner with invalid owner address",
+			&types.AuctionsByOwnerRequest{},
+			false,
+			0,
+		},
+		{
+			"get auctions by owner with valid auction",
+			&types.AuctionsByOwnerRequest{},
+			true,
+			1,
+		},
+	}
+
+	for _, test := range testCases {
+		suite.Run(fmt.Sprintf("Case %s", test.msg), func() {
+			if test.createAuction {
+				auction, _, err := suite.createAuctionAndCommitBid(false)
+				suite.Require().NoError(err)
+				test.req.OwnerAddress = auction.OwnerAddress
+			}
+
+			resp, err := suite.queryClient.AuctionsByOwner(context.Background(), test.req)
+			if test.createAuction {
+				suite.Require().NoError(err)
+				suite.Require().NotNil(resp.Auctions)
+				suite.Require().Equal(test.auctionCount, len(resp.Auctions.Auctions))
+			} else {
+				suite.Require().NotNil(err)
+				suite.Require().Error(err)
+			}
+		})
+	}
+}
+
+func (suite KeeperTestSuite) TestGrpcQueryBalance() {
+	testCases := []struct {
+		msg           string
+		req           *types.BalanceRequest
+		createAuction bool
+		auctionCount  int
+	}{
+		{
+			"get balance with no auctions created",
+			&types.BalanceRequest{},
+			false,
+			0,
+		},
+		{
+			"get balance with single auction created",
+			&types.BalanceRequest{},
+			true,
+			1,
+		},
+	}
+
+	for _, test := range testCases {
+		if test.createAuction {
+			_, _, err := suite.createAuctionAndCommitBid(true)
+			suite.Require().NoError(err)
+		}
+
+		resp, err := suite.queryClient.Balance(context.Background(), test.req)
+		suite.Require().NoError(err)
+		suite.Require().Equal(test.auctionCount, len(resp.GetBalance()))
+	}
+}
+
+func (suite *KeeperTestSuite) createAuctionAndCommitBid(commitBid bool) (*types.Auction, *types.Bid, error) {
+	ctx, k := suite.ctx, suite.app.AuctionKeeper
+	accCount := 1
+	if commitBid {
+		accCount++
+	}
+
+	accounts := app.CreateRandomAccounts(accCount)
+	for _, account := range accounts {
+		err := simapp.FundAccount(suite.app.BankKeeper, ctx, account, sdk.NewCoins(
+			sdk.Coin{Amount: sdk.NewInt(100), Denom: sdk.DefaultBondDenom},
+		))
+		if err != nil {
+			return nil, nil, err
+		}
+	}
+
+	auction, err := k.CreateAuction(ctx, types.NewMsgCreateAuction(k.GetParams(ctx), accounts[0]))
+	if err != nil {
+		return nil, nil, err
+	}
+
+	if commitBid {
+		bid, err := k.CommitBid(ctx, types.NewMsgCommitBid(auction.Id, testCommitHash, accounts[1]))
+		if err != nil {
+			return nil, nil, err
+		}
+
+		return auction, bid, nil
+	}
+
+	return auction, nil, nil
+}
@@ -0,0 +1,37 @@
+package keeper
+
+import (
+	"fmt"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+
+	"github.com/tharsis/ethermint/x/auction/types"
+)
+
+// RegisterInvariants registers all auction module invariants.
+func RegisterInvariants(ir sdk.InvariantRegistry, k Keeper) {
+	ir.RegisterRoute(types.ModuleName, "module-account", ModuleAccountInvariant(k))
+}
+
+// ModuleAccountInvariant checks that the 'auction' module account balance is non-negative.
+func ModuleAccountInvariant(k Keeper) sdk.Invariant {
+	return func(ctx sdk.Context) (string, bool) {
+		moduleAddress := k.accountKeeper.GetModuleAddress(types.ModuleName)
+		if k.bankKeeper.GetAllBalances(ctx, moduleAddress).IsAnyNegative() {
+			return sdk.FormatInvariant(
+					types.ModuleName,
+					"module-account",
+					fmt.Sprintf("Module account '%s' has negative balance.", types.ModuleName)),
+				true
+		}
+
+		return "", false
+	}
+}
+
+// AllInvariants runs all invariants of the auctions module.
+func AllInvariants(k Keeper) sdk.Invariant {
+	return func(ctx sdk.Context) (string, bool) {
+		return ModuleAccountInvariant(k)(ctx)
+	}
+}
@@ -0,0 +1,658 @@
+package keeper
+
+import (
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"time"
+
+	"github.com/cosmos/cosmos-sdk/codec"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
+	auth "github.com/cosmos/cosmos-sdk/x/auth/keeper"
+	bank "github.com/cosmos/cosmos-sdk/x/bank/keeper"
+	params "github.com/cosmos/cosmos-sdk/x/params/types"
+
+	"github.com/tharsis/ethermint/x/auction/types"
+
+	wnsUtils "github.com/tharsis/ethermint/utils"
+)
+
+// CompletedAuctionDeleteTimeout => Completed auctions are deleted after this timeout (after reveals end time).
+const CompletedAuctionDeleteTimeout = time.Hour * 24
+
+// PrefixIDToAuctionIndex is the prefix for Id -> Auction index in the KVStore.
+// Note: This is the primary index in the system.
+// Note: Golang doesn't support const arrays.
+var PrefixIDToAuctionIndex = []byte{0x00}
+
+// prefixOwnerToAuctionsIndex is the prefix for the Owner -> [Auction] index in the KVStore.
+var prefixOwnerToAuctionsIndex = []byte{0x01}
+
+// PrefixAuctionBidsIndex is the prefix for the (auction, bidder) -> Bid index in the KVStore.
+var PrefixAuctionBidsIndex = []byte{0x02}
+
+// PrefixBidderToAuctionsIndex is the prefix for the Bidder -> [Auction] index in the KVStore.
+var PrefixBidderToAuctionsIndex = []byte{0x03}
+
+// Keeper maintains the link to storage and exposes getter/setter methods for the various parts of the state machine
+type Keeper struct {
+	accountKeeper auth.AccountKeeper
+	bankKeeper    bank.Keeper
+
+	// Track auction usage in other cosmos-sdk modules (more like a usage tracker).
+	usageKeepers []types.AuctionUsageKeeper
+
+	storeKey sdk.StoreKey // Unexposed key to access store from sdk.Context
+
+	cdc codec.BinaryCodec // The wire codec for binary encoding/decoding.
+
+	paramSubspace params.Subspace
+}
+
+// AuctionClientKeeper is the subset of functionality exposed to other modules.
+type AuctionClientKeeper interface {
+	HasAuction(ctx sdk.Context, id string) bool
+	GetAuction(ctx sdk.Context, id string) types.Auction
+	MatchAuctions(ctx sdk.Context, matchFn func(*types.Auction) bool) []*types.Auction
+}
+
+// NewKeeper creates new instances of the auction Keeper
+func NewKeeper(accountKeeper auth.AccountKeeper, bankKeeper bank.Keeper, storeKey sdk.StoreKey, cdc codec.BinaryCodec, ps params.Subspace) Keeper {
+	if !ps.HasKeyTable() {
+		ps = ps.WithKeyTable(types.ParamKeyTable())
+	}
+
+	return Keeper{
+		accountKeeper: accountKeeper,
+		bankKeeper:    bankKeeper,
+		storeKey:      storeKey,
+		cdc:           cdc,
+		paramSubspace: ps,
+	}
+}
+
+func (k *Keeper) SetUsageKeepers(usageKeepers []types.AuctionUsageKeeper) {
+	k.usageKeepers = usageKeepers
+}
+
+func (k Keeper) GetUsageKeepers() []types.AuctionUsageKeeper {
+	return k.usageKeepers
+}
+
+// Generates Auction Id -> Auction index key.
+func GetAuctionIndexKey(id string) []byte {
+	return append(PrefixIDToAuctionIndex, []byte(id)...)
+}
+
+// Generates Owner -> Auctions index key.
+func GetOwnerToAuctionsIndexKey(owner string, auctionID string) []byte {
+	return append(append(prefixOwnerToAuctionsIndex, []byte(owner)...), []byte(auctionID)...)
+}
+
+func GetBidderToAuctionsIndexKey(bidder string, auctionID string) []byte {
+	return append(append(PrefixBidderToAuctionsIndex, []byte(bidder)...), []byte(auctionID)...)
+}
+
+func GetBidIndexKey(auctionID string, bidder string) []byte {
+	return append(GetAuctionBidsIndexPrefix(auctionID), []byte(bidder)...)
+}
+
+func GetAuctionBidsIndexPrefix(auctionID string) []byte {
+	return append(append(PrefixAuctionBidsIndex, []byte(auctionID)...))
+}
+
+// SaveAuction - saves a auction to the store.
+func (k Keeper) SaveAuction(ctx sdk.Context, auction *types.Auction) {
+	store := ctx.KVStore(k.storeKey)
+
+	// Auction Id -> Auction index.
+	store.Set(GetAuctionIndexKey(auction.Id), k.cdc.MustMarshal(auction))
+
+	// Owner -> [Auction] index.
+	store.Set(GetOwnerToAuctionsIndexKey(auction.OwnerAddress, auction.Id), []byte{})
+
+	// Notify interested parties.
+	for _, keeper := range k.usageKeepers {
+		keeper.OnAuction(ctx, auction.Id)
+	}
+}
+
+func (k Keeper) SaveBid(ctx sdk.Context, bid *types.Bid) {
+	store := ctx.KVStore(k.storeKey)
+	store.Set(GetBidIndexKey(bid.AuctionId, bid.BidderAddress), k.cdc.MustMarshal(bid))
+	store.Set(GetBidderToAuctionsIndexKey(bid.BidderAddress, bid.AuctionId), []byte{})
+
+	// Notify interested parties.
+	for _, keeper := range k.usageKeepers {
+		keeper.OnAuctionBid(ctx, bid.AuctionId, bid.BidderAddress)
+	}
+}
+
+func (k Keeper) DeleteBid(ctx sdk.Context, bid types.Bid) {
+	store := ctx.KVStore(k.storeKey)
+	store.Delete(GetBidIndexKey(bid.AuctionId, bid.BidderAddress))
+	store.Delete(GetOwnerToAuctionsIndexKey(bid.BidderAddress, bid.AuctionId))
+}
+
+// HasAuction - checks if a auction by the given Id exists.
+func (k Keeper) HasAuction(ctx sdk.Context, id string) bool {
+	store := ctx.KVStore(k.storeKey)
+	return store.Has(GetAuctionIndexKey(id))
+}
+
+func (k Keeper) HasBid(ctx sdk.Context, id string, bidder string) bool {
+	store := ctx.KVStore(k.storeKey)
+	return store.Has(GetBidIndexKey(id, bidder))
+}
+
+// DeleteAuction - deletes the auction.
+func (k Keeper) DeleteAuction(ctx sdk.Context, auction types.Auction) {
+	// Delete all bids first.
+	bids := k.GetBids(ctx, auction.Id)
+	for _, bid := range bids {
+		k.DeleteBid(ctx, *bid)
+	}
+
+	// Delete the auction itself.
+	store := ctx.KVStore(k.storeKey)
+	store.Delete(GetAuctionIndexKey(auction.Id))
+	store.Delete(GetOwnerToAuctionsIndexKey(auction.OwnerAddress, auction.Id))
+}
+
+// GetAuction - gets a record from the store.
+func (k Keeper) GetAuction(ctx sdk.Context, id string) *types.Auction {
+	store := ctx.KVStore(k.storeKey)
+	auctionKey := GetAuctionIndexKey(id)
+	if !store.Has(auctionKey) {
+		return nil
+	}
+
+	bz := store.Get(auctionKey)
+	var obj types.Auction
+	k.cdc.MustUnmarshal(bz, &obj)
+
+	return &obj
+}
+
+// GetBids gets the auction bids.
+func (k Keeper) GetBids(ctx sdk.Context, id string) []*types.Bid {
+	store := ctx.KVStore(k.storeKey)
+	bids := []*types.Bid{}
+	itr := sdk.KVStorePrefixIterator(store, GetAuctionBidsIndexPrefix(id))
+	defer itr.Close()
+	for ; itr.Valid(); itr.Next() {
+		bz := store.Get(itr.Key())
+		if bz != nil {
+			var obj types.Bid
+			k.cdc.MustUnmarshal(bz, &obj)
+			bids = append(bids, &obj)
+		}
+	}
+
+	return bids
+}
+
+func (k Keeper) GetBid(ctx sdk.Context, id string, bidder string) types.Bid {
+	store := ctx.KVStore(k.storeKey)
+
+	bz := store.Get(GetBidIndexKey(id, bidder))
+	var obj types.Bid
+	k.cdc.MustUnmarshal(bz, &obj)
+
+	return obj
+}
+
+// ListAuctions - get all auctions.
+func (k Keeper) ListAuctions(ctx sdk.Context) []types.Auction {
+	var auctions []types.Auction
+
+	store := ctx.KVStore(k.storeKey)
+	itr := sdk.KVStorePrefixIterator(store, PrefixIDToAuctionIndex)
+	defer itr.Close()
+	for ; itr.Valid(); itr.Next() {
+		bz := store.Get(itr.Key())
+		if bz != nil {
+			var obj types.Auction
+			k.cdc.MustUnmarshal(bz, &obj)
+			auctions = append(auctions, obj)
+		}
+	}
+
+	return auctions
+}
+
+// QueryAuctionsByOwner - query auctions by owner.
+func (k Keeper) QueryAuctionsByOwner(ctx sdk.Context, ownerAddress string) []types.Auction {
+	auctions := []types.Auction{}
+
+	ownerPrefix := append(prefixOwnerToAuctionsIndex, []byte(ownerAddress)...)
+	store := ctx.KVStore(k.storeKey)
+	itr := sdk.KVStorePrefixIterator(store, ownerPrefix)
+	defer itr.Close()
+	for ; itr.Valid(); itr.Next() {
+		auctionID := itr.Key()[len(ownerPrefix):]
+		bz := store.Get(append(PrefixIDToAuctionIndex, auctionID...))
+		if bz != nil {
+			var obj types.Auction
+			k.cdc.MustUnmarshal(bz, &obj)
+			auctions = append(auctions, obj)
+		}
+	}
+
+	return auctions
+}
+
+// QueryAuctionsByBidder - query auctions by bidder
+func (k Keeper) QueryAuctionsByBidder(ctx sdk.Context, bidderAddress string) []types.Auction {
+	auctions := []types.Auction{}
+
+	bidderPrefix := append(PrefixBidderToAuctionsIndex, []byte(bidderAddress)...)
+	store := ctx.KVStore(k.storeKey)
+	itr := sdk.KVStorePrefixIterator(store, []byte(bidderPrefix))
+	defer itr.Close()
+	for ; itr.Valid(); itr.Next() {
+		auctionID := itr.Key()[len(bidderPrefix):]
+		bz := store.Get(append(PrefixIDToAuctionIndex, auctionID...))
+		if bz != nil {
+			var obj types.Auction
+			k.cdc.MustUnmarshal(bz, &obj)
+			auctions = append(auctions, obj)
+		}
+	}
+
+	return auctions
+}
+
+// MatchAuctions - get all matching auctions.
+func (k Keeper) MatchAuctions(ctx sdk.Context, matchFn func(*types.Auction) bool) []*types.Auction {
+	var auctions []*types.Auction
+
+	store := ctx.KVStore(k.storeKey)
+	itr := sdk.KVStorePrefixIterator(store, PrefixIDToAuctionIndex)
+	defer itr.Close()
+	for ; itr.Valid(); itr.Next() {
+		bz := store.Get(itr.Key())
+		if bz != nil {
+			var obj types.Auction
+			k.cdc.MustUnmarshal(bz, &obj)
+			if matchFn(&obj) {
+				auctions = append(auctions, &obj)
+			}
+		}
+	}
+
+	return auctions
+}
+
+// CreateAuction creates a new auction.
+func (k Keeper) CreateAuction(ctx sdk.Context, msg types.MsgCreateAuction) (*types.Auction, error) {
+	// Might be called from another module directly, always validate.
+	err := msg.ValidateBasic()
+	if err != nil {
+		return nil, err
+	}
+
+	signerAddress, err := sdk.AccAddressFromBech32(msg.Signer)
+	if err != nil {
+		return nil, err
+	}
+
+	// Generate auction Id.
+	account := k.accountKeeper.GetAccount(ctx, signerAddress)
+	if account == nil {
+		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, "Account not found.")
+	}
+
+	auctionID := types.AuctionID{
+		Address:  signerAddress,
+		AccNum:   account.GetAccountNumber(),
+		Sequence: account.GetSequence(),
+	}.Generate()
+
+	// Compute timestamps.
+	now := ctx.BlockTime()
+	commitsEndTime := now.Add(time.Duration(msg.CommitsDuration))
+	revealsEndTime := now.Add(time.Duration(msg.CommitsDuration + msg.RevealsDuration))
+
+	auction := types.Auction{
+		Id:             auctionID,
+		Status:         types.AuctionStatusCommitPhase,
+		OwnerAddress:   signerAddress.String(),
+		CreateTime:     now,
+		CommitsEndTime: commitsEndTime,
+		RevealsEndTime: revealsEndTime,
+		CommitFee:      msg.CommitFee,
+		RevealFee:      msg.RevealFee,
+		MinimumBid:     msg.MinimumBid,
+	}
+
+	// Save auction in store.
+	k.SaveAuction(ctx, &auction)
+
+	return &auction, nil
+}
+
+func (k Keeper) CommitBid(ctx sdk.Context, msg types.MsgCommitBid) (*types.Bid, error) {
+	if !k.HasAuction(ctx, msg.AuctionId) {
+		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "Auction not found.")
+	}
+
+	auction := k.GetAuction(ctx, msg.AuctionId)
+	if auction.Status != types.AuctionStatusCommitPhase {
+		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "Auction is not in commit phase.")
+	}
+
+	signerAddress, err := sdk.AccAddressFromBech32(msg.Signer)
+	if err != nil {
+		return nil, err
+	}
+
+	// Take auction fees from account.
+	totalFee := auction.CommitFee.Add(auction.RevealFee)
+	sdkErr := k.bankKeeper.SendCoinsFromAccountToModule(ctx, signerAddress, types.ModuleName, sdk.NewCoins(totalFee))
+	if sdkErr != nil {
+		return nil, sdkErr
+	}
+
+	// Check if an old bid already exists, if so, return old bids auction fee (update bid scenario).
+	bidder := signerAddress.String()
+	if k.HasBid(ctx, msg.AuctionId, bidder) {
+		oldBid := k.GetBid(ctx, msg.AuctionId, bidder)
+		oldTotalFee := oldBid.CommitFee.Add(oldBid.RevealFee)
+		sdkErr := k.bankKeeper.SendCoinsFromModuleToAccount(ctx, types.ModuleName, signerAddress, sdk.NewCoins(oldTotalFee))
+		if sdkErr != nil {
+			return nil, sdkErr
+		}
+	}
+
+	// Save new bid.
+	bid := types.Bid{
+		AuctionId:     msg.AuctionId,
+		BidderAddress: bidder,
+		Status:        types.BidStatusCommitted,
+		CommitHash:    msg.CommitHash,
+		CommitTime:    ctx.BlockTime(),
+		CommitFee:     auction.CommitFee,
+		RevealFee:     auction.RevealFee,
+	}
+
+	k.SaveBid(ctx, &bid)
+
+	return &bid, nil
+}
+
+// RevealBid reeals a bid comitted earlier.
+func (k Keeper) RevealBid(ctx sdk.Context, msg types.MsgRevealBid) (*types.Auction, error) {
+	if !k.HasAuction(ctx, msg.AuctionId) {
+		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "Auction not found.")
+	}
+
+	auction := k.GetAuction(ctx, msg.AuctionId)
+	if auction.Status != types.AuctionStatusRevealPhase {
+		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "Auction is not in reveal phase.")
+	}
+
+	signerAddress, err := sdk.AccAddressFromBech32(msg.Signer)
+	if err != nil {
+		return nil, err
+	}
+
+	if !k.HasBid(ctx, msg.AuctionId, signerAddress.String()) {
+		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "Bid not found.")
+	}
+
+	bid := k.GetBid(ctx, auction.Id, signerAddress.String())
+	if bid.Status != types.BidStatusCommitted {
+		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "Bid not in committed state.")
+	}
+
+	revealBytes, err := hex.DecodeString(msg.Reveal)
+	if err != nil {
+		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "Invalid reveal string.")
+	}
+
+	cid, err := wnsUtils.CIDFromJSONBytes(revealBytes)
+	if err != nil {
+		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "Invalid reveal JSON.")
+	}
+
+	if bid.CommitHash != cid {
+		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "Commit hash mismatch.")
+	}
+
+	var reveal map[string]interface{}
+	err = json.Unmarshal(revealBytes, &reveal)
+	if err != nil {
+		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "Reveal JSON unmarshal error.")
+	}
+
+	chainID, err := wnsUtils.GetAttributeAsString(reveal, "chainId")
+	if err != nil || chainID != ctx.ChainID() {
+		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "Invalid reveal chainID.")
+	}
+
+	auctionID, err := wnsUtils.GetAttributeAsString(reveal, "auctionId")
+	if err != nil || auctionID != msg.AuctionId {
+		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "Invalid reveal auction Id.")
+	}
+
+	bidderAddress, err := wnsUtils.GetAttributeAsString(reveal, "bidderAddress")
+	if err != nil {
+		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "Invalid reveal bid address.")
+	}
+
+	if bidderAddress != signerAddress.String() {
+		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "Reveal bid address mismatch.")
+	}
+
+	bidAmountStr, err := wnsUtils.GetAttributeAsString(reveal, "bidAmount")
+	if err != nil {
+		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "Invalid reveal bid amount.")
+	}
+
+	bidAmount, err := sdk.ParseCoinNormalized(bidAmountStr)
+	if err != nil {
+		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "Invalid reveal bid amount.")
+	}
+
+	if bidAmount.IsLT(auction.MinimumBid) {
+		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "Bid is lower than minimum bid.")
+	}
+
+	// Lock bid amount.
+	sdkErr := k.bankKeeper.SendCoinsFromAccountToModule(ctx, signerAddress, types.ModuleName, sdk.NewCoins(bidAmount))
+	if sdkErr != nil {
+		return nil, sdkErr
+	}
+
+	// Update bid.
+	bid.BidAmount = bidAmount
+	bid.RevealTime = ctx.BlockTime()
+	bid.Status = types.BidStatusRevealed
+	k.SaveBid(ctx, &bid)
+
+	return auction, nil
+}
+
+// GetAuctionModuleBalances gets the auction module account(s) balances.
+func (k Keeper) GetAuctionModuleBalances(ctx sdk.Context) sdk.Coins {
+	moduleAddress := k.accountKeeper.GetModuleAddress(types.ModuleName)
+	balances := k.bankKeeper.GetAllBalances(ctx, moduleAddress)
+	return balances
+}
+
+func (k Keeper) EndBlockerProcessAuctions(ctx sdk.Context) {
+	// Transition auction state (commit, reveal, expired, completed).
+	k.processAuctionPhases(ctx)
+
+	// Delete stale auctions.
+	k.deleteCompletedAuctions(ctx)
+}
+
+func (k Keeper) processAuctionPhases(ctx sdk.Context) {
+	auctions := k.MatchAuctions(ctx, func(_ *types.Auction) bool {
+		return true
+	})
+
+	for _, auction := range auctions {
+		// Commit -> Reveal state.
+		if auction.Status == types.AuctionStatusCommitPhase && ctx.BlockTime().After(auction.CommitsEndTime) {
+			auction.Status = types.AuctionStatusRevealPhase
+			k.SaveAuction(ctx, auction)
+			ctx.Logger().Info(fmt.Sprintf("Moved auction %s to reveal phase.", auction.Id))
+		}
+
+		// Reveal -> Expired state.
+		if auction.Status == types.AuctionStatusRevealPhase && ctx.BlockTime().After(auction.RevealsEndTime) {
+			auction.Status = types.AuctionStatusExpired
+			k.SaveAuction(ctx, auction)
+			ctx.Logger().Info(fmt.Sprintf("Moved auction %s to expired state.", auction.Id))
+		}
+
+		// If auction has expired, pick a winner from revealed bids.
+		if auction.Status == types.AuctionStatusExpired {
+			k.pickAuctionWinner(ctx, auction)
+		}
+	}
+}
+
+// Delete completed stale auctions.
+func (k Keeper) deleteCompletedAuctions(ctx sdk.Context) {
+	auctions := k.MatchAuctions(ctx, func(auction *types.Auction) bool {
+		deleteTime := auction.RevealsEndTime.Add(CompletedAuctionDeleteTimeout)
+		return auction.Status == types.AuctionStatusCompleted && ctx.BlockTime().After(deleteTime)
+	})
+
+	for _, auction := range auctions {
+		ctx.Logger().Info(fmt.Sprintf("Deleting completed auction %s after timeout.", auction.Id))
+		k.DeleteAuction(ctx, *auction)
+	}
+}
+
+func (k Keeper) pickAuctionWinner(ctx sdk.Context, auction *types.Auction) {
+	ctx.Logger().Info(fmt.Sprintf("Picking auction %s winner.", auction.Id))
+
+	var highestBid *types.Bid
+	var secondHighestBid *types.Bid
+
+	bids := k.GetBids(ctx, auction.Id)
+	for _, bid := range bids {
+		ctx.Logger().Info(fmt.Sprintf("Processing bid %s %s", bid.BidderAddress, bid.BidAmount.String()))
+
+		// Only consider revealed bids.
+		if bid.Status != types.BidStatusRevealed {
+			ctx.Logger().Info(fmt.Sprintf("Ignoring unrevealed bid %s %s", bid.BidderAddress, bid.BidAmount.String()))
+			continue
+		}
+
+		// Init highest bid.
+		if highestBid == nil {
+			highestBid = bid
+			ctx.Logger().Info(fmt.Sprintf("Initializing 1st bid %s %s", bid.BidderAddress, bid.BidAmount.String()))
+			continue
+		}
+
+		if highestBid.BidAmount.IsLT(bid.BidAmount) {
+			ctx.Logger().Info(fmt.Sprintf("New highest bid %s %s", bid.BidderAddress, bid.BidAmount.String()))
+
+			secondHighestBid = highestBid
+			highestBid = bid
+
+			ctx.Logger().Info(fmt.Sprintf("Updated 1st bid %s %s", highestBid.BidderAddress, highestBid.BidAmount.String()))
+			ctx.Logger().Info(fmt.Sprintf("Updated 2nd bid %s %s", secondHighestBid.BidderAddress, secondHighestBid.BidAmount.String()))
+
+		} else if secondHighestBid == nil || secondHighestBid.BidAmount.IsLT(bid.BidAmount) {
+			ctx.Logger().Info(fmt.Sprintf("New 2nd highest bid %s %s", bid.BidderAddress, bid.BidAmount.String()))
+
+			secondHighestBid = bid
+			ctx.Logger().Info(fmt.Sprintf("Updated 2nd bid %s %s", secondHighestBid.BidderAddress, secondHighestBid.BidAmount.String()))
+		} else {
+			ctx.Logger().Info(fmt.Sprintf("Ignoring bid as it doesn't affect 1st/2nd price %s %s", bid.BidderAddress, bid.BidAmount.String()))
+		}
+	}
+
+	// Highest bid is the winner, but pays second highest bid price.
+	auction.Status = types.AuctionStatusCompleted
+
+	if highestBid != nil {
+		auction.WinnerAddress = highestBid.BidderAddress
+		auction.WinningBid = highestBid.BidAmount
+
+		// Winner pays 2nd price, if a 2nd price exists.
+		auction.WinningPrice = highestBid.BidAmount
+		if secondHighestBid != nil {
+			auction.WinningPrice = secondHighestBid.BidAmount
+		}
+
+		ctx.Logger().Info(fmt.Sprintf("Auction %s winner %s.", auction.Id, auction.WinnerAddress))
+		ctx.Logger().Info(fmt.Sprintf("Auction %s winner bid %s.", auction.Id, auction.WinningBid.String()))
+		ctx.Logger().Info(fmt.Sprintf("Auction %s winner price %s.", auction.Id, auction.WinningPrice.String()))
+
+	} else {
+		ctx.Logger().Info(fmt.Sprintf("Auction %s has no valid revealed bids (no winner).", auction.Id))
+	}
+
+	k.SaveAuction(ctx, auction)
+
+	for _, bid := range bids {
+		bidderAddress, err := sdk.AccAddressFromBech32(bid.BidderAddress)
+		if err != nil {
+			ctx.Logger().Error(fmt.Sprintf("Invalid bidderAddress address. %v", err))
+			panic("Invalid bidder address.")
+		}
+
+		if bid.Status == types.BidStatusRevealed {
+			// Send reveal fee back to bidders that've revealed the bid.
+			sdkErr := k.bankKeeper.SendCoinsFromModuleToAccount(ctx, types.ModuleName, bidderAddress, sdk.NewCoins(bid.RevealFee))
+			if sdkErr != nil {
+				ctx.Logger().Error(fmt.Sprintf("Auction error returning reveal fee: %v", sdkErr))
+				panic(sdkErr)
+			}
+		}
+
+		// Send back locked bid amount to all bidders.
+		sdkErr := k.bankKeeper.SendCoinsFromModuleToAccount(ctx, types.ModuleName, bidderAddress, sdk.NewCoins(bid.BidAmount))
+		if sdkErr != nil {
+			ctx.Logger().Error(fmt.Sprintf("Auction error returning bid amount: %v", sdkErr))
+			panic(sdkErr)
+		}
+	}
+
+	// Process winner account (if nobody bids, there won't be a winner).
+	if auction.WinnerAddress != "" {
+		winnerAddress, err := sdk.AccAddressFromBech32(auction.WinnerAddress)
+		if err != nil {
+			ctx.Logger().Error(fmt.Sprintf("Invalid winner address. %v", err))
+			panic("Invalid winner address.")
+		}
+
+		// Take 2nd price from winner.
+		sdkErr := k.bankKeeper.SendCoinsFromAccountToModule(ctx, winnerAddress, types.ModuleName, sdk.NewCoins(auction.WinningPrice))
+		if sdkErr != nil {
+			ctx.Logger().Error(fmt.Sprintf("Auction error taking funds from winner: %v", sdkErr))
+			panic(sdkErr)
+		}
+
+		// Burn anything over the min. bid amount.
+		amountToBurn := auction.WinningPrice.Sub(auction.MinimumBid)
+		if amountToBurn.IsNegative() {
+			ctx.Logger().Error(fmt.Sprintf("Auction coins to burn cannot be negative."))
+			panic("Auction coins to burn cannot be negative.")
+		}
+
+		// Use auction burn module account instead of actually burning coins to better keep track of supply.
+		sdkErr = k.bankKeeper.SendCoinsFromModuleToModule(ctx, types.ModuleName, types.AuctionBurnModuleAccountName, sdk.NewCoins(amountToBurn))
+		if sdkErr != nil {
+			ctx.Logger().Error(fmt.Sprintf("Auction error burning coins: %v", sdkErr))
+			panic(sdkErr)
+		}
+	}
+
+	// Notify other modules (hook).
+	ctx.Logger().Info(fmt.Sprintf("Auction %s notifying %d modules.", auction.Id, len(k.usageKeepers)))
+	for _, keeper := range k.usageKeepers {
+		ctx.Logger().Info(fmt.Sprintf("Auction %s notifying module %s.", auction.Id, keeper.ModuleName()))
+		keeper.OnAuctionWinnerSelected(ctx, auction.Id)
+	}
+}
@@ -0,0 +1,56 @@
+package keeper_test
+
+import (
+	"testing"
+
+	"github.com/cosmos/cosmos-sdk/baseapp"
+	"github.com/cosmos/cosmos-sdk/simapp"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/stretchr/testify/require"
+	"github.com/stretchr/testify/suite"
+	tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
+	"github.com/tharsis/ethermint/app"
+	auctionkeeper "github.com/tharsis/ethermint/x/auction/keeper"
+	"github.com/tharsis/ethermint/x/auction/types"
+)
+
+type KeeperTestSuite struct {
+	suite.Suite
+	app         *app.EthermintApp
+	ctx         sdk.Context
+	queryClient types.QueryClient
+}
+
+func (suite *KeeperTestSuite) SetupTest() {
+	testApp := app.Setup(false, func(ea *app.EthermintApp, genesis simapp.GenesisState) simapp.GenesisState {
+		return genesis
+	})
+	ctx := testApp.BaseApp.NewContext(false, tmproto.Header{})
+
+	querier := auctionkeeper.Querier{Keeper: testApp.AuctionKeeper}
+
+	queryHelper := baseapp.NewQueryServerTestHelper(ctx, testApp.InterfaceRegistry())
+	types.RegisterQueryServer(queryHelper, querier)
+	queryClient := types.NewQueryClient(queryHelper)
+
+	suite.app, suite.ctx, suite.queryClient = testApp, ctx, queryClient
+}
+
+func TestParams(t *testing.T) {
+	testApp := app.Setup(false, func(ea *app.EthermintApp, genesis simapp.GenesisState) simapp.GenesisState {
+		return genesis
+	})
+	ctx := testApp.BaseApp.NewContext(false, tmproto.Header{})
+
+	expParams := types.DefaultParams()
+	params := testApp.AuctionKeeper.GetParams(ctx)
+	require.Equal(t, expParams.CommitsDuration, params.CommitsDuration)
+	require.Equal(t, expParams.RevealsDuration, params.RevealsDuration)
+	require.Equal(t, expParams.CommitFee, params.CommitFee)
+	require.Equal(t, expParams.RevealFee, params.RevealFee)
+	require.Equal(t, expParams.MinimumBid, params.MinimumBid)
+}
+
+func TestKeeperTestSuite(t *testing.T) {
+	suite.Run(t, new(KeeperTestSuite))
+}
@@ -0,0 +1,110 @@
+package keeper
+
+import (
+	"context"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+
+	"github.com/tharsis/ethermint/x/auction/types"
+)
+
+type msgServer struct {
+	Keeper
+}
+
+func NewMsgServer(keeper Keeper) types.MsgServer {
+	return &msgServer{Keeper: keeper}
+}
+
+var _ types.MsgServer = msgServer{}
+
+func (s msgServer) CreateAuction(c context.Context, msg *types.MsgCreateAuction) (*types.MsgCreateAuctionResponse, error) {
+	ctx := sdk.UnwrapSDKContext(c)
+
+	signerAddress, err := sdk.AccAddressFromBech32(msg.Signer)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := s.Keeper.CreateAuction(ctx, *msg)
+	if err != nil {
+		return nil, err
+	}
+
+	ctx.EventManager().EmitEvents(sdk.Events{
+		sdk.NewEvent(
+			types.EventTypeCreateAuction,
+			sdk.NewAttribute(types.AttributeKeyCommitsDuration, msg.CommitsDuration.String()),
+			sdk.NewAttribute(types.AttributeKeyCommitFee, msg.CommitFee.String()),
+			sdk.NewAttribute(types.AttributeKeyRevealFee, msg.RevealFee.String()),
+			sdk.NewAttribute(types.AttributeKeyMinimumBid, msg.MinimumBid.String()),
+		),
+		sdk.NewEvent(
+			sdk.EventTypeMessage,
+			sdk.NewAttribute(sdk.AttributeKeyModule, types.AttributeValueCategory),
+			sdk.NewAttribute(types.AttributeKeySigner, signerAddress.String()),
+		),
+	})
+
+	return &types.MsgCreateAuctionResponse{Auction: resp}, nil
+}
+
+// CommitBid is the command for committing a bid
+func (s msgServer) CommitBid(c context.Context, msg *types.MsgCommitBid) (*types.MsgCommitBidResponse, error) {
+	ctx := sdk.UnwrapSDKContext(c)
+
+	signerAddress, err := sdk.AccAddressFromBech32(msg.Signer)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := s.Keeper.CommitBid(ctx, *msg)
+	if err != nil {
+		return nil, err
+	}
+
+	ctx.EventManager().EmitEvents(sdk.Events{
+		sdk.NewEvent(
+			types.EventTypeCommitBid,
+			sdk.NewAttribute(types.AttributeKeyAuctionID, msg.AuctionId),
+			sdk.NewAttribute(types.AttributeKeyCommitHash, msg.CommitHash),
+		),
+		sdk.NewEvent(
+			sdk.EventTypeMessage,
+			sdk.NewAttribute(sdk.AttributeKeyModule, types.AttributeValueCategory),
+			sdk.NewAttribute(types.AttributeKeySigner, signerAddress.String()),
+		),
+	})
+
+	return &types.MsgCommitBidResponse{Bid: resp}, nil
+}
+
+//RevealBid is the command for revealing a bid
+func (s msgServer) RevealBid(c context.Context, msg *types.MsgRevealBid) (*types.MsgRevealBidResponse, error) {
+	ctx := sdk.UnwrapSDKContext(c)
+
+	signerAddress, err := sdk.AccAddressFromBech32(msg.Signer)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := s.Keeper.RevealBid(ctx, *msg)
+	if err != nil {
+		return nil, err
+	}
+
+	ctx.EventManager().EmitEvents(sdk.Events{
+		sdk.NewEvent(
+			types.EventTypeRevealBid,
+			sdk.NewAttribute(types.AttributeKeyAuctionID, msg.AuctionId),
+			sdk.NewAttribute(types.AttributeKeyReveal, msg.Reveal),
+		),
+		sdk.NewEvent(
+			sdk.EventTypeMessage,
+			sdk.NewAttribute(sdk.AttributeKeyModule, types.AttributeValueCategory),
+			sdk.NewAttribute(types.AttributeKeySigner, signerAddress.String()),
+		),
+	})
+
+	return &types.MsgRevealBidResponse{Auction: resp}, nil
+}
@@ -0,0 +1,18 @@
+package keeper
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+
+	"github.com/tharsis/ethermint/x/auction/types"
+)
+
+// GetParams - Get all parameteras as types.Params.
+func (k Keeper) GetParams(ctx sdk.Context) (params types.Params) {
+	k.paramSubspace.GetParamSet(ctx, &params)
+	return
+}
+
+// SetParams - set the params.
+func (k Keeper) SetParams(ctx sdk.Context, params types.Params) {
+	k.paramSubspace.SetParamSet(ctx, &params)
+}
@@ -0,0 +1,142 @@
+package auction
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+
+	"github.com/gorilla/mux"
+	"github.com/grpc-ecosystem/grpc-gateway/runtime"
+	"github.com/spf13/cobra"
+
+	"github.com/cosmos/cosmos-sdk/client"
+	"github.com/cosmos/cosmos-sdk/codec"
+	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/types/module"
+
+	abci "github.com/tendermint/tendermint/abci/types"
+
+	"github.com/tharsis/ethermint/x/auction/client/cli"
+	"github.com/tharsis/ethermint/x/auction/keeper"
+	"github.com/tharsis/ethermint/x/auction/types"
+)
+
+// type check to ensure the interface is properly implemented
+var (
+	_ module.AppModule      = AppModule{}
+	_ module.AppModuleBasic = AppModuleBasic{}
+)
+
+// app module Basics object
+type AppModuleBasic struct {
+	cdc codec.Codec
+}
+
+func (b AppModuleBasic) Name() string {
+	return types.ModuleName
+}
+
+func (b AppModuleBasic) RegisterLegacyAminoCodec(cdc *codec.LegacyAmino) {
+	types.RegisterLegacyAminoCodec(cdc)
+}
+
+func (b AppModuleBasic) RegisterInterfaces(registry codectypes.InterfaceRegistry) {
+	types.RegisterInterfaces(registry)
+}
+
+func (b AppModuleBasic) DefaultGenesis(jsonCodec codec.JSONCodec) json.RawMessage {
+	return jsonCodec.MustMarshalJSON(types.DefaultGenesisState())
+}
+
+// Validation check of the Genesis
+func (b AppModuleBasic) ValidateGenesis(cdc codec.JSONCodec, config client.TxEncodingConfig, bz json.RawMessage) error {
+	var data types.GenesisState
+	err := cdc.UnmarshalJSON(bz, &data)
+	if err != nil {
+		return fmt.Errorf("failed to unmarshal %s genesis state: %w", types.ModuleName, err)
+	}
+	// Once json successfully marshalled, passes along to genesis.go
+	return ValidateGenesis(data)
+}
+
+// Register rest routes
+func (b AppModuleBasic) RegisterRESTRoutes(ctx client.Context, rtr *mux.Router) {
+	// No-op.
+}
+
+func (b AppModuleBasic) RegisterGRPCGatewayRoutes(clientCtx client.Context, serveMux *runtime.ServeMux) {
+	err := types.RegisterQueryHandlerClient(context.Background(), serveMux, types.NewQueryClient(clientCtx))
+	if err != nil {
+		panic(err)
+	}
+}
+
+// Get the root query command of this module
+func (b AppModuleBasic) GetQueryCmd() *cobra.Command {
+	return cli.GetQueryCmd()
+}
+
+// Get the root tx command of this module
+func (b AppModuleBasic) GetTxCmd() *cobra.Command {
+	return cli.GetTxCmd()
+}
+
+type AppModule struct {
+	AppModuleBasic
+	keeper keeper.Keeper
+}
+
+// NewAppModule creates a new AppModule Object
+func NewAppModule(cdc codec.Codec, k keeper.Keeper) AppModule {
+	return AppModule{
+		AppModuleBasic: AppModuleBasic{cdc: cdc},
+		keeper:         k,
+	}
+}
+
+func (am AppModule) RegisterInvariants(ir sdk.InvariantRegistry) {
+	keeper.RegisterInvariants(ir, am.keeper)
+}
+
+func (am AppModule) Route() sdk.Route {
+	return sdk.Route{}
+}
+
+func (am AppModule) QuerierRoute() string {
+	return types.QuerierRoute
+}
+
+func (am AppModule) LegacyQuerierHandler(cdc *codec.LegacyAmino) sdk.Querier {
+	return nil
+}
+
+func (am AppModule) RegisterServices(cfg module.Configurator) {
+	querier := keeper.Querier{Keeper: am.keeper}
+	types.RegisterQueryServer(cfg.QueryServer(), querier)
+
+	msgServer := keeper.NewMsgServer(am.keeper)
+	types.RegisterMsgServer(cfg.MsgServer(), msgServer)
+}
+
+func (am AppModule) ConsensusVersion() uint64 {
+	return 1
+}
+
+func (am AppModule) BeginBlock(_ sdk.Context, _ abci.RequestBeginBlock) {}
+
+func (am AppModule) EndBlock(ctx sdk.Context, _ abci.RequestEndBlock) []abci.ValidatorUpdate {
+	return EndBlocker(ctx, am.keeper)
+}
+
+func (am AppModule) InitGenesis(ctx sdk.Context, cdc codec.JSONCodec, data json.RawMessage) []abci.ValidatorUpdate {
+	var genesisState types.GenesisState
+	cdc.MustUnmarshalJSON(data, &genesisState)
+	InitGenesis(ctx, am.keeper, genesisState)
+	return []abci.ValidatorUpdate{}
+}
+
+func (am AppModule) ExportGenesis(ctx sdk.Context, cdc codec.JSONCodec) json.RawMessage {
+	gs := ExportGenesis(ctx, am.keeper)
+	return cdc.MustMarshalJSON(&gs)
+}
@@ -0,0 +1,14 @@
+package auction_test
+
+// func TestItCreatesModuleAccountOnInitBlock(t *testing.T) {
+// 	app := app2.Setup(false)
+// 	ctx := app.BaseApp.NewContext(false, tmproto.Header{})
+
+// 	app.InitChain(abcitypes.RequestInitChain{
+// 		AppStateBytes: []byte("{}"),
+// 		ChainId:       "test-chain-id",
+// 	})
+
+// 	acc := app.AccountKeeper.GetModuleAccount(ctx, auctiontypes.ModuleName)
+// 	require.NotNil(t, acc)
+// }
@@ -0,0 +1,37 @@
+package types
+
+import (
+	"github.com/cosmos/cosmos-sdk/codec"
+	"github.com/cosmos/cosmos-sdk/codec/types"
+	cryptocodec "github.com/cosmos/cosmos-sdk/crypto/codec"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/types/msgservice"
+)
+
+// RegisterLegacyAminoCodec registers the necessary x/auction interfaces and concrete types
+// on the provided LegacyAmino codec. These types are used for Amino JSON serialization.
+func RegisterLegacyAminoCodec(cdc *codec.LegacyAmino) {
+	cdc.RegisterConcrete(&MsgCreateAuction{}, "auction/MsgCreateAuction", nil)
+	cdc.RegisterConcrete(&MsgCommitBid{}, "auction/MsgCommitBid", nil)
+	cdc.RegisterConcrete(&MsgRevealBid{}, "auction/MsgRevealBid", nil)
+}
+
+func RegisterInterfaces(registry types.InterfaceRegistry) {
+	registry.RegisterImplementations((*sdk.Msg)(nil),
+		&MsgCreateAuction{},
+		&MsgCommitBid{},
+		&MsgRevealBid{},
+	)
+	msgservice.RegisterMsgServiceDesc(registry, &_Msg_serviceDesc)
+}
+
+var (
+	amino     = codec.NewLegacyAmino()
+	ModuleCdc = codec.NewAminoCodec(amino)
+)
+
+func init() {
+	RegisterLegacyAminoCodec(amino)
+	cryptocodec.RegisterCrypto(amino)
+	amino.Seal()
+}
@@ -0,0 +1,19 @@
+package types
+
+const (
+	EventTypeCreateAuction = "create-auction"
+	EventTypeCommitBid     = "commit-bid"
+	EventTypeRevealBid     = "reveal-bid"
+
+	AttributeKeyCommitsDuration = "commits-duration"
+	AttributeKeyRevealsDuration = "reveals-duration"
+	AttributeKeyCommitFee       = "commit-fee"
+	AttributeKeyRevealFee       = "reveal-fee"
+	AttributeKeyMinimumBid      = "minimum-bid"
+	AttributeKeySigner          = "signer"
+	AttributeKeyAuctionID       = "auction-id"
+	AttributeKeyCommitHash      = "commit-hash"
+	AttributeKeyReveal          = "reveal"
+
+	AttributeValueCategory = ModuleName
+)
@@ -0,0 +1,16 @@
+package types
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+// AuctionUsageKeeper keep track of auction usage in other modules.
+// Used to, for example, prevent deletion of a auction that's in use.
+type AuctionUsageKeeper interface {
+	ModuleName() string
+	UsesAuction(ctx sdk.Context, auctionID string) bool
+
+	OnAuction(ctx sdk.Context, auctionID string)
+	OnAuctionBid(ctx sdk.Context, auctionID string, bidderAddress string)
+	OnAuctionWinnerSelected(ctx sdk.Context, auctionID string)
+}
@@ -0,0 +1,9 @@
+package types
+
+// DefaultGenesisState sets default evm genesis state with empty accounts and default params and
+// chain config values.
+func DefaultGenesisState() *GenesisState {
+	return &GenesisState{
+		Params: DefaultParams(),
+	}
+}
@@ -0,0 +1,389 @@
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
+// source: vulcanize/auction/v1beta1/genesis.proto
+
+package types
+
+import (
+	fmt "fmt"
+	_ "github.com/gogo/protobuf/gogoproto"
+	proto "github.com/gogo/protobuf/proto"
+	io "io"
+	math "math"
+	math_bits "math/bits"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
+
+// GenesisState defines the genesis state of the auction module
+type GenesisState struct {
+	Params   Params     `protobuf:"bytes,1,opt,name=params,proto3" json:"params"`
+	Auctions []*Auction `protobuf:"bytes,2,rep,name=auctions,proto3" json:"auctions,omitempty" json:"bonds" yaml:"bonds"`
+}
+
+func (m *GenesisState) Reset()         { *m = GenesisState{} }
+func (m *GenesisState) String() string { return proto.CompactTextString(m) }
+func (*GenesisState) ProtoMessage()    {}
+func (*GenesisState) Descriptor() ([]byte, []int) {
+	return fileDescriptor_23ebfbd3a1e67fe6, []int{0}
+}
+func (m *GenesisState) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *GenesisState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_GenesisState.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *GenesisState) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_GenesisState.Merge(m, src)
+}
+func (m *GenesisState) XXX_Size() int {
+	return m.Size()
+}
+func (m *GenesisState) XXX_DiscardUnknown() {
+	xxx_messageInfo_GenesisState.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GenesisState proto.InternalMessageInfo
+
+func (m *GenesisState) GetParams() Params {
+	if m != nil {
+		return m.Params
+	}
+	return Params{}
+}
+
+func (m *GenesisState) GetAuctions() []*Auction {
+	if m != nil {
+		return m.Auctions
+	}
+	return nil
+}
+
+func init() {
+	proto.RegisterType((*GenesisState)(nil), "vulcanize.auction.v1beta1.GenesisState")
+}
+
+func init() {
+	proto.RegisterFile("vulcanize/auction/v1beta1/genesis.proto", fileDescriptor_23ebfbd3a1e67fe6)
+}
+
+var fileDescriptor_23ebfbd3a1e67fe6 = []byte{
+	// 264 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x52, 0x2f, 0x2b, 0xcd, 0x49,
+	0x4e, 0xcc, 0xcb, 0xac, 0x4a, 0xd5, 0x4f, 0x2c, 0x4d, 0x2e, 0xc9, 0xcc, 0xcf, 0xd3, 0x2f, 0x33,
+	0x4c, 0x4a, 0x2d, 0x49, 0x34, 0xd4, 0x4f, 0x4f, 0xcd, 0x4b, 0x2d, 0xce, 0x2c, 0xd6, 0x2b, 0x28,
+	0xca, 0x2f, 0xc9, 0x17, 0x92, 0x84, 0x2b, 0xd4, 0x83, 0x2a, 0xd4, 0x83, 0x2a, 0x94, 0x12, 0x49,
+	0xcf, 0x4f, 0xcf, 0x07, 0xab, 0xd2, 0x07, 0xb1, 0x20, 0x1a, 0xa4, 0x54, 0x71, 0x9b, 0x5c, 0x52,
+	0x59, 0x90, 0x0a, 0x35, 0x57, 0x69, 0x1d, 0x23, 0x17, 0x8f, 0x3b, 0xc4, 0xa6, 0xe0, 0x92, 0xc4,
+	0x92, 0x54, 0x21, 0x7b, 0x2e, 0xb6, 0x82, 0xc4, 0xa2, 0xc4, 0xdc, 0x62, 0x09, 0x46, 0x05, 0x46,
+	0x0d, 0x6e, 0x23, 0x45, 0x3d, 0x9c, 0x36, 0xeb, 0x05, 0x80, 0x15, 0x3a, 0xb1, 0x9c, 0xb8, 0x27,
+	0xcf, 0x10, 0x04, 0xd5, 0x26, 0x14, 0xcb, 0xc5, 0x01, 0x55, 0x57, 0x2c, 0xc1, 0xa4, 0xc0, 0xac,
+	0xc1, 0x6d, 0xa4, 0x84, 0xc7, 0x08, 0x47, 0x08, 0xdf, 0x49, 0xf6, 0xd3, 0x3d, 0x79, 0xc9, 0xac,
+	0xe2, 0xfc, 0x3c, 0x2b, 0xa5, 0xa4, 0xfc, 0xbc, 0x94, 0x62, 0x25, 0x85, 0xca, 0xc4, 0xdc, 0x1c,
+	0x18, 0x27, 0x08, 0x6e, 0xa4, 0x93, 0xdb, 0x89, 0x47, 0x72, 0x8c, 0x17, 0x1e, 0xc9, 0x31, 0x3e,
+	0x78, 0x24, 0xc7, 0x38, 0xe1, 0xb1, 0x1c, 0xc3, 0x85, 0xc7, 0x72, 0x0c, 0x37, 0x1e, 0xcb, 0x31,
+	0x44, 0xe9, 0xa4, 0x67, 0x96, 0x64, 0x94, 0x26, 0xe9, 0x25, 0xe7, 0xe7, 0xea, 0x97, 0x64, 0x24,
+	0x16, 0x15, 0x67, 0x16, 0xeb, 0xa7, 0x96, 0x64, 0xa4, 0x16, 0xe5, 0x66, 0xe6, 0x95, 0xe8, 0x57,
+	0xc0, 0x83, 0x01, 0xec, 0xfd, 0x24, 0x36, 0xb0, 0xff, 0x8d, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff,
+	0x40, 0x0a, 0x31, 0x1a, 0x82, 0x01, 0x00, 0x00,
+}
+
+func (m *GenesisState) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *GenesisState) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *GenesisState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.Auctions) > 0 {
+		for iNdEx := len(m.Auctions) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Auctions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintGenesis(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0x12
+		}
+	}
+	{
+		size, err := m.Params.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = encodeVarintGenesis(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0xa
+	return len(dAtA) - i, nil
+}
+
+func encodeVarintGenesis(dAtA []byte, offset int, v uint64) int {
+	offset -= sovGenesis(v)
+	base := offset
+	for v >= 1<<7 {
+		dAtA[offset] = uint8(v&0x7f | 0x80)
+		v >>= 7
+		offset++
+	}
+	dAtA[offset] = uint8(v)
+	return base
+}
+func (m *GenesisState) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = m.Params.Size()
+	n += 1 + l + sovGenesis(uint64(l))
+	if len(m.Auctions) > 0 {
+		for _, e := range m.Auctions {
+			l = e.Size()
+			n += 1 + l + sovGenesis(uint64(l))
+		}
+	}
+	return n
+}
+
+func sovGenesis(x uint64) (n int) {
+	return (math_bits.Len64(x|1) + 6) / 7
+}
+func sozGenesis(x uint64) (n int) {
+	return sovGenesis(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *GenesisState) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowGenesis
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: GenesisState: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: GenesisState: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenesis
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthGenesis
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenesis
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Auctions", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenesis
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthGenesis
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenesis
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Auctions = append(m.Auctions, &Auction{})
+			if err := m.Auctions[len(m.Auctions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipGenesis(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthGenesis
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func skipGenesis(dAtA []byte) (n int, err error) {
+	l := len(dAtA)
+	iNdEx := 0
+	depth := 0
+	for iNdEx < l {
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return 0, ErrIntOverflowGenesis
+			}
+			if iNdEx >= l {
+				return 0, io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		wireType := int(wire & 0x7)
+		switch wireType {
+		case 0:
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowGenesis
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				iNdEx++
+				if dAtA[iNdEx-1] < 0x80 {
+					break
+				}
+			}
+		case 1:
+			iNdEx += 8
+		case 2:
+			var length int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowGenesis
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				length |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if length < 0 {
+				return 0, ErrInvalidLengthGenesis
+			}
+			iNdEx += length
+		case 3:
+			depth++
+		case 4:
+			if depth == 0 {
+				return 0, ErrUnexpectedEndOfGroupGenesis
+			}
+			depth--
+		case 5:
+			iNdEx += 4
+		default:
+			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+		}
+		if iNdEx < 0 {
+			return 0, ErrInvalidLengthGenesis
+		}
+		if depth == 0 {
+			return iNdEx, nil
+		}
+	}
+	return 0, io.ErrUnexpectedEOF
+}
+
+var (
+	ErrInvalidLengthGenesis        = fmt.Errorf("proto: negative length found during unmarshaling")
+	ErrIntOverflowGenesis          = fmt.Errorf("proto: integer overflow")
+	ErrUnexpectedEndOfGroupGenesis = fmt.Errorf("proto: unexpected end of group")
+)
@@ -0,0 +1,18 @@
+package types
+
+const (
+	// ModuleName is the name of the module
+	ModuleName = "auction"
+
+	// AuctionBurnModuleAccountName is the name of the auction burn module account.
+	AuctionBurnModuleAccountName = "auction_burn"
+
+	// StoreKey to be used when creating the KVStore
+	StoreKey = ModuleName
+
+	// QuerierRoute is the querier route for the staking module
+	QuerierRoute = ModuleName
+
+	// RouterKey is the msg router key for the staking module
+	RouterKey = ModuleName
+)
@@ -0,0 +1,150 @@
+package types
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
+)
+
+var (
+	_ sdk.Msg = &MsgCreateAuction{}
+	_ sdk.Msg = &MsgCommitBid{}
+	_ sdk.Msg = &MsgRevealBid{}
+)
+
+// NewMsgCreateAuction is the constructor function for MsgCreateAuction.
+func NewMsgCreateAuction(params Params, signer sdk.AccAddress) MsgCreateAuction {
+	return MsgCreateAuction{
+		CommitsDuration: params.CommitsDuration,
+		RevealsDuration: params.RevealsDuration,
+		CommitFee:       params.CommitFee,
+		RevealFee:       params.RevealFee,
+		MinimumBid:      params.MinimumBid,
+		Signer:          signer.String(),
+	}
+}
+
+// Route Implements Msg.
+func (msg MsgCreateAuction) Route() string { return RouterKey }
+
+// Type Implements Msg.
+func (msg MsgCreateAuction) Type() string { return "create" }
+
+// ValidateBasic Implements Msg.
+func (msg MsgCreateAuction) ValidateBasic() error {
+	if msg.Signer == "" {
+		return sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, msg.Signer)
+	}
+
+	if msg.CommitsDuration <= 0 {
+		return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "commit phase duration invalid.")
+	}
+
+	if msg.RevealsDuration <= 0 {
+		return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "reveal phase duration invalid.")
+	}
+
+	if !msg.MinimumBid.IsPositive() {
+		return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "minimum bid should be greater than zero.")
+	}
+
+	return nil
+}
+
+// GetSignBytes Implements Msg.
+func (msg MsgCreateAuction) GetSignBytes() []byte {
+	return sdk.MustSortJSON(ModuleCdc.MustMarshalJSON(&msg))
+}
+
+// GetSigners Implements Msg.
+func (msg MsgCreateAuction) GetSigners() []sdk.AccAddress {
+	accAddr, _ := sdk.AccAddressFromBech32(msg.Signer)
+	return []sdk.AccAddress{accAddr}
+}
+
+// NewMsgCommitBid is the constructor function for MsgCommitBid.
+func NewMsgCommitBid(auctionID string, commitHash string, signer sdk.AccAddress) MsgCommitBid {
+
+	return MsgCommitBid{
+		AuctionId:  auctionID,
+		CommitHash: commitHash,
+		Signer:     signer.String(),
+	}
+}
+
+// Route Implements Msg.
+func (msg MsgCommitBid) Route() string { return RouterKey }
+
+// Type Implements Msg.
+func (msg MsgCommitBid) Type() string { return "commit" }
+
+// ValidateBasic Implements Msg.
+func (msg MsgCommitBid) ValidateBasic() error {
+	if msg.Signer == "" {
+		return sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, "invalid signer address.")
+	}
+
+	if msg.AuctionId == "" {
+		return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "invalid auction ID.")
+	}
+
+	if msg.CommitHash == "" {
+		return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "invalid commit hash.")
+	}
+
+	return nil
+}
+
+// GetSignBytes Implements Msg.
+func (msg MsgCommitBid) GetSignBytes() []byte {
+	return sdk.MustSortJSON(ModuleCdc.MustMarshalJSON(&msg))
+}
+
+// GetSigners Implements Msg.
+func (msg MsgCommitBid) GetSigners() []sdk.AccAddress {
+	accAddr, _ := sdk.AccAddressFromBech32(msg.Signer)
+	return []sdk.AccAddress{accAddr}
+}
+
+// NewMsgRevealBid is the constructor function for MsgRevealBid.
+func NewMsgRevealBid(auctionID string, reveal string, signer sdk.AccAddress) MsgRevealBid {
+
+	return MsgRevealBid{
+		AuctionId: auctionID,
+		Reveal:    reveal,
+		Signer:    signer.String(),
+	}
+}
+
+// Route Implements Msg.
+func (msg MsgRevealBid) Route() string { return RouterKey }
+
+// Type Implements Msg.
+func (msg MsgRevealBid) Type() string { return "reveal" }
+
+// ValidateBasic Implements Msg.
+func (msg MsgRevealBid) ValidateBasic() error {
+	if msg.Signer == "" {
+		return sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, "invalid signer address.")
+	}
+
+	if msg.AuctionId == "" {
+		return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "invalid auction ID.")
+	}
+
+	if msg.Reveal == "" {
+		return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "invalid reveal data.")
+	}
+
+	return nil
+}
+
+// GetSignBytes Implements Msg.
+func (msg MsgRevealBid) GetSignBytes() []byte {
+	return sdk.MustSortJSON(ModuleCdc.MustMarshalJSON(&msg))
+}
+
+// GetSigners Implements Msg.
+func (msg MsgRevealBid) GetSigners() []sdk.AccAddress {
+	accAddr, _ := sdk.AccAddressFromBech32(msg.Signer)
+	return []sdk.AccAddress{accAddr}
+}
@@ -0,0 +1,173 @@
+package types
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"strings"
+	"time"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/x/params/types"
+)
+
+// Default parameter namespace.
+const (
+	DefaultParamspace = ModuleName
+)
+
+var (
+	DefaultCommitsDuration = 5 * time.Minute
+	DefaultRevealsDuration = 5 * time.Minute
+	DefaultCommitFee       = sdk.Coin{Amount: sdk.NewInt(10), Denom: sdk.DefaultBondDenom}
+	DefaultRevealFee       = sdk.Coin{Amount: sdk.NewInt(10), Denom: sdk.DefaultBondDenom}
+	DefaultMinimumBid      = sdk.Coin{Amount: sdk.NewInt(1000), Denom: sdk.DefaultBondDenom}
+
+	ParamStoreKeyCommitsDuration = []byte("CommitsDuration")
+	ParamStoreKeyRevealsDuration = []byte("RevealsDuration")
+	ParamStoreKeyCommitFee       = []byte("CommitFee")
+	ParamStoreKeyRevealFee       = []byte("RevealFee")
+	ParamStoreKeyMinimumBid      = []byte("MinimumBid")
+)
+
+var _ types.ParamSet = &Params{}
+
+func NewParams() Params {
+	return DefaultParams()
+}
+
+// ParamKeyTable - ParamTable for bond module.
+func ParamKeyTable() types.KeyTable {
+	return types.NewKeyTable().RegisterParamSet(&Params{})
+}
+
+// ParamSetPairs - implements params.ParamSet
+func (p *Params) ParamSetPairs() types.ParamSetPairs {
+	return types.ParamSetPairs{
+		types.NewParamSetPair(ParamStoreKeyCommitsDuration, &p.CommitsDuration, validateCommitsDuration),
+		types.NewParamSetPair(ParamStoreKeyRevealsDuration, &p.RevealsDuration, validateRevealsDuration),
+		types.NewParamSetPair(ParamStoreKeyCommitFee, &p.CommitFee, validateCommitFee),
+		types.NewParamSetPair(ParamStoreKeyRevealFee, &p.RevealFee, validateRevealFee),
+		types.NewParamSetPair(ParamStoreKeyMinimumBid, &p.MinimumBid, validateMinimumBid),
+	}
+}
+
+// Equal returns a boolean determining if two Params types are identical.
+func (p Params) Equal(p2 Params) bool {
+	bz1 := ModuleCdc.MustMarshalLengthPrefixed(&p)
+	bz2 := ModuleCdc.MustMarshalLengthPrefixed(&p2)
+	return bytes.Equal(bz1, bz2)
+}
+
+// DefaultParams returns a default set of parameters.
+func DefaultParams() Params {
+	return Params{
+		CommitsDuration: DefaultCommitsDuration,
+		RevealsDuration: DefaultRevealsDuration,
+		CommitFee:       DefaultCommitFee,
+		RevealFee:       DefaultRevealFee,
+		MinimumBid:      DefaultMinimumBid,
+	}
+}
+
+// String returns a human readable string representation of the parameters.
+func (p Params) String() string {
+	var sb strings.Builder
+	sb.WriteString("Params: \n")
+	sb.WriteString(fmt.Sprintf("CommitsDuration: %s\n", p.CommitsDuration.String()))
+	sb.WriteString(fmt.Sprintf("RevealsDuration: %s\n", p.RevealsDuration.String()))
+	sb.WriteString(fmt.Sprintf("CommitFee: %s\n", p.CommitFee.String()))
+	sb.WriteString(fmt.Sprintf("RevealFee: %s\n", p.RevealFee.String()))
+	sb.WriteString(fmt.Sprintf("MinimumBid: %s\n", p.MinimumBid.String()))
+	return sb.String()
+}
+
+func validateCommitsDuration(i interface{}) error {
+	v, ok := i.(time.Duration)
+	if !ok {
+		return fmt.Errorf("invalid parameter type: %T", i)
+	}
+
+	if v < 0 {
+		return errors.New("commits duration cannot be negative")
+	}
+
+	return nil
+}
+
+func validateRevealsDuration(i interface{}) error {
+	v, ok := i.(time.Duration)
+	if !ok {
+		return fmt.Errorf("invalid parameter type: %T", i)
+	}
+
+	if v < 0 {
+		return errors.New("commits duration cannot be negative")
+	}
+
+	return nil
+}
+
+func validateCommitFee(i interface{}) error {
+	v, ok := i.(sdk.Coin)
+	if !ok {
+		return fmt.Errorf("invalid parameter type: %T", i)
+	}
+
+	if v.Amount.IsNegative() {
+		return errors.New("commit fee must be positive")
+	}
+
+	return nil
+}
+
+func validateRevealFee(i interface{}) error {
+	v, ok := i.(sdk.Coin)
+	if !ok {
+		return fmt.Errorf("invalid parameter type: %T", i)
+	}
+
+	if v.Amount.IsNegative() {
+		return errors.New("reveal fee must be positive")
+	}
+
+	return nil
+}
+
+func validateMinimumBid(i interface{}) error {
+	v, ok := i.(sdk.Coin)
+	if !ok {
+		return fmt.Errorf("invalid parameter type: %T", i)
+	}
+
+	if v.Amount.IsNegative() {
+		return errors.New("minimum bid must be positive")
+	}
+
+	return nil
+}
+
+// Validate a set of params.
+func (p Params) Validate() error {
+	if err := validateCommitsDuration(p.CommitsDuration); err != nil {
+		return err
+	}
+
+	if err := validateRevealsDuration(p.RevealsDuration); err != nil {
+		return err
+	}
+
+	if err := validateCommitFee(p.CommitFee); err != nil {
+		return err
+	}
+
+	if err := validateRevealFee(p.RevealFee); err != nil {
+		return err
+	}
+
+	if err := validateMinimumBid(p.MinimumBid); err != nil {
+		return err
+	}
+
+	return nil
+}
@@ -0,0 +1,802 @@
+// Code generated by protoc-gen-grpc-gateway. DO NOT EDIT.
+// source: vulcanize/auction/v1beta1/query.proto
+
+/*
+Package types is a reverse proxy.
+
+It translates gRPC into RESTful JSON APIs.
+*/
+package types
+
+import (
+	"context"
+	"io"
+	"net/http"
+
+	"github.com/golang/protobuf/descriptor"
+	"github.com/golang/protobuf/proto"
+	"github.com/grpc-ecosystem/grpc-gateway/runtime"
+	"github.com/grpc-ecosystem/grpc-gateway/utilities"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/grpclog"
+	"google.golang.org/grpc/status"
+)
+
+// Suppress "imported and not used" errors
+var _ codes.Code
+var _ io.Reader
+var _ status.Status
+var _ = runtime.String
+var _ = utilities.NewDoubleArray
+var _ = descriptor.ForMessage
+
+var (
+	filter_Query_Auctions_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}
+)
+
+func request_Query_Auctions_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq AuctionsRequest
+	var metadata runtime.ServerMetadata
+
+	if err := req.ParseForm(); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_Auctions_0); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+
+	msg, err := client.Auctions(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+
+}
+
+func local_request_Query_Auctions_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq AuctionsRequest
+	var metadata runtime.ServerMetadata
+
+	if err := req.ParseForm(); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_Auctions_0); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+
+	msg, err := server.Auctions(ctx, &protoReq)
+	return msg, metadata, err
+
+}
+
+func request_Query_GetAuction_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq AuctionRequest
+	var metadata runtime.ServerMetadata
+
+	var (
+		val string
+		ok  bool
+		err error
+		_   = err
+	)
+
+	val, ok = pathParams["id"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id")
+	}
+
+	protoReq.Id, err = runtime.String(val)
+
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err)
+	}
+
+	msg, err := client.GetAuction(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+
+}
+
+func local_request_Query_GetAuction_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq AuctionRequest
+	var metadata runtime.ServerMetadata
+
+	var (
+		val string
+		ok  bool
+		err error
+		_   = err
+	)
+
+	val, ok = pathParams["id"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id")
+	}
+
+	protoReq.Id, err = runtime.String(val)
+
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err)
+	}
+
+	msg, err := server.GetAuction(ctx, &protoReq)
+	return msg, metadata, err
+
+}
+
+func request_Query_GetBid_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq BidRequest
+	var metadata runtime.ServerMetadata
+
+	var (
+		val string
+		ok  bool
+		err error
+		_   = err
+	)
+
+	val, ok = pathParams["auction_id"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "auction_id")
+	}
+
+	protoReq.AuctionId, err = runtime.String(val)
+
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "auction_id", err)
+	}
+
+	val, ok = pathParams["bidder"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "bidder")
+	}
+
+	protoReq.Bidder, err = runtime.String(val)
+
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "bidder", err)
+	}
+
+	msg, err := client.GetBid(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+
+}
+
+func local_request_Query_GetBid_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq BidRequest
+	var metadata runtime.ServerMetadata
+
+	var (
+		val string
+		ok  bool
+		err error
+		_   = err
+	)
+
+	val, ok = pathParams["auction_id"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "auction_id")
+	}
+
+	protoReq.AuctionId, err = runtime.String(val)
+
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "auction_id", err)
+	}
+
+	val, ok = pathParams["bidder"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "bidder")
+	}
+
+	protoReq.Bidder, err = runtime.String(val)
+
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "bidder", err)
+	}
+
+	msg, err := server.GetBid(ctx, &protoReq)
+	return msg, metadata, err
+
+}
+
+func request_Query_GetBids_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq BidsRequest
+	var metadata runtime.ServerMetadata
+
+	var (
+		val string
+		ok  bool
+		err error
+		_   = err
+	)
+
+	val, ok = pathParams["auction_id"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "auction_id")
+	}
+
+	protoReq.AuctionId, err = runtime.String(val)
+
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "auction_id", err)
+	}
+
+	msg, err := client.GetBids(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+
+}
+
+func local_request_Query_GetBids_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq BidsRequest
+	var metadata runtime.ServerMetadata
+
+	var (
+		val string
+		ok  bool
+		err error
+		_   = err
+	)
+
+	val, ok = pathParams["auction_id"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "auction_id")
+	}
+
+	protoReq.AuctionId, err = runtime.String(val)
+
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "auction_id", err)
+	}
+
+	msg, err := server.GetBids(ctx, &protoReq)
+	return msg, metadata, err
+
+}
+
+func request_Query_AuctionsByBidder_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq AuctionsByBidderRequest
+	var metadata runtime.ServerMetadata
+
+	var (
+		val string
+		ok  bool
+		err error
+		_   = err
+	)
+
+	val, ok = pathParams["bidder_address"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "bidder_address")
+	}
+
+	protoReq.BidderAddress, err = runtime.String(val)
+
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "bidder_address", err)
+	}
+
+	msg, err := client.AuctionsByBidder(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+
+}
+
+func local_request_Query_AuctionsByBidder_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq AuctionsByBidderRequest
+	var metadata runtime.ServerMetadata
+
+	var (
+		val string
+		ok  bool
+		err error
+		_   = err
+	)
+
+	val, ok = pathParams["bidder_address"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "bidder_address")
+	}
+
+	protoReq.BidderAddress, err = runtime.String(val)
+
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "bidder_address", err)
+	}
+
+	msg, err := server.AuctionsByBidder(ctx, &protoReq)
+	return msg, metadata, err
+
+}
+
+func request_Query_AuctionsByOwner_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq AuctionsByOwnerRequest
+	var metadata runtime.ServerMetadata
+
+	var (
+		val string
+		ok  bool
+		err error
+		_   = err
+	)
+
+	val, ok = pathParams["owner_address"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "owner_address")
+	}
+
+	protoReq.OwnerAddress, err = runtime.String(val)
+
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "owner_address", err)
+	}
+
+	msg, err := client.AuctionsByOwner(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+
+}
+
+func local_request_Query_AuctionsByOwner_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq AuctionsByOwnerRequest
+	var metadata runtime.ServerMetadata
+
+	var (
+		val string
+		ok  bool
+		err error
+		_   = err
+	)
+
+	val, ok = pathParams["owner_address"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "owner_address")
+	}
+
+	protoReq.OwnerAddress, err = runtime.String(val)
+
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "owner_address", err)
+	}
+
+	msg, err := server.AuctionsByOwner(ctx, &protoReq)
+	return msg, metadata, err
+
+}
+
+func request_Query_QueryParams_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq QueryParamsRequest
+	var metadata runtime.ServerMetadata
+
+	msg, err := client.QueryParams(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+
+}
+
+func local_request_Query_QueryParams_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq QueryParamsRequest
+	var metadata runtime.ServerMetadata
+
+	msg, err := server.QueryParams(ctx, &protoReq)
+	return msg, metadata, err
+
+}
+
+func request_Query_Balance_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq BalanceRequest
+	var metadata runtime.ServerMetadata
+
+	msg, err := client.Balance(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+
+}
+
+func local_request_Query_Balance_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq BalanceRequest
+	var metadata runtime.ServerMetadata
+
+	msg, err := server.Balance(ctx, &protoReq)
+	return msg, metadata, err
+
+}
+
+// RegisterQueryHandlerServer registers the http handlers for service Query to "mux".
+// UnaryRPC     :call QueryServer directly.
+// StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.
+// Note that using this registration option will cause many gRPC library features (such as grpc.SendHeader, etc) to stop working. Consider using RegisterQueryHandlerFromEndpoint instead.
+func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, server QueryServer) error {
+
+	mux.Handle("GET", pattern_Query_Auctions_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := local_request_Query_Auctions_0(rctx, inboundMarshaler, server, req, pathParams)
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Query_Auctions_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	mux.Handle("GET", pattern_Query_GetAuction_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := local_request_Query_GetAuction_0(rctx, inboundMarshaler, server, req, pathParams)
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Query_GetAuction_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	mux.Handle("GET", pattern_Query_GetBid_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := local_request_Query_GetBid_0(rctx, inboundMarshaler, server, req, pathParams)
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Query_GetBid_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	mux.Handle("GET", pattern_Query_GetBids_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := local_request_Query_GetBids_0(rctx, inboundMarshaler, server, req, pathParams)
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Query_GetBids_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	mux.Handle("GET", pattern_Query_AuctionsByBidder_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := local_request_Query_AuctionsByBidder_0(rctx, inboundMarshaler, server, req, pathParams)
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Query_AuctionsByBidder_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	mux.Handle("GET", pattern_Query_AuctionsByOwner_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := local_request_Query_AuctionsByOwner_0(rctx, inboundMarshaler, server, req, pathParams)
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Query_AuctionsByOwner_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	mux.Handle("GET", pattern_Query_QueryParams_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := local_request_Query_QueryParams_0(rctx, inboundMarshaler, server, req, pathParams)
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Query_QueryParams_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	mux.Handle("GET", pattern_Query_Balance_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := local_request_Query_Balance_0(rctx, inboundMarshaler, server, req, pathParams)
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Query_Balance_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	return nil
+}
+
+// RegisterQueryHandlerFromEndpoint is same as RegisterQueryHandler but
+// automatically dials to "endpoint" and closes the connection when "ctx" gets done.
+func RegisterQueryHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) {
+	conn, err := grpc.Dial(endpoint, opts...)
+	if err != nil {
+		return err
+	}
+	defer func() {
+		if err != nil {
+			if cerr := conn.Close(); cerr != nil {
+				grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
+			}
+			return
+		}
+		go func() {
+			<-ctx.Done()
+			if cerr := conn.Close(); cerr != nil {
+				grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
+			}
+		}()
+	}()
+
+	return RegisterQueryHandler(ctx, mux, conn)
+}
+
+// RegisterQueryHandler registers the http handlers for service Query to "mux".
+// The handlers forward requests to the grpc endpoint over "conn".
+func RegisterQueryHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
+	return RegisterQueryHandlerClient(ctx, mux, NewQueryClient(conn))
+}
+
+// RegisterQueryHandlerClient registers the http handlers for service Query
+// to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "QueryClient".
+// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "QueryClient"
+// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in
+// "QueryClient" to call the correct interceptors.
+func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, client QueryClient) error {
+
+	mux.Handle("GET", pattern_Query_Auctions_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := request_Query_Auctions_0(rctx, inboundMarshaler, client, req, pathParams)
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Query_Auctions_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	mux.Handle("GET", pattern_Query_GetAuction_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := request_Query_GetAuction_0(rctx, inboundMarshaler, client, req, pathParams)
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Query_GetAuction_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	mux.Handle("GET", pattern_Query_GetBid_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := request_Query_GetBid_0(rctx, inboundMarshaler, client, req, pathParams)
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Query_GetBid_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	mux.Handle("GET", pattern_Query_GetBids_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := request_Query_GetBids_0(rctx, inboundMarshaler, client, req, pathParams)
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Query_GetBids_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	mux.Handle("GET", pattern_Query_AuctionsByBidder_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := request_Query_AuctionsByBidder_0(rctx, inboundMarshaler, client, req, pathParams)
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Query_AuctionsByBidder_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	mux.Handle("GET", pattern_Query_AuctionsByOwner_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := request_Query_AuctionsByOwner_0(rctx, inboundMarshaler, client, req, pathParams)
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Query_AuctionsByOwner_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	mux.Handle("GET", pattern_Query_QueryParams_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := request_Query_QueryParams_0(rctx, inboundMarshaler, client, req, pathParams)
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Query_QueryParams_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	mux.Handle("GET", pattern_Query_Balance_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := request_Query_Balance_0(rctx, inboundMarshaler, client, req, pathParams)
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Query_Balance_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	return nil
+}
+
+var (
+	pattern_Query_Auctions_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"vulcanize", "auction", "v1beta1", "auctions"}, "", runtime.AssumeColonVerbOpt(true)))
+
+	pattern_Query_GetAuction_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"vulcanize", "auction", "v1beta1", "auctions", "id"}, "", runtime.AssumeColonVerbOpt(true)))
+
+	pattern_Query_GetBid_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 1, 0, 4, 1, 5, 5}, []string{"vulcanize", "auction", "v1beta1", "bids", "auction_id", "bidder"}, "", runtime.AssumeColonVerbOpt(true)))
+
+	pattern_Query_GetBids_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"vulcanize", "auction", "v1beta1", "bids", "auction_id"}, "", runtime.AssumeColonVerbOpt(true)))
+
+	pattern_Query_AuctionsByBidder_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"vulcanize", "auction", "v1beta1", "by-bidder", "bidder_address"}, "", runtime.AssumeColonVerbOpt(true)))
+
+	pattern_Query_AuctionsByOwner_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"vulcanize", "auction", "v1beta1", "by-owner", "owner_address"}, "", runtime.AssumeColonVerbOpt(true)))
+
+	pattern_Query_QueryParams_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"vulcanize", "auction", "v1beta1", "params"}, "", runtime.AssumeColonVerbOpt(true)))
+
+	pattern_Query_Balance_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"vulcanize", "auction", "v1beta1", "balance"}, "", runtime.AssumeColonVerbOpt(true)))
+)
+
+var (
+	forward_Query_Auctions_0 = runtime.ForwardResponseMessage
+
+	forward_Query_GetAuction_0 = runtime.ForwardResponseMessage
+
+	forward_Query_GetBid_0 = runtime.ForwardResponseMessage
+
+	forward_Query_GetBids_0 = runtime.ForwardResponseMessage
+
+	forward_Query_AuctionsByBidder_0 = runtime.ForwardResponseMessage
+
+	forward_Query_AuctionsByOwner_0 = runtime.ForwardResponseMessage
+
+	forward_Query_QueryParams_0 = runtime.ForwardResponseMessage
+
+	forward_Query_Balance_0 = runtime.ForwardResponseMessage
+)
@@ -0,0 +1,65 @@
+package types
+
+import (
+	"crypto/sha256"
+	"encoding/hex"
+	"fmt"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+// Auction status values.
+const (
+	// Auction is in commit phase.
+	AuctionStatusCommitPhase = "commit"
+
+	// Auction is in reveal phase.
+	AuctionStatusRevealPhase = "reveal"
+
+	// Auction has ended (no reveals allowed).
+	AuctionStatusExpired = "expired"
+
+	// Auction has completed (winner selected).
+	AuctionStatusCompleted = "completed"
+)
+
+// Bid status values.
+const (
+	BidStatusCommitted = "commit"
+	BidStatusRevealed  = "reveal"
+)
+
+// AuctionID simplifies generation of auction IDs.
+type AuctionID struct {
+	Address  sdk.Address
+	AccNum   uint64
+	Sequence uint64
+}
+
+// Generate creates the auction ID.
+func (auctionID AuctionID) Generate() string {
+	hasher := sha256.New()
+	str := fmt.Sprintf("%s:%d:%d", auctionID.Address.String(), auctionID.AccNum, auctionID.Sequence)
+	hasher.Write([]byte(str))
+	return hex.EncodeToString(hasher.Sum(nil))
+}
+
+func (auction Auction) GetCreateTime() string {
+	return string(sdk.FormatTimeBytes(auction.CreateTime))
+}
+
+func (auction Auction) GetCommitsEndTime() string {
+	return string(sdk.FormatTimeBytes(auction.CommitsEndTime))
+}
+
+func (auction Auction) GetRevealsEndTime() string {
+	return string(sdk.FormatTimeBytes(auction.RevealsEndTime))
+}
+
+func (bid Bid) GetCommitTime() string {
+	return string(sdk.FormatTimeBytes(bid.CommitTime))
+}
+
+func (bid Bid) GetRevealTime() string {
+	return string(sdk.FormatTimeBytes(bid.RevealTime))
+}