diff --git a/CHANGELOG.md b/CHANGELOG.md
index aaa6a51f3..30ee8f618 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1937,7 +1937,7 @@ See [UPGRADING.md](UPGRADING.md) for more details.
 
 - [build] [\#3085](https://github.com/tendermint/tendermint/issues/3085) Fix `Version` field in build scripts (@husio)
 - [crypto/multisig] [\#3102](https://github.com/tendermint/tendermint/issues/3102) Fix multisig keys address length
-- [crypto/encoding] [\#3101](https://github.com/tendermint/tendermint/issues/3101) Fix `PubKeyMultisigThreshold` unmarshalling into `crypto.PubKey` interface
+- [crypto/encoding] [\#3101](https://github.com/tendermint/tendermint/issues/3101) Fix `PubKeyMultisigThreshold` unmarshaling into `crypto.PubKey` interface
 - [p2p/conn] [\#3111](https://github.com/tendermint/tendermint/issues/3111) Make SecretConnection thread safe
 - [rpc] [\#3053](https://github.com/tendermint/tendermint/issues/3053) Fix internal error in `/tx_search` when results are empty
   (@gianfelipe93)
@@ -2388,7 +2388,7 @@ FEATURES:
 - [libs] [\#2286](https://github.com/tendermint/tendermint/issues/2286) Panic if `autofile` or `db/fsdb` permissions change from 0600.
 
 IMPROVEMENTS:
-- [libs/db] [\#2371](https://github.com/tendermint/tendermint/issues/2371) Output error instead of panic when the given `db_backend` is not initialised (@bradyjoestar)
+- [libs/db] [\#2371](https://github.com/tendermint/tendermint/issues/2371) Output error instead of panic when the given `db_backend` is not initialized (@bradyjoestar)
 - [mempool] [\#2399](https://github.com/tendermint/tendermint/issues/2399) Make mempool cache a proper LRU (@bradyjoestar)
 - [p2p] [\#2126](https://github.com/tendermint/tendermint/issues/2126) Introduce PeerTransport interface to improve isolation of concerns
 - [libs/common] [\#2326](https://github.com/tendermint/tendermint/issues/2326) Service returns ErrNotStarted
diff --git a/UPGRADING.md b/UPGRADING.md
index 318928fe4..aa34d37d6 100644
--- a/UPGRADING.md
+++ b/UPGRADING.md
@@ -470,7 +470,7 @@ In this case, the WS client will receive an error with description:
   "error": {
     "code": -32000,
     "msg": "Server error",
-    "data": "subscription was cancelled (reason: client is not pulling messages fast enough)" // or "subscription was cancelled (reason: Tendermint exited)"
+    "data": "subscription was canceled (reason: client is not pulling messages fast enough)" // or "subscription was canceled (reason: Tendermint exited)"
   }
 }
 
diff --git a/abci/types/result.go b/abci/types/result.go
index 1442ea39c..dba6bfd15 100644
--- a/abci/types/result.go
+++ b/abci/types/result.go
@@ -42,7 +42,7 @@ func (r ResponseQuery) IsErr() bool {
 }
 
 //---------------------------------------------------------------------------
-// override JSON marshalling so we emit defaults (ie. disable omitempty)
+// override JSON marshaling so we emit defaults (ie. disable omitempty)
 
 var (
 	jsonpbMarshaller = jsonpb.Marshaler{
diff --git a/behaviour/doc.go b/behavior/doc.go
similarity index 77%
rename from behaviour/doc.go
rename to behavior/doc.go
index 40061e095..c4bd06cce 100644
--- a/behaviour/doc.go
+++ b/behavior/doc.go
@@ -1,10 +1,10 @@
 /*
-Package Behaviour provides a mechanism for reactors to report behaviour of peers.
+Package Behavior provides a mechanism for reactors to report behavior of peers.
 
-Instead of a reactor calling the switch directly it will call the behaviour module which will
+Instead of a reactor calling the switch directly it will call the behavior module which will
 handle the stoping and marking peer as good on behalf of the reactor.
 
-There are four different behaviours a reactor can report.
+There are four different behaviors a reactor can report.
 
 1. bad message
 
@@ -39,4 +39,4 @@ type blockPart struct {
 This message will request the peer be marked as good
 
 */
-package behaviour
+package behavior
diff --git a/behavior/peer_behaviour.go b/behavior/peer_behaviour.go
new file mode 100644
index 000000000..9021e491c
--- /dev/null
+++ b/behavior/peer_behaviour.go
@@ -0,0 +1,49 @@
+package behavior
+
+import (
+	"github.com/tendermint/tendermint/p2p"
+)
+
+// PeerBehavior is a struct describing a behavior a peer performed.
+// `peerID` identifies the peer and reason characterizes the specific
+// behavior performed by the peer.
+type PeerBehavior struct {
+	peerID p2p.NodeID
+	reason interface{}
+}
+
+type badMessage struct {
+	explanation string
+}
+
+// BadMessage returns a badMessage PeerBehavior.
+func BadMessage(peerID p2p.NodeID, explanation string) PeerBehavior {
+	return PeerBehavior{peerID: peerID, reason: badMessage{explanation}}
+}
+
+type messageOutOfOrder struct {
+	explanation string
+}
+
+// MessageOutOfOrder returns a messagOutOfOrder PeerBehavior.
+func MessageOutOfOrder(peerID p2p.NodeID, explanation string) PeerBehavior {
+	return PeerBehavior{peerID: peerID, reason: messageOutOfOrder{explanation}}
+}
+
+type consensusVote struct {
+	explanation string
+}
+
+// ConsensusVote returns a consensusVote PeerBehavior.
+func ConsensusVote(peerID p2p.NodeID, explanation string) PeerBehavior {
+	return PeerBehavior{peerID: peerID, reason: consensusVote{explanation}}
+}
+
+type blockPart struct {
+	explanation string
+}
+
+// BlockPart returns blockPart PeerBehavior.
+func BlockPart(peerID p2p.NodeID, explanation string) PeerBehavior {
+	return PeerBehavior{peerID: peerID, reason: blockPart{explanation}}
+}
diff --git a/behaviour/reporter.go b/behavior/reporter.go
similarity index 58%
rename from behaviour/reporter.go
rename to behavior/reporter.go
index a6fbf7d20..aba61f596 100644
--- a/behaviour/reporter.go
+++ b/behavior/reporter.go
@@ -1,4 +1,4 @@
-package behaviour
+package behavior
 
 import (
 	"errors"
@@ -7,13 +7,13 @@ import (
 	"github.com/tendermint/tendermint/p2p"
 )
 
-// Reporter provides an interface for reactors to report the behaviour
+// Reporter provides an interface for reactors to report the behavior
 // of peers synchronously to other components.
 type Reporter interface {
-	Report(behaviour PeerBehaviour) error
+	Report(behavior PeerBehavior) error
 }
 
-// SwitchReporter reports peer behaviour to an internal Switch.
+// SwitchReporter reports peer behavior to an internal Switch.
 type SwitchReporter struct {
 	sw *p2p.Switch
 }
@@ -25,14 +25,14 @@ func NewSwitchReporter(sw *p2p.Switch) *SwitchReporter {
 	}
 }
 
-// Report reports the behaviour of a peer to the Switch.
-func (spbr *SwitchReporter) Report(behaviour PeerBehaviour) error {
-	peer := spbr.sw.Peers().Get(behaviour.peerID)
+// Report reports the behavior of a peer to the Switch.
+func (spbr *SwitchReporter) Report(behavior PeerBehavior) error {
+	peer := spbr.sw.Peers().Get(behavior.peerID)
 	if peer == nil {
 		return errors.New("peer not found")
 	}
 
-	switch reason := behaviour.reason.(type) {
+	switch reason := behavior.reason.(type) {
 	case consensusVote, blockPart:
 		spbr.sw.MarkPeerAsGood(peer)
 	case badMessage:
@@ -48,39 +48,39 @@ func (spbr *SwitchReporter) Report(behaviour PeerBehaviour) error {
 
 // MockReporter is a concrete implementation of the Reporter
 // interface used in reactor tests to ensure reactors report the correct
-// behaviour in manufactured scenarios.
+// behavior in manufactured scenarios.
 type MockReporter struct {
 	mtx tmsync.RWMutex
-	pb  map[p2p.NodeID][]PeerBehaviour
+	pb  map[p2p.NodeID][]PeerBehavior
 }
 
 // NewMockReporter returns a Reporter which records all reported
-// behaviours in memory.
+// behaviors in memory.
 func NewMockReporter() *MockReporter {
 	return &MockReporter{
-		pb: map[p2p.NodeID][]PeerBehaviour{},
+		pb: map[p2p.NodeID][]PeerBehavior{},
 	}
 }
 
-// Report stores the PeerBehaviour produced by the peer identified by peerID.
-func (mpbr *MockReporter) Report(behaviour PeerBehaviour) error {
+// Report stores the PeerBehavior produced by the peer identified by peerID.
+func (mpbr *MockReporter) Report(behavior PeerBehavior) error {
 	mpbr.mtx.Lock()
 	defer mpbr.mtx.Unlock()
-	mpbr.pb[behaviour.peerID] = append(mpbr.pb[behaviour.peerID], behaviour)
+	mpbr.pb[behavior.peerID] = append(mpbr.pb[behavior.peerID], behavior)
 
 	return nil
 }
 
-// GetBehaviours returns all behaviours reported on the peer identified by peerID.
-func (mpbr *MockReporter) GetBehaviours(peerID p2p.NodeID) []PeerBehaviour {
+// GetBehaviors returns all behaviors reported on the peer identified by peerID.
+func (mpbr *MockReporter) GetBehaviors(peerID p2p.NodeID) []PeerBehavior {
 	mpbr.mtx.RLock()
 	defer mpbr.mtx.RUnlock()
 	if items, ok := mpbr.pb[peerID]; ok {
-		result := make([]PeerBehaviour, len(items))
+		result := make([]PeerBehavior, len(items))
 		copy(result, items)
 
 		return result
 	}
 
-	return []PeerBehaviour{}
+	return []PeerBehavior{}
 }
diff --git a/behavior/reporter_test.go b/behavior/reporter_test.go
new file mode 100644
index 000000000..b85410f86
--- /dev/null
+++ b/behavior/reporter_test.go
@@ -0,0 +1,205 @@
+package behavior_test
+
+import (
+	"sync"
+	"testing"
+
+	bh "github.com/tendermint/tendermint/behavior"
+	"github.com/tendermint/tendermint/p2p"
+)
+
+// TestMockReporter tests the MockReporter's ability to store reported
+// peer behavior in memory indexed by the peerID.
+func TestMockReporter(t *testing.T) {
+	var peerID p2p.NodeID = "MockPeer"
+	pr := bh.NewMockReporter()
+
+	behaviors := pr.GetBehaviors(peerID)
+	if len(behaviors) != 0 {
+		t.Error("Expected to have no behaviors reported")
+	}
+
+	badMessage := bh.BadMessage(peerID, "bad message")
+	if err := pr.Report(badMessage); err != nil {
+		t.Error(err)
+	}
+	behaviors = pr.GetBehaviors(peerID)
+	if len(behaviors) != 1 {
+		t.Error("Expected the peer have one reported behavior")
+	}
+
+	if behaviors[0] != badMessage {
+		t.Error("Expected Bad Message to have been reported")
+	}
+}
+
+type scriptItem struct {
+	peerID   p2p.NodeID
+	behavior bh.PeerBehavior
+}
+
+// equalBehaviors returns true if a and b contain the same PeerBehaviors with
+// the same freequencies and otherwise false.
+func equalBehaviors(a []bh.PeerBehavior, b []bh.PeerBehavior) bool {
+	aHistogram := map[bh.PeerBehavior]int{}
+	bHistogram := map[bh.PeerBehavior]int{}
+
+	for _, behavior := range a {
+		aHistogram[behavior]++
+	}
+
+	for _, behavior := range b {
+		bHistogram[behavior]++
+	}
+
+	if len(aHistogram) != len(bHistogram) {
+		return false
+	}
+
+	for _, behavior := range a {
+		if aHistogram[behavior] != bHistogram[behavior] {
+			return false
+		}
+	}
+
+	for _, behavior := range b {
+		if bHistogram[behavior] != aHistogram[behavior] {
+			return false
+		}
+	}
+
+	return true
+}
+
+// TestEqualPeerBehaviors tests that equalBehaviors can tell that two slices
+// of peer behaviors can be compared for the behaviors they contain and the
+// freequencies that those behaviors occur.
+func TestEqualPeerBehaviors(t *testing.T) {
+	var (
+		peerID        p2p.NodeID = "MockPeer"
+		consensusVote            = bh.ConsensusVote(peerID, "voted")
+		blockPart                = bh.BlockPart(peerID, "blocked")
+		equals                   = []struct {
+			left  []bh.PeerBehavior
+			right []bh.PeerBehavior
+		}{
+			// Empty sets
+			{[]bh.PeerBehavior{}, []bh.PeerBehavior{}},
+			// Single behaviors
+			{[]bh.PeerBehavior{consensusVote}, []bh.PeerBehavior{consensusVote}},
+			// Equal Frequencies
+			{[]bh.PeerBehavior{consensusVote, consensusVote},
+				[]bh.PeerBehavior{consensusVote, consensusVote}},
+			// Equal frequencies different orders
+			{[]bh.PeerBehavior{consensusVote, blockPart},
+				[]bh.PeerBehavior{blockPart, consensusVote}},
+		}
+		unequals = []struct {
+			left  []bh.PeerBehavior
+			right []bh.PeerBehavior
+		}{
+			// Comparing empty sets to non empty sets
+			{[]bh.PeerBehavior{}, []bh.PeerBehavior{consensusVote}},
+			// Different behaviors
+			{[]bh.PeerBehavior{consensusVote}, []bh.PeerBehavior{blockPart}},
+			// Same behavior with different frequencies
+			{[]bh.PeerBehavior{consensusVote},
+				[]bh.PeerBehavior{consensusVote, consensusVote}},
+		}
+	)
+
+	for _, test := range equals {
+		if !equalBehaviors(test.left, test.right) {
+			t.Errorf("expected %#v and %#v to be equal", test.left, test.right)
+		}
+	}
+
+	for _, test := range unequals {
+		if equalBehaviors(test.left, test.right) {
+			t.Errorf("expected %#v and %#v to be unequal", test.left, test.right)
+		}
+	}
+}
+
+// TestPeerBehaviorConcurrency constructs a scenario in which
+// multiple goroutines are using the same MockReporter instance.
+// This test reproduces the conditions in which MockReporter will
+// be used within a Reactor `Receive` method tests to ensure thread safety.
+func TestMockPeerBehaviorReporterConcurrency(t *testing.T) {
+	var (
+		behaviorScript = []struct {
+			peerID    p2p.NodeID
+			behaviors []bh.PeerBehavior
+		}{
+			{"1", []bh.PeerBehavior{bh.ConsensusVote("1", "")}},
+			{"2", []bh.PeerBehavior{bh.ConsensusVote("2", ""), bh.ConsensusVote("2", ""), bh.ConsensusVote("2", "")}},
+			{
+				"3",
+				[]bh.PeerBehavior{bh.BlockPart("3", ""),
+					bh.ConsensusVote("3", ""),
+					bh.BlockPart("3", ""),
+					bh.ConsensusVote("3", "")}},
+			{
+				"4",
+				[]bh.PeerBehavior{bh.ConsensusVote("4", ""),
+					bh.ConsensusVote("4", ""),
+					bh.ConsensusVote("4", ""),
+					bh.ConsensusVote("4", "")}},
+			{
+				"5",
+				[]bh.PeerBehavior{bh.BlockPart("5", ""),
+					bh.ConsensusVote("5", ""),
+					bh.BlockPart("5", ""),
+					bh.ConsensusVote("5", "")}},
+		}
+	)
+
+	var receiveWg sync.WaitGroup
+	pr := bh.NewMockReporter()
+	scriptItems := make(chan scriptItem)
+	done := make(chan int)
+	numConsumers := 3
+	for i := 0; i < numConsumers; i++ {
+		receiveWg.Add(1)
+		go func() {
+			defer receiveWg.Done()
+			for {
+				select {
+				case pb := <-scriptItems:
+					if err := pr.Report(pb.behavior); err != nil {
+						t.Error(err)
+					}
+				case <-done:
+					return
+				}
+			}
+		}()
+	}
+
+	var sendingWg sync.WaitGroup
+	sendingWg.Add(1)
+	go func() {
+		defer sendingWg.Done()
+		for _, item := range behaviorScript {
+			for _, reason := range item.behaviors {
+				scriptItems <- scriptItem{item.peerID, reason}
+			}
+		}
+	}()
+
+	sendingWg.Wait()
+
+	for i := 0; i < numConsumers; i++ {
+		done <- 1
+	}
+
+	receiveWg.Wait()
+
+	for _, items := range behaviorScript {
+		reported := pr.GetBehaviors(items.peerID)
+		if !equalBehaviors(reported, items.behaviors) {
+			t.Errorf("expected peer %s to have behaved \nExpected: %#v \nGot %#v \n",
+				items.peerID, items.behaviors, reported)
+		}
+	}
+}
diff --git a/behaviour/peer_behaviour.go b/behaviour/peer_behaviour.go
deleted file mode 100644
index dd45a0d2f..000000000
--- a/behaviour/peer_behaviour.go
+++ /dev/null
@@ -1,49 +0,0 @@
-package behaviour
-
-import (
-	"github.com/tendermint/tendermint/p2p"
-)
-
-// PeerBehaviour is a struct describing a behaviour a peer performed.
-// `peerID` identifies the peer and reason characterizes the specific
-// behaviour performed by the peer.
-type PeerBehaviour struct {
-	peerID p2p.NodeID
-	reason interface{}
-}
-
-type badMessage struct {
-	explanation string
-}
-
-// BadMessage returns a badMessage PeerBehaviour.
-func BadMessage(peerID p2p.NodeID, explanation string) PeerBehaviour {
-	return PeerBehaviour{peerID: peerID, reason: badMessage{explanation}}
-}
-
-type messageOutOfOrder struct {
-	explanation string
-}
-
-// MessageOutOfOrder returns a messagOutOfOrder PeerBehaviour.
-func MessageOutOfOrder(peerID p2p.NodeID, explanation string) PeerBehaviour {
-	return PeerBehaviour{peerID: peerID, reason: messageOutOfOrder{explanation}}
-}
-
-type consensusVote struct {
-	explanation string
-}
-
-// ConsensusVote returns a consensusVote PeerBehaviour.
-func ConsensusVote(peerID p2p.NodeID, explanation string) PeerBehaviour {
-	return PeerBehaviour{peerID: peerID, reason: consensusVote{explanation}}
-}
-
-type blockPart struct {
-	explanation string
-}
-
-// BlockPart returns blockPart PeerBehaviour.
-func BlockPart(peerID p2p.NodeID, explanation string) PeerBehaviour {
-	return PeerBehaviour{peerID: peerID, reason: blockPart{explanation}}
-}
diff --git a/behaviour/reporter_test.go b/behaviour/reporter_test.go
deleted file mode 100644
index 2680cc233..000000000
--- a/behaviour/reporter_test.go
+++ /dev/null
@@ -1,205 +0,0 @@
-package behaviour_test
-
-import (
-	"sync"
-	"testing"
-
-	bh "github.com/tendermint/tendermint/behaviour"
-	"github.com/tendermint/tendermint/p2p"
-)
-
-// TestMockReporter tests the MockReporter's ability to store reported
-// peer behaviour in memory indexed by the peerID.
-func TestMockReporter(t *testing.T) {
-	var peerID p2p.NodeID = "MockPeer"
-	pr := bh.NewMockReporter()
-
-	behaviours := pr.GetBehaviours(peerID)
-	if len(behaviours) != 0 {
-		t.Error("Expected to have no behaviours reported")
-	}
-
-	badMessage := bh.BadMessage(peerID, "bad message")
-	if err := pr.Report(badMessage); err != nil {
-		t.Error(err)
-	}
-	behaviours = pr.GetBehaviours(peerID)
-	if len(behaviours) != 1 {
-		t.Error("Expected the peer have one reported behaviour")
-	}
-
-	if behaviours[0] != badMessage {
-		t.Error("Expected Bad Message to have been reported")
-	}
-}
-
-type scriptItem struct {
-	peerID    p2p.NodeID
-	behaviour bh.PeerBehaviour
-}
-
-// equalBehaviours returns true if a and b contain the same PeerBehaviours with
-// the same freequencies and otherwise false.
-func equalBehaviours(a []bh.PeerBehaviour, b []bh.PeerBehaviour) bool {
-	aHistogram := map[bh.PeerBehaviour]int{}
-	bHistogram := map[bh.PeerBehaviour]int{}
-
-	for _, behaviour := range a {
-		aHistogram[behaviour]++
-	}
-
-	for _, behaviour := range b {
-		bHistogram[behaviour]++
-	}
-
-	if len(aHistogram) != len(bHistogram) {
-		return false
-	}
-
-	for _, behaviour := range a {
-		if aHistogram[behaviour] != bHistogram[behaviour] {
-			return false
-		}
-	}
-
-	for _, behaviour := range b {
-		if bHistogram[behaviour] != aHistogram[behaviour] {
-			return false
-		}
-	}
-
-	return true
-}
-
-// TestEqualPeerBehaviours tests that equalBehaviours can tell that two slices
-// of peer behaviours can be compared for the behaviours they contain and the
-// freequencies that those behaviours occur.
-func TestEqualPeerBehaviours(t *testing.T) {
-	var (
-		peerID        p2p.NodeID = "MockPeer"
-		consensusVote            = bh.ConsensusVote(peerID, "voted")
-		blockPart                = bh.BlockPart(peerID, "blocked")
-		equals                   = []struct {
-			left  []bh.PeerBehaviour
-			right []bh.PeerBehaviour
-		}{
-			// Empty sets
-			{[]bh.PeerBehaviour{}, []bh.PeerBehaviour{}},
-			// Single behaviours
-			{[]bh.PeerBehaviour{consensusVote}, []bh.PeerBehaviour{consensusVote}},
-			// Equal Frequencies
-			{[]bh.PeerBehaviour{consensusVote, consensusVote},
-				[]bh.PeerBehaviour{consensusVote, consensusVote}},
-			// Equal frequencies different orders
-			{[]bh.PeerBehaviour{consensusVote, blockPart},
-				[]bh.PeerBehaviour{blockPart, consensusVote}},
-		}
-		unequals = []struct {
-			left  []bh.PeerBehaviour
-			right []bh.PeerBehaviour
-		}{
-			// Comparing empty sets to non empty sets
-			{[]bh.PeerBehaviour{}, []bh.PeerBehaviour{consensusVote}},
-			// Different behaviours
-			{[]bh.PeerBehaviour{consensusVote}, []bh.PeerBehaviour{blockPart}},
-			// Same behaviour with different frequencies
-			{[]bh.PeerBehaviour{consensusVote},
-				[]bh.PeerBehaviour{consensusVote, consensusVote}},
-		}
-	)
-
-	for _, test := range equals {
-		if !equalBehaviours(test.left, test.right) {
-			t.Errorf("expected %#v and %#v to be equal", test.left, test.right)
-		}
-	}
-
-	for _, test := range unequals {
-		if equalBehaviours(test.left, test.right) {
-			t.Errorf("expected %#v and %#v to be unequal", test.left, test.right)
-		}
-	}
-}
-
-// TestPeerBehaviourConcurrency constructs a scenario in which
-// multiple goroutines are using the same MockReporter instance.
-// This test reproduces the conditions in which MockReporter will
-// be used within a Reactor `Receive` method tests to ensure thread safety.
-func TestMockPeerBehaviourReporterConcurrency(t *testing.T) {
-	var (
-		behaviourScript = []struct {
-			peerID     p2p.NodeID
-			behaviours []bh.PeerBehaviour
-		}{
-			{"1", []bh.PeerBehaviour{bh.ConsensusVote("1", "")}},
-			{"2", []bh.PeerBehaviour{bh.ConsensusVote("2", ""), bh.ConsensusVote("2", ""), bh.ConsensusVote("2", "")}},
-			{
-				"3",
-				[]bh.PeerBehaviour{bh.BlockPart("3", ""),
-					bh.ConsensusVote("3", ""),
-					bh.BlockPart("3", ""),
-					bh.ConsensusVote("3", "")}},
-			{
-				"4",
-				[]bh.PeerBehaviour{bh.ConsensusVote("4", ""),
-					bh.ConsensusVote("4", ""),
-					bh.ConsensusVote("4", ""),
-					bh.ConsensusVote("4", "")}},
-			{
-				"5",
-				[]bh.PeerBehaviour{bh.BlockPart("5", ""),
-					bh.ConsensusVote("5", ""),
-					bh.BlockPart("5", ""),
-					bh.ConsensusVote("5", "")}},
-		}
-	)
-
-	var receiveWg sync.WaitGroup
-	pr := bh.NewMockReporter()
-	scriptItems := make(chan scriptItem)
-	done := make(chan int)
-	numConsumers := 3
-	for i := 0; i < numConsumers; i++ {
-		receiveWg.Add(1)
-		go func() {
-			defer receiveWg.Done()
-			for {
-				select {
-				case pb := <-scriptItems:
-					if err := pr.Report(pb.behaviour); err != nil {
-						t.Error(err)
-					}
-				case <-done:
-					return
-				}
-			}
-		}()
-	}
-
-	var sendingWg sync.WaitGroup
-	sendingWg.Add(1)
-	go func() {
-		defer sendingWg.Done()
-		for _, item := range behaviourScript {
-			for _, reason := range item.behaviours {
-				scriptItems <- scriptItem{item.peerID, reason}
-			}
-		}
-	}()
-
-	sendingWg.Wait()
-
-	for i := 0; i < numConsumers; i++ {
-		done <- 1
-	}
-
-	receiveWg.Wait()
-
-	for _, items := range behaviourScript {
-		reported := pr.GetBehaviours(items.peerID)
-		if !equalBehaviours(reported, items.behaviours) {
-			t.Errorf("expected peer %s to have behaved \nExpected: %#v \nGot %#v \n",
-				items.peerID, items.behaviours, reported)
-		}
-	}
-}
diff --git a/blockchain/v2/processor_test.go b/blockchain/v2/processor_test.go
index f268a0910..c2e4ef458 100644
--- a/blockchain/v2/processor_test.go
+++ b/blockchain/v2/processor_test.go
@@ -82,7 +82,7 @@ func executeProcessorTests(t *testing.T, tests []testFields) {
 					}
 				}()
 
-				// First step must always initialise the currentState as state.
+				// First step must always initialize the currentState as state.
 				if step.currentState != nil {
 					state = makeState(step.currentState)
 				}
diff --git a/blockchain/v2/reactor.go b/blockchain/v2/reactor.go
index 4b37439a3..2e04a2789 100644
--- a/blockchain/v2/reactor.go
+++ b/blockchain/v2/reactor.go
@@ -7,7 +7,7 @@ import (
 
 	proto "github.com/gogo/protobuf/proto"
 
-	"github.com/tendermint/tendermint/behaviour"
+	"github.com/tendermint/tendermint/behavior"
 	bc "github.com/tendermint/tendermint/blockchain"
 	"github.com/tendermint/tendermint/libs/log"
 	tmsync "github.com/tendermint/tendermint/libs/sync"
@@ -44,7 +44,7 @@ type BlockchainReactor struct {
 	syncHeight    int64
 	events        chan Event // non-nil during a fast sync
 
-	reporter behaviour.Reporter
+	reporter behavior.Reporter
 	io       iIO
 	store    blockStore
 }
@@ -54,7 +54,7 @@ type blockApplier interface {
 }
 
 // XXX: unify naming in this package around tmState
-func newReactor(state state.State, store blockStore, reporter behaviour.Reporter,
+func newReactor(state state.State, store blockStore, reporter behavior.Reporter,
 	blockApplier blockApplier, fastSync bool) *BlockchainReactor {
 	initHeight := state.LastBlockHeight + 1
 	if initHeight == 1 {
@@ -82,7 +82,7 @@ func NewBlockchainReactor(
 	blockApplier blockApplier,
 	store blockStore,
 	fastSync bool) *BlockchainReactor {
-	reporter := behaviour.NewMockReporter()
+	reporter := behavior.NewMockReporter()
 	return newReactor(state, store, reporter, blockApplier, fastSync)
 }
 
@@ -126,7 +126,7 @@ func (r *BlockchainReactor) SetLogger(logger log.Logger) {
 
 // Start implements cmn.Service interface
 func (r *BlockchainReactor) Start() error {
-	r.reporter = behaviour.NewSwitchReporter(r.BaseReactor.Switch)
+	r.reporter = behavior.NewSwitchReporter(r.BaseReactor.Switch)
 	if r.fastSync {
 		err := r.startSync(nil)
 		if err != nil {
@@ -136,7 +136,7 @@ func (r *BlockchainReactor) Start() error {
 	return nil
 }
 
-// startSync begins a fast sync, signalled by r.events being non-nil. If state is non-nil,
+// startSync begins a fast sync, signaled by r.events being non-nil. If state is non-nil,
 // the scheduler and processor is updated with this state on startup.
 func (r *BlockchainReactor) startSync(state *state.State) error {
 	r.mtx.Lock()
@@ -376,7 +376,7 @@ func (r *BlockchainReactor) demux(events <-chan Event) {
 				r.processor.send(event)
 			case scPeerError:
 				r.processor.send(event)
-				if err := r.reporter.Report(behaviour.BadMessage(event.peerID, "scPeerError")); err != nil {
+				if err := r.reporter.Report(behavior.BadMessage(event.peerID, "scPeerError")); err != nil {
 					r.logger.Error("Error reporting peer", "err", err)
 				}
 			case scBlockRequest:
@@ -472,13 +472,13 @@ func (r *BlockchainReactor) Receive(chID byte, src p2p.Peer, msgBytes []byte) {
 
 	if err := proto.Unmarshal(msgBytes, msgProto); err != nil {
 		logger.Error("error decoding message", "err", err)
-		_ = r.reporter.Report(behaviour.BadMessage(src.ID(), err.Error()))
+		_ = r.reporter.Report(behavior.BadMessage(src.ID(), err.Error()))
 		return
 	}
 
 	if err := msgProto.Validate(); err != nil {
 		logger.Error("peer sent us an invalid msg", "msg", msgProto, "err", err)
-		_ = r.reporter.Report(behaviour.BadMessage(src.ID(), err.Error()))
+		_ = r.reporter.Report(behavior.BadMessage(src.ID(), err.Error()))
 		return
 	}
 
@@ -518,7 +518,7 @@ func (r *BlockchainReactor) Receive(chID byte, src p2p.Peer, msgBytes []byte) {
 		bi, err := types.BlockFromProto(msg.BlockResponse.Block)
 		if err != nil {
 			logger.Error("error transitioning block from protobuf", "err", err)
-			_ = r.reporter.Report(behaviour.BadMessage(src.ID(), err.Error()))
+			_ = r.reporter.Report(behavior.BadMessage(src.ID(), err.Error()))
 			return
 		}
 		r.mtx.RLock()
diff --git a/blockchain/v2/reactor_test.go b/blockchain/v2/reactor_test.go
index 099d311a0..431eb70c1 100644
--- a/blockchain/v2/reactor_test.go
+++ b/blockchain/v2/reactor_test.go
@@ -15,7 +15,7 @@ import (
 	dbm "github.com/tendermint/tm-db"
 
 	abci "github.com/tendermint/tendermint/abci/types"
-	"github.com/tendermint/tendermint/behaviour"
+	"github.com/tendermint/tendermint/behavior"
 	cfg "github.com/tendermint/tendermint/config"
 	"github.com/tendermint/tendermint/libs/log"
 	"github.com/tendermint/tendermint/libs/service"
@@ -151,7 +151,7 @@ type testReactorParams struct {
 
 func newTestReactor(p testReactorParams) *BlockchainReactor {
 	store, state, _ := newReactorStore(p.genDoc, p.privVals, p.startHeight)
-	reporter := behaviour.NewMockReporter()
+	reporter := behavior.NewMockReporter()
 
 	var appl blockApplier
 
@@ -308,7 +308,7 @@ func newTestReactor(p testReactorParams) *BlockchainReactor {
 // 		t.Run(tt.name, func(t *testing.T) {
 // 			reactor := newTestReactor(params)
 // 			reactor.Start()
-// 			reactor.reporter = behaviour.NewMockReporter()
+// 			reactor.reporter = behavior.NewMockReporter()
 // 			mockSwitch := &mockSwitchIo{switchedToConsensus: false}
 // 			reactor.io = mockSwitch
 // 			// time for go routines to start
diff --git a/blockchain/v2/scheduler_test.go b/blockchain/v2/scheduler_test.go
index b864a5303..8bf82c8cf 100644
--- a/blockchain/v2/scheduler_test.go
+++ b/blockchain/v2/scheduler_test.go
@@ -2230,7 +2230,7 @@ func TestScHandle(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			var sc *scheduler
 			for i, step := range tt.steps {
-				// First step must always initialise the currentState as state.
+				// First step must always initialize the currentState as state.
 				if step.currentSc != nil {
 					sc = newTestScheduler(*step.currentSc)
 				}
diff --git a/cmd/tendermint/commands/init.go b/cmd/tendermint/commands/init.go
index 19b8da89b..389f627d4 100644
--- a/cmd/tendermint/commands/init.go
+++ b/cmd/tendermint/commands/init.go
@@ -14,7 +14,7 @@ import (
 	tmtime "github.com/tendermint/tendermint/types/time"
 )
 
-// InitFilesCmd initialises a fresh Tendermint Core instance.
+// InitFilesCmd initializes a fresh Tendermint Core instance.
 var InitFilesCmd = &cobra.Command{
 	Use:   "init",
 	Short: "Initialize Tendermint",
diff --git a/cmd/tendermint/commands/light.go b/cmd/tendermint/commands/light.go
index 80d8f0750..b9e3741c5 100644
--- a/cmd/tendermint/commands/light.go
+++ b/cmd/tendermint/commands/light.go
@@ -104,7 +104,7 @@ func init() {
 }
 
 func runProxy(cmd *cobra.Command, args []string) error {
-	// Initialise logger.
+	// Initialize logger.
 	logger := log.NewTMLogger(log.NewSyncWriter(os.Stdout))
 	var option log.Option
 	if verbose {
diff --git a/consensus/replay.go b/consensus/replay.go
index 67ba557e6..06f66ba5d 100644
--- a/consensus/replay.go
+++ b/consensus/replay.go
@@ -55,8 +55,8 @@ func (cs *State) readReplayMessage(msg *TimedWALMessage, newStepSub types.Subscr
 				if m.Height != m2.Height || m.Round != m2.Round || m.Step != m2.Step {
 					return fmt.Errorf("roundState mismatch. Got %v; Expected %v", m2, m)
 				}
-			case <-newStepSub.Cancelled():
-				return fmt.Errorf("failed to read off newStepSub.Out(). newStepSub was cancelled")
+			case <-newStepSub.Canceled():
+				return fmt.Errorf("failed to read off newStepSub.Out(). newStepSub was canceled")
 			case <-ticker:
 				return fmt.Errorf("failed to read off newStepSub.Out()")
 			}
diff --git a/consensus/replay_test.go b/consensus/replay_test.go
index 90ee084ca..778f74b31 100644
--- a/consensus/replay_test.go
+++ b/consensus/replay_test.go
@@ -97,8 +97,8 @@ func startNewStateAndWaitForBlock(t *testing.T, consensusReplayConfig *cfg.Confi
 	require.NoError(t, err)
 	select {
 	case <-newBlockSub.Out():
-	case <-newBlockSub.Cancelled():
-		t.Fatal("newBlockSub was cancelled")
+	case <-newBlockSub.Canceled():
+		t.Fatal("newBlockSub was canceled")
 	case <-time.After(120 * time.Second):
 		t.Fatal("Timed out waiting for new block (see trace above)")
 	}
diff --git a/consensus/state.go b/consensus/state.go
index 6476693ff..385214489 100644
--- a/consensus/state.go
+++ b/consensus/state.go
@@ -1934,7 +1934,7 @@ func (cs *State) addVote(
 	}
 
 	// Height mismatch is ignored.
-	// Not necessarily a bad peer, but not favourable behaviour.
+	// Not necessarily a bad peer, but not favorable behavior.
 	if vote.Height != cs.Height {
 		cs.Logger.Debug("vote ignored and not added", "voteHeight", vote.Height, "csHeight", cs.Height, "peerID", peerID)
 		return
diff --git a/crypto/secp256k1/secp256k1.go b/crypto/secp256k1/secp256k1.go
index 26926a966..fa387e355 100644
--- a/crypto/secp256k1/secp256k1.go
+++ b/crypto/secp256k1/secp256k1.go
@@ -152,7 +152,7 @@ func (pubKey PubKey) Address() crypto.Address {
 	return crypto.Address(hasherRIPEMD160.Sum(nil))
 }
 
-// Bytes returns the pubkey marshalled with amino encoding.
+// Bytes returns the pubkey marshaled with amino encoding.
 func (pubKey PubKey) Bytes() []byte {
 	return []byte(pubKey)
 }
diff --git a/crypto/xchacha20poly1305/xchachapoly_test.go b/crypto/xchacha20poly1305/xchachapoly_test.go
index d5e4b6003..b17b1c376 100644
--- a/crypto/xchacha20poly1305/xchachapoly_test.go
+++ b/crypto/xchacha20poly1305/xchachapoly_test.go
@@ -83,7 +83,7 @@ func TestRandom(t *testing.T) {
 	}
 }
 
-// AFOREMENTIONED LICENCE
+// AFOREMENTIONED LICENSE
 // Copyright (c) 2009 The Go Authors. All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
diff --git a/docs/architecture/adr-020-block-size.md b/docs/architecture/adr-020-block-size.md
index 39385789d..71b68a90e 100644
--- a/docs/architecture/adr-020-block-size.md
+++ b/docs/architecture/adr-020-block-size.md
@@ -12,7 +12,7 @@
 ## Context
 
 We currently use MaxTxs to reap txs from the mempool when proposing a block,
-but enforce MaxBytes when unmarshalling a block, so we could easily propose a
+but enforce MaxBytes when unmarshaling a block, so we could easily propose a
 block thats too large to be valid.
 
 We should just remove MaxTxs all together and stick with MaxBytes, and have a
@@ -33,7 +33,7 @@ MaxBytes provides a clear limit on the total size of a block that requires no
 additional calculation if you want to use it to bound resource usage, and there
 has been considerable discussions about optimizing tendermint around 1MB blocks.
 Regardless, we need some maximum on the size of a block so we can avoid
-unmarshalling blocks that are too big during the consensus, and it seems more
+unmarshaling blocks that are too big during the consensus, and it seems more
 straightforward to provide a single fixed number for this rather than a
 computation of "MaxDataBytes + everything else you need to make room for
 (signatures, evidence, header)". MaxBytes provides a simple bound so we can
diff --git a/docs/architecture/adr-033-pubsub.md b/docs/architecture/adr-033-pubsub.md
index 88922646f..3823da756 100644
--- a/docs/architecture/adr-033-pubsub.md
+++ b/docs/architecture/adr-033-pubsub.md
@@ -121,7 +121,7 @@ type Subscription struct {
 }
 
 func (s *Subscription) Out() <-chan MsgAndTags
-func (s *Subscription) Cancelled() <-chan struct{}
+func (s *Subscription) Canceled() <-chan struct{}
 func (s *Subscription) Err() error
 ```
 
@@ -129,10 +129,10 @@ func (s *Subscription) Err() error
 `Unsubscribe`/`UnsubscribeAll` does not close the channel to avoid clients from
 receiving a nil message.
 
-`Cancelled()` returns a channel that's closed when the subscription is terminated
+`Canceled()` returns a channel that's closed when the subscription is terminated
 and supposed to be used in a select statement.
 
-If the channel returned by `Cancelled()` is not closed yet, `Err()` returns nil.
+If the channel returned by `Canceled()` is not closed yet, `Err()` returns nil.
 If the channel is closed, `Err()` returns a non-nil error explaining why:
 `ErrUnsubscribed` if the subscriber choose to unsubscribe,
 `ErrOutOfCapacity` if the subscriber is not pulling messages fast enough and the channel returned by `Out()` became full.
@@ -147,7 +147,7 @@ for {
 select {
   case msgAndTags <- subscription.Out():
     // ...
-  case <-subscription.Cancelled():
+  case <-subscription.Canceled():
     return subscription.Err()
 }
 ```
@@ -232,7 +232,7 @@ In review
 
 - more idiomatic interface
 - subscribers know what tags msg was published with
-- subscribers aware of the reason their subscription was cancelled
+- subscribers aware of the reason their subscription was canceled
 
 ### Negative
 
diff --git a/docs/architecture/adr-062-p2p-architecture.md b/docs/architecture/adr-062-p2p-architecture.md
index dafdaf103..bf8e0f01d 100644
--- a/docs/architecture/adr-062-p2p-architecture.md
+++ b/docs/architecture/adr-062-p2p-architecture.md
@@ -314,7 +314,7 @@ type Channel struct {
     In          <-chan Envelope  // Inbound messages (peers to reactors).
     Out         chan<- Envelope  // outbound messages (reactors to peers)
     Error       chan<- PeerError // Peer error reporting.
-    messageType proto.Message    // Channel's message type, for e.g. unmarshalling.
+    messageType proto.Message    // Channel's message type, for e.g. unmarshaling.
 }
 
 // Close closes the channel, also closing Out and Error.
@@ -529,7 +529,7 @@ func RunEchoReactor(router *p2p.Router, peerManager *p2p.PeerManager) error {
 }
 
 // EchoReactor provides an echo service, pinging all known peers until the given
-// context is cancelled.
+// context is canceled.
 func EchoReactor(ctx context.Context, channel *p2p.Channel, peerUpdates *p2p.PeerUpdates) error {
     ticker := time.NewTicker(5 * time.Second)
     defer ticker.Stop()
@@ -567,7 +567,7 @@ func EchoReactor(ctx context.Context, channel *p2p.Channel, peerUpdates *p2p.Pee
         case peerUpdate := <-peerUpdates:
             fmt.Printf("Peer %q changed status to %q", peerUpdate.PeerID, peerUpdate.Status)
 
-        // Exit when context is cancelled.
+        // Exit when context is canceled.
         case <-ctx.Done():
             return nil
         }
diff --git a/libs/bytes/bytes.go b/libs/bytes/bytes.go
index d154f7b71..cfb7a8db2 100644
--- a/libs/bytes/bytes.go
+++ b/libs/bytes/bytes.go
@@ -58,7 +58,7 @@ func (bz *HexBytes) UnmarshalJSON(data []byte) error {
 	return nil
 }
 
-// Bytes fulfils various interfaces in light-client, etc...
+// Bytes fulfills various interfaces in light-client, etc...
 func (bz HexBytes) Bytes() []byte {
 	return bz
 }
diff --git a/libs/events/event_cache_test.go b/libs/events/event_cache_test.go
index 342fe8c65..d6199bc80 100644
--- a/libs/events/event_cache_test.go
+++ b/libs/events/event_cache_test.go
@@ -13,7 +13,7 @@ func TestEventCache_Flush(t *testing.T) {
 	require.NoError(t, err)
 
 	err = evsw.AddListenerForEvent("nothingness", "", func(data EventData) {
-		// Check we are not initialising an empty buffer full of zeroed eventInfos in the EventCache
+		// Check we are not initializing an empty buffer full of zeroed eventInfos in the EventCache
 		require.FailNow(t, "We should never receive a message on this switch since none are fired")
 	})
 	require.NoError(t, err)
diff --git a/libs/pubsub/pubsub.go b/libs/pubsub/pubsub.go
index f48ee5b86..b5ec56217 100644
--- a/libs/pubsub/pubsub.go
+++ b/libs/pubsub/pubsub.go
@@ -27,7 +27,7 @@
 //         select {
 //         case msg <- subscription.Out():
 //             // handle msg.Data() and msg.Events()
-//         case <-subscription.Cancelled():
+//         case <-subscription.Canceled():
 //             return subscription.Err()
 //         }
 //     }
diff --git a/libs/pubsub/pubsub_test.go b/libs/pubsub/pubsub_test.go
index 8482a13fa..3d5fb21e2 100644
--- a/libs/pubsub/pubsub_test.go
+++ b/libs/pubsub/pubsub_test.go
@@ -59,7 +59,7 @@ func TestSubscribe(t *testing.T) {
 	select {
 	case <-published:
 		assertReceive(t, "Quicksilver", subscription.Out())
-		assertCancelled(t, subscription, pubsub.ErrOutOfCapacity)
+		assertCanceled(t, subscription, pubsub.ErrOutOfCapacity)
 	case <-time.After(3 * time.Second):
 		t.Fatal("Expected Publish(Asylum) not to block")
 	}
@@ -146,7 +146,7 @@ func TestSlowClientIsRemovedWithErrOutOfCapacity(t *testing.T) {
 	err = s.Publish(ctx, "Viper")
 	require.NoError(t, err)
 
-	assertCancelled(t, subscription, pubsub.ErrOutOfCapacity)
+	assertCanceled(t, subscription, pubsub.ErrOutOfCapacity)
 }
 
 func TestDifferentClients(t *testing.T) {
@@ -298,7 +298,7 @@ func TestUnsubscribe(t *testing.T) {
 	require.NoError(t, err)
 	assert.Zero(t, len(subscription.Out()), "Should not receive anything after Unsubscribe")
 
-	assertCancelled(t, subscription, pubsub.ErrUnsubscribed)
+	assertCanceled(t, subscription, pubsub.ErrUnsubscribed)
 }
 
 func TestClientUnsubscribesTwice(t *testing.T) {
@@ -373,8 +373,8 @@ func TestUnsubscribeAll(t *testing.T) {
 	assert.Zero(t, len(subscription1.Out()), "Should not receive anything after UnsubscribeAll")
 	assert.Zero(t, len(subscription2.Out()), "Should not receive anything after UnsubscribeAll")
 
-	assertCancelled(t, subscription1, pubsub.ErrUnsubscribed)
-	assertCancelled(t, subscription2, pubsub.ErrUnsubscribed)
+	assertCanceled(t, subscription1, pubsub.ErrUnsubscribed)
+	assertCanceled(t, subscription2, pubsub.ErrUnsubscribed)
 }
 
 func TestBufferCapacity(t *testing.T) {
@@ -431,7 +431,7 @@ func benchmarkNClients(n int, b *testing.B) {
 				select {
 				case <-subscription.Out():
 					continue
-				case <-subscription.Cancelled():
+				case <-subscription.Canceled():
 					return
 				}
 			}
@@ -472,7 +472,7 @@ func benchmarkNClientsOneQuery(n int, b *testing.B) {
 				select {
 				case <-subscription.Out():
 					continue
-				case <-subscription.Cancelled():
+				case <-subscription.Canceled():
 					return
 				}
 			}
@@ -500,8 +500,8 @@ func assertReceive(t *testing.T, expected interface{}, ch <-chan pubsub.Message,
 	}
 }
 
-func assertCancelled(t *testing.T, subscription *pubsub.Subscription, err error) {
-	_, ok := <-subscription.Cancelled()
+func assertCanceled(t *testing.T, subscription *pubsub.Subscription, err error) {
+	_, ok := <-subscription.Canceled()
 	assert.False(t, ok)
 	assert.Equal(t, err, subscription.Err())
 }
diff --git a/libs/pubsub/subscription.go b/libs/pubsub/subscription.go
index 4d6f605c7..f9c80e373 100644
--- a/libs/pubsub/subscription.go
+++ b/libs/pubsub/subscription.go
@@ -23,16 +23,16 @@ var (
 type Subscription struct {
 	out chan Message
 
-	cancelled chan struct{}
-	mtx       tmsync.RWMutex
-	err       error
+	canceled chan struct{}
+	mtx      tmsync.RWMutex
+	err      error
 }
 
 // NewSubscription returns a new subscription with the given outCapacity.
 func NewSubscription(outCapacity int) *Subscription {
 	return &Subscription{
-		out:       make(chan Message, outCapacity),
-		cancelled: make(chan struct{}),
+		out:      make(chan Message, outCapacity),
+		canceled: make(chan struct{}),
 	}
 }
 
@@ -43,13 +43,13 @@ func (s *Subscription) Out() <-chan Message {
 	return s.out
 }
 
-// Cancelled returns a channel that's closed when the subscription is
+// Canceled returns a channel that's closed when the subscription is
 // terminated and supposed to be used in a select statement.
-func (s *Subscription) Cancelled() <-chan struct{} {
-	return s.cancelled
+func (s *Subscription) Canceled() <-chan struct{} {
+	return s.canceled
 }
 
-// Err returns nil if the channel returned by Cancelled is not yet closed.
+// Err returns nil if the channel returned by Canceled is not yet closed.
 // If the channel is closed, Err returns a non-nil error explaining why:
 //   - ErrUnsubscribed if the subscriber choose to unsubscribe,
 //   - ErrOutOfCapacity if the subscriber is not pulling messages fast enough
@@ -66,7 +66,7 @@ func (s *Subscription) cancel(err error) {
 	s.mtx.Lock()
 	s.err = err
 	s.mtx.Unlock()
-	close(s.cancelled)
+	close(s.canceled)
 }
 
 // Message glues data and events together.
diff --git a/light/store/db/db.go b/light/store/db/db.go
index 9ed121a80..ad230632a 100644
--- a/light/store/db/db.go
+++ b/light/store/db/db.go
@@ -57,7 +57,7 @@ func (s *dbs) SaveLightBlock(lb *types.LightBlock) error {
 
 	lbBz, err := lbpb.Marshal()
 	if err != nil {
-		return fmt.Errorf("marshalling LightBlock: %w", err)
+		return fmt.Errorf("marshaling LightBlock: %w", err)
 	}
 
 	s.mtx.Lock()
diff --git a/node/node_test.go b/node/node_test.go
index 6ec7517e2..5d2b21535 100644
--- a/node/node_test.go
+++ b/node/node_test.go
@@ -51,8 +51,8 @@ func TestNodeStartStop(t *testing.T) {
 	require.NoError(t, err)
 	select {
 	case <-blocksSub.Out():
-	case <-blocksSub.Cancelled():
-		t.Fatal("blocksSub was cancelled")
+	case <-blocksSub.Canceled():
+		t.Fatal("blocksSub was canceled")
 	case <-time.After(10 * time.Second):
 		t.Fatal("timed out waiting for the node to produce a block")
 	}
diff --git a/p2p/netaddress.go b/p2p/netaddress.go
index adf30bad5..5e95dcfef 100644
--- a/p2p/netaddress.go
+++ b/p2p/netaddress.go
@@ -332,10 +332,10 @@ func (na *NetAddress) ReachabilityTo(o *NetAddress) int {
 		}
 		return Default
 	default: /* ipv6 */
-		var tunnelled bool
-		// Is our v6 is tunnelled?
+		var tunneled bool
+		// Is our v6 is tunneled?
 		if o.RFC3964() || o.RFC6052() || o.RFC6145() {
-			tunnelled = true
+			tunneled = true
 		}
 		switch {
 		case !o.Routable():
@@ -344,8 +344,8 @@ func (na *NetAddress) ReachabilityTo(o *NetAddress) int {
 			return Teredo
 		case o.IP.To4() != nil:
 			return Ipv4
-		case tunnelled:
-			// only prioritise ipv6 if we aren't tunnelling it.
+		case tunneled:
+			// only prioritize ipv6 if we aren't tunneling it.
 			return Ipv6Weak
 		}
 		return Ipv6Strong
diff --git a/p2p/pex/addrbook_test.go b/p2p/pex/addrbook_test.go
index 0f1b2b5c8..349df9f13 100644
--- a/p2p/pex/addrbook_test.go
+++ b/p2p/pex/addrbook_test.go
@@ -741,7 +741,7 @@ func countOldAndNewAddrsInSelection(addrs []*p2p.NetAddress, book *addrBook) (nO
 	return
 }
 
-// Analyse the layout of the selection specified by 'addrs'
+// Analyze the layout of the selection specified by 'addrs'
 // Returns:
 // - seqLens - the lengths of the sequences of addresses of same type
 // - seqTypes - the types of sequences in selection
diff --git a/p2p/pex/pex_reactor.go b/p2p/pex/pex_reactor.go
index b241f44ee..092bcb531 100644
--- a/p2p/pex/pex_reactor.go
+++ b/p2p/pex/pex_reactor.go
@@ -492,7 +492,7 @@ func (r *Reactor) ensurePeers() {
 		}
 		// TODO: consider moving some checks from toDial into here
 		// so we don't even consider dialing peers that we want to wait
-		// before dialling again, or have dialed too many times already
+		// before dialing again, or have dialed too many times already
 		r.Logger.Info("Will dial address", "addr", try)
 		toDial[try.ID] = try
 	}
diff --git a/p2p/router.go b/p2p/router.go
index ff2335fe9..80a85d67d 100644
--- a/p2p/router.go
+++ b/p2p/router.go
@@ -58,7 +58,7 @@ type Channel struct {
 	Out   chan<- Envelope  // outbound messages (reactors to peers)
 	Error chan<- PeerError // peer error reporting
 
-	messageType proto.Message // the channel's message type, used for unmarshalling
+	messageType proto.Message // the channel's message type, used for unmarshaling
 	closeCh     chan struct{}
 	closeOnce   sync.Once
 }
@@ -767,7 +767,7 @@ func (r *Router) OnStop() {
 	}
 }
 
-// stopCtx returns a new context that is cancelled when the router stops.
+// stopCtx returns a new context that is canceled when the router stops.
 func (r *Router) stopCtx() context.Context {
 	ctx, cancel := context.WithCancel(context.Background())
 	go func() {
diff --git a/p2p/transport_mconn.go b/p2p/transport_mconn.go
index b6ea2ec5c..35c528611 100644
--- a/p2p/transport_mconn.go
+++ b/p2p/transport_mconn.go
@@ -254,7 +254,7 @@ func (c *mConnConnection) Handshake(
 	)
 	// To handle context cancellation, we need to do the handshake in a
 	// goroutine and abort the blocking network calls by closing the connection
-	// when the context is cancelled.
+	// when the context is canceled.
 	go func() {
 		// FIXME: Since the MConnection code panics, we need to recover it and turn it
 		// into an error. We should remove panics instead.
diff --git a/privval/socket_listeners.go b/privval/socket_listeners.go
index a6d031f8c..1ae95634a 100644
--- a/privval/socket_listeners.go
+++ b/privval/socket_listeners.go
@@ -38,7 +38,7 @@ func TCPListenerTimeoutReadWrite(timeout time.Duration) TCPListenerOption {
 // tcpListener implements net.Listener.
 var _ net.Listener = (*TCPListener)(nil)
 
-// TCPListener wraps a *net.TCPListener to standardise protocol timeouts
+// TCPListener wraps a *net.TCPListener to standardize protocol timeouts
 // and potentially other tuning parameters. It also returns encrypted connections.
 type TCPListener struct {
 	*net.TCPListener
@@ -103,7 +103,7 @@ func UnixListenerTimeoutReadWrite(timeout time.Duration) UnixListenerOption {
 	return func(ul *UnixListener) { ul.timeoutReadWrite = timeout }
 }
 
-// UnixListener wraps a *net.UnixListener to standardise protocol timeouts
+// UnixListener wraps a *net.UnixListener to standardize protocol timeouts
 // and potentially other tuning parameters. It returns unencrypted connections.
 type UnixListener struct {
 	*net.UnixListener
@@ -150,7 +150,7 @@ func (ln *UnixListener) Accept() (net.Conn, error) {
 // timeoutConn implements net.Conn.
 var _ net.Conn = (*timeoutConn)(nil)
 
-// timeoutConn wraps a net.Conn to standardise protocol timeouts / deadline resets.
+// timeoutConn wraps a net.Conn to standardize protocol timeouts / deadline resets.
 type timeoutConn struct {
 	net.Conn
 	timeout time.Duration
diff --git a/rpc/client/interface.go b/rpc/client/interface.go
index c6ff0fee2..f2c68a5c2 100644
--- a/rpc/client/interface.go
+++ b/rpc/client/interface.go
@@ -120,7 +120,7 @@ type MempoolClient interface {
 }
 
 // EvidenceClient is used for submitting an evidence of the malicious
-// behaviour.
+// behavior.
 type EvidenceClient interface {
 	BroadcastEvidence(context.Context, types.Evidence) (*ctypes.ResultBroadcastEvidence, error)
 }
diff --git a/rpc/client/local/local.go b/rpc/client/local/local.go
index eb9cc485b..841e325f4 100644
--- a/rpc/client/local/local.go
+++ b/rpc/client/local/local.go
@@ -241,12 +241,12 @@ func (c *Local) eventsRoutine(
 					c.Logger.Error("wanted to publish ResultEvent, but out channel is full", "result", result, "query", result.Query)
 				}
 			}
-		case <-sub.Cancelled():
+		case <-sub.Canceled():
 			if sub.Err() == tmpubsub.ErrUnsubscribed {
 				return
 			}
 
-			c.Logger.Error("subscription was cancelled, resubscribing...", "err", sub.Err(), "query", q.String())
+			c.Logger.Error("subscription was canceled, resubscribing...", "err", sub.Err(), "query", q.String())
 			sub = c.resubscribe(subscriber, q)
 			if sub == nil { // client was stopped
 				return
diff --git a/rpc/core/events.go b/rpc/core/events.go
index 5e6b3db57..8974fbf74 100644
--- a/rpc/core/events.go
+++ b/rpc/core/events.go
@@ -58,7 +58,7 @@ func Subscribe(ctx *rpctypes.Context, query string) (*ctypes.ResultSubscribe, er
 					env.Logger.Info("Can't write response (slow client)",
 						"to", addr, "subscriptionID", subscriptionID, "err", err)
 				}
-			case <-sub.Cancelled():
+			case <-sub.Canceled():
 				if sub.Err() != tmpubsub.ErrUnsubscribed {
 					var reason string
 					if sub.Err() == nil {
@@ -67,7 +67,7 @@ func Subscribe(ctx *rpctypes.Context, query string) (*ctypes.ResultSubscribe, er
 						reason = sub.Err().Error()
 					}
 					var (
-						err  = fmt.Errorf("subscription was cancelled (reason: %s)", reason)
+						err  = fmt.Errorf("subscription was canceled (reason: %s)", reason)
 						resp = rpctypes.RPCServerError(subscriptionID, err)
 					)
 					if ok := ctx.WSConn.TryWriteRPCResponse(resp); !ok {
diff --git a/rpc/core/mempool.go b/rpc/core/mempool.go
index 48faceee2..7da68418d 100644
--- a/rpc/core/mempool.go
+++ b/rpc/core/mempool.go
@@ -106,14 +106,14 @@ func BroadcastTxCommit(ctx *rpctypes.Context, tx types.Tx) (*ctypes.ResultBroadc
 			Hash:      tx.Hash(),
 			Height:    deliverTxRes.Height,
 		}, nil
-	case <-deliverTxSub.Cancelled():
+	case <-deliverTxSub.Canceled():
 		var reason string
 		if deliverTxSub.Err() == nil {
 			reason = "Tendermint exited"
 		} else {
 			reason = deliverTxSub.Err().Error()
 		}
-		err = fmt.Errorf("deliverTxSub was cancelled (reason: %s)", reason)
+		err = fmt.Errorf("deliverTxSub was canceled (reason: %s)", reason)
 		env.Logger.Error("Error on broadcastTxCommit", "err", err)
 		return &ctypes.ResultBroadcastTxCommit{
 			CheckTx:   *checkTxRes,
diff --git a/rpc/jsonrpc/client/decode.go b/rpc/jsonrpc/client/decode.go
index d0f462076..42941ea68 100644
--- a/rpc/jsonrpc/client/decode.go
+++ b/rpc/jsonrpc/client/decode.go
@@ -19,7 +19,7 @@ func unmarshalResponseBytes(
 	// into the correct type.
 	response := &types.RPCResponse{}
 	if err := json.Unmarshal(responseBytes, response); err != nil {
-		return nil, fmt.Errorf("error unmarshalling: %w", err)
+		return nil, fmt.Errorf("error unmarshaling: %w", err)
 	}
 
 	if response.Error != nil {
@@ -32,7 +32,7 @@ func unmarshalResponseBytes(
 
 	// Unmarshal the RawMessage into the result.
 	if err := tmjson.Unmarshal(response.Result, result); err != nil {
-		return nil, fmt.Errorf("error unmarshalling result: %w", err)
+		return nil, fmt.Errorf("error unmarshaling result: %w", err)
 	}
 
 	return result, nil
@@ -49,7 +49,7 @@ func unmarshalResponseBytesArray(
 	)
 
 	if err := json.Unmarshal(responseBytes, &responses); err != nil {
-		return nil, fmt.Errorf("error unmarshalling: %w", err)
+		return nil, fmt.Errorf("error unmarshaling: %w", err)
 	}
 
 	// No response error checking here as there may be a mixture of successful
@@ -78,7 +78,7 @@ func unmarshalResponseBytesArray(
 
 	for i := 0; i < len(responses); i++ {
 		if err := tmjson.Unmarshal(responses[i].Result, results[i]); err != nil {
-			return nil, fmt.Errorf("error unmarshalling #%d result: %w", i, err)
+			return nil, fmt.Errorf("error unmarshaling #%d result: %w", i, err)
 		}
 	}
 
diff --git a/rpc/jsonrpc/server/http_json_handler.go b/rpc/jsonrpc/server/http_json_handler.go
index ffe9d133b..93a3a124e 100644
--- a/rpc/jsonrpc/server/http_json_handler.go
+++ b/rpc/jsonrpc/server/http_json_handler.go
@@ -52,7 +52,7 @@ func makeJSONRPCHandler(funcMap map[string]*RPCFunc, logger log.Logger) http.Han
 					w,
 					http.StatusInternalServerError,
 					types.RPCParseError(
-						fmt.Errorf("error unmarshalling request: %w", err),
+						fmt.Errorf("error unmarshaling request: %w", err),
 					),
 				)
 				return
diff --git a/rpc/jsonrpc/server/ws_handler.go b/rpc/jsonrpc/server/ws_handler.go
index e4e5d7504..f8a89714e 100644
--- a/rpc/jsonrpc/server/ws_handler.go
+++ b/rpc/jsonrpc/server/ws_handler.go
@@ -49,7 +49,7 @@ func NewWebsocketManager(
 			CheckOrigin: func(r *http.Request) bool {
 				// TODO ???
 				//
-				// The default behaviour would be relevant to browser-based clients,
+				// The default behavior would be relevant to browser-based clients,
 				// afaik. I suppose having a pass-through is a workaround for allowing
 				// for more complex security schemes, shifting the burden of
 				// AuthN/AuthZ outside the Tendermint RPC.
diff --git a/rpc/jsonrpc/types/types.go b/rpc/jsonrpc/types/types.go
index 54d17155c..fb1ecd10b 100644
--- a/rpc/jsonrpc/types/types.go
+++ b/rpc/jsonrpc/types/types.go
@@ -55,7 +55,7 @@ type RPCRequest struct {
 	Params  json.RawMessage `json:"params"` // must be map[string]interface{} or []interface{}
 }
 
-// UnmarshalJSON custom JSON unmarshalling due to jsonrpcid being string or int
+// UnmarshalJSON custom JSON unmarshaling due to jsonrpcid being string or int
 func (req *RPCRequest) UnmarshalJSON(data []byte) error {
 	unsafeReq := &struct {
 		JSONRPC string          `json:"jsonrpc"`
@@ -154,7 +154,7 @@ type RPCResponse struct {
 	Error   *RPCError       `json:"error,omitempty"`
 }
 
-// UnmarshalJSON custom JSON unmarshalling due to jsonrpcid being string or int
+// UnmarshalJSON custom JSON unmarshaling due to jsonrpcid being string or int
 func (resp *RPCResponse) UnmarshalJSON(data []byte) error {
 	unsafeResp := &struct {
 		JSONRPC string          `json:"jsonrpc"`
@@ -187,7 +187,7 @@ func NewRPCSuccessResponse(id jsonrpcid, res interface{}) RPCResponse {
 		var js []byte
 		js, err := tmjson.Marshal(res)
 		if err != nil {
-			return RPCInternalError(id, fmt.Errorf("error marshalling response: %w", err))
+			return RPCInternalError(id, fmt.Errorf("error marshaling response: %w", err))
 		}
 		rawMsg = json.RawMessage(js)
 	}
diff --git a/state/execution_test.go b/state/execution_test.go
index 07a421495..984b79822 100644
--- a/state/execution_test.go
+++ b/state/execution_test.go
@@ -405,8 +405,8 @@ func TestEndBlockValidatorUpdates(t *testing.T) {
 			assert.Equal(t, pubkey, event.ValidatorUpdates[0].PubKey)
 			assert.EqualValues(t, 10, event.ValidatorUpdates[0].VotingPower)
 		}
-	case <-updatesSub.Cancelled():
-		t.Fatalf("updatesSub was cancelled (reason: %v)", updatesSub.Err())
+	case <-updatesSub.Canceled():
+		t.Fatalf("updatesSub was canceled (reason: %v)", updatesSub.Err())
 	case <-time.After(1 * time.Second):
 		t.Fatal("Did not receive EventValidatorSetUpdates within 1 sec.")
 	}
diff --git a/state/state_test.go b/state/state_test.go
index cc13b8ecb..34685d8d0 100644
--- a/state/state_test.go
+++ b/state/state_test.go
@@ -40,7 +40,7 @@ func setupTestCase(t *testing.T) (func(t *testing.T), dbm.DB, sm.State) {
 	return tearDown, stateDB, state
 }
 
-// TestStateCopy tests the correct copying behaviour of State.
+// TestStateCopy tests the correct copying behavior of State.
 func TestStateCopy(t *testing.T) {
 	tearDown, _, state := setupTestCase(t)
 	defer tearDown(t)
diff --git a/state/txindex/indexer_service.go b/state/txindex/indexer_service.go
index 961269d23..4fc9ebcf8 100644
--- a/state/txindex/indexer_service.go
+++ b/state/txindex/indexer_service.go
@@ -32,7 +32,7 @@ func NewIndexerService(idr TxIndexer, eventBus *types.EventBus) *IndexerService
 // and indexing them by events.
 func (is *IndexerService) OnStart() error {
 	// Use SubscribeUnbuffered here to ensure both subscriptions does not get
-	// cancelled due to not pulling messages fast enough. Cause this might
+	// canceled due to not pulling messages fast enough. Cause this might
 	// sometimes happen when there are no other subscribers.
 
 	blockHeadersSub, err := is.eventBus.SubscribeUnbuffered(
diff --git a/statesync/syncer.go b/statesync/syncer.go
index 425705cb1..46799cde7 100644
--- a/statesync/syncer.go
+++ b/statesync/syncer.go
@@ -245,7 +245,7 @@ func (s *syncer) Sync(snapshot *snapshot, chunks *chunkQueue) (sm.State, *types.
 		return sm.State{}, nil, err
 	}
 
-	// Spawn chunk fetchers. They will terminate when the chunk queue is closed or context cancelled.
+	// Spawn chunk fetchers. They will terminate when the chunk queue is closed or context canceled.
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 	for i := int32(0); i < chunkFetchers; i++ {
@@ -385,7 +385,7 @@ func (s *syncer) fetchChunks(ctx context.Context, snapshot *snapshot, chunks *ch
 	for {
 		index, err := chunks.Allocate()
 		if err == errDone {
-			// Keep checking until the context is cancelled (restore is done), in case any
+			// Keep checking until the context is canceled (restore is done), in case any
 			// chunks need to be refetched.
 			select {
 			case <-ctx.Done():
diff --git a/test/app/counter_test.sh b/test/app/counter_test.sh
index 3af2b885f..e5c45a410 100755
--- a/test/app/counter_test.sh
+++ b/test/app/counter_test.sh
@@ -29,7 +29,7 @@ function getCode() {
 	else
 		# protobuf auto adds `omitempty` to everything so code OK and empty data/log
 		# will not even show when marshalled into json
-		# apparently we can use github.com/golang/protobuf/jsonpb to do the marshalling ...
+		# apparently we can use github.com/golang/protobuf/jsonpb to do the marshaling ...
 		echo 0
 	fi
 }
diff --git a/test/e2e/README.md b/test/e2e/README.md
index cacc2f333..1e2df02ba 100644
--- a/test/e2e/README.md
+++ b/test/e2e/README.md
@@ -72,7 +72,7 @@ The test runner has the following stages, which can also be executed explicitly
 
 * `logs`: outputs all node logs.
 
-* `tail`: tails (follows) node logs until cancelled.
+* `tail`: tails (follows) node logs until canceled.
 
 ## Tests
 
diff --git a/test/e2e/app/state.go b/test/e2e/app/state.go
index ad9960105..b34680c1b 100644
--- a/test/e2e/app/state.go
+++ b/test/e2e/app/state.go
@@ -19,7 +19,7 @@ type State struct {
 	Values map[string]string
 	Hash   []byte
 
-	// private fields aren't marshalled to disk.
+	// private fields aren't marshaled to disk.
 	file            string
 	persistInterval uint64
 	initialHeight   uint64
diff --git a/test/e2e/runner/load.go b/test/e2e/runner/load.go
index 495c573d3..4b58c2569 100644
--- a/test/e2e/runner/load.go
+++ b/test/e2e/runner/load.go
@@ -14,7 +14,7 @@ import (
 )
 
 // Load generates transactions against the network until the given
-// context is cancelled.
+// context is canceled.
 func Load(ctx context.Context, testnet *e2e.Testnet) error {
 	// Since transactions are executed across all nodes in the network, we need
 	// to reduce transaction load for larger networks to avoid using too much
@@ -64,7 +64,7 @@ func Load(ctx context.Context, testnet *e2e.Testnet) error {
 	}
 }
 
-// loadGenerate generates jobs until the context is cancelled
+// loadGenerate generates jobs until the context is canceled
 func loadGenerate(ctx context.Context, chTx chan<- types.Tx) {
 	for i := 0; i < math.MaxInt64; i++ {
 		// We keep generating the same 1000 keys over and over, with different values.
diff --git a/test/e2e/runner/main.go b/test/e2e/runner/main.go
index 633073eb2..eca129ada 100644
--- a/test/e2e/runner/main.go
+++ b/test/e2e/runner/main.go
@@ -171,7 +171,7 @@ func NewCLI() *CLI {
 
 	cli.root.AddCommand(&cobra.Command{
 		Use:   "load",
-		Short: "Generates transaction load until the command is cancelled",
+		Short: "Generates transaction load until the command is canceled",
 		RunE: func(cmd *cobra.Command, args []string) error {
 			return Load(context.Background(), cli.testnet)
 		},
diff --git a/test/maverick/consensus/replay.go b/test/maverick/consensus/replay.go
index 50bf4d365..a4dd8db3e 100644
--- a/test/maverick/consensus/replay.go
+++ b/test/maverick/consensus/replay.go
@@ -56,8 +56,8 @@ func (cs *State) readReplayMessage(msg *tmcon.TimedWALMessage, newStepSub types.
 				if m.Height != m2.Height || m.Round != m2.Round || m.Step != m2.Step {
 					return fmt.Errorf("roundState mismatch. Got %v; Expected %v", m2, m)
 				}
-			case <-newStepSub.Cancelled():
-				return fmt.Errorf("failed to read off newStepSub.Out(). newStepSub was cancelled")
+			case <-newStepSub.Canceled():
+				return fmt.Errorf("failed to read off newStepSub.Out(). newStepSub was canceled")
 			case <-ticker:
 				return fmt.Errorf("failed to read off newStepSub.Out()")
 			}
diff --git a/test/maverick/consensus/state.go b/test/maverick/consensus/state.go
index 44cec2ae0..46790d60e 100644
--- a/test/maverick/consensus/state.go
+++ b/test/maverick/consensus/state.go
@@ -387,7 +387,7 @@ func (cs *State) addVote(
 	}
 
 	// Height mismatch is ignored.
-	// Not necessarily a bad peer, but not favourable behaviour.
+	// Not necessarily a bad peer, but not favorable behavior.
 	if vote.Height != cs.Height {
 		cs.Logger.Debug("vote ignored and not added", "voteHeight", vote.Height, "csHeight", cs.Height, "peerID", peerID)
 		return
diff --git a/types/event_bus.go b/types/event_bus.go
index 72ba5e3d6..34f511d14 100644
--- a/types/event_bus.go
+++ b/types/event_bus.go
@@ -23,7 +23,7 @@ type EventBusSubscriber interface {
 
 type Subscription interface {
 	Out() <-chan tmpubsub.Message
-	Cancelled() <-chan struct{}
+	Canceled() <-chan struct{}
 	Err() error
 }
 
diff --git a/types/event_bus_test.go b/types/event_bus_test.go
index a0a2e2e5f..7759d29a6 100644
--- a/types/event_bus_test.go
+++ b/types/event_bus_test.go
@@ -438,7 +438,7 @@ func benchmarkEventBus(numClients int, randQueries bool, randEvents bool, b *tes
 			for {
 				select {
 				case <-sub.Out():
-				case <-sub.Cancelled():
+				case <-sub.Canceled():
 					return
 				}
 			}
diff --git a/types/genesis_test.go b/types/genesis_test.go
index fa579a8d0..bfb122e64 100644
--- a/types/genesis_test.go
+++ b/types/genesis_test.go
@@ -84,7 +84,7 @@ func TestGenesisGood(t *testing.T) {
 		Validators: []GenesisValidator{{pubkey.Address(), pubkey, 10, "myval"}},
 	}
 	genDocBytes, err = tmjson.Marshal(baseGenDoc)
-	assert.NoError(t, err, "error marshalling genDoc")
+	assert.NoError(t, err, "error marshaling genDoc")
 
 	// test base gendoc and check consensus params were filled
 	genDoc, err := GenesisDocFromJSON(genDocBytes)
@@ -96,14 +96,14 @@ func TestGenesisGood(t *testing.T) {
 
 	// create json with consensus params filled
 	genDocBytes, err = tmjson.Marshal(genDoc)
-	assert.NoError(t, err, "error marshalling genDoc")
+	assert.NoError(t, err, "error marshaling genDoc")
 	genDoc, err = GenesisDocFromJSON(genDocBytes)
 	assert.NoError(t, err, "expected no error for valid genDoc json")
 
 	// test with invalid consensus params
 	genDoc.ConsensusParams.Block.MaxBytes = 0
 	genDocBytes, err = tmjson.Marshal(genDoc)
-	assert.NoError(t, err, "error marshalling genDoc")
+	assert.NoError(t, err, "error marshaling genDoc")
 	_, err = GenesisDocFromJSON(genDocBytes)
 	assert.Error(t, err, "expected error for genDoc json with block size of 0")
 
diff --git a/types/signable.go b/types/signable.go
index 074654cc5..25e307316 100644
--- a/types/signable.go
+++ b/types/signable.go
@@ -17,7 +17,7 @@ var (
 // SignBytes returns the bytes to be signed
 // NOTE: chainIDs are part of the SignBytes but not
 // necessarily the object themselves.
-// NOTE: Expected to panic if there is an error marshalling.
+// NOTE: Expected to panic if there is an error marshaling.
 type Signable interface {
 	SignBytes(chainID string) []byte
 }
diff --git a/types/vote_set.go b/types/vote_set.go
index 42bde9856..4449612e1 100644
--- a/types/vote_set.go
+++ b/types/vote_set.go
@@ -498,7 +498,7 @@ func (voteSet *VoteSet) MarshalJSON() ([]byte, error) {
 }
 
 // More human readable JSON of the vote set
-// NOTE: insufficient for unmarshalling from (compressed votes)
+// NOTE: insufficient for unmarshaling from (compressed votes)
 // TODO: make the peerMaj23s nicer to read (eg just the block hash)
 type VoteSetJSON struct {
 	Votes         []string          `json:"votes"`
diff --git a/version/version.go b/version/version.go
index 064150fde..74c6df2c1 100644
--- a/version/version.go
+++ b/version/version.go
@@ -16,7 +16,7 @@ const (
 )
 
 var (
-	// P2PProtocol versions all p2p behaviour and msgs.
+	// P2PProtocol versions all p2p behavior and msgs.
 	// This includes proposer selection.
 	P2PProtocol uint64 = 8