diff --git a/app/app.go b/app/app.go
index 27f31950d4..fa99458e6d 100644
--- a/app/app.go
+++ b/app/app.go
@@ -34,6 +34,8 @@ type Basecoin struct {
 	logger     log.Logger
 }
 
+var _ abci.Application = &Basecoin{}
+
 // NewBasecoin - create a new instance of the basecoin application
 func NewBasecoin(handler basecoin.Handler, eyesCli *eyes.Client, logger log.Logger) *Basecoin {
 	state := sm.NewState(eyesCli, logger.With("module", "state"))
diff --git a/cmd/basecoin/commands/utils.go b/cmd/basecoin/commands/utils.go
deleted file mode 100644
index 8df68faac1..0000000000
--- a/cmd/basecoin/commands/utils.go
+++ /dev/null
@@ -1,23 +0,0 @@
-package commands
-
-import "encoding/hex"
-
-// Returns true for non-empty hex-string prefixed with "0x"
-func isHex(s string) bool {
-	if len(s) > 2 && s[:2] == "0x" {
-		_, err := hex.DecodeString(s[2:])
-		if err != nil {
-			return false
-		}
-		return true
-	}
-	return false
-}
-
-// StripHex remove the first two hex bytes
-func StripHex(s string) string {
-	if isHex(s) {
-		return s[2:]
-	}
-	return s
-}
diff --git a/cmd/basecoin/commands/utils_test.go b/cmd/basecoin/commands/utils_test.go
deleted file mode 100644
index 692fec7433..0000000000
--- a/cmd/basecoin/commands/utils_test.go
+++ /dev/null
@@ -1,24 +0,0 @@
-package commands
-
-import (
-	"encoding/hex"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestHex(t *testing.T) {
-	assert := assert.New(t)
-
-	//test isHex
-	hexNoPrefix := hex.EncodeToString([]byte("foobar"))
-	hexWPrefix := "0x" + hexNoPrefix
-	str := "foobar"
-	strWPrefix := "0xfoobar"
-
-	assert.True(isHex(hexWPrefix), "isHex not identifying hex with 0x prefix")
-	assert.False(isHex(hexNoPrefix), "isHex shouldn't identify hex without 0x prefix")
-	assert.False(isHex(str), "isHex shouldn't identify non-hex string")
-	assert.False(isHex(strWPrefix), "isHex shouldn't identify non-hex string with 0x prefix")
-	assert.True(StripHex(hexWPrefix) == hexNoPrefix, "StripHex doesn't remove first two characters")
-}
diff --git a/errors/common_test.go b/errors/common_test.go
index 42e3204a5e..59d5fc6268 100644
--- a/errors/common_test.go
+++ b/errors/common_test.go
@@ -19,15 +19,15 @@ func (h holder) Unwrap() validate {
 	return h.validate
 }
 
-type DemoTx struct {
+type demoTx struct {
 	Age int
 }
 
-func (t DemoTx) Wrap() holder {
+func (t demoTx) Wrap() holder {
 	return holder{t}
 }
 
-func (t DemoTx) ValidateBasic() error {
+func (t demoTx) ValidateBasic() error {
 	return nil
 }
 
@@ -45,7 +45,7 @@ func TestErrorMatches(t *testing.T) {
 		{errWrongChain, ErrWrongChain("hakz"), true},
 		{errUnknownTxType, ErrUnknownTxType(holder{}), true},
 		{errUnknownTxType, ErrUnknownTxType("some text here..."), true},
-		{errUnknownTxType, ErrUnknownTxType(DemoTx{5}.Wrap()), true},
+		{errUnknownTxType, ErrUnknownTxType(demoTx{5}.Wrap()), true},
 	}
 
 	for i, tc := range cases {
diff --git a/modules/auth/tx.go b/modules/auth/tx.go
index b48c993be9..26e2b94b68 100644
--- a/modules/auth/tx.go
+++ b/modules/auth/tx.go
@@ -1,5 +1,5 @@
 /*
-package auth contains generic Signable implementations that can be used
+Package auth contains generic Signable implementations that can be used
 by your application or tests to handle authentication needs.
 
 It currently supports transaction data as opaque bytes and either single
@@ -71,14 +71,13 @@ func NewSig(tx basecoin.Tx) *OneSig {
 	return &OneSig{Tx: tx}
 }
 
+//nolint
 func (s *OneSig) Wrap() basecoin.Tx {
 	return basecoin.Tx{s}
 }
-
 func (s *OneSig) Next() basecoin.Tx {
 	return s.Tx
 }
-
 func (s *OneSig) ValidateBasic() error {
 	return s.Tx.ValidateBasic()
 }
@@ -143,14 +142,13 @@ func NewMulti(tx basecoin.Tx) *MultiSig {
 	return &MultiSig{Tx: tx}
 }
 
+// nolint
 func (s *MultiSig) Wrap() basecoin.Tx {
 	return basecoin.Tx{s}
 }
-
 func (s *MultiSig) Next() basecoin.Tx {
 	return s.Tx
 }
-
 func (s *MultiSig) ValidateBasic() error {
 	return s.Tx.ValidateBasic()
 }
@@ -204,6 +202,7 @@ func (s *MultiSig) Signers() ([]crypto.PubKey, error) {
 	return keys, nil
 }
 
+// Sign - sign the transaction with private key
 func Sign(tx keys.Signable, key crypto.PrivKey) error {
 	msg := tx.SignBytes()
 	pubkey := key.PubKey()
diff --git a/modules/base/tx.go b/modules/base/tx.go
index e8848a89c3..b4f2cd2b78 100644
--- a/modules/base/tx.go
+++ b/modules/base/tx.go
@@ -22,18 +22,21 @@ func init() {
 }
 
 /**** MultiTx  ******/
+
+// MultiTx - a transaction containing multiple transactions
 type MultiTx struct {
 	Txs []basecoin.Tx `json:"txs"`
 }
 
+var _ basecoin.TxInner = &MultiTx{}
+
+//nolint - TxInner Functions
 func NewMultiTx(txs ...basecoin.Tx) basecoin.Tx {
 	return (MultiTx{Txs: txs}).Wrap()
 }
-
 func (mt MultiTx) Wrap() basecoin.Tx {
 	return basecoin.Tx{mt}
 }
-
 func (mt MultiTx) ValidateBasic() error {
 	for _, t := range mt.Txs {
 		err := t.ValidateBasic()
@@ -52,14 +55,15 @@ type ChainTx struct {
 	ChainID string      `json:"chain_id"`
 }
 
+var _ basecoin.TxInner = &ChainTx{}
+
+//nolint - TxInner Functions
 func NewChainTx(chainID string, tx basecoin.Tx) basecoin.Tx {
 	return (ChainTx{Tx: tx, ChainID: chainID}).Wrap()
 }
-
 func (c ChainTx) Wrap() basecoin.Tx {
 	return basecoin.Tx{c}
 }
-
 func (c ChainTx) ValidateBasic() error {
 	// TODO: more checks? chainID?
 	return c.Tx.ValidateBasic()
diff --git a/modules/coin/coin.go b/modules/coin/coin.go
index c7f1a18568..6696288abf 100644
--- a/modules/coin/coin.go
+++ b/modules/coin/coin.go
@@ -118,10 +118,10 @@ func (coins Coins) IsValid() bool {
 //
 // TODO: handle empty coins!
 // Currently appends an empty coin ...
-func (coinsA Coins) Plus(coinsB Coins) Coins {
+func (coins Coins) Plus(coinsB Coins) Coins {
 	sum := []Coin{}
 	indexA, indexB := 0, 0
-	lenA, lenB := len(coinsA), len(coinsB)
+	lenA, lenB := len(coins), len(coinsB)
 	for {
 		if indexA == lenA {
 			if indexB == lenB {
@@ -129,9 +129,9 @@ func (coinsA Coins) Plus(coinsB Coins) Coins {
 			}
 			return append(sum, coinsB[indexB:]...)
 		} else if indexB == lenB {
-			return append(sum, coinsA[indexA:]...)
+			return append(sum, coins[indexA:]...)
 		}
-		coinA, coinB := coinsA[indexA], coinsB[indexB]
+		coinA, coinB := coins[indexA], coinsB[indexB]
 		switch strings.Compare(coinA.Denom, coinB.Denom) {
 		case -1:
 			sum = append(sum, coinA)
@@ -168,15 +168,15 @@ func (coins Coins) Negative() Coins {
 }
 
 // Minus subtracts a set of coins from another (adds the inverse)
-func (coinsA Coins) Minus(coinsB Coins) Coins {
-	return coinsA.Plus(coinsB.Negative())
+func (coins Coins) Minus(coinsB Coins) Coins {
+	return coins.Plus(coinsB.Negative())
 }
 
-// IsGTE returns True iff coinsA is NonNegative(), and for every
+// IsGTE returns True iff coins is NonNegative(), and for every
 // currency in coinsB, the currency is present at an equal or greater
 // amount in coinsB
-func (coinsA Coins) IsGTE(coinsB Coins) bool {
-	diff := coinsA.Minus(coinsB)
+func (coins Coins) IsGTE(coinsB Coins) bool {
+	diff := coins.Minus(coinsB)
 	if len(diff) == 0 {
 		return true
 	}
@@ -189,12 +189,12 @@ func (coins Coins) IsZero() bool {
 }
 
 // IsEqual returns true if the two sets of Coins have the same value
-func (coinsA Coins) IsEqual(coinsB Coins) bool {
-	if len(coinsA) != len(coinsB) {
+func (coins Coins) IsEqual(coinsB Coins) bool {
+	if len(coins) != len(coinsB) {
 		return false
 	}
-	for i := 0; i < len(coinsA); i++ {
-		if coinsA[i] != coinsB[i] {
+	for i := 0; i < len(coins); i++ {
+		if coins[i] != coinsB[i] {
 			return false
 		}
 	}
diff --git a/modules/fee/tx.go b/modules/fee/tx.go
index 13aac2209f..c17de796c4 100644
--- a/modules/fee/tx.go
+++ b/modules/fee/tx.go
@@ -18,6 +18,8 @@ func init() {
 
 /**** Fee ****/
 
+var _ basecoin.TxLayer = &Fee{}
+
 // Fee attaches a fee payment to the embedded tx
 type Fee struct {
 	Tx    basecoin.Tx    `json:"tx"`
@@ -26,19 +28,17 @@ type Fee struct {
 	// Gas coin.Coin `json:"gas"`  // ?????
 }
 
+// nolint - TxInner Functions
 func NewFee(tx basecoin.Tx, fee coin.Coin, payer basecoin.Actor) basecoin.Tx {
 	return (&Fee{Tx: tx, Fee: fee, Payer: payer}).Wrap()
 }
-
 func (f *Fee) ValidateBasic() error {
 	// TODO: more checks
 	return f.Tx.ValidateBasic()
 }
-
 func (f *Fee) Wrap() basecoin.Tx {
 	return basecoin.Tx{f}
 }
-
 func (f *Fee) Next() basecoin.Tx {
 	return f.Tx
 }
diff --git a/publish/dist.sh b/publish/dist.sh
index f96d6454f9..6f488477bc 100755
--- a/publish/dist.sh
+++ b/publish/dist.sh
@@ -5,7 +5,7 @@ REPO_NAME="basecoin"
 
 # Get the version from the environment, or try to figure it out.
 if [ -z $VERSION ]; then
-	VERSION=$(awk -F\" '/Version =/ { print $2; exit }' < version/version.go)
+    VERSION=$(awk -F\" '/Version =/ { print $2; exit }' < version/version.go)
 fi
 if [ -z "$VERSION" ]; then
     echo "Please specify a version."
@@ -34,8 +34,8 @@ docker run --rm -e "BUILD_TAGS=$BUILD_TAGS" -v "$(pwd)":/go/src/github.com/tende
 rm -rf ./build/dist
 mkdir -p ./build/dist
 for FILENAME in $(find ./build/pkg -mindepth 1 -maxdepth 1 -type f); do
-  FILENAME=$(basename "$FILENAME")
-	cp "./build/pkg/${FILENAME}" "./build/dist/${REPO_NAME}_${VERSION}_${FILENAME}"
+    FILENAME=$(basename "$FILENAME")
+    cp "./build/pkg/${FILENAME}" "./build/dist/${REPO_NAME}_${VERSION}_${FILENAME}"
 done
 
 # Make the checksums.
diff --git a/publish/dist_build.sh b/publish/dist_build.sh
index 4268a7633f..036ee7735c 100755
--- a/publish/dist_build.sh
+++ b/publish/dist_build.sh
@@ -27,13 +27,13 @@ make get_vendor_deps
 # Build!
 echo "==> Building basecoin..."
 "$(which gox)" \
-		-os="${XC_OS}" \
-		-arch="${XC_ARCH}" \
-		-osarch="!darwin/arm !solaris/amd64 !freebsd/amd64" \
-		-ldflags "-X ${GIT_IMPORT}.GitCommit='${GIT_COMMIT}' -X ${GIT_IMPORT}.GitDescribe='${GIT_DESCRIBE}'" \
-		-output "build/pkg/{{.OS}}_{{.Arch}}/basecoin" \
-		-tags="${BUILD_TAGS}" \
-		github.com/tendermint/basecoin/cmd/basecoin
+    -os="${XC_OS}" \
+    -arch="${XC_ARCH}" \
+    -osarch="!darwin/arm !solaris/amd64 !freebsd/amd64" \
+    -ldflags "-X ${GIT_IMPORT}.GitCommit='${GIT_COMMIT}' -X ${GIT_IMPORT}.GitDescribe='${GIT_DESCRIBE}'" \
+    -output "build/pkg/{{.OS}}_{{.Arch}}/basecoin" \
+    -tags="${BUILD_TAGS}" \
+    github.com/tendermint/basecoin/cmd/basecoin
 
 echo "==> Building basecli..."
 "$(which gox)" \
@@ -48,12 +48,12 @@ echo "==> Building basecli..."
 # Zip all the files.
 echo "==> Packaging..."
 for PLATFORM in $(find ./build/pkg -mindepth 1 -maxdepth 1 -type d); do
-		OSARCH=$(basename "${PLATFORM}")
-		echo "--> ${OSARCH}"
+    OSARCH=$(basename "${PLATFORM}")
+    echo "--> ${OSARCH}"
 
-		pushd "$PLATFORM" >/dev/null 2>&1
-		zip "../${OSARCH}.zip" ./*
-		popd >/dev/null 2>&1
+    pushd "$PLATFORM" >/dev/null 2>&1
+    zip "../${OSARCH}.zip" ./*
+    popd >/dev/null 2>&1
 done
 
 
diff --git a/publish/print_test_account.go b/publish/print_test_account.go
index 12e4bd005f..d96d151a49 100644
--- a/publish/print_test_account.go
+++ b/publish/print_test_account.go
@@ -4,6 +4,7 @@ package main
 
 import (
 	"fmt"
+
 	"github.com/tendermint/basecoin/tests"
 	"github.com/tendermint/go-wire"
 )
diff --git a/publish/print_txs.go b/publish/print_txs.go
index d31e70ffa5..68a11285ee 100644
--- a/publish/print_txs.go
+++ b/publish/print_txs.go
@@ -9,11 +9,11 @@ import (
 	"time"
 
 	"github.com/gorilla/websocket"
-	cmn "github.com/tendermint/tmlibs/common"
-	"github.com/tendermint/tendermint/rpc/lib/client"
-	"github.com/tendermint/tendermint/rpc/lib/types"
 	"github.com/tendermint/go-wire"
 	_ "github.com/tendermint/tendermint/rpc/core/types" // Register RPCResponse > Result types
+	"github.com/tendermint/tendermint/rpc/lib/client"
+	"github.com/tendermint/tendermint/rpc/lib/types"
+	cmn "github.com/tendermint/tmlibs/common"
 )
 
 func main() {
diff --git a/publish/publish.sh b/publish/publish.sh
index 434c28e015..738dbdd415 100644
--- a/publish/publish.sh
+++ b/publish/publish.sh
@@ -2,6 +2,6 @@
 
 # Get the version from the environment, or try to figure it out.
 if [ -z $VERSION ]; then
-	VERSION=$(awk -F\" '/Version =/ { print $2; exit }' < version/version.go)
+    VERSION=$(awk -F\" '/Version =/ { print $2; exit }' < version/version.go)
 fi
 aws s3 cp --recursive build/dist s3://tendermint/binaries/basecoin/v${VERSION} --acl public-read
diff --git a/stack/context.go b/stack/context.go
index 8953ee8656..7ff0fa4f22 100644
--- a/stack/context.go
+++ b/stack/context.go
@@ -23,6 +23,7 @@ type secureContext struct {
 	log.Logger
 }
 
+// NewContext - create a new secureContext
 func NewContext(chain string, logger log.Logger) basecoin.Context {
 	return secureContext{
 		id:     nonce(rand.Int63()),
diff --git a/stack/helpers.go b/stack/helpers.go
index 7c482ee8a8..a3dd296e5f 100644
--- a/stack/helpers.go
+++ b/stack/helpers.go
@@ -33,10 +33,15 @@ type RawTx struct {
 	data.Bytes
 }
 
+var _ basecoin.TxInner = RawTx{}
+
+// nolint
+func NewRawTx(d []byte) basecoin.Tx {
+	return RawTx{data.Bytes(d)}.Wrap()
+}
 func (r RawTx) Wrap() basecoin.Tx {
 	return basecoin.Tx{r}
 }
-
 func (r RawTx) ValidateBasic() error {
 	if len(r.Bytes) > rawMaxSize {
 		return errors.ErrTooLarge()
@@ -44,10 +49,6 @@ func (r RawTx) ValidateBasic() error {
 	return nil
 }
 
-func NewRawTx(d []byte) basecoin.Tx {
-	return RawTx{data.Bytes(d)}.Wrap()
-}
-
 // OKHandler just used to return okay to everything
 type OKHandler struct {
 	Log string
@@ -56,7 +57,8 @@ type OKHandler struct {
 
 var _ basecoin.Handler = OKHandler{}
 
-func (_ OKHandler) Name() string {
+// Name - return handler's name
+func (OKHandler) Name() string {
 	return NameOK
 }
 
@@ -77,18 +79,19 @@ type EchoHandler struct {
 
 var _ basecoin.Handler = EchoHandler{}
 
-func (_ EchoHandler) Name() string {
+// Name - return handler's name
+func (EchoHandler) Name() string {
 	return NameEcho
 }
 
 // CheckTx always returns an empty success tx
-func (_ EchoHandler) CheckTx(ctx basecoin.Context, store state.KVStore, tx basecoin.Tx) (res basecoin.Result, err error) {
+func (EchoHandler) CheckTx(ctx basecoin.Context, store state.KVStore, tx basecoin.Tx) (res basecoin.Result, err error) {
 	data, err := data.ToWire(tx)
 	return basecoin.Result{Data: data}, err
 }
 
 // DeliverTx always returns an empty success tx
-func (_ EchoHandler) DeliverTx(ctx basecoin.Context, store state.KVStore, tx basecoin.Tx) (res basecoin.Result, err error) {
+func (EchoHandler) DeliverTx(ctx basecoin.Context, store state.KVStore, tx basecoin.Tx) (res basecoin.Result, err error) {
 	data, err := data.ToWire(tx)
 	return basecoin.Result{Data: data}, err
 }
@@ -101,7 +104,8 @@ type FailHandler struct {
 
 var _ basecoin.Handler = FailHandler{}
 
-func (_ FailHandler) Name() string {
+// Name - return handler's name
+func (FailHandler) Name() string {
 	return NameFail
 }
 
@@ -124,7 +128,8 @@ type PanicHandler struct {
 
 var _ basecoin.Handler = PanicHandler{}
 
-func (_ PanicHandler) Name() string {
+// Name - return handler's name
+func (PanicHandler) Name() string {
 	return NamePanic
 }
 
diff --git a/stack/helperware.go b/stack/helperware.go
index 162b8e888d..adca481c6d 100644
--- a/stack/helperware.go
+++ b/stack/helperware.go
@@ -1,3 +1,4 @@
+//nolint
 package stack
 
 import (
diff --git a/stack/interface.go b/stack/interface.go
index 9d91f9a595..10c818c318 100644
--- a/stack/interface.go
+++ b/stack/interface.go
@@ -1,3 +1,4 @@
+//nolint
 package stack
 
 import (
@@ -19,57 +20,70 @@ type Middleware interface {
 }
 
 type CheckerMiddle interface {
-	CheckTx(ctx basecoin.Context, store state.KVStore, tx basecoin.Tx, next basecoin.Checker) (basecoin.Result, error)
+	CheckTx(ctx basecoin.Context, store state.KVStore,
+		tx basecoin.Tx, next basecoin.Checker) (basecoin.Result, error)
 }
 
-type CheckerMiddleFunc func(basecoin.Context, state.KVStore, basecoin.Tx, basecoin.Checker) (basecoin.Result, error)
+type CheckerMiddleFunc func(basecoin.Context, state.KVStore,
+	basecoin.Tx, basecoin.Checker) (basecoin.Result, error)
 
-func (c CheckerMiddleFunc) CheckTx(ctx basecoin.Context, store state.KVStore, tx basecoin.Tx, next basecoin.Checker) (basecoin.Result, error) {
+func (c CheckerMiddleFunc) CheckTx(ctx basecoin.Context, store state.KVStore,
+	tx basecoin.Tx, next basecoin.Checker) (basecoin.Result, error) {
 	return c(ctx, store, tx, next)
 }
 
 type DeliverMiddle interface {
-	DeliverTx(ctx basecoin.Context, store state.KVStore, tx basecoin.Tx, next basecoin.Deliver) (basecoin.Result, error)
+	DeliverTx(ctx basecoin.Context, store state.KVStore, tx basecoin.Tx,
+		next basecoin.Deliver) (basecoin.Result, error)
 }
 
-type DeliverMiddleFunc func(basecoin.Context, state.KVStore, basecoin.Tx, basecoin.Deliver) (basecoin.Result, error)
+type DeliverMiddleFunc func(basecoin.Context, state.KVStore,
+	basecoin.Tx, basecoin.Deliver) (basecoin.Result, error)
 
-func (d DeliverMiddleFunc) DeliverTx(ctx basecoin.Context, store state.KVStore, tx basecoin.Tx, next basecoin.Deliver) (basecoin.Result, error) {
+func (d DeliverMiddleFunc) DeliverTx(ctx basecoin.Context, store state.KVStore,
+	tx basecoin.Tx, next basecoin.Deliver) (basecoin.Result, error) {
 	return d(ctx, store, tx, next)
 }
 
 type SetOptionMiddle interface {
-	SetOption(l log.Logger, store state.KVStore, module, key, value string, next basecoin.SetOptioner) (string, error)
+	SetOption(l log.Logger, store state.KVStore, module,
+		key, value string, next basecoin.SetOptioner) (string, error)
 }
 
-type SetOptionMiddleFunc func(log.Logger, state.KVStore, string, string, string, basecoin.SetOptioner) (string, error)
+type SetOptionMiddleFunc func(log.Logger, state.KVStore,
+	string, string, string, basecoin.SetOptioner) (string, error)
 
-func (c SetOptionMiddleFunc) SetOption(l log.Logger, store state.KVStore, module, key, value string, next basecoin.SetOptioner) (string, error) {
+func (c SetOptionMiddleFunc) SetOption(l log.Logger, store state.KVStore,
+	module, key, value string, next basecoin.SetOptioner) (string, error) {
 	return c(l, store, module, key, value, next)
 }
 
 // holders
 type PassCheck struct{}
 
-func (_ PassCheck) CheckTx(ctx basecoin.Context, store state.KVStore, tx basecoin.Tx, next basecoin.Checker) (basecoin.Result, error) {
+func (_ PassCheck) CheckTx(ctx basecoin.Context, store state.KVStore,
+	tx basecoin.Tx, next basecoin.Checker) (basecoin.Result, error) {
 	return next.CheckTx(ctx, store, tx)
 }
 
 type PassDeliver struct{}
 
-func (_ PassDeliver) DeliverTx(ctx basecoin.Context, store state.KVStore, tx basecoin.Tx, next basecoin.Deliver) (basecoin.Result, error) {
+func (_ PassDeliver) DeliverTx(ctx basecoin.Context, store state.KVStore,
+	tx basecoin.Tx, next basecoin.Deliver) (basecoin.Result, error) {
 	return next.DeliverTx(ctx, store, tx)
 }
 
 type PassOption struct{}
 
-func (_ PassOption) SetOption(l log.Logger, store state.KVStore, module, key, value string, next basecoin.SetOptioner) (string, error) {
+func (_ PassOption) SetOption(l log.Logger, store state.KVStore, module,
+	key, value string, next basecoin.SetOptioner) (string, error) {
 	return next.SetOption(l, store, module, key, value)
 }
 
 type NopOption struct{}
 
-func (_ NopOption) SetOption(l log.Logger, store state.KVStore, module, key, value string, next basecoin.SetOptioner) (string, error) {
+func (_ NopOption) SetOption(l log.Logger, store state.KVStore, module,
+	key, value string, next basecoin.SetOptioner) (string, error) {
 	return "", nil
 }
 
@@ -98,14 +112,17 @@ func (w wrapped) Name() string {
 	return w.h.Name()
 }
 
-func (w wrapped) CheckTx(ctx basecoin.Context, store state.KVStore, tx basecoin.Tx, _ basecoin.Checker) (basecoin.Result, error) {
+func (w wrapped) CheckTx(ctx basecoin.Context, store state.KVStore,
+	tx basecoin.Tx, _ basecoin.Checker) (basecoin.Result, error) {
 	return w.h.CheckTx(ctx, store, tx)
 }
 
-func (w wrapped) DeliverTx(ctx basecoin.Context, store state.KVStore, tx basecoin.Tx, _ basecoin.Deliver) (basecoin.Result, error) {
+func (w wrapped) DeliverTx(ctx basecoin.Context, store state.KVStore,
+	tx basecoin.Tx, _ basecoin.Deliver) (basecoin.Result, error) {
 	return w.h.DeliverTx(ctx, store, tx)
 }
 
-func (w wrapped) SetOption(l log.Logger, store state.KVStore, module, key, value string, _ basecoin.SetOptioner) (string, error) {
+func (w wrapped) SetOption(l log.Logger, store state.KVStore,
+	module, key, value string, _ basecoin.SetOptioner) (string, error) {
 	return w.h.SetOption(l, store, module, key, value)
 }