diff --git a/.github/golangci.yml b/.github/golangci.yml
index 992398956b1..53141a3143d 100644
--- a/.github/golangci.yml
+++ b/.github/golangci.yml
@@ -1,9 +1,20 @@
 run:
-  timeout: 5m
+  concurrency: 8
+  timeout: 10m
+  issue-exit-code: 1
   tests: true
   skip-dirs-use-default: true
+  modules-download-mode: readonly
+  allow-parallel-runners: false
+  go: ""
+
+output:
+  uniq-by-line: false
+  path-prefix: ""
+  sort-results: true
 
 linters:
+  fast: false
   disable-all: true
   enable:
     - whitespace # Tool for detection of leading and trailing whitespace
@@ -21,12 +32,11 @@ linters:
     - gofmt # Whether the code was gofmt-ed
     - goimports # Unused imports
     - goconst # Repeated strings that could be replaced by a constant
-    #- forcetypeassert # Finds forced type assertions
     - dogsled # Checks assignments with too many blank identifiers (e.g. x, , , _, := f())
-    #- dupl # Code clone detection
     - errname # Checks that sentinel errors are prefixed with the Err and error types are suffixed with the Error
     - errorlint # errorlint is a linter for that can be used to find code that will cause problems with the error wrapping scheme introduced in Go 1.13
     - gofumpt # Stricter gofmt
+    - unused # Checks Go code for unused constants, variables, functions and types
 
 linters-settings:
   gofmt:
@@ -42,9 +52,20 @@ linters-settings:
     checks: [ "all", "-ST1022", "-ST1003" ]
   errorlint:
     asserts: false
+  gocritic:
+    enabled-tags:
+      - diagnostic
+      - experimental
+      - opinionated
+      - performance
+      - style
 
 issues:
   whole-files: true
+  max-issues-per-linter: 0
+  max-same-issues: 0
+  new: false
+  fix: false
   exclude-rules:
     - path: _test\.go
       linters:
diff --git a/gnovm/pkg/gnolang/helpers.go b/gnovm/pkg/gnolang/helpers.go
index c16ea795ea3..4810a67304a 100644
--- a/gnovm/pkg/gnolang/helpers.go
+++ b/gnovm/pkg/gnolang/helpers.go
@@ -440,18 +440,6 @@ var (
 	precs = [][]string{prec1, prec2, prec3, prec4, prec5}
 )
 
-// 0 for prec1... -1 if no match.
-func lowestMatch(op string) int {
-	for i, prec := range precs {
-		for _, op2 := range prec {
-			if op == op2 {
-				return i
-			}
-		}
-	}
-	return -1
-}
-
 func Ss(b ...Stmt) []Stmt {
 	return b
 }
diff --git a/gnovm/pkg/gnolang/preprocess.go b/gnovm/pkg/gnolang/preprocess.go
index e02a158fcf1..1a1edc41222 100644
--- a/gnovm/pkg/gnolang/preprocess.go
+++ b/gnovm/pkg/gnolang/preprocess.go
@@ -3338,23 +3338,6 @@ func elideCompositeExpr(vx *Expr, vt Type) {
 	}
 }
 
-// returns true of x is exactly `nil`.
-func isNilExpr(x Expr) bool {
-	if nx, ok := x.(*NameExpr); ok {
-		return nx.Name == nilStr
-	}
-	return false
-}
-
-func isNilComparableKind(k Kind) bool {
-	switch k {
-	case SliceKind, MapKind, FuncKind:
-		return true
-	default:
-		return false
-	}
-}
-
 // returns number of args, or if arg is a call result,
 // the number of results of the return tuple type.
 func countNumArgs(store Store, last BlockNode, n *CallExpr) (numArgs int) {
@@ -3374,13 +3357,6 @@ func countNumArgs(store Store, last BlockNode, n *CallExpr) (numArgs int) {
 	}
 }
 
-func mergeNames(a, b []Name) []Name {
-	c := make([]Name, len(a)+len(b))
-	copy(c, a)
-	copy(c[len(a):], b)
-	return c
-}
-
 // This is to be run *after* preprocessing is done,
 // to determine the order of var decl execution
 // (which may include functions which may refer to package vars).
diff --git a/gnovm/pkg/gnolang/scanner.go b/gnovm/pkg/gnolang/scanner.go
index 87695c0f346..f0b3f34c9ad 100644
--- a/gnovm/pkg/gnolang/scanner.go
+++ b/gnovm/pkg/gnolang/scanner.go
@@ -192,21 +192,3 @@ func (ss *scanner) advanceEscapeSequence() bool {
 		return ss.done()
 	}
 }
-
-// pops the next monoid term.
-// The result is a string enclosed in balanced parentheses,
-// brackets, or quotes; or what comes before such things.
-// scanner doesn't understand operators, so a polynomial
-// expression could be a single monoid as far as this scanner
-// is concerned.  TODO Chop functions should maybe use this.
-func (ss *scanner) popMonoid() string {
-	startOut := ss.out()
-	start := ss.idx
-	for !ss.advance() {
-		if ss.out() != startOut {
-			end := ss.idx
-			return string(ss.rnz[start:end])
-		}
-	}
-	panic("no monoid")
-}
diff --git a/gnovm/pkg/gnolang/store.go b/gnovm/pkg/gnolang/store.go
index d3628edf216..24aff4936f3 100644
--- a/gnovm/pkg/gnolang/store.go
+++ b/gnovm/pkg/gnolang/store.go
@@ -11,8 +11,6 @@ import (
 	"github.com/gnolang/gno/tm2/pkg/store"
 )
 
-const iavlCacheSize = 1024 * 1024 // TODO increase and parameterize.
-
 // return nil if package doesn't exist.
 type PackageGetter func(pkgPath string) (*PackageNode, *PackageValue)
 
@@ -626,7 +624,7 @@ func (ds *defaultStore) Flush() {
 	// XXX
 }
 
-//----------------------------------------
+// ----------------------------------------
 // StoreOp
 
 type StoreOpType uint8
@@ -723,7 +721,7 @@ func (ds *defaultStore) Print() {
 	}
 }
 
