diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0d759801..37bbf5f0 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -37,6 +37,7 @@ Ref: https://keepachangelog.com/en/1.0.0/
 ## [Unreleased]
 
 ### Features
+* (wasmd) [\#187](https://github.com/CosmWasm/wasmd/issues/187) Introduce wasmgovd binary
 * (wasmd) [\#178](https://github.com/CosmWasm/wasmd/issues/178) Add cli support for wasm gov proposals
 * (wasmd) [\#163](https://github.com/CosmWasm/wasmd/issues/163) Control who can instantiate code
 * (wasmd) [\#164](https://github.com/CosmWasm/wasmd/issues/164) Control who can upload code
diff --git a/Dockerfile b/Dockerfile
index cb77659a..f4683098 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -39,6 +39,7 @@ RUN BUILD_TAGS=muslc make build
 FROM alpine:3.12
 
 COPY --from=go-builder /code/build/wasmd /usr/bin/wasmd
+COPY --from=go-builder /code/build/wasmgovd /usr/bin/wasmgovd
 COPY --from=go-builder /code/build/wasmcli /usr/bin/wasmcli
 
 COPY docker/* /opt/
diff --git a/Makefile b/Makefile
index a1767da4..c123cdb9 100644
--- a/Makefile
+++ b/Makefile
@@ -70,9 +70,11 @@ all: install lint test
 build: go.sum
 ifeq ($(OS),Windows_NT)
 	go build -mod=readonly $(BUILD_FLAGS) -o build/wasmd.exe ./cmd/wasmd
+	go build -mod=readonly $(BUILD_FLAGS) -o build/wasmgovd.exe ./cmd/wasmgovd
 	go build -mod=readonly $(BUILD_FLAGS) -o build/wasmcli.exe ./cmd/wasmcli
 else
 	go build -mod=readonly $(BUILD_FLAGS) -o build/wasmd ./cmd/wasmd
+	go build -mod=readonly $(BUILD_FLAGS) -o build/wasmgovd ./cmd/wasmgovd
 	go build -mod=readonly $(BUILD_FLAGS) -o build/wasmcli ./cmd/wasmcli
 endif
 
diff --git a/cmd/wasmd/main.go b/cmd/wasmd/main.go
index af768d52..64df648b 100644
--- a/cmd/wasmd/main.go
+++ b/cmd/wasmd/main.go
@@ -41,7 +41,7 @@ func main() {
 	cobra.EnableCommandSorting = false
 	rootCmd := &cobra.Command{
 		Use:               "wasmd",
-		Short:             "Wasm Daemon (server)",
+		Short:             "Wasm Daemon (server) with wasm gov proposals disabled\",",
 		PersistentPreRunE: server.PersistentPreRunEFn(ctx),
 	}
 
@@ -86,7 +86,7 @@ func newApp(logger log.Logger, db dbm.DB, traceStore io.Writer) abci.Application
 	}
 
 	return app.NewWasmApp(logger, db, traceStore, true, invCheckPeriod,
-		wasm.EnableAllProposals, skipUpgradeHeights,
+		wasm.DisableAllProposals, skipUpgradeHeights,
 		baseapp.SetPruning(store.NewPruningOptionsFromString(viper.GetString("pruning"))),
 		baseapp.SetMinGasPrices(viper.GetString(server.FlagMinGasPrices)),
 		baseapp.SetHaltHeight(viper.GetUint64(server.FlagHaltHeight)),
@@ -99,7 +99,7 @@ func exportAppStateAndTMValidators(
 ) (json.RawMessage, []tmtypes.GenesisValidator, error) {
 
 	if height != -1 {
-		gapp := app.NewWasmApp(logger, db, traceStore, false, uint(1), wasm.EnableAllProposals, nil)
+		gapp := app.NewWasmApp(logger, db, traceStore, false, uint(1), wasm.DisableAllProposals, nil)
 		err := gapp.LoadHeight(height)
 		if err != nil {
 			return nil, nil, err
@@ -107,6 +107,6 @@ func exportAppStateAndTMValidators(
 		return gapp.ExportAppStateAndValidators(forZeroHeight, jailWhiteList)
 	}
 
-	gapp := app.NewWasmApp(logger, db, traceStore, true, uint(1), wasm.EnableAllProposals, nil)
+	gapp := app.NewWasmApp(logger, db, traceStore, true, uint(1), wasm.DisableAllProposals, nil)
 	return gapp.ExportAppStateAndValidators(forZeroHeight, jailWhiteList)
 }
diff --git a/cmd/wasmd/replay.go b/cmd/wasmd/replay.go
index be683ea2..9ad98637 100644
--- a/cmd/wasmd/replay.go
+++ b/cmd/wasmd/replay.go
@@ -92,7 +92,7 @@ func replayTxs(rootDir string) error {
 	fmt.Fprintln(os.Stderr, "Creating application")
 	gapp := app.NewWasmApp(
 		// TODO: do we want to set skipUpgradeHieghts here?
-		ctx.Logger, appDB, traceStoreWriter, true, uint(1), wasm.EnableAllProposals, nil,
+		ctx.Logger, appDB, traceStoreWriter, true, uint(1), wasm.DisableAllProposals, nil,
 		baseapp.SetPruning(store.PruneEverything))
 
 	// Genesis
diff --git a/cmd/wasmgovd/genaccounts.go b/cmd/wasmgovd/genaccounts.go
new file mode 100644
index 00000000..031e6576
--- /dev/null
+++ b/cmd/wasmgovd/genaccounts.go
@@ -0,0 +1,153 @@
+package main
+
+import (
+	"bufio"
+	"errors"
+	"fmt"
+
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+
+	"github.com/tendermint/tendermint/libs/cli"
+
+	"github.com/cosmos/cosmos-sdk/client/flags"
+	"github.com/cosmos/cosmos-sdk/codec"
+	"github.com/cosmos/cosmos-sdk/crypto/keys"
+	"github.com/cosmos/cosmos-sdk/server"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/x/auth"
+	authexported "github.com/cosmos/cosmos-sdk/x/auth/exported"
+	authvesting "github.com/cosmos/cosmos-sdk/x/auth/vesting"
+	"github.com/cosmos/cosmos-sdk/x/genutil"
+)
+
+const (
+	flagClientHome   = "home-client"
+	flagVestingStart = "vesting-start-time"
+	flagVestingEnd   = "vesting-end-time"
+	flagVestingAmt   = "vesting-amount"
+)
+
+// AddGenesisAccountCmd returns add-genesis-account cobra Command.
+func AddGenesisAccountCmd(
+	ctx *server.Context, cdc *codec.Codec, defaultNodeHome, defaultClientHome string,
+) *cobra.Command {
+
+	cmd := &cobra.Command{
+		Use:   "add-genesis-account [address_or_key_name] [coin][,[coin]]",
+		Short: "Add a genesis account to genesis.json",
+		Long: `Add a genesis account to genesis.json. The provided account must specify
+the account address or key name and a list of initial coins. If a key name is given,
+the address will be looked up in the local Keybase. The list of initial tokens must
+contain valid denominations. Accounts may optionally be supplied with vesting parameters.
+`,
+		Args: cobra.ExactArgs(2),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			config := ctx.Config
+			config.SetRoot(viper.GetString(cli.HomeFlag))
+
+			addr, err := sdk.AccAddressFromBech32(args[0])
+			inBuf := bufio.NewReader(cmd.InOrStdin())
+			if err != nil {
+				// attempt to lookup address from Keybase if no address was provided
+				kb, err := keys.NewKeyring(
+					sdk.KeyringServiceName(),
+					viper.GetString(flags.FlagKeyringBackend),
+					viper.GetString(flagClientHome),
+					inBuf,
+				)
+				if err != nil {
+					return err
+				}
+
+				info, err := kb.Get(args[0])
+				if err != nil {
+					return fmt.Errorf("failed to get address from Keybase: %w", err)
+				}
+
+				addr = info.GetAddress()
+			}
+
+			coins, err := sdk.ParseCoins(args[1])
+			if err != nil {
+				return fmt.Errorf("failed to parse coins: %w", err)
+			}
+
+			vestingStart := viper.GetInt64(flagVestingStart)
+			vestingEnd := viper.GetInt64(flagVestingEnd)
+			vestingAmt, err := sdk.ParseCoins(viper.GetString(flagVestingAmt))
+			if err != nil {
+				return fmt.Errorf("failed to parse vesting amount: %w", err)
+			}
+
+			// create concrete account type based on input parameters
+			var genAccount authexported.GenesisAccount
+
+			baseAccount := auth.NewBaseAccount(addr, coins.Sort(), nil, 0, 0)
+			if !vestingAmt.IsZero() {
+				baseVestingAccount, err := authvesting.NewBaseVestingAccount(baseAccount, vestingAmt.Sort(), vestingEnd)
+				if err != nil {
+					return fmt.Errorf("failed to create base vesting account: %w", err)
+				}
+
+				switch {
+				case vestingStart != 0 && vestingEnd != 0:
+					genAccount = authvesting.NewContinuousVestingAccountRaw(baseVestingAccount, vestingStart)
+
+				case vestingEnd != 0:
+					genAccount = authvesting.NewDelayedVestingAccountRaw(baseVestingAccount)
+
+				default:
+					return errors.New("invalid vesting parameters; must supply start and end time or end time")
+				}
+			} else {
+				genAccount = baseAccount
+			}
+
+			if err := genAccount.Validate(); err != nil {
+				return fmt.Errorf("failed to validate new genesis account: %w", err)
+			}
+
+			genFile := config.GenesisFile()
+			appState, genDoc, err := genutil.GenesisStateFromGenFile(cdc, genFile)
+			if err != nil {
+				return fmt.Errorf("failed to unmarshal genesis state: %w", err)
+			}
+
+			authGenState := auth.GetGenesisStateFromAppState(cdc, appState)
+
+			if authGenState.Accounts.Contains(addr) {
+				return fmt.Errorf("cannot add account at existing address %s", addr)
+			}
+
+			// Add the new account to the set of genesis accounts and sanitize the
+			// accounts afterwards.
+			authGenState.Accounts = append(authGenState.Accounts, genAccount)
+			authGenState.Accounts = auth.SanitizeGenesisAccounts(authGenState.Accounts)
+
+			authGenStateBz, err := cdc.MarshalJSON(authGenState)
+			if err != nil {
+				return fmt.Errorf("failed to marshal auth genesis state: %w", err)
+			}
+
+			appState[auth.ModuleName] = authGenStateBz
+
+			appStateJSON, err := cdc.MarshalJSON(appState)
+			if err != nil {
+				return fmt.Errorf("failed to marshal application genesis state: %w", err)
+			}
+
+			genDoc.AppState = appStateJSON
+			return genutil.ExportGenesisFile(genDoc, genFile)
+		},
+	}
+
+	cmd.Flags().String(cli.HomeFlag, defaultNodeHome, "node's home directory")
+	cmd.Flags().String(flags.FlagKeyringBackend, flags.DefaultKeyringBackend, "Select keyring's backend (os|file|test)")
+	cmd.Flags().String(flagClientHome, defaultClientHome, "client's home directory")
+	cmd.Flags().String(flagVestingAmt, "", "amount of coins for vesting accounts")
+	cmd.Flags().Uint64(flagVestingStart, 0, "schedule start time (unix epoch) for vesting accounts")
+	cmd.Flags().Uint64(flagVestingEnd, 0, "schedule end time (unix epoch) for vesting accounts")
+
+	return cmd
+}
diff --git a/cmd/wasmgovd/main.go b/cmd/wasmgovd/main.go
new file mode 100644
index 00000000..38d4132e
--- /dev/null
+++ b/cmd/wasmgovd/main.go
@@ -0,0 +1,114 @@
+package main
+
+import (
+	"encoding/json"
+	"io"
+	"os"
+
+	"github.com/CosmWasm/wasmd/app"
+	"github.com/CosmWasm/wasmd/x/wasm"
+	"github.com/cosmos/cosmos-sdk/baseapp"
+	"github.com/cosmos/cosmos-sdk/client/debug"
+	"github.com/cosmos/cosmos-sdk/client/flags"
+	"github.com/cosmos/cosmos-sdk/server"
+	"github.com/cosmos/cosmos-sdk/store"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/x/auth"
+	genutilcli "github.com/cosmos/cosmos-sdk/x/genutil/client/cli"
+	"github.com/cosmos/cosmos-sdk/x/staking"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+	abci "github.com/tendermint/tendermint/abci/types"
+	"github.com/tendermint/tendermint/libs/cli"
+	"github.com/tendermint/tendermint/libs/log"
+	tmtypes "github.com/tendermint/tendermint/types"
+	dbm "github.com/tendermint/tm-db"
+)
+
+const flagInvCheckPeriod = "inv-check-period"
+
+var invCheckPeriod uint
+
+func main() {
+	cdc := app.MakeCodec()
+
+	config := sdk.GetConfig()
+	config.SetBech32PrefixForAccount(sdk.Bech32PrefixAccAddr, sdk.Bech32PrefixAccPub)
+	config.SetBech32PrefixForValidator(sdk.Bech32PrefixValAddr, sdk.Bech32PrefixValPub)
+	config.SetBech32PrefixForConsensusNode(sdk.Bech32PrefixConsAddr, sdk.Bech32PrefixConsPub)
+	config.Seal()
+
+	homeDir := os.ExpandEnv("$HOME/.wasmgovd")
+
+	ctx := server.NewDefaultContext()
+	cobra.EnableCommandSorting = false
+	rootCmd := &cobra.Command{
+		Use:               "wasmgovd",
+		Short:             "Wasm Daemon (server) with wasm gov proposals enabled\",",
+		PersistentPreRunE: server.PersistentPreRunEFn(ctx),
+	}
+	rootCmd.AddCommand(genutilcli.InitCmd(ctx, cdc, app.ModuleBasics, homeDir))
+	rootCmd.AddCommand(genutilcli.CollectGenTxsCmd(ctx, cdc, auth.GenesisAccountIterator{}, homeDir))
+	rootCmd.AddCommand(genutilcli.MigrateGenesisCmd(ctx, cdc))
+	rootCmd.AddCommand(
+		genutilcli.GenTxCmd(
+			ctx, cdc, app.ModuleBasics, staking.AppModuleBasic{},
+			auth.GenesisAccountIterator{}, homeDir, app.DefaultCLIHome,
+		),
+	)
+	rootCmd.AddCommand(genutilcli.ValidateGenesisCmd(ctx, cdc, app.ModuleBasics))
+	rootCmd.AddCommand(AddGenesisAccountCmd(ctx, cdc, homeDir, app.DefaultCLIHome))
+	rootCmd.AddCommand(flags.NewCompletionCmd(rootCmd, true))
+	// rootCmd.AddCommand(testnetCmd(ctx, cdc, app.ModuleBasics, auth.GenesisAccountIterator{}))
+	rootCmd.AddCommand(replayCmd())
+	rootCmd.AddCommand(debug.Cmd(cdc))
+
+	server.AddCommands(ctx, cdc, rootCmd, newApp, exportAppStateAndTMValidators)
+
+	// prepare and add flags
+	executor := cli.PrepareBaseCmd(rootCmd, "WM", homeDir)
+	rootCmd.PersistentFlags().UintVar(&invCheckPeriod, flagInvCheckPeriod,
+		0, "Assert registered invariants every N blocks")
+	err := executor.Execute()
+	if err != nil {
+		panic(err)
+	}
+}
+
+func newApp(logger log.Logger, db dbm.DB, traceStore io.Writer) abci.Application {
+	var cache sdk.MultiStorePersistentCache
+
+	if viper.GetBool(server.FlagInterBlockCache) {
+		cache = store.NewCommitKVStoreCacheManager()
+	}
+
+	skipUpgradeHeights := make(map[int64]bool)
+	for _, h := range viper.GetIntSlice(server.FlagUnsafeSkipUpgrades) {
+		skipUpgradeHeights[int64(h)] = true
+	}
+
+	return app.NewWasmApp(logger, db, traceStore, true, invCheckPeriod,
+		wasm.EnableAllProposals, skipUpgradeHeights,
+		baseapp.SetPruning(store.NewPruningOptionsFromString(viper.GetString("pruning"))),
+		baseapp.SetMinGasPrices(viper.GetString(server.FlagMinGasPrices)),
+		baseapp.SetHaltHeight(viper.GetUint64(server.FlagHaltHeight)),
+		baseapp.SetHaltTime(viper.GetUint64(server.FlagHaltTime)),
+		baseapp.SetInterBlockCache(cache))
+}
+
+func exportAppStateAndTMValidators(
+	logger log.Logger, db dbm.DB, traceStore io.Writer, height int64, forZeroHeight bool, jailWhiteList []string,
+) (json.RawMessage, []tmtypes.GenesisValidator, error) {
+
+	if height != -1 {
+		gapp := app.NewWasmApp(logger, db, traceStore, false, uint(1), wasm.EnableAllProposals, nil)
+		err := gapp.LoadHeight(height)
+		if err != nil {
+			return nil, nil, err
+		}
+		return gapp.ExportAppStateAndValidators(forZeroHeight, jailWhiteList)
+	}
+
+	gapp := app.NewWasmApp(logger, db, traceStore, true, uint(1), wasm.EnableAllProposals, nil)
+	return gapp.ExportAppStateAndValidators(forZeroHeight, jailWhiteList)
+}
diff --git a/cmd/wasmgovd/replay.go b/cmd/wasmgovd/replay.go
new file mode 100644
index 00000000..be683ea2
--- /dev/null
+++ b/cmd/wasmgovd/replay.go
@@ -0,0 +1,191 @@
+package main
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"time"
+
+	"github.com/CosmWasm/wasmd/app"
+	"github.com/CosmWasm/wasmd/x/wasm"
+	"github.com/cosmos/cosmos-sdk/baseapp"
+	"github.com/cosmos/cosmos-sdk/server"
+	"github.com/cosmos/cosmos-sdk/store"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	cpm "github.com/otiai10/copy"
+	"github.com/spf13/cobra"
+	abci "github.com/tendermint/tendermint/abci/types"
+	tmos "github.com/tendermint/tendermint/libs/os"
+	"github.com/tendermint/tendermint/proxy"
+	tmsm "github.com/tendermint/tendermint/state"
+	tmstore "github.com/tendermint/tendermint/store"
+	tm "github.com/tendermint/tendermint/types"
+)
+
+func replayCmd() *cobra.Command {
+	return &cobra.Command{
+		Use:   "replay <root-dir>",
+		Short: "Replay gaia transactions",
+		RunE: func(_ *cobra.Command, args []string) error {
+			return replayTxs(args[0])
+		},
+		Args: cobra.ExactArgs(1),
+	}
+}
+
+func replayTxs(rootDir string) error {
+
+	if false {
+		// Copy the rootDir to a new directory, to preserve the old one.
+		fmt.Fprintln(os.Stderr, "Copying rootdir over")
+		oldRootDir := rootDir
+		rootDir = oldRootDir + "_replay"
+		if tmos.FileExists(rootDir) {
+			tmos.Exit(fmt.Sprintf("temporary copy dir %v already exists", rootDir))
+		}
+		if err := cpm.Copy(oldRootDir, rootDir); err != nil {
+			return err
+		}
+	}
+
+	configDir := filepath.Join(rootDir, "config")
+	dataDir := filepath.Join(rootDir, "data")
+	ctx := server.NewDefaultContext()
+
+	// App DB
+	// appDB := dbm.NewMemDB()
+	fmt.Fprintln(os.Stderr, "Opening app database")
+	appDB, err := sdk.NewLevelDB("application", dataDir)
+	if err != nil {
+		return err
+	}
+
+	// TM DB
+	// tmDB := dbm.NewMemDB()
+	fmt.Fprintln(os.Stderr, "Opening tendermint state database")
+	tmDB, err := sdk.NewLevelDB("state", dataDir)
+	if err != nil {
+		return err
+	}
+
+	// Blockchain DB
+	fmt.Fprintln(os.Stderr, "Opening blockstore database")
+	bcDB, err := sdk.NewLevelDB("blockstore", dataDir)
+	if err != nil {
+		return err
+	}
+
+	// TraceStore
+	var traceStoreWriter io.Writer
+	var traceStoreDir = filepath.Join(dataDir, "trace.log")
+	traceStoreWriter, err = os.OpenFile(
+		traceStoreDir,
+		os.O_WRONLY|os.O_APPEND|os.O_CREATE,
+		0666,
+	)
+	if err != nil {
+		return err
+	}
+
+	// Application
+	fmt.Fprintln(os.Stderr, "Creating application")
+	gapp := app.NewWasmApp(
+		// TODO: do we want to set skipUpgradeHieghts here?
+		ctx.Logger, appDB, traceStoreWriter, true, uint(1), wasm.EnableAllProposals, nil,
+		baseapp.SetPruning(store.PruneEverything))
+
+	// Genesis
+	var genDocPath = filepath.Join(configDir, "genesis.json")
+	genDoc, err := tm.GenesisDocFromFile(genDocPath)
+	if err != nil {
+		return err
+	}
+	genState, err := tmsm.MakeGenesisState(genDoc)
+	if err != nil {
+		return err
+	}
+	// tmsm.SaveState(tmDB, genState)
+
+	cc := proxy.NewLocalClientCreator(gapp)
+	proxyApp := proxy.NewAppConns(cc)
+	err = proxyApp.Start()
+	if err != nil {
+		return err
+	}
+	defer func() {
+		err = proxyApp.Stop()
+		if err != nil {
+			return
+		}
+	}()
+
+	state := tmsm.LoadState(tmDB)
+	if state.LastBlockHeight == 0 {
+		// Send InitChain msg
+		fmt.Fprintln(os.Stderr, "Sending InitChain msg")
+		validators := tm.TM2PB.ValidatorUpdates(genState.Validators)
+		csParams := tm.TM2PB.ConsensusParams(genDoc.ConsensusParams)
+		req := abci.RequestInitChain{
+			Time:            genDoc.GenesisTime,
+			ChainId:         genDoc.ChainID,
+			ConsensusParams: csParams,
+			Validators:      validators,
+			AppStateBytes:   genDoc.AppState,
+		}
+		res, err := proxyApp.Consensus().InitChainSync(req)
+		if err != nil {
+			return err
+		}
+		newValidatorz, err := tm.PB2TM.ValidatorUpdates(res.Validators)
+		if err != nil {
+			return err
+		}
+		newValidators := tm.NewValidatorSet(newValidatorz)
+
+		// Take the genesis state.
+		state = genState
+		state.Validators = newValidators
+		state.NextValidators = newValidators
+	}
+
+	// Create executor
+	fmt.Fprintln(os.Stderr, "Creating block executor")
+	blockExec := tmsm.NewBlockExecutor(tmDB, ctx.Logger, proxyApp.Consensus(), nil, tmsm.MockEvidencePool{})
+
+	// Create block store
+	fmt.Fprintln(os.Stderr, "Creating block store")
+	blockStore := tmstore.NewBlockStore(bcDB)
+
+	tz := []time.Duration{0, 0, 0}
+	for i := int(state.LastBlockHeight) + 1; ; i++ {
+		fmt.Fprintln(os.Stderr, "Running block ", i)
+		t1 := time.Now()
+
+		// Apply block
+		fmt.Printf("loading and applying block %d\n", i)
+		blockmeta := blockStore.LoadBlockMeta(int64(i))
+		if blockmeta == nil {
+			fmt.Printf("Couldn't find block meta %d... done?\n", i)
+			return nil
+		}
+		block := blockStore.LoadBlock(int64(i))
+		if block == nil {
+			return fmt.Errorf("couldn't find block %d", i)
+		}
+
+		t2 := time.Now()
+
+		state, err = blockExec.ApplyBlock(state, blockmeta.BlockID, block)
+		if err != nil {
+			return err
+		}
+
+		t3 := time.Now()
+		tz[0] += t2.Sub(t1)
+		tz[1] += t3.Sub(t2)
+
+		fmt.Fprintf(os.Stderr, "new app hash: %X\n", state.AppHash)
+		fmt.Fprintln(os.Stderr, tz)
+	}
+}
diff --git a/cmd/wasmgovd/testnet.go b/cmd/wasmgovd/testnet.go
new file mode 100644
index 00000000..3409f74e
--- /dev/null
+++ b/cmd/wasmgovd/testnet.go
@@ -0,0 +1,374 @@
+package main
+
+// DONTCOVER
+
+import (
+	"bufio"
+	"encoding/json"
+	"fmt"
+	"net"
+	"os"
+	"path/filepath"
+
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+	tmconfig "github.com/tendermint/tendermint/config"
+	"github.com/tendermint/tendermint/crypto"
+	tmos "github.com/tendermint/tendermint/libs/os"
+	tmrand "github.com/tendermint/tendermint/libs/rand"
+	"github.com/tendermint/tendermint/types"
+	tmtime "github.com/tendermint/tendermint/types/time"
+
+	"github.com/cosmos/cosmos-sdk/client/flags"
+	clientkeys "github.com/cosmos/cosmos-sdk/client/keys"
+	"github.com/cosmos/cosmos-sdk/codec"
+	"github.com/cosmos/cosmos-sdk/crypto/keys"
+	"github.com/cosmos/cosmos-sdk/server"
+	srvconfig "github.com/cosmos/cosmos-sdk/server/config"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/types/module"
+	"github.com/cosmos/cosmos-sdk/x/auth"
+	authexported "github.com/cosmos/cosmos-sdk/x/auth/exported"
+	"github.com/cosmos/cosmos-sdk/x/genutil"
+	genutiltypes "github.com/cosmos/cosmos-sdk/x/genutil/types"
+	"github.com/cosmos/cosmos-sdk/x/staking"
+)
+
+var (
+	flagNodeDirPrefix     = "node-dir-prefix"
+	flagNumValidators     = "v"
+	flagOutputDir         = "output-dir"
+	flagNodeDaemonHome    = "node-daemon-home"
+	flagNodeCLIHome       = "node-cli-home"
+	flagStartingIPAddress = "starting-ip-address"
+)
+
+// get cmd to initialize all files for tendermint testnet and application
+func testnetCmd(ctx *server.Context, cdc *codec.Codec,
+	mbm module.BasicManager, genAccIterator genutiltypes.GenesisAccountsIterator,
+) *cobra.Command {
+
+	cmd := &cobra.Command{
+		Use:   "testnet",
+		Short: "Initialize files for a Wasmd testnet",
+		Long: `testnet will create "v" number of directories and populate each with
+necessary files (private validator, genesis, config, etc.).
+
+Note, strict routability for addresses is turned off in the config file.
+
+Example:
+	wasmd testnet --v 4 --output-dir ./output --starting-ip-address 192.168.10.2
+	`,
+		RunE: func(cmd *cobra.Command, _ []string) error {
+			config := ctx.Config
+
+			outputDir := viper.GetString(flagOutputDir)
+			chainID := viper.GetString(flags.FlagChainID)
+			minGasPrices := viper.GetString(server.FlagMinGasPrices)
+			nodeDirPrefix := viper.GetString(flagNodeDirPrefix)
+			nodeDaemonHome := viper.GetString(flagNodeDaemonHome)
+			nodeCLIHome := viper.GetString(flagNodeCLIHome)
+			startingIPAddress := viper.GetString(flagStartingIPAddress)
+			numValidators := viper.GetInt(flagNumValidators)
+
+			return InitTestnet(cmd, config, cdc, mbm, genAccIterator, outputDir, chainID,
+				minGasPrices, nodeDirPrefix, nodeDaemonHome, nodeCLIHome, startingIPAddress, numValidators)
+		},
+	}
+
+	cmd.Flags().Int(flagNumValidators, 4,
+		"Number of validators to initialize the testnet with")
+	cmd.Flags().StringP(flagOutputDir, "o", "./mytestnet",
+		"Directory to store initialization data for the testnet")
+	cmd.Flags().String(flagNodeDirPrefix, "node",
+		"Prefix the directory name for each node with (node results in node0, node1, ...)")
+	cmd.Flags().String(flagNodeDaemonHome, "wasmd",
+		"Home directory of the node's daemon configuration")
+	cmd.Flags().String(flagNodeCLIHome, "wasmcli",
+		"Home directory of the node's cli configuration")
+	cmd.Flags().String(flagStartingIPAddress, "192.168.0.1",
+		"Starting IP address (192.168.0.1 results in persistent peers list ID0@192.168.0.1:46656, ID1@192.168.0.2:46656, ...)")
+	cmd.Flags().String(
+		flags.FlagChainID, "", "genesis file chain-id, if left blank will be randomly created")
+	cmd.Flags().String(
+		server.FlagMinGasPrices, fmt.Sprintf("0.000006%s", sdk.DefaultBondDenom),
+		"Minimum gas prices to accept for transactions; All fees in a tx must meet this minimum (e.g. 0.01photino,0.001stake)")
+	cmd.Flags().String(flags.FlagKeyringBackend, flags.DefaultKeyringBackend, "Select keyring's backend (os|file|test)")
+	return cmd
+}
+
+const nodeDirPerm = 0755
+
+// Initialize the testnet
+func InitTestnet(cmd *cobra.Command, config *tmconfig.Config, cdc *codec.Codec,
+	mbm module.BasicManager, genAccIterator genutiltypes.GenesisAccountsIterator,
+	outputDir, chainID, minGasPrices, nodeDirPrefix, nodeDaemonHome,
+	nodeCLIHome, startingIPAddress string, numValidators int) error {
+
+	if chainID == "" {
+		chainID = "chain-" + tmrand.Str(6)
+	}
+
+	monikers := make([]string, numValidators)
+	nodeIDs := make([]string, numValidators)
+	valPubKeys := make([]crypto.PubKey, numValidators)
+
+	wasmConfig := srvconfig.DefaultConfig()
+	wasmConfig.MinGasPrices = minGasPrices
+
+	//nolint:prealloc
+	var (
+		genAccounts []authexported.GenesisAccount
+		genFiles    []string
+	)
+
+	inBuf := bufio.NewReader(cmd.InOrStdin())
+	// generate private keys, node IDs, and initial transactions
+	for i := 0; i < numValidators; i++ {
+		nodeDirName := fmt.Sprintf("%s%d", nodeDirPrefix, i)
+		nodeDir := filepath.Join(outputDir, nodeDirName, nodeDaemonHome)
+		clientDir := filepath.Join(outputDir, nodeDirName, nodeCLIHome)
+		gentxsDir := filepath.Join(outputDir, "gentxs")
+
+		config.SetRoot(nodeDir)
+		config.RPC.ListenAddress = "tcp://0.0.0.0:26657"
+
+		if err := os.MkdirAll(filepath.Join(nodeDir, "config"), nodeDirPerm); err != nil {
+			_ = os.RemoveAll(outputDir)
+			return err
+		}
+
+		if err := os.MkdirAll(clientDir, nodeDirPerm); err != nil {
+			_ = os.RemoveAll(outputDir)
+			return err
+		}
+
+		monikers = append(monikers, nodeDirName)
+		config.Moniker = nodeDirName
+
+		ip, err := getIP(i, startingIPAddress)
+		if err != nil {
+			_ = os.RemoveAll(outputDir)
+			return err
+		}
+
+		nodeIDs[i], valPubKeys[i], err = genutil.InitializeNodeValidatorFiles(config)
+		if err != nil {
+			_ = os.RemoveAll(outputDir)
+			return err
+		}
+
+		memo := fmt.Sprintf("%s@%s:26656", nodeIDs[i], ip)
+		genFiles = append(genFiles, config.GenesisFile())
+
+		kb, err := keys.NewKeyring(
+			sdk.KeyringServiceName(),
+			viper.GetString(flags.FlagKeyringBackend),
+			viper.GetString(flagClientHome),
+			inBuf,
+		)
+		if err != nil {
+			return err
+		}
+
+		keyPass := clientkeys.DefaultKeyPass
+		addr, secret, err := server.GenerateSaveCoinKey(kb, nodeDirName, keyPass, true)
+		if err != nil {
+			_ = os.RemoveAll(outputDir)
+			return err
+		}
+
+		info := map[string]string{"secret": secret}
+
+		cliPrint, err := json.Marshal(info)
+		if err != nil {
+			return err
+		}
+
+		// save private key seed words
+		if err := writeFile(fmt.Sprintf("%v.json", "key_seed"), clientDir, cliPrint); err != nil {
+			return err
+		}
+
+		accTokens := sdk.TokensFromConsensusPower(1000)
+		accStakingTokens := sdk.TokensFromConsensusPower(500)
+		coins := sdk.Coins{
+			sdk.NewCoin(fmt.Sprintf("%stoken", nodeDirName), accTokens),
+			sdk.NewCoin(sdk.DefaultBondDenom, accStakingTokens),
+		}
+		genAccounts = append(genAccounts, auth.NewBaseAccount(addr, coins.Sort(), nil, 0, 0))
+
+		valTokens := sdk.TokensFromConsensusPower(100)
+		msg := staking.NewMsgCreateValidator(
+			sdk.ValAddress(addr),
+			valPubKeys[i],
+			sdk.NewCoin(sdk.DefaultBondDenom, valTokens),
+			staking.NewDescription(nodeDirName, "", "", "", ""),
+			staking.NewCommissionRates(sdk.ZeroDec(), sdk.ZeroDec(), sdk.ZeroDec()),
+			sdk.OneInt(),
+		)
+
+		tx := auth.NewStdTx([]sdk.Msg{msg}, auth.StdFee{}, []auth.StdSignature{}, memo)
+		txBldr := auth.NewTxBuilderFromCLI(inBuf).WithChainID(chainID).WithMemo(memo).WithKeybase(kb)
+
+		signedTx, err := txBldr.SignStdTx(nodeDirName, clientkeys.DefaultKeyPass, tx, false)
+		if err != nil {
+			_ = os.RemoveAll(outputDir)
+			return err
+		}
+
+		txBytes, err := cdc.MarshalJSON(signedTx)
+		if err != nil {
+			_ = os.RemoveAll(outputDir)
+			return err
+		}
+
+		// gather gentxs folder
+		if err := writeFile(fmt.Sprintf("%v.json", nodeDirName), gentxsDir, txBytes); err != nil {
+			_ = os.RemoveAll(outputDir)
+			return err
+		}
+
+		// TODO: Rename config file to server.toml as it's not particular to Gaia
+		// (REF: https://github.com/cosmos/cosmos-sdk/issues/4125).
+		wasmConfigFilePath := filepath.Join(nodeDir, "config/wasmd.toml")
+		srvconfig.WriteConfigFile(wasmConfigFilePath, wasmConfig)
+	}
+
+	if err := initGenFiles(cdc, mbm, chainID, genAccounts, genFiles, numValidators); err != nil {
+		return err
+	}
+
+	err := collectGenFiles(
+		cdc, config, chainID, monikers, nodeIDs, valPubKeys, numValidators,
+		outputDir, nodeDirPrefix, nodeDaemonHome, genAccIterator,
+	)
+	if err != nil {
+		return err
+	}
+
+	cmd.PrintErrf("Successfully initialized %d node directories\n", numValidators)
+	return nil
+}
+
+func initGenFiles(
+	cdc *codec.Codec, mbm module.BasicManager, chainID string,
+	genAccounts []authexported.GenesisAccount, genFiles []string, numValidators int,
+) error {
+
+	appGenState := mbm.DefaultGenesis()
+
+	// set the accounts in the genesis state
+	authDataBz := appGenState[auth.ModuleName]
+	var authGenState auth.GenesisState
+	cdc.MustUnmarshalJSON(authDataBz, &authGenState)
+	authGenState.Accounts = genAccounts
+	appGenState[auth.ModuleName] = cdc.MustMarshalJSON(authGenState)
+
+	appGenStateJSON, err := codec.MarshalJSONIndent(cdc, appGenState)
+	if err != nil {
+		return err
+	}
+
+	genDoc := types.GenesisDoc{
+		ChainID:    chainID,
+		AppState:   appGenStateJSON,
+		Validators: nil,
+	}
+
+	// generate empty genesis files for each validator and save
+	for i := 0; i < numValidators; i++ {
+		if err := genDoc.SaveAs(genFiles[i]); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func collectGenFiles(
+	cdc *codec.Codec, config *tmconfig.Config, chainID string,
+	monikers, nodeIDs []string, valPubKeys []crypto.PubKey,
+	numValidators int, outputDir, nodeDirPrefix, nodeDaemonHome string,
+	genAccIterator genutiltypes.GenesisAccountsIterator) error {
+
+	var appState json.RawMessage
+	genTime := tmtime.Now()
+
+	for i := 0; i < numValidators; i++ {
+		nodeDirName := fmt.Sprintf("%s%d", nodeDirPrefix, i)
+		nodeDir := filepath.Join(outputDir, nodeDirName, nodeDaemonHome)
+		gentxsDir := filepath.Join(outputDir, "gentxs")
+		moniker := monikers[i]
+		config.Moniker = nodeDirName
+
+		config.SetRoot(nodeDir)
+
+		nodeID, valPubKey := nodeIDs[i], valPubKeys[i]
+		initCfg := genutil.NewInitConfig(chainID, gentxsDir, moniker, nodeID, valPubKey)
+
+		genDoc, err := types.GenesisDocFromFile(config.GenesisFile())
+		if err != nil {
+			return err
+		}
+
+		nodeAppState, err := genutil.GenAppStateFromConfig(cdc, config, initCfg, *genDoc, genAccIterator)
+		if err != nil {
+			return err
+		}
+
+		if appState == nil {
+			// set the canonical application state (they should not differ)
+			appState = nodeAppState
+		}
+
+		genFile := config.GenesisFile()
+
+		// overwrite each validator's genesis file to have a canonical genesis time
+		if err := genutil.ExportGenesisFileWithTime(genFile, chainID, nil, appState, genTime); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func getIP(i int, startingIPAddr string) (ip string, err error) {
+	if len(startingIPAddr) == 0 {
+		ip, err = server.ExternalIP()
+		if err != nil {
+			return "", err
+		}
+		return ip, nil
+	}
+	return calculateIP(startingIPAddr, i)
+}
+
+func calculateIP(ip string, i int) (string, error) {
+	ipv4 := net.ParseIP(ip).To4()
+	if ipv4 == nil {
+		return "", fmt.Errorf("%v: non ipv4 address", ip)
+	}
+
+	for j := 0; j < i; j++ {
+		ipv4[3]++
+	}
+
+	return ipv4.String(), nil
+}
+
+func writeFile(name string, dir string, contents []byte) error {
+	writePath := filepath.Join(dir)
+	file := filepath.Join(writePath, name)
+
+	err := tmos.EnsureDir(writePath, 0700)
+	if err != nil {
+		return err
+	}
+
+	err = tmos.WriteFile(file, contents, 0600)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
diff --git a/docker/run_wasmgovd.sh b/docker/run_wasmgovd.sh
new file mode 100755
index 00000000..7e5d1217
--- /dev/null
+++ b/docker/run_wasmgovd.sh
@@ -0,0 +1,10 @@
+#!/bin/sh
+
+if test -n "$1"; then
+    # need -R not -r to copy hidden files
+    cp -R "$1/.wasmd" /root
+    cp -R "$1/.wasmcli" /root
+fi
+
+mkdir -p /root/log
+wasmgovd start --rpc.laddr tcp://0.0.0.0:26657 --trace
diff --git a/docker/setup.sh b/docker/setup_wasmd.sh
similarity index 100%
rename from docker/setup.sh
rename to docker/setup_wasmd.sh
diff --git a/docker/setup_wasmgovd.sh b/docker/setup_wasmgovd.sh
new file mode 100755
index 00000000..40198c40
--- /dev/null
+++ b/docker/setup_wasmgovd.sh
@@ -0,0 +1,24 @@
+#!/bin/sh
+#set -o errexit -o nounset -o pipefail
+
+PASSWORD=${PASSWORD:-1234567890}
+STAKE=${STAKE_TOKEN:-ustake}
+FEE=${FEE_TOKEN:-ucosm}
+
+wasmgovd init --chain-id=testing testing
+sed -i 's/permission": "Everybody"/permission": "Nobody"/'  "$HOME"/.wasmgovd/config/genesis.json
+# staking/governance token is hardcoded in config, change this
+sed -i "s/\"stake\"/\"$STAKE\"/" "$HOME"/.wasmgovd/config/genesis.json
+if ! wasmcli keys show validator; then
+  (echo "$PASSWORD"; echo "$PASSWORD") | wasmcli keys add validator
+fi
+# hardcode the validator account for this instance
+echo "$PASSWORD" | wasmgovd add-genesis-account validator "1000000000$STAKE,1000000000$FEE"
+# (optionally) add a few more genesis accounts
+for addr in "$@"; do
+  echo $addr
+  wasmgovd add-genesis-account "$addr" "1000000000$STAKE,1000000000$FEE"
+done
+# submit a genesis validator tx
+(echo "$PASSWORD"; echo "$PASSWORD"; echo "$PASSWORD") | wasmgovd gentx --name validator --amount "250000000$STAKE"
+wasmgovd collect-gentxs
diff --git a/x/wasm/client/proposal_handler_test.go b/x/wasm/client/proposal_handler_test.go
index c3222c07..e0ae0b9c 100644
--- a/x/wasm/client/proposal_handler_test.go
+++ b/x/wasm/client/proposal_handler_test.go
@@ -53,12 +53,12 @@ func TestGovRestHandlers(t *testing.T) {
 				"description":    "My proposal",
 				"type":           "store-code",
 				"run_as":         "cosmos100dejzacpanrldpjjwksjm62shqhyss44jf5xz",
-				"wasm_byte_code": "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",
+				"wasm_byte_code": []byte("valid wasm byte code"),
 				"source":         "https://example.com/",
 				"builder":        "my/builder:tag",
 				"instantiate_permission": dict{
-					"type":    2,
-					"address": "cosmos1ve557a5g9yw2g2z57js3pdmcvd5my6g8ze20np",
+					"permission": "OnlyAddress",
+					"address":    "cosmos1ve557a5g9yw2g2z57js3pdmcvd5my6g8ze20np",
 				},
 				"deposit":  []dict{{"denom": "ustake", "amount": "10"}},
 				"proposer": "cosmos1ve557a5g9yw2g2z57js3pdmcvd5my6g8ze20np",
@@ -66,6 +66,42 @@ func TestGovRestHandlers(t *testing.T) {
 			},
 			expCode: http.StatusOK,
 		},
+		"store-code without permission": {
+			srcPath: "/gov/proposals/wasm_store_code",
+			srcBody: dict{
+				"title":          "Test Proposal",
+				"description":    "My proposal",
+				"type":           "store-code",
+				"run_as":         "cosmos100dejzacpanrldpjjwksjm62shqhyss44jf5xz",
+				"wasm_byte_code": []byte("valid wasm byte code"),
+				"source":         "https://example.com/",
+				"builder":        "my/builder:tag",
+				"deposit":        []dict{{"denom": "ustake", "amount": "10"}},
+				"proposer":       "cosmos1ve557a5g9yw2g2z57js3pdmcvd5my6g8ze20np",
+				"base_req":       aBaseReq,
+			},
+			expCode: http.StatusOK,
+		},
+		"store-code invalid permission": {
+			srcPath: "/gov/proposals/wasm_store_code",
+			srcBody: dict{
+				"title":          "Test Proposal",
+				"description":    "My proposal",
+				"type":           "store-code",
+				"run_as":         "cosmos100dejzacpanrldpjjwksjm62shqhyss44jf5xz",
+				"wasm_byte_code": []byte("valid wasm byte code"),
+				"source":         "https://example.com/",
+				"builder":        "my/builder:tag",
+				"instantiate_permission": dict{
+					"permission": "Nobody",
+					"address":    "cosmos1ve557a5g9yw2g2z57js3pdmcvd5my6g8ze20np",
+				},
+				"deposit":  []dict{{"denom": "ustake", "amount": "10"}},
+				"proposer": "cosmos1ve557a5g9yw2g2z57js3pdmcvd5my6g8ze20np",
+				"base_req": aBaseReq,
+			},
+			expCode: http.StatusBadRequest,
+		},
 		"store-code with incomplete proposal data: blank title": {
 			srcPath: "/gov/proposals/wasm_store_code",
 			srcBody: dict{
@@ -73,12 +109,12 @@ func TestGovRestHandlers(t *testing.T) {
 				"description":    "My proposal",
 				"type":           "store-code",
 				"run_as":         "cosmos100dejzacpanrldpjjwksjm62shqhyss44jf5xz",
-				"wasm_byte_code": "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",
+				"wasm_byte_code": []byte("valid wasm byte code"),
 				"source":         "https://example.com/",
 				"builder":        "my/builder:tag",
 				"instantiate_permission": dict{
-					"type":    2,
-					"address": "cosmos1ve557a5g9yw2g2z57js3pdmcvd5my6g8ze20np",
+					"permission": "OnlyAddress",
+					"address":    "cosmos1ve557a5g9yw2g2z57js3pdmcvd5my6g8ze20np",
 				},
 				"deposit":  []dict{{"denom": "ustake", "amount": "10"}},
 				"proposer": "cosmos1ve557a5g9yw2g2z57js3pdmcvd5my6g8ze20np",
@@ -97,8 +133,8 @@ func TestGovRestHandlers(t *testing.T) {
 				"source":         "https://example.com/",
 				"builder":        "my/builder:tag",
 				"instantiate_permission": dict{
-					"type":    2,
-					"address": "cosmos1ve557a5g9yw2g2z57js3pdmcvd5my6g8ze20np",
+					"permission": "OnlyAddress",
+					"address":    "cosmos1ve557a5g9yw2g2z57js3pdmcvd5my6g8ze20np",
 				},
 				"deposit":  []dict{{"denom": "ustake", "amount": "10"}},
 				"proposer": "cosmos1ve557a5g9yw2g2z57js3pdmcvd5my6g8ze20np",
diff --git a/x/wasm/internal/keeper/keeper_test.go b/x/wasm/internal/keeper/keeper_test.go
index 2422becc..47710695 100644
--- a/x/wasm/internal/keeper/keeper_test.go
+++ b/x/wasm/internal/keeper/keeper_test.go
@@ -306,7 +306,7 @@ func TestInstantiate(t *testing.T) {
 	require.Equal(t, "cosmos18vd8fpwxzck93qlwghaj6arh4p7c5n89uzcee5", addr.String())
 
 	gasAfter := ctx.GasMeter().GasConsumed()
-	require.Equal(t, uint64(0x11542), gasAfter-gasBefore)
+	require.Equal(t, uint64(0x1155d), gasAfter-gasBefore)
 
 	// ensure it is stored properly
 	info := keeper.GetContractInfo(ctx, addr)
@@ -527,7 +527,7 @@ func TestExecute(t *testing.T) {
 
 	// make sure gas is properly deducted from ctx
 	gasAfter := ctx.GasMeter().GasConsumed()
-	require.Equal(t, uint64(0x11bfb), gasAfter-gasBefore)
+	require.Equal(t, uint64(0x11c16), gasAfter-gasBefore)
 
 	// ensure bob now exists and got both payments released
 	bobAcct = accKeeper.GetAccount(ctx, bob)
diff --git a/x/wasm/internal/keeper/test_fuzz.go b/x/wasm/internal/keeper/test_fuzz.go
index 5dcc2f55..cc83c867 100644
--- a/x/wasm/internal/keeper/test_fuzz.go
+++ b/x/wasm/internal/keeper/test_fuzz.go
@@ -36,7 +36,14 @@ func FuzzStateModel(m *types.Model, c fuzz.Continue) {
 }
 
 func FuzzAccessType(m *types.AccessType, c fuzz.Continue) {
-	*m = types.AllAccessTypes[c.Int()%len(types.AllAccessTypes)]
+	pos := c.Int() % len(types.AllAccessTypes)
+	for k, _ := range types.AllAccessTypes {
+		if pos == 0 {
+			*m = k
+			return
+		}
+		pos--
+	}
 }
 func FuzzAccessConfig(m *types.AccessConfig, c fuzz.Continue) {
 	FuzzAccessType(&m.Type, c)
diff --git a/x/wasm/internal/types/genesis.go b/x/wasm/internal/types/genesis.go
index 3fa9cd3e..be6a70bf 100644
--- a/x/wasm/internal/types/genesis.go
+++ b/x/wasm/internal/types/genesis.go
@@ -21,9 +21,9 @@ func (s Sequence) ValidateBasic() error {
 // GenesisState is the struct representation of the export genesis
 type GenesisState struct {
 	Params    Params     `json:"params"`
-	Codes     []Code     `json:"codes"`
-	Contracts []Contract `json:"contracts"`
-	Sequences []Sequence `json:"sequences"`
+	Codes     []Code     `json:"codes,omitempty"`
+	Contracts []Contract `json:"contracts,omitempty"`
+	Sequences []Sequence `json:"sequences,omitempty"`
 }
 
 func (s GenesisState) ValidateBasic() error {
diff --git a/x/wasm/internal/types/params.go b/x/wasm/internal/types/params.go
index 58908464..54a89fe7 100644
--- a/x/wasm/internal/types/params.go
+++ b/x/wasm/internal/types/params.go
@@ -18,16 +18,20 @@ const (
 var ParamStoreKeyUploadAccess = []byte("uploadAccess")
 var ParamStoreKeyInstantiateAccess = []byte("instantiateAccess")
 
-type AccessType uint8
+type AccessType string
 
 const (
-	Undefined   AccessType = 0
-	Nobody      AccessType = 1
-	OnlyAddress AccessType = 2
-	Everybody   AccessType = 3
+	Undefined   AccessType = "Undefined"
+	Nobody      AccessType = "Nobody"
+	OnlyAddress AccessType = "OnlyAddress"
+	Everybody   AccessType = "Everybody"
 )
 
-var AllAccessTypes = []AccessType{Nobody, OnlyAddress, Everybody}
+var AllAccessTypes = map[AccessType]struct{}{
+	Nobody:      {},
+	OnlyAddress: {},
+	Everybody:   {},
+}
 
 func (a AccessType) With(addr sdk.AccAddress) AccessConfig {
 	switch a {
@@ -44,9 +48,26 @@ func (a AccessType) With(addr sdk.AccAddress) AccessConfig {
 	panic("unsupported access type")
 }
 
+func (a *AccessType) UnmarshalText(text []byte) error {
+	s := AccessType(text)
+	if _, ok := AllAccessTypes[s]; ok {
+		*a = s
+		return nil
+	}
+	*a = Undefined
+	return nil
+}
+
+func (a AccessType) MarshalText() ([]byte, error) {
+	if _, ok := AllAccessTypes[a]; ok {
+		return []byte(a), nil
+	}
+	return []byte(Undefined), nil
+}
+
 type AccessConfig struct {
-	Type    AccessType     `json:"type" yaml:"type"`
-	Address sdk.AccAddress `json:"address" yaml:"address"`
+	Type    AccessType     `json:"permission" yaml:"permission"`
+	Address sdk.AccAddress `json:"address,omitempty" yaml:"address"`
 }
 
 func (a AccessConfig) Equals(o AccessConfig) bool {
@@ -61,7 +82,7 @@ var (
 
 // Params defines the set of wasm parameters.
 type Params struct {
-	UploadAccess                 AccessConfig `json:"upload_access" yaml:"upload_access"`
+	UploadAccess                 AccessConfig `json:"code_upload_access" yaml:"code_upload_access"`
 	DefaultInstantiatePermission AccessType   `json:"instantiate_default_permission" yaml:"instantiate_default_permission"`
 }
 
@@ -118,12 +139,10 @@ func validateAccessType(i interface{}) error {
 	if v == Undefined {
 		return sdkerrors.Wrap(ErrEmpty, "type")
 	}
-	for i := range AllAccessTypes {
-		if AllAccessTypes[i] == v {
-			return nil
-		}
+	if _, ok := AllAccessTypes[v]; !ok {
+		return sdkerrors.Wrapf(ErrInvalid, "unknown type: %q", v)
 	}
-	return sdkerrors.Wrapf(ErrInvalid, "unknown type: %d", v)
+	return nil
 }
 
 func (v AccessConfig) ValidateBasic() error {
@@ -138,7 +157,7 @@ func (v AccessConfig) ValidateBasic() error {
 	case OnlyAddress:
 		return sdk.VerifyAddressFormat(v.Address)
 	}
-	return sdkerrors.Wrapf(ErrInvalid, "unknown type: %d", v.Type)
+	return sdkerrors.Wrapf(ErrInvalid, "unknown type: %q", v.Type)
 }
 
 func (v AccessConfig) Allowed(actor sdk.AccAddress) bool {
diff --git a/x/wasm/internal/types/params_test.go b/x/wasm/internal/types/params_test.go
index 6743a44b..8bbecc61 100644
--- a/x/wasm/internal/types/params_test.go
+++ b/x/wasm/internal/types/params_test.go
@@ -1,9 +1,11 @@
 package types
 
 import (
+	"encoding/json"
 	"testing"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
@@ -41,14 +43,14 @@ func TestValidateParams(t *testing.T) {
 		"reject empty type in instantiate permission": {
 			src: Params{
 				UploadAccess:                 AllowNobody,
-				DefaultInstantiatePermission: 0,
+				DefaultInstantiatePermission: "",
 			},
 			expErr: true,
 		},
 		"reject unknown type in instantiate": {
 			src: Params{
 				UploadAccess:                 AllowNobody,
-				DefaultInstantiatePermission: 4,
+				DefaultInstantiatePermission: "Undefined",
 			},
 			expErr: true,
 		},
@@ -84,5 +86,44 @@ func TestValidateParams(t *testing.T) {
 			}
 		})
 	}
-
+}
+
+func TestAccessTypeMarshalJson(t *testing.T) {
+	specs := map[string]struct {
+		src AccessType
+		exp string
+	}{
+		"Undefined":   {src: Undefined, exp: `"Undefined"`},
+		"Nobody":      {src: Nobody, exp: `"Nobody"`},
+		"OnlyAddress": {src: OnlyAddress, exp: `"OnlyAddress"`},
+		"Everybody":   {src: Everybody, exp: `"Everybody"`},
+		"unknown":     {src: "", exp: `"Undefined"`},
+	}
+	for msg, spec := range specs {
+		t.Run(msg, func(t *testing.T) {
+			got, err := json.Marshal(spec.src)
+			require.NoError(t, err)
+			assert.Equal(t, []byte(spec.exp), got)
+		})
+	}
+}
+func TestAccessTypeUnMarshalJson(t *testing.T) {
+	specs := map[string]struct {
+		src string
+		exp AccessType
+	}{
+		"Undefined":   {src: `"Undefined"`, exp: Undefined},
+		"Nobody":      {src: `"Nobody"`, exp: Nobody},
+		"OnlyAddress": {src: `"OnlyAddress"`, exp: OnlyAddress},
+		"Everybody":   {src: `"Everybody"`, exp: Everybody},
+		"unknown":     {src: `""`, exp: Undefined},
+	}
+	for msg, spec := range specs {
+		t.Run(msg, func(t *testing.T) {
+			var got AccessType
+			err := json.Unmarshal([]byte(spec.src), &got)
+			require.NoError(t, err)
+			assert.Equal(t, spec.exp, got)
+		})
+	}
 }