-//----------------------------------------
+// ----------------------------------------
 // backend keys
 
 func backendObjectKey(oid ObjectID) string {
@@ -755,7 +753,7 @@ func backendPackagePathKey(path string) string {
 	return fmt.Sprintf("pkg:" + path)
 }
 
-//----------------------------------------
+// ----------------------------------------
 // builtin types and packages
 
 func InitStoreCaches(store Store) {
diff --git a/gnovm/pkg/gnolang/types.go b/gnovm/pkg/gnolang/types.go
index c3e439e9427..6aed71fcf9b 100644
--- a/gnovm/pkg/gnolang/types.go
+++ b/gnovm/pkg/gnolang/types.go
@@ -879,7 +879,6 @@ type InterfaceType struct {
 }
 
 // General empty interface.
-var gEmptyInterfaceType *InterfaceType = &InterfaceType{}
 
 func (it *InterfaceType) IsEmptyInterface() bool {
 	return len(it.Methods) == 0
diff --git a/gnovm/stdlibs/stdlibs.go b/gnovm/stdlibs/stdlibs.go
index fb230a0cf86..8931266eb9a 100644
--- a/gnovm/stdlibs/stdlibs.go
+++ b/gnovm/stdlibs/stdlibs.go
@@ -581,13 +581,3 @@ func typedByteArray(ln int, bz *gno.ArrayValue) gno.TypedValue {
 	tv := gno.TypedValue{T: &gno.ArrayType{Len: ln, Elt: gno.Uint8Type}, V: bz}
 	return tv
 }
-
-func typedByteSlice(bz *gno.SliceValue) gno.TypedValue {
-	tv := gno.TypedValue{T: &gno.SliceType{Elt: gno.Uint8Type}, V: bz}
-	return tv
-}
-
-func typedNil(t gno.Type) gno.TypedValue {
-	tv := gno.TypedValue{T: t, V: nil}
-	return tv
-}
diff --git a/misc/logos/buffer.go b/misc/logos/buffer.go
index 90665f79bfd..81e8d1abc75 100644
--- a/misc/logos/buffer.go
+++ b/misc/logos/buffer.go
@@ -7,7 +7,7 @@ import (
 	"github.com/gdamore/tcell/v2"
 )
 
-//----------------------------------------
+// ----------------------------------------
 // Buffer
 
 // A Buffer is a buffer area in which to draw.
@@ -82,7 +82,7 @@ func (bb *Buffer) DrawToScreen(s tcell.Screen) {
 	}
 }
 
-//----------------------------------------
+// ----------------------------------------
 // Cell
 
 // A terminal character cell.
@@ -131,10 +131,6 @@ var gDefaultSpaceTStyle = tcell.StyleDefault.
 	Dim(true).
 	Background(tcell.ColorGray)
 
-var gDefaultTStyle = gDefaultStyle.GetTStyle().
-	Foreground(gDefaultForeground).
-	Background(gDefaultBackground)
-
 // This is where a bit of dynamic logic is performed,
 // namely where the attr is used to derive the final style.
 func (cc *Cell) GetTCellContent() (mainc rune, combc []rune, tstyle tcell.Style) {
@@ -161,7 +157,7 @@ func (cc *Cell) GetTCellContent() (mainc rune, combc []rune, tstyle tcell.Style)
 	return
 }
 
-//----------------------------------------
+// ----------------------------------------
 // View
 // analogy: "Buffer:View :: array:slice".
 
@@ -205,7 +201,7 @@ func (bs View) GetCell(x, y int) *Cell {
 	)
 }
 
-//----------------------------------------
+// ----------------------------------------
 // BufferedView
 
 // A view onto an element.
diff --git a/misc/logos/cmd/logos.go b/misc/logos/cmd/logos.go
index 228895f852d..3a374fecba2 100644
--- a/misc/logos/cmd/logos.go
+++ b/misc/logos/cmd/logos.go
@@ -10,11 +10,6 @@ import (
 	"github.com/gnolang/gno/misc/logos"
 )
 
-var (
-	row   = 0
-	style = tcell.StyleDefault
-)
-
 func main() {
 	encoding.Register()
 
diff --git a/misc/logos/debug.go b/misc/logos/debug.go
deleted file mode 100644
index 8b2a4692bf4..00000000000
--- a/misc/logos/debug.go
+++ /dev/null
@@ -1,26 +0,0 @@
-package logos
-
-import (
-	"fmt"
-)
-
-// NOTE: the golang compiler doesn't seem to be intelligent
-// enough to remove steps when const debug is True,
-// so it is still faster to first check the truth value
-// before calling debug.Println or debug.Printf.
-
-const debug debugging = false // or flip
-
-type debugging bool
-
-func (d debugging) Println(args ...interface{}) {
-	if d {
-		fmt.Println(append([]interface{}{"DEBUG:"}, args...)...)
-	}
-}
-
-func (d debugging) Printf(format string, args ...interface{}) {
-	if d {
-		fmt.Printf("DEBUG: "+format, args...)
-	}
-}
diff --git a/misc/logos/types.go b/misc/logos/types.go
index 944f02515d3..96e983992eb 100644
--- a/misc/logos/types.go
+++ b/misc/logos/types.go
@@ -7,7 +7,7 @@ import (
 	"github.com/gdamore/tcell/v2"
 )
 
-//----------------------------------------
+// ----------------------------------------
 // Page
 
 // A Page has renderable Elem(ents).
@@ -389,7 +389,7 @@ func (pg *Page) DecCursor(isVertical bool) {
 	}
 }
 
-//----------------------------------------
+// ----------------------------------------
 // TextElem
 
 type TextElem struct {
@@ -474,8 +474,6 @@ func (tel *TextElem) Render() (updated bool) {
 	return true
 }
 
-var ctr = 0
-
 func (tel *TextElem) Draw(offset Coord, view View) {
 	minX, maxX, minY, maxY := computeIntersection(tel.Size, offset, view.Bounds)
 	for y := minY; y < maxY; y++ {
@@ -494,7 +492,7 @@ func (tel *TextElem) ProcessEventKey(ev *EventKey) bool {
 	return false // TODO: clipboard.
 }
 
-//----------------------------------------
+// ----------------------------------------
 // misc.
 
 type Color = tcell.Color
@@ -728,7 +726,7 @@ func (tt *Attrs) Merge(ot *Attrs) {
 	tt.Other = ot.Other // TODO merge by key.
 }
 
-//----------------------------------------
+// ----------------------------------------
 // AttrFlags
 
 // NOTE: AttrFlags are merged with a simple or-assign op.
@@ -752,7 +750,7 @@ type KVPair struct {
 	Value interface{}
 }
 
-//----------------------------------------
+// ----------------------------------------
 // computeIntersection()
 
 // els: element size
@@ -812,7 +810,7 @@ func computeIntersection(els Size, elo Coord, vws Size) (minX, maxX, minY, maxY
 	return
 }
 
-//----------------------------------------
+// ----------------------------------------
 // Misc simple types
 
 type Padding struct {
diff --git a/misc/logos/unicode.go b/misc/logos/unicode.go
index 3bdb46cd88b..924edecc2c5 100644
--- a/misc/logos/unicode.go
+++ b/misc/logos/unicode.go
@@ -4,7 +4,7 @@ func isCombining(r rune) bool {
 	return inTable(r, combining)
 }
 
-//----------------------------------------
+// ----------------------------------------
 // from https://github.com/mattn/go-runewidth
 // runewidth doesn't expose whether a character is combining or not.
 // TODO might as well fork both runewidth and tcell.
@@ -62,15 +62,6 @@ type interval struct {
 
 type table []interval
 
-func inTables(r rune, ts ...table) bool {
-	for _, t := range ts {
-		if inTable(r, t) {
-			return true
-		}
-	}
-	return false
-}
-
 func inTable(r rune, t table) bool {
 	if r < t[0].first {
 		return false
diff --git a/tm2/pkg/amino/binary_decode.go b/tm2/pkg/amino/binary_decode.go
index 8ac4161cede..333994d60b0 100644
--- a/tm2/pkg/amino/binary_decode.go
+++ b/tm2/pkg/amino/binary_decode.go
@@ -12,14 +12,6 @@ const bdOptionByte = 0x01
 // ----------------------------------------
 // cdc.decodeReflectBinary
 
-var ErrOverflowInt = errors.New("encoded integer value overflows int(32)")
-
-const (
-	// architecture dependent int limits:
-	maxInt = int(^uint(0) >> 1)
-	minInt = -maxInt - 1
-)
-
 // This is the main entrypoint for decoding all types from binary form. This
 // function calls decodeReflectBinary*, and generally those functions should
 // only call this one, for overrides all happen here.
diff --git a/tm2/pkg/amino/codec_test.go b/tm2/pkg/amino/codec_test.go
index 7e025f73271..18bc8f2cd5d 100644
--- a/tm2/pkg/amino/codec_test.go
+++ b/tm2/pkg/amino/codec_test.go
@@ -214,9 +214,6 @@ func TestEncodeDecodeString(t *testing.T) {
 }
 
 func TestCodecSeal(t *testing.T) {
-	type Foo interface{}
-	type Bar interface{}
-
 	cdc := amino.NewCodec()
 	cdc.Seal()
 
diff --git a/tm2/pkg/amino/genproto/bindings.go b/tm2/pkg/amino/genproto/bindings.go
index 458d8b14578..5d587870a7d 100644
--- a/tm2/pkg/amino/genproto/bindings.go
+++ b/tm2/pkg/amino/genproto/bindings.go
@@ -105,7 +105,7 @@ func generateMethodsForType(imports *ast.GenDecl, scope *ast.Scope, pkg *amino.P
 	}
 	dpbote_ := pbote_[1:]
 
-	//////////////////
+	// -----------
 	// ToPBMessage()
 	{
 		scope2 := ast.NewScope(scope)
@@ -127,7 +127,7 @@ func generateMethodsForType(imports *ast.GenDecl, scope *ast.Scope, pkg *amino.P
 		))
 	}
 
-	//////////////////
+	// -----------
 	// EmptyPBMessage()
 	// Use to create the pbm to proto.Unmarshal to before FromPBMessage.
 	{
@@ -148,7 +148,7 @@ func generateMethodsForType(imports *ast.GenDecl, scope *ast.Scope, pkg *amino.P
 		))
 	}
 
-	//////////////////
+	// -----------
 	// FromPBMessage()
 	{
 		scope2 := ast.NewScope(scope)
@@ -169,7 +169,7 @@ func generateMethodsForType(imports *ast.GenDecl, scope *ast.Scope, pkg *amino.P
 		))
 	}
 
-	//////////////////
+	// -----------
 	// TypeUrl()
 	{
 		methods = append(methods, _func("GetTypeURL",
@@ -182,7 +182,7 @@ func generateMethodsForType(imports *ast.GenDecl, scope *ast.Scope, pkg *amino.P
 		))
 	}
 
-	//////////////////
+	// -----------
 	// Is*ReprEmpty()
 	{
 		rinfo := info.ReprType
@@ -965,7 +965,7 @@ func isReprEmptyStmts(rootPkg *amino.Package, isRoot bool, imports *ast.GenDecl,
 	return b
 }
 
-//----------------------------------------
+// ----------------------------------------
 // other....
 
 // Splits a Go expression into left and right parts.
@@ -1013,7 +1013,7 @@ func chopRight(expr string) (left string, tok rune, right string) {
 	return
 }
 
-//----------------------------------------
+// ----------------------------------------
 // AST Construction (Expr)
 
 func _i(name string) *ast.Ident {
@@ -1023,14 +1023,6 @@ func _i(name string) *ast.Ident {
 	return &ast.Ident{Name: name}
 }
 
-func _iOrNil(name string) *ast.Ident {
-	if name == "" {
-		return nil
-	} else {
-		return _i(name)
-	}
-}
-
 // recvTypeName is empty if there are no receivers.
 // recvTypeName cannot contain any dots.
 func _func(name string, recvRef string, recvTypeName string, params *ast.FieldList, results *ast.FieldList, b *ast.BlockStmt) *ast.FuncDecl {
@@ -1344,29 +1336,6 @@ func _x(expr string, args ...interface{}) ast.Expr {
 //	3             ==  !=  <  <=  >  >=
 //	2             &&
 //	1             ||
-var sp = " "
-
-var (
-	prec5 = strings.Split("*  /  %  <<  >>  &  &^", sp)
-	prec4 = strings.Split("+ - | ^", sp)
-	prec3 = strings.Split("== != < <= > >=", sp)
-	prec2 = strings.Split("&&", sp)
-	prec1 = strings.Split("||", sp)
-	precs = [][]string{prec1, prec2, prec3, prec4, prec5}
-)
-
-// 0 for prec1... -1 if no match.
-func lowestMatch(op string) int {
-	for i, prec := range precs {
-		for _, op2 := range prec {
-			if op == op2 {
-				return i
-			}
-		}
-	}
-	return -1
-}
-
 func _kv(k, v interface{}) *ast.KeyValueExpr {
 	var kx, vx ast.Expr
 	if ks, ok := k.(string); ok {
@@ -1391,10 +1360,6 @@ func _block(b ...ast.Stmt) *ast.BlockStmt {
 	}
 }
 
-func _xs(exprs ...ast.Expr) []ast.Expr {
-	return exprs
-}
-
 // Usage: _a(lhs1, lhs2, ..., ":=", rhs1, rhs2, ...)
 // Token can be ":=", "=", "+=", etc.
 // Other strings are automatically parsed as _x(arg).
@@ -1470,13 +1435,6 @@ func _call(fn ast.Expr, args ...ast.Expr) *ast.CallExpr {
 	}
 }
 
-func _ta(x ast.Expr, t ast.Expr) *ast.TypeAssertExpr {
-	return &ast.TypeAssertExpr{
-		X:    x,
-		Type: t,
-	}
-}
-
 func _sel(x ast.Expr, sel string) *ast.SelectorExpr {
 	return &ast.SelectorExpr{
 		X:   x,
@@ -1532,7 +1490,7 @@ func _sl(x ast.Expr) *ast.ArrayType {
 	}
 }
 
-//----------------------------------------
+// ----------------------------------------
 // AST Construction (Stmt)
 
 func _if(cond ast.Expr, b ...ast.Stmt) *ast.IfStmt {
@@ -1564,34 +1522,6 @@ func _return(results ...ast.Expr) *ast.ReturnStmt {
 	}
 }
 
-func _continue(label string) *ast.BranchStmt {
-	return &ast.BranchStmt{
-		Tok:   token.CONTINUE,
-		Label: _i(label),
-	}
-}
-
-func _break(label string) *ast.BranchStmt {
-	return &ast.BranchStmt{
-		Tok:   token.BREAK,
-		Label: _i(label),
-	}
-}
-
-func _goto(label string) *ast.BranchStmt {
-	return &ast.BranchStmt{
-		Tok:   token.GOTO,
-		Label: _i(label),
-	}
-}
-
-func _fallthrough(label string) *ast.BranchStmt {
-	return &ast.BranchStmt{
-		Tok:   token.FALLTHROUGH,
-		Label: _i(label),
-	}
-}
-
 // even/odd args are paired,
 // name1, path1, name2, path2, etc.
 func _imports(nameAndPaths ...string) *ast.GenDecl {
@@ -1618,15 +1548,6 @@ func _for(init ast.Stmt, cond ast.Expr, post ast.Stmt, b ...ast.Stmt) *ast.ForSt
 	}
 }
 
-func _loop(b ...ast.Stmt) *ast.ForStmt {
-	return _for(nil, nil, nil, b...)
-}
-
-func _once(b ...ast.Stmt) *ast.ForStmt {
-	b = append(b, _break(""))
-	return _for(nil, nil, nil, b...)
-}
-
 func _len(x ast.Expr) *ast.CallExpr {
 	return _call(_i("len"), x)
 }
@@ -1766,7 +1687,7 @@ func _aop(op string) token.Token {
 	}
 }
 
-//----------------------------------------
+// ----------------------------------------
 // AST Compile-Time
 
 func _ctif(cond bool, then_, else_ ast.Stmt) ast.Stmt {
@@ -1779,7 +1700,7 @@ func _ctif(cond bool, then_, else_ ast.Stmt) ast.Stmt {
 	}
 }
 
-//----------------------------------------
+// ----------------------------------------
 // AST query and manipulation.
 
 func importPathForName(name string, imports *ast.GenDecl) (path string, exists bool) {
@@ -1800,24 +1721,6 @@ func importPathForName(name string, imports *ast.GenDecl) (path string, exists b
 	return "", false
 }
 
-func importNameForPath(path string, imports *ast.GenDecl) (name string, exists bool) {
-	if imports.Tok != token.IMPORT {
-		panic("unexpected ast.GenDecl token " + imports.Tok.String())
-	}
-	for _, spec := range imports.Specs {
-		if ispec, ok := spec.(*ast.ImportSpec); ok {
-			specPath, err := strconv.Unquote(ispec.Path.Value)
-			if err != nil {
-				panic("malformed path " + ispec.Path.Value)
-			}
-			if specPath == path {
-				return ispec.Name.Name, true
-			}
-		}
-	}
-	return "", false
-}
-
 func rootScope(scope *ast.Scope) *ast.Scope {
 	for scope.Outer != nil {
 		scope = scope.Outer
diff --git a/tm2/pkg/amino/genproto/example/main.go b/tm2/pkg/amino/genproto/example/main.go
index 24132305893..6e4023b596d 100644
--- a/tm2/pkg/amino/genproto/example/main.go
+++ b/tm2/pkg/amino/genproto/example/main.go
@@ -11,16 +11,12 @@ import (
 
 // amino
 type StructA struct {
-	fieldA int
-	fieldB int
 	FieldC int
 	FieldD uint32
 }
 
 // amino
 type StructB struct {
-	fieldA int
-	fieldB int
 	FieldC int
 	FieldD uint32
 	FieldE submodule.StructSM
diff --git a/tm2/pkg/amino/genproto/scanner.go b/tm2/pkg/amino/genproto/scanner.go
deleted file mode 100644
index 6c5f770ab48..00000000000
--- a/tm2/pkg/amino/genproto/scanner.go
+++ /dev/null
@@ -1,192 +0,0 @@
-package genproto
-
-import "fmt"
-
-type runestate int
-
-const (
-	runestateCode           runestate = 0
-	runestateRune           runestate = 1
-	runestateStringQuote    runestate = 2
-	runestateStringBacktick runestate = 3
-)
-
-type scanner struct {
-	str string
-	rnz []rune
-	idx int
-	runestate
-	curly  int
-	round  int
-	square int
-}
-
-// returns a new scanner.
-func newScanner(str string) *scanner {
-	rnz := make([]rune, 0, len(str))
-	for _, r := range str {
-		rnz = append(rnz, r)
-	}
-	return &scanner{
-		str:       str,
-		runestate: runestateCode,
-		rnz:       rnz,
-	}
-}
-
-// Peeks the next n runes and returns a string.  returns a shorter string if
-// there are less than n runes left.
-func (ss *scanner) peek(n int) string {
-	if ss.idx+n > len(ss.rnz) {
-		return string(ss.rnz[ss.idx:len(ss.rnz)])
-	}
-	return string(ss.rnz[ss.idx : ss.idx+n])
-}
-
-// Advance a single rune, e.g. by incrementing ss.curly if ss.rnz[ss.idx] is
-// '{' before advancing.  If ss.runestate is runestateRune or runestateQuote,
-// advances escape sequences to completion so ss.idx may increment more than
-// one.  Returns true if done.
-func (ss *scanner) advance() bool {
-	rn := ss.rnz[ss.idx] // just panic if out of scope, caller error.
-	switch ss.runestate {
-	case runestateCode:
-		switch rn {
-		case '}':
-			ss.curly--
-			if ss.curly < 0 {
-				panic("mismatched curly: " + ss.str)
-			}
-		case ')':
-			ss.round--
-			if ss.round < 0 {
-				panic("mismatched round: " + ss.str)
-			}
-		case ']':
-			ss.square--
-			if ss.square < 0 {
-				panic("mismatched square: " + ss.str)
-			}
-		case '{':
-			ss.curly++
-		case '(':
-			ss.round++
-		case '[':
-			ss.square++
-		case '\'':
-			ss.runestate = runestateRune
-		case '"':
-			ss.runestate = runestateStringQuote
-		case '`':
-			ss.runestate = runestateStringBacktick
-		}
-	case runestateRune:
-		switch rn {
-		case '\\':
-			return ss.advanceEscapeSequence()
-		case '\'':
-			ss.runestate = runestateCode
-		}
-	case runestateStringQuote:
-		switch rn {
-		case '\\':
-			return ss.advanceEscapeSequence()
-		case '"':
-			ss.runestate = runestateCode
-		}
-	case runestateStringBacktick:
-		switch rn {
-		case '`':
-			ss.runestate = runestateCode
-		}
-	}
-	ss.idx++
-	return ss.done()
-}
-
-// returns true if no runes left to advance.
-func (ss *scanner) done() bool {
-	return ss.idx == len(ss.rnz)
-}
-
-// returns true if outside the scope of any
-// parentheses, brackets, strings, or rune literals.
-func (ss *scanner) out() bool {
-	return ss.runestate == runestateCode &&
-		ss.curly == int(0) &&
-		ss.round == int(0) &&
-		ss.square == int(0)
-}
-
-func isOctal(r rune) bool {
-	switch r {
-	case '0', '1', '2', '3', '4', '5', '6', '7':
-		return true
-	default:
-		return false
-	}
-}
-
-func isHex(r rune) bool {
-	switch r {
-	case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
-		'a', 'b', 'c', 'd', 'e', 'f',
-		'A', 'B', 'C', 'D', 'E', 'F':
-		return true
-	default:
-		return false
-	}
-}
-
-// Advances runes, while checking that each passes `check`.  if error, panics
-// with info including `back` runes back.
-func (ss *scanner) eatRunes(back int, eat int, check func(rune) bool) {
-	for i := 0; i < eat; i++ {
-		if ss.idx+i == len(ss.rnz) {
-			panic(fmt.Sprintf("eof while parsing: %s",
-				string(ss.rnz[ss.idx-back:])))
-		}
-		if !check(ss.rnz[ss.idx+i]) {
-			panic(fmt.Sprintf("invalid character while parsing: %s",
-				string(ss.rnz[ss.idx-back:ss.idx+i+1])))
-		}
-		ss.idx++
-	}
-}
-
-// increments ss.idx until escape sequence is complete.  returns true if done.
-func (ss *scanner) advanceEscapeSequence() bool {
-	rn1 := ss.rnz[ss.idx]
-	if rn1 != '\\' {
-		panic("should not happen")
-	}
-	if ss.idx == len(ss.rnz)-1 {
-		panic("eof while parsing escape sequence")
-	}
-	rn2 := ss.rnz[ss.idx+1]
-	switch rn2 {
-	case 'x':
-		ss.idx += 2
-		ss.eatRunes(2, 2, isHex)
-		return ss.done()
-	case 'u':
-		ss.idx += 2
-		ss.eatRunes(2, 4, isHex)
-		return ss.done()
-	case 'U':
-		ss.idx += 2
-		ss.eatRunes(2, 8, isHex)
-		return ss.done()
-	case 'a', 'b', 'f', 'n', 'r', 't', 'v', '\\', '\'', '"':
-		ss.idx += 2
-		return ss.done()
-	default:
-		ss.idx += 1
-		if isOctal(rn2) {
-			ss.eatRunes(1, 3, isOctal)
-		} else {
-			panic("invalid escape sequence")
-		}
-		return ss.done()
-	}
-}
diff --git a/tm2/pkg/amino/reflect.go b/tm2/pkg/amino/reflect.go
index bc4fa57e626..01402a320d2 100644
--- a/tm2/pkg/amino/reflect.go
+++ b/tm2/pkg/amino/reflect.go
@@ -1,26 +1,21 @@
 package amino
 
 import (
-	"encoding/json"
 	"fmt"
 	"reflect"
 	"unicode"
 )
 
-//----------------------------------------
+// ----------------------------------------
 // Constants
 
-var (
-	jsonMarshalerType   = reflect.TypeOf(new(json.Marshaler)).Elem()
-	jsonUnmarshalerType = reflect.TypeOf(new(json.Unmarshaler)).Elem()
-	errorType           = reflect.TypeOf(new(error)).Elem()
-)
+var errorType = reflect.TypeOf(new(error)).Elem()
 
-//----------------------------------------
+// ----------------------------------------
 // encode: see binary-encode.go and json-encode.go
 // decode: see binary-decode.go and json-decode.go
 
-//----------------------------------------
+// ----------------------------------------
 // Misc.
 
 // CONTRACT: by the time this is called, len(bz) >= _n
@@ -182,18 +177,6 @@ func constructConcreteType(cinfo *TypeInfo) (crv, irvSet reflect.Value) {
 	return
 }
 
-// Like constructConcreteType(), but if pointer preferred, returns a nil one.
-// We like nil pointers for efficiency.
-func constructConcreteTypeNilPreferred(cinfo *TypeInfo) (crv reflect.Value) {
-	// Construct new concrete type.
-	if cinfo.PointerPreferred {
-		crv = reflect.Zero(cinfo.PtrToType)
-	} else {
-		crv = reflect.New(cinfo.Type).Elem()
-	}
-	return
-}
-
 func toReprObject(rv reflect.Value) (rrv reflect.Value, err error) {
 	var mwrm reflect.Value
 	if rv.CanAddr() {
@@ -269,12 +252,6 @@ func unmarshalAminoReprType(rm reflect.Method) (rrt reflect.Type) {
 	return
 }
 
-func toPBMessage(cdc *Codec, rv reflect.Value) (pbrv reflect.Value) {
-	rm := rv.MethodByName("ToPBMessage")
-	pbrv = rm.Call([]reflect.Value{reflect.ValueOf(cdc)})[0]
-	return
-}
-
 // NOTE: do not change this definition.
 // It is also defined for genproto.
 func isListType(rt reflect.Type) bool {
diff --git a/tm2/pkg/amino/tests/common.go b/tm2/pkg/amino/tests/common.go
index b7213a56efc..1abf3aaf601 100644
--- a/tm2/pkg/amino/tests/common.go
+++ b/tm2/pkg/amino/tests/common.go
@@ -32,8 +32,6 @@ type PrimitivesStruct struct {
 	Time        time.Time
 	Duration    time.Duration
 	Empty       EmptyStruct
-
-	unexposed int8
 }
 
 type ShortArraysStruct struct {
diff --git a/tm2/pkg/bft/abci/client/client.go b/tm2/pkg/bft/abci/client/client.go
index b3d5a945839..f9f21f08fdb 100644
--- a/tm2/pkg/bft/abci/client/client.go
+++ b/tm2/pkg/bft/abci/client/client.go
@@ -7,11 +7,6 @@ import (
 	"github.com/gnolang/gno/tm2/pkg/service"
 )
 
-const (
-	dialRetryIntervalSeconds = 3
-	echoRetryIntervalSeconds = 1
-)
-
 // Client defines an interface for an ABCI client.
 // All `Async` methods return a `ReqRes` object.
 // All `Sync` methods return the appropriate protobuf ResponseXxx struct and an error.
@@ -48,11 +43,11 @@ type Client interface {
 	EndBlockSync(abci.RequestEndBlock) (abci.ResponseEndBlock, error)
 }
 
-//----------------------------------------
+// ----------------------------------------
 
 type Callback func(abci.Request, abci.Response)
 
-//----------------------------------------
+// ----------------------------------------
 
 type ReqRes struct {
 	abci.Request
diff --git a/tm2/pkg/bft/consensus/common_test.go b/tm2/pkg/bft/consensus/common_test.go
index 7424305c00a..0c71e04475b 100644
--- a/tm2/pkg/bft/consensus/common_test.go
+++ b/tm2/pkg/bft/consensus/common_test.go
@@ -30,7 +30,6 @@ import (
 	"github.com/gnolang/gno/tm2/pkg/events"
 	"github.com/gnolang/gno/tm2/pkg/log"
 	osm "github.com/gnolang/gno/tm2/pkg/os"
-	"github.com/gnolang/gno/tm2/pkg/p2p"
 )
 
 const (
@@ -702,15 +701,6 @@ func randConsensusNetWithPeers(nValidators, nPeers int, testName string, tickerF
 	}
 }
 
-func getSwitchIndex(switches []*p2p.Switch, peer p2p.Peer) int {
-	for i, s := range switches {
-		if peer.NodeInfo().ID() == s.NodeInfo().ID() {
-			return i
-		}
-	}
-	panic("didnt find peer in switches")
-}
-
 // -------------------------------------------------------------------------------
 // genesis
 
diff --git a/tm2/pkg/bft/consensus/replay.go b/tm2/pkg/bft/consensus/replay.go
index 16b4ba3fa87..b228c1b63e4 100644
--- a/tm2/pkg/bft/consensus/replay.go
+++ b/tm2/pkg/bft/consensus/replay.go
@@ -4,7 +4,6 @@ import (
 	"bytes"
 	"errors"
 	"fmt"
-	"hash/crc32"
 	"io"
 	"reflect"
 	"time"
@@ -21,8 +20,6 @@ import (
 	"github.com/gnolang/gno/tm2/pkg/log"
 )
 
-var crc32c = crc32.MakeTable(crc32.Castagnoli)
-
 // Functionality to replay blocks and messages on recovery from a crash.
 // There are two general failure scenarios:
 //
diff --git a/tm2/pkg/bft/consensus/state_test.go b/tm2/pkg/bft/consensus/state_test.go
index 1587fa03057..0e2e6b629a4 100644
--- a/tm2/pkg/bft/consensus/state_test.go
+++ b/tm2/pkg/bft/consensus/state_test.go
@@ -59,7 +59,7 @@ x * TestHalt1 - if we see +2/3 precommits after timing out into new round, we sh
 
 */
 
-//----------------------------------------------------------------------------------------------------
+// ----------------------------------------------------------------------------------------------------
 // ProposeSuite
 
 func TestStateProposerSelection0(t *testing.T) {
@@ -255,7 +255,7 @@ func TestStateBadProposal(t *testing.T) {
 	signAddVotes(cs1, types.PrecommitType, propBlock.Hash(), propBlock.MakePartSet(partSize).Header(), vs2)
 }
 
-//----------------------------------------------------------------------------------------------------
+// ----------------------------------------------------------------------------------------------------
 // FullRoundSuite
 
 // propose, prevote, and precommit a block
@@ -354,7 +354,7 @@ func TestStateFullRound2(t *testing.T) {
 	ensureNewBlock(newBlockCh, height)
 }
 
-//------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------
 // LockSuite
 
 // two validators, 4 rounds.
@@ -409,7 +409,7 @@ func TestStateLockNoPOL(t *testing.T) {
 	// but with invalid args. then we enterPrecommitWait, and the timeout to new round
 	ensureNewTimeout(timeoutWaitCh, height, round, cs1.config.Precommit(round).Nanoseconds())
 
-	///
+	// -----------
 
 	round++ // moving to the next round
 	ensureNewRound(newRoundCh, height, round)
@@ -1496,7 +1496,7 @@ func TestFlappyResetTimeoutPrecommitUponNewHeight(t *testing.T) {
 	assert.False(t, rs.TriggeredTimeoutPrecommit, "triggeredTimeoutPrecommit should be false at the beginning of each height")
 }
 
-//------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------
 // SlashingSuite
 // TODO: Slashing
 
@@ -1573,10 +1573,10 @@ func TestStateSlashingPrecommits(t *testing.T) {
 }
 */
 
-//------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------
 // CatchupSuite
 
-//------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------
 // HaltSuite
 
 // 4 vals.
diff --git a/tm2/pkg/bft/consensus/wal_generator.go b/tm2/pkg/bft/consensus/wal_generator.go
index dff1cca1446..7893c544c7f 100644
--- a/tm2/pkg/bft/consensus/wal_generator.go
+++ b/tm2/pkg/bft/consensus/wal_generator.go
@@ -40,7 +40,7 @@ func WALGenerateNBlocks(t *testing.T, wr io.Writer, numBlocks int) (err error) {
 	logger := log.TestingLogger().With("wal_generator", "wal_generator")
 	logger.Info("generating WAL (last height msg excluded)", "numBlocks", numBlocks)
 
-	/////////////////////////////////////////////////////////////////////////////
+	// -----------
 	// COPY PASTE FROM node.go WITH A FEW MODIFICATIONS
 	// NOTE: we can't import node package because of circular dependency.
 	// NOTE: we don't do handshake so need to set state.Version.Consensus.App directly.
@@ -83,7 +83,7 @@ func WALGenerateNBlocks(t *testing.T, wr io.Writer, numBlocks int) (err error) {
 		consensusState.SetPrivValidator(privValidator)
 	}
 	// END OF COPY PASTE
-	/////////////////////////////////////////////////////////////////////////////
+	// -----------
 
 	// set consensus wal to buffered WAL, which will write all incoming msgs to buffer
 	numBlocksWritten := make(chan struct{})
diff --git a/tm2/pkg/bft/consensus/wal_test.go b/tm2/pkg/bft/consensus/wal_test.go
index 1b271fb73c7..50f8f4c8b2a 100644
--- a/tm2/pkg/bft/consensus/wal_test.go
+++ b/tm2/pkg/bft/consensus/wal_test.go
@@ -13,10 +13,6 @@ import (
 	"github.com/gnolang/gno/tm2/pkg/log"
 )
 
-const (
-	walTestFlushInterval = time.Duration(100) * time.Millisecond
-)
-
 // ----------------------------------------
 // copied over from wal/wal_test.go
 
@@ -53,8 +49,7 @@ func makeTempWAL(t *testing.T, walChunkSize int64) (wal walm.WAL) {
 // ----------------------------------------
 
 func TestWALTruncate(t *testing.T) {
-	const maxTestMsgSize = 1024 * 1024 // 1MB
-	const walChunkSize = 409610        // 4KB
+	const walChunkSize = 409610 // 4KB
 	wal := makeTempWAL(t, walChunkSize)
 
 	wal.SetLogger(log.TestingLogger())
diff --git a/tm2/pkg/bft/node/node.go b/tm2/pkg/bft/node/node.go
index bdeb5061540..9d6143e7af3 100644
--- a/tm2/pkg/bft/node/node.go
+++ b/tm2/pkg/bft/node/node.go
@@ -665,7 +665,6 @@ func (n *Node) ConfigureRPC() {
 	rpccore.SetPubKey(pubKey)
 	rpccore.SetGenesisDoc(n.genesisDoc)
 	rpccore.SetProxyAppQuery(n.proxyApp.Query())
-	rpccore.SetTxEventStore(n.txEventStore)
 	rpccore.SetConsensusReactor(n.consensusReactor)
 	rpccore.SetLogger(n.Logger.With("module", "rpc"))
 	rpccore.SetEventSwitch(n.evsw)
diff --git a/tm2/pkg/bft/privval/signer_listener_endpoint_test.go b/tm2/pkg/bft/privval/signer_listener_endpoint_test.go
index 8e5b1613454..c2d89660baf 100644
--- a/tm2/pkg/bft/privval/signer_listener_endpoint_test.go
+++ b/tm2/pkg/bft/privval/signer_listener_endpoint_test.go
@@ -130,7 +130,7 @@ func TestRetryConnToRemoteSigner(t *testing.T) {
 	}
 }
 
-// /////////////////////////////////
+// -----------
 
 func newSignerListenerEndpoint(logger log.Logger, ln net.Listener, timeoutReadWrite time.Duration) *SignerListenerEndpoint {
 	var listener net.Listener
diff --git a/tm2/pkg/bft/rpc/core/pipe.go b/tm2/pkg/bft/rpc/core/pipe.go
index a8b102d9ab7..abfdc300d31 100644
--- a/tm2/pkg/bft/rpc/core/pipe.go
+++ b/tm2/pkg/bft/rpc/core/pipe.go
@@ -10,7 +10,6 @@ import (
 	"github.com/gnolang/gno/tm2/pkg/bft/proxy"
 	cfg "github.com/gnolang/gno/tm2/pkg/bft/rpc/config"
 	sm "github.com/gnolang/gno/tm2/pkg/bft/state"
-	"github.com/gnolang/gno/tm2/pkg/bft/state/eventstore"
 	"github.com/gnolang/gno/tm2/pkg/bft/types"
 	"github.com/gnolang/gno/tm2/pkg/crypto"
 	dbm "github.com/gnolang/gno/tm2/pkg/db"
@@ -68,7 +67,6 @@ var (
 	// objects
 	pubKey           crypto.PubKey
 	genDoc           *types.GenesisDoc // cache the genesis structure
-	txEventStore     eventstore.TxEventStore
 	consensusReactor *consensus.ConsensusReactor
 	evsw             events.EventSwitch
 	gTxDispatcher    *txDispatcher
@@ -115,10 +113,6 @@ func SetProxyAppQuery(appConn proxy.AppConnQuery) {
 	proxyAppQuery = appConn
 }
 
-func SetTxEventStore(indexer eventstore.TxEventStore) {
-	txEventStore = indexer
-}
-
 func SetConsensusReactor(conR *consensus.ConsensusReactor) {
 	consensusReactor = conR
 }
@@ -169,12 +163,3 @@ func validatePerPage(perPage int) int {
 	}
 	return perPage
 }
-
-func validateSkipCount(page, perPage int) int {
-	skipCount := (page - 1) * perPage
-	if skipCount < 0 {
-		return 0
-	}
-
-	return skipCount
-}
diff --git a/tm2/pkg/bft/rpc/lib/client/ws_client.go b/tm2/pkg/bft/rpc/lib/client/ws_client.go
index 040437d11ff..4e159a3e3dc 100644
--- a/tm2/pkg/bft/rpc/lib/client/ws_client.go
+++ b/tm2/pkg/bft/rpc/lib/client/ws_client.go
@@ -226,7 +226,7 @@ func (c *WSClient) CallWithArrayParams(ctx context.Context, method string, param
 	return c.Send(ctx, request)
 }
 
-///////////////////////////////////////////////////////////////////////////////
+// -----------
 // Private methods
 
 func (c *WSClient) dial() error {
diff --git a/tm2/pkg/bft/rpc/lib/server/handlers_test.go b/tm2/pkg/bft/rpc/lib/server/handlers_test.go
index 8bf2cc0f7f1..04f1c2e8bbc 100644
--- a/tm2/pkg/bft/rpc/lib/server/handlers_test.go
+++ b/tm2/pkg/bft/rpc/lib/server/handlers_test.go
@@ -18,11 +18,11 @@ import (
 	"github.com/gnolang/gno/tm2/pkg/log"
 )
 
-//////////////////////////////////////////////////////////////////////////////
+// -----------
 // HTTP REST API
 // TODO
 
-//////////////////////////////////////////////////////////////////////////////
+// -----------
 // JSON-RPC over HTTP
 
 func testMux() *http.ServeMux {
@@ -229,7 +229,7 @@ func TestUnknownRPCPath(t *testing.T) {
 	require.Equal(t, http.StatusNotFound, res.StatusCode, "should always return 404")
 }
 
-//////////////////////////////////////////////////////////////////////////////
+// -----------
 // JSON-RPC over WEBSOCKETS
 
 func TestWebsocketManagerHandler(t *testing.T) {
diff --git a/tm2/pkg/bft/state/helpers_test.go b/tm2/pkg/bft/state/helpers_test.go
index 219baaf0f55..ca4175185a9 100644
--- a/tm2/pkg/bft/state/helpers_test.go
+++ b/tm2/pkg/bft/state/helpers_test.go
@@ -8,7 +8,6 @@ import (
 	"github.com/gnolang/gno/tm2/pkg/bft/proxy"
 	sm "github.com/gnolang/gno/tm2/pkg/bft/state"
 	"github.com/gnolang/gno/tm2/pkg/bft/types"
-	tmtime "github.com/gnolang/gno/tm2/pkg/bft/types/time"
 	"github.com/gnolang/gno/tm2/pkg/crypto"
 	"github.com/gnolang/gno/tm2/pkg/crypto/ed25519"
 	dbm "github.com/gnolang/gno/tm2/pkg/db"
@@ -190,24 +189,7 @@ func makeHeaderPartsResponsesParams(state sm.State, params abci.ConsensusParams)
 	return block.Header, types.BlockID{Hash: block.Hash(), PartsHeader: types.PartSetHeader{}}, abciResponses
 }
 
-func randomGenesisDoc() *types.GenesisDoc {
-	pubkey := ed25519.GenPrivKey().PubKey()
-	return &types.GenesisDoc{
-		GenesisTime: tmtime.Now(),
-		ChainID:     "abc",
-		Validators: []types.GenesisValidator{
-			{
-				Address: pubkey.Address(),
-				PubKey:  pubkey,
-				Power:   10,
-				Name:    "myval",
-			},
-		},
-		ConsensusParams: types.DefaultConsensusParams(),
-	}
-}
-
-//----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 type testApp struct {
 	abci.BaseApplication
diff --git a/tm2/pkg/bft/types/validator_set.go b/tm2/pkg/bft/types/validator_set.go
index 617ceecaae5..80ed994ca39 100644
--- a/tm2/pkg/bft/types/validator_set.go
+++ b/tm2/pkg/bft/types/validator_set.go
@@ -758,7 +758,7 @@ func (vals *ValidatorSet) VerifyFutureCommit(newSet *ValidatorSet, chainID strin
 	return nil
 }
 
-//-----------------
+// -----------------
 // ErrTooMuchChange
 
 func IsErrTooMuchChange(err error) bool {
@@ -775,7 +775,7 @@ func (e tooMuchChangeError) Error() string {
 	return fmt.Sprintf("Invalid commit -- insufficient old voting power: got %v, needed %v", e.got, e.needed)
 }
 
-//----------------
+// ----------------
 
 func (vals *ValidatorSet) String() string {
 	return vals.StringIndented("")
@@ -802,7 +802,7 @@ func (vals *ValidatorSet) StringIndented(indent string) string {
 		indent)
 }
 
-//-------------------------------------
+// -------------------------------------
 // Implements sort for sorting validators by address.
 
 // Sort validators by address.
@@ -822,7 +822,7 @@ func (valz ValidatorsByAddress) Swap(i, j int) {
 	valz[j] = it
 }
 
-//----------------------------------------
+// ----------------------------------------
 // for testing
 
 // RandValidatorSet returns a randomized validator set, useful for testing.
@@ -841,7 +841,7 @@ func RandValidatorSet(numValidators int, votingPower int64) (*ValidatorSet, []Pr
 	return vals, privValidators
 }
 
-///////////////////////////////////////////////////////////////////////////////
+// -----------
 // safe addition/subtraction
 
 func safeAdd(a, b int64) (int64, bool) {
diff --git a/tm2/pkg/bft/wal/wal.go b/tm2/pkg/bft/wal/wal.go
index b66a34df222..a4a14d638dd 100644
--- a/tm2/pkg/bft/wal/wal.go
+++ b/tm2/pkg/bft/wal/wal.go
@@ -436,7 +436,7 @@ OUTER_LOOP:
 	return nil, false, nil
 }
 
-// /////////////////////////////////////////////////////////////////////////////
+// -----------
 
 // A WALWriter writes custom-encoded WAL messages to an output stream.
 // Each binary WAL entry is length encoded, then crc encoded,
@@ -512,7 +512,7 @@ func (enc *WALWriter) WriteMeta(meta MetaMessage) error {
 	return err
 }
 
-// /////////////////////////////////////////////////////////////////////////////
+// -----------
 
 // IsDataCorruptionError returns true if data has been corrupted inside WAL.
 func IsDataCorruptionError(err error) bool {
diff --git a/tm2/pkg/bft/wal/wal_test.go b/tm2/pkg/bft/wal/wal_test.go
index 4cb94766389..a1a3e831a79 100644
--- a/tm2/pkg/bft/wal/wal_test.go
+++ b/tm2/pkg/bft/wal/wal_test.go
@@ -29,7 +29,7 @@ type TestMessage struct {
 
 func (TestMessage) AssertWALMessage() {}
 
-var testPackage = amino.RegisterPackage(amino.NewPackage(
+var _ = amino.RegisterPackage(amino.NewPackage(
 	"github.com/gnolang/gno/tm2/pkg/bft/wal",
 	"wal",
 	amino.GetCallersDirname(),
diff --git a/tm2/pkg/crypto/keys/client/export_test.go b/tm2/pkg/crypto/keys/client/export_test.go
index a5f1ec8f48e..04db99cf063 100644
--- a/tm2/pkg/crypto/keys/client/export_test.go
+++ b/tm2/pkg/crypto/keys/client/export_test.go
@@ -64,11 +64,9 @@ func addRandomKeyToKeybase(
 }
 
 type testCmdKeyOptsBase struct {
-	kbHome          string
-	keyName         string
-	decryptPassword string
-	encryptPassword string
-	unsafe          bool
+	kbHome  string
+	keyName string
+	unsafe  bool
 }
 
 type testExportKeyOpts struct {
diff --git a/tm2/pkg/crypto/keys/keybase.go b/tm2/pkg/crypto/keys/keybase.go
index 16b3631d188..13f6e00979d 100644
--- a/tm2/pkg/crypto/keys/keybase.go
+++ b/tm2/pkg/crypto/keys/keybase.go
@@ -46,14 +46,6 @@ const (
 	infoSuffix    = "info"
 )
 
-const (
-	// used for deriving seed from mnemonic
-	DefaultBIP39Passphrase = ""
-
-	// bits of entropy to draw when creating a mnemonic
-	defaultEntropySize = 256
-)
-
 var (
 	// ErrUnsupportedSigningAlgo is raised when the caller tries to use a
 	// different signing scheme than secp256k1.
diff --git a/tm2/pkg/crypto/merkle/proof_test.go b/tm2/pkg/crypto/merkle/proof_test.go
index 676e281ac60..3319963ce6c 100644
--- a/tm2/pkg/crypto/merkle/proof_test.go
+++ b/tm2/pkg/crypto/merkle/proof_test.go
@@ -26,19 +26,6 @@ func NewDominoOp(key, input, output string) DominoOp {
 	}
 }
 
-//nolint:unused
-func DominoOpDecoder(pop ProofOp) (ProofOperator, error) {
-	if pop.Type != ProofOpDomino {
-		panic("unexpected proof op type")
-	}
-	var op DominoOp // a bit strange as we'll discard this, but it works.
-	err := amino.UnmarshalSized(pop.Data, &op)
-	if err != nil {
-		return nil, errors.Wrap(err, "decoding ProofOp.Data into SimpleValueOp")
-	}
-	return NewDominoOp(string(pop.Key), op.Input, op.Output), nil
-}
-
 func (dop DominoOp) ProofOp() ProofOp {
 	bz := amino.MustMarshalSized(dop)
 	return ProofOp{
@@ -63,7 +50,7 @@ func (dop DominoOp) GetKey() []byte {
 	return []byte(dop.key)
 }
 
-//----------------------------------------
+// ----------------------------------------
 
 func TestProofOperators(t *testing.T) {
 	var err error
diff --git a/tm2/pkg/crypto/util.go b/tm2/pkg/crypto/util.go
deleted file mode 100644
index f017557f09b..00000000000
--- a/tm2/pkg/crypto/util.go
+++ /dev/null
@@ -1,7 +0,0 @@
-package crypto
-
-func cp(bz []byte) (ret []byte) {
-	ret = make([]byte, len(bz))
-	copy(ret, bz)
-	return ret
-}
diff --git a/tm2/pkg/events/store.go b/tm2/pkg/events/store.go
index bea4626394e..1891fd17ac6 100644
--- a/tm2/pkg/events/store.go
+++ b/tm2/pkg/events/store.go
@@ -1,33 +1,12 @@
 package events
 
-import (
-	"fmt"
-
-	auto "github.com/gnolang/gno/tm2/pkg/autofile"
-)
-
 // StoreStream stores events to disk but is also listenaable.
 type StoreStream interface {
 	Eventable
 	SetHeight(height int64) // to demarcate height in WAL for replay.
 }
 
-type storeStream struct {
-	afile  *auto.AutoFile
-	buf    []byte
-	height int64
-}
-
-func (ss *storeStream) SetHeight(height int64) {
-	if ss.height < height {
-		// write new height
-		ss.height = height
-	} else /* if height <= ss.height */ {
-		panic(fmt.Sprintf("invalid SetHeight height value. current %v, got %v", ss.height, height))
-	}
-}
-
-//----------------------------------------
+// ----------------------------------------
 // move to own file
 
 // FilterStream is listenable and lets you filter.
diff --git a/tm2/pkg/iavl/benchmarks/bench_test.go b/tm2/pkg/iavl/benchmarks/bench_test.go
index de6a573020e..77ad77eed28 100644
--- a/tm2/pkg/iavl/benchmarks/bench_test.go
+++ b/tm2/pkg/iavl/benchmarks/bench_test.go
@@ -75,19 +75,6 @@ func runKnownQueries(b *testing.B, t *iavl.MutableTree, keys [][]byte) {
 	}
 }
 
-func runInsert(b *testing.B, t *iavl.MutableTree, keyLen, dataLen, blockSize int) *iavl.MutableTree {
-	b.Helper()
-
-	for i := 1; i <= b.N; i++ {
-		t.Set(randBytes(keyLen), randBytes(dataLen))
-		if i%blockSize == 0 {
-			t.Hash()
-			t.SaveVersion()
-		}
-	}
-	return t
-}
-
 func runUpdate(b *testing.B, t *iavl.MutableTree, dataLen, blockSize int, keys [][]byte) *iavl.MutableTree {
 	b.Helper()
 
@@ -102,23 +89,6 @@ func runUpdate(b *testing.B, t *iavl.MutableTree, dataLen, blockSize int, keys [
 	return t
 }
 
-func runDelete(b *testing.B, t *iavl.MutableTree, blockSize int, keys [][]byte) *iavl.MutableTree {
-	b.Helper()
-
-	var key []byte
-	l := int32(len(keys))
-	for i := 1; i <= b.N; i++ {
-		key = keys[rand.Int31n(l)]
-		// key = randBytes(16)
-		// TODO: test if removed, use more keys (from insert)
-		t.Remove(key)
-		if i%blockSize == 0 {
-			commitTree(b, t)
-		}
-	}
-	return t
-}
-
 // runBlock measures time for an entire block, not just one tx
 func runBlock(b *testing.B, t *iavl.MutableTree, keyLen, dataLen, blockSize int, keys [][]byte) *iavl.MutableTree {
 	b.Helper()
diff --git a/tm2/pkg/iavl/node.go b/tm2/pkg/iavl/node.go
index f2a944afc6a..ee522016f0c 100644
--- a/tm2/pkg/iavl/node.go
+++ b/tm2/pkg/iavl/node.go
@@ -371,10 +371,6 @@ func (node *Node) traverse(t *ImmutableTree, ascending bool, cb func(*Node) bool
 	})
 }
 
-func (node *Node) traverseWithDepth(t *ImmutableTree, ascending bool, cb func(*Node, uint8) bool) bool {
-	return node.traverseInRange(t, nil, nil, ascending, false, 0, cb)
-}
-
 func (node *Node) traverseInRange(t *ImmutableTree, start, end []byte, ascending bool, inclusive bool, depth uint8, cb func(*Node, uint8) bool) bool {
 	afterStart := start == nil || bytes.Compare(start, node.key) < 0
 	startOrAfter := start == nil || bytes.Compare(start, node.key) <= 0
diff --git a/tm2/pkg/iavl/nodedb.go b/tm2/pkg/iavl/nodedb.go
index 3e59b3480e9..e1998d8cc1d 100644
--- a/tm2/pkg/iavl/nodedb.go
+++ b/tm2/pkg/iavl/nodedb.go
@@ -385,7 +385,7 @@ func (ndb *nodeDB) saveRoot(hash []byte, version int64) error {
 	return nil
 }
 
-////////////////// Utility and test functions /////////////////////////////////
+// ----------- Utility and test functions // -----------
 
 func (ndb *nodeDB) leafNodes() []*Node {
 	leaves := []*Node{}
diff --git a/tm2/pkg/iavl/proof_path.go b/tm2/pkg/iavl/proof_path.go
index f66fcf3c48c..a5ac14bc4e7 100644
--- a/tm2/pkg/iavl/proof_path.go
+++ b/tm2/pkg/iavl/proof_path.go
@@ -1,11 +1,8 @@
 package iavl
 
 import (
-	"bytes"
 	"fmt"
 	"strings"
-
-	"github.com/gnolang/gno/tm2/pkg/errors"
 )
 
 // pathWithLeaf is a path to a leaf node and the leaf node itself.
@@ -28,14 +25,6 @@ func (pwl pathWithLeaf) StringIndented(indent string) string {
 		indent)
 }
 
-// `verify` checks that the leaf node's hash + the inner nodes merkle-izes to
-// the given root. If it returns an error, it means the leafHash or the
-// PathToLeaf is incorrect.
-func (pwl pathWithLeaf) verify(root []byte) error {
-	leafHash := pwl.Leaf.Hash()
-	return pwl.Path.verify(leafHash, root)
-}
-
 // `computeRootHash` computes the root hash with leaf node.
 // Does not verify the root hash.
 func (pwl pathWithLeaf) computeRootHash() []byte {
@@ -73,21 +62,6 @@ func (pl PathToLeaf) stringIndented(indent string) string {
 		indent)
 }
 
-// `verify` checks that the leaf node's hash + the inner nodes merkle-izes to
-// the given root. If it returns an error, it means the leafHash or the
-// PathToLeaf is incorrect.
-func (pl PathToLeaf) verify(leafHash []byte, root []byte) error {
-	hash := leafHash
-	for i := len(pl) - 1; i >= 0; i-- {
-		pin := pl[i]
-		hash = pin.Hash(hash)
-	}
-	if !bytes.Equal(root, hash) {
-		return errors.Wrap(ErrInvalidProof, "")
-	}
-	return nil
-}
-
 // `computeRootHash` computes the root hash assuming some leaf hash.
 // Does not verify the root hash.
 func (pl PathToLeaf) computeRootHash(leafHash []byte) []byte {
@@ -117,37 +91,6 @@ func (pl PathToLeaf) isRightmost() bool {
 	return true
 }
 
-func (pl PathToLeaf) isEmpty() bool {
-	return pl == nil || len(pl) == 0
-}
-
-func (pl PathToLeaf) dropRoot() PathToLeaf {
-	if pl.isEmpty() {
-		return pl
-	}
-	return pl[:len(pl)-1]
-}
-
-func (pl PathToLeaf) hasCommonRoot(pl2 PathToLeaf) bool {
-	if pl.isEmpty() || pl2.isEmpty() {
-		return false
-	}
-	leftEnd := pl[len(pl)-1]
-	rightEnd := pl2[len(pl2)-1]
-
-	return bytes.Equal(leftEnd.Left, rightEnd.Left) &&
-		bytes.Equal(leftEnd.Right, rightEnd.Right)
-}
-
-func (pl PathToLeaf) isLeftAdjacentTo(pl2 PathToLeaf) bool {
-	for pl.hasCommonRoot(pl2) {
-		pl, pl2 = pl.dropRoot(), pl2.dropRoot()
-	}
-	pl, pl2 = pl.dropRoot(), pl2.dropRoot()
-
-	return pl.isRightmost() && pl2.isLeftmost()
-}
-
 // returns -1 if invalid.
 func (pl PathToLeaf) Index() (idx int64) {
 	for i, node := range pl {
diff --git a/tm2/pkg/iavl/proof_range.go b/tm2/pkg/iavl/proof_range.go
index 799fb65cebb..ea6bce24fc0 100644
--- a/tm2/pkg/iavl/proof_range.go
+++ b/tm2/pkg/iavl/proof_range.go
@@ -299,7 +299,7 @@ func (proof *RangeProof) _computeRootHash() (rootHash []byte, treeEnd bool, err
 	return rootHash, treeEnd, nil
 }
 
-///////////////////////////////////////////////////////////////////////////////
+// -----------
 
 // keyStart is inclusive and keyEnd is exclusive.
 // If keyStart or keyEnd don't exist, the leaf before keyStart
@@ -442,7 +442,7 @@ func (t *ImmutableTree) getRangeProof(keyStart, keyEnd []byte, limit int) (proof
 	}, keys, values, nil
 }
 
-//----------------------------------------
+// ----------------------------------------
 
 // GetWithProof gets the value under the key if it exists, or returns nil.
 // A proof of existence or absence is returned alongside the value.
diff --git a/tm2/pkg/iavl/tree_test.go b/tm2/pkg/iavl/tree_test.go
index 56a00ee2424..f15a3276653 100644
--- a/tm2/pkg/iavl/tree_test.go
+++ b/tm2/pkg/iavl/tree_test.go
@@ -1290,7 +1290,7 @@ func TestLoadVersionForOverwriting(t *testing.T) {
 	require.NoError(err, "SaveVersion should not fail.")
 }
 
-//////////////////////////// BENCHMARKS ///////////////////////////////////////
+// ----------- BENCHMARKS // -----------
 
 func BenchmarkTreeLoadAndDelete(b *testing.B) {
 	if testing.Short() {
diff --git a/tm2/pkg/p2p/config/config.go b/tm2/pkg/p2p/config/config.go
index 855c0fd9844..830f84ad137 100644
--- a/tm2/pkg/p2p/config/config.go
+++ b/tm2/pkg/p2p/config/config.go
@@ -6,7 +6,7 @@ import (
 	"github.com/gnolang/gno/tm2/pkg/errors"
 )
 
-//-----------------------------------------------------------------------------
+// -----------------------------------------------------------------------------
 // P2PConfig
 
 const (
@@ -16,8 +16,6 @@ const (
 	FuzzModeDelay
 )
 
-var defaultConfigDir = "config" // duplicate across module configs?
-
 // P2PConfig defines the configuration options for the Tendermint peer-to-peer networking layer
 type P2PConfig struct {
 	RootDir string `toml:"home"`
diff --git a/tm2/pkg/p2p/switch.go b/tm2/pkg/p2p/switch.go
index 1f693544d5a..368de659fb1 100644
--- a/tm2/pkg/p2p/switch.go
+++ b/tm2/pkg/p2p/switch.go
@@ -387,10 +387,6 @@ func (sw *Switch) reconnectToPeer(addr *NetAddress) {
 // ---------------------------------------------------------------------
 // Dialing
 
-type privateAddr interface {
-	PrivateAddr() bool
-}
-
 // DialPeersAsync dials a list of peers asynchronously in random order.
 // Used to dial peers from config on startup or from unsafe-RPC (trusted sources).
 // It ignores NetAddressLookupError. However, if there are other errors, first
diff --git a/tm2/pkg/sdk/auth/test_common.go b/tm2/pkg/sdk/auth/test_common.go
index a51c8576bad..ee4153184a4 100644
--- a/tm2/pkg/sdk/auth/test_common.go
+++ b/tm2/pkg/sdk/auth/test_common.go
@@ -19,33 +19,6 @@ type testEnv struct {
 	bank BankKeeperI
 }
 
-// moduleAccount defines an account for modules that holds coins on a pool
-type moduleAccount struct {
-	*std.BaseAccount
-	name        string   `json:"name" yaml:"name"`              // name of the module
-	permissions []string `json:"permissions" yaml"permissions"` // permissions of module account
-}
-
-// HasPermission returns whether or not the module account has permission.
-func (ma moduleAccount) HasPermission(permission string) bool {
-	for _, perm := range ma.permissions {
-		if perm == permission {
-			return true
-		}
-	}
-	return false
-}
-
-// GetName returns the the name of the holder's module
-func (ma moduleAccount) GetName() string {
-	return ma.name
-}
-
-// GetPermissions returns permissions granted to the module account
-func (ma moduleAccount) GetPermissions() []string {
-	return ma.permissions
-}
-
 func setupTestEnv() testEnv {
 	db := dbm.NewMemDB()
 
diff --git a/tm2/pkg/sdk/baseapp_test.go b/tm2/pkg/sdk/baseapp_test.go
index 2d130583885..3fb44e5f744 100644
--- a/tm2/pkg/sdk/baseapp_test.go
+++ b/tm2/pkg/sdk/baseapp_test.go
@@ -444,10 +444,6 @@ func (mch msgCounterHandler) Query(ctx Context, req abci.RequestQuery) abci.Resp
 	panic("should not happen")
 }
 
-func i2b(i int64) []byte {
-	return []byte{byte(i)}
-}
-
 func getIntFromStore(store store.Store, key []byte) int64 {
 	bz := store.Get(key)
 	if len(bz) == 0 {
@@ -477,7 +473,7 @@ func incrementingCounter(t *testing.T, store store.Store, counterKey []byte, cou
 	return
 }
 
-//---------------------------------------------------------------------
+// ---------------------------------------------------------------------
 // Tx processing - CheckTx, DeliverTx, SimulateTx.
 // These tests use the serialized tx as input, while most others will use the
 // Check(), Deliver(), Simulate() methods directly.
diff --git a/tm2/pkg/std/coin.go b/tm2/pkg/std/coin.go
index d5eb9bb1da0..75063320ad3 100644
--- a/tm2/pkg/std/coin.go
+++ b/tm2/pkg/std/coin.go
@@ -619,11 +619,9 @@ var (
 	// Denominations can be 3 ~ 16 characters long.
 	reDnmString = `[a-z][a-z0-9]{2,15}`
 	reAmt       = `[[:digit:]]+`
-	reDecAmt    = `[[:digit:]]*\.[[:digit:]]+`
 	reSpc       = `[[:space:]]*`
 	reDnm       = regexp.MustCompile(fmt.Sprintf(`^%s$`, reDnmString))
 	reCoin      = regexp.MustCompile(fmt.Sprintf(`^(%s)%s(%s)$`, reAmt, reSpc, reDnmString))
-	reDecCoin   = regexp.MustCompile(fmt.Sprintf(`^(%s)%s(%s)$`, reDecAmt, reSpc, reDnmString))
 )
 
 func validateDenom(denom string) error {
diff --git a/tm2/pkg/store/gas/store_test.go b/tm2/pkg/store/gas/store_test.go
index 70f1fc8ea7f..ad335d73c24 100644
--- a/tm2/pkg/store/gas/store_test.go
+++ b/tm2/pkg/store/gas/store_test.go
@@ -13,12 +13,6 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-func newGasKVStore() types.Store {
-	meter := types.NewGasMeter(10000)
-	mem := dbadapter.Store{dbm.NewMemDB()}
-	return gas.New(mem, meter, types.DefaultGasConfig())
-}
-
 func bz(s string) []byte { return []byte(s) }
 
 func keyFmt(i int) []byte { return bz(fmt.Sprintf("key%0.8d", i)) }
diff --git a/tm2/pkg/store/rootmulti/dbadapter.go b/tm2/pkg/store/rootmulti/dbadapter.go
deleted file mode 100644
index 254d139a608..00000000000
--- a/tm2/pkg/store/rootmulti/dbadapter.go
+++ /dev/null
@@ -1,33 +0,0 @@
-package rootmulti
-
-import (
-	"github.com/gnolang/gno/tm2/pkg/store/dbadapter"
-	"github.com/gnolang/gno/tm2/pkg/store/types"
-)
-
-var commithash = []byte("FAKE_HASH")
-
-//----------------------------------------
-// commitDBStoreWrapper should only be used for simulation/debugging,
-// as it doesn't compute any commit hash, and it cannot load older state.
-
-// Wrapper type for dbm.Db with implementation of KVStore
-type commitDBStoreAdapter struct {
-	dbadapter.Store
-}
-
-func (cdsa commitDBStoreAdapter) Commit() types.CommitID {
-	return types.CommitID{
-		Version: -1,
-		Hash:    commithash,
-	}
-}
-
-func (cdsa commitDBStoreAdapter) LastCommitID() types.CommitID {
-	return types.CommitID{
-		Version: -1,
-		Hash:    commithash,
-	}
-}
-
-func (cdsa commitDBStoreAdapter) SetPruning(_ types.PruningOptions) {}